@onekeyfe/hd-core 1.2.0-alpha.50 → 1.2.0-alpha.52

package/__tests__/protocol-v2.test.ts

@@ -5,7 +5,6 @@ import {
   DeviceSettingsPage,
   DeviceType,
 } from '@onekeyfe/hd-transport';
-import { sha256 } from '@noble/hashes/sha256';
 
 import * as firmwareBinaryApi from '../src/api/firmware/getBinary';
 import DnxGetAddress from '../src/api/dynex/DnxGetAddress';
@@ -62,7 +61,6 @@ import { createCoreApi } from '../src/inject';
 import { Device, preloadSessionCache } from '../src/device/Device';
 import { deviceWalletSessionStore } from '../src/device/DeviceWalletSessionStore';
 import { DevicePool } from '../src/device/DevicePool';
-import { DEVICE } from '../src/events';
 import { UI_REQUEST } from '../src/events/ui-request';
 import {
   PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
@@ -76,15 +74,11 @@ import {
   requestProtocolV2ProtocolInfo,
   supportsProtocolV2Message,
 } from '../src/protocols/protocol-v2/features';
-import { PROTOCOL_V2_RESOURCE_DEVICE_PATHS } from '../src/protocols/protocol-v2/resources';
 import {
   getProtocolV2WalletSession,
   refreshProtocolV2DeviceStatus,
 } from '../src/protocols/protocol-v2/walletSession';
-import {
-  createProtocolV2UnlockContext,
-  runMethodWithUnlockPolicy,
-} from '../src/protocols/protocol-v2/unlockPolicyRunner';
+import { runMethodWithUnlockRetry } from '../src/protocols/protocol-v2/unlockRetry';
 import { BaseMethod } from '../src/api/BaseMethod';
 import {
   buildProtocolV1FeaturesPayload,
@@ -98,6 +92,7 @@ import {
   getMethodVersionRange,
 } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
+import { openFirmwareByteSource } from '../src/api/firmware/FirmwareArtifactSource';
 import {
   getPassphraseState,
   getPassphraseStateWithRefreshDeviceInfo,
@@ -246,7 +241,7 @@ describe('UploadPortfolio', () => {
     (method as any).device = device;
 
     method.init();
-    await runMethodWithUnlockPolicy(method, device as any);
+    await runMethodWithUnlockRetry(method, device as any);
 
     expect(unlockDevice).not.toHaveBeenCalled();
     expect(typedCall).toHaveBeenNthCalledWith(
@@ -422,16 +417,14 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
     }
     return d.features;
   };
-  d.ensureProtocolV2RuntimeContext ??= (timeoutMs?: number) =>
-    requestProtocolV2ProtocolInfo({
-      commands: d.getCommands?.() ?? d.commands,
-      timeoutMs,
-    });
   d.probeProtocolV2RuntimeState ??= async (
     deviceInfo: ProtocolV2DeviceInfo,
     timeoutMs?: number
   ) => {
-    const protocolInfo = await d.ensureProtocolV2RuntimeContext(timeoutMs);
+    const protocolInfo = await requestProtocolV2ProtocolInfo({
+      commands: d.getCommands(),
+      timeoutMs,
+    });
     const runtimeMode = getProtocolV2RuntimeMode(protocolInfo);
     if (runtimeMode === 'bootloader' || runtimeMode === 'romloader') {
       return d.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
@@ -788,9 +781,6 @@ describe('Protocol V2 feature adapter', () => {
         if (request === 'DeviceStatusGet') {
           return { type: 'DeviceStatus', message: { unlocked: true } };
         }
-        if (request === 'DeviceSessionAskPassphrase') {
-          return { type: 'Success', message: {} };
-        }
         if (request === 'DeviceSessionGet') {
           return {
             type: 'DeviceSession',
@@ -815,7 +805,7 @@ describe('Protocol V2 feature adapter', () => {
     ).resolves.toEqual({
       passphraseState: 'state-1',
       newSession: 'session-1',
-      unlockedAttachPin: false,
+      unlockedAttachPin: undefined,
       resumed: false,
     });
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
@@ -824,13 +814,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
       type: DeviceSessionPinType.Main,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
-      passphrase: '',
-      on_device: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     device.passphraseState = 'state-1';
     expect(device.getInternalState()).toBe('session-1');
   });
@@ -863,7 +847,6 @@ describe('Protocol V2 feature adapter', () => {
           },
         };
       }
-      if (request === 'DeviceSessionAskPassphrase') return { message: {} };
       if (request === 'DeviceSessionGet') {
         return {
           message: {
@@ -880,16 +863,9 @@ describe('Protocol V2 feature adapter', () => {
     await getProtocolV2WalletSession(device, { onlyMainPin: true });
 
     expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPin')).toHaveLength(1);
-    expect(
-      typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPassphrase')
-    ).toHaveLength(1);
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'standard-session',
-      btc_test_address: 'standard-state',
-      seed_domains: [],
     });
     expect(deviceWalletSessionStore.getStandard(deviceId)).toEqual({
       passphraseState: 'standard-state',
@@ -931,7 +907,6 @@ describe('Protocol V2 feature adapter', () => {
           },
         };
       }
-      if (request === 'DeviceSessionAskPassphrase') return { message: {} };
       if (request === 'DeviceSessionAskPin') {
         return { type: 'Success', message: { message: 'PIN verified' } };
       }
@@ -1026,7 +1001,6 @@ describe('Protocol V2 feature adapter', () => {
       if (request === 'DeviceStatusGet') {
         return { message: { device_id: deviceId, unlocked: true, passphrase_enabled: true } };
       }
-      if (request === 'DeviceSessionAskPassphrase') return { message: {} };
       if (request === 'DeviceSessionGet') {
         sessionGetCalls += 1;
         return {
@@ -1253,9 +1227,7 @@ describe('Protocol V2 feature adapter', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('deviceStatusGet returns raw DeviceStatus and updates dynamic features', async () => {
@@ -1363,8 +1335,6 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'session-a',
-      btc_test_address: 'state-a',
-      seed_domains: [],
     });
     expect(device.getInternalState()).toBe('session-b');
   });
@@ -1432,15 +1402,7 @@ describe('Protocol V2 feature adapter', () => {
     });
     expect(typedCall.mock.calls).toEqual([
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
-      [
-        'DeviceSessionGet',
-        'DeviceSession',
-        {
-          session_id: 'session-a',
-          btc_test_address: 'state-a',
-          seed_domains: [],
-        },
-      ],
+      ['DeviceSessionGet', 'DeviceSession', { session_id: 'session-a' }],
     ]);
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.getInternalState()).toBeUndefined();
@@ -1488,7 +1450,7 @@ describe('Protocol V2 feature adapter', () => {
         { passphrase: 'host hidden wallet', on_device: false },
       ],
       ['DeviceStatusGet', 'DeviceStatus', {}],
-      ['DeviceSessionGet', 'DeviceSession', { seed_domains: [] }],
+      ['DeviceSessionGet', 'DeviceSession', {}],
     ]);
   });
 
@@ -1591,73 +1553,6 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
   });
 
-  test.each([false, true])(
-    'rejects a different Attach PIN wallet when Pro2 lock failure is %s',
-    async lockFails => {
-      const deviceId = 'attach-mismatch-device';
-      const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
-      (device as any).features = normalizeProtocolV2Features(
-        { ...descriptor, protocolType: 'V2' } as any,
-        {
-          status: {
-            device_id: deviceId,
-            unlocked: true,
-            passphrase_enabled: true,
-            attach_to_pin_enabled: true,
-            unlocked_by_attach_to_pin: false,
-          },
-        }
-      );
-      device.passphraseState = 'expected-state';
-
-      const typedCall = jest.fn((request: string) => {
-        if (request === 'ProtocolInfoRequest') return { message: { version: 2 } };
-        if (request === 'DeviceSessionAskPin') return { message: { message: 'PIN verified' } };
-        if (request === 'DeviceStatusGet') {
-          return {
-            message: {
-              device_id: deviceId,
-              unlocked: true,
-              passphrase_enabled: true,
-              attach_to_pin_enabled: true,
-              unlocked_by_attach_to_pin: true,
-            },
-          };
-        }
-        if (request === 'DeviceSessionGet') {
-          return {
-            message: {
-              btc_test_address: 'wrong-attach-state',
-              session_id: 'wrong-attach-session',
-            },
-          };
-        }
-        if (request === 'LockDevice') {
-          if (lockFails) throw new Error('Lock unsupported');
-          return { message: { message: 'Device locked' } };
-        }
-        throw new Error(`Unexpected request: ${request}`);
-      });
-      const promptPassphrase = jest.fn().mockResolvedValue({ attachPinOnDevice: true });
-      (device as any).commands = { typedCall, promptPassphrase };
-
-      await expect(
-        getProtocolV2WalletSession(device, { expectedPassphraseState: 'expected-state' })
-      ).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.DeviceCheckUnlockTypeError,
-      });
-
-      expect(promptPassphrase).not.toHaveBeenCalled();
-      expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-        btc_test_address: 'expected-state',
-        seed_domains: [],
-      });
-      expect(typedCall).toHaveBeenCalledWith('LockDevice', 'Success', {});
-      expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toHaveLength(1);
-      expect(device.getInternalState()).toBeUndefined();
-    }
-  );
-
   test('recovers an expired Attach PIN wallet through the unified wallet selector', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-attach-recovery',
@@ -1714,17 +1609,7 @@ describe('Protocol V2 feature adapter', () => {
       }),
       { cancelDeviceOnReject: false }
     );
-    expect(unlockDevice).toHaveBeenCalledWith(
-      DeviceSessionPinType.AttachToPin,
-      expect.objectContaining({
-        emitUiEvent: false,
-        interaction: expect.objectContaining({
-          phase: 'pin',
-          transition: 'start',
-          protocol: 'V2',
-        }),
-      })
-    );
+    expect(unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin);
     expect(device.getInternalState()).toBe('new-attach-session');
   });
 
@@ -2008,10 +1893,12 @@ describe('Protocol V2 feature adapter', () => {
     expect(getFeatures).not.toHaveBeenCalled();
   });
 
-  test('uses the cached wallet address when the local session is missing', async () => {
+  test('marks an interactive cache miss as a wallet-session recovery', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'expected-state',
@@ -2039,11 +1926,16 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       getProtocolV2WalletSession(device, { expectedPassphraseState: 'expected-state' })
     ).resolves.toMatchObject({ passphraseState: 'expected-state' });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      btc_test_address: 'expected-state',
-      seed_domains: [],
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      {
+        existsAttachPinUser: false,
+        deviceOnly: false,
+        source: 'wallet-session-coordinator',
+        reason: 'session-recovery',
+        expectedPassphraseState: 'expected-state',
+      },
+      { cancelDeviceOnReject: false }
+    );
   });
 
   test('reuses the Pro2 session opened by legacy getPassphraseState on the next App call', async () => {
@@ -2109,15 +2001,8 @@ describe('Protocol V2 feature adapter', () => {
       true
     );
     expect(typedCall.mock.calls).toEqual([
-      [
-        'DeviceSessionGet',
-        'DeviceSession',
-        {
-          session_id: 'session-pro2-app',
-          btc_test_address: 'state-pro2-app',
-          seed_domains: [],
-        },
-      ],
+      ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
+      ['DeviceSessionGet', 'DeviceSession', { session_id: 'session-pro2-app' }],
     ]);
   });
 
@@ -2306,9 +2191,7 @@ describe('Protocol V2 feature adapter', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('does not mark Pro2 passphrase enabled from a main PIN session alone', async () => {
@@ -2386,18 +2269,12 @@ describe('Protocol V2 feature adapter', () => {
     );
 
     expect(device.getInternalState()).toBeUndefined();
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      btc_test_address: 'expected-state',
-      seed_domains: [],
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceStatusGet', 'DeviceStatus', {});
+    expect(typedCall).toHaveBeenNthCalledWith(4, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('useEmptyPassphrase ignores a stale hidden-wallet state during Protocol V2 safety check', async () => {
@@ -2434,15 +2311,6 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
-      passphrase: '',
-      on_device: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
-    expect(typedCall).not.toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', expect.anything());
   });
 
   test('marks fallback features as unavailable when DeviceInfo is missing', () => {
@@ -2813,9 +2681,7 @@ describe('Protocol V2 feature adapter', () => {
         timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
       }
     );
-    expect(typedCall).toHaveBeenNthCalledWith(2, 'ProtocolInfoRequest', 'ProtocolInfo', {
-      eventless_wallet_session: true,
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'ProtocolInfoRequest', 'ProtocolInfo', {});
     expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceStatusGet', 'DeviceStatus', {});
   });
 
@@ -2853,9 +2719,7 @@ describe('Protocol V2 feature adapter', () => {
       }),
       expect.anything()
     );
-    expect(typedCall).toHaveBeenNthCalledWith(2, 'ProtocolInfoRequest', 'ProtocolInfo', {
-      eventless_wallet_session: true,
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'ProtocolInfoRequest', 'ProtocolInfo', {});
     expect(typedCall).not.toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
     expect(device.features).toMatchObject({
       deviceId: null,
@@ -3121,6 +2985,10 @@ describe('Protocol V2 feature adapter', () => {
           fw: { application: { version: '1.2.4' } },
         },
       })
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2ApplicationInfo,
+      })
       .mockResolvedValueOnce({
         type: 'DeviceStatus',
         message: { init_states: true, unlocked: true },
@@ -3142,7 +3010,7 @@ describe('Protocol V2 feature adapter', () => {
       firmwareVersion: '1.2.4',
       passphraseProtection: null,
     });
-    expect(typedCall).toHaveBeenCalledTimes(5);
+    expect(typedCall).toHaveBeenCalledTimes(6);
     expect(typedCall).toHaveBeenNthCalledWith(
       4,
       'DeviceInfoGet',
@@ -3256,23 +3124,9 @@ describe('Protocol V2 feature adapter', () => {
         status: { init_states: true },
       }
     );
-    const pinOnDevice = jest.fn();
-    device.on(DEVICE.PIN_ON_DEVICE, pinOnDevice);
 
     const features = await device.unlockDevice();
 
-    expect(pinOnDevice).toHaveBeenCalledWith(
-      device,
-      DeviceSessionPinType.Main,
-      expect.objectContaining({
-        source: 'unlock-coordinator',
-        reason: 'device-unlock',
-        deviceOnly: true,
-      })
-    );
-    expect(pinOnDevice.mock.invocationCallOrder[0]).toBeLessThan(
-      typedCall.mock.invocationCallOrder[0]
-    );
     expect(typedCall.mock.calls).toEqual([
       ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.Main }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
@@ -3318,12 +3172,9 @@ describe('Protocol V2 feature adapter', () => {
       throw new Error(`Unexpected request: ${requestType}`);
     });
     (device as any).commands = { typedCall };
-    const pinOnDevice = jest.fn();
-    device.on(DEVICE.PIN_ON_DEVICE, pinOnDevice);
 
-    await device.unlockDevice(DeviceSessionPinType.Main, { emitUiEvent: false });
+    await device.unlockDevice();
 
-    expect(pinOnDevice).not.toHaveBeenCalled();
     expect(typedCall.mock.calls).toEqual([
       ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.Main }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
@@ -3726,15 +3577,6 @@ describe('API compatibility handling', () => {
 
 describe('Protocol V2 firmware update targets', () => {
   const OKPP_HEADER_SIZE = 0x52a0;
-  let forceReloadDataSpy: jest.SpyInstance<Promise<void>, []>;
-
-  beforeEach(() => {
-    forceReloadDataSpy = jest.spyOn(DataManager, 'forceReloadData').mockResolvedValue(undefined);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
 
   const buildOkppHeader = ({
     type = 'RESC',
@@ -3875,7 +3717,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('enters Protocol V2 bootloader before upload', async () => {
+  test('delegates Protocol V2 mode transition to the phase executor', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -3910,7 +3752,7 @@ describe('Protocol V2 firmware update targets', () => {
 
     await method.run();
 
-    expect((method as any).enterProtocolV2BootloaderMode).toHaveBeenCalledTimes(1);
+    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
       fwBinaryMap: [
         {
@@ -3923,68 +3765,6 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('enters Protocol V2 bootloader before reading and downloading remote resources', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-        targetsToUpdate: ['resource'],
-      },
-    });
-    method.init();
-
-    (method as any).device = stubDevice({
-      originalDescriptor: { id: 'usb-id', path: 'app-path', protocolType: 'V2' },
-      features: {
-        deviceType: 'pro2',
-        firmwareVersion: '1.0.0',
-        mode: 'normal',
-        bootloaderMode: false,
-        capabilities: [],
-      },
-      isBootloader: () => false,
-      isRomloader: () => false,
-    });
-    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
-    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue({
-      bootloaderBinary: null,
-      fwBinaryMap: [],
-      installItems: [],
-    });
-
-    const order: string[] = [];
-    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockImplementation(() => {
-      order.push('enter-bootloader');
-      return Promise.resolve(true);
-    });
-    (method as any).prepareProtocolV2ResourceBundles = jest.fn().mockImplementation(() => {
-      order.push('prepare-resources');
-      return Promise.resolve([
-        {
-          name: 'images.okpkg',
-          binary: new Uint8Array([1]).buffer,
-          devicePath: 'vol0:/bundles/images/images.okpkg',
-        },
-      ]);
-    });
-    (method as any).executeProtocolV2Update = jest.fn().mockImplementation(() => {
-      order.push('execute-update');
-      return Promise.resolve();
-    });
-    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
-    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
-      bootloaderVersion: '1.0.0',
-      bleVersion: '1.0.0',
-      firmwareVersion: '1.0.0',
-    });
-    method.postTipMessage = jest.fn();
-
-    await method.run();
-
-    expect(order).toEqual(['enter-bootloader', 'prepare-resources', 'execute-update']);
-  });
-
   test('reboots Protocol V2 normal-mode device to bootloader before transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4034,33 +3814,6 @@ describe('Protocol V2 firmware update targets', () => {
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
   });
 
-  test('keeps Protocol V2 bootloader active before firmware transfer', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-      },
-    });
-    (method as any).device = stubDevice({
-      originalDescriptor: { id: 'usb-id', path: 'bootloader-path', protocolType: 'V2' },
-      features: {
-        deviceType: 'pro2',
-        mode: 'bootloader',
-        bootloaderMode: true,
-        capabilities: [],
-      },
-      isBootloader: () => true,
-      isRomloader: () => false,
-    });
-    (method as any).protocolV2Reboot = jest.fn();
-    method.postTipMessage = jest.fn();
-
-    await expect((method as any).enterProtocolV2BootloaderMode()).resolves.toBe(false);
-
-    expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
-    expect(method.postTipMessage).not.toHaveBeenCalledWith('AutoRebootToBootloader');
-  });
-
   test('keeps Protocol V2 romloader active before firmware transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4113,9 +3866,6 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
-    const prepareResourceBundles = jest
-      .spyOn(method as any, 'prepareProtocolV2ResourceBundles')
-      .mockResolvedValue(undefined);
     (method as any).protocolV2Reboot = jest.fn();
     (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
     (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
@@ -4128,7 +3878,6 @@ describe('Protocol V2 firmware update targets', () => {
 
     await method.run();
 
-    expect(prepareResourceBundles).not.toHaveBeenCalled();
     expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
       bootloaderBinary: null,
@@ -4211,10 +3960,7 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => commands,
       mainId: 'usb-path',
     });
-    const cachedDevice = {
-      getConnectId: () => 'usb-path',
-      getCurrentSerialNo: () => '',
-    };
+    const cachedDevice = { getConnectId: () => 'usb-path' };
     const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
       devices: {},
       deviceList: [cachedDevice],
@@ -4231,259 +3977,83 @@ describe('Protocol V2 firmware update targets', () => {
     expect(initialize).not.toHaveBeenCalled();
   });
 
-  test('selects the matching physical device from multiple Protocol V2 USB reconnect candidates', async () => {
+  test('reuses an acquired Protocol V2 USB session while polling reconnect readiness', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const commands = { disposed: true, mainId: '' };
-    const updateFromCache = jest.fn();
+    const commands = { disposed: false, mainId: 'usb-session' };
+    const acquire = jest.fn().mockResolvedValue(undefined);
     const device = stubDevice({
-      originalDescriptor: { id: 'old-usb-id', path: 'old-usb-path', protocolType: 'V2' },
+      originalDescriptor: {
+        id: 'usb-id',
+        path: 'usb-path',
+        session: 'usb-session',
+        protocolType: 'V2',
+      },
       deviceConnector: {
         enumerate: jest.fn().mockResolvedValue({
           descriptors: [
-            { id: 'usb-a', path: 'usb-a', protocolType: 'V2' },
-            { id: 'usb-b', path: 'usb-b', protocolType: 'V2' },
+            {
+              id: 'usb-id',
+              path: 'usb-path',
+              session: 'usb-session',
+              protocolType: 'V2',
+            },
           ],
         }),
       },
-      updateFromCache,
-      hasDeviceAcquire: jest.fn(() => false),
-      acquire: jest.fn().mockResolvedValue(undefined),
+      updateDescriptor: jest.fn(),
+      updateFromCache: jest.fn(),
+      hasDeviceAcquire: jest.fn(() => true),
+      acquire,
       commands,
       getCommands: () => commands,
-      mainId: 'old-usb-path',
+      mainId: 'usb-session',
     });
-    const otherDevice = {
-      getConnectId: () => 'usb-a',
-      getCurrentSerialNo: () => 'PRO2-PHYSICAL-A',
-    };
-    const expectedDevice = {
-      getConnectId: () => 'usb-b',
-      getCurrentSerialNo: () => 'PRO2-PHYSICAL-B',
-    };
     const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
       devices: {},
-      deviceList: [otherDevice, expectedDevice],
+      deviceList: [{ getConnectId: () => 'usb-path' }],
     } as any);
     (method as any).device = device;
-    (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-B';
 
     try {
       await (method as any).reconnectProtocolV2Device();
+      await (method as any).reconnectProtocolV2Device();
     } finally {
       getDevices.mockRestore();
     }
 
-    expect(updateFromCache).toHaveBeenCalledWith(expectedDevice);
+    expect(acquire).not.toHaveBeenCalled();
+    expect(device.hasDeviceAcquire).toHaveBeenCalledTimes(2);
   });
 
-  test('rejects ambiguous Protocol V2 USB reconnect candidates without an identity match', async () => {
+  test('stops final reconnect polling immediately when firmware changes device identity', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const updateFromCache = jest.fn();
-    const device = stubDevice({
-      originalDescriptor: { id: 'old-usb-id', path: 'old-usb-path', protocolType: 'V2' },
-      deviceConnector: {
-        enumerate: jest.fn().mockResolvedValue({
-          descriptors: [
-            { id: 'usb-a', path: 'usb-a', protocolType: 'V2' },
-            { id: 'usb-b', path: 'usb-b', protocolType: 'V2' },
-          ],
-        }),
+    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceInfo',
+      message: {
+        hw: { serial_no: 'PR2SERIAL' },
+        fw: { application: { version: '1.0.0' } },
       },
-      updateFromCache,
-    });
-    const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
-      devices: {},
-      deviceList: [
-        {
-          getConnectId: () => 'usb-a',
-          getCurrentSerialNo: () => 'PRO2-PHYSICAL-A',
-        },
-        {
-          getConnectId: () => 'usb-b',
-          getCurrentSerialNo: () => 'PRO2-PHYSICAL-B',
-        },
-      ],
-    } as any);
-    (method as any).device = device;
-    (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-C';
-
-    try {
-      await expect((method as any).reconnectProtocolV2Device()).rejects.toBeDefined();
-    } finally {
-      getDevices.mockRestore();
-    }
-
-    expect(updateFromCache).not.toHaveBeenCalled();
-  });
-
-  test('allows a single Protocol V2 USB reconnect candidate when its physical serial is unavailable', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-      },
-    });
-    const commands = { disposed: true, mainId: '' };
-    const updateFromCache = jest.fn();
-    const device = stubDevice({
-      originalDescriptor: { id: 'old-usb-id', path: 'old-usb-path', protocolType: 'V2' },
-      deviceConnector: {
-        enumerate: jest.fn().mockResolvedValue({
-          descriptors: [{ id: 'usb-a', path: 'usb-a', protocolType: 'V2' }],
-        }),
-      },
-      updateFromCache,
-      hasDeviceAcquire: jest.fn(() => false),
-      acquire: jest.fn().mockResolvedValue(undefined),
-      commands,
-      getCommands: () => commands,
-      mainId: 'old-usb-path',
-    });
-    const candidate = {
-      getConnectId: () => 'usb-a',
-      getCurrentSerialNo: () => '',
-    };
-    const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
-      devices: {},
-      deviceList: [candidate],
-    } as any);
-    (method as any).device = device;
-    (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-A';
-
-    try {
-      await (method as any).reconnectProtocolV2Device();
-    } finally {
-      getDevices.mockRestore();
-    }
-
-    expect(updateFromCache).toHaveBeenCalledWith(candidate);
-  });
-
-  test('rejects a single Protocol V2 USB reconnect candidate with a different physical serial', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-      },
-    });
-    const updateFromCache = jest.fn();
-    const device = stubDevice({
-      originalDescriptor: { id: 'old-usb-id', path: 'old-usb-path', protocolType: 'V2' },
-      deviceConnector: {
-        enumerate: jest.fn().mockResolvedValue({
-          descriptors: [{ id: 'usb-a', path: 'usb-a', protocolType: 'V2' }],
-        }),
-      },
-      updateFromCache,
-    });
-    const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
-      devices: {},
-      deviceList: [
-        {
-          getConnectId: () => 'usb-a',
-          getCurrentSerialNo: () => 'PRO2-PHYSICAL-A',
-        },
-      ],
-    } as any);
-    (method as any).device = device;
-    (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-B';
-
-    try {
-      await expect((method as any).reconnectProtocolV2Device()).rejects.toBeDefined();
-    } finally {
-      getDevices.mockRestore();
-    }
-
-    expect(updateFromCache).not.toHaveBeenCalled();
-  });
-
-  test('reuses an acquired Protocol V2 USB session while polling reconnect readiness', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-      },
-    });
-    const commands = { disposed: false, mainId: 'usb-session' };
-    const acquire = jest.fn().mockResolvedValue(undefined);
-    const device = stubDevice({
-      originalDescriptor: {
-        id: 'usb-id',
-        path: 'usb-path',
-        session: 'usb-session',
-        protocolType: 'V2',
-      },
-      deviceConnector: {
-        enumerate: jest.fn().mockResolvedValue({
-          descriptors: [
-            {
-              id: 'usb-id',
-              path: 'usb-path',
-              session: 'usb-session',
-              protocolType: 'V2',
-            },
-          ],
-        }),
-      },
-      updateDescriptor: jest.fn(),
-      updateFromCache: jest.fn(),
-      hasDeviceAcquire: jest.fn(() => true),
-      acquire,
-      commands,
-      getCommands: () => commands,
-      mainId: 'usb-session',
-    });
-    const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
-      devices: {},
-      deviceList: [{ getConnectId: () => 'usb-path' }],
-    } as any);
-    (method as any).device = device;
-
-    try {
-      await (method as any).reconnectProtocolV2Device();
-      await (method as any).reconnectProtocolV2Device();
-    } finally {
-      getDevices.mockRestore();
-    }
-
-    expect(acquire).not.toHaveBeenCalled();
-    expect(device.hasDeviceAcquire).toHaveBeenCalledTimes(2);
-  });
-
-  test('stops final reconnect polling immediately when firmware changes device identity', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-      },
-    });
-    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceInfo',
-      message: {
-        hw: { serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '1.0.0' } },
-      },
-    });
-    (method as any).protocolV2ExpectedSerialNumber = 'expected-serial';
-    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
-    (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall }),
-      probeProtocolV2RuntimeState: jest.fn().mockResolvedValue({
-        deviceId: 'changed-device',
-        mode: 'normal',
-        bootloaderMode: false,
-      }),
+    });
+    (method as any).protocolV2ExpectedSerialNumber = 'expected-serial';
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      probeProtocolV2RuntimeState: jest.fn().mockResolvedValue({
+        deviceId: 'changed-device',
+        mode: 'normal',
+        bootloaderMode: false,
+      }),
     });
 
     await expect((method as any).waitForProtocolV2ReconnectAndFeatures(60_000)).rejects.toThrow(
@@ -4565,9 +4135,9 @@ describe('Protocol V2 firmware update targets', () => {
     const typedCall = jest
       .fn()
       .mockRejectedValue(
-        new DOMException(
-          "Failed to execute 'open' on 'USBDevice': The device was disconnected",
-          'NotFoundError'
+        Object.assign(
+          new Error("Failed to execute 'open' on 'USBDevice': The device was disconnected"),
+          { name: 'NotFoundError' }
         )
       );
 
@@ -4748,6 +4318,77 @@ describe('Protocol V2 firmware update targets', () => {
     expect((method as any).probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
   });
 
+  test('rejects a finished target whose payload version conflicts with the plan', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        expectedTargetVersions: {
+          app_v1: '2.0.0',
+        },
+      },
+    });
+    method.init();
+    method.postProgressMessage = jest.fn();
+
+    expect(() =>
+      (method as any).assertProtocolV2TargetStatus(
+        [{ target_id: 4, status: 2, payload_version: 0x010000 }],
+        new Set([4])
+      )
+    ).toThrow('expected 131072');
+  });
+
+  test('does not fail a completed multi-app install when final app versions are unobservable', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        targetsToUpdate: ['app_v1', 'app_v2'],
+        expectedTargetVersions: {
+          app_v1: '1.0.0',
+          app_v2: '2.0.0',
+        },
+      },
+    });
+    method.init();
+    (method as any).protocolV2LatestFinalFeatures = {
+      major_version: 3,
+      minor_version: 0,
+      patch_version: 0,
+    };
+    (method as any).protocolV2FinalStatusVerified = true;
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
+  });
+
+  test('rejects unobservable final versions after the status endpoint fallback', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        targetsToUpdate: ['app_v1', 'app_v2'],
+        expectedTargetVersions: {
+          app_v1: '1.0.0',
+          app_v2: '2.0.0',
+        },
+      },
+    });
+    method.init();
+    (method as any).protocolV2LatestFinalFeatures = {
+      major_version: 3,
+      minor_version: 0,
+      patch_version: 0,
+    };
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).toThrow(
+      'has no observable final version after status fallback'
+    );
+  });
+
   test('polls target status after update ACK and finishes when all targets complete', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4824,7 +4465,7 @@ describe('Protocol V2 firmware update targets', () => {
     ).toBe(true);
 
     (method.postProgressMessage as jest.Mock).mockClear();
-    expect(
+    expect(() =>
       (method as any).assertProtocolV2TargetStatus(
         [
           { target_id: 4, status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED' },
@@ -4832,8 +4473,8 @@ describe('Protocol V2 firmware update targets', () => {
         ],
         new Set([4, 10])
       )
-    ).toBe(false);
-    expect(method.postProgressMessage).toHaveBeenCalledWith(50, 'installingFirmware');
+    ).toThrow('Protocol V2 install status conflicts with target 4');
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalledWith(100, 'installingFirmware');
 
     expect(
@@ -4937,10 +4578,14 @@ describe('Protocol V2 firmware update targets', () => {
     const writtenPaths: string[] = [];
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockImplementation(params => {
+    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockImplementation(params => {
       writtenPaths.push(params.filePath);
-      return Number(params.processedSize ?? 0) + Number(params.payload.byteLength);
+      return Number(params.processedSize ?? 0) + Number(params.source.size);
     });
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({});
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
@@ -4980,10 +4625,12 @@ describe('Protocol V2 firmware update targets', () => {
       'vol0:/coprocessor.bin',
       1
     );
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(1);
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(2);
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(1, {
+      targets: [{ target_id: 3, path: 'vol0:/bootloader.bin' }],
+    });
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(2, {
       targets: [
-        { target_id: 3, path: 'vol0:/bootloader.bin' },
         { target_id: 6, path: 'vol0:/coprocessor.bin' },
         { target_id: 7, path: 'vol0:/se01.bin' },
         { target_id: 4, path: 'vol0:/application_p1.bin' },
@@ -4993,7 +4640,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect((method as any).waitForProtocolV2FirmwareUpdateComplete).toHaveBeenCalled();
   });
 
-  test('announces one transfer when syncing resource bundles and staging firmware', async () => {
+  test('announces separate resource and component transfer phases', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5003,11 +4650,14 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest
+    (method as any).protocolV2SourceUpdateProcess = jest
       .fn()
       .mockImplementation(params =>
-        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
+        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.source.size))
       );
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
@@ -5027,21 +4677,22 @@ describe('Protocol V2 firmware update targets', () => {
         {
           fileName: 'application_p1.bin',
           binary: new Uint8Array([3]).buffer,
-          targetId: 3,
+          targetId: 4,
         },
       ],
     });
 
-    expect(method.postTipMessage).toHaveBeenCalledTimes(2);
+    expect(method.postTipMessage).toHaveBeenCalledTimes(3);
     expect(method.postTipMessage).toHaveBeenNthCalledWith(1, 'StartTransferData');
-    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'ConfirmOnDevice');
-    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenNthCalledWith(
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'StartTransferData');
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(3, 'ConfirmOnDevice');
+    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenNthCalledWith(
       1,
-      expect.objectContaining({ processedSize: 0, totalSize: 3 })
+      expect.objectContaining({ processedSize: 0, totalSize: 2 })
     );
-    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenNthCalledWith(
+    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenNthCalledWith(
       2,
-      expect.objectContaining({ processedSize: 2, totalSize: 3 })
+      expect.objectContaining({ processedSize: 0, totalSize: 1 })
     );
   });
 
@@ -5055,7 +4706,8 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
     (method as any).device = stubDevice({
       getCommands: () => ({
         typedCall: jest.fn().mockResolvedValue({
@@ -5101,11 +4753,14 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest
+    (method as any).protocolV2SourceUpdateProcess = jest
       .fn()
       .mockImplementation(params =>
-        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
+        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.source.size))
       );
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
@@ -5320,42 +4975,33 @@ describe('Protocol V2 firmware update targets', () => {
     getFirmwareLatestReleaseSpy.mockRestore();
   });
 
-  test('does not download Pro2 firmware components that App did not select', async () => {
+  test('maps remote Pro2 resource bundles to direct-write descriptors', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
+        targetsToUpdate: ['resource'],
       },
     });
     method.init();
 
-    const getSysResourceBinarySpy = jest
-      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
-      .mockResolvedValue({ binary: new Uint8Array([1]).buffer });
     const getFirmwareLatestReleaseSpy = jest
       .spyOn(DataManager, 'getFirmwareLatestRelease')
       .mockReturnValue({
         required: false,
         version: [1, 0, 0],
-        url: 'https://example.com/applicationP1.pp.bin',
-        bootloaderVersion: [1, 0, 0],
-        upgradeType: 'payload-package-set',
-        installOrder: ['bootloader', 'applicationP1', 'applicationP2'],
-        components: {
-          bootloader: {
-            target: 'BOOTLOADER',
-            url: 'https://example.com/bootloader.pp.bin',
-          },
-          applicationP1: {
-            target: 'APPLICATION_P1',
-            url: 'https://example.com/applicationP1.pp.bin',
-          },
-          applicationP2: {
-            target: 'APPLICATION_P2',
-            url: 'https://example.com/applicationP2.pp.bin',
+        url: '',
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://example.com/images.okpkg',
+            devicePath: 'VOL0:/resource/images/images.okpkg',
+            version: [2, 0, 0],
+            payloadHash: 'ab'.repeat(64),
+            headerHash: 'cd'.repeat(64),
           },
-        },
+        ],
         fingerprint: '',
         changelog: {
           'zh-CN': '',
@@ -5363,53 +5009,187 @@ describe('Protocol V2 firmware update targets', () => {
         },
       });
 
-    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+    const bundles = (method as any).prepareProtocolV2ResourceBundles('universal', {
       deviceType: 'pro2',
       firmwareVersion: '1.0.0',
-      bootloaderVersion: '1.0.0',
       capabilities: [],
     });
 
-    expect(remoteBinaries).toEqual({
-      bootloaderBinary: null,
-      fwBinaryMap: [],
-      installItems: [],
-    });
-    expect(getSysResourceBinarySpy).not.toHaveBeenCalled();
+    expect(bundles).toEqual([
+      {
+        name: 'images',
+        binary: expect.any(ArrayBuffer),
+        devicePath: 'vol0:/resource/images/images.okpkg',
+        url: 'https://example.com/images.okpkg',
+        version: [2, 0, 0],
+        payloadHash: 'ab'.repeat(64),
+        headerHash: 'cd'.repeat(64),
+      },
+    ]);
+    expect(bundles[0].binary.byteLength).toBe(0);
 
-    getSysResourceBinarySpy.mockRestore();
     getFirmwareLatestReleaseSpy.mockRestore();
   });
 
-  test('uses Pro2 remote components when firmwareUpdateV4 has no explicit binaries', async () => {
+  test('rejects remote RESC bundle paths before download or bootloader entry', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
+        targetsToUpdate: ['resource'],
       },
     });
     method.init();
     (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
 
-    const remoteBinaries = {
-      bootloaderBinary: new Uint8Array([1]).buffer,
-      fwBinaryMap: [
-        {
-          fileName: 'application_p1.bin',
-          binary: new Uint8Array([2]).buffer,
-          targetId: 3,
+    const getSysResourceBinarySpy = jest.spyOn(firmwareBinaryApi, 'getSysResourceBinary');
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://example.com/images.okpkg',
+            devicePath: 'vol0:/resource/../images.okpkg',
+          },
+        ],
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
         },
-      ],
-    };
+      });
 
     (method as any).device = stubDevice({
       originalDescriptor: { protocolType: 'V2' },
-      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
+      features: { deviceType: 'pro2', firmwareVersion: '1.0.0', capabilities: [] },
     });
-    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue(remoteBinaries);
-    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(true);
-    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
+    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue({
+      bootloaderBinary: null,
+      fwBinaryMap: [],
+    });
+    (method as any).enterProtocolV2BootloaderMode = jest.fn();
+    method.postTipMessage = jest.fn();
+
+    await expect(method.run()).rejects.toThrow('resourceBundles[0].devicePath');
+    expect(getSysResourceBinarySpy).not.toHaveBeenCalled();
+    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
+
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('rejects prepared RESC bundle paths before opening an artifact source', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const openPreparedSource = jest.fn();
+    (method as any).params = {
+      targetsToUpdate: ['resource'],
+      resourceBundleArtifacts: [
+        {
+          name: 'images',
+          artifact: {
+            artifactRef: `fw:${'a'.repeat(64)}`,
+            size: 1,
+            sha256: 'a'.repeat(64),
+          },
+        },
+      ],
+    };
+    (method as any).openProtocolV2PreparedSource = openPreparedSource;
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://example.com/images.okpkg',
+            devicePath: 'vol0:/resource/../images.okpkg',
+          },
+        ],
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    await expect(
+      (method as any).prepareProtocolV2ResourceSources('universal', {
+        deviceType: 'pro2',
+      })
+    ).rejects.toThrow('resourceBundles[].devicePath');
+    expect(openPreparedSource).not.toHaveBeenCalled();
+
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('downloads and validates remote RESC bundles before entering bootloader', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['resource'],
+      },
+    });
+    method.init();
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+
+    const order: string[] = [];
+    const resourceBinary = buildOkppHeader().buffer as ArrayBuffer;
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockImplementation(() => {
+        order.push('download');
+        return Promise.resolve({ binary: resourceBinary });
+      });
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://example.com/images.okpkg',
+            devicePath: '  VOL0:/resource/images/images.okpkg  ',
+          },
+        ],
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    (method as any).device = stubDevice({
+      originalDescriptor: { protocolType: 'V2' },
+      features: { deviceType: 'pro2', firmwareVersion: '1.0.0', capabilities: [] },
+    });
+    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue({
+      bootloaderBinary: null,
+      fwBinaryMap: [],
+    });
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockImplementation(() => {
+      order.push('bootloader');
+      return Promise.resolve(true);
+    });
+    const executeProtocolV2UpdateSpy = jest.spyOn(method as any, 'executeProtocolV2Update');
+    (method as any).executeProtocolV2TransferPhase = jest.fn().mockResolvedValue(undefined);
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue(undefined);
     (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
       bootloaderVersion: '1.0.0',
@@ -5420,37 +5200,208 @@ describe('Protocol V2 firmware update targets', () => {
 
     await method.run();
 
-    expect(forceReloadDataSpy).toHaveBeenCalledTimes(1);
-    expect((method as any).prepareRemoteProtocolV2Binaries).toHaveBeenCalledTimes(1);
-    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
-      bootloaderBinary: remoteBinaries.bootloaderBinary,
-      fwBinaryMap: remoteBinaries.fwBinaryMap,
+    expect(order).toEqual(['download', 'bootloader']);
+    expect(executeProtocolV2UpdateSpy).toHaveBeenCalledWith({
+      bootloaderBinary: null,
+      fwBinaryMap: [],
+      resourceBundles: [
+        {
+          name: 'images',
+          binary: resourceBinary,
+          devicePath: 'vol0:/resource/images/images.okpkg',
+          url: 'https://example.com/images.okpkg',
+        },
+      ],
     });
+
+    executeProtocolV2UpdateSpy.mockRestore();
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
   });
 
-  test('stops a remote update before reboot when the latest config cannot be refreshed', async () => {
+  test('rejects a remote RESC bundle without an OKPP header when metadata is absent', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    method.init();
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockResolvedValue({ binary: new Uint8Array([1, 2, 3]).buffer });
+
+    await expect(
+      (method as any).materializeProtocolV2ResourceBundles([
+        {
+          name: 'images',
+          binary: new ArrayBuffer(0),
+          devicePath: 'vol0:/resource/images/images.okpkg',
+          url: 'https://example.com/images.okpkg',
+        },
+      ])
+    ).rejects.toThrow('Invalid Protocol V2 RESC bundle header: images');
+
+    getSysResourceBinarySpy.mockRestore();
+  });
+
+  test('rejects an empty remote RESC bundle before entering bootloader', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
+        targetsToUpdate: ['resource'],
       },
     });
     method.init();
     (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockResolvedValue({ binary: new ArrayBuffer(0) });
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://example.com/images.okpkg',
+            devicePath: 'vol0:/resource/images/images.okpkg',
+          },
+        ],
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
     (method as any).device = stubDevice({
       originalDescriptor: { protocolType: 'V2' },
-      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
+      features: { deviceType: 'pro2', firmwareVersion: '1.0.0', capabilities: [] },
+    });
+    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue({
+      bootloaderBinary: null,
+      fwBinaryMap: [],
     });
-    forceReloadDataSpy.mockRejectedValue(new Error('latest config unavailable'));
-    (method as any).prepareRemoteProtocolV2Binaries = jest.fn();
     (method as any).enterProtocolV2BootloaderMode = jest.fn();
     method.postTipMessage = jest.fn();
 
-    await expect(method.run()).rejects.toThrow('latest config unavailable');
-
-    expect((method as any).prepareRemoteProtocolV2Binaries).not.toHaveBeenCalled();
+    await expect(method.run()).rejects.toThrow('Protocol V2 RESC bundle is empty: images');
     expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
+
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('does not download Pro2 firmware components that App did not select', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockResolvedValue({ binary: new Uint8Array([1]).buffer });
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: 'https://example.com/applicationP1.pp.bin',
+        bootloaderVersion: [1, 0, 0],
+        upgradeType: 'payload-package-set',
+        installOrder: ['bootloader', 'applicationP1', 'applicationP2'],
+        components: {
+          bootloader: {
+            target: 'BOOTLOADER',
+            url: 'https://example.com/bootloader.pp.bin',
+          },
+          applicationP1: {
+            target: 'APPLICATION_P1',
+            url: 'https://example.com/applicationP1.pp.bin',
+          },
+          applicationP2: {
+            target: 'APPLICATION_P2',
+            url: 'https://example.com/applicationP2.pp.bin',
+          },
+        },
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '1.0.0',
+      bootloaderVersion: '1.0.0',
+      capabilities: [],
+    });
+
+    expect(remoteBinaries).toEqual({
+      bootloaderBinary: null,
+      fwBinaryMap: [],
+      installItems: [],
+    });
+    expect(getSysResourceBinarySpy).not.toHaveBeenCalled();
+
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('uses Pro2 remote components when firmwareUpdateV4 has no explicit binaries', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+
+    const remoteBinaries = {
+      bootloaderBinary: new Uint8Array([1]).buffer,
+      fwBinaryMap: [
+        {
+          fileName: 'application_p1.bin',
+          binary: new Uint8Array([2]).buffer,
+          targetId: 3,
+        },
+      ],
+    };
+
+    (method as any).device = stubDevice({
+      originalDescriptor: { protocolType: 'V2' },
+      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
+    });
+    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue(remoteBinaries);
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(true);
+    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
+      bootloaderVersion: '1.0.0',
+      bleVersion: '0.0.0',
+      firmwareVersion: '1.0.0',
+    });
+    method.postTipMessage = jest.fn();
+
+    await method.run();
+
+    expect((method as any).prepareRemoteProtocolV2Binaries).toHaveBeenCalledTimes(1);
+    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
+      bootloaderBinary: remoteBinaries.bootloaderBinary,
+      fwBinaryMap: remoteBinaries.fwBinaryMap,
+    });
   });
 
   test('keeps explicit Protocol V2 binaries isolated from remote component auto-fill', async () => {
@@ -5578,7 +5529,10 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
+    (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn();
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest.fn();
 
@@ -5594,7 +5548,7 @@ describe('Protocol V2 firmware update targets', () => {
       fwBinaryMap: [],
     });
 
-    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenCalledTimes(1);
     expect((method as any).protocolV2StartFirmwareUpdate).not.toHaveBeenCalled();
     expect((method as any).waitForProtocolV2FirmwareUpdateComplete).not.toHaveBeenCalled();
   });
@@ -5625,12 +5579,19 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
 
-    await (method as any).protocolV2CommonUpdateProcess({
-      payload: new Uint8Array(4097).buffer,
-      filePath: 'vol1:firmware.bin',
-      processedSize: 0,
-      totalSize: 4097,
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(4097).buffer,
     });
+    try {
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
+        filePath: 'vol1:firmware.bin',
+        processedSize: 0,
+        totalSize: 4097,
+      });
+    } finally {
+      await source?.close();
+    }
 
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
     expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 4000]);
@@ -5687,12 +5648,16 @@ describe('Protocol V2 firmware update targets', () => {
     method.postProgressMessage = jest.fn();
 
     try {
-      await (method as any).protocolV2CommonUpdateProcess({
-        payload: new Uint8Array(8001).buffer,
+      const source = await openFirmwareByteSource({
+        binary: new Uint8Array(8001).buffer,
+      });
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
         filePath: 'vol0:/firmware.bin',
         processedSize: 0,
         totalSize: 8001,
       });
+      await source?.close();
     } finally {
       setTimeoutSpy.mockRestore();
     }
@@ -5727,16 +5692,21 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
     method.postTipMessage = jest.fn();
+    (method as any).recoverProtocolV2FileTransfer = jest.fn().mockResolvedValue(undefined);
 
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(4097).buffer,
+    });
     await expect(
-      (method as any).protocolV2WriteWholeFile({
-        payload: new Uint8Array(4097).buffer,
+      (method as any).protocolV2SourceUpdateProcess({
+        source,
         filePath: 'vol0:/firmware.bin',
         processedSize: 0,
         totalSize: 4097,
       })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.EmmcFileWriteFirmwareError });
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    await source?.close();
+    expect(typedCall).toHaveBeenCalledTimes(6);
   });
 
   test('caps native BLE firmware upload chunks below the WebUSB limit', async () => {
@@ -5769,12 +5739,19 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
 
-    await (method as any).protocolV2CommonUpdateProcess({
-      payload: new Uint8Array(1801).buffer,
-      filePath: 'vol1:ble-firmware.bin',
-      processedSize: 0,
-      totalSize: 1801,
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(1801).buffer,
     });
+    try {
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
+        filePath: 'vol1:ble-firmware.bin',
+        processedSize: 0,
+        totalSize: 1801,
+      });
+    } finally {
+      await source?.close();
+    }
 
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
     expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 1800]);
@@ -5891,9 +5868,9 @@ describe('Protocol V2 firmware update method', () => {
     const typedCall = jest
       .fn()
       .mockRejectedValue(
-        new DOMException(
-          "Failed to execute 'open' on 'USBDevice': The device was disconnected",
-          'NotFoundError'
+        Object.assign(
+          new Error("Failed to execute 'open' on 'USBDevice': The device was disconnected"),
+          { name: 'NotFoundError' }
         )
       );
 
@@ -6058,63 +6035,20 @@ describe('Protocol V2 firmware update method', () => {
 });
 
 describe('Protocol V2 firmware reconnect identity', () => {
-  const createResourceFilesystemTypedCall = (
-    stable: Array<{ type: string; size: number; headerHash: string }>,
-    missingTypes: string[] = []
-  ) => {
-    const missing = new Set(missingTypes);
-    const resourceByPath = new Map(
-      stable.map(resource => [
-        PROTOCOL_V2_RESOURCE_DEVICE_PATHS[
-          resource.type as keyof typeof PROTOCOL_V2_RESOURCE_DEVICE_PATHS
-        ],
-        resource,
-      ])
-    );
-    return jest.fn((requestType: string, _responseType: string, payload: Record<string, any>) => {
-      if (requestType === 'ResourceInventoryGet') {
-        throw new Error('ResourceInventoryGet is unavailable on released firmware');
-      }
-      if (requestType === 'FilesystemPathInfoQuery') {
-        const resource = resourceByPath.get(payload.path);
-        const exists = Boolean(resource && !missing.has(resource.type));
-        return {
-          message: {
-            exist: exists,
-            directory: false,
-            size: exists ? resource?.size : 0,
-          },
-        };
-      }
-      if (requestType === 'FilesystemFileRead') {
-        const resource = resourceByPath.get(payload.file.path);
-        if (!resource || missing.has(resource.type)) throw new Error('missing resource');
-        const header = new Uint8Array(0x52a0);
-        const view = new DataView(header.buffer);
-        'OKPP'.split('').forEach((char, index) => {
-          header[index] = char.charCodeAt(0);
-        });
-        'RESC'.split('').forEach((char, index) => {
-          header[0x08 + index] = char.charCodeAt(0);
-        });
-        view.setUint32(0x0c, header.byteLength, true);
-        for (let index = 0; index < resource.headerHash.length / 2; index++) {
-          header[0x240 + index] = Number.parseInt(
-            resource.headerHash.slice(index * 2, index * 2 + 2),
-            16
-          );
-        }
-        const offset = Number(payload.file.offset);
-        const chunkLength = Number(payload.chunk_len);
-        return {
-          message: {
-            data: header.slice(offset, offset + chunkLength),
-          },
-        };
-      }
-      throw new Error(`Unexpected request: ${requestType}`);
+  test('keeps the host plan identity as the V4 reconnect anchor', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'native',
+        expectedDeviceId: 'persisted-device-id',
+      },
     });
-  };
+
+    method.init();
+
+    expect((method as any).params.expectedDeviceId).toBe('persisted-device-id');
+  });
 
   test('rejects a different physical serial before firmware transfer resumes', () => {
     expect(() => assertProtocolV2ReconnectIdentity('expected-serial', 'other-serial')).toThrow(
@@ -6125,10 +6059,16 @@ describe('Protocol V2 firmware reconnect identity', () => {
     ).not.toThrow();
   });
 
-  test('allows reconnect when either physical serial is unavailable', () => {
-    expect(() => assertProtocolV2ReconnectIdentity('expected-serial', undefined)).not.toThrow();
-    expect(() => assertProtocolV2ReconnectIdentity(undefined, 'actual-serial')).not.toThrow();
-    expect(() => assertProtocolV2ReconnectIdentity(undefined, undefined)).not.toThrow();
+  test('fails closed when the physical serial is unavailable', () => {
+    expect(() => assertProtocolV2ReconnectIdentity('expected-serial', undefined)).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotFound })
+    );
+    expect(() => assertProtocolV2ReconnectIdentity(undefined, 'actual-serial')).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotFound })
+    );
+    expect(() => assertProtocolV2ReconnectIdentity(undefined, undefined)).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotFound })
+    );
   });
 
   test('captures physical identity from active DeviceInfo instead of wallet deviceId', async () => {
@@ -6161,7 +6101,7 @@ describe('Protocol V2 firmware reconnect identity', () => {
     );
   });
 
-  test('allows firmware update startup when DeviceInfo has no physical serial', async () => {
+  test('rejects firmware update startup when DeviceInfo has no physical serial', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: { method: 'firmwareUpdateV4' },
@@ -6174,209 +6114,39 @@ describe('Protocol V2 firmware reconnect identity', () => {
       getCommands: () => ({ typedCall }),
     });
 
-    await expect((method as any).captureProtocolV2PhysicalIdentity()).resolves.toBeUndefined();
-    expect((method as any).protocolV2ExpectedSerialNumber).toBeUndefined();
-  });
-
-  test('uses filesystem reads instead of ResourceInventoryGet for resource comparison', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-        targetsToUpdate: ['resource'],
-      },
+    await expect((method as any).captureProtocolV2PhysicalIdentity()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceNotFound,
     });
-    method.init();
-    const stable = ['images', 'animation', 'wallpaper', 'translations', 'roobert', 'noto'].map(
-      (type, index) => ({
-        type,
-        url: `https://example.com/${type}.okpkg`,
-        size: 0x52a0 + index + 1,
-        fileHash: 'a'.repeat(64),
-        headerHash: index.toString(16).padStart(128, '0'),
-      })
-    );
-    const typedCall = createResourceFilesystemTypedCall(stable);
-    (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall }),
-    });
-    const resourcesSpy = jest
-      .spyOn(DataManager, 'getProtocolV2Resources')
-      .mockReturnValue(stable as any);
-    (method as any).downloadProtocolV2Resource = jest.fn();
-
-    await expect((method as any).prepareProtocolV2ResourceBundles()).resolves.toEqual([]);
-    expect(typedCall.mock.calls.some(call => call[0] === 'ResourceInventoryGet')).toBe(false);
-    expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileRead')).toBe(true);
-    expect((method as any).downloadProtocolV2Resource).not.toHaveBeenCalled();
-    resourcesSpy.mockRestore();
   });
 
-  test('downloads only changed resources from loader inventory', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: { method: 'firmwareUpdateV4', platform: 'web', targetsToUpdate: ['resource'] },
-    });
-    method.init();
-    const stable = ['images', 'animation', 'wallpaper', 'translations', 'roobert', 'noto'].map(
-      (type, index) => ({
-        type,
-        url: `https://example.com/${type}.okpkg`,
-        size: 0x52a0 + index + 1,
-        fileHash: 'a'.repeat(64),
-        headerHash: index.toString(16).padStart(128, '0'),
-      })
-    );
-    const typedCall = createResourceFilesystemTypedCall(stable, ['images']);
-    (method as any).device = stubDevice({ getCommands: () => ({ typedCall }) });
-    const resourcesSpy = jest
-      .spyOn(DataManager, 'getProtocolV2Resources')
-      .mockReturnValue(stable as any);
-    (method as any).downloadProtocolV2Resource = jest.fn(resource =>
-      Promise.resolve({
-        name: `${resource.type}.okpkg`,
-        binary: new ArrayBuffer(resource.size),
-        devicePath: `vol0:/${resource.type}.okpkg`,
-      })
-    );
-
-    const bundles = await (method as any).prepareProtocolV2ResourceBundles();
-
-    expect(bundles).toHaveLength(1);
-    expect((method as any).downloadProtocolV2Resource).toHaveBeenCalledWith(stable[0]);
-    resourcesSpy.mockRestore();
-  });
-
-  test('uses filesystem inventory for incremental Bootloader recovery', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: { method: 'firmwareUpdateV4', platform: 'web', targetsToUpdate: ['resource'] },
-    });
-    method.init();
-    const stable = ['images', 'animation', 'wallpaper', 'translations', 'roobert', 'noto'].map(
-      (type, index) => ({
-        type,
-        url: `https://example.com/${type}.okpkg`,
-        size: 0x52a0 + index + 1,
-        fileHash: 'a'.repeat(64),
-        headerHash: index.toString(16).padStart(128, '0'),
-      })
-    );
-    const typedCall = createResourceFilesystemTypedCall(stable, ['images']);
-    (method as any).device = stubDevice({ getCommands: () => ({ typedCall }) });
-    const resourcesSpy = jest
-      .spyOn(DataManager, 'getProtocolV2Resources')
-      .mockReturnValue(stable as any);
-    (method as any).downloadProtocolV2Resource = jest.fn(resource =>
-      Promise.resolve({
-        name: `${resource.type}.okpkg`,
-        binary: new ArrayBuffer(resource.size),
-        devicePath: `vol0:/${resource.type}.okpkg`,
-      })
-    );
-
-    const bundles = await (method as any).prepareProtocolV2ResourceBundles();
-
-    expect(bundles).toHaveLength(1);
-    expect(typedCall.mock.calls.some(call => call[0] === 'ResourceInventoryGet')).toBe(false);
-    expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemPathInfoQuery')).toBe(true);
-    expect((method as any).downloadProtocolV2Resource).toHaveBeenCalledWith(stable[0]);
-    resourcesSpy.mockRestore();
-  });
-
-  const buildBootResourcesHeader = ({
-    type = 'CRAT',
-    payloadHash = 'ab'.repeat(64),
-    headerHash = 'cd'.repeat(64),
-  }: {
-    type?: string;
-    payloadHash?: string;
-    headerHash?: string;
-  } = {}) => {
-    const header = new Uint8Array(0x52a0);
-    const view = new DataView(header.buffer);
-    'OKPP'.split('').forEach((char, index) => {
-      header[index] = char.charCodeAt(0);
-    });
-    type.split('').forEach((char, index) => {
-      header[0x08 + index] = char.charCodeAt(0);
-    });
-    view.setUint32(0x0c, header.byteLength, true);
-    const writeHex = (offset: number, hex: string) => {
-      for (let index = 0; index < hex.length / 2; index++) {
-        header[offset + index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
-      }
-    };
-    writeHex(0x200, payloadHash);
-    writeHex(0x240, headerHash);
-    return header;
-  };
-
-  test('does not resolve boot resources unless the optional target is selected', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: { method: 'firmwareUpdateV4', platform: 'web' },
-    });
-    method.init();
-    const configSpy = jest.spyOn(DataManager, 'getProtocolV2BootResources');
-    const downloadSpy = jest.spyOn(firmwareBinaryApi, 'getSysResourceBinary');
-
-    await expect((method as any).prepareProtocolV2BootResources()).resolves.toBeUndefined();
-
-    expect(configSpy).not.toHaveBeenCalled();
-    expect(downloadSpy).not.toHaveBeenCalled();
-  });
-
-  test('downloads and maps the selected boot resources CRATE target', async () => {
-    const payloadHash = 'ab'.repeat(64);
-    const headerHash = 'cd'.repeat(64);
-    const bytes = buildBootResourcesHeader({ payloadHash, headerHash });
-    const binary = bytes.buffer as ArrayBuffer;
-    const fileHash = Array.from(sha256(bytes), byte => byte.toString(16).padStart(2, '0')).join('');
-    const resource = {
-      required: false as const,
-      target: 'CRATE' as const,
-      url: 'https://example.com/boot-resources.crate.okpkg',
-      size: bytes.byteLength,
-      fileHash,
-      payloadHash,
-      headerHash,
-    };
+  test('uses the BLE read limit when reading an existing firmware bundle header', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
-        platform: 'web',
-        targetsToUpdate: ['boot_resources'],
+        platform: 'native',
+        chunkSize: 1800,
       },
     });
     method.init();
-    jest.spyOn(DataManager, 'getProtocolV2BootResources').mockReturnValue(resource);
-    jest.spyOn(firmwareBinaryApi, 'getSysResourceBinary').mockResolvedValue({ binary });
-
-    await expect((method as any).prepareProtocolV2BootResources()).resolves.toEqual({
-      fileName: 'boot_resources.crate.okpkg',
-      binary,
-      targetId: 1,
-      kind: 'boot_resources',
+    const readChunkLengths: number[] = [];
+    const typedCall = jest.fn((requestType: string, _responseType: string, request: any) => {
+      if (requestType === 'FilesystemPathInfoQuery') {
+        return Promise.resolve({ message: { exist: true, directory: false, size: 0x52a0 } });
+      }
+      if (requestType === 'FilesystemFileRead') {
+        readChunkLengths.push(request.chunk_len);
+        return Promise.resolve({ message: { data: new Uint8Array(request.chunk_len) } });
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
     });
-  });
-
-  test('rejects a non-CRATE manual boot resources package', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-        bootResourcesBinary: buildBootResourcesHeader({ type: 'RESC' }).buffer,
-      },
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
     });
-    method.init();
 
-    await expect((method as any).prepareProtocolV2BootResources()).rejects.toThrow(
-      'Invalid Pro2 boot resources CRATE header'
-    );
+    await expect((method as any).readProtocolV2DeviceFileHeader('bundle.okpp')).resolves.toBeNull();
+    expect(readChunkLengths.length).toBeGreaterThan(1);
+    expect(Math.max(...readChunkLengths)).toBe(900);
   });
 });
 
@@ -6491,257 +6261,338 @@ describe('Protocol V2 protected method execution', () => {
       payload: { method: 'deviceSettings', label: 'My Pro 2' },
     });
 
-    method.init();
-
-    expect(method.protocolV2UiInteraction).toEqual({
-      request: 'button',
-      source: 'method-lifecycle',
-      reason: 'device-management',
-      completion: 'operation-completed',
-      deviceOnly: true,
-      operation: 'change-label',
+    method.init();
+
+    expect(method.protocolV2UiInteraction).toEqual({
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'device-management',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      operation: 'change-label',
+    });
+  });
+
+  test.each([
+    ['deviceInfoGet', DeviceInfoGet],
+    ['deviceStatusGet', DeviceStatusGet],
+  ])('does not auto-unlock the read-only %s method', (_name, MethodClass) => {
+    const method = new MethodClass({
+      id: 1,
+      payload: { method: _name },
+    } as any);
+    method.init();
+
+    expect(method.unlockPolicy).toBe('none');
+  });
+
+  test('unlocks and retries an opted-in Protocol V2 method once', async () => {
+    const calls: string[] = [];
+    const method = {
+      name: 'testBusinessMethod',
+      unlockPolicy: 'retry-on-locked',
+      protocolV2UiInteraction: { reason: 'settings-page' },
+      run: jest
+        .fn()
+        .mockImplementationOnce(() => {
+          calls.push('run-1');
+          return Promise.reject(deviceLockedError());
+        })
+        .mockImplementationOnce(() => {
+          calls.push('run-2');
+          return Promise.resolve({ message: 'ok' });
+        }),
+    };
+    const device = {
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn(() => {
+        calls.push('unlock');
+        return Promise.resolve();
+      }),
+    };
+    const uiCoordinator = {
+      enterMethodInteraction: jest.fn(() => calls.push('method-prompt')),
+      enterUnlockInteraction: jest.fn(() => calls.push('unlock-prompt')),
+      resumeMethodInteraction: jest.fn(() => calls.push('method-prompt')),
+    };
+
+    await expect(
+      runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any)
+    ).resolves.toEqual({ message: 'ok' });
+    expect(calls).toEqual([
+      'method-prompt',
+      'run-1',
+      'unlock-prompt',
+      'unlock',
+      'method-prompt',
+      'run-2',
+    ]);
+  });
+
+  test('restores the expected hidden-wallet session before retrying after unlock', async () => {
+    const calls: string[] = [];
+    const method = {
+      name: 'evmSignMessage',
+      payload: { passphraseState: 'hidden-state' },
+      useDevicePassphraseState: true,
+      unlockPolicy: 'retry-on-locked',
+      run: jest
+        .fn()
+        .mockImplementationOnce(() => {
+          calls.push('run-1');
+          return Promise.reject(deviceLockedError());
+        })
+        .mockImplementationOnce(() => {
+          calls.push('run-2');
+          return Promise.resolve({ message: 'ok' });
+        }),
+    };
+    const typedCall = jest.fn((requestType: string, _responseType: string, request: any) => {
+      if (requestType === 'ProtocolInfoRequest') {
+        calls.push('negotiate-session');
+        return Promise.resolve({ message: { version: 2 } });
+      }
+      if (requestType === 'DeviceSessionGet') {
+        calls.push('resume-hidden-session');
+        expect(request).toEqual({ session_id: 'hidden-session' });
+        return Promise.resolve({
+          message: {
+            session_id: 'hidden-session',
+            btc_test_address: 'hidden-state',
+          },
+        });
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const device = {
+      features: { unlocked: true, passphraseProtection: true },
+      passphraseState: 'hidden-state',
+      commands: { typedCall },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn(() => {
+        calls.push('unlock');
+        return Promise.resolve();
+      }),
+      getCurrentPassphraseProtection: () => true,
+      getInternalState: () => 'hidden-session',
+      clearInternalState: jest.fn(),
+      getCurrentDeviceId: () => 'wallet-device-id',
+      updateInternalState: jest.fn(() => calls.push('validate-hidden-session')),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      message: 'ok',
     });
+    expect(calls).toEqual([
+      'run-1',
+      'unlock',
+      'negotiate-session',
+      'resume-hidden-session',
+      'validate-hidden-session',
+      'run-2',
+    ]);
   });
 
-  test.each([
-    ['deviceInfoGet', DeviceInfoGet],
-    ['deviceStatusGet', DeviceStatusGet],
-  ])('does not auto-unlock the read-only %s method', (_name, MethodClass) => {
-    const method = new MethodClass({
-      id: 1,
-      payload: { method: _name },
-    } as any);
-    method.init();
+  test('does not replay a business method when the hidden-wallet session cannot be restored after unlock', async () => {
+    const initialError = deviceLockedError();
+    const restoreError = new Error('Invalid wallet session');
+    const method = {
+      name: 'evmSignMessage',
+      payload: { passphraseState: 'hidden-state' },
+      useDevicePassphraseState: true,
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn().mockRejectedValueOnce(initialError),
+    };
+    const typedCall = jest.fn((requestType: string) => {
+      if (requestType === 'ProtocolInfoRequest') {
+        return Promise.resolve({ message: { version: 2 } });
+      }
+      if (requestType === 'DeviceSessionGet') {
+        return Promise.reject(restoreError);
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const device = {
+      features: { unlocked: true, passphraseProtection: true },
+      passphraseState: 'hidden-state',
+      commands: { typedCall },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
+      getCurrentPassphraseProtection: () => true,
+      getInternalState: () => 'hidden-session',
+      clearInternalState: jest.fn(),
+      getCurrentDeviceId: () => 'wallet-device-id',
+      updateInternalState: jest.fn(),
+    };
 
-    expect(method.unlockPolicy).toBe('none');
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).rejects.toBe(restoreError);
+    expect(method.run).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.clearInternalState).toHaveBeenCalledTimes(1);
+    expect(device.updateInternalState).not.toHaveBeenCalled();
   });
 
-  test('checks fresh status for a wallet business method without a name allowlist', async () => {
+  test('restores the expected hidden-wallet session after pre-unlock without selecting Attach PIN', async () => {
     const calls: string[] = [];
-    const features = { unlocked: true };
     const method = {
-      name: 'confluxSignMessageCIP23',
-      unlockPolicy: 'none',
+      name: 'evmSignMessage',
+      payload: { passphraseState: 'hidden-state' },
       useDevicePassphraseState: true,
-      protocolV2UiInteraction: { reason: 'address-confirmation' },
+      unlockPolicy: 'retry-on-locked',
       run: jest.fn(() => {
         calls.push('run');
-        return Promise.resolve({ address: '0x1' });
+        return Promise.resolve({ message: 'ok' });
       }),
     };
+    const typedCall = jest.fn((requestType: string, _responseType: string, request: any) => {
+      if (requestType === 'ProtocolInfoRequest') {
+        calls.push('negotiate-session');
+        return Promise.resolve({ message: { version: 2 } });
+      }
+      if (requestType === 'DeviceSessionGet') {
+        calls.push('resume-hidden-session');
+        expect(request).toEqual({ session_id: 'hidden-session' });
+        return Promise.resolve({
+          message: {
+            session_id: 'hidden-session',
+            btc_test_address: 'hidden-state',
+          },
+        });
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const features = {
+      unlocked: false,
+      unlockedAttachPin: true,
+      passphraseProtection: true,
+    };
     const device = {
       features,
-      commands: {
-        typedCall: jest.fn(() => {
-          calls.push('status');
-          return Promise.resolve({ message: { unlocked: true } });
-        }),
-      },
+      passphraseState: 'hidden-state',
+      commands: { typedCall },
       isProtocolV2: () => true,
-      isBootloader: () => false,
-      isRomloader: () => false,
-      updateProtocolV2Status: jest.fn((status: { unlocked?: boolean }) => {
-        features.unlocked = status.unlocked === true;
-        return features;
+      unlockDevice: jest.fn(() => {
+        calls.push('unlock-main');
+        features.unlocked = true;
+        features.unlockedAttachPin = false;
+        return Promise.resolve();
       }),
-      unlockDevice: jest.fn(),
-    };
-    const uiCoordinator = {
-      enterMethodInteraction: jest.fn(() => calls.push('method-prompt')),
-      enterUnlockInteraction: jest.fn(),
+      getCurrentPassphraseProtection: () => true,
+      getInternalState: () => 'hidden-session',
+      clearInternalState: jest.fn(),
+      getCurrentDeviceId: () => 'wallet-device-id',
+      updateInternalState: jest.fn(() => calls.push('validate-hidden-session')),
     };
 
-    await expect(
-      runMethodWithUnlockPolicy(method as any, device as any, {
-        uiCoordinator: uiCoordinator as any,
-      })
-    ).resolves.toEqual({ address: '0x1' });
-
-    expect(calls).toEqual(['status', 'method-prompt', 'run']);
-    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
-    expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(method.run).toHaveBeenCalledTimes(1);
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      message: 'ok',
+    });
+    expect(device.unlockDevice).toHaveBeenCalledWith();
+    expect(calls).toEqual([
+      'unlock-main',
+      'negotiate-session',
+      'resume-hidden-session',
+      'validate-hidden-session',
+      'run',
+    ]);
   });
 
-  test('validates the fresh device identity before starting unlock', async () => {
-    const calls: string[] = [];
-    const identityError = new Error('Unexpected device');
+  test('does not restore a hidden-wallet session for a standard-wallet pre-unlock', async () => {
     const method = {
-      name: 'evmSignMessage',
-      unlockPolicy: 'none',
+      name: 'evmGetAddress',
+      payload: { useEmptyPassphrase: true },
       useDevicePassphraseState: true,
-      run: jest.fn(),
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn().mockResolvedValue({ address: 'standard-wallet-address' }),
     };
-    const features = { unlocked: false };
     const device = {
-      features,
-      commands: {
-        typedCall: jest.fn(() => {
-          calls.push('status');
-          return Promise.resolve({ message: { unlocked: false } });
-        }),
-      },
+      features: { unlocked: false },
+      passphraseState: 'stale-hidden-state',
       isProtocolV2: () => true,
-      isBootloader: () => false,
-      isRomloader: () => false,
-      updateProtocolV2Status: jest.fn(() => features),
-      unlockDevice: jest.fn(),
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
     };
 
-    await expect(
-      runMethodWithUnlockPolicy(method as any, device as any, {
-        afterStatusBeforeUnlock: () => {
-          calls.push('identity');
-          throw identityError;
-        },
-      })
-    ).rejects.toBe(identityError);
-
-    expect(calls).toEqual(['status', 'identity']);
-    expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(method.run).not.toHaveBeenCalled();
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      address: 'standard-wallet-address',
+    });
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(method.run).toHaveBeenCalledTimes(1);
   });
 
-  test('unlocks before business and never replays the callback', async () => {
+  test('refreshes status and unlocks before a protected Protocol V2 method', async () => {
     const calls: string[] = [];
-    const features = { unlocked: true };
     const method = {
-      name: 'evmSignMessage',
+      name: 'deviceSettingsPageShow',
       unlockPolicy: 'unlock-before-run',
-      protocolV2UiInteraction: { reason: 'signing-confirmation' },
+      protocolV2UiInteraction: { reason: 'settings-page' },
       run: jest.fn(() => {
         calls.push('run');
-        return Promise.resolve({ signature: 'signed' });
+        return Promise.resolve({ message: 'ok' });
       }),
     };
+    const features = { unlocked: true };
     const device = {
       features,
       commands: {
         typedCall: jest.fn(() => {
-          calls.push('status');
+          calls.push('refresh-status');
           return Promise.resolve({ message: { unlocked: false } });
         }),
       },
       isProtocolV2: () => true,
-      isBootloader: () => false,
-      isRomloader: () => false,
       updateProtocolV2Status: jest.fn((status: { unlocked?: boolean }) => {
-        features.unlocked = status.unlocked === true;
+        features.unlocked = status.unlocked ?? features.unlocked;
         return features;
       }),
       unlockDevice: jest.fn(() => {
         calls.push('unlock');
         features.unlocked = true;
-        return Promise.resolve(features);
+        return Promise.resolve();
       }),
     };
     const uiCoordinator = {
       enterMethodInteraction: jest.fn(() => calls.push('method-prompt')),
-      enterUnlockInteraction: jest.fn(() => {
-        calls.push('unlock-prompt');
-        return undefined;
-      }),
+      enterUnlockInteraction: jest.fn(() => calls.push('unlock-prompt')),
+      resumeMethodInteraction: jest.fn(() => calls.push('method-prompt')),
     };
 
     await expect(
-      runMethodWithUnlockPolicy(method as any, device as any, {
-        uiCoordinator: uiCoordinator as any,
-        prepare: () => {
-          calls.push('wallet-session');
-          return Promise.resolve();
-        },
-      })
-    ).resolves.toEqual({ signature: 'signed' });
-
-    expect(calls).toEqual([
-      'status',
-      'unlock-prompt',
-      'unlock',
-      'wallet-session',
-      'method-prompt',
-      'run',
-    ]);
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+      runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any)
+    ).resolves.toEqual({ message: 'ok' });
+    expect(calls).toEqual(['refresh-status', 'unlock-prompt', 'unlock', 'method-prompt', 'run']);
+    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
     expect(method.run).toHaveBeenCalledTimes(1);
+    expect(uiCoordinator.enterMethodInteraction).toHaveBeenCalledTimes(1);
+    expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
   });
 
-  test('fails closed when fresh status does not explicitly report unlocked state', async () => {
-    const method = {
-      name: 'evmGetAddress',
-      unlockPolicy: 'unlock-before-run',
-      run: jest.fn(),
-    };
-    const device = {
-      features: { unlocked: undefined },
-      commands: { typedCall: jest.fn().mockResolvedValue({ message: {} }) },
-      isProtocolV2: () => true,
-      isBootloader: () => false,
-      isRomloader: () => false,
-      updateProtocolV2Status: jest.fn(() => ({ unlocked: undefined })),
-      unlockDevice: jest.fn(),
-    };
-
-    await expect(runMethodWithUnlockPolicy(method as any, device as any)).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.RuntimeError,
-    });
-    expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(method.run).not.toHaveBeenCalled();
-  });
-
-  test('returns a business DeviceLocked error without unlocking or replaying', async () => {
-    const error = deviceLockedError();
+  test('uses refreshed unlocked status instead of a stale locked cache', async () => {
+    const features = { unlocked: false };
     const method = {
-      name: 'evmSignMessage',
+      name: 'deviceSettings',
       unlockPolicy: 'unlock-before-run',
-      run: jest.fn().mockRejectedValue(error),
+      run: jest.fn().mockResolvedValue({ message: 'ok' }),
     };
-    const features = { unlocked: true };
     const device = {
       features,
-      commands: { typedCall: jest.fn().mockResolvedValue({ message: { unlocked: true } }) },
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: true } }),
+      },
       isProtocolV2: () => true,
-      isBootloader: () => false,
-      isRomloader: () => false,
-      updateProtocolV2Status: jest.fn(() => features),
+      updateProtocolV2Status: jest.fn((status: { unlocked?: boolean }) => {
+        features.unlocked = status.unlocked ?? features.unlocked;
+        return features;
+      }),
       unlockDevice: jest.fn(),
     };
 
-    await expect(runMethodWithUnlockPolicy(method as any, device as any)).rejects.toBe(error);
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      message: 'ok',
+    });
     expect(device.unlockDevice).not.toHaveBeenCalled();
     expect(method.run).toHaveBeenCalledTimes(1);
   });
 
-  test('reuses one lightweight preflight context across nested protected methods', async () => {
-    const features = { unlocked: true };
-    const context = createProtocolV2UnlockContext();
-    const firstMethod = {
-      name: 'allNetworkGetAddress',
-      unlockPolicy: 'unlock-before-run',
-      run: jest.fn().mockResolvedValue({ root: true }),
-    };
-    const nestedMethod = {
-      name: 'evmGetAddress',
-      unlockPolicy: 'unlock-before-run',
-      run: jest.fn().mockResolvedValue({ address: '0x1' }),
-    };
-    const device = {
-      features,
-      commands: { typedCall: jest.fn().mockResolvedValue({ message: { unlocked: true } }) },
-      isProtocolV2: () => true,
-      isBootloader: () => false,
-      isRomloader: () => false,
-      updateProtocolV2Status: jest.fn(() => features),
-      unlockDevice: jest.fn(),
-    };
-
-    await runMethodWithUnlockPolicy(firstMethod as any, device as any, { context });
-    await runMethodWithUnlockPolicy(nestedMethod as any, device as any, { context });
-
-    expect(device.commands.typedCall).toHaveBeenCalledTimes(1);
-    expect(firstMethod.run).toHaveBeenCalledTimes(1);
-    expect(nestedMethod.run).toHaveBeenCalledTimes(1);
-  });
-
   test.each(['bootloader', 'romloader'] as const)(
     'skips DeviceStatus and unlock in Protocol V2 %s mode',
     async mode => {
@@ -6759,7 +6610,7 @@ describe('Protocol V2 protected method execution', () => {
         unlockDevice: jest.fn(),
       };
 
-      await expect(runMethodWithUnlockPolicy(method as any, device as any)).resolves.toEqual({
+      await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
         message: 'updating',
       });
       expect(device.commands.typedCall).not.toHaveBeenCalled();
@@ -6768,30 +6619,157 @@ describe('Protocol V2 protected method execution', () => {
     }
   );
 
-  test('keeps Protocol V1 and lock-free methods outside the preflight path', async () => {
+  test('infers a signing interaction before running a Protocol V2 business method', async () => {
+    const method = {
+      name: 'evmSignMessage',
+      params: { message: 'not-exposed-in-event' },
+      payload: {},
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn().mockResolvedValue({ signature: 'test' }),
+    };
+    const device = {
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn(),
+    };
+    const uiCoordinator = {
+      enterMethodInteraction: jest.fn(),
+      enterUnlockInteraction: jest.fn(),
+      resumeMethodInteraction: jest.fn(),
+    };
+
+    await runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any);
+
+    expect(uiCoordinator.enterMethodInteraction).toHaveBeenCalledWith({
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'signing-confirmation',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      operation: 'evmSignMessage',
+    });
+  });
+
+  test('does not unlock a Protocol V1 device or a method without the policy', async () => {
     for (const [isProtocolV2, unlockPolicy] of [
-      [false, 'unlock-before-run'],
+      [false, 'retry-on-locked'],
       [true, 'none'],
     ] as const) {
+      const error = deviceLockedError();
       const method = {
         unlockPolicy,
-        useDevicePassphraseState: false,
-        run: jest.fn().mockResolvedValue({ message: 'ok' }),
+        run: jest.fn().mockRejectedValue(error),
       };
       const device = {
-        commands: { typedCall: jest.fn() },
         isProtocolV2: () => isProtocolV2,
         unlockDevice: jest.fn(),
       };
 
-      await expect(runMethodWithUnlockPolicy(method as any, device as any)).resolves.toEqual({
-        message: 'ok',
-      });
-      expect(device.commands.typedCall).not.toHaveBeenCalled();
+      await expect(runMethodWithUnlockRetry(method as any, device as any)).rejects.toBe(error);
       expect(device.unlockDevice).not.toHaveBeenCalled();
       expect(method.run).toHaveBeenCalledTimes(1);
     }
   });
+
+  test('runs lock-free eventless methods without unlocking or synthesized UI', async () => {
+    const method = {
+      name: 'uploadPortfolio',
+      unlockPolicy: 'none',
+      protocolV2UiMode: 'none',
+      run: jest.fn().mockResolvedValue({ message: 'ok' }),
+    };
+    const device = {
+      features: { unlocked: false },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
+    };
+    const uiCoordinator = {
+      enterMethodInteraction: jest.fn(),
+      enterUnlockInteraction: jest.fn(),
+      resumeMethodInteraction: jest.fn(),
+    };
+
+    await expect(
+      runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any)
+    ).resolves.toEqual({ message: 'ok' });
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+    expect(uiCoordinator.enterMethodInteraction).not.toHaveBeenCalled();
+    expect(uiCoordinator.enterUnlockInteraction).not.toHaveBeenCalled();
+    expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
+  });
+
+  test('does not unlock or replay a lock-free state-changing method after a locked response', async () => {
+    const error = deviceLockedError();
+    const method = {
+      name: 'uploadPortfolio',
+      unlockPolicy: 'none',
+      run: jest.fn().mockRejectedValue(error),
+    };
+    const device = {
+      features: { unlocked: true },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn(),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).rejects.toBe(error);
+    expect(method.run).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+  });
+
+  test('does not retry when unlock fails or when the retry is still locked', async () => {
+    const initialError = deviceLockedError();
+    const unlockError = new Error('PIN cancelled');
+    const unlockFailMethod = {
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn().mockRejectedValue(initialError),
+    };
+    const unlockFailDevice = {
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn().mockRejectedValue(unlockError),
+    };
+    const unlockFailCoordinator = {
+      enterMethodInteraction: jest.fn(),
+      enterUnlockInteraction: jest.fn(),
+      resumeMethodInteraction: jest.fn(),
+    };
+
+    await expect(
+      runMethodWithUnlockRetry(
+        unlockFailMethod as any,
+        unlockFailDevice as any,
+        unlockFailCoordinator as any
+      )
+    ).rejects.toBe(unlockError);
+    expect(unlockFailMethod.run).toHaveBeenCalledTimes(1);
+    expect(unlockFailCoordinator.enterUnlockInteraction).toHaveBeenCalledTimes(1);
+    expect(unlockFailCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
+
+    const retryError = deviceLockedError();
+    const retryFailMethod = {
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn().mockRejectedValueOnce(initialError).mockRejectedValueOnce(retryError),
+    };
+    const retryFailDevice = {
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
+    };
+    const retryFailCoordinator = {
+      enterMethodInteraction: jest.fn(),
+      enterUnlockInteraction: jest.fn(),
+      resumeMethodInteraction: jest.fn(),
+    };
+
+    await expect(
+      runMethodWithUnlockRetry(
+        retryFailMethod as any,
+        retryFailDevice as any,
+        retryFailCoordinator as any
+      )
+    ).rejects.toBe(retryError);
+    expect(retryFailMethod.run).toHaveBeenCalledTimes(2);
+    expect(retryFailDevice.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(retryFailCoordinator.enterUnlockInteraction).toHaveBeenCalledTimes(1);
+    expect(retryFailCoordinator.resumeMethodInteraction).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe('Protocol V2 current low-level methods', () => {
@@ -6923,9 +6901,7 @@ describe('Protocol V2 current low-level methods', () => {
 
     await method.run();
 
-    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
-      eventless_wallet_session: true,
-    });
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {});
   });
 
   test('sends DeviceFactoryInfoSet and DeviceFactoryInfoGet', async () => {