@webex/contact-center 3.11.0 → 3.12.0-auth-prejoin-fetch.1

package/dist/services/task/TaskManager.js

@@ -12,11 +12,18 @@ var _constants2 = require("./constants");
 var _types2 = require("../config/types");
 var _types3 = require("../../types");
 var _loggerProxy = _interopRequireDefault(require("../../logger-proxy"));
-var _ = _interopRequireDefault(require("."));
-var _MetricsManager = _interopRequireDefault(require("../../metrics/MetricsManager"));
-var _constants3 = require("../../metrics/constants");
 var _TaskUtils = require("./TaskUtils");
+var _TaskFactory = _interopRequireDefault(require("./TaskFactory"));
+var _WebexCallingUtils = require("./WebexCallingUtils");
+var _WebRTC = _interopRequireDefault(require("./voice/WebRTC"));
+var _stateMachine = require("./state-machine");
+var _constants3 = require("./state-machine/constants");
+var _taskDataNormalizer = require("./taskDataNormalizer");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const CC_EVENT_SET = new Set(Object.values(_types2.CC_EVENTS));
+const MAIN_INTERACTION_CORRELATED_EVENTS = new Set([_types2.CC_EVENTS.AGENT_CONSULT_ENDED, _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE]);
+const isCcEvent = value => CC_EVENT_SET.has(value);
+
 /** @internal */
 class TaskManager extends _events.default {
   /**
@@ -25,24 +32,71 @@ class TaskManager extends _events.default {
    * @private
    */
 
+  // eslint-disable-next-line no-use-before-define
+
   /**
    * @param contact - Routing Contact layer. Talks to AQMReq layer to convert events to promises
    * @param webCallingService - Webrtc Service Layer
    * @param webSocketManager - Websocket Manager to maintain websocket connection and keepalives
    */
-  constructor(contact, webCallingService, webSocketManager) {
+  constructor(apiAIAssistant, contact, webCallingService, webSocketManager, rtdWebSocketManager) {
     super();
+    this.apiAIAssistant = apiAIAssistant;
     this.contact = contact;
-    this.taskCollection = {};
     this.webCallingService = webCallingService;
     this.webSocketManager = webSocketManager;
-    this.metricsManager = _MetricsManager.default.getInstance();
+    this.rtdWebSocketManager = rtdWebSocketManager;
+    this.taskCollection = {};
+    this.webRtcEnabled = false;
     this.registerTaskListeners();
     this.registerIncomingCallEvent();
   }
+  handleRealtimeWebsocketEvent(event) {
+    try {
+      const payload = JSON.parse(event);
+      const interactionId = payload?.data?.data?.conversationId;
+      if (!interactionId) return;
+      const task = this.taskCollection[interactionId];
+      if (!task) {
+        _loggerProxy.default.info(`Realtime transcription task not found`, {
+          module: _constants.TASK_MANAGER_FILE,
+          method: _constants2.METHODS.HANDLE_REAL_TIME_WEBSOCKET_EVENT,
+          interactionId
+        });
+        return;
+      }
+      switch (payload.type) {
+        case _types2.CC_EVENTS.REAL_TIME_TRANSCRIPTION:
+        case _types2.CC_EVENTS.SUGGESTED_RESPONSE:
+          task.emit(payload.type, payload.data);
+          break;
+      }
+    } catch (error) {
+      _loggerProxy.default.error('Failed to parse RTD WebSocket message', {
+        module: _constants.TASK_MANAGER_FILE,
+        method: _constants2.METHODS.HANDLE_REAL_TIME_WEBSOCKET_EVENT,
+        error
+      });
+    }
+  }
+
+  /**
+   * Set config flags for task creation
+   */
+  setConfigFlags(configFlags) {
+    this.configFlags = configFlags;
+  }
+
+  /**
+   * Set wrapup configuration data
+   */
   setWrapupData(wrapupData) {
     this.wrapupData = wrapupData;
   }
+
+  /**
+   * Set agent ID for task operations
+   */
   setAgentId(agentId) {
     this.agentId = agentId;
   }
@@ -58,8 +112,11 @@ class TaskManager extends _events.default {
   setWebRtcEnabled(webRtcEnabled) {
     this.webRtcEnabled = webRtcEnabled;
   }
+  setAnswerCallOnWebexService(answerCallOnWebexService) {
+    this.answerCallOnWebexService = answerCallOnWebexService;
+  }
   handleIncomingWebCall = call => {
-    const currentTask = Object.values(this.taskCollection).find(task => task.data.interaction.mediaType === 'telephony');
+    const currentTask = Object.values(this.taskCollection).find(task => task.data.interaction.mediaType === 'telephony' && !(0, _TaskUtils.isCampaignPreviewReservation)(task));
     if (currentTask) {
       this.webCallingService.mapCallToTask(call.getCallId(), currentTask.data.interactionId);
       _loggerProxy.default.log(`Call mapped to task`, {
@@ -67,7 +124,12 @@ class TaskManager extends _events.default {
         method: _constants2.METHODS.HANDLE_INCOMING_WEB_CALL,
         interactionId: currentTask.data.interactionId
       });
-      this.emit(_types.TASK_EVENTS.TASK_INCOMING, currentTask);
+
+      // Send TASK_INCOMING to state machine - it will emit on the task object
+      const eventPayload = TaskManager.mapEventToTaskStateMachineEvent(_types2.CC_EVENTS.AGENT_CONTACT_RESERVED, currentTask.data);
+      if (eventPayload && currentTask) {
+        currentTask.sendStateMachineEvent(eventPayload);
+      }
     }
     this.call = call;
   };
@@ -77,409 +139,919 @@ class TaskManager extends _events.default {
   unregisterIncomingCallEvent() {
     this.webCallingService.off(_calling.LINE_EVENTS.INCOMING_CALL, this.handleIncomingWebCall);
   }
-  registerTaskListeners() {
-    this.webSocketManager.on('message', event => {
-      const payload = JSON.parse(event);
-      // Re-emit the task events to the task object
-      let task;
-      if (payload.data?.type) {
-        if (Object.values(_types2.CC_TASK_EVENTS).includes(payload.data.type)) {
-          task = this.taskCollection[payload.data.interactionId];
+
+  /**
+   * Map WebSocket CC_EVENTS to state machine TaskEvent
+   * @param ccEvent - The CC_EVENT type from WebSocket
+   * @param payload - The event payload
+   * @param agentId - Optional agent ID for state detection (needed for HYDRATE)
+   * @param task - Optional task instance for state-aware CONTACT_ENDED mapping
+   * @returns TaskEventPayload for state machine or null if no mapping
+   */
+  static mapEventToTaskStateMachineEvent(ccEvent, payload, agentId, task, enableWxBetterTogether) {
+    const mediaResourceId = payload.mediaResourceId || payload.interaction?.media?.[payload.interactionId]?.mediaResourceId;
+    switch (ccEvent) {
+      // CC -> TaskEvent mappings (see TaskStateMachine comment for quick reference)
+      case _types2.CC_EVENTS.AGENT_CONTACT_RESERVED:
+        // AgentContactReserved -> TASK_INCOMING
+        if ((0, _TaskUtils.isCampaignPreviewTask)(payload)) {
+          return {
+            type: _stateMachine.TaskEvent.TASK_INCOMING,
+            taskData: payload,
+            isCampaignReservationAccept: true
+          };
         }
-        _loggerProxy.default.info(`Handling task event ${payload.data?.type}`, {
-          module: _constants.TASK_MANAGER_FILE,
-          method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
-          interactionId: payload.data?.interactionId
-        });
-        switch (payload.data.type) {
-          case _types2.CC_EVENTS.AGENT_CONTACT:
-            // Case1 : Task is already present in taskCollection
-            if (this.taskCollection[payload.data.interactionId]) {
-              _loggerProxy.default.log(`Got AGENT_CONTACT: Task already exists in collection`, {
-                module: _constants.TASK_MANAGER_FILE,
-                method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
-                interactionId: payload.data.interactionId
-              });
-              break;
-            } else if (!this.taskCollection[payload.data.interactionId]) {
-              // Case2 : Task is not present in taskCollection
-              _loggerProxy.default.log(`Got AGENT_CONTACT : Creating new task in taskManager`, {
-                module: _constants.TASK_MANAGER_FILE,
-                method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
-                interactionId: payload.data.interactionId
-              });
-
-              // Check if auto-answer should happen for this task
-              const shouldAutoAnswer = (0, _TaskUtils.shouldAutoAnswerTask)(payload.data, this.agentId, this.webCallingService.loginOption, this.webRtcEnabled);
-              task = new _.default(this.contact, this.webCallingService, {
-                ...payload.data,
-                wrapUpRequired: payload.data.interaction?.participants?.[this.agentId]?.isWrapUp || false,
-                isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(payload.data),
-                isAutoAnswering: shouldAutoAnswer // Set flag before emitting
-              }, this.wrapupData, this.agentId);
-              this.taskCollection[payload.data.interactionId] = task;
-              // Condition 1: The state is=new i.e it is a incoming task
-              if (payload.data.interaction.state === 'new') {
-                _loggerProxy.default.log(`Got AGENT_CONTACT for a task with state=new, sending TASK_INCOMING event`, {
-                  module: _constants.TASK_MANAGER_FILE,
-                  method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
-                  interactionId: payload.data.interactionId
-                });
-                this.emit(_types.TASK_EVENTS.TASK_INCOMING, task);
-              } else {
-                // Condition 2: The state is anything else i.e the task was connected
-                _loggerProxy.default.log(`Got AGENT_CONTACT for a task with state=${payload.data.interaction.state}, sending TASK_HYDRATE event`, {
-                  module: _constants.TASK_MANAGER_FILE,
-                  method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
-                  interactionId: payload.data.interactionId
-                });
-                this.emit(_types.TASK_EVENTS.TASK_HYDRATE, task);
-              }
-            }
-            break;
-          case _types2.CC_EVENTS.AGENT_CONTACT_RESERVED:
-            {
-              // Check if auto-answer should happen for this task
-              const shouldAutoAnswerReserved = (0, _TaskUtils.shouldAutoAnswerTask)(payload.data, this.agentId, this.webCallingService.loginOption, this.webRtcEnabled);
-              task = new _.default(this.contact, this.webCallingService, {
-                ...payload.data,
-                isConsulted: false,
-                isAutoAnswering: shouldAutoAnswerReserved // Set flag before emitting
-              }, this.wrapupData, this.agentId);
-              this.taskCollection[payload.data.interactionId] = task;
-              if (this.webCallingService.loginOption !== _types3.LoginOption.BROWSER || task.data.interaction.mediaType !== _types.MEDIA_CHANNEL.TELEPHONY // for digital channels
-              ) {
-                this.emit(_types.TASK_EVENTS.TASK_INCOMING, task);
-              } else if (this.call) {
-                this.emit(_types.TASK_EVENTS.TASK_INCOMING, task);
-              }
-              break;
-            }
-          case _types2.CC_EVENTS.AGENT_OFFER_CONTACT:
-            // We don't have to emit any event here since this will be result of promise.
-            task = this.updateTaskData(task, payload.data);
-            _loggerProxy.default.log(`Agent offer contact received for task`, {
-              module: _constants.TASK_MANAGER_FILE,
-              method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
-              interactionId: payload.data?.interactionId
-            });
-            this.emit(_types.TASK_EVENTS.TASK_OFFER_CONTACT, task);
-
-            // Handle auto-answer for offer contact
-            this.handleAutoAnswer(task);
-            break;
-          case _types2.CC_EVENTS.AGENT_OUTBOUND_FAILED:
-            if (task) {
-              task = this.updateTaskData(task, payload.data);
-              this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_OUTDIAL_FAILED, {
-                ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(payload.data),
-                taskId: payload.data.interactionId,
-                reason: payload.data.reasonCode || payload.data.reason
-              }, ['behavioral', 'operational']);
-              _loggerProxy.default.log(`Agent outbound failed for task`, {
-                module: _constants.TASK_MANAGER_FILE,
-                method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
-                interactionId: payload.data.interactionId
-              });
-              task.emit(_types.TASK_EVENTS.TASK_OUTDIAL_FAILED, payload.data.reason ?? 'UNKNOWN_REASON');
-            }
-            break;
-          case _types2.CC_EVENTS.AGENT_CONTACT_ASSIGNED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_ASSIGNED, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONTACT_UNASSIGNED:
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              wrapUpRequired: true
-            });
-            task.emit(_types.TASK_EVENTS.TASK_END, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONTACT_OFFER_RONA:
-          case _types2.CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED:
-          case _types2.CC_EVENTS.AGENT_INVITE_FAILED:
-            {
-              task = this.updateTaskData(task, payload.data);
-              const eventTypeToMetricMap = {
-                [_types2.CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED]: 'AGENT_CONTACT_ASSIGN_FAILED',
-                [_types2.CC_EVENTS.AGENT_INVITE_FAILED]: 'AGENT_INVITE_FAILED'
-              };
-              const metricEventName = eventTypeToMetricMap[payload.data.type] || 'AGENT_RONA';
-              this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES[metricEventName], {
-                ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(payload.data),
-                taskId: payload.data.interactionId,
-                reason: payload.data.reason
-              }, ['behavioral', 'operational']);
-              this.handleTaskCleanup(task);
-              task.emit(_types.TASK_EVENTS.TASK_REJECT, payload.data.reason);
-              break;
-            }
-          case _types2.CC_EVENTS.CONTACT_ENDED:
-            // Update task data
-            if (task) {
-              task = this.updateTaskData(task, {
-                ...payload.data,
-                wrapUpRequired: payload.data.interaction.state !== 'new' && !(0, _TaskUtils.isSecondaryEpDnAgent)(payload.data.interaction)
-              });
-
-              // Handle cleanup based on whether task should be deleted
-              this.handleTaskCleanup(task);
-              task?.emit(_types.TASK_EVENTS.TASK_END, task);
-            }
-            break;
-          case _types2.CC_EVENTS.CONTACT_MERGED:
-            task = this.handleContactMerged(task, payload.data);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONTACT_HELD:
-            // As soon as the main interaction is held, we need to emit TASK_HOLD
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_HOLD, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONTACT_UNHELD:
-            // As soon as the main interaction is unheld, we need to emit TASK_RESUME
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_RESUME, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_VTEAM_TRANSFERRED:
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              wrapUpRequired: true
-            });
-            task.emit(_types.TASK_EVENTS.TASK_END, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CTQ_CANCEL_FAILED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_CONSULT_QUEUE_FAILED, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONSULT_CREATED:
-            // Received when self agent initiates a consult
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              isConsulted: false // This ensures that the task consult status is always reset
-            });
-            task.emit(_types.TASK_EVENTS.TASK_CONSULT_CREATED, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_OFFER_CONSULT:
-            // Received when other agent sends us a consult offer
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              isConsulted: true // This ensures that the task is marked as us being requested for a consult
-            });
-            task.emit(_types.TASK_EVENTS.TASK_OFFER_CONSULT, task);
-
-            // Handle auto-answer for consult offer
-            this.handleAutoAnswer(task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONSULTING:
-            // Received when agent is in an active consult state
-            // TODO: Check if we can use backend consult state instead of isConsulted
-            task = this.updateTaskData(task, payload.data);
-            if (task.data.isConsulted) {
-              // Fire only if you are the agent who received the consult request
-              task.emit(_types.TASK_EVENTS.TASK_CONSULT_ACCEPTED, task);
-            } else {
-              // Fire only if you are the agent who initiated the consult
-              task.emit(_types.TASK_EVENTS.TASK_CONSULTING, task);
-            }
-            break;
-          case _types2.CC_EVENTS.AGENT_CONSULT_FAILED:
-            // This can only be received by the agent who initiated the consult.
-            // We need not emit any event here since this will be result of promise
-            task = this.updateTaskData(task, payload.data);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONSULT_ENDED:
-            task = this.updateTaskData(task, payload.data);
-            if (task.data.isConsulted) {
-              // This will be the end state of the task as soon as we end the consult in case of
-              // us being offered a consult
-              this.removeTaskFromCollection(task);
-            }
-            task.emit(_types.TASK_EVENTS.TASK_CONSULT_END, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CTQ_CANCELLED:
-            // This event is received when the consult using queue is cancelled using API
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_CONSULT_QUEUE_CANCELLED, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_WRAPUP:
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              wrapUpRequired: true
-            });
-            task.emit(_types.TASK_EVENTS.TASK_END, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_WRAPPEDUP:
-            task.cancelAutoWrapupTimer();
-            this.removeTaskFromCollection(task);
-            task.emit(_types.TASK_EVENTS.TASK_WRAPPEDUP, task);
-            break;
-          case _types2.CC_EVENTS.CONTACT_RECORDING_PAUSED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_RECORDING_PAUSED, task);
-            break;
-          case _types2.CC_EVENTS.CONTACT_RECORDING_PAUSE_FAILED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_RECORDING_PAUSE_FAILED, task);
-            break;
-          case _types2.CC_EVENTS.CONTACT_RECORDING_RESUMED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_RECORDING_RESUMED, task);
-            break;
-          case _types2.CC_EVENTS.CONTACT_RECORDING_RESUME_FAILED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_RECORDING_RESUME_FAILED, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCING:
-            // Conference is being established - update task state and emit establishing event
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_CONFERENCE_ESTABLISHING, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCED:
-            // Conference started successfully - update task state and emit event
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCE_FAILED:
-            // Conference failed - update task state and emit failure event
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_CONFERENCE_FAILED, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED:
-            // Conference ended - update task state and emit event
-            task = this.updateTaskData(task, payload.data);
-            if (!task || (0, _TaskUtils.isPrimary)(task, this.agentId) || (0, _TaskUtils.isParticipantInMainInteraction)(task, this.agentId)) {
-              _loggerProxy.default.log('Primary or main interaction participant leaving conference');
-            } else {
-              this.removeTaskFromCollection(task);
-            }
-            task.emit(_types.TASK_EVENTS.TASK_CONFERENCE_ENDED, task);
-            break;
-          case _types2.CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE:
-            {
-              task = this.updateTaskData(task, {
-                ...payload.data,
-                isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(payload.data)
-              });
-              task.emit(_types.TASK_EVENTS.TASK_PARTICIPANT_JOINED, task);
-              break;
-            }
-          case _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE:
-            {
-              // Conference ended - update task state and emit event
-
-              task = this.updateTaskData(task, {
-                ...payload.data,
-                isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(payload.data)
-              });
-              if ((0, _TaskUtils.checkParticipantNotInInteraction)(task, this.agentId)) {
-                if ((0, _TaskUtils.isParticipantInMainInteraction)(task, this.agentId) || (0, _TaskUtils.isPrimary)(task, this.agentId)) {
-                  _loggerProxy.default.log('Primary or main interaction participant leaving conference');
-                } else {
-                  this.removeTaskFromCollection(task);
-                }
+        return {
+          type: _stateMachine.TaskEvent.TASK_INCOMING,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION:
+        // -> TASK_INCOMING (campaign branch via guard)
+        return {
+          type: _stateMachine.TaskEvent.TASK_INCOMING,
+          taskData: payload,
+          isCampaignReservationAccept: true
+        };
+      case _types2.CC_EVENTS.AGENT_OFFER_CONTACT:
+        // AgentOfferContact -> TASK_OFFERED
+        return {
+          type: _stateMachine.TaskEvent.TASK_OFFERED,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_CONTACT:
+        // AgentContact -> HYDRATE
+        // Include agentId for state detection (e.g., checking isWrapUp in participant data)
+        return {
+          type: _stateMachine.TaskEvent.HYDRATE,
+          taskData: payload,
+          agentId
+        };
+      case _types2.CC_EVENTS.CONTACT_UPDATED:
+        if (task && typeof payload.interaction?.owner === 'string' && payload.interaction.owner.trim().length > 0 && payload.interaction.owner !== task.data?.interaction?.owner) {
+          return {
+            type: _stateMachine.TaskEvent.CONTACT_OWNER_CHANGED,
+            taskData: payload
+          };
+        }
+        return {
+          type: _stateMachine.TaskEvent.CONTACT_UPDATED,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.CONTACT_OWNER_CHANGED:
+        return {
+          type: _stateMachine.TaskEvent.CONTACT_OWNER_CHANGED,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_OFFER_CONSULT:
+        // AgentOfferConsult -> OFFER_CONSULT
+        return {
+          type: _stateMachine.TaskEvent.OFFER_CONSULT,
+          taskData: {
+            ...payload,
+            isConsulted: true
+          }
+        };
+      case _types2.CC_EVENTS.AGENT_CONTACT_ASSIGNED:
+        // AgentContactAssigned -> ASSIGN
+        return {
+          type: _stateMachine.TaskEvent.ASSIGN,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_CONTACT_HELD:
+        return {
+          type: _stateMachine.TaskEvent.HOLD_SUCCESS,
+          mediaResourceId: mediaResourceId || '',
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_CONTACT_UNHELD:
+        return {
+          type: _stateMachine.TaskEvent.UNHOLD_SUCCESS,
+          mediaResourceId: mediaResourceId || '',
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_CONSULT_CREATED:
+        return {
+          type: _stateMachine.TaskEvent.CONSULT_CREATED,
+          taskData: {
+            ...payload,
+            isConsulted: false
+          }
+        };
+      case _types2.CC_EVENTS.AGENT_CONSULTING:
+        // AgentConsulting -> CONSULTING_ACTIVE
+        // use context to figure out if it's the initiator or receiver using consultInitiator from context
+        return {
+          type: _stateMachine.TaskEvent.CONSULTING_ACTIVE,
+          consultDestinationAgentJoined: true,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_CONSULT_ENDED:
+        // AgentConsultEnded -> CONSULT_END
+        return {
+          type: _stateMachine.TaskEvent.CONSULT_END,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_CONSULT_FAILED:
+      case _types2.CC_EVENTS.AGENT_CTQ_FAILED:
+        return {
+          type: _stateMachine.TaskEvent.CONSULT_FAILED,
+          reason: payload.reason,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_CTQ_CANCELLED:
+        return {
+          type: _stateMachine.TaskEvent.CTQ_CANCEL,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_CTQ_CANCEL_FAILED:
+        return {
+          type: _stateMachine.TaskEvent.CTQ_CANCEL_FAILED,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_BLIND_TRANSFERRED: // AgentBlindTransferred -> TRANSFER_SUCCESS
+      case _types2.CC_EVENTS.AGENT_CONSULT_TRANSFERRED: // AgentConsultTransferred -> TRANSFER_SUCCESS
+      case _types2.CC_EVENTS.AGENT_VTEAM_TRANSFERRED:
+        // AgentVTeamTransferred -> TRANSFER_SUCCESS
+        return {
+          type: _stateMachine.TaskEvent.TRANSFER_SUCCESS,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_WRAPUP:
+        return {
+          type: _stateMachine.TaskEvent.TASK_WRAPUP,
+          taskData: {
+            ...payload,
+            wrapUpRequired: true
+          }
+        };
+      case _types2.CC_EVENTS.AGENT_CONTACT_UNASSIGNED:
+        return null;
+      // Add WRAPUP if needed
+
+      case _types2.CC_EVENTS.AGENT_BLIND_TRANSFER_FAILED:
+      case _types2.CC_EVENTS.AGENT_VTEAM_TRANSFER_FAILED:
+      case _types2.CC_EVENTS.AGENT_CONSULT_TRANSFER_FAILED:
+      case _types2.CC_EVENTS.AGENT_CONFERENCE_TRANSFER_FAILED:
+        return {
+          type: _stateMachine.TaskEvent.TRANSFER_FAILED,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.CONTACT_ENDED:
+        {
+          const wrapUpRequired = (0, _TaskUtils.isCampaignPreviewTask)(payload) ? false : payload.agentsPendingWrapUp?.includes(agentId || '') || false;
+
+          // Post-accept wxApp outdial agent-end delivers ContactEnded instead of
+          // AgentOutboundFailed. Normalize to OUTBOUND_FAILED so state machine
+          // enters WRAPPING_UP and emits TASK_OUTDIAL_FAILED (AGENT_ENDS).
+          // Pre-accept cancelTask decline stays CONTACT_ENDED → TERMINATED (no wrapup).
+          if (TaskManager.isAgentTerminatedOutdialWrapup(payload, wrapUpRequired, task, agentId, enableWxBetterTogether)) {
+            return {
+              type: _stateMachine.TaskEvent.OUTBOUND_FAILED,
+              reason: 'AGENT_ENDS',
+              taskData: {
+                ...payload,
+                wrapUpRequired: true
               }
-              task.emit(_types.TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
-              break;
+            };
+          }
+          return {
+            type: _stateMachine.TaskEvent.CONTACT_ENDED,
+            taskData: {
+              ...payload,
+              wrapUpRequired
             }
-          case _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE_FAILED:
-            // Conference exit failed - update task state and emit failure event
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_PARTICIPANT_LEFT_FAILED, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCE_END_FAILED:
-            // Conference end failed - update task state with error details and emit failure event
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_CONFERENCE_END_FAILED, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONFERENCE_TRANSFERRED:
-            // Conference was transferred - update task state and emit transfer success event
-            // Note: Backend should provide hasLeft and wrapUpRequired status
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_CONFERENCE_TRANSFERRED, task);
-            break;
-          case _types2.CC_EVENTS.AGENT_CONFERENCE_TRANSFER_FAILED:
-            // Conference transfer failed - update task state with error details and emit failure event
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED, task);
-            break;
-          case _types2.CC_EVENTS.PARTICIPANT_POST_CALL_ACTIVITY:
-            // Post-call activity for participant - update task state with activity details
-            task = this.updateTaskData(task, payload.data);
-            task.emit(_types.TASK_EVENTS.TASK_POST_CALL_ACTIVITY, task);
-            break;
-          default:
-            break;
+          };
         }
-        if (task) {
-          task.emit(payload.data.type, payload.data);
+      case _types2.CC_EVENTS.AGENT_INVITE_FAILED:
+        return {
+          type: _stateMachine.TaskEvent.INVITE_FAILED,
+          reason: payload.reason
+        };
+      case _types2.CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED:
+        return {
+          type: _stateMachine.TaskEvent.ASSIGN_FAILED,
+          reason: payload.reason
+        };
+      case _types2.CC_EVENTS.AGENT_CONTACT_OFFER_RONA:
+        return {
+          type: _stateMachine.TaskEvent.RONA,
+          taskData: payload,
+          reason: payload.reason
+        };
+      case _types2.CC_EVENTS.AGENT_OUTBOUND_FAILED:
+        {
+          const isAgentTerminatedOutdial = payload.interaction?.outboundType === 'OUTDIAL' && (payload.terminatingParty === 'Agent' || payload.reason === 'AGENT_ENDS');
+          const suppressOutdialFailedPopup = isAgentTerminatedOutdial && !TaskManager.isWxAppManagedOutdialTask(agentId, payload, task, enableWxBetterTogether);
+          return {
+            type: _stateMachine.TaskEvent.OUTBOUND_FAILED,
+            taskData: suppressOutdialFailedPopup ? {
+              ...payload,
+              suppressOutdialFailedPopup: true
+            } : payload,
+            reason: payload.reason
+          };
         }
+      case _types2.CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED:
+        return {
+          type: _stateMachine.TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED:
+        return {
+          type: _stateMachine.TaskEvent.CAMPAIGN_PREVIEW_SKIP_FAILED,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.CAMPAIGN_PREVIEW_REMOVE_FAILED:
+        return {
+          type: _stateMachine.TaskEvent.CAMPAIGN_PREVIEW_REMOVE_FAILED,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.CONTACT_RECORDING_STARTED:
+        return {
+          type: _stateMachine.TaskEvent.RECORDING_STARTED,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.CONTACT_RECORDING_PAUSED:
+        return {
+          type: _stateMachine.TaskEvent.PAUSE_RECORDING,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.CONTACT_RECORDING_RESUMED:
+        return {
+          type: _stateMachine.TaskEvent.RESUME_RECORDING,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_WRAPPEDUP:
+        return {
+          type: _stateMachine.TaskEvent.WRAPUP_COMPLETE,
+          taskData: payload
+        };
+
+      // Conference events - these trigger state machine transition to CONFERENCING
+      case _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCED:
+      case _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCING:
+      case _types2.CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE:
+        return {
+          type: _stateMachine.TaskEvent.CONFERENCE_START,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCE_FAILED:
+        return {
+          type: _stateMachine.TaskEvent.CONFERENCE_FAILED,
+          reason: payload.reason,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED:
+        return {
+          type: _stateMachine.TaskEvent.CONFERENCE_END,
+          taskData: payload
+        };
+      case _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE:
+        return {
+          type: _stateMachine.TaskEvent.PARTICIPANT_LEAVE,
+          taskData: payload,
+          participantId: payload?.participantId
+        };
+      case _types2.CC_EVENTS.AGENT_CONFERENCE_TRANSFERRED:
+        return {
+          type: _stateMachine.TaskEvent.TRANSFER_CONFERENCE_SUCCESS,
+          taskData: payload
+        };
+      default:
+        // Not all events need state machine mapping
+        return null;
+    }
+  }
+
+  /**
+   * True when the current agent's task is a wxApp-managed outdial (thick-client telephony).
+   */
+  static isWxAppManagedOutdialTask(agentId, payload, task, enableWxBetterTogether) {
+    const wxAppEnabled = task?.uiControlConfig?.enableWxBetterTogether ?? enableWxBetterTogether ?? false;
+    if (!wxAppEnabled) {
+      return false;
+    }
+    const effectiveAgentId = agentId ?? task?.data?.agentId;
+    const participants = payload.interaction?.participants ?? task?.data?.interaction?.participants;
+    const details = (0, _WebexCallingUtils.getWebexCallingDeviceDetailsForAgent)(effectiveAgentId, participants);
+    return details?.deviceType === 'wxApp';
+  }
+
+  /**
+   * True when ContactEnded represents an agent-terminated wxApp outdial that should
+   * enter wrapup with an outdial-failed popup (legacy AgentOutboundFailed parity).
+   */
+  static isAgentTerminatedOutdialWrapup(payload, wrapUpRequired, task, agentId, enableWxBetterTogether) {
+    const isOutdial = payload.interaction?.outboundType === 'OUTDIAL';
+    const agentTerminated = payload.terminatingParty === 'Agent';
+    if (!isOutdial || !agentTerminated) {
+      return false;
+    }
+    if (!TaskManager.isWxAppManagedOutdialTask(agentId, payload, task, enableWxBetterTogether)) {
+      return false;
+    }
+    const wxAppAnswerPending = task?.uiControlConfig?.wxAppAnswerPending ?? false;
+
+    // Pre-accept decline: decline() clears wxAppAnswerPending; backend may still send state wrapUp.
+    if (!wxAppAnswerPending && !wrapUpRequired) {
+      return false;
+    }
+    const interactionWrapUp = payload.interaction?.state === 'wrapUp';
+    return wrapUpRequired || interactionWrapUp || wxAppAnswerPending;
+  }
+
+  /**
+   * Register WebSocket message listeners for task events
+   *
+   * Main entry point that orchestrates event processing through a clear pipeline:
+   * 1. Parse and validate incoming WebSocket messages
+   * 2. Prepare event context with task and state machine mappings
+   * 3. Handle task lifecycle (creation, updates, collection management)
+   * 4. Send events to state machine (task-level transitions/emissions)
+   * 5. Cleanup is triggered via task events emitted by the state machine
+   *
+   * This architecture separates concerns:
+   * - TaskManager: Manages task collection lifecycle and operational concerns
+   * - State Machine: Manages individual task state and event emissions
+   */
+  registerTaskListeners() {
+    this.webSocketManager.on('message', event => {
+      // Step 1: Parse and validate the message
+      const message = TaskManager.parseWebSocketMessage(event);
+      if (!message) return;
+
+      // Step 2: Prepare event context
+      const eventContext = this.prepareEventContext(message);
+      if (!eventContext) return;
+      const actions = this.handleTaskLifecycleEvent(eventContext);
+      const {
+        task
+      } = actions;
+      if (!task) return;
+      const {
+        payload,
+        stateMachineEvent
+      } = eventContext;
+
+      // Always keep task.data updated (even for mapped events) so consumers relying
+      // on TaskManager-managed task instances see the latest payload.
+      if (payload) {
+        this.updateTaskData(task, payload);
       }
+
+      // Send event to state machine - this will trigger all TASK_EVENTS emissions
+      // including TASK_INCOMING which is now handled via the state machine callbacks
+      if (stateMachineEvent) {
+        task.sendStateMachineEvent(stateMachineEvent);
+      }
+
+      // Emit TASK_POST_CALL_ACTIVITY for ParticipantPostCallActivity events so
+      // consumers (Widgets) can detect the interaction state change to post_call.
+      if (eventContext.eventType === _types2.CC_EVENTS.PARTICIPANT_POST_CALL_ACTIVITY) {
+        task.emit(_types.TASK_EVENTS.TASK_POST_CALL_ACTIVITY, task);
+      }
+
+      // Send transcript start/stop events for relevant CC events
+      this.requestRealTimeTranscripts(eventContext.eventType, payload.interactionId);
     });
   }
-  updateTaskData(task, taskData) {
-    if (!task) {
-      return undefined;
+
+  /**
+   * Parse and validate WebSocket message
+   * @returns Parsed message or null if invalid/keepalive
+   */
+  static parseWebSocketMessage(event) {
+    try {
+      const payload = JSON.parse(event);
+
+      // Filter out keepalive messages
+      if (payload?.keepalive === 'true' || payload?.keepalive === true) {
+        return null;
+      }
+
+      // Normalize task data if present
+      if (payload?.data?.interaction) {
+        payload.data = (0, _taskDataNormalizer.normalizeTaskData)(payload.data);
+      }
+      return payload;
+    } catch (error) {
+      _loggerProxy.default.error('Failed to parse WebSocket message', {
+        module: _constants.TASK_MANAGER_FILE,
+        method: 'parseWebSocketMessage',
+        error
+      });
+      return null;
+    }
+  }
+
+  /**
+   * Prepare context for event processing
+   * @returns Event context or null if event type is invalid
+   */
+  prepareEventContext(message) {
+    const eventType = message.data?.type || message.type;
+    if (!eventType || !isCcEvent(eventType)) {
+      return null;
     }
-    if (!taskData?.interactionId) {
-      _loggerProxy.default.warn('Received task update with missing interactionId', {
+    const interactionId = message.data.interactionId;
+    const reservationInteractionId = message.data.reservationInteractionId;
+    let task = this.taskCollection[interactionId];
+
+    // When a campaign preview contact is accepted, the assigned event may arrive
+    // with a new interactionId while the task is stored under the original
+    // reservationInteractionId. Fall back to that key so the task is found.
+    if (!task && reservationInteractionId) {
+      task = this.taskCollection[reservationInteractionId];
+      if (task) {
+        // Re-key the task under the new interaction ID and remove the old entry
+        delete this.taskCollection[reservationInteractionId];
+        this.taskCollection[interactionId] = task;
+      }
+    }
+    if (!task && eventType === _types2.CC_EVENTS.CONTACT_OWNER_CHANGED) {
+      task = this.findTaskForContactOwnerChange(message.data);
+    }
+    if (!task && MAIN_INTERACTION_CORRELATED_EVENTS.has(eventType)) {
+      task = this.findUniqueTaskByRelatedInteraction(message.data);
+    }
+    const wasConsultedTask = Boolean(task?.data?.isConsulted);
+    const computeWrapUpRequired = () => {
+      if (message.data.wrapUpRequired !== undefined) {
+        return message.data.wrapUpRequired;
+      }
+      if (message.data.isConsulted !== undefined) {
+        return !message.data.isConsulted;
+      }
+      return !wasConsultedTask;
+    };
+    let adjustedPayload = eventType === _types2.CC_EVENTS.AGENT_CONSULT_TRANSFERRED || eventType === _types2.CC_EVENTS.AGENT_BLIND_TRANSFERRED || eventType === _types2.CC_EVENTS.AGENT_VTEAM_TRANSFERRED ? {
+      ...message.data,
+      wrapUpRequired: computeWrapUpRequired()
+    } : message.data;
+    if (task && eventType === _types2.CC_EVENTS.CONTACT_OWNER_CHANGED) {
+      adjustedPayload = TaskManager.preserveMainTaskIdentity(task, adjustedPayload);
+    }
+    if (task && eventType === _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE) {
+      adjustedPayload = TaskManager.preserveConfirmedOwner(task, adjustedPayload);
+    }
+    const stateMachineEvent = TaskManager.mapEventToTaskStateMachineEvent(eventType, adjustedPayload, this.agentId, task, this.configFlags?.enableWxBetterTogether);
+    _loggerProxy.default.info(`Handling task event ${eventType}`, {
+      module: _constants.TASK_MANAGER_FILE,
+      method: 'prepareEventContext',
+      interactionId
+    });
+    return {
+      eventType,
+      payload: adjustedPayload,
+      task,
+      stateMachineEvent
+    };
+  }
+
+  /**
+   * ContactOwnerChanged can identify the promoted agent's child interaction while
+   * the surviving task is stored under the main interaction. Accept one related
+   * task when its existing snapshot or the authoritative incoming promotion proves
+   * current-agent main-call membership, while excluding non-promoted and ambiguous matches.
+   */
+  findTaskForContactOwnerChange(payload) {
+    const relatedCandidates = this.findRelatedTasks(payload, {
+      includeCollectionKeys: true,
+      includeMainCallMediaKeys: true
+    });
+    const incomingShowsCurrentAgentPromotion = this.isCurrentAgentPromotedOnIncomingMainCall(payload);
+    const eligibleCandidates = relatedCandidates.filter(candidate => this.isCurrentAgentActiveOnMainInteraction(candidate.data) || incomingShowsCurrentAgentPromotion);
+    if (eligibleCandidates.length === 1) {
+      return eligibleCandidates[0];
+    }
+    if (eligibleCandidates.length > 1) {
+      _loggerProxy.default.warn('Unable to correlate task event to a unique main interaction task', {
         module: _constants.TASK_MANAGER_FILE,
-        method: _constants2.METHODS.UPDATE_TASK_DATA
+        method: 'findTaskForContactOwnerChange',
+        interactionId: payload.interaction?.mainInteractionId || payload.interaction?.parentInteractionId || payload.interaction?.callProcessingDetails?.parentInteractionId || payload.interactionId
       });
+      return undefined;
     }
-    try {
-      const currentTask = task.updateTaskData(taskData);
-      this.taskCollection[taskData.interactionId] = currentTask;
-      return currentTask;
-    } catch (error) {
-      _loggerProxy.default.error(`Failed to update task`, {
+    return undefined;
+  }
+  isCurrentAgentActiveOnMainInteraction(taskData) {
+    const currentAgentId = this.agentId || taskData?.agentId;
+    if (!currentAgentId) return false;
+    return TaskManager.isParticipantActiveOnMainInteraction(taskData, currentAgentId);
+  }
+  static isParticipantActiveOnMainInteraction(taskData, participantId) {
+    const interaction = taskData?.interaction;
+    const participant = interaction?.participants?.[participantId];
+    if (!participant || participant.hasLeft === true) return false;
+    return Object.values(interaction?.media ?? {}).some(media => media?.mType === _constants3.MEDIA_TYPE_MAIN_CALL && media.participants?.includes(participantId));
+  }
+  isCurrentAgentPromotedOnIncomingMainCall(payload) {
+    return Boolean(this.agentId && payload.interaction?.owner === this.agentId && TaskManager.isParticipantActiveOnMainInteraction(payload, this.agentId));
+  }
+  static getMainCallMediaId(interaction) {
+    return Object.entries(interaction?.media ?? {}).find(([, media]) => media?.mType === _constants3.MEDIA_TYPE_MAIN_CALL)?.[0];
+  }
+  static getStableMainInteractionId(payload) {
+    return payload.interaction?.mainInteractionId || TaskManager.getMainCallMediaId(payload.interaction) || payload.interaction?.interactionId || payload.interactionId;
+  }
+  canRecoverTaskFromContactOwnerChanged(payload) {
+    const interaction = payload.interaction;
+    const stableInteractionId = TaskManager.getStableMainInteractionId(payload);
+    return Boolean(this.agentId && stableInteractionId && interaction?.mediaType === _types.MEDIA_CHANNEL.TELEPHONY && interaction.isTerminated !== true && interaction.owner === this.agentId && TaskManager.isParticipantActiveOnMainInteraction(payload, this.agentId));
+  }
+
+  /** Keep a related owner-change event from re-keying the surviving main task to a child ID. */
+  static preserveMainTaskIdentity(task, payload) {
+    const currentMainInteractionId = task.data?.interaction?.mainInteractionId;
+    const payloadMainInteractionId = payload.interaction?.mainInteractionId;
+    const currentMainMediaId = TaskManager.getMainCallMediaId(task.data?.interaction);
+    const payloadMainMediaId = TaskManager.getMainCallMediaId(payload.interaction);
+    const stableInteractionId = currentMainInteractionId || payloadMainInteractionId || currentMainMediaId || payloadMainMediaId || payload.interaction?.interactionId || task.data?.interaction?.interactionId || task.data?.interactionId;
+    if (!stableInteractionId || stableInteractionId === payload.interactionId) {
+      return payload;
+    }
+    return {
+      ...payload,
+      interactionId: stableInteractionId
+    };
+  }
+
+  /**
+   * ParticipantLeftConference may arrive after an owner update while still carrying
+   * the departed owner. Keep the confirmed owner only when the new roster proves that
+   * owner is active on mainCall and identifies the incoming owner as departed.
+   */
+  static preserveConfirmedOwner(task, payload) {
+    const confirmedOwner = task.data?.interaction?.owner;
+    const incomingOwner = payload.interaction?.owner;
+    if (!confirmedOwner || !incomingOwner || confirmedOwner === incomingOwner) {
+      return payload;
+    }
+    const confirmedOwnerIsActive = TaskManager.isParticipantActiveOnMainInteraction(payload, confirmedOwner);
+    const incomingOwnerIsExplicitlyDeparted = payload.participantId === incomingOwner || payload.interaction?.participants?.[incomingOwner]?.hasLeft === true;
+    if (!confirmedOwnerIsActive || !incomingOwnerIsExplicitlyDeparted) {
+      return payload;
+    }
+    return {
+      ...payload,
+      owner: confirmedOwner,
+      interaction: {
+        ...payload.interaction,
+        owner: confirmedOwner
+      }
+    };
+  }
+
+  /**
+   * Resolve lifecycle events that are emitted for the main interaction while the
+   * local task can still be indexed by a child consult interaction. Exact task
+   * keys are handled before this fallback. Multiple aliases of the same task are
+   * treated as one candidate; genuinely ambiguous matches are intentionally ignored.
+   */
+  findUniqueTaskByRelatedInteraction(payload, candidateFilter = () => true) {
+    const candidates = this.findRelatedTasks(payload).filter(candidateFilter);
+    if (candidates.length === 1) {
+      return candidates[0];
+    }
+    if (candidates.length > 1) {
+      _loggerProxy.default.warn('Unable to correlate task event to a unique main interaction task', {
         module: _constants.TASK_MANAGER_FILE,
-        method: _constants2.METHODS.UPDATE_TASK_DATA,
-        interactionId: taskData.interactionId
+        method: 'findUniqueTaskByRelatedInteraction',
+        interactionId: payload.interaction?.mainInteractionId || payload.interaction?.parentInteractionId || payload.interaction?.callProcessingDetails?.parentInteractionId || payload.interactionId
       });
-      return task;
     }
+    return undefined;
+  }
+  findRelatedTasks(payload, options = {}) {
+    const {
+      includeCollectionKeys = false,
+      includeMainCallMediaKeys = false
+    } = options;
+    const payloadInteractionIds = new Set([payload.interactionId, payload.interaction?.interactionId, payload.interaction?.mainInteractionId, payload.interaction?.parentInteractionId, payload.interaction?.callProcessingDetails?.parentInteractionId, ...(includeMainCallMediaKeys ? [TaskManager.getMainCallMediaId(payload.interaction)] : [])].filter(interactionId => Boolean(interactionId)));
+    if (payloadInteractionIds.size === 0) return [];
+    return [...new Set(Object.entries(this.taskCollection).filter(([taskId, candidate]) => {
+      const taskInteraction = candidate?.data?.interaction;
+      const candidateInteractionIds = [...(includeCollectionKeys ? [taskId] : []), candidate?.data?.interactionId, taskInteraction?.interactionId, taskInteraction?.mainInteractionId, taskInteraction?.parentInteractionId, taskInteraction?.callProcessingDetails?.parentInteractionId, ...(includeMainCallMediaKeys ? [TaskManager.getMainCallMediaId(taskInteraction)] : [])];
+      return candidateInteractionIds.some(interactionId => Boolean(interactionId) && payloadInteractionIds.has(interactionId));
+    }).map(([, candidate]) => candidate))];
   }
 
   /**
-   * Handles CONTACT_MERGED event logic
-   * @param task - The task to process
-   * @param taskData - The task data from the event payload
-   * @returns Updated or newly created task
-   * @private
+   * Handle task lifecycle events and determine required actions
+   *
+   * Delegates to specific event handlers based on event type. Each handler
+   * is responsible for TaskManager-level concerns:
+   * - Task creation and collection management
+   * - Metrics tracking
+   * - Resource cleanup decisions
+   *
+   * Note: Task-level state transitions and event emissions are handled by
+   * the task state machine via sendStateMachineEvent()
    */
-  handleContactMerged(task, taskData) {
-    if (taskData.childInteractionId) {
-      // remove the child task from collection
-      this.removeTaskFromCollection(this.taskCollection[taskData.childInteractionId]);
+  handleTaskLifecycleEvent(context) {
+    const {
+      eventType
+    } = context;
+    switch (eventType) {
+      case _types2.CC_EVENTS.AGENT_CONTACT_RESERVED:
+        return this.handleContactReserved(context);
+      case _types2.CC_EVENTS.AGENT_CONTACT:
+        return this.handleAgentContact(context);
+      case _types2.CC_EVENTS.CONTACT_MERGED:
+        return this.handleContactMergedEvent(context);
+      case _types2.CC_EVENTS.CONTACT_OWNER_CHANGED:
+        return this.handleContactOwnerChanged(context);
+      case _types2.CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION:
+        return this.handleCampaignPreviewReservation(context);
+      case _types2.CC_EVENTS.CAMPAIGN_CONTACT_UPDATED:
+        return this.handleCampaignContactUpdated(context);
+      default:
+        return {
+          task: context.task
+        };
     }
-    if (this.taskCollection[taskData.interactionId]) {
-      _loggerProxy.default.log(`Got CONTACT_MERGED: Task already exists in collection`, {
+  }
+
+  /**
+   * Recover the promoted agent's active voice task when local task state was lost.
+   * Existing related tasks are never replaced: an unresolved or ambiguous relation
+   * is safer to ignore than to create a duplicate task.
+   */
+  handleContactOwnerChanged(context) {
+    if (context.task) {
+      return {
+        task: context.task
+      };
+    }
+    const {
+      payload
+    } = context;
+    if (this.findRelatedTasks(payload, {
+      includeCollectionKeys: true,
+      includeMainCallMediaKeys: true
+    }).length > 0 || !this.canRecoverTaskFromContactOwnerChanged(payload)) {
+      return {};
+    }
+    const stableInteractionId = TaskManager.getStableMainInteractionId(payload);
+    if (!stableInteractionId || this.taskCollection[stableInteractionId]) {
+      return {};
+    }
+    const normalizedPayload = payload.interactionId === stableInteractionId ? payload : {
+      ...payload,
+      interactionId: stableInteractionId
+    };
+    const taskData = {
+      ...normalizedPayload,
+      owner: normalizedPayload.interaction.owner,
+      wrapUpRequired: normalizedPayload.interaction.participants?.[this.agentId]?.isWrapUp || false,
+      isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(normalizedPayload),
+      isConsulted: false,
+      isAutoAnswering: false
+    };
+    const task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
+    this.taskCollection[stableInteractionId] = task;
+
+    // Restore the actor before installing listeners so the internal hydrate does
+    // not leak as a second public hydrate or as an incoming-task notification.
+    task.sendStateMachineEvent({
+      type: _stateMachine.TaskEvent.HYDRATE,
+      taskData,
+      agentId: this.agentId
+    });
+    this.setupTaskListeners(task);
+    context.payload = taskData;
+    context.stateMachineEvent = {
+      type: _stateMachine.TaskEvent.CONTACT_OWNER_CHANGED,
+      taskData
+    };
+    return {
+      task
+    };
+  }
+  handleCampaignContactUpdated(context) {
+    const {
+      payload
+    } = context;
+    let {
+      task
+    } = context;
+    // CampaignContactUpdated is a non-terminal event (e.g., next contact after skip/remove).
+    // Update the task data and emit an event so consumers can react to the updated contact.
+    // Do NOT remove the task or emit TASK_END — cleanup is handled by CONTACT_ENDED.
+    if (task) {
+      // Carry forward campaign preview fields from existing task data since the updated
+      // contact payload may not include them, and reconcileData would delete them.
+      const existingCpd = task.data?.interaction?.callProcessingDetails;
+      const updatedData = {
+        ...payload
+      };
+      if (existingCpd) {
+        const campaignFields = {
+          ...(existingCpd.campaignPreviewAutoAction && {
+            campaignPreviewAutoAction: existingCpd.campaignPreviewAutoAction
+          }),
+          ...(existingCpd.campaignPreviewOfferTimeout && {
+            campaignPreviewOfferTimeout: existingCpd.campaignPreviewOfferTimeout
+          }),
+          ...(existingCpd.campaignPreviewSkipDisabled && {
+            campaignPreviewSkipDisabled: existingCpd.campaignPreviewSkipDisabled
+          }),
+          ...(existingCpd.campaignPreviewRemoveDisabled && {
+            campaignPreviewRemoveDisabled: existingCpd.campaignPreviewRemoveDisabled
+          })
+        };
+        if (!updatedData.interaction) {
+          updatedData.interaction = {};
+        }
+        updatedData.interaction = {
+          ...updatedData.interaction,
+          callProcessingDetails: {
+            ...campaignFields,
+            ...(updatedData.interaction.callProcessingDetails || {})
+          }
+        };
+      }
+      _loggerProxy.default.log('Campaign contact updated - carrying forward preview fields', {
         module: _constants.TASK_MANAGER_FILE,
         method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
-        interactionId: taskData.interactionId
+        interactionId: payload.interactionId,
+        data: {
+          hasCpd: !!updatedData.interaction?.callProcessingDetails,
+          autoAction: updatedData.interaction?.callProcessingDetails?.campaignPreviewAutoAction,
+          skipDisabled: updatedData.interaction?.callProcessingDetails?.campaignPreviewSkipDisabled,
+          removeDisabled: updatedData.interaction?.callProcessingDetails?.campaignPreviewRemoveDisabled
+        }
       });
-      // update the task data
-      task = this.updateTaskData(task, taskData);
+      task = this.updateTaskData(task, updatedData);
+      task.emit(_types.TASK_EVENTS.TASK_CAMPAIGN_CONTACT_UPDATED, task);
+    }
+    return {
+      task
+    };
+  }
+
+  /**
+   * Creates or updates a task for campaign preview reservation.
+   * TASK_CAMPAIGN_PREVIEW_RESERVATION is emitted by the state machine (campaign TASK_INCOMING branch).
+   */
+  handleCampaignPreviewReservation(context) {
+    const {
+      payload
+    } = context;
+    let {
+      task
+    } = context;
+    _loggerProxy.default.log('Campaign preview reservation received', {
+      module: _constants.TASK_MANAGER_FILE,
+      method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
+      interactionId: payload.interactionId
+    });
+    if (!task) {
+      task = _TaskFactory.default.createTask(this.contact, this.webCallingService, {
+        ...payload,
+        wrapUpRequired: false,
+        isConferenceInProgress: false,
+        isAutoAnswering: false
+      }, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
+      this.setupTaskListeners(task);
+      this.taskCollection[payload.interactionId] = task;
     } else {
-      // Case2 : Task is not present in taskCollection
-      _loggerProxy.default.log(`Got CONTACT_MERGED : Creating new task in taskManager`, {
+      task = this.updateTaskData(task, payload);
+    }
+    return {
+      task
+    };
+  }
+
+  /**
+   * Handle AGENT_CONTACT_RESERVED event
+   * Creates a new task; state machine event is sent during processing
+   */
+  handleContactReserved(context) {
+    const {
+      payload
+    } = context;
+    const isConsultedTask = payload.isConsulted === true || (0, _TaskUtils.isSecondaryEpDnAgent)(payload.interaction);
+    const shouldAutoAnswer = (0, _TaskUtils.shouldAutoAnswerTask)(payload, this.agentId, this.webCallingService.loginOption, this.webRtcEnabled);
+    const taskData = {
+      ...payload,
+      isConsulted: isConsultedTask,
+      isAutoAnswering: shouldAutoAnswer
+    };
+    const task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
+    this.setupTaskListeners(task);
+    this.taskCollection[payload.interactionId] = task;
+    return {
+      task
+    };
+  }
+
+  /**
+   * Handle AGENT_CONTACT event
+   * Re-creates task if missing (multi-session scenario)
+   */
+  handleAgentContact(context) {
+    let {
+      task
+    } = context;
+    const {
+      payload
+    } = context;
+    if (!task) {
+      const isConsultedTask = payload.isConsulted === true || (0, _TaskUtils.isSecondaryEpDnAgent)(payload.interaction);
+      const shouldAutoAnswer = (0, _TaskUtils.shouldAutoAnswerTask)(payload, this.agentId, this.webCallingService.loginOption, this.webRtcEnabled);
+      const taskData = {
+        ...payload,
+        isConsulted: isConsultedTask,
+        wrapUpRequired: payload.interaction?.participants?.[this.agentId]?.isWrapUp || false,
+        isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(payload),
+        isAutoAnswering: shouldAutoAnswer
+      };
+      task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
+      this.setupTaskListeners(task);
+      this.taskCollection[payload.interactionId] = task;
+    }
+    return {
+      task
+    };
+  }
+  updateTaskData(task, taskData) {
+    if (!task) {
+      throw new Error('Task not found for update');
+    }
+    const snapshot = task.stateMachineService?.getSnapshot?.();
+    const isConsultingFlow = snapshot?.value === 'CONSULTING' || taskData.interaction?.state === 'consulting';
+    const updateTaskData = isConsultingFlow ? {
+      ...taskData,
+      destAgentId: taskData.destAgentId ?? snapshot?.context?.consultDestinationAgentId ?? null,
+      destinationType: taskData.destinationType ?? snapshot?.context?.consultDestinationType ?? null
+    } : taskData;
+    task.updateTaskData(updateTaskData);
+
+    // A main-interaction lifecycle event can re-key a child consult task. Remove
+    // any aliases first so consumers never observe duplicate task entries.
+    Object.entries(this.taskCollection).forEach(([taskId, candidate]) => {
+      if (candidate === task && taskId !== taskData.interactionId) {
+        delete this.taskCollection[taskId];
+      }
+    });
+    this.taskCollection[taskData.interactionId] = task;
+    return task;
+  }
+
+  /**
+   * Setup listeners for task events that need to be bubbled up to TaskManager
+   * This replaces the previous callback injection pattern
+   */
+  setupTaskListeners(task) {
+    // Listen for TASK_INCOMING and re-emit so webex.cc can notify consumers
+    task.on(_types.TASK_EVENTS.TASK_INCOMING, t => {
+      _loggerProxy.default.log(`Task incoming event received`, {
         module: _constants.TASK_MANAGER_FILE,
         method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
-        interactionId: taskData.interactionId
+        interactionId: t.data?.interactionId
       });
-      task = new _.default(this.contact, this.webCallingService, {
-        ...taskData,
-        wrapUpRequired: taskData.interaction?.participants?.[this.agentId]?.isWrapUp || false,
-        isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(taskData)
-      }, this.wrapupData, this.agentId);
-      this.taskCollection[taskData.interactionId] = task;
-    }
-    this.emit(_types.TASK_EVENTS.TASK_MERGED, task);
-    return task;
+      this.emit(_types.TASK_EVENTS.TASK_INCOMING, t);
+    });
+    task.on(_types.TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, t => {
+      _loggerProxy.default.log(`Campaign preview reservation event received`, {
+        module: _constants.TASK_MANAGER_FILE,
+        method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
+        interactionId: t.data?.interactionId
+      });
+      this.emit(_types.TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, t);
+    });
+
+    // Listen for TASK_HYDRATE on the task and re-emit on TaskManager
+    task.on(_types.TASK_EVENTS.TASK_HYDRATE, t => {
+      // Task data is already updated by the task itself before emitting
+      this.emit(_types.TASK_EVENTS.TASK_HYDRATE, t);
+    });
+    task.on(_types.TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, t => {
+      this.emit(_types.TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, t);
+    });
+
+    // Listen for internal cleanup signal emitted by the state machine
+    task.on(_types.TASK_EVENTS.TASK_CLEANUP, (t, options) => {
+      this.handleTaskCleanup(t);
+      if (options?.removeFromCollection) {
+        const taskIsStillCollected = Object.values(this.taskCollection).some(candidate => candidate === t);
+        if (taskIsStillCollected) {
+          this.removeTaskFromCollection(t);
+        }
+      }
+    });
   }
   removeTaskFromCollection(task) {
+    if (typeof task.cancelAutoWrapupTimer === 'function') {
+      task.cancelAutoWrapupTimer();
+    }
     if (task?.data?.interactionId) {
-      delete this.taskCollection[task.data.interactionId];
+      Object.entries(this.taskCollection).forEach(([taskId, candidate]) => {
+        if (candidate === task) {
+          delete this.taskCollection[taskId];
+        }
+      });
       _loggerProxy.default.info(`Task removed from collection`, {
         module: _constants.TASK_MANAGER_FILE,
         method: _constants2.METHODS.REMOVE_TASK_FROM_COLLECTION,
@@ -489,62 +1061,62 @@ class TaskManager extends _events.default {
   }
 
   /**
-   * Handles auto-answer logic for incoming tasks
-   * Automatically accepts tasks when isAutoAnswering flag is set
-   * The flag is set during task creation based on:
-   * 1. WebRTC calls with auto-answer enabled in agent profile
-   * 2. Agent-initiated WebRTC outdial calls
-   * 3. Agent-initiated digital outbound (Email/SMS) without previous transfers
-   *
-   * @param task - The task to auto-answer
+   * Handles CONTACT_MERGED event logic
+   * @param task - The task to process
+   * @param taskData - The task data from the event payload
+   * @returns Updated or newly created task
    * @private
    */
-  async handleAutoAnswer(task) {
-    if (!task || !task.data || !task.data.isAutoAnswering) {
-      return;
+  handleContactMergedEvent(context) {
+    const {
+      payload
+    } = context;
+    let task = context.task;
+    if (payload.childInteractionId && this.taskCollection[payload.childInteractionId]) {
+      this.removeTaskFromCollection(this.taskCollection[payload.childInteractionId]);
     }
-    _loggerProxy.default.info(`Auto-answering task`, {
-      module: _constants.TASK_MANAGER_FILE,
-      method: 'handleAutoAnswer',
-      interactionId: task.data.interactionId
-    });
-    try {
-      await task.accept();
-      _loggerProxy.default.info(`Task auto-answered successfully`, {
+    if (task) {
+      _loggerProxy.default.log(`Got CONTACT_MERGED: Task already exists in collection`, {
         module: _constants.TASK_MANAGER_FILE,
-        method: 'handleAutoAnswer',
-        interactionId: task.data.interactionId
-      });
-
-      // Track successful auto-answer
-      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_SUCCESS, {
-        taskId: task.data.interactionId,
-        mediaType: task.data.interaction.mediaType,
-        isAutoAnswered: true
-      }, ['behavioral', 'operational']);
-      // Emit task:autoAnswered event for widgets/UI to react
-      task.emit(_types.TASK_EVENTS.TASK_AUTO_ANSWERED, task);
-    } catch (error) {
-      // Reset isAutoAnswering flag on failure
-      task.updateTaskData({
-        ...task.data,
-        isAutoAnswering: false
+        method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
+        interactionId: payload.interactionId
       });
-      _loggerProxy.default.error(`Failed to auto-answer task`, {
+      // update the task data
+      this.updateTaskData(task, payload);
+    } else {
+      // Case2 : Task is not present in taskCollection
+      _loggerProxy.default.log(`Got CONTACT_MERGED : Creating new task in taskManager`, {
         module: _constants.TASK_MANAGER_FILE,
-        method: 'handleAutoAnswer',
-        interactionId: task.data.interactionId,
-        error
+        method: _constants2.METHODS.REGISTER_TASK_LISTENERS,
+        interactionId: payload.interactionId
       });
+      const taskData = {
+        ...payload,
+        wrapUpRequired: payload.interaction?.participants?.[this.agentId]?.isWrapUp || false,
+        isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(payload),
+        isConsulted: false
+      };
+      task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
+      this.taskCollection[payload.interactionId] = task;
 
-      // Track auto-answer failure
-      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_FAILED, {
-        taskId: task.data.interactionId,
-        mediaType: task.data.interaction.mediaType,
-        error: error?.message || 'Unknown error',
-        isAutoAnswered: false
-      }, ['behavioral', 'operational']);
+      // Transition the new task out of IDLE immediately so UI controls are
+      // computed before TASK_MERGED is emitted. This handles the race where
+      // AgentContactAssigned arrives before ContactMerged and gets dropped.
+      // Send HYDRATE before setupTaskListeners so the emitTaskHydrate action
+      // doesn't bubble up to the Widget (avoids duplicate listener registration).
+      task.sendStateMachineEvent({
+        type: _stateMachine.TaskEvent.HYDRATE,
+        taskData,
+        agentId: this.agentId
+      });
+      this.setupTaskListeners(task);
+    }
+    if (task) {
+      this.emit(_types.TASK_EVENTS.TASK_MERGED, task);
     }
+    return {
+      task
+    };
   }
 
   /**
@@ -554,48 +1126,102 @@ class TaskManager extends _events.default {
    */
   handleTaskCleanup(task) {
     // Clean up Desktop/WebRTC calling resources for browser-based telephony tasks
-    if (this.webCallingService.loginOption === _types3.LoginOption.BROWSER && task.data.interaction.mediaType === 'telephony') {
+    if (this.webCallingService.loginOption === _types3.LoginOption.BROWSER && task.data.interaction.mediaType === _types.MEDIA_CHANNEL.TELEPHONY && task instanceof _WebRTC.default) {
       task.unregisterWebCallListeners();
       this.webCallingService.cleanUpCall();
     }
     const isOutdial = task.data.interaction.outboundType === 'OUTDIAL';
     const isNew = task.data.interaction.state === 'new';
-    const needsWrapUp = task.data.agentsPendingWrapUp?.length > 0;
+    const needsWrapUp = task.data.agentsPendingWrapUp?.includes(this.agentId) ?? false;
 
     // For OUTDIAL: only remove if NOT terminated (user-declined, no wrap-up follows)
-    // If terminated, keep task for wrap-up flow (CONTACT_ENDED → AGENT_WRAPUP)
     // For non-OUTDIAL: remove if state is 'new'
     // Always remove if secondary EpDn agent
-    if (isNew && !(isOutdial && needsWrapUp) || (0, _TaskUtils.isSecondaryEpDnAgent)(task.data.interaction)) {
+    if (isNew && !(isOutdial && needsWrapUp) || (0, _TaskUtils.isSecondaryEpDnAgent)(task.data.interaction) || !needsWrapUp && isOutdial // For outdial tasks, needs wrap-up is false and state is "WRAPUP". We need to just remove the task.
+    ) {
       this.removeTaskFromCollection(task);
     }
   }
 
   /**
-   * @param taskId - Unique identifier for each task
+   * Sends transcript start/stop event based on the CC event type.
+   * Fire-and-forget; errors are logged but do not interrupt event processing.
    */
-  getTask = taskId => {
+  requestRealTimeTranscripts(eventType, interactionId) {
+    const action = _constants2.TRANSCRIPT_EVENT_MAP[eventType];
+    if (!action || !this.apiAIAssistant) return;
+    if (this.configFlags?.aiFeature?.realtimeTranscripts?.enable !== true) return;
+    this.apiAIAssistant.sendEvent(this.agentId, interactionId, _types3.AIAssistantEventType.CUSTOM_EVENT, _types3.AIAssistantEventName.GET_TRANSCRIPTS, {
+      action
+    }).catch(error => {
+      _loggerProxy.default.error(`Failed to send transcript ${action} event`, {
+        module: _constants.TASK_MANAGER_FILE,
+        method: _constants2.METHODS.REQUEST_REAL_TIME_TRANSCRIPTS,
+        interactionId,
+        error
+      });
+    });
+  }
+  getTask(taskId) {
     return this.taskCollection[taskId];
-  };
+  }
+  getAllTasks() {
+    return {
+      ...this.taskCollection
+    };
+  }
 
   /**
-   * @param taskId - Unique identifier for each task
+   * Propagate runtime enableWxBetterTogether changes to config flags and active tasks.
    */
-  getAllTasks = () => {
-    return this.taskCollection;
-  };
+  applyEnableWxBetterTogether(enabled) {
+    if (this.configFlags) {
+      this.configFlags = {
+        ...this.configFlags,
+        enableWxBetterTogether: enabled
+      };
+    }
+    Object.values(this.taskCollection).forEach(task => {
+      task.setEnableWxBetterTogether(enabled);
+      if (enabled) {
+        TaskManager.syncWxAppMuteFromCallDetailsForTask(task);
+      }
+    });
+  }
 
   /**
-   * @param contact - Routing Contact layer. Talks to AQMReq layer to convert events to promises
-   * @param webCallingService - Webrtc Service Layer
-   * @param webSocketManager - Websocket Manager to maintain websocket connection and keepalives
+   * Propagate wxApp mute state from Mercury sync to active voice tasks.
+   */
+  applyWxAppMuteStateFromSync(callId, muted) {
+    Object.values(this.taskCollection).forEach(task => {
+      task.applyWxAppMuteStateFromSync(callId, muted);
+    });
+  }
+
+  /**
+   * Re-seeds wxApp mute state from GET telephony/calls/{callId} for one task.
    */
-  static getTaskManager = (contact, webCallingService, webSocketManager) => {
-    if (!this.taskManager) {
-      this.taskManager = new TaskManager(contact, webCallingService, webSocketManager);
+  static syncWxAppMuteFromCallDetailsForTask(task) {
+    const sync = task.syncWxAppMuteFromCallDetails?.bind(task);
+    if (typeof sync === 'function') {
+      sync().catch(() => undefined);
     }
-    return this.taskManager;
-  };
+  }
+
+  /**
+   * Re-seeds wxApp mute for all engaged voice tasks (reload / runtime enable backfill).
+   */
+  syncWxAppMuteFromCallDetailsForAllTasks() {
+    Object.values(this.taskCollection).forEach(task => {
+      TaskManager.syncWxAppMuteFromCallDetailsForTask(task);
+    });
+  }
+  static getTaskManager(apiAIAssistant, contact, webCallingService, webSocketManager, rtdWebSocketManager) {
+    if (!TaskManager.taskManager) {
+      TaskManager.taskManager = new TaskManager(apiAIAssistant, contact, webCallingService, webSocketManager, rtdWebSocketManager);
+    }
+    return TaskManager.taskManager;
+  }
 }
 exports.default = TaskManager;
 //# sourceMappingURL=TaskManager.js.map