@webex/contact-center 3.11.0 → 3.12.0-auth-prejoin-fetch.1

package/dist/services/task/state-machine/TaskStateMachine.js

@@ -0,0 +1,971 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTaskStateMachine = createTaskStateMachine;
+exports.getTaskStateMachineConfig = getTaskStateMachineConfig;
+var _xstate = require("xstate");
+var _constants = require("./constants");
+var _actions = require("./actions");
+var _guards = require("./guards");
+var _TaskUtils = require("../TaskUtils");
+/**
+ * Task State Machine Configuration
+ *
+ * This file defines the XState state machine configuration for contact center tasks.
+ * It orchestrates state transitions, guards, and actions for task lifecycle management.
+ *
+ * GUARD FUNCTIONS: All guard logic is centralized in guards.ts for reusability and testing.
+ * This file imports and uses those guards via the `guards` object.
+ */
+
+const taskStateMachineSetup = (0, _xstate.setup)({
+  actors: {},
+  types: {
+    context: {},
+    events: {}
+  }
+});
+
+/**
+ * Get task state machine configuration with UI control config
+ * Defines all states, transitions, guards, and actions for task management
+ *
+ * @param uiControlConfig - UI control configuration
+ * @returns State machine configuration object
+ */
+function getTaskStateMachineConfig(uiControlConfig) {
+  /**
+   * Event mapping reference (CC WebSocket -> TaskEvent)
+   *
+   * AgentContactReserved      -> TaskEvent.TASK_INCOMING
+   * AgentOfferContact         -> TaskEvent.TASK_OFFERED
+   * AgentOfferConsult         -> TaskEvent.OFFER_CONSULT
+   * AgentConsulting           -> TaskEvent.CONSULTING_ACTIVE
+   * AgentConsultCreated       -> TaskEvent.CONSULT_CREATED
+   * AgentConsultTransferred   -> TaskEvent.TRANSFER_SUCCESS
+   * AgentContactAssigned      -> TaskEvent.ASSIGN
+   * 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.guards.didCurrentAgentLeaveMainInteraction(params) && _guards.guards.shouldWrapUp(params),
+    target: _constants.TaskState.WRAPPING_UP,
+    actions: ['updateTaskData', 'handleParticipantLeft', 'markEnded', 'clearConsultState', 'emitTaskParticipantLeft', 'emitTaskWrapup']
+  }, {
+    guard: _guards.guards.didCurrentAgentLeaveMainInteraction,
+    target: _constants.TaskState.TERMINATED,
+    actions: ['updateTaskData', 'handleParticipantLeft', 'markEnded', 'clearConsultState', 'emitTaskParticipantLeft', 'emitTaskEnd']
+  }];
+  const currentAgentConsultEndTransitions = () => [{
+    guard: params => _guards.guards.didCurrentAgentLeaveMainInteraction(params) && _guards.guards.shouldWrapUp(params),
+    target: _constants.TaskState.WRAPPING_UP,
+    actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskConsultEnd', 'emitTaskWrapup']
+  }, {
+    guard: _guards.guards.didCurrentAgentLeaveMainInteraction,
+    target: _constants.TaskState.TERMINATED,
+    actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskConsultEnd', 'emitTaskEnd']
+  }];
+  return {
+    id: 'taskStateMachine',
+    initial: _constants.TaskState.IDLE,
+    context: (0, _actions.createInitialContext)(uiControlConfig, _constants.TaskState.IDLE),
+    on: {
+      [_constants.TaskEvent.RECORDING_STARTED]: {
+        actions: ['updateTaskData', 'emitTaskRecordingStarted']
+      },
+      [_constants.TaskEvent.CONTACT_UPDATED]: {
+        actions: ['updateTaskData', 'syncTaskDataFromEvent']
+      },
+      [_constants.TaskEvent.CONTACT_OWNER_CHANGED]: {
+        actions: ['updateTaskData', 'syncTaskDataFromEvent', 'emitTaskHydrate']
+      },
+      // HYDRATE: Update task data from AgentContact event
+      // Note: State restoration with transitions is handled in IDLE state.
+      // This root-level handler is for when task is already in another state (just updates data).
+      [_constants.TaskEvent.HYDRATE]: {
+        actions: ['updateTaskData', 'emitTaskHydrate']
+      },
+      // AgentConsultCreated from Stable Prod while already HELD/CONNECTED (external consult).
+      // Child states do not handle CONSULT_CREATED; wire here so updateTaskData + setConsultInitiator run.
+      [_constants.TaskEvent.CONSULT_CREATED]: {
+        actions: ['updateTaskData', 'setConsultInitiator']
+      },
+      // AgentConsultFailed (RONA) while HELD/CONNECTED without passing through CONSULT_INITIATING.
+      [_constants.TaskEvent.CONSULT_FAILED]: {
+        actions: ['updateTaskData', 'handleConsultFailed']
+      }
+    },
+    states: {
+      [_constants.TaskState.IDLE]: {
+        on: {
+          // HYDRATE: Restore state machine to correct state based on hydrated task data
+          // This handles page refresh/reconnection scenarios where task needs to be restored
+          // IMPORTANT: This MUST be in IDLE state (not root) because root-level events cannot
+          // transition to child states in XState
+          [_constants.TaskEvent.HYDRATE]: [{
+            guard: _guards.guards.isInteractionTerminated,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskHydrate']
+          }, {
+            guard: _guards.guards.isEpDnPendingConferenceMergeHydrate,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }, {
+            guard: _guards.guards.isInteractionConsulting,
+            target: _constants.TaskState.CONSULTING,
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }, {
+            guard: _guards.guards.isInteractionHeld,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }, {
+            guard: _guards.guards.isInteractionConnected,
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }, {
+            guard: _guards.guards.isConferencingByParticipants,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }, {
+            // Default: just update data, stay in IDLE
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }],
+          // AgentContactReserved (direct incoming/consult/transfer/outdial, or campaign preview accept)
+          [_constants.TaskEvent.TASK_INCOMING]: [{
+            guard: _guards.guards.isCampaignReservationAccept,
+            target: _constants.TaskState.OFFERED,
+            actions: ['initializeTask', 'emitTaskCampaignPreviewReservation']
+          }, {
+            target: _constants.TaskState.OFFERED,
+            actions: ['initializeTask', 'emitTaskIncoming']
+          }],
+          // AgentOutboundFailed can arrive before TASK_INCOMING due to race conditions
+          [_constants.TaskEvent.OUTBOUND_FAILED]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd']
+          },
+          // EP-DN split-leg ordering can deliver AgentConsulting before HYDRATE/TASK_INCOMING.
+          // Do not drop it in IDLE; bootstrap to CONSULTING using event taskData.
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['setConsultInitiator', 'setConsultDestination', 'setConsultFromConference', 'setConsultAgentJoined', 'updateTaskData', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          }
+        }
+      },
+      [_constants.TaskState.OFFERED]: {
+        on: {
+          // AgentContactOffer
+          [_constants.TaskEvent.TASK_OFFERED]: {
+            actions: ['updateTaskData', 'emitTaskOfferContact', 'requestAutoAnswer']
+          },
+          // AgentContactAssigned
+          [_constants.TaskEvent.ASSIGN]: [{
+            guard: _guards.guards.isConsultingAssignment,
+            target: _constants.TaskState.CONSULTING,
+            actions: ['updateTaskData', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'emitTaskAssigned']
+          }],
+          // AgentOfferContactRONA
+          [_constants.TaskEvent.RONA]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskReject']
+          },
+          [_constants.TaskEvent.TASK_WRAPUP]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd']
+          }],
+          [_constants.TaskEvent.CONTACT_ENDED]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd']
+          },
+          // This needs to be handled for all assign failed scenarios (contact, buddy)
+          // [AgentContactAssignFailed, AgentCtqFailed, AgentBlindTransferFailed,
+          //  AgentVTeamTransferFailed, AgentConsultTransferFailed]
+          [_constants.TaskEvent.ASSIGN_FAILED]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskReject']
+          },
+          [_constants.TaskEvent.INVITE_FAILED]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskReject']
+          },
+          [_constants.TaskEvent.OUTBOUND_FAILED]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd']
+          }],
+          [_constants.TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED]: {
+            actions: ['updateTaskData', 'emitTaskCampaignPreviewAcceptFailed']
+          },
+          [_constants.TaskEvent.CAMPAIGN_PREVIEW_SKIP_FAILED]: {
+            actions: ['updateTaskData', 'emitTaskCampaignPreviewSkipFailed']
+          },
+          [_constants.TaskEvent.CAMPAIGN_PREVIEW_REMOVE_FAILED]: {
+            actions: ['updateTaskData', 'emitTaskCampaignPreviewRemoveFailed']
+          },
+          // AgentConsulting comes for received after the initial consult is accepted
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: [{
+            target: _constants.TaskState.CONSULTING,
+            actions: ['setConsultAgentJoined', 'setConsultDestination', 'updateTaskData', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          }],
+          // agentOfferConsult happens only on the receiver side of consult
+          [_constants.TaskEvent.OFFER_CONSULT]: {
+            actions: ['updateTaskData', 'emitTaskOfferConsult', 'requestAutoAnswer']
+          },
+          // AgentConsultFailed - when consulted agent (Agent 2) doesn't answer (RONA or decline)
+          // Clears the incoming consult notification by transitioning to TERMINATED
+          [_constants.TaskEvent.CONSULT_FAILED]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskReject']
+          },
+          // AgentConsultEnded - when consult initiator (Agent 1) ends the consult before
+          // the consulted agent (Agent 2) accepts. Clears the incoming notification.
+          [_constants.TaskEvent.CONSULT_END]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }
+        }
+      },
+      [_constants.TaskState.CONNECTED]: {
+        on: {
+          // AgentConsultConferenced / ParticipantJoinedConference can arrive while connected.
+          [_constants.TaskEvent.CONFERENCE_START]: {
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'syncTaskDataFromEvent', 'clearConsultState', 'emitTaskConferenceStarted']
+          },
+          // AgentConsulting may arrive while machine is CONNECTED (EP-DN/event ordering).
+          // Derive consultInitiator from payload so controls are set correctly.
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['setConsultInitiator', 'setConsultDestination', 'setConsultAgentJoined', 'updateTaskData', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          },
+          // AgentContactAssigned can be resent after consult transfers; keep context in sync
+          /* TODO: This transition needs to be checked if this is even needed as receiver will
+           * be in Consult Accept state which can be consulting state and ASSIGNED will be only
+           * for the receiver. So receuving ASSIGNED in Connected state is highly unlikely.
+           */
+          [_constants.TaskEvent.ASSIGN]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'emitTaskAssigned']
+          },
+          // Click of hold button
+          [_constants.TaskEvent.HOLD_INITIATED]: {
+            target: _constants.TaskState.HOLD_INITIATING
+          },
+          // Remote hold from another login session (multi-login)
+          [_constants.TaskEvent.HOLD_SUCCESS]: {
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskHold']
+          },
+          [_constants.TaskEvent.UNHOLD_INITIATED]: {
+            target: _constants.TaskState.RESUME_INITIATING
+          },
+          // Resume while machine is CONNECTED but main media is still on hold (stale state after consult RONA/decline).
+          [_constants.TaskEvent.UNHOLD_SUCCESS]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskResume']
+          },
+          // Click of the consult button
+          [_constants.TaskEvent.CONSULT]: {
+            target: _constants.TaskState.CONSULT_INITIATING,
+            actions: ['setConsultInitiator', 'setConsultDestination']
+          },
+          // AgentConsultTransferred / AgentVTeamTransferred / AgentBlindTransferred
+          [_constants.TaskEvent.TRANSFER_SUCCESS]: [{
+            guard: _guards.guards.shouldWrapUpOrIsInitiator,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          }, {
+            // Receiver goes to connected as he receives transferSuccess event
+            actions: ['updateTaskData', 'clearConsultState']
+          }],
+          [_constants.TaskEvent.TRANSFER_FAILED]: {
+            actions: ['updateTaskData']
+          },
+          // AgentConsultEnded from Stable Prod while on connected leg (external end consult).
+          [_constants.TaskEvent.CONSULT_END]: [...currentAgentConsultEndTransitions(), {
+            guard: ({
+              context,
+              event
+            }) => {
+              if (context.consultInitiator !== true) return false;
+              const taskData = (0, _guards.getTaskDataFromEvent)(event);
+              const mainId = taskData?.interaction?.mainInteractionId || taskData?.interactionId;
+              return Boolean(mainId && taskData?.interaction?.media?.[mainId]?.isHold === true);
+            },
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }, {
+            guard: ({
+              context
+            }) => context.consultInitiator === true,
+            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.
+          [_constants.TaskEvent.PARTICIPANT_LEAVE]: [...currentAgentParticipantLeaveTransitions(), {
+            actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']
+          }],
+          // AgentContactEnded Event
+          [_constants.TaskEvent.CONTACT_ENDED]: [{
+            // Campaign preview ContactEnded is terminal cleanup; never enter wrapup.
+            guard: _guards.guards.isCampaignPreviewContactEnded,
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd']
+          }, {
+            // Conference still active → CONFERENCING
+            guard: _guards.guards.conferenceInProgressFromEvent,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'emitTaskConferenceStarted', 'requestCleanup']
+          }, {
+            // Agent should wrap up → WRAPPING_UP
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup', 'requestCleanup']
+          }, {
+            // Consulted agent → TERMINATED
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd']
+          }],
+          [_constants.TaskEvent.TASK_WRAPUP]: {
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup']
+          },
+          [_constants.TaskEvent.OUTBOUND_FAILED]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd']
+          }],
+          [_constants.TaskEvent.PAUSE_RECORDING]: {
+            actions: ['updateTaskData', 'setRecordingState', 'emitTaskRecordingPaused']
+          },
+          [_constants.TaskEvent.RESUME_RECORDING]: {
+            actions: ['updateTaskData', 'setRecordingState', 'emitTaskRecordingResumed']
+          }
+        }
+      },
+      [_constants.TaskState.HOLD_INITIATING]: {
+        on: {
+          // AgentContactHeld Event
+          [_constants.TaskEvent.HOLD_SUCCESS]: {
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskHold']
+          },
+          // AgentContactHoldFailed Event
+          [_constants.TaskEvent.HOLD_FAILED]: {
+            target: _constants.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.
+          [_constants.TaskEvent.PARTICIPANT_LEAVE]: [...currentAgentParticipantLeaveTransitions(), {
+            actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']
+          }],
+          [_constants.TaskEvent.OUTBOUND_FAILED]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd']
+          }]
+        }
+      },
+      [_constants.TaskState.HELD]: {
+        on: {
+          // Conference can be merged while this agent is in held state after refresh/recovery.
+          [_constants.TaskEvent.CONFERENCE_START]: {
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'syncTaskDataFromEvent', 'clearConsultState', 'emitTaskConferenceStarted']
+          },
+          [_constants.TaskEvent.PAUSE_RECORDING]: {
+            actions: ['updateTaskData', 'setRecordingState', 'emitTaskRecordingPaused']
+          },
+          [_constants.TaskEvent.RESUME_RECORDING]: {
+            actions: ['updateTaskData', 'setRecordingState', 'emitTaskRecordingResumed']
+          },
+          // Click of the unhold button
+          [_constants.TaskEvent.UNHOLD_INITIATED]: {
+            target: _constants.TaskState.RESUME_INITIATING
+          },
+          // Remote resume from another login session (multi-login)
+          [_constants.TaskEvent.UNHOLD_SUCCESS]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskResume']
+          },
+          // Click of the consult button
+          [_constants.TaskEvent.CONSULT]: {
+            target: _constants.TaskState.CONSULT_INITIATING,
+            actions: ['setConsultInitiator', 'setConsultDestination']
+          },
+          // AgentConsulting while main leg is held (Task Refactor / Stable Prod consult accept).
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['setConsultInitiator', 'setConsultDestination', 'setConsultAgentJoined', 'updateTaskData', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          },
+          // TODO: This may not be a valid transition, need to be removed
+          // AgentConsultTransferred / AgentVTeamTransferred / AgentBlindTransferred
+          [_constants.TaskEvent.TRANSFER_SUCCESS]: [{
+            guard: _guards.guards.shouldWrapUpOrIsInitiator,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState']
+          }],
+          [_constants.TaskEvent.TRANSFER_FAILED]: {
+            actions: ['updateTaskData']
+          },
+          [_constants.TaskEvent.CONTACT_ENDED]: [{
+            // Campaign preview ContactEnded is terminal cleanup; never enter wrapup.
+            guard: _guards.guards.isCampaignPreviewContactEnded,
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd']
+          }, {
+            guard: _guards.guards.conferenceInProgressFromEvent,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'emitTaskConferenceStarted', 'requestCleanup']
+          }, {
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup', 'requestCleanup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd']
+          }],
+          // AgentConsultEnded from Stable Prod while main leg is held (external end consult).
+          [_constants.TaskEvent.CONSULT_END]: [...currentAgentConsultEndTransitions(), {
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }],
+          [_constants.TaskEvent.PARTICIPANT_LEAVE]: [...currentAgentParticipantLeaveTransitions(), {
+            actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']
+          }],
+          // TODO: This may not be a valid transition, this needs to be checked as well
+          [_constants.TaskEvent.TASK_WRAPUP]: {
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup']
+          },
+          [_constants.TaskEvent.OUTBOUND_FAILED]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd']
+          }]
+        }
+      },
+      [_constants.TaskState.RESUME_INITIATING]: {
+        on: {
+          [_constants.TaskEvent.UNHOLD_SUCCESS]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskResume']
+          },
+          [_constants.TaskEvent.UNHOLD_FAILED]: {
+            target: _constants.TaskState.HELD
+          },
+          // The same remote-removal race can occur while an unhold request is in flight.
+          [_constants.TaskEvent.PARTICIPANT_LEAVE]: [...currentAgentParticipantLeaveTransitions(), {
+            actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']
+          }],
+          [_constants.TaskEvent.OUTBOUND_FAILED]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd']
+          }]
+        }
+      },
+      [_constants.TaskState.CONSULT_INITIATING]: {
+        on: {
+          [_constants.TaskEvent.HOLD_SUCCESS]: {
+            actions: ['updateTaskData']
+          },
+          [_constants.TaskEvent.HOLD_FAILED]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          },
+          // AgentConsulting
+          // NOTE: Don't set consultDestinationAgentJoined here - wait for CONSULTING_ACTIVE
+          [_constants.TaskEvent.CONSULT_SUCCESS]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['updateTaskData', 'setConsultInitiator']
+          },
+          // AgentConsulting (Task Refactor: AgentConsulting event, not CONSULT_SUCCESS)
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['setConsultInitiator', 'setConsultDestination', 'setConsultAgentJoined', 'updateTaskData', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          },
+          // AgentConsultFailed, API Failures, AgentCtqFailed
+          [_constants.TaskEvent.CONSULT_FAILED]: [{
+            // Consult from conference → back to CONFERENCING
+            guard: ({
+              context
+            }) => context.consultFromConference === true,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          }, {
+            guard: _guards.guards.isPrimaryMediaOnHold,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          }],
+          // AgentCtqCancelled Event
+          [_constants.TaskEvent.CTQ_CANCEL]: [{
+            guard: _guards.guards.isPrimaryMediaOnHold,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'clearConsultState']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState']
+          }],
+          // AgentConsultEnded from Stable Prod during consult initiation (external end consult).
+          [_constants.TaskEvent.CONSULT_END]: [...currentAgentConsultEndTransitions(), {
+            guard: _guards.guards.isPrimaryMediaOnHold,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }],
+          [_constants.TaskEvent.PARTICIPANT_LEAVE]: [...currentAgentParticipantLeaveTransitions(), {
+            actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']
+          }],
+          [_constants.TaskEvent.OUTBOUND_FAILED]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd']
+          }]
+        }
+      },
+      [_constants.TaskState.CONSULTING]: {
+        on: {
+          // AgentConsulting updates consulted agent arrival
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: {
+            actions: ['setConsultAgentJoined', 'setConsultDestination', 'updateTaskData', 'emitTaskConsulting']
+          },
+          // AgentConsultFailed (RONA / consultee declined) while the initiator is already in
+          // CONSULTING (AgentConsulting arrived during ringing). Mirror CONSULT_INITIATING so the
+          // initiator returns to their own leg (HELD when main is on hold, else CONNECTED) instead
+          // of staying in CONSULTING. Without this, handleConsultFailed clears consultInitiator but
+          // the machine stays in CONSULTING, so the trailing AgentConsultEnded falls through the
+          // CONSULT_END "consulted agent" branch to TERMINATED and wrongly clears the task.
+          [_constants.TaskEvent.CONSULT_FAILED]: [{
+            guard: ({
+              context
+            }) => context.consultFromConference === true,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          }, {
+            guard: _guards.guards.isPrimaryMediaOnHold,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          }],
+          // AgentConsultEnded
+          [_constants.TaskEvent.CONSULT_END]: [...currentAgentConsultEndTransitions(), {
+            // Initiator returning to conference only while conference is still active.
+            guard: ({
+              context,
+              event
+            }) => context.consultInitiator === true && _guards.guards.conferenceInProgressFromEvent({
+              context,
+              event
+            }),
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }, {
+            // Conference consult ended after conference downgrade while main leg is held.
+            guard: ({
+              context,
+              event
+            }) => context.consultInitiator === true && context.consultFromConference === true && !_guards.guards.conferenceInProgressFromEvent({
+              context,
+              event
+            }) && _guards.guards.isConferenceHoldParticipantFromEvent({
+              context,
+              event
+            }),
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }, {
+            // Conference consult ended after conference downgrade while main leg is connected.
+            guard: ({
+              context,
+              event
+            }) => context.consultInitiator === true && context.consultFromConference === true && !_guards.guards.conferenceInProgressFromEvent({
+              context,
+              event
+            }) && !_guards.guards.isConferenceHoldParticipantFromEvent({
+              context,
+              event
+            }),
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }, {
+            // Initiator already switched back to the main/customer leg
+            guard: ({
+              context
+            }) => context.consultInitiator === true && context.consultCallHeld === true,
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }, {
+            // Interaction terminated during consult (customer left) → WRAPPING_UP
+            guard: ({
+              context,
+              event
+            }) => {
+              // if (context.consultInitiator !== true) return false;
+              // const taskData = getTaskDataFromEvent(event);
+              const taskData = (0, _guards.getTaskDataFromEvent)(event);
+              const cpd = taskData?.interaction?.callProcessingDetails;
+              if (cpd?.hasCustomerLeft !== 'true') return false;
+              return taskData?.interaction?.isTerminated === true && (0, _guards.shouldWrapUpForThisAgent)(context, taskData);
+            },
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup', 'requestCleanup']
+          }, {
+            // Initiator (no conference) → HELD
+            guard: ({
+              context
+            }) => context.consultInitiator === true,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }, {
+            // Consulted agent → TERMINATED
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskConsultEnd', 'emitTaskEnd']
+          }],
+          // Switch between consult and main call (UI-driven toggle)
+          [_constants.TaskEvent.SWITCH_TO_MAIN_CALL]: {
+            actions: ['handleSwitchToMainCall', 'emitTaskSwitchCall']
+          },
+          [_constants.TaskEvent.SWITCH_TO_CONSULT]: {
+            actions: ['handleSwitchToConsult', 'emitTaskSwitchCall']
+          },
+          [_constants.TaskEvent.HOLD_SUCCESS]: {
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskHold']
+          },
+          [_constants.TaskEvent.UNHOLD_SUCCESS]: {
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskResume']
+          },
+          [_constants.TaskEvent.PARTICIPANT_LEAVE]: [...currentAgentParticipantLeaveTransitions(), {
+            guard: params => !_guards.guards.didCurrentAgentLeaveMainInteraction(params) && _guards.guards.shouldDowngradeConferenceToConnected(params),
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'handleParticipantLeft', 'clearConsultState', 'emitTaskParticipantLeft', 'emitTaskConferenceEnded']
+          }, {
+            actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']
+          }],
+          [_constants.TaskEvent.TRANSFER_SUCCESS]: [{
+            guard: _guards.guards.shouldWrapUpOrIsInitiator,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState']
+          }],
+          [_constants.TaskEvent.TRANSFER_FAILED]: {
+            actions: ['updateTaskData']
+          },
+          [_constants.TaskEvent.TRANSFER_CONFERENCE]: {
+            // Track that this agent initiated the conference transfer so we can
+            // apply the correct lifecycle transition when success arrives.
+            actions: ['setTransferConferenceRequested', 'emitTaskTransferConference']
+          },
+          [_constants.TaskEvent.TRANSFER_CONFERENCE_SUCCESS]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested', 'emitTaskWrapup']
+          }, {
+            // Non-initiator (e.g. consultee receiving transfer) moves to CONFERENCING
+            guard: params => !_guards.guards.isSelfConferenceTransferInitiator(params),
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'clearConsultState', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested', 'emitTaskEnd']
+          }],
+          [_constants.TaskEvent.TRANSFER_CONFERENCE_FAILED]: {
+            actions: ['clearTransferConferenceRequested', 'emitTaskTransferConferenceFailed']
+          },
+          // AgentContactAssigned - receiver side becomes connected to customer
+          [_constants.TaskEvent.ASSIGN]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'emitTaskAssigned']
+          },
+          // AgentContactEnded
+          [_constants.TaskEvent.CONTACT_ENDED]: {
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup', 'requestCleanup']
+          },
+          [_constants.TaskEvent.TASK_WRAPUP]: {
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          },
+          [_constants.TaskEvent.OUTBOUND_FAILED]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd']
+          }],
+          [_constants.TaskEvent.MERGE_TO_CONFERENCE]: {
+            target: _constants.TaskState.CONF_INITIATING
+          },
+          // AgentConsultConferenced, ParticipantJoinedConference
+          [_constants.TaskEvent.CONFERENCE_START]: {
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'syncTaskDataFromEvent', 'handleConferenceStarted', 'clearConsultState']
+          }
+        }
+      },
+      [_constants.TaskState.CONF_INITIATING]: {
+        on: {
+          // AgentConsultConferenced, AgentConsultConferencing, ParticipantJoinedConference
+          [_constants.TaskEvent.CONFERENCE_START]: {
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'syncTaskDataFromEvent', 'handleConferenceStarted', 'clearConsultState']
+          },
+          // AgentConsultConferenceFailed
+          [_constants.TaskEvent.CONFERENCE_FAILED]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['handleConferenceFailed', 'emitTaskConferenceFailed']
+          },
+          // AgentConsultEnded while conference is initiating (end call before conference completes)
+          [_constants.TaskEvent.CONSULT_END]: [...currentAgentConsultEndTransitions(), {
+            guard: ({
+              event
+            }) => {
+              const taskData = (0, _guards.getTaskDataFromEvent)(event);
+              return taskData?.interaction?.isTerminated === true;
+            },
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState']
+          }],
+          [_constants.TaskEvent.PARTICIPANT_LEAVE]: [...currentAgentParticipantLeaveTransitions(), {
+            actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']
+          }],
+          [_constants.TaskEvent.OUTBOUND_FAILED]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd']
+          }]
+        }
+      },
+      [_constants.TaskState.CONFERENCING]: {
+        on: {
+          [_constants.TaskEvent.CONFERENCE_START]: {
+            actions: ['updateTaskData', 'syncTaskDataFromEvent', 'clearConsultState', 'emitTaskConferenceStarted']
+          },
+          [_constants.TaskEvent.EXIT_CONFERENCE_SUCCESS]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskEnd']
+          }],
+          // Needed as all agents in conference get this event, hence we need to clear the consult state
+          [_constants.TaskEvent.CONSULT_END]: [...currentAgentConsultEndTransitions(), {
+            guard: ({
+              context,
+              event
+            }) => {
+              const taskData = (0, _guards.getTaskDataFromEvent)(event);
+              return taskData?.interaction?.isTerminated === true && (0, _guards.shouldWrapUpForThisAgent)(context, taskData);
+            },
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          }, {
+            actions: ['updateTaskData', 'clearConsultState']
+          }],
+          [_constants.TaskEvent.HOLD_SUCCESS]: [{
+            // Conference already downgraded (no other agents) and backend hold arrives.
+            // Move to HELD so the UI renders resume action.
+            guard: _guards.guards.shouldDowngradeConferenceToConnected,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskHold']
+          }, {
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskHold']
+          }],
+          [_constants.TaskEvent.UNHOLD_SUCCESS]: [{
+            // Conference already downgraded (no other agents) and backend unhold arrives.
+            // Move to CONNECTED so hold action is available again.
+            guard: _guards.guards.shouldDowngradeConferenceToConnected,
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'syncTaskDataFromEvent', 'setHoldState', 'emitTaskResume']
+          }, {
+            actions: ['updateTaskData', 'syncTaskDataFromEvent', 'setHoldState', 'emitTaskResume']
+          }],
+          // Start a new consult from within an active conference
+          [_constants.TaskEvent.CONSULT]: {
+            target: _constants.TaskState.CONSULT_INITIATING,
+            actions: ['setConsultInitiator', 'setConsultDestination', 'setConsultFromConference']
+          },
+          // AgentConsulting while still in conference (EP-DN/external ordering).
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['setConsultInitiator', 'setConsultDestination', 'setConsultFromConference', 'setConsultAgentJoined', 'updateTaskData', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          },
+          // Participant leaves - handle conference downgrade scenarios
+          [_constants.TaskEvent.PARTICIPANT_LEAVE]: [...currentAgentParticipantLeaveTransitions(), {
+            // Conference downgraded, customer present → CONNECTED
+            guard: params => !_guards.guards.didCurrentAgentLeaveMainInteraction(params) && _guards.guards.shouldDowngradeConferenceToConnected(params),
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'handleParticipantLeft', 'clearConsultState', 'emitTaskParticipantLeft', 'emitTaskConferenceEnded']
+          }, {
+            actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']
+          }],
+          [_constants.TaskEvent.TRANSFER_CONFERENCE]: {
+            actions: ['setTransferConferenceRequested', 'emitTaskTransferConference']
+          },
+          [_constants.TaskEvent.TRANSFER_CONFERENCE_SUCCESS]: [{
+            guard: _guards.guards.isPassiveConferenceTransferObserver,
+            actions: ['updateTaskData', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested']
+          }, {
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested', 'emitTaskWrapup']
+          }, {
+            guard: params => !_guards.guards.isSelfConferenceTransferInitiator(params),
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'clearConsultState', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested', 'emitTaskEnd']
+          }],
+          [_constants.TaskEvent.TRANSFER_CONFERENCE_FAILED]: {
+            actions: ['clearTransferConferenceRequested', 'emitTaskTransferConferenceFailed']
+          },
+          // Conference ends explicitly
+          [_constants.TaskEvent.CONFERENCE_END]: [{
+            // Agent who should wrap up → WRAPPING_UP
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          }, {
+            // Customer still in call → CONNECTED
+            guard: ({
+              context,
+              event
+            }) => {
+              if (context.exitingConference === true) return false;
+              const taskData = event?.taskData ?? context.taskData;
+              if (!taskData?.interaction) return false;
+              const mainCallId = taskData.interaction.mainInteractionId || taskData.interactionId;
+              if (!mainCallId) return false;
+              return (0, _TaskUtils.getIsCustomerInCall)(taskData.interaction, mainCallId);
+            },
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConferenceEnded']
+          }, {
+            // Otherwise → TERMINATED
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskEnd']
+          }],
+          // CONTACT_ENDED in conference
+          [_constants.TaskEvent.CONTACT_ENDED]: [{
+            // Conference still active → stay
+            actions: ['updateTaskData', 'requestCleanup']
+          }],
+          [_constants.TaskEvent.CONSULT_FAILED]: {
+            actions: ['updateTaskData', 'handleConsultFailed']
+          },
+          [_constants.TaskEvent.TASK_WRAPUP]: {
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          },
+          [_constants.TaskEvent.OUTBOUND_FAILED]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd']
+          }]
+        }
+      },
+      [_constants.TaskState.WRAPPING_UP]: {
+        // Only emit wrapup event on entry - task:end should only be emitted when COMPLETED
+        entry: ['emitTaskWrapup'],
+        on: {
+          // AgentWrappedup Event
+          [_constants.TaskEvent.WRAPUP_COMPLETE]: {
+            target: _constants.TaskState.COMPLETED,
+            actions: ['updateTaskData']
+          }
+        }
+      },
+      [_constants.TaskState.COMPLETED]: {
+        type: 'final',
+        entry: ['emitTaskWrappedup', 'cleanupResources']
+      },
+      [_constants.TaskState.TERMINATED]: {
+        type: 'final',
+        entry: ['cleanupResources']
+      }
+    }
+  };
+}
+
+/**
+ * Create a task state machine instance using only the built-in actions.
+ * The resulting machine is ready for most consumers that rely on the default
+ * context mutators declared in actions.ts.
+ *
+ * @param uiControlConfig - UI control configuration
+ * @returns StateMachine instance for task management
+ */
+function createTaskStateMachine(uiControlConfig, options) {
+  return taskStateMachineSetup.createMachine(getTaskStateMachineConfig(uiControlConfig)).provide({
+    actions: {
+      ..._actions.actions,
+      ...(options?.actions ?? {})
+    }
+  });
+}
+//# sourceMappingURL=TaskStateMachine.js.map