@webex/contact-center 3.12.0-next.122 → 3.12.0-next.124

package/dist/types/services/task/state-machine/TaskStateMachine.d.ts

@@ -227,6 +227,15 @@ export declare function getTaskStateMachineConfig(uiControlConfig: UIControlConf
                 RESUME_RECORDING: {
                     actions: string[];
                 };
+                EXIT_CONFERENCE_SUCCESS: ({
+                    guard: ({ context, event }: import("./guards").GuardParams) => boolean;
+                    target: TaskState;
+                    actions: string[];
+                } | {
+                    target: TaskState;
+                    actions: string[];
+                    guard?: undefined;
+                })[];
             };
         };
         HOLD_INITIATING: {
@@ -248,6 +257,10 @@ export declare function getTaskStateMachineConfig(uiControlConfig: UIControlConf
                     actions: string[];
                     guard?: undefined;
                 })[];
+                TASK_WRAPUP: {
+                    target: TaskState;
+                    actions: string[];
+                };
             };
         };
         HELD: {
@@ -325,6 +338,15 @@ export declare function getTaskStateMachineConfig(uiControlConfig: UIControlConf
                     actions: string[];
                     guard?: undefined;
                 })[];
+                EXIT_CONFERENCE_SUCCESS: ({
+                    guard: ({ context, event }: import("./guards").GuardParams) => boolean;
+                    target: TaskState;
+                    actions: string[];
+                } | {
+                    target: TaskState;
+                    actions: string[];
+                    guard?: undefined;
+                })[];
             };
         };
         RESUME_INITIATING: {
@@ -352,6 +374,10 @@ export declare function getTaskStateMachineConfig(uiControlConfig: UIControlConf
                     actions: string[];
                     guard?: undefined;
                 })[];
+                TASK_WRAPUP: {
+                    target: TaskState;
+                    actions: string[];
+                };
             };
         };
         CONSULT_INITIATING: {
@@ -415,6 +441,10 @@ export declare function getTaskStateMachineConfig(uiControlConfig: UIControlConf
                     actions: string[];
                     guard?: undefined;
                 })[];
+                TASK_WRAPUP: {
+                    target: TaskState;
+                    actions: string[];
+                };
             };
         };
         CONSULTING: {
@@ -544,6 +574,10 @@ export declare function getTaskStateMachineConfig(uiControlConfig: UIControlConf
                     actions: string[];
                     guard?: undefined;
                 })[];
+                TASK_WRAPUP: {
+                    target: TaskState;
+                    actions: string[];
+                };
             };
         };
         CONFERENCING: {
@@ -660,6 +694,15 @@ export declare function getTaskStateMachineConfig(uiControlConfig: UIControlConf
         WRAPPING_UP: {
             entry: string[];
             on: {
+                TASK_WRAPUP: ({
+                    guard: ({ context }: {
+                        context: any;
+                    }) => boolean;
+                    actions: string[];
+                } | {
+                    actions: string[];
+                    guard?: undefined;
+                })[];
                 WRAPUP_COMPLETE: {
                     target: TaskState;
                     actions: string[];
@@ -904,6 +947,15 @@ export declare function createTaskStateMachine(uiControlConfig: UIControlConfig,
                 RESUME_RECORDING: {
                     actions: string[];
                 };
+                EXIT_CONFERENCE_SUCCESS: ({
+                    guard: ({ context, event }: import("./guards").GuardParams) => boolean;
+                    target: TaskState;
+                    actions: string[];
+                } | {
+                    target: TaskState;
+                    actions: string[];
+                    guard?: undefined;
+                })[];
             };
         };
         HOLD_INITIATING: {
@@ -925,6 +977,10 @@ export declare function createTaskStateMachine(uiControlConfig: UIControlConfig,
                     actions: string[];
                     guard?: undefined;
                 })[];
+                TASK_WRAPUP: {
+                    target: TaskState;
+                    actions: string[];
+                };
             };
         };
         HELD: {
@@ -1002,6 +1058,15 @@ export declare function createTaskStateMachine(uiControlConfig: UIControlConfig,
                     actions: string[];
                     guard?: undefined;
                 })[];
+                EXIT_CONFERENCE_SUCCESS: ({
+                    guard: ({ context, event }: import("./guards").GuardParams) => boolean;
+                    target: TaskState;
+                    actions: string[];
+                } | {
+                    target: TaskState;
+                    actions: string[];
+                    guard?: undefined;
+                })[];
             };
         };
         RESUME_INITIATING: {
@@ -1029,6 +1094,10 @@ export declare function createTaskStateMachine(uiControlConfig: UIControlConfig,
                     actions: string[];
                     guard?: undefined;
                 })[];
+                TASK_WRAPUP: {
+                    target: TaskState;
+                    actions: string[];
+                };
             };
         };
         CONSULT_INITIATING: {
@@ -1092,6 +1161,10 @@ export declare function createTaskStateMachine(uiControlConfig: UIControlConfig,
                     actions: string[];
                     guard?: undefined;
                 })[];
+                TASK_WRAPUP: {
+                    target: TaskState;
+                    actions: string[];
+                };
             };
         };
         CONSULTING: {
@@ -1221,6 +1294,10 @@ export declare function createTaskStateMachine(uiControlConfig: UIControlConfig,
                     actions: string[];
                     guard?: undefined;
                 })[];
+                TASK_WRAPUP: {
+                    target: TaskState;
+                    actions: string[];
+                };
             };
         };
         CONFERENCING: {
@@ -1337,6 +1414,15 @@ export declare function createTaskStateMachine(uiControlConfig: UIControlConfig,
         WRAPPING_UP: {
             entry: string[];
             on: {
+                TASK_WRAPUP: ({
+                    guard: ({ context }: {
+                        context: any;
+                    }) => boolean;
+                    actions: string[];
+                } | {
+                    actions: string[];
+                    guard?: undefined;
+                })[];
                 WRAPUP_COMPLETE: {
                     target: TaskState;
                     actions: string[];

package/dist/webex.js

@@ -41,7 +41,7 @@ if (!global.Buffer) {
  */
 const Webex = _webexCore.default.extend({
   webex: true,
-  version: `3.12.0-next.122`
+  version: `3.12.0-next.124`
 });
 
 /**

package/package.json

@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "@types/platform": "1.3.4",
-    "@webex/calling": "3.12.0-next.98",
+    "@webex/calling": "3.12.0-next.99",
     "@webex/internal-plugin-mercury": "3.12.0-next.51",
     "@webex/internal-plugin-metrics": "3.12.0-next.47",
     "@webex/internal-plugin-support": "3.12.0-next.54",
@@ -84,5 +84,5 @@
     "typedoc": "^0.25.0",
     "typescript": "5.4.5"
   },
-  "version": "3.12.0-next.122"
+  "version": "3.12.0-next.124"
 }

package/src/services/task/TaskManager.ts

@@ -30,7 +30,7 @@ import TaskFactory from './TaskFactory';
 import AnswerCallOnWebexService from '../AnswerCallOnWebexService';
 import {getWebexCallingDeviceDetailsForAgent} from './WebexCallingUtils';
 import WebRTC from './voice/WebRTC';
-import {TaskEvent, type TaskEventPayload} from './state-machine';
+import {TaskEvent, TaskState, type TaskEventPayload} from './state-machine';
 import {MEDIA_TYPE_MAIN_CALL} from './state-machine/constants';
 import {normalizeTaskData} from './taskDataNormalizer';
 import {ApiAIAssistant} from '../ApiAiAssistant';
@@ -44,6 +44,21 @@ const MAIN_INTERACTION_CORRELATED_EVENTS = new Set<CC_EVENTS>([
 
 const isCcEvent = (value: string): value is CC_EVENTS => CC_EVENT_SET.has(value as CC_EVENTS);
 
+const WRAP_UP_STAMP_EVENTS = new Set<CC_EVENTS>([
+  CC_EVENTS.AGENT_WRAPUP,
+  CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED,
+  CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+  CC_EVENTS.AGENT_CONFERENCE_TRANSFERRED,
+]);
+
+const PARTICIPANT_LEAVE_WRAP_STATES = new Set<TaskState>([
+  TaskState.HELD,
+  TaskState.RESUME_INITIATING,
+  TaskState.CONSULTING,
+  TaskState.CONSULT_INITIATING,
+  TaskState.CONFERENCING,
+]);
+
 /** @internal */
 export default class TaskManager extends EventEmitter {
   private call: ICall;
@@ -195,6 +210,175 @@ export default class TaskManager extends EventEmitter {
     this.webCallingService.off(LINE_EVENTS.INCOMING_CALL, this.handleIncomingWebCall);
   }
 
+  /**
+   * True when this agent left on the current payload.
+   * A named other participantId is never self-leave (even if the participants
+   * map is partial). Missing-map fallback is EP-DN only: participantId absent
+   * and self omitted now, with previous-task evidence when a prior map exists.
+   */
+  private static didSelfLeaveConference(
+    payload: WebSocketPayload,
+    agentId?: string,
+    task?: ITask
+  ): boolean {
+    if (!agentId) {
+      return false;
+    }
+    if (payload.participantId === agentId) {
+      return true;
+    }
+    if (payload.participantId && payload.participantId !== agentId) {
+      return false;
+    }
+
+    const participants = payload.interaction?.participants;
+    if (!participants || agentId in participants) {
+      return false;
+    }
+
+    const previousParticipants = task?.data?.interaction?.participants;
+    if (previousParticipants && !(agentId in previousParticipants)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Consulted non-owner: Voice exitConference / shouldWrapUpForThisAgent stays
+   * false unless an explicit wrap-up signal includes this agent.
+   */
+  private static isConsultedNonOwner(
+    payload: WebSocketPayload,
+    agentId?: string,
+    task?: ITask
+  ): boolean {
+    const isConsulted = payload.isConsulted ?? task?.data?.isConsulted;
+    if (isConsulted !== true) {
+      return false;
+    }
+    const owner = payload.interaction?.owner ?? task?.data?.interaction?.owner;
+
+    return Boolean(agentId && owner && owner !== agentId);
+  }
+
+  private static hasNonemptyPendingWrapUp(payload: WebSocketPayload): boolean {
+    return Array.isArray(payload.agentsPendingWrapUp) && payload.agentsPendingWrapUp.length > 0;
+  }
+
+  /**
+   * Transfer initiator fallback: widgets set transferConferenceRequested on the
+   * actor; desktop success payloads may include consultingAgentId. Only used
+   * when agentsPendingWrapUp is empty or absent.
+   */
+  private static isSelfConferenceTransferInitiator(
+    payload: WebSocketPayload,
+    agentId?: string,
+    task?: ITask
+  ): boolean {
+    const snapshotContext = task?.stateMachineService?.getSnapshot?.()?.context as
+      | {transferConferenceRequested?: boolean}
+      | undefined;
+    if (snapshotContext?.transferConferenceRequested === true) {
+      return true;
+    }
+
+    return Boolean(agentId && payload.consultingAgentId === agentId);
+  }
+
+  /**
+   * Explicit wrap-up signals only (no owner / isConsulted fallback).
+   * Used for events that remaining conference agents also receive.
+   * nonempty agentsPendingWrapUp is authoritative, then wrapUpRequired / isWrapUp.
+   */
+  private static wrapUpRequiredFromExplicitSignals(
+    payload: WebSocketPayload,
+    agentId?: string
+  ): boolean {
+    const pending = payload.agentsPendingWrapUp;
+    if (Array.isArray(pending) && pending.length > 0) {
+      return Boolean(agentId && pending.includes(agentId));
+    }
+
+    if (payload.wrapUpRequired === true) {
+      return true;
+    }
+    if (!agentId) {
+      return false;
+    }
+
+    return payload.interaction?.participants?.[agentId]?.isWrapUp === true;
+  }
+
+  /**
+   * Stamp wrapUpRequired once at ingress (prepareEventContext) so updateTaskData
+   * and the mapper see the same flag. Remaining agents stay false.
+   */
+  private static stampWrapUpRequiredForEvent(
+    eventType: CC_EVENTS,
+    payload: WebSocketPayload,
+    agentId?: string,
+    task?: ITask
+  ): WebSocketPayload {
+    if (!WRAP_UP_STAMP_EVENTS.has(eventType)) {
+      return payload;
+    }
+
+    if (eventType === CC_EVENTS.AGENT_WRAPUP) {
+      return {...payload, wrapUpRequired: true};
+    }
+
+    if (eventType === CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED) {
+      return {
+        ...payload,
+        wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId),
+      };
+    }
+
+    if (eventType === CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE) {
+      const actorState = task?.stateMachineService?.getSnapshot?.()?.value;
+      if (actorState && !PARTICIPANT_LEAVE_WRAP_STATES.has(actorState as TaskState)) {
+        return payload;
+      }
+
+      const left = TaskManager.didSelfLeaveConference(payload, agentId, task);
+      if (!left) {
+        return {
+          ...payload,
+          wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId),
+        };
+      }
+      if (TaskManager.hasNonemptyPendingWrapUp(payload)) {
+        return {
+          ...payload,
+          wrapUpRequired: Boolean(agentId && payload.agentsPendingWrapUp?.includes(agentId)),
+        };
+      }
+
+      return {
+        ...payload,
+        wrapUpRequired:
+          TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId) ||
+          !TaskManager.isConsultedNonOwner(payload, agentId, task),
+      };
+    }
+
+    // AGENT_CONFERENCE_TRANSFERRED — pending list wins; initiator only if empty/absent
+    if (TaskManager.hasNonemptyPendingWrapUp(payload)) {
+      return {
+        ...payload,
+        wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId),
+      };
+    }
+
+    return {
+      ...payload,
+      wrapUpRequired:
+        TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId) ||
+        TaskManager.isSelfConferenceTransferInitiator(payload, agentId, task),
+    };
+  }
+
   /**
    * Map WebSocket CC_EVENTS to state machine TaskEvent
    * @param ccEvent - The CC_EVENT type from WebSocket
@@ -645,6 +829,15 @@ export default class TaskManager extends EventEmitter {
       adjustedPayload = TaskManager.preserveConfirmedOwner(task, adjustedPayload);
     }
 
+    if (WRAP_UP_STAMP_EVENTS.has(eventType)) {
+      adjustedPayload = TaskManager.stampWrapUpRequiredForEvent(
+        eventType,
+        adjustedPayload,
+        this.agentId,
+        task
+      );
+    }
+
     const stateMachineEvent = TaskManager.mapEventToTaskStateMachineEvent(
       eventType,
       adjustedPayload,

package/src/services/task/ai-docs/task-spec.md

@@ -438,6 +438,7 @@ The public `TASK_EVENTS` enum contains 49 members; every member is listed below
 | TASK-R-008 | Voice `dropConferenceParticipant` must validate the public target, resolve the latest main interaction, POST an empty body to the encoded participant-drop route, and settle only from `ParticipantLeftConference`, `ParticipantDropConferenceFailed`, HTTP failure, or the existing AQM timeout. | Participant removal is backend-authoritative and must preserve event-driven roster/state synchronization without exposing participant identifiers through telemetry or logs. | `src/services/task/voice/Voice.ts`, `src/services/task/contact.ts`, `src/services/task/types.ts` | `test/unit/spec/services/task/voice/Voice.ts`, `test/unit/spec/services/task/contact.ts`, `test/unit/spec/services/core/aqm-reqs.ts` | Backend authorization and media removal are remote-service responsibilities. | PRESENT |
 | TASK-R-009 | ContactCenter must inject Desktop Profile collaboration policy into TaskFactory, and every created voice/digital Task must expose ordered Consult and Transfer destination categories through `TaskUIControls.consultTransferDestinations`. | Task consumers need one already-computed policy surface and must not fetch profile flags or duplicate destination decisions. | `src/cc.ts`, `src/services/task/TaskFactory.ts`, `src/services/task/types.ts` | `test/unit/spec/cc.ts`, `test/unit/spec/services/task/TaskFactory.ts` | Host-specific UI options may only further hide an SDK-allowed category. | PRESENT |
 | TASK-R-010 | TaskManager must propagate backend owner promotion without electing an owner locally. `ContactOwnerChanged` resolves an exact task first, then one unique related task whose existing snapshot proves that the current Agent is active on `mainCall`, or whose incoming snapshot both names that Agent as `interaction.owner` and proves the same active-main-leg membership. Active membership requires a participant entry with `hasLeft !== true`. If no task exists, recovery is limited to that incoming owner=current-Agent proof: create the normal Task under the stable main interaction ID, silently HYDRATE its actor before listener installation, then process the original owner-change event so consumers receive one `task:hydrate` and no `task:incoming`. An owner-changing `ContactUpdated` uses the existing owner-change hydrate path only for an existing task, and a late `ParticipantLeftConference` cannot replace a confirmed active owner with the departed participant. | Every surviving agent must observe the backend-selected primary Agent immediately, including stale child-keyed and narrowly recoverable desynchronization cases, without duplicating tasks or exposing an uninitialized actor. | `src/services/task/TaskManager.ts` | `test/unit/spec/services/task/TaskManager.ts`, `test/unit/spec/services/task/Task.ts` | Backend owner selection and delivery of a complete owner-bearing `ContactOwnerChanged` payload remain remote responsibilities; missing-task `ContactUpdated` remains update-only. | PRESENT |
+| TASK-R-011 | TaskManager must stamp `wrapUpRequired` once in `prepareEventContext` on `AGENT_WRAPUP`, `AGENT_CONSULT_CONFERENCE_ENDED`, `PARTICIPANT_LEFT_CONFERENCE`, and `AGENT_CONFERENCE_TRANSFERRED` before `updateTaskData` / mapper (mapper passes the already-stamped payload through). Voice `exitConference` stamps the same flag on `EXIT_CONFERENCE_SUCCESS` (that HTTP path skips TaskManager) using `shouldWrapUpForThisAgent`, then the same empty-pending self-exit fallback as leave (true unless this agent is a consulted non-owner). Voice pending-list precedence uses the correlated HTTP response only (a cached `agentsPendingWrapUp` is ignored when the response omits the list). `AGENT_WRAPUP` is always `true`. Conference-end uses explicit signals only (`agentsPendingWrapUp`, then `wrapUpRequired` / `isWrapUp`). A nonempty `agentsPendingWrapUp` is authoritative and wins over initiator fallback: `consultingAgentId === self` and actor `transferConferenceRequested` are honored only when the list is empty or absent. On participant leave: do not stamp when the actor ignores `PARTICIPANT_LEAVE` (`CONNECTED`, `HOLD_INITIATING`, `CONF_INITIATING`); stamp only in `HELD`, `RESUME_INITIATING`, `CONSULTING`, `CONSULT_INITIATING`, or `CONFERENCING` (or when no actor snapshot exists). A named other `participantId` is never self-leave (do not infer leave from a partial `participants` map); missing-map fallback applies only when `participantId` is absent (EP-DN), and when a previous task map exists it must have contained self. Remaining agents use explicit signals only; this agent left + nonempty pending uses `includes(self)`; this agent left + empty/absent pending stamps `true` unless this agent is a consulted non-owner. Remaining conference agents stay `false`. `setupAutoWrapupTimer()` still requires profile `autoWrapup !== false`, a valid interval, and a default reason. `PARTICIPANT_LEAVE` and Voice `EXIT_CONFERENCE_SUCCESS` into `WRAPPING_UP` do not transition-emit; the `WRAPPING_UP` entry still emits `task:wrapup`. `EXIT_CONFERENCE_SUCCESS` is handled in `CONNECTED`, `HELD`, and `CONFERENCING`. `TASK_WRAPUP` is handled in `HOLD_INITIATING`, `RESUME_INITIATING`, `CONSULT_INITIATING`, and `CONF_INITIATING` (transition `updateTaskData` + `markEnded` only). Late `TASK_WRAPUP` in `WRAPPING_UP` always runs `updateTaskData` and runs `emitTaskWrapup` only when `context.taskData.wrapUpRequired` was not already `true`. | Consumers rely on `task:wrapup` and `task.autoWrapup` when wrap-up starts; those surfaces only activate when ingress task data already has `wrapUpRequired === true`. | `src/services/task/TaskManager.ts`, `src/services/task/voice/Voice.ts`, `src/services/task/Task.ts`, `src/services/task/state-machine/TaskStateMachine.ts` | `test/unit/spec/services/task/TaskManager.ts`, `test/unit/spec/services/task/voice/Voice.ts`, `test/unit/spec/services/task/Task.ts`, `test/unit/spec/services/task/state-machine/TaskStateMachine.ts` | Profile auto wrap-up, interval, and default reason remain agent-config responsibilities. | PRESENT |
 
 ## Design Overview
 Task separates its stable consumption boundary from collaborators so ownership and failure behavior stay explicit. A shared Task base preserves a stable API while media-specific subclasses and a separate state engine enforce capability differences.
@@ -452,7 +453,7 @@ Task separates its stable consumption boundary from collaborators so ownership a
 | `facebook` | Unsupported by TaskFactory; throws `Unknown media type` |
 | `whatsapp` | Unsupported by TaskFactory; throws `Unknown media type` |
 
-If enabled in agent profile, wrapup completes automatically after timeout:
+If enabled in agent profile, wrapup completes automatically after timeout. The timer starts only when ingress task data has `wrapUpRequired === true` (TASK-R-011).
 
 > **Host-application example:** `updateWrapupStatus` is a consumer-owned UI callback, not SDK package logging.
 
@@ -1432,6 +1433,7 @@ Use `test/unit/spec/services/task/Task.ts`, `TaskFactory.ts`, `TaskManager.ts`,
 | `TASK-R-008` | `test/unit/spec/services/task/Task.ts`, `test/unit/spec/services/task/voice/Voice.ts`, `test/unit/spec/services/task/contact.ts`, `test/unit/spec/services/core/aqm-reqs.ts`, `test/unit/spec/services/task/TaskManager.ts` | None. |
 | `TASK-R-009` | `test/unit/spec/cc.ts`, `test/unit/spec/services/task/TaskFactory.ts`, `test/unit/spec/services/task/state-machine/uiControlsComputer.ts` | None. |
 | `TASK-R-010` | `test/unit/spec/services/task/TaskManager.ts`, `test/unit/spec/services/task/Task.ts` | None. |
+| `TASK-R-011` | `test/unit/spec/services/task/TaskManager.ts`, `test/unit/spec/services/task/voice/Voice.ts`, `test/unit/spec/services/task/Task.ts`, `test/unit/spec/services/task/state-machine/TaskStateMachine.ts` | None. |
 
 ## Traceability
 - Repo architecture: `../../../../ai-docs/ARCHITECTURE.md` · Registry: `../../../../ai-docs/SPEC_INDEX.md`

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

@@ -73,7 +73,6 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
         'markEnded',
         'clearConsultState',
         'emitTaskParticipantLeft',
-        'emitTaskWrapup',
       ],
     },
     {
@@ -90,6 +89,18 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
     },
   ];
 
+  const exitConferenceSuccessTransitions = () => [
+    {
+      guard: guards.shouldWrapUp,
+      target: TaskState.WRAPPING_UP,
+      actions: ['updateTaskData', 'markEnded', 'clearConsultState'],
+    },
+    {
+      target: TaskState.TERMINATED,
+      actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskEnd'],
+    },
+  ];
+
   const currentAgentConsultEndTransitions = () => [
     {
       guard: (params) =>
@@ -252,7 +263,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             {
               guard: guards.shouldWrapUp,
               target: TaskState.WRAPPING_UP,
-              actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup'],
+              actions: ['updateTaskData', 'markEnded'],
             },
             {
               target: TaskState.TERMINATED,
@@ -444,7 +455,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           ],
           [TaskEvent.TASK_WRAPUP]: {
             target: TaskState.WRAPPING_UP,
-            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup'],
+            actions: ['updateTaskData', 'markEnded'],
           },
           [TaskEvent.OUTBOUND_FAILED]: [
             {
@@ -463,6 +474,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           [TaskEvent.RESUME_RECORDING]: {
             actions: ['updateTaskData', 'setRecordingState', 'emitTaskRecordingResumed'],
           },
+          [TaskEvent.EXIT_CONFERENCE_SUCCESS]: exitConferenceSuccessTransitions(),
         },
       },
 
@@ -489,6 +501,10 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
             },
           ],
+          [TaskEvent.TASK_WRAPUP]: {
+            target: TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded'],
+          },
         },
       },
 
@@ -586,7 +602,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           // 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'],
+            actions: ['updateTaskData', 'markEnded'],
           },
           [TaskEvent.OUTBOUND_FAILED]: [
             {
@@ -599,6 +615,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
             },
           ],
+          [TaskEvent.EXIT_CONFERENCE_SUCCESS]: exitConferenceSuccessTransitions(),
         },
       },
 
@@ -626,6 +643,10 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
             },
           ],
+          [TaskEvent.TASK_WRAPUP]: {
+            target: TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded'],
+          },
         },
       },
 
@@ -714,6 +735,10 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
             },
           ],
+          [TaskEvent.TASK_WRAPUP]: {
+            target: TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded'],
+          },
         },
       },
 
@@ -893,7 +918,6 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
                 'clearConsultState',
                 'handleTransferConferenceSuccess',
                 'clearTransferConferenceRequested',
-                'emitTaskWrapup',
               ],
             },
             {
@@ -941,7 +965,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           },
           [TaskEvent.TASK_WRAPUP]: {
             target: TaskState.WRAPPING_UP,
-            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup'],
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState'],
           },
           [TaskEvent.OUTBOUND_FAILED]: [
             {
@@ -1015,6 +1039,10 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
             },
           ],
+          [TaskEvent.TASK_WRAPUP]: {
+            target: TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded'],
+          },
         },
       },
 
@@ -1028,17 +1056,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               'emitTaskConferenceStarted',
             ],
           },
-          [TaskEvent.EXIT_CONFERENCE_SUCCESS]: [
-            {
-              guard: guards.shouldWrapUp,
-              target: TaskState.WRAPPING_UP,
-              actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup'],
-            },
-            {
-              target: TaskState.TERMINATED,
-              actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskEnd'],
-            },
-          ],
+          [TaskEvent.EXIT_CONFERENCE_SUCCESS]: exitConferenceSuccessTransitions(),
 
           // Needed as all agents in conference get this event, hence we need to clear the consult state
           [TaskEvent.CONSULT_END]: [
@@ -1156,7 +1174,6 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
                 'clearConsultState',
                 'handleTransferConferenceSuccess',
                 'clearTransferConferenceRequested',
-                'emitTaskWrapup',
               ],
             },
             {
@@ -1191,7 +1208,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               // Agent who should wrap up → WRAPPING_UP
               guard: guards.shouldWrapUp,
               target: TaskState.WRAPPING_UP,
-              actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup'],
+              actions: ['updateTaskData', 'markEnded', 'clearConsultState'],
             },
             {
               // Customer still in call → CONNECTED
@@ -1229,7 +1246,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           [TaskEvent.TASK_WRAPUP]: {
             guard: guards.shouldWrapUp,
             target: TaskState.WRAPPING_UP,
-            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup'],
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState'],
           },
           [TaskEvent.OUTBOUND_FAILED]: [
             {
@@ -1249,6 +1266,16 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
         // Only emit wrapup event on entry - task:end should only be emitted when COMPLETED
         entry: ['emitTaskWrapup'],
         on: {
+          // Late AgentWrapup after conference exit already entered WRAPPING_UP
+          [TaskEvent.TASK_WRAPUP]: [
+            {
+              guard: ({context}) => context.taskData?.wrapUpRequired === true,
+              actions: ['updateTaskData'],
+            },
+            {
+              actions: ['updateTaskData', 'emitTaskWrapup'],
+            },
+          ],
           // AgentWrappedup Event
           [TaskEvent.WRAPUP_COMPLETE]: {
             target: TaskState.COMPLETED,