@gravity-rail/sdk 0.22.0 → 0.33.0

package/dist/index.cjs

@@ -28,6 +28,16 @@ __export(src_exports, {
   AccessGrantStatus: () => AccessGrantStatus,
   AccessGrantTrigger: () => AccessGrantTrigger,
   AccessLevel: () => AccessLevel2,
+  ActivityCapability: () => ActivityCapability,
+  ActivityEventFamily: () => ActivityEventFamily,
+  ActivityEventType: () => ActivityEventType,
+  ActivityGrain: () => ActivityGrain,
+  ActivityGroupBy: () => ActivityGroupBy,
+  ActivityOpenItemOrder: () => ActivityOpenItemOrder,
+  ActivityOutcome: () => ActivityOutcome,
+  ActivityVisibility: () => ActivityVisibility,
+  ActivityWindowBasis: () => ActivityWindowBasis,
+  ActorKind: () => ActorKind,
   AgentBuilder: () => AgentBuilder,
   ApiError: () => ApiError,
   ApplyError: () => ApplyError,
@@ -48,8 +58,16 @@ __export(src_exports, {
   CalendarScheduleRecurrence: () => CalendarScheduleRecurrence,
   CalendarSource: () => CalendarSource,
   CapabilityClass: () => CapabilityClass,
+  ChannelMessageDirection: () => ChannelMessageDirection,
+  ChannelMessageSource: () => ChannelMessageSource,
+  ChannelMessagesUnavailableReason: () => ChannelMessagesUnavailableReason,
+  ChatInteractionController: () => ChatInteractionController,
+  ChatMuteReason: () => ChatMuteReason,
   ConsentMethod: () => ConsentMethod,
   CriterionType: () => CriterionType,
+  DEFAULT_AGENT_CHAT_MODEL: () => DEFAULT_AGENT_CHAT_MODEL,
+  DEFAULT_AGENT_REALTIME_MODEL: () => DEFAULT_AGENT_REALTIME_MODEL,
+  DEFAULT_AGENT_REALTIME_MODEL_CONFIG: () => DEFAULT_AGENT_REALTIME_MODEL_CONFIG,
   DEFAULT_CHAT_MODEL: () => DEFAULT_CHAT_MODEL,
   DEFAULT_CUSTOM_VOICE_MODEL: () => DEFAULT_CUSTOM_VOICE_MODEL,
   DEFAULT_THINKING_SPEECH_PHRASES: () => DEFAULT_THINKING_SPEECH_PHRASES,
@@ -59,8 +77,11 @@ __export(src_exports, {
   DataRecordRetirementResponseReason: () => DataRecordRetirementResponseReason,
   DataSensitivity: () => DataSensitivity,
   DataTypeRecordScope: () => DataTypeRecordScope,
+  DigestSlotRole: () => DigestSlotRole,
   DriverMode: () => DriverMode,
+  EhrWritebackOutcomeResponseStatus: () => EhrWritebackOutcomeResponseStatus,
   EmailDnsRecordType: () => EmailDnsRecordType,
+  EntityKind: () => EntityKind,
   EventRuleActionType: () => EventRuleActionType,
   EventRuleEventType: () => EventRuleEventType,
   EventRuleObjectType: () => EventRuleObjectType,
@@ -71,6 +92,11 @@ __export(src_exports, {
   FhirVendor: () => FhirVendor,
   FormBuilder: () => FormBuilder,
   GravityRailClient: () => GravityRailClient,
+  ImportSkippedRuleResourceGroupResourceType: () => ImportSkippedRuleResourceGroupResourceType,
+  ImportSkippedRuleResponseNeededResourceTypesItem: () => ImportSkippedRuleResponseNeededResourceTypesItem,
+  ImportSkippedRuleResponseParentKind: () => ImportSkippedRuleResponseParentKind,
+  ImportSkippedRuleResponseReasonCode: () => ImportSkippedRuleResponseReasonCode,
+  ImportSkippedRuleResponseStatus: () => ImportSkippedRuleResponseStatus,
   InboundFaxStatusValues: () => InboundFaxStatus,
   IndexStatus: () => IndexStatus,
   InvitationStatus: () => InvitationStatus,
@@ -78,6 +104,7 @@ __export(src_exports, {
   JourneyBuilder: () => JourneyBuilder,
   JourneyStepBuilder: () => JourneyStepBuilder,
   MASKED_SECRET_SENTINEL: () => MASKED_SECRET_SENTINEL,
+  MEMBER_RELATIONSHIP_KINDS: () => MEMBER_RELATIONSHIP_KINDS,
   McpServerState: () => McpServerState,
   MemberFeature: () => MemberFeature,
   MemberFilterBuilder: () => MemberFilterBuilder,
@@ -85,6 +112,7 @@ __export(src_exports, {
   MemberImportPreviewRowAction: () => MemberImportPreviewRowAction,
   MemberImportValidationError: () => MemberImportValidationError,
   MemberLabelBuilder: () => MemberLabelBuilder,
+  MemberRelationshipKind: () => MemberRelationshipKind,
   MemberType: () => MemberType,
   MenuItemResponseItemType: () => MenuItemResponseItemType,
   MenuItemType: () => MenuItemResponseItemType,
@@ -120,8 +148,11 @@ __export(src_exports, {
   REALTIME_MODEL_OPENAI: () => REALTIME_MODEL_OPENAI,
   REALTIME_MODEL_OPENAI_2: () => REALTIME_MODEL_OPENAI_2,
   REALTIME_MODEL_OPENAI_MINI: () => REALTIME_MODEL_OPENAI_MINI,
+  RefResolutionStatus: () => RefResolutionStatus,
   Region: () => Region,
   RegistrationIdentifier: () => RegistrationIdentifier,
+  RelatedMemberRole: () => RelatedMemberRole,
+  RelationshipCardinality: () => RelationshipCardinality,
   Resource: () => Resource,
   RoleUpdate: () => RoleUpdate,
   RoutineBuilder: () => RoutineBuilder,
@@ -146,7 +177,12 @@ __export(src_exports, {
   TTS_PREVIEW_PROVIDERS: () => TTS_PREVIEW_PROVIDERS,
   TaskBuilder: () => TaskBuilder,
   TemplatesApi: () => TemplatesApi,
+  TestChatRunLane: () => TestChatRunLane,
+  TestChatRunOutcome: () => TestChatRunOutcome,
   ToolkitState: () => ToolkitState,
+  UiPromptPresentedKindValues: () => UiPromptPresentedKind,
+  UiPromptResponseKindValues: () => UiPromptResponseKind,
+  UiPromptResponseStatusValues: () => UiPromptResponseStatus,
   WIDGET_SLUGS: () => WIDGET_SLUGS,
   WORKFLOW_IMPLICIT_USE_SCOPE: () => WORKFLOW_IMPLICIT_USE_SCOPE,
   WorkflowAccessWarningResourceType: () => WorkflowAccessWarningResourceType,
@@ -221,6 +257,9 @@ function isApiValidationError(value) {
   const v = value;
   return typeof v.field === "string" && typeof v.kind === "string" && typeof v.message === "string";
 }
+function logApiClientError(_error) {
+  console.warn("API request failed");
+}
 var ApiError = class extends Error {
   statusCode;
   /** Legacy string-array errors — kept for non-validation callers. */
@@ -239,6 +278,7 @@ var ApiError = class extends Error {
   errorData;
   constructor(message, statusCode, errors, validationErrors) {
     super(message);
+    this.name = "ApiError";
     this.statusCode = statusCode;
     this.errors = errors;
     this.validationErrors = validationErrors;
@@ -498,9 +538,10 @@ ${formattedErrors}`, response.status);
           const message = errorData.detail ? `${errorData.detail}: ${details}` : `Validation failed: ${details}`;
           throw new ApiError(message, response.status, stringErrors);
         }
-        const structuredError = errorData.detail || errorData;
+        const detail = errorData.detail;
+        const structuredError = detail && typeof detail === "object" ? detail : errorData;
         if (structuredError && typeof structuredError === "object" && (structuredError.error === true || structuredError.code)) {
-          const message = structuredError.message || structuredError.code || "Unknown error";
+          const message = typeof detail === "string" && detail || structuredError.message || structuredError.code || "Unknown error";
           const error = new ApiError(message, response.status);
           error.errorData = structuredError;
           throw error;
@@ -517,7 +558,7 @@ ${formattedErrors}`, response.status);
       }
       return response.json();
     } catch (error) {
-      console.warn(error);
+      logApiClientError(error);
       throw error;
     }
   }
@@ -624,7 +665,7 @@ ${formattedErrors}`, response.status);
       }
       return response;
     } catch (error) {
-      console.warn(error);
+      logApiClientError(error);
       throw error;
     }
   }
@@ -670,7 +711,7 @@ ${formattedErrors}`, response.status);
       }
       return response.json();
     } catch (error) {
-      console.warn(error);
+      logApiClientError(error);
       throw error;
     }
   }
@@ -1911,17 +1952,6 @@ var CallsApi = class extends BaseApiClient {
       `w/${wid}/calls${params.toString() ? `?${params.toString()}` : ""}`
     );
   }
-  /** Initiate a new outbound call. */
-  async initiateCall(wid, request) {
-    return this.fetch(`w/${wid}/call`, {
-      method: "POST",
-      body: JSON.stringify(request)
-    });
-  }
-  /** Get a voice authentication token for real-time audio. */
-  async getVoiceToken(wid) {
-    return this.fetch(`w/${wid}/voice/token`);
-  }
   /** Get message timing data for a chat recording. */
   async getMessageTiming(wid, chatId) {
     return this.fetch(`w/${wid}/recordings/chat/${chatId}/message-timing`);
@@ -2047,6 +2077,26 @@ var ChatsApi = class extends BaseApiClient {
   async getChat(wid, id) {
     return this.fetch(`w/${wid}/chats/${id}`);
   }
+  /**
+   * Get a short-lived, interactive AgentCore browser view for this Chat.
+   *
+   * The signed URL is deliberately response-local. Callers must keep it in
+   * memory only and request a fresh value when reopening the view.
+   */
+  async getChatBrowserLiveView(wid, chatId) {
+    const response = await this.fetchRaw(`w/${wid}/chats/${chatId}/browser/live-view`);
+    if (response.status === 204) return null;
+    return response.json();
+  }
+  /**
+   * Which machine resources this Chat is running right now.
+   *
+   * Infrastructure state only — no Chat content — so it is safe to poll while
+   * a Chat is open.
+   */
+  async getChatMachineResources(wid, chatId) {
+    return this.fetch(`w/${wid}/chats/${chatId}/machine-resources`);
+  }
   /**
    * Create-chat preflight for SMS: is a conversation already live between this
    * workspace number and this member?
@@ -2074,6 +2124,23 @@ var ChatsApi = class extends BaseApiClient {
   async getChatCallbacks(wid, chatId) {
     return this.fetch(`w/${wid}/chats/${chatId}/callbacks`);
   }
+  /**
+   * List EHR write-back outcomes for a chat (newest first).
+   *
+   * Operator surface: the endpoint requires `chats:read` in addition to the
+   * chat's own object authorization, so a chat owner reading their own chat
+   * does not reach it. The response carries IDs and closed-vocabulary codes
+   * only — no note body, summary, member fields, or provider messages.
+   */
+  async getChatEhrWritebackOutcomes(wid, chatId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) params.append("limit", options.limit.toString());
+    if (options.cursor) params.append("cursor", options.cursor);
+    const queryString = params.toString();
+    return this.fetch(
+      `w/${wid}/chats/${chatId}/ehr-writeback-outcomes${queryString ? `?${queryString}` : ""}`
+    );
+  }
   /** Cancel a pending scheduled callback on a chat. */
   async cancelChatCallback(wid, chatId, callbackId) {
     return this.fetch(
@@ -2085,6 +2152,18 @@ var ChatsApi = class extends BaseApiClient {
   async getChatTodos(wid, chatId) {
     return this.fetch(`w/${wid}/chats/${chatId}/todos`);
   }
+  /**
+   * The caller's own live inline-connect link for a chat.
+   *
+   * An `inline_connect` prompt (`UiPromptPresented.connect`) names the
+   * connection but carries no URL; fetch it here when the member chooses to
+   * connect. 404 when nothing is live for the caller in this chat.
+   */
+  async getInlineConnectLink(wid, chatId, appSlug) {
+    return this.fetch(
+      `w/${wid}/chats/${chatId}/inline-connect/${encodeURIComponent(appSlug)}/link`
+    );
+  }
   /** Get loaded and revealed skills for a chat. */
   async getChatSkills(wid, chatId) {
     return this.fetch(`w/${wid}/chats/${chatId}/skills`);
@@ -2119,6 +2198,23 @@ var ChatsApi = class extends BaseApiClient {
       method: "PUT"
     });
   }
+  /** Start an interaction within an existing Chat without changing its channel. */
+  async createChatInteractionSession(wid, chatId, request) {
+    return this.fetch(
+      `w/${wid}/chats/${chatId}/interaction-sessions`,
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      }
+    );
+  }
+  /** End one mode session and append its replacement in the same Chat. */
+  async transitionChatInteractionSession(wid, chatId, sessionId, request) {
+    return this.fetch(
+      `w/${wid}/chats/${chatId}/interaction-sessions/${encodeURIComponent(sessionId)}/transition`,
+      { method: "POST", body: JSON.stringify(request) }
+    );
+  }
   /** Create a new chat. */
   async createChat(wid, chat) {
     const { agentMemberId, ...rest } = chat;
@@ -2178,22 +2274,12 @@ var ChatsApi = class extends BaseApiClient {
     });
   }
   /** Update the mute status of a chat. */
-  async updateChatMute(wid, id, muted) {
+  async updateChatMute(wid, id, muted, muteReason, muteExpiresOnInbound) {
     return this.fetch(`w/${wid}/chats/${id}/mute`, {
       method: "PUT",
-      body: JSON.stringify({ muted })
+      body: JSON.stringify({ muted, muteReason, muteExpiresOnInbound })
     });
   }
-  /** Update the needs-response flag on a chat. */
-  async updateChatNeedsResponse(wid, id, needsResponse) {
-    return this.fetch(
-      `w/${wid}/chats/${id}/needs-response`,
-      {
-        method: "PUT",
-        body: JSON.stringify({ needsResponse })
-      }
-    );
-  }
   /** Generate an AI summary for a chat, optionally updating its labels. */
   async summarizeChat(wid, id, updateLabels) {
     const params = new URLSearchParams();
@@ -2209,10 +2295,11 @@ var ChatsApi = class extends BaseApiClient {
   }
   /** List messages in a chat with optional pagination.
    *  ``id`` is the numeric chat id (documented) or the chat uuid (accepted). */
-  async getChatMessages(wid, id, limit, offset) {
+  async getChatMessages(wid, id, limit, offset, before) {
     const params = new URLSearchParams();
     if (limit) params.append("limit", limit.toString());
     if (offset) params.append("offset", offset.toString());
+    if (before) params.append("before", before);
     return this.fetch(
       `w/${wid}/chats/${id}/messages${params.toString() ? `?${params.toString()}` : ""}`
     );
@@ -2632,6 +2719,35 @@ var DashboardsApi = class extends BaseApiClient {
 
 // src/api/data-types.ts
 var DataTypesApi = class extends BaseApiClient {
+  /** Read the local Form's draft and optimistic publication counters. */
+  async getDataTypeDraft(wid, id) {
+    return this.fetch(`w/${wid}/data-types/${id}/schema-draft`);
+  }
+  /** Save a draft without changing the schema used to validate live records. */
+  async saveDataTypeDraft(wid, id, request) {
+    return this.fetch(`w/${wid}/data-types/${id}/schema-draft`, {
+      method: "PUT",
+      body: JSON.stringify(request)
+    });
+  }
+  /** Publish the expected draft as the next immutable local schema version. */
+  async publishDataTypeDraft(wid, id, request) {
+    return this.fetch(`w/${wid}/data-types/${id}/schema-publish`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** List schema history newest first; use the last version as the next cursor. */
+  async getDataTypeVersions(wid, id, options) {
+    const params = new URLSearchParams();
+    if (options?.beforeVersion !== void 0)
+      params.set("beforeVersion", String(options.beforeVersion));
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    const query = params.toString();
+    return this.fetch(
+      `w/${wid}/data-types/${id}/schema-versions${query ? `?${query}` : ""}`
+    );
+  }
   /** List all data types for a workspace, optionally filtering by archived status. */
   async getDataTypes(wid, options) {
     const params = new URLSearchParams();
@@ -2700,7 +2816,6 @@ var DataTypesApi = class extends BaseApiClient {
     const params = new URLSearchParams();
     if (options?.memberId !== void 0) params.append("member_id", options.memberId.toString());
     if (options?.memberIds?.length) params.append("member_ids", options.memberIds.join(","));
-    if (options?.recordId !== void 0) params.append("record_id", options.recordId.toString());
     if (options?.search) params.append("search", options.search);
     if (options?.searchField) params.append("search_field", options.searchField);
     if (options?.dataRecordFilterId != null) {
@@ -2856,36 +2971,35 @@ function isUuid(value) {
 
 // src/api/devices.ts
 var DevicesApi = class extends BaseApiClient {
-  /** List devices visible to the caller (own devices, or all with devices:admin). */
-  async getDevices(wid, options = {}) {
-    const qs = options.mine ? "?mine=true" : "";
-    return this.fetch(`w/${wid}/devices${qs}`);
+  /** List devices owned by the current Account. */
+  async getDevices() {
+    return this.fetch("account/devices");
   }
-  /** Fetch one device by UUID. Non-owners without devices:admin receive 404. */
-  async getDevice(wid, deviceUuid) {
-    return this.fetch(`w/${wid}/devices/${deviceUuid}`);
+  /** Fetch one device owned by the current Account. Other devices return 404. */
+  async getDevice(deviceUuid) {
+    return this.fetch(`account/devices/${deviceUuid}`);
   }
   /** List shippable companion-device products (Lantern, later SKUs). */
-  async getDeviceKinds(wid) {
-    return this.fetch(`w/${wid}/devices/kinds`);
+  async getDeviceKinds() {
+    return this.fetch("account/devices/kinds");
   }
-  /** Claim a pairing code shown on a companion device. Requires devices:write. */
-  async claimDevicePairing(wid, body) {
-    return this.fetch(`w/${wid}/devices/pairing/claim`, {
+  /** Claim a pairing code shown on a companion device for the current Account. */
+  async claimDevicePairing(body) {
+    return this.fetch("account/devices/pairing/claim", {
       method: "POST",
       body: JSON.stringify(body)
     });
   }
-  /** Update display name and/or LAN capability flags. Requires devices:write. */
-  async updateDevice(wid, deviceUuid, body) {
-    return this.fetch(`w/${wid}/devices/${deviceUuid}`, {
+  /** Update display name and/or LAN capability flags on an owned device. */
+  async updateDevice(deviceUuid, body) {
+    return this.fetch(`account/devices/${deviceUuid}`, {
       method: "PATCH",
       body: JSON.stringify(body)
     });
   }
-  /** Revoke a device credential. The device must pair again. Requires devices:write. */
-  async revokeDevice(wid, deviceUuid) {
-    return this.fetch(`w/${wid}/devices/${deviceUuid}/revoke`, {
+  /** Revoke an owned device credential. The device must pair again. */
+  async revokeDevice(deviceUuid) {
+    return this.fetch(`account/devices/${deviceUuid}/revoke`, {
       method: "POST",
       body: JSON.stringify({})
     });
@@ -3314,6 +3428,22 @@ var EventsApi = class extends BaseApiClient {
       }
     );
   }
+  /**
+   * Preview what would stop a draft Routine placing its scheduled outbound
+   * calls — the Member voice opt-out, a missing member phone, or a
+   * workspace number that is stale, archived, or not voice-enabled.
+   * Non-persisting and advisory. The audience is reported as counts only,
+   * never as Member rows.
+   */
+  async previewRoutineVoiceReadiness(wid, request) {
+    return this.fetch(
+      `w/${wid}/routines/preview-voice-readiness`,
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      }
+    );
+  }
   /** List routines with optional pagination and active status filtering. */
   async getRoutines(wid, options = {}) {
     const params = new URLSearchParams();
@@ -3323,6 +3453,8 @@ var EventsApi = class extends BaseApiClient {
     if (options.sortOrder) params.append("sortOrder", options.sortOrder);
     if (options.owner) params.append("owner", options.owner);
     if (options.ownerId) params.append("ownerId", options.ownerId.toString());
+    if (options.agentId) params.append("agentId", options.agentId.toString());
+    if (options.agentOnly) params.append("agentOnly", "true");
     return this.fetch(
       `w/${wid}/routines${params.toString() ? `?${params.toString()}` : ""}`
     );
@@ -4299,7 +4431,14 @@ var InboxesApi = class extends BaseApiClient {
   async getInboxes(wid) {
     return this.fetch(`w/${wid}/inboxes`);
   }
-  /** Get an inbox by ID. */
+  /**
+   * Get an inbox by ID or UUID.
+   *
+   * The route has always taken either (`inbox_id: str = Path(..., description=
+   * "Inbox ID or UUID")`); the signature said `number`, which put the UUID path
+   * out of reach for a caller holding an inbox ref from the activity feed —
+   * where refs are UUID-only by design.
+   */
   async getInbox(wid, id) {
     return this.fetch(`w/${wid}/inboxes/${id}`);
   }
@@ -4838,6 +4977,19 @@ var MembersApi = class extends BaseApiClient {
   async getWorkspaceMember(wid, memberId) {
     return this.fetch(`w/${wid}/members/${memberId}`);
   }
+  /**
+   * Get one member of an org's workspace, under `org:read`.
+   *
+   * The same record and the same shape as `getWorkspaceMember`, for a reader
+   * whose authority is the org rather than a member row in that workspace —
+   * an org Activity pane opening a member it just listed. A workspace outside
+   * the org is a 404, indistinguishable from a member id that does not exist.
+   */
+  async getOrgWorkspaceMember(orgUuid, workspaceUuid, memberId) {
+    return this.fetch(
+      `o/${orgUuid}/activity/workspaces/${workspaceUuid}/members/${memberId}`
+    );
+  }
   /** Create a new workspace member. */
   async createWorkspaceMember(wid, data) {
     return this.fetch(`w/${wid}/members`, {
@@ -5017,17 +5169,11 @@ var MembersApi = class extends BaseApiClient {
    * operator can decide whether to skip or explicitly overwrite before
    * committing. Requires MEMBERS_ADMIN and is bulk-PHI audited server-side.
    */
-  async previewImportMembers(wid, file, newMemberRoleId, options) {
+  async previewImportMembers(wid, file, newMemberRoleId) {
     const formData = new FormData();
     formData.append("file", file);
     const params = new URLSearchParams();
     params.append("new_member_role_id", newMemberRoleId.toString());
-    if (options?.trustEmailAddresses) {
-      params.append("trust_email_addresses", "true");
-    }
-    if (options?.trustPhoneNumbers) {
-      params.append("trust_phone_numbers", "true");
-    }
     const response = await this.fetchRaw(
       `w/${wid}/members/import/preview?${params.toString()}`,
       {
@@ -5054,12 +5200,6 @@ var MembersApi = class extends BaseApiClient {
     formData.append("file", file);
     const params = new URLSearchParams();
     params.append("new_member_role_id", newMemberRoleId.toString());
-    if (options?.trustEmailAddresses) {
-      params.append("trust_email_addresses", "true");
-    }
-    if (options?.trustPhoneNumbers) {
-      params.append("trust_phone_numbers", "true");
-    }
     if (options?.identityConflictPolicy) {
       params.append("identity_conflict_policy", options.identityConflictPolicy);
     }
@@ -5308,13 +5448,255 @@ var MembersApi = class extends BaseApiClient {
   async getMemberSyncLinks(wid, memberId) {
     return this.fetch(`w/${wid}/members/${memberId}/sync-links`);
   }
+  async getMemberRelationships(wid, memberId, params) {
+    const search = new URLSearchParams();
+    if (params?.page) search.set("page", String(params.page));
+    if (params?.pageSize) search.set("pageSize", String(params.pageSize));
+    if (params?.kind) search.set("kind", params.kind);
+    const qs = search.toString();
+    return this.fetch(
+      `w/${wid}/members/${memberId}/relationships${qs ? `?${qs}` : ""}`
+    );
+  }
+  async createMemberRelationship(wid, memberId, body) {
+    return this.fetch(`w/${wid}/members/${memberId}/relationships`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async archiveMemberRelationship(wid, memberId, relationshipId) {
+    return this.fetch(
+      `w/${wid}/members/${memberId}/relationships/${relationshipId}`,
+      { method: "DELETE" }
+    );
+  }
 };
 
-// src/api/activity-timeline.ts
-var ActivityTimelineApi = class extends BaseApiClient {
-  /** One page of activity. Omit `cursor` for a fresh snapshot. */
-  async queryActivityTimeline(wid, request = {}) {
-    return this.fetch(`w/${wid}/activity-timeline/query`, {
+// src/api/activity.ts
+var ActivityApi = class extends BaseApiClient {
+  /** The account mount: this caller's whole estate, at any grain. */
+  async queryActivity(request) {
+    return this.fetch("activity/query", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Latest admitted event for each workspace-qualified Activity subject.
+   * Scope authorization and any event-type leaf authorization are both
+   * applied before a subject is returned.
+   */
+  async queryActivityLatestSubjects(request) {
+    return this.fetch("activity/latest-subjects", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * The account mount's priority lane — one queue per human. `openedAfter`
+   * may bound the active backlog without changing the priority policy.
+   */
+  async queryActivityOpenItems(request = {}) {
+    return this.fetch("activity/open-items", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * The account mount's one view: one stream of occurrences, some carrying
+   * open state. The window bounds the event axis; open items older than it
+   * arrive as `olderOpenCount`, never hidden.
+   */
+  async queryActivityOneView(request) {
+    return this.fetch("activity/one-view", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The account mount's badge numbers. */
+  async getActivityCounts(request = {}) {
+    return this.fetch("activity/counts", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * What this caller's estate admits, so a client renders honest controls.
+   *
+   * Account mount only, and deliberately so: the org and workspace mounts
+   * answer the same question through the surfaces that already serve their
+   * membership. Not an authorization decision — every read re-derives that.
+   */
+  async getActivityCapabilities() {
+    return this.fetch("activity/capabilities", { method: "GET" });
+  }
+  /** The org mount. `org:info` is the entry gate; `org:read` widens the rows. */
+  async queryOrgActivity(orgUuid, request) {
+    return this.fetch(`o/${orgUuid}/activity/query`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async queryOrgActivityLatestSubjects(orgUuid, request) {
+    return this.fetch(`o/${orgUuid}/activity/latest-subjects`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The org mount's priority lane. */
+  async queryOrgActivityOpenItems(orgUuid, request = {}) {
+    return this.fetch(`o/${orgUuid}/activity/open-items`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The org mount's one view. */
+  async queryOrgActivityOneView(orgUuid, request) {
+    return this.fetch(`o/${orgUuid}/activity/one-view`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The org mount's badge numbers. */
+  async getOrgActivityCounts(orgUuid, request = {}) {
+    return this.fetch(`o/${orgUuid}/activity/counts`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * The specifics behind a page of aggregate lines, in one round trip.
+   *
+   * Each entry of `request.lines` is an aggregate line's **own server-issued
+   * drill**, POSTed back verbatim, and the response is positional with it — so
+   * a caller maps groups back to rows without inventing a key and without a
+   * second expression of the slice that could drift from the count above it.
+   *
+   * Aggregate-shaped, never row-level: counts per PHI-silent key. A digest the
+   * server could not finish comes back with `complete: false` and no groups,
+   * which a client renders as the plain count phrase rather than as a slice
+   * presented as the whole.
+   */
+  async queryActivityDigest(request) {
+    return this.fetch("activity/digest", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The org mount's digest. */
+  async queryOrgActivityDigest(orgUuid, request) {
+    return this.fetch(`o/${orgUuid}/activity/digest`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The workspace mount's digest. */
+  async queryWorkspaceActivityDigest(workspaceUuid, request) {
+    return this.fetch(`w/${workspaceUuid}/activity/digest`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The workspace mount. The request's own member session carries its scopes. */
+  async queryWorkspaceActivity(workspaceUuid, request) {
+    return this.fetch(`w/${workspaceUuid}/activity/query`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async queryWorkspaceActivityLatestSubjects(workspaceUuid, request) {
+    return this.fetch(`w/${workspaceUuid}/activity/latest-subjects`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The workspace mount's priority lane. */
+  async queryWorkspaceActivityOpenItems(workspaceUuid, request = {}) {
+    return this.fetch(`w/${workspaceUuid}/activity/open-items`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The workspace mount's one view. */
+  async queryWorkspaceActivityOneView(workspaceUuid, request) {
+    return this.fetch(`w/${workspaceUuid}/activity/one-view`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The workspace mount's badge numbers. */
+  async getWorkspaceActivityCounts(workspaceUuid, request = {}) {
+    return this.fetch(`w/${workspaceUuid}/activity/counts`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Hydrate a page of typed refs in one round trip.
+   *
+   * The relief valve the design names for chatty hydration, and the by-UUID
+   * read path most entity kinds otherwise lack: nineteen kinds resolve here,
+   * each through the workspace's own live authorizers under the caller's
+   * session. One request per workspace per listing, instead of one per ref.
+   *
+   * **Every requested ref comes back**, in the order it was sent and
+   * deduplicated on `(kind, uuid)`. A ref the caller may not see is an entry
+   * with `status: 'unresolved'` — never a 404, and never an omission, so a
+   * page's ability to render never depends on what it happens to name.
+   * `status: 'unsupported'` means this build has no by-UUID path for that
+   * kind at all (account, org, workspace, domain, subscription and the
+   * commerce kinds; see the resolve registry for each one's reason) — those
+   * resolve through the mount that owns them, and retrying here will not
+   * help.
+   *
+   * PHI: resolved labels are member-identifying data. They belong in the UI
+   * and nowhere else — never a log line, never an error message.
+   */
+  async resolveEntityRefs(workspaceUuid, request) {
+    return this.fetch(`w/${workspaceUuid}/entity-refs/resolve`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Hydrate a page of typed refs spanning an org's workspaces, in one round
+   * trip. `org:info` is the gate; what it buys differs per workspace, and the
+   * server decides — an `org:read` holder reads every workspace in the org,
+   * an `org:info` holder the ones they belong to.
+   *
+   * The request groups refs by workspace because the same UUID under two
+   * workspaces is two entities. A group naming a workspace this caller cannot
+   * reach comes back entirely `unresolved` — the same answer a denied ref
+   * gets, never an error.
+   *
+   * Caps: at most 500 refs and 25 workspaces across the whole request, and a
+   * workspace may be named at most once in it. Each answered group carries the
+   * same per-entry contract as the workspace mount: every requested ref comes
+   * back, with a marker status rather than an omission.
+   *
+   * PHI: resolved labels are member-identifying data. They belong in the UI
+   * and nowhere else — never a log line, never an error message.
+   */
+  async resolveOrgEntityRefs(orgUuid, request) {
+    return this.fetch(`o/${orgUuid}/activity/entity-refs/resolve`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Hydrate a page of typed refs spanning the caller's whole estate.
+   *
+   * The same grouped body as the org mount, and the same rule that the server
+   * chooses each group's authority: a workspace the caller belongs to resolves
+   * under their own member row, and a workspace they reach by holding
+   * `org:read` on its org resolves under that. A client never states which,
+   * because stating it would mean carrying a copy of the policy.
+   *
+   * PHI: resolved labels are member-identifying data. They belong in the UI
+   * and nowhere else — never a log line, never an error message.
+   */
+  async resolveAccountEntityRefs(request) {
+    return this.fetch(`activity/entity-refs/resolve`, {
       method: "POST",
       body: JSON.stringify(request)
     });
@@ -5508,6 +5890,10 @@ var MondayIntegrationApi = class extends BaseApiClient {
 
 // src/api/intervention-requests.ts
 var InterventionRequestsApi = class extends BaseApiClient {
+  /** List every visible Chat that currently needs attention in Agent Mode. */
+  async getAgentModeAttention(wid) {
+    return this.fetch(`w/${wid}/agent-mode/attention`);
+  }
   /** List intervention requests in a workspace, newest first. */
   async getInterventionRequests(wid, params = {}) {
     const query = new URLSearchParams();
@@ -5521,6 +5907,23 @@ var InterventionRequestsApi = class extends BaseApiClient {
       `w/${wid}/intervention-requests${qs ? `?${qs}` : ""}`
     );
   }
+  /**
+   * Resolve one intervention request. One row, one resolution — whoever takes
+   * it closes it for everyone who was notified. Resolving an already-resolved
+   * request is a 409 conflict; a non-escalation request is a 409 too.
+   *
+   * The JSON body (empty when no note is supplied) is required as a CSRF
+   * barrier (GRA-6284), so a cross-site form POST cannot reach it.
+   */
+  async resolveInterventionRequest(wid, requestId, params = {}) {
+    return this.fetch(
+      `w/${wid}/intervention-requests/${requestId}/resolve`,
+      {
+        method: "POST",
+        body: JSON.stringify(params)
+      }
+    );
+  }
 };
 
 // src/api/notification-rules.ts
@@ -5602,12 +6005,6 @@ var OperatorApi = class extends BaseApiClient {
   async getPresenceStatus(wid) {
     return this.fetch(`w/${wid}/presence/me`);
   }
-  /** Disconnect the current member's presence session. */
-  async disconnectPresence(wid) {
-    return this.fetch(`w/${wid}/presence/disconnect-self`, {
-      method: "POST"
-    });
-  }
   // Operator chat message methods
   /** Get paginated chat messages for an operator chat. */
   async getOperatorChatMessages(wid, chatId, limit = 50, offset = 0) {
@@ -6177,6 +6574,28 @@ var OrgApi = class extends BaseApiClient {
   async getLegalEntity(orgUuid, legalEntityUuid) {
     return this.fetch(`o/${orgUuid}/legal-entities/${legalEntityUuid}`);
   }
+  /**
+   * Read one registration draft for a legal entity.
+   *
+   * A draft is what the operator has typed but not submitted. It exists so
+   * data entry is never gated on a prerequisite: someone can write down the
+   * caller-ID name today and submit it the day the business is verified.
+   */
+  async getRegistrationDraft(orgUuid, legalEntityUuid, kind) {
+    return this.fetch(
+      `o/${orgUuid}/legal-entities/${legalEntityUuid}/registration-drafts/${kind}`
+    );
+  }
+  /**
+   * Save one registration draft. Always accepted — the server refuses only
+   * an oversized body, never an unfinished one.
+   */
+  async saveRegistrationDraft(orgUuid, legalEntityUuid, kind, data) {
+    return this.fetch(
+      `o/${orgUuid}/legal-entities/${legalEntityUuid}/registration-drafts/${kind}`,
+      { method: "PUT", body: JSON.stringify({ data }) }
+    );
+  }
   /** Cached voice trust product state (CNAM / SHAKEN-STIR / Voice Integrity) for one legal entity. */
   async getVoiceTrustProducts(orgUuid, legalEntityUuid) {
     return this.fetch(
@@ -6350,6 +6769,42 @@ var OrgApi = class extends BaseApiClient {
       }
     );
   }
+  // =========================================================================
+  // Organization webhook endpoints (GRA-8314)
+  // =========================================================================
+  async listOrgWebhookEndpoints(orgIdOrUuid) {
+    return this.fetch(`o/${orgIdOrUuid}/webhooks`);
+  }
+  /**
+   * The subscribable event-type vocabulary for the org UI's event-type
+   * picker — exactly what the create/update validators accept, so the UI
+   * never offers a type the API would reject.
+   */
+  async listOrgWebhookEventTypes(orgIdOrUuid) {
+    return this.fetch(`o/${orgIdOrUuid}/webhooks/event-types`);
+  }
+  async createOrgWebhookEndpoint(orgIdOrUuid, data) {
+    return this.fetch(`o/${orgIdOrUuid}/webhooks`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateOrgWebhookEndpoint(orgIdOrUuid, endpointUuid, data) {
+    return this.fetch(`o/${orgIdOrUuid}/webhooks/${endpointUuid}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteOrgWebhookEndpoint(orgIdOrUuid, endpointUuid) {
+    return this.fetch(`o/${orgIdOrUuid}/webhooks/${endpointUuid}`, {
+      method: "DELETE"
+    });
+  }
+  async listOrgWebhookEndpointDeliveries(orgIdOrUuid, endpointUuid, limit = 50) {
+    return this.fetch(
+      `o/${orgIdOrUuid}/webhooks/${endpointUuid}/deliveries?limit=${limit}`
+    );
+  }
 };
 function businessProfilePath(orgUuid, legalEntityUuid) {
   return legalEntityUuid ? `o/${orgUuid}/legal-entities/${legalEntityUuid}/business-profile` : `o/${orgUuid}/business-profile`;
@@ -6770,6 +7225,8 @@ var PersonasApi = class extends BaseApiClient {
     const q = new URLSearchParams();
     if (params?.page !== void 0) q.set("page", String(params.page));
     if (params?.pageSize !== void 0) q.set("pageSize", String(params.pageSize));
+    if (params?.includeArchived !== void 0)
+      q.set("includeArchived", String(params.includeArchived));
     const qs = q.toString() ? `?${q.toString()}` : "";
     return this.fetch(`w/${wid}/personas${qs}`);
   }
@@ -6788,6 +7245,18 @@ var PersonasApi = class extends BaseApiClient {
       body: JSON.stringify(data)
     });
   }
+  async archivePersona(wid, id) {
+    return this.fetch(`w/${wid}/personas/${id}/archive`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+  async unarchivePersona(wid, id) {
+    return this.fetch(`w/${wid}/personas/${id}/unarchive`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
   async deletePersona(wid, id) {
     return this.fetch(`w/${wid}/personas/${id}`, { method: "DELETE" });
   }
@@ -8462,14 +8931,74 @@ var JourneysApi = class extends BaseApiClient {
   async getJourneyAuthoring(wid, journeyId) {
     return this.fetch(`w/${wid}/journeys/${journeyId}/authoring`);
   }
-  /** Create a new journey. Returns the READ projection (`JourneyRead`). */
+  /**
+   * Atomically replace a v2 Journey's whole definition (Journey v2 plan §3.8).
+   *
+   * ONE request carries the ordered touches, the wait into each touch, the
+   * ordered Endings, action associations, goals, and
+   * `expectedUpdatedAt` for optimistic concurrency. It is a full replacement,
+   * not a patch — omitting `goals` is the one exception and leaves them alone.
+   *
+   * Returns the AUTHORING projection (`Journey`): the caller just wrote the
+   * CEL and holds the `journeys:write` scope that authorizes reading it back.
+   *
+   * Refusals are HTTP 409 with a stable `code`:
+   *   * `journey_v2_execution_model_mismatch` — the Journey is legacy; use the
+   *     step/connection/goal endpoints.
+   *   * `journey_v2_structural_edit_not_allowed` — it is live; pause it first.
+   *   * `journey_v2_definition_conflict` — someone saved first; reload.
+   *   * `journey_v2_invalid_topology` — the resulting graph is not executable;
+   *     the body carries `issues` (codes and resource uuids, never CEL).
+   */
+  async putJourneyV2Definition(wid, journeyId, data) {
+    return this.fetch(`w/${wid}/journeys/${journeyId}/v2-definition`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Dry-run the v2 publish validator against the STORED definition.
+   *
+   * Answers "could I activate this right now?" without attempting the
+   * transition. Issues carry closed codes and resource uuids only — never CEL
+   * and never member data — so they are safe to render or log.
+   */
+  async getJourneyV2Validation(wid, journeyId) {
+    return this.fetch(
+      `w/${wid}/journeys/${journeyId}/v2-definition/validation`
+    );
+  }
+  /**
+   * MemberFilter ids and names, for the Journey authoring picker.
+   *
+   * A v2 wait, route or Ending may carry a structured MemberFilter predicate
+   * and the author selects it by NAME (rule-filters plan §3.10). This is the
+   * catalogue for that control and the whole of what it needs: two scalars per
+   * filter, no `query` predicate, no rules, no counts.
+   *
+   * Authorized on `journeys:write` alone — deliberately NOT the Members
+   * surface's `MembersApi.getMemberFilters`, which is `members:read`
+   * because it returns each filter's predicate. Journey authoring should not
+   * require Member-read access to name a cohort.
+   */
+  async getJourneyFilterOptions(wid) {
+    return this.fetch(`w/${wid}/journeys/filter-options`);
+  }
+  /** Create a new journey. Returns the READ projection (`JourneyRead`). */
   async createJourney(wid, data) {
     return this.fetch(`w/${wid}/journeys`, {
       method: "POST",
       body: JSON.stringify(data)
     });
   }
-  /** Update an existing journey. Returns the READ projection (`JourneyRead`). */
+  /**
+   * Update an existing journey. Returns the READ projection (`JourneyRead`).
+   *
+   * `executionModel` is excluded: it is a CREATE-only field. Flipping a live
+   * Journey's engine is a guarded, audited migration operation (Journey v2
+   * plan §3.11), so the server has no update counterpart and sending one here
+   * would silently do nothing.
+   */
   async updateJourney(wid, journeyId, data) {
     return this.fetch(`w/${wid}/journeys/${journeyId}`, {
       method: "PUT",
@@ -8576,8 +9105,6 @@ var JourneysApi = class extends BaseApiClient {
       qs.set("currentTaskId", String(params.currentTaskId));
     if (params?.runtimeFailureEdgeId !== void 0)
       qs.set("runtimeFailureEdgeId", String(params.runtimeFailureEdgeId));
-    if (params?.memberJourneyId !== void 0)
-      qs.set("memberJourneyId", String(params.memberJourneyId));
     const query = qs.toString();
     return this.fetch(
       `w/${wid}/journeys/${journeyId}/members${query ? `?${query}` : ""}`
@@ -8731,6 +9258,15 @@ var WorkflowsApi = class extends BaseApiClient {
   async getWorkflow(wid, id) {
     return this.fetch(`w/${wid}/workflows/${id}`);
   }
+  async getWorkflowOpeningTurnConversionReport(wid, id) {
+    return this.fetch(`w/${wid}/workflows/${id}/opening-turn/conversion-report`);
+  }
+  async convertWorkflowStartTaskOpeningMessage(wid, id, expectedRuleId) {
+    return this.fetch(`w/${wid}/workflows/${id}/opening-turn/convert-start-task-message`, {
+      method: "POST",
+      body: JSON.stringify({ expectedRuleId })
+    });
+  }
   /** Get activity metrics for a single workflow. */
   async getWorkflowActivity(wid, id, options) {
     const params = options?.days ? `?days=${options.days}` : "";
@@ -9222,7 +9758,9 @@ var Scope = /* @__PURE__ */ ((Scope2) => {
 var BulkMemberResultStatus = {
   created: "created",
   updated: "updated",
-  failed: "failed"
+  failed: "failed",
+  conflict: "conflict",
+  skipped: "skipped"
 };
 var MemberImportMatchInfoMatchType = {
   external_id: "external_id",
@@ -9236,6 +9774,7 @@ var MemberImportPreviewRowAction = {
   update: "update",
   unchanged: "unchanged",
   conflict: "conflict",
+  skipped: "skipped",
   error: "error"
 };
 
@@ -9384,6 +9923,8 @@ var EventRuleActionType = /* @__PURE__ */ ((EventRuleActionType2) => {
   EventRuleActionType2["CONNECTOR_OPERATION"] = "connector:operation";
   EventRuleActionType2["ECW_REFRESH_MEMBER_ENCOUNTERS"] = "ecw:refresh_member_encounters";
   EventRuleActionType2["PLAY_AUDIO"] = "audio:play";
+  EventRuleActionType2["CHARLESTON_SEND_PMD_PAGE"] = "charleston:send_pmd_page";
+  EventRuleActionType2["PATIENTSYNC_TRANSFER"] = "patientsync:transfer";
   return EventRuleActionType2;
 })(EventRuleActionType || {});
 function eventRuleActionParams(params) {
@@ -9405,6 +9946,7 @@ var WorkspaceFeature = /* @__PURE__ */ ((WorkspaceFeature2) => {
   WorkspaceFeature2["BROWSER"] = "browser";
   WorkspaceFeature2["WEB_SEARCH"] = "web_search";
   WorkspaceFeature2["CALENDAR"] = "calendar";
+  WorkspaceFeature2["JOURNEY_V2_EDITOR"] = "journey_v2_editor";
   WorkspaceFeature2["EXPERIMENTS"] = "experiments";
   WorkspaceFeature2["MAILBOX_USER_INPUT"] = "mailbox_user_input";
   WorkspaceFeature2["FORKED_TRAJECTORIES"] = "forked_trajectories";
@@ -9567,6 +10109,7 @@ var ModelProvider = {
   elevenlabs: "elevenlabs",
   deepgram: "deepgram",
   xai: "xai",
+  fireworks: "fireworks",
   custom: "custom"
 };
 var ModelType = {
@@ -9669,6 +10212,24 @@ var FhirClientType = /* @__PURE__ */ ((FhirClientType2) => {
   return FhirClientType2;
 })(FhirClientType || {});
 
+// src/types/generated/qualification.ts
+var TestChatRunLane = {
+  text: "text",
+  web_realtime: "web_realtime",
+  core_agent_only: "core_agent_only",
+  unsupported: "unsupported",
+  unknown: "unknown"
+};
+var TestChatRunOutcome = {
+  simulator_end: "simulator_end",
+  terminal_tool: "terminal_tool",
+  agent_silent: "agent_silent",
+  max_turns: "max_turns",
+  human_end: "human_end",
+  configuration_failure: "configuration_failure",
+  instrument_failure: "instrument_failure"
+};
+
 // src/types/qualification-types.ts
 var CriterionType = /* @__PURE__ */ ((CriterionType2) => {
   CriterionType2["EXPRESSION"] = "expression";
@@ -9727,6 +10288,253 @@ var ConsentMethod = /* @__PURE__ */ ((ConsentMethod2) => {
   return ConsentMethod2;
 })(ConsentMethod || {});
 
+// src/types/generated/member_relationship.ts
+var MemberRelationshipKind = {
+  parent_of: "parent_of",
+  sibling_of: "sibling_of",
+  spouse_of: "spouse_of",
+  caregiver_of: "caregiver_of",
+  emergency_contact_of: "emergency_contact_of",
+  next_of_kin_of: "next_of_kin_of",
+  legal_guardian_of: "legal_guardian_of",
+  healthcare_agent_of: "healthcare_agent_of",
+  doctor_of: "doctor_of",
+  primary_contact_of: "primary_contact_of"
+};
+var RelatedMemberRole = {
+  parent: "parent",
+  child: "child",
+  sibling: "sibling",
+  spouse: "spouse",
+  caregiver: "caregiver",
+  care_recipient: "care_recipient",
+  emergency_contact: "emergency_contact",
+  emergency_contact_for: "emergency_contact_for",
+  next_of_kin: "next_of_kin",
+  next_of_kin_for: "next_of_kin_for",
+  legal_guardian: "legal_guardian",
+  legal_guardian_for: "legal_guardian_for",
+  healthcare_agent: "healthcare_agent",
+  healthcare_agent_for: "healthcare_agent_for",
+  doctor: "doctor",
+  patient: "patient",
+  primary_contact: "primary_contact",
+  primary_contact_for: "primary_contact_for"
+};
+var RelationshipCardinality = {
+  many_to_many: "many_to_many",
+  one_to_one: "one_to_one",
+  one_per_target: "one_per_target"
+};
+
+// src/types/generated/member_relationship_catalog.ts
+var MEMBER_RELATIONSHIP_KINDS = [
+  {
+    "kind": "parent_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "parent",
+        "label": "Parent",
+        "inverseLabel": "Child",
+        "description": "This person is a parent of the member. For a minor, also add Legal guardian if they should read the chart."
+      },
+      {
+        "role": "child",
+        "label": "Child",
+        "inverseLabel": "Parent",
+        "description": "This person is a child of the member."
+      }
+    ]
+  },
+  {
+    "kind": "sibling_of",
+    "cardinality": "many_to_many",
+    "symmetric": true,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "sibling",
+        "label": "Sibling",
+        "inverseLabel": "Sibling",
+        "description": "These members are siblings."
+      }
+    ]
+  },
+  {
+    "kind": "spouse_of",
+    "cardinality": "one_to_one",
+    "symmetric": true,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "spouse",
+        "label": "Spouse",
+        "inverseLabel": "Spouse",
+        "description": "These members are spouses or partners."
+      }
+    ]
+  },
+  {
+    "kind": "caregiver_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "caregiver",
+        "label": "Caregiver",
+        "inverseLabel": "Care recipient",
+        "description": "This person provides care for the member at home."
+      },
+      {
+        "role": "care_recipient",
+        "label": "Care recipient",
+        "inverseLabel": "Caregiver",
+        "description": "This person receives care from the member."
+      }
+    ]
+  },
+  {
+    "kind": "emergency_contact_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "emergency_contact",
+        "label": "Emergency contact",
+        "inverseLabel": "Emergency contact for",
+        "description": "This person is the member's emergency contact."
+      },
+      {
+        "role": "emergency_contact_for",
+        "label": "Emergency contact for",
+        "inverseLabel": "Emergency contact",
+        "description": "The member is listed as this person's emergency contact."
+      }
+    ]
+  },
+  {
+    "kind": "next_of_kin_of",
+    "cardinality": "one_per_target",
+    "symmetric": false,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "next_of_kin",
+        "label": "Next of kin",
+        "inverseLabel": "Next of kin for",
+        "description": "This person is the member's designated next of kin. A member has at most one."
+      },
+      {
+        "role": "next_of_kin_for",
+        "label": "Next of kin for",
+        "inverseLabel": "Next of kin",
+        "description": "The member is this person's designated next of kin."
+      }
+    ]
+  },
+  {
+    "kind": "legal_guardian_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": true,
+    "roles": [
+      {
+        "role": "legal_guardian",
+        "label": "Legal guardian",
+        "inverseLabel": "Legal guardian for",
+        "description": "Court-appointed guardian, or parent/person with parental responsibility for a minor."
+      },
+      {
+        "role": "legal_guardian_for",
+        "label": "Legal guardian for",
+        "inverseLabel": "Legal guardian",
+        "description": "The member is this person's legal guardian."
+      }
+    ]
+  },
+  {
+    "kind": "healthcare_agent_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": true,
+    "roles": [
+      {
+        "role": "healthcare_agent",
+        "label": "Healthcare agent",
+        "inverseLabel": "Healthcare agent for",
+        "description": "Healthcare power of attorney or health proxy."
+      },
+      {
+        "role": "healthcare_agent_for",
+        "label": "Healthcare agent for",
+        "inverseLabel": "Healthcare agent",
+        "description": "The member is this person's healthcare agent (healthcare power of attorney or health proxy)."
+      }
+    ]
+  },
+  {
+    "kind": "doctor_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": true,
+    "roles": [
+      {
+        "role": "doctor",
+        "label": "Doctor",
+        "inverseLabel": "Patient",
+        "description": "This person is a treating clinician for the member."
+      },
+      {
+        "role": "patient",
+        "label": "Patient",
+        "inverseLabel": "Doctor",
+        "description": "This person is a patient of the member."
+      }
+    ]
+  },
+  {
+    "kind": "primary_contact_of",
+    "cardinality": "one_per_target",
+    "symmetric": false,
+    "grantsChartAccess": true,
+    "roles": [
+      {
+        "role": "primary_contact",
+        "label": "Primary contact",
+        "inverseLabel": "Primary contact for",
+        "description": "This person is the organization's primary contact for the member. A member has at most one."
+      },
+      {
+        "role": "primary_contact_for",
+        "label": "Primary contact for",
+        "inverseLabel": "Primary contact",
+        "description": "The member is this person's assigned primary contact inside the organization."
+      }
+    ]
+  }
+];
+
+// src/types/generated/ui_prompt.ts
+var UiPromptPresentedKind = {
+  render_ui: "render_ui",
+  present_choice_list: "present_choice_list",
+  inline_connect: "inline_connect"
+};
+var UiPromptResponseKind = {
+  render_ui: "render_ui",
+  present_choice_list: "present_choice_list",
+  inline_connect: "inline_connect"
+};
+var UiPromptResponseStatus = {
+  submitted: "submitted",
+  declined: "declined"
+};
+
 // src/api/workspace-invitations.ts
 var WorkspaceInvitationsApi = class extends BaseApiClient {
   /**
@@ -9862,11 +10670,31 @@ var WorkspaceInvitationsApi = class extends BaseApiClient {
 };
 
 // src/api/workspaces.ts
+function planFields(options) {
+  if (!options) return {};
+  const fields = {};
+  if (options.intent !== void 0) fields.intent = options.intent;
+  if (options.expectedPlanFingerprint !== void 0) {
+    fields.expectedPlanFingerprint = options.expectedPlanFingerprint;
+  }
+  if (options.bindings !== void 0 && options.bindings.length > 0) {
+    fields.bindings = options.bindings;
+  }
+  return fields;
+}
 var WorkspacesApi = class extends BaseApiClient {
   /** List all workspaces accessible to the current user. */
   async getWorkspaces() {
     return this.fetch("w/");
   }
+  /**
+   * Compact rows for the workspaces a companion device could enter — the
+   * Lantern picker. Filtered by the same admission policy a device
+   * credential is gated by, without needing the device credential.
+   */
+  async getDeviceAdmissibleWorkspaces() {
+    return this.fetch("w/?can_use_device=1");
+  }
   /** List all publicly visible workspaces. */
   async getPublicWorkspaces() {
     return this.fetch("w/public");
@@ -10160,18 +10988,62 @@ var WorkspacesApi = class extends BaseApiClient {
     const qs = searchParams.toString();
     return this.fetch(`w/${wid}/export${qs ? `?${qs}` : ""}`);
   }
-  /** Preview the result of importing workspace configuration without applying changes. */
-  async previewWorkspaceImport(wid, exportData, importMappings, createNew, autoMap) {
+  /** Preview the result of importing workspace configuration without applying changes.
+   *
+   * Pass `options.intent = 'template_reapply'` to get the deterministic
+   * re-apply plan: `planRows`, `sourceFingerprint` and `planFingerprint` come
+   * back beside the legacy preview items, and the fingerprint is what
+   * `importWorkspace` must be given to apply exactly that projection.
+   */
+  async previewWorkspaceImport(wid, exportData, importMappings, createNew, autoMap, options) {
     return this.fetch(`w/${wid}/preview-import`, {
       method: "POST",
       body: JSON.stringify({
         exportData,
         importMappings,
         createNew,
-        autoMap
+        autoMap,
+        ...planFields(options)
       })
     });
   }
+  /**
+   * Plan a workspace export ZIP against this workspace without importing it.
+   *
+   * The sibling of `previewWorkspaceImport`, and it exists for one reason: a
+   * JSON preview has no archive, so it cannot decide whether File BYTES would
+   * be replaced — that decision compares the archive's blob digest against the
+   * destination's current content digest.
+   */
+  async previewWorkspaceImportZip(wid, archive, options) {
+    const { exportData, importMappings, createNew, autoMap, ...planOptions } = options ?? {};
+    const payload = {
+      importMappings: importMappings ?? {},
+      createNew: createNew ?? {},
+      ...planFields(planOptions)
+    };
+    if (exportData) payload.exportData = exportData;
+    if (autoMap) payload.autoMap = autoMap;
+    const form = new FormData();
+    form.append(
+      "request",
+      new Blob([JSON.stringify(payload)], { type: "application/json" }),
+      "import.json"
+    );
+    form.append("archive", archive, "workspace-export.zip");
+    return this.fetch(`w/${wid}/preview-import.zip`, {
+      method: "POST",
+      body: form
+    });
+  }
+  /**
+   * Everything a template re-apply adds to an import or a preview.
+   *
+   * `bindings` values are sent in the request body only. They are never
+   * projected from a response and must never be logged: the point of a
+   * binding is that a webhook endpoint and a signing secret belong to ONE
+   * target workspace.
+   */
   /** Download a workspace export ZIP (``export.json`` + file blobs). */
   async exportWorkspaceZip(wid, workflowId, scope, exclude) {
     const searchParams = new URLSearchParams();
@@ -10185,46 +11057,138 @@ var WorkspacesApi = class extends BaseApiClient {
   /** Import workspace configuration from exported JSON, or from a ZIP archive.
    * Pass ``archive`` (the ZIP from ``exportWorkspaceZip``) to restore file
    * contents. ``exportData`` may be omitted when the ZIP contains it.
-   */
-  async importWorkspace(wid, exportData, importMappings, createNew, archive) {
-    const payload = {
-      importMappings,
-      createNew
-    };
-    if (exportData) {
-      payload.exportData = exportData;
-    }
+   *
+   * ``activateWebhookRules`` is safety-default false: imported
+   * ``webhook:send`` EventRules are force-disabled unless the operator
+   * opts in. An exported-inactive rule stays inactive either way.
+   *
+   * With ``options.intent = 'template_reapply'`` this is the GUARDED apply.
+   * It requires ``options.expectedPlanFingerprint`` — the digest a preview
+   * returned — and answers 200 ``success``, 200 ``noop`` (the target already
+   * matched the template, so nothing at all was recorded), 409
+   * ``stale_import_plan`` or 409 ``import_plan_refused``. Both 409s commit
+   * nothing and carry the complete values-free ``planRows``.
+   */
+  async importWorkspace(wid, exportData, importMappings, createNew, archive, activateWebhookRules, autoMap, options) {
     if (archive) {
-      const form = new FormData();
-      form.append(
-        "request",
-        new Blob([JSON.stringify(payload)], { type: "application/json" }),
-        "import.json"
-      );
-      form.append("archive", archive, "workspace-export.zip");
-      return this.fetch(`w/${wid}/import.zip`, {
-        method: "POST",
-        body: form
+      return this.importWorkspaceZip(wid, archive, {
+        ...options,
+        exportData,
+        importMappings,
+        createNew,
+        autoMap,
+        activateWebhookRules
       });
     }
     if (!exportData) {
       throw new Error("exportData is required for JSON import");
     }
+    const payload = {
+      exportData,
+      importMappings,
+      createNew,
+      ...planFields(options)
+    };
+    if (activateWebhookRules) {
+      payload.activateWebhookRules = activateWebhookRules;
+    }
+    if (autoMap) {
+      payload.autoMap = autoMap;
+    }
     return this.fetch(`w/${wid}/import`, {
       method: "POST",
       body: JSON.stringify(payload)
     });
   }
+  /**
+   * Apply a workspace export ZIP to this workspace.
+   *
+   * The apply sibling of `previewWorkspaceImportZip`, and the same multipart
+   * shape: the archive travels as `archive`, everything else as one JSON
+   * `request` part. `exportData` defaults to `export.json` inside the ZIP, so
+   * it is sent only to override it.
+   *
+   * With `options.intent = 'template_reapply'` this is the GUARDED apply. It
+   * requires `options.expectedPlanFingerprint` — the digest a preview
+   * returned — and answers 200 `success`, 200 `noop` (the target already
+   * matched the template, so nothing at all was recorded), 409
+   * `stale_import_plan` or 409 `import_plan_refused`. Both 409s commit
+   * nothing and carry the complete values-free `planRows`.
+   *
+   * `options.bindings` values are sent in the request body only. They are
+   * never projected from a response and must never be logged: the point of a
+   * binding is that a webhook endpoint and a signing secret belong to ONE
+   * target workspace.
+   */
+  async importWorkspaceZip(wid, archive, options) {
+    const {
+      exportData,
+      importMappings,
+      createNew,
+      autoMap,
+      activateWebhookRules,
+      ...planOptions
+    } = options ?? {};
+    const payload = {
+      importMappings: importMappings ?? {},
+      createNew: createNew ?? {},
+      ...planFields(planOptions)
+    };
+    if (exportData) payload.exportData = exportData;
+    if (activateWebhookRules) payload.activateWebhookRules = activateWebhookRules;
+    if (autoMap) payload.autoMap = autoMap;
+    const form = new FormData();
+    form.append(
+      "request",
+      new Blob([JSON.stringify(payload)], { type: "application/json" }),
+      "import.json"
+    );
+    form.append("archive", archive, "workspace-export.zip");
+    return this.fetch(`w/${wid}/import.zip`, {
+      method: "POST",
+      body: form
+    });
+  }
+  /**
+   * Reconnectable EventRules skipped by the latest workspace import, grouped
+   * by the missing phone / inbox / member. Templates and action params are
+   * not returned.
+   */
+  async getImportSkippedRules(wid, status) {
+    const params = new URLSearchParams();
+    if (status !== void 0) {
+      params.set("status", status);
+    }
+    const qs = params.toString();
+    return this.fetch(
+      `w/${wid}/import/skipped-rules${qs ? `?${qs}` : ""}`
+    );
+  }
+  /** Current bounded phone, inbox, and phone-chat binding gaps after an import. */
+  async getImportReadiness(wid) {
+    return this.fetch(`w/${wid}/import/readiness`);
+  }
+  /**
+   * Re-point every outstanding skipped EventRule that needed the same source
+   * resource onto a re-provisioned one, recreating each rule from its
+   * preserved definition. Repeat calls no-op on already-reconnected rows.
+   */
+  async rebuildImportSkippedRules(wid, body) {
+    return this.fetch(
+      `w/${wid}/import/skipped-rules/rebuild`,
+      { method: "POST", body: JSON.stringify(body) }
+    );
+  }
   /** Preview a workspace import using the legacy untyped interface. */
   // Legacy method for backward compatibility
-  async previewImportWorkspace(wid, exportData, importMappings = {}, createNew = {}) {
+  async previewImportWorkspace(wid, exportData, importMappings = {}, createNew = {}, autoMap) {
+    const payload = { exportData, importMappings, createNew };
+    if (autoMap) {
+      payload.autoMap = autoMap;
+    }
     return this.fetch(`w/${wid}/preview-import`, {
       method: "POST",
-      body: JSON.stringify({
-        exportData,
-        importMappings,
-        createNew
-      })
+      body: JSON.stringify(payload)
     });
   }
   /** List available themes for a workspace. */
@@ -10372,7 +11336,7 @@ function createApiModules(apiKey, baseUrl, customFetch) {
     connectionSync: new ConnectionSyncApi(apiKey, baseUrl, customFetch),
     mcpServers: new McpServersApi(apiKey, baseUrl, customFetch),
     members: new MembersApi(apiKey, baseUrl, customFetch),
-    activityTimeline: new ActivityTimelineApi(apiKey, baseUrl, customFetch),
+    activity: new ActivityApi(apiKey, baseUrl, customFetch),
     motd: new MotdApi(apiKey, baseUrl, customFetch),
     trackedLinks: new TrackedLinksApi(apiKey, baseUrl, customFetch),
     confluence: new ConfluenceApi(apiKey, baseUrl, customFetch),
@@ -10419,6 +11383,8 @@ var WORKSPACE_METHOD_NAMES = [
   "archiveDataType",
   "archiveJourney",
   "archiveMember",
+  "archiveMemberRelationship",
+  "archivePersona",
   "archivePhoneNumber",
   "archiveStep",
   "archiveTask",
@@ -10471,6 +11437,8 @@ var WORKSPACE_METHOD_NAMES = [
   "createCalendarEventType",
   "createCalendarSchedule",
   "createChat",
+  "createChatInteractionSession",
+  "transitionChatInteractionSession",
   "createChatCompletion",
   "createChatFilter",
   "createChatLabel",
@@ -10500,6 +11468,7 @@ var WORKSPACE_METHOD_NAMES = [
   "createMemberFilter",
   "createMemberLabel",
   "createMemberMemory",
+  "createMemberRelationship",
   "createMemberRole",
   "createMenuItem",
   "createNotificationRule",
@@ -10602,7 +11571,6 @@ var WORKSPACE_METHOD_NAMES = [
   "disconnectConfluence",
   "disconnectHubspot",
   "disconnectMondayConnection",
-  "disconnectPresence",
   "disconnectSalesforce",
   "discordLinkPreflight",
   "discoverOAuthMetadata",
@@ -10665,6 +11633,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getAccessGrant",
   "getAccessGrants",
   "getAgent",
+  "getAgentModeAttention",
   "getAgentTask",
   "getAgentTaskMessages",
   "getAgentTasks",
@@ -10696,7 +11665,9 @@ var WORKSPACE_METHOD_NAMES = [
   "getCharlestonTestDeliveryRecipients",
   "getChat",
   "getChatAssignmentTasks",
+  "getChatBrowserLiveView",
   "getChatCallbacks",
+  "getChatEhrWritebackOutcomes",
   "getChatEmails",
   "getChatFilter",
   "getChatFilterByUuid",
@@ -10705,6 +11676,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getChatLabel",
   "getChatLabelByUuid",
   "getChatLabels",
+  "getChatMachineResources",
   "getChatMessages",
   "getChatModelOverride",
   "getChatPhoneCalls",
@@ -10745,6 +11717,8 @@ var WORKSPACE_METHOD_NAMES = [
   "getDataRecordFilters",
   "getDataRecords",
   "getDataType",
+  "getDataTypeDraft",
+  "getDataTypeVersions",
   "getDataTypeByUuid",
   "getDataTypeBySlug",
   "getDataTypes",
@@ -10788,9 +11762,16 @@ var WORKSPACE_METHOD_NAMES = [
   "listChatRecordings",
   "previewQuery",
   "publishSiteSource",
-  "queryActivityTimeline",
+  "publishDataTypeDraft",
+  "saveDataTypeDraft",
+  "queryWorkspaceActivity",
+  "queryWorkspaceActivityLatestSubjects",
+  "queryWorkspaceActivityOpenItems",
+  "queryWorkspaceActivityOneView",
+  "queryWorkspaceActivityDigest",
   "registerDiscordSlashCommands",
   "reopenWorkspaceSupportRequest",
+  "resolveEntityRefs",
   "resetSiteSource",
   "resolveFilePath",
   "getFileLabel",
@@ -10818,16 +11799,22 @@ var WORKSPACE_METHOD_NAMES = [
   "getHubspotSyncLogs",
   "getHubspotTransformPresets",
   "getICalFeedUrl",
+  "getImportSkippedRules",
+  "getImportReadiness",
+  "rebuildImportSkippedRules",
   "getInbox",
   "getInboxEmail",
   "getInboxEmails",
   "getInboxThreads",
   "getInboxes",
+  "getInterventionRequests",
   "getJourney",
   "getJourneyAuthoring",
+  "getJourneyFilterOptions",
   "getJourneyHealth",
   "getJourneyMembers",
   "getJourneyNotes",
+  "getJourneyV2Validation",
   "getJourneys",
   "getLinkablePhones",
   "getLinkedHealthieMembers",
@@ -10855,6 +11842,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getMemberMemories",
   "getMemberMemory",
   "getMemberRecordCounts",
+  "getMemberRelationships",
   "getMemberRole",
   "getMemberRoleCleanupPlan",
   "getMemberRoleByUuid",
@@ -10903,8 +11891,6 @@ var WORKSPACE_METHOD_NAMES = [
   "getPublicFolder",
   "getPublicFolderFiles",
   "getPublicProducts",
-  "previewPromoCode",
-  "startPromoPlanTrial",
   "getQualification",
   "getQualifications",
   "getRecordingInfo",
@@ -10959,10 +11945,10 @@ var WORKSPACE_METHOD_NAMES = [
   "getUnreadNotificationCount",
   "getUsageDashboard",
   "getVariableRegistry",
-  "getVoiceToken",
   "getVoiceUsageReport",
   "getWebhookLogs",
   "getWorkflow",
+  "getWorkflowOpeningTurnConversionReport",
   "getWorkflowAccessValidation",
   "getWorkflowActivity",
   "getWorkflowConfigValidation",
@@ -10979,6 +11965,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getWorkflows",
   "getWorkflowsActivityBatch",
   "getWorkspace",
+  "getWorkspaceActivityCounts",
   "getWorkspaceBuilder",
   "getWorkspaceBuilders",
   "getWorkspaceCounts",
@@ -10998,7 +11985,7 @@ var WORKSPACE_METHOD_NAMES = [
   "importMembers",
   "importSalesforceMembers",
   "importWorkspace",
-  "initiateCall",
+  "importWorkspaceZip",
   "initiateOutboundCall",
   "inspectPrompt",
   "installHubspot",
@@ -11055,14 +12042,17 @@ var WORKSPACE_METHOD_NAMES = [
   "previewMemberWorkflowVoice",
   "previewRenameFieldSlug",
   "previewImportWorkspace",
+  "previewRoutineVoiceReadiness",
   "previewRoutineWorkflowAccess",
   "previewSchedule",
   "previewTTS",
   "previewTemplate",
   "previewThinkingSound",
   "previewWorkspaceImport",
+  "previewWorkspaceImportZip",
   "provisionClientWorkspace",
   "publishWorkflowRevision",
+  "putJourneyV2Definition",
   "rateMessage",
   "getChatFeedback",
   "reenrollMember",
@@ -11083,6 +12073,7 @@ var WORKSPACE_METHOD_NAMES = [
   "resetRoutineRuns",
   "resolveAccessGrant",
   "resolveAnonymousMember",
+  "resolveInterventionRequest",
   "restoreFileVersion",
   "revokeAccessGrant",
   "revokeApiKey",
@@ -11123,6 +12114,7 @@ var WORKSPACE_METHOD_NAMES = [
   "unarchiveChat",
   "unarchiveDataType",
   "unarchiveMember",
+  "unarchivePersona",
   "unarchiveStep",
   "unarchiveTask",
   "unarchiveWorkflow",
@@ -11147,7 +12139,6 @@ var WORKSPACE_METHOD_NAMES = [
   "updateChatLabel",
   "updateChatModelOverride",
   "updateChatMute",
-  "updateChatNeedsResponse",
   "updateClientWorkspace",
   "updateConnection",
   "updateConnectionSyncConfig",
@@ -11211,6 +12202,7 @@ var WORKSPACE_METHOD_NAMES = [
   "uploadFile",
   "updateVoicemailStatus",
   "updateWorkflow",
+  "convertWorkflowStartTaskOpeningMessage",
   "updateWorkflowContributor",
   "updateWorkflowNote",
   "updateWorkflowRevisionMetadata",
@@ -11257,6 +12249,13 @@ function bindAccessGrantsMethods(target, accessGrants) {
   target.getGranteeGrants = accessGrants.getGranteeGrants.bind(accessGrants);
 }
 
+// src/client/bindings/intervention-requests.ts
+function bindInterventionRequestsMethods(target, interventionRequests) {
+  target.getAgentModeAttention = interventionRequests.getAgentModeAttention.bind(interventionRequests);
+  target.getInterventionRequests = interventionRequests.getInterventionRequests.bind(interventionRequests);
+  target.resolveInterventionRequest = interventionRequests.resolveInterventionRequest.bind(interventionRequests);
+}
+
 // src/client/bindings/agent-tasks.ts
 function bindAgentTasksMethods(target, api) {
   target.getAgentTasks = api.getAgentTasks.bind(api);
@@ -11297,10 +12296,15 @@ function bindTasksMethods(target, tasks, abilities) {
 
 // src/client/bindings/chats.ts
 function bindChatsMethods(target, chats) {
+  target.createChatInteractionSession = chats.createChatInteractionSession.bind(chats);
+  target.transitionChatInteractionSession = chats.transitionChatInteractionSession.bind(chats);
   target.getChats = chats.getChats.bind(chats);
   target.getChat = chats.getChat.bind(chats);
+  target.getChatBrowserLiveView = chats.getChatBrowserLiveView.bind(chats);
+  target.getChatMachineResources = chats.getChatMachineResources.bind(chats);
   target.getCurrentSmsChat = chats.getCurrentSmsChat.bind(chats);
   target.getChatCallbacks = chats.getChatCallbacks.bind(chats);
+  target.getChatEhrWritebackOutcomes = chats.getChatEhrWritebackOutcomes.bind(chats);
   target.cancelChatCallback = chats.cancelChatCallback.bind(chats);
   target.getChatTokenUsage = chats.getChatTokenUsage.bind(chats);
   target.getChatTodos = chats.getChatTodos.bind(chats);
@@ -11318,7 +12322,6 @@ function bindChatsMethods(target, chats) {
   target.getChatModelOverride = chats.getChatModelOverride.bind(chats);
   target.updateChatModelOverride = chats.updateChatModelOverride.bind(chats);
   target.updateChatMute = chats.updateChatMute.bind(chats);
-  target.updateChatNeedsResponse = chats.updateChatNeedsResponse.bind(chats);
   target.summarizeChat = chats.summarizeChat.bind(chats);
   target.getChatMessages = chats.getChatMessages.bind(chats);
   target.getChildThreadMessages = chats.getChildThreadMessages.bind(chats);
@@ -11353,8 +12356,6 @@ function bindChatsMethods(target, chats) {
 // src/client/bindings/calls.ts
 function bindCallsMethods(target, calls, cel) {
   target.getPhoneCalls = calls.getPhoneCalls.bind(calls);
-  target.initiateCall = calls.initiateCall.bind(calls);
-  target.getVoiceToken = calls.getVoiceToken.bind(calls);
   target.getMessageTiming = calls.getMessageTiming.bind(calls);
   target.getRecordingInfo = calls.getRecordingInfo.bind(calls);
   target.listChatRecordings = calls.listChatRecordings.bind(calls);
@@ -11375,9 +12376,30 @@ function bindDashboardsMethods(target, dashboards) {
   target.getConfigurationHealth = dashboards.getConfigurationHealth.bind(dashboards);
 }
 
-// src/client/bindings/activity-timeline.ts
-function bindActivityTimelineMethods(target, activityTimeline) {
-  target.queryActivityTimeline = activityTimeline.queryActivityTimeline.bind(activityTimeline);
+// src/client/bindings/activity.ts
+function bindActivityMethods(target, activity) {
+  target.queryActivity = activity.queryActivity.bind(activity);
+  target.queryActivityLatestSubjects = activity.queryActivityLatestSubjects.bind(activity);
+  target.queryActivityOpenItems = activity.queryActivityOpenItems.bind(activity);
+  target.queryActivityOneView = activity.queryActivityOneView.bind(activity);
+  target.queryActivityDigest = activity.queryActivityDigest.bind(activity);
+  target.getActivityCounts = activity.getActivityCounts.bind(activity);
+  target.getActivityCapabilities = activity.getActivityCapabilities.bind(activity);
+  target.queryOrgActivity = activity.queryOrgActivity.bind(activity);
+  target.queryOrgActivityLatestSubjects = activity.queryOrgActivityLatestSubjects.bind(activity);
+  target.queryOrgActivityOpenItems = activity.queryOrgActivityOpenItems.bind(activity);
+  target.queryOrgActivityOneView = activity.queryOrgActivityOneView.bind(activity);
+  target.queryOrgActivityDigest = activity.queryOrgActivityDigest.bind(activity);
+  target.getOrgActivityCounts = activity.getOrgActivityCounts.bind(activity);
+  target.queryWorkspaceActivity = activity.queryWorkspaceActivity.bind(activity);
+  target.queryWorkspaceActivityLatestSubjects = activity.queryWorkspaceActivityLatestSubjects.bind(activity);
+  target.queryWorkspaceActivityOpenItems = activity.queryWorkspaceActivityOpenItems.bind(activity);
+  target.queryWorkspaceActivityOneView = activity.queryWorkspaceActivityOneView.bind(activity);
+  target.queryWorkspaceActivityDigest = activity.queryWorkspaceActivityDigest.bind(activity);
+  target.getWorkspaceActivityCounts = activity.getWorkspaceActivityCounts.bind(activity);
+  target.resolveEntityRefs = activity.resolveEntityRefs.bind(activity);
+  target.resolveOrgEntityRefs = activity.resolveOrgEntityRefs.bind(activity);
+  target.resolveAccountEntityRefs = activity.resolveAccountEntityRefs.bind(activity);
 }
 
 // src/client/bindings/motd.ts
@@ -11399,6 +12421,10 @@ function bindTrackedLinksMethods(target, trackedLinks) {
 
 // src/client/bindings/data-types.ts
 function bindDataTypesMethods(target, dataTypes) {
+  target.getDataTypeDraft = dataTypes.getDataTypeDraft.bind(dataTypes);
+  target.saveDataTypeDraft = dataTypes.saveDataTypeDraft.bind(dataTypes);
+  target.publishDataTypeDraft = dataTypes.publishDataTypeDraft.bind(dataTypes);
+  target.getDataTypeVersions = dataTypes.getDataTypeVersions.bind(dataTypes);
   target.getDataTypes = dataTypes.getDataTypes.bind(dataTypes);
   target.getDataType = dataTypes.getDataType.bind(dataTypes);
   target.getDataTypeByUuid = dataTypes.getDataTypeByUuid.bind(dataTypes);
@@ -11455,6 +12481,7 @@ function bindMembersMethods(target, members) {
   target.updateCurrentMember = members.updateCurrentMember.bind(members);
   target.getWorkspaceMembers = members.getWorkspaceMembers.bind(members);
   target.getWorkspaceMember = members.getWorkspaceMember.bind(members);
+  target.getOrgWorkspaceMember = members.getOrgWorkspaceMember.bind(members);
   target.createWorkspaceMember = members.createWorkspaceMember.bind(members);
   target.updateMember = members.updateMember.bind(members);
   target.deleteMember = members.deleteMember.bind(members);
@@ -11484,6 +12511,8 @@ function bindMembersMethods(target, members) {
   target.createMemberRole = members.createMemberRole.bind(members);
   target.updateMemberRole = members.updateMemberRole.bind(members);
   target.deleteMemberRole = members.deleteMemberRole.bind(members);
+  target.getMemberRoleCleanupPlan = members.getMemberRoleCleanupPlan.bind(members);
+  target.mergeMemberRoles = members.mergeMemberRoles.bind(members);
   target.getMemberFields = members.getMemberFields.bind(members);
   target.getMemberFieldDefinitions = members.getMemberFieldDefinitions.bind(members);
   target.createMemberField = members.createMemberField.bind(members);
@@ -11501,11 +12530,15 @@ function bindMembersMethods(target, members) {
   target.createMemberMemory = members.createMemberMemory.bind(members);
   target.deleteMemberMemory = members.deleteMemberMemory.bind(members);
   target.getMemberSyncLinks = members.getMemberSyncLinks.bind(members);
+  target.getMemberRelationships = members.getMemberRelationships.bind(members);
+  target.createMemberRelationship = members.createMemberRelationship.bind(members);
+  target.archiveMemberRelationship = members.archiveMemberRelationship.bind(members);
 }
 
 // src/client/bindings/workspaces.ts
 function bindWorkspacesMethods(target, workspaces, signupRequests) {
   target.getWorkspaces = workspaces.getWorkspaces.bind(workspaces);
+  target.getDeviceAdmissibleWorkspaces = workspaces.getDeviceAdmissibleWorkspaces.bind(workspaces);
   target.getPublicWorkspaces = workspaces.getPublicWorkspaces.bind(workspaces);
   target.getWorkspace = workspaces.getWorkspace.bind(workspaces);
   target.createWorkspace = workspaces.createWorkspace.bind(workspaces);
@@ -11536,6 +12569,8 @@ function bindWorkspacesMethods(target, workspaces, signupRequests) {
   target.getProduct = workspaces.getProduct.bind(workspaces);
   target.getWorkspaceProduct = workspaces.getWorkspaceProduct.bind(workspaces);
   target.getPublicProducts = workspaces.getPublicProducts.bind(workspaces);
+  target.previewPromoCode = workspaces.previewPromoCode.bind(workspaces);
+  target.startPromoPlanTrial = workspaces.startPromoPlanTrial.bind(workspaces);
   target.getPublicProduct = workspaces.getPublicProduct.bind(workspaces);
   target.createProduct = workspaces.createProduct.bind(workspaces);
   target.updateProduct = workspaces.updateProduct.bind(workspaces);
@@ -11543,7 +12578,12 @@ function bindWorkspacesMethods(target, workspaces, signupRequests) {
   target.exportWorkspace = workspaces.exportWorkspace.bind(workspaces);
   target.exportWorkspaceZip = workspaces.exportWorkspaceZip.bind(workspaces);
   target.previewWorkspaceImport = workspaces.previewWorkspaceImport.bind(workspaces);
+  target.previewWorkspaceImportZip = workspaces.previewWorkspaceImportZip.bind(workspaces);
   target.importWorkspace = workspaces.importWorkspace.bind(workspaces);
+  target.importWorkspaceZip = workspaces.importWorkspaceZip.bind(workspaces);
+  target.getImportSkippedRules = workspaces.getImportSkippedRules.bind(workspaces);
+  target.getImportReadiness = workspaces.getImportReadiness.bind(workspaces);
+  target.rebuildImportSkippedRules = workspaces.rebuildImportSkippedRules.bind(workspaces);
   target.previewImportWorkspace = workspaces.previewImportWorkspace.bind(workspaces);
   target.getWorkspaceThemes = workspaces.getWorkspaceThemes.bind(workspaces);
   target.updateWorkspaceThemes = workspaces.updateWorkspaceThemes.bind(workspaces);
@@ -11751,9 +12791,11 @@ function bindEventsMethods(target, events) {
   target.updateRoutine = events.updateRoutine.bind(events);
   target.deleteRoutine = events.deleteRoutine.bind(events);
   target.runRoutine = events.runRoutine.bind(events);
+  target.getRoutineConfigEvents = events.getRoutineConfigEvents.bind(events);
   target.getRoutineRuns = events.getRoutineRuns.bind(events);
   target.resetRoutineRuns = events.resetRoutineRuns.bind(events);
   target.previewSchedule = events.previewSchedule.bind(events);
+  target.previewRoutineVoiceReadiness = events.previewRoutineVoiceReadiness.bind(events);
   target.previewRoutineWorkflowAccess = events.previewRoutineWorkflowAccess.bind(events);
 }
 
@@ -11778,6 +12820,8 @@ function bindExperimentsMethods(target, experiments) {
 function bindWorkflowsMethods(target, workflows, workflowNotes, voice, supervisors) {
   target.getWorkflows = workflows.getWorkflows.bind(workflows);
   target.getWorkflow = workflows.getWorkflow.bind(workflows);
+  target.getWorkflowOpeningTurnConversionReport = workflows.getWorkflowOpeningTurnConversionReport.bind(workflows);
+  target.convertWorkflowStartTaskOpeningMessage = workflows.convertWorkflowStartTaskOpeningMessage.bind(workflows);
   target.getWorkflowActivity = workflows.getWorkflowActivity.bind(workflows);
   target.getWorkflowsActivityBatch = workflows.getWorkflowsActivityBatch.bind(workflows);
   target.getWorkflowDiagram = workflows.getWorkflowDiagram.bind(workflows);
@@ -12198,7 +13242,6 @@ function bindOperatorMethods(target, operatorGroups) {
   target.removeGroupMember = operatorGroups.removeGroupMember.bind(operatorGroups);
   target.getLiveOperators = operatorGroups.getLiveOperators.bind(operatorGroups);
   target.getPresenceStatus = operatorGroups.getPresenceStatus.bind(operatorGroups);
-  target.disconnectPresence = operatorGroups.disconnectPresence.bind(operatorGroups);
   target.getOperatorChatMessages = operatorGroups.getOperatorChatMessages.bind(operatorGroups);
   target.sendOperatorMessage = operatorGroups.sendOperatorMessage.bind(operatorGroups);
 }
@@ -12226,6 +13269,8 @@ function bindOrgMethods(target, org) {
   target.listLegalEntities = org.listLegalEntities.bind(org);
   target.getLegalEntity = org.getLegalEntity.bind(org);
   target.createLegalEntity = org.createLegalEntity.bind(org);
+  target.getRegistrationDraft = org.getRegistrationDraft.bind(org);
+  target.saveRegistrationDraft = org.saveRegistrationDraft.bind(org);
   target.getVoiceTrustProducts = org.getVoiceTrustProducts.bind(org);
   target.syncVoiceTrustProducts = org.syncVoiceTrustProducts.bind(org);
   target.createOrganizationWorkspace = org.createOrganizationWorkspace.bind(org);
@@ -12257,6 +13302,9 @@ function bindJourneysMethods(target, journeys) {
   target.getJourneys = journeys.getJourneys.bind(journeys);
   target.getJourney = journeys.getJourney.bind(journeys);
   target.getJourneyAuthoring = journeys.getJourneyAuthoring.bind(journeys);
+  target.putJourneyV2Definition = journeys.putJourneyV2Definition.bind(journeys);
+  target.getJourneyV2Validation = journeys.getJourneyV2Validation.bind(journeys);
+  target.getJourneyFilterOptions = journeys.getJourneyFilterOptions.bind(journeys);
   target.getJourneyHealth = journeys.getJourneyHealth.bind(journeys);
   target.createJourney = journeys.createJourney.bind(journeys);
   target.updateJourney = journeys.updateJourney.bind(journeys);
@@ -12312,6 +13360,8 @@ function bindPersonasMethods(target, personas) {
   target.getPersona = personas.getPersona.bind(personas);
   target.createPersona = personas.createPersona.bind(personas);
   target.updatePersona = personas.updatePersona.bind(personas);
+  target.archivePersona = personas.archivePersona.bind(personas);
+  target.unarchivePersona = personas.unarchivePersona.bind(personas);
   target.deletePersona = personas.deletePersona.bind(personas);
 }
 
@@ -12411,8 +13461,11 @@ var GravityRailClient = class {
   // Chats API
   getChats;
   getChat;
+  getChatBrowserLiveView;
+  getChatMachineResources;
   getCurrentSmsChat;
   getChatCallbacks;
+  getChatEhrWritebackOutcomes;
   cancelChatCallback;
   getChatTokenUsage;
   getChatTodos;
@@ -12424,13 +13477,14 @@ var GravityRailClient = class {
   archiveChat;
   unarchiveChat;
   createChat;
+  createChatInteractionSession;
+  transitionChatInteractionSession;
   createWorkflowOutboundVoiceChat;
   deleteChat;
   updateChat;
   getChatModelOverride;
   updateChatModelOverride;
   updateChatMute;
-  updateChatNeedsResponse;
   summarizeChat;
   getChatMessages;
   getChildThreadMessages;
@@ -12462,8 +13516,6 @@ var GravityRailClient = class {
   getChatFilterCount;
   // Calls API
   getPhoneCalls;
-  initiateCall;
-  getVoiceToken;
   getMessageTiming;
   getRecordingInfo;
   listChatRecordings;
@@ -12472,6 +13524,10 @@ var GravityRailClient = class {
   validateCelExpression;
   // Data Types API
   getDataTypes;
+  getDataTypeDraft;
+  saveDataTypeDraft;
+  publishDataTypeDraft;
+  getDataTypeVersions;
   getDataType;
   getDataTypeByUuid;
   getDataTypeBySlug;
@@ -12514,6 +13570,9 @@ var GravityRailClient = class {
   updateCurrentMember;
   getWorkspaceMembers;
   getWorkspaceMember;
+  // Org-scoped, so deliberately absent from WORKSPACE_METHOD_NAMES: that proxy
+  // passes a workspace uuid as the first argument.
+  getOrgWorkspaceMember;
   createWorkspaceMember;
   updateMember;
   deleteMember;
@@ -12567,6 +13626,10 @@ var GravityRailClient = class {
   deleteMemberMemory;
   // Member Sync Links
   getMemberSyncLinks;
+  // Member Relationships
+  getMemberRelationships;
+  createMemberRelationship;
+  archiveMemberRelationship;
   // Agent Tasks API (operator-facing async sub-agent inspection/cancel)
   getAgentTasks;
   getAgentTask;
@@ -12604,6 +13667,8 @@ var GravityRailClient = class {
   getPersona;
   createPersona;
   updatePersona;
+  archivePersona;
+  unarchivePersona;
   deletePersona;
   // Metrics API (customer-defined outcome metrics)
   listMetrics;
@@ -12623,8 +13688,32 @@ var GravityRailClient = class {
   getDashboardChannelStats;
   getDashboardWorkflowAssignmentStats;
   getConfigurationHealth;
-  // Activity Timeline API
-  queryActivityTimeline;
+  // Activity Spine serving API — one query shape, three mounts
+  // (docs/projects/active/activity-spine.md).
+  queryActivity;
+  queryActivityLatestSubjects;
+  queryActivityOpenItems;
+  queryActivityOneView;
+  queryActivityDigest;
+  getActivityCounts;
+  getActivityCapabilities;
+  queryOrgActivity;
+  queryOrgActivityLatestSubjects;
+  queryOrgActivityOpenItems;
+  queryOrgActivityOneView;
+  queryOrgActivityDigest;
+  getOrgActivityCounts;
+  queryWorkspaceActivity;
+  queryWorkspaceActivityLatestSubjects;
+  queryWorkspaceActivityOpenItems;
+  queryWorkspaceActivityOneView;
+  queryWorkspaceActivityDigest;
+  getWorkspaceActivityCounts;
+  // Hydration: typed refs in, display summaries out, one round trip. The org
+  // variant carries several workspaces' groups in that one trip.
+  resolveEntityRefs;
+  resolveOrgEntityRefs;
+  resolveAccountEntityRefs;
   // MOTD API
   getMotd;
   // Tracked Links analytics (#10934)
@@ -12640,6 +13729,9 @@ var GravityRailClient = class {
   getJourneys;
   getJourney;
   getJourneyAuthoring;
+  putJourneyV2Definition;
+  getJourneyV2Validation;
+  getJourneyFilterOptions;
   getJourneyHealth;
   createJourney;
   updateJourney;
@@ -12694,7 +13786,6 @@ var GravityRailClient = class {
   removeGroupMember;
   getLiveOperators;
   getPresenceStatus;
-  disconnectPresence;
   getOperatorChatMessages;
   sendOperatorMessage;
   // Access Grants API
@@ -12707,10 +13798,15 @@ var GravityRailClient = class {
   getAccessGrants;
   getMemberGrants;
   getGranteeGrants;
+  // Intervention Requests API
+  getAgentModeAttention;
+  getInterventionRequests;
+  resolveInterventionRequest;
   // Prompts API
   inspectPrompt;
   // Workspaces API
   getWorkspaces;
+  getDeviceAdmissibleWorkspaces;
   getPublicWorkspaces;
   getWorkspace;
   createWorkspace;
@@ -12750,7 +13846,12 @@ var GravityRailClient = class {
   exportWorkspace;
   exportWorkspaceZip;
   previewWorkspaceImport;
+  previewWorkspaceImportZip;
   importWorkspace;
+  importWorkspaceZip;
+  getImportSkippedRules;
+  getImportReadiness;
+  rebuildImportSkippedRules;
   previewImportWorkspace;
   getWorkspaceThemes;
   updateWorkspaceThemes;
@@ -12785,6 +13886,8 @@ var GravityRailClient = class {
   listLegalEntities;
   getLegalEntity;
   createLegalEntity;
+  getRegistrationDraft;
+  saveRegistrationDraft;
   getVoiceTrustProducts;
   syncVoiceTrustProducts;
   createOrganizationWorkspace;
@@ -12976,10 +14079,13 @@ var GravityRailClient = class {
   getRoutineRuns;
   resetRoutineRuns;
   previewSchedule;
+  previewRoutineVoiceReadiness;
   previewRoutineWorkflowAccess;
   // Workflows API
   getWorkflows;
   getWorkflow;
+  getWorkflowOpeningTurnConversionReport;
+  convertWorkflowStartTaskOpeningMessage;
   getWorkflowActivity;
   getWorkflowsActivityBatch;
   getWorkflowDiagram;
@@ -13455,7 +14561,7 @@ var GravityRailClient = class {
     bindMetricsMethods(this, apis.metrics);
     bindQueriesMethods(this, apis.queries);
     bindDashboardsMethods(this, apis.dashboards);
-    bindActivityTimelineMethods(this, apis.activityTimeline);
+    bindActivityMethods(this, apis.activity);
     bindMotdMethods(this, apis.motd);
     bindTrackedLinksMethods(this, apis.trackedLinks);
     bindJourneysMethods(this, apis.journeys);
@@ -13463,6 +14569,7 @@ var GravityRailClient = class {
     bindOperatorMethods(this, apis.operatorGroups);
     bindOrgMethods(this, apis.org);
     bindAccessGrantsMethods(this, apis.accessGrants);
+    bindInterventionRequestsMethods(this, apis.interventionRequests);
     bindPromptsMethods(this, apis.prompts);
     bindWorkspacesMethods(this, apis.workspaces, apis.workspaceInvitations);
     bindAuthMethods(this, apis.auth, apis.assignments);
@@ -13659,6 +14766,19 @@ var WorkspaceBuilderResource = class {
   get isImplicit() {
     return false;
   }
+  /**
+   * True when `apply()` is safe — and required — to run against a resource
+   * that was ADOPTED rather than created.
+   *
+   * False by default because most builders create only: re-running their
+   * `apply()` on an existing resource would make a duplicate. Override it
+   * when `apply()` is an idempotent full write keyed on stable identities,
+   * which is the only way a re-run can express an EDIT (a removed goal, a
+   * reordered timeline) rather than just an addition.
+   */
+  get appliesWhenExisting() {
+    return false;
+  }
   matchKey() {
     return void 0;
   }
@@ -14337,6 +15457,755 @@ function buildJourneyGoalPayload(goal) {
     ...goal.value !== void 0 ? { value: goal.value } : {}
   };
 }
+var V2RouteBuilder = class {
+  constructor(name, options = {}) {
+    this.name = name;
+    this.options = options;
+  }
+  name;
+  options;
+  touches = [];
+  /**
+   * The DECISION RULE uuid. Adopted for the same reason an Ending's is:
+   * `MemberJourneyStep.entry_decision_rule_id` points at this row with
+   * `ON DELETE SET NULL`, so recreating it on a re-run would erase which arm
+   * every already-routed enrollment is on — invisibly, since both rules
+   * "exist" afterwards.
+   */
+  _ruleUuid;
+  /** Append a touch to this arm. Order is call order. */
+  touch(name, options = {}) {
+    const touch = new V2TouchBuilder(name, options);
+    this.touches.push(touch);
+    return touch;
+  }
+};
+var V2BranchBuilder = class {
+  routes = [];
+  /** Append a route. Declaration order is evaluation order. */
+  route(name, options = {}) {
+    const route = new V2RouteBuilder(name, options);
+    this.routes.push(route);
+    return route;
+  }
+};
+var V2TouchBuilder = class {
+  /**
+   * The name is CANONICALIZED here, once, and everything downstream reads it:
+   * the `key:<name>` address, the payload, adoption's name lookup, and the
+   * uniqueness gate. The API trims it before storing
+   * (`JourneyV2TouchInput`/`JourneyV2EndingInput` name validators), so a
+   * builder holding `" Welcome "` would send an address for a name the server
+   * does not have, fail to find its own step on the way back, and treat it as
+   * new on the next run — archiving the live step and its history. One
+   * representation at the boundary is the only way that cannot happen; a
+   * second trim anywhere downstream would be a place for the two to drift.
+   */
+  constructor(name, options = {}) {
+    this.options = options;
+    this.name = name.trim();
+  }
+  options;
+  rules = [];
+  /** Filled in from the server's response so a re-run keeps this touch. */
+  _uuid;
+  /**
+   * The exclusive branch that follows this touch, when it has one. A touch
+   * carrying a branch gets NO ordinary outgoing connection: its routes are
+   * the only way out, so touches declared after it are reached only by an arm
+   * naming them in `continueAt`.
+   */
+  _branch;
+  name;
+  /**
+   * Attach an exclusive branch after this touch, or return the existing one.
+   *
+   * Idempotent so a script can add routes in stages without accidentally
+   * declaring two branches on one touch — which the server has no shape for,
+   * since a touch owns exactly one ordered route set.
+   */
+  branch() {
+    this._branch ??= new V2BranchBuilder();
+    return this._branch;
+  }
+  /**
+   * The request-local address this step answers to (plan §3.8 / phase 6).
+   *
+   * A saved step is addressed by its uuid; an unsaved one by a `key` derived
+   * from its authored name. Deriving from the NAME rather than minting a
+   * uuid4 keeps the payload stable across re-runs of the same script — a
+   * fresh random key on every run would make the request differ from itself
+   * for no reason, and the server's EventRule sync matches on the uuids the
+   * payload carries. Names are already asserted unique within a journey,
+   * which is what makes a name-derived key unique.
+   *
+   * {@link V2EndingBuilder} INHERITS this rather than deriving its own: an
+   * Ending's anchor key and a touch's key land in one server-side namespace
+   * (`stepKey` is one field), so two derivations that drifted would produce
+   * two spellings of the same address and a goal would 404 on the one its
+   * step was not sent under.
+   *
+   * Two steps of one name therefore answer to one address. {@link preflight}
+   * is the first enforcement point and refuses it before any write, counting
+   * touches and Endings together and comparing names trimmed, as the API
+   * stores them. Without that gate the collision surfaces twice and both
+   * times too late: the server rejects the definition PUT after `apply()` has
+   * created the Journey, and {@link indexStoredByName} rejects the SECOND run
+   * of a script whose two stored steps make `adopt()` a coin flip.
+   */
+  get _address() {
+    return this._uuid ?? `key:${this.name}`;
+  }
+  /**
+   * Re-attach the EventRule uuids the server already stores for this touch.
+   *
+   * Identity is the operator-set rule NAME. `.sendsSms(...)` does not require
+   * one, so an unnamed rule falls back to its actionType — but ONLY when that
+   * answer is 1:1: exactly one unnamed draft of that actionType here, and
+   * exactly one stored rule of it left unclaimed there. Anything else throws.
+   *
+   * The ordinal-within-actionType fallback this replaces was not a weaker
+   * identity, it was the wrong one. Inserting a new unnamed rule ABOVE an
+   * existing same-type rule shifts every position by one, so the new rule
+   * adopted the existing rule's uuid — taking over its delivery bookkeeping —
+   * and the existing rule was written as brand new and archived. Nothing in
+   * the payload showed it: both rules "exist" afterwards. When the script
+   * cannot say which rule is which, the honest answer is to ask the author to
+   * name them, not to guess by position.
+   */
+  adoptRuleUuids(serverRules) {
+    const namedDrafts = this.rules.filter((draft) => !!draft.options.name);
+    const storedByName = indexStoredByName(
+      serverRules,
+      new Set(namedDrafts.map((draft) => draft.options.name)),
+      `touch '${this.name}'`,
+      "action"
+    );
+    const claimed = /* @__PURE__ */ new Set();
+    for (const draft of namedDrafts) {
+      const match = storedByName.get(draft.options.name);
+      if (!match) continue;
+      draft.adoptedUuid = match.uuid;
+      claimed.add(match);
+    }
+    const unnamedByActionType = /* @__PURE__ */ new Map();
+    for (const draft of this.rules) {
+      if (draft.options.name) continue;
+      const actionType = String(draft.actionType);
+      unnamedByActionType.set(actionType, [
+        ...unnamedByActionType.get(actionType) ?? [],
+        draft
+      ]);
+    }
+    for (const [actionType, drafts] of unnamedByActionType) {
+      const candidates = serverRules.filter(
+        (rule) => String(rule.actionType) === actionType && !claimed.has(rule)
+      );
+      if (!candidates.length) continue;
+      if (drafts.length === 1 && candidates.length === 1) {
+        drafts[0].adoptedUuid = candidates[0].uuid;
+        continue;
+      }
+      throw new Error(
+        `touch '${this.name}' has ${drafts.length} unnamed ${actionType} action(s) and the server has ${candidates.length} \u2014 so there is no way to tell which stored action each one is. Adopting by position swaps their identities the moment an action is inserted or removed, which moves one action's delivery history onto another. Give these actions names (\`{ name: ... }\`) so each one can be matched to the right rule.`
+      );
+    }
+  }
+  /** Attach a `JOURNEY_STEP_EXECUTE` action. Same contract as legacy. */
+  onExecute(actionType, params = {}, options = {}) {
+    this.rules.push({
+      uuid: crypto.randomUUID(),
+      actionType,
+      actionParams: params,
+      options
+    });
+    return this;
+  }
+  sendsSms(params, options = {}) {
+    return this.onExecute("sms:send" /* SMS_SEND */, params, options);
+  }
+  callsMember(params, options = {}) {
+    return this.onExecute("phone:call" /* PHONE_CALL */, params, options);
+  }
+  sendsEmail(params, options = {}) {
+    return this.onExecute("email:send" /* EMAIL_SEND */, params, options);
+  }
+  get hasOutreach() {
+    return this.rules.length > 0;
+  }
+  eventRuleInputs() {
+    return this.rules.map((rule) => ({
+      uuid: rule.adoptedUuid ?? rule.uuid,
+      eventType: "journey_step:execute" /* JOURNEY_STEP_EXECUTE */,
+      actionType: rule.actionType,
+      actionParams: resolveRefs(rule.actionParams),
+      ...rule.options.name ? { name: rule.options.name } : {},
+      ...rule.options.when ? { conditions: rule.options.when } : {},
+      ...rule.options.delaySeconds ? { delay: rule.options.delaySeconds } : {},
+      active: rule.options.active ?? true
+    }));
+  }
+};
+var V2EndingBuilder = class extends V2TouchBuilder {
+  constructor(name, when, filterId) {
+    super(name);
+    this.when = when;
+    this.filterId = filterId;
+  }
+  when;
+  filterId;
+  /**
+   * The DECISION RULE uuid, distinct from `_uuid` (the anchor step's).
+   *
+   * An Ending is two rows: a `JourneyDecisionRule` carrying the condition and
+   * precedence, and a `JourneyStep` anchor carrying its actions, goals, and
+   * status history. Adopting only the anchor left the rule to be recreated on
+   * every re-run — and `MemberJourney.latched_ending_rule_id` /
+   * `JourneyStatusLog.journey_decision_rule_id` point at the RULE with
+   * `ON DELETE SET NULL`, so every completed enrollment silently forgot which
+   * Ending it took.
+   */
+  _ruleUuid;
+  /**
+   * An Ending cannot carry a branch, and saying so is the whole override.
+   *
+   * `V2EndingBuilder extends V2TouchBuilder` for the identity and addressing
+   * an Ending's anchor shares with a touch, which also inherits every touch
+   * method — `branch()` among them. Inherited unchanged it would set
+   * `_branch` on an object nothing ever reads it from: the Ending serializer
+   * writes `{uuid|key, name, celCondition, filterId, eventRules}` and no
+   * `branch`, and `allTouches()` walks only the timeline, so the routes are
+   * never numbered, validated, adopted or sent. The author gets no error and
+   * a definition quietly missing what they asked for.
+   *
+   * An Ending is terminal by construction — it is the rule that ENDS an
+   * enrollment — so there is no shape to serialize even if the payload had a
+   * field for it. Refusing at the call is the only point where the author is
+   * still holding the mistake.
+   *
+   * @see foreignAnchorProblem for why this names no Ending.
+   */
+  branch() {
+    throw new Error(
+      "an Ending cannot carry a branch. An Ending terminates an enrollment, so there is nothing after it to route to, and the atomic definition has no field to send one under \u2014 the routes would be silently dropped. Put the branch on the touch that leads to this Ending instead, and give each arm its own Ending."
+    );
+  }
+};
+var JourneyV2Builder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.description = options.description ?? "";
+    this.activate = options.activate ?? false;
+  }
+  name;
+  description;
+  touches = [];
+  endings = [];
+  goals = [];
+  /** Activate after the definition is written and validated. */
+  activate;
+  /** Optimistic-concurrency token, from create or adoption. */
+  _expectedUpdatedAt;
+  /** Server status at adoption — decides whether a re-run must pause first. */
+  _status;
+  /**
+   * A v2 definition write is idempotent, so an ADOPTED journey is written
+   * too. That is the whole point of adopting one: the PUT is a full,
+   * uuid-keyed replacement, so re-running a script is how an author expresses
+   * an edit. The legacy builder stays create-only — its `apply()` only knows
+   * how to create, and re-running it would duplicate.
+   */
+  get appliesWhenExisting() {
+    return true;
+  }
+  /** Append a touch to the timeline. Order is call order. */
+  touch(name, options = {}) {
+    const touch = new V2TouchBuilder(name, options);
+    this.touches.push(touch);
+    return touch;
+  }
+  /**
+   * Every touch in the timeline, arms included, depth first.
+   *
+   * Identity adoption, name-uniqueness and validation all have to see arm
+   * touches — a walk over the top level alone would leave every arm touch
+   * recreated on each re-run, silently archiving its member history.
+   */
+  allTouches() {
+    const out = [];
+    const walk = (touches) => {
+      for (const touch of touches) {
+        out.push(touch);
+        for (const route of touch._branch?.routes ?? []) walk(route.touches);
+      }
+    };
+    walk(this.touches);
+    return out;
+  }
+  /** Every route in the timeline, at every nesting depth, depth first. */
+  allRoutes() {
+    const out = [];
+    for (const touch of this.allTouches()) {
+      for (const route of touch._branch?.routes ?? []) out.push(route);
+    }
+    return out;
+  }
+  /** Append an Ending. Call order is evaluation order. */
+  ending(name, options) {
+    const ending = new V2EndingBuilder(name, options.when, options.filterId);
+    this.endings.push(ending);
+    return ending;
+  }
+  goal(name, options = {}) {
+    this.goals.push({
+      name,
+      description: options.description,
+      step: options.step,
+      completionCel: options.completionCel,
+      value: options.value
+    });
+    return this;
+  }
+  /**
+   * Authoring problems the server's publish validator would reject.
+   *
+   * A different rule set from the legacy builder's on purpose. "No incoming
+   * edge" has no meaning in a timeline — position is the order — and the v2
+   * failure modes are different ones: an action-less touch that is not an
+   * explicit wait, and an Ending with no condition.
+   */
+  validate() {
+    const problems = [];
+    if (!this.touches.length) {
+      problems.push(
+        `journey '${this.name}' has no touches \u2014 an empty timeline has nothing to execute.`
+      );
+    }
+    const armHeads = new Set(
+      this.allRoutes().map((route) => route.touches[0]).filter(Boolean)
+    );
+    this.allTouches().forEach((touch) => {
+      if (touch.hasOutreach) return;
+      const wait = touch.options.wait;
+      const isFirst = this.touches[0] === touch;
+      const isExplicitWait = !isFirst && !armHeads.has(touch) && (wait?.afterDays !== void 0 || !!wait?.when || wait?.filterId !== void 0);
+      if (isExplicitWait) return;
+      problems.push(
+        `touch '${touch.name}' has no JOURNEY_STEP_EXECUTE action \u2014 a member reaching it gets nothing. Add one, or give it a wait so it is an explicit grace period.`
+      );
+    });
+    for (const touch of this.allTouches()) {
+      const branch = touch._branch;
+      if (!branch) continue;
+      const fallbacks = branch.routes.filter(
+        (route) => !route.options.when?.trim() && route.options.filterId === void 0
+      );
+      if (branch.routes.length - fallbacks.length < 1) {
+        problems.push(
+          `branch after touch '${touch.name}' needs at least one conditional route \u2014 one declared with a \`when\`, a \`filterId\`, or both. Members wait at the branch until a route matches, so an Otherwise is optional.`
+        );
+      }
+      if (fallbacks.length > 1) {
+        problems.push(
+          `branch after touch '${touch.name}' declares ${fallbacks.length} Otherwise routes; a branch has at most one unconditional fallback.`
+        );
+      }
+      if (fallbacks.length === 1 && branch.routes[branch.routes.length - 1] !== fallbacks[0]) {
+        problems.push(
+          `the Otherwise route of the branch after touch '${touch.name}' is not last; it is taken immediately, so any route after it can never be reached.`
+        );
+      }
+      for (const route of branch.routes) {
+        if (!route.touches.length && !route.options.continueAt) {
+          problems.push(
+            `route '${route.name}' has no target \u2014 give it at least one touch, or a \`continueAt\` naming the touch it continues to.`
+          );
+        }
+      }
+    }
+    for (const ending of this.endings) {
+      if (!ending.when?.trim() && ending.filterId === void 0) {
+        problems.push(
+          `ending '${ending.name}' has no condition \u2014 an Ending that always matches terminates every enrolment on evaluation order alone. Give it a \`when\` expression, a \`filterId\`, or both.`
+        );
+      }
+    }
+    return problems;
+  }
+  /**
+   * Shapes this definition cannot express, found BEFORE anything is written.
+   *
+   * A different list from {@link validate}, and a different consequence:
+   * those are warnings the orchestrator prints and then writes anyway, these
+   * are refusals. For each one the payload has no way to say what the script
+   * asked for, so serializing past it would write a DIFFERENT program from
+   * the one the script wrote, with nothing afterwards to say so.
+   *
+   * It has to run before the first write rather than during serialization,
+   * because {@link apply} creates the Journey — or pauses a live one — before
+   * it builds the payload. A refusal raised from `definitionPayload()` has
+   * therefore already left an empty journey shell behind, or taken a
+   * production program off the air.
+   *
+   * PURE: reads only what the script declared, never what the server holds,
+   * so it is correct at any point — before adoption included — and
+   * `WorkspaceBuilder.preflight()` can stay a synchronous, side-effect-free
+   * check a caller may run directly. Nothing here needs adoption to have run:
+   * an anchor the server has not seen is addressed by its request-local key,
+   * so "has this Ending been saved" is no longer a question a refusal
+   * depends on.
+   */
+  preflight() {
+    const problems = [];
+    this.allTouches().forEach((touch, index) => {
+      const wait = touch.options.wait;
+      if (wait?.afterDays !== void 0 && wait.when) {
+        problems.push(waitExclusivityProblem(index));
+      }
+    });
+    const owned = this.ownedAnchors();
+    this.goals.forEach((goal, index) => {
+      const step = goal.step;
+      if (step && !owned.has(step)) {
+        problems.push(foreignAnchorProblem(index, anchorKind(step)));
+      }
+    });
+    const stepNames = [
+      ...this.allTouches().map((touch) => touch.name),
+      ...this.endings.map((ending) => ending.name)
+    ];
+    const claims = /* @__PURE__ */ new Map();
+    for (const name of stepNames) claims.set(name, (claims.get(name) ?? 0) + 1);
+    const repeated = [...claims.values()].filter((count) => count > 1).length;
+    if (repeated) problems.push(sharedStepNameProblem(repeated));
+    const nameless = stepNames.filter((name) => !name).length;
+    if (nameless) problems.push(namelessStepProblem(nameless));
+    return problems;
+  }
+  /**
+   * Every step a goal in THIS journey can anchor to, compared by object
+   * identity — touches AND Endings, which is why the element type names both
+   * rather than leaning on `V2EndingBuilder extends V2TouchBuilder` to smuggle
+   * Endings in under a touch-only annotation.
+   *
+   * A goal anchored to some other journey's builder is not a near miss the
+   * server can catch: an unsaved one sends a `stepKey` this definition never
+   * declares (a 404 whose cause is invisible), and a SAVED one sends a real
+   * `stepUuid` belonging to a live step somewhere else.
+   */
+  ownedAnchors() {
+    return /* @__PURE__ */ new Set([...this.allTouches(), ...this.endings]);
+  }
+  planLine() {
+    const parts = [];
+    const touchCount = this.allTouches().length;
+    const routeCount = this.allRoutes().length;
+    if (touchCount) parts.push(`${touchCount} touches`);
+    if (routeCount) parts.push(`${routeCount} routes`);
+    if (this.endings.length) parts.push(`${this.endings.length} endings`);
+    if (this.goals.length) parts.push(`${this.goals.length} goals`);
+    return `Journey (v2): ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+  }
+  /**
+   * Re-attach every stable child identity the server already holds.
+   *
+   * The atomic endpoint is a FULL REPLACEMENT keyed on uuids: an omitted
+   * uuid does not mean "unchanged", it means "create a new one and archive
+   * whatever the old one was". So anything this misses is silently recreated
+   * on every re-run of the same script — and a script is normally re-run,
+   * because a program is built in stages. Each identity has a different thing
+   * hanging off it, and losing it costs something specific:
+   *
+   * | identity | what re-creating it destroys |
+   * |---|---|
+   * | touch step uuid | the touch's `MemberJourneyStep` history |
+   * | EventRule uuid | that action's delivery bookkeeping |
+   * | Ending RULE uuid | which Ending completed enrollments latched |
+   * | Ending anchor uuid | the Ending's status history and goal anchor |
+   * | goal uuid | every member's satisfaction row for that goal |
+   *
+   * `existing` is the journey DETAIL or AUTHORING projection. Both carry
+   * `steps[].eventRules`, `goals`, and `decisionRules` —
+   * the read projection redacts CEL, not identity — so one fetch is enough
+   * and no second round trip is needed. (The orchestrator asks for the
+   * authoring projection anyway: this builder holds `journeys:write` because
+   * it is about to PUT, and the superset costs nothing.)
+   *
+   * Names are the only key available on a FIRST adoption, and a duplicate
+   * name makes adoption a coin flip between two live resources. That throws
+   * rather than guessing: silently attaching a touch to the wrong step
+   * archives real member history.
+   */
+  adopt(existing) {
+    super.adopt(existing);
+    this._expectedUpdatedAt = existing.updatedAt;
+    this._status = existing.status;
+    this.assertUnambiguousNames();
+    this.adoptChildIdentities(existing);
+  }
+  /** Reject a script whose own names cannot identify a resource. */
+  assertUnambiguousNames() {
+    assertUniqueNames(
+      this.allTouches().map((touch) => touch.name),
+      `journey '${this.name}'`,
+      "touch"
+    );
+    assertUniqueNames(
+      this.allRoutes().map((route) => route.name),
+      `journey '${this.name}'`,
+      "route"
+    );
+    assertUniqueNames(
+      this.endings.map((ending) => ending.name),
+      `journey '${this.name}'`,
+      "ending"
+    );
+    assertUniqueNames(
+      this.goals.map((goal) => goal.name),
+      `journey '${this.name}'`,
+      "goal"
+    );
+    for (const touch of [...this.allTouches(), ...this.endings]) {
+      const names = touch.rules.map((rule) => rule.options.name).filter(Boolean);
+      assertUniqueNames(names, `touch '${touch.name}'`, "action name");
+    }
+  }
+  adoptChildIdentities(payload) {
+    const steps = payload.steps ?? [];
+    const referencedStepNames = /* @__PURE__ */ new Set([
+      ...this.allTouches().map((touch) => touch.name),
+      ...this.endings.map((ending) => ending.name)
+    ]);
+    const stepsByName = indexStoredByName(
+      steps,
+      referencedStepNames,
+      `journey '${this.name}'`,
+      "step"
+    );
+    const stepsById = new Map(steps.map((step) => [step.id, step]));
+    for (const touch of this.allTouches()) {
+      const match = stepsByName.get(touch.name);
+      if (!match) continue;
+      touch._uuid = match.uuid;
+      touch.adoptRuleUuids(match.eventRules ?? []);
+    }
+    const routeRules = (payload.decisionRules ?? []).filter(
+      (rule) => rule.sourceStepId !== null && rule.sourceStepId !== void 0
+    );
+    const declaredRoutes = this.allRoutes();
+    const routesByName = indexStoredByName(
+      routeRules,
+      new Set(declaredRoutes.map((route) => route.name)),
+      `journey '${this.name}'`,
+      "route"
+    );
+    for (const route of declaredRoutes) {
+      const stored = routesByName.get(route.name);
+      if (stored) route._ruleUuid = stored.uuid;
+    }
+    const endingRules = (payload.decisionRules ?? []).filter(
+      (rule) => rule.sourceStepId === null || rule.sourceStepId === void 0
+    );
+    const rulesByName = indexStoredByName(
+      endingRules,
+      new Set(this.endings.map((ending) => ending.name)),
+      `journey '${this.name}'`,
+      "ending"
+    );
+    for (const ending of this.endings) {
+      const rule = rulesByName.get(ending.name);
+      const anchor = rule ? stepsById.get(rule.targetStepId) : stepsByName.get(ending.name);
+      if (rule) ending._ruleUuid = rule.uuid;
+      if (!anchor) continue;
+      ending._uuid = anchor.uuid;
+      ending.adoptRuleUuids(anchor.eventRules ?? []);
+    }
+    const goalsByName = indexStoredByName(
+      payload.goals ?? [],
+      new Set(this.goals.map((goal) => goal.name)),
+      `journey '${this.name}'`,
+      "goal"
+    );
+    for (const goal of this.goals) {
+      const match = goalsByName.get(goal.name);
+      if (match) goal._uuid = match.uuid;
+    }
+  }
+  /** The atomic request body. Exposed so a test can assert it without HTTP. */
+  definitionPayload() {
+    const owned = this.ownedAnchors();
+    const positions = new Map(
+      this.allTouches().map((touch, index) => [touch, index])
+    );
+    return {
+      expectedUpdatedAt: this._expectedUpdatedAt ?? "",
+      touches: this.touches.map((touch) => serializeV2Touch(touch, positions)),
+      endings: this.endings.map((ending) => ({
+        ...ending._ruleUuid ? { uuid: ending._ruleUuid } : {},
+        // Anchor address, exactly as `serializeV2Touch` sends a touch's:
+        // the saved anchor's uuid, or the request-local `key` a goal in
+        // this same save names it by. Both come from `_address`, so the
+        // Ending and the goal cannot be sent under two spellings.
+        ...ending._uuid ? { anchorUuid: ending._uuid } : { key: ending._address },
+        name: ending.name,
+        // The two predicates are sent INDEPENDENTLY (rule-filters plan
+        // §3.2). A filter-only Ending carries no `celCondition` at all
+        // rather than an empty one the server would have to normalize.
+        ...ending.when ? { celCondition: ending.when } : {},
+        ...ending.filterId !== void 0 ? { filterId: ending.filterId } : {},
+        eventRules: ending.eventRuleInputs()
+      })),
+      // ALWAYS sent, `[]` included. The field distinguishes omitted (leave
+      // goals alone) from empty (delete them), and this builder owns the
+      // goal list — so omitting an empty list would make goal REMOVAL the
+      // one edit a script cannot express: delete the `.goal(...)` call, re-run,
+      // and the goal stays live forever.
+      goals: this.goals.map((goal, index) => ({
+        ...goal._uuid ? { uuid: goal._uuid } : {},
+        name: goal.name,
+        ...goal.description ? { description: goal.description } : {},
+        ...serializeV2GoalAnchor(goal.step, index, owned),
+        ...goal.completionCel ? { completionCel: goal.completionCel } : {},
+        ...goal.value !== void 0 ? { value: goal.value } : {}
+      }))
+    };
+  }
+  async apply(client) {
+    const problems = this.preflight();
+    if (problems.length) {
+      throw new Error(
+        `Journey (v2) has ${problems.length} problem(s) and was not applied:
+` + problems.map((problem) => `  - ${problem}`).join("\n")
+      );
+    }
+    if (!this._existed) {
+      const created = await client.createJourney({
+        name: this.name,
+        description: this.description,
+        // Explicit, always. An omitted executionModel means `legacy` on the
+        // server, so a v2 builder that forgot it would quietly author a
+        // legacy Journey that happens to look like a timeline.
+        executionModel: "v2"
+      });
+      this._id = created.id;
+      this._uuid = created.uuid;
+      this._created = true;
+      this._expectedUpdatedAt = created.updatedAt;
+    } else if (this._status === "active" && this.activate) {
+      const paused = await client.updateJourney(this.id, { status: "paused" });
+      this._expectedUpdatedAt = paused.updatedAt;
+    }
+    const saved = await client.putJourneyV2Definition(this.id, this.definitionPayload());
+    this._expectedUpdatedAt = saved.updatedAt;
+    this.adoptWrittenUuids(saved);
+    if (this.activate) {
+      await client.updateJourney(this.id, { status: "active" });
+    }
+  }
+  /**
+   * Re-attach the uuids the server assigned, so a follow-up write matches.
+   *
+   * The PUT returns the AUTHORING projection, which is the same shape
+   * `adopt` reads — so this is the same operation against a payload we just
+   * caused, and it uses the same code path rather than a second, thinner
+   * copy that would drift.
+   */
+  adoptWrittenUuids(saved) {
+    this.adoptChildIdentities(saved);
+  }
+};
+function indexStoredByName(rows, referenced, owner, kind) {
+  const byName = /* @__PURE__ */ new Map();
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const name = row.name;
+    if (typeof name !== "string" || !name) continue;
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+    if (!byName.has(name)) byName.set(name, row);
+  }
+  for (const [name, count] of counts) {
+    if (count < 2 || !referenced.has(name)) continue;
+    throw new Error(
+      `${owner} already has ${count} ${kind}s named '${name}'. This script adopts by name, so it cannot tell which ${kind} it owns \u2014 and the one it does not pick is archived on the next save, taking its history with it. Rename them so each name identifies one ${kind}.`
+    );
+  }
+  return byName;
+}
+function assertUniqueNames(names, owner, kind) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (seen.has(name)) {
+      throw new Error(
+        `${owner} has two ${kind}s named '${name}'. The v2 builder adopts an existing journey by name, so duplicates would attach a builder to either one at random \u2014 archiving the other's history on the next save. Rename one.`
+      );
+    }
+    seen.add(name);
+  }
+}
+function serializeV2Touch(touch, positions) {
+  return {
+    ...touch._uuid ? { uuid: touch._uuid } : { key: touch._address },
+    name: touch.name,
+    ...touch.options.description ? { description: touch.options.description } : {},
+    ...touch.options.wait ? { wait: buildV2Wait(touch.options.wait, positions.get(touch)) } : {},
+    eventRules: touch.eventRuleInputs(),
+    ...touch._branch ? {
+      branch: {
+        routes: touch._branch.routes.map((route) => ({
+          ...route._ruleUuid ? { uuid: route._ruleUuid } : {},
+          name: route.name,
+          // Omitted, not null, and INDEPENDENT of each other: a route
+          // with neither predicate IS the Otherwise marker, one with
+          // either is conditional, and one with both is ANDed
+          // (rule-filters plan §3.2). The server normalizes "" to the
+          // same thing as omitted.
+          ...route.options.when ? { celCondition: route.options.when } : {},
+          ...route.options.filterId !== void 0 ? { filterId: route.options.filterId } : {},
+          touches: route.touches.map((armTouch) => serializeV2Touch(armTouch, positions)),
+          ...route.options.continueAt ? { continueAt: route.options.continueAt._address } : {}
+        }))
+      }
+    } : {}
+  };
+}
+function serializeV2GoalAnchor(step, goalIndex, owned) {
+  if (!step) return {};
+  if (!owned.has(step)) throw new Error(foreignAnchorProblem(goalIndex, anchorKind(step)));
+  if (step._uuid) return { stepUuid: step._uuid };
+  return { stepKey: step._address };
+}
+function foreignAnchorProblem(goalIndex, kind) {
+  return `goal at index ${goalIndex} is anchored to ${kind === "Ending" ? "an" : "a"} ${kind} that belongs to a different journey builder. A goal anchor is part of the same atomic definition as its step, so it can only name a touch or Ending this journey declares.`;
+}
+function waitExclusivityProblem(touchIndex) {
+  const where = touchIndex === void 0 ? "this touch" : `touch at index ${touchIndex}`;
+  return `${where} sets both afterDays and when; fold the day count into \`when\`. A v2 wait is either a whole-day count or Advanced CEL, not both.`;
+}
+function sharedStepNameProblem(count) {
+  return `${count} step name(s) are claimed more than once. Touches and Endings are one namespace: until a save mints their uuids they address themselves by name and the definition resolves those keys through one field, and once saved they are stored steps the next run cannot tell apart. Names are canonical (trimmed), as the API stores them. Rename one.`;
+}
+function namelessStepProblem(count) {
+  return `${count} step(s) have an empty name once trimmed. A step's name is its request-local address until a save mints its uuid, so a nameless one has nothing to be addressed by, and the API refuses it. Name them.`;
+}
+function anchorKind(step) {
+  return step instanceof V2EndingBuilder ? "Ending" : "touch";
+}
+function buildV2Wait(wait, touchIndex) {
+  if (wait.afterDays !== void 0 && wait.when) {
+    throw new Error(waitExclusivityProblem(touchIndex));
+  }
+  const extras = {
+    ...wait.filterId !== void 0 ? { filterId: wait.filterId } : {}
+  };
+  if (wait.afterDays !== void 0) {
+    return { kind: "wholeDays", days: wait.afterDays, ...extras };
+  }
+  if (wait.when) {
+    return { kind: "advanced", cel: wait.when, ...extras };
+  }
+  return { kind: "none", ...extras };
+}
 
 // src/workspace-builder/role-update.ts
 var RoleUpdate = class extends WorkspaceBuilderResource {
@@ -14572,6 +16441,7 @@ var AgentBuilder = class extends WorkspaceBuilderResource {
     this.memberRoleId = options.roleId ?? options.role_id;
     this.tools = options.tools ?? [];
     this.codeInterpreterEnabled = options.codeInterpreterEnabled ?? options.code_interpreter_enabled ?? false;
+    this.webBrowserEnabled = options.webBrowserEnabled ?? options.web_browser_enabled ?? false;
   }
   name;
   chatModelId;
@@ -14579,6 +16449,7 @@ var AgentBuilder = class extends WorkspaceBuilderResource {
   memberRoleId;
   tools;
   codeInterpreterEnabled;
+  webBrowserEnabled;
   planLine() {
     const parts = [];
     if (this.chatModelId) parts.push(`model=${this.chatModelId}`);
@@ -14599,7 +16470,8 @@ var AgentBuilder = class extends WorkspaceBuilderResource {
       chatModelId: this.chatModelId,
       systemPrompt: this.systemPrompt,
       ...this.tools.length ? { tools: this.tools } : {},
-      ...this.codeInterpreterEnabled ? { codeInterpreterEnabled: true } : {}
+      ...this.codeInterpreterEnabled ? { codeInterpreterEnabled: true } : {},
+      ...this.webBrowserEnabled ? { webBrowserEnabled: true } : {}
     };
     const result = await client.createAgent(payload);
     this._id = result.id;
@@ -14620,6 +16492,9 @@ var PHASES = /* @__PURE__ */ new Map([
   [RoutineBuilder, 6],
   [NotificationRuleBuilder, 6],
   [JourneyBuilder, 7],
+  // Same phase as the legacy builder: a v2 Journey is written whole by its
+  // own apply(), so it has no child resources to sequence after it.
+  [JourneyV2Builder, 7],
   [JourneyStepBuilder, 8]
 ]);
 var LIST_PAGE_SIZE = 100;
@@ -14681,6 +16556,21 @@ var WorkspaceBuilder = class {
     this.resources.push(journey);
     return journey;
   }
+  /**
+   * A Journey v2 timeline (plan §3.8): ordered touches, structured waits, and
+   * ordered Endings, written through the atomic definition endpoint.
+   *
+   * A separate factory rather than an option on {@link journey}, because the
+   * two return different builders with different vocabularies — `.touch()`
+   * and `.ending()` versus `.step()` and `.connectsTo()`. The legacy builder
+   * keeps its current behaviour untouched, which is the plan's explicit
+   * compatibility requirement.
+   */
+  journeyV2(name, options = {}) {
+    const journey = new JourneyV2Builder(name, options);
+    this.resources.push(journey);
+    return journey;
+  }
   agent(name, options = {}) {
     const agent = new AgentBuilder(name, options);
     this.resources.push(agent);
@@ -14764,7 +16654,9 @@ ${"=".repeat(50)}`);
    * surfaced before the write rather than discovered from a member's phone.
    */
   reportJourneyWarnings() {
-    const problems = this.resources.filter((resource) => resource instanceof JourneyBuilder).flatMap((journey) => journey.validate());
+    const problems = this.resources.filter(
+      (resource) => resource instanceof JourneyBuilder || resource instanceof JourneyV2Builder
+    ).flatMap((journey) => journey.validate());
     if (!problems.length) return;
     writeLine("\n  Journey warnings:");
     for (const problem of problems) writeLine(`    ! ${problem}`);
@@ -14781,6 +16673,12 @@ ${"=".repeat(50)}`);
    * Deliberately narrow: only cross-resource facts the builder can see with
    * certainty. Per-field CEL schema checking stays server-side, where the
    * real validator lives — duplicating it here would drift.
+   *
+   * Pure: reads only what the plan declares, never what the server holds, so
+   * it is correct before adoption and safe for a caller to run directly. It
+   * is also the WHOLE gate: every anchor a v2 definition can name has a
+   * request-local address whether or not the server has seen it, so no
+   * refusal has to wait for adoption to decide it.
    */
   preflight() {
     const problems = [];
@@ -14804,39 +16702,46 @@ ${"=".repeat(50)}`);
         }
       }
     }
+    for (const resource of this.resources) {
+      if (resource instanceof JourneyV2Builder) problems.push(...resource.preflight());
+    }
     return [...new Set(problems)];
   }
-  async apply() {
-    const problems = this.preflight();
-    if (problems.length) {
-      writeLine("\nPlan rejected \u2014 nothing was created:");
-      for (const problem of problems) writeLine(`  ! ${problem}`);
-      throw new Error(
-        `Plan has ${problems.length} problem(s) and was not applied:
+  /** The plan-rejection shape: every problem printed, nothing written. */
+  rejectIfProblems(problems) {
+    if (!problems.length) return;
+    writeLine("\nPlan rejected \u2014 nothing was created:");
+    for (const problem of problems) writeLine(`  ! ${problem}`);
+    throw new Error(
+      `Plan has ${problems.length} problem(s) and was not applied:
 ` + problems.map((problem) => `  - ${problem}`).join("\n")
-      );
-    }
+    );
+  }
+  async apply() {
     const resources = this.sortedResources();
+    this.rejectIfProblems(this.preflight());
     await this.resolveExisting(resources);
     const summary = {};
     writeLine("Applying...");
     for (const resource of resources) {
       try {
         if (resource.isImplicit) continue;
-        if (resource._existed) {
+        if (resource._existed && !resource.appliesWhenExisting) {
           const key = resourceKey(resource);
           summary[key] ??= [];
           summary[key].push(resource._id);
           writeLine(`  Exists ${resource.planLine()} -> id=${resource._id}`);
           continue;
         }
+        const updating = resource._existed;
         await resource.apply(this.client);
         if (resource._created || resource._id !== void 0) {
           const key = resourceKey(resource);
           summary[key] ??= [];
           summary[key].push(resource._id);
           const startTag = resource instanceof TaskBuilder && resource.start ? " [start]" : "";
-          writeLine(`  Created ${resource.planLine()}${startTag} -> id=${resource._id}`);
+          const verb = updating ? "Updated" : "Created";
+          writeLine(`  ${verb} ${resource.planLine()}${startTag} -> id=${resource._id}`);
         } else {
           writeLine(`  Skipped: ${resource.planLine()}`);
         }
@@ -14855,6 +16760,11 @@ Done! Created ${count} resources.`);
     return summary;
   }
   async resolveExisting(resources) {
+    assertUniqueJourneyNames(
+      resources.filter(
+        (resource) => resource instanceof JourneyBuilder || resource instanceof JourneyV2Builder
+      )
+    );
     const formSlugs = new Map(
       resources.filter((resource) => resource instanceof FormBuilder).map((resource) => [resource.slug, resource])
     );
@@ -14893,14 +16803,33 @@ Done! Created ${count} resources.`);
       }
     }
     const journeyNames = new Map(
-      resources.filter((resource) => resource instanceof JourneyBuilder).map((resource) => [resource.name, resource])
+      resources.filter(
+        (resource) => resource instanceof JourneyBuilder || resource instanceof JourneyV2Builder
+      ).map((resource) => [resource.name, resource])
     );
     if (journeyNames.size) {
-      const existingJourneys = await this.client.getJourneys();
-      for (const existing of existingJourneys.items) {
+      const pageSize = 500;
+      const firstPage = await this.client.getJourneys(false, { page: 1, pageSize });
+      const allJourneys = [...firstPage.items];
+      for (let page = 2; page <= firstPage.totalPages; page++) {
+        const nextPage = await this.client.getJourneys(false, { page, pageSize });
+        allJourneys.push(...nextPage.items);
+      }
+      const storedByName = /* @__PURE__ */ new Map();
+      for (const existing of allJourneys) {
         if (!existing.name || !journeyNames.has(existing.name)) continue;
-        const detail = await this.client.getJourney(existing.id);
-        journeyNames.get(existing.name).adopt(detail);
+        storedByName.set(existing.name, [...storedByName.get(existing.name) ?? [], existing]);
+      }
+      for (const [name, matches] of storedByName) {
+        if (matches.length > 1) {
+          throw new Error(
+            `This workspace has ${matches.length} journeys named '${name}', and the script adopts an existing journey by name \u2014 so it cannot tell which one it owns. Adopting the wrong one replaces that journey whole on the next save. Rename the others in the app, or rename the journey in the script.`
+          );
+        }
+        const existing = matches[0];
+        const builder = journeyNames.get(name);
+        const detail = builder instanceof JourneyV2Builder ? await this.client.getJourneyAuthoring(existing.id) : await this.client.getJourney(existing.id);
+        builder.adopt(detail);
       }
     }
     const agentNames = new Map(
@@ -15079,6 +17008,12 @@ Done! Created ${count} resources.`);
         }
       } else if (resource instanceof JourneyBuilder) {
         for (const goal of resource.goals) lines.push(`Goal: ${goal.name}`);
+      } else if (resource instanceof JourneyV2Builder) {
+        resource.touches.forEach((touch, index) => {
+          lines.push(`${index + 1}. ${touch.name}`);
+        });
+        for (const ending of resource.endings) lines.push(`Ending: ${ending.name}`);
+        for (const goal of resource.goals) lines.push(`Goal: ${goal.name}`);
       }
     }
     return lines;
@@ -15237,6 +17172,17 @@ var ApplyError = class extends Error {
     return this.#cause;
   }
 };
+function assertUniqueJourneyNames(journeys) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const journey of journeys) {
+    if (seen.has(journey.name)) {
+      throw new Error(
+        `This script declares two journeys named '${journey.name}'. A journey is adopted and re-applied by name, so only one of them could ever be written \u2014 and a v2 apply replaces the journey it adopted whole. Rename one.`
+      );
+    }
+    seen.add(journey.name);
+  }
+}
 function resourceKey(resource) {
   if (resource instanceof RoleUpdate) return "roleUpdates";
   if (resource instanceof FormBuilder) return "forms";
@@ -15246,7 +17192,9 @@ function resourceKey(resource) {
   if (resource instanceof MemberFilterBuilder) return "memberFilters";
   if (resource instanceof RoutineBuilder) return "routines";
   if (resource instanceof NotificationRuleBuilder) return "notificationRules";
-  if (resource instanceof JourneyBuilder) return "journeys";
+  if (resource instanceof JourneyBuilder || resource instanceof JourneyV2Builder) {
+    return "journeys";
+  }
   if (resource instanceof JourneyStepBuilder) return "journeySteps";
   if (resource instanceof AgentBuilder) return "agents";
   return "resources";
@@ -15357,7 +17305,7 @@ function writeScopeForResource(resource) {
   if (resource instanceof RoutineBuilder || resource instanceof NotificationRuleBuilder) {
     return "automations:admin";
   }
-  if (resource instanceof JourneyBuilder || resource instanceof JourneyStepBuilder) {
+  if (resource instanceof JourneyBuilder || resource instanceof JourneyStepBuilder || resource instanceof JourneyV2Builder) {
     return "journeys:write";
   }
   if (resource instanceof RoleUpdate) return "member_roles:write";
@@ -15501,6 +17449,36 @@ var QUERY_VALUELESS_OPS = /* @__PURE__ */ new Set([
   "exists"
 ]);
 
+// src/types/generated/channel_message.ts
+var ChannelMessageDirection = {
+  inbound: "inbound",
+  outbound: "outbound"
+};
+var ChannelMessageSource = {
+  sms_record: "sms_record",
+  other_chat: "other_chat"
+};
+
+// src/types/generated/chat.ts
+var ChannelMessagesUnavailableReason = {
+  not_single_channel: "not_single_channel",
+  no_phone_number: "no_phone_number",
+  no_counterpart_phone: "no_counterpart_phone"
+};
+var ChatMuteReason = {
+  working: "working",
+  waiting_on_person: "waiting_on_person",
+  resolved_elsewhere: "resolved_elsewhere",
+  not_mine: "not_mine"
+};
+
+// src/types/generated/ehr_writeback.ts
+var EhrWritebackOutcomeResponseStatus = {
+  accepted: "accepted",
+  skipped: "skipped",
+  failed: "failed"
+};
+
 // src/types/chat-types.ts
 var SMS_DELIVERY_FAILURE_STATUSES = /* @__PURE__ */ new Set([
   "failed",
@@ -15657,6 +17635,35 @@ var PromoCodeStatus = {
   exhausted: "exhausted"
 };
 
+// src/types/generated/import_skipped_rule.ts
+var ImportSkippedRuleResourceGroupResourceType = {
+  phone: "phone",
+  inbox: "inbox",
+  member: "member"
+};
+var ImportSkippedRuleResponseNeededResourceTypesItem = {
+  phone: "phone",
+  inbox: "inbox",
+  member: "member"
+};
+var ImportSkippedRuleResponseParentKind = {
+  routine: "routine",
+  journey_step: "journey_step",
+  task: "task",
+  workflow: "workflow",
+  other: "other"
+};
+var ImportSkippedRuleResponseReasonCode = {
+  missing_binding: "missing_binding",
+  invalid_event_rule_cel: "invalid_event_rule_cel",
+  unresolved_journey_scope: "unresolved_journey_scope"
+};
+var ImportSkippedRuleResponseStatus = {
+  outstanding: "outstanding",
+  reconnected: "reconnected",
+  dismissed: "dismissed"
+};
+
 // src/features/registry.ts
 var FeatureCategory = /* @__PURE__ */ ((FeatureCategory2) => {
   FeatureCategory2["COMMUNICATION"] = "communication";
@@ -15782,6 +17789,12 @@ function isChatType(value) {
 
 // src/constants/models.ts
 var DEFAULT_CHAT_MODEL = "aws:bedrock:claude-4-5-haiku";
+var DEFAULT_AGENT_CHAT_MODEL = "openai:chat:gpt-5.6-luna";
+var DEFAULT_AGENT_REALTIME_MODEL = "xai:realtime:voice-agent-2";
+var DEFAULT_AGENT_REALTIME_MODEL_CONFIG = {
+  ttsModel: "native",
+  voiceModel: "xai:voice:cosmo"
+};
 var DEFAULT_VOICE_INFERENCE_MODEL = "openai:chat:gpt-5.6-luna";
 var DEFAULT_CUSTOM_VOICE_MODEL = "elevenlabs:voice:river";
 
@@ -15873,6 +17886,176 @@ function getAllResourceSlugs() {
   return Object.keys(RESOURCE_METADATA);
 }
 
+// src/types/generated/digest.ts
+var DigestSlotRole = {
+  people: "people",
+  subject: "subject",
+  actor: "actor",
+  workflow: "workflow",
+  journey: "journey",
+  phone_number: "phone_number",
+  data_type: "data_type",
+  operator_group: "operator_group",
+  channel: "channel",
+  origin: "origin",
+  source: "source",
+  reason: "reason",
+  direction: "direction",
+  area: "area",
+  conclusion: "conclusion"
+};
+
+// src/types/generated/activity_feed.ts
+var ActivityGrain = {
+  month: "month",
+  week: "week",
+  day: "day",
+  hour: "hour",
+  event: "event"
+};
+var ActivityGroupBy = {
+  workspace: "workspace",
+  event_type: "event_type",
+  family: "family",
+  workspace_family: "workspace_family"
+};
+var ActivityOpenItemOrder = {
+  priority: "priority",
+  recency: "recency"
+};
+var ActivityWindowBasis = {
+  absolute: "absolute",
+  workspace_local: "workspace_local"
+};
+
+// src/types/generated/family.ts
+var ActivityEventFamily = {
+  people: "people",
+  conversations: "conversations",
+  journeys: "journeys",
+  automation: "automation",
+  operators: "operators",
+  administration: "administration"
+};
+var ActivityOutcome = {
+  ok: "ok",
+  attention: "attention",
+  failed: "failed"
+};
+
+// src/types/generated/entity_ref.ts
+var RefResolutionStatus = {
+  resolved: "resolved",
+  unresolved: "unresolved",
+  unsupported: "unsupported"
+};
+
+// src/types/generated/event_type.ts
+var ActivityCapability = {
+  "assignments:read": "assignments:read",
+  "chats:read": "chats:read",
+  "journeys:read": "journeys:read",
+  "members:read": "members:read",
+  "operator:read": "operator:read",
+  "org:read": "org:read",
+  "phones:read": "phones:read",
+  "workflows:read": "workflows:read",
+  "workspace:read": "workspace:read"
+};
+var ActivityEventType = {
+  membercreated: "member.created",
+  memberremoved: "member.removed",
+  memberrole_changed: "member.role_changed",
+  memberlabels_changed: "member.labels_changed",
+  memberattributes_changed: "member.attributes_changed",
+  importstarted: "import.started",
+  importcompleted: "import.completed",
+  assignmentstarted: "assignment.started",
+  assignmentconcluded: "assignment.concluded",
+  journeyenrolled: "journey.enrolled",
+  journeyunenrolled: "journey.unenrolled",
+  journeycompleted: "journey.completed",
+  journeystep_transitioned: "journey.step_transitioned",
+  journeyactivated: "journey.activated",
+  chatstarted: "chat.started",
+  chatawaiting_human: "chat.awaiting_human",
+  chathuman_replied: "chat.human_replied",
+  chatcall_ended: "chat.call_ended",
+  escalationopened: "escalation.opened",
+  escalationresolved: "escalation.resolved",
+  callstarted: "call.started",
+  callcompleted: "call.completed",
+  callmissed: "call.missed",
+  presencewent_online: "presence.went_online",
+  presencewent_offline: "presence.went_offline",
+  operator_groupmember_added: "operator_group.member_added",
+  operator_groupmember_removed: "operator_group.member_removed",
+  voicemailreceived: "voicemail.received",
+  voicemaillistened: "voicemail.listened",
+  routinestarted: "routine.started",
+  routinecompleted: "routine.completed",
+  routinefailed: "routine.failed",
+  workflowpublished: "workflow.published",
+  subscriptionstarted: "subscription.started",
+  subscriptionupdated: "subscription.updated",
+  subscriptioncanceled: "subscription.canceled",
+  member_subscriptionstarted: "member_subscription.started",
+  member_subscriptioncanceled: "member_subscription.canceled",
+  purchasecompleted: "purchase.completed",
+  phone_numberprovisioned: "phone_number.provisioned",
+  phone_numberarchived: "phone_number.archived",
+  domainlinked: "domain.linked",
+  domainverified: "domain.verified",
+  configupdated: "config.updated"
+};
+var ActivityVisibility = {
+  workspace: "workspace",
+  org: "org",
+  account_private: "account_private"
+};
+
+// src/types/generated/ref.ts
+var ActorKind = {
+  account: "account",
+  agent: "agent",
+  connection: "connection",
+  member: "member",
+  org_account: "org_account",
+  system: "system"
+};
+var EntityKind = {
+  account: "account",
+  org: "org",
+  org_account: "org_account",
+  workspace: "workspace",
+  agent: "agent",
+  connection: "connection",
+  member: "member",
+  assignment: "assignment",
+  journey: "journey",
+  journey_step: "journey_step",
+  routine: "routine",
+  task: "task",
+  workflow: "workflow",
+  workflow_revision: "workflow_revision",
+  call: "call",
+  chat: "chat",
+  escalation: "escalation",
+  inbox: "inbox",
+  phone_number: "phone_number",
+  voicemail: "voicemail",
+  domain: "domain",
+  import: "import",
+  invoice: "invoice",
+  member_label: "member_label",
+  member_subscription: "member_subscription",
+  operator_group: "operator_group",
+  purchase: "purchase",
+  subscription: "subscription",
+  data_type: "data_type",
+  workspace_config: "workspace_config"
+};
+
 // src/scopes.ts
 var ScopeCategory = /* @__PURE__ */ ((ScopeCategory2) => {
   ScopeCategory2["WORKSPACE"] = "workspace";
@@ -15978,7 +18161,9 @@ var SCOPES = {
   "chats:write": {
     name: "chats:write",
     category: "chats" /* CHATS */,
-    description: "Send messages in conversations",
+    // Cross-member: acting in a conversation that is not yours. Sending in
+    // your own needs no scope (see the chats:read note on "all").
+    description: "Modify other members' conversations",
     implies: ["chats:read"]
   },
   "chats:admin": {
@@ -16546,6 +18731,50 @@ function getRevisionState(workflow, revision) {
     state: revision?.publishedAt != null ? "published" : "draft"
   };
 }
+
+// src/helpers/chat-interaction.ts
+var ChatInteractionController = class {
+  constructor(api, workspaceId, chatId) {
+    this.api = api;
+    this.workspaceId = workspaceId;
+    this.chatId = chatId;
+  }
+  api;
+  workspaceId;
+  chatId;
+  current;
+  pending;
+  tail = Promise.resolve();
+  clientSessionId = crypto.randomUUID();
+  /** Serialize switches and reuse request IDs when a response is lost. */
+  ensure(mode) {
+    const operation = this.tail.then(async () => {
+      if (this.pending) await this.applyPending();
+      if (this.current?.mode !== mode) {
+        this.pending = { mode, requestId: crypto.randomUUID() };
+        await this.applyPending();
+      }
+      if (!this.current) throw new Error("Interaction session unavailable");
+      return this.current;
+    });
+    this.tail = operation.catch(() => void 0);
+    return operation;
+  }
+  async applyPending() {
+    const pending = this.pending;
+    if (!pending) return;
+    this.current = this.current ? await this.api.transitionChatInteractionSession(
+      this.workspaceId,
+      this.chatId,
+      this.current.id,
+      pending
+    ) : await this.api.createChatInteractionSession(this.workspaceId, this.chatId, {
+      ...pending,
+      clientSessionId: this.clientSessionId
+    });
+    this.pending = void 0;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_NOTE_ORIGINS,
@@ -16556,6 +18785,16 @@ function getRevisionState(workflow, revision) {
   AccessGrantStatus,
   AccessGrantTrigger,
   AccessLevel,
+  ActivityCapability,
+  ActivityEventFamily,
+  ActivityEventType,
+  ActivityGrain,
+  ActivityGroupBy,
+  ActivityOpenItemOrder,
+  ActivityOutcome,
+  ActivityVisibility,
+  ActivityWindowBasis,
+  ActorKind,
   AgentBuilder,
   ApiError,
   ApplyError,
@@ -16576,8 +18815,16 @@ function getRevisionState(workflow, revision) {
   CalendarScheduleRecurrence,
   CalendarSource,
   CapabilityClass,
+  ChannelMessageDirection,
+  ChannelMessageSource,
+  ChannelMessagesUnavailableReason,
+  ChatInteractionController,
+  ChatMuteReason,
   ConsentMethod,
   CriterionType,
+  DEFAULT_AGENT_CHAT_MODEL,
+  DEFAULT_AGENT_REALTIME_MODEL,
+  DEFAULT_AGENT_REALTIME_MODEL_CONFIG,
   DEFAULT_CHAT_MODEL,
   DEFAULT_CUSTOM_VOICE_MODEL,
   DEFAULT_THINKING_SPEECH_PHRASES,
@@ -16587,8 +18834,11 @@ function getRevisionState(workflow, revision) {
   DataRecordRetirementResponseReason,
   DataSensitivity,
   DataTypeRecordScope,
+  DigestSlotRole,
   DriverMode,
+  EhrWritebackOutcomeResponseStatus,
   EmailDnsRecordType,
+  EntityKind,
   EventRuleActionType,
   EventRuleEventType,
   EventRuleObjectType,
@@ -16599,6 +18849,11 @@ function getRevisionState(workflow, revision) {
   FhirVendor,
   FormBuilder,
   GravityRailClient,
+  ImportSkippedRuleResourceGroupResourceType,
+  ImportSkippedRuleResponseNeededResourceTypesItem,
+  ImportSkippedRuleResponseParentKind,
+  ImportSkippedRuleResponseReasonCode,
+  ImportSkippedRuleResponseStatus,
   InboundFaxStatusValues,
   IndexStatus,
   InvitationStatus,
@@ -16606,6 +18861,7 @@ function getRevisionState(workflow, revision) {
   JourneyBuilder,
   JourneyStepBuilder,
   MASKED_SECRET_SENTINEL,
+  MEMBER_RELATIONSHIP_KINDS,
   McpServerState,
   MemberFeature,
   MemberFilterBuilder,
@@ -16613,6 +18869,7 @@ function getRevisionState(workflow, revision) {
   MemberImportPreviewRowAction,
   MemberImportValidationError,
   MemberLabelBuilder,
+  MemberRelationshipKind,
   MemberType,
   MenuItemResponseItemType,
   MenuItemType,
@@ -16648,8 +18905,11 @@ function getRevisionState(workflow, revision) {
   REALTIME_MODEL_OPENAI,
   REALTIME_MODEL_OPENAI_2,
   REALTIME_MODEL_OPENAI_MINI,
+  RefResolutionStatus,
   Region,
   RegistrationIdentifier,
+  RelatedMemberRole,
+  RelationshipCardinality,
   Resource,
   RoleUpdate,
   RoutineBuilder,
@@ -16674,7 +18934,12 @@ function getRevisionState(workflow, revision) {
   TTS_PREVIEW_PROVIDERS,
   TaskBuilder,
   TemplatesApi,
+  TestChatRunLane,
+  TestChatRunOutcome,
   ToolkitState,
+  UiPromptPresentedKindValues,
+  UiPromptResponseKindValues,
+  UiPromptResponseStatusValues,
   WIDGET_SLUGS,
   WORKFLOW_IMPLICIT_USE_SCOPE,
   WorkflowAccessWarningResourceType,