@webex/contact-center 3.12.0-next.15 → 3.12.0-next.151

package/src/services/task/TaskManager.ts

@@ -3,25 +3,63 @@ import {ICall, LINE_EVENTS} from '@webex/calling';
 import {WebSocketManager} from '../core/websocket/WebSocketManager';
 import routingContact from './contact';
 import WebCallingService from '../WebCallingService';
-import {ITask, MEDIA_CHANNEL, TASK_EVENTS, TaskData, TaskId} from './types';
+import {
+  MEDIA_CHANNEL,
+  TASK_EVENTS,
+  TaskData,
+  TaskId,
+  ITask,
+  WebSocketPayload,
+  WebSocketMessage,
+  TaskEventActions,
+  EventContext,
+  AISummaryFeatureEnablement,
+  AISummary,
+} from './types';
 import {TASK_MANAGER_FILE} from '../../constants';
 import {METHODS, TRANSCRIPT_EVENT_MAP} from './constants';
 import {CC_EVENTS, CC_TASK_EVENTS, WrapupData} from '../config/types';
-import {AIAssistantEventName, AIAssistantEventType, LoginOption} from '../../types';
+import {ConfigFlags, LoginOption, AIAssistantEventType, AIAssistantEventName} from '../../types';
 import LoggerProxy from '../../logger-proxy';
-import Task from '.';
-import MetricsManager from '../../metrics/MetricsManager';
-import {METRIC_EVENT_NAMES} from '../../metrics/constants';
 import {
-  checkParticipantNotInInteraction,
   getIsConferenceInProgress,
+  isCampaignPreviewTask,
   isCampaignPreviewReservation,
-  isParticipantInMainInteraction,
-  isPrimary,
   isSecondaryEpDnAgent,
   shouldAutoAnswerTask,
 } from './TaskUtils';
-import ApiAIAssistant from '../ApiAiAssistant';
+import TaskFactory from './TaskFactory';
+import AnswerCallOnWebexService from '../AnswerCallOnWebexService';
+import {getWebexCallingDeviceDetailsForAgent} from './WebexCallingUtils';
+import WebRTC from './voice/WebRTC';
+import {TaskEvent, TaskState, type TaskEventPayload} from './state-machine';
+import {MEDIA_TYPE_MAIN_CALL} from './state-machine/constants';
+import {normalizeTaskData} from './taskDataNormalizer';
+import {ApiAIAssistant} from '../ApiAiAssistant';
+
+const CC_EVENT_SET = new Set<CC_EVENTS>(Object.values(CC_EVENTS) as CC_EVENTS[]);
+
+const MAIN_INTERACTION_CORRELATED_EVENTS = new Set<CC_EVENTS>([
+  CC_EVENTS.AGENT_CONSULT_ENDED,
+  CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+]);
+
+const isCcEvent = (value: string): value is CC_EVENTS => CC_EVENT_SET.has(value as CC_EVENTS);
+
+const WRAP_UP_STAMP_EVENTS = new Set<CC_EVENTS>([
+  CC_EVENTS.AGENT_WRAPUP,
+  CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED,
+  CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+  CC_EVENTS.AGENT_CONFERENCE_TRANSFERRED,
+]);
+
+const PARTICIPANT_LEAVE_WRAP_STATES = new Set<TaskState>([
+  TaskState.HELD,
+  TaskState.RESUME_INITIATING,
+  TaskState.CONSULTING,
+  TaskState.CONSULT_INITIATING,
+  TaskState.CONFERENCING,
+]);
 
 /** @internal */
 export default class TaskManager extends EventEmitter {
@@ -35,12 +73,21 @@ export default class TaskManager extends EventEmitter {
   private taskCollection: Record<TaskId, ITask>;
   private webCallingService: WebCallingService;
   private webSocketManager: WebSocketManager;
-  private metricsManager: MetricsManager;
-  private static taskManager;
+  private rtdWebSocketManager: WebSocketManager;
+  // eslint-disable-next-line no-use-before-define
+  private static taskManager: TaskManager;
+  private configFlags?: ConfigFlags;
   private wrapupData: WrapupData;
   private agentId: string;
+  private agentName: string;
   private webRtcEnabled: boolean;
+  private answerCallOnWebexService?: AnswerCallOnWebexService;
   private apiAIAssistant?: ApiAIAssistant;
+  private receivingSummaryBuffer = new Map<string, AISummary>();
+
+  // RTD feature frames can arrive before AQM creates the task.
+  private pendingFeatureEnablement = new Map<string, AISummaryFeatureEnablement>();
+
   /**
    * @param contact - Routing Contact layer. Talks to AQMReq layer to convert events to promises
    * @param webCallingService - Webrtc Service Layer
@@ -50,588 +97,1480 @@ export default class TaskManager extends EventEmitter {
     apiAIAssistant: ApiAIAssistant,
     contact: ReturnType<typeof routingContact>,
     webCallingService: WebCallingService,
-    webSocketManager: WebSocketManager
+    webSocketManager: WebSocketManager,
+    rtdWebSocketManager: WebSocketManager
   ) {
     super();
     this.apiAIAssistant = apiAIAssistant;
     this.contact = contact;
-    this.taskCollection = {};
     this.webCallingService = webCallingService;
     this.webSocketManager = webSocketManager;
-    this.metricsManager = MetricsManager.getInstance();
+    this.rtdWebSocketManager = rtdWebSocketManager;
+    this.taskCollection = {};
+    this.webRtcEnabled = false;
     this.registerTaskListeners();
     this.registerIncomingCallEvent();
   }
 
+  public handleRealtimeWebsocketEvent(event: string) {
+    try {
+      const payload = JSON.parse(event);
+
+      switch (payload?.type) {
+        case CC_TASK_EVENTS.FEATURE_ENABLEMENT: {
+          const enablement: AISummaryFeatureEnablement = payload?.data?.data;
+          if (!enablement?.interactionId) return;
+
+          const task = this.taskCollection[enablement.interactionId];
+          if (task) {
+            this.pendingFeatureEnablement.delete(enablement.interactionId);
+            task.setFeatureEnablement?.(enablement);
+            task.emit(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, enablement);
+          } else {
+            this.pendingFeatureEnablement.set(enablement.interactionId, enablement);
+          }
+
+          return;
+        }
+        case CC_TASK_EVENTS.POST_CALL_SUMMARY:
+        case CC_TASK_EVENTS.MID_CALL_SUMMARY: {
+          if (!payload?.data?.data?.conversationId) return;
+
+          this.apiAIAssistant?.resolveFromRtdEvent(
+            payload.type,
+            payload.data.data.conversationId,
+            payload.data.data
+          );
+
+          return;
+        }
+        case CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT: {
+          if (!payload?.data?.data?.conversationId) return;
+
+          const summary: AISummary = payload.data.data;
+          const {conversationId} = summary;
+          const task = this.taskCollection[conversationId];
+          const taskState = task?.state?.value;
+
+          // Emit only once the task is answered; until then it waits for the answer event.
+          if (task && taskState !== TaskState.IDLE && taskState !== TaskState.OFFERED) {
+            this.receivingSummaryBuffer.delete(conversationId);
+            task.emit(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, summary);
+          } else {
+            this.receivingSummaryBuffer.set(conversationId, summary);
+          }
+
+          return;
+        }
+        default:
+          break;
+      }
+
+      const interactionId = payload?.data?.data?.conversationId;
+      if (!interactionId) return;
+
+      const task = this.taskCollection[interactionId];
+      if (!task) {
+        LoggerProxy.info(`Realtime transcription task not found`, {
+          module: TASK_MANAGER_FILE,
+          method: METHODS.HANDLE_REAL_TIME_WEBSOCKET_EVENT,
+          interactionId,
+        });
+
+        return;
+      }
+
+      switch (payload.type) {
+        case CC_EVENTS.REAL_TIME_TRANSCRIPTION:
+        case CC_EVENTS.SUGGESTED_RESPONSE:
+          task.emit(payload.type, payload.data);
+          break;
+        default:
+          break;
+      }
+    } catch (error) {
+      LoggerProxy.error('Failed to parse RTD WebSocket message', {
+        module: TASK_MANAGER_FILE,
+        method: METHODS.HANDLE_REAL_TIME_WEBSOCKET_EVENT,
+        error,
+      });
+    }
+  }
+
+  /**
+   * Set config flags for task creation
+   */
+  public setConfigFlags(configFlags: ConfigFlags) {
+    this.configFlags = configFlags;
+  }
+
+  public clearAISummaryState(): void {
+    this.apiAIAssistant?.clearAllRtdRequests();
+    Object.values(this.taskCollection).forEach((task) => task.clearFeatureEnablement?.());
+    this.receivingSummaryBuffer.clear();
+    this.pendingFeatureEnablement.clear();
+  }
+
+  /**
+   * Set wrapup configuration data
+   */
   public setWrapupData(wrapupData: WrapupData) {
     this.wrapupData = wrapupData;
   }
 
-  public setAgentId(agentId: string) {
-    this.agentId = agentId;
+  /**
+   * Set agent ID for task operations
+   */
+  public setAgentId(agentId: string) {
+    this.agentId = agentId;
+  }
+
+  public setAgentName(agentName: string) {
+    this.agentName = agentName;
+  }
+
+  /**
+   * Gets the current agent ID
+   * @returns {string} The agent ID set for this task manager instance
+   * @public
+   */
+  public getAgentId(): string {
+    return this.agentId;
+  }
+
+  public setWebRtcEnabled(webRtcEnabled: boolean) {
+    this.webRtcEnabled = webRtcEnabled;
+  }
+
+  public setAnswerCallOnWebexService(answerCallOnWebexService: AnswerCallOnWebexService) {
+    this.answerCallOnWebexService = answerCallOnWebexService;
+  }
+
+  private handleIncomingWebCall = (call: ICall) => {
+    const currentTask = Object.values(this.taskCollection).find(
+      (task) =>
+        task.data.interaction.mediaType === 'telephony' && !isCampaignPreviewReservation(task)
+    );
+
+    if (currentTask) {
+      this.webCallingService.mapCallToTask(call.getCallId(), currentTask.data.interactionId);
+      LoggerProxy.log(`Call mapped to task`, {
+        module: TASK_MANAGER_FILE,
+        method: METHODS.HANDLE_INCOMING_WEB_CALL,
+        interactionId: currentTask.data.interactionId,
+      });
+
+      // Send TASK_INCOMING to state machine - it will emit on the task object
+      const eventPayload = TaskManager.mapEventToTaskStateMachineEvent(
+        CC_EVENTS.AGENT_CONTACT_RESERVED,
+        currentTask.data
+      );
+      if (eventPayload && currentTask) {
+        currentTask.sendStateMachineEvent(eventPayload);
+      }
+    }
+    this.call = call;
+  };
+
+  public registerIncomingCallEvent() {
+    this.webCallingService.on(LINE_EVENTS.INCOMING_CALL, this.handleIncomingWebCall);
+  }
+
+  public unregisterIncomingCallEvent() {
+    this.webCallingService.off(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.
+   */
+  private static didSelfLeaveConference(
+    payload: WebSocketPayload,
+    agentId?: string,
+    task?: ITask
+  ): boolean {
+    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.
+   */
+  private static isConsultedNonOwner(
+    payload: WebSocketPayload,
+    agentId?: string,
+    task?: ITask
+  ): boolean {
+    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);
+  }
+
+  private static hasNonemptyPendingWrapUp(payload: WebSocketPayload): boolean {
+    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.
+   */
+  private static isSelfConferenceTransferInitiator(
+    payload: WebSocketPayload,
+    agentId?: string,
+    task?: ITask
+  ): boolean {
+    const snapshotContext = task?.stateMachineService?.getSnapshot?.()?.context as
+      | {transferConferenceRequested?: boolean}
+      | undefined;
+    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.
+   */
+  private static wrapUpRequiredFromExplicitSignals(
+    payload: WebSocketPayload,
+    agentId?: string
+  ): boolean {
+    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.
+   */
+  private static stampWrapUpRequiredForEvent(
+    eventType: CC_EVENTS,
+    payload: WebSocketPayload,
+    agentId?: string,
+    task?: ITask
+  ): WebSocketPayload {
+    if (!WRAP_UP_STAMP_EVENTS.has(eventType)) {
+      return payload;
+    }
+
+    if (eventType === CC_EVENTS.AGENT_WRAPUP) {
+      return {...payload, wrapUpRequired: true};
+    }
+
+    if (eventType === CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED) {
+      return {
+        ...payload,
+        wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId),
+      };
+    }
+
+    if (eventType === CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE) {
+      const actorState = task?.stateMachineService?.getSnapshot?.()?.value;
+      if (actorState && !PARTICIPANT_LEAVE_WRAP_STATES.has(actorState as TaskState)) {
+        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
+   */
+  private static mapEventToTaskStateMachineEvent(
+    ccEvent: CC_EVENTS,
+    payload: WebSocketPayload,
+    agentId?: string,
+    task?: ITask,
+    enableWxBetterTogether?: boolean
+  ): TaskEventPayload | null {
+    const mediaResourceId =
+      payload.mediaResourceId ||
+      payload.interaction?.media?.[payload.interactionId]?.mediaResourceId;
+
+    switch (ccEvent) {
+      // CC -> TaskEvent mappings (see TaskStateMachine comment for quick reference)
+      case CC_EVENTS.AGENT_CONTACT_RESERVED: // AgentContactReserved -> TASK_INCOMING
+        if (isCampaignPreviewTask(payload)) {
+          return {
+            type: TaskEvent.TASK_INCOMING,
+            taskData: payload,
+            isCampaignReservationAccept: true,
+          };
+        }
+
+        return {type: TaskEvent.TASK_INCOMING, taskData: payload};
+
+      case CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION: // -> TASK_INCOMING (campaign branch via guard)
+        return {
+          type: TaskEvent.TASK_INCOMING,
+          taskData: payload,
+          isCampaignReservationAccept: true,
+        };
+
+      case CC_EVENTS.AGENT_OFFER_CONTACT: // AgentOfferContact -> TASK_OFFERED
+        return {type: TaskEvent.TASK_OFFERED, taskData: payload};
+
+      case CC_EVENTS.AGENT_CONTACT: // AgentContact -> HYDRATE
+        // Include agentId for state detection (e.g., checking isWrapUp in participant data)
+        return {type: TaskEvent.HYDRATE, taskData: payload, agentId};
+
+      case 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: TaskEvent.CONTACT_OWNER_CHANGED, taskData: payload};
+        }
+
+        return {type: TaskEvent.CONTACT_UPDATED, taskData: payload};
+      case CC_EVENTS.CONTACT_OWNER_CHANGED:
+        return {type: TaskEvent.CONTACT_OWNER_CHANGED, taskData: payload};
+
+      case CC_EVENTS.AGENT_OFFER_CONSULT: // AgentOfferConsult -> OFFER_CONSULT
+        return {
+          type: TaskEvent.OFFER_CONSULT,
+          taskData: {...payload, isConsulted: true},
+        };
+
+      case CC_EVENTS.AGENT_CONTACT_ASSIGNED: // AgentContactAssigned -> ASSIGN
+        return {type: TaskEvent.ASSIGN, taskData: payload};
+
+      case CC_EVENTS.AGENT_CONTACT_HELD:
+        return {
+          type: TaskEvent.HOLD_SUCCESS,
+          mediaResourceId: mediaResourceId || '',
+          taskData: payload,
+        };
+
+      case CC_EVENTS.AGENT_CONTACT_UNHELD:
+        return {
+          type: TaskEvent.UNHOLD_SUCCESS,
+          mediaResourceId: mediaResourceId || '',
+          taskData: payload,
+        };
+
+      case CC_EVENTS.AGENT_CONSULT_CREATED:
+        return {
+          type: TaskEvent.CONSULT_CREATED,
+          taskData: {...payload, isConsulted: false},
+        };
+
+      case 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: TaskEvent.CONSULTING_ACTIVE,
+          consultDestinationAgentJoined: true,
+          taskData: payload,
+        };
+
+      case CC_EVENTS.AGENT_CONSULT_ENDED: // AgentConsultEnded -> CONSULT_END
+        return {type: TaskEvent.CONSULT_END, taskData: payload};
+
+      case CC_EVENTS.AGENT_CONSULT_FAILED:
+      case CC_EVENTS.AGENT_CTQ_FAILED:
+        return {type: TaskEvent.CONSULT_FAILED, reason: payload.reason, taskData: payload};
+
+      case CC_EVENTS.AGENT_CTQ_CANCELLED:
+        return {type: TaskEvent.CTQ_CANCEL, taskData: payload};
+
+      case CC_EVENTS.AGENT_CTQ_CANCEL_FAILED:
+        return {type: TaskEvent.CTQ_CANCEL_FAILED, taskData: payload};
+
+      case CC_EVENTS.AGENT_BLIND_TRANSFERRED: // AgentBlindTransferred -> TRANSFER_SUCCESS
+      case CC_EVENTS.AGENT_CONSULT_TRANSFERRED: // AgentConsultTransferred -> TRANSFER_SUCCESS
+      case CC_EVENTS.AGENT_VTEAM_TRANSFERRED: // AgentVTeamTransferred -> TRANSFER_SUCCESS
+        return {
+          type: TaskEvent.TRANSFER_SUCCESS,
+          taskData: payload,
+        };
+
+      case CC_EVENTS.AGENT_WRAPUP:
+        return {type: TaskEvent.TASK_WRAPUP, taskData: {...payload, wrapUpRequired: true}};
+      case CC_EVENTS.AGENT_CONTACT_UNASSIGNED:
+        return null; // Add WRAPUP if needed
+
+      case CC_EVENTS.AGENT_BLIND_TRANSFER_FAILED:
+      case CC_EVENTS.AGENT_VTEAM_TRANSFER_FAILED:
+      case CC_EVENTS.AGENT_CONSULT_TRANSFER_FAILED:
+      case CC_EVENTS.AGENT_CONFERENCE_TRANSFER_FAILED:
+        return {type: TaskEvent.TRANSFER_FAILED, taskData: payload};
+
+      case CC_EVENTS.CONTACT_ENDED: {
+        const wrapUpRequired = 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: TaskEvent.OUTBOUND_FAILED,
+            reason: 'AGENT_ENDS',
+            taskData: {...payload, wrapUpRequired: true},
+          };
+        }
+
+        return {
+          type: TaskEvent.CONTACT_ENDED,
+          taskData: {
+            ...payload,
+            wrapUpRequired,
+          },
+        };
+      }
+
+      case CC_EVENTS.AGENT_INVITE_FAILED:
+        return {type: TaskEvent.INVITE_FAILED, reason: payload.reason};
+
+      case CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED:
+        return {type: TaskEvent.ASSIGN_FAILED, reason: payload.reason};
+
+      case CC_EVENTS.AGENT_CONTACT_OFFER_RONA:
+        return {type: TaskEvent.RONA, taskData: payload, reason: payload.reason};
+
+      case 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: TaskEvent.OUTBOUND_FAILED,
+          taskData: suppressOutdialFailedPopup
+            ? {...payload, suppressOutdialFailedPopup: true}
+            : payload,
+          reason: payload.reason,
+        };
+      }
+
+      case CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED:
+        return {type: TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED, taskData: payload};
+
+      case CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED:
+        return {type: TaskEvent.CAMPAIGN_PREVIEW_SKIP_FAILED, taskData: payload};
+
+      case CC_EVENTS.CAMPAIGN_PREVIEW_REMOVE_FAILED:
+        return {type: TaskEvent.CAMPAIGN_PREVIEW_REMOVE_FAILED, taskData: payload};
+
+      case CC_EVENTS.CONTACT_RECORDING_STARTED:
+        return {type: TaskEvent.RECORDING_STARTED, taskData: payload};
+
+      case CC_EVENTS.CONTACT_RECORDING_PAUSED:
+        return {type: TaskEvent.PAUSE_RECORDING, taskData: payload};
+
+      case CC_EVENTS.CONTACT_RECORDING_RESUMED:
+        return {type: TaskEvent.RESUME_RECORDING, taskData: payload};
+
+      case CC_EVENTS.AGENT_WRAPPEDUP:
+        return {type: TaskEvent.WRAPUP_COMPLETE, taskData: payload};
+
+      // Conference events - these trigger state machine transition to CONFERENCING
+      case CC_EVENTS.AGENT_CONSULT_CONFERENCED:
+      case CC_EVENTS.AGENT_CONSULT_CONFERENCING:
+      case CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE:
+        return {type: TaskEvent.CONFERENCE_START, taskData: payload};
+
+      case CC_EVENTS.AGENT_CONSULT_CONFERENCE_FAILED:
+        return {type: TaskEvent.CONFERENCE_FAILED, reason: payload.reason, taskData: payload};
+
+      case CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED:
+        return {type: TaskEvent.CONFERENCE_END, taskData: payload};
+
+      case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE:
+        return {
+          type: TaskEvent.PARTICIPANT_LEAVE,
+          taskData: payload,
+          participantId: payload?.participantId,
+        };
+
+      case CC_EVENTS.AGENT_CONFERENCE_TRANSFERRED:
+        return {type: 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).
+   */
+  private static isWxAppManagedOutdialTask(
+    agentId: string | undefined,
+    payload: WebSocketPayload,
+    task: ITask | undefined,
+    enableWxBetterTogether?: boolean
+  ): boolean {
+    const wxAppEnabled =
+      (task as {uiControlConfig?: {enableWxBetterTogether?: boolean}})?.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 = 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).
+   */
+  private static isAgentTerminatedOutdialWrapup(
+    payload: WebSocketPayload,
+    wrapUpRequired: boolean,
+    task?: ITask,
+    agentId?: string,
+    enableWxBetterTogether?: boolean
+  ): boolean {
+    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 as {uiControlConfig?: {wxAppAnswerPending?: boolean}})?.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
+   */
+  private 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);
+      }
+
+      // A receiving summary held while the task rang is emitted right after the answer
+      // event above (AgentContactAssigned / AgentConsulting) has been emitted.
+      const bufferedSummary = this.receivingSummaryBuffer.get(task.data.interactionId);
+      const taskState = task.state?.value;
+      if (bufferedSummary && taskState !== TaskState.IDLE && taskState !== TaskState.OFFERED) {
+        this.receivingSummaryBuffer.delete(task.data.interactionId);
+        task.emit(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, bufferedSummary);
+      }
+
+      // Emit TASK_POST_CALL_ACTIVITY for ParticipantPostCallActivity events so
+      // consumers (Widgets) can detect the interaction state change to post_call.
+      if (eventContext.eventType === CC_EVENTS.PARTICIPANT_POST_CALL_ACTIVITY) {
+        task.emit(TASK_EVENTS.TASK_POST_CALL_ACTIVITY, task);
+      }
+
+      // Send transcript start/stop events for relevant CC events
+      this.requestRealTimeTranscripts(eventContext.eventType, payload.interactionId);
+    });
+  }
+
+  /**
+   * Parse and validate WebSocket message
+   * @returns Parsed message or null if invalid/keepalive
+   */
+  private static parseWebSocketMessage(event: string): WebSocketMessage | null {
+    try {
+      const payload = JSON.parse(event) as WebSocketMessage;
+
+      // Filter out keepalive messages
+      if (payload?.keepalive === 'true' || payload?.keepalive === true) {
+        return null;
+      }
+
+      // Normalize task data if present
+      if (payload?.data?.interaction) {
+        payload.data = normalizeTaskData(payload.data);
+      }
+
+      return payload;
+    } catch (error) {
+      LoggerProxy.error('Failed to parse WebSocket message', {
+        module: TASK_MANAGER_FILE,
+        method: 'parseWebSocketMessage',
+        error,
+      });
+
+      return null;
+    }
+  }
+
+  /**
+   * Prepare context for event processing
+   * @returns Event context or null if event type is invalid
+   */
+  private prepareEventContext(message: WebSocketMessage): EventContext | null {
+    const eventType = message.data?.type || message.type;
+
+    if (!eventType || !isCcEvent(eventType)) {
+      return null;
+    }
+
+    const interactionId = message.data.interactionId;
+    const reservationInteractionId = message.data.reservationInteractionId;
+    let task = this.taskCollection[interactionId];
+    let ownerChangeResolvedByRelatedInteraction = false;
+
+    // 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;
+        this.pendingFeatureEnablement.delete(reservationInteractionId);
+      }
+    }
+
+    if (!task && eventType === CC_EVENTS.CONTACT_OWNER_CHANGED) {
+      const incomingShowsCurrentAgentPromotion = Boolean(
+        this.agentId &&
+          message.data.interaction?.owner === this.agentId &&
+          TaskManager.isParticipantActiveOnMainInteraction(message.data, this.agentId)
+      );
+
+      task = this.findUniqueTaskByRelatedInteraction(
+        message.data,
+        (candidate) => {
+          const currentAgentId = this.agentId || candidate.data?.agentId;
+
+          return Boolean(
+            currentAgentId &&
+              (TaskManager.isParticipantActiveOnMainInteraction(candidate.data, currentAgentId) ||
+                incomingShowsCurrentAgentPromotion)
+          );
+        },
+        {includeCollectionKeys: true, includeMainCallMediaKeys: true}
+      );
+      ownerChangeResolvedByRelatedInteraction = Boolean(task);
+    }
+
+    let ownerChangeMainInteractionId: string | undefined;
+    if (task && eventType === CC_EVENTS.CONTACT_OWNER_CHANGED) {
+      const taskMainInteractionId = task.data?.interaction?.mainInteractionId;
+      const payloadMainInteractionId = message.data.interaction?.mainInteractionId;
+      const hasConflictingMainInteractionIds = Boolean(
+        taskMainInteractionId &&
+          payloadMainInteractionId &&
+          taskMainInteractionId !== payloadMainInteractionId
+      );
+      // A promoted child task can retain stale embedded IDs. Prefer the
+      // authoritative incoming main-call identity before local snapshot IDs.
+      const stableMainInteractionId =
+        payloadMainInteractionId ||
+        TaskManager.getMainCallMediaId(message.data.interaction) ||
+        TaskManager.getMainCallMediaId(task.data?.interaction) ||
+        taskMainInteractionId ||
+        message.data.interaction?.interactionId ||
+        task.data?.interaction?.interactionId ||
+        task.data?.interactionId;
+      const taskAtStableKey = stableMainInteractionId
+        ? this.taskCollection[stableMainInteractionId]
+        : undefined;
+
+      if (
+        !stableMainInteractionId ||
+        hasConflictingMainInteractionIds ||
+        (taskAtStableKey && taskAtStableKey !== task)
+      ) {
+        LoggerProxy.warn('Unable to safely correlate owner change to the main interaction task', {
+          module: TASK_MANAGER_FILE,
+          method: 'prepareEventContext',
+          interactionId:
+            payloadMainInteractionId || taskMainInteractionId || message.data.interactionId,
+        });
+        task = undefined;
+      } else if (ownerChangeResolvedByRelatedInteraction) {
+        ownerChangeMainInteractionId = stableMainInteractionId;
+      }
+    }
+
+    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: WebSocketPayload =
+      eventType === CC_EVENTS.AGENT_CONSULT_TRANSFERRED ||
+      eventType === CC_EVENTS.AGENT_BLIND_TRANSFERRED ||
+      eventType === CC_EVENTS.AGENT_VTEAM_TRANSFERRED
+        ? {
+            ...message.data,
+            wrapUpRequired: computeWrapUpRequired(),
+          }
+        : message.data;
+
+    if (task && ownerChangeMainInteractionId) {
+      adjustedPayload = {
+        ...adjustedPayload,
+        interactionId: ownerChangeMainInteractionId,
+      };
+    }
+
+    if (task && eventType === 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.info(`Handling task event ${eventType}`, {
+      module: TASK_MANAGER_FILE,
+      method: 'prepareEventContext',
+      interactionId,
+    });
+
+    return {
+      eventType,
+      payload: adjustedPayload,
+      task,
+      stateMachineEvent,
+    };
+  }
+
+  private static isParticipantActiveOnMainInteraction(
+    taskData: TaskData | WebSocketPayload | undefined,
+    participantId: string
+  ): boolean {
+    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 === MEDIA_TYPE_MAIN_CALL && media.participants?.includes(participantId)
+    );
+  }
+
+  private static getMainCallMediaId(
+    interaction: TaskData['interaction'] | undefined
+  ): string | undefined {
+    return Object.entries(interaction?.media ?? {}).find(
+      ([, media]) => media?.mType === MEDIA_TYPE_MAIN_CALL
+    )?.[0];
+  }
+
+  private static getStableMainInteractionId(payload: WebSocketPayload): string | undefined {
+    return (
+      payload.interaction?.mainInteractionId ||
+      TaskManager.getMainCallMediaId(payload.interaction) ||
+      payload.interaction?.interactionId ||
+      payload.interactionId
+    );
+  }
+
+  private canRecoverTaskFromContactOwnerChanged(payload: WebSocketPayload): boolean {
+    const interaction = payload.interaction;
+    const stableInteractionId = TaskManager.getStableMainInteractionId(payload);
+
+    return Boolean(
+      this.agentId &&
+        stableInteractionId &&
+        interaction?.mediaType === MEDIA_CHANNEL.TELEPHONY &&
+        interaction.isTerminated !== true &&
+        interaction.owner === this.agentId &&
+        TaskManager.isParticipantActiveOnMainInteraction(payload, this.agentId)
+    );
+  }
+
+  /**
+   * 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.
+   */
+  private static preserveConfirmedOwner(task: ITask, payload: WebSocketPayload): WebSocketPayload {
+    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.
+   */
+  private findUniqueTaskByRelatedInteraction(
+    payload: WebSocketPayload,
+    candidateFilter: (task: ITask) => boolean = () => true,
+    options: {includeCollectionKeys?: boolean; includeMainCallMediaKeys?: boolean} = {}
+  ): ITask | undefined {
+    const candidates = this.findRelatedTasks(payload, options).filter(candidateFilter);
+
+    if (candidates.length === 1) {
+      return candidates[0];
+    }
+
+    if (candidates.length > 1) {
+      LoggerProxy.warn('Unable to correlate task event to a unique main interaction task', {
+        module: TASK_MANAGER_FILE,
+        method: 'findUniqueTaskByRelatedInteraction',
+        interactionId:
+          payload.interaction?.mainInteractionId ||
+          payload.interaction?.parentInteractionId ||
+          payload.interaction?.callProcessingDetails?.parentInteractionId ||
+          payload.interactionId,
+      });
+    }
+
+    return undefined;
+  }
+
+  private findRelatedTasks(
+    payload: WebSocketPayload,
+    options: {includeCollectionKeys?: boolean; includeMainCallMediaKeys?: boolean} = {}
+  ): ITask[] {
+    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((relatedInteractionId): relatedInteractionId is string =>
+        Boolean(relatedInteractionId)
+      )
+    );
+    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(
+              (relatedInteractionId) =>
+                Boolean(relatedInteractionId) && payloadInteractionIds.has(relatedInteractionId)
+            );
+          })
+          .map(([, candidate]) => candidate)
+      ),
+    ];
   }
 
   /**
-   * Gets the current agent ID
-   * @returns {string} The agent ID set for this task manager instance
-   * @public
+   * 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()
    */
-  public getAgentId(): string {
-    return this.agentId;
+  private handleTaskLifecycleEvent(context: EventContext): TaskEventActions {
+    const {eventType} = context;
+
+    switch (eventType) {
+      case CC_EVENTS.AGENT_CONTACT_RESERVED:
+        return this.handleContactReserved(context);
+
+      case CC_EVENTS.AGENT_CONTACT:
+        return this.handleAgentContact(context);
+
+      case CC_EVENTS.CONTACT_MERGED:
+        return this.handleContactMergedEvent(context);
+
+      case CC_EVENTS.CONTACT_OWNER_CHANGED:
+        return this.handleContactOwnerChanged(context);
+
+      case CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION:
+        return this.handleCampaignPreviewReservation(context);
+
+      case CC_EVENTS.CAMPAIGN_CONTACT_UPDATED:
+        return this.handleCampaignContactUpdated(context);
+
+      default:
+        return {task: context.task};
+    }
   }
 
-  public setWebRtcEnabled(webRtcEnabled: boolean) {
-    this.webRtcEnabled = webRtcEnabled;
+  /**
+   * 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.
+   */
+  private handleContactOwnerChanged(context: EventContext): TaskEventActions {
+    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: WebSocketPayload =
+      payload.interactionId === stableInteractionId
+        ? payload
+        : {...payload, interactionId: stableInteractionId};
+    const taskData: TaskData = {
+      ...normalizedPayload,
+      owner: normalizedPayload.interaction.owner,
+      wrapUpRequired: normalizedPayload.interaction.participants?.[this.agentId]?.isWrapUp || false,
+      isConferenceInProgress: getIsConferenceInProgress(normalizedPayload),
+      isConsulted: false,
+      isAutoAnswering: false,
+    };
+    const task = TaskFactory.createTask(
+      this.contact,
+      this.webCallingService,
+      taskData,
+      this.configFlags,
+      this.wrapupData,
+      this.agentId,
+      this.agentName,
+      this.answerCallOnWebexService,
+      this.apiAIAssistant
+    );
+
+    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: TaskEvent.HYDRATE,
+      taskData,
+      agentId: this.agentId,
+    } as TaskEventPayload);
+
+    this.setupTaskListeners(task);
+    context.payload = taskData;
+    context.stateMachineEvent = {
+      type: TaskEvent.CONTACT_OWNER_CHANGED,
+      taskData,
+    };
+
+    return {task};
   }
 
-  public handleRealtimeWebsocketEvent(event: string) {
-    try {
-      const payload = JSON.parse(event);
+  private handleCampaignContactUpdated(context: EventContext) {
+    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: TaskData = {...payload};
 
-      const eventType = payload?.type || payload?.data?.notifType;
-      const interactionId = payload?.data?.data?.conversationId;
-      if (!eventType || !interactionId) return;
+      if (existingCpd) {
+        const campaignFields = {
+          ...(existingCpd.campaignPreviewAutoAction && {
+            campaignPreviewAutoAction: existingCpd.campaignPreviewAutoAction,
+          }),
+          ...(existingCpd.campaignPreviewOfferTimeout && {
+            campaignPreviewOfferTimeout: existingCpd.campaignPreviewOfferTimeout,
+          }),
+          ...(existingCpd.campaignPreviewSkipDisabled && {
+            campaignPreviewSkipDisabled: existingCpd.campaignPreviewSkipDisabled,
+          }),
+          ...(existingCpd.campaignPreviewRemoveDisabled && {
+            campaignPreviewRemoveDisabled: existingCpd.campaignPreviewRemoveDisabled,
+          }),
+        };
 
-      const task = this.taskCollection[interactionId];
-      if (!task) {
-        LoggerProxy.info(`Realtime transcription task not found`, {
-          module: TASK_MANAGER_FILE,
-          method: METHODS.HANDLE_REAL_TIME_WEBSOCKET_EVENT,
-          interactionId,
-        });
+        if (!updatedData.interaction) {
+          updatedData.interaction = {} as typeof updatedData.interaction;
+        }
 
-        return;
+        updatedData.interaction = {
+          ...updatedData.interaction,
+          callProcessingDetails: {
+            ...campaignFields,
+            ...(updatedData.interaction.callProcessingDetails || {}),
+          } as typeof existingCpd,
+        };
       }
 
-      task.emit(eventType, payload.data);
-    } catch (error) {
-      LoggerProxy.error('Failed to parse RTD WebSocket message', {
+      LoggerProxy.log('Campaign contact updated - carrying forward preview fields', {
         module: TASK_MANAGER_FILE,
-        method: METHODS.HANDLE_REAL_TIME_WEBSOCKET_EVENT,
-        error,
+        method: METHODS.REGISTER_TASK_LISTENERS,
+        interactionId: payload.interactionId,
+        data: {
+          hasCpd: !!updatedData.interaction?.callProcessingDetails,
+          autoAction: updatedData.interaction?.callProcessingDetails?.campaignPreviewAutoAction,
+          skipDisabled: updatedData.interaction?.callProcessingDetails?.campaignPreviewSkipDisabled,
+          removeDisabled:
+            updatedData.interaction?.callProcessingDetails?.campaignPreviewRemoveDisabled,
+        },
       });
+
+      task = this.updateTaskData(task, updatedData);
+      task.emit(TASK_EVENTS.TASK_CAMPAIGN_CONTACT_UPDATED, task);
     }
+
+    return {task};
   }
 
-  private handleIncomingWebCall = (call: ICall) => {
-    const currentTask = Object.values(this.taskCollection).find(
-      (task) =>
-        task.data.interaction.mediaType === 'telephony' && !isCampaignPreviewReservation(task)
-    );
+  /**
+   * Creates or updates a task for campaign preview reservation.
+   * TASK_CAMPAIGN_PREVIEW_RESERVATION is emitted by the state machine (campaign TASK_INCOMING branch).
+   */
+  private handleCampaignPreviewReservation(context: EventContext): TaskEventActions {
+    const {payload} = context;
+    let {task} = context;
 
-    if (currentTask) {
-      this.webCallingService.mapCallToTask(call.getCallId(), currentTask.data.interactionId);
-      LoggerProxy.log(`Call mapped to task`, {
-        module: TASK_MANAGER_FILE,
-        method: METHODS.HANDLE_INCOMING_WEB_CALL,
-        interactionId: currentTask.data.interactionId,
-      });
-      this.emit(TASK_EVENTS.TASK_INCOMING, currentTask);
+    LoggerProxy.log('Campaign preview reservation received', {
+      module: TASK_MANAGER_FILE,
+      method: METHODS.REGISTER_TASK_LISTENERS,
+      interactionId: payload.interactionId,
+    });
+
+    if (!task) {
+      task = TaskFactory.createTask(
+        this.contact,
+        this.webCallingService,
+        {
+          ...payload,
+          wrapUpRequired: false,
+          isConferenceInProgress: false,
+          isAutoAnswering: false,
+        },
+        this.configFlags,
+        this.wrapupData,
+        this.agentId,
+        this.agentName,
+        this.answerCallOnWebexService,
+        this.apiAIAssistant
+      );
+      this.setupTaskListeners(task);
+      this.taskCollection[payload.interactionId] = task;
+    } else {
+      task = this.updateTaskData(task, payload);
     }
-    this.call = call;
-  };
 
-  public registerIncomingCallEvent() {
-    this.webCallingService.on(LINE_EVENTS.INCOMING_CALL, this.handleIncomingWebCall);
+    return {task};
   }
 
-  public unregisterIncomingCallEvent() {
-    this.webCallingService.off(LINE_EVENTS.INCOMING_CALL, this.handleIncomingWebCall);
+  /**
+   * Handle AGENT_CONTACT_RESERVED event
+   * Creates a new task; state machine event is sent during processing
+   */
+  private handleContactReserved(context: EventContext): TaskEventActions {
+    const {payload} = context;
+    const isConsultedTask =
+      payload.isConsulted === true || isSecondaryEpDnAgent(payload.interaction);
+    const shouldAutoAnswer = shouldAutoAnswerTask(
+      payload,
+      this.agentId,
+      this.webCallingService.loginOption,
+      this.webRtcEnabled
+    );
+
+    const taskData: TaskData = {
+      ...payload,
+      isConsulted: isConsultedTask,
+      isAutoAnswering: shouldAutoAnswer,
+    };
+
+    const task = TaskFactory.createTask(
+      this.contact,
+      this.webCallingService,
+      taskData,
+      this.configFlags,
+      this.wrapupData,
+      this.agentId,
+      this.agentName,
+      this.answerCallOnWebexService,
+      this.apiAIAssistant
+    );
+
+    this.setupTaskListeners(task);
+    this.taskCollection[payload.interactionId] = task;
+
+    return {task};
   }
 
-  private registerTaskListeners() {
-    this.webSocketManager.on('message', (event) => {
-      const payload = JSON.parse(event);
-      // Re-emit the task events to the task object
-      let task: ITask;
-      if (payload.data?.type || payload.type) {
-        if (Object.values(CC_TASK_EVENTS).includes(payload.data.type || payload.type)) {
-          task =
-            this.taskCollection[payload.data?.interactionId] ||
-            this.taskCollection[payload.data?.data?.conversationId];
+  /**
+   * Handle AGENT_CONTACT event
+   * Re-creates task if missing (multi-session scenario)
+   */
+  private handleAgentContact(context: EventContext): TaskEventActions {
+    let {task} = context;
+    const {payload} = context;
+
+    if (!task) {
+      const isConsultedTask =
+        payload.isConsulted === true || isSecondaryEpDnAgent(payload.interaction);
+      const shouldAutoAnswer = shouldAutoAnswerTask(
+        payload,
+        this.agentId,
+        this.webCallingService.loginOption,
+        this.webRtcEnabled
+      );
+      const taskData: TaskData = {
+        ...payload,
+        isConsulted: isConsultedTask,
+        wrapUpRequired: payload.interaction?.participants?.[this.agentId]?.isWrapUp || false,
+        isConferenceInProgress: getIsConferenceInProgress(payload),
+        isAutoAnswering: shouldAutoAnswer,
+      };
+
+      task = TaskFactory.createTask(
+        this.contact,
+        this.webCallingService,
+        taskData,
+        this.configFlags,
+        this.wrapupData,
+        this.agentId,
+        this.agentName,
+        this.answerCallOnWebexService,
+        this.apiAIAssistant
+      );
+      this.setupTaskListeners(task);
+      this.taskCollection[payload.interactionId] = task;
+    }
+
+    return {task};
+  }
+
+  private updateTaskData(task: ITask, taskData: TaskData): ITask {
+    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,
         }
-        LoggerProxy.info(`Handling task event ${payload.data?.type}`, {
-          module: TASK_MANAGER_FILE,
-          method: METHODS.REGISTER_TASK_LISTENERS,
-          interactionId: payload.data?.interactionId,
-        });
-        switch (payload.data.type) {
-          case CC_EVENTS.AGENT_CONTACT:
-            // Case1 : Task is already present in taskCollection
-            if (this.taskCollection[payload.data.interactionId]) {
-              LoggerProxy.log(`Got AGENT_CONTACT: Task already exists in collection`, {
-                module: TASK_MANAGER_FILE,
-                method: METHODS.REGISTER_TASK_LISTENERS,
-                interactionId: payload.data.interactionId,
-              });
-              break;
-            } else if (!this.taskCollection[payload.data.interactionId]) {
-              // Case2 : Task is not present in taskCollection
-              LoggerProxy.log(`Got AGENT_CONTACT : Creating new task in taskManager`, {
-                module: TASK_MANAGER_FILE,
-                method: METHODS.REGISTER_TASK_LISTENERS,
-                interactionId: payload.data.interactionId,
-              });
-
-              // Check if auto-answer should happen for this task
-              const shouldAutoAnswer = shouldAutoAnswerTask(
-                payload.data,
-                this.agentId,
-                this.webCallingService.loginOption,
-                this.webRtcEnabled
-              );
-
-              task = new Task(
-                this.contact,
-                this.webCallingService,
-                {
-                  ...payload.data,
-                  wrapUpRequired:
-                    payload.data.interaction?.participants?.[this.agentId]?.isWrapUp || false,
-                  isConferenceInProgress: 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.log(
-                  `Got AGENT_CONTACT for a task with state=new, sending TASK_INCOMING event`,
-                  {
-                    module: TASK_MANAGER_FILE,
-                    method: METHODS.REGISTER_TASK_LISTENERS,
-                    interactionId: payload.data.interactionId,
-                  }
-                );
-                this.emit(TASK_EVENTS.TASK_INCOMING, task);
-              } else {
-                // Condition 2: The state is anything else i.e the task was connected
-                LoggerProxy.log(
-                  `Got AGENT_CONTACT for a task with state=${payload.data.interaction.state}, sending TASK_HYDRATE event`,
-                  {
-                    module: TASK_MANAGER_FILE,
-                    method: METHODS.REGISTER_TASK_LISTENERS,
-                    interactionId: payload.data.interactionId,
-                  }
-                );
-                this.emit(TASK_EVENTS.TASK_HYDRATE, task);
-              }
-            }
-            break;
-
-          case CC_EVENTS.AGENT_CONTACT_RESERVED: {
-            // Check if auto-answer should happen for this task
-            const shouldAutoAnswerReserved = shouldAutoAnswerTask(
-              payload.data,
-              this.agentId,
-              this.webCallingService.loginOption,
-              this.webRtcEnabled
-            );
+      : taskData;
 
-            task = new Task(
-              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 !== LoginOption.BROWSER ||
-              task.data.interaction.mediaType !== MEDIA_CHANNEL.TELEPHONY // for digital channels
-            ) {
-              this.emit(TASK_EVENTS.TASK_INCOMING, task);
-            } else if (this.call) {
-              this.emit(TASK_EVENTS.TASK_INCOMING, task);
-            }
-            break;
-          }
-          case 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.log(`Agent offer contact received for task`, {
-              module: TASK_MANAGER_FILE,
-              method: METHODS.REGISTER_TASK_LISTENERS,
-              interactionId: payload.data?.interactionId,
-            });
-            this.emit(TASK_EVENTS.TASK_OFFER_CONTACT, task);
-
-            // Handle auto-answer for offer contact
-            this.handleAutoAnswer(task);
-            break;
-          case CC_EVENTS.AGENT_OUTBOUND_FAILED:
-            if (task) {
-              task = this.updateTaskData(task, payload.data);
-              this.metricsManager.trackEvent(
-                METRIC_EVENT_NAMES.TASK_OUTDIAL_FAILED,
-                {
-                  ...MetricsManager.getCommonTrackingFieldForAQMResponse(payload.data),
-                  taskId: payload.data.interactionId,
-                  reason: payload.data.reasonCode || payload.data.reason,
-                },
-                ['behavioral', 'operational']
-              );
-              LoggerProxy.log(`Agent outbound failed for task`, {
-                module: TASK_MANAGER_FILE,
-                method: METHODS.REGISTER_TASK_LISTENERS,
-                interactionId: payload.data.interactionId,
-              });
-              task.emit(TASK_EVENTS.TASK_OUTDIAL_FAILED, payload.data.reason ?? 'UNKNOWN_REASON');
-            }
-            break;
-          case CC_EVENTS.AGENT_CONTACT_ASSIGNED:
-            // 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 && payload.data.reservationInteractionId) {
-              task = this.taskCollection[payload.data.reservationInteractionId];
-              if (task) {
-                // Re-key the task under the new interaction ID and remove the old entry
-                delete this.taskCollection[payload.data.reservationInteractionId];
-                this.taskCollection[payload.data.interactionId] = task;
-              }
-            }
-            if (task) {
-              task = this.updateTaskData(task, payload.data);
-              task.emit(TASK_EVENTS.TASK_ASSIGNED, task);
-            }
-            break;
-          case CC_EVENTS.AGENT_CONTACT_UNASSIGNED:
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              wrapUpRequired: true,
-            });
-            task.emit(TASK_EVENTS.TASK_END, task);
-            break;
-          case CC_EVENTS.AGENT_CONTACT_OFFER_RONA:
-          case CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED:
-          case CC_EVENTS.AGENT_INVITE_FAILED: {
-            LoggerProxy.warn(
-              `[DEBUG-CAMPAIGN-CLEAR] Task removal triggered by ${payload.data.type}, interactionId=${payload.data.interactionId}, taskType=${task?.data?.type}`,
-              {
-                module: TASK_MANAGER_FILE,
-                method: METHODS.REGISTER_TASK_LISTENERS,
-                interactionId: payload.data.interactionId,
-              }
-            );
-            task = this.updateTaskData(task, payload.data);
-
-            const eventTypeToMetricMap: Record<string, keyof typeof METRIC_EVENT_NAMES> = {
-              [CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED]: 'AGENT_CONTACT_ASSIGN_FAILED',
-              [CC_EVENTS.AGENT_INVITE_FAILED]: 'AGENT_INVITE_FAILED',
-            };
-            const metricEventName: keyof typeof METRIC_EVENT_NAMES =
-              eventTypeToMetricMap[payload.data.type] || 'AGENT_RONA';
-
-            this.metricsManager.trackEvent(
-              METRIC_EVENT_NAMES[metricEventName],
-              {
-                ...MetricsManager.getCommonTrackingFieldForAQMResponse(payload.data),
-                taskId: payload.data.interactionId,
-                reason: payload.data.reason,
-              },
-              ['behavioral', 'operational']
-            );
-            this.handleTaskCleanup(task);
-            task.emit(TASK_EVENTS.TASK_REJECT, payload.data.reason);
-            break;
-          }
-          case CC_EVENTS.CONTACT_ENDED:
-            // Update task data
-            if (task) {
-              LoggerProxy.warn(
-                `[DEBUG-CAMPAIGN-CLEAR] CONTACT_ENDED, interactionId=${payload.data.interactionId}, taskType=${task?.data?.type}, state=${task?.data?.interaction?.state}`,
-                {
-                  module: TASK_MANAGER_FILE,
-                  method: METHODS.REGISTER_TASK_LISTENERS,
-                  interactionId: payload.data.interactionId,
-                }
-              );
-              task = this.updateTaskData(task, {
-                ...payload.data,
-                wrapUpRequired: payload.data.agentsPendingWrapUp?.includes(this.agentId) || false,
-              });
-
-              // Handle cleanup based on whether task should be deleted
-              this.handleTaskCleanup(task);
-
-              task?.emit(TASK_EVENTS.TASK_END, task);
-            }
-            break;
-          case CC_EVENTS.CAMPAIGN_CONTACT_UPDATED:
-            // CampaignContactUpdated is a non-terminal event (intermediate update during accept).
-            // Only update the task data — do NOT remove the task or emit TASK_END.
-            // Task cleanup is handled by CONTACT_ENDED or other terminal events.
-            if (task) {
-              task = this.updateTaskData(task, payload.data);
-            }
-            break;
-          case CC_EVENTS.CONTACT_MERGED:
-            task = this.handleContactMerged(task, payload.data);
-            break;
-          case 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(TASK_EVENTS.TASK_HOLD, task);
-            break;
-          case 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(TASK_EVENTS.TASK_RESUME, task);
-            break;
-          case CC_EVENTS.AGENT_VTEAM_TRANSFERRED:
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              wrapUpRequired: true,
-            });
-            task.emit(TASK_EVENTS.TASK_END, task);
-            break;
-          case CC_EVENTS.AGENT_CTQ_CANCEL_FAILED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_CONSULT_QUEUE_FAILED, task);
-            break;
-          case 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(TASK_EVENTS.TASK_CONSULT_CREATED, task);
-            break;
-          case 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(TASK_EVENTS.TASK_OFFER_CONSULT, task);
-
-            // Handle auto-answer for consult offer
-            this.handleAutoAnswer(task);
-            break;
-          case 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(TASK_EVENTS.TASK_CONSULT_ACCEPTED, task);
-            } else {
-              // Fire only if you are the agent who initiated the consult
-              task.emit(TASK_EVENTS.TASK_CONSULTING, task);
-            }
-            break;
-          case 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 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(TASK_EVENTS.TASK_CONSULT_END, task);
-            break;
-          case 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(TASK_EVENTS.TASK_CONSULT_QUEUE_CANCELLED, task);
-            break;
-          case CC_EVENTS.AGENT_WRAPUP:
-            task = this.updateTaskData(task, {...payload.data, wrapUpRequired: true});
-            task.emit(TASK_EVENTS.TASK_END, task);
-            break;
-          case CC_EVENTS.AGENT_WRAPPEDUP:
-            task.cancelAutoWrapupTimer();
-            this.removeTaskFromCollection(task);
-            task.emit(TASK_EVENTS.TASK_WRAPPEDUP, task);
-            break;
-          case CC_EVENTS.CONTACT_RECORDING_PAUSED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_RECORDING_PAUSED, task);
-            break;
-          case CC_EVENTS.CONTACT_RECORDING_PAUSE_FAILED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_RECORDING_PAUSE_FAILED, task);
-            break;
-          case CC_EVENTS.CONTACT_RECORDING_RESUMED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_RECORDING_RESUMED, task);
-            break;
-          case CC_EVENTS.CONTACT_RECORDING_RESUME_FAILED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_RECORDING_RESUME_FAILED, task);
-            break;
-          case CC_EVENTS.AGENT_CONSULT_CONFERENCING:
-            // Conference is being established - update task state and emit establishing event
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_CONFERENCE_ESTABLISHING, task);
-            break;
-          case CC_EVENTS.AGENT_CONSULT_CONFERENCED:
-            // Conference started successfully - update task state and emit event
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
-            break;
-          case CC_EVENTS.AGENT_CONSULT_CONFERENCE_FAILED:
-            // Conference failed - update task state and emit failure event
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_CONFERENCE_FAILED, task);
-            break;
-          case CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED:
-            // Conference ended - update task state and emit event
-            task = this.updateTaskData(task, payload.data);
-            if (
-              !task ||
-              isPrimary(task, this.agentId) ||
-              isParticipantInMainInteraction(task, this.agentId)
-            ) {
-              LoggerProxy.log('Primary or main interaction participant leaving conference');
-            } else {
-              this.removeTaskFromCollection(task);
-            }
-            task.emit(TASK_EVENTS.TASK_CONFERENCE_ENDED, task);
-            break;
-          case CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE: {
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              isConferenceInProgress: getIsConferenceInProgress(payload.data),
-            });
-            task.emit(TASK_EVENTS.TASK_PARTICIPANT_JOINED, task);
-            break;
-          }
-          case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE: {
-            // Conference ended - update task state and emit event
-
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              isConferenceInProgress: getIsConferenceInProgress(payload.data),
-            });
-            if (checkParticipantNotInInteraction(task, this.agentId)) {
-              if (
-                isParticipantInMainInteraction(task, this.agentId) ||
-                isPrimary(task, this.agentId)
-              ) {
-                LoggerProxy.log('Primary or main interaction participant leaving conference');
-              } else {
-                this.removeTaskFromCollection(task);
-              }
-            }
-            task.emit(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
-            break;
-          }
-          case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE_FAILED:
-            // Conference exit failed - update task state and emit failure event
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_PARTICIPANT_LEFT_FAILED, task);
-            break;
-          case 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(TASK_EVENTS.TASK_CONFERENCE_END_FAILED, task);
-            break;
-          case 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(TASK_EVENTS.TASK_CONFERENCE_TRANSFERRED, task);
-            break;
-          case 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(TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED, task);
-            break;
-          case 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(TASK_EVENTS.TASK_POST_CALL_ACTIVITY, task);
-            break;
-          case CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION: {
-            // Campaign preview contact offered to agent
-            // Create a task in the collection so subsequent events (e.g. AGENT_CONTACT_ASSIGNED
-            // after acceptPreviewContact) can find and update it.
-            // Emit TASK_CAMPAIGN_PREVIEW_RESERVATION instead of TASK_INCOMING so the call
-            // does not ring out to the customer before the agent explicitly accepts the preview contact.
-            LoggerProxy.log('Campaign preview reservation received', {
+    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;
+    const enablement = this.pendingFeatureEnablement.get(task.data.interactionId);
+    if (enablement) {
+      task.setFeatureEnablement?.(enablement);
+    }
+
+    return task;
+  }
+
+  /**
+   * Setup listeners for task events that need to be bubbled up to TaskManager
+   * This replaces the previous callback injection pattern
+   */
+  private setupTaskListeners(task: ITask): void {
+    // Apply flags before publication; retain the frame until consumers can attach listeners.
+    const enablement = this.pendingFeatureEnablement.get(task.data.interactionId);
+    if (enablement) {
+      task.setFeatureEnablement?.(enablement);
+    }
+
+    [
+      TASK_EVENTS.TASK_INCOMING,
+      TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
+      TASK_EVENTS.TASK_HYDRATE,
+      TASK_EVENTS.TASK_ASSIGNED,
+    ].forEach((eventName) => {
+      task.on(eventName, (t: ITask) => {
+        if (
+          eventName === TASK_EVENTS.TASK_INCOMING ||
+          eventName === TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION
+        ) {
+          LoggerProxy.log(
+            eventName === TASK_EVENTS.TASK_INCOMING
+              ? 'Task incoming event received'
+              : 'Campaign preview reservation event received',
+            {
               module: TASK_MANAGER_FILE,
               method: METHODS.REGISTER_TASK_LISTENERS,
-              interactionId: payload.data.interactionId,
-            });
-
-            if (!this.taskCollection[payload.data.interactionId]) {
-              task = new Task(
-                this.contact,
-                this.webCallingService,
-                {
-                  ...payload.data,
-                  wrapUpRequired: false,
-                  isConferenceInProgress: false,
-                  isAutoAnswering: false,
-                },
-                this.wrapupData,
-                this.agentId
-              );
-              this.taskCollection[payload.data.interactionId] = task;
-            } else {
-              task = this.updateTaskData(task, payload.data);
+              interactionId: t.data?.interactionId,
             }
+          );
+        }
 
-            this.emit(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, task);
-            break;
-          }
-
-          default:
-            break;
+        // Assignment is already emitted on the task; the other events publish it to consumers.
+        if (eventName !== TASK_EVENTS.TASK_ASSIGNED) {
+          this.emit(eventName, t);
         }
-        if (task) {
-          task.emit(payload.data.type, payload.data);
+
+        const pendingEnablement = this.pendingFeatureEnablement.get(task.data.interactionId);
+        if (pendingEnablement) {
+          this.pendingFeatureEnablement.delete(task.data.interactionId);
+          task.emit(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, pendingEnablement);
         }
+      });
+    });
 
-        const transcriptInteractionId =
-          payload.data?.interactionId ||
-          payload.data?.data?.conversationId ||
-          task?.data?.interactionId;
+    task.on(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, (t: ITask) => {
+      this.emit(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, t);
+    });
 
-        if (TRANSCRIPT_EVENT_MAP[payload.data.type] && transcriptInteractionId) {
-          this.requestRealTimeTranscripts(payload.data.type, transcriptInteractionId);
+    // Listen for internal cleanup signal emitted by the state machine
+    task.on(TASK_EVENTS.TASK_CLEANUP, (t: ITask, options?: {removeFromCollection?: boolean}) => {
+      this.handleTaskCleanup(t);
+      if (options?.removeFromCollection) {
+        const taskIsStillCollected = Object.values(this.taskCollection).some(
+          (candidate) => candidate === t
+        );
+        if (taskIsStillCollected) {
+          this.removeTaskFromCollection(t);
         }
       }
     });
   }
 
-  private updateTaskData(task: ITask, taskData: TaskData): ITask {
-    if (!task) {
-      return undefined;
+  private removeTaskFromCollection(task: ITask) {
+    task.clearFeatureEnablement?.();
+    task.disposeWxAppOfferObservability?.();
+    if (typeof task.cancelAutoWrapupTimer === 'function') {
+      task.cancelAutoWrapupTimer();
     }
-
-    if (!taskData?.interactionId) {
-      LoggerProxy.warn('Received task update with missing interactionId', {
-        module: TASK_MANAGER_FILE,
-        method: METHODS.UPDATE_TASK_DATA,
+    if (task?.data?.interactionId) {
+      this.pendingFeatureEnablement.delete(task.data.interactionId);
+      // An offer that ends unanswered (RONA, declined, consult cancelled) is removed here,
+      // so its held receiving summary is dropped instead of being emitted.
+      this.receivingSummaryBuffer.delete(task.data.interactionId);
+      Object.entries(this.taskCollection).forEach(([taskId, candidate]) => {
+        if (candidate === task) {
+          delete this.taskCollection[taskId];
+        }
       });
-    }
-
-    try {
-      const currentTask = task.updateTaskData(taskData);
-      this.taskCollection[taskData.interactionId] = currentTask;
-
-      return currentTask;
-    } catch (error) {
-      LoggerProxy.error(`Failed to update task`, {
+      LoggerProxy.info(`Task removed from collection`, {
         module: TASK_MANAGER_FILE,
-        method: METHODS.UPDATE_TASK_DATA,
-        interactionId: taskData.interactionId,
+        method: METHODS.REMOVE_TASK_FROM_COLLECTION,
+        interactionId: task.data.interactionId,
       });
-
-      return task;
     }
   }
 
@@ -642,122 +1581,74 @@ export default class TaskManager extends EventEmitter {
    * @returns Updated or newly created task
    * @private
    */
-  private handleContactMerged(task: ITask, taskData: TaskData): ITask {
-    if (taskData.childInteractionId) {
-      // remove the child task from collection
-      this.removeTaskFromCollection(this.taskCollection[taskData.childInteractionId]);
+  private handleContactMergedEvent(context: EventContext): TaskEventActions {
+    const {payload} = context;
+    let task = context.task;
+
+    if (payload.childInteractionId && this.taskCollection[payload.childInteractionId]) {
+      this.removeTaskFromCollection(this.taskCollection[payload.childInteractionId]);
     }
 
-    if (this.taskCollection[taskData.interactionId]) {
+    if (task) {
       LoggerProxy.log(`Got CONTACT_MERGED: Task already exists in collection`, {
         module: TASK_MANAGER_FILE,
         method: METHODS.REGISTER_TASK_LISTENERS,
-        interactionId: taskData.interactionId,
+        interactionId: payload.interactionId,
       });
       // update the task data
-      task = this.updateTaskData(task, taskData);
+      this.updateTaskData(task, payload);
     } else {
       // Case2 : Task is not present in taskCollection
       LoggerProxy.log(`Got CONTACT_MERGED : Creating new task in taskManager`, {
         module: TASK_MANAGER_FILE,
         method: METHODS.REGISTER_TASK_LISTENERS,
-        interactionId: taskData.interactionId,
+        interactionId: payload.interactionId,
       });
 
-      task = new Task(
+      const taskData: TaskData = {
+        ...payload,
+        wrapUpRequired: payload.interaction?.participants?.[this.agentId]?.isWrapUp || false,
+        isConferenceInProgress: getIsConferenceInProgress(payload),
+        isConsulted: false,
+      };
+
+      task = TaskFactory.createTask(
         this.contact,
         this.webCallingService,
-        {
-          ...taskData,
-          wrapUpRequired: taskData.interaction?.participants?.[this.agentId]?.isWrapUp || false,
-          isConferenceInProgress: getIsConferenceInProgress(taskData),
-        },
+        taskData,
+        this.configFlags,
         this.wrapupData,
-        this.agentId
+        this.agentId,
+        this.agentName,
+        this.answerCallOnWebexService,
+        this.apiAIAssistant
       );
-      this.taskCollection[taskData.interactionId] = task;
-    }
+      this.taskCollection[payload.interactionId] = task;
 
-    this.emit(TASK_EVENTS.TASK_MERGED, task);
-
-    return task;
-  }
+      // 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: TaskEvent.HYDRATE,
+        taskData,
+        agentId: this.agentId,
+      } as TaskEventPayload);
 
-  private removeTaskFromCollection(task: ITask) {
-    if (task?.data?.interactionId) {
-      delete this.taskCollection[task.data.interactionId];
-      LoggerProxy.info(`Task removed from collection`, {
-        module: TASK_MANAGER_FILE,
-        method: METHODS.REMOVE_TASK_FROM_COLLECTION,
-        interactionId: task.data.interactionId,
-      });
+      this.setupTaskListeners(task);
     }
-  }
 
-  /**
-   * 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
-   * @private
-   */
-  private async handleAutoAnswer(task: ITask): Promise<void> {
-    if (!task || !task.data || !task.data.isAutoAnswering) {
-      return;
+    if (task) {
+      this.emit(TASK_EVENTS.TASK_MERGED, task);
+      const enablement = this.pendingFeatureEnablement.get(task.data.interactionId);
+      if (enablement) {
+        this.pendingFeatureEnablement.delete(task.data.interactionId);
+        task.emit(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, enablement);
+      }
     }
 
-    LoggerProxy.info(`Auto-answering task`, {
-      module: TASK_MANAGER_FILE,
-      method: 'handleAutoAnswer',
-      interactionId: task.data.interactionId,
-    });
-
-    try {
-      await task.accept();
-      LoggerProxy.info(`Task auto-answered successfully`, {
-        module: TASK_MANAGER_FILE,
-        method: 'handleAutoAnswer',
-        interactionId: task.data.interactionId,
-      });
-
-      // Track successful auto-answer
-      this.metricsManager.trackEvent(
-        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(TASK_EVENTS.TASK_AUTO_ANSWERED, task);
-    } catch (error) {
-      // Reset isAutoAnswering flag on failure
-      task.updateTaskData({...task.data, isAutoAnswering: false});
-      LoggerProxy.error(`Failed to auto-answer task`, {
-        module: TASK_MANAGER_FILE,
-        method: 'handleAutoAnswer',
-        interactionId: task.data.interactionId,
-        error,
-      });
-
-      // Track auto-answer failure
-      this.metricsManager.trackEvent(
-        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']
-      );
-    }
+    return {task};
   }
 
   /**
@@ -769,7 +1660,8 @@ export default class TaskManager extends EventEmitter {
     // Clean up Desktop/WebRTC calling resources for browser-based telephony tasks
     if (
       this.webCallingService.loginOption === LoginOption.BROWSER &&
-      task.data.interaction.mediaType === 'telephony'
+      task.data.interaction.mediaType === MEDIA_CHANNEL.TELEPHONY &&
+      task instanceof WebRTC
     ) {
       task.unregisterWebCallListeners();
       this.webCallingService.cleanUpCall();
@@ -797,12 +1689,8 @@ export default class TaskManager extends EventEmitter {
    */
   private requestRealTimeTranscripts(eventType: string, interactionId: string): void {
     const action = TRANSCRIPT_EVENT_MAP[eventType];
-    if (
-      !action ||
-      !this.apiAIAssistant ||
-      this.apiAIAssistant.aiFeature?.realtimeTranscripts?.enable === false
-    )
-      return;
+    if (!action || !this.apiAIAssistant) return;
+    if (this.configFlags?.aiFeature?.realtimeTranscripts?.enable !== true) return;
 
     this.apiAIAssistant
       .sendEvent(
@@ -810,12 +1698,12 @@ export default class TaskManager extends EventEmitter {
         interactionId,
         AIAssistantEventType.CUSTOM_EVENT,
         AIAssistantEventName.GET_TRANSCRIPTS,
-        action
+        {action}
       )
       .catch((error) => {
         LoggerProxy.error(`Failed to send transcript ${action} event`, {
           module: TASK_MANAGER_FILE,
-          method: 'requestRealTimeTranscripts',
+          method: METHODS.REQUEST_REAL_TIME_TRANSCRIPTS,
           interactionId,
           error,
         });
@@ -826,28 +1714,81 @@ export default class TaskManager extends EventEmitter {
     return this.taskCollection[taskId];
   }
 
+  public getAllTasks(): Record<TaskId, ITask> {
+    return {...this.taskCollection};
+  }
+
   /**
-   * @param taskId - Unique identifier for each task
+   * Propagate runtime enableWxBetterTogether changes to config flags and active tasks.
    */
-  public getAllTasks = (): Record<TaskId, ITask> => {
-    return this.taskCollection;
-  };
+  public applyEnableWxBetterTogether(enabled: boolean): void {
+    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.
+   */
+  public applyWxAppMuteStateFromSync(callId: string, muted: boolean): void {
+    Object.values(this.taskCollection).forEach((task) => {
+      task.applyWxAppMuteStateFromSync(callId, muted);
+    });
+  }
+
+  /**
+   * Re-seeds wxApp mute state from GET telephony/calls/{callId} for one task.
+   */
+  public static syncWxAppMuteFromCallDetailsForTask(task: ITask): void {
+    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).
+   */
+  public syncWxAppMuteFromCallDetailsForAllTasks(): void {
+    Object.values(this.taskCollection).forEach((task) => {
+      TaskManager.syncWxAppMuteFromCallDetailsForTask(task);
+    });
+  }
+
+  /**
+   * Re-run OFFERED wxApp offer diagnostics for collected voice tasks.
+   * Used after usersub publish so pre-publish offers can schedule mismatch grace.
+   */
+  public refreshWxAppOfferObservabilityForAllTasks(): void {
+    Object.values(this.taskCollection).forEach((task) => {
+      task.refreshWxAppOfferObservability?.();
+    });
+  }
 
   public static getTaskManager(
     apiAIAssistant: ApiAIAssistant,
     contact: ReturnType<typeof routingContact>,
     webCallingService: WebCallingService,
-    webSocketManager: WebSocketManager
+    webSocketManager: WebSocketManager,
+    rtdWebSocketManager?: WebSocketManager
   ): TaskManager {
     if (!TaskManager.taskManager) {
       TaskManager.taskManager = new TaskManager(
         apiAIAssistant,
         contact,
         webCallingService,
-        webSocketManager
+        webSocketManager,
+        rtdWebSocketManager
       );
     }
 
-    return this.taskManager;
+    return TaskManager.taskManager;
   }
 }