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

package/test/unit/spec/services/task/state-machine/TaskStateMachine.ts

@@ -5,6 +5,7 @@ import {
   TaskState,
 } from '../../../../../../src/services/task/state-machine';
 import {createTaskData} from '../taskTestUtils';
+import {guards} from '../../../../../../src/services/task/state-machine/guards';
 
 const createConfig = () => ({
   channelType: 'voice' as const,
@@ -14,6 +15,18 @@ const createConfig = () => ({
   isRecordingEnabled: true,
 });
 
+/** Mirrors Task.emitTaskWrapup: publishWrapup spy only runs when context would emit task:wrapup. */
+function createPublishAwareEmitTaskWrapupMock() {
+  const publishWrapup = jest.fn();
+  const emitTaskWrapup = ({context}: {context: {taskData?: {wrapUpRequired?: boolean}}}) => {
+    if (context.taskData?.wrapUpRequired) {
+      publishWrapup();
+    }
+  };
+
+  return {emitTaskWrapup, publishWrapup};
+}
+
 describe('Task state machine', () => {
   const startMachine = () => {
     const actor = createActor(createTaskStateMachine(createConfig()));
@@ -106,6 +119,234 @@ describe('Task state machine', () => {
     });
   });
 
+  describe('partial lifecycle payloads', () => {
+    const createActiveMainCallTaskData = (isHold = false) =>
+      createTaskData({
+        agentId: 'agent-1',
+        interactionId: 'interaction-1',
+        mediaResourceId: 'main-media',
+        interaction: {
+          state: 'connected',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'main-media': {
+              mediaResourceId: 'main-media',
+              mType: 'mainCall',
+              participants: ['agent-1', 'customer-1'],
+              isHold,
+            },
+          },
+        } as any,
+      });
+
+    const createPartialMainCallTaskData = (isHold = false, omitSelf = false) =>
+      createTaskData({
+        agentId: 'agent-1',
+        interactionId: 'interaction-1',
+        mediaResourceId: 'main-media',
+        interaction: {
+          state: 'connected',
+          participants: omitSelf
+            ? {'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false}}
+            : {
+                'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+                'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+              },
+          media: {
+            'main-media': {
+              mediaResourceId: 'main-media',
+              mType: 'mainCall',
+              participants: ['customer-1'],
+              isHold,
+            },
+          },
+        } as any,
+      });
+
+    const startMachineWithEndSpy = () => {
+      const emitTaskEnd = jest.fn();
+      const service = createActor(
+        createTaskStateMachine({...createConfig(), agentId: 'agent-1'}, {actions: {emitTaskEnd}})
+      );
+      service.start();
+
+      return {service, emitTaskEnd};
+    };
+
+    const enterTransientHoldState = (
+      service: ReturnType<typeof startMachine>,
+      state: TaskState.HOLD_INITIATING | TaskState.RESUME_INITIATING,
+      taskData: ReturnType<typeof createActiveMainCallTaskData>
+    ) => {
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.HOLD_INITIATED, mediaResourceId: 'main-media'});
+
+      if (state === TaskState.RESUME_INITIATING) {
+        service.send({type: TaskEvent.HOLD_SUCCESS, mediaResourceId: 'main-media'});
+        service.send({type: TaskEvent.UNHOLD_INITIATED, mediaResourceId: 'main-media'});
+      }
+
+      expect(service.getSnapshot().value).toBe(state);
+    };
+
+    it('keeps CONNECTED when another participant leave event has a partial mainCall', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData();
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-2',
+        taskData: createPartialMainCallTaskData(false, true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+      expect(emitTaskEnd).not.toHaveBeenCalled();
+    });
+
+    it('ignores PARTICIPANT_LEAVE in CONNECTED even when it identifies the current agent', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData();
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-1',
+        taskData: createPartialMainCallTaskData(false, true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+      expect(emitTaskEnd).not.toHaveBeenCalled();
+    });
+
+    it('enters WRAPPING_UP on TASK_WRAPUP while HOLD_INITIATING and emits wrap-up once', () => {
+      const emitTaskWrapup = jest.fn();
+      const service = createActor(
+        createTaskStateMachine({...createConfig(), agentId: 'agent-1'}, {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const taskData = createActiveMainCallTaskData();
+
+      enterTransientHoldState(service, TaskState.HOLD_INITIATING, taskData);
+      service.send({
+        type: TaskEvent.TASK_WRAPUP,
+        taskData: {...taskData, wrapUpRequired: true},
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(emitTaskWrapup).toHaveBeenCalledTimes(1);
+    });
+
+    it('ignores PARTICIPANT_LEAVE in HOLD_INITIATING when a remote Drop identifies the current agent', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData();
+
+      enterTransientHoldState(service, TaskState.HOLD_INITIATING, taskData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-1',
+        taskData: createPartialMainCallTaskData(false, true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.HOLD_INITIATING);
+      expect(emitTaskEnd).not.toHaveBeenCalled();
+    });
+
+    it('terminates RESUME_INITIATING when a remote Drop identifies the current agent', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData(true);
+
+      enterTransientHoldState(service, TaskState.RESUME_INITIATING, taskData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-1',
+        taskData: createPartialMainCallTaskData(true, true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+      expect(emitTaskEnd).toHaveBeenCalledTimes(1);
+    });
+
+    it('keeps HOLD_INITIATING when ParticipantLeftConference identifies another participant', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData();
+
+      enterTransientHoldState(service, TaskState.HOLD_INITIATING, taskData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-2',
+        taskData: createPartialMainCallTaskData(false, true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.HOLD_INITIATING);
+      expect(emitTaskEnd).not.toHaveBeenCalled();
+    });
+
+    it('terminates RESUME_INITIATING when another participant leave omits self from the roster', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData(true);
+
+      enterTransientHoldState(service, TaskState.RESUME_INITIATING, taskData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-2',
+        taskData: createPartialMainCallTaskData(true, true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+      expect(emitTaskEnd).toHaveBeenCalledTimes(1);
+    });
+
+    it('terminates HELD when another participant leave event omits self from its roster', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData(true);
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.HOLD_INITIATED, mediaResourceId: 'main-media'});
+      service.send({type: TaskEvent.HOLD_SUCCESS, mediaResourceId: 'main-media'});
+      expect(service.getSnapshot().value).toBe(TaskState.HELD);
+
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-2',
+        taskData: createPartialMainCallTaskData(true, true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+      expect(emitTaskEnd).toHaveBeenCalledTimes(1);
+    });
+
+    it('keeps HELD when CONSULT_END has a partial mainCall', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData(true);
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.HOLD_INITIATED, mediaResourceId: 'main-media'});
+      service.send({type: TaskEvent.HOLD_SUCCESS, mediaResourceId: 'main-media'});
+      expect(service.getSnapshot().value).toBe(TaskState.HELD);
+
+      service.send({
+        type: TaskEvent.CONSULT_END,
+        taskData: createPartialMainCallTaskData(true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.HELD);
+      expect(emitTaskEnd).not.toHaveBeenCalled();
+    });
+  });
+
   describe('recording pause/resume events', () => {
     it('toggles recordingPaused flag based on events', () => {
       const service = startMachine();
@@ -180,6 +421,32 @@ describe('Task state machine', () => {
       service.send({type: TaskEvent.WRAPUP_COMPLETE});
       expect(service.getSnapshot().value).toBe(TaskState.COMPLETED);
     });
+
+    it('emits task wrappedup before cleanup on COMPLETED entry', () => {
+      const actionOrder: string[] = [];
+      const actor = createActor(
+        createTaskStateMachine(createConfig(), {
+          actions: {
+            emitTaskWrappedup: () => {
+              actionOrder.push('emitTaskWrappedup');
+            },
+            cleanupResources: () => {
+              actionOrder.push('cleanupResources');
+            },
+          },
+        })
+      );
+      actor.start();
+      const taskData = createTaskData();
+
+      actor.send({type: TaskEvent.TASK_INCOMING, taskData});
+      actor.send({type: TaskEvent.ASSIGN, taskData});
+      actor.send({type: TaskEvent.TASK_WRAPUP});
+      actor.send({type: TaskEvent.WRAPUP_COMPLETE});
+
+      expect(actor.getSnapshot().value).toBe(TaskState.COMPLETED);
+      expect(actionOrder).toEqual(['emitTaskWrappedup', 'cleanupResources']);
+    });
   });
 
   describe('consult and conference flows', () => {
@@ -343,53 +610,53 @@ describe('Task state machine', () => {
       expect(snapshot.context.consultFromConference).toBe(true);
     });
 
-  it('hydrates consulted agent to CONSULTING when self consultState is consulting and main leg is held', () => {
-    const service = startMachine();
-    const taskData = createTaskData({
-      agentId: 'agent-2',
-      isConsulted: true,
-      interaction: {
-        state: 'conference',
-        mainInteractionId: 'interaction-1',
-        interactionId: 'interaction-1',
-        participants: {
-          'agent-1': {
-            id: 'agent-1',
-            pType: 'Agent',
-            hasLeft: false,
-            consultState: 'consulting',
-            isConsulted: false,
-          },
-          'agent-2': {
-            id: 'agent-2',
-            pType: 'Agent',
-            hasLeft: false,
-            consultState: 'consulting',
-            isConsulted: true,
-          },
-          'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
-        },
-        media: {
-          'interaction-1': {
-            mediaResourceId: 'interaction-1',
-            mType: 'mainCall',
-            participants: ['agent-1', 'customer-1'],
-            isHold: true,
-          },
-          'consult-media-1': {
-            mediaResourceId: 'consult-media-1',
-            mType: 'consult',
-            participants: ['agent-1', 'agent-2'],
-            isHold: false,
+    it('hydrates consulted agent to CONSULTING when self consultState is consulting and main leg is held', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        agentId: 'agent-2',
+        isConsulted: true,
+        interaction: {
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consulting',
+              isConsulted: false,
+            },
+            'agent-2': {
+              id: 'agent-2',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consulting',
+              isConsulted: true,
+            },
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
           },
-        },
-      } as any,
-    });
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: ['agent-1', 'customer-1'],
+              isHold: true,
+            },
+            'consult-media-1': {
+              mediaResourceId: 'consult-media-1',
+              mType: 'consult',
+              participants: ['agent-1', 'agent-2'],
+              isHold: false,
+            },
+          },
+        } as any,
+      });
 
-    service.send({type: TaskEvent.HYDRATE, taskData});
+      service.send({type: TaskEvent.HYDRATE, taskData});
 
-    expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
-  });
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
+    });
 
     it('hydrates to CONSULTING when consult is pending (self consultState is consultInitiated)', () => {
       const service = startMachine();
@@ -1587,13 +1854,25 @@ describe('Task state machine', () => {
       expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
     });
 
-    it('terminates when EXIT_CONFERENCE_SUCCESS is received in conferencing and wrapup is not required', () => {
-      const service = startMachine();
-      const taskData = createTaskData({
-        isConsulted: true,
-        wrapUpRequired: false,
+    const primeConferencing = (service: ReturnType<typeof startMachine>, taskData: ReturnType<typeof createTaskData>) => {
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({
+        type: TaskEvent.CONSULT,
+        destination: 'agent-42',
+        destinationType: 'agent',
+      });
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      service.send({type: TaskEvent.MERGE_TO_CONFERENCE});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+    };
+
+    const conferenceInProgressTaskData = (overrides: Parameters<typeof createTaskData>[0] = {}) =>
+      createTaskData({
+        wrapUpRequired: true,
         interaction: {
-          owner: 'other-agent',
+          owner: 'agent-1',
           state: 'conference',
           mainInteractionId: 'interaction-1',
           interactionId: 'interaction-1',
@@ -1604,54 +1883,485 @@ describe('Task state machine', () => {
               type: 'Agent',
               hasJoined: true,
               hasLeft: false,
-              isInPredial: false,
-              isWrapUp: false,
             },
-            c1: {
-              id: 'c1',
-              pType: 'Customer',
-              type: 'Customer',
+            'agent-2': {
+              id: 'agent-2',
+              pType: 'Agent',
+              type: 'Agent',
               hasJoined: true,
               hasLeft: false,
-              isInPredial: false,
             },
           },
           media: {
             'interaction-1': {
               mediaResourceId: 'interaction-1',
               mediaType: 'telephony',
-              mediaMgr: 'mm',
-              participants: ['agent-1', 'c1'],
+              participants: ['agent-1', 'agent-2'],
               mType: 'mainCall',
               isHold: false,
-              holdTimestamp: null,
             },
           },
         } as any,
+        ...overrides,
       });
 
+    const primeConnectedWithConferenceTaskData = (
+      service: ReturnType<typeof startMachine>,
+      taskData: ReturnType<typeof createTaskData>
+    ) => {
       service.send({type: TaskEvent.TASK_INCOMING, taskData});
       service.send({type: TaskEvent.ASSIGN, taskData});
-      service.send({
-        type: TaskEvent.CONSULT,
-        destination: 'agent-42',
-        destinationType: 'agent',
-      });
-      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
-      service.send({type: TaskEvent.MERGE_TO_CONFERENCE});
-      service.send({type: TaskEvent.CONFERENCE_START, taskData});
-      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+    };
+
+    it('enters WRAPPING_UP on EXIT_CONFERENCE_SUCCESS while CONNECTED with conference in task data', () => {
+      const service = startMachine();
+      const taskData = conferenceInProgressTaskData();
 
+      primeConnectedWithConferenceTaskData(service, taskData);
       service.send({type: TaskEvent.EXIT_CONFERENCE_SUCCESS, taskData});
-      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(service.getSnapshot().context.taskData?.wrapUpRequired).toBe(true);
     });
 
-    it('downgrades to HELD on HOLD_SUCCESS when no other agents remain on task', () => {
-      const service = startMachine();
-      const conferenceTaskData = createSingleAgentConferenceTaskData('conference');
-      const heldTaskData = createSingleAgentConferenceTaskData('hold', true);
+    it('emits wrap-up once on EXIT_CONFERENCE_SUCCESS while CONNECTED', () => {
+      const emitTaskWrapup = jest.fn();
+      const service = createActor(
+        createTaskStateMachine(createConfig(), {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const taskData = conferenceInProgressTaskData();
 
-      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
+      primeConnectedWithConferenceTaskData(service, taskData);
+      service.send({type: TaskEvent.EXIT_CONFERENCE_SUCCESS, taskData});
+
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(emitTaskWrapup).toHaveBeenCalledTimes(1);
+    });
+
+    it('terminates on EXIT_CONFERENCE_SUCCESS while CONNECTED when wrap-up is not required', () => {
+      const service = startMachine();
+      const taskData = conferenceInProgressTaskData({
+        wrapUpRequired: false,
+        interaction: {
+          owner: 'other-agent',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              type: 'Agent',
+              hasJoined: true,
+              hasLeft: false,
+              isWrapUp: false,
+            },
+            'agent-2': {
+              id: 'agent-2',
+              pType: 'Agent',
+              type: 'Agent',
+              hasJoined: true,
+              hasLeft: false,
+            },
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mediaType: 'telephony',
+              participants: ['agent-1', 'agent-2'],
+              mType: 'mainCall',
+              isHold: false,
+            },
+          },
+        } as any,
+      });
+
+      primeConnectedWithConferenceTaskData(service, taskData);
+      service.send({type: TaskEvent.EXIT_CONFERENCE_SUCCESS, taskData});
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+    });
+
+    it('does not re-emit wrap-up on late TASK_WRAPUP when wrap-up was already published', () => {
+      const {emitTaskWrapup, publishWrapup} = createPublishAwareEmitTaskWrapupMock();
+      const service = createActor(
+        createTaskStateMachine(createConfig(), {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const taskData = conferenceInProgressTaskData();
+
+      primeConferencing(service, taskData);
+      service.send({
+        type: TaskEvent.EXIT_CONFERENCE_SUCCESS,
+        taskData: {...taskData, wrapUpRequired: true},
+      });
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(service.getSnapshot().context.taskData?.wrapUpRequired).toBe(true);
+
+      const emitCountAfterExit = publishWrapup.mock.calls.length;
+      service.send({
+        type: TaskEvent.TASK_WRAPUP,
+        taskData: {...taskData, wrapUpRequired: true},
+      });
+
+      expect(publishWrapup.mock.calls.length).toBe(emitCountAfterExit);
+    });
+
+    it('emits wrap-up on late TASK_WRAPUP when wrap-up was not yet published', () => {
+      const {emitTaskWrapup, publishWrapup} = createPublishAwareEmitTaskWrapupMock();
+      const service = createActor(
+        createTaskStateMachine(createConfig(), {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const taskData = createTaskData({
+        wrapUpRequired: false,
+        interaction: {
+          owner: 'agent-1',
+          state: 'connected',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              type: 'Agent',
+              hasJoined: true,
+              hasLeft: false,
+            },
+          },
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.TASK_WRAPUP, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(service.getSnapshot().context.taskData?.wrapUpRequired).not.toBe(true);
+      expect(publishWrapup).not.toHaveBeenCalled();
+
+      service.send({
+        type: TaskEvent.TASK_WRAPUP,
+        taskData: {...taskData, wrapUpRequired: true},
+      });
+
+      expect(publishWrapup).toHaveBeenCalledTimes(1);
+    });
+
+    it('terminates when EXIT_CONFERENCE_SUCCESS is received in conferencing and wrapup is not required', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        isConsulted: true,
+        wrapUpRequired: false,
+        interaction: {
+          owner: 'other-agent',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              type: 'Agent',
+              hasJoined: true,
+              hasLeft: false,
+              isInPredial: false,
+              isWrapUp: false,
+            },
+            c1: {
+              id: 'c1',
+              pType: 'Customer',
+              type: 'Customer',
+              hasJoined: true,
+              hasLeft: false,
+              isInPredial: false,
+            },
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mediaType: 'telephony',
+              mediaMgr: 'mm',
+              participants: ['agent-1', 'c1'],
+              mType: 'mainCall',
+              isHold: false,
+              holdTimestamp: null,
+            },
+          },
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({
+        type: TaskEvent.CONSULT,
+        destination: 'agent-42',
+        destinationType: 'agent',
+      });
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      service.send({type: TaskEvent.MERGE_TO_CONFERENCE});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      service.send({type: TaskEvent.EXIT_CONFERENCE_SUCCESS, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+    });
+
+    it('enters WRAPPING_UP on CONFERENCE_END when wrapUpRequired is stamped', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        wrapUpRequired: true,
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              type: 'Agent',
+              isWrapUp: true,
+              hasJoined: true,
+              hasLeft: true,
+            },
+          },
+        } as any,
+      });
+
+      primeConferencing(service, taskData);
+      service.send({type: TaskEvent.CONFERENCE_END, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('emits wrap-up once on CONFERENCE_END when wrap-up is required', () => {
+      const {emitTaskWrapup, publishWrapup} = createPublishAwareEmitTaskWrapupMock();
+      const service = createActor(
+        createTaskStateMachine(createConfig(), {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const taskData = createTaskData({
+        wrapUpRequired: true,
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              type: 'Agent',
+              isWrapUp: true,
+              hasJoined: true,
+              hasLeft: true,
+            },
+          },
+        } as any,
+      });
+
+      primeConferencing(service, taskData);
+      service.send({type: TaskEvent.CONFERENCE_END, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(publishWrapup).toHaveBeenCalledTimes(1);
+    });
+
+    it('emits wrap-up once on TASK_WRAPUP from CONSULTING when wrap-up is required', () => {
+      const {emitTaskWrapup, publishWrapup} = createPublishAwareEmitTaskWrapupMock();
+      const service = createActor(
+        createTaskStateMachine(createConfig(), {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const taskData = createTaskData({
+        interaction: {owner: 'agent-1', state: 'connected'} as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-2', destinationType: 'agent'});
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
+
+      service.send({
+        type: TaskEvent.TASK_WRAPUP,
+        taskData: {...taskData, wrapUpRequired: true},
+      });
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(publishWrapup).toHaveBeenCalledTimes(1);
+    });
+
+    it('emits wrap-up once on TASK_WRAPUP from CONFERENCING when wrap-up is required', () => {
+      const {emitTaskWrapup, publishWrapup} = createPublishAwareEmitTaskWrapupMock();
+      const service = createActor(
+        createTaskStateMachine(createConfig(), {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const taskData = createTaskData({
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+        } as any,
+      });
+
+      primeConferencing(service, taskData);
+      service.send({
+        type: TaskEvent.TASK_WRAPUP,
+        taskData: {...taskData, wrapUpRequired: true},
+      });
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(publishWrapup).toHaveBeenCalledTimes(1);
+    });
+
+    it('enters WRAPPING_UP on PARTICIPANT_LEAVE when this agent left and wrap-up is required', () => {
+      const service = startMachine();
+      const conferenceData = createTaskData({
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+            'agent-2': {id: 'agent-2', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+          },
+        } as any,
+      });
+      const leaveData = createTaskData({
+        wrapUpRequired: true,
+        participantId: 'agent-1',
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-2': {id: 'agent-2', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+          },
+        } as any,
+      });
+
+      primeConferencing(service, conferenceData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-1',
+        taskData: leaveData,
+      });
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('emits wrap-up once on PARTICIPANT_LEAVE when wrap-up is required', () => {
+      const emitTaskWrapup = jest.fn();
+      const service = createActor(
+        createTaskStateMachine(createConfig(), {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const conferenceData = createTaskData({
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+            'agent-2': {id: 'agent-2', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+          },
+        } as any,
+      });
+      const leaveData = createTaskData({
+        wrapUpRequired: true,
+        participantId: 'agent-1',
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-2': {id: 'agent-2', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+          },
+        } as any,
+      });
+
+      primeConferencing(service, conferenceData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-1',
+        taskData: leaveData,
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(emitTaskWrapup).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not wrap remaining agent on PARTICIPANT_LEAVE', () => {
+      const service = startMachine();
+      const conferenceData = createTaskData({
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+            'agent-2': {id: 'agent-2', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+            c1: {id: 'c1', pType: 'Customer', type: 'Customer', hasJoined: true, hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mediaType: 'telephony',
+              mediaMgr: 'mm',
+              participants: ['agent-1', 'agent-2', 'c1'],
+              mType: 'mainCall',
+              isHold: false,
+              holdTimestamp: null,
+            },
+          },
+        } as any,
+      });
+      const otherLeft = createTaskData({
+        wrapUpRequired: false,
+        participantId: 'agent-2',
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+            c1: {id: 'c1', pType: 'Customer', type: 'Customer', hasJoined: true, hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mediaType: 'telephony',
+              mediaMgr: 'mm',
+              participants: ['agent-1', 'c1'],
+              mType: 'mainCall',
+              isHold: false,
+              holdTimestamp: null,
+            },
+          },
+        } as any,
+      });
+
+      primeConferencing(service, conferenceData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-2',
+        taskData: otherLeft,
+      });
+      expect(service.getSnapshot().value).not.toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('downgrades to HELD on HOLD_SUCCESS when no other agents remain on task', () => {
+      const service = startMachine();
+      const conferenceTaskData = createSingleAgentConferenceTaskData('conference');
+      const heldTaskData = createSingleAgentConferenceTaskData('hold', true);
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
       service.send({type: TaskEvent.ASSIGN, taskData: conferenceTaskData});
       service.send({type: TaskEvent.CONFERENCE_START, taskData: conferenceTaskData});
       expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
@@ -1684,6 +2394,47 @@ describe('Task state machine', () => {
       expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
     });
 
+    it('downgrades to CONNECTED on PARTICIPANT_LEAVE when the current agent remains', () => {
+      const service = startMachine();
+      const conferenceTaskData = createSingleAgentConferenceTaskData('conference');
+      const connectedTaskData = createSingleAgentConferenceTaskData('connected');
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.ASSIGN, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData: conferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-2',
+        taskData: connectedTaskData,
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+    });
+
+    it('terminates instead of downgrading when PARTICIPANT_LEAVE identifies the current agent', () => {
+      const service = startMachine();
+      const conferenceTaskData = createSingleAgentConferenceTaskData('conference');
+      const connectedTaskData = {
+        ...createSingleAgentConferenceTaskData('connected'),
+        wrapUpRequired: false,
+      };
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.ASSIGN, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData: conferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-1',
+        taskData: connectedTaskData,
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+    });
+
     it('returns to CONNECTED when CTQ cancel arrives before queue connects', () => {
       const service = startMachine();
       const taskData = createTaskData();
@@ -1798,13 +2549,21 @@ describe('Task state machine', () => {
           owner: 'agent-1',
         } as any,
       });
-      service.send({type: TaskEvent.CONSULT_END, taskData: terminatedTaskData});
-      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
-    });
-
-    it('transitions to CONNECTED on CONSULT_END without isTerminated during CONF_INITIATING', () => {
-      const service = startMachine();
-      const taskData = createTaskData({consultingAgentId: 'agent-1'});
+      service.send({type: TaskEvent.CONSULT_END, taskData: terminatedTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('transitions to CONNECTED on CONSULT_END without isTerminated during CONF_INITIATING', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        consultingAgentId: 'agent-1',
+        interaction: {
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+        } as any,
+      });
 
       service.send({type: TaskEvent.TASK_INCOMING, taskData});
       service.send({type: TaskEvent.ASSIGN, taskData});
@@ -1820,10 +2579,8 @@ describe('Task state machine', () => {
       service.send({type: TaskEvent.CONSULT_END, taskData});
       expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
     });
-
   });
 
-
   describe('CONFERENCING state CONSULT_FAILED ANOTHER_CONSULT_IN_PROGRESS (CAI-8329)', () => {
     it('keeps hideBlindTransfer flag and hides transfer after secondary consult rejected from Agent Desktop', () => {
       const service = startMachine();
@@ -1848,7 +2605,12 @@ describe('Task state machine', () => {
               consultState: 'conferencing',
             },
             '+13159998059': {id: '+13159998059', pType: 'EP-DN', hasLeft: false},
-            '+14696762938': {id: '+14696762938', pType: 'Customer', hasJoined: true, hasLeft: false},
+            '+14696762938': {
+              id: '+14696762938',
+              pType: 'Customer',
+              hasJoined: true,
+              hasLeft: false,
+            },
           },
           media: {
             'interaction-1': {
@@ -1902,7 +2664,12 @@ describe('Task state machine', () => {
               consultState: 'conferencing',
             },
             '+13159998059': {id: '+13159998059', pType: 'EP-DN', hasLeft: false},
-            '+14696762938': {id: '+14696762938', pType: 'Customer', hasJoined: true, hasLeft: false},
+            '+14696762938': {
+              id: '+14696762938',
+              pType: 'Customer',
+              hasJoined: true,
+              hasLeft: false,
+            },
           },
           media: {
             'interaction-1': {
@@ -1920,12 +2687,19 @@ describe('Task state machine', () => {
           },
         } as any,
       });
-      service.send({type: TaskEvent.CONSULT_FAILED, taskData: consultFailedTaskData, reason: 'ANOTHER_CONSULT_IN_PROGRESS'});
+      service.send({
+        type: TaskEvent.CONSULT_FAILED,
+        taskData: consultFailedTaskData,
+        reason: 'ANOTHER_CONSULT_IN_PROGRESS',
+      });
 
       const snapshot = service.getSnapshot();
       expect(snapshot.value).toBe(TaskState.CONFERENCING);
       expect(snapshot.context.hideBlindTransferForEpDnPendingMerge).toBe(true);
-      expect(snapshot.context.uiControls.main.transfer).toEqual({isVisible: false, isEnabled: false});
+      expect(snapshot.context.uiControls.main.transfer).toEqual({
+        isVisible: false,
+        isEnabled: false,
+      });
       expect(snapshot.context.uiControls.main.consult).toEqual({isVisible: true, isEnabled: false});
     });
   });
@@ -2126,6 +2900,72 @@ describe('Task state machine', () => {
       service.send({type: TaskEvent.CONSULT_FAILED, taskData});
       expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
     });
+
+    it('emits only consult-end when an unaccepted consulted offer is ended', () => {
+      const emitTaskConsultEnd = jest.fn();
+      const emitTaskEnd = jest.fn();
+      const service = createActor(
+        createTaskStateMachine(createConfig(), {
+          actions: {emitTaskConsultEnd, emitTaskEnd},
+        })
+      );
+      service.start();
+      const taskData = createTaskData({isConsulted: true, consultingAgentId: 'agent-1'});
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.CONSULT_END, taskData});
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+      expect(emitTaskConsultEnd).toHaveBeenCalledTimes(1);
+      expect(emitTaskEnd).not.toHaveBeenCalled();
+    });
+
+    it('transitions to WRAPPING_UP on TASK_WRAPUP when wrapup is required', () => {
+      const service = startMachine();
+      const offerTaskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.OFFERED);
+
+      const wrapupTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
+        wrapUpRequired: true,
+        interaction: {
+          outboundType: 'OUTDIAL',
+          state: 'wrapUp',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.TASK_WRAPUP, taskData: wrapupTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('emits wrap-up once on TASK_WRAPUP from OFFERED when wrapup is required', () => {
+      const {emitTaskWrapup, publishWrapup} = createPublishAwareEmitTaskWrapupMock();
+      const service = createActor(
+        createTaskStateMachine(createConfig(), {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const offerTaskData = createTaskData({
+        interaction: {outboundType: 'OUTDIAL'} as any,
+      });
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.OFFERED);
+
+      const wrapupTaskData = createTaskData({
+        agentId: 'agent-1',
+        wrapUpRequired: true,
+        interaction: {outboundType: 'OUTDIAL', state: 'wrapUp', isTerminated: true} as any,
+      });
+      service.send({type: TaskEvent.TASK_WRAPUP, taskData: wrapupTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(publishWrapup).toHaveBeenCalledTimes(1);
+    });
   });
 
   describe('OUTBOUND_FAILED handling', () => {
@@ -2152,29 +2992,247 @@ describe('Task state machine', () => {
         } as any,
       });
 
-      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
-      expect(service.getSnapshot().value).toBe(TaskState.OFFERED);
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.OFFERED);
+
+      const failedTaskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({
+        type: TaskEvent.OUTBOUND_FAILED,
+        taskData: failedTaskData,
+        reason: 'CUSTOMER_BUSY',
+      });
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+    });
+
+    it('transitions from OFFERED to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+      const service = startMachine();
+      const offerTaskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.OFFERED);
+
+      const failedTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({
+        type: TaskEvent.OUTBOUND_FAILED,
+        taskData: failedTaskData,
+        reason: 'CUSTOMER_BUSY',
+      });
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('transitions from CONNECTED to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+      const service = startMachine();
+      const offerTaskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
+      service.send({type: TaskEvent.ASSIGN, taskData: offerTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+
+      const failedTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'AGENT_ENDS'});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('transitions from HELD to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.HOLD_INITIATED, mediaResourceId: taskData.mediaResourceId});
+      service.send({type: TaskEvent.HOLD_SUCCESS, mediaResourceId: taskData.mediaResourceId});
+      expect(service.getSnapshot().value).toBe(TaskState.HELD);
+
+      const failedTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'AGENT_ENDS'});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('transitions from CONSULTING to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-42', destinationType: 'agent'});
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
+
+      const failedTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'AGENT_ENDS'});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('transitions from CONFERENCING to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        consultingAgentId: 'agent-1',
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-42', destinationType: 'agent'});
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      service.send({type: TaskEvent.MERGE_TO_CONFERENCE});
+      service.send({type: TaskEvent.CONFERENCE_START});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      const failedTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'AGENT_ENDS'});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('transitions from HOLD_INITIATING to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.HOLD_INITIATED, mediaResourceId: taskData.mediaResourceId});
+      expect(service.getSnapshot().value).toBe(TaskState.HOLD_INITIATING);
+
+      const failedTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'AGENT_ENDS'});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('transitions from RESUME_INITIATING to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.HOLD_INITIATED, mediaResourceId: taskData.mediaResourceId});
+      service.send({type: TaskEvent.HOLD_SUCCESS, mediaResourceId: taskData.mediaResourceId});
+      service.send({type: TaskEvent.UNHOLD_INITIATED, mediaResourceId: taskData.mediaResourceId});
+      expect(service.getSnapshot().value).toBe(TaskState.RESUME_INITIATING);
+
+      const failedTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'AGENT_ENDS'});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('transitions from CONSULT_INITIATING to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-42', destinationType: 'agent'});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULT_INITIATING);
 
       const failedTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
         interaction: {
           outboundType: 'OUTDIAL',
           isTerminated: true,
         } as any,
       });
-      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'CUSTOMER_BUSY'});
-      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'AGENT_ENDS'});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
     });
 
-    it('transitions from OFFERED to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+    it('transitions from CONF_INITIATING to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
       const service = startMachine();
-      const offerTaskData = createTaskData({
+      const taskData = createTaskData({
+        consultingAgentId: 'agent-1',
         interaction: {
           outboundType: 'OUTDIAL',
         } as any,
       });
 
-      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
-      expect(service.getSnapshot().value).toBe(TaskState.OFFERED);
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-42', destinationType: 'agent'});
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      service.send({type: TaskEvent.MERGE_TO_CONFERENCE});
+      expect(service.getSnapshot().value).toBe(TaskState.CONF_INITIATING);
 
       const failedTaskData = createTaskData({
         agentId: 'agent-1',
@@ -2184,16 +3242,14 @@ describe('Task state machine', () => {
           isTerminated: true,
         } as any,
       });
-      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'CUSTOMER_BUSY'});
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'AGENT_ENDS'});
       expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
     });
   });
 
   describe('CONSULTING state TRANSFER_CONFERENCE_SUCCESS desktop-initiated (CAI-8329)', () => {
     const startAgent2Machine = () => {
-      const actor = createActor(
-        createTaskStateMachine({...createConfig(), agentId: 'agent-2'})
-      );
+      const actor = createActor(createTaskStateMachine({...createConfig(), agentId: 'agent-2'}));
       actor.start();
 
       return actor;
@@ -2292,7 +3348,54 @@ describe('Task state machine', () => {
         } as any,
       });
 
-    const setupSecondaryAgentConsultingFromConference = (service: ReturnType<typeof startAgent2Machine>) => {
+    const createSecondaryAgentRemovedTaskData = () =>
+      createTaskData({
+        agentId: 'agent-2',
+        isConsulted: true,
+        interactionId: 'interaction-1',
+        mediaResourceId: 'interaction-1',
+        consultMediaResourceId: 'consult-media-1',
+        interaction: {
+          state: 'conference',
+          owner: 'agent-1',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'conferencing',
+            },
+            'agent-3': {
+              id: 'agent-3',
+              pType: 'Agent',
+              hasLeft: false,
+              isConsulted: true,
+              consultState: 'consulting',
+            },
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'arbitrary-main-media-key': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: ['agent-1', 'customer-1'],
+              isHold: false,
+            },
+            'consult-media-1': {
+              mediaResourceId: 'consult-media-1',
+              mType: 'consult',
+              participants: ['agent-2', 'agent-3'],
+              isHold: false,
+            },
+          },
+        } as any,
+      });
+
+    const setupSecondaryAgentConsultingFromConference = (
+      service: ReturnType<typeof startAgent2Machine>
+    ) => {
       const conferenceTaskData = createSecondaryAgentConferenceBaseTaskData();
       const consultingTaskData = createSecondaryAgentConsultingTaskData();
 
@@ -2339,7 +3442,10 @@ describe('Task state machine', () => {
       setupSecondaryAgentDesktopConsultingFromConference(service);
 
       const transferSuccessTaskData = createSecondaryAgentConsultingTaskData();
-      service.send({type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS, taskData: transferSuccessTaskData});
+      service.send({
+        type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS,
+        taskData: transferSuccessTaskData,
+      });
 
       expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
     });
@@ -2349,7 +3455,10 @@ describe('Task state machine', () => {
       setupSecondaryAgentConsultingFromConference(service);
 
       const transferSuccessTaskData = createSecondaryAgentConsultingTaskData();
-      service.send({type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS, taskData: transferSuccessTaskData});
+      service.send({
+        type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS,
+        taskData: transferSuccessTaskData,
+      });
 
       const snapshot = service.getSnapshot();
       expect(snapshot.value).toBe(TaskState.TERMINATED);
@@ -2359,9 +3468,7 @@ describe('Task state machine', () => {
 
     it('moves consultee to CONFERENCING when primary agent conference-transfers', () => {
       const startAgent3Machine = () => {
-        const actor = createActor(
-          createTaskStateMachine({...createConfig(), agentId: 'agent-3'})
-        );
+        const actor = createActor(createTaskStateMachine({...createConfig(), agentId: 'agent-3'}));
         actor.start();
 
         return actor;
@@ -2524,7 +3631,10 @@ describe('Task state machine', () => {
       expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
       expect(service.getSnapshot().context.consultInitiator).toBe(false);
 
-      service.send({type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS, taskData: transferSuccessTaskData});
+      service.send({
+        type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS,
+        taskData: transferSuccessTaskData,
+      });
       expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
     });
 
@@ -2582,7 +3692,10 @@ describe('Task state machine', () => {
       expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
       expect(service.getSnapshot().context.consultInitiator).toBe(false);
 
-      service.send({type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS, taskData: transferSuccessTaskData});
+      service.send({
+        type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS,
+        taskData: transferSuccessTaskData,
+      });
       expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
     });
 
@@ -2592,11 +3705,87 @@ describe('Task state machine', () => {
 
       const transferSuccessTaskData = createSecondaryAgentConsultingTaskData();
       service.send({type: TaskEvent.TRANSFER_CONFERENCE});
-      service.send({type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS, taskData: transferSuccessTaskData});
+      service.send({
+        type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS,
+        taskData: transferSuccessTaskData,
+      });
 
       expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
     });
 
+    it('emits wrap-up once on TRANSFER_CONFERENCE_SUCCESS from CONSULTING when wrap-up is required', () => {
+      const {emitTaskWrapup, publishWrapup} = createPublishAwareEmitTaskWrapupMock();
+      const service = createActor(
+        createTaskStateMachine({...createConfig(), agentId: 'agent-1'}, {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const taskData = createTaskData({
+        agentId: 'agent-1',
+        consultingAgentId: 'agent-1',
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+            'agent-2': {id: 'agent-2', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+          },
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-2', destinationType: 'agent'});
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
+
+      service.send({type: TaskEvent.TRANSFER_CONFERENCE});
+      service.send({
+        type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS,
+        taskData: {...taskData, wrapUpRequired: true},
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(publishWrapup).toHaveBeenCalledTimes(1);
+    });
+
+    it('emits wrap-up once on TRANSFER_CONFERENCE_SUCCESS from CONFERENCING when wrap-up is required', () => {
+      const {emitTaskWrapup, publishWrapup} = createPublishAwareEmitTaskWrapupMock();
+      const service = createActor(
+        createTaskStateMachine({...createConfig(), agentId: 'agent-1'}, {actions: {emitTaskWrapup}})
+      );
+      service.start();
+      const taskData = createTaskData({
+        agentId: 'agent-1',
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+            'agent-2': {id: 'agent-2', pType: 'Agent', type: 'Agent', hasJoined: true, hasLeft: false},
+          },
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.MERGE_TO_CONFERENCE});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      service.send({type: TaskEvent.TRANSFER_CONFERENCE});
+      service.send({
+        type: TaskEvent.TRANSFER_CONFERENCE_SUCCESS,
+        taskData: {...taskData, wrapUpRequired: true},
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+      expect(publishWrapup).toHaveBeenCalledTimes(1);
+    });
+
     it('terminates secondary agent on PARTICIPANT_LEAVE while in CONSULTING during conference', () => {
       const service = startAgent2Machine();
       setupSecondaryAgentDesktopConsultingFromConference(service);
@@ -2647,5 +3836,192 @@ describe('Task state machine', () => {
 
       expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
     });
+
+    it('terminates secondary agent on PARTICIPANT_LEAVE while consult is initiating', () => {
+      const service = startAgent2Machine();
+      const conferenceTaskData = createSecondaryAgentConferenceBaseTaskData();
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.ASSIGN, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-3', destinationType: 'agent'});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULT_INITIATING);
+      expect(service.getSnapshot().context.taskData.interaction).toBe(
+        conferenceTaskData.interaction
+      );
+      expect(service.getSnapshot().context.taskData.destAgentId).toBe('agent-3');
+
+      const participantLeaveEvent = {
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        taskData: createSecondaryAgentRemovedTaskData(),
+      } as const;
+      expect(
+        guards.didCurrentAgentLeaveMainInteraction({
+          context: service.getSnapshot().context,
+          event: participantLeaveEvent,
+        })
+      ).toBe(true);
+
+      service.send(participantLeaveEvent);
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+    });
+
+    it('terminates secondary agent on CONSULT_END while consult is initiating', () => {
+      const service = startAgent2Machine();
+      const conferenceTaskData = createSecondaryAgentConferenceBaseTaskData();
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.ASSIGN, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-3', destinationType: 'agent'});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULT_INITIATING);
+
+      const consultEndEvent = {
+        type: TaskEvent.CONSULT_END,
+        taskData: createSecondaryAgentRemovedTaskData(),
+      } as const;
+      expect(
+        guards.didCurrentAgentLeaveMainInteraction({
+          context: service.getSnapshot().context,
+          event: consultEndEvent,
+        })
+      ).toBe(true);
+
+      service.send(consultEndEvent);
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+    });
+
+    it('terminates a consulting secondary initiator when CONSULT_END removes it from mainCall', () => {
+      const service = startAgent2Machine();
+      setupSecondaryAgentConsultingFromConference(service);
+
+      service.send({
+        type: TaskEvent.CONSULT_END,
+        taskData: createSecondaryAgentRemovedTaskData(),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+      expect(service.getSnapshot().context.consultInitiator).toBe(false);
+      expect(service.getSnapshot().context.consultDestinationAgentJoined).toBe(false);
+    });
+
+    it('does not infer departure from a partial CONSULT_END payload', () => {
+      const service = startAgent2Machine();
+      setupSecondaryAgentConsultingFromConference(service);
+      const partialTaskData = {
+        ...createTaskData({agentId: 'agent-2', interactionId: 'interaction-1'}),
+        interaction: {
+          state: 'conference',
+          interactionId: 'interaction-1',
+          mainInteractionId: 'interaction-1',
+        },
+      } as any;
+
+      const consultEndEvent = {type: TaskEvent.CONSULT_END, taskData: partialTaskData} as const;
+      expect(service.getSnapshot().context.consultInitiator).toBe(true);
+      expect(
+        guards.didCurrentAgentLeaveMainInteraction({
+          context: service.getSnapshot().context,
+          event: consultEndEvent,
+        })
+      ).toBe(false);
+
+      service.send(consultEndEvent);
+
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+    });
+
+    it('emits consult-end and task-end when AgentConsultEnded terminates the consulted agent', () => {
+      const emitTaskConsultEnd = jest.fn();
+      const emitTaskEnd = jest.fn();
+      const cleanupResources = jest.fn();
+      const service = createActor(
+        createTaskStateMachine(
+          {...createConfig(), agentId: 'agent-3'},
+          {
+            actions: {emitTaskConsultEnd, emitTaskEnd, cleanupResources},
+          }
+        )
+      );
+      service.start();
+
+      const consultingTaskData = createTaskData({
+        agentId: 'agent-3',
+        isConsulted: true,
+        interactionId: 'consult-child',
+        interaction: {
+          state: 'consulting',
+          owner: 'agent-1',
+          interactionId: 'consult-child',
+          mainInteractionId: 'interaction-1',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+            'agent-2': {
+              id: 'agent-2',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consulting',
+            },
+            'agent-3': {
+              id: 'agent-3',
+              pType: 'Agent',
+              hasLeft: false,
+              isConsulted: true,
+              consultState: 'consulting',
+            },
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: ['agent-1', 'agent-2', 'customer-1'],
+              isHold: true,
+            },
+            'consult-child': {
+              mediaResourceId: 'consult-child',
+              mType: 'consult',
+              participants: ['agent-2', 'agent-3'],
+              isHold: false,
+            },
+          },
+        } as any,
+      });
+      service.send({type: TaskEvent.HYDRATE, taskData: consultingTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
+
+      const consultEndedTaskData = createTaskData({
+        ...consultingTaskData,
+        type: 'AgentConsultEnded' as any,
+        interaction: {
+          ...consultingTaskData.interaction,
+          state: 'conference',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+            'agent-2': {id: 'agent-2', pType: 'Agent', hasLeft: false},
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: ['agent-1', 'agent-2', 'customer-1'],
+              isHold: false,
+            },
+          },
+        } as any,
+      });
+
+      service.send({type: TaskEvent.CONSULT_END, taskData: consultEndedTaskData});
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+      expect(emitTaskConsultEnd).toHaveBeenCalledTimes(1);
+      expect(emitTaskEnd).toHaveBeenCalledTimes(1);
+      expect(cleanupResources).toHaveBeenCalledTimes(1);
+      expect(service.getSnapshot().context.consultDestinationAgentJoined).toBe(false);
+      expect(service.getSnapshot().context.consultInitiator).toBe(false);
+    });
   });
 });