@webex/contact-center 3.12.0-llmrefactor.1 → 3.12.0-llmrefactor.10

package/test/unit/spec/cc.ts

@@ -169,10 +169,13 @@ describe('webex.cc', () => {
       setWrapupData: jest.fn(),
       setAgentId: jest.fn(),
       setWebRtcEnabled: jest.fn(),
+      setAnswerCallOnWebexService: jest.fn(),
       registerIncomingCallEvent: jest.fn(),
       registerTaskListeners: jest.fn(),
       getTask: jest.fn(),
       getActiveTasks: jest.fn(),
+      applyEnableWxBetterTogether: jest.fn(),
+      syncWxAppMuteFromCallDetailsForAllTasks: jest.fn(),
       on: jest.fn(),
       off: jest.fn(),
       emit: jest.fn(),
@@ -311,6 +314,9 @@ describe('webex.cc', () => {
       isEndConsultEnabled: false,
       agentDbId: '',
       allowConsultToQueue: false,
+      accessQueue: 'SPECIFIC',
+      accessEntryPoint: 'ALL',
+      accessBuddyTeam: 'ALL',
       agentPersonalStatsEnabled: false,
       isTimeoutDesktopInactivityEnabled: false,
       webRtcEnabled: true,
@@ -404,6 +410,13 @@ describe('webex.cc', () => {
         webRtcEnabled: mockAgentProfile.webRtcEnabled,
         autoWrapup: mockAgentProfile.wrapUpData.wrapUpProps.autoWrapup ?? false,
         aiFeature: mockAgentProfile.aiFeature,
+        consultTransfer: {
+          allowConsultToQueue: mockAgentProfile.allowConsultToQueue,
+          accessQueue: mockAgentProfile.accessQueue,
+          accessEntryPoint: mockAgentProfile.accessEntryPoint,
+          accessBuddyTeam: mockAgentProfile.accessBuddyTeam,
+        },
+        enableWxBetterTogether: false,
       });
       expect(reloadSpy).toHaveBeenCalled();
       expect(result).toEqual(mockAgentProfile);
@@ -716,7 +729,7 @@ describe('webex.cc', () => {
       expect(registerWebCallingLineSpy).toHaveBeenCalled();
       expect(stationLoginMock).toHaveBeenCalledWith({
         data: {
-          dialNumber: 'agentId',
+          dialNumber: `${WEB_RTC_PREFIX}agentId`,
           teamId: 'teamId',
           deviceType: LoginOption.BROWSER,
           isExtension: false,
@@ -734,6 +747,7 @@ describe('webex.cc', () => {
         METRIC_EVENT_NAMES.STATION_LOGIN_FAILED,
       ]);
       expect(result).toEqual(responseMock);
+      expect(webex.cc.agentConfig.deviceType).toBe(LoginOption.BROWSER);
 
       const onSpy = jest.spyOn(mockTaskManager, 'on');
       const emitSpy = jest.spyOn(webex.cc, 'trigger');
@@ -875,7 +889,7 @@ describe('webex.cc', () => {
       expect(registerWebCallingLineSpy).not.toHaveBeenCalled();
       expect(stationLoginSpy).toHaveBeenCalledWith({
         data: {
-          dialNumber: 'agentId',
+          dialNumber: `${WEB_RTC_PREFIX}agentId`,
           teamId: 'teamId',
           deviceType: LoginOption.BROWSER,
           isExtension: false,
@@ -1019,6 +1033,639 @@ describe('webex.cc', () => {
         {module: CC_FILE, method: 'stationLogin', trackingId: error.details.trackingId}
       );
     });
+
+    it('should publish usersub and subscribe Mercury on station login when enableWxBetterTogether is true at init', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {
+        userId: 'user-123',
+        url: 'https://wdm.example.com/devices/dev-1',
+        registered: true,
+        register: jest.fn().mockResolvedValue(undefined),
+      };
+      webex.internal.mercury.connected = true;
+      webex.internal.mercury.connect = jest.fn().mockResolvedValue(undefined);
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      const subscribeSpy = jest
+        .spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe')
+        .mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(publishSpy).toHaveBeenCalledWith(true, {userId: 'user-123', trackPublishMetrics: true});
+      expect(subscribeSpy).toHaveBeenCalledWith('agentId', expect.any(Function));
+    });
+
+    it('should rollback wxApp config when post-station-login init fails', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      mockTaskManager.applyEnableWxBetterTogether(true);
+
+      jest
+        .spyOn(webex.cc as never, 'publishAnswerOnWebexCrossClientState' as never)
+        .mockRejectedValue(new Error('usersub publish failed'));
+      const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(unsubscribeSpy).toHaveBeenCalled();
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockTaskManager.applyEnableWxBetterTogether).toHaveBeenCalledWith(false);
+    });
+
+    it('should reset wxApp config when Mercury fails before usersub publish on station login', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      mockTaskManager.applyEnableWxBetterTogether(true);
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      jest
+        .spyOn(webex.cc as any, 'ensureWxAppMercuryConnected')
+        .mockRejectedValue(new Error('mercury connect failed'));
+      const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+      const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+      jest
+        .spyOn(webex.cc as any, 'releaseWxAppMercuryResources')
+        .mockResolvedValue(undefined);
+      const metricSpy = jest.spyOn(mockMetricsManager, 'trackEvent');
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(publishSpy).not.toHaveBeenCalled();
+      expect(teardownSpy).not.toHaveBeenCalled();
+      expect(unsubscribeSpy).toHaveBeenCalled();
+      expect(metricSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED,
+        expect.objectContaining({skipReason: 'mercury_subscribe_failed'}),
+        ['operational', 'behavioral']
+      );
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockTaskManager.applyEnableWxBetterTogether).toHaveBeenCalledWith(false);
+    });
+
+    it('should record publish_failed when usersub publish fails after Mercury init', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      mockTaskManager.applyEnableWxBetterTogether(true);
+
+      jest.spyOn(webex.cc as any, 'ensureWxAppMercuryConnected').mockResolvedValue(undefined);
+      jest
+        .spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe')
+        .mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockRejectedValue(new Error('publish failed'));
+      jest
+        .spyOn(webex.cc as any, 'releaseWxAppMercuryResources')
+        .mockResolvedValue(undefined);
+      const metricSpy = jest.spyOn(mockMetricsManager, 'trackEvent');
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(metricSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED,
+        expect.objectContaining({skipReason: 'publish_failed'}),
+        ['operational', 'behavioral']
+      );
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+    });
+
+    it('should register device before publishing usersub true on extension station login', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {
+        userId: 'user-123',
+        registered: false,
+        register: jest.fn().mockImplementation(async function (this: {
+          url?: string;
+          registered?: boolean;
+        }) {
+          this.url = 'https://wdm.example.com/devices/dev-1';
+          this.registered = true;
+        }),
+      };
+      webex.internal.mercury = {
+        connected: false,
+        connect: jest.fn().mockResolvedValue(undefined),
+      };
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe').mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+
+      const callOrder: string[] = [];
+      jest.spyOn(webex.internal.device, 'register').mockImplementation(async function (this: {
+        url?: string;
+        registered?: boolean;
+      }) {
+        callOrder.push('device.register');
+        this.url = 'https://wdm.example.com/devices/dev-1';
+        this.registered = true;
+      });
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockImplementation(async (enable: boolean) => {
+          if (enable === true && !webex.internal.device.url) {
+            throw new Error('Device URL is unavailable for cross-client publish');
+          }
+          callOrder.push(enable ? 'publish:true' : 'publish:false');
+        });
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(callOrder).toEqual(['device.register', 'publish:true']);
+    });
+
+    it('should register device before publishing forced usersub false when wxApp is disabled at station login', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: false};
+      webex.internal.device = {
+        userId: 'user-123',
+        registered: false,
+        register: jest.fn().mockImplementation(async function (this: {
+          url?: string;
+          registered?: boolean;
+        }) {
+          this.url = 'https://wdm.example.com/devices/dev-1';
+          this.registered = true;
+        }),
+      };
+      webex.internal.mercury = {
+        connected: false,
+        connect: jest.fn().mockResolvedValue(undefined),
+      };
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      jest
+        .spyOn(webex.cc as any, 'releaseWxAppMercuryResources')
+        .mockResolvedValue(undefined);
+
+      const callOrder: string[] = [];
+      jest.spyOn(webex.internal.device, 'register').mockImplementation(async function (this: {
+        url?: string;
+        registered?: boolean;
+      }) {
+        callOrder.push('device.register');
+        this.url = 'https://wdm.example.com/devices/dev-1';
+        this.registered = true;
+      });
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockImplementation(async (enable: boolean) => {
+          if (!webex.internal.device.url) {
+            throw new Error('Device URL is unavailable for cross-client publish');
+          }
+          callOrder.push(enable ? 'publish:true' : 'publish:false');
+        });
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(callOrder).toEqual(['device.register', 'publish:false']);
+    });
+
+    it('should retry forced false publish when wxApp is disabled at station login', async () => {
+      jest.useFakeTimers();
+      try {
+        webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: false};
+        webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+        webex.cc.agentConfig = {
+          agentId: 'agentId',
+          webRtcEnabled: false,
+          loginVoiceOptions: ['EXTENSION'],
+        };
+        webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+
+        const publishSpy = jest
+          .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+          .mockRejectedValueOnce(new Error('usersub publish failed'))
+          .mockResolvedValue(undefined);
+        const scheduleRetrySpy = jest.spyOn(
+          webex.cc as any,
+          'scheduleForcedFalsePublishRetry'
+        );
+        const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+        jest
+          .spyOn(webex.cc as any, 'releaseWxAppMercuryResources')
+          .mockResolvedValue(undefined);
+
+        jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+          data: {
+            agentId: 'agentId',
+            teamId: 'teamId',
+            channelsMap: {chat: [], email: [], social: [], telephony: []},
+          },
+          trackingId: 'track-1',
+        } as StationLoginSuccess);
+
+        await webex.cc.stationLogin({
+          teamId: 'teamId',
+          loginOption: LoginOption.EXTENSION,
+          dialNumber: '1001',
+        });
+
+        expect(publishSpy).toHaveBeenCalledTimes(1);
+        expect(scheduleRetrySpy).toHaveBeenCalled();
+        expect(teardownSpy).not.toHaveBeenCalled();
+
+        jest.advanceTimersByTime(30_000);
+        await publishSpy.mock.results[1]?.value;
+
+        expect(publishSpy).toHaveBeenCalledTimes(2);
+        expect(publishSpy).toHaveBeenLastCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+
+    it('should not publish usersub on BROWSER station login even when enableWxBetterTogether is true at init', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: true,
+        loginVoiceOptions: ['BROWSER'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.BROWSER;
+
+      const publishSpy = jest.spyOn(
+        webex.cc['webexCrossClientService'],
+        'setManageWebexCallingInWxcc'
+      );
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.BROWSER,
+      });
+
+      expect(publishSpy).not.toHaveBeenCalled();
+    });
+
+    it('should force-publish usersub false on station login when enableWxBetterTogether is false at init', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: false};
+      webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+      const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(publishSpy).toHaveBeenCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+      expect(teardownSpy).toHaveBeenCalled();
+      expect(unsubscribeSpy).toHaveBeenCalled();
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_SESSION_SKIPPED,
+        expect.objectContaining({
+          enableWxBetterTogether: false,
+          skipReason: 'flag_disabled',
+        }),
+        ['operational', 'behavioral']
+      );
+    });
+
+    it('should not emit WXAPP_SESSION_INIT_FAILED when flag-disabled cleanup fails', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: false};
+      webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockRejectedValue(new Error('forced false publish failed'));
+      const metricSpy = jest.spyOn(mockMetricsManager, 'trackEvent');
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(metricSpy).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED,
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('should still publish usersub but record session init failed when Mercury is unavailable', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {
+        userId: 'user-123',
+        url: 'https://wdm.example.com/devices/dev-1',
+        registered: true,
+        register: jest.fn().mockResolvedValue(undefined),
+      };
+      delete webex.internal.mercury;
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      mockTaskManager.applyEnableWxBetterTogether(true);
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'isAnswerCallsStateActive')
+        .mockReturnValue(true);
+      const metricSpy = jest.spyOn(mockMetricsManager, 'trackEvent');
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(publishSpy).toHaveBeenCalledWith(true, {userId: 'user-123', trackPublishMetrics: true});
+      expect(metricSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_FAILED,
+        expect.objectContaining({error: 'Mercury is unavailable for wxApp mute sync'}),
+        ['operational', 'behavioral']
+      );
+      expect(metricSpy).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_SUCCESS,
+        expect.anything(),
+        expect.anything()
+      );
+      expect(metricSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED,
+        expect.objectContaining({skipReason: 'mercury_not_subscribed'}),
+        ['operational', 'behavioral']
+      );
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(true);
+    });
+
+    it('should record session init failed when userId is missing but not emit success', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {
+        url: 'https://wdm.example.com/devices/dev-1',
+        registered: true,
+        register: jest.fn().mockResolvedValue(undefined),
+      };
+      webex.internal.mercury = {
+        connected: true,
+        connect: jest.fn().mockResolvedValue(undefined),
+        on: jest.fn(),
+        off: jest.fn(),
+      };
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      mockTaskManager.applyEnableWxBetterTogether(true);
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+      const metricSpy = jest.spyOn(mockMetricsManager, 'trackEvent');
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(publishSpy).not.toHaveBeenCalledWith(true, expect.anything());
+      expect(metricSpy).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_SUCCESS,
+        expect.anything(),
+        expect.anything()
+      );
+      expect(metricSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED,
+        expect.objectContaining({skipReason: 'usersub_not_published'}),
+        ['operational', 'behavioral']
+      );
+      expect(metricSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+        expect.objectContaining({skipReason: 'user_id_unavailable'}),
+        ['operational', 'behavioral']
+      );
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(true);
+    });
+
+    it('should clear stale usersub on login after prior session enabled wxApp then hard refresh', async () => {
+      webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      webex.request = jest.fn().mockResolvedValue({body: {}});
+
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      webex.cc['webexCrossClientService'].teardown();
+      webex.cc['wxAppTelephonyMercurySync'].unsubscribe();
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: false};
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(publishSpy).toHaveBeenCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+    });
   });
 
   describe('stationLogout', () => {
@@ -1042,23 +1689,233 @@ describe('webex.cc', () => {
         method: 'stationLogout',
       });
 
-      expect(stationLogoutMock).toHaveBeenCalledWith({data: data});
-      // TODO: https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-626777 Implement the de-register method and close the listener there
-      // expect(mockTaskManager.unregisterIncomingCallEvent).toHaveBeenCalledWith();
-      // expect(mockTaskManager.off).toHaveBeenCalledWith(
-      //   TASK_EVENTS.TASK_INCOMING,
-      //   expect.any(Function)
-      // );
-      // expect(mockTaskManager.off).toHaveBeenCalledWith(
-      //   TASK_EVENTS.TASK_HYDRATE,
-      //   expect.any(Function)
-      // );
-      // expect(mockWebSocketManager.off).toHaveBeenCalledWith('message', expect.any(Function));
-      expect(result).toEqual(response);
-      expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith([
-        METRIC_EVENT_NAMES.STATION_LOGOUT_SUCCESS,
-        METRIC_EVENT_NAMES.STATION_LOGOUT_FAILED,
-      ]);
+      expect(stationLogoutMock).toHaveBeenCalledWith({data: data});
+      // TODO: https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-626777 Implement the de-register method and close the listener there
+      // expect(mockTaskManager.unregisterIncomingCallEvent).toHaveBeenCalledWith();
+      // expect(mockTaskManager.off).toHaveBeenCalledWith(
+      //   TASK_EVENTS.TASK_INCOMING,
+      //   expect.any(Function)
+      // );
+      // expect(mockTaskManager.off).toHaveBeenCalledWith(
+      //   TASK_EVENTS.TASK_HYDRATE,
+      //   expect.any(Function)
+      // );
+      // expect(mockWebSocketManager.off).toHaveBeenCalledWith('message', expect.any(Function));
+      expect(result).toEqual(response);
+      expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith([
+        METRIC_EVENT_NAMES.STATION_LOGOUT_SUCCESS,
+        METRIC_EVENT_NAMES.STATION_LOGOUT_FAILED,
+      ]);
+    });
+
+    it('should not publish usersub false on logout when wxApp was never enabled', async () => {
+      webex.internal.device = {userId: 'user-123'};
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+      const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+
+      jest.spyOn(webex.cc.services.agent, 'logout').mockResolvedValue({
+        trackingId: 'track-1',
+      } as StationLogoutResponse);
+
+      await webex.cc.stationLogout({logoutReason: 'Logout reason'});
+
+      expect(publishSpy).not.toHaveBeenCalled();
+      expect(teardownSpy).toHaveBeenCalled();
+      expect(unsubscribeSpy).toHaveBeenCalled();
+    });
+
+    it('should publish usersub false and teardown wxApp sync on logout when wxApp was enabled', async () => {
+      webex.internal.device = {
+        userId: 'user-123',
+        url: 'https://wdm.example.com/devices/dev-1',
+        registered: false,
+        register: jest.fn().mockResolvedValue(undefined),
+        unregister: jest.fn().mockResolvedValue(undefined),
+      };
+      webex.internal.mercury = {
+        connected: false,
+        connect: jest.fn().mockResolvedValue(undefined),
+        disconnect: jest.fn().mockResolvedValue(undefined),
+      };
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe').mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+      webex.request = jest.fn().mockResolvedValue({body: {}});
+      webex.cc['agentConfig'] = {
+        agentId: 'agent-123',
+        deviceType: LoginOption.EXTENSION,
+      } as Profile;
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+
+      await (webex.cc as any).setManageWebexCallingInWxcc(true);
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+      const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+
+      jest.spyOn(webex.cc.services.agent, 'logout').mockResolvedValue({
+        trackingId: 'track-1',
+      } as StationLogoutResponse);
+
+      await webex.cc.stationLogout({logoutReason: 'Logout reason'});
+
+      expect(publishSpy).toHaveBeenCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+      expect(teardownSpy).toHaveBeenCalled();
+      expect(unsubscribeSpy).toHaveBeenCalled();
+    });
+
+    it('should teardown wxApp state on logout even when usersub publish fails', async () => {
+      webex.internal.device = {userId: 'user-123'};
+      webex.cc['agentConfig'] = {
+        agentId: 'agent-123',
+        deviceType: LoginOption.EXTENSION,
+      } as Profile;
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      mockTaskManager.applyEnableWxBetterTogether(true);
+
+      jest.spyOn(webex.cc.services.agent, 'logout').mockResolvedValue({
+        trackingId: 'track-1',
+      } as StationLogoutResponse);
+      jest
+        .spyOn(webex.cc as never, 'publishAnswerOnWebexCrossClientState' as never)
+        .mockRejectedValue(new Error('usersub publish failed'));
+      const scheduleRetrySpy = jest.spyOn(
+        webex.cc as any,
+        'scheduleCompensatingFalsePublishRetry'
+      );
+      const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+      const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+
+      const result = await webex.cc.stationLogout({logoutReason: 'Logout reason'});
+
+      expect(result).toEqual({trackingId: 'track-1'});
+      expect(teardownSpy).toHaveBeenCalled();
+      expect(unsubscribeSpy).toHaveBeenCalled();
+      expect(scheduleRetrySpy).toHaveBeenCalled();
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(true);
+    });
+
+    it('should retry compensating false publish when teardown usersub publish fails on logout', async () => {
+      jest.useFakeTimers();
+      try {
+        webex.internal.device = {
+          userId: 'user-123',
+          url: 'https://wdm.example.com/devices/dev-1',
+        };
+        webex.cc['agentConfig'] = {
+          agentId: 'agent-123',
+          deviceType: LoginOption.EXTENSION,
+        } as Profile;
+        webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+        webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+        mockTaskManager.applyEnableWxBetterTogether(true);
+        webex.cc['webexCrossClientService'].answerCallsState = true;
+
+        jest.spyOn(webex.cc.services.agent, 'logout').mockResolvedValue({
+          trackingId: 'track-1',
+        } as StationLogoutResponse);
+
+        const publishSpy = jest
+          .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+          .mockRejectedValueOnce(new Error('usersub publish failed'))
+          .mockResolvedValue(undefined);
+        const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+        const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+        jest
+          .spyOn(webex.cc as any, 'releaseWxAppMercuryResources')
+          .mockResolvedValue(undefined);
+
+        const result = await webex.cc.stationLogout({logoutReason: 'Logout reason'});
+
+        expect(result).toEqual({trackingId: 'track-1'});
+        expect(publishSpy).toHaveBeenCalledTimes(1);
+        expect(publishSpy).toHaveBeenCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+        expect(teardownSpy).toHaveBeenCalled();
+        expect(unsubscribeSpy).toHaveBeenCalled();
+
+        jest.advanceTimersByTime(30_000);
+        await publishSpy.mock.results[1]?.value;
+
+        expect(publishSpy).toHaveBeenCalledTimes(2);
+        expect(publishSpy).toHaveBeenLastCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+
+    it('should cancel compensating retry when station login succeeds before retry fires', async () => {
+      jest.useFakeTimers();
+      try {
+        webex.internal.device = {
+          userId: 'user-123',
+          url: 'https://wdm.example.com/devices/dev-1',
+          registered: false,
+          register: jest.fn().mockResolvedValue(undefined),
+          unregister: jest.fn().mockResolvedValue(undefined),
+        };
+        webex.internal.mercury = {
+          connected: false,
+          connect: jest.fn().mockResolvedValue(undefined),
+          disconnect: jest.fn().mockResolvedValue(undefined),
+        };
+        jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe').mockImplementation(() => {});
+        jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+        webex.cc['agentConfig'] = {
+          agentId: 'agent-123',
+          deviceType: LoginOption.EXTENSION,
+          webRtcEnabled: false,
+          loginVoiceOptions: ['EXTENSION'],
+        } as Profile;
+        webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+        webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+        mockTaskManager.applyEnableWxBetterTogether(true);
+        webex.cc['webexCrossClientService'].answerCallsState = true;
+
+        jest.spyOn(webex.cc.services.agent, 'logout').mockResolvedValue({
+          trackingId: 'track-1',
+        } as StationLogoutResponse);
+        jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+          data: {
+            agentId: 'agent-123',
+            teamId: 'team-123',
+            channelsMap: {chat: [], email: [], social: [], telephony: []},
+          },
+          trackingId: 'track-2',
+        } as StationLoginSuccess);
+
+        const publishSpy = jest
+          .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+          .mockRejectedValueOnce(new Error('usersub publish failed'))
+          .mockResolvedValue(undefined);
+        const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+        jest
+          .spyOn(webex.cc as any, 'releaseWxAppMercuryResources')
+          .mockResolvedValue(undefined);
+
+        await webex.cc.stationLogout({logoutReason: 'Logout reason'});
+        await webex.cc.stationLogin({
+          teamId: 'team-123',
+          loginOption: LoginOption.EXTENSION,
+          dialNumber: '1001',
+        });
+
+        expect(publishSpy).toHaveBeenCalledTimes(2);
+        expect(publishSpy).toHaveBeenNthCalledWith(1, false, {userId: 'user-123', trackPublishMetrics: true});
+        expect(publishSpy).toHaveBeenNthCalledWith(2, true, {userId: 'user-123', trackPublishMetrics: true});
+        expect(teardownSpy).toHaveBeenCalledTimes(1);
+
+        jest.advanceTimersByTime(30_000);
+
+        expect(publishSpy).toHaveBeenCalledTimes(2);
+        expect(teardownSpy).toHaveBeenCalledTimes(1);
+      } finally {
+        jest.useRealTimers();
+      }
     });
 
     it('should handle error during stationLogout', async () => {
@@ -1276,6 +2133,41 @@ describe('webex.cc', () => {
       ]);
     });
 
+    it('should map Transfer action to an Available backend state filter', async () => {
+      webex.cc.agentConfig = {agentProfileID: 'test-agent-profile-id'};
+      const buddyAgentsResponse = {data: {agentList: []}};
+      const buddyAgentsSpy = jest
+        .spyOn(webex.cc.services.agent, 'buddyAgents')
+        .mockResolvedValue(buddyAgentsResponse);
+
+      await webex.cc.getBuddyAgents({action: 'Transfer', mediaType: 'chat'});
+
+      expect(buddyAgentsSpy).toHaveBeenCalledWith({
+        data: {
+          agentProfileId: 'test-agent-profile-id',
+          mediaType: 'chat',
+          state: 'Available',
+        },
+      });
+    });
+
+    it('should omit the backend state filter for Consult and default media type to telephony', async () => {
+      webex.cc.agentConfig = {agentProfileID: 'test-agent-profile-id'};
+      const buddyAgentsResponse = {data: {agentList: []}};
+      const buddyAgentsSpy = jest
+        .spyOn(webex.cc.services.agent, 'buddyAgents')
+        .mockResolvedValue(buddyAgentsResponse);
+
+      await webex.cc.getBuddyAgents({action: 'Consult'});
+
+      expect(buddyAgentsSpy).toHaveBeenCalledWith({
+        data: {
+          agentProfileId: 'test-agent-profile-id',
+          mediaType: 'telephony',
+        },
+      });
+    });
+
     it('should handle error', async () => {
       const data: BuddyAgents = {state: 'Available', mediaType: 'telephony'};
       webex.cc.agentConfig = {
@@ -1503,6 +2395,82 @@ describe('webex.cc', () => {
       expect(webex.cc.agentConfig.deviceType).toBe(LoginOption.AGENT_DN);
       expect(webex.cc.agentConfig.dn).toBe('67890');
     });
+
+    it('should publish usersub true on silent relogin when enableWxBetterTogether is true at init', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {
+        userId: 'user-123',
+        url: 'https://wdm.example.com/devices/dev-1',
+        registered: true,
+        register: jest.fn().mockResolvedValue(undefined),
+      };
+      webex.internal.mercury.connected = true;
+      webex.internal.mercury.connect = jest.fn().mockResolvedValue(undefined);
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        agentProfileID: 'test-agent-profile-id',
+        isAgentLoggedIn: false,
+      } as Profile;
+
+      jest.spyOn(webex.cc.services.agent, 'reload').mockResolvedValue({
+        data: {
+          auxCodeId: 'auxCodeId',
+          agentId: 'agentId',
+          deviceType: LoginOption.EXTENSION,
+          dn: '1001',
+          teamId: 'teamId',
+          lastStateChangeTimestamp: 1738575135188,
+          lastIdleCodeChangeTimestamp: 1738575135189,
+        },
+      });
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      const subscribeSpy = jest
+        .spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe')
+        .mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+
+      await webex.cc['silentRelogin']();
+
+      expect(publishSpy).toHaveBeenCalledWith(true, {userId: 'user-123', trackPublishMetrics: true});
+      expect(subscribeSpy).toHaveBeenCalledWith('agentId', expect.any(Function));
+    });
+
+    it('should force-publish usersub false on silent relogin when enableWxBetterTogether is false at init', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: false};
+      webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        agentProfileID: 'test-agent-profile-id',
+        isAgentLoggedIn: false,
+      } as Profile;
+
+      jest.spyOn(webex.cc.services.agent, 'reload').mockResolvedValue({
+        data: {
+          auxCodeId: 'auxCodeId',
+          agentId: 'agentId',
+          deviceType: LoginOption.EXTENSION,
+          dn: '1001',
+          teamId: 'teamId',
+          lastStateChangeTimestamp: 1738575135188,
+          lastIdleCodeChangeTimestamp: 1738575135189,
+        },
+      });
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+      const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+
+      await webex.cc['silentRelogin']();
+
+      expect(publishSpy).toHaveBeenCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+      expect(teardownSpy).toHaveBeenCalled();
+      expect(unsubscribeSpy).toHaveBeenCalled();
+    });
   });
 
   describe('setupEventListeners()', () => {
@@ -1741,6 +2709,18 @@ describe('webex.cc', () => {
         on: jest.fn(),
       } as any;
 
+      webex.internal.device = {
+        ...webex.internal.device,
+        userId: 'user-123',
+        unregister: jest.fn().mockResolvedValue(undefined),
+      };
+      deviceUnregisterSpy = jest.spyOn(webex.internal.device, 'unregister');
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+      const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+
       await webex.cc.deregister();
 
       expect(mockTaskManager.off).toHaveBeenCalledWith(
@@ -1829,6 +2809,39 @@ describe('webex.cc', () => {
       expect(connectionCalls).toHaveLength(1);
       const [, connectionCallback] = connectionCalls[0];
       expect(connectionCallback).toBe(webex.cc['handleConnectionLost']);
+
+      expect(publishSpy).not.toHaveBeenCalled();
+      expect(teardownSpy).toHaveBeenCalled();
+      expect(unsubscribeSpy).toHaveBeenCalled();
+    });
+
+    it('should publish usersub false before device unregister when wxApp is active on deregister', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.cc['webexCrossClientService'].answerCallsState = true;
+      webex.internal.device = {
+        userId: 'user-123',
+        url: 'https://wdm.example.com/devices/dev-1',
+        unregister: jest.fn().mockResolvedValue(undefined),
+      };
+      deviceUnregisterSpy = jest.spyOn(webex.internal.device, 'unregister');
+
+      const callOrder: string[] = [];
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockImplementation(async (enable: boolean) => {
+          if (enable === false && !webex.internal.device.url) {
+            throw new Error('Device URL is unavailable for cross-client publish');
+          }
+          callOrder.push(enable ? 'publish:true' : 'publish:false');
+        });
+      deviceUnregisterSpy.mockImplementation(async () => {
+        callOrder.push('device.unregister');
+        webex.internal.device.url = undefined;
+      });
+
+      await webex.cc.deregister();
+
+      expect(callOrder).toEqual(['publish:false', 'device.unregister']);
     });
 
     it('should skip webCallingService and internal cleanup when webrtc is disabled', async () => {
@@ -1878,6 +2891,135 @@ describe('webex.cc', () => {
       expect(webex.cc.agentConfig).toBeNull();
     });
 
+    it('should teardown wxApp state on deregister even when usersub publish fails', async () => {
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: [LoginOption.EXTENSION],
+      };
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.cc['webexCrossClientService'].answerCallsState = true;
+      webex.internal.device = {
+        userId: 'user-123',
+        unregister: jest.fn().mockResolvedValue(undefined),
+      };
+
+      jest
+        .spyOn(webex.cc as never, 'publishAnswerOnWebexCrossClientState' as never)
+        .mockRejectedValue(new Error('usersub publish failed'));
+      const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+      const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+
+      await expect(webex.cc.deregister()).rejects.toThrow('usersub publish failed');
+
+      expect(teardownSpy).toHaveBeenCalled();
+      expect(unsubscribeSpy).toHaveBeenCalled();
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockWebSocketManager.close).toHaveBeenCalledWith(false, 'Unregistering the SDK');
+      expect(webex.cc.agentConfig).toBeNull();
+    });
+
+    it('should publish forced false during teardown when enable publish is still in flight', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {
+        userId: 'user-123',
+        url: 'https://wdm.example.com/devices/dev-1',
+      };
+
+      let resolveEnable: () => void = () => {};
+      const enableGate = new Promise<void>((resolve) => {
+        resolveEnable = resolve;
+      });
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockImplementation(async (enable: boolean) => {
+          if (enable) {
+            await enableGate;
+          }
+        });
+      jest
+        .spyOn(webex.cc as any, 'releaseWxAppMercuryResources')
+        .mockResolvedValue(undefined);
+
+      expect(webex.cc['webexCrossClientService'].answerCallsState).toBe(false);
+
+      const enableInFlight = (webex.cc as any).publishAnswerOnWebexCrossClientState(true);
+
+      await (webex.cc as any).teardownWxAppLocalState();
+
+      expect(publishSpy).toHaveBeenCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+
+      resolveEnable();
+      await enableInFlight;
+    });
+
+    it('should release wxApp-owned Mercury and device on deregister', async () => {
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: [LoginOption.EXTENSION],
+      };
+      webex.cc['wxAppMercuryConnectedByCc'] = true;
+      webex.cc['wxAppDeviceRegisteredByCc'] = true;
+      webex.internal.mercury.connected = true;
+      webex.internal.device.registered = true;
+
+      const mercuryDisconnectSpy = jest
+        .spyOn(webex.internal.mercury, 'disconnect')
+        .mockResolvedValue(undefined);
+      const deviceUnregisterSpy = jest
+        .spyOn(webex.internal.device, 'unregister')
+        .mockResolvedValue(undefined);
+
+      await webex.cc.deregister();
+
+      expect(mercuryDisconnectSpy).toHaveBeenCalled();
+      expect(deviceUnregisterSpy).toHaveBeenCalled();
+      expect(webex.cc['wxAppMercuryConnectedByCc']).toBe(false);
+      expect(webex.cc['wxAppDeviceRegisteredByCc']).toBe(false);
+    });
+
+    it('should retain wxApp Mercury ownership when disconnect fails and retry cleanup', async () => {
+      webex.cc['wxAppMercuryConnectedByCc'] = true;
+      webex.internal.mercury.connected = true;
+
+      const mercuryDisconnectSpy = jest
+        .spyOn(webex.internal.mercury, 'disconnect')
+        .mockRejectedValueOnce(new Error('disconnect failed'))
+        .mockResolvedValueOnce(undefined);
+
+      await webex.cc['releaseWxAppMercuryResources']();
+
+      expect(mercuryDisconnectSpy).toHaveBeenCalledTimes(1);
+      expect(webex.cc['wxAppMercuryConnectedByCc']).toBe(true);
+
+      await webex.cc['releaseWxAppMercuryResources']();
+
+      expect(mercuryDisconnectSpy).toHaveBeenCalledTimes(2);
+      expect(webex.cc['wxAppMercuryConnectedByCc']).toBe(false);
+    });
+
+    it('should retain wxApp device ownership when unregister fails and retry cleanup', async () => {
+      webex.cc['wxAppDeviceRegisteredByCc'] = true;
+      webex.internal.device.registered = true;
+
+      const deviceUnregisterSpy = jest
+        .spyOn(webex.internal.device, 'unregister')
+        .mockRejectedValueOnce(new Error('unregister failed'))
+        .mockResolvedValueOnce(undefined);
+
+      await webex.cc['releaseWxAppMercuryResources']();
+
+      expect(deviceUnregisterSpy).toHaveBeenCalledTimes(1);
+      expect(webex.cc['wxAppDeviceRegisteredByCc']).toBe(true);
+
+      await webex.cc['releaseWxAppMercuryResources']();
+
+      expect(deviceUnregisterSpy).toHaveBeenCalledTimes(2);
+      expect(webex.cc['wxAppDeviceRegisteredByCc']).toBe(false);
+    });
+
     it('should handle errors during unregister and track metrics', async () => {
       const mockError = new Error('Failed to deregister device');
       webex.internal.device.unregister.mockRejectedValue(mockError);
@@ -2128,6 +3270,55 @@ describe('webex.cc', () => {
       expect(result).toEqual(mockResp);
     });
 
+    it('should preserve enableWxBetterTogether init flag across profile update logout/login', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+      webex.cc.agentConfig = {
+        ...webex.cc.agentConfig,
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['BROWSER', 'EXTENSION'],
+      } as Profile;
+      webex.cc.webCallingService.loginOption = LoginOption.BROWSER;
+      webex.cc.webCallingService.setLoginOption = jest.fn((loginOption: LoginOption) => {
+        webex.cc.webCallingService.loginOption = loginOption;
+      });
+      webex.cc['webexCrossClientService'].answerCallsState = true;
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      jest
+        .spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe')
+        .mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+      jest.spyOn(webex.cc as any, 'releaseWxAppMercuryResources').mockResolvedValue(undefined);
+
+      jest.spyOn(webex.cc.services.agent, 'logout').mockResolvedValue({
+        trackingId: 'track-logout',
+      } as StationLogoutResponse);
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-login',
+      } as StationLoginSuccess);
+
+      webex.internal.mercury.connected = true;
+
+      await webex.cc.updateAgentProfile({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(true);
+      expect(publishSpy).toHaveBeenCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+      expect(publishSpy).toHaveBeenCalledWith(true, {userId: 'user-123', trackPublishMetrics: true});
+    });
+
     it('should use provided teamId if passed in payload', async () => {
       const dataWithTeam = {
         teamId: 'newTeam',
@@ -2640,4 +3831,316 @@ describe('webex.cc', () => {
       expect(getErrorDetailsSpy).toHaveBeenCalledWith(error, 'removePreviewContact', CC_FILE);
     });
   });
+
+  describe('private setManageWebexCallingInWxcc (runtime toggle impl)', () => {
+    beforeEach(() => {
+      webex.internal.device = {
+        userId: 'user-123',
+        registered: false,
+        register: jest.fn().mockResolvedValue(undefined),
+        unregister: jest.fn().mockResolvedValue(undefined),
+      };
+      webex.internal.mercury = {
+        connected: false,
+        connect: jest.fn().mockResolvedValue(undefined),
+        disconnect: jest.fn().mockResolvedValue(undefined),
+      };
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe').mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: false};
+      webex.cc['agentConfig'] = {
+        agentId: 'agent-123',
+        deviceType: LoginOption.EXTENSION,
+      } as Profile;
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      webex.cc.webCallingService.setLoginOption = jest.fn((loginOption: LoginOption) => {
+        webex.cc.webCallingService.loginOption = loginOption;
+      });
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should update config, task manager, and publish usersub when enabled', async () => {
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+
+      await (webex.cc as any).setManageWebexCallingInWxcc(true);
+
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(true);
+      expect(mockTaskManager.applyEnableWxBetterTogether).toHaveBeenCalledWith(true);
+      expect(publishSpy).toHaveBeenCalledWith(true, {userId: 'user-123', trackPublishMetrics: true});
+    });
+
+    it('should publish false and update config when disabled after wxApp was enabled', async () => {
+      webex.internal.device = {
+        userId: 'user-123',
+        url: 'https://wdm.example.com/devices/dev-1',
+      };
+      webex.request = jest.fn().mockResolvedValue({body: {}});
+
+      await (webex.cc as any).setManageWebexCallingInWxcc(true);
+
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+
+      await (webex.cc as any).setManageWebexCallingInWxcc(false);
+
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockTaskManager.applyEnableWxBetterTogether).toHaveBeenCalledWith(false);
+      expect(publishSpy).toHaveBeenCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+    });
+
+    it('should skip usersub publish when disabling without prior wxApp publish', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+
+      await (webex.cc as any).setManageWebexCallingInWxcc(false);
+
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockTaskManager.applyEnableWxBetterTogether).toHaveBeenCalledWith(false);
+      expect(publishSpy).not.toHaveBeenCalled();
+    });
+
+    it('should throw when enabling before login', async () => {
+      webex.internal.device = undefined;
+
+      await expect((webex.cc as any).setManageWebexCallingInWxcc(true)).rejects.toThrow(
+        'Cannot publish answer-calls-on-wxcc: user is not logged in'
+      );
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockTaskManager.applyEnableWxBetterTogether).not.toHaveBeenCalled();
+    });
+
+    it('should throw when enabling on BROWSER (Desktop) login', async () => {
+      webex.cc['agentConfig'] = {deviceType: LoginOption.BROWSER} as Profile;
+      webex.cc.webCallingService.loginOption = LoginOption.BROWSER;
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+
+      await expect((webex.cc as any).setManageWebexCallingInWxcc(true)).rejects.toThrow(
+        'setManageWebexCallingInWxcc requires EXTENSION or AGENT_DN station login'
+      );
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockTaskManager.applyEnableWxBetterTogether).not.toHaveBeenCalled();
+      expect(publishSpy).not.toHaveBeenCalled();
+    });
+
+    it('should throw when enabling before station login', async () => {
+      webex.cc['agentConfig'] = undefined as unknown as Profile;
+      webex.cc.webCallingService.loginOption = undefined as unknown as LoginOption;
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+
+      await expect((webex.cc as any).setManageWebexCallingInWxcc(true)).rejects.toThrow(
+        'setManageWebexCallingInWxcc requires EXTENSION or AGENT_DN station login'
+      );
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockTaskManager.applyEnableWxBetterTogether).not.toHaveBeenCalled();
+      expect(publishSpy).not.toHaveBeenCalled();
+    });
+
+    it('should throw when webCallingService is BROWSER even if agentConfig deviceType is stale', async () => {
+      webex.cc['agentConfig'] = {deviceType: LoginOption.EXTENSION} as Profile;
+      webex.cc.webCallingService.loginOption = LoginOption.BROWSER;
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+
+      await expect((webex.cc as any).setManageWebexCallingInWxcc(true)).rejects.toThrow(
+        'setManageWebexCallingInWxcc requires EXTENSION or AGENT_DN station login'
+      );
+      expect(publishSpy).not.toHaveBeenCalled();
+    });
+
+    it('should publish usersub when enabling on AGENT_DN login', async () => {
+      webex.cc['agentConfig'] = {
+        agentId: 'agent-123',
+        deviceType: LoginOption.AGENT_DN,
+      } as Profile;
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+
+      await (webex.cc as any).setManageWebexCallingInWxcc(true);
+
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(true);
+      expect(publishSpy).toHaveBeenCalledWith(true, {userId: 'user-123', trackPublishMetrics: true});
+    });
+
+    it('should no-op usersub publish when disabling before login', async () => {
+      webex.internal.device = undefined;
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+
+      await (webex.cc as any).setManageWebexCallingInWxcc(false);
+
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockTaskManager.applyEnableWxBetterTogether).toHaveBeenCalledWith(false);
+      expect(publishSpy).not.toHaveBeenCalled();
+    });
+
+    it('should subscribe to wxApp Mercury mute sync when enabled', async () => {
+      webex.cc['agentConfig'] = {agentId: 'agent-123'} as Profile;
+      webex.internal.device = {
+        ...webex.internal.device,
+        registered: true,
+        register: jest.fn().mockResolvedValue(undefined),
+      };
+      webex.internal.mercury.connected = true;
+      webex.internal.mercury.connect = jest.fn().mockResolvedValue(undefined);
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      const subscribeSpy = jest
+        .spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe')
+        .mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+
+      await (webex.cc as any).setManageWebexCallingInWxcc(true);
+
+      expect(subscribeSpy).toHaveBeenCalledWith('agent-123', expect.any(Function));
+    });
+
+    it('should unsubscribe from wxApp Mercury mute sync when disabled', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      const unsubscribeSpy = jest
+        .spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe')
+        .mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+
+      await (webex.cc as any).setManageWebexCallingInWxcc(false);
+
+      expect(unsubscribeSpy).toHaveBeenCalled();
+    });
+
+    it('should register device and connect mercury when enabling wxApp sync', async () => {
+      webex.cc['agentConfig'] = {agentId: 'agent-123'} as Profile;
+      webex.internal.device = {
+        userId: 'user-123',
+        registered: false,
+        register: jest.fn().mockResolvedValue(undefined),
+      };
+      webex.internal.mercury = {
+        connected: false,
+        connect: jest.fn().mockResolvedValue(undefined),
+      };
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      const subscribeSpy = jest
+        .spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe')
+        .mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+
+      await (webex.cc as any).setManageWebexCallingInWxcc(true);
+
+      expect(webex.internal.device.register).toHaveBeenCalled();
+      expect(webex.internal.mercury.connect).toHaveBeenCalled();
+      expect(subscribeSpy).toHaveBeenCalledWith('agent-123', expect.any(Function));
+    });
+
+    it('should rollback config and task manager when usersub publish fails', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: false};
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockRejectedValue(new Error('usersub failed'));
+
+      await expect((webex.cc as any).setManageWebexCallingInWxcc(true)).rejects.toThrow('usersub failed');
+
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockTaskManager.applyEnableWxBetterTogether).toHaveBeenCalledWith(true);
+      expect(mockTaskManager.applyEnableWxBetterTogether).toHaveBeenLastCalledWith(false);
+    });
+
+    it('should rollback config and release Mercury resources when Mercury connect fails', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: false};
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      jest
+        .spyOn(webex.cc as any, 'ensureWxAppMercuryConnected')
+        .mockRejectedValue(new Error('mercury connect failed'));
+      const releaseSpy = jest
+        .spyOn(webex.cc as any, 'releaseWxAppMercuryResources')
+        .mockResolvedValue(undefined);
+      const unsubscribeSpy = jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'unsubscribe');
+      const teardownSpy = jest.spyOn(webex.cc['webexCrossClientService'], 'teardown');
+
+      await expect((webex.cc as any).setManageWebexCallingInWxcc(true)).rejects.toThrow(
+        'mercury connect failed'
+      );
+
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+      expect(mockTaskManager.applyEnableWxBetterTogether).toHaveBeenLastCalledWith(false);
+      expect(publishSpy).not.toHaveBeenCalled();
+      expect(teardownSpy).not.toHaveBeenCalled();
+      expect(unsubscribeSpy).toHaveBeenCalled();
+      expect(releaseSpy).toHaveBeenCalled();
+    });
+
+    it('should schedule compensating false retry when rollback publish fails after enable error', async () => {
+      jest.useFakeTimers();
+      try {
+        webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+        webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+        webex.cc.agentConfig = {
+          agentId: 'agent-123',
+          deviceType: LoginOption.EXTENSION,
+        };
+        webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+
+        const publishSpy = jest
+          .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+          .mockResolvedValueOnce(undefined)
+          .mockRejectedValueOnce(new Error('compensating false failed'))
+          .mockResolvedValue(undefined);
+        jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe').mockImplementation(() => {});
+        jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+        jest
+          .spyOn(webex.cc as any, 'ensureWxAppMercuryConnected')
+          .mockResolvedValue(undefined);
+        jest
+          .spyOn(webex.cc as any, 'releaseWxAppMercuryResources')
+          .mockResolvedValue(undefined);
+        jest
+          .spyOn(mockTaskManager, 'syncWxAppMuteFromCallDetailsForAllTasks')
+          .mockImplementation(() => {
+            throw new Error('sync failed');
+          });
+        const scheduleRetrySpy = jest.spyOn(
+          webex.cc as any,
+          'scheduleCompensatingFalsePublishRetry'
+        );
+
+        await expect((webex.cc as any).setManageWebexCallingInWxcc(true)).rejects.toThrow(
+          'sync failed'
+        );
+
+        expect(scheduleRetrySpy).toHaveBeenCalled();
+        expect(publishSpy).toHaveBeenCalledTimes(2);
+        expect(publishSpy).toHaveBeenNthCalledWith(1, true, {userId: 'user-123', trackPublishMetrics: true});
+        expect(publishSpy).toHaveBeenNthCalledWith(2, false, {userId: 'user-123', trackPublishMetrics: true});
+
+        jest.advanceTimersByTime(30_000);
+        await publishSpy.mock.results[2]?.value;
+
+        expect(publishSpy).toHaveBeenCalledTimes(3);
+        expect(publishSpy).toHaveBeenLastCalledWith(false, {userId: 'user-123', trackPublishMetrics: true});
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+  });
 });