@gravity-rail/cli 0.7.3 → 0.8.0

package/dist/lib.js

@@ -29,7 +29,7 @@ import {
   startAccountPhoneVerify,
   stderr,
   unwrapItems
-} from "./chunk-KTTHOL3B.js";
+} from "./chunk-L5YCPUAM.js";
 import {
   AGUIClient,
   formatTimestamp,
@@ -959,8 +959,8 @@ function requireNumberFrom(args, ...keys) {
       if (!isNaN(num)) return num;
     }
   }
-  const hint = keys.map((k) => `--${k}`).join(" or ");
-  throw new Error(`Missing required argument: ${hint}`);
+  const hint2 = keys.map((k) => `--${k}`).join(" or ");
+  throw new Error(`Missing required argument: ${hint2}`);
 }
 
 // src/domains/agent-tasks.ts
@@ -1102,6 +1102,29 @@ var TOOL_COLUMNS = [
   COL.name(),
   { header: "DESCRIPTION", getValue: (item) => (item.description ?? "").slice(0, 60) }
 ];
+var ABILITY_COLUMNS = [
+  COL.uuid(),
+  { header: "ABILITY-TYPE", getValue: (item) => item.abilityType ?? "" },
+  COL.enabled(),
+  { header: "CEL-CONDITION", getValue: (item) => item.celCondition ?? "" }
+];
+function requireAbilityScope(args) {
+  const hasWorkflow = typeof args["workflow-id"] === "string";
+  const hasTask = typeof args["task-id"] === "string";
+  if (hasWorkflow === hasTask) {
+    throw new CLIError(
+      "Specify exactly one of --workflow-id or --task-id. Abilities are scoped to a workflow or task, not to the agent row itself."
+    );
+  }
+  if (hasTask) {
+    const taskId = Number(args["task-id"]);
+    if (isNaN(taskId)) throw new CLIError("--task-id must be a number");
+    return { taskId };
+  }
+  const workflowId = Number(args["workflow-id"]);
+  if (isNaN(workflowId)) throw new CLIError("--workflow-id must be a number");
+  return { workflowId };
+}
 function normalizeChannel(channel) {
   const aliases = {
     phone: "phone-voice",
@@ -1126,11 +1149,16 @@ var agentsDomain = {
       archiveMethod: "archiveAgent",
       unarchiveMethod: "unarchiveAgent",
       columns: COLUMNS,
-      paginationSupport: "full"
+      paginationSupport: "full",
+      updateHelp: "Update an agent. Body schema (JSON via --data/--file/stdin), all fields optional:\n  name              string   display name\n  description       string   short summary shown in listings\n  systemPrompt      string   base instructions for the agent\n  model             string   AI model slug (see `gr ai-models list`)\n  temperature       number   sampling temperature (0-2)\n  avatarFileId      number   workspace file ID for the avatar\n  config            object   AgentConfig overrides (advanced)\nAbilities are NOT set here \u2014 they live on a workflow/task scope; use `gr agents abilities` to manage them.",
+      updateExamples: [
+        `gr agents update --id 42 --data '{"name":"Scheduler","temperature":0.4}'`,
+        "gr agents update --id 42 --file agent.json"
+      ]
     }),
     {
       path: ["agents", "resolve-tools"],
-      description: "Show resolved runtime tools for an agent in a channel context. Channel accepts canonical values (phone-voice, web-voice, phone-sms, web-chat) or shorthand aliases: phone -> phone-voice, voice -> phone-voice, sms -> phone-sms, web -> web-chat. Unknown values are passed through unchanged.",
+      description: "Show resolved runtime tools for an agent in a channel context. Channel accepts canonical values (phone-voice, web-voice, phone-sms, web-chat) or shorthand aliases: phone -> phone-voice, voice -> phone-voice, sms -> phone-sms, web -> web-chat. Unknown values are passed through unchanged. When neither --task-id nor --task-uuid is supplied the agent's workflow start task is used.",
       requiresWorkspace: true,
       args: [
         { name: "id", description: "Agent ID", required: true },
@@ -1141,22 +1169,142 @@ var agentsDomain = {
         },
         {
           name: "task-id",
-          description: "Task ID whose workflow abilities to resolve",
-          required: true
+          description: "Numeric task ID whose workflow abilities to resolve. Omit to use the workflow start task (or supply --task-uuid instead).",
+          required: false
+        },
+        {
+          name: "task-uuid",
+          description: "Task UUID as an alternative to --task-id. Omit to use the workflow start task.",
+          required: false
         }
       ],
       handler: async ({ ctx, workspace, args }) => {
+        const rawTaskId = args["task-id"];
+        const rawTaskUuid = args["task-uuid"];
+        if (rawTaskId !== void 0 && rawTaskUuid !== void 0) {
+          throw new Error("Provide at most one of --task-id or --task-uuid, not both");
+        }
+        const options = {
+          channel: normalizeChannel(String(args.channel))
+        };
+        if (typeof rawTaskId === "string") {
+          const n = Number(rawTaskId);
+          if (isNaN(n)) throw new Error("Argument --task-id must be a number");
+          options.taskId = n;
+        }
+        if (typeof rawTaskUuid === "string") {
+          options.taskUuid = rawTaskUuid;
+        }
         const result2 = await requireAuth(ctx).apiClient.resolveAgentTools(
           workspace,
           requireNumber(args, "id"),
-          {
-            channel: normalizeChannel(String(args.channel)),
-            taskId: requireNumber(args, "task-id")
-          }
+          options
         );
         const tools = result2.tools ?? result2;
         outputData(Array.isArray(tools) ? tools : [tools], ctx, TOOL_COLUMNS);
       }
+    },
+    {
+      path: ["agents", "abilities", "list"],
+      description: "Show the abilities effective for an agent on a task (read-only). Requires --task-id because abilities are resolved through the task's workflow, not stored on the agent row.",
+      requiresWorkspace: true,
+      columns: ABILITY_COLUMNS,
+      args: [
+        { name: "id", description: "Agent ID", required: true },
+        {
+          name: "task-id",
+          description: "Task ID whose workflow abilities to list",
+          required: true
+        }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        const result2 = await requireAuth(ctx).apiClient.listAgentAbilities(
+          workspace,
+          requireNumber(args, "id"),
+          { taskId: requireNumber(args, "task-id") }
+        );
+        outputData(result2, ctx, ABILITY_COLUMNS);
+      }
+    },
+    {
+      path: ["agents", "abilities", "enable"],
+      description: "Enable (create) an ability on a workflow or task scope. Requires exactly one of --workflow-id or --task-id \u2014 abilities are scoped to a workflow/task, never to the agent row. Provide initial --config JSON inline or via --data/--file.",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "ability-type", description: "Ability type slug (e.g. 'communication:send_sms')", required: true },
+        { name: "workflow-id", description: "Workflow scope (mutually exclusive with --task-id)" },
+        { name: "task-id", description: "Task scope (mutually exclusive with --workflow-id)" }
+      ],
+      examples: [
+        "gr agents abilities enable --workflow-id 7 --ability-type tools:web_search",
+        `gr agents abilities enable --task-id 12 --ability-type integration:data_access --data '{"dataTypeUuid":"..."}'`
+      ],
+      handler: async ({ ctx, workspace, args, data }) => {
+        const abilityType = args["ability-type"];
+        if (typeof abilityType !== "string") {
+          throw new CLIError("--ability-type is required");
+        }
+        const scope = requireAbilityScope(args);
+        const config = data && typeof data === "object" ? data : {};
+        const body = {
+          abilityType,
+          config,
+          ...scope
+        };
+        const result2 = await requireAuth(ctx).apiClient.createAbility(workspace, body);
+        outputSingle(result2, ctx, ABILITY_COLUMNS);
+      }
+    },
+    {
+      path: ["agents", "abilities", "disable"],
+      description: "Disable an ability instance by UUID (sets enabled=false, keeps config). Use `gr agents abilities list` to find the UUID.",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [{ name: "uuid", description: "Ability instance UUID", required: true }],
+      handler: async ({ ctx, workspace, args }) => {
+        const uuid = args.uuid;
+        if (typeof uuid !== "string") throw new CLIError("--uuid is required");
+        const result2 = await requireAuth(ctx).apiClient.updateAbility(workspace, uuid, {
+          enabled: false
+        });
+        outputSingle(result2, ctx, ABILITY_COLUMNS);
+      }
+    },
+    {
+      path: ["agents", "abilities", "configure"],
+      description: "Update an ability instance by UUID. Pass --data/--file JSON to merge into config, and/or --enabled true|false to toggle. config is merged with the existing config server-side.",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "uuid", description: "Ability instance UUID", required: true },
+        { name: "enabled", description: "Set enabled state (true|false)" }
+      ],
+      examples: [
+        `gr agents abilities configure --uuid <uuid> --data '{"canForward":true}'`,
+        "gr agents abilities configure --uuid <uuid> --enabled true"
+      ],
+      handler: async ({ ctx, workspace, args, data }) => {
+        const uuid = args.uuid;
+        if (typeof uuid !== "string") throw new CLIError("--uuid is required");
+        const body = {};
+        if (data && typeof data === "object") {
+          body.config = data;
+        }
+        if (typeof args.enabled === "string") {
+          if (args.enabled !== "true" && args.enabled !== "false") {
+            throw new CLIError("--enabled must be true or false");
+          }
+          body.enabled = args.enabled === "true";
+        }
+        if (Object.keys(body).length === 0) {
+          throw new CLIError(
+            "Nothing to update: provide --data config and/or --enabled"
+          );
+        }
+        const result2 = await requireAuth(ctx).apiClient.updateAbility(workspace, uuid, body);
+        outputSingle(result2, ctx, ABILITY_COLUMNS);
+      }
     }
   ]
 };
@@ -1382,21 +1530,47 @@ var chatsDomain = {
     // Inspect (aggregated debug view)
     {
       path: ["chats", "inspect"],
-      description: "Inspect a chat with messages, assignment state, and data records",
-      requiresWorkspace: true,
+      description: "Inspect a chat with messages, assignment state, and data records. Omit -w for concierge (account-level) chats.",
+      requiresWorkspace: false,
       args: [{ name: "id", description: "Chat ID", required: true }],
       handler: async ({ ctx, workspace, args }) => {
         const chatId = requireNumber(args, "id");
-        const [chat, messages, ws] = await Promise.all([
-          requireAuth(ctx).apiClient.getChat(workspace, chatId),
-          requireAuth(ctx).apiClient.getChatMessages(workspace, chatId),
-          requireAuth(ctx).apiClient.getWorkspace(workspace)
-        ]);
-        const isHipaa = ws.features?.includes("hipaa_compliance");
+        const authed = requireAuth(ctx);
         const truncate2 = (content) => {
           const text = typeof content === "string" ? content : JSON.stringify(content);
           return text.slice(0, 200);
         };
+        if (!workspace) {
+          const [chat2, messages2] = await Promise.all([
+            getConciergeChat(authed, chatId),
+            getConciergeChatMessages(authed, chatId)
+          ]);
+          outputSingle(
+            {
+              chat: {
+                id: chat2.id,
+                uuid: chat2.uuid,
+                title: chat2.title,
+                chatType: chat2.chatType,
+                threadId: chat2.threadId,
+                createdAt: chat2.createdAt
+              },
+              messages: messages2.map((m) => ({
+                id: m.id,
+                role: m.role,
+                content: truncate2(m.content)
+              }))
+            },
+            ctx
+          );
+          return;
+        }
+        const [chat, messages, ws] = await Promise.all([
+          authed.apiClient.getChat(workspace, chatId),
+          authed.apiClient.getChatMessages(workspace, chatId),
+          authed.apiClient.getWorkspace(workspace)
+        ]);
+        const isHipaa = ws.features?.includes("hipaa_compliance");
         const result2 = {
           chat: {
             id: chat.id,
@@ -1416,10 +1590,7 @@ var chatsDomain = {
         };
         const assignmentId = chat.assignmentId;
         if (assignmentId) {
-          const assignment = await requireAuth(ctx).apiClient.getAssignment(
-            workspace,
-            assignmentId
-          );
+          const assignment = await authed.apiClient.getAssignment(workspace, assignmentId);
           result2.assignment = {
             id: assignment.id,
             status: assignment.status,
@@ -1674,10 +1845,7 @@ var memberRolesDomain = {
     updateMethod: "updateMemberRole",
     deleteMethod: "deleteMemberRole",
     columns: ROLE_COLUMNS2,
-    createExamples: [
-      "gr member-roles list -w $WID",
-      "gr member-roles get -w $WID --id 2"
-    ]
+    createExamples: ["gr member-roles list -w $WID", "gr member-roles get -w $WID --id 2"]
   })
 };
 
@@ -1686,10 +1854,13 @@ var COLUMNS4 = [
   COL.id(),
   COL.uuid(),
   COL.name(),
-  COL.status(),
+  // TaskResponse has no `status` field — it has `archived`. Surface that
+  // directly so active vs archived is visible in the default table (relevant
+  // once --include-archived mixes both into the listing).
+  { header: "STATUS", getValue: (item) => item.archived ? "archived" : "active" },
   {
     header: "WORKFLOW",
-    getValue: (item) => item.workflow_name ?? String(item.workflow_id ?? "")
+    getValue: (item) => String(item.workflowId ?? "")
   },
   COL.created()
 ];
@@ -1707,7 +1878,21 @@ var tasksDomain = {
       deleteMethod: "deleteTask",
       archiveMethod: "archiveTask",
       unarchiveMethod: "unarchiveTask",
-      columns: COLUMNS4
+      columns: COLUMNS4,
+      // `tasks list` is workspace-wide by default. Filter to one workflow
+      // with --workflow-id, and opt into archived tasks with
+      // --include-archived (active-only by default, matching the backend).
+      listArgs: [
+        {
+          name: "workflow-id",
+          description: "Filter tasks to a single workflow by ID"
+        },
+        {
+          name: "include-archived",
+          description: "Include archived tasks in the listing",
+          isFlag: true
+        }
+      ]
     }),
     {
       path: ["tasks", "clone"],
@@ -1762,9 +1947,18 @@ var COLUMNS5 = [
   COL.id(),
   COL.uuid(),
   COL.name(),
-  { header: "TASKS", getValue: (item) => String(item.taskCount ?? "") },
+  // taskCount is the total (active + archived). Show the active count as the
+  // headline number — matching `tasks list` — and call out archived tasks
+  // separately so the table never overstates how many tasks actually run.
+  { header: "TASKS", getValue: (item) => formatTaskCount(item) },
   COL.created()
 ];
+function formatTaskCount(item) {
+  const total = Number(item.taskCount ?? 0);
+  const archived = Number(item.archivedTaskCount ?? 0);
+  const active = total - archived;
+  return archived > 0 ? `${active} (+${archived} archived)` : String(active);
+}
 var NOTE_COLUMNS = [
   COL.id(),
   { header: "TITLE", getValue: (item) => item.title ?? "" },
@@ -1865,13 +2059,21 @@ var workflowsDomain = {
     // Diagram
     {
       path: ["workflows", "diagram"],
-      description: "Get workflow diagram",
+      description: "Get workflow diagram (active tasks only by default)",
       requiresWorkspace: true,
-      args: [{ name: "id", description: "Workflow ID", required: true }],
+      args: [
+        { name: "id", description: "Workflow ID", required: true },
+        {
+          name: "include-archived",
+          description: "Render archived tasks (distinctly styled) too",
+          isFlag: true
+        }
+      ],
       handler: async ({ ctx, workspace, args }) => {
         const result2 = await requireAuth(ctx).apiClient.getWorkflowDiagram(
           workspace,
-          requireNumber(args, "id")
+          requireNumber(args, "id"),
+          { includeArchived: args["include-archived"] === true }
         );
         outputSingle(result2, ctx);
       }
@@ -2388,28 +2590,64 @@ var workspacesDomain = {
         outputSingle(result2, ctx, COLUMNS7);
       }
     },
-    // Create a workspace via the public endpoint
+    // Provision a workspace under an organization's active subscription.
     {
       path: ["workspaces", "create"],
-      description: "Create a workspace",
+      description: "Provision a workspace in an organization (requires an active subscription)",
       mutates: true,
       requiresWorkspace: false,
-      handler: async ({ ctx, data }) => {
-        if (!data) throw new CLIError("JSON data required (--data, --file, or stdin)");
-        const payload = data;
-        if (!payload.organizationId) {
+      args: [
+        {
+          name: "org",
+          aliases: ["org-uuid"],
+          description: "Organization UUID",
+          required: true
+        },
+        { name: "product", description: "Workspace plan product ID", required: true },
+        { name: "name", description: "Workspace name", required: true },
+        { name: "period", description: "Billing period: 'month' or 'year'", default: "month" },
+        { name: "slug", description: "Workspace slug (optional)" },
+        { name: "template", description: "Template workspace UUID to clone (optional)" }
+      ],
+      examples: ['gr workspaces create --org <org-uuid> --product 14 --name "Front Desk"'],
+      handler: async ({ ctx, args }) => {
+        const orgUuid = args.org ?? args["org-uuid"];
+        const name = args.name;
+        const productRaw = args.product;
+        if (!orgUuid) throw new CLIError("Missing required argument: --org <org-uuid>");
+        if (!name) throw new CLIError("Missing required argument: --name");
+        if (!productRaw) {
           throw new CLIError(
-            `organizationId is required in --data (e.g. --data '{"organizationId": 1, "name": "My Workspace"}')`
+            "Missing required argument: --product\nList workspace plans with: gr billing products --type workspace"
           );
         }
+        const payload = {
+          name,
+          productId: Number(productRaw),
+          planPeriod: args.period || "month"
+        };
+        if (args.slug) payload.slug = args.slug;
+        if (args.template) payload.templateWorkspaceUuid = args.template;
         try {
-          const result2 = await requireAuth(ctx).apiClient.createWorkspace(payload);
+          const result2 = await requireAuth(ctx).apiClient.createOrganizationWorkspace(
+            orgUuid,
+            payload
+          );
           outputSingle(result2, ctx, COLUMNS7);
+          if ((ctx.outputFormat ?? "table") === "table") {
+            const wsUuid = result2?.uuid ?? "<workspace-uuid>";
+            process.stdout.write(
+              `
+Provisioning started. Watch it come up with:
+  gr workspaces get -w ${wsUuid}
+`
+            );
+          }
         } catch (err) {
           const statusCode = err?.statusCode;
-          if (statusCode === 405) {
+          if (statusCode === 400) {
             throw new CLIError(
-              'Creating a workspace directly is not supported \u2014 provisioning runs through the concierge (it handles product selection and billing).\nNext: gr concierge chat --allow-write --message "Create a new workspace"\nThen: gr workspaces list  (to get the new workspace UUID for -w)'
+              "Could not create the workspace. The organization needs an active, paid subscription first.\n  gr billing products --type org      # pick an org plan\n  gr billing checkout --product <id>  # pay up front\n  gr billing status                   # confirm it is active"
             );
           }
           throw err;
@@ -3463,35 +3701,24 @@ Common optional
 Scope (set exactly one when objectType requires it)
   routineId, workflowId, taskId, dataTypeId, journeyStepId, calendarId, ...
 
-chat:create actionParams (outbound voice/SMS)
-  {"workflowId":<id>,"channel":"phone-voice"|"phone-sms","phoneNumberId":<id>,
-   "inboxId":<optional>,"assistantEnabled":<bool>}
+chat:create actionParams (outbound voice/SMS \u2014 starts a workflow chat)
+  {"workflowUUID":"<workflow-uuid>","channel":"phone-voice"|"phone-sms",
+   "phoneNumberUUID":"<uuid>","inboxUUID":"<optional-uuid>","assistantEnabled":<bool>}
+  Keys are UUID strings: workflowUUID (not workflowId), phoneNumberUUID (not
+  phoneNumberId), inboxUUID (not inboxId). Unknown keys are rejected.
+
+sms:send actionParams (send an SMS, or start an SMS workflow chat)
+  One-off text:  {"phoneNumberUUID":"<from-number-uuid>","messageTemplate":"Hi {{name}} \u2026"}
+  Workflow chat: {"phoneNumberUUID":"<from-number-uuid>","workflowUUID":"<workflow-uuid>",
+                  "initialUserMessage":"<optional seed>"}
+  phoneNumberUUID (the from-number) is required. The message body is messageTemplate
+  (supports {{record/member}} template vars) \u2014 there is no "body"/"message" key.
+  Provide messageTemplate for a one-off text, OR workflowUUID to start a chat.
 
 member:label actionParams
   {"addLabelIds":["<uuid>"],"removeLabelIds":["<uuid>"]}
 `;
 
-// src/lib/routines/field-help.ts
-var ROUTINE_FIELD_REFERENCE = `
-Field reference for --data JSON (create/update):
-
-Core
-  name (string)                         Display name
-  workflowId (number)                   Workflow run when the routine fires
-  targetMemberId (number)               Member who receives the scheduled outreach
-
-Schedule
-  scheduleEnabled (bool)                Master on/off for the cron trigger
-  scheduleMode (string)                 "CRON" (only mode today)
-  cronString (string)                   Standard cron, e.g. "0 7 * * *"
-  timezone (string, optional)           IANA name, e.g. "America/Los_Angeles"
-                                        Defaults to workspace timezone, else UTC
-
-Visibility / lifecycle
-  archived (bool)                       Archive flag on update
-  event rules                           Use gr events rules create \u2014 not inline here
-`;
-
 // src/domains/events.ts
 var RULE_COLUMNS = [
   COL.id(),
@@ -3499,15 +3726,6 @@ var RULE_COLUMNS = [
   { header: "EVENT", getValue: (item) => item.eventType ?? "" },
   { header: "ACTIVE", getValue: (item) => String(item.active ?? "") }
 ];
-var ROUTINE_COLUMNS = [
-  COL.id(),
-  COL.name(),
-  { header: "MODE", getValue: (item) => item.scheduleMode ?? "" },
-  { header: "CRON", getValue: (item) => item.cronString ?? "" },
-  { header: "TZ", getValue: (item) => item.timezone ?? "UTC" },
-  { header: "ENABLED", getValue: (item) => String(item.scheduleEnabled ?? "") },
-  { header: "NEXT RUN", getValue: (item) => item.nextRun ?? "" }
-];
 var eventRulesCrudNoList = crudCommands({
   prefix: ["events", "rules"],
   entityName: "event rule",
@@ -3531,8 +3749,8 @@ ${EVENT_RULE_FIELD_REFERENCE}`,
     `gr events rules create -w $WID --allow-write --data '{"name":"AM voice check-in",`,
     '  "objectType":"routine","eventType":"routine:triggered","actionType":"chat:create",',
     '  "routineId":<routine-id>,',
-    '  "actionParams":{"workflowId":<workflow-id>,"channel":"phone-voice",',
-    `  "phoneNumberId":<workspace-phone-id>}}'`,
+    '  "actionParams":{"workflowUUID":"<workflow-uuid>","channel":"phone-voice",',
+    `  "phoneNumberUUID":"<workspace-phone-uuid>"}}'`,
     "",
     '  PM SMS variant: use "channel":"phone-sms" and a second rule on the same routineId.',
     "  Prereq: org phone assigned + gr phone-numbers link; workflow published with start task.",
@@ -3670,74 +3888,6 @@ var eventsDomain = {
         const result2 = await requireAuth(ctx).apiClient.searchEventRules(workspace, opts);
         outputData(result2, ctx, RULE_COLUMNS);
       }
-    },
-    // Routines
-    ...crudCommands({
-      prefix: ["routines"],
-      entityName: "routine",
-      listMethod: "getRoutines",
-      getMethod: "getRoutine",
-      createMethod: "createRoutine",
-      updateMethod: "updateRoutine",
-      deleteMethod: "deleteRoutine",
-      paginationSupport: "full",
-      columns: ROUTINE_COLUMNS,
-      createHelp: `Create a routine
-
-${ROUTINE_FIELD_REFERENCE}`,
-      updateHelp: `Update a routine
-
-${ROUTINE_FIELD_REFERENCE}`,
-      createExamples: [
-        "Daily 7am check-in in the member\u2019s timezone (cron is interpreted in `timezone`):",
-        `gr routines create -w $WID --allow-write --data '{"name":"AM check-in",`,
-        '  "scheduleEnabled":true,"scheduleMode":"CRON","cronString":"0 7 * * *",',
-        `  "timezone":"America/Los_Angeles","targetMemberId":1,"workflowId":2}'`,
-        "  (timezone is an IANA name; omit it to default to the workspace timezone, else UTC.",
-        '   Without it, "0 7 * * *" fires at 07:00 UTC, not 7am local.)'
-      ]
-    }),
-    {
-      path: ["routines", "run"],
-      description: "Run a routine now",
-      mutates: true,
-      requiresWorkspace: true,
-      args: [{ name: "id", description: "Routine ID", required: true }],
-      handler: async ({ ctx, workspace, args, data }) => {
-        const result2 = await requireAuth(ctx).apiClient.runRoutine(
-          workspace,
-          requireNumber(args, "id"),
-          data ?? {}
-        );
-        outputSingle(result2, ctx);
-      }
-    },
-    {
-      path: ["routines", "runs", "list"],
-      description: "List runs for a routine",
-      requiresWorkspace: true,
-      args: [
-        {
-          name: "id",
-          description: "Routine ID (aligns with routines get/run/update/delete)"
-        },
-        { name: "status", description: "Filter by run status" },
-        { name: "page", description: "Page number (1-indexed)" },
-        { name: "page-size", description: "Page size (max 100)" }
-      ],
-      handler: async ({ ctx, workspace, args }) => {
-        const routineId = args.id ? requireNumber(args, "id") : void 0;
-        const page = args.page ? requireNumber(args, "page") : void 0;
-        const pageSize = args["page-size"] ? requireNumber(args, "page-size") : void 0;
-        const status = args.status ?? void 0;
-        const result2 = await requireAuth(ctx).apiClient.getRoutineRuns(workspace, {
-          ...routineId !== void 0 ? { routineId } : {},
-          ...page !== void 0 ? { page } : {},
-          ...pageSize !== void 0 ? { pageSize } : {},
-          ...status ? { status } : {}
-        });
-        outputData(result2, ctx);
-      }
     }
   ]
 };
@@ -5354,6 +5504,178 @@ var sitesDomain = {
   ]
 };
 
+// src/domains/abilities.ts
+import { randomUUID } from "crypto";
+var ATTACHED_COLUMNS = [
+  { header: "UUID", getValue: (item) => item.uuid ?? "" },
+  { header: "TYPE", getValue: (item) => item.abilityType ?? "" },
+  { header: "ENABLED", getValue: (item) => item.enabled === false ? "" : "yes" },
+  { header: "CEL", getValue: (item) => item.celCondition ?? "" }
+];
+function toAbilityData(a) {
+  return {
+    uuid: a.uuid,
+    abilityType: a.abilityType,
+    config: a.config ?? {},
+    enabled: a.enabled ?? true,
+    ...a.celCondition ? { celCondition: a.celCondition } : {}
+  };
+}
+var TYPE_COLUMNS = [
+  { header: "SLUG", getValue: (item) => item.slug ?? "" },
+  { header: "TITLE", getValue: (item) => item.title ?? "" },
+  { header: "CATEGORY", getValue: (item) => item.category ?? "" },
+  {
+    header: "CHANNELS",
+    // null channels means "all channels" — show that explicitly so an empty
+    // cell never reads as "no channels".
+    getValue: (item) => Array.isArray(item.channels) ? item.channels.join(",") : "all"
+  },
+  { header: "SINGLETON", getValue: (item) => item.singleton ? "yes" : "" },
+  { header: "FEATURE-GATE", getValue: (item) => item.requiredFeature ?? "" }
+];
+var abilitiesDomain = {
+  name: "abilities",
+  description: "Inspect ability types and attach/detach them on a task",
+  commands: [
+    {
+      path: ["abilities", "list"],
+      description: "List builtin ability types with their channel constraints and param specs. Table shows SLUG, TITLE, CATEGORY, CHANNELS (all = every channel), SINGLETON, FEATURE-GATE; use -o json for full specs including the params JSON Schema.",
+      requiresWorkspace: true,
+      columns: TYPE_COLUMNS,
+      args: [
+        {
+          name: "include-system",
+          description: "Also list auto-injected system abilities (hidden by default)",
+          isFlag: true
+        }
+      ],
+      handler: async (hctx) => {
+        const includeSystem = hctx.args["include-system"] === true;
+        const result2 = await requireAuth(hctx.ctx).apiClient.getAbilityTypes(
+          hctx.workspace,
+          includeSystem ? { includeSystem: true } : {}
+        );
+        outputData(result2.types ?? [], hctx.ctx, TYPE_COLUMNS);
+      }
+    },
+    {
+      path: ["abilities", "get"],
+      description: "Show the full spec for one ability type: title, description, category, channels, singleton/system flags, required feature, and the JSON Schema of its params model.",
+      requiresWorkspace: true,
+      args: [
+        {
+          name: "name",
+          aliases: ["slug"],
+          description: "Ability type slug (e.g. 'communication:phone_call_tools')",
+          required: true
+        }
+      ],
+      handler: async (hctx) => {
+        const slug = hctx.args.name ?? hctx.args.slug;
+        if (!slug) throw new CLIError("--name is required");
+        const result2 = await requireAuth(hctx.ctx).apiClient.getAbilityType(
+          hctx.workspace,
+          slug
+        );
+        outputSingle(result2, hctx.ctx);
+      }
+    },
+    {
+      path: ["abilities", "attached"],
+      description: "List a task's task-specific abilities (excludes workflow-inherited).",
+      requiresWorkspace: true,
+      columns: ATTACHED_COLUMNS,
+      args: [{ name: "task", description: "Task ID", required: true }],
+      handler: async (hctx) => {
+        const task = await requireAuth(hctx.ctx).apiClient.getTask(
+          hctx.workspace,
+          requireNumber(hctx.args, "task")
+        );
+        outputData(task.abilities ?? [], hctx.ctx, ATTACHED_COLUMNS);
+      }
+    },
+    {
+      path: ["abilities", "attach"],
+      description: "Attach an ability to a task. Reads the task, appends the new ability (generating its uuid), and saves \u2014 so existing abilities aren't lost. Find slugs via 'gr abilities list' and the config schema via 'gr abilities get'.",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "task", description: "Task ID to attach to", required: true },
+        {
+          name: "type",
+          aliases: ["ability-type", "slug"],
+          description: "Ability type slug, e.g. 'integration:data_access'",
+          required: true
+        },
+        {
+          name: "config",
+          description: `Ability config as a JSON object, e.g. '{"pauseOnEscalate":true}'`
+        },
+        { name: "cel", description: "Optional CEL activation condition" },
+        {
+          name: "disabled",
+          description: "Attach in a disabled state (default: enabled)",
+          isFlag: true
+        }
+      ],
+      handler: async (hctx) => {
+        const api = requireAuth(hctx.ctx).apiClient;
+        const taskId = requireNumber(hctx.args, "task");
+        const abilityType = hctx.args.type ?? hctx.args["ability-type"] ?? hctx.args.slug;
+        if (!abilityType) throw new CLIError("--type is required (an ability type slug)");
+        let config = {};
+        if (hctx.args.config) {
+          try {
+            config = JSON.parse(hctx.args.config);
+          } catch {
+            throw new CLIError("--config must be a valid JSON object");
+          }
+        }
+        const task = await api.getTask(hctx.workspace, taskId);
+        const existing = (task.abilities ?? []).map(toAbilityData);
+        const next = {
+          uuid: randomUUID(),
+          abilityType,
+          config,
+          enabled: hctx.args.disabled !== true,
+          ...hctx.args.cel ? { celCondition: hctx.args.cel } : {}
+        };
+        const updated = await api.updateTask(hctx.workspace, taskId, {
+          abilities: [...existing, next]
+        });
+        outputData(updated.abilities ?? [], hctx.ctx, ATTACHED_COLUMNS);
+      }
+    },
+    {
+      path: ["abilities", "detach"],
+      description: "Detach an ability from a task by its uuid (from `gr abilities attached`). Re-saves the remaining task-specific abilities so the rest are preserved.",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [
+        { name: "task", description: "Task ID", required: true },
+        { name: "uuid", description: "UUID of the attached ability to remove", required: true }
+      ],
+      handler: async (hctx) => {
+        const api = requireAuth(hctx.ctx).apiClient;
+        const taskId = requireNumber(hctx.args, "task");
+        const uuid = hctx.args.uuid;
+        if (!uuid) throw new CLIError("--uuid is required");
+        const task = await api.getTask(hctx.workspace, taskId);
+        const existing = task.abilities ?? [];
+        const remaining = existing.filter((a) => a.uuid !== uuid).map(toAbilityData);
+        if (remaining.length === existing.length) {
+          throw new CLIError(`No attached ability with uuid '${uuid}' on task ${taskId}`);
+        }
+        const updated = await api.updateTask(hctx.workspace, taskId, {
+          abilities: remaining
+        });
+        outputData(updated.abilities ?? [], hctx.ctx, ATTACHED_COLUMNS);
+      }
+    }
+  ]
+};
+
 // src/domains/access-grants.ts
 var COLUMNS14 = [
   COL.id(),
@@ -5875,6 +6197,149 @@ var authManageDomain = {
   ]
 };
 
+// src/domains/billing.ts
+function priceSummary(product) {
+  const plans = product.plans ?? {};
+  const abbr = { month: "mo", year: "yr", quarter: "qtr" };
+  const parts = [];
+  for (const [period, plan] of Object.entries(plans)) {
+    const cents = plan?.costPerPeriod ?? 0;
+    if (!plan?.stripePriceId) continue;
+    parts.push(`$${(cents / 100).toFixed(0)}/${abbr[period] ?? period}`);
+  }
+  return parts.join(", ") || "\u2014";
+}
+var PRODUCT_COLUMNS2 = [
+  { header: "ID", getValue: (p) => String(p.id ?? "") },
+  { header: "NAME", getValue: (p) => p.name ?? "" },
+  { header: "TYPE", getValue: (p) => String(p.productType ?? "") },
+  { header: "PRICE", getValue: (p) => priceSummary(p) },
+  {
+    header: "TRIAL",
+    getValue: (p) => {
+      const days = p.trialPeriodDays ?? 0;
+      return days > 0 ? `${days}d` : "\u2014";
+    }
+  }
+];
+var SUBSCRIPTION_COLUMNS = [
+  COL.id(),
+  COL.status(),
+  { header: "PLAN", getValue: (s) => String(s.plan_name ?? s.productName ?? s.plan ?? "") },
+  { header: "PERIOD", getValue: (s) => String(s.planPeriod ?? s.plan_period ?? "") },
+  {
+    header: "ORG",
+    getValue: (s) => String(s.organizationUuid ?? s.customerOrganizationUuid ?? "")
+  }
+];
+function isTable(ctx) {
+  return (ctx.outputFormat ?? "table") === "table";
+}
+function hint(ctx, lines) {
+  if (!isTable(ctx)) return;
+  process.stdout.write("\n" + lines.join("\n") + "\n");
+}
+function productType(args) {
+  const t = args.type ?? args["product-type"];
+  if (t === "org" || t === "workspace") return t;
+  return void 0;
+}
+var billingDomain = {
+  name: "billing",
+  description: "Browse plans, start checkout, and check subscription status",
+  commands: [
+    {
+      path: ["billing", "products"],
+      description: "List self-service plans you can purchase",
+      requiresWorkspace: false,
+      args: [
+        {
+          name: "type",
+          description: "Filter by plan type: 'org' or 'workspace'"
+        }
+      ],
+      examples: ["gr billing products --type org"],
+      handler: async ({ ctx, args }) => {
+        const products = await requireAuth(ctx).apiClient.listSelfServeProducts(
+          productType(args)
+        );
+        outputData(products, ctx, PRODUCT_COLUMNS2);
+        if (products.length === 0) {
+          hint(ctx, ["No purchasable plans found. (Free plans are not sold via the CLI.)"]);
+        } else {
+          hint(ctx, [
+            "Next \u2014 buy an organization plan to get started:",
+            "  gr billing checkout --product <id> [--period month|year]"
+          ]);
+        }
+      }
+    },
+    {
+      path: ["billing", "checkout"],
+      description: "Get a Stripe payment link to purchase an organization plan",
+      mutates: true,
+      requiresWorkspace: false,
+      args: [
+        { name: "product", description: "Product ID of the org plan to buy", required: true },
+        { name: "period", description: "Billing period: 'month' or 'year'", default: "month" }
+      ],
+      examples: ["gr billing checkout --product 12 --period month"],
+      handler: async ({ ctx, args }) => {
+        const productId = Number(requireString(args, "product"));
+        const period = args.period || "month";
+        const result2 = await requireAuth(ctx).apiClient.createCheckoutSession(
+          productId,
+          period
+        );
+        if (isTable(ctx)) {
+          process.stdout.write(
+            `
+\u{1F4B3}  Open this link in a browser to complete payment:
+
+    ${result2.checkoutUrl}
+
+Once payment succeeds, your organization and subscription are created automatically.
+Then check it landed:
+  gr billing status
+`
+          );
+        } else {
+          outputSingle(result2, ctx);
+        }
+      }
+    },
+    {
+      path: ["billing", "status"],
+      description: "Show your subscriptions and what to do next",
+      requiresWorkspace: false,
+      examples: ["gr billing status"],
+      handler: async ({ ctx }) => {
+        const subs = await requireAuth(ctx).apiClient.getSubscriptions();
+        outputData(subs, ctx, SUBSCRIPTION_COLUMNS);
+        const active = subs.find(
+          (s) => ["active", "trialing"].includes(String(s.status ?? s.subscriptionStatus ?? ""))
+        );
+        if (!active) {
+          hint(ctx, [
+            "No active subscription yet. To get started:",
+            "  gr billing products --type org        # pick a plan",
+            "  gr billing checkout --product <id>    # pay up front"
+          ]);
+          return;
+        }
+        const orgUuid = String(
+          active.organizationUuid ?? active.customerOrganizationUuid ?? "<org-uuid>"
+        );
+        hint(ctx, [
+          "You have an active subscription. Add a workspace:",
+          "  gr billing products --type workspace                       # pick a workspace plan",
+          `  gr workspaces create --org ${orgUuid} --product <id> --name "My Workspace"`
+        ]);
+      }
+    }
+  ]
+};
+
 // src/domains/billing-portal.ts
 var INVOICE_COLUMNS = [
   { header: "ID", getValue: (i) => String(i.id) },
@@ -7575,9 +8040,22 @@ function formatPhoneNumberBehaviorMatrix(phone, outboundUsers, warnings = collec
   lines.push(`UUID: ${phone.uuid}  |  Mapped: ${phone.isMapped ? "yes" : "no"}`);
   lines.push("");
   lines.push("## Channels");
-  lines.push(`  Voice: ${phone.enableVoice ? "on" : "off"}  SMS: ${phone.enableSms ? "on" : "off"}  WhatsApp: ${phone.enableWhatsApp ? "on" : "off"}`);
+  lines.push(
+    `  Voice: ${phone.enableVoice ? "on" : "off"}  SMS: ${phone.enableSms ? "on" : "off"}  WhatsApp: ${phone.enableWhatsApp ? "on" : "off"}`
+  );
   lines.push(`  Assistant: ${phone.assistantEnabled ? "on" : "off"}`);
   lines.push("");
+  if (phone.enableVoice) {
+    lines.push("## Channel defaults (auto-injected on voice)");
+    lines.push(
+      "  Voice channels auto-add the hang_up_call tool (system:voice_channel);"
+    );
+    lines.push(
+      "  it is not listed by `gr agents abilities list`. See `gr abilities get"
+    );
+    lines.push("  --name communication:phone_call_tools` for the voice ability spec.");
+    lines.push("");
+  }
   lines.push("## Inbound route");
   lines.push(
     `  defaultWorkflowId (inbound): ${phone.defaultWorkflowId ?? "null"}  restartDelay: ${phone.restartDelay ?? "null"}s`
@@ -7658,9 +8136,7 @@ async function findOutboundPhoneUsers(client, workspace, phone) {
     }
     page += 1;
     if (page > 50) {
-      process.stderr.write(
-        "Warning: event-rules lookup truncated at 5000 results (50 pages)\n"
-      );
+      process.stderr.write("Warning: event-rules lookup truncated at 5000 results (50 pages)\n");
       break;
     }
   }
@@ -10775,6 +11251,115 @@ var reportsDomain = {
   ]
 };
 
+// src/lib/routines/field-help.ts
+var ROUTINE_FIELD_REFERENCE = `
+Field reference for --data JSON (create/update):
+
+Core
+  name (string)                         Display name
+  workflowId (number)                   Workflow run when the routine fires
+  targetMemberId (number)               Member who receives the scheduled outreach
+
+Schedule
+  scheduleEnabled (bool)                Master on/off for the cron trigger
+  scheduleMode (string)                 "CRON" (only mode today)
+  cronString (string)                   Standard cron, e.g. "0 7 * * *"
+  timezone (string, optional)           IANA name, e.g. "America/Los_Angeles"
+                                        Defaults to workspace timezone, else UTC
+
+Visibility / lifecycle
+  archived (bool)                       Archive flag on update
+  event rules                           Use gr events rules create \u2014 not inline here
+`;
+
+// src/domains/routines.ts
+var ROUTINE_COLUMNS = [
+  COL.id(),
+  COL.name(),
+  { header: "MODE", getValue: (item) => item.scheduleMode ?? "" },
+  { header: "CRON", getValue: (item) => item.cronString ?? "" },
+  { header: "TZ", getValue: (item) => item.timezone ?? "UTC" },
+  { header: "ENABLED", getValue: (item) => String(item.scheduleEnabled ?? "") },
+  { header: "NEXT RUN", getValue: (item) => item.nextRun ?? "" }
+];
+var routinesDomain = {
+  name: "routines",
+  description: "Schedule recurring outbound (e.g. a daily SMS/voice check-in via cron)",
+  commands: [
+    ...crudCommands({
+      prefix: ["routines"],
+      entityName: "routine",
+      listMethod: "getRoutines",
+      getMethod: "getRoutine",
+      createMethod: "createRoutine",
+      updateMethod: "updateRoutine",
+      deleteMethod: "deleteRoutine",
+      paginationSupport: "full",
+      columns: ROUTINE_COLUMNS,
+      createHelp: `Create a routine
+
+${ROUTINE_FIELD_REFERENCE}`,
+      updateHelp: `Update a routine
+
+${ROUTINE_FIELD_REFERENCE}`,
+      createExamples: [
+        "Daily 7am check-in in the member\u2019s timezone (cron is interpreted in `timezone`):",
+        `gr routines create -w $WID --allow-write --data '{"name":"AM check-in",`,
+        '  "scheduleEnabled":true,"scheduleMode":"CRON","cronString":"0 7 * * *",',
+        `  "timezone":"America/Los_Angeles","targetMemberId":1,"workflowId":2}'`,
+        "  (timezone is an IANA name; omit it to default to the workspace timezone, else UTC.",
+        '   Without it, "0 7 * * *" fires at 07:00 UTC, not 7am local.)',
+        "",
+        "To actually send via SMS/voice, pair the routine with an event rule:",
+        '  gr events rules create \u2014 objectType "routine", eventType "routine:triggered",',
+        '  actionType "chat:create". See `gr events --help`.'
+      ]
+    }),
+    {
+      path: ["routines", "run"],
+      description: "Run a routine now",
+      mutates: true,
+      requiresWorkspace: true,
+      args: [{ name: "id", description: "Routine ID", required: true }],
+      handler: async ({ ctx, workspace, args, data }) => {
+        const result2 = await requireAuth(ctx).apiClient.runRoutine(
+          workspace,
+          requireNumber(args, "id"),
+          data ?? {}
+        );
+        outputSingle(result2, ctx);
+      }
+    },
+    {
+      path: ["routines", "runs", "list"],
+      description: "List runs for a routine",
+      requiresWorkspace: true,
+      args: [
+        {
+          name: "id",
+          description: "Routine ID (aligns with routines get/run/update/delete)"
+        },
+        { name: "status", description: "Filter by run status" },
+        { name: "page", description: "Page number (1-indexed)" },
+        { name: "page-size", description: "Page size (max 100)" }
+      ],
+      handler: async ({ ctx, workspace, args }) => {
+        const routineId = args.id ? requireNumber(args, "id") : void 0;
+        const page = args.page ? requireNumber(args, "page") : void 0;
+        const pageSize = args["page-size"] ? requireNumber(args, "page-size") : void 0;
+        const status = args.status ?? void 0;
+        const result2 = await requireAuth(ctx).apiClient.getRoutineRuns(workspace, {
+          ...routineId !== void 0 ? { routineId } : {},
+          ...page !== void 0 ? { page } : {},
+          ...pageSize !== void 0 ? { pageSize } : {},
+          ...status ? { status } : {}
+        });
+        outputData(result2, ctx);
+      }
+    }
+  ]
+};
+
 // src/domains/subscriptions.ts
 var COLUMNS27 = [
   COL.id(),
@@ -12637,11 +13222,13 @@ function registerPublicDomains(registry) {
   registry.register(sitesDomain);
   registry.register(filesDomain);
   registry.register(eventsDomain);
+  registry.register(routinesDomain);
   registry.register(experimentsDomain);
   registry.register(calendarsDomain);
   registry.register(qualificationsDomain);
   registry.register(personasDomain);
   registry.register(journeysDomain);
+  registry.register(abilitiesDomain);
   registry.register(phoneNumbersDomain);
   registry.register(inboxesDomain);
   registry.register(operatorGroupsDomain);
@@ -12654,6 +13241,7 @@ function registerPublicDomains(registry) {
   registry.register(mcpServersDomain);
   registry.register(apiKeysDomain);
   registry.register(subscriptionsDomain);
+  registry.register(billingDomain);
   registry.register(supportDomain);
   registry.register(reportsDomain);
   registry.register(aiModelsDomain);
@@ -13069,13 +13657,25 @@ async function runConciergeAguiLoop(client, initialMessages, onEvent, opts) {
       process.stderr.write(
         "  [HITL] Unsupported interrupt in CLI \u2014 open app.gravityrail.com/setup to continue.\n"
       );
-      break;
+      return {
+        streamText,
+        hasToolCalls,
+        unsupportedHitl: normalizeUnsupportedHitl(hitlPayload)
+      };
     }
     resume = next;
     streamText = "";
   }
   return { streamText, hasToolCalls };
 }
+function normalizeUnsupportedHitl(raw) {
+  const payload = raw && typeof raw === "object" ? raw : {};
+  return {
+    type: typeof payload.type === "string" ? payload.type : void 0,
+    interruptId: typeof payload.interrupt_id === "string" ? payload.interrupt_id : void 0,
+    payload
+  };
+}
 
 // src/lib/realtime-client.ts
 import { EventEmitter } from "events";
@@ -14147,8 +14747,8 @@ var ChatTUI = class {
     const indent = " ".repeat(labelWidth);
     if (!this.streamContent) {
       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}`);
+        const hint2 = this.runState === "tool_running" && this.activeToolName ? `Running ${this.activeToolName}\u2026` : "Thinking\u2026";
+        lines.push(`${label}${YELLOW}${hint2}${RESET}`);
       } else {
         lines.push(label);
       }
@@ -14641,6 +15241,7 @@ var AudioPlayer = class extends EventEmitter2 {
 };
 
 // src/lib/chat-session.ts
+var HITL_INTERRUPT_EXIT_CODE = 3;
 async function runChatSession(session, args) {
   const debug = !!args.debug;
   const isVoice = !!args.voice;
@@ -14670,6 +15271,14 @@ async function runChatSession(session, args) {
 function vadMode(args) {
   return typeof args.vad === "string" ? args.vad : "server";
 }
+function sanitizeInterruptForStdout(result2) {
+  const url = typeof result2.payload.url === "string" ? result2.payload.url : void 0;
+  return {
+    type: result2.type,
+    interrupt_id: result2.interruptId,
+    url
+  };
+}
 async function singleTurnChatSession(session, message, debug, autoApprove = false, allowWrite = false) {
   const aguiClient = new AGUIClient({
     baseUrl: session.ctx.envConfig.apiUrl,
@@ -14689,7 +15298,7 @@ async function singleTurnChatSession(session, message, debug, autoApprove = fals
 `);
     }
   };
-  const { streamText, hasToolCalls } = await runConciergeAguiLoop(
+  const { streamText, hasToolCalls, unsupportedHitl } = await runConciergeAguiLoop(
     aguiClient,
     [{ role: "user", content: message }],
     onEvent,
@@ -14702,6 +15311,21 @@ async function singleTurnChatSession(session, message, debug, autoApprove = fals
       nonInteractive: true
     }
   );
+  if (unsupportedHitl) {
+    const jsonPayload = JSON.stringify({
+      error: "hitl_interrupt",
+      message: "A human-in-the-loop interrupt requires out-of-band action before the operation can continue.",
+      resume: {
+        chatId: session.chatId,
+        chatUuid: session.chatUuid,
+        interruptId: unsupportedHitl.interruptId
+      },
+      interrupt: sanitizeInterruptForStdout(unsupportedHitl)
+    });
+    process.stdout.write(`${jsonPayload}
+`);
+    throw new CLIError("HITL interrupt requires out-of-band handling", HITL_INTERRUPT_EXIT_CODE);
+  }
   if (streamText) {
     process.stdout.write(`\x1B[32mAssistant:\x1B[0m ${streamText}
 `);
@@ -15209,11 +15833,12 @@ async function createMemberChat(apiClient, workspace, memberId) {
 async function conciergeOutboundCommand(hctx) {
   const ctx = requireAuth(hctx.ctx);
   const { args } = hctx;
+  const message = typeof args.message === "string" ? args.message : void 0;
   if (args.call && args.sms) {
     throw new CLIError("--call and --sms are mutually exclusive");
   }
   if (args.call) {
-    const result2 = await originateConciergeCall(ctx);
+    const result2 = await originateConciergeCall(ctx, "concierge_setup", message, "cli");
     process.stderr.write(
       `Concierge call started. callSid=${result2.callSid} startedAt=${result2.startedAt}
 `
@@ -15647,7 +16272,7 @@ var topLevelCommands = [
     mutates: true,
     args: [{ name: "phone", description: "E.164 phone number (optional; prompts if omitted)" }],
     handler: async (hctx) => {
-      const { accountVerifyPhoneCommand } = await import("./account-verify-phone-TDQNZ5XN.js");
+      const { accountVerifyPhoneCommand } = await import("./account-verify-phone-TC73QIIE.js");
       await accountVerifyPhoneCommand(hctx);
     }
   },
@@ -15669,7 +16294,11 @@ var topLevelCommands = [
         description: "SMS your verified account phone (server-side)",
         isFlag: true
       },
-      { name: "message", alias: "m", description: "Single-turn: send one message and exit" },
+      {
+        name: "message",
+        alias: "m",
+        description: 'Single-turn: send one message and exit. With --call: the "why I am calling" anchor for the opening self-introduction.'
+      },
       { name: "chat-id", description: "Resume an existing chat by numeric ID" },
       { name: "vad", description: "Voice activity detection: server (default) or client" },
       { name: "list-devices", description: "List audio devices and exit", isFlag: true },