@webex/contact-center 3.12.0-task-refactor.11 → 3.12.0-task-refactor.12

package/test/unit/spec/services/task/TaskManager.ts

@@ -164,7 +164,19 @@ describe('TaskManager', () => {
   beforeEach(() => {
     contactMock = contact;
     webSocketManagerMock = new EventEmitter();
+<<<<<<< HEAD
     rtdWebSocketManagerMock = new EventEmitter();
+=======
+    mockApiAIAssistant = {
+      sendEvent: jest.fn().mockResolvedValue({}),
+      setAIFeatureFlags: jest.fn(),
+      aiFeature: {
+        realtimeTranscripts: {
+          enable: true,
+        },
+      },
+    };
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     webex = {
       logger: {
@@ -194,6 +206,7 @@ describe('TaskManager', () => {
     onSpy = jest.spyOn(webCallingService, 'on');
     offSpy = jest.spyOn(webCallingService, 'off');
 
+<<<<<<< HEAD
     mockApiAIAssistant = {
       sendEvent: jest.fn().mockResolvedValue({}),
     };
@@ -207,6 +220,26 @@ describe('TaskManager', () => {
     );
     taskManager.taskCollection[taskId] = createMockTask(taskDataMock);
     (taskManager as any).setupTaskListeners?.(taskManager.taskCollection[taskId]);
+=======
+    taskManager = new TaskManager(
+      mockApiAIAssistant,
+      contactMock,
+      webCallingService,
+      webSocketManagerMock
+    );
+    const taskMock = {
+      emit: jest.fn(),
+      accept: jest.fn(),
+      decline: jest.fn(),
+      updateTaskData: jest.fn().mockImplementation((updatedData) => {
+        taskMock.data = {...taskMock.data, ...updatedData};
+        return taskMock;
+      }),
+      data: taskDataMock,
+    };
+    taskManager.taskCollection[taskId] = taskMock;
+    taskManager.agentId = 'test-agent-id';
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     taskManager.call = mockCall;
     taskManager.setAgentId('test-agent-id');
 
@@ -233,8 +266,15 @@ describe('TaskManager', () => {
 
     incomingCallCb(mockCall);
 
+<<<<<<< HEAD
     expect(incomingHandler).toHaveBeenCalledWith(taskManager.getTask(taskId));
     taskManager.off(TASK_EVENTS.TASK_INCOMING, incomingHandler);
+=======
+    expect(taskEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_INCOMING,
+      taskManager.getTask(taskId)
+    );
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
   });
 
   it('should re-emit task related events', () => {
@@ -432,6 +472,106 @@ describe('TaskManager', () => {
     expect(existingTaskEmitSpy).not.toHaveBeenCalled();
   });
 
+  it('should invoke sendEvent for configured start/stop backend events', () => {
+    const message = (type: CC_EVENTS) =>
+      JSON.stringify({
+        data: {
+          ...taskDataMock,
+          taskId,
+          type,
+        },
+      });
+
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONTACT_ASSIGNED));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULTING));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULT_CONFERENCED));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULT_ENDED));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_WRAPUP));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE));
+
+    expect(mockApiAIAssistant.sendEvent).toHaveBeenCalledTimes(6);
+    expect(mockApiAIAssistant.sendEvent).toHaveBeenCalledWith(
+      'test-agent-id',
+      taskId,
+      'CUSTOM_EVENT',
+      'GET_TRANSCRIPTS',
+      'START'
+    );
+    expect(mockApiAIAssistant.sendEvent).toHaveBeenCalledWith(
+      'test-agent-id',
+      taskId,
+      'CUSTOM_EVENT',
+      'GET_TRANSCRIPTS',
+      'STOP'
+    );
+  });
+
+  it('should not invoke sendEvent for transcript events when realtime transcript feature is disabled', () => {
+    mockApiAIAssistant.aiFeature = {
+      realtimeTranscripts: {
+        enable: false,
+      },
+    };
+    mockApiAIAssistant.setAIFeatureFlags(mockApiAIAssistant.aiFeature);
+
+    const message = (type: CC_EVENTS) =>
+      JSON.stringify({
+        data: {
+          ...taskDataMock,
+          taskId,
+          type,
+        },
+      });
+
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONTACT_ASSIGNED));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULTING));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULT_CONFERENCED));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULT_ENDED));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_WRAPUP));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE));
+
+    expect(mockApiAIAssistant.sendEvent).not.toHaveBeenCalled();
+  });
+
+  it('should emit REAL_TIME_TRANSCRIPTION from task object', () => {
+    const task = taskManager.getTask(taskId);
+    const taskEmitSpy = jest.spyOn(task, 'emit');
+    const realtimePayload = {
+      data: {
+        ...taskDataMock,
+        type: CC_EVENTS.REAL_TIME_TRANSCRIPTION,
+        data: {
+          content: 'hello from transcript',
+        },
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(realtimePayload));
+
+    expect(taskEmitSpy).toHaveBeenCalledWith(
+      CC_EVENTS.REAL_TIME_TRANSCRIPTION,
+      realtimePayload.data
+    );
+  });
+
+  it('should emit REAL_TIME_TRANSCRIPTION from RTD websocket payload on task object', () => {
+    const task = taskManager.getTask(taskId);
+    const taskEmitSpy = jest.spyOn(task, 'emit');
+    const realtimePayload = {
+      data: {
+        notifType: CC_EVENTS.REAL_TIME_TRANSCRIPTION,
+        data: {
+          conversationId: taskId,
+          content: 'hello from rtd websocket',
+        },
+      },
+    };
+
+    taskManager.handleRealtimeWebsocketEvent(JSON.stringify(realtimePayload));
+
+    expect(taskEmitSpy).toHaveBeenCalledWith(CC_EVENTS.REAL_TIME_TRANSCRIPTION, realtimePayload.data);
+  });
+
   it('should not re-emit agent related events', () => {
     const dummyPayload = {
       data: {
@@ -673,6 +813,7 @@ describe('TaskManager', () => {
   it('test call listeners being switched off on call end', () => {
     webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
 
+<<<<<<< HEAD
     const webrtcTask = new WebRTC(contactMock, webCallingService, taskDataMock, {
       isEndTaskEnabled: true,
       isEndConsultEnabled: true,
@@ -695,6 +836,13 @@ describe('TaskManager', () => {
     });
 
     const webCallListenerSpy = jest.spyOn(task, 'unregisterWebCallListeners');
+=======
+    const taskEmitSpy = jest.spyOn(taskManager.getTask(taskId), 'emit');
+    const webCallListenerSpy = jest.spyOn(
+      taskManager.getTask(taskId),
+      'unregisterWebCallListeners'
+    );
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     const callOffSpy = jest.spyOn(mockCall, 'off');
     const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
     const payload = {
@@ -727,12 +875,18 @@ describe('TaskManager', () => {
     webSocketManagerMock.emit('message', JSON.stringify(hydratePayload));
 
     taskManager.getTask(taskId).data = payload.data;
+<<<<<<< HEAD
     webSocketManagerMock.emit('message', JSON.stringify(payload));
     const stateMachineEvent = expectLastStateMachineEvent(
       sendStateMachineEventSpy,
       TaskEvent.CONTACT_ENDED
     );
     expect(stateMachineEvent?.taskData.wrapUpRequired).toBe(false);
+=======
+    const task = taskManager.getTask(taskId);
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_END, task);
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     expect(webCallListenerSpy).toHaveBeenCalledWith();
     expect(callOffSpy).toHaveBeenCalledWith(
       CALL_EVENT_KEYS.REMOTE_MEDIA,
@@ -769,19 +923,29 @@ describe('TaskManager', () => {
 
     task.updateTaskData(payload.data);
     webSocketManagerMock.emit('message', JSON.stringify(payload));
+<<<<<<< HEAD
     const stateMachineEvent = expectLastStateMachineEvent(
       sendStateMachineEventSpy,
       TaskEvent.CONTACT_ENDED
     );
     expect(stateMachineEvent?.taskData.wrapUpRequired).toBe(true);
     sendStateMachineEventSpy.mockRestore();
+=======
+    expect(taskEmitSpy).toHaveBeenCalledWith(CC_EVENTS.CONTACT_ENDED, {...payload.data});
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_END, taskManager.getTask(taskId));
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
   });
 
   it('should emit TASK_REJECT event on AGENT_INVITE_FAILED event', () => {
     webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
 
+<<<<<<< HEAD
     const task = taskManager.getTask(taskId);
     const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+=======
+    const taskEmitSpy = jest.spyOn(taskManager.getTask(taskId), 'emit');
+    const metricsTrackSpy = jest.spyOn(taskManager.metricsManager, 'trackEvent');
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     const payload = {
       data: {
         type: CC_EVENTS.AGENT_INVITE_FAILED,
@@ -800,6 +964,7 @@ describe('TaskManager', () => {
       },
     };
 
+<<<<<<< HEAD
     task.updateTaskData(payload.data);
     webSocketManagerMock.emit('message', JSON.stringify(payload));
     const stateMachineEvent = expectLastStateMachineEvent(
@@ -811,6 +976,18 @@ describe('TaskManager', () => {
   });
 
   it('should emit TASK_HYDRATE even if task is already present in taskManager', () => {
+=======
+    taskManager.getTask(taskId).updateTaskData(payload.data);
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+    expect(taskEmitSpy).toHaveBeenCalledWith(CC_EVENTS.AGENT_INVITE_FAILED, {...payload.data});
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_REJECT, payload.data.reason);
+    // Verify the correct metric event name is used for AGENT_INVITE_FAILED
+    expect(metricsTrackSpy).toHaveBeenCalled();
+    expect(metricsTrackSpy.mock.calls[0][0]).toBe('Agent Invite Failed');
+  });
+
+  it('should not emit TASK_HYDRATE if task is already present in taskManager', () => {
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     const payload = {
       data: {
         ...initalPayload.data,
@@ -947,7 +1124,11 @@ describe('TaskManager', () => {
     expect(createdTask.data.isConferenceInProgress).toBe(false);
   });
 
+<<<<<<< HEAD
   it('should emit TASK_WRAPUP event on AGENT_WRAPUP event', () => {
+=======
+  it('should emit TASK_END event on AGENT_WRAPUP event', () => {
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
 
     const wrapupPayload = {
@@ -1102,8 +1283,13 @@ describe('TaskManager', () => {
 
       const task = taskManager.getTask(taskId);
       const taskEmitSpy = jest.spyOn(task, 'emit');
+<<<<<<< HEAD
       const taskAcceptSpy = jest.spyOn(task, 'accept').mockResolvedValue(undefined);
       const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+=======
+      const taskManagerEmitSpy = jest.spyOn(taskManager, 'emit');
+      const taskAcceptSpy = jest.spyOn(task, 'accept').mockResolvedValue(undefined);
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
       // Step 2: Trigger AGENT_OFFER_CONTACT with auto-answer
       const autoAnswerPayload = {
@@ -1127,6 +1313,7 @@ describe('TaskManager', () => {
       // Verify accept was called
       expect(taskAcceptSpy).toHaveBeenCalledTimes(1);
 
+<<<<<<< HEAD
       const stateMachineEvent = expectLastStateMachineEvent(
         sendStateMachineEventSpy,
         TaskEvent.TASK_OFFERED
@@ -1135,6 +1322,11 @@ describe('TaskManager', () => {
       // Verify task auto-answer event was emitted
       expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_AUTO_ANSWERED, task);
       sendStateMachineEventSpy.mockRestore();
+=======
+      // Verify BOTH events were emitted
+      expect(taskManagerEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_OFFER_CONTACT, task);
+      expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_AUTO_ANSWERED, task);
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     });
 
     it('should NOT emit TASK_AUTO_ANSWERED event when auto-answer fails', async () => {
@@ -1180,7 +1372,10 @@ describe('TaskManager', () => {
       const task = taskManager.getTask(taskId);
       const taskEmitSpy = jest.spyOn(task, 'emit');
       const taskAcceptSpy = jest.spyOn(task, 'accept').mockResolvedValue(undefined);
+<<<<<<< HEAD
       const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+=======
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
       // Step 2: Trigger AGENT_OFFER_CONSULT with auto-answer
       const consultAutoAnswerPayload = {
@@ -1205,6 +1400,7 @@ describe('TaskManager', () => {
       // Verify accept was called
       expect(taskAcceptSpy).toHaveBeenCalledTimes(1);
 
+<<<<<<< HEAD
       const stateMachineEvent = expectLastStateMachineEvent(
         sendStateMachineEventSpy,
         TaskEvent.OFFER_CONSULT
@@ -1214,11 +1410,18 @@ describe('TaskManager', () => {
         isConsulted: true,
       });
       // Verify task auto-answer event was emitted
+=======
+      // Verify BOTH events were emitted
+      expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_OFFER_CONSULT, task);
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
       expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_AUTO_ANSWERED, task);
 
       // Verify isConsulted flag is set correctly
       expect(task.data.isConsulted).toBe(true);
+<<<<<<< HEAD
       sendStateMachineEventSpy.mockRestore();
+=======
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     });
 
     it('should NOT emit TASK_AUTO_ANSWERED when isAutoAnswering is false', async () => {
@@ -1259,6 +1462,7 @@ describe('TaskManager', () => {
     });
   });
 
+<<<<<<< HEAD
   it('should remove OUTDIAL task from taskCollection on AGENT_OUTBOUND_FAILED when terminated', () => {
     const task = taskManager.getTask(taskId);
     Object.assign(task.data, {
@@ -1273,6 +1477,26 @@ describe('TaskManager', () => {
     task.unregisterWebCallListeners = jest.fn();
     const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
     const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+=======
+  it('should NOT remove OUTDIAL task from taskCollection on AGENT_OUTBOUND_FAILED when terminated (wrap-up flow)', () => {
+    const task = taskManager.getTask(taskId);
+    task.updateTaskData = jest.fn().mockImplementation((newData) => {
+      task.data = {
+        ...task.data,
+        ...newData,
+        interaction: {
+          ...task.data.interaction,
+          ...newData.interaction,
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          isTerminated: true,
+        },
+      };
+      return task;
+    });
+    task.unregisterWebCallListeners = jest.fn();
+    const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     const payload = {
       data: {
@@ -1285,7 +1509,10 @@ describe('TaskManager', () => {
           state: 'new',
           isTerminated: true,
         },
+<<<<<<< HEAD
         agentsPendingWrapUp: ['agent-123'],
+=======
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
         interactionId: taskId,
         orgId: '6ecef209-9a34-4ed1-a07a-7ddd1dbe925a',
         trackingId: '575c0ec2-618c-42af-a61c-53aeb0a221ee',
@@ -1299,62 +1526,26 @@ describe('TaskManager', () => {
     };
 
     webSocketManagerMock.emit('message', JSON.stringify(payload));
+<<<<<<< HEAD
+=======
 
-    webSocketManagerMock.emit('message', JSON.stringify(payload));
-
-    expect(taskManager.getTask(taskId)).toBeUndefined();
-    expect(removeTaskSpy).toHaveBeenCalled();
-    const stateMachineEvent = expectLastStateMachineEvent(
-      sendStateMachineEventSpy,
-      TaskEvent.OUTBOUND_FAILED
-    );
-    expect(stateMachineEvent?.reason).toBe('CUSTOMER_BUSY');
-    sendStateMachineEventSpy.mockRestore();
+    expect(taskManager.getTask(taskId)).toBeDefined();
+    expect(removeTaskSpy).not.toHaveBeenCalled();
   });
 
   it('should emit TASK_OUTDIAL_FAILED event on AGENT_OUTBOUND_FAILED', () => {
     const task = taskManager.getTask(taskId);
-    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
-    const payload = {
-      data: {
-        type: CC_EVENTS.AGENT_OUTBOUND_FAILED,
-        interactionId: taskId,
-        reason: 'CUSTOMER_BUSY',
-      },
-    };
-    webSocketManagerMock.emit('message', JSON.stringify(payload));
-    const stateMachineEvent = expectLastStateMachineEvent(
-      sendStateMachineEventSpy,
-      TaskEvent.OUTBOUND_FAILED
-    );
-    expect(stateMachineEvent?.reason).toBe('CUSTOMER_BUSY');
-    sendStateMachineEventSpy.mockRestore();
-  });
-
-  it('should pass taskData in OUTBOUND_FAILED event for shouldWrapUp guard evaluation', () => {
-    const task = taskManager.getTask(taskId);
-    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+    task.updateTaskData = jest.fn().mockReturnValue(task);
+    const taskEmitSpy = jest.spyOn(task, 'emit');
     const payload = {
       data: {
         type: CC_EVENTS.AGENT_OUTBOUND_FAILED,
         interactionId: taskId,
         reason: 'CUSTOMER_BUSY',
-        agentsPendingWrapUp: ['agent-123'],
-        interaction: {
-          outboundType: 'OUTDIAL',
-          isTerminated: true,
-        },
       },
     };
     webSocketManagerMock.emit('message', JSON.stringify(payload));
-    const stateMachineEvent = expectLastStateMachineEvent(
-      sendStateMachineEventSpy,
-      TaskEvent.OUTBOUND_FAILED
-    );
-    expect(stateMachineEvent?.taskData).toBeDefined();
-    expect(stateMachineEvent?.taskData?.agentsPendingWrapUp).toEqual(['agent-123']);
-    expect(stateMachineEvent?.taskData?.interaction?.outboundType).toBe('OUTDIAL');
-    sendStateMachineEventSpy.mockRestore();
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_OUTDIAL_FAILED, 'CUSTOMER_BUSY');
   });
 
   it('should handle AGENT_OUTBOUND_FAILED gracefully when task is undefined', () => {
@@ -1372,15 +1563,23 @@ describe('TaskManager', () => {
   });
 
   it('should NOT remove OUTDIAL task on CONTACT_ENDED when agentsPendingWrapUp exists', () => {
+    const agentId = '723a8ffb-a26e-496d-b14a-ff44fb83b64f';
+    taskManager.setAgentId(agentId);
+
     const task = taskManager.getTask(taskId);
-    Object.assign(task.data, {
-      interaction: {
-        ...task.data.interaction,
-        outboundType: 'OUTDIAL',
-        state: 'new',
-        mediaType: 'telephony',
-      },
-      agentsPendingWrapUp: ['agent-123'],
+    task.updateTaskData = jest.fn().mockImplementation((newData) => {
+      task.data = {
+        ...task.data,
+        ...newData,
+        interaction: {
+          ...task.data.interaction,
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        agentsPendingWrapUp: [agentId],
+      };
+      return task;
     });
     task.unregisterWebCallListeners = jest.fn();
     const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
@@ -1394,7 +1593,7 @@ describe('TaskManager', () => {
           state: 'new',
           mediaType: 'telephony',
         },
-        agentsPendingWrapUp: ['agent-123'],
+        agentsPendingWrapUp: [agentId],
       },
     };
 
@@ -1406,14 +1605,19 @@ describe('TaskManager', () => {
 
   it('should remove OUTDIAL task on CONTACT_ENDED when agentsPendingWrapUp is empty', () => {
     const task = taskManager.getTask(taskId);
-    Object.assign(task.data, {
-      interaction: {
-        ...task.data.interaction,
-        outboundType: 'OUTDIAL',
-        state: 'new',
-        mediaType: 'telephony',
-      },
-      agentsPendingWrapUp: [],
+    task.updateTaskData = jest.fn().mockImplementation((newData) => {
+      task.data = {
+        ...task.data,
+        ...newData,
+        interaction: {
+          ...task.data.interaction,
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        agentsPendingWrapUp: [],
+      };
+      return task;
     });
     task.unregisterWebCallListeners = jest.fn();
     const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
@@ -1438,13 +1642,19 @@ describe('TaskManager', () => {
 
   it('should remove OUTDIAL task on CONTACT_ENDED when agentsPendingWrapUp is undefined', () => {
     const task = taskManager.getTask(taskId);
-    Object.assign(task.data, {
-      interaction: {
-        ...task.data.interaction,
-        outboundType: 'OUTDIAL',
-        state: 'new',
-        mediaType: 'telephony',
-      },
+    task.updateTaskData = jest.fn().mockImplementation((newData) => {
+      task.data = {
+        ...task.data,
+        ...newData,
+        interaction: {
+          ...task.data.interaction,
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        // agentsPendingWrapUp is undefined
+      };
+      return task;
     });
     task.unregisterWebCallListeners = jest.fn();
     const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
@@ -1483,131 +1693,666 @@ describe('TaskManager', () => {
     }).not.toThrow();
   });
 
-  it('should remove OUTDIAL task from taskCollection on AGENT_CONTACT_ASSIGN_FAILED when NOT terminated (user-declined)', () => {
-    const task = taskManager.getTask(taskId);
-    Object.assign(task.data, {
-      interaction: {
-        ...task.data.interaction,
-        outboundType: 'OUTDIAL',
-        state: 'new',
-        isTerminated: false,
-      },
-    });
-    task.unregisterWebCallListeners = jest.fn();
-    const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+  describe('wrapUpRequired logic in CONTACT_ENDED event', () => {
+    const agentId = '723a8ffb-a26e-496d-b14a-ff44fb83b64f';
 
-    const payload = {
-      data: {
-        type: CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED,
-        agentId: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
-        eventTime: 1733211616959,
-        eventType: 'RoutingMessage',
-        interaction: {
-          outboundType: 'OUTDIAL',
-          state: 'new',
-          isTerminated: false,
-        },
-        interactionId: taskId,
-        orgId: '6ecef209-9a34-4ed1-a07a-7ddd1dbe925a',
-        trackingId: '575c0ec2-618c-42af-a61c-53aeb0a221ee',
-        mediaResourceId: '0ae913a4-c857-4705-8d49-76dd3dde75e4',
-        destAgentId: 'ebeb893b-ba67-4f36-8418-95c7492b28c2',
-        owner: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
-        queueMgr: 'aqm',
-        reason: 'USER_DECLINED',
-        reasonCode: 156,
-      },
-    };
+    beforeEach(() => {
+      // Set the agent ID on taskManager
+      taskManager.setAgentId(agentId);
+    });
 
-    webSocketManagerMock.emit('message', JSON.stringify(payload));
+    it('should set wrapUpRequired to true when agent is in agentsPendingWrapUp array for non-campaign tasks', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
 
-    expect(taskManager.getTask(taskId)).toBeUndefined();
-    expect(removeTaskSpy).toHaveBeenCalled();
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'connected',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId, 'other-agent-id'],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.updateTaskData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          wrapUpRequired: true,
+        })
+      );
+    });
+
+    it('should set wrapUpRequired to false when agent is not in agentsPendingWrapUp array', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'connected',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: ['other-agent-id', 'another-agent-id'],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.updateTaskData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          wrapUpRequired: false,
+        })
+      );
+    });
+
+    it('should set wrapUpRequired to false when agentsPendingWrapUp is an empty array', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'connected',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.updateTaskData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          wrapUpRequired: false,
+        })
+      );
+    });
+
+    it('should set wrapUpRequired to false when agentsPendingWrapUp is undefined', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'connected',
+            mediaType: 'telephony',
+          },
+          // agentsPendingWrapUp is not defined
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.updateTaskData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          wrapUpRequired: false,
+        })
+      );
+    });
+
+    it('should set wrapUpRequired to false when agentsPendingWrapUp is null', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'connected',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: null,
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.updateTaskData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          wrapUpRequired: false,
+        })
+      );
+    });
+
+    it('should set wrapUpRequired to true when agent is the only one in agentsPendingWrapUp for non-campaign tasks', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'connected',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.updateTaskData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          wrapUpRequired: true,
+        })
+      );
+    });
+
+    it('should set wrapUpRequired to true for different interaction states when agent is in agentsPendingWrapUp for non-campaign tasks', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+          interaction: {
+            ...task.data.interaction,
+            ...newData.interaction,
+          },
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+
+      // Test with 'connected' state
+      const payloadConnected = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'connected',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payloadConnected));
+
+      expect(task.updateTaskData).toHaveBeenNthCalledWith(
+        1,
+        expect.objectContaining({
+          wrapUpRequired: true,
+        })
+      );
+
+      // Test with 'held' state to verify it still works regardless of state
+      const payloadHeld = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'held',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payloadHeld));
+
+      expect(task.updateTaskData).toHaveBeenNthCalledWith(
+        2,
+        expect.objectContaining({
+          wrapUpRequired: true,
+        })
+      );
+    });
+
+    it('should set wrapUpRequired to false for campaign preview tasks even when agent is in agentsPendingWrapUp', () => {
+      const task = taskManager.getTask(taskId);
+      // Set up task as a campaign preview task via outboundType
+      task.data.interaction = {
+        ...task.data.interaction,
+        outboundType: 'STANDARD_PREVIEW_CAMPAIGN',
+      };
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'connected',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.updateTaskData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          wrapUpRequired: false,
+        })
+      );
+    });
   });
 
-  it('handle AGENT_OFFER_CONSULT event', () => {
+  it('should remove OUTDIAL task from taskCollection on AGENT_CONTACT_ASSIGN_FAILED when NOT terminated (user-declined)', () => {
+    const task = taskManager.getTask(taskId);
+    task.updateTaskData = jest.fn().mockImplementation((newData) => {
+      task.data = {
+        ...task.data,
+        ...newData,
+        interaction: {
+          ...task.data.interaction,
+          ...newData.interaction,
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          isTerminated: false,
+        },
+      };
+      return task;
+    });
+    task.unregisterWebCallListeners = jest.fn();
+    const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
     const payload = {
       data: {
-        ...initalPayload.data,
-        type: CC_EVENTS.AGENT_OFFER_CONSULT,
+        type: CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED,
+        agentId: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
+        eventTime: 1733211616959,
+        eventType: 'RoutingMessage',
+        interaction: {
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          isTerminated: false,
+        },
+        interactionId: taskId,
+        orgId: '6ecef209-9a34-4ed1-a07a-7ddd1dbe925a',
+        trackingId: '575c0ec2-618c-42af-a61c-53aeb0a221ee',
+        mediaResourceId: '0ae913a4-c857-4705-8d49-76dd3dde75e4',
+        destAgentId: 'ebeb893b-ba67-4f36-8418-95c7492b28c2',
+        owner: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
+        queueMgr: 'aqm',
+        reason: 'USER_DECLINED',
+        reasonCode: 156,
       },
     };
-
-    webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
-    const task = taskManager.getTask(taskId);
-    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     webSocketManagerMock.emit('message', JSON.stringify(payload));
 
+    expect(taskManager.getTask(taskId)).toBeUndefined();
+    expect(removeTaskSpy).toHaveBeenCalled();
+<<<<<<< HEAD
     const stateMachineEvent = expectLastStateMachineEvent(
       sendStateMachineEventSpy,
-      TaskEvent.OFFER_CONSULT
+      TaskEvent.OUTBOUND_FAILED
     );
-    expect(stateMachineEvent?.taskData).toEqual({...payload.data, isConsulted: true});
+    expect(stateMachineEvent?.reason).toBe('CUSTOMER_BUSY');
     sendStateMachineEventSpy.mockRestore();
   });
 
-  it('should emit TASK_CONSULT_ACCEPTED event on AGENT_CONSULTING event', () => {
-    const initialConsultingPayload = {
-      data: {
-        ...initalPayload.data,
-        type: CC_EVENTS.AGENT_OFFER_CONSULT,
-      },
-    };
-
-    const consultingPayload = {
+  it('should emit TASK_OUTDIAL_FAILED event on AGENT_OUTBOUND_FAILED', () => {
+    const task = taskManager.getTask(taskId);
+    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+    const payload = {
       data: {
-        ...initalPayload.data,
-        type: CC_EVENTS.AGENT_CONSULTING,
+        type: CC_EVENTS.AGENT_OUTBOUND_FAILED,
+        interactionId: taskId,
+        reason: 'CUSTOMER_BUSY',
       },
     };
-
-    webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
-
-    const task = taskManager.getTask(taskId);
-    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
-
-    webSocketManagerMock.emit('message', JSON.stringify(initialConsultingPayload));
-    webSocketManagerMock.emit('message', JSON.stringify(consultingPayload));
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
     const stateMachineEvent = expectLastStateMachineEvent(
       sendStateMachineEventSpy,
-      TaskEvent.CONSULTING_ACTIVE
+      TaskEvent.OUTBOUND_FAILED
     );
-    expect(stateMachineEvent?.taskData).toEqual(consultingPayload.data);
+    expect(stateMachineEvent?.reason).toBe('CUSTOMER_BUSY');
     sendStateMachineEventSpy.mockRestore();
   });
 
-  it('should emit TASK_CONSULT_ENDED event on AGENT_CONSULT_ENDED event', () => {
+  it('should pass taskData in OUTBOUND_FAILED event for shouldWrapUp guard evaluation', () => {
+    const task = taskManager.getTask(taskId);
+    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
     const payload = {
       data: {
-        ...initalPayload.data,
-        type: CC_EVENTS.AGENT_CONSULT_ENDED,
+        type: CC_EVENTS.AGENT_OUTBOUND_FAILED,
+        interactionId: taskId,
+        reason: 'CUSTOMER_BUSY',
+        agentsPendingWrapUp: ['agent-123'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        },
       },
     };
-
-    webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
-    taskManager.getTask(taskId).data.isConsulted = true;
-    const task = taskManager.getTask(taskId);
-    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
     webSocketManagerMock.emit('message', JSON.stringify(payload));
     const stateMachineEvent = expectLastStateMachineEvent(
       sendStateMachineEventSpy,
-      TaskEvent.CONSULT_END
+      TaskEvent.OUTBOUND_FAILED
     );
-    expect(stateMachineEvent?.taskData).toEqual(payload.data);
+    expect(stateMachineEvent?.taskData).toBeDefined();
+    expect(stateMachineEvent?.taskData?.agentsPendingWrapUp).toEqual(['agent-123']);
+    expect(stateMachineEvent?.taskData?.interaction?.outboundType).toBe('OUTDIAL');
     sendStateMachineEventSpy.mockRestore();
   });
 
-  it('should emit TASK_CONSULT_ENDED event and remove currentTask when on AGENT_CONSULT_ENDED event when requested for a consult', () => {
+  it('should handle AGENT_OUTBOUND_FAILED gracefully when task is undefined', () => {
     const payload = {
       data: {
-        ...initalPayload.data,
-        type: CC_EVENTS.AGENT_CONSULT_ENDED,
+        type: CC_EVENTS.AGENT_OUTBOUND_FAILED,
+        interactionId: 'non-existent-task-id',
+        reason: 'CUSTOMER_BUSY',
       },
     };
-
-    webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
-
+    // Should not throw error when task doesn't exist
+    expect(() => {
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+    }).not.toThrow();
+  });
+
+  it('should NOT remove OUTDIAL task on CONTACT_ENDED when agentsPendingWrapUp exists', () => {
+    const task = taskManager.getTask(taskId);
+    Object.assign(task.data, {
+      interaction: {
+        ...task.data.interaction,
+        outboundType: 'OUTDIAL',
+        state: 'new',
+        mediaType: 'telephony',
+      },
+      agentsPendingWrapUp: ['agent-123'],
+    });
+    task.unregisterWebCallListeners = jest.fn();
+    const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+    const payload = {
+      data: {
+        type: CC_EVENTS.CONTACT_ENDED,
+        interactionId: taskId,
+        interaction: {
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        agentsPendingWrapUp: ['agent-123'],
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+    expect(removeTaskSpy).not.toHaveBeenCalled();
+    expect(taskManager.getTask(taskId)).toBeDefined();
+  });
+
+  it('should remove OUTDIAL task on CONTACT_ENDED when agentsPendingWrapUp is empty', () => {
+    const task = taskManager.getTask(taskId);
+    Object.assign(task.data, {
+      interaction: {
+        ...task.data.interaction,
+        outboundType: 'OUTDIAL',
+        state: 'new',
+        mediaType: 'telephony',
+      },
+      agentsPendingWrapUp: [],
+    });
+    task.unregisterWebCallListeners = jest.fn();
+    const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+    const payload = {
+      data: {
+        type: CC_EVENTS.CONTACT_ENDED,
+        interactionId: taskId,
+        interaction: {
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        agentsPendingWrapUp: [],
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+    expect(removeTaskSpy).toHaveBeenCalled();
+  });
+
+  it('should remove OUTDIAL task on CONTACT_ENDED when agentsPendingWrapUp is undefined', () => {
+    const task = taskManager.getTask(taskId);
+    Object.assign(task.data, {
+      interaction: {
+        ...task.data.interaction,
+        outboundType: 'OUTDIAL',
+        state: 'new',
+        mediaType: 'telephony',
+      },
+    });
+    task.unregisterWebCallListeners = jest.fn();
+    const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+    const payload = {
+      data: {
+        type: CC_EVENTS.CONTACT_ENDED,
+        interactionId: taskId,
+        interaction: {
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        // agentsPendingWrapUp not included
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+    expect(removeTaskSpy).toHaveBeenCalled();
+  });
+
+  it('should handle CONTACT_ENDED gracefully when task is undefined', () => {
+    const payload = {
+      data: {
+        type: CC_EVENTS.CONTACT_ENDED,
+        interactionId: 'non-existent-task-id',
+        interaction: {
+          state: 'new',
+        },
+      },
+    };
+    // Should not throw error when task doesn't exist
+    expect(() => {
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+    }).not.toThrow();
+  });
+
+  it('should remove OUTDIAL task from taskCollection on AGENT_CONTACT_ASSIGN_FAILED when NOT terminated (user-declined)', () => {
+    const task = taskManager.getTask(taskId);
+    Object.assign(task.data, {
+      interaction: {
+        ...task.data.interaction,
+        outboundType: 'OUTDIAL',
+        state: 'new',
+        isTerminated: false,
+      },
+    });
+    task.unregisterWebCallListeners = jest.fn();
+    const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+    const payload = {
+      data: {
+        type: CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED,
+        agentId: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
+        eventTime: 1733211616959,
+        eventType: 'RoutingMessage',
+        interaction: {
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          isTerminated: false,
+        },
+        interactionId: taskId,
+        orgId: '6ecef209-9a34-4ed1-a07a-7ddd1dbe925a',
+        trackingId: '575c0ec2-618c-42af-a61c-53aeb0a221ee',
+        mediaResourceId: '0ae913a4-c857-4705-8d49-76dd3dde75e4',
+        destAgentId: 'ebeb893b-ba67-4f36-8418-95c7492b28c2',
+        owner: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
+        queueMgr: 'aqm',
+        reason: 'USER_DECLINED',
+        reasonCode: 156,
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+    expect(taskManager.getTask(taskId)).toBeUndefined();
+    expect(removeTaskSpy).toHaveBeenCalled();
+=======
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
+  });
+
+  it('handle AGENT_OFFER_CONSULT event', () => {
+    const payload = {
+      data: {
+        ...initalPayload.data,
+        type: CC_EVENTS.AGENT_OFFER_CONSULT,
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
+    const task = taskManager.getTask(taskId);
+    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+    const stateMachineEvent = expectLastStateMachineEvent(
+      sendStateMachineEventSpy,
+      TaskEvent.OFFER_CONSULT
+    );
+    expect(stateMachineEvent?.taskData).toEqual({...payload.data, isConsulted: true});
+    sendStateMachineEventSpy.mockRestore();
+  });
+
+  it('should emit TASK_CONSULT_ACCEPTED event on AGENT_CONSULTING event', () => {
+    const initialConsultingPayload = {
+      data: {
+        ...initalPayload.data,
+        type: CC_EVENTS.AGENT_OFFER_CONSULT,
+      },
+    };
+
+    const consultingPayload = {
+      data: {
+        ...initalPayload.data,
+        type: CC_EVENTS.AGENT_CONSULTING,
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
+
+    const task = taskManager.getTask(taskId);
+    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+
+    webSocketManagerMock.emit('message', JSON.stringify(initialConsultingPayload));
+    webSocketManagerMock.emit('message', JSON.stringify(consultingPayload));
+    const stateMachineEvent = expectLastStateMachineEvent(
+      sendStateMachineEventSpy,
+      TaskEvent.CONSULTING_ACTIVE
+    );
+    expect(stateMachineEvent?.taskData).toEqual(consultingPayload.data);
+    sendStateMachineEventSpy.mockRestore();
+  });
+
+  it('should emit TASK_CONSULT_ENDED event on AGENT_CONSULT_ENDED event', () => {
+    const payload = {
+      data: {
+        ...initalPayload.data,
+        type: CC_EVENTS.AGENT_CONSULT_ENDED,
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
+    taskManager.getTask(taskId).data.isConsulted = true;
+    const task = taskManager.getTask(taskId);
+    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+<<<<<<< HEAD
+    const stateMachineEvent = expectLastStateMachineEvent(
+      sendStateMachineEventSpy,
+      TaskEvent.CONSULT_END
+    );
+    expect(stateMachineEvent?.taskData).toEqual(payload.data);
+    sendStateMachineEventSpy.mockRestore();
+=======
+    expect(taskUpdateTaskDataSpy).toHaveBeenCalledWith(payload.data);
+    expect(taskEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_CONSULT_END,
+      taskManager.getTask(taskId)
+    );
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
+  });
+
+  it('should emit TASK_CONSULT_ENDED event and remove currentTask when on AGENT_CONSULT_ENDED event when requested for a consult', () => {
+    const payload = {
+      data: {
+        ...initalPayload.data,
+        type: CC_EVENTS.AGENT_CONSULT_ENDED,
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
+
     taskManager.getTask(taskId).data.isConsulted = true;
     const task = taskManager.getTask(taskId);
 
@@ -1775,12 +2520,23 @@ describe('TaskManager', () => {
 
     webSocketManagerMock.emit('message', JSON.stringify(assignFailedPayload));
 
+<<<<<<< HEAD
     const stateMachineEvent = expectLastStateMachineEvent(
       sendStateMachineEventSpy,
       TaskEvent.ASSIGN_FAILED
     );
     expect(stateMachineEvent?.reason).toBe(assignFailedPayload.data.reason);
     sendStateMachineEventSpy.mockRestore();
+=======
+    expect(taskUpdateDataSpy).toHaveBeenCalledWith(assignFailedPayload.data);
+    expect(taskEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_REJECT,
+      assignFailedPayload.data.reason
+    );
+    // Verify the correct metric event name is used for AGENT_CONTACT_ASSIGN_FAILED
+    expect(metricsTrackSpy).toHaveBeenCalled();
+    expect(metricsTrackSpy.mock.calls[0][0]).toBe('Agent Contact Assign Failed');
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
   });
 
   it('should remove currentTask from taskCollection on AGENT_WRAPPEDUP event', () => {
@@ -1855,12 +2611,20 @@ describe('TaskManager', () => {
       },
     };
     webSocketManagerMock.emit('message', JSON.stringify(consultingPayload));
+<<<<<<< HEAD
     expectLastStateMachineEvent(sendStateMachineEventSpy, TaskEvent.CONSULTING_ACTIVE);
     expect(taskManagerEmitSpy).toHaveBeenCalledWith(
       TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
       taskManager.getTask(taskId)
     );
     sendStateMachineEventSpy.mockRestore();
+=======
+    expect(taskEmitSpy).toHaveBeenCalledWith(CC_EVENTS.AGENT_CONSULTING, consultingPayload.data);
+    expect(taskEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_CONSULTING,
+      taskManager.getTask(taskId)
+    );
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
   });
 
   it('should update task data on AGENT_CONTACT_UNASSIGNED', () => {
@@ -1887,6 +2651,7 @@ describe('TaskManager', () => {
       },
     };
     webSocketManagerMock.emit('message', JSON.stringify(unassignedPayload));
+<<<<<<< HEAD
     expect(sendStateMachineEventSpy).not.toHaveBeenCalled();
     expect(updateTaskDataSpy).toHaveBeenCalledWith(unassignedPayload.data);
   });
@@ -1957,6 +2722,13 @@ describe('TaskManager', () => {
         destinationType: null,
       })
     );
+=======
+    expect(taskEmitSpy).toHaveBeenCalledWith(
+      CC_EVENTS.AGENT_CONTACT_UNASSIGNED,
+      unassignedPayload.data
+    );
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_END, taskManager.getTask(taskId));
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
   });
 
   it('should handle chat interaction and emit TASK_INCOMING immediately', () => {
@@ -1968,6 +2740,11 @@ describe('TaskManager', () => {
       },
     };
 
+<<<<<<< HEAD
+=======
+    const taskIncomingSpy = jest.spyOn(taskManager, 'emit');
+
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     // Simulate receiving a chat task
     webSocketManagerMock.emit('message', JSON.stringify(chatPayload));
 
@@ -1990,6 +2767,11 @@ describe('TaskManager', () => {
       },
     };
 
+<<<<<<< HEAD
+=======
+    const taskIncomingSpy = jest.spyOn(taskManager, 'emit');
+
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     // Simulate receiving an email task
     webSocketManagerMock.emit('message', JSON.stringify(emailPayload));
 
@@ -2013,11 +2795,21 @@ describe('TaskManager', () => {
       },
     };
 
+<<<<<<< HEAD
     webSocketManagerMock.emit('message', JSON.stringify(chatReservedPayload));
     const task = taskManager.getTask(chatReservedPayload.data.interactionId);
     const sendStateMachineEventSpy = task.sendStateMachineEvent as jest.Mock;
 
     expectLastStateMachineEvent(sendStateMachineEventSpy, TaskEvent.TASK_INCOMING);
+=======
+    const taskIncomingSpy = jest.spyOn(taskManager, 'emit');
+    webSocketManagerMock.emit('message', JSON.stringify(chatReservedPayload));
+
+    expect(taskIncomingSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_INCOMING,
+      taskManager.getTask(chatReservedPayload.data.interactionId)
+    );
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     // 2. Chat task is assigned
     const chatAssignedPayload = {
@@ -2027,9 +2819,18 @@ describe('TaskManager', () => {
       },
     };
 
+<<<<<<< HEAD
     webSocketManagerMock.emit('message', JSON.stringify(chatAssignedPayload));
 
     expectLastStateMachineEvent(sendStateMachineEventSpy, TaskEvent.ASSIGN);
+=======
+    const task = taskManager.getTask(chatReservedPayload.data.interactionId);
+    const taskEmitSpy = jest.spyOn(task, 'emit');
+
+    webSocketManagerMock.emit('message', JSON.stringify(chatAssignedPayload));
+
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_ASSIGNED, task);
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     // 3. Chat task is ended with state 'new' to trigger cleanup
     const chatEndedPayload = {
@@ -2037,7 +2838,10 @@ describe('TaskManager', () => {
         ...chatReservedPayload.data,
         type: CC_EVENTS.CONTACT_ENDED,
         interaction: {mediaType: 'chat', state: 'new'}, // Change to 'new' state
+<<<<<<< HEAD
         wrapUpRequired: false,
+=======
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
       },
     };
 
@@ -2134,8 +2938,18 @@ describe('TaskManager', () => {
     expect(taskManager.getAllTasks()).toHaveProperty(task2Payload.data.interactionId);
     expect(taskManager.getAllTasks()).toHaveProperty(task3Payload.data.interactionId);
 
+<<<<<<< HEAD
     const task2 = taskManager.getTask(task2Payload.data.interactionId);
     const task2SendStateMachineEventSpy = task2.sendStateMachineEvent as jest.Mock;
+=======
+    // Create spies for all tasks
+    const task1EmitSpy = jest.spyOn(taskManager.getTask(task1Payload.data.interactionId), 'emit');
+    const task2EmitSpy = jest.spyOn(taskManager.getTask(task2Payload.data.interactionId), 'emit');
+    const task3EmitSpy = jest.spyOn(taskManager.getTask(task3Payload.data.interactionId), 'emit');
+
+    // Store reference to task2 before it gets removed
+    const task2 = taskManager.getTask(task2Payload.data.interactionId);
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     // End only the second task (chat task)
     const chatEndedPayload = {
@@ -2143,6 +2957,7 @@ describe('TaskManager', () => {
         ...task2Payload.data,
         type: CC_EVENTS.CONTACT_ENDED,
         interaction: {mediaType: 'chat', state: 'new'}, // Using 'new' to trigger cleanup
+<<<<<<< HEAD
         wrapUpRequired: false,
       },
     };
@@ -2155,6 +2970,17 @@ describe('TaskManager', () => {
       TaskEvent.CONTACT_ENDED
     );
     expect(firstEndEvent?.taskData).toEqual(chatEndedPayload.data);
+=======
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(chatEndedPayload));
+
+    // Verify only task2 emitted TASK_END
+    expect(task1EmitSpy).not.toHaveBeenCalledWith(TASK_EVENTS.TASK_END);
+    expect(task2EmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_END, task2);
+    expect(task3EmitSpy).not.toHaveBeenCalledWith(TASK_EVENTS.TASK_END);
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     // Verify task2 was removed from collection (since state was 'new')
     expect(taskManager.getTask(task2Payload.data.interactionId)).toBeUndefined();
@@ -2165,7 +2991,10 @@ describe('TaskManager', () => {
 
     // Store reference to task3 before we end it
     const task3 = taskManager.getTask(task3Payload.data.interactionId);
+<<<<<<< HEAD
     const task3SendStateMachineEventSpy = task3.sendStateMachineEvent as jest.Mock;
+=======
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     // Now end task3 with a state that doesn't trigger cleanup
     const emailEndedPayload = {
@@ -2173,6 +3002,7 @@ describe('TaskManager', () => {
         ...task3Payload.data,
         type: CC_EVENTS.CONTACT_ENDED,
         interaction: {mediaType: 'email', state: 'connected'}, // Using 'connected' to NOT trigger cleanup
+<<<<<<< HEAD
         wrapUpRequired: true,
       },
     };
@@ -2185,6 +3015,15 @@ describe('TaskManager', () => {
       TaskEvent.CONTACT_ENDED
     );
     expect(secondEndEvent?.taskData).toEqual(emailEndedPayload.data);
+=======
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(emailEndedPayload));
+
+    // Verify task3 emitted TASK_END
+    expect(task3EmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_END, task3);
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     // Verify task3 is still in collection (since state was 'connected')
     expect(taskManager.getTask(task3Payload.data.interactionId)).toBeDefined();
@@ -2196,8 +3035,17 @@ describe('TaskManager', () => {
   it('should emit TRANSFER_SUCCESS event on AGENT_VTEAM_TRANSFERRED event', () => {
     // First create a task by emitting the initial payload
     webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
+<<<<<<< HEAD
     const task = taskManager.getTask(taskId);
     const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+=======
+
+    // Get a reference to the task from taskCollection
+    const task = taskManager.getTask(taskId);
+
+    // Now spy on the task's emit method
+    const taskEmitSpy = jest.spyOn(task, 'emit');
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     const vteamTransferredPayload = {
       data: {
@@ -2221,9 +3069,14 @@ describe('TaskManager', () => {
 
     webSocketManagerMock.emit('message', JSON.stringify(vteamTransferredPayload));
 
+<<<<<<< HEAD
     // Check that the state machine received the END event
     expectLastStateMachineEvent(sendStateMachineEventSpy, TaskEvent.TRANSFER_SUCCESS);
     sendStateMachineEventSpy.mockRestore();
+=======
+    // Check that task.emit was called with TASK_END event
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_END, task);
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
 
     // The task should still exist in the collection based on current implementation
     expect(taskManager.getTask(taskId)).toBeDefined();
@@ -2238,7 +3091,14 @@ describe('TaskManager', () => {
       },
     };
     const task = taskManager.getTask(taskId);
+<<<<<<< HEAD
     const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+=======
+    const updateSpy = jest.spyOn(task, 'updateTaskData').mockImplementation((data) => {
+      task.data = {...(task.data || {}), ...(data || {})};
+      return task;
+    });
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     webSocketManagerMock.emit('message', JSON.stringify(payload));
     expect(sendStateMachineEventSpy).toHaveBeenCalled();
     const stateMachineEvent = sendStateMachineEventSpy.mock.calls.at(-1)?.[0];
@@ -2359,6 +3219,7 @@ describe('TaskManager', () => {
 
   describe('Conference event handling', () => {
     let task;
+<<<<<<< HEAD
 
     beforeEach(() => {
       task = {
@@ -2366,6 +3227,22 @@ describe('TaskManager', () => {
         emit: jest.fn(),
         updateTaskData: jest.fn(),
         sendStateMachineEvent: jest.fn(),
+=======
+    const agentId = '723a8ffb-a26e-496d-b14a-ff44fb83b64f';
+
+    beforeEach(() => {
+      // Set the agentId on taskManager before tests run
+      taskManager.setAgentId(agentId);
+
+      task = {
+        data: {interactionId: taskId},
+        emit: jest.fn(),
+        updateTaskData: jest.fn().mockImplementation((updatedData) => {
+          // Mock the updateTaskData method to actually update task.data
+          task.data = {...task.data, ...updatedData};
+          return task;
+        }),
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
       };
       taskManager.taskCollection[taskId] = task as any;
     });
@@ -2402,7 +3279,28 @@ describe('TaskManager', () => {
 
     it('sends PARTICIPANT_LEFT_CONFERENCE to state machine as PARTICIPANT_LEAVE', () => {
       const payload = {
+<<<<<<< HEAD
         data: {type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE, interactionId: taskId},
+=======
+        data: {
+          type: CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE,
+          interactionId: taskId,
+          participantId: 'new-participant-123',
+          participantType: 'agent',
+          interaction: {
+            participants: {
+              [agentId]: {pType: 'Agent', hasLeft: false},
+              'new-participant-123': {pType: 'Agent', hasLeft: false},
+            },
+            media: {
+              [taskId]: {
+                mType: 'mainCall',
+                participants: [agentId, 'new-participant-123'],
+              },
+            },
+          },
+        },
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
       };
       webSocketManagerMock.emit('message', JSON.stringify(payload));
       expect(task.sendStateMachineEvent).toHaveBeenCalled();
@@ -2410,7 +3308,346 @@ describe('TaskManager', () => {
       expect(call.type).toBe(TaskEvent.PARTICIPANT_LEAVE);
     });
 
+<<<<<<< HEAD
     it('handles AGENT_CONSULT_CONFERENCING event without errors', () => {
+=======
+    it('should call updateTaskData only once for PARTICIPANT_JOINED_CONFERENCE with pre-calculated isConferenceInProgress', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE,
+          interactionId: taskId,
+          participantId: 'new-agent-789',
+          interaction: {
+            participants: {
+              [agentId]: {pType: 'Agent', hasLeft: false},
+              'agent-2': {pType: 'Agent', hasLeft: false},
+              'new-agent-789': {pType: 'Agent', hasLeft: false},
+              'customer-1': {pType: 'Customer', hasLeft: false},
+            },
+            media: {
+              [taskId]: {
+                mType: 'mainCall',
+                participants: [agentId, 'agent-2', 'new-agent-789', 'customer-1'],
+              },
+            },
+          },
+        },
+      };
+
+      const updateTaskDataSpy = jest.spyOn(task, 'updateTaskData');
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      // Verify updateTaskData was called exactly once
+      expect(updateTaskDataSpy).toHaveBeenCalledTimes(1);
+
+      // Verify it was called with isConferenceInProgress already calculated
+      expect(updateTaskDataSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          participantId: 'new-agent-789',
+          isConferenceInProgress: true, // 3 active agents
+        })
+      );
+
+      expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_JOINED, task);
+    });
+
+    describe('PARTICIPANT_LEFT_CONFERENCE event handling', () => {
+      it('should call updateTaskData only once for PARTICIPANT_LEFT_CONFERENCE with pre-calculated isConferenceInProgress', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {pType: 'Agent', hasLeft: false},
+                'agent-2': {pType: 'Agent', hasLeft: true}, // This agent left
+                'customer-1': {pType: 'Customer', hasLeft: false},
+              },
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: [agentId, 'customer-1'], // agent-2 removed from participants
+                },
+              },
+            },
+          },
+        };
+
+        const updateTaskDataSpy = jest.spyOn(task, 'updateTaskData');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Verify updateTaskData was called exactly once
+        expect(updateTaskDataSpy).toHaveBeenCalledTimes(1);
+
+        // Verify it was called with isConferenceInProgress already calculated
+        expect(updateTaskDataSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            isConferenceInProgress: false, // Only 1 active agent remains
+          })
+        );
+
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should emit TASK_PARTICIPANT_LEFT event when participant leaves conference', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should NOT remove task when agent is still in interaction', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should still exist in collection
+        expect(taskManager.getTask(taskId)).toBeDefined();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should NOT remove task when agent left but is in main interaction', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: true,
+                },
+              },
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: [agentId],
+                },
+              },
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should still exist - not removed
+        expect(removeTaskSpy).not.toHaveBeenCalled();
+        expect(taskManager.getTask(taskId)).toBeDefined();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should NOT remove task when agent left but is primary (owner)', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: true,
+                },
+              },
+              owner: agentId,
+              media: {
+                [taskId]: {
+                  mType: 'consultCall',
+                  participants: ['other-agent'],
+                },
+              },
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should still exist - not removed because agent is primary
+        expect(removeTaskSpy).not.toHaveBeenCalled();
+        expect(taskManager.getTask(taskId)).toBeDefined();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should remove task when agent left and is NOT in main interaction and is NOT primary', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: true,
+                },
+              },
+              owner: 'another-agent-id',
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: ['another-agent-id'],
+                },
+              },
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should be removed
+        expect(removeTaskSpy).toHaveBeenCalled();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should remove task when agent is not in participants list', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                'other-agent-id': {
+                  hasLeft: false,
+                },
+              },
+              owner: 'another-agent-id',
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should be removed because agent is not in participants
+        expect(removeTaskSpy).toHaveBeenCalled();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should update isConferenceInProgress based on remaining active agents', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                  pType: 'Agent',
+                },
+                'agent-2': {
+                  hasLeft: false,
+                  pType: 'Agent',
+                },
+                'customer-1': {
+                  hasLeft: false,
+                  pType: 'Customer',
+                },
+              },
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: [agentId, 'agent-2', 'customer-1'],
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // isConferenceInProgress should be true (2 active agents)
+        expect(task.data.isConferenceInProgress).toBe(true);
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should set isConferenceInProgress to false when only one agent remains', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                  pType: 'Agent',
+                },
+                'agent-2': {
+                  hasLeft: true,
+                  pType: 'Agent',
+                },
+                'customer-1': {
+                  hasLeft: false,
+                  pType: 'Customer',
+                },
+              },
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: [agentId, 'customer-1'],
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // isConferenceInProgress should be false (only 1 active agent)
+        expect(task.data.isConferenceInProgress).toBe(false);
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should handle participant left when no participants data exists', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {},
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // When no participants data exists, checkParticipantNotInInteraction returns true
+        // Since agent won't be in main interaction either, task should be removed
+        expect(removeTaskSpy).toHaveBeenCalled();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+    });
+
+    it('should handle PARTICIPANT_LEFT_CONFERENCE_FAILED event', () => {
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
       const payload = {
         data: {type: CC_EVENTS.AGENT_CONSULT_CONFERENCING, interactionId: taskId},
       };
@@ -2430,7 +3667,11 @@ describe('TaskManager', () => {
 
     it('only routes conference events to matching tasks', () => {
       const otherTaskId = 'other-task-id';
+<<<<<<< HEAD
       const otherTask: any = {
+=======
+      const otherTask = {
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
         data: {interactionId: otherTaskId},
         emit: jest.fn(),
         updateTaskData: jest.fn(),
@@ -2443,6 +3684,7 @@ describe('TaskManager', () => {
       };
       webSocketManagerMock.emit('message', JSON.stringify(payload));
 
+<<<<<<< HEAD
       expect(task.sendStateMachineEvent).toHaveBeenCalled();
       expect(otherTask.sendStateMachineEvent).not.toHaveBeenCalled();
     });
@@ -2474,6 +3716,939 @@ describe('TaskManager', () => {
       });
 
       sendStateMachineEventSpy.mockRestore();
+=======
+      // Only the matching task should be updated
+      expect(task.data.isConferencing).toBe(true);
+      expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
+
+      // Other task should not be affected
+      expect(otherTask.data.isConferencing).toBeUndefined();
+      expect(otherTask.emit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('handleTaskCleanup - stage changes', () => {
+    const agentId = '723a8ffb-a26e-496d-b14a-ff44fb83b64f';
+
+    beforeEach(() => {
+      taskManager.setAgentId(agentId);
+    });
+
+    it('should remove OUTDIAL task on CONTACT_ENDED when current agent is NOT in agentsPendingWrapUp', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+          interaction: {
+            ...task.data.interaction,
+            outboundType: 'OUTDIAL',
+            state: 'new',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: ['different-agent-123'], // Current agent not in the list
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+      const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            outboundType: 'OUTDIAL',
+            state: 'new',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: ['different-agent-123'], // Current agent not in the list
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(removeTaskSpy).toHaveBeenCalled();
+      expect(taskManager.getTask(taskId)).toBeUndefined();
+    });
+
+    it('should NOT remove OUTDIAL task on CONTACT_ENDED when current agent IS in agentsPendingWrapUp', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+          interaction: {
+            ...task.data.interaction,
+            outboundType: 'OUTDIAL',
+            state: 'new',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId, 'other-agent-456'], // Current agent IS in the list
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+      const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            outboundType: 'OUTDIAL',
+            state: 'new',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId, 'other-agent-456'], // Current agent IS in the list
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(removeTaskSpy).not.toHaveBeenCalled();
+      expect(taskManager.getTask(taskId)).toBeDefined();
+    });
+
+    it('should remove OUTDIAL task when needsWrapUp is false and task is outdial', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+          interaction: {
+            ...task.data.interaction,
+            outboundType: 'OUTDIAL',
+            state: 'WRAPUP', // Not 'new' state
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [], // No agents pending wrap-up
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+      const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            outboundType: 'OUTDIAL',
+            state: 'WRAPUP', // Not 'new' state
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [], // No agents pending wrap-up
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(removeTaskSpy).toHaveBeenCalled();
+      expect(taskManager.getTask(taskId)).toBeUndefined();
+    });
+
+    it('should remove OUTDIAL task when needsWrapUp is false (agentsPendingWrapUp is undefined)', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+          interaction: {
+            ...task.data.interaction,
+            outboundType: 'OUTDIAL',
+            state: 'WRAPUP',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: undefined, // No agentsPendingWrapUp field
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+      const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            outboundType: 'OUTDIAL',
+            state: 'WRAPUP',
+            mediaType: 'telephony',
+          },
+          // agentsPendingWrapUp not included
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(removeTaskSpy).toHaveBeenCalled();
+      expect(taskManager.getTask(taskId)).toBeUndefined();
+    });
+
+    it('should NOT remove OUTDIAL task when needsWrapUp is true (current agent in agentsPendingWrapUp) even if state is WRAPUP', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+          interaction: {
+            ...task.data.interaction,
+            outboundType: 'OUTDIAL',
+            state: 'WRAPUP',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId], // Current agent needs wrap-up
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+      const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            outboundType: 'OUTDIAL',
+            state: 'WRAPUP',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId], // Current agent needs wrap-up
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(removeTaskSpy).not.toHaveBeenCalled();
+      expect(taskManager.getTask(taskId)).toBeDefined();
+    });
+
+    it('should remove non-OUTDIAL task when state is new regardless of agentsPendingWrapUp', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+          interaction: {
+            ...task.data.interaction,
+            outboundType: 'PREVIEW', // Not OUTDIAL
+            state: 'new',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId],
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+      const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            outboundType: 'PREVIEW',
+            state: 'new',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(removeTaskSpy).toHaveBeenCalled();
+      expect(taskManager.getTask(taskId)).toBeUndefined();
+    });
+
+    it('should handle agentsPendingWrapUp with multiple agents correctly - remove if current agent not in list', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+          interaction: {
+            ...task.data.interaction,
+            outboundType: 'OUTDIAL',
+            state: 'new',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: ['agent-1', 'agent-2', 'agent-3'], // Current agent not in the list
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+      const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            outboundType: 'OUTDIAL',
+            state: 'new',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: ['agent-1', 'agent-2', 'agent-3'],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(removeTaskSpy).toHaveBeenCalled();
+      expect(taskManager.getTask(taskId)).toBeUndefined();
+    });
+
+    it('should handle agentsPendingWrapUp with multiple agents correctly - keep if current agent is in list', () => {
+      const task = taskManager.getTask(taskId);
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+          interaction: {
+            ...task.data.interaction,
+            outboundType: 'OUTDIAL',
+            state: 'new',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: ['agent-1', agentId, 'agent-3'], // Current agent IS in the list
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+      const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            outboundType: 'OUTDIAL',
+            state: 'new',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: ['agent-1', agentId, 'agent-3'],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(removeTaskSpy).not.toHaveBeenCalled();
+      expect(taskManager.getTask(taskId)).toBeDefined();
+    });
+  });
+
+  describe('CONTACT_MERGED event handling', () => {
+    let task;
+    let taskEmitSpy;
+    let managerEmitSpy;
+
+    beforeEach(() => {
+      // Create initial task
+      webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
+      task = taskManager.getTask(taskId);
+      taskEmitSpy = jest.spyOn(task, 'emit');
+      managerEmitSpy = jest.spyOn(taskManager, 'emit');
+    });
+
+    it('should update existing task data and emit TASK_MERGED event when CONTACT_MERGED is received', () => {
+      const mergedPayload = {
+        data: {
+          type: CC_EVENTS.CONTACT_MERGED,
+          interactionId: taskId,
+          agentId: taskDataMock.agentId,
+          interaction: {
+            ...taskDataMock.interaction,
+            state: 'merged',
+            customField: 'updated-value',
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(mergedPayload));
+
+      const updatedTask = taskManager.getTask(taskId);
+      expect(updatedTask).toBeDefined();
+      expect(updatedTask.data.interaction.customField).toBe('updated-value');
+      expect(updatedTask.data.interaction.state).toBe('merged');
+      expect(managerEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_MERGED, updatedTask);
+    });
+
+    it('should create new task when CONTACT_MERGED is received for non-existing task', () => {
+      const newMergedTaskId = 'new-merged-task-id';
+      const mergedPayload = {
+        data: {
+          type: CC_EVENTS.CONTACT_MERGED,
+          interactionId: newMergedTaskId,
+          agentId: taskDataMock.agentId,
+          interaction: {
+            mediaType: 'telephony',
+            state: 'merged',
+            participants: {
+              [taskDataMock.agentId]: {
+                isWrapUp: false,
+                hasJoined: true,
+              },
+            },
+          },
+        },
+      };
+
+      // Verify task doesn't exist before
+      expect(taskManager.getTask(newMergedTaskId)).toBeUndefined();
+
+      webSocketManagerMock.emit('message', JSON.stringify(mergedPayload));
+
+      // Verify task was created
+      const newTask = taskManager.getTask(newMergedTaskId);
+      expect(newTask).toBeDefined();
+      expect(newTask.data.interactionId).toBe(newMergedTaskId);
+      expect(managerEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_MERGED, newTask);
+    });
+
+    it('should remove child task when childInteractionId is present in CONTACT_MERGED', () => {
+      const childTaskId = 'child-task-id';
+      const parentTaskId = 'parent-task-id';
+
+      // Create child task
+      const childPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONTACT_RESERVED,
+          interactionId: childTaskId,
+          agentId: taskDataMock.agentId,
+          interaction: {mediaType: 'telephony'},
+        },
+      };
+      webSocketManagerMock.emit('message', JSON.stringify(childPayload));
+
+      // Verify child task exists
+      expect(taskManager.getTask(childTaskId)).toBeDefined();
+
+      // Create parent task
+      const parentPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONTACT_RESERVED,
+          interactionId: parentTaskId,
+          agentId: taskDataMock.agentId,
+          interaction: {mediaType: 'telephony'},
+        },
+      };
+      webSocketManagerMock.emit('message', JSON.stringify(parentPayload));
+
+      // Send CONTACT_MERGED with childInteractionId
+      const mergedPayload = {
+        data: {
+          type: CC_EVENTS.CONTACT_MERGED,
+          interactionId: parentTaskId,
+          childInteractionId: childTaskId,
+          agentId: taskDataMock.agentId,
+          interaction: {
+            mediaType: 'telephony',
+            state: 'merged',
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(mergedPayload));
+
+      // Verify child task was removed
+      expect(taskManager.getTask(childTaskId)).toBeUndefined();
+
+      // Verify parent task still exists
+      expect(taskManager.getTask(parentTaskId)).toBeDefined();
+
+      // Verify TASK_MERGED event was emitted
+      expect(managerEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_MERGED,
+        expect.objectContaining({
+          data: expect.objectContaining({
+            interactionId: parentTaskId,
+          }),
+        })
+      );
+    });
+
+    it('should handle CONTACT_MERGED with EP-DN participant correctly', () => {
+      const epdnTaskId = 'epdn-merged-task';
+      const mergedPayload = {
+        data: {
+          type: CC_EVENTS.CONTACT_MERGED,
+          interactionId: epdnTaskId,
+          agentId: taskDataMock.agentId,
+          interaction: {
+            mediaType: 'telephony',
+            state: 'merged',
+            participants: {
+              [taskDataMock.agentId]: {
+                type: 'Agent',
+                isWrapUp: false,
+                hasJoined: true,
+              },
+              'epdn-participant': {
+                type: 'EpDn',
+                epId: 'entry-point-123',
+                isWrapUp: false,
+              },
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(mergedPayload));
+
+      const mergedTask = taskManager.getTask(epdnTaskId);
+      expect(mergedTask).toBeDefined();
+      expect(mergedTask.data.interaction.participants['epdn-participant']).toBeDefined();
+      expect(mergedTask.data.interaction.participants['epdn-participant'].type).toBe('EpDn');
+      expect(managerEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_MERGED, mergedTask);
+    });
+
+    it('should not affect other tasks when CONTACT_MERGED is received', () => {
+      const otherTaskId = 'other-unrelated-task';
+      const otherPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONTACT_RESERVED,
+          interactionId: otherTaskId,
+          agentId: taskDataMock.agentId,
+          interaction: {mediaType: 'chat'},
+        },
+      };
+      webSocketManagerMock.emit('message', JSON.stringify(otherPayload));
+
+      const otherTask = taskManager.getTask(otherTaskId);
+      const otherTaskEmitSpy = jest.spyOn(otherTask, 'emit');
+
+      // Send CONTACT_MERGED for the original task
+      const mergedPayload = {
+        data: {
+          type: CC_EVENTS.CONTACT_MERGED,
+          interactionId: taskId,
+          agentId: taskDataMock.agentId,
+          interaction: {
+            mediaType: 'telephony',
+            state: 'merged',
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(mergedPayload));
+
+      // Verify other task was not affected
+      expect(otherTaskEmitSpy).not.toHaveBeenCalled();
+      expect(otherTask.data.interaction.mediaType).toBe('chat');
+
+      // Verify original task was updated
+      expect(managerEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_MERGED,
+        expect.objectContaining({
+          data: expect.objectContaining({
+            interactionId: taskId,
+          }),
+        })
+      );
+    });
+  });
+
+  describe('Campaign Preview Reservation', () => {
+    it('should create a task and emit TASK_CAMPAIGN_PREVIEW_RESERVATION when AgentOfferCampaignReservation is received', () => {
+      const campaignPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: 'campaign-interaction-123',
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      const managerEmitSpy = jest.spyOn(taskManager, 'emit');
+
+      webSocketManagerMock.emit('message', JSON.stringify(campaignPayload));
+
+      // Should emit with a task object (not raw data)
+      expect(managerEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
+        expect.objectContaining({
+          data: expect.objectContaining({
+            interactionId: 'campaign-interaction-123',
+            type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+            wrapUpRequired: false,
+            isAutoAnswering: false,
+          }),
+        })
+      );
+
+      // Task should be in the collection so subsequent events (e.g. AGENT_CONTACT_ASSIGNED) can find it
+      expect(taskManager['taskCollection']['campaign-interaction-123']).toBeDefined();
+    });
+
+    it('should re-key task and emit TASK_ASSIGNED when AgentContactAssigned uses a new interactionId', () => {
+      const reservationInteractionId = 'campaign-reservation-id';
+      const assignedInteractionId = 'campaign-assigned-id';
+
+      webSocketManagerMock.emit(
+        'message',
+        JSON.stringify({
+          data: {
+            type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+            interactionId: reservationInteractionId,
+            agentId: taskDataMock.agentId,
+            orgId: taskDataMock.orgId,
+            trackingId: 'campaign-tracking-456',
+            interaction: {
+              mediaType: 'telephony',
+              callProcessingDetails: {campaignId: 'campaign-789'},
+            },
+          },
+        })
+      );
+
+      const taskBeforeAssign = taskManager['taskCollection'][reservationInteractionId];
+      expect(taskBeforeAssign).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(taskBeforeAssign, 'emit');
+
+      webSocketManagerMock.emit(
+        'message',
+        JSON.stringify({
+          data: {
+            type: CC_EVENTS.AGENT_CONTACT_ASSIGNED,
+            interactionId: assignedInteractionId,
+            reservationInteractionId,
+            agentId: taskDataMock.agentId,
+            orgId: taskDataMock.orgId,
+            trackingId: 'campaign-tracking-assigned',
+            interaction: {mediaType: 'telephony', state: 'connected'},
+          },
+        })
+      );
+
+      expect(taskManager['taskCollection'][reservationInteractionId]).toBeUndefined();
+      expect(taskManager['taskCollection'][assignedInteractionId]).toBe(taskBeforeAssign);
+      expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_ASSIGNED, taskBeforeAssign);
+
+      taskEmitSpy.mockRestore();
+    });
+
+    it('should not emit TASK_INCOMING for campaign preview reservation when incoming WebRTC call arrives', () => {
+      const campaignPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: 'campaign-interaction-123',
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      // Remove the default task so only the campaign preview task is in the collection
+      delete taskManager['taskCollection'][taskId];
+
+      // Create campaign preview task via the reservation event
+      webSocketManagerMock.emit('message', JSON.stringify(campaignPayload));
+
+      const managerEmitSpy = jest.spyOn(taskManager, 'emit');
+
+      // Simulate an incoming WebRTC call
+      const incomingCallCb = onSpy.mock.calls[0][1];
+      incomingCallCb(mockCall);
+
+      // TASK_INCOMING should NOT be emitted because the only telephony task is a campaign preview
+      expect(managerEmitSpy).not.toHaveBeenCalledWith(TASK_EVENTS.TASK_INCOMING, expect.anything());
+    });
+
+    it('should update existing task when AgentOfferCampaignReservation is received for known interactionId', () => {
+      const campaignPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: 'campaign-interaction-123',
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      // Send the first reservation to create the task
+      webSocketManagerMock.emit('message', JSON.stringify(campaignPayload));
+
+      const managerEmitSpy = jest.spyOn(taskManager, 'emit');
+
+      // Send a second reservation for the same interactionId
+      webSocketManagerMock.emit('message', JSON.stringify(campaignPayload));
+
+      expect(managerEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
+        expect.objectContaining({
+          data: expect.objectContaining({
+            interactionId: 'campaign-interaction-123',
+          }),
+        })
+      );
+    });
+
+    it('should emit TASK_CAMPAIGN_CONTACT_UPDATED and NOT remove task when CampaignContactUpdated is received', () => {
+      const campaignInteractionId = 'campaign-interaction-123';
+
+      // First create a campaign preview task
+      const reservationPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(reservationPayload));
+
+      // Verify task exists in collection
+      const task = taskManager['taskCollection'][campaignInteractionId];
+      expect(task).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+
+      // Now send CampaignContactUpdated
+      const campaignContactUpdatedPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_CONTACT_UPDATED,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          interaction: {
+            mediaType: 'telephony',
+            state: 'new',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(campaignContactUpdatedPayload));
+
+      // Task should still exist in collection (not removed — non-terminal event)
+      expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
+
+      // TASK_CAMPAIGN_CONTACT_UPDATED should have been emitted
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_CONTACT_UPDATED,
+        expect.objectContaining({
+          data: expect.objectContaining({
+            interactionId: campaignInteractionId,
+          }),
+        })
+      );
+
+      // TASK_END should NOT have been emitted
+      expect(taskEmitSpy).not.toHaveBeenCalledWith(TASK_EVENTS.TASK_END, expect.anything());
+    });
+
+    it('should emit TASK_CAMPAIGN_PREVIEW_ACCEPT_FAILED when CampaignPreviewAcceptFailed is received', () => {
+      const campaignInteractionId = 'campaign-interaction-123';
+
+      // First create a campaign preview task
+      const reservationPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(reservationPayload));
+
+      const task = taskManager['taskCollection'][campaignInteractionId];
+      expect(task).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED,
+          interactionId: campaignInteractionId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_ACCEPT_FAILED,
+        expect.objectContaining({
+          data: expect.objectContaining({interactionId: campaignInteractionId}),
+        })
+      );
+      // Task should still exist (failure is non-terminal)
+      expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
+
+      // Failure payload (reason, campaignId) should be merged into task.data
+      expect(task.data.reason).toBe('INTERNAL_ERROR');
+
+      // Original reservation data must be preserved
+      expect(task.data.interaction).toBeDefined();
+      expect(task.data.interaction.callProcessingDetails.campaignId).toBe('campaign-789');
+    });
+
+    it('should emit TASK_CAMPAIGN_PREVIEW_SKIP_FAILED when CampaignPreviewSkipFailed is received', () => {
+      const campaignInteractionId = 'campaign-interaction-123';
+
+      const reservationPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(reservationPayload));
+
+      const task = taskManager['taskCollection'][campaignInteractionId];
+      expect(task).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED,
+          interactionId: campaignInteractionId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_SKIP_FAILED,
+        expect.objectContaining({
+          data: expect.objectContaining({interactionId: campaignInteractionId}),
+        })
+      );
+      expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
+
+      // Failure payload (reason) should be merged into task.data
+      expect(task.data.reason).toBe('INTERNAL_ERROR');
+
+      // Original reservation data must be preserved
+      expect(task.data.interaction).toBeDefined();
+      expect(task.data.interaction.callProcessingDetails.campaignId).toBe('campaign-789');
+    });
+
+    it('should emit TASK_CAMPAIGN_PREVIEW_REMOVE_FAILED when CampaignPreviewRemoveFailed is received', () => {
+      const campaignInteractionId = 'campaign-interaction-123';
+
+      const reservationPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(reservationPayload));
+
+      const task = taskManager['taskCollection'][campaignInteractionId];
+      expect(task).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_REMOVE_FAILED,
+          interactionId: campaignInteractionId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_REMOVE_FAILED,
+        expect.objectContaining({
+          data: expect.objectContaining({interactionId: campaignInteractionId}),
+        })
+      );
+      expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
+
+      // Failure payload (reason) should be merged into task.data
+      expect(task.data.reason).toBe('INTERNAL_ERROR');
+
+      // Original reservation data must be preserved
+      expect(task.data.interaction).toBeDefined();
+      expect(task.data.interaction.callProcessingDetails.campaignId).toBe('campaign-789');
+    });
+
+    it('should not emit campaign preview failure events when task does not exist', () => {
+      const nonExistentId = 'non-existent-interaction';
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED,
+          interactionId: nonExistentId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      // Should not throw when task is not found
+      expect(() => {
+        webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+      }).not.toThrow();
+
+      expect(taskManager['taskCollection'][nonExistentId]).toBeUndefined();
+>>>>>>> 81672300901738f14289fd2a7414c6c4b1389aa6
     });
   });
 });