@webex/contact-center 3.12.0-next.16 → 3.12.0-next.161

package/dist/cc.js

@@ -19,6 +19,10 @@ var _Utils = require("./services/core/Utils");
 var _types3 = require("./services/config/types");
 var _TaskManager = _interopRequireDefault(require("./services/task/TaskManager"));
 var _WebCallingService = _interopRequireDefault(require("./services/WebCallingService"));
+var _AnswerCallOnWebexService = _interopRequireDefault(require("./services/AnswerCallOnWebexService"));
+var _WebexCrossClientService = _interopRequireDefault(require("./services/WebexCrossClientService"));
+var _WxAppTelephonyMercurySync = _interopRequireDefault(require("./services/WxAppTelephonyMercurySync"));
+var _wxAppDiagnosticLogging = require("./services/wxAppDiagnosticLogging");
 var _types4 = require("./services/task/types");
 var _MetricsManager = _interopRequireDefault(require("./metrics/MetricsManager"));
 var _constants4 = require("./metrics/constants");
@@ -26,6 +30,7 @@ var _EntryPoint = require("./services/EntryPoint");
 var _AddressBook = require("./services/AddressBook");
 var _Queue = require("./services/Queue");
 var _ApiAiAssistant = require("./services/ApiAiAssistant");
+var _UserPreference = require("./services/UserPreference");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * @module CCPlugin
@@ -35,6 +40,13 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * with Webex Contact Center features through the WebexSDK.
  */
 
+/**
+ * Typed allow-list of server-controlled websocket event names this SDK re-emits verbatim.
+ * Guards against emitting an arbitrary/unknown `data.type` supplied by the websocket payload.
+ * @ignore
+ */
+const CC_EVENT_ALLOW_LIST = new Set(Object.values(_types3.CC_EVENTS));
+
 /**
  * The main Contact Center plugin class that enables integration with Webex Contact Center.
  *
@@ -118,7 +130,7 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  *
  *     // Login with browser-based calling
  *     await cc.stationLogin({
- *       teamId: profile.teams[0].teamId,
+ *       teamId: profile.teams[0].id,
  *       loginOption: 'BROWSER'
  *     });
  *
@@ -184,6 +196,29 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * @private
    */
 
+  /**
+   * REST telephony for wxApp thick-client answer (WXCC-6026)
+   * @private
+   */
+
+  /**
+   * usersub cross-client state for Webex App toast suppression
+   * @private
+   */
+
+  /**
+   * Mercury telephony mute sync for wxApp thick-client answer
+   * @private
+   */
+
+  /** True when wxApp mute sync opened Mercury (Extension/DN-only profiles). */
+  wxAppMercuryConnectedByCc = false;
+
+  /** True when wxApp mute sync registered the Webex device. */
+  wxAppDeviceRegisteredByCc = false;
+  static WXAPP_FALSE_PUBLISH_RETRY_DELAY_MS = 30_000;
+  static WXAPP_FALSE_PUBLISH_MAX_RETRIES = 3;
+
   /**
    * Core service managers for Contact Center operations
    * Includes agent, connection, and configuration services
@@ -212,6 +247,16 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * @private
    */
 
+  /** Current login/relogin session used for agent-scoped wellness validation. */
+
+  /** Registered-session cache for the system WellbeingBreak idle code. */
+
+  /** Registration generation that owns the wellness idle-code cache and in-flight lookups. */
+  wellnessRegistrationGeneration = 0;
+  updateWellnessSession(agentSessionId) {
+    this.currentAgentSessionId = agentSessionId;
+  }
+
   /**
    * API instance for managing Webex Contact Center entry points
    * Provides functionality to fetch entry points with caching support
@@ -274,6 +319,36 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * ```
    */
 
+  /**
+   * API instance for managing Webex Contact Center user preferences
+   * Provides functionality to get, create, update, and delete user preferences
+   * @type {UserPreference}
+   * @public
+   * @example
+   * ```typescript
+   * const cc = webex.cc;
+   * await cc.register();
+   * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+   *
+   * // Get user preferences for current user
+   * const preferences = await cc.userPreference.getUserPreference();
+   *
+   * // Create new user preferences
+   * const newPrefs = await cc.userPreference.createUserPreference({
+   *   userId: 'user123',
+   *   preferences: { e911Reminder: true }
+   * });
+   *
+   * // Update user preferences
+   * const updatedPrefs = await cc.userPreference.updateUserPreference('user123', {
+   *   preferences: { e911Reminder: false }
+   * });
+   *
+   * // Delete user preferences
+   * await cc.userPreference.deleteUserPreference('user123');
+   * ```
+   */
+
   /**
    * API instance for AI Assistant operations such as transcript controls.
    * @type {ApiAIAssistant}
@@ -301,6 +376,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
     this.$webex.once(_constants.READY, () => {
       // @ts-ignore
       this.$config = this.config;
+      this.validatePluginConfig();
 
       /**
        * This is used for handling the async requests by sending webex.request and wait for corresponding websocket event.
@@ -312,13 +388,20 @@ class ContactCenter extends _webexCore.WebexPlugin {
         webex: this.$webex,
         connectionConfig: this.getConnectionConfig()
       });
-      this.services.webSocketManager.on('message', this.handleWebsocketMessage);
       this.webCallingService = new _WebCallingService.default(this.$webex);
-      this.apiAIAssistant = new _ApiAiAssistant.ApiAIAssistant(this.$webex);
+      this.answerCallOnWebexService = new _AnswerCallOnWebexService.default(this.$webex);
+      this.webexCrossClientService = new _WebexCrossClientService.default(this.$webex);
+      this.wxAppTelephonyMercurySync = new _WxAppTelephonyMercurySync.default(this.$webex);
+      this.apiAIAssistant = new _ApiAiAssistant.ApiAIAssistant(this.$webex, () => ({
+        isWellnessBreakEnabled: this.agentConfig?.isWellnessBreakEnabled === true,
+        agentId: this.agentConfig?.agentId,
+        agentSessionId: this.currentAgentSessionId
+      }));
       this.metricsManager = _MetricsManager.default.getInstance({
         webex: this.$webex
       });
-      this.taskManager = _TaskManager.default.getTaskManager(this.apiAIAssistant, this.services.contact, this.webCallingService, this.services.webSocketManager);
+      this.taskManager = _TaskManager.default.getTaskManager(this.apiAIAssistant, this.services.contact, this.webCallingService, this.services.webSocketManager, this.services.rtdWebSocketManager);
+      this.taskManager.setAnswerCallOnWebexService(this.answerCallOnWebexService);
       this.incomingTaskListener();
 
       // Initialize API instances
@@ -326,6 +409,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
       this.entryPoint = new _EntryPoint.EntryPoint(this.$webex);
       this.addressBook = new _AddressBook.AddressBook(this.$webex, () => this.agentConfig?.addressBookId);
       this.queue = new _Queue.Queue(this.$webex);
+      this.userPreference = new _UserPreference.UserPreference(this.$webex, () => this.agentConfig?.agentId);
       _loggerProxy.default.initialize(this.$webex.logger);
     });
   }
@@ -350,6 +434,16 @@ class ContactCenter extends _webexCore.WebexPlugin {
     this.trigger(_types4.TASK_EVENTS.TASK_HYDRATE, task);
   };
 
+  /**
+   * Handles multi-login hydrate events for SDK instances without Mobius registration
+   * @private
+   * @param {ITask} task The task object associated with the multi-login hydrate
+   */
+  handleTaskMultiLoginHydrate = task => {
+    // @ts-ignore
+    this.trigger(_types4.TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, task);
+  };
+
   /**
    * Handles task merged events when tasks are combined eg: EPDN merge/transfer
    * @private
@@ -369,8 +463,83 @@ class ContactCenter extends _webexCore.WebexPlugin {
     // @ts-ignore
     this.trigger(_types4.TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, task);
   };
-  handleRTDWebsocketMessage = payload => {
-    this.taskManager.handleRealtimeWebsocketEvent(payload);
+  trackInvalidWellnessEvent(reason) {
+    this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.AI_ASSISTANT_WELLNESS_EVENT_INVALID, {
+      reason
+    }, ['operational']);
+  }
+  normalizeWellnessBreakEvent(payload) {
+    if (this.agentConfig?.isWellnessBreakEnabled !== true) {
+      this.trackInvalidWellnessEvent('wellness_disabled');
+      return null;
+    }
+    const notificationData = (0, _Utils.isRecord)(payload.data) ? payload.data : null;
+    const notificationDetails = notificationData && (0, _Utils.isRecord)(notificationData.notifDetails) ? notificationData.notifDetails : null;
+    const sessionData = notificationData && (0, _Utils.isRecord)(notificationData.data) ? notificationData.data : null;
+    const actionEvent = notificationDetails?.actionEvent;
+    if (payload.type !== _constants.WELLNESS_BREAK_HANDLER || notificationData?.notifType !== _constants.WELLNESS_BREAK_HANDLER || typeof actionEvent !== 'string') {
+      this.trackInvalidWellnessEvent('malformed_wellness_event');
+      return null;
+    }
+    if (!Object.values(_types.WELLNESS_BREAK_NOTIFICATION_ACTIONS).includes(actionEvent)) {
+      this.trackInvalidWellnessEvent('unknown_wellness_action');
+      return null;
+    }
+    const agentId = notificationData.agentId;
+    const eventOrgId = notificationData.orgId;
+    const sessionOrgId = sessionData?.orgId;
+    const envelopeOrgId = payload.orgId;
+    const agentSessionId = sessionData?.agentSessionId;
+    const currentOrgId = this.$webex.credentials.getOrgId();
+    if (typeof agentId !== 'string' || typeof eventOrgId !== 'string' || typeof sessionOrgId !== 'string' || typeof envelopeOrgId !== 'string' || typeof agentSessionId !== 'string' || !agentId || !eventOrgId || !sessionOrgId || !envelopeOrgId || !agentSessionId) {
+      this.trackInvalidWellnessEvent('missing_wellness_identity');
+      return null;
+    }
+    if (agentId !== this.agentConfig?.agentId || eventOrgId !== currentOrgId || sessionOrgId !== currentOrgId || envelopeOrgId !== currentOrgId) {
+      this.trackInvalidWellnessEvent('mismatched_wellness_identity');
+      return null;
+    }
+    const interactionValue = sessionData.interactionId ?? sessionData.InteractionId;
+    const actionText = notificationDetails.actionText;
+    const trackingId = payload.trackingId;
+    return {
+      agentId,
+      orgId: currentOrgId,
+      agentSessionId,
+      actionEvent: actionEvent,
+      ...(typeof actionText === 'string' ? {
+        actionText
+      } : {}),
+      ...(typeof interactionValue === 'string' ? {
+        interactionId: interactionValue
+      } : {}),
+      ...(typeof trackingId === 'string' ? {
+        trackingId
+      } : {})
+    };
+  }
+  handleWellnessBreakWebsocketPayload(payload) {
+    if (payload.type !== _constants.WELLNESS_BREAK_HANDLER) {
+      return false;
+    }
+    const wellnessEvent = this.normalizeWellnessBreakEvent(payload);
+    if (wellnessEvent) {
+      // @ts-ignore - WebexPlugin emit is available at runtime but absent from its declaration.
+      this.emit(_types3.CC_EVENTS.WELLNESS_BREAK, wellnessEvent);
+    }
+    return true;
+  }
+  handleRTDWebsocketMessage = event => {
+    let payload;
+    try {
+      payload = JSON.parse(event);
+    } catch {
+      // TaskManager retains its existing malformed RTD message handling.
+    }
+    if ((0, _Utils.isRecord)(payload) && this.handleWellnessBreakWebsocketPayload(payload)) {
+      return;
+    }
+    this.taskManager.handleRealtimeWebsocketEvent(event);
   };
 
   /**
@@ -381,6 +550,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
   incomingTaskListener() {
     this.taskManager.on(_types4.TASK_EVENTS.TASK_INCOMING, this.handleIncomingTask);
     this.taskManager.on(_types4.TASK_EVENTS.TASK_HYDRATE, this.handleTaskHydrate);
+    this.taskManager.on(_types4.TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this.handleTaskMultiLoginHydrate);
     this.taskManager.on(_types4.TASK_EVENTS.TASK_MERGED, this.handleTaskMerged);
     this.taskManager.on(_types4.TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, this.handleCampaignPreviewReservation);
   }
@@ -413,22 +583,25 @@ class ContactCenter extends _webexCore.WebexPlugin {
    *
    * console.log('Agent ID:', profile.agentId);
    * console.log('Default DN:', profile.defaultDn);
-   * console.log('Teams:', profile.teams.map(t => t.teamId));
+   * console.log('Teams:', profile.teams.map(t => t.id));
    * console.log('WebRTC Enabled:', profile.webRtcEnabled);
    * console.log('Supported Login Options:', profile.loginVoiceOptions);
    *
    * // Now you can proceed with station login, state changes, etc.
-   * await cc.stationLogin({ teamId: profile.teams[0].teamId, loginOption: 'BROWSER' });
+   * await cc.stationLogin({ teamId: profile.teams[0].id, loginOption: 'BROWSER' });
    * ```
    */
   async register() {
-    _loggerProxy.default.info('Starting CC SDK registration', {
+    this.wellnessRegistrationGeneration += 1;
+    this.wellbeingBreakIdleCode = undefined;
+    _loggerProxy.default.log('Starting CC SDK registration', {
       module: _constants.CC_FILE,
       method: _constants.METHODS.REGISTER
     });
     try {
       this.metricsManager.timeEvent([_constants4.METRIC_EVENT_NAMES.WEBSOCKET_REGISTER_SUCCESS, _constants4.METRIC_EVENT_NAMES.WEBSOCKET_REGISTER_FAILED]);
       this.setupEventListeners();
+      this.services.webSocketManager.on('message', this.handleWebsocketMessage);
       const resp = await this.connectWebsocket();
       // Ensure 'dn' is always populated from 'defaultDn'
       resp.dn = resp.defaultDn;
@@ -440,7 +613,14 @@ class ContactCenter extends _webexCore.WebexPlugin {
         module: _constants.CC_FILE,
         method: _constants.METHODS.REGISTER
       });
-      return resp;
+
+      // Registration can silently restore a station session without emitting a
+      // relogin event. Project the active session for consumers that must
+      // recover session-scoped state after a page refresh.
+      return resp.isAgentLoggedIn && this.currentAgentSessionId ? {
+        ...resp,
+        agentSessionId: this.currentAgentSessionId
+      } : resp;
     } catch (error) {
       this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WEBSOCKET_REGISTER_FAILED, {
         orgId: error.orgId
@@ -487,15 +667,25 @@ class ContactCenter extends _webexCore.WebexPlugin {
    *
     */
   async deregister() {
+    this.wellnessRegistrationGeneration += 1;
+    this.wellbeingBreakIdleCode = undefined;
+    this.updateWellnessSession();
     try {
       this.metricsManager.timeEvent([_constants4.METRIC_EVENT_NAMES.WEBSOCKET_DEREGISTER_SUCCESS, _constants4.METRIC_EVENT_NAMES.WEBSOCKET_DEREGISTER_FAIL]);
+      this.taskManager.clearAISummaryState();
       this.taskManager.off(_types4.TASK_EVENTS.TASK_INCOMING, this.handleIncomingTask);
       this.taskManager.off(_types4.TASK_EVENTS.TASK_HYDRATE, this.handleTaskHydrate);
+      this.taskManager.off(_types4.TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this.handleTaskMultiLoginHydrate);
       this.taskManager.off(_types4.TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, this.handleCampaignPreviewReservation);
       this.taskManager.unregisterIncomingCallEvent();
       this.services.webSocketManager.off('message', this.handleWebsocketMessage);
       this.services.rtdWebSocketManager.off('message', this.handleRTDWebsocketMessage);
       this.services.connectionService.off('connectionLost', this.handleConnectionLost);
+      const {
+        publishError: wxAppPublishError
+      } = await this.teardownWxAppLocalState({
+        clearInitFlag: true
+      });
       if (this.agentConfig.webRtcEnabled && this.agentConfig.loginVoiceOptions.includes(_types.LoginOption.BROWSER)) {
         if (this.$webex.internal.mercury.connected) {
           this.$webex.internal.mercury.off('online');
@@ -512,12 +702,20 @@ class ContactCenter extends _webexCore.WebexPlugin {
       if (!this.services.webSocketManager.isSocketClosed) {
         this.services.webSocketManager.close(false, 'Unregistering the SDK');
       }
+      if (this.services.rtdWebSocketManager && !this.services.rtdWebSocketManager.isSocketClosed) {
+        this.services.rtdWebSocketManager.close(false, 'Unregistering the SDK');
+      }
       if (this.services.rtdWebSocketManager && !this.services.rtdWebSocketManager.isSocketClosed) {
         this.services.rtdWebSocketManager.close(false, 'Unregistering the RTD websocket');
       }
 
       // Clear any cached agent configuration
+      this.wellbeingBreakIdleCode = undefined;
       this.agentConfig = null;
+      this.updateWellnessSession();
+      if (wxAppPublishError) {
+        throw wxAppPublishError;
+      }
       _loggerProxy.default.log('Deregistered successfully', {
         module: _constants.CC_FILE,
         method: _constants.METHODS.DEREGISTER
@@ -571,6 +769,12 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * ```
    */
   async getBuddyAgents(data) {
+    const {
+      action,
+      state,
+      mediaType = 'telephony'
+    } = data;
+    const buddyAgentState = state ?? (action === 'Transfer' ? _constants2.AGENT_STATE_AVAILABLE : undefined);
     _loggerProxy.default.info('Fetching buddy agents', {
       module: _constants.CC_FILE,
       method: _constants.METHODS.GET_BUDDY_AGENTS
@@ -580,13 +784,16 @@ class ContactCenter extends _webexCore.WebexPlugin {
       const resp = await this.services.agent.buddyAgents({
         data: {
           agentProfileId: this.agentConfig.agentProfileID,
-          ...data
+          mediaType,
+          ...(buddyAgentState ? {
+            state: buddyAgentState
+          } : {})
         }
       });
       this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.FETCH_BUDDY_AGENTS_SUCCESS, {
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(resp),
-        mediaType: data.mediaType,
-        buddyAgentState: data.state,
+        mediaType,
+        buddyAgentState,
         buddyAgentCount: resp.data.agentList.length
       }, ['operational']);
       _loggerProxy.default.log(`Successfully retrieved ${resp.data.agentList.length} buddy agents`, {
@@ -599,8 +806,8 @@ class ContactCenter extends _webexCore.WebexPlugin {
       const failureResp = error.details;
       this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.FETCH_BUDDY_AGENTS_FAILED, {
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(failureResp),
-        mediaType: data.mediaType,
-        buddyAgentState: data.state
+        mediaType,
+        buddyAgentState
       }, ['operational']);
       const {
         error: detailedError
@@ -616,7 +823,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * @private
    */
   async connectWebsocket() {
-    _loggerProxy.default.info('Connecting to websocket', {
+    _loggerProxy.default.log('Connecting to websocket', {
       module: _constants.CC_FILE,
       method: _constants.METHODS.CONNECT_WEBSOCKET
     });
@@ -632,18 +839,42 @@ class ContactCenter extends _webexCore.WebexPlugin {
         module: _constants.CC_FILE,
         method: _constants.METHODS.CONNECT_WEBSOCKET
       });
-
+      const configFlags = {
+        isEndTaskEnabled: this.agentConfig.isEndTaskEnabled,
+        isEndConsultEnabled: this.agentConfig.isEndConsultEnabled,
+        webRtcEnabled: this.agentConfig.webRtcEnabled,
+        autoWrapup: this.agentConfig.wrapUpData?.wrapUpProps?.autoWrapup ?? false,
+        aiFeature: this.agentConfig.aiFeature,
+        consultTransfer: {
+          allowConsultToQueue: this.agentConfig.allowConsultToQueue,
+          accessQueue: this.agentConfig.accessQueue,
+          accessEntryPoint: this.agentConfig.accessEntryPoint,
+          accessBuddyTeam: this.agentConfig.accessBuddyTeam
+        },
+        enableWxBetterTogether: this.isWxBetterTogetherEnabled(),
+        getWxAppUsersubPublished: () => this.webexCrossClientService.isAnswerCallsStateActive()
+      };
+      this.taskManager.setConfigFlags(configFlags);
       // TODO: Make profile a singleton to make it available throughout app/sdk so we dont need to inject info everywhere
       this.taskManager.setWrapupData(this.agentConfig.wrapUpData);
       this.taskManager.setAgentId(this.agentConfig.agentId);
+      this.taskManager.setAgentName(this.agentConfig.agentName);
       this.taskManager.setWebRtcEnabled(this.agentConfig.webRtcEnabled);
       this.apiAIAssistant.setAIFeatureFlags(this.agentConfig.aiFeature);
-      if (this.agentConfig.aiFeature?.realtimeTranscripts?.enable) {
+      this.wellbeingBreakIdleCode = undefined;
+      this.updateWellnessSession();
+
+      /**
+       * RTD websocket currently supports realtime transcripts and suggested responses.
+       * Extend this condition when additional AI RTD features are introduced.
+       * Wellness break notifications also arrive on this websocket.
+       */
+      if (this.agentConfig.aiFeature?.realtimeTranscripts?.enable || this.agentConfig.aiFeature?.suggestedResponses?.enable || this.agentConfig.aiFeature?.generatedSummaries?.wrapUpSummariesEnabled === true || this.agentConfig.aiFeature?.generatedSummaries?.consultTransferSummariesEnabled === true || this.agentConfig.isWellnessBreakEnabled) {
         _loggerProxy.default.info('Connecting to RTD websocket', {
           module: _constants.CC_FILE,
           method: _constants.METHODS.CONNECT_WEBSOCKET
         });
-        await this.services.rtdWebSocketManager.initWebSocket({
+        this.services.rtdWebSocketManager.initWebSocket({
           body: this.getConnectionConfig(),
           resource: _constants3.RTD_SUBSCRIBE_API
         }).then(() => {
@@ -653,13 +884,13 @@ class ContactCenter extends _webexCore.WebexPlugin {
           });
           this.services.rtdWebSocketManager.on('message', this.handleRTDWebsocketMessage);
         }).catch(error => {
-          _loggerProxy.default.error(`Error during RTD websocket setup: ${error}`, {
+          _loggerProxy.default.error(`Error connecting to RTD websocket ${error}`, {
             module: _constants.CC_FILE,
             method: _constants.METHODS.CONNECT_WEBSOCKET
           });
         });
       }
-      if (this.agentConfig.webRtcEnabled && this.agentConfig.loginVoiceOptions.includes(_types.LoginOption.BROWSER)) {
+      if (this.agentConfig.webRtcEnabled && this.agentConfig.loginVoiceOptions.includes(_types.LoginOption.BROWSER) && !this.isWebRTCRegistrationDisabled()) {
         try {
           await this.$webex.internal.mercury.connect();
           _loggerProxy.default.log('Authentication: webex.internal.mercury.connect successful', {
@@ -672,12 +903,23 @@ class ContactCenter extends _webexCore.WebexPlugin {
             method: _constants.METHODS.CONNECT_WEBSOCKET
           });
         }
+      } else if (this.isWebRTCRegistrationDisabled()) {
+        _loggerProxy.default.info('Skipping Mobius registration because disableWebRTCRegistration is enabled', {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.CONNECT_WEBSOCKET
+        });
       }
       if (this.$config && this.$config.allowAutomatedRelogin) {
         await this.silentRelogin();
+      } else {
+        _loggerProxy.default.log('Skipping silent relogin: allowAutomatedRelogin is disabled', {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.CONNECT_WEBSOCKET
+        });
       }
       return this.agentConfig;
     } catch (error) {
+      this.updateWellnessSession();
       _loggerProxy.default.error(`Error during register: ${error}`, {
         module: _constants.CC_FILE,
         method: _constants.METHODS.CONNECT_WEBSOCKET
@@ -715,30 +957,37 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * ```
    */
   async stationLogin(data) {
-    _loggerProxy.default.info('Starting agent station login', {
+    const loggerContext = {
       module: _constants.CC_FILE,
       method: _constants.METHODS.STATION_LOGIN
-    });
+    };
     try {
+      _loggerProxy.default.log(`Starting agent station login | loginOption: ${data?.loginOption} teamId: ${data?.teamId}`, loggerContext);
       this.metricsManager.timeEvent([_constants4.METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS, _constants4.METRIC_EVENT_NAMES.STATION_LOGIN_FAILED]);
       const dialPlanEntries = this.agentConfig?.dialPlan?.dialPlanEntity ?? [];
-      if (data.loginOption === _types.LoginOption.AGENT_DN && !(0, _Utils.isValidDialNumber)(data.dialNumber, dialPlanEntries)) {
-        const error = new Error('INVALID_DIAL_NUMBER');
-        // @ts-ignore - adding custom key to the error object
-        error.details = {
-          data: {
-            reason: 'INVALID_DIAL_NUMBER'
-          }
-        };
-        throw error;
+      if (data.loginOption === _types.LoginOption.AGENT_DN) {
+        _loggerProxy.default.log(`Validating dial number | dialPlanEnabled: ${!!this.agentConfig?.dialPlan} | dialPlanEntryCount: ${dialPlanEntries.length}`, loggerContext);
+        if (!(0, _Utils.isValidDialNumber)(data.dialNumber, dialPlanEntries)) {
+          _loggerProxy.default.log(`Dial number validation failed | dialNumber: ${data.dialNumber} | dialPlanEntryCount: ${dialPlanEntries.length}`, loggerContext);
+          const error = new Error('INVALID_DIAL_NUMBER');
+          // @ts-ignore - adding custom key to the error object
+          error.details = {
+            data: {
+              reason: 'INVALID_DIAL_NUMBER'
+            }
+          };
+          throw error;
+        }
       }
+      const deviceId = this.getDeviceId(data.loginOption, data.dialNumber);
       const loginResponse = await this.services.agent.stationLogin({
         data: {
-          dialNumber: data.loginOption === _types.LoginOption.BROWSER ? this.agentConfig.agentId : data.dialNumber,
+          // BROWSER DN must be webrtc-{agentId} so VPOP/RTMS do not treat a bare UUID as PSTN.
+          dialNumber: data.loginOption === _types.LoginOption.BROWSER ? deviceId : data.dialNumber,
           teamId: data.teamId,
           deviceType: data.loginOption,
           isExtension: data.loginOption === _types.LoginOption.EXTENSION,
-          deviceId: this.getDeviceId(data.loginOption, data.dialNumber),
+          deviceId,
           roles: [_constants3.AGENT],
           teamName: _constants.EMPTY_STRING,
           siteId: _constants.EMPTY_STRING,
@@ -746,14 +995,20 @@ class ContactCenter extends _webexCore.WebexPlugin {
           auxCodeId: _constants.EMPTY_STRING
         }
       });
-      if (this.agentConfig.webRtcEnabled && data.loginOption === _types.LoginOption.BROWSER) {
+      if (this.agentConfig.webRtcEnabled && data.loginOption === _types.LoginOption.BROWSER && !this.isWebRTCRegistrationDisabled()) {
         await this.webCallingService.registerWebCallingLine();
+      } else if (this.agentConfig.webRtcEnabled && data.loginOption === _types.LoginOption.BROWSER && this.isWebRTCRegistrationDisabled()) {
+        _loggerProxy.default.info('Skipping web calling line registration because disableWebRTCRegistration is enabled', {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.STATION_LOGIN
+        });
       }
       const resp = await loginResponse;
       const {
         channelsMap,
         ...loginData
       } = resp.data;
+      this.updateWellnessSession(resp.data.agentSessionId);
       this.agentConfig.currentTeamId = resp.data.teamId;
       const response = {
         ...loginData,
@@ -766,6 +1021,13 @@ class ContactCenter extends _webexCore.WebexPlugin {
         notifsTrackingId: resp.trackingId
       };
       this.webCallingService.setLoginOption(data.loginOption);
+      if (this.agentConfig) {
+        this.agentConfig.deviceType = data.loginOption;
+        if (data.loginOption === _types.LoginOption.AGENT_DN || data.loginOption === _types.LoginOption.EXTENSION) {
+          this.agentConfig.defaultDn = data.dialNumber;
+          this.agentConfig.dn = data.dialNumber;
+        }
+      }
       this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS, {
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(resp),
         loginType: data.loginOption,
@@ -778,6 +1040,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
         method: _constants.METHODS.STATION_LOGIN,
         trackingId: resp.trackingId
       });
+      await this.ensureWxAppPostStationLogin();
       return response;
     } catch (error) {
       const failure = error.details;
@@ -832,6 +1095,8 @@ class ContactCenter extends _webexCore.WebexPlugin {
       if (this.webCallingService) {
         this.webCallingService.deregisterWebCallingLine();
       }
+      await this.teardownWxAppLocalState();
+      this.updateWellnessSession();
       _loggerProxy.default.log(`Agent station logout completed successfully`, {
         module: _constants.CC_FILE,
         method: _constants.METHODS.STATION_LOGOUT,
@@ -925,7 +1190,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
       this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.AGENT_STATE_CHANGE_SUCCESS, {
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(agentStatusResponse),
         requestedState: data.state,
-        teamId: this.agentConfig?.teams[0]?.teamId ?? _constants.EMPTY_STRING,
+        teamId: this.agentConfig?.teams[0]?.id ?? _constants.EMPTY_STRING,
         status: agentStatusResponse.data?.status,
         subStatus: agentStatusResponse.data?.subStatus,
         auxCodeId: data.auxCodeId,
@@ -952,6 +1217,63 @@ class ContactCenter extends _webexCore.WebexPlugin {
     }
   }
 
+  /**
+   * Returns the system-managed `WellbeingBreak` idle code for the current registration.
+   * The value is fetched outside Desktop Profile filtering and cached until deregistration.
+   * @returns The normalized system idle-code entity
+   * @throws Structured Contact Center error when wellness is disabled or the code is unavailable
+   * @example
+   * const idleCode = await webex.cc.getWellbeingBreakIdleCode();
+   * @public
+   */
+  async getWellbeingBreakIdleCode() {
+    const method = _constants.METHODS.GET_WELLBEING_BREAK_IDLE_CODE;
+    try {
+      if (!this.agentConfig?.isWellnessBreakEnabled) {
+        const validationError = new Error('WELLNESS_BREAK_NOT_ENABLED');
+        validationError.details = {
+          type: 'SDK_VALIDATION_ERROR',
+          orgId: this.$webex.credentials.getOrgId(),
+          trackingId: _constants.EMPTY_STRING,
+          data: {
+            reason: 'WELLNESS_BREAK_NOT_ENABLED'
+          }
+        };
+        throw validationError;
+      }
+      if (this.wellbeingBreakIdleCode) {
+        return this.wellbeingBreakIdleCode;
+      }
+      this.metricsManager.timeEvent([_constants4.METRIC_EVENT_NAMES.WELLBEING_BREAK_IDLE_CODE_FETCH_SUCCESS, _constants4.METRIC_EVENT_NAMES.WELLBEING_BREAK_IDLE_CODE_FETCH_FAILED]);
+      const registrationGeneration = this.wellnessRegistrationGeneration;
+      const orgId = this.$webex.credentials.getOrgId();
+      const idleCode = await this.services.config.getWellbeingBreakIdleCode(orgId);
+      if (registrationGeneration !== this.wellnessRegistrationGeneration || orgId !== this.$webex.credentials.getOrgId() || !this.agentConfig?.isWellnessBreakEnabled) {
+        const staleRegistrationError = new Error('WELLNESS_BREAK_REGISTRATION_CHANGED');
+        staleRegistrationError.details = {
+          type: 'SDK_VALIDATION_ERROR',
+          orgId,
+          trackingId: _constants.EMPTY_STRING,
+          data: {
+            reason: 'WELLNESS_BREAK_REGISTRATION_CHANGED'
+          }
+        };
+        throw staleRegistrationError;
+      }
+      this.wellbeingBreakIdleCode = idleCode;
+      this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WELLBEING_BREAK_IDLE_CODE_FETCH_SUCCESS, {}, ['operational']);
+      return idleCode;
+    } catch (error) {
+      this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WELLBEING_BREAK_IDLE_CODE_FETCH_FAILED, {
+        reason: error instanceof Error ? error.message : _constants.UNKNOWN_ERROR
+      }, ['operational']);
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, method, _constants.CC_FILE);
+      throw detailedError;
+    }
+  }
+
   /**
    * Processes incoming websocket messages and emits corresponding events
    * Handles various event types including agent state changes, login events,
@@ -961,8 +1283,9 @@ class ContactCenter extends _webexCore.WebexPlugin {
    */
   handleWebsocketMessage = event => {
     const eventData = JSON.parse(event);
-    // Re-emit all the events related to agent except keep-alives
-    if (!eventData.keepalive && eventData.data && eventData.data.type) {
+    // Re-emit all the events related to agent except keep-alives. Only event names present in
+    // the typed CC_EVENTS allow-list are emitted; unknown/server-injected types are ignored.
+    if (!eventData.keepalive && eventData.data && eventData.data.type && CC_EVENT_ALLOW_LIST.has(eventData.data.type)) {
       // @ts-ignore
       this.emit(eventData.data.type, eventData.data);
     }
@@ -985,8 +1308,14 @@ class ContactCenter extends _webexCore.WebexPlugin {
       };
       this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WEBSOCKET_EVENT_RECEIVED, metricsPayload, ['operational']);
     }
+    if (this.handleWellnessBreakWebsocketPayload(eventData)) {
+      return;
+    }
     switch (eventData.type) {
       case _types3.CC_EVENTS.AGENT_MULTI_LOGIN:
+        if (eventData.data?.type === 'AgentMultiLoginCloseSession' && (!eventData.data.agentSessionId || eventData.data.agentSessionId === this.currentAgentSessionId)) {
+          this.updateWellnessSession();
+        }
         // @ts-ignore
         this.emit(_types2.AGENT_EVENTS.AGENT_MULTI_LOGIN, eventData.data);
         break;
@@ -1007,6 +1336,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
             channelsMap,
             ...loginData
           } = eventData.data;
+          this.updateWellnessSession(loginData.agentSessionId);
           const stationLoginData = {
             ...loginData,
             mmProfile: {
@@ -1028,6 +1358,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
             channelsMap,
             ...loginData
           } = eventData.data;
+          this.updateWellnessSession(loginData.agentSessionId);
           const stationReLoginData = {
             ...loginData,
             mmProfile: {
@@ -1040,8 +1371,8 @@ class ContactCenter extends _webexCore.WebexPlugin {
           };
           // @ts-ignore
           this.emit(_types2.AGENT_EVENTS.AGENT_RELOGIN_SUCCESS, stationReLoginData);
+          break;
         }
-        break;
       case _types3.CC_EVENTS.AGENT_STATE_CHANGE_SUCCESS:
         // @ts-ignore
         this.emit(_types2.AGENT_EVENTS.AGENT_STATE_CHANGE_SUCCESS, eventData.data);
@@ -1055,6 +1386,9 @@ class ContactCenter extends _webexCore.WebexPlugin {
         this.emit(_types2.AGENT_EVENTS.AGENT_STATION_LOGIN_FAILED, eventData.data);
         break;
       case _types3.CC_EVENTS.AGENT_LOGOUT_SUCCESS:
+        if (!eventData.data.agentSessionId || eventData.data.agentSessionId === this.currentAgentSessionId) {
+          this.updateWellnessSession();
+        }
         // @ts-ignore
         this.emit(_types2.AGENT_EVENTS.AGENT_LOGOUT_SUCCESS, eventData.data);
         break;
@@ -1071,6 +1405,504 @@ class ContactCenter extends _webexCore.WebexPlugin {
     }
   };
 
+  /**
+   * Checks whether Mobius/WebRTC registration should be skipped by config
+   * @returns {boolean} True when browser WebRTC registration is disabled
+   * @private
+   */
+  isWebRTCRegistrationDisabled() {
+    return this.$config?.disableWebRTCRegistration === true;
+  }
+
+  /**
+   * Validates contact-center plugin configuration before service initialization
+   * @private
+   */
+  validatePluginConfig() {
+    if (this.$config?.disableWebRTCRegistration === true && this.$config?.allowMultiLogin === false) {
+      throw new Error('Invalid Contact Center configuration: disableWebRTCRegistration cannot be true when allowMultiLogin is false. Enable allowMultiLogin or allow WebRTC registration so an SDK instance can receive Mobius/WebRTC task events.');
+    }
+  }
+
+  /**
+   * Whether wxApp thick-client answer is enabled for this SDK instance.
+   * @public
+   */
+  isWxBetterTogetherEnabled() {
+    return this.$config?.enableWxBetterTogether === true;
+  }
+
+  /**
+   * Current station login option (Extension, Dial Number, or Browser/Desktop).
+   * Prefer webCallingService — updated on every stationLogin before wxApp hooks run.
+   * @private
+   */
+  getCurrentStationLoginOption() {
+    return this.webCallingService?.loginOption ?? this.agentConfig?.deviceType;
+  }
+
+  /**
+   * wxApp thick-client answer is supported for Extension and Dial Number station login only —
+   * not Browser/Desktop (WebRTC) login.
+   * @private
+   */
+  assertWxAppStationLoginSupportedForEnable() {
+    const loginOption = this.getCurrentStationLoginOption();
+    if (loginOption !== _types.LoginOption.EXTENSION && loginOption !== _types.LoginOption.AGENT_DN) {
+      throw new Error('setManageWebexCallingInWxcc requires EXTENSION or AGENT_DN station login. Complete station login before enabling.');
+    }
+  }
+
+  /**
+   * Clears runtime wxApp config after logout/deregister so stale flags do not apply on relogin.
+   * @private
+   */
+  resetEnableWxBetterTogetherConfig() {
+    if (this.$config) {
+      this.$config.enableWxBetterTogether = false;
+    }
+    this.taskManager.applyEnableWxBetterTogether(false);
+  }
+
+  /**
+   * Runtime enable/disable for wxApp Better Together (toast suppression + Mercury mute sync).
+   *
+   * **Phase 1 (WXCC-6026 / MMT): NOT part of the public host contract.**
+   * Hosts must set `webexConfig.cc.enableWxBetterTogether` before `webex.init()` / `cc.register()`.
+   * To change the flag after the SDK is initialized, re-init the SDK with the updated config.
+   *
+   * **Supported public read API:** {@link isWxBetterTogetherEnabled}.
+   * **Supported telephony API:** unified `task.accept()`, `task.decline()`, `task.toggleMute()`,
+   * `task.transmitDtmf()` — SDK routes wxApp calls internally when the init flag is active.
+   *
+   * **Production lifecycle does not call this method.** Station login, silent relogin, logout,
+   * and deregister use {@link ensureWxAppPostStationLogin} and {@link teardownWxAppLocalState}
+   * (usersub publish + Mercury subscribe/unsubscribe based on the init flag).
+   *
+   * This setter remains as a **private implementation** for Phase 2 runtime toggle and unit tests.
+   * It updates `$config.enableWxBetterTogether`, TaskManager flags, cross-client usersub
+   * (`answer-calls-on-wxcc`), and Mercury mute sync; rolls back config on publish/connect failure.
+   *
+   * @param enabled - `true` to enable wxApp answer + usersub suppression; `false` to disable and tear down.
+   * @throws When enabling without login, on unsupported BROWSER station login, or when usersub/Mercury init fails.
+   * @internal
+   * @see enableWxBetterTogether (CCPluginConfig init flag)
+   * @see ensureWxAppPostStationLogin
+   * @see teardownWxAppLocalState
+   */
+  async setManageWebexCallingInWxcc(enabled) {
+    if (enabled && !this.$webex.internal.device?.userId) {
+      throw new Error('Cannot publish answer-calls-on-wxcc: user is not logged in');
+    }
+    if (enabled) {
+      this.assertWxAppStationLoginSupportedForEnable();
+    }
+    const previousEnabled = this.isWxBetterTogetherEnabled();
+    if (this.$config) {
+      this.$config.enableWxBetterTogether = enabled;
+    }
+    this.taskManager.applyEnableWxBetterTogether(enabled);
+    let publishedEnable = false;
+    try {
+      if (enabled) {
+        await this.ensureWxAppMercuryAndSubscribe();
+        await this.publishAnswerOnWebexCrossClientState(true);
+        publishedEnable = true;
+        this.taskManager.syncWxAppMuteFromCallDetailsForAllTasks();
+        this.taskManager.refreshWxAppOfferObservabilityForAllTasks();
+      } else {
+        await this.publishAnswerOnWebexCrossClientState(false);
+        this.wxAppTelephonyMercurySync.unsubscribe();
+        await this.releaseWxAppMercuryResources();
+      }
+    } catch (error) {
+      if (publishedEnable) {
+        await this.revertWxAppCrossClientPublish();
+      } else if (enabled) {
+        this.wxAppTelephonyMercurySync.unsubscribe();
+        await this.releaseWxAppMercuryResources();
+      }
+      if (this.$config) {
+        this.$config.enableWxBetterTogether = previousEnabled;
+      }
+      this.taskManager.applyEnableWxBetterTogether(previousEnabled);
+      throw error;
+    }
+  }
+  getWxAppTelephonyTaskType() {
+    const loginOption = this.getCurrentStationLoginOption();
+    if (loginOption === _types.LoginOption.BROWSER) {
+      return 'WebRTC';
+    }
+    if (loginOption === _types.LoginOption.EXTENSION || loginOption === _types.LoginOption.AGENT_DN) {
+      return 'Voice';
+    }
+    return 'unknown';
+  }
+  async ensureWxAppPostStationLogin() {
+    const loginOption = this.getCurrentStationLoginOption();
+    const flagEnabled = this.isWxBetterTogetherEnabled();
+    const telephonyTaskType = this.getWxAppTelephonyTaskType();
+    if (loginOption === _types.LoginOption.BROWSER) {
+      if (flagEnabled) {
+        (0, _wxAppDiagnosticLogging.logWxAppSessionReadiness)({
+          enableWxBetterTogether: true,
+          loginOption,
+          wxAppHooksApplied: false,
+          usersubPublished: false,
+          mercurySubscribed: false,
+          telephonyTaskType,
+          skipReason: 'unsupported_browser_login'
+        });
+        this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WXAPP_SESSION_SKIPPED, {
+          loginOption,
+          enableWxBetterTogether: true,
+          skipReason: 'unsupported_browser_login'
+        }, ['operational', 'behavioral']);
+      }
+      return;
+    }
+    let publishedEnable = false;
+    let wxAppInitStage = 'mercury';
+    try {
+      if (flagEnabled) {
+        this.metricsManager.timeEvent([_constants4.METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_SUCCESS, _constants4.METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED]);
+        await this.ensureWxAppMercuryAndSubscribe();
+        wxAppInitStage = 'publish';
+        await this.publishAnswerOnWebexCrossClientState(true);
+        publishedEnable = true;
+        this.taskManager.syncWxAppMuteFromCallDetailsForAllTasks();
+        this.taskManager.refreshWxAppOfferObservabilityForAllTasks();
+        const mercurySubscribed = this.wxAppTelephonyMercurySync.isSubscribed();
+        const usersubPublished = this.webexCrossClientService.isAnswerCallsStateActive();
+        (0, _wxAppDiagnosticLogging.logWxAppSessionReadiness)({
+          enableWxBetterTogether: true,
+          loginOption,
+          wxAppHooksApplied: true,
+          usersubPublished,
+          mercurySubscribed,
+          telephonyTaskType
+        });
+        const sessionInitReady = mercurySubscribed && usersubPublished;
+        if (sessionInitReady) {
+          this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_SUCCESS, {
+            loginOption,
+            enableWxBetterTogether: true,
+            usersubPublished,
+            mercurySubscribed,
+            telephonyTaskType
+          }, ['operational', 'behavioral']);
+        } else {
+          this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED, {
+            loginOption,
+            enableWxBetterTogether: true,
+            usersubPublished,
+            mercurySubscribed,
+            telephonyTaskType,
+            skipReason: !usersubPublished ? 'usersub_not_published' : 'mercury_not_subscribed'
+          }, ['operational', 'behavioral']);
+        }
+      } else {
+        await this.ensureWxAppDeviceRegistered();
+        await this.publishAnswerOnWebexCrossClientState(false, {
+          force: true
+        });
+        this.webexCrossClientService.teardown();
+        this.wxAppTelephonyMercurySync.unsubscribe();
+        await this.releaseWxAppMercuryResources();
+        (0, _wxAppDiagnosticLogging.logWxAppSessionReadiness)({
+          enableWxBetterTogether: false,
+          loginOption,
+          wxAppHooksApplied: true,
+          usersubPublished: false,
+          mercurySubscribed: false,
+          telephonyTaskType,
+          skipReason: 'flag_disabled'
+        });
+        this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WXAPP_SESSION_SKIPPED, {
+          loginOption,
+          enableWxBetterTogether: false,
+          skipReason: 'flag_disabled'
+        }, ['operational', 'behavioral']);
+      }
+    } catch (error) {
+      _loggerProxy.default.error(`Failed to initialize wxApp post-station-login: ${error}`, {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.STATION_LOGIN
+      });
+      if (flagEnabled) {
+        const sessionInitFailureReason = wxAppInitStage === 'mercury' ? 'mercury_subscribe_failed' : 'publish_failed';
+        this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED, {
+          loginOption,
+          enableWxBetterTogether: true,
+          usersubPublished: this.webexCrossClientService.isAnswerCallsStateActive(),
+          mercurySubscribed: this.wxAppTelephonyMercurySync.isSubscribed(),
+          telephonyTaskType,
+          skipReason: sessionInitFailureReason,
+          error: error instanceof Error ? error.toString() : String(error)
+        }, ['operational', 'behavioral']);
+        (0, _wxAppDiagnosticLogging.logWxAppSessionReadiness)({
+          enableWxBetterTogether: true,
+          loginOption,
+          wxAppHooksApplied: false,
+          usersubPublished: this.webexCrossClientService.isAnswerCallsStateActive(),
+          mercurySubscribed: this.wxAppTelephonyMercurySync.isSubscribed(),
+          telephonyTaskType,
+          skipReason: sessionInitFailureReason
+        });
+        if (publishedEnable) {
+          await this.revertWxAppCrossClientPublish();
+        } else {
+          this.wxAppTelephonyMercurySync.unsubscribe();
+          await this.releaseWxAppMercuryResources();
+        }
+        this.resetEnableWxBetterTogetherConfig();
+      } else {
+        this.scheduleForcedFalsePublishRetry();
+      }
+    }
+  }
+  clearWxAppFalsePublishRetryTimer() {
+    if (this.wxAppFalsePublishRetryTimer) {
+      clearTimeout(this.wxAppFalsePublishRetryTimer);
+      this.wxAppFalsePublishRetryTimer = undefined;
+    }
+  }
+  scheduleForcedFalsePublishRetry(retryAttempt = 0) {
+    this.scheduleFalsePublishRetry(retryAttempt, {
+      requireDisabled: true
+    });
+  }
+
+  /**
+   * Retries compensating false publish after rollback failure, regardless of enabled flag.
+   * @private
+   */
+  scheduleCompensatingFalsePublishRetry(retryAttempt = 0) {
+    this.scheduleFalsePublishRetry(retryAttempt);
+  }
+  scheduleFalsePublishRetry(retryAttempt = 0, options = {}) {
+    if (retryAttempt >= ContactCenter.WXAPP_FALSE_PUBLISH_MAX_RETRIES) {
+      return;
+    }
+    if (options?.requireDisabled && this.isWxBetterTogetherEnabled()) {
+      return;
+    }
+    this.clearWxAppFalsePublishRetryTimer();
+    this.wxAppFalsePublishRetryTimer = setTimeout(async () => {
+      this.wxAppFalsePublishRetryTimer = undefined;
+      if (options?.requireDisabled && this.isWxBetterTogetherEnabled()) {
+        return;
+      }
+      if (!options?.requireDisabled && this.isWxBetterTogetherEnabled() && this.webexCrossClientService.isAnswerCallsStateActive()) {
+        return;
+      }
+      try {
+        await this.ensureWxAppDeviceRegistered();
+        await this.publishAnswerOnWebexCrossClientState(false, {
+          force: true
+        });
+        this.webexCrossClientService.teardown();
+        this.wxAppTelephonyMercurySync.unsubscribe();
+        await this.releaseWxAppMercuryResources();
+      } catch (retryError) {
+        _loggerProxy.default.error(`Failed to retry forced answer-calls-on-wxcc false publish: ${retryError}`, {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.SET_MANAGE_WEBEX_CALLING_IN_WXCC
+        });
+        this.scheduleFalsePublishRetry(retryAttempt + 1, options);
+      }
+    }, ContactCenter.WXAPP_FALSE_PUBLISH_RETRY_DELAY_MS);
+  }
+
+  /**
+   * Best-effort rollback when usersub true was published but wxApp setup did not complete.
+   * @private
+   */
+  async revertWxAppCrossClientPublish() {
+    try {
+      await this.publishAnswerOnWebexCrossClientState(false, {
+        force: true
+      });
+    } catch (error) {
+      _loggerProxy.default.error(`Failed to publish compensating answer-calls-on-wxcc false during wxApp rollback: ${error}`, {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.SET_MANAGE_WEBEX_CALLING_IN_WXCC
+      });
+      this.scheduleCompensatingFalsePublishRetry();
+    }
+    this.webexCrossClientService.teardown();
+    this.wxAppTelephonyMercurySync.unsubscribe();
+    await this.releaseWxAppMercuryResources();
+  }
+  async ensureWxAppDeviceRegistered() {
+    const device = this.$webex.internal.device;
+    if (device && !device.registered && device.register) {
+      await device.register();
+      this.wxAppDeviceRegisteredByCc = true;
+      _loggerProxy.default.log('WxApp: device registered for cross-client publish', {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.ENSURE_WXAPP_MERCURY_CONNECTED
+      });
+    }
+  }
+  async ensureWxAppMercuryConnected() {
+    const mercury = this.$webex.internal.mercury;
+    await this.ensureWxAppDeviceRegistered();
+    if (mercury && !mercury.connected) {
+      await mercury.connect();
+      this.wxAppMercuryConnectedByCc = true;
+      _loggerProxy.default.log('WxApp mute sync: mercury connected', {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.ENSURE_WXAPP_MERCURY_CONNECTED
+      });
+    }
+  }
+
+  /**
+   * Disconnects Mercury and unregisters the device when wxApp mute sync opened them.
+   * @private
+   */
+  async releaseWxAppMercuryResources() {
+    const mercury = this.$webex.internal.mercury;
+    const device = this.$webex.internal.device;
+    if (this.wxAppMercuryConnectedByCc && mercury?.connected) {
+      try {
+        await mercury.disconnect();
+        this.wxAppMercuryConnectedByCc = false;
+        _loggerProxy.default.log('WxApp mute sync: mercury disconnected', {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.ENSURE_WXAPP_MERCURY_CONNECTED
+        });
+      } catch (error) {
+        _loggerProxy.default.error(`Failed to disconnect wxApp Mercury: ${error}`, {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.ENSURE_WXAPP_MERCURY_CONNECTED
+        });
+      }
+    }
+    if (this.wxAppDeviceRegisteredByCc && device?.registered && device.unregister) {
+      try {
+        // @ts-ignore
+        await device.unregister();
+        this.wxAppDeviceRegisteredByCc = false;
+        _loggerProxy.default.log('WxApp mute sync: device unregistered', {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.ENSURE_WXAPP_MERCURY_CONNECTED
+        });
+      } catch (error) {
+        _loggerProxy.default.error(`Failed to unregister wxApp device: ${error}`, {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.ENSURE_WXAPP_MERCURY_CONNECTED
+        });
+      }
+    } else if (this.wxAppDeviceRegisteredByCc) {
+      this.wxAppDeviceRegisteredByCc = false;
+    }
+  }
+
+  /**
+   * Clears wxApp runtime state and feature-owned resources. Publish failures are logged;
+   * optional rethrow for deregister when callers need to surface usersub errors.
+   * @private
+   */
+  async teardownWxAppLocalState(options) {
+    this.clearWxAppFalsePublishRetryTimer();
+    let publishError;
+    try {
+      const shouldForceFalsePublish = this.isWxBetterTogetherEnabled() || this.webexCrossClientService.isAnswerCallsStateActive();
+      await this.publishAnswerOnWebexCrossClientState(false, {
+        force: shouldForceFalsePublish
+      });
+    } catch (error) {
+      publishError = error;
+      _loggerProxy.default.error(`Failed to publish answer-calls-on-wxcc false during wxApp teardown: ${error}`, {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.SET_MANAGE_WEBEX_CALLING_IN_WXCC
+      });
+    }
+    this.webexCrossClientService.teardown();
+    this.wxAppTelephonyMercurySync.unsubscribe();
+    await this.releaseWxAppMercuryResources();
+    if (options?.clearInitFlag) {
+      this.resetEnableWxBetterTogetherConfig();
+    }
+    if (publishError) {
+      this.scheduleCompensatingFalsePublishRetry();
+    }
+    if (options?.rethrowPublishError && publishError) {
+      throw publishError;
+    }
+    return {
+      publishError: publishError ?? undefined
+    };
+  }
+  async ensureWxAppMercuryAndSubscribe() {
+    if (!this.isWxBetterTogetherEnabled()) {
+      return;
+    }
+    if (this.getCurrentStationLoginOption() === _types.LoginOption.BROWSER) {
+      return;
+    }
+    const agentId = this.agentConfig?.agentId;
+    if (!agentId) {
+      _loggerProxy.default.error('Cannot subscribe wxApp mute sync: agentId unavailable', {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.SYNC_WXAPP_MUTE_FROM_MERCURY
+      });
+      this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_FAILED, {
+        error: 'agentId unavailable',
+        mercurySubscribed: false
+      }, ['operational', 'behavioral']);
+      return;
+    }
+    try {
+      await this.ensureWxAppMercuryConnected();
+      this.wxAppTelephonyMercurySync.subscribe(agentId, (callId, muted) => {
+        this.taskManager.applyWxAppMuteStateFromSync(callId, muted);
+      });
+    } catch (error) {
+      _loggerProxy.default.error(`Failed to ensure wxApp Mercury mute sync: ${error}`, {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.SYNC_WXAPP_MUTE_FROM_MERCURY
+      });
+      this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_FAILED, {
+        error: error instanceof Error ? error.toString() : String(error),
+        mercurySubscribed: false
+      }, ['operational', 'behavioral']);
+      this.wxAppTelephonyMercurySync.unsubscribe();
+      await this.releaseWxAppMercuryResources();
+      throw error;
+    }
+  }
+  async publishAnswerOnWebexCrossClientState(enable, options) {
+    if (enable && !this.isWxBetterTogetherEnabled()) {
+      return;
+    }
+    if (!enable && !options?.force && !this.webexCrossClientService.isAnswerCallsStateActive()) {
+      return;
+    }
+    const userId = this.$webex.internal.device?.userId;
+    if (!userId) {
+      if (enable && this.isWxBetterTogetherEnabled()) {
+        this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED, {
+          enableWxBetterTogether: true,
+          usersubPublished: this.webexCrossClientService.isAnswerCallsStateActive(),
+          skipReason: 'user_id_unavailable',
+          error: 'User ID is unavailable for cross-client publish'
+        }, ['operational', 'behavioral']);
+      }
+      return;
+    }
+    await this.webexCrossClientService.setManageWebexCallingInWxcc(enable, {
+      userId,
+      trackPublishMetrics: true
+    });
+    if (enable) {
+      this.clearWxAppFalsePublishRetryTimer();
+    }
+  }
+
   /**
    * Initializes event listeners for the Contact Center service
    * Sets up handlers for connection state changes and other core events
@@ -1102,13 +1934,13 @@ class ContactCenter extends _webexCore.WebexPlugin {
   async handleConnectionLost(msg) {
     if (msg.isConnectionLost) {
       // TODO: Emit an event saying connection is lost
-      _loggerProxy.default.info('event=handleConnectionLost | Connection lost', {
+      _loggerProxy.default.log('event=handleConnectionLost | Connection lost', {
         module: _constants.CC_FILE,
         method: _constants.METHODS.HANDLE_CONNECTION_LOST
       });
     } else if (msg.isSocketReconnected) {
       // TODO: Emit an event saying connection is re-estabilished
-      _loggerProxy.default.info('event=handleConnectionReconnect | Connection reconnected attempting to request silent relogin', {
+      _loggerProxy.default.log('event=handleConnectionReconnect | Connection reconnected attempting to request silent relogin', {
         module: _constants.CC_FILE,
         method: _constants.METHODS.HANDLE_CONNECTION_LOST
       });
@@ -1123,12 +1955,13 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * @private
    */
   async silentRelogin() {
-    _loggerProxy.default.info('Starting silent relogin process', {
+    _loggerProxy.default.log('Starting silent relogin process', {
       module: _constants.CC_FILE,
       method: _constants.METHODS.SILENT_RELOGIN
     });
     try {
       const reLoginResponse = await this.services.agent.reload();
+      this.updateWellnessSession(reLoginResponse.data.agentSessionId);
       const {
         agentId,
         lastStateChangeReason,
@@ -1145,7 +1978,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
       this.agentConfig.currentTeamId = reLoginResponse.data.teamId;
       await this.handleDeviceType(deviceType, dn);
       if (lastStateChangeReason === 'agent-wss-disconnect') {
-        _loggerProxy.default.info('event=requestAutoStateChange | Requesting state change to available on socket reconnect', {
+        _loggerProxy.default.log('event=requestAutoStateChange | Requesting state change to available on socket reconnect', {
           module: _constants.CC_FILE,
           method: _constants.METHODS.SILENT_RELOGIN
         });
@@ -1169,8 +2002,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
       }
       this.agentConfig.lastStateAuxCodeId = auxCodeId;
       this.agentConfig.isAgentLoggedIn = true;
-      // TODO: https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-626777 Implement the de-register method and close the listener there
-      this.services.webSocketManager.on('message', this.handleWebsocketMessage);
+      await this.ensureWxAppPostStationLogin();
       _loggerProxy.default.log(`Silent relogin process completed successfully with login Option: ${reLoginResponse.data.deviceType} teamId: ${reLoginResponse.data.teamId}`, {
         module: _constants.CC_FILE,
         method: _constants.METHODS.SILENT_RELOGIN,
@@ -1205,6 +2037,13 @@ class ContactCenter extends _webexCore.WebexPlugin {
     this.agentConfig.deviceType = deviceType;
     switch (deviceType) {
       case _types.LoginOption.BROWSER:
+        if (this.isWebRTCRegistrationDisabled()) {
+          _loggerProxy.default.info('Skipping web calling line registration because disableWebRTCRegistration is enabled', {
+            module: _constants.CC_FILE,
+            method: _constants.METHODS.HANDLE_DEVICE_TYPE
+          });
+          break;
+        }
         try {
           await this.webCallingService.registerWebCallingLine();
         } catch (error) {
@@ -1780,8 +2619,8 @@ class ContactCenter extends _webexCore.WebexPlugin {
   }
 
   /**
-   * Returns paginated entry points for the organization.
-   * Thin wrapper around internal EntryPoint instance.
+   * Returns paginated entry points using the EntryPoint service defaults.
+   * Existing request parameters can override those defaults.
    * @public
    */
   async getEntryPoints(params = {}) {
@@ -1789,8 +2628,8 @@ class ContactCenter extends _webexCore.WebexPlugin {
   }
 
   /**
-   * Returns paginated contact service queues for the organization.
-   * Thin wrapper around internal Queue instance.
+   * Returns paginated contact service queues using the Queue service defaults.
+   * Existing request parameters can override those defaults.
    * @public
    */
   async getQueues(params = {}) {