@gravity-rail/cli 0.7.2 → 0.8.0

package/dist/gr.js

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
-import { createRequire } from 'module';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
 import fs, { readFileSync, existsSync, mkdirSync, writeFileSync, createWriteStream, chmodSync, unlinkSync } from 'fs';
-import path3, { join, resolve, dirname } from 'path';
+import path3, { join, resolve, dirname as dirname$1 } from 'path';
 import { createServer } from 'http';
-import { randomBytes, createHash } from 'crypto';
+import { randomUUID, randomBytes, createHash } from 'crypto';
 import { execSync, execFile, exec, spawn, spawnSync } from 'child_process';
 import * as readline from 'readline';
 import readline__default from 'readline';
 import os, { homedir } from 'os';
-import * as readline6 from 'readline/promises';
+import * as readline5 from 'readline/promises';
 import { stdout, stdin } from 'process';
 import { EventEmitter } from 'events';
 
 const require$1 = createRequire(import.meta.url);
+const __filename$1 = fileURLToPath(import.meta.url);
+dirname(__filename$1);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -73,6 +77,16 @@ function handleError(err) {
       process.stderr.write(
         `
 Hint: Run "gr login" to authenticate, or set GRAVITY_RAIL_API_KEY for non-interactive use.
+`
+      );
+    }
+    if ("statusCode" in err && err.statusCode === 403 && process.env.GRAVITY_RAIL_SANDBOX === "1") {
+      process.stderr.write(
+        `
+Hint: This is a write/admin operation and the sandbox token lacks the required scope.
+Re-run the exec tool with the needed write scope, e.g.:
+  exec(code="<your gr command>", language="bash", scopes=["datatypes:write"])
+Common scopes: datatypes:write, workflows:write, members:write, automations:admin, agents:write
 `
       );
     }
@@ -2671,7 +2685,7 @@ var init_libphonenumber_js = __esm({
   }
 });
 
-// ../sdk/dist/chunk-WXSLDWIA.js
+// ../sdk/dist/chunk-ML55PVP7.js
 function getCookieValue(name) {
   if (typeof document === "undefined") return void 0;
   const cookies = document.cookie.split(";");
@@ -2725,6 +2739,41 @@ function sanitizePhoneForBackend(phoneNumber) {
   }
   return phoneNumber;
 }
+function isUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+async function dataToBytes(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  throw new Error("Unsupported file data type");
+}
+function bytesToBase64(bytes) {
+  if (typeof btoa === "function") {
+    const chunkSize = 32768;
+    let binary = "";
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+    }
+    return btoa(binary);
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  throw new Error("No base64 encoder is available in this runtime");
+}
 function getOAuthPath(providerSlug, action) {
   if (providerSlug === "google_calendar") {
     return `oauth/google/calendar/${action}`;
@@ -2822,6 +2871,22 @@ function createApiModules(apiKey, baseUrl3, customFetch) {
     workspaces: new WorkspacesApi(apiKey, baseUrl3, customFetch)
   };
 }
+function createWorkspaceClient(root, workspaceUuid) {
+  return new Proxy(
+    { root, workspaceUuid },
+    {
+      get(target, prop, receiver) {
+        if (prop in target) return Reflect.get(target, prop, receiver);
+        if (typeof prop !== "string" || !WORKSPACE_METHOD_NAME_SET.has(prop)) {
+          return void 0;
+        }
+        const value = root[prop];
+        if (typeof value !== "function") return void 0;
+        return (...args) => value.call(root, workspaceUuid, ...args);
+      }
+    }
+  );
+}
 function bindAccessGrantsMethods(target, accessGrants) {
   target.getMyReceivedGrants = accessGrants.getMyReceivedGrants.bind(accessGrants);
   target.getMyGivenGrants = accessGrants.getMyGivenGrants.bind(accessGrants);
@@ -2846,6 +2911,8 @@ function bindAgentsMethods(target, agents) {
   target.deleteAgent = agents.deleteAgent.bind(agents);
   target.archiveAgent = agents.archiveAgent.bind(agents);
   target.unarchiveAgent = agents.unarchiveAgent.bind(agents);
+  target.resolveAgentTools = agents.resolveAgentTools.bind(agents);
+  target.listAgentAbilities = agents.listAgentAbilities.bind(agents);
 }
 function bindTasksMethods(target, tasks, abilities) {
   target.getTasks = tasks.getTasks.bind(tasks);
@@ -2857,6 +2924,11 @@ function bindTasksMethods(target, tasks, abilities) {
   target.unarchiveTask = tasks.unarchiveTask.bind(tasks);
   target.cloneTask = tasks.cloneTask.bind(tasks);
   target.getAbilityTypes = abilities.getAbilityTypes.bind(abilities);
+  target.getAbilityType = abilities.getAbilityType.bind(abilities);
+  target.listAbilities = abilities.listAbilities.bind(abilities);
+  target.createAbility = abilities.createAbility.bind(abilities);
+  target.updateAbility = abilities.updateAbility.bind(abilities);
+  target.deleteAbility = abilities.deleteAbility.bind(abilities);
 }
 function bindChatsMethods(target, chats) {
   target.getChats = chats.getChats.bind(chats);
@@ -2904,6 +2976,7 @@ function bindChatsMethods(target, chats) {
   target.getChatFilterCount = chats.getChatFilterCount.bind(chats);
 }
 function bindCallsMethods(target, calls, cel) {
+  target.getPhoneCalls = calls.getPhoneCalls.bind(calls);
   target.initiateCall = calls.initiateCall.bind(calls);
   target.getVoiceToken = calls.getVoiceToken.bind(calls);
   target.getMessageTiming = calls.getMessageTiming.bind(calls);
@@ -2912,6 +2985,7 @@ function bindCallsMethods(target, calls, cel) {
 function bindDataTypesMethods(target, dataTypes) {
   target.getDataTypes = dataTypes.getDataTypes.bind(dataTypes);
   target.getDataType = dataTypes.getDataType.bind(dataTypes);
+  target.getDataTypeByUuid = dataTypes.getDataTypeByUuid.bind(dataTypes);
   target.getDataTypeBySlug = dataTypes.getDataTypeBySlug.bind(dataTypes);
   target.createDataType = dataTypes.createDataType.bind(dataTypes);
   target.updateDataType = dataTypes.updateDataType.bind(dataTypes);
@@ -3138,6 +3212,7 @@ function bindFilesMethods(target, files) {
   target.getFiles = files.getFiles.bind(files);
   target.getFile = files.getFile.bind(files);
   target.createFile = files.createFile.bind(files);
+  target.uploadFile = files.uploadFile.bind(files);
   target.updateFile = files.updateFile.bind(files);
   target.deleteFile = files.deleteFile.bind(files);
   target.convertFile = files.convertFile.bind(files);
@@ -3378,6 +3453,8 @@ function bindBillingMethods(target, apiKeys, subscriptions, reports) {
   target.updateSubscription = subscriptions.updateSubscription.bind(subscriptions);
   target.addWorkspaceToSubscription = subscriptions.addWorkspaceToSubscription.bind(subscriptions);
   target.purchaseCredits = subscriptions.purchaseCredits.bind(subscriptions);
+  target.createCheckoutSession = subscriptions.createCheckoutSession.bind(subscriptions);
+  target.listSelfServeProducts = subscriptions.listSelfServeProducts.bind(subscriptions);
   target.getAIUsageReport = reports.getAIUsageReport.bind(reports);
   target.getSMSUsageReport = reports.getSMSUsageReport.bind(reports);
   target.getPhoneUsageReport = reports.getPhoneUsageReport.bind(reports);
@@ -3571,6 +3648,7 @@ function bindIntegrationsMethods(target, mondayIntegration, discordBots, slackAp
   target.updatePlatformApp = appConnections.updatePlatformApp.bind(appConnections);
   target.deletePlatformApp = appConnections.deletePlatformApp.bind(appConnections);
   target.listConnectionMemberFieldKeys = appConnections.listConnectionMemberFieldKeys.bind(appConnections);
+  target.setDefaultGooglePlatformAccount = appConnections.setDefaultGooglePlatformAccount.bind(appConnections);
 }
 function bindOperatorMethods(target, operatorGroups) {
   target.getOperatorGroups = operatorGroups.getOperatorGroups.bind(operatorGroups);
@@ -3604,6 +3682,8 @@ function bindOrgMethods(target, org) {
   target.updateBusinessProfile = org.updateBusinessProfile.bind(org);
   target.submitBusinessProfile = org.submitBusinessProfile.bind(org);
   target.cancelBusinessProfile = org.cancelBusinessProfile.bind(org);
+  target.createOrganizationWorkspace = org.createOrganizationWorkspace.bind(org);
+  target.getOrgBillingCustomer = org.getOrgBillingCustomer.bind(org);
 }
 function bindPronunciationsMethods(target, pronunciations) {
   target.getPronunciationEntries = pronunciations.getPronunciationEntries.bind(pronunciations);
@@ -3642,6 +3722,10 @@ function bindJourneysMethods(target, journeys) {
   target.reenrollMember = journeys.reenrollMember.bind(journeys);
   target.deleteEnrollment = journeys.deleteEnrollment.bind(journeys);
   target.getMemberJourneys = journeys.getMemberJourneys.bind(journeys);
+  target.getStepMembers = journeys.getStepMembers.bind(journeys);
+  target.getStepMemberCounts = journeys.getStepMemberCounts.bind(journeys);
+  target.advanceStep = journeys.advanceStep.bind(journeys);
+  target.skipStep = journeys.skipStep.bind(journeys);
   target.testRunJourney = journeys.testRunJourney.bind(journeys);
   target.getJourneyNotes = journeys.getJourneyNotes.bind(journeys);
   target.createJourneyNote = journeys.createJourneyNote.bind(journeys);
@@ -3711,9 +3795,9 @@ function bindSupportRequestMethods(target, supportRequests) {
   target.closeWorkspaceSupportRequest = supportRequests.closeWorkspaceSupportRequest.bind(supportRequests);
   target.clickWorkspaceSupportRequestResource = supportRequests.clickWorkspaceSupportRequestResource.bind(supportRequests);
 }
-var ApiError, BaseApiClient, AbilitiesApi, AccessGrantsApi, AgentTasksApi, AgentsApi, AIModelsApi, ApiKeysApi, AppsApi, AssignmentsApi, VoiceApi, AuthApi, BuildersApi, CalendarsApi, CallsApi, CELApi, ChatsApi, ConfluenceApi, CustomToolkitsApi, DataTypesApi, DiscordBotsApi, SlackAppsApi, EventsApi, FeaturesApi, FhirConnectionsApi, HealthieApi, FilesApi, InboxesApi, InquiriesApi, AppConnectionsApi, McpServersApi, MembersApi, MilestonesApi, MondayIntegrationApi, NotificationRulesApi, OperatorApi, OrgApi, OAuthConnectionsApi, OAuthApi, PhoneNumbersApi, PronunciationsApi, PromptsApi, PersonasApi, QualificationsApi, ReportsApi, SalesforceApi, ConnectionSyncApi, HubspotApi, SitesApi, SubscriptionsApi, SupportRequestsApi, CustomersApi, ResellersApi, SupervisorsApi, TasksApi, TemplatesApi, ToolkitsApi, JourneysApi, WorkflowsApi, WorkflowNotesApi, EventRuleEventType, WorkspaceInvitationsApi, WorkspacesApi, TeamsAppsApi, ExperimentsApi, GravityRailClient, CHAT_TYPES, BUILTIN_ASSISTANT_CHAT_TYPES;
-var init_chunk_WXSLDWIA = __esm({
-  "../sdk/dist/chunk-WXSLDWIA.js"() {
+var ApiError, BaseApiClient, AbilitiesApi, AccessGrantsApi, AgentTasksApi, AgentsApi, AIModelsApi, ApiKeysApi, AppsApi, AssignmentsApi, VoiceApi, AuthApi, BuildersApi, CalendarsApi, CallsApi, CELApi, ChatsApi, ConfluenceApi, CustomToolkitsApi, DataTypesApi, DiscordBotsApi, SlackAppsApi, EventsApi, FeaturesApi, FhirConnectionsApi, HealthieApi, FilesApi, InboxesApi, InquiriesApi, AppConnectionsApi, McpServersApi, MembersApi, MilestonesApi, MondayIntegrationApi, NotificationRulesApi, OperatorApi, OrgApi, OAuthConnectionsApi, OAuthApi, PhoneNumbersApi, PronunciationsApi, PromptsApi, PersonasApi, QualificationsApi, ReportsApi, SalesforceApi, ConnectionSyncApi, HubspotApi, SitesApi, SubscriptionsApi, SupportRequestsApi, CustomersApi, ResellersApi, SupervisorsApi, TasksApi, TemplatesApi, ToolkitsApi, JourneysApi, WorkflowsApi, WorkflowNotesApi, EventRuleEventType, WorkspaceInvitationsApi, WorkspacesApi, TeamsAppsApi, ExperimentsApi, WORKSPACE_METHOD_NAMES, WORKSPACE_METHOD_NAME_SET, GravityRailClient, CHAT_TYPES, BUILTIN_ASSISTANT_CHAT_TYPES;
+var init_chunk_ML55PVP7 = __esm({
+  "../sdk/dist/chunk-ML55PVP7.js"() {
     init_libphonenumber_js();
     ApiError = class extends Error {
       statusCode;
@@ -4129,10 +4213,52 @@ ${formattedErrors}`, response.status);
     };
     AbilitiesApi = class extends BaseApiClient {
       /**
-       * List all available ability types from the registry.
+       * List available ability types from the registry.
+       * Pass includeSystem to also return auto-injected system abilities.
        */
-      async getAbilityTypes(wid) {
-        return this.fetch(`w/${wid}/abilities/types`);
+      async getAbilityTypes(wid, options = {}) {
+        const params = new URLSearchParams();
+        if (options.includeSystem) params.append("includeSystem", "true");
+        const qs = params.toString() ? `?${params.toString()}` : "";
+        return this.fetch(`w/${wid}/abilities/types${qs}`);
+      }
+      /** Get the full spec for a single ability type by slug. */
+      async getAbilityType(wid, slug) {
+        return this.fetch(
+          `w/${wid}/abilities/types/${encodeURIComponent(slug)}`
+        );
+      }
+      /**
+       * List configured ability instances for a workflow or task scope.
+       * Exactly one of workflowId / taskId must be provided.
+       */
+      async listAbilities(wid, options) {
+        const params = new URLSearchParams();
+        if (options.workflowId !== void 0)
+          params.append("workflowId", options.workflowId.toString());
+        if (options.taskId !== void 0)
+          params.append("taskId", options.taskId.toString());
+        return this.fetch(`w/${wid}/abilities?${params}`);
+      }
+      /** Create (enable) a configured ability on a workflow or task scope. */
+      async createAbility(wid, body) {
+        return this.fetch(`w/${wid}/abilities`, {
+          method: "POST",
+          body: JSON.stringify(body)
+        });
+      }
+      /** Update a configured ability (configure / enable / disable) by UUID. */
+      async updateAbility(wid, abilityUuid, body) {
+        return this.fetch(`w/${wid}/abilities/${abilityUuid}`, {
+          method: "PATCH",
+          body: JSON.stringify(body)
+        });
+      }
+      /** Delete a configured ability instance by UUID. */
+      async deleteAbility(wid, abilityUuid) {
+        return this.fetch(`w/${wid}/abilities/${abilityUuid}`, {
+          method: "DELETE"
+        });
       }
     };
     AccessGrantsApi = class extends BaseApiClient {
@@ -4285,6 +4411,25 @@ ${formattedErrors}`, response.status);
           method: "POST"
         });
       }
+      /** Resolve runtime tools for an agent on a simulated channel. */
+      async resolveAgentTools(wid, id, options) {
+        const params = new URLSearchParams();
+        params.append("channel", options.channel);
+        if (options.taskId !== void 0) params.append("taskId", options.taskId.toString());
+        if (options.taskUuid !== void 0) params.append("taskUuid", options.taskUuid);
+        return this.fetch(`w/${wid}/agents/${id}/resolve-tools?${params}`);
+      }
+      /**
+       * List the configured abilities effective for an agent via a task's workflow.
+       * Requires taskId because abilities are scoped to workflows/tasks, not agents.
+       */
+      async listAgentAbilities(wid, id, options) {
+        const params = new URLSearchParams();
+        params.append("taskId", options.taskId.toString());
+        return this.fetch(
+          `w/${wid}/agents/${id}/abilities?${params}`
+        );
+      }
     };
     AIModelsApi = class extends BaseApiClient {
       /**
@@ -4340,7 +4485,11 @@ ${formattedErrors}`, response.status);
         return this.fetch(url);
       }
       /**
-       * Get available speech-to-text models
+       * Get available speech-to-text models.
+       *
+       * Returns the per-shape `STTModelsResponse` so callers see `languages` and
+       * `capabilities` on each model (the chat-shape `AIModelsResponse` it used
+       * to return doesn't include either).
        */
       async getSTTModels(provider) {
         const searchParams = new URLSearchParams();
@@ -5187,6 +5336,23 @@ ${formattedErrors}`, response.status);
       }
     };
     CallsApi = class extends BaseApiClient {
+      /** List workspace phone calls with optional filtering. */
+      async getPhoneCalls(wid, 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.phoneNumberId !== void 0)
+          params.set("phoneNumberId", String(options.phoneNumberId));
+        if (options.chatId !== void 0) params.set("chatId", String(options.chatId));
+        if (options.workflowId !== void 0) params.set("workflowId", String(options.workflowId));
+        if (options.status) params.set("status", options.status);
+        if (options.inbound !== void 0) params.set("inbound", String(options.inbound));
+        if (options.dateFrom) params.set("dateFrom", options.dateFrom);
+        if (options.dateTo) params.set("dateTo", options.dateTo);
+        return this.fetch(
+          `w/${wid}/calls${params.toString() ? `?${params.toString()}` : ""}`
+        );
+      }
       /** Initiate a new outbound call. */
       async initiateCall(wid, request) {
         return this.fetch(`w/${wid}/call`, {
@@ -5701,10 +5867,17 @@ ${formattedErrors}`, response.status);
         const queryString = params.toString();
         return this.fetch(`w/${wid}/data-types${queryString ? `?${queryString}` : ""}`);
       }
-      /** Get a single data type by ID. */
+      /** Get a single data type by numeric ID, or by UUID when a UUID string is supplied. */
       async getDataType(wid, id) {
+        if (typeof id === "string" && isUuid(id)) {
+          return this.getDataTypeByUuid(wid, id);
+        }
         return this.fetch(`w/${wid}/data-types/${id}`);
       }
+      /** Get a single data type by UUID. */
+      async getDataTypeByUuid(wid, uuid) {
+        return this.fetch(`w/${wid}/data-types/${uuid}`);
+      }
       /** Get a single data type by its slug. */
       async getDataTypeBySlug(wid, slug) {
         return this.fetch(`w/${wid}/data-types/slug/${slug}`);
@@ -6589,6 +6762,25 @@ ${formattedErrors}`, response.status);
           body: JSON.stringify(file)
         });
       }
+      /** Upload in-memory file content through the API's database-backed file path. */
+      async uploadFile(wid, request) {
+        const mimeType = request.mimeType ?? "application/octet-stream";
+        const bytes = await dataToBytes(request.data);
+        return this.createFile(wid, {
+          title: request.title ?? request.filename,
+          filename: request.filename,
+          description: request.description,
+          mimeType,
+          folderId: request.folderId,
+          siteId: request.siteId,
+          dataBase64: bytesToBase64(bytes),
+          externalId: request.externalId,
+          oauthCredentialUuid: request.oauthCredentialUuid,
+          access: request.access,
+          labelIds: request.labelIds,
+          overwrite: request.overwrite
+        });
+      }
       /** Update an existing file's metadata. */
       async updateFile(wid, id, file) {
         return this.fetch(`w/${wid}/files/${id}`, {
@@ -7014,6 +7206,12 @@ ${formattedErrors}`, response.status);
        * values are intentionally never exposed. Operators can also add a
        * new key via the UI's "Add custom field key" free-text action.
        */
+      async setDefaultGooglePlatformAccount(wid, connectionUuid, credentialUuid) {
+        return this.fetch(
+          `w/${wid}/app-connections/google/platform-apps/${connectionUuid}/accounts/${credentialUuid}/default`,
+          { method: "POST" }
+        );
+      }
       async listConnectionMemberFieldKeys(wid, connectionId) {
         return this.fetch(
           `w/${wid}/app-connections/${connectionId}/member-field-keys`
@@ -9295,6 +9493,28 @@ ${formattedErrors}`, response.status);
       async getSubscriptions() {
         return this.fetch("subscriptions");
       }
+      /**
+       * Create a Stripe Checkout session to purchase an organization plan.
+       * Returns the checkout URL to open in a browser. The organization, billing
+       * customer, and subscription are created on payment by the checkout
+       * completion handler.
+       */
+      async createCheckoutSession(productId, planPeriod = "month") {
+        return this.fetch(`subscriptions/checkout-session`, {
+          method: "POST",
+          credentials: "include",
+          body: JSON.stringify({ productId, planPeriod }),
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      /**
+       * List self-service, purchasable plans (org or workspace). Only plans with a
+       * paid Stripe price are returned. No auth required.
+       */
+      async listSelfServeProducts(productType2) {
+        const qs = productType2 ? `?product_type=${productType2}` : "";
+        return this.fetch(`products/self-service${qs}`);
+      }
       /** List all subscriptions associated with a workspace. */
       async getWorkspaceSubscriptions(wid) {
         return this.fetch(`w/${wid}/subscriptions`);
@@ -9335,6 +9555,10 @@ ${formattedErrors}`, response.status);
           }
         });
       }
+      /** List line items for a subscription. */
+      async getSubscriptionItems(subscriptionId) {
+        return this.fetch(`subscriptions/${subscriptionId}/items`);
+      }
       /** Purchase extra credits on a subscription (org-level). */
       async purchaseCredits(subscriptionId, amountCents) {
         return this.fetch(`subscriptions/${subscriptionId}/purchase-credits`, {
@@ -9558,6 +9782,12 @@ ${formattedErrors}`, response.status);
         if (options.workflowId) {
           params.append("workflow_id", options.workflowId.toString());
         }
+        if (options.sortBy) {
+          params.append("sortBy", options.sortBy);
+        }
+        if (options.sortOrder) {
+          params.append("sortOrder", options.sortOrder);
+        }
         return this.fetch(
           `w/${wid}/tasks${params.toString() ? `?${params.toString()}` : ""}`
         );
@@ -9828,6 +10058,36 @@ ${formattedErrors}`, response.status);
       async getMemberJourneys(wid, memberId) {
         return this.fetch(`w/${wid}/journeys/by-member/${memberId}`);
       }
+      /** List members currently or historically associated with one journey step. */
+      async getStepMembers(wid, journeyId, stepUuid, params = {}) {
+        const qs = new URLSearchParams();
+        if (params.status) qs.set("status", params.status);
+        if (params.mode) qs.set("mode", params.mode);
+        if (params.page) qs.set("page", String(params.page));
+        if (params.pageSize) qs.set("pageSize", String(params.pageSize));
+        const query = qs.toString();
+        return this.fetch(
+          `w/${wid}/journeys/${journeyId}/steps/${stepUuid}/members${query ? `?${query}` : ""}`
+        );
+      }
+      /** Get member counts by status for each journey step. */
+      async getStepMemberCounts(wid, journeyId) {
+        return this.fetch(`w/${wid}/journeys/${journeyId}/step-member-counts`);
+      }
+      /** Advance a journey step in the current execution context. */
+      async advanceStep(wid, journeyId, stepUuid, data = {}) {
+        return this.fetch(
+          `w/${wid}/journeys/${journeyId}/steps/${stepUuid}/advance`,
+          { method: "POST", body: JSON.stringify(data) }
+        );
+      }
+      /** Skip a journey step in the current execution context. */
+      async skipStep(wid, journeyId, stepUuid, data = {}) {
+        return this.fetch(
+          `w/${wid}/journeys/${journeyId}/steps/${stepUuid}/skip`,
+          { method: "POST", body: JSON.stringify(data) }
+        );
+      }
       /**
        * Dry-run heartbeat CEL evaluation for an enrolled member.
        *
@@ -9890,9 +10150,17 @@ ${formattedErrors}`, response.status);
           `w/${wid}/workflows/activity/batch?${params.toString()}`
         );
       }
-      /** Get the Mermaid diagram representation of a workflow. */
-      async getWorkflowDiagram(wid, id) {
-        return this.fetch(`w/${wid}/workflows/${id}/diagram`);
+      /**
+       * Get the Mermaid diagram representation of a workflow.
+       *
+       * By default only active tasks are rendered. Pass `includeArchived: true`
+       * to also render archived tasks (distinctly styled). `taskCount` is always
+       * the total (active + archived); `archivedTaskCount` breaks out the archived
+       * portion so the active count can be derived.
+       */
+      async getWorkflowDiagram(wid, id, options = {}) {
+        const query = options.includeArchived ? "?include_archived=true" : "";
+        return this.fetch(`w/${wid}/workflows/${id}/diagram${query}`);
       }
       /**
        * Get workflow thumbnail URL.
@@ -10795,6 +11063,703 @@ ${formattedErrors}`, response.status);
         );
       }
     };
+    WORKSPACE_METHOD_NAMES = [
+      "activateWorkflowVersion",
+      "addGroupMember",
+      "advanceStep",
+      "approveWorkspaceInvitation",
+      "archiveAgent",
+      "archiveChat",
+      "archiveDataType",
+      "archiveJourney",
+      "archiveMember",
+      "archivePhoneNumber",
+      "archiveStep",
+      "archiveTask",
+      "archiveWorkflow",
+      "authorizeMondayConnection",
+      "autoCreateDataTypeFromBoard",
+      "blockWorkspaceInvitation",
+      "bookHealthieAppointment",
+      "buildWorkspace",
+      "bulkLinkMembersToHubspot",
+      "bulkLinkMembersToMonday",
+      "bulkLinkMembersToSalesforce",
+      "cancelAgentTask",
+      "cancelAssignment",
+      "cancelCalendarEvent",
+      "cancelCredentialUpdateInvite",
+      "checkAvailability",
+      "checkSiteDomainAvailability",
+      "checkSiteSlugAvailability",
+      "clearConnectionMemberExclusion",
+      "clearMemberSwitch",
+      "clickWorkspaceSupportRequestResource",
+      "cloneDataType",
+      "cloneTask",
+      "cloneWorkflow",
+      "closeWorkspaceSupportRequest",
+      "commentOnWorkspaceSupportRequest",
+      "configureConfluence",
+      "configureHealthie",
+      "configureHubspot",
+      "configureMondayConnection",
+      "configureSalesforce",
+      "convertEmail",
+      "convertFile",
+      "crawlSite",
+      "createAbility",
+      "createAccessGrant",
+      "createAgent",
+      "createApiKey",
+      "createAssignment",
+      "createCalendar",
+      "createCalendarEvent",
+      "createCalendarSchedule",
+      "createChat",
+      "createChatCompletion",
+      "createChatFilter",
+      "createChatLabel",
+      "createClientWorkspace",
+      "createConnection",
+      "createCustomTool",
+      "createCustomToolkit",
+      "createDataRecord",
+      "createDataType",
+      "createDiscordBot",
+      "createEventRule",
+      "createEventType",
+      "createExperiment",
+      "createExperimentAssignment",
+      "createExperimentGroup",
+      "createFhirConnection",
+      "createFile",
+      "createFileLabel",
+      "createFolder",
+      "createGoal",
+      "createInbox",
+      "createJourney",
+      "createJourneyNote",
+      "createMcpServer",
+      "createMemberField",
+      "createMemberFilter",
+      "createMemberLabel",
+      "createMemberMemory",
+      "createMemberRole",
+      "createMenuItem",
+      "createMilestone",
+      "createNotificationRule",
+      "createOperatorGroup",
+      "createPage",
+      "createPersona",
+      "createPhoneNumber",
+      "createProduct",
+      "createRoutine",
+      "createScenario",
+      "createSignup",
+      "createSite",
+      "createSlackApp",
+      "createSnippet",
+      "createStep",
+      "createSupervisor",
+      "createTask",
+      "createTeamsApp",
+      "createWorkflow",
+      "createWorkflowContributor",
+      "createWorkflowFromTemplate",
+      "createWorkflowNote",
+      "createWorkflowOutboundVoiceChat",
+      "createWorkspaceMember",
+      "createWorkspaceSupportRequest",
+      "deactivateWorkflowVersion",
+      "deleteAbility",
+      "deleteAgent",
+      "deleteAssignment",
+      "deleteCalendar",
+      "deleteCalendarEvent",
+      "deleteCalendarSchedule",
+      "deleteChat",
+      "deleteChatFilter",
+      "deleteChatLabel",
+      "deleteClientWorkspace",
+      "deleteConfluence",
+      "deleteConnection",
+      "deleteCustomTool",
+      "deleteCustomToolkit",
+      "deleteDataRecord",
+      "deleteDataType",
+      "deleteDiscordBot",
+      "deleteEnrollment",
+      "deleteEventRule",
+      "deleteEventType",
+      "deleteExperiment",
+      "deleteExperimentAssignment",
+      "deleteExperimentGroup",
+      "deleteFhirConnection",
+      "deleteFile",
+      "deleteFileLabel",
+      "deleteFolder",
+      "deleteGoal",
+      "deleteHubspot",
+      "deleteInbox",
+      "deleteJourneyNote",
+      "deleteMcpServer",
+      "deleteMember",
+      "deleteMemberField",
+      "deleteMemberFilter",
+      "deleteMemberLabel",
+      "deleteMemberMemory",
+      "deleteMemberRole",
+      "deleteMenuItem",
+      "deleteMilestone",
+      "deleteMondayConnection",
+      "deleteNotificationRule",
+      "deleteOperatorGroup",
+      "deletePage",
+      "deletePersona",
+      "deletePlatformApp",
+      "deleteProduct",
+      "deleteRoutine",
+      "deleteSalesforce",
+      "deleteScenario",
+      "deleteSite",
+      "deleteSlackApp",
+      "deleteSnippet",
+      "deleteSupervisor",
+      "deleteTask",
+      "deleteTeamsApp",
+      "deleteWorkflow",
+      "deleteWorkflowContributor",
+      "deleteWorkflowNote",
+      "deleteWorkspace",
+      "deleteWorkspaceInvitationAdmin",
+      "denyWorkspaceInvitation",
+      "describeSalesforceObject",
+      "diffWorkflowVersions",
+      "disableConfluence",
+      "disableCustomToolkit",
+      "disableHubspot",
+      "disableMcpServer",
+      "disableMondayConnection",
+      "disableSalesforce",
+      "disconnectConfluence",
+      "disconnectHubspot",
+      "disconnectMondayConnection",
+      "disconnectPresence",
+      "disconnectSalesforce",
+      "discoverOAuthMetadata",
+      "dismissAllNotifications",
+      "dismissNotification",
+      "downloadEmailAttachment",
+      "enableConfluence",
+      "enableCustomToolkit",
+      "enableHubspot",
+      "enableMcpServer",
+      "enableMondayConnection",
+      "enablePlatformApp",
+      "enableSalesforce",
+      "endTestChatRun",
+      "enrollMembers",
+      "evaluateTestChatRun",
+      "executeAssignmentTool",
+      "expireAnonymousMember",
+      "exportChat",
+      "exportChats",
+      "exportMembers",
+      "exportWorkspace",
+      "fetchVoicemailAudio",
+      "fhirBackfillEncounterSync",
+      "fhirCreateEncounter",
+      "fhirCsvImportApply",
+      "fhirCsvImportInspect",
+      "fhirFetchCareTeam",
+      "fhirFetchEncounters",
+      "fhirGetCsvImportRunItems",
+      "fhirGetCsvImportRuns",
+      "fhirGetCsvImportSettings",
+      "fhirGetEncounterSyncRuns",
+      "fhirGetEncounterSyncStatus",
+      "fhirImportPatient",
+      "fhirLinkMember",
+      "fhirListLinkedMembers",
+      "fhirRefreshEncounterPatient",
+      "fhirRunEncounterSync",
+      "fhirSearchLocations",
+      "fhirSearchPatients",
+      "fhirSearchPractitioners",
+      "fhirSyncMember",
+      "fhirUnlinkMember",
+      "fhirUpdateCsvImportSettings",
+      "fhirUpdateEncounterSync",
+      "findOrCreateDMChat",
+      "generateFileUploadUrl",
+      "generateICalToken",
+      "generateSiteMediaUploadUrl",
+      "getAIUsageReport",
+      "getAbilityType",
+      "getAbilityTypes",
+      "getAccessGrant",
+      "getAccessGrants",
+      "getAgent",
+      "getAgentTask",
+      "getAgentTaskMessages",
+      "getAgentTasks",
+      "getAgents",
+      "getAnonymousResolution",
+      "getAnonymousResolutions",
+      "getApiKeys",
+      "getArchiveBlockers",
+      "getAssignment",
+      "getAssignmentCelContext",
+      "getAssignmentMessages",
+      "getAssignmentTask",
+      "getAssignmentTaskDetail",
+      "getAssignmentTools",
+      "getAssignments",
+      "getAvailableActions",
+      "getAvailablePhoneNumbers",
+      "getAvailableSlots",
+      "getBoardColumns",
+      "getBoardGroups",
+      "getBoards",
+      "getBusinessHoursStatus",
+      "getCalendar",
+      "getCalendarEvent",
+      "getCalendarEvents",
+      "getCalendarSchedules",
+      "getCalendars",
+      "getCelContext",
+      "getChat",
+      "getChatAssignmentTasks",
+      "getChatEmails",
+      "getChatFilter",
+      "getChatFilterByUuid",
+      "getChatFilterCount",
+      "getChatFilters",
+      "getChatLabel",
+      "getChatLabelByUuid",
+      "getChatLabels",
+      "getChatMessages",
+      "getChatPhoneCalls",
+      "getChatSkills",
+      "getChatTodos",
+      "getChatTokenUsage",
+      "getChatToolCallMessages",
+      "getChatTools",
+      "getChats",
+      "getChatsDailyCreationStats",
+      "getChatsNeedsResponse",
+      "getClientWorkspace",
+      "getConfluenceStatus",
+      "getConnectionSyncCapabilities",
+      "getConnectionSyncCheckpoint",
+      "getConnectionSyncConfig",
+      "getCredentialUpdateInvites",
+      "getCurrentMember",
+      "getCurrentUserInfo",
+      "getCustomToolkit",
+      "getCustomToolkits",
+      "getDataRecord",
+      "getDataRecordChanges",
+      "getDataRecords",
+      "getDataType",
+      "getDataTypeByUuid",
+      "getDataTypeBySlug",
+      "getDataTypes",
+      "getDiscordBot",
+      "getDiscordBotAccounts",
+      "getDiscordBotByUuid",
+      "getDiscordBots",
+      "getDiscordGuilds",
+      "getDiscordThreads",
+      "getEventRule",
+      "getEventRules",
+      "getEventType",
+      "getEventTypes",
+      "getExperiment",
+      "getExperimentStats",
+      "getExperiments",
+      "getFhirConnection",
+      "getFhirConnectionByUuid",
+      "getFhirConnections",
+      "getFieldIndexStatus",
+      "getFile",
+      "getFileLabel",
+      "getFileLabelByUuid",
+      "getFileLabels",
+      "getFileSharing",
+      "getFiles",
+      "getFirstRunState",
+      "getFolder",
+      "getFolderSharing",
+      "getFolders",
+      "getGoogleCalendarStatus",
+      "getHealthieAvailableSlots",
+      "getHealthieReconciliationMatches",
+      "getHealthieStatus",
+      "getHubspotContactProperties",
+      "getHubspotManagedRules",
+      "getHubspotReconciliationMatches",
+      "getHubspotStatus",
+      "getHubspotSyncLogs",
+      "getHubspotTransformPresets",
+      "getICalFeedUrl",
+      "getInbox",
+      "getInboxEmail",
+      "getInboxEmails",
+      "getInboxThreads",
+      "getInboxes",
+      "getJourney",
+      "getJourneyHealth",
+      "getJourneyMembers",
+      "getJourneyNotes",
+      "getJourneys",
+      "getLinkablePhones",
+      "getLinkedHealthieMembers",
+      "getLinkedHubspotMembers",
+      "getLinkedMondayMembers",
+      "getLinkedRecords",
+      "getLinkedSalesforceMembers",
+      "getLiveOperators",
+      "getMcpServer",
+      "getMcpServerPrompts",
+      "getMcpServerResources",
+      "getMcpServerTools",
+      "getMcpServers",
+      "getMemberExperiments",
+      "getMemberFieldDefinitions",
+      "getMemberFields",
+      "getMemberFilter",
+      "getMemberFilterCount",
+      "getMemberFilters",
+      "getMemberGrants",
+      "getMemberJourneys",
+      "getMemberLabel",
+      "getMemberLabelByUuid",
+      "getMemberLabels",
+      "getMemberMemories",
+      "getMemberRecordCounts",
+      "getMemberRole",
+      "getMemberRoleByUuid",
+      "getMemberRoles",
+      "getMemberSyncSummary",
+      "getMemberUsage",
+      "getMembersMessageActivity",
+      "getMenuItems",
+      "getMessageTiming",
+      "getMilestone",
+      "getMilestones",
+      "getMondayConnectionBoardColumns",
+      "getMondayConnectionBoardGroups",
+      "getMondayConnectionBoards",
+      "getMondayConnectionStatus",
+      "getMondayReconciliationMatches",
+      "getMondaySyncConfig",
+      "getMyCredentials",
+      "getMyGivenGrants",
+      "getMyReceivedGrants",
+      "getNotification",
+      "getNotificationRules",
+      "getNotifications",
+      "getOperatorChatMessages",
+      "getOperatorGroup",
+      "getOperatorGroups",
+      "getOrCreateQualificationForWorkflow",
+      "getOwnedMembers",
+      "getPage",
+      "getPageBySlug",
+      "getPersona",
+      "getPhoneCalls",
+      "getPhoneNumber",
+      "getPhoneNumberCalls",
+      "getPhoneNumberMessages",
+      "getPhoneNumberVoicemails",
+      "getPhoneNumbers",
+      "getPhoneUsageReport",
+      "getPlatformApp",
+      "getPresenceStatus",
+      "getProducts",
+      "getPublicFile",
+      "getPublicFolder",
+      "getPublicFolderFiles",
+      "getPublicProducts",
+      "getQualification",
+      "getQualifications",
+      "getResellerWorkspaces",
+      "getRoutine",
+      "getRoutineRuns",
+      "getRoutines",
+      "getRuleExecutions",
+      "getSMSUsageReport",
+      "getSalesforceReconciliationMatches",
+      "getSalesforceStatus",
+      "getSalesforceSyncConfig",
+      "getScenario",
+      "getSite",
+      "getSiteByUuid",
+      "getSiteCounts",
+      "getSiteMenu",
+      "getSitePages",
+      "getSiteRenderedMenu",
+      "getSiteRenderedPage",
+      "getSites",
+      "getSlackApp",
+      "getSlackAppAccounts",
+      "getSlackApps",
+      "getSlackInstallations",
+      "getSlackThreads",
+      "getSnippet",
+      "getStepMemberCounts",
+      "getStepMembers",
+      "getSupervisor",
+      "getSupervisors",
+      "getSyncRunItems",
+      "getSyncRuns",
+      "getTask",
+      "getTaskChats",
+      "getTasks",
+      "getTeamsApp",
+      "getTeamsAppAccounts",
+      "getTeamsApps",
+      "getTeamsConversations",
+      "getTeamsInstallations",
+      "getTemplateContext",
+      "getTestChatRun",
+      "getThreadEmails",
+      "getTool",
+      "getToolCallNames",
+      "getToolkits",
+      "getUnreadNotificationCount",
+      "getUsageDashboard",
+      "getVariableRegistry",
+      "getVoiceToken",
+      "getVoiceUsageReport",
+      "getWebhookLogs",
+      "getWorkflow",
+      "getWorkflowAccessValidation",
+      "getWorkflowActivity",
+      "getWorkflowConfigValidation",
+      "getWorkflowContributors",
+      "getWorkflowDeletionPreview",
+      "getWorkflowDiagram",
+      "getWorkflowNotes",
+      "getWorkflowRouteDryRun",
+      "getWorkflowTaskAssignmentStats",
+      "getWorkflowTemplates",
+      "getWorkflowThumbnailUrl",
+      "getWorkflowVersion",
+      "getWorkflowVersionActive",
+      "getWorkflowVersions",
+      "getWorkflows",
+      "getWorkflowsActivityBatch",
+      "getWorkspace",
+      "getWorkspaceBuilder",
+      "getWorkspaceBuilders",
+      "getWorkspaceCounts",
+      "getWorkspaceDefaults",
+      "getWorkspaceEmailDomains",
+      "getWorkspaceMember",
+      "getWorkspaceMembers",
+      "getWorkspaceNotices",
+      "getWorkspaceProduct",
+      "getWorkspaceSiteDomains",
+      "getWorkspaceSubscriptions",
+      "getWorkspaceSupportRequest",
+      "getWorkspaceThemes",
+      "importFromBoard",
+      "importHubspotMembers",
+      "importMembers",
+      "importSalesforceMembers",
+      "importWorkspace",
+      "initiateCall",
+      "initiateOutboundCall",
+      "inspectPrompt",
+      "inviteMemberCredentialUpdate",
+      "inviteToWorkspace",
+      "leaveWorkspace",
+      "linkCalendarToGoogle",
+      "linkCalendarToHealthie",
+      "linkMemberToHealthie",
+      "linkMemberToHubspot",
+      "linkMemberToMonday",
+      "linkMemberToSalesforce",
+      "linkPhoneNumber",
+      "listAbilities",
+      "listAgentAbilities",
+      "listAppConnections",
+      "listAvailableAppConnections",
+      "listConfluencePages",
+      "listConfluenceSpaces",
+      "listConnectionMemberFieldKeys",
+      "setDefaultGooglePlatformAccount",
+      "listGoogleCalendars",
+      "listHealthieAppointmentTypes",
+      "listHealthiePatients",
+      "listHealthieProviders",
+      "listPersonas",
+      "listPushSubscriptions",
+      "listScenarios",
+      "listSnippets",
+      "listTestChatRuns",
+      "listWorkspaceInvitationsAdmin",
+      "listWorkspaceSupportRequests",
+      "markEmailAsRead",
+      "markEmailAsUnread",
+      "markNotificationAsRead",
+      "previewImportWorkspace",
+      "previewSchedule",
+      "previewTTS",
+      "previewTemplate",
+      "previewThinkingSound",
+      "previewWorkspaceImport",
+      "provisionClientWorkspace",
+      "publishWorkflowVersion",
+      "rateMessage",
+      "reenrollMember",
+      "registerLinkedRolesMetadata",
+      "registerPushSubscription",
+      "registerSlashCommands",
+      "reindexFolder",
+      "releasePhoneNumber",
+      "removeFileRole",
+      "removeFolderRole",
+      "removeGroupMember",
+      "reorderEventRules",
+      "reorderMenuItems",
+      "replyToEmail",
+      "requestPhoneNumber",
+      "requestWorkspaceMembership",
+      "resetRoutineRuns",
+      "resolveAccessGrant",
+      "resolveAgentTools",
+      "resolveAnonymousMember",
+      "revokeAccessGrant",
+      "revokeApiKey",
+      "revokeICalToken",
+      "runRoutine",
+      "searchEventRules",
+      "searchFolder",
+      "searchHubspotRecords",
+      "searchSalesforceRecords",
+      "selectCurrentAssignmentTask",
+      "sendAssistantMessage",
+      "sendChatMessage",
+      "sendOperatorMessage",
+      "siteGoogleOAuthInitiate",
+      "siteSendEmailCode",
+      "siteSendPhoneCode",
+      "siteSignup",
+      "siteVerifyCode",
+      "skipStep",
+      "startConfluenceOAuth",
+      "startHubspotOAuth",
+      "startSalesforceOAuth",
+      "startSyncRun",
+      "startTestChatRun",
+      "summarizeChat",
+      "switchMember",
+      "syncCalendarWithGoogle",
+      "syncCalendarWithHealthie",
+      "testFhirConnection",
+      "testMcpServerConnection",
+      "testMondayConnection",
+      "testRunJourney",
+      "toggleFieldIndex",
+      "unarchiveAgent",
+      "unarchiveChat",
+      "unarchiveDataType",
+      "unarchiveMember",
+      "unarchiveTask",
+      "unarchiveWorkflow",
+      "unenrollMembers",
+      "unlinkCalendarFromGoogle",
+      "unlinkCalendarFromHealthie",
+      "unlinkCredential",
+      "unlinkMemberFromHealthie",
+      "unlinkMemberFromHubspot",
+      "unlinkMemberFromMonday",
+      "unlinkMemberFromSalesforce",
+      "unregisterPushSubscription",
+      "updateAbility",
+      "updateAgent",
+      "updateAssignment",
+      "updateCalendar",
+      "updateCalendarEvent",
+      "updateCalendarSchedule",
+      "updateChat",
+      "updateChatFilter",
+      "updateChatLabel",
+      "updateChatMute",
+      "updateChatNeedsResponse",
+      "updateClientWorkspace",
+      "updateConnection",
+      "updateConnectionSyncConfig",
+      "updateCurrentMember",
+      "updateCustomTool",
+      "updateCustomToolkit",
+      "updateDataRecord",
+      "updateDataType",
+      "updateDiscordBot",
+      "updateEventAttendee",
+      "updateEventRule",
+      "updateEventType",
+      "updateExperiment",
+      "updateExperimentAssignment",
+      "updateExperimentGroup",
+      "updateFhirConnection",
+      "updateFile",
+      "updateFileLabel",
+      "updateFileRoles",
+      "updateFileSharing",
+      "updateFirstRunState",
+      "updateFolder",
+      "updateFolderRoles",
+      "updateFolderSharing",
+      "updateGoal",
+      "updateInbox",
+      "updateJourney",
+      "updateJourneyNote",
+      "updateMcpServer",
+      "updateMember",
+      "updateMemberField",
+      "updateMemberFilter",
+      "updateMemberLabel",
+      "updateMemberRole",
+      "updateMenuItem",
+      "updateMilestone",
+      "updateMondaySyncConfig",
+      "updateNotificationRule",
+      "updateOperatorGroup",
+      "updatePage",
+      "updatePersona",
+      "updatePhoneNumber",
+      "updatePlatformApp",
+      "updateProduct",
+      "updateRoutine",
+      "updateSalesforceSyncConfig",
+      "updateScenario",
+      "updateSite",
+      "updateSlackApp",
+      "updateSnippet",
+      "updateStep",
+      "updateSupervisor",
+      "updateTask",
+      "updateTeamsApp",
+      "uploadFile",
+      "updateVoicemailStatus",
+      "updateWorkflow",
+      "updateWorkflowContributor",
+      "updateWorkflowNote",
+      "updateWorkflowVersion",
+      "updateWorkspace",
+      "updateWorkspaceDefaults",
+      "updateWorkspaceInvitationAdmin",
+      "updateWorkspaceThemes",
+      "upsertDataRecord",
+      "validateDataTypeSlug",
+      "validateWorkflowName"
+    ];
+    WORKSPACE_METHOD_NAME_SET = new Set(WORKSPACE_METHOD_NAMES);
     GravityRailClient = class {
       // WorkspaceInvitations is exposed publicly for backward compatibility
       workspaceInvitations;
@@ -10810,6 +11775,11 @@ ${formattedErrors}`, response.status);
       unarchiveTask;
       cloneTask;
       getAbilityTypes;
+      getAbilityType;
+      listAbilities;
+      createAbility;
+      updateAbility;
+      deleteAbility;
       // Chats API
       getChats;
       getChat;
@@ -10855,6 +11825,7 @@ ${formattedErrors}`, response.status);
       deleteChatFilter;
       getChatFilterCount;
       // Calls API
+      getPhoneCalls;
       initiateCall;
       getVoiceToken;
       getMessageTiming;
@@ -10862,6 +11833,7 @@ ${formattedErrors}`, response.status);
       // Data Types API
       getDataTypes;
       getDataType;
+      getDataTypeByUuid;
       getDataTypeBySlug;
       createDataType;
       updateDataType;
@@ -10946,6 +11918,8 @@ ${formattedErrors}`, response.status);
       deleteAgent;
       archiveAgent;
       unarchiveAgent;
+      resolveAgentTools;
+      listAgentAbilities;
       // Qualifications API
       getQualifications;
       getQualification;
@@ -10988,6 +11962,10 @@ ${formattedErrors}`, response.status);
       reenrollMember;
       deleteEnrollment;
       getMemberJourneys;
+      getStepMembers;
+      getStepMemberCounts;
+      advanceStep;
+      skipStep;
       testRunJourney;
       getJourneyNotes;
       createJourneyNote;
@@ -11096,6 +12074,8 @@ ${formattedErrors}`, response.status);
       updateBusinessProfile;
       submitBusinessProfile;
       cancelBusinessProfile;
+      createOrganizationWorkspace;
+      getOrgBillingCustomer;
       getVapidPublicKey;
       registerPushSubscription;
       unregisterPushSubscription;
@@ -11203,6 +12183,7 @@ ${formattedErrors}`, response.status);
       getFiles;
       getFile;
       createFile;
+      uploadFile;
       updateFile;
       deleteFile;
       convertFile;
@@ -11423,6 +12404,8 @@ ${formattedErrors}`, response.status);
       updateSubscription;
       addWorkspaceToSubscription;
       purchaseCredits;
+      createCheckoutSession;
+      listSelfServeProducts;
       getAIUsageReport;
       getSMSUsageReport;
       getPhoneUsageReport;
@@ -11625,6 +12608,7 @@ ${formattedErrors}`, response.status);
       updatePlatformApp;
       deletePlatformApp;
       listConnectionMemberFieldKeys;
+      setDefaultGooglePlatformAccount;
       // Pronunciations API
       getPronunciationEntries;
       createPronunciationEntry;
@@ -11738,6 +12722,20 @@ ${formattedErrors}`, response.status);
         bindResellersMethods(this, apis.resellers);
         bindSupportRequestMethods(this, apis.supportRequests);
       }
+      /**
+       * Return a workspace-scoped client facade.
+       *
+       * Methods on the returned client are the same public SDK methods, but with
+       * the workspace UUID pre-bound:
+       *
+       * ```ts
+       * const workspace = client.workspace("workspace-uuid");
+       * await workspace.getAccessGrants({ status: "approved" });
+       * ```
+       */
+      workspace(workspaceUuid) {
+        return createWorkspaceClient(this, workspaceUuid);
+      }
       /**
        * Set the handler for enhanced authentication requirements (RFC 9470 Step-Up Auth).
        * This handler is called when a 401 response includes WWW-Authenticate header
@@ -11850,10 +12848,23 @@ var init_chunk_QS6ZRQUZ = __esm({
 });
 
 // ../sdk/dist/index.js
+var SEARCHABLE_EVENT_RULE_SOURCE_FIELDS;
 var init_dist = __esm({
   "../sdk/dist/index.js"() {
-    init_chunk_WXSLDWIA();
+    init_chunk_ML55PVP7();
     init_chunk_QS6ZRQUZ();
+    SEARCHABLE_EVENT_RULE_SOURCE_FIELDS = [
+      "taskId",
+      "dataTypeId",
+      "routineId",
+      "workflowId",
+      "journeyStepId"
+    ];
+    [
+      ...SEARCHABLE_EVENT_RULE_SOURCE_FIELDS,
+      "calendarId",
+      "calendarEventTypeId"
+    ];
   }
 });
 function detectWorktreePorts() {
@@ -11865,7 +12876,7 @@ function detectWorktreePorts() {
       overridePath = candidate;
       break;
     }
-    const parent = dirname(dir);
+    const parent = dirname$1(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -12468,46 +13479,6 @@ function formatTimestamp(isoString) {
   if (diff < 6048e5) return `${Math.floor(diff / 864e5)}d ago`;
   return date.toLocaleDateString();
 }
-function wrapText(text, width = 70) {
-  const words = text.split(" ");
-  const lines = [];
-  let currentLine = "";
-  for (const word of words) {
-    if (currentLine.length + word.length + 1 <= width) {
-      currentLine += (currentLine ? " " : "") + word;
-    } else {
-      if (currentLine) lines.push(currentLine);
-      currentLine = word;
-    }
-  }
-  if (currentLine) lines.push(currentLine);
-  return lines;
-}
-function printMessage(content, role, indent = "  ") {
-  const roleColors = {
-    user: "\x1B[34m",
-    // Blue
-    assistant: "\x1B[32m",
-    // Green
-    system: "\x1B[90m"
-    // Gray
-  };
-  const resetColor = "\x1B[0m";
-  const color = roleColors[role] || resetColor;
-  const label = role === "user" ? "You" : role === "assistant" ? "Assistant" : "System";
-  console.log(`${indent}${color}[${label}]${resetColor}`);
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const wrapped = wrapText(line, 70);
-    for (const wrappedLine of wrapped) {
-      console.log(`${indent}  ${wrappedLine}`);
-    }
-  }
-  console.log("");
-}
-function clearScreen() {
-  process.stdout.write("\x1B[2J\x1B[H");
-}
 var NEW_ITEM_MARKER;
 var init_ui = __esm({
   "src/cli-utils/ui.ts"() {
@@ -16612,11 +17583,11 @@ var require_util2 = __commonJS({
     var { isUint8Array } = __require("util/types");
     var { webidl } = require_webidl();
     var supportedHashes = [];
-    var crypto;
+    var crypto2;
     try {
-      crypto = __require("crypto");
+      crypto2 = __require("crypto");
       const possibleRelevantHashes = ["sha256", "sha384", "sha512"];
-      supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
+      supportedHashes = crypto2.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
     } catch {
     }
     function responseURL(response) {
@@ -16888,7 +17859,7 @@ var require_util2 = __commonJS({
       }
     }
     function bytesMatch(bytes, metadataList) {
-      if (crypto === void 0) {
+      if (crypto2 === void 0) {
         return true;
       }
       const parsedMetadata = parseMetadata(metadataList);
@@ -16903,7 +17874,7 @@ var require_util2 = __commonJS({
       for (const item of metadata) {
         const algorithm = item.algo;
         const expectedValue = item.hash;
-        let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64");
+        let actualValue = crypto2.createHash(algorithm).update(bytes).digest("base64");
         if (actualValue[actualValue.length - 1] === "=") {
           if (actualValue[actualValue.length - 2] === "=") {
             actualValue = actualValue.slice(0, -2);
@@ -17961,8 +18932,8 @@ var require_body = __commonJS({
     var { multipartFormDataParser } = require_formdata_parser();
     var random;
     try {
-      const crypto = __require("crypto");
-      random = (max) => crypto.randomInt(0, max);
+      const crypto2 = __require("crypto");
+      random = (max) => crypto2.randomInt(0, max);
     } catch {
       random = (max) => Math.floor(Math.random(max));
     }
@@ -27210,7 +28181,7 @@ var require_util4 = __commonJS({
     var { serializeAMimeType, parseMIMEType } = require_data_url();
     var { types } = __require("util");
     var { StringDecoder } = __require("string_decoder");
-    var { btoa } = __require("buffer");
+    var { btoa: btoa2 } = __require("buffer");
     var staticPropertyDescriptors = {
       enumerable: true,
       writable: false,
@@ -27302,9 +28273,9 @@ var require_util4 = __commonJS({
           dataURL += ";base64,";
           const decoder = new StringDecoder("latin1");
           for (const chunk of bytes) {
-            dataURL += btoa(decoder.write(chunk));
+            dataURL += btoa2(decoder.write(chunk));
           }
-          dataURL += btoa(decoder.end());
+          dataURL += btoa2(decoder.end());
           return dataURL;
         }
         case "Text": {
@@ -29290,13 +30261,13 @@ var require_frame = __commonJS({
   "../../node_modules/undici/lib/web/websocket/frame.js"(exports$1, module) {
     var { maxUnsigned16Bit } = require_constants5();
     var BUFFER_SIZE = 16386;
-    var crypto;
+    var crypto2;
     var buffer = null;
     var bufIdx = BUFFER_SIZE;
     try {
-      crypto = __require("crypto");
+      crypto2 = __require("crypto");
     } catch {
-      crypto = {
+      crypto2 = {
         // not full compatibility, but minimum.
         randomFillSync: function randomFillSync(buffer2, _offset, _size) {
           for (let i = 0; i < buffer2.length; ++i) {
@@ -29309,7 +30280,7 @@ var require_frame = __commonJS({
     function generateMask() {
       if (bufIdx === BUFFER_SIZE) {
         bufIdx = 0;
-        crypto.randomFillSync(buffer ??= Buffer.allocUnsafe(BUFFER_SIZE), 0, BUFFER_SIZE);
+        crypto2.randomFillSync(buffer ??= Buffer.allocUnsafe(BUFFER_SIZE), 0, BUFFER_SIZE);
       }
       return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]];
     }
@@ -29380,9 +30351,9 @@ var require_connection = __commonJS({
     var { Headers: Headers2, getHeadersList } = require_headers();
     var { getDecodeSplit } = require_util2();
     var { WebsocketFrameSend } = require_frame();
-    var crypto;
+    var crypto2;
     try {
-      crypto = __require("crypto");
+      crypto2 = __require("crypto");
     } catch {
     }
     function establishWebSocketConnection(url, protocols, client, ws, onEstablish, options) {
@@ -29402,7 +30373,7 @@ var require_connection = __commonJS({
         const headersList = getHeadersList(new Headers2(options.headers));
         request.headersList = headersList;
       }
-      const keyValue = crypto.randomBytes(16).toString("base64");
+      const keyValue = crypto2.randomBytes(16).toString("base64");
       request.headersList.append("sec-websocket-key", keyValue);
       request.headersList.append("sec-websocket-version", "13");
       for (const protocol of protocols) {
@@ -29432,7 +30403,7 @@ var require_connection = __commonJS({
             return;
           }
           const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
-          const digest = crypto.createHash("sha1").update(keyValue + uid).digest("base64");
+          const digest = crypto2.createHash("sha1").update(keyValue + uid).digest("base64");
           if (secWSAccept !== digest) {
             failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header.");
             return;
@@ -29973,9 +30944,9 @@ var require_sender = __commonJS({
       constructor(socket) {
         this.#socket = socket;
       }
-      add(item, cb, hint) {
-        if (hint !== sendHints.blob) {
-          const frame = createFrame(item, hint);
+      add(item, cb, hint2) {
+        if (hint2 !== sendHints.blob) {
+          const frame = createFrame(item, hint2);
           if (!this.#running) {
             this.#socket.write(frame, cb);
           } else {
@@ -29991,7 +30962,7 @@ var require_sender = __commonJS({
         const node = {
           promise: item.arrayBuffer().then((ab) => {
             node.promise = null;
-            node.frame = createFrame(ab, hint);
+            node.frame = createFrame(ab, hint2);
           }),
           callback: cb,
           frame: null
@@ -30015,11 +30986,11 @@ var require_sender = __commonJS({
         this.#running = false;
       }
     };
-    function createFrame(data, hint) {
-      return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.string ? opcodes.TEXT : opcodes.BINARY);
+    function createFrame(data, hint2) {
+      return new WebsocketFrameSend(toBuffer(data, hint2)).createFrame(hint2 === sendHints.string ? opcodes.TEXT : opcodes.BINARY);
     }
-    function toBuffer(data, hint) {
-      switch (hint) {
+    function toBuffer(data, hint2) {
+      switch (hint2) {
         case sendHints.string:
           return Buffer.from(data);
         case sendHints.arrayBuffer:
@@ -31164,32 +32135,31 @@ function createPinnedFetch(apiUrl, apiIp) {
 }
 function withAuditHeaders(fetchFn, headers2) {
   const { chatId, sessionId, toolCallId } = headers2;
-  if (chatId === void 0 && !sessionId && !toolCallId) {
-    return fetchFn;
-  }
   return async (input2, init) => {
     const reqHeaders = new Headers(init?.headers);
+    const dynamicToolCallId = globalThis.__GRAVITY_RAIL_TOOL_CALL_ID__ || (typeof process !== "undefined" ? process.env.GRAVITY_RAIL_TOOL_CALL_ID : void 0);
     if (chatId !== void 0) {
       reqHeaders.set("X-GR-Chat-Id", String(chatId));
     }
     if (sessionId) {
       reqHeaders.set("X-GR-Session-Id", sessionId);
     }
-    if (toolCallId) {
-      reqHeaders.set("X-GR-Tool-Call-Id", toolCallId);
+    if (dynamicToolCallId || toolCallId) {
+      reqHeaders.set("X-GR-Tool-Call-Id", dynamicToolCallId || toolCallId || "");
     }
     return fetchFn(input2, { ...init, headers: reqHeaders });
   };
 }
 function createSandboxFetchFromEnv(apiUrl) {
-  const apiIp = process.env.GRAVITY_RAIL_API_IP;
+  const env = typeof process !== "undefined" ? process.env : {};
+  const apiIp = env.GRAVITY_RAIL_API_IP;
   let fetchFn = createPinnedFetch(apiUrl, apiIp);
-  const chatIdRaw = process.env.GRAVITY_RAIL_CHAT_ID;
+  const chatIdRaw = env.GRAVITY_RAIL_CHAT_ID;
   const chatId = chatIdRaw ? Number(chatIdRaw) : void 0;
   return withAuditHeaders(fetchFn, {
     chatId: chatId !== void 0 && Number.isFinite(chatId) ? chatId : void 0,
-    sessionId: process.env.GRAVITY_RAIL_SESSION_ID,
-    toolCallId: process.env.GRAVITY_RAIL_TOOL_CALL_ID
+    sessionId: env.GRAVITY_RAIL_SESSION_ID,
+    toolCallId: env.GRAVITY_RAIL_TOOL_CALL_ID
   });
 }
 var import_undici;
@@ -31271,7 +32241,7 @@ var init_context = __esm({
 });
 
 // src/lib/concierge-api.ts
-function baseUrl2(ctx) {
+function baseUrl(ctx) {
   return `${ctx.envConfig.apiUrl}/api/v2/concierge`;
 }
 function authHeaders(ctx) {
@@ -31302,13 +32272,13 @@ function toCamelMessage(raw) {
   };
 }
 async function listConciergeChats(ctx) {
-  const res = await fetch(`${baseUrl2(ctx)}/chats`, { headers: authHeaders(ctx) });
+  const res = await fetch(`${baseUrl(ctx)}/chats`, { headers: authHeaders(ctx) });
   if (!res.ok) throw new Error(`Failed to list concierge chats: ${res.status}`);
   const data = await res.json();
   return data.map(toCamelChat);
 }
 async function createConciergeChat(ctx, title) {
-  const res = await fetch(`${baseUrl2(ctx)}/chats`, {
+  const res = await fetch(`${baseUrl(ctx)}/chats`, {
     method: "POST",
     headers: authHeaders(ctx),
     body: JSON.stringify({ title: null })
@@ -31317,15 +32287,18 @@ async function createConciergeChat(ctx, title) {
   return toCamelChat(await res.json());
 }
 async function getConciergeChat(ctx, chatId) {
-  const res = await fetch(`${baseUrl2(ctx)}/chats/${chatId}`, { headers: authHeaders(ctx) });
+  const res = await fetch(`${baseUrl(ctx)}/chats/${chatId}`, { headers: authHeaders(ctx) });
   if (!res.ok) throw new Error(`Failed to get concierge chat ${chatId}: ${res.status}`);
   return toCamelChat(await res.json());
 }
-async function originateConciergeCall(ctx, kind = "concierge_setup") {
-  const res = await fetch(`${baseUrl2(ctx)}/calls`, {
+async function originateConciergeCall(ctx, kind = "concierge_setup", outboundMessage, clientSurface) {
+  const body = { kind };
+  if (outboundMessage) body.outbound_message = outboundMessage;
+  body.client_surface = clientSurface;
+  const res = await fetch(`${baseUrl(ctx)}/calls`, {
     method: "POST",
     headers: authHeaders(ctx),
-    body: JSON.stringify({ kind })
+    body: JSON.stringify(body)
   });
   if (res.status === 412) {
     throw new Error("Your account phone is not verified. Run `gr account verify-phone` first.");
@@ -31337,7 +32310,7 @@ async function originateConciergeCall(ctx, kind = "concierge_setup") {
   return await res.json();
 }
 async function originateConciergeSms(ctx, kind = "concierge_setup") {
-  const res = await fetch(`${baseUrl2(ctx)}/sms`, {
+  const res = await fetch(`${baseUrl(ctx)}/sms`, {
     method: "POST",
     headers: authHeaders(ctx),
     body: JSON.stringify({ kind })
@@ -31374,7 +32347,7 @@ async function confirmAccountPhoneVerify(ctx, code) {
   }
 }
 async function getConciergeChatMessages(ctx, chatId) {
-  const res = await fetch(`${baseUrl2(ctx)}/chats/${chatId}/messages`, {
+  const res = await fetch(`${baseUrl(ctx)}/chats/${chatId}/messages`, {
     headers: authHeaders(ctx)
   });
   if (!res.ok)
@@ -31410,7 +32383,7 @@ async function accountVerifyPhoneCommand(hctx) {
   );
 }
 async function promptLine(question) {
-  const rl = readline6.createInterface({ input: stdin, output: stdout });
+  const rl = readline5.createInterface({ input: stdin, output: stdout });
   try {
     return await rl.question(question) ?? "";
   } finally {
@@ -31884,6 +32857,11 @@ var CommandRegistry = class {
     const key = cmd.path.join(" ");
     this.commands.set(key, cmd);
   }
+  registerCommands(commands3) {
+    for (const cmd of commands3) {
+      this.registerCommand(cmd);
+    }
+  }
   /** Resolve command words to a CommandDef using longest-match.
    *  Supports {param} path segments that match any word and extract as pathParams. */
   resolve(words) {
@@ -31916,6 +32894,7 @@ var CommandRegistry = class {
   }
   /** Generate help text. If prefix given, show commands under that prefix. */
   getHelp(prefix) {
+    const inSandbox = process.env.GRAVITY_RAIL_SANDBOX === "1";
     if (!prefix || prefix.length === 0) {
       return this.getTopLevelHelp();
     }
@@ -31952,18 +32931,21 @@ var CommandRegistry = class {
 `, "Commands:"];
     for (const cmd of matching.sort((a, b) => a.path.join(" ").localeCompare(b.path.join(" ")))) {
       const subPath = cmd.path.slice(prefix.length).join(" ") || cmd.path[cmd.path.length - 1];
-      lines.push(`  ${subPath.padEnd(28)} ${cmd.description}`);
+      const description = inSandbox ? sandboxHelpText(cmd.description) : cmd.description;
+      lines.push(`  ${subPath.padEnd(28)} ${description}`);
     }
     return lines.join("\n") + "\n";
   }
   getCommandHelp(cmd) {
     const cmdStr = cmd.path.join(" ");
-    const lines = [`${cmd.description}
+    const inSandbox = process.env.GRAVITY_RAIL_SANDBOX === "1";
+    const description = inSandbox ? sandboxHelpText(cmd.description) : cmd.description;
+    const lines = [`${description}
 `, `Usage: gr ${cmdStr} [options]`];
-    if (cmd.requiresWorkspace) {
+    if (cmd.requiresWorkspace && !inSandbox) {
       lines.push("  Requires: -w <workspace-uuid>  (or --realm <workspace>/<member> in dev)");
     }
-    if (cmd.mutates) {
+    if (cmd.mutates && !inSandbox) {
       lines.push("  Requires: --allow-write");
     }
     const action = cmd.path[cmd.path.length - 1] ?? "";
@@ -31985,7 +32967,7 @@ var CommandRegistry = class {
     if (cmd.examples && cmd.examples.length > 0) {
       lines.push("", "Examples:");
       for (const ex of cmd.examples) {
-        lines.push(`  ${ex}`);
+        lines.push(`  ${inSandbox ? sandboxExample(ex) : ex}`);
       }
     }
     return lines.join("\n") + "\n";
@@ -32000,38 +32982,50 @@ var CommandRegistry = class {
   }
   getTopLevelHelp() {
     const lines = ["Usage: gr <command> [options]\n", "Commands:"];
+    const inSandbox = process.env.GRAVITY_RAIL_SANDBOX === "1";
     const seen = /* @__PURE__ */ new Set();
     for (const domain of this.domains) {
       if (!seen.has(domain.name)) {
         seen.add(domain.name);
-        lines.push(`  ${domain.name.padEnd(28)} ${domain.description}`);
+        const description = inSandbox ? sandboxHelpText(domain.description) : domain.description;
+        lines.push(`  ${domain.name.padEnd(28)} ${description}`);
       }
     }
     for (const [, cmd] of this.commands) {
       const topWord = cmd.path[0];
       if (!seen.has(topWord) && cmd.path.length === 1) {
         seen.add(topWord);
-        lines.push(`  ${topWord.padEnd(28)} ${cmd.description}`);
+        const description = inSandbox ? sandboxHelpText(cmd.description) : cmd.description;
+        lines.push(`  ${topWord.padEnd(28)} ${description}`);
       }
     }
-    lines.push(
+    const globalOptions = [
       "",
       "Global Options:",
-      "  --env <env>               Environment: dev, staging, prod (default: dev)",
-      "  --realm <ws>/<member>     Dev auth shortcut (dev only; sets -w automatically)",
-      "  --api-url <url>           API base URL (or GRAVITY_RAIL_API_URL)",
-      "  -w, --workspace <uuid>    Workspace UUID",
+      ...!inSandbox ? [
+        "  --env <env>               Environment: dev, staging, prod (default: dev)",
+        "  --realm <ws>/<member>     Dev auth shortcut (dev only; sets -w automatically)",
+        "  --api-url <url>           API base URL (or GRAVITY_RAIL_API_URL)",
+        "  -w, --workspace <uuid>    Workspace UUID"
+      ] : [],
       "  -d, --data <json>         JSON body (create/update and other write commands)",
       "  -f, --file <path>         JSON body from file",
-      "  --allow-write             Required for create/update/delete/archive",
+      ...!inSandbox ? ["  --allow-write             Required for create/update/delete/archive"] : [],
       "  -o, --output-format <fmt> Output format: json, jsonl, table (default: auto)",
       "  -v, --verbose             Verbose output to stderr",
       "  --help                    Show help",
       "  --version                 Show version"
-    );
+    ];
+    lines.push(...globalOptions);
     return lines.join("\n") + "\n";
   }
 };
+function sandboxHelpText(text) {
+  return text.replace(/\byarn gr\b/g, "gr").replace(/\s--allow-write\b/g, "").replace(/\s--realm\s+(?:"[^"]+"|'[^']+'|<[^>]+>|\S+)/g, "").replace(/\s-w\s+(?:"[^"]+"|'[^']+'|<[^>]+>|\S+)/g, "");
+}
+function sandboxExample(example) {
+  return sandboxHelpText(example);
+}
 
 // src/lib/types.ts
 function requireString(args, key) {
@@ -32054,8 +33048,8 @@ function requireNumberFrom(args, ...keys) {
       if (!isNaN(num)) return num;
     }
   }
-  const hint = keys.map((k) => `--${k}`).join(" or ");
-  throw new Error(`Missing required argument: ${hint}`);
+  const hint2 = keys.map((k) => `--${k}`).join(" or ");
+  throw new Error(`Missing required argument: ${hint2}`);
 }
 
 // src/domains/agent-tasks.ts
@@ -32195,7 +33189,45 @@ var agentTasksDomain = {
 
 // src/domains/agents.ts
 init_output();
+init_context();
+init_errors();
 var COLUMNS = [COL.id(), COL.uuid(), COL.name(), COL.status(), COL.created()];
+var TOOL_COLUMNS = [
+  COL.name(),
+  { header: "DESCRIPTION", getValue: (item) => (item.description ?? "").slice(0, 60) }
+];
+var ABILITY_COLUMNS = [
+  COL.uuid(),
+  { header: "ABILITY-TYPE", getValue: (item) => item.abilityType ?? "" },
+  COL.enabled(),
+  { header: "CEL-CONDITION", getValue: (item) => item.celCondition ?? "" }
+];
+function requireAbilityScope(args) {
+  const hasWorkflow = typeof args["workflow-id"] === "string";
+  const hasTask = typeof args["task-id"] === "string";
+  if (hasWorkflow === hasTask) {
+    throw new CLIError(
+      "Specify exactly one of --workflow-id or --task-id. Abilities are scoped to a workflow or task, not to the agent row itself."
+    );
+  }
+  if (hasTask) {
+    const taskId = Number(args["task-id"]);
+    if (isNaN(taskId)) throw new CLIError("--task-id must be a number");
+    return { taskId };
+  }
+  const workflowId = Number(args["workflow-id"]);
+  if (isNaN(workflowId)) throw new CLIError("--workflow-id must be a number");
+  return { workflowId };
+}
+function normalizeChannel(channel) {
+  const aliases = {
+    phone: "phone-voice",
+    voice: "phone-voice",
+    sms: "phone-sms",
+    web: "web-chat"
+  };
+  return aliases[channel] ?? channel;
+}
 var agentsDomain = {
   name: "agents",
   description: "Manage agents",
@@ -32211,8 +33243,163 @@ var agentsDomain = {
       archiveMethod: "archiveAgent",
       unarchiveMethod: "unarchiveAgent",
       columns: COLUMNS,
-      paginationSupport: "full"
-    })
+      paginationSupport: "full",
+      updateHelp: "Update an agent. Body schema (JSON via --data/--file/stdin), all fields optional:\n  name              string   display name\n  description       string   short summary shown in listings\n  systemPrompt      string   base instructions for the agent\n  model             string   AI model slug (see `gr ai-models list`)\n  temperature       number   sampling temperature (0-2)\n  avatarFileId      number   workspace file ID for the avatar\n  config            object   AgentConfig overrides (advanced)\nAbilities are NOT set here \u2014 they live on a workflow/task scope; use `gr agents abilities` to manage them.",
+      updateExamples: [
+        `gr agents update --id 42 --data '{"name":"Scheduler","temperature":0.4}'`,
+        "gr agents update --id 42 --file agent.json"
+      ]
+    }),
+    {
+      path: ["agents", "resolve-tools"],
+      description: "Show resolved runtime tools for an agent in a channel context. Channel accepts canonical values (phone-voice, web-voice, phone-sms, web-chat) or shorthand aliases: phone -> phone-voice, voice -> phone-voice, sms -> phone-sms, web -> web-chat. Unknown values are passed through unchanged. When neither --task-id nor --task-uuid is supplied the agent's workflow start task is used.",
+      requiresWorkspace: true,
+      args: [
+        { name: "id", description: "Agent ID", required: true },
+        {
+          name: "channel",
+          description: "Channel to simulate. Canonical: phone-voice, web-voice, phone-sms, web-chat. Aliases: phone|voice -> phone-voice, sms -> phone-sms, web -> web-chat.",
+          required: true
+        },
+        {
+          name: "task-id",
+          description: "Numeric task ID whose workflow abilities to resolve. Omit to use the workflow start task (or supply --task-uuid instead).",
+          required: false
+        },
+        {
+          name: "task-uuid",
+          description: "Task UUID as an alternative to --task-id. Omit to use the workflow start task.",
+          required: false
+        }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        const rawTaskId = args["task-id"];
+        const rawTaskUuid = args["task-uuid"];
+        if (rawTaskId !== void 0 && rawTaskUuid !== void 0) {
+          throw new Error("Provide at most one of --task-id or --task-uuid, not both");
+        }
+        const options = {
+          channel: normalizeChannel(String(args.channel))
+        };
+        if (typeof rawTaskId === "string") {
+          const n = Number(rawTaskId);
+          if (isNaN(n)) throw new Error("Argument --task-id must be a number");
+          options.taskId = n;
+        }
+        if (typeof rawTaskUuid === "string") {
+          options.taskUuid = rawTaskUuid;
+        }
+        const result2 = await requireAuth(ctx).apiClient.resolveAgentTools(
+          workspace,
+          requireNumber(args, "id"),
+          options
+        );
+        const tools = result2.tools ?? result2;
+        outputData(Array.isArray(tools) ? tools : [tools], ctx, TOOL_COLUMNS);
+      }
+    },
+    {
+      path: ["agents", "abilities", "list"],
+      description: "Show the abilities effective for an agent on a task (read-only). Requires --task-id because abilities are resolved through the task's workflow, not stored on the agent row.",
+      requiresWorkspace: true,
+      columns: ABILITY_COLUMNS,
+      args: [
+        { name: "id", description: "Agent ID", required: true },
+        {
+          name: "task-id",
+          description: "Task ID whose workflow abilities to list",
+          required: true
+        }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        const result2 = await requireAuth(ctx).apiClient.listAgentAbilities(
+          workspace,
+          requireNumber(args, "id"),
+          { taskId: requireNumber(args, "task-id") }
+        );
+        outputData(result2, ctx, ABILITY_COLUMNS);
+      }
+    },
+    {
+      path: ["agents", "abilities", "enable"],
+      description: "Enable (create) an ability on a workflow or task scope. Requires exactly one of --workflow-id or --task-id \u2014 abilities are scoped to a workflow/task, never to the agent row. Provide initial --config JSON inline or via --data/--file.",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "ability-type", description: "Ability type slug (e.g. 'communication:send_sms')", required: true },
+        { name: "workflow-id", description: "Workflow scope (mutually exclusive with --task-id)" },
+        { name: "task-id", description: "Task scope (mutually exclusive with --workflow-id)" }
+      ],
+      examples: [
+        "gr agents abilities enable --workflow-id 7 --ability-type tools:web_search",
+        `gr agents abilities enable --task-id 12 --ability-type integration:data_access --data '{"dataTypeUuid":"..."}'`
+      ],
+      handler: async ({ ctx, workspace, args, data }) => {
+        const abilityType = args["ability-type"];
+        if (typeof abilityType !== "string") {
+          throw new CLIError("--ability-type is required");
+        }
+        const scope = requireAbilityScope(args);
+        const config = data && typeof data === "object" ? data : {};
+        const body = {
+          abilityType,
+          config,
+          ...scope
+        };
+        const result2 = await requireAuth(ctx).apiClient.createAbility(workspace, body);
+        outputSingle(result2, ctx, ABILITY_COLUMNS);
+      }
+    },
+    {
+      path: ["agents", "abilities", "disable"],
+      description: "Disable an ability instance by UUID (sets enabled=false, keeps config). Use `gr agents abilities list` to find the UUID.",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [{ name: "uuid", description: "Ability instance UUID", required: true }],
+      handler: async ({ ctx, workspace, args }) => {
+        const uuid = args.uuid;
+        if (typeof uuid !== "string") throw new CLIError("--uuid is required");
+        const result2 = await requireAuth(ctx).apiClient.updateAbility(workspace, uuid, {
+          enabled: false
+        });
+        outputSingle(result2, ctx, ABILITY_COLUMNS);
+      }
+    },
+    {
+      path: ["agents", "abilities", "configure"],
+      description: "Update an ability instance by UUID. Pass --data/--file JSON to merge into config, and/or --enabled true|false to toggle. config is merged with the existing config server-side.",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "uuid", description: "Ability instance UUID", required: true },
+        { name: "enabled", description: "Set enabled state (true|false)" }
+      ],
+      examples: [
+        `gr agents abilities configure --uuid <uuid> --data '{"canForward":true}'`,
+        "gr agents abilities configure --uuid <uuid> --enabled true"
+      ],
+      handler: async ({ ctx, workspace, args, data }) => {
+        const uuid = args.uuid;
+        if (typeof uuid !== "string") throw new CLIError("--uuid is required");
+        const body = {};
+        if (data && typeof data === "object") {
+          body.config = data;
+        }
+        if (typeof args.enabled === "string") {
+          if (args.enabled !== "true" && args.enabled !== "false") {
+            throw new CLIError("--enabled must be true or false");
+          }
+          body.enabled = args.enabled === "true";
+        }
+        if (Object.keys(body).length === 0) {
+          throw new CLIError(
+            "Nothing to update: provide --data config and/or --enabled"
+          );
+        }
+        const result2 = await requireAuth(ctx).apiClient.updateAbility(workspace, uuid, body);
+        outputSingle(result2, ctx, ABILITY_COLUMNS);
+      }
+    }
   ]
 };
 
@@ -32220,6 +33407,7 @@ var agentsDomain = {
 init_output();
 init_cli_utils();
 init_context();
+init_concierge_api();
 var COLUMNS2 = [
   COL.id(),
   COL.uuid(),
@@ -32440,21 +33628,47 @@ var chatsDomain = {
     // Inspect (aggregated debug view)
     {
       path: ["chats", "inspect"],
-      description: "Inspect a chat with messages, assignment state, and data records",
-      requiresWorkspace: true,
+      description: "Inspect a chat with messages, assignment state, and data records. Omit -w for concierge (account-level) chats.",
+      requiresWorkspace: false,
       args: [{ name: "id", description: "Chat ID", required: true }],
       handler: async ({ ctx, workspace, args }) => {
         const chatId = requireNumber(args, "id");
-        const [chat, messages, ws] = await Promise.all([
-          requireAuth(ctx).apiClient.getChat(workspace, chatId),
-          requireAuth(ctx).apiClient.getChatMessages(workspace, chatId),
-          requireAuth(ctx).apiClient.getWorkspace(workspace)
-        ]);
-        const isHipaa = ws.features?.includes("hipaa_compliance");
+        const authed = requireAuth(ctx);
         const truncate2 = (content) => {
           const text = typeof content === "string" ? content : JSON.stringify(content);
           return text.slice(0, 200);
         };
+        if (!workspace) {
+          const [chat2, messages2] = await Promise.all([
+            getConciergeChat(authed, chatId),
+            getConciergeChatMessages(authed, chatId)
+          ]);
+          outputSingle(
+            {
+              chat: {
+                id: chat2.id,
+                uuid: chat2.uuid,
+                title: chat2.title,
+                chatType: chat2.chatType,
+                threadId: chat2.threadId,
+                createdAt: chat2.createdAt
+              },
+              messages: messages2.map((m) => ({
+                id: m.id,
+                role: m.role,
+                content: truncate2(m.content)
+              }))
+            },
+            ctx
+          );
+          return;
+        }
+        const [chat, messages, ws] = await Promise.all([
+          authed.apiClient.getChat(workspace, chatId),
+          authed.apiClient.getChatMessages(workspace, chatId),
+          authed.apiClient.getWorkspace(workspace)
+        ]);
+        const isHipaa = ws.features?.includes("hipaa_compliance");
         const result2 = {
           chat: {
             id: chat.id,
@@ -32474,10 +33688,7 @@ var chatsDomain = {
         };
         const assignmentId = chat.assignmentId;
         if (assignmentId) {
-          const assignment = await requireAuth(ctx).apiClient.getAssignment(
-            workspace,
-            assignmentId
-          );
+          const assignment = await authed.apiClient.getAssignment(workspace, assignmentId);
           result2.assignment = {
             id: assignment.id,
             status: assignment.status,
@@ -32735,10 +33946,7 @@ var memberRolesDomain = {
     updateMethod: "updateMemberRole",
     deleteMethod: "deleteMemberRole",
     columns: ROLE_COLUMNS2,
-    createExamples: [
-      "gr member-roles list -w $WID",
-      "gr member-roles get -w $WID --id 2"
-    ]
+    createExamples: ["gr member-roles list -w $WID", "gr member-roles get -w $WID --id 2"]
   })
 };
 
@@ -32749,10 +33957,13 @@ var COLUMNS4 = [
   COL.id(),
   COL.uuid(),
   COL.name(),
-  COL.status(),
+  // TaskResponse has no `status` field — it has `archived`. Surface that
+  // directly so active vs archived is visible in the default table (relevant
+  // once --include-archived mixes both into the listing).
+  { header: "STATUS", getValue: (item) => item.archived ? "archived" : "active" },
   {
     header: "WORKFLOW",
-    getValue: (item) => item.workflow_name ?? String(item.workflow_id ?? "")
+    getValue: (item) => String(item.workflowId ?? "")
   },
   COL.created()
 ];
@@ -32770,7 +33981,21 @@ var tasksDomain = {
       deleteMethod: "deleteTask",
       archiveMethod: "archiveTask",
       unarchiveMethod: "unarchiveTask",
-      columns: COLUMNS4
+      columns: COLUMNS4,
+      // `tasks list` is workspace-wide by default. Filter to one workflow
+      // with --workflow-id, and opt into archived tasks with
+      // --include-archived (active-only by default, matching the backend).
+      listArgs: [
+        {
+          name: "workflow-id",
+          description: "Filter tasks to a single workflow by ID"
+        },
+        {
+          name: "include-archived",
+          description: "Include archived tasks in the listing",
+          isFlag: true
+        }
+      ]
     }),
     {
       path: ["tasks", "clone"],
@@ -32830,9 +34055,18 @@ var COLUMNS5 = [
   COL.id(),
   COL.uuid(),
   COL.name(),
-  { header: "TASKS", getValue: (item) => String(item.taskCount ?? "") },
+  // taskCount is the total (active + archived). Show the active count as the
+  // headline number — matching `tasks list` — and call out archived tasks
+  // separately so the table never overstates how many tasks actually run.
+  { header: "TASKS", getValue: (item) => formatTaskCount(item) },
   COL.created()
 ];
+function formatTaskCount(item) {
+  const total = Number(item.taskCount ?? 0);
+  const archived = Number(item.archivedTaskCount ?? 0);
+  const active = total - archived;
+  return archived > 0 ? `${active} (+${archived} archived)` : String(active);
+}
 var NOTE_COLUMNS = [
   COL.id(),
   { header: "TITLE", getValue: (item) => item.title ?? "" },
@@ -32933,13 +34167,21 @@ var workflowsDomain = {
     // Diagram
     {
       path: ["workflows", "diagram"],
-      description: "Get workflow diagram",
+      description: "Get workflow diagram (active tasks only by default)",
       requiresWorkspace: true,
-      args: [{ name: "id", description: "Workflow ID", required: true }],
+      args: [
+        { name: "id", description: "Workflow ID", required: true },
+        {
+          name: "include-archived",
+          description: "Render archived tasks (distinctly styled) too",
+          isFlag: true
+        }
+      ],
       handler: async ({ ctx, workspace, args }) => {
         const result2 = await requireAuth(ctx).apiClient.getWorkflowDiagram(
           workspace,
-          requireNumber(args, "id")
+          requireNumber(args, "id"),
+          { includeArchived: args["include-archived"] === true }
         );
         outputSingle(result2, ctx);
       }
@@ -33462,28 +34704,64 @@ var workspacesDomain = {
         outputSingle(result2, ctx, COLUMNS7);
       }
     },
-    // Create a workspace via the public endpoint
+    // Provision a workspace under an organization's active subscription.
     {
       path: ["workspaces", "create"],
-      description: "Create a workspace",
+      description: "Provision a workspace in an organization (requires an active subscription)",
       mutates: true,
       requiresWorkspace: false,
-      handler: async ({ ctx, data }) => {
-        if (!data) throw new CLIError("JSON data required (--data, --file, or stdin)");
-        const payload = data;
-        if (!payload.organizationId) {
+      args: [
+        {
+          name: "org",
+          aliases: ["org-uuid"],
+          description: "Organization UUID",
+          required: true
+        },
+        { name: "product", description: "Workspace plan product ID", required: true },
+        { name: "name", description: "Workspace name", required: true },
+        { name: "period", description: "Billing period: 'month' or 'year'", default: "month" },
+        { name: "slug", description: "Workspace slug (optional)" },
+        { name: "template", description: "Template workspace UUID to clone (optional)" }
+      ],
+      examples: ['gr workspaces create --org <org-uuid> --product 14 --name "Front Desk"'],
+      handler: async ({ ctx, args }) => {
+        const orgUuid = args.org ?? args["org-uuid"];
+        const name = args.name;
+        const productRaw = args.product;
+        if (!orgUuid) throw new CLIError("Missing required argument: --org <org-uuid>");
+        if (!name) throw new CLIError("Missing required argument: --name");
+        if (!productRaw) {
           throw new CLIError(
-            `organizationId is required in --data (e.g. --data '{"organizationId": 1, "name": "My Workspace"}')`
+            "Missing required argument: --product\nList workspace plans with: gr billing products --type workspace"
           );
         }
+        const payload = {
+          name,
+          productId: Number(productRaw),
+          planPeriod: args.period || "month"
+        };
+        if (args.slug) payload.slug = args.slug;
+        if (args.template) payload.templateWorkspaceUuid = args.template;
         try {
-          const result2 = await requireAuth(ctx).apiClient.createWorkspace(payload);
+          const result2 = await requireAuth(ctx).apiClient.createOrganizationWorkspace(
+            orgUuid,
+            payload
+          );
           outputSingle(result2, ctx, COLUMNS7);
+          if ((ctx.outputFormat ?? "table") === "table") {
+            const wsUuid = result2?.uuid ?? "<workspace-uuid>";
+            process.stdout.write(
+              `
+Provisioning started. Watch it come up with:
+  gr workspaces get -w ${wsUuid}
+`
+            );
+          }
         } catch (err) {
           const statusCode = err?.statusCode;
-          if (statusCode === 405) {
+          if (statusCode === 400) {
             throw new CLIError(
-              'Creating a workspace directly is not supported \u2014 provisioning runs through the concierge (it handles product selection and billing).\nNext: gr concierge chat --allow-write --message "Create a new workspace"\nThen: gr workspaces list  (to get the new workspace UUID for -w)'
+              "Could not create the workspace. The organization needs an active, paid subscription first.\n  gr billing products --type org      # pick an org plan\n  gr billing checkout --product <id>  # pay up front\n  gr billing status                   # confirm it is active"
             );
           }
           throw err;
@@ -33985,7 +35263,7 @@ var MESSAGE_COLUMNS4 = [
   COL.created()
 ];
 var TASK_COLUMNS = [COL.id(), COL.name(), COL.status()];
-var TOOL_COLUMNS = [
+var TOOL_COLUMNS2 = [
   COL.name(),
   { header: "DESCRIPTION", getValue: (item) => (item.description ?? "").slice(0, 60) }
 ];
@@ -34093,7 +35371,7 @@ var assignmentsDomain = {
           requireNumber(args, "assignment-id")
         );
         const tools = result2.tools ?? result2;
-        outputData(Array.isArray(tools) ? tools : [tools], ctx, TOOL_COLUMNS);
+        outputData(Array.isArray(tools) ? tools : [tools], ctx, TOOL_COLUMNS2);
       }
     }
   ]
@@ -34549,35 +35827,24 @@ Common optional
 Scope (set exactly one when objectType requires it)
   routineId, workflowId, taskId, dataTypeId, journeyStepId, calendarId, ...
 
-chat:create actionParams (outbound voice/SMS)
-  {"workflowId":<id>,"channel":"phone-voice"|"phone-sms","phoneNumberId":<id>,
-   "inboxId":<optional>,"assistantEnabled":<bool>}
+chat:create actionParams (outbound voice/SMS \u2014 starts a workflow chat)
+  {"workflowUUID":"<workflow-uuid>","channel":"phone-voice"|"phone-sms",
+   "phoneNumberUUID":"<uuid>","inboxUUID":"<optional-uuid>","assistantEnabled":<bool>}
+  Keys are UUID strings: workflowUUID (not workflowId), phoneNumberUUID (not
+  phoneNumberId), inboxUUID (not inboxId). Unknown keys are rejected.
+
+sms:send actionParams (send an SMS, or start an SMS workflow chat)
+  One-off text:  {"phoneNumberUUID":"<from-number-uuid>","messageTemplate":"Hi {{name}} \u2026"}
+  Workflow chat: {"phoneNumberUUID":"<from-number-uuid>","workflowUUID":"<workflow-uuid>",
+                  "initialUserMessage":"<optional seed>"}
+  phoneNumberUUID (the from-number) is required. The message body is messageTemplate
+  (supports {{record/member}} template vars) \u2014 there is no "body"/"message" key.
+  Provide messageTemplate for a one-off text, OR workflowUUID to start a chat.
 
 member:label actionParams
   {"addLabelIds":["<uuid>"],"removeLabelIds":["<uuid>"]}
 `;
 
-// src/lib/routines/field-help.ts
-var ROUTINE_FIELD_REFERENCE = `
-Field reference for --data JSON (create/update):
-
-Core
-  name (string)                         Display name
-  workflowId (number)                   Workflow run when the routine fires
-  targetMemberId (number)               Member who receives the scheduled outreach
-
-Schedule
-  scheduleEnabled (bool)                Master on/off for the cron trigger
-  scheduleMode (string)                 "CRON" (only mode today)
-  cronString (string)                   Standard cron, e.g. "0 7 * * *"
-  timezone (string, optional)           IANA name, e.g. "America/Los_Angeles"
-                                        Defaults to workspace timezone, else UTC
-
-Visibility / lifecycle
-  archived (bool)                       Archive flag on update
-  event rules                           Use gr events rules create \u2014 not inline here
-`;
-
 // src/domains/events.ts
 var RULE_COLUMNS = [
   COL.id(),
@@ -34585,15 +35852,6 @@ var RULE_COLUMNS = [
   { header: "EVENT", getValue: (item) => item.eventType ?? "" },
   { header: "ACTIVE", getValue: (item) => String(item.active ?? "") }
 ];
-var ROUTINE_COLUMNS = [
-  COL.id(),
-  COL.name(),
-  { header: "MODE", getValue: (item) => item.scheduleMode ?? "" },
-  { header: "CRON", getValue: (item) => item.cronString ?? "" },
-  { header: "TZ", getValue: (item) => item.timezone ?? "UTC" },
-  { header: "ENABLED", getValue: (item) => String(item.scheduleEnabled ?? "") },
-  { header: "NEXT RUN", getValue: (item) => item.nextRun ?? "" }
-];
 var eventRulesCrudNoList = crudCommands({
   prefix: ["events", "rules"],
   entityName: "event rule",
@@ -34617,8 +35875,8 @@ ${EVENT_RULE_FIELD_REFERENCE}`,
     `gr events rules create -w $WID --allow-write --data '{"name":"AM voice check-in",`,
     '  "objectType":"routine","eventType":"routine:triggered","actionType":"chat:create",',
     '  "routineId":<routine-id>,',
-    '  "actionParams":{"workflowId":<workflow-id>,"channel":"phone-voice",',
-    `  "phoneNumberId":<workspace-phone-id>}}'`,
+    '  "actionParams":{"workflowUUID":"<workflow-uuid>","channel":"phone-voice",',
+    `  "phoneNumberUUID":"<workspace-phone-uuid>"}}'`,
     "",
     '  PM SMS variant: use "channel":"phone-sms" and a second rule on the same routineId.',
     "  Prereq: org phone assigned + gr phone-numbers link; workflow published with start task.",
@@ -34756,74 +36014,6 @@ var eventsDomain = {
         const result2 = await requireAuth(ctx).apiClient.searchEventRules(workspace, opts);
         outputData(result2, ctx, RULE_COLUMNS);
       }
-    },
-    // Routines
-    ...crudCommands({
-      prefix: ["routines"],
-      entityName: "routine",
-      listMethod: "getRoutines",
-      getMethod: "getRoutine",
-      createMethod: "createRoutine",
-      updateMethod: "updateRoutine",
-      deleteMethod: "deleteRoutine",
-      paginationSupport: "full",
-      columns: ROUTINE_COLUMNS,
-      createHelp: `Create a routine
-
-${ROUTINE_FIELD_REFERENCE}`,
-      updateHelp: `Update a routine
-
-${ROUTINE_FIELD_REFERENCE}`,
-      createExamples: [
-        "Daily 7am check-in in the member\u2019s timezone (cron is interpreted in `timezone`):",
-        `gr routines create -w $WID --allow-write --data '{"name":"AM check-in",`,
-        '  "scheduleEnabled":true,"scheduleMode":"CRON","cronString":"0 7 * * *",',
-        `  "timezone":"America/Los_Angeles","targetMemberId":1,"workflowId":2}'`,
-        "  (timezone is an IANA name; omit it to default to the workspace timezone, else UTC.",
-        '   Without it, "0 7 * * *" fires at 07:00 UTC, not 7am local.)'
-      ]
-    }),
-    {
-      path: ["routines", "run"],
-      description: "Run a routine now",
-      mutates: true,
-      requiresWorkspace: true,
-      args: [{ name: "id", description: "Routine ID", required: true }],
-      handler: async ({ ctx, workspace, args, data }) => {
-        const result2 = await requireAuth(ctx).apiClient.runRoutine(
-          workspace,
-          requireNumber(args, "id"),
-          data ?? {}
-        );
-        outputSingle(result2, ctx);
-      }
-    },
-    {
-      path: ["routines", "runs", "list"],
-      description: "List runs for a routine",
-      requiresWorkspace: true,
-      args: [
-        {
-          name: "id",
-          description: "Routine ID (aligns with routines get/run/update/delete)"
-        },
-        { name: "status", description: "Filter by run status" },
-        { name: "page", description: "Page number (1-indexed)" },
-        { name: "page-size", description: "Page size (max 100)" }
-      ],
-      handler: async ({ ctx, workspace, args }) => {
-        const routineId = args.id ? requireNumber(args, "id") : void 0;
-        const page = args.page ? requireNumber(args, "page") : void 0;
-        const pageSize = args["page-size"] ? requireNumber(args, "page-size") : void 0;
-        const status = args.status ?? void 0;
-        const result2 = await requireAuth(ctx).apiClient.getRoutineRuns(workspace, {
-          ...routineId !== void 0 ? { routineId } : {},
-          ...page !== void 0 ? { page } : {},
-          ...pageSize !== void 0 ? { pageSize } : {},
-          ...status ? { status } : {}
-        });
-        outputData(result2, ctx);
-      }
     }
   ]
 };
@@ -35218,11 +36408,11 @@ var ACTION_COLUMNS = [
   { header: "ACTIVE", getValue: (item) => String(item.active ?? "") },
   { header: "CONDITIONS", getValue: (item) => (item.conditions ?? "").slice(0, 40) }
 ];
-function baseUrl(ctx, wid) {
+function baseUrl2(ctx, wid) {
   return `${ctx.envConfig.apiUrl}/api/v2/w/${wid}/journeys`;
 }
 function notesUrl(ctx, wid, journeyId) {
-  return `${baseUrl(ctx, wid)}/${journeyId}/notes`;
+  return `${baseUrl2(ctx, wid)}/${journeyId}/notes`;
 }
 function headers(ctx) {
   return {
@@ -35289,7 +36479,7 @@ var journeysDomain = {
       requiresWorkspace: true,
       examples: ["gr journeys list -w $WID --env staging"],
       handler: async ({ ctx, workspace }) => {
-        const result2 = await apiGet(requireAuth(ctx), baseUrl(requireAuth(ctx), workspace));
+        const result2 = await apiGet(requireAuth(ctx), baseUrl2(requireAuth(ctx), workspace));
         outputData(listResult(result2, false), ctx, JOURNEY_COLUMNS);
       }
     },
@@ -35302,7 +36492,7 @@ var journeysDomain = {
         const id = requireString(args, "id");
         const result2 = await apiGet(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${id}`
+          `${baseUrl2(requireAuth(ctx), workspace)}/${id}`
         );
         outputSingle(result2, ctx, JOURNEY_COLUMNS);
       }
@@ -35322,7 +36512,7 @@ var journeysDomain = {
         if (!data) throw new CLIError("JSON data required (--data, --file, or stdin)");
         const result2 = await apiPost(
           requireAuth(ctx),
-          baseUrl(requireAuth(ctx), workspace),
+          baseUrl2(requireAuth(ctx), workspace),
           data
         );
         outputSingle(result2, ctx, JOURNEY_COLUMNS);
@@ -35340,7 +36530,7 @@ var journeysDomain = {
         const id = requireString(args, "id");
         const result2 = await apiPut(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${id}`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${id}`,
           data
         );
         outputSingle(result2, ctx, JOURNEY_COLUMNS);
@@ -35354,7 +36544,7 @@ var journeysDomain = {
       args: [{ name: "id", description: "Journey ID", required: true }],
       handler: async ({ ctx, workspace, args }) => {
         const id = requireString(args, "id");
-        await apiDelete(requireAuth(ctx), `${baseUrl(requireAuth(ctx), workspace)}/${id}`);
+        await apiDelete(requireAuth(ctx), `${baseUrl2(requireAuth(ctx), workspace)}/${id}`);
         process.stdout.write(`Archived journey ${id}
 `);
       }
@@ -35370,7 +36560,7 @@ var journeysDomain = {
         const id = requireString(args, "id");
         const result2 = await apiGet(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${id}`
+          `${baseUrl2(requireAuth(ctx), workspace)}/${id}`
         );
         outputData(result2?.steps ?? [], ctx, STEP_COLUMNS);
       }
@@ -35395,7 +36585,7 @@ var journeysDomain = {
         const journeyId = requireString(args, "journey-id");
         const result2 = await apiPost(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/steps`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/steps`,
           data
         );
         outputSingle(result2, ctx, STEP_COLUMNS);
@@ -35416,7 +36606,7 @@ var journeysDomain = {
         const stepId = requireString(args, "id");
         const result2 = await apiPut(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/steps/${stepId}`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/steps/${stepId}`,
           data
         );
         outputSingle(result2, ctx, STEP_COLUMNS);
@@ -35436,7 +36626,7 @@ var journeysDomain = {
         const stepId = requireString(args, "id");
         await apiDelete(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/steps/${stepId}`
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/steps/${stepId}`
         );
         process.stdout.write(`Archived step ${stepId}
 `);
@@ -35453,7 +36643,7 @@ var journeysDomain = {
         const id = requireString(args, "id");
         const result2 = await apiGet(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${id}`
+          `${baseUrl2(requireAuth(ctx), workspace)}/${id}`
         );
         const seen = /* @__PURE__ */ new Set();
         const connections = [];
@@ -35497,7 +36687,7 @@ var journeysDomain = {
         const journeyId = requireString(args, "journey-id");
         const result2 = await apiPost(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/connections`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/connections`,
           data
         );
         outputSingle(result2, ctx, CONNECTION_COLUMNS);
@@ -35518,7 +36708,7 @@ var journeysDomain = {
         const connId = requireString(args, "id");
         const result2 = await apiPut(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/connections/${connId}`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/connections/${connId}`,
           data
         );
         outputSingle(result2, ctx, CONNECTION_COLUMNS);
@@ -35538,7 +36728,7 @@ var journeysDomain = {
         const connId = requireString(args, "id");
         await apiDelete(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/connections/${connId}`
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/connections/${connId}`
         );
         process.stdout.write(`Deleted connection ${connId}
 `);
@@ -35555,7 +36745,7 @@ var journeysDomain = {
         const id = requireString(args, "id");
         const result2 = await apiGet(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${id}`
+          `${baseUrl2(requireAuth(ctx), workspace)}/${id}`
         );
         outputData(result2?.goals ?? [], ctx, GOAL_COLUMNS);
       }
@@ -35578,7 +36768,7 @@ var journeysDomain = {
         const journeyId = requireString(args, "journey-id");
         const result2 = await apiPost(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/goals`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/goals`,
           data
         );
         outputSingle(result2, ctx, GOAL_COLUMNS);
@@ -35599,7 +36789,7 @@ var journeysDomain = {
         const goalId = requireString(args, "id");
         const result2 = await apiPut(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/goals/${goalId}`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/goals/${goalId}`,
           data
         );
         outputSingle(result2, ctx, GOAL_COLUMNS);
@@ -35619,7 +36809,7 @@ var journeysDomain = {
         const goalId = requireString(args, "id");
         await apiDelete(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/goals/${goalId}`
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/goals/${goalId}`
         );
         process.stdout.write(`Deleted goal ${goalId}
 `);
@@ -35643,7 +36833,7 @@ var journeysDomain = {
         const id = requireString(args, "id");
         const result2 = await apiPost(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${id}/enroll`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${id}/enroll`,
           data
         );
         outputData(listResult(result2, false), ctx, MEMBER_JOURNEY_COLUMNS);
@@ -35663,7 +36853,7 @@ var journeysDomain = {
         const id = requireString(args, "id");
         await apiPost(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${id}/unenroll`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${id}/unenroll`,
           data
         );
         process.stdout.write(`Unenrolled member(s) from journey ${id}
@@ -35681,7 +36871,7 @@ var journeysDomain = {
         const id = requireString(args, "id");
         const result2 = await apiPost(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${id}/reenroll`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${id}/reenroll`,
           data
         );
         outputSingle(result2, ctx, MEMBER_JOURNEY_COLUMNS);
@@ -35701,7 +36891,7 @@ var journeysDomain = {
         const memberId = requireString(args, "member-id");
         await apiDelete(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/members/${memberId}`
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/members/${memberId}`
         );
         process.stdout.write(
           `Deleted enrollment for member ${memberId} from journey ${journeyId}
@@ -35718,7 +36908,7 @@ var journeysDomain = {
         const journeyId = requireString(args, "journey-id");
         const result2 = await apiGet(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/members`
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/members`
         );
         outputData(listResult(result2, false), ctx, MEMBER_JOURNEY_COLUMNS);
       }
@@ -35732,7 +36922,7 @@ var journeysDomain = {
         const memberId = requireString(args, "member-id");
         const result2 = await apiGet(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/by-member/${memberId}`
+          `${baseUrl2(requireAuth(ctx), workspace)}/by-member/${memberId}`
         );
         outputData(listResult(result2, false), ctx, MEMBER_JOURNEY_COLUMNS);
       }
@@ -35759,7 +36949,7 @@ var journeysDomain = {
         const stepId = requireString(args, "id");
         const result2 = await apiPost(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/steps/${stepId}/advance`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/steps/${stepId}/advance`,
           data ?? {}
         );
         outputSingle(result2, ctx, MEMBER_STEP_COLUMNS);
@@ -35782,7 +36972,7 @@ var journeysDomain = {
         const stepId = requireString(args, "id");
         const result2 = await apiPost(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/steps/${stepId}/skip`,
+          `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/steps/${stepId}/skip`,
           data ?? {}
         );
         outputSingle(result2, ctx, MEMBER_STEP_COLUMNS);
@@ -35813,7 +37003,7 @@ var journeysDomain = {
           if (d.pageSize) qs.set("pageSize", String(d.pageSize));
         }
         const query = qs.toString();
-        const url = `${baseUrl(requireAuth(ctx), workspace)}/${journeyId}/steps/${stepId}/members${query ? `?${query}` : ""}`;
+        const url = `${baseUrl2(requireAuth(ctx), workspace)}/${journeyId}/steps/${stepId}/members${query ? `?${query}` : ""}`;
         const result2 = await apiGet(requireAuth(ctx), url);
         const STEP_MEMBER_COLS = [
           { header: "MEMBER_ID", getValue: (item) => String(item.memberId ?? "") },
@@ -35836,7 +37026,7 @@ var journeysDomain = {
         const id = requireString(args, "id");
         const result2 = await apiGet(
           requireAuth(ctx),
-          `${baseUrl(requireAuth(ctx), workspace)}/${id}/step-member-counts`
+          `${baseUrl2(requireAuth(ctx), workspace)}/${id}/step-member-counts`
         );
         const COUNT_COLS = [
           { header: "STEP_ID", getValue: (item) => String(item.stepId ?? "") },
@@ -36454,6 +37644,178 @@ var sitesDomain = {
     }
   ]
 };
+init_output();
+init_context();
+init_errors();
+var ATTACHED_COLUMNS = [
+  { header: "UUID", getValue: (item) => item.uuid ?? "" },
+  { header: "TYPE", getValue: (item) => item.abilityType ?? "" },
+  { header: "ENABLED", getValue: (item) => item.enabled === false ? "" : "yes" },
+  { header: "CEL", getValue: (item) => item.celCondition ?? "" }
+];
+function toAbilityData(a) {
+  return {
+    uuid: a.uuid,
+    abilityType: a.abilityType,
+    config: a.config ?? {},
+    enabled: a.enabled ?? true,
+    ...a.celCondition ? { celCondition: a.celCondition } : {}
+  };
+}
+var TYPE_COLUMNS = [
+  { header: "SLUG", getValue: (item) => item.slug ?? "" },
+  { header: "TITLE", getValue: (item) => item.title ?? "" },
+  { header: "CATEGORY", getValue: (item) => item.category ?? "" },
+  {
+    header: "CHANNELS",
+    // null channels means "all channels" — show that explicitly so an empty
+    // cell never reads as "no channels".
+    getValue: (item) => Array.isArray(item.channels) ? item.channels.join(",") : "all"
+  },
+  { header: "SINGLETON", getValue: (item) => item.singleton ? "yes" : "" },
+  { header: "FEATURE-GATE", getValue: (item) => item.requiredFeature ?? "" }
+];
+var abilitiesDomain = {
+  name: "abilities",
+  description: "Inspect ability types and attach/detach them on a task",
+  commands: [
+    {
+      path: ["abilities", "list"],
+      description: "List builtin ability types with their channel constraints and param specs. Table shows SLUG, TITLE, CATEGORY, CHANNELS (all = every channel), SINGLETON, FEATURE-GATE; use -o json for full specs including the params JSON Schema.",
+      requiresWorkspace: true,
+      columns: TYPE_COLUMNS,
+      args: [
+        {
+          name: "include-system",
+          description: "Also list auto-injected system abilities (hidden by default)",
+          isFlag: true
+        }
+      ],
+      handler: async (hctx) => {
+        const includeSystem = hctx.args["include-system"] === true;
+        const result2 = await requireAuth(hctx.ctx).apiClient.getAbilityTypes(
+          hctx.workspace,
+          includeSystem ? { includeSystem: true } : {}
+        );
+        outputData(result2.types ?? [], hctx.ctx, TYPE_COLUMNS);
+      }
+    },
+    {
+      path: ["abilities", "get"],
+      description: "Show the full spec for one ability type: title, description, category, channels, singleton/system flags, required feature, and the JSON Schema of its params model.",
+      requiresWorkspace: true,
+      args: [
+        {
+          name: "name",
+          aliases: ["slug"],
+          description: "Ability type slug (e.g. 'communication:phone_call_tools')",
+          required: true
+        }
+      ],
+      handler: async (hctx) => {
+        const slug = hctx.args.name ?? hctx.args.slug;
+        if (!slug) throw new CLIError("--name is required");
+        const result2 = await requireAuth(hctx.ctx).apiClient.getAbilityType(
+          hctx.workspace,
+          slug
+        );
+        outputSingle(result2, hctx.ctx);
+      }
+    },
+    {
+      path: ["abilities", "attached"],
+      description: "List a task's task-specific abilities (excludes workflow-inherited).",
+      requiresWorkspace: true,
+      columns: ATTACHED_COLUMNS,
+      args: [{ name: "task", description: "Task ID", required: true }],
+      handler: async (hctx) => {
+        const task = await requireAuth(hctx.ctx).apiClient.getTask(
+          hctx.workspace,
+          requireNumber(hctx.args, "task")
+        );
+        outputData(task.abilities ?? [], hctx.ctx, ATTACHED_COLUMNS);
+      }
+    },
+    {
+      path: ["abilities", "attach"],
+      description: "Attach an ability to a task. Reads the task, appends the new ability (generating its uuid), and saves \u2014 so existing abilities aren't lost. Find slugs via 'gr abilities list' and the config schema via 'gr abilities get'.",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "task", description: "Task ID to attach to", required: true },
+        {
+          name: "type",
+          aliases: ["ability-type", "slug"],
+          description: "Ability type slug, e.g. 'integration:data_access'",
+          required: true
+        },
+        {
+          name: "config",
+          description: `Ability config as a JSON object, e.g. '{"pauseOnEscalate":true}'`
+        },
+        { name: "cel", description: "Optional CEL activation condition" },
+        {
+          name: "disabled",
+          description: "Attach in a disabled state (default: enabled)",
+          isFlag: true
+        }
+      ],
+      handler: async (hctx) => {
+        const api = requireAuth(hctx.ctx).apiClient;
+        const taskId = requireNumber(hctx.args, "task");
+        const abilityType = hctx.args.type ?? hctx.args["ability-type"] ?? hctx.args.slug;
+        if (!abilityType) throw new CLIError("--type is required (an ability type slug)");
+        let config = {};
+        if (hctx.args.config) {
+          try {
+            config = JSON.parse(hctx.args.config);
+          } catch {
+            throw new CLIError("--config must be a valid JSON object");
+          }
+        }
+        const task = await api.getTask(hctx.workspace, taskId);
+        const existing = (task.abilities ?? []).map(toAbilityData);
+        const next = {
+          uuid: randomUUID(),
+          abilityType,
+          config,
+          enabled: hctx.args.disabled !== true,
+          ...hctx.args.cel ? { celCondition: hctx.args.cel } : {}
+        };
+        const updated = await api.updateTask(hctx.workspace, taskId, {
+          abilities: [...existing, next]
+        });
+        outputData(updated.abilities ?? [], hctx.ctx, ATTACHED_COLUMNS);
+      }
+    },
+    {
+      path: ["abilities", "detach"],
+      description: "Detach an ability from a task by its uuid (from `gr abilities attached`). Re-saves the remaining task-specific abilities so the rest are preserved.",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "task", description: "Task ID", required: true },
+        { name: "uuid", description: "UUID of the attached ability to remove", required: true }
+      ],
+      handler: async (hctx) => {
+        const api = requireAuth(hctx.ctx).apiClient;
+        const taskId = requireNumber(hctx.args, "task");
+        const uuid = hctx.args.uuid;
+        if (!uuid) throw new CLIError("--uuid is required");
+        const task = await api.getTask(hctx.workspace, taskId);
+        const existing = task.abilities ?? [];
+        const remaining = existing.filter((a) => a.uuid !== uuid).map(toAbilityData);
+        if (remaining.length === existing.length) {
+          throw new CLIError(`No attached ability with uuid '${uuid}' on task ${taskId}`);
+        }
+        const updated = await api.updateTask(hctx.workspace, taskId, {
+          abilities: remaining
+        });
+        outputData(updated.abilities ?? [], hctx.ctx, ATTACHED_COLUMNS);
+      }
+    }
+  ]
+};
 
 // src/domains/access-grants.ts
 init_output();
@@ -36530,6 +37892,7 @@ var accessGrantsDomain = {
     {
       path: ["access-grants", "resolve"],
       description: "Resolve an access grant",
+      mutates: true,
       requiresWorkspace: true,
       args: [{ name: "id", description: "Access grant ID", required: true }],
       handler: async ({ ctx, workspace, args, data }) => {
@@ -36986,6 +38349,151 @@ var authManageDomain = {
   ]
 };
 
+// src/domains/billing.ts
+init_context();
+init_output();
+function priceSummary(product) {
+  const plans = product.plans ?? {};
+  const abbr = { month: "mo", year: "yr", quarter: "qtr" };
+  const parts = [];
+  for (const [period, plan] of Object.entries(plans)) {
+    const cents = plan?.costPerPeriod ?? 0;
+    if (!plan?.stripePriceId) continue;
+    parts.push(`$${(cents / 100).toFixed(0)}/${abbr[period] ?? period}`);
+  }
+  return parts.join(", ") || "\u2014";
+}
+var PRODUCT_COLUMNS2 = [
+  { header: "ID", getValue: (p) => String(p.id ?? "") },
+  { header: "NAME", getValue: (p) => p.name ?? "" },
+  { header: "TYPE", getValue: (p) => String(p.productType ?? "") },
+  { header: "PRICE", getValue: (p) => priceSummary(p) },
+  {
+    header: "TRIAL",
+    getValue: (p) => {
+      const days = p.trialPeriodDays ?? 0;
+      return days > 0 ? `${days}d` : "\u2014";
+    }
+  }
+];
+var SUBSCRIPTION_COLUMNS = [
+  COL.id(),
+  COL.status(),
+  { header: "PLAN", getValue: (s) => String(s.plan_name ?? s.productName ?? s.plan ?? "") },
+  { header: "PERIOD", getValue: (s) => String(s.planPeriod ?? s.plan_period ?? "") },
+  {
+    header: "ORG",
+    getValue: (s) => String(s.organizationUuid ?? s.customerOrganizationUuid ?? "")
+  }
+];
+function isTable(ctx) {
+  return (ctx.outputFormat ?? "table") === "table";
+}
+function hint(ctx, lines) {
+  if (!isTable(ctx)) return;
+  process.stdout.write("\n" + lines.join("\n") + "\n");
+}
+function productType(args) {
+  const t = args.type ?? args["product-type"];
+  if (t === "org" || t === "workspace") return t;
+  return void 0;
+}
+var billingDomain = {
+  name: "billing",
+  description: "Browse plans, start checkout, and check subscription status",
+  commands: [
+    {
+      path: ["billing", "products"],
+      description: "List self-service plans you can purchase",
+      requiresWorkspace: false,
+      args: [
+        {
+          name: "type",
+          description: "Filter by plan type: 'org' or 'workspace'"
+        }
+      ],
+      examples: ["gr billing products --type org"],
+      handler: async ({ ctx, args }) => {
+        const products = await requireAuth(ctx).apiClient.listSelfServeProducts(
+          productType(args)
+        );
+        outputData(products, ctx, PRODUCT_COLUMNS2);
+        if (products.length === 0) {
+          hint(ctx, ["No purchasable plans found. (Free plans are not sold via the CLI.)"]);
+        } else {
+          hint(ctx, [
+            "Next \u2014 buy an organization plan to get started:",
+            "  gr billing checkout --product <id> [--period month|year]"
+          ]);
+        }
+      }
+    },
+    {
+      path: ["billing", "checkout"],
+      description: "Get a Stripe payment link to purchase an organization plan",
+      mutates: true,
+      requiresWorkspace: false,
+      args: [
+        { name: "product", description: "Product ID of the org plan to buy", required: true },
+        { name: "period", description: "Billing period: 'month' or 'year'", default: "month" }
+      ],
+      examples: ["gr billing checkout --product 12 --period month"],
+      handler: async ({ ctx, args }) => {
+        const productId = Number(requireString(args, "product"));
+        const period = args.period || "month";
+        const result2 = await requireAuth(ctx).apiClient.createCheckoutSession(
+          productId,
+          period
+        );
+        if (isTable(ctx)) {
+          process.stdout.write(
+            `
+\u{1F4B3}  Open this link in a browser to complete payment:
+
+    ${result2.checkoutUrl}
+
+Once payment succeeds, your organization and subscription are created automatically.
+Then check it landed:
+  gr billing status
+`
+          );
+        } else {
+          outputSingle(result2, ctx);
+        }
+      }
+    },
+    {
+      path: ["billing", "status"],
+      description: "Show your subscriptions and what to do next",
+      requiresWorkspace: false,
+      examples: ["gr billing status"],
+      handler: async ({ ctx }) => {
+        const subs = await requireAuth(ctx).apiClient.getSubscriptions();
+        outputData(subs, ctx, SUBSCRIPTION_COLUMNS);
+        const active = subs.find(
+          (s) => ["active", "trialing"].includes(String(s.status ?? s.subscriptionStatus ?? ""))
+        );
+        if (!active) {
+          hint(ctx, [
+            "No active subscription yet. To get started:",
+            "  gr billing products --type org        # pick a plan",
+            "  gr billing checkout --product <id>    # pay up front"
+          ]);
+          return;
+        }
+        const orgUuid = String(
+          active.organizationUuid ?? active.customerOrganizationUuid ?? "<org-uuid>"
+        );
+        hint(ctx, [
+          "You have an active subscription. Add a workspace:",
+          "  gr billing products --type workspace                       # pick a workspace plan",
+          `  gr workspaces create --org ${orgUuid} --product <id> --name "My Workspace"`
+        ]);
+      }
+    }
+  ]
+};
+
 // src/domains/billing-portal.ts
 init_errors();
 init_output();
@@ -37139,7 +38647,7 @@ init_errors();
 init_output();
 init_context();
 var COLUMNS17 = [COL.id(), COL.name(), COL.description(), COL.enabled()];
-var TOOL_COLUMNS2 = [COL.id(), COL.name(), COL.description()];
+var TOOL_COLUMNS3 = [COL.id(), COL.name(), COL.description()];
 var customToolkitsDomain = {
   name: "custom-toolkits",
   description: "Manage custom toolkits and their tools",
@@ -37197,7 +38705,7 @@ var customToolkitsDomain = {
           toolkitId,
           data
         );
-        outputSingle(result2, ctx, TOOL_COLUMNS2);
+        outputSingle(result2, ctx, TOOL_COLUMNS3);
       }
     },
     {
@@ -37219,7 +38727,7 @@ var customToolkitsDomain = {
           toolId,
           data
         );
-        outputSingle(result2, ctx, TOOL_COLUMNS2);
+        outputSingle(result2, ctx, TOOL_COLUMNS3);
       }
     },
     {
@@ -38459,6 +39967,50 @@ function parseCallerRole(value) {
   }
   return VALID_CALLER_ROLES.has(value) ? value : void 0;
 }
+var PERMISSION_USE2 = 1;
+function evaluateWorkflowMemberRoleAccess(memberRoleId, memberRoleAccess) {
+  if (memberRoleAccess === void 0) {
+    return { outcome: "skip", detail: "workflow memberRoleAccess not available" };
+  }
+  if (memberRoleAccess.length === 0) {
+    return { outcome: "allow", detail: "no workflow role restrictions configured" };
+  }
+  if (memberRoleId === void 0) {
+    return {
+      outcome: "skip",
+      detail: "caller member role unknown \u2014 cannot evaluate role gate"
+    };
+  }
+  const hasUse = memberRoleAccess.some(
+    (entry) => entry.memberRoleId === memberRoleId && (entry.accessMode & PERMISSION_USE2) === PERMISSION_USE2
+  );
+  if (hasUse) {
+    return { outcome: "allow", detail: `memberRoleId=${memberRoleId} has USE on workflow` };
+  }
+  return {
+    outcome: "deny",
+    detail: `memberRoleId=${memberRoleId} lacks USE in workflow memberRoleAccess`
+  };
+}
+function parseWorkflowMemberRoleAccess(workflow) {
+  const raw = workflow.memberRoleAccess;
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  const entries = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const row = item;
+    const memberRoleId = typeof row.memberRoleId === "number" ? row.memberRoleId : Number(row.memberRoleId);
+    const accessMode = typeof row.accessMode === "number" ? row.accessMode : Number(row.accessMode);
+    if (Number.isFinite(memberRoleId) && Number.isFinite(accessMode)) {
+      entries.push({ memberRoleId, accessMode });
+    }
+  }
+  return entries;
+}
 function inferCallerRole(phone, opts) {
   if (opts.asRole) {
     return opts.asRole;
@@ -38585,6 +40137,32 @@ function simulateInboundRouting(phone, opts = {}) {
     return finish("no_inbound_workflow", false, true, steps, recommendations, callerRole);
   }
   steps.push({ step: "inbound_workflow", outcome: "ok", detail: `workflowId=${workflowId}` });
+  const callerMemberRoleId = callerRole === "member" ? opts.matchedMemberRoleId : callerRole === "anonymous" ? phone.anonymousMemberRoleId ?? void 0 : void 0;
+  const roleAccess = evaluateWorkflowMemberRoleAccess(
+    callerMemberRoleId,
+    opts.workflowMemberRoleAccess
+  );
+  if (roleAccess.outcome === "deny") {
+    steps.push({
+      step: "workflow_member_role_access",
+      outcome: "reject",
+      detail: roleAccess.detail
+    });
+    recommendations.push(
+      "Grant the caller's member role USE access on the inbound workflow (workflow memberRoleAccess or `gr member-roles update` workflowAccess)"
+    );
+    return finish("workflow_member_role_denied", false, true, steps, recommendations, callerRole);
+  }
+  steps.push({
+    step: "workflow_member_role_access",
+    outcome: roleAccess.outcome === "skip" ? "skipped" : "ok",
+    detail: roleAccess.detail
+  });
+  if (roleAccess.outcome === "skip" && callerMemberRoleId === void 0 && opts.workflowMemberRoleAccess !== void 0 && opts.workflowMemberRoleAccess.length > 0) {
+    recommendations.push(
+      "Workflow has member role restrictions but caller memberRoleId was not resolved \u2014 re-run with --as +E.164 (caller phone) so the role gate can be evaluated against real data"
+    );
+  }
   steps.push({ step: "chat_create", outcome: "create_phone_voice_chat" });
   steps.push({ step: "assistant", outcome: "connect_media_stream" });
   return finish("ai_voice_chat", true, true, steps, recommendations, callerRole);
@@ -38601,6 +40179,7 @@ function finish(code, createsChat, createsPhoneCall, steps, recommendations, cal
     voicemail_record: "Record voicemail",
     play_message_hangup: "Play off-hours message, hang up",
     no_inbound_workflow: "Play unavailable message (no inbound workflow)",
+    workflow_member_role_denied: "Reject \u2014 caller member role lacks workflow USE (memberRoleAccess)",
     ai_voice_chat: "Create chat + connect AI voice"
   };
   return {
@@ -38652,9 +40231,22 @@ function formatPhoneNumberBehaviorMatrix(phone, outboundUsers, warnings = collec
   lines.push(`UUID: ${phone.uuid}  |  Mapped: ${phone.isMapped ? "yes" : "no"}`);
   lines.push("");
   lines.push("## Channels");
-  lines.push(`  Voice: ${phone.enableVoice ? "on" : "off"}  SMS: ${phone.enableSms ? "on" : "off"}  WhatsApp: ${phone.enableWhatsApp ? "on" : "off"}`);
+  lines.push(
+    `  Voice: ${phone.enableVoice ? "on" : "off"}  SMS: ${phone.enableSms ? "on" : "off"}  WhatsApp: ${phone.enableWhatsApp ? "on" : "off"}`
+  );
   lines.push(`  Assistant: ${phone.assistantEnabled ? "on" : "off"}`);
   lines.push("");
+  if (phone.enableVoice) {
+    lines.push("## Channel defaults (auto-injected on voice)");
+    lines.push(
+      "  Voice channels auto-add the hang_up_call tool (system:voice_channel);"
+    );
+    lines.push(
+      "  it is not listed by `gr agents abilities list`. See `gr abilities get"
+    );
+    lines.push("  --name communication:phone_call_tools` for the voice ability spec.");
+    lines.push("");
+  }
   lines.push("## Inbound route");
   lines.push(
     `  defaultWorkflowId (inbound): ${phone.defaultWorkflowId ?? "null"}  restartDelay: ${phone.restartDelay ?? "null"}s`
@@ -38735,9 +40327,7 @@ async function findOutboundPhoneUsers(client, workspace, phone) {
     }
     page += 1;
     if (page > 50) {
-      process.stderr.write(
-        "Warning: event-rules lookup truncated at 5000 results (50 pages)\n"
-      );
+      process.stderr.write("Warning: event-rules lookup truncated at 5000 results (50 pages)\n");
       break;
     }
   }
@@ -38756,7 +40346,9 @@ function normalizeCallerE164(phone) {
 var MEMBER_SEARCH_PAGE_SIZE = 100;
 async function resolveMemberByCallerPhone(client, workspace, callerE164) {
   const normalized = normalizeCallerE164(callerE164);
-  const candidates = [normalized, callerE164.trim()].filter(
+  const digits = callerE164.replace(/\D/g, "");
+  const nsn = digits.length === 11 && digits.startsWith("1") ? digits.slice(1) : digits;
+  const candidates = [normalized, callerE164.trim(), digits, nsn].filter(
     (v, i, arr) => Boolean(v) && arr.indexOf(v) === i
   );
   const matchInRows = (rows) => {
@@ -38801,6 +40393,25 @@ async function resolveMemberByCallerPhone(client, workspace, callerE164) {
   return void 0;
 }
 
+// src/lib/phone-numbers/workflow-role-access.ts
+async function loadInboundWorkflowMemberRoleAccess(client, workspace, defaultWorkflowId) {
+  const workflowId = typeof defaultWorkflowId === "number" ? defaultWorkflowId : defaultWorkflowId === null || defaultWorkflowId === void 0 ? void 0 : Number(defaultWorkflowId);
+  if (workflowId === void 0 || !Number.isFinite(workflowId)) {
+    return void 0;
+  }
+  try {
+    const workflow = await client.getWorkflow(workspace, workflowId);
+    return parseWorkflowMemberRoleAccess(workflow);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    process.stderr.write(
+      `[diagnose] Could not fetch workflow ${workflowId} memberRoleAccess \u2014 role gate will be skipped (${reason})
+`
+    );
+    return void 0;
+  }
+}
+
 // src/domains/phone-numbers.ts
 function asPhoneRecord(value) {
   return value;
@@ -38859,9 +40470,8 @@ var phoneNumbersDomain = {
         const client = requireAuth(ctx).apiClient;
         const id = requireNumber(args, "id");
         const phone = asPhoneRecord(await client.getPhoneNumber(workspace, id));
-        if (args.raw) {
-          process.stdout.write(`${JSON.stringify(phone, null, 2)}
-`);
+        if (args.raw || ctx.outputFormat !== "table") {
+          outputSingle(phone, ctx);
           return;
         }
         const outboundUsers = await findOutboundPhoneUsers(client, workspace, phone);
@@ -39035,21 +40645,34 @@ Setup complete: id=${phone.id} uuid=${phone.uuid}
         const asRole = parseCallerRole(args["as-role"]);
         let hasMemberMatch = asRole === "member";
         let matchedMemberId;
+        let matchedMemberRoleId;
         let matchedMemberPhoneType;
         if (!asRole && typeof args.as === "string") {
           const match = await resolveMemberByCallerPhone(client, workspace, args.as);
           if (match) {
             hasMemberMatch = true;
             matchedMemberId = match.memberId;
+            matchedMemberRoleId = match.memberRoleId;
             matchedMemberPhoneType = match.phoneType;
           }
         }
+        const workflowMemberRoleAccess = await loadInboundWorkflowMemberRoleAccess(
+          client,
+          workspace,
+          phone.defaultWorkflowId
+        );
         const sim = simulateInboundRouting(phone, {
           asRole,
           hasMemberMatch,
           matchedMemberId,
-          matchedMemberPhoneType
+          matchedMemberRoleId,
+          matchedMemberPhoneType,
+          workflowMemberRoleAccess
         });
+        if (ctx.outputFormat !== "table") {
+          outputSingle({ phoneNumberId: id, simulation: sim }, ctx);
+          return;
+        }
         process.stdout.write(`${formatRoutingSimulation(sim, phone)}
 `);
       }
@@ -39071,10 +40694,28 @@ Setup complete: id=${phone.id} uuid=${phone.uuid}
         const id = requireNumber(args, "id");
         const role = requireCallerRole(args, "as-role");
         const phone = asPhoneRecord(await client.getPhoneNumber(workspace, id));
+        const workflowMemberRoleAccess = await loadInboundWorkflowMemberRoleAccess(
+          client,
+          workspace,
+          phone.defaultWorkflowId
+        );
         const sim = simulateInboundRouting(phone, {
           asRole: role,
-          hasMemberMatch: role === "member"
+          hasMemberMatch: role === "member",
+          workflowMemberRoleAccess
         });
+        if (ctx.outputFormat !== "table") {
+          outputSingle(
+            {
+              phoneNumberId: id,
+              callerRole: role,
+              finalBehavior: sim.finalBehavior,
+              simulation: sim
+            },
+            ctx
+          );
+          return;
+        }
         process.stdout.write(
           `If a caller in role "${role}" dials this line right now:
   \u2192 ${sim.finalBehavior}
@@ -39100,17 +40741,26 @@ ${formatRoutingSimulation(sim, phone)}
         const asRole = parseCallerRole(args["as-role"]);
         let hasMemberMatch = asRole === "member";
         let matchedMemberId;
+        let matchedMemberRoleId;
         if (!asRole && typeof args.as === "string") {
           const match = await resolveMemberByCallerPhone(client, workspace, args.as);
           if (match) {
             hasMemberMatch = true;
             matchedMemberId = match.memberId;
+            matchedMemberRoleId = match.memberRoleId;
           }
         }
+        const workflowMemberRoleAccess = await loadInboundWorkflowMemberRoleAccess(
+          client,
+          workspace,
+          phone.defaultWorkflowId
+        );
         const sim = simulateInboundRouting(phone, {
           asRole,
           hasMemberMatch,
-          matchedMemberId
+          matchedMemberId,
+          matchedMemberRoleId,
+          workflowMemberRoleAccess
         });
         process.stdout.write(
           `${JSON.stringify({ phoneNumberId: id, simulation: sim }, null, 2)}
@@ -39154,11 +40804,15 @@ ${formatRoutingSimulation(sim, phone)}
           { inbound: true }
         );
         const inbound = result2.items ?? [];
-        process.stdout.write(`Inbound calls (most recent page): ${inbound.length} shown
+        if (ctx.outputFormat === "table") {
+          process.stdout.write(`Inbound calls (most recent page): ${inbound.length} shown
 `);
-        process.stdout.write(
-          "Tip: gr phone-numbers diagnose --id <id> --as +1\u2026 simulates routing without a live call.\n"
-        );
+          process.stdout.write(
+            "Tip: gr phone-numbers diagnose --id <id> --as +1\u2026 simulates routing without a live call.\n"
+          );
+        } else {
+          stderr2(`Inbound calls (most recent page): ${inbound.length} shown`);
+        }
         outputData(inbound, ctx);
       }
     },
@@ -39539,6 +41193,119 @@ var reportsDomain = {
   ]
 };
 
+// src/domains/routines.ts
+init_output();
+init_context();
+
+// src/lib/routines/field-help.ts
+var ROUTINE_FIELD_REFERENCE = `
+Field reference for --data JSON (create/update):
+
+Core
+  name (string)                         Display name
+  workflowId (number)                   Workflow run when the routine fires
+  targetMemberId (number)               Member who receives the scheduled outreach
+
+Schedule
+  scheduleEnabled (bool)                Master on/off for the cron trigger
+  scheduleMode (string)                 "CRON" (only mode today)
+  cronString (string)                   Standard cron, e.g. "0 7 * * *"
+  timezone (string, optional)           IANA name, e.g. "America/Los_Angeles"
+                                        Defaults to workspace timezone, else UTC
+
+Visibility / lifecycle
+  archived (bool)                       Archive flag on update
+  event rules                           Use gr events rules create \u2014 not inline here
+`;
+
+// src/domains/routines.ts
+var ROUTINE_COLUMNS = [
+  COL.id(),
+  COL.name(),
+  { header: "MODE", getValue: (item) => item.scheduleMode ?? "" },
+  { header: "CRON", getValue: (item) => item.cronString ?? "" },
+  { header: "TZ", getValue: (item) => item.timezone ?? "UTC" },
+  { header: "ENABLED", getValue: (item) => String(item.scheduleEnabled ?? "") },
+  { header: "NEXT RUN", getValue: (item) => item.nextRun ?? "" }
+];
+var routinesDomain = {
+  name: "routines",
+  description: "Schedule recurring outbound (e.g. a daily SMS/voice check-in via cron)",
+  commands: [
+    ...crudCommands({
+      prefix: ["routines"],
+      entityName: "routine",
+      listMethod: "getRoutines",
+      getMethod: "getRoutine",
+      createMethod: "createRoutine",
+      updateMethod: "updateRoutine",
+      deleteMethod: "deleteRoutine",
+      paginationSupport: "full",
+      columns: ROUTINE_COLUMNS,
+      createHelp: `Create a routine
+
+${ROUTINE_FIELD_REFERENCE}`,
+      updateHelp: `Update a routine
+
+${ROUTINE_FIELD_REFERENCE}`,
+      createExamples: [
+        "Daily 7am check-in in the member\u2019s timezone (cron is interpreted in `timezone`):",
+        `gr routines create -w $WID --allow-write --data '{"name":"AM check-in",`,
+        '  "scheduleEnabled":true,"scheduleMode":"CRON","cronString":"0 7 * * *",',
+        `  "timezone":"America/Los_Angeles","targetMemberId":1,"workflowId":2}'`,
+        "  (timezone is an IANA name; omit it to default to the workspace timezone, else UTC.",
+        '   Without it, "0 7 * * *" fires at 07:00 UTC, not 7am local.)',
+        "",
+        "To actually send via SMS/voice, pair the routine with an event rule:",
+        '  gr events rules create \u2014 objectType "routine", eventType "routine:triggered",',
+        '  actionType "chat:create". See `gr events --help`.'
+      ]
+    }),
+    {
+      path: ["routines", "run"],
+      description: "Run a routine now",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [{ name: "id", description: "Routine ID", required: true }],
+      handler: async ({ ctx, workspace, args, data }) => {
+        const result2 = await requireAuth(ctx).apiClient.runRoutine(
+          workspace,
+          requireNumber(args, "id"),
+          data ?? {}
+        );
+        outputSingle(result2, ctx);
+      }
+    },
+    {
+      path: ["routines", "runs", "list"],
+      description: "List runs for a routine",
+      requiresWorkspace: true,
+      args: [
+        {
+          name: "id",
+          description: "Routine ID (aligns with routines get/run/update/delete)"
+        },
+        { name: "status", description: "Filter by run status" },
+        { name: "page", description: "Page number (1-indexed)" },
+        { name: "page-size", description: "Page size (max 100)" }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        const routineId = args.id ? requireNumber(args, "id") : void 0;
+        const page = args.page ? requireNumber(args, "page") : void 0;
+        const pageSize = args["page-size"] ? requireNumber(args, "page-size") : void 0;
+        const status = args.status ?? void 0;
+        const result2 = await requireAuth(ctx).apiClient.getRoutineRuns(workspace, {
+          ...routineId !== void 0 ? { routineId } : {},
+          ...page !== void 0 ? { page } : {},
+          ...pageSize !== void 0 ? { pageSize } : {},
+          ...status ? { status } : {}
+        });
+        outputData(result2, ctx);
+      }
+    }
+  ]
+};
+
 // src/domains/subscriptions.ts
 init_output();
 init_context();
@@ -41438,11 +43205,13 @@ function registerPublicDomains(registry) {
   registry.register(sitesDomain);
   registry.register(filesDomain);
   registry.register(eventsDomain);
+  registry.register(routinesDomain);
   registry.register(experimentsDomain);
   registry.register(calendarsDomain);
   registry.register(qualificationsDomain);
   registry.register(personasDomain);
   registry.register(journeysDomain);
+  registry.register(abilitiesDomain);
   registry.register(phoneNumbersDomain);
   registry.register(inboxesDomain);
   registry.register(operatorGroupsDomain);
@@ -41455,6 +43224,7 @@ function registerPublicDomains(registry) {
   registry.register(mcpServersDomain);
   registry.register(apiKeysDomain);
   registry.register(subscriptionsDomain);
+  registry.register(billingDomain);
   registry.register(supportDomain);
   registry.register(reportsDomain);
   registry.register(aiModelsDomain);
@@ -41480,9 +43250,6 @@ function registerPublicDomains(registry) {
   registry.register(billingPortalDomain);
 }
 
-// src/lib.ts
-init_concierge_api();
-
 // src/commands/auth-browser.ts
 init_output();
 async function authBrowserCommand(ctx, args) {
@@ -41527,11 +43294,10 @@ function openUrl(url) {
   });
 }
 
-// src/commands/concierge.ts
+// src/commands/manage.ts
 init_cli_utils();
-init_concierge_api();
-init_context();
 init_errors();
+init_context();
 function buildCliConciergeAppContext() {
   const shell = process.env.SHELL ? path3.basename(process.env.SHELL) : void 0;
   return {
@@ -41841,24 +43607,42 @@ async function runConciergeAguiLoop(client, initialMessages, onEvent, opts) {
     if (!hitlPayload) {
       break;
     }
-    const next = await handleCliHitlInterrupt(hitlPayload, {
-      allowWrite: opts.allowWrite,
-      autoApprove: opts.autoApprove,
-      trustCwd: opts.trustCwd,
-      trustDir: opts.trustDir,
-      nonInteractive: opts.nonInteractive
-    });
+    opts.onHitlPromptStart?.();
+    let next;
+    try {
+      next = await handleCliHitlInterrupt(hitlPayload, {
+        allowWrite: opts.allowWrite,
+        autoApprove: opts.autoApprove,
+        trustCwd: opts.trustCwd,
+        trustDir: opts.trustDir,
+        nonInteractive: opts.nonInteractive
+      });
+    } finally {
+      opts.onHitlPromptEnd?.();
+    }
     if (!next) {
       process.stderr.write(
         "  [HITL] Unsupported interrupt in CLI \u2014 open app.gravityrail.com/setup to continue.\n"
       );
-      break;
+      return {
+        streamText,
+        hasToolCalls,
+        unsupportedHitl: normalizeUnsupportedHitl(hitlPayload)
+      };
     }
     resume = next;
     streamText = "";
   }
   return { streamText, hasToolCalls };
 }
+function normalizeUnsupportedHitl(raw) {
+  const payload = raw && typeof raw === "object" ? raw : {};
+  return {
+    type: typeof payload.type === "string" ? payload.type : void 0,
+    interruptId: typeof payload.interrupt_id === "string" ? payload.interrupt_id : void 0,
+    payload
+  };
+}
 
 // src/lib/chat-session.ts
 init_errors();
@@ -42116,6 +43900,19 @@ function isToolCall(item) {
 function isToolResult(item) {
   return "kind" in item && item.kind === "tool_result";
 }
+function toolResultLooksFailed(content) {
+  const trimmed = content.trim();
+  if (!trimmed) return false;
+  if (/^error[:\s]/i.test(trimmed)) return true;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed.ok === false) return true;
+    if (typeof parsed.error === "string" && parsed.error.length > 0) return true;
+    if (typeof parsed.status === "string" && parsed.status.toLowerCase() === "error") return true;
+  } catch {
+  }
+  return false;
+}
 function getTruncationLabel(reason, truncatedAtMs) {
   const timeStr = truncatedAtMs ? ` at ${(truncatedAtMs / 1e3).toFixed(1)}s` : "";
   switch (reason) {
@@ -42149,6 +43946,8 @@ var CLEAR_EOL = `${CSI}K`;
 var RESET = `${CSI}0m`;
 var MOUSE_ON = `${CSI}?1000h${CSI}?1006h`;
 var MOUSE_OFF = `${CSI}?1000l${CSI}?1006l`;
+var BRACKETED_PASTE_ON = `${CSI}?2004h`;
+var BRACKETED_PASTE_OFF = `${CSI}?2004l`;
 var BLUE = `${CSI}34m`;
 var GREEN = `${CSI}32m`;
 var GRAY = `${CSI}90m`;
@@ -42157,6 +43956,11 @@ var ORANGE = `${CSI}38;5;208m`;
 var LIGHT_BLUE = `${CSI}38;5;117m`;
 var DIM = `${CSI}2m`;
 var DIM_ITALIC_GRAY = `${CSI}2;3;90m`;
+var RED = `${CSI}31m`;
+var CYAN = `${CSI}36m`;
+var MAX_INPUT_ROWS = 6;
+var INPUT_LABEL = "You: ";
+var INPUT_LABEL_WIDTH = 5;
 function moveTo(row, col) {
   return `${CSI}${row};${col}H`;
 }
@@ -42181,6 +43985,11 @@ var ChatTUI = class {
   // Escape sequence accumulator for raw stdin parsing
   escBuf = "";
   escTimer = null;
+  // Run / inference status (title bar)
+  runState = "idle";
+  activeToolName = "";
+  pausedForPrompt = false;
+  turnInProgress = false;
   constructor(options) {
     this.options = options;
     this.debugPanelVisible = !!options.debug;
@@ -42192,8 +44001,8 @@ var ChatTUI = class {
   // ─── Lifecycle ──────────────────────────────────────────────────────
   start() {
     this.updateDimensions();
-    process.stdout.write(ALT_SCREEN_ON + MOUSE_ON);
-    process.stdout.write(`${CSI}1;${Math.max(1, this.rows - 2)}r`);
+    process.stdout.write(ALT_SCREEN_ON + MOUSE_ON + BRACKETED_PASTE_ON);
+    this.applyScrollRegion();
     process.stdin.setEncoding("utf8");
     if (process.stdin.isTTY) process.stdin.setRawMode(true);
     process.stdin.on("data", this.onData);
@@ -42236,6 +44045,7 @@ var ChatTUI = class {
   streamStart() {
     this.isStreaming = true;
     this.streamContent = "";
+    this.runState = "streaming";
     this.scrollOffset = 0;
     this.dirty();
   }
@@ -42251,8 +44061,42 @@ var ChatTUI = class {
     this.streamContent = "";
     this.dirty();
   }
+  runStarted() {
+    this.turnInProgress = true;
+    this.runState = "thinking";
+    this.activeToolName = "";
+    this.dirty();
+  }
+  runFinished() {
+    this.turnInProgress = false;
+    this.runState = "idle";
+    this.activeToolName = "";
+    this.dirty();
+  }
+  /** Temporarily leave alt-screen for an external prompt (HITL). */
+  pauseForPrompt() {
+    if (!this.started || this.pausedForPrompt) return;
+    this.pausedForPrompt = true;
+    process.stdin.removeListener("data", this.onData);
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdout.write(
+      `${MOUSE_OFF}${BRACKETED_PASTE_OFF}${CSI}r${ALT_SCREEN_OFF}${SHOW_CURSOR}`
+    );
+  }
+  /** Re-enter alt-screen after an external prompt. */
+  resumeAfterPrompt() {
+    if (!this.started || !this.pausedForPrompt) return;
+    this.pausedForPrompt = false;
+    process.stdout.write(ALT_SCREEN_ON + MOUSE_ON + BRACKETED_PASTE_ON);
+    this.applyScrollRegion();
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.on("data", this.onData);
+    this.render();
+  }
   toolCallStart(id, name) {
     this.items.push({ kind: "tool_call", id, name, args: "", done: false });
+    this.runState = "tool_running";
+    this.activeToolName = name;
     this.dirty();
   }
   toolCallArgs(id, delta) {
@@ -42305,7 +44149,12 @@ var ChatTUI = class {
     this.dirty();
   }
   toolCallResult(toolCallId, toolName, content) {
-    this.items.push({ kind: "tool_result", toolCallId, toolName, content });
+    const failed = toolResultLooksFailed(content);
+    this.items.push({ kind: "tool_result", toolCallId, toolName, content, failed });
+    if (!this.isStreaming) {
+      this.runState = "thinking";
+      this.activeToolName = "";
+    }
     this.dirty();
   }
   /** Find the tool name for a given tool call ID */
@@ -42358,7 +44207,9 @@ var ChatTUI = class {
     this.scheduleRender();
   }
   restoreTerminal = () => {
-    process.stdout.write(`${MOUSE_OFF}${CSI}r${ALT_SCREEN_OFF}${SHOW_CURSOR}`);
+    process.stdout.write(
+      `${MOUSE_OFF}${BRACKETED_PASTE_OFF}${CSI}r${ALT_SCREEN_OFF}${SHOW_CURSOR}`
+    );
   };
   updateDimensions() {
     this.rows = process.stdout.rows || 24;
@@ -42374,11 +44225,32 @@ var ChatTUI = class {
     if (!this.debugVisible) return 0;
     return this.cols - this.chatWidth() - 1;
   }
+  titleRows() {
+    return this.options.title || this.options.subtitle ? 1 : 0;
+  }
+  inputRows() {
+    const lines = this.inputBuffer.split("\n").length;
+    return Math.min(MAX_INPUT_ROWS, Math.max(1, lines));
+  }
+  footerRows() {
+    return 1 + this.inputRows();
+  }
+  messageAreaTop() {
+    return 1 + this.titleRows();
+  }
+  messageAreaBottom() {
+    return this.rows - this.footerRows();
+  }
+  applyScrollRegion() {
+    const top = this.messageAreaTop();
+    const bottom = Math.max(top, this.messageAreaBottom());
+    process.stdout.write(`${CSI}${top};${bottom}r`);
+  }
   scrollHeight() {
-    return Math.max(1, this.rows - 2);
+    return Math.max(1, this.messageAreaBottom() - this.messageAreaTop() + 1);
   }
   pageSize() {
-    return Math.max(1, this.rows - 4);
+    return Math.max(1, this.scrollHeight() - 2);
   }
   // ─── Scroll ───────────────────────────────────────────────────────
   scrollUp(lines) {
@@ -42444,6 +44316,11 @@ var ChatTUI = class {
   }
   /** Handle a parsed CSI sequence: params is everything between \x1B[ and the final char */
   handleCSI(params, code) {
+    if (params === "201~") {
+      this.scrollToBottom();
+      this.dirty();
+      return;
+    }
     if (params.startsWith("<") && (code === "M" || code === "m")) {
       if (code === "m") return;
       const parts = params.slice(1).split(";");
@@ -42525,22 +44402,31 @@ var ChatTUI = class {
       this.handleEnter();
       return;
     }
+    if (code === 10) {
+      this.inputBuffer += "\n";
+      this.dirty();
+      return;
+    }
     if (code === 127 || code === 8) {
       if (this.inputBuffer.length > 0) {
         this.inputBuffer = this.inputBuffer.slice(0, -1);
-        this.renderInputLine();
+        this.dirty();
       }
       return;
     }
     if (code < 32) return;
     this.inputBuffer += ch;
-    this.renderInputLine();
+    this.dirty();
   }
   handleEnter() {
+    if (this.turnInProgress) {
+      this.dirty();
+      return;
+    }
     const text = this.inputBuffer.trim();
     this.inputBuffer = "";
     if (!text) {
-      this.renderInputLine();
+      this.dirty();
       return;
     }
     if (text.toLowerCase() === "exit" || text.toLowerCase() === "quit") {
@@ -42557,7 +44443,7 @@ var ChatTUI = class {
   // ─── Events ───────────────────────────────────────────────────────
   onResize = () => {
     this.updateDimensions();
-    process.stdout.write(`${CSI}1;${Math.max(1, this.rows - 2)}r`);
+    this.applyScrollRegion();
     this.displayLinesCache = null;
     this.debugLinesCache = null;
     this.render();
@@ -42599,19 +44485,24 @@ var ChatTUI = class {
       visible = displayLines.slice(start, end);
     }
     const buf = [HIDE_CURSOR];
+    const msgTop = this.messageAreaTop();
+    if (this.titleRows()) {
+      buf.push(moveTo(1, 1), this.buildTitleBar(), CLEAR_EOL);
+    }
     if (this.debugVisible) {
-      this.renderSplitScreen(buf, visible, sh);
+      this.renderSplitScreen(buf, visible, sh, msgTop);
     } else {
       for (let i = 0; i < sh; i++) {
-        buf.push(moveTo(i + 1, 1), visible[i] || "", CLEAR_EOL);
+        buf.push(moveTo(msgTop + i, 1), visible[i] || "", CLEAR_EOL);
       }
     }
-    buf.push(moveTo(this.rows - 1, 1), this.buildSeparator(), CLEAR_EOL);
-    buf.push(moveTo(this.rows, 1), `${BLUE}You:${RESET} ${this.inputBuffer}${CLEAR_EOL}`);
+    const sepRow = this.rows - this.inputRows();
+    buf.push(moveTo(sepRow, 1), this.buildSeparator(), CLEAR_EOL);
+    this.renderInputArea(buf, sepRow + 1);
     buf.push(SHOW_CURSOR);
     process.stdout.write(buf.join(""));
   }
-  renderSplitScreen(buf, chatVisible, sh) {
+  renderSplitScreen(buf, chatVisible, sh, msgTop = 1) {
     const cw = this.chatWidth();
     const dw = this.debugWidth();
     const divCol = cw + 1;
@@ -42627,21 +44518,68 @@ var ChatTUI = class {
       const chatLine = truncateAnsi(chatVisible[i] || "", cw);
       const debugLine = truncateAnsi(debugVisible[i] || "", dw);
       buf.push(
-        moveTo(i + 1, 1),
+        moveTo(msgTop + i, 1),
         chatLine,
         CLEAR_EOL,
         // clear to end handles rest, but we need to position divider
-        moveTo(i + 1, divCol),
+        moveTo(msgTop + i, divCol),
         `${DIM}\u2502${RESET}`,
         debugLine
       );
       buf.push(CLEAR_EOL);
     }
   }
-  renderInputLine() {
-    process.stdout.write(
-      `${moveTo(this.rows, 1)}${BLUE}You:${RESET} ${this.inputBuffer}${CLEAR_EOL}`
-    );
+  renderInputArea(buf, startRow) {
+    const inputRows = this.inputRows();
+    const width = this.chatWidth();
+    const contentWidth = Math.max(1, width - INPUT_LABEL_WIDTH);
+    const inputLines = this.wrapInputLines(this.inputBuffer, contentWidth, inputRows);
+    for (let i = 0; i < inputRows; i++) {
+      const row = startRow + i;
+      const line = inputLines[i] ?? "";
+      const prefix = i === 0 ? `${BLUE}${INPUT_LABEL}${RESET} ` : " ".repeat(INPUT_LABEL_WIDTH);
+      buf.push(moveTo(row, 1), prefix, line, CLEAR_EOL);
+    }
+  }
+  wrapInputLines(text, maxWidth, maxRows) {
+    const rawLines = text.split("\n");
+    const wrapped = [];
+    for (const raw of rawLines) {
+      for (const wl of this.wrapText(raw, maxWidth)) {
+        wrapped.push(wl);
+      }
+    }
+    if (!wrapped.length) wrapped.push("");
+    if (wrapped.length > maxRows) {
+      const trimmed = wrapped.slice(wrapped.length - maxRows);
+      trimmed[0] = "\u2026" + trimmed[0].slice(1);
+      return trimmed;
+    }
+    return wrapped;
+  }
+  buildTitleBar() {
+    const parts = [];
+    if (this.options.title) {
+      parts.push(`${CYAN}${this.options.title}${RESET}`);
+    }
+    if (this.options.subtitle) {
+      parts.push(`${DIM}${this.options.subtitle}${RESET}`);
+    }
+    let status = "";
+    switch (this.runState) {
+      case "thinking":
+        status = `${YELLOW}Thinking\u2026${RESET}`;
+        break;
+      case "tool_running":
+        status = `${YELLOW}Running ${this.activeToolName}\u2026${RESET}`;
+        break;
+      case "streaming":
+        status = `${GREEN}Writing\u2026${RESET}`;
+        break;
+    }
+    if (status) parts.push(status);
+    const line = parts.join(` ${DIM}|${RESET} `);
+    return truncateAnsi(line, this.cols);
   }
   // ─── Separator ────────────────────────────────────────────────────
   buildSeparator() {
@@ -42656,6 +44594,7 @@ var ChatTUI = class {
     if (this.options.debug) {
       hints.push(`^D ${this.debugPanelVisible ? "hide" : "show"} debug`);
     }
+    hints.push("Enter send");
     const lineWidth = Math.min(this.cols, 60);
     if (!hints.length) {
       return `${GRAY}${"\u2500".repeat(lineWidth)}${RESET}`;
@@ -42686,8 +44625,9 @@ var ChatTUI = class {
     return lines;
   }
   appendToolCallLines(lines, tc, width) {
-    const status = tc.done ? "Called" : "Calling";
-    const summary = `  ${GRAY}${status} ${tc.name}${tc.done ? "" : "..."}${RESET}`;
+    const status = tc.done ? "\u2713" : "\u2026";
+    const verb = tc.done ? "Called" : "Calling";
+    const summary = `  ${tc.done ? GREEN : YELLOW}${status}${RESET} ${GRAY}${verb} ${tc.name}${RESET}`;
     if (!this.expandDetails) {
       lines.push(summary);
       return;
@@ -42708,14 +44648,15 @@ var ChatTUI = class {
     }
   }
   appendToolResultLines(lines, tr, width) {
+    const mark = tr.failed ? `${RED}\u2717${RESET}` : `${GREEN}\u2713${RESET}`;
     if (!this.expandDetails) {
-      const maxLen = width - 10;
+      const maxLen = width - 12;
       const preview = tr.content.replace(/\n/g, " ").slice(0, maxLen);
       const truncated = preview.length < tr.content.length ? "..." : "";
-      lines.push(`    ${GRAY}\u2192 ${tr.toolName}: ${preview}${truncated}${RESET}`);
+      lines.push(`    ${mark} ${GRAY}${tr.toolName}: ${preview}${truncated}${RESET}`);
       return;
     }
-    lines.push(`    ${GRAY}\u2192 ${tr.toolName} result:${RESET}`);
+    lines.push(`    ${mark} ${GRAY}${tr.toolName} result:${RESET}`);
     let formatted = tr.content;
     try {
       formatted = JSON.stringify(JSON.parse(tr.content), null, 2);
@@ -42767,7 +44708,12 @@ var ChatTUI = class {
     const labelWidth = 12;
     const indent = " ".repeat(labelWidth);
     if (!this.streamContent) {
-      lines.push(label);
+      if (this.runState === "thinking" || this.runState === "tool_running") {
+        const hint2 = this.runState === "tool_running" && this.activeToolName ? `Running ${this.activeToolName}\u2026` : "Thinking\u2026";
+        lines.push(`${label}${YELLOW}${hint2}${RESET}`);
+      } else {
+        lines.push(label);
+      }
       return;
     }
     let first = true;
@@ -42884,6 +44830,58 @@ function buildDebugSummary(_direction, msg) {
   }
   return type;
 }
+
+// src/lib/agui-tui-events.ts
+init_agui();
+function handleAguiEvent(tui, event) {
+  const type = event.type?.toLowerCase() ?? "";
+  switch (type) {
+    case "run_started":
+      tui.runStarted();
+      break;
+    case "run_finished":
+      tui.runFinished();
+      break;
+    case "text_message_start":
+      tui.streamStart();
+      break;
+    case "text_message_content": {
+      const delta = getTextDelta(event);
+      if (delta) tui.streamDelta(delta);
+      break;
+    }
+    case "text_message_end":
+      tui.streamEnd();
+      break;
+    case "tool_call_start":
+      tui.toolCallStart(
+        event.toolCallId ?? "",
+        event.toolCallName ?? event.name ?? "tool"
+      );
+      break;
+    case "tool_call_args":
+      if (event.toolCallId && event.delta) {
+        tui.toolCallArgs(event.toolCallId, event.delta);
+      }
+      break;
+    case "tool_call_end":
+      if (event.toolCallId) tui.toolCallEnd(event.toolCallId);
+      break;
+    case "tool_call_result": {
+      const toolCallId = event.toolCallId ?? "";
+      const toolName = tui.findToolCallName(toolCallId);
+      const content = typeof event.content === "string" ? event.content : typeof event.result === "string" ? event.result : JSON.stringify(event.result ?? event.content ?? "");
+      tui.toolCallResult(toolCallId, toolName, content);
+      break;
+    }
+    case "run_error": {
+      const errorMsg = getErrorMessage(event);
+      if (errorMsg) tui.showError(errorMsg);
+      tui.runFinished();
+      break;
+    }
+  }
+}
 var SAMPLE_RATE = 24e3;
 var MIC_CHUNK_BYTES = 4800;
 function checkSoxAvailable() {
@@ -43199,6 +45197,7 @@ var AudioPlayer = class extends EventEmitter {
 };
 
 // src/lib/chat-session.ts
+var HITL_INTERRUPT_EXIT_CODE = 3;
 async function runChatSession(session, args) {
   const debug = !!args.debug;
   const isVoice = !!args.voice;
@@ -43228,6 +45227,14 @@ async function runChatSession(session, args) {
 function vadMode(args) {
   return typeof args.vad === "string" ? args.vad : "server";
 }
+function sanitizeInterruptForStdout(result2) {
+  const url = typeof result2.payload.url === "string" ? result2.payload.url : void 0;
+  return {
+    type: result2.type,
+    interrupt_id: result2.interruptId,
+    url
+  };
+}
 async function singleTurnChatSession(session, message, debug, autoApprove = false, allowWrite = false) {
   const aguiClient = new AGUIClient({
     baseUrl: session.ctx.envConfig.apiUrl,
@@ -43247,18 +45254,34 @@ async function singleTurnChatSession(session, message, debug, autoApprove = fals
 `);
     }
   };
-  const { streamText, hasToolCalls } = await runConciergeAguiLoop(
+  const { streamText, hasToolCalls, unsupportedHitl } = await runConciergeAguiLoop(
     aguiClient,
     [{ role: "user", content: message }],
     onEvent,
     {
       autoApprove,
       allowWrite: allowWrite || !!session.allowWrite,
+      debug,
       trustCwd: session.trustCwd,
       trustDir: session.trustDir,
       nonInteractive: true
     }
   );
+  if (unsupportedHitl) {
+    const jsonPayload = JSON.stringify({
+      error: "hitl_interrupt",
+      message: "A human-in-the-loop interrupt requires out-of-band action before the operation can continue.",
+      resume: {
+        chatId: session.chatId,
+        chatUuid: session.chatUuid,
+        interruptId: unsupportedHitl.interruptId
+      },
+      interrupt: sanitizeInterruptForStdout(unsupportedHitl)
+    });
+    process.stdout.write(`${jsonPayload}
+`);
+    throw new CLIError("HITL interrupt requires out-of-band handling", HITL_INTERRUPT_EXIT_CODE);
+  }
   if (streamText) {
     process.stdout.write(`\x1B[32mAssistant:\x1B[0m ${streamText}
 `);
@@ -43303,99 +45326,81 @@ async function interactiveChatSession(session, debug, autoApprove, allowWrite) {
     model: session.model,
     appContext: session.appContext
   });
-  clearScreen();
-  console.log("=".repeat(60));
-  console.log(session.label);
-  console.log("=".repeat(60));
-  console.log(`Chat: ${session.chatTitle}`);
-  console.log("Type your message and press Enter. Type 'exit' or Ctrl+C to quit.");
-  console.log("=".repeat(60));
-  console.log("");
   const existingMessages = await session.loadMessages();
-  if (existingMessages.length > 0) {
-    console.log("\x1B[90m--- Previous messages ---\x1B[0m\n");
-    for (const msg of existingMessages.slice(-10)) {
-      const text = typeof msg.content === "string" ? msg.content : "";
-      if (text && text.trim()) {
-        printMessage(text, msg.role);
+  const history = buildHistory(existingMessages);
+  const conversationMessages = buildConversationMessages(existingMessages);
+  let tui;
+  const sendTurn = async (text) => {
+    conversationMessages.push({ role: "user", content: text });
+    let assistantContent = "";
+    try {
+      tui.runStarted();
+      const { streamText } = await runConciergeAguiLoop(
+        aguiClient,
+        conversationMessages,
+        (event) => {
+          handleAguiEvent(tui, event);
+          const type = event.type?.toLowerCase() ?? "";
+          if (type === "text_message_content" && event.delta) {
+            assistantContent += event.delta;
+          }
+          const errorMsg = getErrorMessage(event);
+          if (errorMsg) tui.showError(errorMsg);
+        },
+        {
+          autoApprove,
+          allowWrite: allowWrite || !!session.allowWrite,
+          debug,
+          trustCwd: session.trustCwd,
+          trustDir: session.trustDir,
+          onHitlPromptStart: () => tui.pauseForPrompt(),
+          onHitlPromptEnd: () => tui.resumeAfterPrompt()
+        }
+      );
+      if (streamText && !assistantContent) {
+        assistantContent = streamText;
+      }
+      if (assistantContent) {
+        conversationMessages.push({ role: "assistant", content: assistantContent });
       }
+    } catch (error) {
+      tui.showError(error instanceof Error ? error.message : String(error));
+    } finally {
+      tui.runFinished();
     }
-    console.log("\x1B[90m--- End of history ---\x1B[0m\n");
-  }
-  const conversationMessages = [];
-  for (const msg of existingMessages.slice(-10)) {
+  };
+  await new Promise((resolve2) => {
+    tui = new ChatTUI({
+      title: session.label,
+      subtitle: session.chatTitle,
+      onSend: (text) => {
+        void sendTurn(text);
+      },
+      onExit: () => {
+        tui.stop();
+        resolve2();
+      },
+      debug,
+      env: session.ctx.env
+    });
+    tui.loadHistory(history);
+    tui.start();
+  });
+}
+function buildConversationMessages(messages) {
+  const out = [];
+  for (const msg of messages) {
     const text = typeof msg.content === "string" ? msg.content : "";
-    if (text && text.trim() && (msg.role === "user" || msg.role === "assistant")) {
-      conversationMessages.push({ role: msg.role, content: text });
+    if (text.trim() && (msg.role === "user" || msg.role === "assistant")) {
+      out.push({ role: msg.role, content: text });
     }
   }
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve2) => {
-    const prompt = () => {
-      rl.question("\x1B[34mYou:\x1B[0m ", async (input2) => {
-        const trimmed = input2.trim();
-        if (!trimmed) {
-          prompt();
-          return;
-        }
-        if (trimmed.toLowerCase() === "exit" || trimmed.toLowerCase() === "quit") {
-          console.log("\nGoodbye!");
-          rl.close();
-          return;
-        }
-        conversationMessages.push({ role: "user", content: trimmed });
-        process.stdout.write("\n\x1B[32mAssistant:\x1B[0m ");
-        let assistantContent = "";
-        try {
-          const { streamText } = await runConciergeAguiLoop(
-            aguiClient,
-            conversationMessages,
-            (event) => {
-              const delta = getTextDelta(event);
-              if (delta) {
-                process.stdout.write(delta);
-                assistantContent += delta;
-              }
-              const errorMsg = getErrorMessage(event);
-              if (errorMsg) console.log(`
-\x1B[31mError: ${errorMsg}\x1B[0m`);
-            },
-            {
-              autoApprove,
-              allowWrite: allowWrite || !!session.allowWrite,
-              debug,
-              trustCwd: session.trustCwd,
-              trustDir: session.trustDir
-            }
-          );
-          if (streamText && !assistantContent) {
-            assistantContent = streamText;
-            process.stdout.write(streamText);
-          }
-          if (assistantContent) {
-            conversationMessages.push({ role: "assistant", content: assistantContent });
-          }
-          console.log("\n");
-        } catch (error) {
-          console.log(
-            `
-\x1B[31mError: ${error instanceof Error ? error.message : error}\x1B[0m
-`
-          );
-        }
-        prompt();
-      });
-    };
-    rl.on("close", () => {
-      console.log("\nGoodbye!");
-      resolve2();
-    });
-    prompt();
-  });
+  return out;
 }
-function buildHistory(messages) {
+function buildHistory(messages, limit) {
   const history = [];
-  for (const msg of messages.slice(-30)) {
+  const slice = limit ? messages.slice(-limit) : messages;
+  for (const msg of slice) {
     const text = typeof msg.content === "string" ? msg.content : "";
     if (msg.role === "user" || msg.role === "assistant") {
       if (text.trim()) {
@@ -43467,7 +45472,7 @@ async function realtimeChatSession(session, vad, debug) {
     throw new CLIError(`Failed to connect: ${err instanceof Error ? err.message : err}`);
   }
   const existingMessages = await session.loadMessages();
-  const history = buildHistory(existingMessages);
+  const history = buildHistory(existingMessages, 30);
   const tui = new ChatTUI({
     onSend: (text) => {
       client.sendTextMessage(text);
@@ -43532,7 +45537,7 @@ Connecting to ${session.label.toLowerCase()}...
     throw new CLIError(`Failed to connect: ${err instanceof Error ? err.message : err}`);
   }
   const existingMessages = await session.loadMessages();
-  const history = buildHistory(existingMessages);
+  const history = buildHistory(existingMessages, 30);
   const mic = new MicCapture((pcm16) => {
     if (!client.isConnected()) return;
     client.sendAudio(pcm16);
@@ -43627,15 +45632,173 @@ async function listAudioDevices() {
   }
 }
 
+// src/lib/chat-history.ts
+var PAGE_SIZE = 100;
+var HARD_CAP = 2e3;
+async function loadAllChatMessages(ctx, workspaceUuid, chatId) {
+  const items = [];
+  let offset = 0;
+  while (items.length < HARD_CAP) {
+    const batch = await ctx.apiClient.getChatMessages(workspaceUuid, chatId, PAGE_SIZE, offset).catch(() => []);
+    if (!batch.length) break;
+    items.push(...batch);
+    if (batch.length < PAGE_SIZE) break;
+    offset += batch.length;
+  }
+  return items;
+}
+
+// src/commands/manage.ts
+async function manageCommand(hctx) {
+  const ctx = requireAuth(hctx.ctx);
+  const { workspace, args } = hctx;
+  const asMember = typeof args["as-member"] === "string" ? args["as-member"] : void 0;
+  const chatIdArg = typeof args["chat-id"] === "string" ? args["chat-id"] : void 0;
+  const message = typeof args.message === "string" ? args.message : void 0;
+  const chat = await getOrCreateChat(ctx, workspace, chatIdArg, asMember, "manager", !!message);
+  const session = buildWorkspaceSession(ctx, workspace, chat, "Workspace Manager", {
+    appContext: buildCliConciergeAppContext(),
+    allowWrite: true,
+    trustCwd: !!args["trust-cwd"],
+    trustDir: typeof args["trust-dir"] === "string" ? args["trust-dir"] : void 0
+  });
+  process.stderr.write(`Chat #${session.chatId}
+`);
+  await runChatSession(session, args);
+  process.stderr.write(`Chat #${session.chatId}
+`);
+}
+async function chatCommand(hctx) {
+  const ctx = requireAuth(hctx.ctx);
+  const { workspace, args } = hctx;
+  const chatIdArg = typeof args["chat-id"] === "string" ? args["chat-id"] : void 0;
+  const workflowId = typeof args.workflow === "string" ? args.workflow : void 0;
+  const memberId = typeof args.member === "string" ? args.member : void 0;
+  let chat;
+  if (chatIdArg) {
+    const id = Number(chatIdArg);
+    if (isNaN(id)) throw new CLIError("--chat-id must be a number");
+    chat = await ctx.apiClient.getChat(workspace, id);
+  } else if (workflowId) {
+    chat = await createAssignmentChat(ctx.apiClient, workspace, Number(workflowId), memberId);
+  } else if (memberId) {
+    chat = await createMemberChat(ctx.apiClient, workspace, memberId);
+  } else {
+    throw new CLIError(
+      'Specify --workflow <id>, --member <id>, or --chat-id <id>.\nUse "gr manage" for workspace manager chats.'
+    );
+  }
+  const session = buildWorkspaceSession(ctx, workspace, chat, "Chat");
+  await runChatSession(session, args);
+}
+function buildWorkspaceSession(ctx, workspace, chat, label, extra) {
+  const wsBase = ctx.envConfig.apiUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+  return {
+    ctx,
+    workspaceUuid: workspace,
+    chatId: chat.id,
+    chatUuid: chat.uuid,
+    chatTitle: chat.title || chat.uuid,
+    aguiEndpointUrl: `${ctx.envConfig.apiUrl}/api/v2/w/${workspace}/web-chat/${chat.id}/chat/agui`,
+    wsUrl: `${wsBase}/api/v2/w/${workspace}/realtime/stream-ws`,
+    loadMessages: () => loadAllChatMessages(ctx, workspace, chat.id),
+    label,
+    model: "manager",
+    ...extra
+  };
+}
+async function getOrCreateChat(ctx, workspace, chatIdArg, asMemberId, chatType, skipSelection = false) {
+  if (chatIdArg) {
+    const chatId = Number(chatIdArg);
+    if (isNaN(chatId)) throw new CLIError("--chat-id must be a number");
+    return ctx.apiClient.getChat(workspace, chatId);
+  }
+  if (skipSelection) {
+    return createManagerChat(ctx.apiClient, workspace, asMemberId);
+  }
+  const chatsResponse = await ctx.apiClient.getChats(workspace, {
+    chatType,
+    sortBy: "updatedAt",
+    sortOrder: "desc",
+    pageSize: 20
+  });
+  const chats = chatsResponse.items || [];
+  const { item: selectedChat, isNew } = await selectFromList(chats, {
+    title: "Select a chat or create a new one",
+    labelFn: (chat) => chat.title || `Chat ${chat.uuid.slice(0, 8)}...`,
+    detailFn: (chat) => {
+      const time = formatTimestamp(chat.updatedAt);
+      const msgCount = chat.messageCount || 0;
+      return `${msgCount} msg${msgCount !== 1 ? "s" : ""} - ${time}`;
+    },
+    emptyMessage: "No existing chats.",
+    allowNew: true,
+    newLabel: "+ Start new chat"
+  });
+  if (!selectedChat && !isNew) {
+    throw new CLIError("No chat selected.");
+  }
+  if (isNew) {
+    return createManagerChat(ctx.apiClient, workspace, asMemberId);
+  }
+  return selectedChat;
+}
+async function createManagerChat(apiClient, workspace, asMemberId) {
+  const data = {
+    chatType: "manager",
+    channel: "web-chat"
+  };
+  if (asMemberId) {
+    data.memberId = Number(asMemberId);
+  }
+  const chat = await apiClient.createChat(workspace, data);
+  process.stderr.write(`Created chat #${chat.id}
+`);
+  return chat;
+}
+async function createAssignmentChat(apiClient, workspace, workflowId, asMemberId) {
+  if (isNaN(workflowId)) throw new CLIError("--workflow must be a number");
+  const data = {
+    chatType: "assignment",
+    channel: "web-chat",
+    workflowId
+  };
+  if (asMemberId) {
+    data.memberId = Number(asMemberId);
+  }
+  const chat = await apiClient.createChat(workspace, data);
+  process.stderr.write(`Created assignment chat #${chat.id} (workflow ${workflowId})
+`);
+  return chat;
+}
+async function createMemberChat(apiClient, workspace, memberId) {
+  const id = Number(memberId);
+  if (isNaN(id)) throw new CLIError("--member must be a number");
+  const data = {
+    chatType: "member",
+    channel: "web-chat",
+    memberId: id
+  };
+  const chat = await apiClient.createChat(workspace, data);
+  process.stderr.write(`Created DM chat #${chat.id} (member ${memberId})
+`);
+  return chat;
+}
+
 // src/commands/concierge.ts
+init_cli_utils();
+init_concierge_api();
+init_context();
+init_errors();
 async function conciergeOutboundCommand(hctx) {
   const ctx = requireAuth(hctx.ctx);
   const { args } = hctx;
+  const message = typeof args.message === "string" ? args.message : void 0;
   if (args.call && args.sms) {
     throw new CLIError("--call and --sms are mutually exclusive");
   }
   if (args.call) {
-    const result2 = await originateConciergeCall(ctx);
+    const result2 = await originateConciergeCall(ctx, "concierge_setup", message, "cli");
     process.stderr.write(
       `Concierge call started. callSid=${result2.callSid} startedAt=${result2.startedAt}
 `
@@ -43726,6 +45889,63 @@ async function getOrCreateConciergeChat(ctx, chatIdArg, skipSelection) {
   return selectedChat;
 }
 
+// src/commands/dev.ts
+init_errors();
+init_output();
+async function devImportLocalCommand(ctx, workspace) {
+  stderr2(`Exporting workspace ${workspace}...`);
+  const exportData = await ctx.apiClient.exportWorkspace(workspace);
+  stderr2("Export successful!");
+  stderr2(`  Workflows: ${(exportData.workflows || []).length}`);
+  stderr2(`  Tasks: ${(exportData.tasks || []).length}`);
+  stderr2(`  Data Types: ${(exportData.dataTypes || []).length}`);
+  stderr2(`  Sites: ${(exportData.sites || []).length}`);
+  const slug = workspace.slice(0, 8);
+  const importCacheDir = join(ctx.credentialsManager.getCacheDir(), "imports");
+  if (!existsSync(importCacheDir)) {
+    mkdirSync(importCacheDir, { recursive: true });
+  }
+  const filename = `ws-${slug}-${workspace}.json`;
+  const filepath = join(importCacheDir, filename);
+  writeFileSync(filepath, JSON.stringify(exportData, null, 2));
+  stderr2(`Saved to: ${filepath}`);
+  stderr2("Running dev:restore...");
+  const rootDir = findProjectRoot();
+  const relativePath = filepath.replace(rootDir + "/", "");
+  try {
+    const result2 = execSync(`yarn dev:restore ${relativePath}`, {
+      cwd: rootDir,
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    process.stderr.write(result2);
+    const failed = result2.includes("Failed/Skipped: ") && !result2.includes("Failed/Skipped: 0") || result2.includes("Successfully restored: 0");
+    if (failed) throw new CLIError("Import failed");
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    const execError = error;
+    if (execError.stdout) process.stderr.write(execError.stdout);
+    if (execError.stderr) process.stderr.write(execError.stderr);
+    throw new CLIError("dev:restore failed");
+  }
+  stderr2(`Import complete: ${workspace}`);
+}
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== "/") {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.workspaces) return dir;
+      } catch {
+      }
+    }
+    dir = join(dir, "..");
+  }
+  return process.cwd();
+}
+
 // src/commands/get-started.ts
 init_context();
 var WEB_SETUP = "https://app.gravityrail.com/setup";
@@ -43826,63 +46046,6 @@ async function getStartedCommand(hctx) {
   process.stdout.write(LLM_GUIDE);
 }
 
-// src/commands/dev.ts
-init_errors();
-init_output();
-async function devImportLocalCommand(ctx, workspace) {
-  stderr2(`Exporting workspace ${workspace}...`);
-  const exportData = await ctx.apiClient.exportWorkspace(workspace);
-  stderr2("Export successful!");
-  stderr2(`  Workflows: ${(exportData.workflows || []).length}`);
-  stderr2(`  Tasks: ${(exportData.tasks || []).length}`);
-  stderr2(`  Data Types: ${(exportData.dataTypes || []).length}`);
-  stderr2(`  Sites: ${(exportData.sites || []).length}`);
-  const slug = workspace.slice(0, 8);
-  const importCacheDir = join(ctx.credentialsManager.getCacheDir(), "imports");
-  if (!existsSync(importCacheDir)) {
-    mkdirSync(importCacheDir, { recursive: true });
-  }
-  const filename = `ws-${slug}-${workspace}.json`;
-  const filepath = join(importCacheDir, filename);
-  writeFileSync(filepath, JSON.stringify(exportData, null, 2));
-  stderr2(`Saved to: ${filepath}`);
-  stderr2("Running dev:restore...");
-  const rootDir = findProjectRoot();
-  const relativePath = filepath.replace(rootDir + "/", "");
-  try {
-    const result2 = execSync(`yarn dev:restore ${relativePath}`, {
-      cwd: rootDir,
-      stdio: "pipe",
-      encoding: "utf-8"
-    });
-    process.stderr.write(result2);
-    const failed = result2.includes("Failed/Skipped: ") && !result2.includes("Failed/Skipped: 0") || result2.includes("Successfully restored: 0");
-    if (failed) throw new CLIError("Import failed");
-  } catch (error) {
-    if (error instanceof CLIError) throw error;
-    const execError = error;
-    if (execError.stdout) process.stderr.write(execError.stdout);
-    if (execError.stderr) process.stderr.write(execError.stderr);
-    throw new CLIError("dev:restore failed");
-  }
-  stderr2(`Import complete: ${workspace}`);
-}
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== "/") {
-    const pkgPath = join(dir, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.workspaces) return dir;
-      } catch {
-      }
-    }
-    dir = join(dir, "..");
-  }
-  return process.cwd();
-}
-
 // src/commands/login.ts
 init_dist();
 init_cli_utils();
@@ -43902,146 +46065,6 @@ async function logoutCommand(ctx) {
   stderr2(`Credentials cleared for ${ctx.env}`);
 }
 
-// src/commands/manage.ts
-init_cli_utils();
-init_errors();
-init_context();
-async function manageCommand(hctx) {
-  const ctx = requireAuth(hctx.ctx);
-  const { workspace, args } = hctx;
-  const asMember = typeof args["as-member"] === "string" ? args["as-member"] : void 0;
-  const chatIdArg = typeof args["chat-id"] === "string" ? args["chat-id"] : void 0;
-  const message = typeof args.message === "string" ? args.message : void 0;
-  const chat = await getOrCreateChat(ctx, workspace, chatIdArg, asMember, "manager", !!message);
-  const session = buildWorkspaceSession(ctx, workspace, chat, "Workspace Manager", {
-    appContext: buildCliConciergeAppContext(),
-    allowWrite: true,
-    trustCwd: !!args["trust-cwd"],
-    trustDir: typeof args["trust-dir"] === "string" ? args["trust-dir"] : void 0
-  });
-  process.stderr.write(`Chat #${session.chatId}
-`);
-  await runChatSession(session, args);
-  process.stderr.write(`Chat #${session.chatId}
-`);
-}
-async function chatCommand(hctx) {
-  const ctx = requireAuth(hctx.ctx);
-  const { workspace, args } = hctx;
-  const chatIdArg = typeof args["chat-id"] === "string" ? args["chat-id"] : void 0;
-  const workflowId = typeof args.workflow === "string" ? args.workflow : void 0;
-  const memberId = typeof args.member === "string" ? args.member : void 0;
-  let chat;
-  if (chatIdArg) {
-    const id = Number(chatIdArg);
-    if (isNaN(id)) throw new CLIError("--chat-id must be a number");
-    chat = await ctx.apiClient.getChat(workspace, id);
-  } else if (workflowId) {
-    chat = await createAssignmentChat(ctx.apiClient, workspace, Number(workflowId), memberId);
-  } else if (memberId) {
-    chat = await createMemberChat(ctx.apiClient, workspace, memberId);
-  } else {
-    throw new CLIError(
-      'Specify --workflow <id>, --member <id>, or --chat-id <id>.\nUse "gr manage" for workspace manager chats.'
-    );
-  }
-  const session = buildWorkspaceSession(ctx, workspace, chat, "Chat");
-  await runChatSession(session, args);
-}
-function buildWorkspaceSession(ctx, workspace, chat, label, extra) {
-  const wsBase = ctx.envConfig.apiUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
-  return {
-    ctx,
-    workspaceUuid: workspace,
-    chatId: chat.id,
-    chatUuid: chat.uuid,
-    chatTitle: chat.title || chat.uuid,
-    aguiEndpointUrl: `${ctx.envConfig.apiUrl}/api/v2/w/${workspace}/web-chat/${chat.id}/chat/agui`,
-    wsUrl: `${wsBase}/api/v2/w/${workspace}/realtime/stream-ws`,
-    loadMessages: () => ctx.apiClient.getChatMessages(workspace, chat.id, 50).catch(() => []),
-    label,
-    model: "manager",
-    ...extra
-  };
-}
-async function getOrCreateChat(ctx, workspace, chatIdArg, asMemberId, chatType, skipSelection = false) {
-  if (chatIdArg) {
-    const chatId = Number(chatIdArg);
-    if (isNaN(chatId)) throw new CLIError("--chat-id must be a number");
-    return ctx.apiClient.getChat(workspace, chatId);
-  }
-  if (skipSelection) {
-    return createManagerChat(ctx.apiClient, workspace, asMemberId);
-  }
-  const chatsResponse = await ctx.apiClient.getChats(workspace, {
-    chatType,
-    sortBy: "updatedAt",
-    sortOrder: "desc",
-    pageSize: 20
-  });
-  const chats = chatsResponse.items || [];
-  const { item: selectedChat, isNew } = await selectFromList(chats, {
-    title: "Select a chat or create a new one",
-    labelFn: (chat) => chat.title || `Chat ${chat.uuid.slice(0, 8)}...`,
-    detailFn: (chat) => {
-      const time = formatTimestamp(chat.updatedAt);
-      const msgCount = chat.messageCount || 0;
-      return `${msgCount} msg${msgCount !== 1 ? "s" : ""} - ${time}`;
-    },
-    emptyMessage: "No existing chats.",
-    allowNew: true,
-    newLabel: "+ Start new chat"
-  });
-  if (!selectedChat && !isNew) {
-    throw new CLIError("No chat selected.");
-  }
-  if (isNew) {
-    return createManagerChat(ctx.apiClient, workspace, asMemberId);
-  }
-  return selectedChat;
-}
-async function createManagerChat(apiClient, workspace, asMemberId) {
-  const data = {
-    chatType: "manager",
-    channel: "web-chat"
-  };
-  if (asMemberId) {
-    data.memberId = Number(asMemberId);
-  }
-  const chat = await apiClient.createChat(workspace, data);
-  process.stderr.write(`Created chat #${chat.id}
-`);
-  return chat;
-}
-async function createAssignmentChat(apiClient, workspace, workflowId, asMemberId) {
-  if (isNaN(workflowId)) throw new CLIError("--workflow must be a number");
-  const data = {
-    chatType: "assignment",
-    channel: "web-chat",
-    workflowId
-  };
-  if (asMemberId) {
-    data.memberId = Number(asMemberId);
-  }
-  const chat = await apiClient.createChat(workspace, data);
-  process.stderr.write(`Created assignment chat #${chat.id} (workflow ${workflowId})
-`);
-  return chat;
-}
-async function createMemberChat(apiClient, workspace, memberId) {
-  const id = Number(memberId);
-  if (isNaN(id)) throw new CLIError("--member must be a number");
-  const data = {
-    chatType: "member",
-    channel: "web-chat",
-    memberId: id
-  };
-  const chat = await apiClient.createChat(workspace, data);
-  process.stderr.write(`Created DM chat #${chat.id} (member ${memberId})
-`);
-  return chat;
-}
-
 // src/commands/organizations.ts
 init_output();
 var COLUMNS34 = [
@@ -44072,26 +46095,26 @@ async function whoamiCommand(ctx) {
   outputSingle(account, ctx, columns);
 }
 
-// src/register-special-commands.ts
+// src/top-level-commands.ts
 init_context();
-function registerSpecialCommands(registry) {
-  registry.registerCommand({
+var topLevelCommands = [
+  {
     path: ["login"],
     description: "Authenticate via OAuth",
     requiresAuth: false,
     handler: async ({ ctx }) => {
       await loginCommand(ctx);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["logout"],
     description: "Clear cached credentials",
     requiresAuth: false,
     handler: async ({ ctx }) => {
       await logoutCommand(ctx);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["auth", "browser"],
     description: "Open an authenticated browser session using CLI credentials",
     args: [
@@ -44100,8 +46123,8 @@ function registerSpecialCommands(registry) {
     handler: async ({ ctx, args }) => {
       await authBrowserCommand(requireAuth(ctx), args);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["manage"],
     description: "Interactive workspace manager chat (text, realtime, or voice)",
     requiresWorkspace: true,
@@ -44135,8 +46158,8 @@ function registerSpecialCommands(registry) {
     handler: async (hctx) => {
       await manageCommand(hctx);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["chat"],
     description: "Chat with a workflow, member, or existing chat (text, realtime, or voice)",
     requiresWorkspace: true,
@@ -44162,8 +46185,8 @@ function registerSpecialCommands(registry) {
     handler: async (hctx) => {
       await chatCommand(hctx);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["get-started"],
     description: "Bootstrap instructions for new users and LLM agents",
     requiresAuth: false,
@@ -44181,8 +46204,8 @@ function registerSpecialCommands(registry) {
     handler: async (hctx) => {
       await getStartedCommand(hctx);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["setup"],
     description: "Alias for get-started \u2014 bootstrap instructions",
     requiresAuth: false,
@@ -44193,8 +46216,8 @@ function registerSpecialCommands(registry) {
     handler: async (hctx) => {
       await getStartedCommand(hctx);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["concierge"],
     description: "Call or SMS your verified phone via the Concierge (server-side)",
     requiresWorkspace: false,
@@ -44206,8 +46229,8 @@ function registerSpecialCommands(registry) {
     handler: async (hctx) => {
       await conciergeOutboundCommand(hctx);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["account", "verify-phone"],
     description: "Verify your account phone for concierge chat --call / --sms",
     requiresWorkspace: false,
@@ -44217,8 +46240,8 @@ function registerSpecialCommands(registry) {
       const { accountVerifyPhoneCommand: accountVerifyPhoneCommand2 } = await Promise.resolve().then(() => (init_account_verify_phone(), account_verify_phone_exports));
       await accountVerifyPhoneCommand2(hctx);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["concierge", "chat"],
     description: "Interactive concierge chat (text, realtime, or voice)",
     requiresWorkspace: false,
@@ -44236,7 +46259,11 @@ function registerSpecialCommands(registry) {
         description: "SMS your verified account phone (server-side)",
         isFlag: true
       },
-      { name: "message", alias: "m", description: "Single-turn: send one message and exit" },
+      {
+        name: "message",
+        alias: "m",
+        description: 'Single-turn: send one message and exit. With --call: the "why I am calling" anchor for the opening self-introduction.'
+      },
       { name: "chat-id", description: "Resume an existing chat by numeric ID" },
       { name: "vad", description: "Voice activity detection: server (default) or client" },
       { name: "list-devices", description: "List audio devices and exit", isFlag: true },
@@ -44261,48 +46288,51 @@ function registerSpecialCommands(registry) {
     handler: async (hctx) => {
       await conciergeCommand(hctx);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["dev", "import-local"],
     description: "Import remote workspace locally",
     requiresWorkspace: true,
     handler: async ({ ctx, workspace }) => {
       await devImportLocalCommand(requireAuth(ctx), workspace);
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["whoami"],
     description: "Show current user info",
     handler: async ({ ctx }) => {
       await whoamiCommand(requireAuth(ctx));
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["organizations", "list"],
     description: "List organizations",
     handler: async ({ ctx }) => {
       await organizationsListCommand(requireAuth(ctx));
     }
-  });
-  registry.registerCommand({
+  },
+  {
     path: ["orgs", "list"],
     description: "List organizations",
     handler: async ({ ctx }) => {
       await organizationsListCommand(requireAuth(ctx));
     }
-  });
-}
+  }
+];
+
+// src/lib.ts
+init_concierge_api();
 
 // package.json
 var package_default = {
-  version: "0.7.2"};
+  version: "0.8.0"};
 
 // src/gr.ts
 var VERSION = package_default.version;
 function createRegistry() {
   const registry = new CommandRegistry();
   registerPublicDomains(registry);
-  registerSpecialCommands(registry);
+  registry.registerCommands(topLevelCommands);
   return registry;
 }
 function parseGlobalOptions(argv) {
@@ -44409,7 +46439,8 @@ async function main() {
       workspace: ""
     };
   }
-  if (cmd.mutates && !opts.allowWrite) {
+  const inSandbox = process.env.GRAVITY_RAIL_SANDBOX === "1";
+  if (cmd.mutates && !opts.allowWrite && !inSandbox) {
     process.stderr.write(
       `Error: "${commandWords.join(" ")}" is a write operation. Pass --allow-write to execute.
 `