@webex/contact-center 3.12.0-llmrefactor.2 → 3.12.0-llmrefactor.4

package/src/services/task/state-machine/TaskStateMachine.ts

@@ -52,12 +52,70 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
    * AgentContactHeld          -> TaskEvent.HOLD_SUCCESS
    * AgentContactUnheld        -> TaskEvent.UNHOLD_SUCCESS
    * AgentConsultEnded         -> TaskEvent.CONSULT_END
+   * ParticipantLeftConference -> TaskEvent.PARTICIPANT_LEAVE
    * AgentContactEnded         -> TaskEvent.CONTACT_ENDED
    * AgentWrapup               -> TaskEvent.TASK_WRAPUP (wrapUpRequired)
    * AgentWrappedup            -> TaskEvent.WRAPUP_COMPLETE
    *
    * (See TaskManager.mapEventToTaskStateMachineEvent for the full mapping table.)
    */
+  // XState evaluates these guarded transition arrays in order. Each returned entry is a
+  // complete transition with its own target and actions; sharing them keeps lifecycle-event
+  // handling consistent across active states where ParticipantLeftConference can arrive.
+  const currentAgentParticipantLeaveTransitions = () => [
+    {
+      guard: (params) =>
+        guards.didCurrentAgentLeaveMainInteraction(params) && guards.shouldWrapUp(params),
+      target: TaskState.WRAPPING_UP,
+      actions: [
+        'updateTaskData',
+        'handleParticipantLeft',
+        'markEnded',
+        'clearConsultState',
+        'emitTaskParticipantLeft',
+        'emitTaskWrapup',
+      ],
+    },
+    {
+      guard: guards.didCurrentAgentLeaveMainInteraction,
+      target: TaskState.TERMINATED,
+      actions: [
+        'updateTaskData',
+        'handleParticipantLeft',
+        'markEnded',
+        'clearConsultState',
+        'emitTaskParticipantLeft',
+        'emitTaskEnd',
+      ],
+    },
+  ];
+
+  const currentAgentConsultEndTransitions = () => [
+    {
+      guard: (params) =>
+        guards.didCurrentAgentLeaveMainInteraction(params) && guards.shouldWrapUp(params),
+      target: TaskState.WRAPPING_UP,
+      actions: [
+        'updateTaskData',
+        'markEnded',
+        'clearConsultState',
+        'emitTaskConsultEnd',
+        'emitTaskWrapup',
+      ],
+    },
+    {
+      guard: guards.didCurrentAgentLeaveMainInteraction,
+      target: TaskState.TERMINATED,
+      actions: [
+        'updateTaskData',
+        'markEnded',
+        'clearConsultState',
+        'emitTaskConsultEnd',
+        'emitTaskEnd',
+      ],
+    },
+  ];
+
   return {
     id: 'taskStateMachine',
     initial: TaskState.IDLE,
@@ -70,7 +128,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
         actions: ['updateTaskData', 'syncTaskDataFromEvent'],
       },
       [TaskEvent.CONTACT_OWNER_CHANGED]: {
-        actions: ['updateTaskData', 'syncTaskDataFromEvent'],
+        actions: ['updateTaskData', 'syncTaskDataFromEvent', 'emitTaskHydrate'],
       },
       // HYDRATE: Update task data from AgentContact event
       // Note: State restoration with transitions is handled in IDLE state.
@@ -190,10 +248,17 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             target: TaskState.TERMINATED,
             actions: ['updateTaskData', 'markEnded', 'emitTaskReject'],
           },
-          [TaskEvent.TASK_WRAPUP]: {
-            target: TaskState.TERMINATED,
-            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd'],
-          },
+          [TaskEvent.TASK_WRAPUP]: [
+            {
+              guard: guards.shouldWrapUp,
+              target: TaskState.WRAPPING_UP,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup'],
+            },
+            {
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskEnd'],
+            },
+          ],
           [TaskEvent.CONTACT_ENDED]: {
             target: TaskState.TERMINATED,
             actions: ['updateTaskData', 'markEnded', 'emitTaskEnd'],
@@ -334,6 +399,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           },
           // AgentConsultEnded from Stable Prod while on connected leg (external end consult).
           [TaskEvent.CONSULT_END]: [
+            ...currentAgentConsultEndTransitions(),
             {
               guard: ({context, event}) => {
                 if (context.consultInitiator !== true) return false;
@@ -350,6 +416,14 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
             },
           ],
+          // Routing lifecycle events can arrive out of order in child-task/EP-DN flows. The
+          // local actor may still be CONNECTED when ParticipantLeftConference reports that this
+          // agent left the main interaction. Handle that self-departure race; for another
+          // participant, the action-only fallback updates data while preserving CONNECTED.
+          [TaskEvent.PARTICIPANT_LEAVE]: [
+            ...currentAgentParticipantLeaveTransitions(),
+            {actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']},
+          ],
           // AgentContactEnded Event
           [TaskEvent.CONTACT_ENDED]: [
             {
@@ -380,6 +454,17 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             target: TaskState.WRAPPING_UP,
             actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup'],
           },
+          [TaskEvent.OUTBOUND_FAILED]: [
+            {
+              guard: guards.shouldWrapUp,
+              target: TaskState.WRAPPING_UP,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup'],
+            },
+            {
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
+            },
+          ],
           [TaskEvent.PAUSE_RECORDING]: {
             actions: ['updateTaskData', 'setRecordingState', 'emitTaskRecordingPaused'],
           },
@@ -401,6 +486,24 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             target: TaskState.CONNECTED,
             actions: ['updateTaskData'],
           },
+          // Another agent can remove this agent while the local hold request is awaiting its
+          // routing acknowledgement. Process that backend lifecycle event independently of
+          // whether Drop was initiated from this task; another-participant event preserves state.
+          [TaskEvent.PARTICIPANT_LEAVE]: [
+            ...currentAgentParticipantLeaveTransitions(),
+            {actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']},
+          ],
+          [TaskEvent.OUTBOUND_FAILED]: [
+            {
+              guard: guards.shouldWrapUp,
+              target: TaskState.WRAPPING_UP,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup'],
+            },
+            {
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
+            },
+          ],
         },
       },
 
@@ -487,14 +590,30 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             },
           ],
           // AgentConsultEnded from Stable Prod while main leg is held (external end consult).
-          [TaskEvent.CONSULT_END]: {
-            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
-          },
+          [TaskEvent.CONSULT_END]: [
+            ...currentAgentConsultEndTransitions(),
+            {actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']},
+          ],
+          [TaskEvent.PARTICIPANT_LEAVE]: [
+            ...currentAgentParticipantLeaveTransitions(),
+            {actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']},
+          ],
           // TODO: This may not be a valid transition, this needs to be checked as well
           [TaskEvent.TASK_WRAPUP]: {
             target: TaskState.WRAPPING_UP,
             actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup'],
           },
+          [TaskEvent.OUTBOUND_FAILED]: [
+            {
+              guard: guards.shouldWrapUp,
+              target: TaskState.WRAPPING_UP,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup'],
+            },
+            {
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
+            },
+          ],
         },
       },
 
@@ -507,6 +626,22 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           [TaskEvent.UNHOLD_FAILED]: {
             target: TaskState.HELD,
           },
+          // The same remote-removal race can occur while an unhold request is in flight.
+          [TaskEvent.PARTICIPANT_LEAVE]: [
+            ...currentAgentParticipantLeaveTransitions(),
+            {actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']},
+          ],
+          [TaskEvent.OUTBOUND_FAILED]: [
+            {
+              guard: guards.shouldWrapUp,
+              target: TaskState.WRAPPING_UP,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup'],
+            },
+            {
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
+            },
+          ],
         },
       },
 
@@ -569,6 +704,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           ],
           // AgentConsultEnded from Stable Prod during consult initiation (external end consult).
           [TaskEvent.CONSULT_END]: [
+            ...currentAgentConsultEndTransitions(),
             {
               guard: guards.isPrimaryMediaOnHold,
               target: TaskState.HELD,
@@ -579,6 +715,21 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
             },
           ],
+          [TaskEvent.PARTICIPANT_LEAVE]: [
+            ...currentAgentParticipantLeaveTransitions(),
+            {actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']},
+          ],
+          [TaskEvent.OUTBOUND_FAILED]: [
+            {
+              guard: guards.shouldWrapUp,
+              target: TaskState.WRAPPING_UP,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup'],
+            },
+            {
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
+            },
+          ],
         },
       },
 
@@ -619,6 +770,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
 
           // AgentConsultEnded
           [TaskEvent.CONSULT_END]: [
+            ...currentAgentConsultEndTransitions(),
             {
               // Initiator returning to conference only while conference is still active.
               guard: ({context, event}) =>
@@ -686,7 +838,13 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             {
               // Consulted agent → TERMINATED
               target: TaskState.TERMINATED,
-              actions: ['updateTaskData'],
+              actions: [
+                'updateTaskData',
+                'markEnded',
+                'clearConsultState',
+                'emitTaskConsultEnd',
+                'emitTaskEnd',
+              ],
             },
           ],
 
@@ -705,34 +863,10 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           },
 
           [TaskEvent.PARTICIPANT_LEAVE]: [
+            ...currentAgentParticipantLeaveTransitions(),
             {
               guard: (params) =>
-                guards.didCurrentAgentLeaveConference(params) && guards.shouldWrapUp(params),
-              target: TaskState.WRAPPING_UP,
-              actions: [
-                'updateTaskData',
-                'handleParticipantLeft',
-                'markEnded',
-                'clearConsultState',
-                'emitTaskParticipantLeft',
-                'emitTaskWrapup',
-              ],
-            },
-            {
-              guard: guards.didCurrentAgentLeaveConference,
-              target: TaskState.TERMINATED,
-              actions: [
-                'updateTaskData',
-                'handleParticipantLeft',
-                'markEnded',
-                'clearConsultState',
-                'emitTaskParticipantLeft',
-                'emitTaskEnd',
-              ],
-            },
-            {
-              guard: (params) =>
-                !guards.didCurrentAgentLeaveConference(params) &&
+                !guards.didCurrentAgentLeaveMainInteraction(params) &&
                 guards.shouldDowngradeConferenceToConnected(params),
               target: TaskState.CONNECTED,
               actions: [
@@ -825,6 +959,17 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             target: TaskState.WRAPPING_UP,
             actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup'],
           },
+          [TaskEvent.OUTBOUND_FAILED]: [
+            {
+              guard: guards.shouldWrapUp,
+              target: TaskState.WRAPPING_UP,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup'],
+            },
+            {
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
+            },
+          ],
           [TaskEvent.MERGE_TO_CONFERENCE]: {
             target: TaskState.CONF_INITIATING,
           },
@@ -860,6 +1005,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           },
           // AgentConsultEnded while conference is initiating (end call before conference completes)
           [TaskEvent.CONSULT_END]: [
+            ...currentAgentConsultEndTransitions(),
             {
               guard: ({event}) => {
                 const taskData = getTaskDataFromEvent(event);
@@ -874,6 +1020,21 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'clearConsultState'],
             },
           ],
+          [TaskEvent.PARTICIPANT_LEAVE]: [
+            ...currentAgentParticipantLeaveTransitions(),
+            {actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']},
+          ],
+          [TaskEvent.OUTBOUND_FAILED]: [
+            {
+              guard: guards.shouldWrapUp,
+              target: TaskState.WRAPPING_UP,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup'],
+            },
+            {
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
+            },
+          ],
         },
       },
 
@@ -901,6 +1062,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
 
           // Needed as all agents in conference get this event, hence we need to clear the consult state
           [TaskEvent.CONSULT_END]: [
+            ...currentAgentConsultEndTransitions(),
             {
               guard: ({context, event}) => {
                 const taskData = getTaskDataFromEvent(event);
@@ -975,37 +1137,11 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
 
           // Participant leaves - handle conference downgrade scenarios
           [TaskEvent.PARTICIPANT_LEAVE]: [
-            {
-              // Only the leaving agent should wrap up → WRAPPING_UP
-              guard: (params) =>
-                guards.didCurrentAgentLeaveConference(params) && guards.shouldWrapUp(params),
-              target: TaskState.WRAPPING_UP,
-              actions: [
-                'updateTaskData',
-                'handleParticipantLeft',
-                'markEnded',
-                'clearConsultState',
-                'emitTaskParticipantLeft',
-                'emitTaskWrapup',
-              ],
-            },
-            {
-              // Only the leaving agent (no wrapup) → TERMINATED
-              guard: guards.didCurrentAgentLeaveConference,
-              target: TaskState.TERMINATED,
-              actions: [
-                'updateTaskData',
-                'handleParticipantLeft',
-                'markEnded',
-                'clearConsultState',
-                'emitTaskParticipantLeft',
-                'emitTaskEnd',
-              ],
-            },
+            ...currentAgentParticipantLeaveTransitions(),
             {
               // Conference downgraded, customer present → CONNECTED
               guard: (params) =>
-                !guards.didCurrentAgentLeaveConference(params) &&
+                !guards.didCurrentAgentLeaveMainInteraction(params) &&
                 guards.shouldDowngradeConferenceToConnected(params),
               target: TaskState.CONNECTED,
               actions: [
@@ -1115,6 +1251,17 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             target: TaskState.WRAPPING_UP,
             actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup'],
           },
+          [TaskEvent.OUTBOUND_FAILED]: [
+            {
+              guard: guards.shouldWrapUp,
+              target: TaskState.WRAPPING_UP,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup'],
+            },
+            {
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
+            },
+          ],
         },
       },
 

package/src/services/task/state-machine/actions.ts

@@ -515,12 +515,15 @@ export const actions: TaskActionsMap = {
   }),
   handleConferenceStarted: assign({consultInitiator: false}),
 
-  setConsultDestination: assign(({event}: TaskActionArgs) => {
+  setConsultDestination: assign(({context, event}: TaskActionArgs) => {
     if (!event || event.type !== TaskEvent.CONSULT) {
       return {};
     }
 
-    const taskData = getTaskDataFromEvent(event);
+    // CONSULT is a user action and does not carry taskData. Preserve the current interaction
+    // snapshot while recording the destination; replacing it with only destAgentId would remove
+    // the main-leg membership needed to correlate an immediately following lifecycle event.
+    const taskData = context.taskData;
     const consultDestinationType =
       'destinationType' in event ? event.destinationType ?? null : null;
     const consultDestinationAgentId =

package/src/services/task/state-machine/ai-docs/AGENTS.md

@@ -66,7 +66,7 @@ state-machine/
 - **State Graph and Transition Rules**: `TaskStateMachine.ts` defines all states, transition tables, and event handlers that drive the task lifecycle.
 - **Deterministic Context Updates**: `actions.ts` implements XState actions for task context mutation and provides emitter placeholders that `Task` overrides to surface SDK events.
 - **Transition Eligibility**: `guards.ts` contains pure predicates that gate transitions based on current context, task data, and backend state.
-- **UI Controls Computation**: `uiControlsComputer.ts` derives `TaskUIControls` from state and context for voice/digital channels, keeping UI enablement centralized.
+- **UI Controls Computation**: `uiControlsComputer.ts` derives per-leg action controls and ordered Consult/Transfer destination categories from state, Task data, and injected profile policy for voice/digital channels. Consumers read `task.uiControls`; do not add a parallel policy method or UI-side decision tree.
 - **Typed Event Contracts**: `constants.ts` and `types.ts` define `TaskState`, `TaskEvent`, and the `TaskEventPayloadMap` so transitions and payloads stay type-safe.
 - **Public Exports**: `index.ts` exposes the state machine factory, event enums, and types for consumption by the task layer.
 
@@ -266,14 +266,18 @@ shouldWrapUpOrIsInitiator(context, event) {
   return Boolean(event.taskData?.wrapUpRequired || context.consultInitiator);
 }
 
-// Check whether the leaving participant is the current agent
-didCurrentAgentLeaveConference(context, event) {
+// Check whether the current agent left the main interaction
+didCurrentAgentLeaveMainInteraction(context, event) {
   const selfAgentId = getSelfAgentId(context, event.taskData);
   if (!selfAgentId) return false;
 
   const participantIdFromEvent = 'participantId' in event ? event.participantId : undefined;
   const participantId = participantIdFromEvent ?? event.taskData?.participantId;
-  return Boolean(participantId) && participantId === selfAgentId;
+  if (Boolean(participantId) && participantId === selfAgentId) return true;
+  // Explicit hasLeft or removal of a previously active self from the participant map is terminal.
+  // PARTICIPANT_LEAVE naming another participant does not infer self departure from media.
+  // Only a from-conference CONSULT_END may compare mainCall membership, and only when self
+  // remains active in the participant map and on the consult leg. Partial ordinary calls are false.
 }
 ```
 

package/src/services/task/state-machine/ai-docs/ARCHITECTURE.md

@@ -30,7 +30,7 @@ It is instantiated by `Task` and receives mapped backend/user events through `se
 2. `createActor(machine).start()`
 3. `TaskManager` and task APIs map external signals to `TaskEvent`
 4. Actor transitions update context and execute action overrides
-5. `Task` recomputes UI controls and emits task-level events
+5. `Task` recomputes per-leg controls plus ordered Consult/Transfer destination availability and emits task-level events when either changes
 
 ---
 
@@ -464,10 +464,10 @@ It is instantiated by `Task` and receives mapped backend/user events through `se
   - Guard: none
   - Actions: `clearTransferConferenceRequested`
 - `PARTICIPANT_LEAVE` -> `WRAPPING_UP`
-  - Guard: `guards.didCurrentAgentLeaveConference && guards.shouldWrapUp`
+  - Guard: `guards.didCurrentAgentLeaveMainInteraction && guards.shouldWrapUp`
   - Actions: `updateTaskData`, `handleParticipantLeft`, `markEnded`, `clearConsultState`, `emitTaskParticipantLeft`, `emitTaskWrapup`
 - `PARTICIPANT_LEAVE` -> `TERMINATED`
-  - Guard: `guards.didCurrentAgentLeaveConference`
+  - Guard: `guards.didCurrentAgentLeaveMainInteraction`
   - Actions: `updateTaskData`, `handleParticipantLeft`, `markEnded`, `clearConsultState`, `emitTaskParticipantLeft`, `emitTaskEnd`
 - `PARTICIPANT_LEAVE` -> `CONNECTED`
   - Guard: `guards.shouldDowngradeConferenceToConnected`
@@ -475,6 +475,15 @@ It is instantiated by `Task` and receives mapped backend/user events through `se
 - `PARTICIPANT_LEAVE` -> stay `CONFERENCING` (default)
   - Guard: default
   - Actions: `updateTaskData`, `handleParticipantLeft`, `emitTaskParticipantLeft`
+
+`didCurrentAgentLeaveMainInteraction` treats an explicit self participant ID,
+self `hasLeft`, or removal from a previously active participant map as terminal.
+A `PARTICIPANT_LEAVE` event naming another participant does not infer departure
+from media membership. The previous-versus-updated `mainCall` comparison is
+restricted to from-conference `CONSULT_END` nested-consult cleanup when self
+remains active in the participant map and on the consult leg; partial ordinary CONNECTED/HELD
+snapshots remain non-terminal.
+
 - `CONFERENCE_END` -> `WRAPPING_UP`
   - Guard: `guards.shouldWrapUp`
   - Actions: `updateTaskData`, `markEnded`, `clearConsultState`, `emitTaskWrapup`
@@ -809,7 +818,7 @@ Complete mapping from backend CC_EVENTS to internal TaskEvent types.
 | API `task.consultConference()`   | `MERGE_TO_CONFERENCE`         | CONSULTING → CONF_INITIATING                               | Starts merge flow                                                                             |
 | `AgentConsultConferenced`        | `CONFERENCE_START`            | CONSULTING/CONF_INITIATING → CONFERENCING                  | `handleConferenceStarted` path                                                                |
 | `ParticipantJoinedConference`    | `CONFERENCE_START`            | CONFERENCING → CONFERENCING                                | Refresh + emit conference started                                                             |
-| `ParticipantLeftConference`      | `PARTICIPANT_LEAVE`           | CONFERENCING → WRAPPING_UP / TERMINATED / CONNECTED / stay | Uses `didCurrentAgentLeaveConference`, `shouldWrapUp`, `shouldDowngradeConferenceToConnected` |
+| `ParticipantLeftConference`      | `PARTICIPANT_LEAVE`           | Any active call-control state → WRAPPING_UP / TERMINATED / CONNECTED / stay | Uses `didCurrentAgentLeaveMainInteraction`, `shouldWrapUp`, `shouldDowngradeConferenceToConnected` |
 | `AgentConsultConferenceEnded`    | `CONFERENCE_END`              | CONFERENCING → WRAPPING_UP / CONNECTED / TERMINATED        | Guard-based branch                                                                            |
 | `AgentConsultConferenceFailed`   | `CONFERENCE_FAILED`           | CONF_INITIATING → CONSULTING                               | Merge failed fallback                                                                         |
 | `AgentConferenceTransferred`     | `TRANSFER_CONFERENCE_SUCCESS` | CONSULTING/CONFERENCING branch logic                       | Initiator/receiver dependent                                                                  |
@@ -921,8 +930,8 @@ stateDiagram-v2
 
     %% CONFERENCING
     CONFERENCING --> CONSULT_INITIATING: CONSULT (State Machine Event)
-    CONFERENCING --> WRAPPING_UP: PARTICIPANT_LEAVE (CC Event) -> PARTICIPANT_LEAVE (State Machine Event) [didCurrentAgentLeaveConference && shouldWrapUp]
-    CONFERENCING --> TERMINATED: PARTICIPANT_LEAVE (CC Event) -> PARTICIPANT_LEAVE (State Machine Event) [didCurrentAgentLeaveConference]
+    CONFERENCING --> WRAPPING_UP: PARTICIPANT_LEAVE (CC Event) -> PARTICIPANT_LEAVE (State Machine Event) [didCurrentAgentLeaveMainInteraction && shouldWrapUp]
+    CONFERENCING --> TERMINATED: PARTICIPANT_LEAVE (CC Event) -> PARTICIPANT_LEAVE (State Machine Event) [didCurrentAgentLeaveMainInteraction]
     CONFERENCING --> CONNECTED: PARTICIPANT_LEAVE (CC Event) -> PARTICIPANT_LEAVE (State Machine Event) [shouldDowngradeConferenceToConnected]
     CONFERENCING --> WRAPPING_UP: CONFERENCE_END (CC Event) -> CONFERENCE_END (State Machine Event) [shouldWrapUp]
     CONFERENCING --> CONNECTED: CONFERENCE_END (CC Event) -> CONFERENCE_END (State Machine Event) [customerInCall]
@@ -1038,8 +1047,8 @@ stateDiagram-v2
     CONFERENCING --> CONFERENCING: AGENT_CONFERENCE_TRANSFERRED -> TRANSFER_CONFERENCE_SUCCESS
     CONFERENCING --> CONFERENCING: AGENT_CONFERENCE_TRANSFER_FAILED-> TRANSFER_CONFERENCE_FAILED
 
-    CONFERENCING --> WRAPPING_UP: PARTICIPANT_LEFT_CONFERENCE -> PARTICIPANT_LEAVE [didCurrentAgentLeaveConference && shouldWrapUp]
-    CONFERENCING --> TERMINATED: PARTICIPANT_LEFT_CONFERENCE -> PARTICIPANT_LEAVE [didCurrentAgentLeaveConference]
+    CONFERENCING --> WRAPPING_UP: PARTICIPANT_LEFT_CONFERENCE -> PARTICIPANT_LEAVE [didCurrentAgentLeaveMainInteraction && shouldWrapUp]
+    CONFERENCING --> TERMINATED: PARTICIPANT_LEFT_CONFERENCE -> PARTICIPANT_LEAVE [didCurrentAgentLeaveMainInteraction]
     CONFERENCING --> CONNECTED: PARTICIPANT_LEFT_CONFERENCE -> PARTICIPANT_LEAVE [shouldDowngradeConferenceToConnected]
     CONFERENCING --> WRAPPING_UP: AGENT_CONSULT_CONFERENCE_ENDED -> CONFERENCE_END [shouldWrapUp]
     CONFERENCING --> CONNECTED: AGENT_CONSULT_CONFERENCE_ENDED -> CONFERENCE_END [customerInCall]