@webex/contact-center 3.12.0-task-refactor.4 → 3.12.0-task-refactor.6

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

@@ -46,6 +46,487 @@ function createConsultTaskData() {
   });
 }
 
+function createConsultedAgentInconsistentTaskData() {
+  return createTaskData({
+    agentId: 'agent-2',
+    mediaResourceId: 'interaction-1',
+    consultMediaResourceId: 'consult-media',
+    consultingAgentId: 'agent-1',
+    isConsulted: false,
+    interaction: {
+      interactionId: 'interaction-1',
+      mainInteractionId: 'interaction-1',
+      participants: {
+        'agent-1': {id: 'agent-1', pType: 'AGENT', hasLeft: false},
+        'agent-2': {
+          id: 'agent-2',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consulting',
+          currentState: 'consulting',
+          isConsulted: true,
+        },
+        'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+      } as any,
+      media: {
+        'interaction-1': {
+          mediaResourceId: 'interaction-1',
+          mType: 'mainCall',
+          isHold: false,
+          participants: ['agent-1', 'customer-1'],
+        },
+        'consult-media': {
+          mediaResourceId: 'consult-media',
+          mType: 'consult',
+          isHold: false,
+          participants: ['agent-1', 'agent-2'],
+        },
+      } as any,
+    } as any,
+  });
+}
+
+function createPendingConsultHydrateTaskData() {
+  return createTaskData({
+    agentId: 'agent-1',
+    mediaResourceId: 'interaction-1',
+    consultMediaResourceId: 'consult-media',
+    isConsulted: false,
+    interaction: {
+      state: 'conference',
+      interactionId: 'interaction-1',
+      mainInteractionId: 'interaction-1',
+      participants: {
+        'agent-1': {
+          id: 'agent-1',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consultInitiated',
+          isConsulted: false,
+        },
+        'agent-2': {
+          id: 'agent-2',
+          pType: 'AGENT',
+          hasLeft: false,
+          hasJoined: false,
+          consultState: 'consultReserved',
+          isConsulted: true,
+        },
+        'agent-3': {id: 'agent-3', pType: 'AGENT', hasLeft: false, consultState: 'conferencing'},
+        'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+      } as any,
+      media: {
+        'interaction-1': {
+          mediaResourceId: 'interaction-1',
+          isHold: true,
+          mType: 'mainCall',
+          participants: ['agent-1', 'agent-3', 'customer-1'],
+        },
+        'consult-media': {
+          mediaResourceId: 'consult-media',
+          isHold: false,
+          mType: 'consult',
+          participants: ['agent-1', 'agent-2'],
+        },
+      } as any,
+      callProcessingDetails: {
+        conferenceHoldParticipant: 'true',
+      },
+    } as any,
+  });
+}
+
+function createHeldConferenceWithActiveConsultTaskData() {
+  return createTaskData({
+    agentId: 'agent-2',
+    mediaResourceId: 'interaction-1',
+    consultMediaResourceId: 'consult-media',
+    consultingAgentId: 'agent-1',
+    isConsulted: false,
+    interaction: {
+      state: 'conference',
+      interactionId: 'interaction-1',
+      mainInteractionId: 'interaction-1',
+      participants: {
+        'agent-1': {
+          id: 'agent-1',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consulting',
+          isConsulted: false,
+        },
+        'agent-2': {
+          id: 'agent-2',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'agent-3': {
+          id: 'agent-3',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consultReserved',
+          isConsulted: true,
+        },
+        'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+      } as any,
+      media: {
+        'interaction-1': {
+          mediaResourceId: 'interaction-1',
+          isHold: true,
+          mType: 'mainCall',
+          participants: ['agent-1', 'agent-2', 'customer-1'],
+        },
+        'consult-media': {
+          mediaResourceId: 'consult-media',
+          isHold: false,
+          mType: 'consult',
+          participants: ['agent-1', 'agent-3'],
+        },
+      } as any,
+    } as any,
+  });
+}
+
+function createUnheldConferenceWithActiveConsultTaskData() {
+  return createTaskData({
+    agentId: 'agent-2',
+    mediaResourceId: 'interaction-1',
+    isConsulted: false,
+    interaction: {
+      state: 'conference',
+      type: 'AgentContactUnheld',
+      interactionId: 'interaction-1',
+      mainInteractionId: 'interaction-1',
+      owner: 'agent-5',
+      participants: {
+        'agent-2': {
+          id: 'agent-2',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'agent-5': {
+          id: 'agent-5',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consulting',
+          isConsulted: false,
+        },
+        'agent-15': {
+          id: 'agent-15',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consulting',
+          isConsulted: true,
+        },
+        'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+      } as any,
+      media: {
+        'interaction-1': {
+          mediaResourceId: 'interaction-1',
+          isHold: false,
+          mType: 'mainCall',
+          participants: ['customer-1', 'agent-5', 'agent-2'],
+        },
+        'consult-media': {
+          mediaResourceId: 'consult-media',
+          isHold: true,
+          mType: 'consult',
+          participants: ['agent-5', 'agent-15'],
+        },
+      } as any,
+    } as any,
+  });
+}
+
+function createConferenceWithOtherAgentConsultPendingTaskData() {
+  return createTaskData({
+    agentId: 'agent-2',
+    mediaResourceId: 'interaction-1',
+    consultMediaResourceId: 'consult-media',
+    isConsulted: false,
+    interaction: {
+      state: 'conference',
+      interactionId: 'interaction-1',
+      mainInteractionId: 'interaction-1',
+      participants: {
+        'agent-1': {
+          id: 'agent-1',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consultInitiated',
+          isConsulted: false,
+        },
+        'agent-2': {
+          id: 'agent-2',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'agent-3': {
+          id: 'agent-3',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consultReserved',
+          isConsulted: true,
+        },
+        'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+      } as any,
+      media: {
+        'interaction-1': {
+          mediaResourceId: 'interaction-1',
+          isHold: false,
+          mType: 'mainCall',
+          participants: ['agent-1', 'agent-2', 'customer-1'],
+        },
+        'consult-media': {
+          mediaResourceId: 'consult-media',
+          isHold: false,
+          mType: 'consult',
+          participants: ['agent-1', 'agent-3'],
+        },
+      } as any,
+    } as any,
+  });
+}
+
+function createPostConsultCompletedMultiAgentTaskData(agentId: string) {
+  return createTaskData({
+    agentId,
+    mediaResourceId: 'interaction-1',
+    consultMediaResourceId: null as any,
+    isConsulted: false,
+    interaction: {
+      state: 'conference',
+      interactionId: 'interaction-1',
+      mainInteractionId: 'interaction-1',
+      owner: 'agent-1',
+      participants: {
+        'agent-1': {
+          id: 'agent-1',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consultCompleted',
+          isConsulted: false,
+        },
+        'agent-2': {
+          id: 'agent-2',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'agent-3': {
+          id: 'agent-3',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'agent-4': {
+          id: 'agent-4',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'agent-5': {
+          id: 'agent-5',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+      } as any,
+      media: {
+        'interaction-1': {
+          mediaResourceId: 'interaction-1',
+          isHold: true,
+          mType: 'mainCall',
+          participants: ['agent-1', 'agent-2', 'agent-3', 'agent-4', 'agent-5', 'customer-1'],
+        },
+      } as any,
+    } as any,
+  });
+}
+
+function createConferenceConsultingInitiatorTaskData() {
+  return createTaskData({
+    agentId: 'agent-1',
+    mediaResourceId: 'interaction-1',
+    consultMediaResourceId: 'consult-media',
+    consultingAgentId: 'agent-1',
+    isConsulted: false,
+    interaction: {
+      state: 'conference',
+      interactionId: 'interaction-1',
+      mainInteractionId: 'interaction-1',
+      owner: 'agent-1',
+      participants: {
+        'agent-1': {
+          id: 'agent-1',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consulting',
+          isConsulted: false,
+        },
+        'agent-2': {
+          id: 'agent-2',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'agent-4': {
+          id: 'agent-4',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consultReserved',
+          isConsulted: true,
+        },
+        'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+      } as any,
+      media: {
+        'interaction-1': {
+          mediaResourceId: 'interaction-1',
+          isHold: true,
+          mType: 'mainCall',
+          participants: ['agent-1', 'agent-2', 'customer-1'],
+        },
+        'consult-media': {
+          mediaResourceId: 'consult-media',
+          isHold: false,
+          mType: 'consult',
+          participants: ['agent-1', 'agent-4'],
+        },
+      } as any,
+    } as any,
+  });
+}
+
+function createConferenceConsultInitiatedInitiatorTaskData() {
+  return createTaskData({
+    agentId: 'agent-1',
+    mediaResourceId: 'interaction-1',
+    consultMediaResourceId: 'consult-media',
+    destAgentId: 'agent-4',
+    destinationType: 'Agent',
+    isConsulted: false,
+    type: 'AgentConsultCreated' as any,
+    interaction: {
+      state: 'conference',
+      interactionId: 'interaction-1',
+      mainInteractionId: 'interaction-1',
+      owner: 'agent-5',
+      participants: {
+        'agent-1': {
+          id: 'agent-1',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consultInitiated',
+          isConsulted: false,
+        },
+        'agent-2': {
+          id: 'agent-2',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'agent-4': {
+          id: 'agent-4',
+          pType: 'AGENT',
+          hasLeft: false,
+          hasJoined: false,
+          consultState: null,
+          isConsulted: true,
+        },
+        'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+      } as any,
+      media: {
+        'interaction-1': {
+          mediaResourceId: 'interaction-1',
+          isHold: true,
+          mType: 'mainCall',
+          participants: ['agent-1', 'agent-2', 'customer-1'],
+        },
+        'consult-media': {
+          mediaResourceId: 'consult-media',
+          isHold: false,
+          mType: 'consult',
+          participants: ['agent-1', 'agent-4'],
+        },
+      } as any,
+    } as any,
+  });
+}
+
+function createAgentContactUnheldInitiatorConsultTaskData() {
+  return createTaskData({
+    agentId: 'agent-1',
+    mediaResourceId: 'interaction-1',
+    consultMediaResourceId: 'consult-media',
+    destAgentId: null as any,
+    isConsulted: false,
+    interaction: {
+      state: 'conference',
+      interactionId: 'interaction-1',
+      mainInteractionId: 'interaction-1',
+      owner: 'agent-5',
+      participants: {
+        'agent-1': {
+          id: 'agent-1',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consulting',
+          isConsulted: false,
+        },
+        'agent-15': {
+          id: 'agent-15',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'consulting',
+          isConsulted: true,
+        },
+        'agent-5': {
+          id: 'agent-5',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'agent-3': {
+          id: 'agent-3',
+          pType: 'AGENT',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+      } as any,
+      media: {
+        'interaction-1': {
+          mediaResourceId: 'interaction-1',
+          isHold: true,
+          mType: 'mainCall',
+          participants: ['customer-1', 'agent-5', 'agent-3', 'agent-1'],
+        },
+        'consult-media': {
+          mediaResourceId: 'consult-media',
+          isHold: false,
+          mType: 'consult',
+          participants: ['agent-15', 'agent-1'],
+        },
+      } as any,
+    } as any,
+  });
+}
+
 function createVoiceContext(overrides: Partial<TaskContext> = {}): TaskContext {
   return {
     taskData: createConsultTaskData(),
@@ -71,78 +552,574 @@ function createVoiceContext(overrides: Partial<TaskContext> = {}): TaskContext {
   };
 }
 
-describe('uiControlsComputer consult initiator controls', () => {
-  it('returns separate main and consult controls when consult leg is active', () => {
-    const context = createVoiceContext();
+function createTaskData1LikeConferenceConsultTaskData() {
+  return createTaskData({
+    agentId: '058b3e7c-8fcf-45ee-b0c4-4ef546d360b9',
+    mediaResourceId: '72402b8c-802d-4537-84d4-f244c3e586b1',
+    consultMediaResourceId: '66cc5edd-8ac9-4f27-8f48-286edea460b2',
+    consultingAgentId: '058b3e7c-8fcf-45ee-b0c4-4ef546d360b9',
+    destAgentId: '747a2138-0a24-48fc-8d69-3a336d9b7158',
+    interaction: {
+      state: 'conference',
+      type: 'AgentConsulting',
+      interactionId: '72402b8c-802d-4537-84d4-f244c3e586b1',
+      mainInteractionId: '72402b8c-802d-4537-84d4-f244c3e586b1',
+      participants: {
+        '058b3e7c-8fcf-45ee-b0c4-4ef546d360b9': {
+          id: '058b3e7c-8fcf-45ee-b0c4-4ef546d360b9',
+          pType: 'Agent',
+          hasLeft: false,
+          consultState: 'consulting',
+          isConsulted: false,
+        },
+        '747a2138-0a24-48fc-8d69-3a336d9b7158': {
+          id: '747a2138-0a24-48fc-8d69-3a336d9b7158',
+          pType: 'Agent',
+          hasLeft: false,
+          consultState: 'consulting',
+          isConsulted: true,
+        },
+        'e271075a-077d-42d0-9ae4-2a43cb847664': {
+          id: 'e271075a-077d-42d0-9ae4-2a43cb847664',
+          pType: 'Agent',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        'ed612aec-bafe-404d-b9b2-ea7de23a04f0': {
+          id: 'ed612aec-bafe-404d-b9b2-ea7de23a04f0',
+          pType: 'Agent',
+          hasLeft: false,
+          consultState: 'conferencing',
+          isConsulted: false,
+        },
+        '+14696762938': {id: '+14696762938', pType: 'Customer', hasLeft: false},
+      } as any,
+      media: {
+        '72402b8c-802d-4537-84d4-f244c3e586b1': {
+          mediaResourceId: '72402b8c-802d-4537-84d4-f244c3e586b1',
+          mType: 'mainCall',
+          isHold: true,
+          participants: [
+            '+14696762938',
+            'e271075a-077d-42d0-9ae4-2a43cb847664',
+            'ed612aec-bafe-404d-b9b2-ea7de23a04f0',
+            '058b3e7c-8fcf-45ee-b0c4-4ef546d360b9',
+          ],
+        },
+        '66cc5edd-8ac9-4f27-8f48-286edea460b2': {
+          mediaResourceId: '66cc5edd-8ac9-4f27-8f48-286edea460b2',
+          mType: 'consult',
+          isHold: false,
+          participants: ['747a2138-0a24-48fc-8d69-3a336d9b7158', '058b3e7c-8fcf-45ee-b0c4-4ef546d360b9'],
+        },
+      } as any,
+      owner: 'e271075a-077d-42d0-9ae4-2a43cb847664',
+      callProcessingDetails: {
+        conferenceHoldParticipant: 'true',
+      },
+    } as any,
+  });
+}
+
+describe('uiControlsComputer consult initiator controls', () => {
+  it('returns separate main and consult controls when consult leg is active', () => {
+    const context = createVoiceContext();
+
+    const uiControls = computeUIControls(TaskState.CONSULTING, context, context.taskData);
+
+    expect(uiControls.activeLeg).toBe('consult');
+    expect(uiControls.consult).toBeDefined();
+
+    expect(uiControls.main.hold).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.main.transfer).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.main.conference).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: false});
+
+    expect(uiControls.consult.hold).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.consult.mute).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.consult.transfer).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.conference).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.endConsult).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.switch).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('switches top-level controls to main leg while keeping consult leg visible', () => {
+    const context = createVoiceContext({
+      consultCallHeld: true,
+    });
+
+    const uiControls = computeUIControls(TaskState.CONNECTED, context, context.taskData);
+
+    expect(uiControls.activeLeg).toBe('main');
+    expect(uiControls.consult).toBeDefined();
+
+    expect(uiControls.main.hold).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.main.switch).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.transfer).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.conference).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: false});
+
+    expect(uiControls.consult.hold).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.consult.mute).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.consult.transfer).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.consult.conference).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.consult.endConsult).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.end).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.consult.switch).toEqual({isVisible: false, isEnabled: false});
+  });
+
+  it('hides transfer for the consulted agent during consult', () => {
+    const consultedTaskData = createConsultTaskData();
+    const consultedContext = createVoiceContext({
+      consultInitiator: false,
+      taskData: {
+        ...consultedTaskData,
+        isConsulted: true,
+      } as any,
+    });
+
+    const uiControls = computeUIControls(
+      TaskState.CONSULTING,
+      consultedContext,
+      consultedContext.taskData
+    );
+
+    expect(uiControls.consult.transfer).toEqual({isVisible: false, isEnabled: false});
+  });
+
+  it('hides main-leg controls for consulted agent when payload isConsulted is stale false', () => {
+    const taskData = createConsultedAgentInconsistentTaskData();
+    const baseContext = createVoiceContext();
+    const consultedContext = createVoiceContext({
+      consultInitiator: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-2',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONNECTED, consultedContext, taskData);
+
+    expect(uiControls.main.transfer).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.main.end).toEqual({isVisible: false, isEnabled: false});
+  });
+
+  it('keeps consult-ring controls disabled except endConsult during hydrate pending state', () => {
+    const pendingTaskData = createPendingConsultHydrateTaskData();
+    const context = createVoiceContext({
+      taskData: pendingTaskData as any,
+      consultInitiator: false,
+      consultFromConference: false,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+    });
+
+    const uiControls = computeUIControls(TaskState.CONSULTING, context, pendingTaskData as any);
+
+    expect(uiControls.main.transfer).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.main.conference).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: false});
+
+    expect(uiControls.consult.transfer).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.consult.switch).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.consult.mergeToConference).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.consult.endConsult).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('collapses stale consult leg controls during wrapup', () => {
+    const context = createVoiceContext();
+
+    const uiControls = computeUIControls(TaskState.WRAPPING_UP, context, context.taskData);
+
+    expect(uiControls.activeLeg).toBe('main');
+    expect(uiControls.main.wrapup).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult).toEqual(getDefaultUIControls().consult);
+  });
+
+  it('disables consult for non-initiators when another agent has active consult', () => {
+    const taskData = createConferenceWithOtherAgentConsultPendingTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: false,
+      consultFromConference: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-2',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
+
+    expect(uiControls.main.consult).toEqual({isVisible: true, isEnabled: false});
+  });
+
+  it('enables end and exitConference for non-initiators on held main leg while another agent consults', () => {
+    const taskData = createHeldConferenceWithActiveConsultTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-2',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
 
-    const uiControls = computeUIControls(TaskState.CONSULTING, context, context.taskData);
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.exitConference).toEqual({isVisible: true, isEnabled: true});
+  });
 
-    expect(uiControls.activeLeg).toBe('consult');
-    expect(uiControls.consult).toBeDefined();
+  it('enables end and exitConference on held main leg when consultInitiator flag is stale true', () => {
+    const taskData = createHeldConferenceWithActiveConsultTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: true,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-2',
+      },
+    });
 
-    expect(uiControls.main.hold).toEqual({isVisible: false, isEnabled: false});
-    expect(uiControls.main.transfer).toEqual({isVisible: true, isEnabled: false});
-    expect(uiControls.main.conference).toEqual({isVisible: true, isEnabled: false});
-    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: false});
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
 
-    expect(uiControls.consult.hold).toEqual({isVisible: false, isEnabled: false});
-    expect(uiControls.consult.transfer).toEqual({isVisible: true, isEnabled: true});
-    expect(uiControls.consult.conference).toEqual({isVisible: true, isEnabled: true});
-    expect(uiControls.consult.endConsult).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.exitConference).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('enables end and exitConference on unheld main leg for non-initiator during active conference consult', () => {
+    const taskData = createUnheldConferenceWithActiveConsultTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-2',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
+
+    expect(uiControls.activeLeg).toBe('main');
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.exitConference).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('keeps consult disabled for non-owner after owner consult completes in multi-agent conference', () => {
+    const taskData = createPostConsultCompletedMultiAgentTaskData('agent-2');
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-2',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
+
+    expect(uiControls.main.consult).toEqual({isVisible: true, isEnabled: false});
+  });
+
+  it('keeps consult enabled for owner after consult completes in multi-agent conference', () => {
+    const taskData = createPostConsultCompletedMultiAgentTaskData('agent-1');
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-1',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
+
+    expect(uiControls.main.consult).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('hides transfer and enables transferConference on consult leg for conference initiator', () => {
+    const taskData = createConferenceConsultingInitiatorTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: true,
+      consultFromConference: true,
+      consultDestinationAgentJoined: true,
+      consultCallHeld: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-1',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONSULTING, context, taskData);
+
+    expect(uiControls.consult.transfer).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.consult.transferConference).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.transferConference).toEqual({isVisible: true, isEnabled: false});
+  });
+
+  it('keeps consult leg controls active and main leg conference controls disabled on hydrate-like context', () => {
+    const taskData = createConferenceConsultingInitiatorTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: true,
+      consultFromConference: true,
+      consultDestinationAgentJoined: true,
+      consultCallHeld: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-1',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONSULTING, context, taskData);
+
+    expect(uiControls.activeLeg).toBe('consult');
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.main.conference).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.main.transferConference).toEqual({isVisible: true, isEnabled: false});
     expect(uiControls.consult.switch).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.transferConference).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.mergeToConference).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.endConsult).toEqual({isVisible: true, isEnabled: true});
   });
 
-  it('switches top-level controls to main leg while keeping consult leg visible', () => {
+  it('keeps transferConference visible on consult leg for initiator even when state is conferencing', () => {
+    const taskData = createConferenceConsultingInitiatorTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: true,
+      consultFromConference: true,
+      consultDestinationAgentJoined: true,
+      consultCallHeld: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-1',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
+
+    expect(uiControls.consult.transfer).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.consult.transferConference).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('shows transferConference for initiator in AgentContactUnheld-style conference consult context', () => {
+    const taskData = createAgentContactUnheldInitiatorConsultTaskData();
+    const baseContext = createVoiceContext();
     const context = createVoiceContext({
+      consultInitiator: true,
+      consultFromConference: false,
+      consultDestinationAgentJoined: true,
+      consultCallHeld: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-1',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
+
+    expect(uiControls.consult.transferConference).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('shows transferConference on main leg when initiator has active conference consult', () => {
+    const taskData = createConferenceConsultingInitiatorTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: true,
+      consultFromConference: true,
+      consultDestinationAgentJoined: true,
       consultCallHeld: true,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-1',
+      },
     });
 
-    const uiControls = computeUIControls(TaskState.CONNECTED, context, context.taskData);
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
 
     expect(uiControls.activeLeg).toBe('main');
-    expect(uiControls.consult).toBeDefined();
+    expect(uiControls.main.transfer).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.main.transferConference).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.transferConference).toEqual({isVisible: true, isEnabled: false});
+  });
 
-    expect(uiControls.main.hold).toEqual({isVisible: false, isEnabled: false});
-    expect(uiControls.main.switch).toEqual({isVisible: true, isEnabled: true});
-    expect(uiControls.main.transfer).toEqual({isVisible: true, isEnabled: true});
-    expect(uiControls.main.conference).toEqual({isVisible: true, isEnabled: true});
-    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: false});
+  it('keeps transferConference visible on consult leg for taskData1-style payload', () => {
+    const taskData = createTaskData1LikeConferenceConsultTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: true,
+      consultFromConference: true,
+      consultDestinationAgentJoined: true,
+      consultCallHeld: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: '058b3e7c-8fcf-45ee-b0c4-4ef546d360b9',
+      },
+    });
 
-    expect(uiControls.consult.hold).toEqual({isVisible: false, isEnabled: false});
-    expect(uiControls.consult.transfer).toEqual({isVisible: true, isEnabled: false});
-    expect(uiControls.consult.conference).toEqual({isVisible: true, isEnabled: false});
-    expect(uiControls.consult.endConsult).toEqual({isVisible: true, isEnabled: true});
-    expect(uiControls.consult.end).toEqual({isVisible: false, isEnabled: false});
-    expect(uiControls.consult.switch).toEqual({isVisible: false, isEnabled: false});
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
+
+    expect(uiControls.activeLeg).toBe('consult');
+    expect(uiControls.consult.transferConference).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.transfer).toEqual({isVisible: false, isEnabled: false});
   });
 
-  it('hides transfer for the consulted agent during consult', () => {
-    const consultedTaskData = createConsultTaskData();
-    const consultedContext = createVoiceContext({
-      consultInitiator: false,
-      taskData: {
-        ...consultedTaskData,
-        isConsulted: true,
-      } as any,
+  it('enables transferConference after AgentConsulting follows AgentConsultCreated for initiator', () => {
+    const baseContext = createVoiceContext();
+    const createdTaskData = createConferenceConsultInitiatedInitiatorTaskData();
+    const createdContext = createVoiceContext({
+      consultInitiator: true,
+      consultFromConference: true,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      taskData: createdTaskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-1',
+      },
     });
+    const createdControls = computeUIControls(TaskState.CONSULTING, createdContext, createdTaskData);
 
-    const uiControls = computeUIControls(
+    expect(createdControls.consult.transferConference).toEqual({isVisible: true, isEnabled: false});
+
+    const consultingTaskData = createConferenceConsultingInitiatorTaskData();
+    const consultingContext = createVoiceContext({
+      ...createdContext,
+      taskData: consultingTaskData,
+      consultDestinationAgentJoined: true,
+    });
+    const consultingControls = computeUIControls(
       TaskState.CONSULTING,
-      consultedContext,
-      consultedContext.taskData
+      consultingContext,
+      consultingTaskData
     );
 
-    expect(uiControls.consult.transfer).toEqual({isVisible: false, isEnabled: false});
+    expect(consultingControls.consult.transferConference).toEqual({isVisible: true, isEnabled: true});
   });
 
-  it('collapses stale consult leg controls during wrapup', () => {
-    const context = createVoiceContext();
+  it('hides exitConference on main leg for consult initiator before destination joins', () => {
+    const taskData = createConferenceConsultInitiatedInitiatorTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: true,
+      consultFromConference: true,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-1',
+      },
+    });
 
-    const uiControls = computeUIControls(TaskState.WRAPPING_UP, context, context.taskData);
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, taskData);
 
-    expect(uiControls.activeLeg).toBe('main');
-    expect(uiControls.main.wrapup).toEqual({isVisible: true, isEnabled: true});
-    expect(uiControls.consult).toEqual(getDefaultUIControls().consult);
+    expect(uiControls.main.exitConference).toEqual({isVisible: false, isEnabled: false});
+  });
+
+  it('hides exitConference on main leg while consulting and destination has not joined', () => {
+    const taskData = createConferenceConsultInitiatedInitiatorTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: true,
+      consultFromConference: true,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-1',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONSULTING, context, taskData);
+
+    expect(uiControls.main.exitConference).toEqual({isVisible: false, isEnabled: false});
+  });
+
+  it('hides exitConference on main leg for pending self consult even with stale initiator flags', () => {
+    const taskData = createConferenceConsultInitiatedInitiatorTaskData();
+    const baseContext = createVoiceContext();
+    const context = createVoiceContext({
+      consultInitiator: false,
+      consultFromConference: false,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      taskData,
+      uiControlConfig: {
+        ...baseContext.uiControlConfig,
+        agentId: 'agent-1',
+      },
+    });
+
+    const uiControls = computeUIControls(TaskState.CONSULTING, context, taskData);
+
+    expect(uiControls.main.exitConference).toEqual({isVisible: false, isEnabled: false});
+  });
+
+});
+
+describe('uiControlsComputer outdial accept/decline controls', () => {
+  function createOutdialContext(voiceVariant: 'webrtc' | 'pstn' = 'webrtc'): TaskContext {
+    const taskData = createTaskData({
+      interaction: {
+        outboundType: 'OUTDIAL',
+        state: 'new',
+        isTerminated: false,
+      } as any,
+    });
+    return {
+      taskData,
+      consultInitiator: false,
+      exitingConference: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      recordingControlsAvailable: false,
+      recordingInProgress: false,
+      uiControlConfig: {
+        isEndTaskEnabled: true,
+        isEndConsultEnabled: true,
+        channelType: TASK_CHANNEL_TYPE.VOICE,
+        isRecordingEnabled: false,
+        agentId: 'agent-1',
+        voiceVariant,
+      },
+      uiControls: getDefaultUIControls(),
+    };
+  }
+
+  it('accept is visible but disabled for WebRTC outdial in OFFERED state', () => {
+    const context = createOutdialContext('webrtc');
+    const uiControls = computeUIControls(TaskState.OFFERED, context, context.taskData);
+
+    expect(uiControls.main.accept).toEqual({isVisible: true, isEnabled: false});
+  });
+
+  it('decline is visible but disabled for WebRTC outdial in OFFERED state', () => {
+    const context = createOutdialContext('webrtc');
+    const uiControls = computeUIControls(TaskState.OFFERED, context, context.taskData);
+
+    expect(uiControls.main.decline).toEqual({isVisible: true, isEnabled: false});
   });
 });