@gravity-rail/cli 0.6.0 → 0.7.1

package/dist/lib.js

@@ -305,6 +305,25 @@ var AdminApi = class extends BaseApiClient {
       method: "POST"
     });
   }
+  // Proactive Support: outbound (us→customer) requests + resources
+  async createOutboundSupportRequestAsAdmin(data) {
+    return this.fetch("admin/support-requests/outbound", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async attachSupportRequestResourceAsAdmin(uuid, data) {
+    return this.fetch(`admin/support-requests/${uuid}/resources`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async revokeSupportRequestResourceAsAdmin(uuid, resourceUuid) {
+    return this.fetch(
+      `admin/support-requests/${uuid}/resources/${resourceUuid}/revoke`,
+      { method: "POST" }
+    );
+  }
   // Admin Accounts API
   async getAccounts(options) {
     const params = new URLSearchParams();
@@ -318,6 +337,8 @@ var AdminApi = class extends BaseApiClient {
     if (options.isActive !== void 0) params.append("isActive", options.isActive.toString());
     if (options.organizationId !== void 0)
       params.append("organizationId", options.organizationId.toString());
+    if (options.workspaceId !== void 0)
+      params.append("workspaceId", options.workspaceId.toString());
     if (options.pendingDeletion !== void 0)
       params.append("pendingDeletion", options.pendingDeletion.toString());
     return this.fetch(`admin/accounts?${params.toString()}`);
@@ -1431,6 +1452,45 @@ var AdminApi = class extends BaseApiClient {
       `admin/temporal/workflows/${encoded}${qs ? `?${qs}` : ""}`
     );
   }
+  // ── Customer activity events (cross-workspace operator feed) ──────────────
+  async listCustomerActivityEvents(params = {}) {
+    const qs = new URLSearchParams();
+    if (params.page) qs.set("page", String(params.page));
+    if (params.pageSize) qs.set("pageSize", String(params.pageSize));
+    if (params.status) qs.set("status", params.status);
+    if (params.subjectType) qs.set("subjectType", params.subjectType);
+    if (params.source) qs.set("source", params.source);
+    if (params.severity) qs.set("severity", params.severity);
+    if (params.disposition) qs.set("disposition", params.disposition);
+    if (params.workspaceId !== void 0) qs.set("workspaceId", String(params.workspaceId));
+    if (params.organizationId !== void 0)
+      qs.set("organizationId", String(params.organizationId));
+    if (params.accountId !== void 0) qs.set("accountId", String(params.accountId));
+    const query = qs.toString();
+    return this.fetch(
+      `admin/customer-activity${query ? `?${query}` : ""}`
+    );
+  }
+  async getCustomerActivityEvent(uuid) {
+    return this.fetch(`admin/customer-activity/${uuid}`);
+  }
+  async setCustomerActivityEventDisposition(uuid, data) {
+    return this.fetch(`admin/customer-activity/${uuid}/disposition`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async setCustomerActivityEventStatus(uuid, data) {
+    return this.fetch(`admin/customer-activity/${uuid}/status`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async reclassifyCustomerActivityEvent(uuid) {
+    return this.fetch(`admin/customer-activity/${uuid}/reclassify`, {
+      method: "POST"
+    });
+  }
 };
 function appendTemporalWorkspaceParams(params, options) {
   const seen = /* @__PURE__ */ new Set();
@@ -1454,6 +1514,14 @@ function bindAdminMethods(target, admin) {
   target.updateSupportRequestStatusAsAdmin = admin.updateSupportRequestStatusAsAdmin.bind(admin);
   target.updateSupportRequestAttributesAsAdmin = admin.updateSupportRequestAttributesAsAdmin.bind(admin);
   target.createSupportRequestLinearIssueAsAdmin = admin.createSupportRequestLinearIssueAsAdmin.bind(admin);
+  target.createOutboundSupportRequestAsAdmin = admin.createOutboundSupportRequestAsAdmin.bind(admin);
+  target.attachSupportRequestResourceAsAdmin = admin.attachSupportRequestResourceAsAdmin.bind(admin);
+  target.revokeSupportRequestResourceAsAdmin = admin.revokeSupportRequestResourceAsAdmin.bind(admin);
+  target.listCustomerActivityEvents = admin.listCustomerActivityEvents.bind(admin);
+  target.getCustomerActivityEvent = admin.getCustomerActivityEvent.bind(admin);
+  target.setCustomerActivityEventDisposition = admin.setCustomerActivityEventDisposition.bind(admin);
+  target.setCustomerActivityEventStatus = admin.setCustomerActivityEventStatus.bind(admin);
+  target.reclassifyCustomerActivityEvent = admin.reclassifyCustomerActivityEvent.bind(admin);
   target.getAccounts = admin.getAccounts.bind(admin);
   target.getAccountDetails = admin.getAccountDetails.bind(admin);
   target.getAccountByUuid = admin.getAccountByUuid.bind(admin);
@@ -1626,6 +1694,14 @@ var ApiClient = class extends GravityRailClient {
   updateSupportRequestStatusAsAdmin;
   updateSupportRequestAttributesAsAdmin;
   createSupportRequestLinearIssueAsAdmin;
+  createOutboundSupportRequestAsAdmin;
+  attachSupportRequestResourceAsAdmin;
+  revokeSupportRequestResourceAsAdmin;
+  listCustomerActivityEvents;
+  getCustomerActivityEvent;
+  setCustomerActivityEventDisposition;
+  setCustomerActivityEventStatus;
+  reclassifyCustomerActivityEvent;
   getAccounts;
   getAccountDetails;
   getAccountByUuid;
@@ -2101,9 +2177,78 @@ This workspace requires organization SSO authentication.`);
   });
 }
 
+// src/lib/pinned-fetch.ts
+import { Agent, fetch as undiciFetch } from "undici";
+function createPinnedFetch(apiUrl, apiIp) {
+  if (!apiIp) return fetch;
+  let parsed;
+  try {
+    parsed = new URL(apiUrl);
+  } catch {
+    return fetch;
+  }
+  const hostname = parsed.hostname;
+  const dispatcher = new Agent({
+    connect: {
+      servername: hostname
+    }
+  });
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    let reqUrl;
+    try {
+      reqUrl = new URL(url, apiUrl);
+    } catch {
+      return fetch(input, init);
+    }
+    const headers2 = new Headers(init?.headers);
+    if (reqUrl.hostname === hostname) {
+      headers2.set("Host", hostname);
+      reqUrl = new URL(reqUrl.href);
+      reqUrl.hostname = apiIp;
+    }
+    return undiciFetch(reqUrl, {
+      ...init,
+      headers: headers2,
+      dispatcher
+    });
+  };
+}
+function withAuditHeaders(fetchFn, headers2) {
+  const { chatId, sessionId, toolCallId } = headers2;
+  if (chatId === void 0 && !sessionId && !toolCallId) {
+    return fetchFn;
+  }
+  return async (input, init) => {
+    const reqHeaders = new Headers(init?.headers);
+    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);
+    }
+    return fetchFn(input, { ...init, headers: reqHeaders });
+  };
+}
+function createSandboxFetchFromEnv(apiUrl) {
+  const apiIp = process.env.GRAVITY_RAIL_API_IP;
+  let fetchFn = createPinnedFetch(apiUrl, apiIp);
+  const chatIdRaw = process.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
+  });
+}
+
 // src/lib/context.ts
 function makeApiClient(accessToken, apiUrl) {
-  const apiClient = new ApiClient(accessToken, apiUrl);
+  const fetchFn = createSandboxFetchFromEnv(apiUrl);
+  const apiClient = new ApiClient(accessToken, apiUrl, fetchFn);
   registerOrgAuthHandler(apiClient, apiUrl, accessToken);
   return apiClient;
 }
@@ -2120,7 +2265,9 @@ async function tryTokenRefresh(ctx, creds) {
   return { ...ctx, accessToken: refreshed.accessToken, apiClient };
 }
 function createContext(opts) {
-  const envConfig = getEnvironmentConfig(opts.env);
+  const baseConfig = getEnvironmentConfig(opts.env);
+  const apiUrl = opts.apiUrl || process.env.GRAVITY_RAIL_API_URL || baseConfig.apiUrl;
+  const envConfig = apiUrl === baseConfig.apiUrl ? baseConfig : { ...baseConfig, apiUrl };
   const credentialsManager = new CredentialsManager(homedir(), envConfig.apiUrl);
   return {
     env: opts.env,
@@ -2206,6 +2353,40 @@ async function createPublicAuthenticatedContext(opts) {
 
 // src/lib/input.ts
 import { readFileSync as readFileSync2 } from "fs";
+var JSON_BODY_ACTIONS = /* @__PURE__ */ new Set([
+  "create",
+  "update",
+  "import",
+  "enroll",
+  "unenroll",
+  "reenroll",
+  "advance",
+  "skip",
+  "send",
+  "review",
+  "submit-answer",
+  "start-scenario",
+  "update-status"
+]);
+function commandNeedsJsonBody(cmd, parsedArgs) {
+  if (parsedArgs.data !== void 0 || parsedArgs.file !== void 0) {
+    return true;
+  }
+  if (cmd.args?.some((a) => a.name === "data" || a.name === "file")) {
+    return true;
+  }
+  if (!cmd.mutates) {
+    return false;
+  }
+  const action = cmd.path[cmd.path.length - 1] ?? "";
+  if (JSON_BODY_ACTIONS.has(action)) {
+    return true;
+  }
+  if (action === "send" || action === "cancel" && cmd.path.length > 1) {
+    return true;
+  }
+  return false;
+}
 async function readJsonInput(args) {
   const dataStr = args.data;
   const filePath = args.file;
@@ -2236,18 +2417,18 @@ function readStdinIfPiped() {
   return new Promise((resolve, reject) => {
     let data = "";
     let settled = false;
-    const finish = (value) => {
+    const finish2 = (value) => {
       if (settled) return;
       settled = true;
       resolve(value);
     };
     const flush = () => {
       if (!data.trim()) {
-        finish(void 0);
+        finish2(void 0);
         return;
       }
       try {
-        finish(JSON.parse(data));
+        finish2(JSON.parse(data));
       } catch {
         reject(new CLIError("Invalid JSON from stdin"));
       }
@@ -2267,11 +2448,104 @@ function readStdinIfPiped() {
         flush();
         return;
       }
-      finish(void 0);
+      finish2(void 0);
     });
   });
 }
 
+// src/lib/phone-voice.ts
+var FAILED_TERMINATION_REASONS = /* @__PURE__ */ new Set([
+  "failed",
+  "busy",
+  "no-answer",
+  "canceled",
+  "timeout",
+  "error"
+]);
+var SEED_PHONE_PATTERN = /^\+1212555010\d$/;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function latestOutboundCall(calls) {
+  return calls.filter((c) => !c.inbound).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
+}
+function isTerminalFailure(call) {
+  if (call.status === "ERROR") {
+    return true;
+  }
+  const reason = call.terminationReason ?? "";
+  return FAILED_TERMINATION_REASONS.has(reason);
+}
+function formatOutboundCallFailure(call, memberId) {
+  const reason = call.terminationReason ?? call.status;
+  const lines = [`Outbound call failed (phoneCallId=${call.id}, terminationReason=${reason}).`];
+  if (reason === "failed") {
+    lines.push(
+      "Twilio rejected the dial \u2014 common causes: invalid/unverified callee number, trial account restrictions, or unreachable DEV_TUNNEL_URL for the answer URL."
+    );
+  }
+  lines.push(
+    `Update the callee phone: gr members update --id ${memberId} --data '{"phone":"+1YOUR_MOBILE"}' --allow-write`
+  );
+  return lines.join("\n");
+}
+function isLikelySeedPhoneNumber(phone) {
+  return SEED_PHONE_PATTERN.test(phone);
+}
+async function waitForOutboundPhoneCallOutcome(client, workspaceUuid, chatId, memberId, options) {
+  const timeoutMs = options?.timeoutMs ?? 2e4;
+  const intervalMs = options?.intervalMs ?? 500;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const calls2 = await client.getChatPhoneCalls(workspaceUuid, chatId);
+    const outbound2 = latestOutboundCall(calls2);
+    if (!outbound2) {
+      await sleep(intervalMs);
+      continue;
+    }
+    if (isTerminalFailure(outbound2)) {
+      throw new CLIError(formatOutboundCallFailure(outbound2, memberId));
+    }
+    if (outbound2.status === "STARTED") {
+      return outbound2;
+    }
+    if (outbound2.status === "FINISHED") {
+      return outbound2;
+    }
+    await sleep(intervalMs);
+  }
+  const calls = await client.getChatPhoneCalls(workspaceUuid, chatId);
+  const outbound = latestOutboundCall(calls);
+  if (!outbound) {
+    throw new CLIError(
+      `Outbound call was not initiated for chat ${chatId}. Check API logs, DEV_TUNNEL_URL, and that ngrok points at https://api.gravityrail.test:5054.`
+    );
+  }
+  if (isTerminalFailure(outbound)) {
+    throw new CLIError(formatOutboundCallFailure(outbound, memberId));
+  }
+  throw new CLIError(
+    `Timed out after ${timeoutMs / 1e3}s waiting for outbound call result (phoneCallId=${outbound.id}, status=${outbound.status}). The call may still be ringing \u2014 check Twilio console or gr chats phone-calls.`
+  );
+}
+async function resolveVoicePhoneNumberId(client, workspaceUuid, explicitId) {
+  if (explicitId !== void 0) {
+    return explicitId;
+  }
+  const defaults = await client.getWorkspaceDefaults(workspaceUuid);
+  if (defaults.defaultPhoneNumberId) {
+    return defaults.defaultPhoneNumberId;
+  }
+  const numbers = await client.getPhoneNumbers(workspaceUuid);
+  const voiceLine = numbers.find((n) => n.enableVoice !== false && !n.isArchived);
+  if (!voiceLine) {
+    throw new CLIError(
+      "No voice-enabled phone number in workspace \u2014 run: yarn dev:twilio-ngrok dev.<you> -w <slug> or pass --phone-number-id"
+    );
+  }
+  return voiceLine.id;
+}
+
 // src/lib/crud.ts
 function crudCommands(config) {
   const {
@@ -2379,6 +2653,7 @@ function crudCommands(config) {
       mutates: true,
       args: [{ name: "id", description: `${entityName} ID`, required: true }],
       requiresWorkspace,
+      ...config.updateExamples ? { examples: config.updateExamples } : {},
       handler: async (hctx) => {
         if (!hctx.data) throw new CLIError("JSON data required (--data, --file, or stdin)");
         const id = resolveId(hctx);
@@ -2801,11 +3076,13 @@ var CommandRegistry = class {
     const lines = [`${cmd.description}
 `, `Usage: gr ${cmdStr} [options]`];
     if (cmd.requiresWorkspace) {
-      lines.push("  Requires: -w <workspace-uuid>");
+      lines.push("  Requires: -w <workspace-uuid>  (or --realm <workspace>/<member> in dev)");
     }
     if (cmd.mutates) {
       lines.push("  Requires: --allow-write");
     }
+    const action = cmd.path[cmd.path.length - 1] ?? "";
+    const showsJsonHints = action === "create" || action === "update" || cmd.args?.some((a) => a.name === "data" || a.name === "file");
     if (cmd.args && cmd.args.length > 0) {
       lines.push("", "Arguments:");
       for (const arg of cmd.args) {
@@ -2814,6 +3091,12 @@ var CommandRegistry = class {
         lines.push(`  ${flag.padEnd(28)} ${arg.description}${req}`);
       }
     }
+    if (showsJsonHints) {
+      lines.push("", "JSON body (one of):");
+      lines.push("  -d, --data <json>           Inline JSON");
+      lines.push("  -f, --file <path>           JSON file");
+      lines.push("  stdin                       Pipe JSON when not a TTY");
+    }
     if (cmd.examples && cmd.examples.length > 0) {
       lines.push("", "Examples:");
       for (const ex of cmd.examples) {
@@ -2822,6 +3105,14 @@ var CommandRegistry = class {
     }
     return lines.join("\n") + "\n";
   }
+  /** All registered domains (for docs generation and introspection). */
+  getDomains() {
+    return this.domains;
+  }
+  /** All registered commands (for docs generation and introspection). */
+  getAllCommands() {
+    return [...this.commands.values()];
+  }
   getTopLevelHelp() {
     const lines = ["Usage: gr <command> [options]\n", "Commands:"];
     const seen = /* @__PURE__ */ new Set();
@@ -2842,6 +3133,12 @@ var CommandRegistry = class {
       "",
       "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",
+      "  -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",
       "  -o, --output-format <fmt> Output format: json, jsonl, table (default: auto)",
       "  -v, --verbose             Verbose output to stderr",
       "  --help                    Show help",
@@ -3368,7 +3665,11 @@ var membersDomain = {
       deleteMethod: "deleteMember",
       archiveMethod: "archiveMember",
       unarchiveMethod: "unarchiveMember",
-      columns: COLUMNS3
+      columns: COLUMNS3,
+      updateExamples: [
+        `yarn gr members update -w $UUID --id 2 --data '{"phone":"+15551234567"}' --allow-write`,
+        "yarn gr members update --realm acme-demo/acme-admin --id 2 --file /tmp/member.json --allow-write"
+      ]
     }),
     // Current member
     {
@@ -3522,6 +3823,31 @@ var membersDomain = {
   ]
 };
 
+// src/domains/member-roles.ts
+var ROLE_COLUMNS2 = [
+  { header: "ID", getValue: (item) => String(item.id ?? "") },
+  { header: "NAME", getValue: (item) => item.name ?? "" },
+  { header: "DESCRIPTION", getValue: (item) => String(item.description ?? "").slice(0, 40) }
+];
+var memberRolesDomain = {
+  name: "member-roles",
+  description: "Workspace member roles (alias for gr members roles). Use when resolving anonymousMemberRoleId / signupMemberRoleId.",
+  commands: crudCommands({
+    prefix: ["member-roles"],
+    entityName: "member role",
+    listMethod: "getMemberRoles",
+    getMethod: "getMemberRole",
+    createMethod: "createMemberRole",
+    updateMethod: "updateMemberRole",
+    deleteMethod: "deleteMemberRole",
+    columns: ROLE_COLUMNS2,
+    createExamples: [
+      "gr member-roles list -w $WID",
+      "gr member-roles get -w $WID --id 2"
+    ]
+  })
+};
+
 // src/domains/tasks.ts
 var COLUMNS4 = [
   COL.id(),
@@ -4188,8 +4514,18 @@ var workspacesDomain = {
             `organizationId is required in --data (e.g. --data '{"organizationId": 1, "name": "My Workspace"}')`
           );
         }
-        const result = await requireAuth(ctx).apiClient.createWorkspace(payload);
-        outputSingle(result, ctx, COLUMNS7);
+        try {
+          const result = await requireAuth(ctx).apiClient.createWorkspace(payload);
+          outputSingle(result, ctx, COLUMNS7);
+        } catch (err) {
+          const statusCode = err?.statusCode;
+          if (statusCode === 405) {
+            throw new CLIError(
+              'Creating a workspace directly is not supported \u2014 provisioning runs through the concierge (it handles product selection and billing).\nNext: gr concierge chat --allow-write --message "Create a new workspace"\nThen: gr workspaces list  (to get the new workspace UUID for -w)'
+            );
+          }
+          throw err;
+        }
       }
     },
     // Defaults
@@ -5226,11 +5562,14 @@ var RULE_COLUMNS = [
   { header: "EVENT", getValue: (item) => item.eventType ?? "" },
   { header: "ACTIVE", getValue: (item) => String(item.active ?? "") }
 ];
-var EVENT_COLUMNS2 = [
+var ROUTINE_COLUMNS = [
   COL.id(),
   COL.name(),
-  { header: "SLUG", getValue: (item) => item.slug ?? "" },
-  COL.status()
+  { header: "MODE", getValue: (item) => item.scheduleMode ?? "" },
+  { header: "CRON", getValue: (item) => item.cronString ?? "" },
+  { header: "TZ", getValue: (item) => item.timezone ?? "UTC" },
+  { header: "ENABLED", getValue: (item) => String(item.scheduleEnabled ?? "") },
+  { header: "NEXT RUN", getValue: (item) => item.nextRun ?? "" }
 ];
 var eventRulesCrudNoList = crudCommands({
   prefix: ["events", "rules"],
@@ -5399,7 +5738,15 @@ var eventsDomain = {
       updateMethod: "updateRoutine",
       deleteMethod: "deleteRoutine",
       paginationSupport: "full",
-      columns: EVENT_COLUMNS2
+      columns: ROUTINE_COLUMNS,
+      createExamples: [
+        "Daily 7am check-in in the member\u2019s timezone (cron is interpreted in `timezone`):",
+        `gr routines create -w $WID --allow-write --data '{"name":"AM check-in",`,
+        '  "scheduleEnabled":true,"scheduleMode":"CRON","cronString":"0 7 * * *",',
+        `  "timezone":"America/Los_Angeles","targetMemberId":1,"workflowId":2}'`,
+        "  (timezone is an IANA name; omit it to default to the workspace timezone, else UTC.",
+        '   Without it, "0 7 * * *" fires at 07:00 UTC, not 7am local.)'
+      ]
     }),
     {
       path: ["routines", "run"],
@@ -5446,6 +5793,232 @@ var eventsDomain = {
   ]
 };
 
+// src/domains/experiments.ts
+var EXPERIMENT_COLUMNS = [
+  COL.id(),
+  { header: "UUID", getValue: (item) => (item.uuid ?? "").slice(0, 8) },
+  { header: "SLUG", getValue: (item) => item.slug ?? "" },
+  COL.name(),
+  COL.status(),
+  {
+    header: "ASSIGNED",
+    getValue: (item) => item.assignmentCount != null ? String(item.assignmentCount) : "0"
+  },
+  COL.created()
+];
+var GROUP_COLUMNS = [
+  COL.id(),
+  { header: "SLUG", getValue: (item) => item.slug ?? "" },
+  COL.name(),
+  {
+    header: "WEIGHT",
+    getValue: (item) => item.allocationWeight != null ? String(item.allocationWeight) : ""
+  },
+  {
+    header: "CONTROL",
+    getValue: (item) => item.isControl ? "yes" : ""
+  },
+  { header: "ORDER", getValue: (item) => String(item.order ?? "") }
+];
+var STATS_COLUMNS = [
+  { header: "GROUP_ID", getValue: (item) => String(item.groupId ?? "") },
+  { header: "SLUG", getValue: (item) => item.groupSlug ?? "" },
+  { header: "NAME", getValue: (item) => item.groupName ?? "" },
+  {
+    header: "CONTROL",
+    getValue: (item) => item.isControl ? "yes" : ""
+  },
+  {
+    header: "ASSIGNED",
+    getValue: (item) => item.assignedCount != null ? String(item.assignedCount) : "0"
+  },
+  {
+    header: "EXPOSED",
+    getValue: (item) => item.exposedCount != null ? String(item.exposedCount) : "0"
+  }
+];
+var MEMBER_ASSIGNMENT_COLUMNS = [
+  COL.id(),
+  {
+    header: "EXPERIMENT",
+    getValue: (item) => item.experimentSlug ?? String(item.experimentId ?? "")
+  },
+  {
+    header: "GROUP",
+    getValue: (item) => item.groupSlug ?? String(item.groupId ?? "")
+  },
+  { header: "ASSIGNED", getValue: (item) => item.assignedAt ?? "" },
+  { header: "SOURCE", getValue: (item) => item.assignmentSource ?? "" }
+];
+var experimentsDomain = {
+  name: "experiments",
+  description: "Manage member A/B experiments, groups, and reporting",
+  commands: [
+    {
+      path: ["experiments", "list"],
+      description: "List experiments",
+      requiresWorkspace: true,
+      args: [
+        ...LIST_PAGINATION_ARGS,
+        {
+          name: "include-archived",
+          description: "Include archived experiments",
+          required: false
+        }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        const includeArchived = args["include-archived"] === "true";
+        const pag = parsePaginationArgs(args);
+        const result = await requireAuth(ctx).apiClient.getExperiments(workspace, {
+          ...pag.page ? { page: pag.page } : {},
+          ...pag.pageSize ? { pageSize: pag.pageSize } : {},
+          includeArchived
+        });
+        outputData(listResult(result, true), ctx, EXPERIMENT_COLUMNS);
+      }
+    },
+    {
+      path: ["experiments", "get"],
+      description: "Get an experiment by ID",
+      requiresWorkspace: true,
+      args: [{ name: "id", description: "Experiment ID", required: true }],
+      handler: async ({ ctx, workspace, args }) => {
+        const result = await requireAuth(ctx).apiClient.getExperiment(
+          workspace,
+          requireNumber(args, "id")
+        );
+        outputSingle(result, ctx);
+      }
+    },
+    {
+      path: ["experiments", "create"],
+      description: "Create a draft experiment (pass JSON via --data)",
+      mutates: true,
+      requiresWorkspace: true,
+      handler: async ({ ctx, workspace, data }) => {
+        if (!data) throw new CLIError("JSON data required (--data, --file, or stdin)");
+        const result = await requireAuth(ctx).apiClient.createExperiment(
+          workspace,
+          data
+        );
+        outputSingle(result, ctx, EXPERIMENT_COLUMNS);
+      }
+    },
+    {
+      path: ["experiments", "update"],
+      description: "Update an experiment (pass JSON via --data)",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [{ name: "id", description: "Experiment ID", required: true }],
+      handler: async ({ ctx, workspace, args, data }) => {
+        if (!data) throw new CLIError("JSON data required (--data, --file, or stdin)");
+        const result = await requireAuth(ctx).apiClient.updateExperiment(
+          workspace,
+          requireNumber(args, "id"),
+          data
+        );
+        outputSingle(result, ctx, EXPERIMENT_COLUMNS);
+      }
+    },
+    {
+      path: ["experiments", "delete"],
+      description: "Delete a draft experiment or archive a running one",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [{ name: "id", description: "Experiment ID", required: true }],
+      handler: async ({ ctx, workspace, args }) => {
+        const result = await requireAuth(ctx).apiClient.deleteExperiment(
+          workspace,
+          requireNumber(args, "id")
+        );
+        process.stdout.write(`${result.status} experiment ${args["id"]}
+`);
+      }
+    },
+    {
+      path: ["experiments", "stats"],
+      description: "Get assignment and exposure counts by group",
+      requiresWorkspace: true,
+      args: [{ name: "id", description: "Experiment ID", required: true }],
+      handler: async ({ ctx, workspace, args }) => {
+        const result = await requireAuth(ctx).apiClient.getExperimentStats(
+          workspace,
+          requireNumber(args, "id")
+        );
+        outputData(result.groups, ctx, STATS_COLUMNS);
+      }
+    },
+    {
+      path: ["experiments", "groups", "create"],
+      description: "Create a group on an experiment (pass JSON via --data)",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [{ name: "experiment-id", description: "Experiment ID", required: true }],
+      handler: async ({ ctx, workspace, args, data }) => {
+        if (!data) throw new CLIError("JSON data required (--data, --file, or stdin)");
+        const result = await requireAuth(ctx).apiClient.createExperimentGroup(
+          workspace,
+          requireNumber(args, "experiment-id"),
+          data
+        );
+        outputSingle(result, ctx, GROUP_COLUMNS);
+      }
+    },
+    {
+      path: ["experiments", "groups", "update"],
+      description: "Update a group (pass JSON via --data)",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "experiment-id", description: "Experiment ID", required: true },
+        { name: "group-id", description: "Group ID", required: true }
+      ],
+      handler: async ({ ctx, workspace, args, data }) => {
+        if (!data) throw new CLIError("JSON data required (--data, --file, or stdin)");
+        const result = await requireAuth(ctx).apiClient.updateExperimentGroup(
+          workspace,
+          requireNumber(args, "experiment-id"),
+          requireNumber(args, "group-id"),
+          data
+        );
+        outputSingle(result, ctx, GROUP_COLUMNS);
+      }
+    },
+    {
+      path: ["experiments", "groups", "delete"],
+      description: "Delete a group with no member assignments",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "experiment-id", description: "Experiment ID", required: true },
+        { name: "group-id", description: "Group ID", required: true }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        await requireAuth(ctx).apiClient.deleteExperimentGroup(
+          workspace,
+          requireNumber(args, "experiment-id"),
+          requireNumber(args, "group-id")
+        );
+        process.stdout.write(`Deleted group ${args["group-id"]}
+`);
+      }
+    },
+    {
+      path: ["experiments", "members", "list"],
+      description: "List experiment assignments for a member",
+      requiresWorkspace: true,
+      args: [{ name: "member-id", description: "Member ID", required: true }],
+      handler: async ({ ctx, workspace, args }) => {
+        const result = await requireAuth(ctx).apiClient.getMemberExperiments(
+          workspace,
+          requireNumber(args, "member-id")
+        );
+        outputData(result, ctx, MEMBER_ASSIGNMENT_COLUMNS);
+      }
+    }
+  ]
+};
+
 // src/domains/files.ts
 var COLUMNS11 = [
   COL.id(),
@@ -7477,9 +8050,9 @@ function toCamelMessage(raw) {
     id: raw.id,
     role: raw.role,
     content: raw.content ?? "",
-    createdAt: raw.created_at ?? null,
-    toolCalls: raw.tool_calls ?? null,
-    toolCallId: raw.tool_call_id ?? null
+    createdAt: raw.createdAt ?? raw.created_at ?? null,
+    toolCalls: raw.toolCalls ?? raw.tool_calls ?? null,
+    toolCallId: raw.toolCallId ?? raw.tool_call_id ?? null
   };
 }
 async function listConciergeChats(ctx) {
@@ -7502,20 +8075,72 @@ async function getConciergeChat(ctx, chatId) {
   if (!res.ok) throw new Error(`Failed to get concierge chat ${chatId}: ${res.status}`);
   return toCamelChat(await res.json());
 }
-async function getConciergeChatMessages(ctx, chatId) {
-  const res = await fetch(`${baseUrl2(ctx)}/chats/${chatId}/messages`, {
-    headers: authHeaders(ctx)
+async function originateConciergeCall(ctx, kind = "concierge_setup") {
+  const res = await fetch(`${baseUrl2(ctx)}/calls`, {
+    method: "POST",
+    headers: authHeaders(ctx),
+    body: JSON.stringify({ kind })
   });
-  if (!res.ok)
-    throw new Error(`Failed to get concierge messages for chat ${chatId}: ${res.status}`);
-  const data = await res.json();
-  return data.map(toCamelMessage);
+  if (res.status === 412) {
+    throw new Error("Your account phone is not verified. Run `gr account verify-phone` first.");
+  }
+  if (!res.ok) {
+    const detail = await res.text();
+    throw new Error(`Failed to start concierge call: ${res.status} ${detail}`);
+  }
+  return await res.json();
 }
-
-// src/domains/concierge.ts
-var CHAT_COLUMNS = [
-  COL.id(),
-  COL.uuid(),
+async function originateConciergeSms(ctx, kind = "concierge_setup") {
+  const res = await fetch(`${baseUrl2(ctx)}/sms`, {
+    method: "POST",
+    headers: authHeaders(ctx),
+    body: JSON.stringify({ kind })
+  });
+  if (res.status === 412) {
+    throw new Error("Your account phone is not verified. Run `gr account verify-phone` first.");
+  }
+  if (!res.ok) {
+    const detail = await res.text();
+    throw new Error(`Failed to start concierge SMS: ${res.status} ${detail}`);
+  }
+  return await res.json();
+}
+async function startAccountPhoneVerify(ctx, phone) {
+  const res = await fetch(`${ctx.envConfig.apiUrl}/api/v2/account/phone/verify/start`, {
+    method: "POST",
+    headers: authHeaders(ctx),
+    body: JSON.stringify({ phone })
+  });
+  if (!res.ok) {
+    const detail = await res.text();
+    throw new Error(`Failed to send verification code: ${res.status} ${detail}`);
+  }
+}
+async function confirmAccountPhoneVerify(ctx, code) {
+  const res = await fetch(`${ctx.envConfig.apiUrl}/api/v2/account/phone/verify/confirm`, {
+    method: "POST",
+    headers: authHeaders(ctx),
+    body: JSON.stringify({ code })
+  });
+  if (!res.ok) {
+    const detail = await res.text();
+    throw new Error(`Failed to confirm verification code: ${res.status} ${detail}`);
+  }
+}
+async function getConciergeChatMessages(ctx, chatId) {
+  const res = await fetch(`${baseUrl2(ctx)}/chats/${chatId}/messages`, {
+    headers: authHeaders(ctx)
+  });
+  if (!res.ok)
+    throw new Error(`Failed to get concierge messages for chat ${chatId}: ${res.status}`);
+  const data = await res.json();
+  return data.map(toCamelMessage);
+}
+
+// src/domains/concierge.ts
+var CHAT_COLUMNS = [
+  COL.id(),
+  COL.uuid(),
   { header: "TITLE", getValue: (c) => c.title ?? "" },
   { header: "UPDATED", getValue: (c) => c.updatedAt ?? "" }
 ];
@@ -8658,27 +9283,780 @@ var orgPhoneNumbersDomain = {
   commands: commands2
 };
 
+// src/lib/phone-numbers/defaults.ts
+var PHONE_NUMBER_CREATE_DEFAULTS = {
+  allowSignup: false,
+  allowAnonymous: false,
+  restartDelay: 900,
+  enableSms: true,
+  enableVoice: true,
+  assistantEnabled: true,
+  voiceUnavailableMessage: "This phone number is not available for voice calls right now. Please try again later or send a text message.",
+  smsUnavailableMessage: "This phone number is not available for text messages right now. Please try again later.",
+  anonymousRejectionMessage: "Hello. Unfortunately we could not find your phone number in our system. Goodbye.",
+  voicemailGreeting: "Please leave a message after the tone."
+};
+function mergePhoneNumberCreateDefaults(data) {
+  return { ...PHONE_NUMBER_CREATE_DEFAULTS, ...data };
+}
+
+// src/lib/phone-numbers/field-help.ts
+var PHONE_NUMBER_FIELD_REFERENCE = `
+Field reference for --data JSON (create/update):
+
+Identity & branding
+  name (string)                         Display label
+  brandName, brandDescription, brandWebsite (string, optional)
+
+Inbound routing (phone_numbers.defaultWorkflowId = INBOUND workflow)
+  defaultWorkflowId (number|null)       Workflow for inbound voice/SMS chats (required for voice)
+  allowSignup (bool, default false)     Unknown callers can start signup flow
+  signupMemberRoleId (number)           Required when allowSignup=true
+  allowAnonymous (bool, default false)  Unknown callers get anonymous member per call
+  anonymousMemberRoleId (number)        Required when allowAnonymous=true
+  restartDelay (number|null, default 900) Seconds before a new inbound conversation starts
+  restartPrompt (string|null)
+
+Channels
+  enableVoice (bool, default true)
+  enableSms (bool, default true)
+  enableWhatsApp (bool, default false)
+  assistantEnabled (bool, default true)
+
+Caller-facing messages
+  voiceUnavailableMessage (string)      Played when voice cannot be handled
+  voiceGreetingMessage (string)         Played before AI connects
+  anonymousRejectionMessage (string)  Unknown caller denied (TTS)
+  smsUnavailableMessage (string)
+  voicemailGreeting (string)
+
+Work modes (voiceWorkMode / smsWorkMode)
+  always_forward | forward_off_hours | always_message | message_off_hours | voicemail | voicemail_off_hours
+  voiceForwardNumber, smsForwardNumber, voiceOffHoursMessage, smsOffHoursMessage
+
+Provider link
+  providerPhoneUuid (string)            Org provider phone UUID \u2014 use gr phone-numbers link after org assign
+
+Constraints
+  allowAnonymous=true  \u2192 anonymousMemberRoleId required
+  allowSignup=true     \u2192 signupMemberRoleId required
+
+Outbound (different field on workflows, not this resource):
+  workflows.defaultPhoneNumberId = OUTBOUND origin for that workflow
+  Event rules may reference phoneNumberUUID (workspace phone uuid string)
+
+List roles: gr member-roles list -w $WID
+Provisioning: gr phone-numbers setup --help
+`.trim();
+
+// src/lib/phone-numbers/validation-hints.ts
+var HINT_RULES = [
+  {
+    pattern: /anonymousMemberRoleId.*required/i,
+    hint: "Fix: set anonymousMemberRoleId (gr member-roles list -w $WID) or set allowAnonymous=false."
+  },
+  {
+    pattern: /signupMemberRoleId/i,
+    hint: "Fix: set signupMemberRoleId from gr member-roles list -w $WID, or disable allowSignup."
+  },
+  {
+    pattern: /memberRoleAccess/i,
+    hint: "Fix: memberRoleAccess entries need { memberRoleId, accessMode }. List roles: gr member-roles list -w $WID"
+  },
+  {
+    pattern: /defaultWorkflowId/i,
+    hint: "Fix: defaultWorkflowId is the INBOUND workflow id (gr workflows list -w $WID). Outbound uses workflows.defaultPhoneNumberId."
+  },
+  {
+    pattern: /providerPhoneUuid|provider_phone/i,
+    hint: "Fix: link org number \u2014 gr org phone-numbers assign \u2026 then gr phone-numbers link --provider-phone-uuid <uuid> --allow-write"
+  }
+];
+function enrichPhoneNumberApiError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  const extra = [];
+  for (const rule of HINT_RULES) {
+    if (rule.pattern.test(message)) {
+      extra.push(rule.hint);
+    }
+  }
+  if ("errors" in err && Array.isArray(err.errors)) {
+    for (const e of err.errors) {
+      for (const rule of HINT_RULES) {
+        if (rule.pattern.test(e)) {
+          extra.push(rule.hint);
+        }
+      }
+    }
+  }
+  const unique = [...new Set(extra)];
+  const body = unique.length > 0 ? `${message}
+
+${unique.map((h) => `${h}`).join("\n")}` : message;
+  throw new CLIError(body);
+}
+
+// src/lib/phone-numbers/warnings.ts
+function collectPhoneNumberWarnings(phone) {
+  const warnings = [];
+  const enableVoice = phone.enableVoice === true;
+  const defaultWorkflowId = phone.defaultWorkflowId;
+  const isMapped = phone.isMapped === true;
+  const allowAnonymous = phone.allowAnonymous === true;
+  const anonymousMemberRoleId = phone.anonymousMemberRoleId;
+  if (!isMapped) {
+    warnings.push({
+      severity: "warn",
+      code: "not_mapped",
+      message: "Phone line is not linked to an org provider number (isMapped=false). Inbound PSTN will not reach this workspace until linked.",
+      fixCommand: "gr org phone-numbers assign \u2026 then gr phone-numbers link -w $WID --id <id> --provider-phone-uuid <uuid> --allow-write"
+    });
+  }
+  if (enableVoice && (defaultWorkflowId === null || defaultWorkflowId === void 0)) {
+    warnings.push({
+      severity: "error",
+      code: "voice_no_inbound_workflow",
+      message: "Voice is enabled but defaultWorkflowId (inbound route) is unset. Known callers may hear a rejection message; misconfiguration can drop calls without a call log.",
+      fixCommand: `gr phone-numbers update --id <id> --data '{"defaultWorkflowId":<workflowId>}' --allow-write`
+    });
+  }
+  if (enableVoice && !phone.voiceUnavailableMessage) {
+    warnings.push({
+      severity: "warn",
+      code: "missing_voice_unavailable_message",
+      message: "voiceUnavailableMessage is unset. If voice cannot be handled, callers may get a generic or empty response."
+    });
+  }
+  if (allowAnonymous && (anonymousMemberRoleId === null || anonymousMemberRoleId === void 0)) {
+    warnings.push({
+      severity: "error",
+      code: "anonymous_missing_role",
+      message: "allowAnonymous=true requires anonymousMemberRoleId.",
+      fixCommand: "gr member-roles list -w $WID  # then set anonymousMemberRoleId in update JSON"
+    });
+  }
+  if (!allowAnonymous && !phone.allowSignup && enableVoice && !phone.anonymousRejectionMessage) {
+    warnings.push({
+      severity: "warn",
+      code: "missing_anonymous_rejection_message",
+      message: "Unknown callers are rejected (allowAnonymous=false, allowSignup=false) but anonymousRejectionMessage is unset (platform default TTS will be used)."
+    });
+  }
+  if (phone.allowSignup === true && !phone.signupMemberRoleId) {
+    warnings.push({
+      severity: "error",
+      code: "signup_missing_role",
+      message: "allowSignup=true requires signupMemberRoleId.",
+      fixCommand: "gr member-roles list -w $WID"
+    });
+  }
+  return warnings;
+}
+
+// src/lib/phone-numbers/routing-simulate.ts
+var VALID_CALLER_ROLES = /* @__PURE__ */ new Set([
+  "anonymous",
+  "member",
+  "operator",
+  "signup",
+  "unknown"
+]);
+function parseCallerRole(value) {
+  if (typeof value !== "string" || value === "") {
+    return void 0;
+  }
+  return VALID_CALLER_ROLES.has(value) ? value : void 0;
+}
+function inferCallerRole(phone, opts) {
+  if (opts.asRole) {
+    return opts.asRole;
+  }
+  if (opts.hasMemberMatch) {
+    return "member";
+  }
+  if (phone.allowAnonymous === true) {
+    return "anonymous";
+  }
+  if (phone.allowSignup === true && phone.signupMemberRoleId) {
+    return "signup";
+  }
+  return "anonymous";
+}
+function simulateInboundRouting(phone, opts = {}) {
+  const steps = [];
+  const recommendations = [];
+  const isBusinessHours = opts.isBusinessHours ?? true;
+  if (!phone.isMapped) {
+    steps.push({
+      step: "provider_mapping",
+      outcome: "reject",
+      detail: "Number not linked to org provider (isMapped=false)"
+    });
+    return finish("reject_unmapped", false, false, steps, recommendations, opts.asRole);
+  }
+  if (!phone.enableVoice) {
+    steps.push({
+      step: "channel_voice",
+      outcome: "reject",
+      detail: "enableVoice=false \u2014 plays voiceUnavailableMessage or default"
+    });
+    return finish(
+      "voice_disabled_message",
+      false,
+      false,
+      steps,
+      recommendations,
+      opts.asRole
+    );
+  }
+  steps.push({ step: "channel_voice", outcome: "ok" });
+  const callerRole = inferCallerRole(phone, opts);
+  steps.push({ step: "caller_resolution", outcome: callerRole });
+  if (callerRole === "member") {
+    steps.push({ step: "member_access", outcome: "proceed" });
+  } else if (callerRole === "anonymous") {
+    if (!phone.anonymousMemberRoleId) {
+      steps.push({
+        step: "anonymous_role",
+        outcome: "reject",
+        detail: "allowAnonymous without anonymousMemberRoleId"
+      });
+      recommendations.push(
+        "Set anonymousMemberRoleId or disable allowAnonymous (gr member-roles list -w $WID)"
+      );
+      return finish("misconfigured_anonymous", false, false, steps, recommendations, callerRole);
+    }
+    steps.push({ step: "anonymous_member", outcome: "create_ephemeral_member" });
+  } else if (callerRole === "signup") {
+    steps.push({ step: "signup_flow", outcome: "redirect_voice_consent" });
+    return finish("signup_consent_redirect", false, false, steps, recommendations, callerRole);
+  } else if (callerRole === "unknown" || callerRole === "operator") {
+    steps.push({
+      step: "caller_access",
+      outcome: "reject",
+      detail: "Unknown caller; anonymous and signup disabled"
+    });
+    return finish("anonymous_rejection_tts", false, false, steps, recommendations, callerRole);
+  }
+  const voiceWorkMode = phone.voiceWorkMode;
+  if (voiceWorkMode === "always_forward" && phone.voiceForwardNumber) {
+    steps.push({ step: "voice_work_mode", outcome: "forward", detail: voiceWorkMode });
+    return finish("forward_pstn", false, true, steps, recommendations, callerRole);
+  }
+  if (voiceWorkMode === "forward_off_hours" && !isBusinessHours && phone.voiceForwardNumber) {
+    steps.push({ step: "voice_work_mode", outcome: "forward_off_hours" });
+    return finish("forward_pstn", false, true, steps, recommendations, callerRole);
+  }
+  if (voiceWorkMode === "voicemail" || voiceWorkMode === "voicemail_off_hours" && !isBusinessHours) {
+    steps.push({ step: "voice_work_mode", outcome: "voicemail" });
+    return finish("voicemail_record", true, true, steps, recommendations, callerRole);
+  }
+  if ((voiceWorkMode === "always_message" || voiceWorkMode === "message_off_hours") && phone.voiceOffHoursMessage) {
+    steps.push({ step: "voice_work_mode", outcome: "play_message" });
+    return finish("play_message_hangup", false, false, steps, recommendations, callerRole);
+  }
+  steps.push({ step: "voice_work_mode", outcome: "ai_path" });
+  const workflowId = phone.defaultWorkflowId;
+  if (workflowId === null || workflowId === void 0) {
+    steps.push({
+      step: "inbound_workflow",
+      outcome: "reject",
+      detail: "defaultWorkflowId unset \u2014 plays unavailable message; call log should be created"
+    });
+    recommendations.push(
+      `Set defaultWorkflowId: gr phone-numbers update --id <id> --data '{"defaultWorkflowId":<wf>}' --allow-write`
+    );
+    return finish("no_inbound_workflow", false, true, steps, recommendations, callerRole);
+  }
+  steps.push({ step: "inbound_workflow", outcome: "ok", detail: `workflowId=${workflowId}` });
+  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);
+}
+function finish(code, createsChat, createsPhoneCall, steps, recommendations, callerRole) {
+  const labels = {
+    reject_unmapped: "Reject \u2014 not mapped to provider",
+    voice_disabled_message: "Play voice-unavailable message",
+    misconfigured_anonymous: "Reject \u2014 anonymous misconfigured",
+    signup_consent_redirect: "Redirect to voice signup consent",
+    anonymous_rejection_tts: "Play anonymous rejection TTS, hang up",
+    forward_pstn: "Forward to voiceForwardNumber",
+    voicemail_record: "Record voicemail",
+    play_message_hangup: "Play off-hours message, hang up",
+    no_inbound_workflow: "Play unavailable message (no inbound workflow)",
+    ai_voice_chat: "Create chat + connect AI voice"
+  };
+  return {
+    callerRole: callerRole ?? "unknown",
+    steps,
+    finalBehavior: labels[code] ?? code,
+    createsChat,
+    createsPhoneCall,
+    recommendations
+  };
+}
+function formatRoutingSimulation(sim, phone) {
+  const lines = [];
+  lines.push(`Phone ${phone.id} (${String(phone.number ?? "").slice(0, 6)}\u2026)`);
+  lines.push(`Caller role (simulated): ${sim.callerRole}`);
+  lines.push("");
+  lines.push("Routing trace:");
+  for (const s of sim.steps) {
+    const detail = s.detail ? ` \u2014 ${s.detail}` : "";
+    lines.push(`  \u2022 ${s.step}: ${s.outcome}${detail}`);
+  }
+  lines.push("");
+  lines.push(`Final: ${sim.finalBehavior}`);
+  lines.push(`Creates chat: ${sim.createsChat ? "yes" : "no"}`);
+  lines.push(`Creates phone call record: ${sim.createsPhoneCall ? "yes" : "no"}`);
+  if (sim.recommendations.length > 0) {
+    lines.push("");
+    lines.push("Recommendations:");
+    for (const r of sim.recommendations) {
+      lines.push(`  \u2192 ${r}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/lib/phone-numbers/behavior-matrix.ts
+var ROLE_ROWS = ["anonymous", "member", "signup", "operator"];
+function roleExperience(phone, role) {
+  const sim = simulateInboundRouting(phone, {
+    asRole: role,
+    hasMemberMatch: role === "member"
+  });
+  return sim.finalBehavior;
+}
+function formatPhoneNumberBehaviorMatrix(phone, outboundUsers, warnings = collectPhoneNumberWarnings(phone)) {
+  const lines = [];
+  const maskedNumber = typeof phone.number === "string" && phone.number.length > 4 ? `${phone.number.slice(0, 6)}\u2026` : "(no number)";
+  lines.push(`Phone number ${phone.id} \u2014 ${phone.name ?? "(unnamed)"} \u2014 ${maskedNumber}`);
+  lines.push(`UUID: ${phone.uuid}  |  Mapped: ${phone.isMapped ? "yes" : "no"}`);
+  lines.push("");
+  lines.push("## Channels");
+  lines.push(`  Voice: ${phone.enableVoice ? "on" : "off"}  SMS: ${phone.enableSms ? "on" : "off"}  WhatsApp: ${phone.enableWhatsApp ? "on" : "off"}`);
+  lines.push(`  Assistant: ${phone.assistantEnabled ? "on" : "off"}`);
+  lines.push("");
+  lines.push("## Inbound route");
+  lines.push(
+    `  defaultWorkflowId (inbound): ${phone.defaultWorkflowId ?? "null"}  restartDelay: ${phone.restartDelay ?? "null"}s`
+  );
+  lines.push(
+    `  allowAnonymous: ${phone.allowAnonymous} (role ${phone.anonymousMemberRoleId ?? "\u2014"})  allowSignup: ${phone.allowSignup} (role ${phone.signupMemberRoleId ?? "\u2014"})`
+  );
+  if (phone.voiceWorkMode) {
+    lines.push(`  voiceWorkMode: ${phone.voiceWorkMode}`);
+  }
+  lines.push("");
+  lines.push("## Outbound users");
+  if (outboundUsers.length === 0) {
+    lines.push("  (none \u2014 no workflow defaultPhoneNumberId or event rule phoneNumberUUID)");
+  } else {
+    for (const u of outboundUsers) {
+      lines.push(`  \u2022 [${u.kind}] ${u.name} (id ${u.id})${u.detail ? ` \u2014 ${u.detail}` : ""}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Role experience (simulated inbound)");
+  for (const role of ROLE_ROWS) {
+    lines.push(`  ${role.padEnd(10)} \u2192 ${roleExperience(phone, role)}`);
+  }
+  lines.push("");
+  if (warnings.length > 0) {
+    lines.push("## Warnings");
+    for (const w of warnings) {
+      const tag = w.severity === "error" ? "ERROR" : "WARN";
+      lines.push(`  [${tag}] ${w.message}`);
+      if (w.fixCommand) {
+        lines.push(`         Fix: ${w.fixCommand}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("Tip: gr phone-numbers diagnose --id <id> --as +1\u2026  |  --raw for full JSON");
+  return lines.join("\n");
+}
+
+// src/lib/phone-numbers/outbound-users.ts
+async function findOutboundPhoneUsers(client, workspace, phone) {
+  const phoneId = phone.id;
+  const phoneUuid = String(phone.uuid ?? "");
+  const users = [];
+  const workflows = await client.getWorkflows(workspace, false);
+  for (const wf of workflows) {
+    if (wf.defaultPhoneNumberId === phoneId) {
+      users.push({
+        kind: "workflow_default",
+        id: wf.id,
+        name: String(wf.name ?? `workflow ${wf.id}`),
+        detail: "workflows.defaultPhoneNumberId (outbound origin)"
+      });
+    }
+  }
+  let page = 1;
+  const pageSize = 100;
+  for (; ; ) {
+    const rulesPage = await client.getEventRules(workspace, { page, pageSize });
+    const list = rulesPage.items;
+    for (const rule of list) {
+      const params = rule.actionParams ?? rule.action_params;
+      if (!params) continue;
+      const pnUuid = params.phoneNumberUUID ?? params.phone_number_uuid;
+      const pnId = params.phoneNumberId ?? params.phone_number_id;
+      if (pnUuid === phoneUuid || pnId === phoneId) {
+        users.push({
+          kind: "event_rule",
+          id: rule.id,
+          name: String(rule.name ?? `rule ${rule.id}`),
+          detail: `action=${String(rule.actionType ?? rule.action_type ?? "")}`
+        });
+      }
+    }
+    if (!rulesPage.totalPages || page >= rulesPage.totalPages || list.length < pageSize) {
+      break;
+    }
+    page += 1;
+    if (page > 50) {
+      process.stderr.write(
+        "Warning: event-rules lookup truncated at 5000 results (50 pages)\n"
+      );
+      break;
+    }
+  }
+  return users;
+}
+
 // src/domains/phone-numbers.ts
+function asPhoneRecord(value) {
+  return value;
+}
+function requireCallerRole(args, flag) {
+  const role = parseCallerRole(args[flag]);
+  if (!role) {
+    throw new CLIError(
+      `Invalid --${flag}. Use one of: anonymous, member, operator, signup, unknown`
+    );
+  }
+  return role;
+}
 var COLUMNS25 = [
   COL.id(),
-  { header: "NUMBER", getValue: (item) => item.phone_number ?? "" },
-  { header: "LABEL", getValue: (item) => item.label ?? "" },
+  { header: "NUMBER", getValue: (item) => item.phone_number ?? item.number ?? "" },
+  { header: "LABEL", getValue: (item) => item.label ?? item.name ?? "" },
   COL.status()
 ];
+var PROVISIONING_HELP = `
+Provisioning chain (org \u2192 workspace):
+  1. gr org phone-numbers search --org <org-uuid> [--area-code 775]
+  2. gr org phone-numbers purchase --org <org-uuid> --data '{"phoneNumber":"+1\u2026"}' --allow-write
+  3. gr org phone-numbers assign --org <org-uuid> --data '{"providerPhoneUuid":"\u2026","workspaceUuid":"\u2026"}' --allow-write
+  4. gr phone-numbers create -w $WID --data '{"name":"\u2026","providerPhoneUuid":"\u2026"}' --allow-write
+     OR gr phone-numbers link -w $WID --id <id> --provider-phone-uuid <uuid> --allow-write
+  5. gr phone-numbers update --id <id> --data '{"defaultWorkflowId":<wf>}' --allow-write
+
+IDs: workspace phone id (numeric) vs uuid (string, used in event rules phoneNumberUUID).
+Inbound: phone_numbers.defaultWorkflowId  |  Outbound: workflows.defaultPhoneNumberId
+`.trim();
 var phoneNumbersDomain = {
   name: "phone-numbers",
-  description: "Manage phone numbers",
+  description: `Workspace phone numbers (inbound/outbound voice & SMS). ${PROVISIONING_HELP}`,
   commands: [
     ...crudCommands({
       prefix: ["phone-numbers"],
       entityName: "phone number",
       listMethod: "getPhoneNumbers",
-      getMethod: "getPhoneNumber",
-      createMethod: "createPhoneNumber",
-      updateMethod: "updatePhoneNumber",
       archiveMethod: "archivePhoneNumber",
       columns: COLUMNS25
     }),
+    {
+      path: ["phone-numbers", "get"],
+      description: "Get a phone number (behavior matrix; use --raw for JSON)",
+      requiresWorkspace: true,
+      args: [
+        { name: "id", description: "Phone number ID", required: true },
+        { name: "raw", description: "Output full JSON instead of behavior matrix", isFlag: true }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        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)}
+`);
+          return;
+        }
+        const outboundUsers = await findOutboundPhoneUsers(client, workspace, phone);
+        process.stdout.write(
+          `${formatPhoneNumberBehaviorMatrix(phone, outboundUsers)}
+`
+        );
+      }
+    },
+    {
+      path: ["phone-numbers", "create"],
+      description: `Create a phone number
+
+${PHONE_NUMBER_FIELD_REFERENCE}`,
+      mutates: true,
+      requiresWorkspace: true,
+      examples: [
+        "gr phone-numbers create -w $WID --allow-write -f /tmp/phone.json",
+        `gr phone-numbers create -w $WID --allow-write --data '{"name":"Line 1","defaultWorkflowId":1}'`
+      ],
+      handler: async ({ ctx, workspace, data }) => {
+        if (!data || typeof data !== "object") {
+          throw new CLIError("JSON data required (--data, --file, or stdin)");
+        }
+        const payload = mergePhoneNumberCreateDefaults(data);
+        try {
+          const result = await requireAuth(ctx).apiClient.createPhoneNumber(
+            workspace,
+            payload
+          );
+          const record = asPhoneRecord(result);
+          const warnings = collectPhoneNumberWarnings(record);
+          outputData([record], ctx, COLUMNS25);
+          if (warnings.length > 0) {
+            process.stderr.write("\nWarnings after create:\n");
+            for (const w of warnings) {
+              process.stderr.write(`  [${w.severity}] ${w.message}
+`);
+            }
+          }
+        } catch (err) {
+          return enrichPhoneNumberApiError(err);
+        }
+      }
+    },
+    {
+      path: ["phone-numbers", "update"],
+      description: `Update a phone number
+
+${PHONE_NUMBER_FIELD_REFERENCE}`,
+      mutates: true,
+      requiresWorkspace: true,
+      args: [{ name: "id", description: "Phone number ID", required: true }],
+      handler: async ({ ctx, workspace, args, data }) => {
+        if (!data || typeof data !== "object") {
+          throw new CLIError("JSON data required (--data, --file, or stdin)");
+        }
+        const id = requireNumber(args, "id");
+        try {
+          const result = await requireAuth(ctx).apiClient.updatePhoneNumber(
+            workspace,
+            id,
+            data
+          );
+          outputData([result], ctx, COLUMNS25);
+        } catch (err) {
+          return enrichPhoneNumberApiError(err);
+        }
+      }
+    },
+    {
+      path: ["phone-numbers", "setup"],
+      description: "Provision/link a workspace phone line with inbound defaults (happy-path wizard)",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "name", description: "Display name for the line" },
+        {
+          name: "inbound-workflow",
+          aliases: ["inbound-workflow-id"],
+          description: "Inbound defaultWorkflowId"
+        },
+        { name: "area-code", description: "Area code when requesting a new number" },
+        { name: "provider-phone-uuid", description: "Existing org provider phone UUID to link" },
+        { name: "enable-voice", description: "Enable voice (default true)", isFlag: true },
+        { name: "enable-sms", description: "Enable SMS (default true)", isFlag: true },
+        { name: "allow-anonymous", description: "Allow anonymous inbound callers", isFlag: true },
+        {
+          name: "anonymous-member-role-id",
+          description: "Role id when --allow-anonymous"
+        }
+      ],
+      examples: [
+        'gr phone-numbers setup -w $WID --allow-write --name "Main" --inbound-workflow 1',
+        "gr phone-numbers setup -w $WID --allow-write --provider-phone-uuid <uuid> --inbound-workflow 2"
+      ],
+      handler: async ({ ctx, workspace, args, data }) => {
+        const client = requireAuth(ctx).apiClient;
+        const payload = mergePhoneNumberCreateDefaults({
+          name: typeof args.name === "string" ? args.name : "Voice line",
+          enableVoice: args["enable-voice"] === false ? false : true,
+          enableSms: args["enable-sms"] === false ? false : true,
+          ...typeof args["inbound-workflow"] === "string" ? { defaultWorkflowId: Number(args["inbound-workflow"]) } : {},
+          ...args["allow-anonymous"] ? { allowAnonymous: true } : {},
+          ...typeof args["anonymous-member-role-id"] === "string" ? { anonymousMemberRoleId: Number(args["anonymous-member-role-id"]) } : {},
+          ...typeof args["provider-phone-uuid"] === "string" ? { providerPhoneUuid: args["provider-phone-uuid"] } : {},
+          ...data && typeof data === "object" ? data : {}
+        });
+        let phone;
+        try {
+          if (payload.providerPhoneUuid) {
+            phone = asPhoneRecord(
+              await client.createPhoneNumber(workspace, payload)
+            );
+          } else if (typeof args["area-code"] === "string") {
+            phone = asPhoneRecord(
+              await client.requestPhoneNumber(workspace, {
+                areaCode: args["area-code"],
+                name: payload.name
+              })
+            );
+            if (payload.defaultWorkflowId) {
+              phone = asPhoneRecord(
+                await client.updatePhoneNumber(workspace, phone.id, {
+                  defaultWorkflowId: payload.defaultWorkflowId,
+                  ...payload
+                })
+              );
+            }
+          } else {
+            throw new CLIError(
+              "Provide --provider-phone-uuid (link existing org number) or --area-code (request new number)"
+            );
+          }
+        } catch (err) {
+          return enrichPhoneNumberApiError(err);
+        }
+        process.stdout.write(`
+Setup complete: id=${phone.id} uuid=${phone.uuid}
+
+`);
+        const outboundUsers = await findOutboundPhoneUsers(client, workspace, phone);
+        process.stdout.write(
+          `${formatPhoneNumberBehaviorMatrix(phone, outboundUsers)}
+`
+        );
+      }
+    },
+    {
+      path: ["phone-numbers", "diagnose"],
+      description: "Simulate inbound routing for a caller number (no PSTN)",
+      requiresWorkspace: true,
+      args: [
+        { name: "id", description: "Phone number ID", required: true },
+        { name: "as", description: "Caller E.164 (e.g. +15551234567)" },
+        {
+          name: "as-role",
+          description: "Caller role: anonymous|member|operator|signup (skips number lookup)"
+        }
+      ],
+      examples: ["gr phone-numbers diagnose -w $WID --id 2 --as +15551234567"],
+      handler: async ({ ctx, workspace, args }) => {
+        const client = requireAuth(ctx).apiClient;
+        const id = requireNumber(args, "id");
+        const phone = asPhoneRecord(await client.getPhoneNumber(workspace, id));
+        const asRole = parseCallerRole(args["as-role"]);
+        let hasMemberMatch = asRole === "member";
+        if (!asRole && typeof args.as === "string") {
+          hasMemberMatch = false;
+        }
+        const sim = simulateInboundRouting(phone, { asRole, hasMemberMatch });
+        process.stdout.write(`${formatRoutingSimulation(sim, phone)}
+`);
+      }
+    },
+    {
+      path: ["phone-numbers", "experience"],
+      description: "Preview caller experience by role (no PSTN)",
+      requiresWorkspace: true,
+      args: [
+        { name: "id", description: "Phone number ID", required: true },
+        {
+          name: "as-role",
+          description: "anonymous|member|operator|signup",
+          required: true
+        }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        const client = requireAuth(ctx).apiClient;
+        const id = requireNumber(args, "id");
+        const role = requireCallerRole(args, "as-role");
+        const phone = asPhoneRecord(await client.getPhoneNumber(workspace, id));
+        const sim = simulateInboundRouting(phone, {
+          asRole: role,
+          hasMemberMatch: role === "member"
+        });
+        process.stdout.write(
+          `If a caller in role "${role}" dials this line right now:
+  \u2192 ${sim.finalBehavior}
+
+${formatRoutingSimulation(sim, phone)}
+`
+        );
+      }
+    },
+    {
+      path: ["phone-numbers", "test-inbound"],
+      description: "Server-side inbound routing simulation (JSON; no Twilio call)",
+      requiresWorkspace: true,
+      args: [
+        { name: "id", description: "Phone number ID", required: true },
+        { name: "as", description: "Caller E.164" },
+        { name: "as-role", description: "anonymous|member|signup" }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        const client = requireAuth(ctx).apiClient;
+        const id = requireNumber(args, "id");
+        const phone = asPhoneRecord(await client.getPhoneNumber(workspace, id));
+        const asRole = parseCallerRole(args["as-role"]);
+        const sim = simulateInboundRouting(phone, {
+          asRole,
+          hasMemberMatch: asRole === "member"
+        });
+        process.stdout.write(`${JSON.stringify({ phoneNumberId: id, simulation: sim }, null, 2)}
+`);
+      }
+    },
+    {
+      path: ["phone-numbers", "users"],
+      description: "List workflows and event rules using this number for outbound",
+      requiresWorkspace: true,
+      args: [{ name: "id", description: "Phone number ID", required: true }],
+      handler: async ({ ctx, workspace, args }) => {
+        const client = requireAuth(ctx).apiClient;
+        const id = requireNumber(args, "id");
+        const phone = asPhoneRecord(await client.getPhoneNumber(workspace, id));
+        const users = await findOutboundPhoneUsers(client, workspace, phone);
+        outputData(users, ctx);
+      }
+    },
+    {
+      path: ["phone-numbers", "inbound-log"],
+      description: "Recent inbound call activity for this line (use calls list; routing detail in status)",
+      requiresWorkspace: true,
+      args: [
+        {
+          name: "phone-number-id",
+          aliases: ["id"],
+          description: "Phone number ID",
+          required: true
+        },
+        { name: "page", description: "Page number" },
+        { name: "page-size", description: "Page size" }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        const result = await requireAuth(ctx).apiClient.getPhoneNumberCalls(
+          workspace,
+          requireNumberFrom(args, "phone-number-id", "id"),
+          args.page ? Number(args.page) : 1,
+          args["page-size"] ? Number(args["page-size"]) : 20,
+          { inbound: true }
+        );
+        const inbound = result.items ?? [];
+        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"
+        );
+        outputData(inbound, ctx);
+      }
+    },
     {
       path: ["phone-numbers", "available"],
       description: "List available phone numbers for purchase",
@@ -8715,7 +10093,7 @@ var phoneNumbersDomain = {
     },
     {
       path: ["phone-numbers", "request"],
-      description: "Request a phone number",
+      description: "Request a phone number from Twilio",
       mutates: true,
       requiresWorkspace: true,
       handler: async ({ ctx, workspace, data }) => {
@@ -9234,6 +10612,64 @@ var supportDomain = {
         const result = wid ? await client.commentOnWorkspaceSupportRequest(wid, id, payload) : orgUuid ? await client.commentOnOrgSupportRequest(orgUuid, id, payload) : await client.commentOnSupportRequest(id, payload);
         outputSingle(result, ctx, SUPPORT_COLUMNS);
       }
+    },
+    {
+      path: ["support", "close"],
+      description: "Close one of your support requests (workspace-scoped)",
+      mutates: true,
+      args: [
+        { name: "workspace", aliases: ["w"], description: "Workspace UUID", required: true },
+        { name: "id", aliases: ["uuid"], description: "Support request UUID", required: true },
+        { name: "reason", description: "Optional close reason" }
+      ],
+      handler: async ({ ctx, args, workspace, data }) => {
+        const client = requireAuth(ctx).apiClient;
+        const id = requireString(args, "id");
+        const wid = args.workspace ?? workspace;
+        if (!wid) throw new Error("--workspace is required to close a support request");
+        const input = data ?? {};
+        const reason = input.reason ?? args.reason;
+        const result = await client.closeWorkspaceSupportRequest(
+          wid,
+          id,
+          reason ? { reason } : {}
+        );
+        outputSingle(result, ctx, SUPPORT_COLUMNS);
+      }
+    },
+    {
+      path: ["support", "resource-click"],
+      description: "Record a click on a pushed resource (consume + track usefulness)",
+      mutates: true,
+      args: [
+        { name: "workspace", aliases: ["w"], description: "Workspace UUID", required: true },
+        { name: "id", aliases: ["uuid"], description: "Support request UUID", required: true },
+        {
+          name: "resource-uuid",
+          description: "UUID of the resource that was opened",
+          required: true
+        },
+        {
+          name: "resulting-chat-uuid",
+          description: "Manager Chat UUID a manager_prompt opened (links resource\u2192chat)"
+        }
+      ],
+      handler: async ({ ctx, args, workspace, data }) => {
+        const client = requireAuth(ctx).apiClient;
+        const id = requireString(args, "id");
+        const resourceUuid = requireString(args, "resource-uuid");
+        const wid = args.workspace ?? workspace;
+        if (!wid) throw new Error("--workspace is required to click a resource");
+        const input = data ?? {};
+        const resultingChatUuid = input.resultingChatUuid ?? args["resulting-chat-uuid"];
+        const result = await client.clickWorkspaceSupportRequestResource(
+          wid,
+          id,
+          resourceUuid,
+          resultingChatUuid ? { resultingChatUuid } : {}
+        );
+        outputSingle(result, ctx, SUPPORT_COLUMNS);
+      }
     }
   ]
 };
@@ -10795,6 +12231,7 @@ function registerPublicDomains(registry) {
   registry.register(tasksDomain);
   registry.register(chatsDomain);
   registry.register(membersDomain);
+  registry.register(memberRolesDomain);
   registry.register(workspacesDomain);
   registry.register(workflowsDomain);
   registry.register(workflowVersionsDomain);
@@ -10805,6 +12242,7 @@ function registerPublicDomains(registry) {
   registry.register(sitesDomain);
   registry.register(filesDomain);
   registry.register(eventsDomain);
+  registry.register(experimentsDomain);
   registry.register(calendarsDomain);
   registry.register(qualificationsDomain);
   registry.register(personasDomain);
@@ -13018,9 +14456,45 @@ async function listAudioDevices() {
 }
 
 // src/commands/concierge.ts
+async function conciergeOutboundCommand(hctx) {
+  const ctx = requireAuth(hctx.ctx);
+  const { args } = hctx;
+  if (args.call && args.sms) {
+    throw new CLIError("--call and --sms are mutually exclusive");
+  }
+  if (args.call) {
+    const result = await originateConciergeCall(ctx);
+    process.stderr.write(
+      `Concierge call started. callSid=${result.callSid} startedAt=${result.startedAt}
+`
+    );
+    return;
+  }
+  if (args.sms) {
+    const result = await originateConciergeSms(ctx);
+    process.stderr.write(
+      `Concierge SMS started. messageSid=${result.messageSid} conversationId=${result.conversationId}
+`
+    );
+    return;
+  }
+  throw new CLIError(
+    "Use `gr concierge chat --call`, `gr concierge chat --sms`, or `gr concierge chat` for interactive mode."
+  );
+}
 async function conciergeCommand(hctx) {
   const ctx = requireAuth(hctx.ctx);
   const { args } = hctx;
+  if (args.call || args.sms) {
+    if (args.call && args.sms) {
+      throw new CLIError("--call and --sms are mutually exclusive");
+    }
+    if (args.voice || args.realtime) {
+      throw new CLIError("--call/--sms cannot be combined with --voice or --realtime");
+    }
+    await conciergeOutboundCommand(hctx);
+    return;
+  }
   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 getOrCreateConciergeChat(ctx, chatIdArg, !!message);
@@ -13154,6 +14628,16 @@ After directory trust + \`--allow-write\`, the concierge can use \`read_local_fi
 
 ## Verify success
 \`gr workspaces list\` then \`gr workflows list -w <uuid>\` or \`gr agents list -w <uuid>\`
+
+## Local phone / voice QA (monorepo dev)
+\`\`\`bash
+yarn dev:twilio-ngrok --start-ngrok --url gravityrail.ngrok.io dev.<you> -w acme-demo
+yarn gr phone setup
+yarn gr account verify-phone --phone +1\u2026 --allow-write --realm superadmin
+yarn gr concierge chat --call --allow-write --realm superadmin
+yarn gr phone outbound --realm acme-demo/acme-admin --workflow-id 1 --allow-write
+\`\`\`
+See \`.claude/skills/phone-voice-qa/SKILL.md\` and \`./scripts/e2e-voice-phone-matrix.sh\`.
 `;
 async function getStartedCommand(hctx) {
   const format = hctx.args.format ?? hctx.args.agent;
@@ -13418,7 +14902,10 @@ export {
   authBrowserCommand,
   buildCliConciergeAppContext,
   chatCommand,
+  commandNeedsJsonBody,
   conciergeCommand,
+  conciergeOutboundCommand,
+  confirmAccountPhoneVerify,
   createAuthenticatedContext,
   createConciergeChat,
   createContext,
@@ -13437,6 +14924,7 @@ export {
   handleError,
   isCursorPaginatedResponse,
   isDirectoryTrusted,
+  isLikelySeedPhoneNumber,
   isListResult,
   isPagePaginatedResponse,
   isPaginatedResponse,
@@ -13446,6 +14934,8 @@ export {
   logoutCommand,
   manageCommand,
   organizationsListCommand,
+  originateConciergeCall,
+  originateConciergeSms,
   outputData,
   outputSingle,
   parseArgs,
@@ -13456,9 +14946,12 @@ export {
   requireDirectoryTrust,
   requireNumber,
   requireString,
+  resolveVoicePhoneNumberId,
   simpleCrudCommands,
+  startAccountPhoneVerify,
   stderr,
   unwrapItems,
+  waitForOutboundPhoneCallOutcome,
   whoamiCommand
 };
 //# sourceMappingURL=lib.js.map