@webex/contact-center 3.12.0-llmrefactor.1 → 3.12.0-llmrefactor.10

package/dist/services/task/TaskManager.js

@@ -14,12 +14,17 @@ var _types3 = require("../../types");
 var _loggerProxy = _interopRequireDefault(require("../../logger-proxy"));
 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);
+const WRAP_UP_STAMP_EVENTS = new Set([_types2.CC_EVENTS.AGENT_WRAPUP, _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED, _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE, _types2.CC_EVENTS.AGENT_CONFERENCE_TRANSFERRED]);
+const PARTICIPANT_LEAVE_WRAP_STATES = new Set([_stateMachine.TaskState.HELD, _stateMachine.TaskState.RESUME_INITIATING, _stateMachine.TaskState.CONSULTING, _stateMachine.TaskState.CONSULT_INITIATING, _stateMachine.TaskState.CONFERENCING]);
 
 /** @internal */
 class TaskManager extends _events.default {
@@ -109,6 +114,9 @@ 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' && !(0, _TaskUtils.isCampaignPreviewReservation)(task));
     if (currentTask) {
@@ -134,14 +142,147 @@ class TaskManager extends _events.default {
     this.webCallingService.off(_calling.LINE_EVENTS.INCOMING_CALL, this.handleIncomingWebCall);
   }
 
+  /**
+   * True when this agent left on the current payload.
+   * A named other participantId is never self-leave (even if the participants
+   * map is partial). Missing-map fallback is EP-DN only: participantId absent
+   * and self omitted now, with previous-task evidence when a prior map exists.
+   */
+  static didSelfLeaveConference(payload, agentId, task) {
+    if (!agentId) {
+      return false;
+    }
+    if (payload.participantId === agentId) {
+      return true;
+    }
+    if (payload.participantId && payload.participantId !== agentId) {
+      return false;
+    }
+    const participants = payload.interaction?.participants;
+    if (!participants || agentId in participants) {
+      return false;
+    }
+    const previousParticipants = task?.data?.interaction?.participants;
+    if (previousParticipants && !(agentId in previousParticipants)) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Consulted non-owner: Voice exitConference / shouldWrapUpForThisAgent stays
+   * false unless an explicit wrap-up signal includes this agent.
+   */
+  static isConsultedNonOwner(payload, agentId, task) {
+    const isConsulted = payload.isConsulted ?? task?.data?.isConsulted;
+    if (isConsulted !== true) {
+      return false;
+    }
+    const owner = payload.interaction?.owner ?? task?.data?.interaction?.owner;
+    return Boolean(agentId && owner && owner !== agentId);
+  }
+  static hasNonemptyPendingWrapUp(payload) {
+    return Array.isArray(payload.agentsPendingWrapUp) && payload.agentsPendingWrapUp.length > 0;
+  }
+
+  /**
+   * Transfer initiator fallback: widgets set transferConferenceRequested on the
+   * actor; desktop success payloads may include consultingAgentId. Only used
+   * when agentsPendingWrapUp is empty or absent.
+   */
+  static isSelfConferenceTransferInitiator(payload, agentId, task) {
+    const snapshotContext = task?.stateMachineService?.getSnapshot?.()?.context;
+    if (snapshotContext?.transferConferenceRequested === true) {
+      return true;
+    }
+    return Boolean(agentId && payload.consultingAgentId === agentId);
+  }
+
+  /**
+   * Explicit wrap-up signals only (no owner / isConsulted fallback).
+   * Used for events that remaining conference agents also receive.
+   * nonempty agentsPendingWrapUp is authoritative, then wrapUpRequired / isWrapUp.
+   */
+  static wrapUpRequiredFromExplicitSignals(payload, agentId) {
+    const pending = payload.agentsPendingWrapUp;
+    if (Array.isArray(pending) && pending.length > 0) {
+      return Boolean(agentId && pending.includes(agentId));
+    }
+    if (payload.wrapUpRequired === true) {
+      return true;
+    }
+    if (!agentId) {
+      return false;
+    }
+    return payload.interaction?.participants?.[agentId]?.isWrapUp === true;
+  }
+
+  /**
+   * Stamp wrapUpRequired once at ingress (prepareEventContext) so updateTaskData
+   * and the mapper see the same flag. Remaining agents stay false.
+   */
+  static stampWrapUpRequiredForEvent(eventType, payload, agentId, task) {
+    if (!WRAP_UP_STAMP_EVENTS.has(eventType)) {
+      return payload;
+    }
+    if (eventType === _types2.CC_EVENTS.AGENT_WRAPUP) {
+      return {
+        ...payload,
+        wrapUpRequired: true
+      };
+    }
+    if (eventType === _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED) {
+      return {
+        ...payload,
+        wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId)
+      };
+    }
+    if (eventType === _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE) {
+      const actorState = task?.stateMachineService?.getSnapshot?.()?.value;
+      if (actorState && !PARTICIPANT_LEAVE_WRAP_STATES.has(actorState)) {
+        return payload;
+      }
+      const left = TaskManager.didSelfLeaveConference(payload, agentId, task);
+      if (!left) {
+        return {
+          ...payload,
+          wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId)
+        };
+      }
+      if (TaskManager.hasNonemptyPendingWrapUp(payload)) {
+        return {
+          ...payload,
+          wrapUpRequired: Boolean(agentId && payload.agentsPendingWrapUp?.includes(agentId))
+        };
+      }
+      return {
+        ...payload,
+        wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId) || !TaskManager.isConsultedNonOwner(payload, agentId, task)
+      };
+    }
+
+    // AGENT_CONFERENCE_TRANSFERRED — pending list wins; initiator only if empty/absent
+    if (TaskManager.hasNonemptyPendingWrapUp(payload)) {
+      return {
+        ...payload,
+        wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId)
+      };
+    }
+    return {
+      ...payload,
+      wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId) || TaskManager.isSelfConferenceTransferInitiator(payload, agentId, task)
+    };
+  }
+
   /**
    * 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) {
+  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)
@@ -180,6 +321,12 @@ class TaskManager extends _events.default {
           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
@@ -284,13 +431,31 @@ class TaskManager extends _events.default {
           taskData: payload
         };
       case _types2.CC_EVENTS.CONTACT_ENDED:
-        return {
-          type: _stateMachine.TaskEvent.CONTACT_ENDED,
-          taskData: {
-            ...payload,
-            wrapUpRequired: (0, _TaskUtils.isCampaignPreviewTask)(payload) ? false : payload.agentsPendingWrapUp?.includes(agentId || '') || false
+        {
+          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
+              }
+            };
           }
-        };
+          return {
+            type: _stateMachine.TaskEvent.CONTACT_ENDED,
+            taskData: {
+              ...payload,
+              wrapUpRequired
+            }
+          };
+        }
       case _types2.CC_EVENTS.AGENT_INVITE_FAILED:
         return {
           type: _stateMachine.TaskEvent.INVITE_FAILED,
@@ -308,11 +473,18 @@ class TaskManager extends _events.default {
           reason: payload.reason
         };
       case _types2.CC_EVENTS.AGENT_OUTBOUND_FAILED:
-        return {
-          type: _stateMachine.TaskEvent.OUTBOUND_FAILED,
-          taskData: payload,
-          reason: payload.reason
-        };
+        {
+          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,
@@ -385,6 +557,43 @@ class TaskManager extends _events.default {
     }
   }
 
+  /**
+   * 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
    *
@@ -493,6 +702,12 @@ class TaskManager extends _events.default {
         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) {
@@ -503,11 +718,20 @@ class TaskManager extends _events.default {
       }
       return !wasConsultedTask;
     };
-    const adjustedPayload = eventType === _types2.CC_EVENTS.AGENT_CONSULT_TRANSFERRED || eventType === _types2.CC_EVENTS.AGENT_BLIND_TRANSFERRED || eventType === _types2.CC_EVENTS.AGENT_VTEAM_TRANSFERRED ? {
+    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;
-    const stateMachineEvent = TaskManager.mapEventToTaskStateMachineEvent(eventType, adjustedPayload, this.agentId);
+    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);
+    }
+    if (WRAP_UP_STAMP_EVENTS.has(eventType)) {
+      adjustedPayload = TaskManager.stampWrapUpRequiredForEvent(eventType, adjustedPayload, this.agentId, task);
+    }
+    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',
@@ -521,6 +745,134 @@ class TaskManager extends _events.default {
     };
   }
 
+  /**
+   * 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: 'findTaskForContactOwnerChange',
+        interactionId: payload.interaction?.mainInteractionId || payload.interaction?.parentInteractionId || payload.interaction?.callProcessingDetails?.parentInteractionId || payload.interactionId
+      });
+      return undefined;
+    }
+    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: 'findUniqueTaskByRelatedInteraction',
+        interactionId: payload.interaction?.mainInteractionId || payload.interaction?.parentInteractionId || payload.interaction?.callProcessingDetails?.parentInteractionId || payload.interactionId
+      });
+    }
+    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))];
+  }
+
   /**
    * Handle task lifecycle events and determine required actions
    *
@@ -544,6 +896,8 @@ class TaskManager extends _events.default {
         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:
@@ -554,6 +908,63 @@ class TaskManager extends _events.default {
         };
     }
   }
+
+  /**
+   * 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
@@ -638,7 +1049,7 @@ class TaskManager extends _events.default {
         wrapUpRequired: false,
         isConferenceInProgress: false,
         isAutoAnswering: false
-      }, this.configFlags, this.wrapupData, this.agentId);
+      }, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
       this.setupTaskListeners(task);
       this.taskCollection[payload.interactionId] = task;
     } else {
@@ -664,7 +1075,7 @@ class TaskManager extends _events.default {
       isConsulted: isConsultedTask,
       isAutoAnswering: shouldAutoAnswer
     };
-    const task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId);
+    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 {
@@ -693,7 +1104,7 @@ class TaskManager extends _events.default {
         isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(payload),
         isAutoAnswering: shouldAutoAnswer
       };
-      task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId);
+      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;
     }
@@ -713,6 +1124,14 @@ class TaskManager extends _events.default {
       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;
   }
@@ -753,8 +1172,8 @@ class TaskManager extends _events.default {
     task.on(_types.TASK_EVENTS.TASK_CLEANUP, (t, options) => {
       this.handleTaskCleanup(t);
       if (options?.removeFromCollection) {
-        const interactionId = t?.data?.interactionId;
-        if (interactionId && this.taskCollection[interactionId]) {
+        const taskIsStillCollected = Object.values(this.taskCollection).some(candidate => candidate === t);
+        if (taskIsStillCollected) {
           this.removeTaskFromCollection(t);
         }
       }
@@ -765,7 +1184,11 @@ class TaskManager extends _events.default {
       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,
@@ -810,7 +1233,7 @@ class TaskManager extends _events.default {
         isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(payload),
         isConsulted: false
       };
-      task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId);
+      task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
       this.taskCollection[payload.interactionId] = task;
 
       // Transition the new task out of IDLE immediately so UI controls are
@@ -884,6 +1307,52 @@ class TaskManager extends _events.default {
       ...this.taskCollection
     };
   }
+
+  /**
+   * Propagate runtime enableWxBetterTogether changes to config flags and active tasks.
+   */
+  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);
+      }
+    });
+  }
+
+  /**
+   * 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 syncWxAppMuteFromCallDetailsForTask(task) {
+    const sync = task.syncWxAppMuteFromCallDetails?.bind(task);
+    if (typeof sync === 'function') {
+      sync().catch(() => undefined);
+    }
+  }
+
+  /**
+   * 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);