@webex/contact-center 3.12.0-next.147 → 3.12.0-next.149

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

@@ -1,19 +1,195 @@
 import 'jsdom-global/register';
 import EventEmitter from 'events';
-import {LoginOption, WebexSDK} from '../../../../../src/types';
+import {ConfigFlags, LoginOption, WebexSDK} from '../../../../../src/types';
 import {CALL_EVENT_KEYS, CallingClientConfig, LINE_EVENTS} from '@webex/calling';
-import {CC_AGENT_EVENTS, CC_EVENTS} from '../../../../../src/services/config/types';
+import {
+  CC_AGENT_EVENTS,
+  CC_TASK_EVENTS,
+  CC_EVENTS,
+  WrapupData,
+} from '../../../../../src/services/config/types';
 import TaskManager from '../../../../../src/services/task/TaskManager';
-import * as contact from '../../../../../src/services/task/contact';
 import Task from '../../../../../src/services/task/Task';
+import * as contact from '../../../../../src/services/task/contact';
 import {TASK_EVENTS} from '../../../../../src/services/task/types';
 import {TaskEvent, TaskState} from '../../../../../src/services/task/state-machine';
 import WebRTC from '../../../../../src/services/task/voice/WebRTC';
-import {Profile} from '../../../../../src/services/config/types';
 import WebCallingService from '../../../../../src/services/WebCallingService';
 import config from '../../../../../src/config';
-import {CC_TASK_EVENTS} from '../../../../../src/services/config/types';
 import TaskFactory from '../../../../../src/services/task/TaskFactory';
+import {
+  AI_SUMMARY_DURATION_MS,
+  AI_SUMMARY_REQUEST_CANCELLED,
+  METHODS,
+} from '../../../../../src/services/task/constants';
+import {AI_SUMMARY_ERROR_CODES, TASK_MANAGER_FILE} from '../../../../../src/constants';
+import {
+  checkParticipantNotInInteraction,
+  getConferenceParticipantsCount,
+  getConsultMediaResourceId,
+  getIsConsultInProgressForConferenceControls,
+  getIsConsultedAgentForControls,
+  getIsCustomerInCall,
+  getServerHoldStateForControls,
+  hasAgentInitiatedOutdial,
+  isAutoAnswerEnabled,
+  isCampaignPreviewReservation,
+  isCampaignPreviewTask,
+  isDigitalOutbound,
+  isParticipantInMainInteraction,
+  isPrimary,
+  isSecondaryAgent,
+  isSecondaryEpDnAgent,
+  isWebRTCCall,
+  shouldAutoAnswerTask,
+} from '../../../../../src/services/task/TaskUtils';
+
+jest.mock('../../../../../src/logger-proxy', () => ({
+  __esModule: true,
+  default: {
+    error: jest.fn(),
+    info: jest.fn(),
+    log: jest.fn(),
+    warn: jest.fn(),
+  },
+}));
+
+jest.mock('../../../../../src/services/task/contact', () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+
+jest.mock('../../../../../src/services/WebCallingService', () => {
+  const EventEmitter = require('events');
+
+  return {
+    __esModule: true,
+    default: class MockWebCallingService extends EventEmitter {
+      loginOption?: string;
+      call?: unknown;
+      mapCallToTask = jest.fn();
+      cleanUpCall = jest.fn(() => {
+        (this.call as {off?: (event: string, listener: () => void) => void})?.off?.(
+          'remote_media',
+          () => undefined
+        );
+        (this.call as {off?: (event: string, listener: () => void) => void})?.off?.(
+          'disconnect',
+          () => undefined
+        );
+      });
+    },
+  };
+});
+
+jest.mock('../../../../../src/services/task/TaskFactory', () => ({
+  __esModule: true,
+  default: {
+    createTask: jest.fn(),
+  },
+}));
+
+jest.mock('../../../../../src/services/task/state-machine', () => {
+  const TaskEvent = {
+    TASK_INCOMING: 'TASK_INCOMING',
+    TASK_OFFERED: 'TASK_OFFERED',
+    OFFER_CONSULT: 'OFFER_CONSULT',
+    HYDRATE: 'HYDRATE',
+    CONTACT_UPDATED: 'CONTACT_UPDATED',
+    CONTACT_OWNER_CHANGED: 'CONTACT_OWNER_CHANGED',
+    ASSIGN: 'ASSIGN',
+    HOLD_SUCCESS: 'HOLD_SUCCESS',
+    UNHOLD_SUCCESS: 'UNHOLD_SUCCESS',
+    CONSULT_CREATED: 'CONSULT_CREATED',
+    CONSULTING_ACTIVE: 'CONSULTING_ACTIVE',
+    CONSULT_END: 'CONSULT_END',
+    CONSULT_FAILED: 'CONSULT_FAILED',
+    CTQ_CANCEL: 'CTQ_CANCEL',
+    CTQ_CANCEL_FAILED: 'CTQ_CANCEL_FAILED',
+    CONFERENCE_START: 'CONFERENCE_START',
+    CONFERENCE_FAILED: 'CONFERENCE_FAILED',
+    CONFERENCE_END: 'CONFERENCE_END',
+    PARTICIPANT_LEAVE: 'PARTICIPANT_LEAVE',
+    TRANSFER_SUCCESS: 'TRANSFER_SUCCESS',
+    TRANSFER_FAILED: 'TRANSFER_FAILED',
+    TRANSFER_CONFERENCE_SUCCESS: 'TRANSFER_CONFERENCE_SUCCESS',
+    TASK_WRAPUP: 'TASK_WRAPUP',
+    CONTACT_ENDED: 'CONTACT_ENDED',
+    WRAPUP_COMPLETE: 'WRAPUP_COMPLETE',
+    ASSIGN_FAILED: 'ASSIGN_FAILED',
+    INVITE_FAILED: 'INVITE_FAILED',
+    RONA: 'RONA',
+    OUTBOUND_FAILED: 'OUTBOUND_FAILED',
+    PAUSE_RECORDING: 'PAUSE_RECORDING',
+    RECORDING_STARTED: 'RECORDING_STARTED',
+    RESUME_RECORDING: 'RESUME_RECORDING',
+    CAMPAIGN_PREVIEW_ACCEPT_FAILED: 'CAMPAIGN_PREVIEW_ACCEPT_FAILED',
+    CAMPAIGN_PREVIEW_SKIP_FAILED: 'CAMPAIGN_PREVIEW_SKIP_FAILED',
+    CAMPAIGN_PREVIEW_REMOVE_FAILED: 'CAMPAIGN_PREVIEW_REMOVE_FAILED',
+    END: 'END',
+  };
+
+  const TaskState = {
+    IDLE: 'IDLE',
+    OFFERED: 'OFFERED',
+    CONNECTED: 'CONNECTED',
+    HOLD_INITIATING: 'HOLD_INITIATING',
+    HELD: 'HELD',
+    RESUME_INITIATING: 'RESUME_INITIATING',
+    CONSULT_INITIATING: 'CONSULT_INITIATING',
+    CONSULTING: 'CONSULTING',
+    CONF_INITIATING: 'CONF_INITIATING',
+    CONFERENCING: 'CONFERENCING',
+    TERMINATED: 'TERMINATED',
+  };
+
+  return {
+    __esModule: true,
+    TaskEvent,
+    TaskState,
+    createTaskStateMachine: jest.requireActual(
+      '../../../../../src/services/task/state-machine'
+    ).createTaskStateMachine,
+  };
+});
+
+jest.mock('../../../../../src/services/task/voice/WebRTC', () => {
+  const EventEmitter = require('events');
+
+  return {
+    __esModule: true,
+    default: class MockWebRTC extends EventEmitter {
+      data: Record<string, unknown>;
+      webCallingService: EventEmitter;
+      handleRemoteMedia = jest.fn();
+      unregisterWebCallListeners = jest.fn(() => {
+        this.webCallingService.off('remote_media', this.handleRemoteMedia);
+      });
+      cancelAutoWrapupTimer = jest.fn();
+      updateUiControls = jest.fn();
+      updateTaskData = jest.fn((newData) => {
+        this.data = {...this.data, ...newData};
+
+        return this;
+      });
+      sendStateMachineEvent = jest.fn((event) => {
+        if (event.taskData) {
+          this.updateTaskData(event.taskData);
+        }
+        if (event.type === 'CONTACT_ENDED') {
+          this.emit('task:cleanup', this, {removeFromCollection: false});
+        }
+      });
+
+      constructor(_contact: unknown, _webCallingService: unknown, data: Record<string, unknown>) {
+        super();
+        this.data = data;
+        this.webCallingService = _webCallingService as EventEmitter;
+        this.webCallingService.on('remote_media', this.handleRemoteMedia);
+      }
+    },
+  };
+});
 
 describe('TaskManager', () => {
   let mockCall;
@@ -28,9 +204,118 @@ describe('TaskManager', () => {
   let webCallingService;
   let webex: WebexSDK;
   const taskId = '0ae913a4-c857-4705-8d49-76dd3dde75e4';
+  const createRtdError = (errorCode: string) => {
+    const error = new Error(errorCode) as Error & {data?: Record<string, unknown>};
+    error.data = {errorCode};
+
+    return error;
+  };
+  const createPendingRtdRequest = (
+    api: any,
+    correlationId: string,
+    eventType: string,
+    timeoutCode: string
+  ) =>
+    ({
+      result: api.requestAndWaitForRtd({
+        correlationId,
+        rtdEventType: eventType,
+        timeoutMs: AI_SUMMARY_DURATION_MS,
+        createTimeoutError: () => createRtdError(timeoutCode),
+        agentId: 'agent-1',
+        interactionId: 'interaction-1',
+        eventType: 'CTI_EVENT',
+        eventName: 'GET_POST_CALL_SUMMARY',
+      }),
+    });
+  const createSummaryApiMock = () => {
+    const pendingRequests = new Map<string, any>();
+    const api: any = {
+      sendEvent: jest.fn().mockResolvedValue({}),
+      pendingRequests,
+    };
+    api.requestAndWaitForRtd = jest.fn(async (options: any) => {
+      const key = JSON.stringify([options.rtdEventType, options.correlationId]);
+      const previousRequest = pendingRequests.get(key);
+      if (previousRequest) {
+        clearTimeout(previousRequest.timeoutId);
+      }
+      let resolveResult: (payload: any) => void = () => undefined;
+      let rejectResult: (error: Error) => void = () => undefined;
+      const result = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+      });
+      const request = {
+        correlationId: options.correlationId,
+        eventType: options.rtdEventType,
+        result,
+        resolve: resolveResult,
+        reject: rejectResult,
+        timeoutId: setTimeout(() => {
+          pendingRequests.delete(key);
+          rejectResult(options.createTimeoutError());
+        }, options.timeoutMs),
+      };
+      pendingRequests.set(key, request);
+
+      const acknowledgement = api.sendEvent(
+        options.agentId,
+        options.interactionId,
+        options.eventType,
+        options.eventName,
+        options.eventMetaData,
+        undefined,
+        undefined,
+        options.publishTimestamp,
+        options.timeout
+      );
+      try {
+        const [payload] = await Promise.all([result, acknowledgement]);
+        return payload;
+      } catch (error) {
+        clearTimeout(request.timeoutId);
+        if (pendingRequests.get(key) === request) {
+          pendingRequests.delete(key);
+        }
+        throw error;
+      }
+    });
+    api.resolveFromRtdEvent = jest.fn((eventType: string, correlationId: string, payload: any) => {
+      const key = JSON.stringify([eventType, correlationId]);
+      const request = pendingRequests.get(key);
+      if (!request) return 'not-found';
+      clearTimeout(request.timeoutId);
+      pendingRequests.delete(key);
+      request.resolve(payload);
+      return 'resolved';
+    });
+    api.clearAllRtdRequests = jest.fn(() => {
+      Array.from(pendingRequests.values()).forEach((request: any) => {
+        clearTimeout(request.timeoutId);
+        request.reject(createRtdError(AI_SUMMARY_REQUEST_CANCELLED));
+      });
+      pendingRequests.clear();
+    });
+
+    return api;
+  };
+  const getLoggerProxy = (): Record<string, jest.Mock> =>
+    require('../../../../../src/logger-proxy').default;
+  const expectNoSensitiveDiagnostics = (...sensitiveValues: string[]) => {
+    const diagnostics = JSON.stringify({
+      warnings: getLoggerProxy().warn.mock.calls,
+      errors: getLoggerProxy().error.mock.calls,
+    });
+
+    sensitiveValues.forEach((value) => {
+      expect(diagnostics).not.toContain(value);
+    });
+  };
 
-  const createMockTask = (data = taskDataMock) => {
+  const createEventEmitterTask = (data = taskDataMock) => {
     const task = new EventEmitter() as any;
+    const originalOn = task.on.bind(task);
 
     const updateTaskData = jest.fn().mockImplementation((newData) => {
       task.data = {...task.data, ...newData};
@@ -39,13 +324,21 @@ describe('TaskManager', () => {
 
     Object.assign(task, {
       data,
+      on: jest.fn((...args) => originalOn(...args)),
       accept: jest.fn(),
       decline: jest.fn(),
       updateTaskData,
+      setFeatureEnablement: jest.fn(),
       unregisterWebCallListeners: jest.fn(),
       cancelAutoWrapupTimer: jest.fn(),
     });
 
+    return task;
+  };
+
+  const createStateMachineTask = (data = taskDataMock) => {
+    const task = createEventEmitterTask(data);
+
     const taskEventMap: Partial<Record<TaskEvent, string>> = {
       [TaskEvent.TASK_INCOMING]: TASK_EVENTS.TASK_INCOMING,
       [TaskEvent.TASK_OFFERED]: TASK_EVENTS.TASK_OFFER_CONTACT,
@@ -73,12 +366,30 @@ describe('TaskManager', () => {
       [TaskEvent.WRAPUP_COMPLETE]: TASK_EVENTS.TASK_WRAPPEDUP,
     };
 
+    // Mirrors the real state machine's offered (ringing) and answered states.
+    const taskStateMap: Partial<Record<TaskEvent, string>> = {
+      [TaskEvent.TASK_INCOMING]: TaskState.OFFERED,
+      [TaskEvent.TASK_OFFERED]: TaskState.OFFERED,
+      [TaskEvent.OFFER_CONSULT]: TaskState.OFFERED,
+      [TaskEvent.ASSIGN]: TaskState.CONNECTED,
+      [TaskEvent.CONSULTING_ACTIVE]: TaskState.CONSULTING,
+      [TaskEvent.HYDRATE]: TaskState.CONNECTED,
+      // Offers that end without being answered.
+      [TaskEvent.RONA]: TaskState.TERMINATED,
+      [TaskEvent.ASSIGN_FAILED]: TaskState.TERMINATED,
+      [TaskEvent.CONSULT_END]: TaskState.TERMINATED,
+    };
+
     task.sendStateMachineEvent = jest.fn().mockImplementation((event) => {
       if (event.taskData) {
         task.updateTaskData(event.taskData);
       }
 
-      const mappedEvent = taskEventMap[event.type as TaskEvent];
+      let mappedEvent = taskEventMap[event.type as TaskEvent];
+      if (event.type === TaskEvent.TASK_INCOMING && event.isCampaignReservationAccept === true) {
+        mappedEvent = TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION;
+      }
+
       if (mappedEvent) {
         if (
           [TaskEvent.ASSIGN_FAILED, TaskEvent.RONA, TaskEvent.INVITE_FAILED].includes(
@@ -129,11 +440,18 @@ describe('TaskManager', () => {
         const removeFromCollection = eventType !== TaskEvent.CONTACT_ENDED;
         task.emit(TASK_EVENTS.TASK_CLEANUP, task, {removeFromCollection});
       }
+
+      // Like Task's state machine subscriber, `state` updates after the transition's emissions.
+      if (taskStateMap[eventType]) {
+        task.state = {value: taskStateMap[eventType]};
+      }
     });
 
     return task;
   };
 
+  const createMockTask = createStateMachineTask;
+
   taskDataMock = {
     type: CC_EVENTS.AGENT_CONTACT_RESERVED,
     agentId: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
@@ -197,10 +515,7 @@ describe('TaskManager', () => {
     onSpy = jest.spyOn(webCallingService, 'on');
     offSpy = jest.spyOn(webCallingService, 'off');
 
-    mockApiAIAssistant = {
-      sendEvent: jest.fn().mockResolvedValue({}),
-    };
-
+    mockApiAIAssistant = createSummaryApiMock();
     taskManager = new TaskManager(
       mockApiAIAssistant as any,
       contactMock,
@@ -208,17 +523,20 @@ describe('TaskManager', () => {
       webSocketManagerMock as any,
       rtdWebSocketManagerMock as any
     );
-    taskManager.taskCollection[taskId] = createMockTask(taskDataMock);
+    taskManager.taskCollection[taskId] = createStateMachineTask(taskDataMock);
     (taskManager as any).setupTaskListeners?.(taskManager.taskCollection[taskId]);
     taskManager.call = mockCall;
     taskManager.setAgentId('test-agent-id');
 
     jest
       .spyOn(TaskFactory, 'createTask')
-      .mockImplementation((contact, webCallingService, data, configFlags) => createMockTask(data));
+      .mockImplementation((contact, webCallingService, data, configFlags) =>
+        createStateMachineTask(data)
+      );
   });
 
   afterEach(() => {
+    jest.useRealTimers();
     jest.clearAllMocks();
     jest.resetAllMocks();
   });
@@ -251,188 +569,1978 @@ describe('TaskManager', () => {
     expect(webCallingService.listenerCount(LINE_EVENTS.INCOMING_CALL)).toBe(1);
     expect(webSocketManagerMock.listenerCount('message')).toBe(1);
 
-    webSocketManagerMock.emit('message', JSON.stringify(dummyPayload));
+    webSocketManagerMock.emit('message', JSON.stringify(dummyPayload));
+
+    expect(taskEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_CONSULT_ACCEPTED,
+      taskManager.getTask(taskId)
+    );
+  });
+
+  it('should invoke sendEvent for configured start/stop backend events', () => {
+    taskManager.setConfigFlags({
+      isEndTaskEnabled: true,
+      isEndConsultEnabled: true,
+      webRtcEnabled: true,
+      autoWrapup: false,
+      aiFeature: {
+        id: 'ai-feature-1',
+        realtimeTranscripts: {
+          enable: true,
+        },
+      },
+    });
+
+    const interactionId = taskId;
+    const message = (type: CC_EVENTS) =>
+      JSON.stringify({
+        data: {
+          ...taskDataMock,
+          interactionId,
+          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.PARTICIPANT_LEFT_CONFERENCE));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_WRAPUP));
+
+    expect(mockApiAIAssistant.sendEvent).toHaveBeenCalledTimes(6);
+    expect(mockApiAIAssistant.sendEvent).toHaveBeenCalledWith(
+      'test-agent-id',
+      interactionId,
+      'CUSTOM_EVENT',
+      'GET_TRANSCRIPTS',
+      {action: 'START'}
+    );
+    expect(mockApiAIAssistant.sendEvent).toHaveBeenCalledWith(
+      'test-agent-id',
+      interactionId,
+      'CUSTOM_EVENT',
+      'GET_TRANSCRIPTS',
+      {action: 'STOP'}
+    );
+  });
+
+  it('should not invoke sendEvent when realtime transcripts are disabled in aiFeature', () => {
+    taskManager.setConfigFlags({
+      isEndTaskEnabled: true,
+      isEndConsultEnabled: true,
+      webRtcEnabled: true,
+      autoWrapup: false,
+      aiFeature: {
+        id: 'ai-feature-1',
+        realtimeTranscripts: {
+          enable: false,
+        },
+      },
+    });
+
+    const message = (type: CC_EVENTS) =>
+      JSON.stringify({
+        data: {
+          ...taskDataMock,
+          interactionId: taskId,
+          type,
+        },
+      });
+
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONTACT_ASSIGNED));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULTING));
+
+    expect(mockApiAIAssistant.sendEvent).not.toHaveBeenCalled();
+  });
+
+  it('should not invoke sendEvent when realtime transcripts config is missing', () => {
+    taskManager.setConfigFlags({
+      isEndTaskEnabled: true,
+      isEndConsultEnabled: true,
+      webRtcEnabled: true,
+      autoWrapup: false,
+      aiFeature: {
+        id: 'ai-feature-1',
+        suggestedResponses: {
+          enable: true,
+        },
+      },
+    });
+
+    const message = (type: CC_EVENTS) =>
+      JSON.stringify({
+        data: {
+          ...taskDataMock,
+          interactionId: taskId,
+          type,
+        },
+      });
+
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONTACT_ASSIGNED));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULTING));
+
+    expect(mockApiAIAssistant.sendEvent).not.toHaveBeenCalled();
+  });
+
+  it('should preserve REAL_TIME_TRANSCRIPTION payloads exactly once across AI summary frames', () => {
+    const task = taskManager.getTask(taskId);
+    const taskEmitSpy = jest.spyOn(task, 'emit');
+    const observedOrder: string[] = [];
+    const transcriptHandler = jest.fn((payload) => {
+      observedOrder.push(`transcript:${payload.data.messageId}`);
+    });
+    const createRealtimePayload = (messageId: string, content: string) => ({
+      data: {
+        agentId: 'test-agent-id',
+        data: {
+          content,
+          conversationId: taskId,
+          isFinal: true,
+          languageCode: 'en-US',
+          messageId,
+          orgId: 'org-id',
+          publishTimestamp: 1773807297475,
+          role: 'AGENT',
+          trackingId: `tracking-id-${messageId}`,
+          utteranceId: `utterance-id-${messageId}`,
+        },
+        notifDetails: {
+          actionEvent: 'REAL_TIME_TRANSCRIPTION',
+        },
+        notifType: 'REAL_TIME_TRANSCRIPTION',
+        orgId: 'org-id',
+      },
+      orgId: 'org-id',
+      trackingId: 'notifs_tracking-id',
+      type: 'REAL_TIME_TRANSCRIPTION',
+    });
+    const firstRealtimePayload = createRealtimePayload('1', 'Thank you. Okay.');
+    const secondRealtimePayload = createRealtimePayload('2', 'I can help with that.');
+
+    task.on(CC_EVENTS.REAL_TIME_TRANSCRIPTION, transcriptHandler);
+    taskManager.handleRealtimeWebsocketEvent(JSON.stringify(firstRealtimePayload));
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.POST_CALL_SUMMARY,
+        data: {data: {conversationId: taskId, summaryText: {invalid: true}}},
+      })
+    );
+    taskManager.handleRealtimeWebsocketEvent(JSON.stringify(secondRealtimePayload));
+
+    expect(taskEmitSpy).toHaveBeenCalledTimes(2);
+    expect(taskEmitSpy).toHaveBeenNthCalledWith(
+      1,
+      CC_EVENTS.REAL_TIME_TRANSCRIPTION,
+      firstRealtimePayload.data
+    );
+    expect(taskEmitSpy).toHaveBeenNthCalledWith(
+      2,
+      CC_EVENTS.REAL_TIME_TRANSCRIPTION,
+      secondRealtimePayload.data
+    );
+    expect(transcriptHandler).toHaveBeenCalledTimes(2);
+    expect(transcriptHandler).toHaveBeenNthCalledWith(1, firstRealtimePayload.data);
+    expect(transcriptHandler).toHaveBeenNthCalledWith(2, secondRealtimePayload.data);
+    expect(observedOrder).toEqual(['transcript:1', 'transcript:2']);
+  });
+
+  it('should ignore RTD transcript events when task is not found', () => {
+    const realtimePayload = {
+      data: {
+        data: {
+          content: 'Thank you. Okay.',
+          conversationId: 'missing-task-id',
+          isFinal: true,
+          languageCode: 'en-US',
+          messageId: '1',
+          orgId: 'org-id',
+          publishTimestamp: 1773807297475,
+          role: 'AGENT',
+          trackingId: 'tracking-id',
+          utteranceId: 'utterance-id',
+        },
+        notifDetails: {
+          actionEvent: 'REAL_TIME_TRANSCRIPTION',
+        },
+        notifType: 'REAL_TIME_TRANSCRIPTION',
+        orgId: 'org-id',
+      },
+      orgId: 'org-id',
+      trackingId: 'notifs_tracking-id',
+      type: 'REAL_TIME_TRANSCRIPTION',
+    };
+
+    const existingTaskEmitSpy = jest.spyOn(taskManager.getTask(taskId), 'emit');
+
+    taskManager.handleRealtimeWebsocketEvent(JSON.stringify(realtimePayload));
+
+    expect(existingTaskEmitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should update the matching task with the latest feature enablement frame', () => {
+    const payload = {
+      type: CC_TASK_EVENTS.FEATURE_ENABLEMENT,
+      data: {
+        data: {
+          interactionId: taskId,
+          postCallEnabled: true,
+          midCallEnabled: false,
+          actionTimestamp: 10,
+        },
+      },
+    };
+
+    taskManager.handleRealtimeWebsocketEvent(JSON.stringify(payload));
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.FEATURE_ENABLEMENT,
+        data: {
+          data: {
+            interactionId: taskId,
+            postCallEnabled: undefined,
+            midCallEnabled: true,
+          },
+        },
+      })
+    );
+
+    expect((taskManager.getTask(taskId) as any).setFeatureEnablement).toHaveBeenLastCalledWith({
+      interactionId: taskId,
+      postCallEnabled: undefined,
+      midCallEnabled: true,
+    });
+  });
+
+  it('should emit task:featureEnablement on the matching task when a feature frame arrives with the task registered', () => {
+    const taskEmitSpy = jest.spyOn(taskManager.getTask(taskId), 'emit');
+    const featurePayload = {
+      interactionId: taskId,
+      postCallEnabled: true,
+      midCallEnabled: false,
+      actionTimestamp: 10,
+    };
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: 'FEATURE_ENABLEMENT',
+        data: {data: featurePayload},
+      })
+    );
+
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, featurePayload);
+  });
+
+  it('should replay retained feature enablement after the public incoming task event', () => {
+    const interactionId = 'retained-feature-task';
+    const featurePayload = {
+      interactionId,
+      postCallEnabled: true,
+      midCallEnabled: true,
+      actionTimestamp: 10,
+    };
+    const incomingPayload = {
+      ...taskDataMock,
+      interactionId,
+      mediaResourceId: interactionId,
+    };
+    const featureHandler = jest.fn();
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.FEATURE_ENABLEMENT,
+        data: {data: featurePayload},
+      })
+    );
+    taskManager.taskCollection = {};
+    taskManager.on(TASK_EVENTS.TASK_INCOMING, (task) => {
+      task.on(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, featureHandler);
+    });
+
+    webSocketManagerMock.emit(
+      'message',
+      JSON.stringify({data: {...incomingPayload, type: CC_EVENTS.AGENT_CONTACT_RESERVED}})
+    );
+
+    expect(featureHandler).toHaveBeenCalledTimes(1);
+    expect(featureHandler).toHaveBeenCalledWith(featurePayload);
+  });
+
+  it('should apply retained feature flags before publishing the task and emit them afterward', () => {
+    const newInteractionId = 'orphan-task-id';
+    const featurePayload = {
+      interactionId: newInteractionId,
+      postCallEnabled: true,
+      midCallEnabled: true,
+      actionTimestamp: 5,
+    };
+
+    // Feature frame arrives before task registration — stored as orphan
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.FEATURE_ENABLEMENT,
+        data: {data: featurePayload},
+      })
+    );
+
+    // Register through the task lifecycle so the consumer can attach its listener.
+    const orphanTask = createStateMachineTask({
+      ...taskDataMock,
+      interactionId: newInteractionId,
+      mediaResourceId: newInteractionId,
+      interaction: {mediaType: 'telephony'},
+    });
+    const taskEmitSpy = jest.spyOn(orphanTask, 'emit');
+    const featureHandler = jest.fn();
+    (TaskFactory.createTask as jest.Mock).mockReturnValueOnce(orphanTask);
+    taskManager.once(TASK_EVENTS.TASK_INCOMING, (publishedTask) => {
+      expect(publishedTask).toBe(orphanTask);
+      expect(orphanTask.setFeatureEnablement).toHaveBeenCalledWith(featurePayload);
+      expect((taskManager as any).pendingFeatureEnablement.get(newInteractionId)).toEqual(
+        featurePayload
+      );
+      expect(taskEmitSpy).not.toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_FEATURE_ENABLEMENT,
+        featurePayload
+      );
+      publishedTask.on(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, featureHandler);
+    });
+
+    webSocketManagerMock.emit(
+      'message',
+      JSON.stringify({data: {...orphanTask.data, type: CC_EVENTS.AGENT_CONTACT_RESERVED}})
+    );
+
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, featurePayload);
+    expect(featureHandler).toHaveBeenCalledTimes(1);
+    expect(featureHandler).toHaveBeenCalledWith(featurePayload);
+    expect((taskManager as any).pendingFeatureEnablement.has(newInteractionId)).toBe(false);
+  });
+
+  it('should retain an unmatched feature enablement snapshot until session cleanup', () => {
+    jest.useFakeTimers();
+    const interactionId = 'unmatched-feature-interaction';
+    const featurePayload = {
+      interactionId,
+      postCallEnabled: true,
+      midCallEnabled: true,
+    };
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.FEATURE_ENABLEMENT,
+        data: {data: featurePayload},
+      })
+    );
+
+    expect((taskManager as any).pendingFeatureEnablement.get(interactionId)).toEqual(featurePayload);
+    expect(jest.getTimerCount()).toBe(0);
+
+    jest.advanceTimersByTime(AI_SUMMARY_DURATION_MS);
+
+    expect((taskManager as any).pendingFeatureEnablement.get(interactionId)).toEqual(featurePayload);
+
+    taskManager.clearAISummaryState();
+
+    expect((taskManager as any).pendingFeatureEnablement.get(interactionId)).toBeUndefined();
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('should not use a main interaction feature frame as fallback for a child task key', () => {
+    jest.useFakeTimers();
+    const coordinator = (taskManager as any).apiAIAssistant;
+    const childInteractionId = 'child-task';
+    const conversationId = 'conversation-1';
+    const childTask = createStateMachineTask({
+      ...taskDataMock,
+      interactionId: childInteractionId,
+      interaction: {
+        mediaType: 'telephony',
+        mainInteractionId: conversationId,
+      },
+    });
+    const featurePayload = {
+      interactionId: conversationId,
+      postCallEnabled: true,
+      midCallEnabled: true,
+      actionTimestamp: 10,
+    };
+
+    taskManager.taskCollection = {
+      [childInteractionId]: childTask,
+    };
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.FEATURE_ENABLEMENT,
+        data: {data: featurePayload},
+      })
+    );
+
+    expect((taskManager as any).pendingFeatureEnablement.get(conversationId)).toEqual(featurePayload);
+    expect(
+      (taskManager as any).pendingFeatureEnablement.get(childInteractionId)
+    ).toBeUndefined();
+
+    taskManager.clearAISummaryState();
+  });
+
+  it.each([
+    [
+      'post-call',
+      'POST_CALL_SUMMARY',
+      'POST_CALL_SUMMARY',
+      'POST_CALL_SUMMARY_TIMEOUT',
+      {
+        conversationId: taskId,
+        adaptiveCard: {body: ['card']},
+        adaptiveCardId: 'adaptive-card-id',
+        editAdaptiveCard: {body: ['edit-card']},
+        editAdaptiveCardId: 'edit-adaptive-card-id',
+        languageCode: 'en-US',
+        summaryText: 'safe summary',
+        resolution: 'resolved',
+        areTranscriptsAvailable: true,
+        sections: {initialContactReason: 'billing', safeKey: 'safe value'},
+        suggestedWrapUpCodes: [{name: 'Resolved', id: 'wrap-up-code-id'}],
+        suggestedWrapUpCodesMessage: 'Use resolved wrap-up',
+        timestamp: 1773807297475,
+      },
+    ],
+    [
+      'mid-call',
+      'MID_CALL_SUMMARY',
+      'MID_CALL_SUMMARY',
+      'MID_CALL_SUMMARY_TIMEOUT',
+      {
+        conversationId: 'mid-summary-conversation',
+        adaptiveCard: {body: ['mid-card']},
+        adaptiveCardId: 'mid-adaptive-card-id',
+        editAdaptiveCard: {body: ['mid-edit-card']},
+        editAdaptiveCardId: 'mid-edit-adaptive-card-id',
+        languageCode: 'en-US',
+        summaryText: 'safe mid summary',
+        resolution: 'transferred',
+        areTranscriptsAvailable: false,
+        sections: {reasonForTransferOrConsult: 'specialist', safeKey: 'safe value'},
+        timestamp: 1773807297476,
+      },
+    ],
+  ] as const)(
+    'should resolve matching %s initiator summary payload through the request Promise only',
+    async (_summaryKind, realtimeEvent, inboundType, timeoutCode, summaryPayload) => {
+      const coordinator = (taskManager as any).apiAIAssistant;
+      const registration = createPendingRtdRequest(
+        coordinator,
+        summaryPayload.conversationId,
+        inboundType,
+        timeoutCode
+      );
+      const task = createStateMachineTask({
+        ...taskDataMock,
+        interactionId: summaryPayload.conversationId,
+        mediaResourceId: summaryPayload.conversationId,
+      });
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+      const taskManagerEmitSpy = jest.spyOn(taskManager, 'emit');
+
+      taskManager.taskCollection[summaryPayload.conversationId] = task;
+
+      taskManager.handleRealtimeWebsocketEvent(
+        JSON.stringify({
+          type: realtimeEvent,
+          data: {data: summaryPayload},
+        })
+      );
+
+      await expect(registration.result).resolves.toStrictEqual(summaryPayload);
+
+      const taskEmittedEvents = taskEmitSpy.mock.calls.map(([eventName]) => eventName);
+      const taskManagerEmittedEvents = taskManagerEmitSpy.mock.calls.map(
+        ([eventName]) => eventName
+      );
+
+      [CC_TASK_EVENTS.POST_CALL_SUMMARY, CC_TASK_EVENTS.MID_CALL_SUMMARY].forEach(
+        (summaryInboundEvent) => {
+          expect(taskEmittedEvents).not.toContain(summaryInboundEvent);
+          expect(taskManagerEmittedEvents).not.toContain(summaryInboundEvent);
+        }
+      );
+    }
+  );
+
+  it('should resolve only the matching active mid-call initiator slot through TaskManager RTD routing', async () => {
+    jest.useFakeTimers();
+    const coordinator = (taskManager as any).apiAIAssistant;
+    const conversationId = 'shared-summary-conversation';
+    const midSummaryPayload = {
+      conversationId,
+      adaptiveCard: {body: ['mid-card']},
+      adaptiveCardId: 'mid-adaptive-card-id',
+      editAdaptiveCard: {body: ['mid-edit-card']},
+      editAdaptiveCardId: 'mid-edit-adaptive-card-id',
+      languageCode: 'en-US',
+      summaryText: 'private mid summary',
+      resolution: 'transferred',
+      areTranscriptsAvailable: true,
+      sections: {reasonForTransferOrConsult: 'specialist'},
+      timestamp: 1773807297476,
+    };
+    const postRegistration = createPendingRtdRequest(
+      coordinator,
+      conversationId,
+      'POST_CALL_SUMMARY',
+      'POST_CALL_SUMMARY_TIMEOUT'
+    );
+    const midRegistration = createPendingRtdRequest(
+      coordinator,
+      conversationId,
+      'MID_CALL_SUMMARY',
+      'MID_CALL_SUMMARY_TIMEOUT'
+    );
+    const postResolved = jest.fn();
+    const postRejected = jest.fn();
+    const midResolved = jest.fn();
+    const midRejected = jest.fn();
+    const initiatorTask = createStateMachineTask({
+      ...taskDataMock,
+      interactionId: conversationId,
+      mediaResourceId: conversationId,
+    });
+    const initiatorTaskEmitSpy = jest.spyOn(initiatorTask, 'emit');
+    const taskManagerEmitSpy = jest.spyOn(taskManager, 'emit');
+
+    postRegistration.result.then(postResolved, postRejected);
+    midRegistration.result.then(midResolved, midRejected);
+    taskManager.taskCollection = {[conversationId]: initiatorTask};
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY,
+        data: {data: midSummaryPayload},
+      })
+    );
+    await expect(midRegistration.result).resolves.toEqual(midSummaryPayload);
+    expect(midRejected).not.toHaveBeenCalled();
+    expect(postResolved).not.toHaveBeenCalled();
+    expect(postRejected).not.toHaveBeenCalled();
+    [CC_TASK_EVENTS.POST_CALL_SUMMARY, CC_TASK_EVENTS.MID_CALL_SUMMARY].forEach(
+      (summaryInboundEvent) => {
+        expect(initiatorTaskEmitSpy).not.toHaveBeenCalledWith(
+          summaryInboundEvent,
+          expect.anything()
+        );
+        expect(taskManagerEmitSpy).not.toHaveBeenCalledWith(summaryInboundEvent, expect.anything());
+      }
+    );
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY,
+        data: {data: midSummaryPayload},
+      })
+    );
+
+    expectNoSensitiveDiagnostics('private mid summary', 'specialist');
+
+    expect(coordinator.pendingRequests.size).toBe(1);
+  });
+
+  it('should reject on timeout and drop one later mid-call frame without changing settlement', async () => {
+    jest.useFakeTimers();
+    const coordinator = (taskManager as any).apiAIAssistant;
+    const registration = createPendingRtdRequest(
+      coordinator,
+      'mid-timeout-conversation',
+      'MID_CALL_SUMMARY',
+      'MID_CALL_SUMMARY_TIMEOUT'
+    );
+    const rejection = registration.result.catch((error) => error);
+
+    jest.advanceTimersByTime(AI_SUMMARY_DURATION_MS);
+
+    const timeoutError = await rejection;
+
+    expect(timeoutError).toEqual(
+      expect.objectContaining({
+        message: AI_SUMMARY_ERROR_CODES.MID_CALL_SUMMARY_TIMEOUT,
+        data: {errorCode: AI_SUMMARY_ERROR_CODES.MID_CALL_SUMMARY_TIMEOUT},
+      })
+    );
+    expect(jest.getTimerCount()).toBe(0);
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY,
+        data: {
+          data: {
+            conversationId: 'mid-timeout-conversation',
+            summaryText: 'late summary must not resettle the request',
+          },
+        },
+      })
+    );
+
+    await expect(registration.result).rejects.toBe(timeoutError);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('should drop late post-call initiator summary events once', async () => {
+    const coordinator = (taskManager as any).apiAIAssistant;
+    const postSummaryPayload = {
+      conversationId: taskId,
+      adaptiveCard: {body: ['card']},
+      adaptiveCardId: 'adaptive-card-id',
+      editAdaptiveCard: {body: ['edit-card']},
+      editAdaptiveCardId: 'edit-adaptive-card-id',
+      languageCode: 'en-US',
+      summaryText: 'safe summary',
+      resolution: 'resolved',
+      areTranscriptsAvailable: true,
+      sections: {initialContactReason: 'billing', safeKey: 'safe value'},
+      suggestedWrapUpCodes: [{name: 'Resolved', id: 'wrap-up-code-id'}],
+      suggestedWrapUpCodesMessage: 'Use resolved wrap-up',
+      timestamp: 1773807297475,
+    };
+    const postRegistration = createPendingRtdRequest(
+      coordinator,
+      taskId,
+      'POST_CALL_SUMMARY',
+      'POST_CALL_SUMMARY_TIMEOUT'
+    );
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.POST_CALL_SUMMARY,
+        data: {data: postSummaryPayload},
+      })
+    );
+
+    await expect(postRegistration.result).resolves.toStrictEqual(postSummaryPayload);
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.POST_CALL_SUMMARY,
+        data: {data: postSummaryPayload},
+      })
+    );
+
+  });
+
+  it.each(['target-first', 'other-first'] as const)(
+    'should emit a receiving summary immediately on the answered task indexed by conversation id for %s order',
+    (registryOrder) => {
+      const conversationId = 'conversation-1';
+      const receivingTask = createStateMachineTask({...taskDataMock, interactionId: conversationId});
+      const otherTask = createStateMachineTask({...taskDataMock, interactionId: 'other-conversation'});
+      receivingTask.state = {value: TaskState.CONNECTED};
+      otherTask.state = {value: TaskState.CONNECTED};
+
+      taskManager.taskCollection =
+        registryOrder === 'target-first'
+          ? {[conversationId]: receivingTask, [otherTask.data.interactionId]: otherTask}
+          : {[otherTask.data.interactionId]: otherTask, [conversationId]: receivingTask};
+
+      const receivingTaskEmitSpy = jest.spyOn(receivingTask, 'emit');
+      const otherTaskEmitSpy = jest.spyOn(otherTask, 'emit');
+      const receivingPayload = {
+        conversationId,
+        summaryText: 'receiver summary',
+      };
+
+      taskManager.handleRealtimeWebsocketEvent(
+        JSON.stringify({
+          type: 'MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT',
+          data: {data: receivingPayload},
+        })
+      );
+
+      expect(receivingTaskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED,
+        receivingPayload
+      );
+      expect(otherTaskEmitSpy).not.toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED,
+        expect.anything()
+      );
+    }
+  );
+
+  it('should emit on the indexed receiving task without logging private summary content', () => {
+    const conversationId = 'conversation-1';
+    const invalidTaskId = 'invalid-correlation-task-id';
+    const invalidTaskPayloadSentinel = 'private-invalid-task-payload';
+    const rawEnvelopeSentinel = 'private-raw-envelope';
+    const summarySentinel = 'private-summary';
+    const sectionKeySentinel = 'private-section-key';
+    const sectionValueSentinel = 'private-section-value';
+    const arbitraryErrorSentinel = 'private-arbitrary-error';
+    const invalidTask = createStateMachineTask({
+      ...taskDataMock,
+      taskId: invalidTaskId,
+      interactionId: '',
+      privatePayload: invalidTaskPayloadSentinel,
+      interaction: {
+        mainInteractionId: conversationId,
+        callProcessingDetails: {},
+      },
+    });
+    const validPeerTask = createStateMachineTask({
+      ...taskDataMock,
+      interactionId: conversationId,
+      interaction: {
+        mainInteractionId: conversationId,
+        callProcessingDetails: {},
+      },
+    });
+    const receivingPayload = {
+      conversationId,
+      summaryText: summarySentinel,
+      sections: {[sectionKeySentinel]: sectionValueSentinel},
+      error: {message: arbitraryErrorSentinel},
+    };
+    validPeerTask.state = {value: TaskState.CONNECTED};
+    const invalidEmitSpy = jest.spyOn(invalidTask, 'emit');
+    const validPeerEmitSpy = jest.spyOn(validPeerTask, 'emit');
+
+    taskManager.taskCollection = {[invalidTaskId]: invalidTask, [conversationId]: validPeerTask};
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: receivingPayload},
+        rawEnvelope: rawEnvelopeSentinel,
+      })
+    );
+
+    expect(invalidEmitSpy).not.toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED,
+      expect.anything()
+    );
+    expect(validPeerEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED,
+      receivingPayload
+    );
+
+    const loggerDiagnostics = JSON.stringify({
+      warnings: getLoggerProxy().warn.mock.calls,
+      errors: getLoggerProxy().error.mock.calls,
+      info: getLoggerProxy().info.mock.calls,
+      logs: getLoggerProxy().log.mock.calls,
+    });
+
+    [
+      invalidTaskPayloadSentinel,
+      rawEnvelopeSentinel,
+      summarySentinel,
+      sectionKeySentinel,
+      sectionValueSentinel,
+      arbitraryErrorSentinel,
+    ].forEach((sensitiveValue) => {
+      expect(loggerDiagnostics).not.toContain(sensitiveValue);
+    });
+  });
+
+  it.each([
+    ['transferred call', [], CC_EVENTS.AGENT_CONTACT_ASSIGNED, TASK_EVENTS.TASK_ASSIGNED],
+    [
+      'consult',
+      [CC_EVENTS.AGENT_OFFER_CONSULT],
+      CC_EVENTS.AGENT_CONSULTING,
+      TASK_EVENTS.TASK_CONSULT_ACCEPTED,
+    ],
+  ] as const)(
+    'should keep a receiving summary while the %s is ringing and emit it right after it is answered',
+    (_name, ringingUpdates, answerEvent, answeredTaskEvent) => {
+      taskManager.taskCollection = {};
+      const receivingPayload = {
+        conversationId: 'conversation-1',
+        summaryText: 'buffered receiver summary',
+      };
+
+      taskManager.handleRealtimeWebsocketEvent(
+        JSON.stringify({
+          type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+          data: {data: receivingPayload},
+        })
+      );
+
+      const task = createStateMachineTask({
+        ...taskDataMock,
+        interactionId: receivingPayload.conversationId,
+        interaction: {
+          mediaType: 'telephony',
+          callProcessingDetails: {},
+        },
+      });
+      const observedOrder: string[] = [];
+      task.on(answeredTaskEvent, () => observedOrder.push('answered'));
+      task.on(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, (payload) =>
+        observedOrder.push(`receiver-summary:${payload.summaryText}`)
+      );
+      (TaskFactory.createTask as jest.Mock).mockReturnValueOnce(task);
+
+      [CC_EVENTS.AGENT_CONTACT_RESERVED, ...ringingUpdates].forEach((ringingEvent) => {
+        webSocketManagerMock.emit('message', JSON.stringify({data: {...task.data, type: ringingEvent}}));
+      });
+
+      expect(task.state).toEqual({value: TaskState.OFFERED});
+      expect(observedOrder).toEqual([]);
+      expect((taskManager as any).receivingSummaryBuffer.get(receivingPayload.conversationId)).toEqual(
+        receivingPayload
+      );
+
+      webSocketManagerMock.emit('message', JSON.stringify({data: {...task.data, type: answerEvent}}));
+
+      expect(observedOrder).toEqual(['answered', 'receiver-summary:buffered receiver summary']);
+      expect((taskManager as any).receivingSummaryBuffer.has(receivingPayload.conversationId)).toBe(
+        false
+      );
+    }
+  );
+
+  it('should keep a receiving summary that arrives while its task is ringing until the task is answered', () => {
+    const conversationId = 'conversation-1';
+    const task = createStateMachineTask({...taskDataMock, interactionId: conversationId});
+    task.state = {value: TaskState.OFFERED};
+    taskManager.taskCollection = {[conversationId]: task};
+    const receiverHandler = jest.fn();
+    task.on(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, receiverHandler);
+    const receivingPayload = {conversationId, summaryText: 'ringing receiver summary'};
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: receivingPayload},
+      })
+    );
+
+    expect(receiverHandler).not.toHaveBeenCalled();
+    expect((taskManager as any).receivingSummaryBuffer.get(conversationId)).toEqual(receivingPayload);
+
+    webSocketManagerMock.emit(
+      'message',
+      JSON.stringify({data: {...task.data, type: CC_EVENTS.AGENT_CONTACT_ASSIGNED}})
+    );
+
+    expect(receiverHandler).toHaveBeenCalledTimes(1);
+    expect(receiverHandler).toHaveBeenCalledWith(receivingPayload);
+  });
+
+  it.each([
+    ['the offer is not answered in time (RONA)', [], CC_EVENTS.AGENT_CONTACT_OFFER_RONA],
+    ['the offer is declined', [], CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED],
+    [
+      'the consult is cancelled before it is accepted',
+      [CC_EVENTS.AGENT_OFFER_CONSULT],
+      CC_EVENTS.AGENT_CONSULT_ENDED,
+    ],
+  ] as const)(
+    'should drop a receiving summary held for a ringing task when %s',
+    (_name, ringingUpdates, endEvent) => {
+      taskManager.taskCollection = {};
+      const receivingPayload = {
+        conversationId: 'conversation-1',
+        summaryText: 'unanswered receiver summary',
+      };
+
+      taskManager.handleRealtimeWebsocketEvent(
+        JSON.stringify({
+          type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+          data: {data: receivingPayload},
+        })
+      );
+
+      const task = createStateMachineTask({
+        ...taskDataMock,
+        interactionId: receivingPayload.conversationId,
+        isConsulted: ringingUpdates.length > 0,
+        interaction: {
+          mediaType: 'telephony',
+          callProcessingDetails: {},
+        },
+      });
+      const receiverHandler = jest.fn();
+      task.on(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, receiverHandler);
+      (TaskFactory.createTask as jest.Mock).mockReturnValueOnce(task);
+
+      [CC_EVENTS.AGENT_CONTACT_RESERVED, ...ringingUpdates, endEvent].forEach((event) => {
+        webSocketManagerMock.emit('message', JSON.stringify({data: {...task.data, type: event}}));
+      });
+
+      expect(receiverHandler).not.toHaveBeenCalled();
+      expect((taskManager as any).receivingSummaryBuffer.has(receivingPayload.conversationId)).toBe(
+        false
+      );
+    }
+  );
+
+  it('should keep a stored receiving summary while an unrelated task is updated', () => {
+    jest.useFakeTimers();
+    const conversationId = 'pending-summary-conversation';
+    const receivingPayload = {
+      conversationId,
+      summaryText: 'pending receiver summary',
+    };
+
+    taskManager.taskCollection = {};
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: receivingPayload},
+      })
+    );
+
+    const unrelatedTask = createStateMachineTask({...taskDataMock, interactionId: 'unrelated-task'});
+    const unrelatedTaskEmitSpy = jest.spyOn(unrelatedTask, 'emit');
+    taskManager.taskCollection = {
+      [unrelatedTask.data.interactionId]: unrelatedTask,
+    };
+
+    webSocketManagerMock.emit(
+      'message',
+      JSON.stringify({data: {...unrelatedTask.data, type: CC_EVENTS.AGENT_CONTACT_UNASSIGNED}})
+    );
+
+    expect(unrelatedTaskEmitSpy).not.toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED,
+      expect.anything()
+    );
+    expect((taskManager as any).receivingSummaryBuffer.get(conversationId)).toEqual(receivingPayload);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('should replay a stored receiving summary when an unmapped update rekeys the task to its conversation id', () => {
+    jest.useFakeTimers();
+    const conversationId = 'unmapped-update-conversation';
+    const task = taskManager.getTask(taskId);
+    const receiverHandler = jest.fn();
+    const sendStateMachineEventSpy = task.sendStateMachineEvent as jest.Mock;
+    const receivingPayload = {
+      conversationId,
+      summaryText: 'buffered unmapped update summary',
+    };
+
+    task.on(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, receiverHandler);
+    sendStateMachineEventSpy.mockClear();
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: receivingPayload},
+      })
+    );
+
+    expect(jest.getTimerCount()).toBe(0);
+    expect((taskManager as any).receivingSummaryBuffer.get(conversationId)).toEqual(receivingPayload);
+
+    webSocketManagerMock.emit(
+      'message',
+      JSON.stringify({
+        data: {
+          ...taskDataMock,
+          type: CC_EVENTS.AGENT_CONTACT_UNASSIGNED,
+          interactionId: conversationId,
+          reservationInteractionId: taskId,
+          mediaResourceId: conversationId,
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {},
+          },
+        },
+      })
+    );
+
+    expect(sendStateMachineEventSpy).not.toHaveBeenCalled();
+    expect(receiverHandler).toHaveBeenCalledTimes(1);
+    expect(receiverHandler).toHaveBeenCalledWith(receivingPayload);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('should clear reservation feature state and flush buffered receiver summary after reservation re-key', () => {
+    jest.useFakeTimers();
+    taskManager.taskCollection = {};
+    const coordinator = (taskManager as any).apiAIAssistant;
+    const reservationInteractionId = 'reservation-rekey-id';
+    const assignedInteractionId = 'assigned-rekey-id';
+    const conversationId = assignedInteractionId;
+    const featurePayload = {
+      interactionId: reservationInteractionId,
+      postCallEnabled: true,
+      midCallEnabled: true,
+    };
+    const assignedFeaturePayload = {
+      interactionId: assignedInteractionId,
+      postCallEnabled: false,
+      midCallEnabled: true,
+    };
+    const receivingPayload = {
+      conversationId,
+      summaryText: 'buffered reservation rekey summary',
+    };
+    const receiverHandler = jest.fn();
+
+    webSocketManagerMock.emit(
+      'message',
+      JSON.stringify({
+        data: {
+          ...taskDataMock,
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: reservationInteractionId,
+          mediaResourceId: reservationInteractionId,
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {},
+          },
+        },
+      })
+    );
+
+    const reservationTask = taskManager.getTask(reservationInteractionId);
+    reservationTask.on(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, receiverHandler);
+    const featureHandler = jest.fn();
+    reservationTask.on(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, featureHandler);
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.FEATURE_ENABLEMENT,
+        data: {data: featurePayload},
+      })
+    );
+
+    expect(reservationTask.setFeatureEnablement).toHaveBeenCalledWith(featurePayload);
+    expect(jest.getTimerCount()).toBe(0);
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.FEATURE_ENABLEMENT,
+        data: {data: assignedFeaturePayload},
+      })
+    );
+
+    expect((taskManager as any).pendingFeatureEnablement.get(assignedInteractionId)).toEqual(
+      assignedFeaturePayload
+    );
+    expect(jest.getTimerCount()).toBe(0);
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: receivingPayload},
+      })
+    );
+
+    expect(jest.getTimerCount()).toBe(0);
+    expect((taskManager as any).receivingSummaryBuffer.get(conversationId)).toEqual(receivingPayload);
+
+    webSocketManagerMock.emit(
+      'message',
+      JSON.stringify({
+        data: {
+          ...taskDataMock,
+          type: CC_EVENTS.AGENT_CONTACT_ASSIGNED,
+          interactionId: assignedInteractionId,
+          reservationInteractionId,
+          mediaResourceId: assignedInteractionId,
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {},
+          },
+        },
+      })
+    );
+
+    expect(taskManager.getTask(assignedInteractionId)).toBe(reservationTask);
+    expect(taskManager.getTask(reservationInteractionId)).toBeUndefined();
+    expect((taskManager as any).pendingFeatureEnablement.get(reservationInteractionId)).toBeUndefined();
+    expect(featureHandler).toHaveBeenCalledWith(assignedFeaturePayload);
+    expect(receiverHandler).toHaveBeenCalledTimes(1);
+    expect(receiverHandler).toHaveBeenCalledWith(receivingPayload);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('should retain the latest unmatched receiving summary until its task is answered without an expiry timer', () => {
+    jest.useFakeTimers();
+    const unmatchedTask = createStateMachineTask({...taskDataMock, interactionId: 'other-conversation'});
+    const unmatchedTaskEmitSpy = jest.spyOn(unmatchedTask, 'emit');
+    const taskManagerEmitSpy = jest.spyOn(taskManager, 'emit');
+    const receivingPayload = {
+      conversationId: 'conversation-1',
+      summaryText: 'private retained receiver summary',
+    };
+    const latestPayload = {...receivingPayload, summaryText: 'private latest receiver summary'};
+
+    taskManager.taskCollection = {[unmatchedTask.data.interactionId]: unmatchedTask};
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: receivingPayload},
+      })
+    );
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: latestPayload},
+      })
+    );
+
+    expect(unmatchedTaskEmitSpy).not.toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED,
+      expect.anything()
+    );
+    expect(taskManagerEmitSpy).not.toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED,
+      expect.anything()
+    );
+    expect(jest.getTimerCount()).toBe(0);
+
+    jest.advanceTimersByTime(AI_SUMMARY_DURATION_MS * 2);
+    expect((taskManager as any).receivingSummaryBuffer.get(receivingPayload.conversationId)).toEqual(
+      latestPayload
+    );
+
+    const receiverTask = createStateMachineTask({
+      ...taskDataMock,
+      interactionId: receivingPayload.conversationId,
+      interaction: {mediaType: 'telephony'},
+    });
+    const receiverHandler = jest.fn();
+    (TaskFactory.createTask as jest.Mock).mockReturnValueOnce(receiverTask);
+    taskManager.once(TASK_EVENTS.TASK_INCOMING, (publishedTask) => {
+      publishedTask.on(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, receiverHandler);
+    });
+
+    webSocketManagerMock.emit(
+      'message',
+      JSON.stringify({data: {...receiverTask.data, type: CC_EVENTS.AGENT_CONTACT_RESERVED}})
+    );
+
+    expect(receiverHandler).not.toHaveBeenCalled();
+    expect((taskManager as any).receivingSummaryBuffer.get(receivingPayload.conversationId)).toEqual(
+      latestPayload
+    );
+
+    webSocketManagerMock.emit(
+      'message',
+      JSON.stringify({data: {...receiverTask.data, type: CC_EVENTS.AGENT_CONTACT_ASSIGNED}})
+    );
+
+    expect(receiverHandler).toHaveBeenCalledTimes(1);
+    expect(receiverHandler).toHaveBeenCalledWith(latestPayload);
+    expect(
+      (taskManager as any).receivingSummaryBuffer.has(receivingPayload.conversationId)
+    ).toBe(false);
+
+    expect(unmatchedTaskEmitSpy).not.toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED,
+      expect.anything()
+    );
+    expect(taskManagerEmitSpy).not.toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED,
+      expect.anything()
+    );
+    expectNoSensitiveDiagnostics(receivingPayload.summaryText, latestPayload.summaryText);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it.each([
+    [
+      'reserved contact',
+      CC_EVENTS.AGENT_CONTACT_RESERVED,
+      TASK_EVENTS.TASK_INCOMING,
+      'receiver-reserved-task',
+    ],
+    [
+      'campaign preview reservation',
+      CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+      TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
+      'receiver-campaign-task',
+    ],
+  ] as const)(
+    'should keep buffered receiving summaries after %s publication until the task is answered',
+    (_name, eventType, publicationEvent, interactionId) => {
+      taskManager.taskCollection = {};
+      const receivingPayload = {
+        conversationId: interactionId,
+        summaryText: `buffered summary for ${interactionId}`,
+      };
+      const deliveryHandler = jest.fn();
+
+      taskManager.handleRealtimeWebsocketEvent(
+        JSON.stringify({
+          type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+          data: {data: receivingPayload},
+        })
+      );
+
+      taskManager.on(publicationEvent, (publishedTask) => {
+        publishedTask.on(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, deliveryHandler);
+      });
+
+      webSocketManagerMock.emit(
+        'message',
+        JSON.stringify({
+          data: {
+            ...taskDataMock,
+            type: eventType,
+            interactionId,
+            mediaResourceId: interactionId,
+            interaction: {
+              mediaType: 'telephony',
+              callProcessingDetails: {},
+            },
+          },
+        })
+      );
+
+      expect(deliveryHandler).not.toHaveBeenCalled();
+      expect((taskManager as any).receivingSummaryBuffer.get(interactionId)).toEqual(receivingPayload);
+    }
+  );
+
+  it.each([
+    [
+      'agent contact hydrate',
+      CC_EVENTS.AGENT_CONTACT,
+      TASK_EVENTS.TASK_HYDRATE,
+      'receiver-agent-contact-task',
+    ],
+  ] as const)(
+    'should flush buffered receiving summaries once after %s publication of an answered task',
+    (_name, eventType, publicationEvent, interactionId) => {
+      jest.useFakeTimers();
+      taskManager.taskCollection = {};
+      const receivingPayload = {
+        conversationId: interactionId,
+        summaryText: `buffered summary for ${interactionId}`,
+      };
+      const deliveryHandler = jest.fn();
+      const observedOrder: string[] = [];
+
+      taskManager.handleRealtimeWebsocketEvent(
+        JSON.stringify({
+          type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+          data: {data: receivingPayload},
+        })
+      );
+
+      taskManager.on(publicationEvent, (publishedTask) => {
+        observedOrder.push('published');
+        expect(publishedTask).toBe(taskManager.getTask(interactionId));
+        publishedTask.on(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, (payload) => {
+          observedOrder.push('receiver-summary');
+          deliveryHandler(payload);
+        });
+      });
+
+      webSocketManagerMock.emit(
+        'message',
+        JSON.stringify({
+          data: {
+            ...taskDataMock,
+            type: eventType,
+            interactionId,
+            mediaResourceId: interactionId,
+            interaction: {
+              mediaType: 'telephony',
+              callProcessingDetails: {},
+            },
+          },
+        })
+      );
+
+      expect(observedOrder).toEqual(['published', 'receiver-summary']);
+      expect(deliveryHandler).toHaveBeenCalledTimes(1);
+      expect(deliveryHandler).toHaveBeenCalledWith(receivingPayload);
+      expect(jest.getTimerCount()).toBe(0);
+    }
+  );
+
+  it('should flush buffered receiving summaries once after TASK_MERGED publication', () => {
+    jest.useFakeTimers();
+    taskManager.taskCollection = {};
+    const interactionId = 'receiver-merged-task';
+    const receivingPayload = {
+      conversationId: interactionId,
+      summaryText: 'buffered summary for merged task',
+    };
+    const deliveryHandler = jest.fn();
+    const observedOrder: string[] = [];
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: receivingPayload},
+      })
+    );
+
+    taskManager.on(TASK_EVENTS.TASK_MERGED, (publishedTask) => {
+      observedOrder.push('published');
+      expect(publishedTask).toBe(taskManager.getTask(interactionId));
+      publishedTask.on(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, (payload) => {
+        observedOrder.push('receiver-summary');
+        deliveryHandler(payload);
+      });
+    });
+
+    webSocketManagerMock.emit(
+      'message',
+      JSON.stringify({
+        data: {
+          ...taskDataMock,
+          type: CC_EVENTS.CONTACT_MERGED,
+          interactionId,
+          mediaResourceId: interactionId,
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {},
+          },
+        },
+      })
+    );
+
+    expect(observedOrder).toEqual(['published', 'receiver-summary']);
+    expect(deliveryHandler).toHaveBeenCalledTimes(1);
+    expect(deliveryHandler).toHaveBeenCalledWith(receivingPayload);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('should retain a summary for a missing task without logging its private content', () => {
+    const receivingPayload = {
+      conversationId: 'missing-conversation',
+      summaryText: 'private-summary',
+      sections: {privateKey: 'private-value'},
+      adaptiveCard: {body: ['private-card']},
+      agentName: 'private-agent',
+    };
+    taskManager.taskCollection = {};
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: receivingPayload},
+      })
+    );
+
+    expect((taskManager as any).receivingSummaryBuffer.get(receivingPayload.conversationId)).toEqual(
+      receivingPayload
+    );
+    expectNoSensitiveDiagnostics('private-summary', 'private-value', 'private-card', 'private-agent');
+  });
+
+  it('should clear AI summary state, cancel pending requests, and clear buffered frames', async () => {
+    jest.useFakeTimers();
+    const coordinator = (taskManager as any).apiAIAssistant;
+    const postRegistration = createPendingRtdRequest(
+      coordinator,
+      taskId,
+      'POST_CALL_SUMMARY',
+      'POST_CALL_SUMMARY_TIMEOUT'
+    );
+    const midRegistration = createPendingRtdRequest(
+      coordinator,
+      taskId,
+      'MID_CALL_SUMMARY',
+      'MID_CALL_SUMMARY_TIMEOUT'
+    );
+
+    const pendingFeatureInteractionId = 'pending-feature-interaction';
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.FEATURE_ENABLEMENT,
+        data: {data: {interactionId: pendingFeatureInteractionId, postCallEnabled: true}},
+      })
+    );
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: {conversationId: 'conversation-1', summaryText: 'summary'}},
+      })
+    );
+    expect(jest.getTimerCount()).toBe(2);
+
+    taskManager.clearAISummaryState();
+
+    await expect(postRegistration.result).rejects.toEqual(
+      expect.objectContaining({
+        message: AI_SUMMARY_REQUEST_CANCELLED,
+        data: {errorCode: AI_SUMMARY_REQUEST_CANCELLED},
+      })
+    );
+    await expect(midRegistration.result).rejects.toEqual(
+      expect.objectContaining({
+        message: AI_SUMMARY_REQUEST_CANCELLED,
+        data: {errorCode: AI_SUMMARY_REQUEST_CANCELLED},
+      })
+    );
+    expect((coordinator as any).pendingRequests.size).toBe(0);
+    expect((taskManager as any).receivingSummaryBuffer.size).toBe(0);
+    expect((taskManager as any).pendingFeatureEnablement.size).toBe(0);
+    expect(jest.getTimerCount()).toBe(0);
+    jest.useRealTimers();
+  });
+
+  it.each([
+    [
+      'without a conversationId',
+      {
+        type: 'UNKNOWN_SUMMARY_EVENT',
+        data: {
+          data: {
+            summaryText: 'private-summary',
+            sections: {privateKey: 'private-value'},
+          },
+        },
+      },
+    ],
+    [
+      'without a registered task',
+      {
+        type: 'UNKNOWN_SUMMARY_EVENT',
+        data: {
+          data: {
+            conversationId: 'missing-task-id',
+            summaryText: 'private-summary',
+          },
+        },
+      },
+    ],
+  ])('should ignore unknown summary-like RTD frames %s', (_label, payload) => {
+    taskManager.taskCollection = {};
+
+    taskManager.handleRealtimeWebsocketEvent(JSON.stringify(payload));
+
+    expect(getLoggerProxy().warn).not.toHaveBeenCalled();
+    expectNoSensitiveDiagnostics('private-summary', 'privateKey', 'private-value');
+  });
+
+  it('should ignore malformed summary frames and log parser errors', () => {
+    taskManager.handleRealtimeWebsocketEvent('{bad-json "private-summary"');
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({type: CC_TASK_EVENTS.POST_CALL_SUMMARY, data: {}})
+    );
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.POST_CALL_SUMMARY,
+        data: {data: {conversationId: ''}},
+      })
+    );
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT,
+        data: {data: {conversationId: ''}},
+      })
+    );
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({type: CC_EVENTS.REAL_TIME_TRANSCRIPTION, data: {data: {}}})
+    );
+
+    expect(getLoggerProxy().error).toHaveBeenCalledWith('Failed to parse RTD WebSocket message', {
+      module: TASK_MANAGER_FILE,
+      method: METHODS.HANDLE_REAL_TIME_WEBSOCKET_EVENT,
+      error: expect.any(SyntaxError),
+    });
+    expectNoSensitiveDiagnostics('private-summary');
+  });
+
+  it('should keep a pending request operational after unparseable, malformed, and unknown frames', async () => {
+    const coordinator = (taskManager as any).apiAIAssistant;
+    const conversationId = 'recovery-conversation';
+    const registration = createPendingRtdRequest(
+      coordinator,
+      conversationId,
+      'POST_CALL_SUMMARY',
+      'POST_CALL_SUMMARY_TIMEOUT'
+    );
+    const validPayload = {
+      conversationId,
+      summaryText: 'valid recovery summary',
+    };
+
+    taskManager.handleRealtimeWebsocketEvent('{not-json');
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({type: CC_TASK_EVENTS.POST_CALL_SUMMARY, data: {}})
+    );
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({type: 'UNKNOWN_SUMMARY_RECOVERY_EVENT', data: {data: {conversationId}}})
+    );
+
+    taskManager.handleRealtimeWebsocketEvent(
+      JSON.stringify({
+        type: CC_TASK_EVENTS.POST_CALL_SUMMARY,
+        data: {data: validPayload},
+      })
+    );
+
+    await expect(registration.result).resolves.toStrictEqual(validPayload);
+  });
+
+  it('should contain throwing transcript listeners', () => {
+    const task = taskManager.getTask(taskId);
+    const transcriptHandler = jest.fn(() => {
+      throw new Error('private transcript listener failure');
+    });
+    const payload = {
+      data: {
+        data: {
+          content: 'private transcript content',
+          conversationId: taskId,
+          messageId: 'throwing-transcript',
+        },
+      },
+      type: CC_EVENTS.REAL_TIME_TRANSCRIPTION,
+    };
+
+    task.on(CC_EVENTS.REAL_TIME_TRANSCRIPTION, transcriptHandler);
+
+    taskManager.handleRealtimeWebsocketEvent(JSON.stringify(payload));
+
+    expect(transcriptHandler).toHaveBeenCalledWith(payload.data);
+    expect(getLoggerProxy().warn).not.toHaveBeenCalled();
+    expect(getLoggerProxy().error).toHaveBeenCalledWith('Failed to parse RTD WebSocket message', {
+      module: TASK_MANAGER_FILE,
+      method: METHODS.HANDLE_REAL_TIME_WEBSOCKET_EVENT,
+      error: expect.any(Error),
+    });
+    expectNoSensitiveDiagnostics(
+      'private transcript content',
+      'private transcript listener failure'
+    );
+  });
+
+  const expectTaskConstructedForAISummary = () => {
+    expect((TaskFactory.createTask as jest.Mock).mock.calls.at(-1)?.[8]).toBe(mockApiAIAssistant);
+  };
+
+  it.each([
+    [
+      'AGENT_CONTACT_RESERVED',
+      TASK_EVENTS.TASK_INCOMING,
+      {
+        ...taskDataMock,
+        type: CC_EVENTS.AGENT_CONTACT_RESERVED,
+        interactionId: 'ai-summary-reserved-task',
+        mediaResourceId: 'ai-summary-reserved-task',
+        interaction: {mediaType: 'telephony'},
+      },
+    ],
+    [
+      'missing-task AGENT_CONTACT',
+      TASK_EVENTS.TASK_HYDRATE,
+      {
+        ...taskDataMock,
+        type: CC_EVENTS.AGENT_CONTACT,
+        interactionId: 'ai-summary-agent-contact-task',
+        mediaResourceId: 'ai-summary-agent-contact-task',
+        interaction: {mediaType: 'telephony'},
+      },
+    ],
+    [
+      'campaign-preview reservation',
+      TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
+      {
+        ...taskDataMock,
+        type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+        interactionId: 'ai-summary-campaign-task',
+        mediaResourceId: 'ai-summary-campaign-task',
+        interaction: {mediaType: 'telephony'},
+      },
+    ],
+    [
+      'missing-task CONTACT_MERGED',
+      TASK_EVENTS.TASK_MERGED,
+      {
+        ...taskDataMock,
+        type: CC_EVENTS.CONTACT_MERGED,
+        interactionId: 'ai-summary-merged-task',
+        mediaResourceId: 'ai-summary-merged-task',
+        interaction: {mediaType: 'telephony', callProcessingDetails: {}},
+      },
+    ],
+  ] as const)(
+    'should pass AI summary dependencies into task construction before publishing %s',
+    (_name, publicationEvent, payload) => {
+      taskManager.taskCollection = {};
+      (TaskFactory.createTask as jest.Mock).mockClear();
+      const publishedTasks: any[] = [];
+      let registryEntryDuringConstruction: unknown = 'not-observed';
+      let injectedApiAIAssistant;
+      const taskManagerEmitSpy = jest.spyOn(taskManager, 'emit');
+
+      (TaskFactory.createTask as jest.Mock).mockImplementationOnce(
+        (
+          _contact,
+          _webCallingService,
+          data,
+          _configFlags,
+          _wrapupData,
+          _agentId,
+          _agentName,
+          _answerCallService,
+          apiAIAssistant
+        ) => {
+          const createdTask = createStateMachineTask(data);
+
+          registryEntryDuringConstruction = taskManager.getTask(payload.interactionId);
+          injectedApiAIAssistant = apiAIAssistant;
+
+          return createdTask;
+        }
+      );
+
+      taskManager.on(publicationEvent, (publishedTask) => {
+        publishedTasks.push(publishedTask);
+        expect(publishedTask).toBe((TaskFactory.createTask as jest.Mock).mock.results[0].value);
+        expectTaskConstructedForAISummary();
+      });
+
+      webSocketManagerMock.emit('message', JSON.stringify({data: payload}));
+
+      const createdTask = (TaskFactory.createTask as jest.Mock).mock.results[0].value;
+
+      expect(TaskFactory.createTask).toHaveBeenCalledTimes(1);
+      expect(taskManager.getTask(payload.interactionId)).toBe(createdTask);
+      expect(publishedTasks).toEqual([createdTask]);
+      expectTaskConstructedForAISummary();
+      expect(registryEntryDuringConstruction).toBeUndefined();
+      expect(injectedApiAIAssistant).toBe(mockApiAIAssistant);
+      const publicationCallIndex = taskManagerEmitSpy.mock.calls.findIndex(
+        ([eventName]) => eventName === publicationEvent
+      );
+
+      expect(publicationCallIndex).toBeGreaterThanOrEqual(0);
+    }
+  );
 
-    expect(taskEmitSpy).toHaveBeenCalledWith(
-      TASK_EVENTS.TASK_CONSULT_ACCEPTED,
-      taskManager.getTask(taskId)
-    );
-  });
+  it('should cover task websocket parser exits and reservation re-key', () => {
+    webSocketManagerMock.emit('message', '{bad-json');
+    webSocketManagerMock.emit('message', JSON.stringify({keepalive: true}));
+    webSocketManagerMock.emit('message', JSON.stringify({data: {type: 'unknown'}}));
 
-  it('should invoke sendEvent for configured start/stop backend events', () => {
-    taskManager.setConfigFlags({
-      isEndTaskEnabled: true,
-      isEndConsultEnabled: true,
-      webRtcEnabled: true,
-      autoWrapup: false,
-      aiFeature: {
-        id: 'ai-feature-1',
-        realtimeTranscripts: {
-          enable: true,
-        },
-      },
+    const reservationTask = createStateMachineTask({
+      ...taskDataMock,
+      interactionId: 'reservation-id',
     });
-
-    const interactionId = taskId;
-    const message = (type: CC_EVENTS) =>
+    taskManager.taskCollection = {'reservation-id': reservationTask};
+    webSocketManagerMock.emit(
+      'message',
       JSON.stringify({
         data: {
           ...taskDataMock,
-          interactionId,
-          type,
+          type: CC_EVENTS.AGENT_CONTACT_ASSIGNED,
+          interactionId: 'assigned-id',
+          reservationInteractionId: 'reservation-id',
+          interaction: {mediaType: 'telephony'},
         },
-      });
+      })
+    );
 
-    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.PARTICIPANT_LEFT_CONFERENCE));
-    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_WRAPUP));
+    expect(taskManager.getTask('assigned-id')).toBe(reservationTask);
+    expect(taskManager.getTask('reservation-id')).toBeUndefined();
 
-    expect(mockApiAIAssistant.sendEvent).toHaveBeenCalledTimes(6);
-    expect(mockApiAIAssistant.sendEvent).toHaveBeenCalledWith(
-      'test-agent-id',
-      interactionId,
-      'CUSTOM_EVENT',
-      'GET_TRANSCRIPTS',
-      {action: 'START'}
-    );
-    expect(mockApiAIAssistant.sendEvent).toHaveBeenCalledWith(
-      'test-agent-id',
-      interactionId,
-      'CUSTOM_EVENT',
-      'GET_TRANSCRIPTS',
-      {action: 'STOP'}
-    );
   });
 
-  it('should not invoke sendEvent when realtime transcripts are disabled in aiFeature', () => {
-    taskManager.setConfigFlags({
-      isEndTaskEnabled: true,
-      isEndConsultEnabled: true,
-      webRtcEnabled: true,
-      autoWrapup: false,
-      aiFeature: {
-        id: 'ai-feature-1',
-        realtimeTranscripts: {
-          enable: false,
+  it('should handle campaign update and preview reservation lifecycle hooks', () => {
+    const task = taskManager.getTask(taskId);
+    const campaignUpdatePayload = {
+      data: {
+        ...taskDataMock,
+        type: CC_EVENTS.CAMPAIGN_CONTACT_UPDATED,
+        interaction: {
+          callProcessingDetails: {
+            campaignPreviewAutoAction: 'ACCEPT',
+          },
         },
       },
-    });
+    };
+    const campaignUpdateEmitSpy = jest.spyOn(task, 'emit');
 
-    const message = (type: CC_EVENTS) =>
+    webSocketManagerMock.emit('message', JSON.stringify(campaignUpdatePayload));
+
+    expect(campaignUpdateEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_CAMPAIGN_CONTACT_UPDATED,
+      task
+    );
+    expect(task.data.interaction.callProcessingDetails.campaignPreviewAutoAction).toBe('ACCEPT');
+
+    taskManager.taskCollection = {};
+    webSocketManagerMock.emit(
+      'message',
       JSON.stringify({
         data: {
           ...taskDataMock,
-          interactionId: taskId,
-          type,
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interaction: {mediaType: 'telephony'},
         },
-      });
-
-    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONTACT_ASSIGNED));
-    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULTING));
+      })
+    );
 
-    expect(mockApiAIAssistant.sendEvent).not.toHaveBeenCalled();
+    expect(taskManager.getTask(taskId)).toBeDefined();
+    expect(TaskFactory.createTask).toHaveBeenLastCalledWith(
+      contactMock,
+      webCallingService,
+      expect.objectContaining({
+        wrapUpRequired: false,
+        isConferenceInProgress: false,
+        isAutoAnswering: false,
+      }),
+      undefined,
+      undefined,
+      'test-agent-id',
+      undefined,
+      undefined,
+      mockApiAIAssistant
+    );
   });
 
-  it('should not invoke sendEvent when realtime transcripts config is missing', () => {
-    taskManager.setConfigFlags({
-      isEndTaskEnabled: true,
-      isEndConsultEnabled: true,
-      webRtcEnabled: true,
-      autoWrapup: false,
-      aiFeature: {
-        id: 'ai-feature-1',
-        suggestedResponses: {
-          enable: true,
-        },
+  it('should handle contact merge creation and child cleanup paths', () => {
+    const mergedHandler = jest.fn();
+    const childTask = createStateMachineTask({
+      ...taskDataMock,
+      interactionId: 'child-interaction',
+      interaction: {
+        mediaType: 'telephony',
+        callProcessingDetails: {},
       },
     });
+    taskManager.taskCollection = {child: childTask};
+    taskManager.on(TASK_EVENTS.TASK_MERGED, mergedHandler);
 
-    const message = (type: CC_EVENTS) =>
+    webSocketManagerMock.emit(
+      'message',
       JSON.stringify({
         data: {
           ...taskDataMock,
-          interactionId: taskId,
-          type,
+          type: CC_EVENTS.CONTACT_MERGED,
+          childInteractionId: 'child-interaction',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {},
+          },
         },
-      });
-
-    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONTACT_ASSIGNED));
-    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULTING));
+      })
+    );
 
-    expect(mockApiAIAssistant.sendEvent).not.toHaveBeenCalled();
+    expect(taskManager.getTask('child-interaction')).toBeUndefined();
+    expect(mergedHandler).toHaveBeenCalledWith(taskManager.getTask(taskId));
   });
 
-  it('should emit REAL_TIME_TRANSCRIPTION from RTD websocket payload', () => {
-    const task = taskManager.getTask(taskId);
-    const taskEmitSpy = jest.spyOn(task, 'emit');
-    const realtimePayload = {
-      data: {
-        agentId: 'test-agent-id',
-        data: {
-          content: 'Thank you. Okay.',
-          conversationId: taskId,
-          isFinal: true,
-          languageCode: 'en-US',
-          messageId: '1',
-          orgId: 'org-id',
-          publishTimestamp: 1773807297475,
-          role: 'AGENT',
-          trackingId: 'tracking-id',
-          utteranceId: 'utterance-id',
-        },
-        notifDetails: {
-          actionEvent: 'REAL_TIME_TRANSCRIPTION',
-        },
-        notifType: 'REAL_TIME_TRANSCRIPTION',
-        orgId: 'org-id',
-      },
-      orgId: 'org-id',
-      trackingId: 'notifs_tracking-id',
-      type: 'REAL_TIME_TRANSCRIPTION',
-    };
-
-    taskManager.handleRealtimeWebsocketEvent(JSON.stringify(realtimePayload));
+  it('should return the singleton from getTaskManager', () => {
+    (TaskManager as any).taskManager = undefined;
 
-    expect(taskEmitSpy).toHaveBeenCalledWith(
-      CC_EVENTS.REAL_TIME_TRANSCRIPTION,
-      realtimePayload.data
+    const singleton = TaskManager.getTaskManager(
+      mockApiAIAssistant as any,
+      contactMock,
+      webCallingService,
+      webSocketManagerMock as any,
+      rtdWebSocketManagerMock as any
     );
+
+    expect(
+      TaskManager.getTaskManager(
+        mockApiAIAssistant as any,
+        contactMock,
+        webCallingService,
+        webSocketManagerMock as any,
+        rtdWebSocketManagerMock as any
+      )
+    ).toBe(singleton);
   });
 
-  it('should ignore RTD transcript events when task is not found', () => {
-    const realtimePayload = {
+  it('should cover TaskManager-imported TaskUtils helper branches', () => {
+    const interaction = {
+      interactionId: 'main',
+      owner: 'agent-1',
+      mediaType: 'telephony',
+      participants: {
+        'agent-1': {pType: 'Agent', hasLeft: false},
+        'agent-2': {pType: 'Agent', hasLeft: false, consultState: 'consulting'},
+        customer: {pType: 'Customer', hasLeft: false},
+      },
+      media: {
+        main: {mType: 'mainCall', participants: ['agent-1', 'customer'], isHold: true},
+        consult: {mType: 'consult', participants: ['agent-1', 'agent-2'], isHold: false},
+      },
+      callProcessingDetails: {
+        relationshipType: 'consult',
+        parentInteractionId: 'parent',
+      },
+    } as any;
+    const task = {
       data: {
-        data: {
-          content: 'Thank you. Okay.',
-          conversationId: 'missing-task-id',
-          isFinal: true,
-          languageCode: 'en-US',
-          messageId: '1',
-          orgId: 'org-id',
-          publishTimestamp: 1773807297475,
-          role: 'AGENT',
-          trackingId: 'tracking-id',
-          utteranceId: 'utterance-id',
+        agentId: 'agent-1',
+        interactionId: 'main',
+        mediaResourceId: 'consult',
+        interaction,
+      },
+    } as any;
+
+    expect(getIsCustomerInCall(interaction, 'main')).toBe(true);
+    expect(getConferenceParticipantsCount(interaction, 'main')).toBe(1);
+    expect(getIsConsultInProgressForConferenceControls(interaction, 'main', 'agent-1')).toBe(true);
+    expect(getIsConsultedAgentForControls({isConsulted: true} as any, {} as any, false)).toBe(true);
+    expect(getServerHoldStateForControls({taskData: task.data} as any, 'main')).toBe(true);
+    expect(isPrimary(task, 'agent-1')).toBe(true);
+    expect(isParticipantInMainInteraction(task, 'agent-1')).toBe(true);
+    expect(checkParticipantNotInInteraction(task, 'missing-agent')).toBe(true);
+    expect(getConsultMediaResourceId(interaction, undefined, 'agent-1')).toBe('consult');
+  });
+
+  it('should cover TaskManager-imported TaskUtils negative and auto-answer branches', () => {
+    const baseInteraction = {
+      interactionId: 'interaction-1',
+      owner: 'agent-1',
+      mediaType: 'telephony',
+      mediaChannel: 'telephony',
+      contactDirection: {type: 'OUTBOUND'},
+      outboundType: 'OUTDIAL',
+      previousVTeams: [],
+      participants: {
+        'agent-1': {pType: 'Agent', hasLeft: false, autoAnswerEnabled: true},
+        'agent-left': {pType: 'Agent', hasLeft: true},
+        supervisor: {pType: 'Supervisor', hasLeft: false},
+        vva: {pType: 'VVA', hasLeft: false},
+        customer: {pType: 'Customer', hasLeft: true},
+      },
+      media: {
+        main: {
+          mType: 'mainCall',
+          participants: ['agent-1', 'agent-left', 'supervisor', 'vva', 'customer'],
         },
-        notifDetails: {
-          actionEvent: 'REAL_TIME_TRANSCRIPTION',
+        consultReserved: {
+          mType: 'consult',
+          participants: ['agent-1', 'reserved-agent'],
         },
-        notifType: 'REAL_TIME_TRANSCRIPTION',
-        orgId: 'org-id',
       },
-      orgId: 'org-id',
-      trackingId: 'notifs_tracking-id',
-      type: 'REAL_TIME_TRANSCRIPTION',
-    };
-
-    const existingTaskEmitSpy = jest.spyOn(taskManager.getTask(taskId), 'emit');
-
-    taskManager.handleRealtimeWebsocketEvent(JSON.stringify(realtimePayload));
+      callProcessingDetails: {
+        relationshipType: 'consult',
+        parentInteractionId: 'parent',
+        outdialAgentId: 'agent-1',
+      },
+    } as any;
+
+    expect(getIsCustomerInCall(baseInteraction, 'main')).toBe(false);
+    expect(getIsCustomerInCall({media: {}, participants: {}} as any, 'missing')).toBe(false);
+    expect(getConferenceParticipantsCount(baseInteraction, 'main')).toBe(1);
+    expect(getConferenceParticipantsCount({media: {}, participants: {}} as any, 'missing')).toBe(0);
+    expect(getIsConsultInProgressForConferenceControls(undefined, 'main', 'agent-1')).toBe(false);
+    expect(getIsConsultInProgressForConferenceControls(baseInteraction, undefined, 'agent-1')).toBe(
+      false
+    );
+    expect(
+      getIsConsultInProgressForConferenceControls(
+        {
+          ...baseInteraction,
+          participants: {
+            ...baseInteraction.participants,
+            'reserved-agent': {
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consultReserved',
+              hasJoined: false,
+            },
+          },
+        },
+        'main',
+        'agent-1'
+      )
+    ).toBe(false);
+    expect(getIsConsultedAgentForControls({} as any, {consultInitiator: true} as any, true)).toBe(
+      false
+    );
+    expect(getServerHoldStateForControls({} as any, 'missing')).toBeUndefined();
+    expect(
+      getServerHoldStateForControls(
+        {taskData: {interaction: {media: {main: {}}}, mediaResourceId: 'main'}} as any,
+        undefined
+      )
+    ).toBeUndefined();
 
-    expect(existingTaskEmitSpy).not.toHaveBeenCalled();
+    expect(isPrimary({data: {agentId: 'agent-1', interaction: {}}} as any, 'agent-1')).toBe(true);
+    expect(
+      isPrimary({data: {agentId: 'agent-2', interaction: {owner: 'agent-1'}}} as any, 'agent-2')
+    ).toBe(false);
+    expect(isParticipantInMainInteraction({data: {interaction: {}}} as any, 'agent-1')).toBe(false);
+    expect(checkParticipantNotInInteraction({data: {interaction: {}}} as any, 'agent-1')).toBe(
+      true
+    );
+    expect(
+      checkParticipantNotInInteraction(
+        {
+          data: {
+            interaction: {
+              participants: {'agent-1': {hasLeft: true}},
+            },
+          },
+        } as any,
+        'agent-1'
+      )
+    ).toBe(true);
+    expect(isSecondaryAgent({callProcessingDetails: undefined} as any)).toBe(false);
+    expect(isSecondaryEpDnAgent({...baseInteraction, mediaType: 'email'})).toBe(false);
+    expect(
+      isCampaignPreviewTask({
+        interaction: {
+          outboundType: 'STANDARD_PREVIEW_CAMPAIGN',
+          callProcessingDetails: {},
+        },
+      } as any)
+    ).toBe(true);
+    expect(
+      isCampaignPreviewReservation({
+        data: {type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION},
+      } as any)
+    ).toBe(true);
+    expect(isAutoAnswerEnabled(baseInteraction, 'missing-agent')).toBe(false);
+    expect(isWebRTCCall(baseInteraction, LoginOption.BROWSER, true)).toBe(true);
+    expect(isWebRTCCall(baseInteraction, LoginOption.AGENT_DN, true)).toBe(false);
+    expect(
+      isDigitalOutbound({
+        ...baseInteraction,
+        mediaChannel: 'email',
+      })
+    ).toBe(true);
+    expect(isDigitalOutbound({...baseInteraction, contactDirection: {type: 'INBOUND'}})).toBe(
+      false
+    );
+    expect(hasAgentInitiatedOutdial(baseInteraction, 'agent-1')).toBe(true);
+    expect(
+      hasAgentInitiatedOutdial(
+        {
+          ...baseInteraction,
+          callProcessingDetails: {
+            ...baseInteraction.callProcessingDetails,
+            BLIND_TRANSFER_IN_PROGRESS: true,
+          },
+        },
+        'agent-1'
+      )
+    ).toBe(false);
+    expect(
+      shouldAutoAnswerTask(
+        {interaction: baseInteraction} as any,
+        'agent-1',
+        LoginOption.BROWSER,
+        true
+      )
+    ).toBe(true);
+    expect(
+      shouldAutoAnswerTask(
+        {
+          interaction: {
+            ...baseInteraction,
+            mediaType: 'email',
+            mediaChannel: 'email',
+            previousVTeams: ['queue-1'],
+          },
+        } as any,
+        'agent-1',
+        LoginOption.AGENT_DN,
+        false
+      )
+    ).toBe(false);
+    expect(getConsultMediaResourceId(undefined, undefined, 'agent-1')).toBeUndefined();
   });
 
   it('should not re-emit agent related events', () => {
@@ -2258,7 +4366,7 @@ describe('TaskManager', () => {
   });
 
   it('preserves consult fields from state context during consulting payload refresh', () => {
-    const task = createMockTask({
+    const task = createStateMachineTask({
       ...taskDataMock,
       interaction: {state: 'consulting'} as any,
       interactionId: taskId,
@@ -2292,7 +4400,7 @@ describe('TaskManager', () => {
   });
 
   it('does not preserve stale consult fields once consult is no longer active', () => {
-    const task = createMockTask({
+    const task = createStateMachineTask({
       ...taskDataMock,
       interaction: {state: 'connected'} as any,
       interactionId: taskId,
@@ -2868,17 +4976,11 @@ describe('TaskManager', () => {
     it('correlates child-keyed ContactOwnerChanged and keeps the main task identity', () => {
       const childTaskId = 'surviving-child-id';
       const promotedChildId = 'promoted-child-id';
-      const task = installTask(
-        createConferenceTaskData(childTaskId, previousOwnerId, taskId)
-      );
+      const task = installTask(createConferenceTaskData(childTaskId, previousOwnerId, taskId));
       const hydrateHandler = jest.fn();
       taskManager.on(TASK_EVENTS.TASK_HYDRATE, hydrateHandler);
 
-      const ownerChangeData = createConferenceTaskData(
-        promotedChildId,
-        promotedOwnerId,
-        taskId
-      );
+      const ownerChangeData = createConferenceTaskData(promotedChildId, promotedOwnerId, taskId);
       ownerChangeData.interaction.interactionId = taskId;
       webSocketManagerMock.emit(
         'message',
@@ -2893,9 +4995,9 @@ describe('TaskManager', () => {
       expect(taskManager.taskCollection[childTaskId]).toBeUndefined();
       expect(taskManager.taskCollection[promotedChildId]).toBeUndefined();
       expect(taskManager.taskCollection[taskId]).toBe(task);
-      expect(Object.values(taskManager.taskCollection).filter((entry) => entry === task)).toHaveLength(
-        1
-      );
+      expect(
+        Object.values(taskManager.taskCollection).filter((entry) => entry === task)
+      ).toHaveLength(1);
       expect(hydrateHandler).toHaveBeenCalledTimes(1);
     });
 
@@ -2931,11 +5033,7 @@ describe('TaskManager', () => {
       const mainMediaInteractionId = 'main-media-interaction-id';
       const promotedChildId = 'promoted-child-without-main-id';
       const task = installTask(
-        createConferenceTaskData(
-          mainMediaInteractionId,
-          previousOwnerId,
-          mainMediaInteractionId
-        )
+        createConferenceTaskData(mainMediaInteractionId, previousOwnerId, mainMediaInteractionId)
       );
       const hydrateHandler = jest.fn();
       taskManager.on(TASK_EVENTS.TASK_HYDRATE, hydrateHandler);
@@ -3335,10 +5433,13 @@ describe('TaskManager', () => {
         undefined,
         undefined,
         currentAgentId,
-        undefined
+        undefined,
+        undefined,
+        mockApiAIAssistant
       );
 
       const recoveredTask = (TaskFactory.createTask as jest.Mock).mock.results[0].value;
+      expectTaskConstructedForAISummary();
       expect(recoveredTask.sendStateMachineEvent).toHaveBeenCalledTimes(2);
       expect(recoveredTask.sendStateMachineEvent).toHaveBeenNthCalledWith(
         1,
@@ -3621,7 +5722,7 @@ describe('TaskManager', () => {
 
     it('routes participant-left from a main interaction to a child-keyed task', () => {
       const childTaskId = 'child-interaction-id';
-      const childTask = createMockTask({
+      const childTask = createStateMachineTask({
         ...taskDataMock,
         interactionId: childTaskId,
         isConsulted: true,
@@ -3665,7 +5766,7 @@ describe('TaskManager', () => {
 
     it('routes consult-end from a main interaction to a child-keyed consulted task', () => {
       const childTaskId = 'consult-child-interaction-id';
-      const childTask = createMockTask({
+      const childTask = createStateMachineTask({
         ...taskDataMock,
         interactionId: childTaskId,
         isConsulted: true,
@@ -3700,7 +5801,7 @@ describe('TaskManager', () => {
 
     it('deduplicates aliases of the same child task during related-interaction lookup', () => {
       const childTaskId = 'aliased-child-interaction-id';
-      const childTask = createMockTask({
+      const childTask = createStateMachineTask({
         ...taskDataMock,
         interactionId: childTaskId,
         interaction: {
@@ -3732,7 +5833,7 @@ describe('TaskManager', () => {
 
     it('prefers an exact task match over a child task with the same main interaction', () => {
       const childTaskId = 'child-interaction-id';
-      const childTask = createMockTask({
+      const childTask = createStateMachineTask({
         ...taskDataMock,
         interactionId: childTaskId,
         interaction: {
@@ -3761,7 +5862,7 @@ describe('TaskManager', () => {
     it('does not route a main-interaction event when multiple unique child tasks match', () => {
       delete taskManager.taskCollection[taskId];
       const createChildTask = (interactionId: string) =>
-        createMockTask({
+        createStateMachineTask({
           ...taskDataMock,
           interactionId,
           interaction: {
@@ -3823,7 +5924,7 @@ describe('TaskManager', () => {
 
     it('replaces an EP-DN child task with a hydrated main task on CONTACT_MERGED', () => {
       const childTaskId = 'ep-dn-child-interaction-id';
-      const childTask = createMockTask({
+      const childTask = createStateMachineTask({
         ...taskDataMock,
         interactionId: childTaskId,
         interaction: {
@@ -3915,6 +6016,52 @@ describe('TaskManager', () => {
   });
 
   describe('state machine integration', () => {
+    it('maps the complete contact-center lifecycle event surface', () => {
+      const mapEvent = (TaskManager as any).mapEventToTaskStateMachineEvent.bind(TaskManager);
+      const payload = {
+        ...taskDataMock,
+        participantId: 'participant-1',
+        reason: 'test-reason',
+        agentsPendingWrapUp: ['agent-1'],
+      } as any;
+
+      Object.values(CC_EVENTS).forEach((eventType) => {
+        mapEvent(eventType, payload, 'agent-1');
+      });
+
+      expect(
+        mapEvent(
+          CC_EVENTS.AGENT_CONTACT_RESERVED,
+          {
+            ...payload,
+            interaction: {...payload.interaction, outboundType: 'STANDARD_PREVIEW_CAMPAIGN'},
+          },
+          'agent-1'
+        )
+      ).toMatchObject({isCampaignReservationAccept: true});
+      expect(
+        mapEvent(
+          CC_EVENTS.AGENT_CONTACT_HELD,
+          {
+            ...payload,
+            mediaResourceId: undefined,
+            interaction: {
+              ...payload.interaction,
+              media: {
+                [payload.interactionId]: {mediaResourceId: 'fallback-media-resource'},
+              },
+            },
+          },
+          'agent-1'
+        )
+      ).toMatchObject({mediaResourceId: 'fallback-media-resource'});
+      expect(
+        mapEvent(CC_EVENTS.CONTACT_ENDED, {...payload, agentsPendingWrapUp: undefined}, 'agent-1')
+          .taskData.wrapUpRequired
+      ).toBe(false);
+      expect(mapEvent('UNMAPPED_EVENT', payload, 'agent-1')).toBeNull();
+    });
+
     it('maps CC events to task state machine events using normalized payload', () => {
       const mapped = (TaskManager as any).mapEventToTaskStateMachineEvent(
         CC_EVENTS.AGENT_CONTACT_ASSIGNED,