@gravity-rail/cli 0.7.2 → 0.7.3

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 { 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-YCASSXLL.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,7 @@ 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);
 }
 function bindTasksMethods(target, tasks, abilities) {
   target.getTasks = tasks.getTasks.bind(tasks);
@@ -2904,6 +2970,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 +2979,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 +3206,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);
@@ -3642,6 +3711,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 +3784,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_YCASSXLL = __esm({
+  "../sdk/dist/chunk-YCASSXLL.js"() {
     init_libphonenumber_js();
     ApiError = class extends Error {
       statusCode;
@@ -4285,6 +4358,13 @@ ${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);
+        params.append("taskId", options.taskId.toString());
+        return this.fetch(`w/${wid}/agents/${id}/resolve-tools?${params}`);
+      }
     };
     AIModelsApi = class extends BaseApiClient {
       /**
@@ -5187,6 +5267,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 +5798,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 +6693,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}`, {
@@ -9828,6 +9951,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.
        *
@@ -10795,6 +10948,696 @@ ${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",
+      "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",
+      "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",
+      "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",
+      "listAppConnections",
+      "listAvailableAppConnections",
+      "listConfluencePages",
+      "listConfluenceSpaces",
+      "listConnectionMemberFieldKeys",
+      "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",
+      "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;
@@ -10855,6 +11698,7 @@ ${formattedErrors}`, response.status);
       deleteChatFilter;
       getChatFilterCount;
       // Calls API
+      getPhoneCalls;
       initiateCall;
       getVoiceToken;
       getMessageTiming;
@@ -10862,6 +11706,7 @@ ${formattedErrors}`, response.status);
       // Data Types API
       getDataTypes;
       getDataType;
+      getDataTypeByUuid;
       getDataTypeBySlug;
       createDataType;
       updateDataType;
@@ -10946,6 +11791,7 @@ ${formattedErrors}`, response.status);
       deleteAgent;
       archiveAgent;
       unarchiveAgent;
+      resolveAgentTools;
       // Qualifications API
       getQualifications;
       getQualification;
@@ -10988,6 +11834,10 @@ ${formattedErrors}`, response.status);
       reenrollMember;
       deleteEnrollment;
       getMemberJourneys;
+      getStepMembers;
+      getStepMemberCounts;
+      advanceStep;
+      skipStep;
       testRunJourney;
       getJourneyNotes;
       createJourneyNote;
@@ -11203,6 +12053,7 @@ ${formattedErrors}`, response.status);
       getFiles;
       getFile;
       createFile;
+      uploadFile;
       updateFile;
       deleteFile;
       convertFile;
@@ -11738,6 +12589,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 +12715,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_YCASSXLL();
     init_chunk_QS6ZRQUZ();
+    SEARCHABLE_EVENT_RULE_SOURCE_FIELDS = [
+      "taskId",
+      "dataTypeId",
+      "routineId",
+      "workflowId",
+      "journeyStepId"
+    ];
+    [
+      ...SEARCHABLE_EVENT_RULE_SOURCE_FIELDS,
+      "calendarId",
+      "calendarEventTypeId"
+    ];
   }
 });
 function detectWorktreePorts() {
@@ -11865,7 +12743,7 @@ function detectWorktreePorts() {
       overridePath = candidate;
       break;
     }
-    const parent = dirname(dir);
+    const parent = dirname$1(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -12468,46 +13346,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 +17450,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 +17726,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 +17741,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 +18799,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 +28048,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 +28140,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 +30128,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 +30147,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 +30218,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 +30240,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 +30270,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;
@@ -31164,32 +32002,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;
@@ -31410,7 +32247,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 +32721,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 +32758,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 +32795,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 +32831,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 +32846,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) {
@@ -32195,7 +33053,21 @@ var agentTasksDomain = {
 
 // src/domains/agents.ts
 init_output();
+init_context();
 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) }
+];
+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",
@@ -32212,7 +33084,37 @@ var agentsDomain = {
       unarchiveMethod: "unarchiveAgent",
       columns: COLUMNS,
       paginationSupport: "full"
-    })
+    }),
+    {
+      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.",
+      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: "Task ID whose workflow abilities to resolve",
+          required: true
+        }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        const result2 = await requireAuth(ctx).apiClient.resolveAgentTools(
+          workspace,
+          requireNumber(args, "id"),
+          {
+            channel: normalizeChannel(String(args.channel)),
+            taskId: requireNumber(args, "task-id")
+          }
+        );
+        const tools = result2.tools ?? result2;
+        outputData(Array.isArray(tools) ? tools : [tools], ctx, TOOL_COLUMNS);
+      }
+    }
   ]
 };
 
@@ -33985,7 +34887,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 +34995,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);
       }
     }
   ]
@@ -36530,6 +37432,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 }) => {
@@ -37139,7 +38042,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 +38100,7 @@ var customToolkitsDomain = {
           toolkitId,
           data
         );
-        outputSingle(result2, ctx, TOOL_COLUMNS2);
+        outputSingle(result2, ctx, TOOL_COLUMNS3);
       }
     },
     {
@@ -37219,7 +38122,7 @@ var customToolkitsDomain = {
           toolId,
           data
         );
-        outputSingle(result2, ctx, TOOL_COLUMNS2);
+        outputSingle(result2, ctx, TOOL_COLUMNS3);
       }
     },
     {
@@ -38459,6 +39362,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 +39532,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 +39574,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 {
@@ -38756,7 +39730,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 +39777,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 +39854,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 +40029,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 +40078,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 +40125,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 +40188,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);
       }
     },
@@ -41480,9 +42518,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 +42562,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,13 +42875,19 @@ 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"
@@ -42116,6 +43156,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 +43202,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 +43212,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 +43241,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 +43257,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 +43301,7 @@ var ChatTUI = class {
   streamStart() {
     this.isStreaming = true;
     this.streamContent = "";
+    this.runState = "streaming";
     this.scrollOffset = 0;
     this.dirty();
   }
@@ -42251,8 +43317,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 +43405,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 +43463,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 +43481,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 +43572,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 +43658,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 +43699,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 +43741,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 +43774,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 +43850,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 +43881,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 +43904,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 +43964,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 hint = this.runState === "tool_running" && this.activeToolName ? `Running ${this.activeToolName}\u2026` : "Thinking\u2026";
+        lines.push(`${label}${YELLOW}${hint}${RESET}`);
+      } else {
+        lines.push(label);
+      }
       return;
     }
     let first = true;
@@ -42884,6 +44086,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() {
@@ -43254,6 +44508,7 @@ async function singleTurnChatSession(session, message, debug, autoApprove = fals
     {
       autoApprove,
       allowWrite: allowWrite || !!session.allowWrite,
+      debug,
       trustCwd: session.trustCwd,
       trustDir: session.trustDir,
       nonInteractive: true
@@ -43303,99 +44558,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 +44704,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 +44769,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,7 +44864,164 @@ 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;
@@ -43726,6 +45120,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 +45277,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 +45296,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 +45326,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 +45354,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 +45389,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 +45416,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 +45435,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 +45447,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 +45460,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 +45471,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,
@@ -44261,48 +45515,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.7.3"};
 
 // 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 +45666,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.
 `