@onekeyfe/hd-core 1.2.0-alpha.98 → 1.2.0

package/__tests__/protocol-v2.test.ts

@@ -1,7 +1,9 @@
-import { EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { Buffer } from 'buffer';
+import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { sha256 } from '@noble/hashes/sha256';
 import { bytesToHex } from '@noble/hashes/utils';
 import JSZip from 'jszip';
+import { encode as encodeJpeg } from 'jpeg-js';
 import {
   DeviceRebootType,
   DeviceSessionPinType,
@@ -123,23 +125,43 @@ jest.mock('../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
+const jpegBase64Cache = new Map<string, string>();
+
+const createJpegBase64 = (width: number, height: number) => {
+  const key = `${width}x${height}`;
+  const cached = jpegBase64Cache.get(key);
+  if (cached) return cached;
+  const rgba = new Uint8Array(width * height * 4).fill(0xff);
+  const value = encodeJpeg({ width, height, data: rgba }, 80).data.toString('base64');
+  jpegBase64Cache.set(key, value);
+  return value;
+};
+
 const createProtocolV2OkppBinary = ({
   version = [1, 2, 3],
+  devicePath = 'vol0:/bundles/images/images.okpkg',
   payloadHashByte = 0x11,
   headerHashByte = 0x22,
 }: {
   version?: [number, number, number];
+  devicePath?: string;
   payloadHashByte?: number;
   headerHashByte?: number;
 } = {}) => {
-  const bytes = new Uint8Array(0x52a0);
+  const headerSize = 0x5f90;
+  const payloadSize = 1;
+  const bytes = new Uint8Array(headerSize + payloadSize);
   bytes.set([0x4f, 0x4b, 0x50, 0x50], 0);
   bytes.set([0x52, 0x45, 0x53, 0x43], 0x08);
   const view = new DataView(bytes.buffer);
-  view.setUint32(0x0c, 0x52a0, true);
+  view.setUint32(0x04, 1, true);
+  view.setUint32(0x0c, headerSize, true);
   view.setUint32(0x10, version[0] * 0x10000 + version[1] * 0x100 + version[2], true);
+  view.setUint32(0x14, payloadSize, true);
+  bytes.set(new TextEncoder().encode(devicePath), 0x6c);
   bytes.fill(payloadHashByte, 0x200, 0x240);
   bytes.fill(headerHashByte, 0x240, 0x280);
+  bytes[headerSize] = 0xaa;
   return bytes.buffer;
 };
 
@@ -160,8 +182,19 @@ const createWalletSessionTypedCall = (
   });
 
 describe('DeviceUploadWallpaper', () => {
+  const wallpaperProtocolInfo = {
+    version: 2,
+    supported_messages: [60412, 60805, 60809],
+  };
+
+  const stubWallpaperDevice = <T extends Record<string, any>>(device: T) =>
+    stubDevice({
+      ...device,
+      ensureProtocolV2RuntimeContext: jest.fn().mockResolvedValue(wallpaperProtocolInfo),
+      refreshProtocolV2SettingsAfterMutation: jest.fn().mockResolvedValue({}),
+    });
+
   test('encodes, uploads and applies a Pro2 wallpaper', async () => {
-    const rgba = new Uint8Array(604 * 1024 * 4).fill(255);
     const typedCall = jest.fn().mockImplementation((request, _response, params) => {
       if (request === 'FilesystemDirMake') return { message: { message: 'directory ready' } };
       if (request === 'FilesystemFileWrite') {
@@ -175,16 +208,21 @@ describe('DeviceUploadWallpaper', () => {
     });
     const method = new DeviceUploadWallpaper({
       id: 1,
-      payload: { method: 'deviceUploadWallpaper', width: 604, height: 1024, rgba },
+      payload: {
+        method: 'deviceUploadWallpaper',
+        jpegBase64: createJpegBase64(604, 1024),
+      },
     });
-    (method as any).device = stubDevice({ commands: { typedCall } });
+    const device = stubWallpaperDevice({ commands: { typedCall } });
+    (method as any).device = device;
     method.postMessage = jest.fn();
 
     method.init();
     const result = await method.run();
 
     expect(method.getSupportedProtocols()).toEqual(['V2']);
-    expect(method.unlockPolicy).toBe('none');
+    expect(method.unlockPolicy).toBe('unlock-before-run');
+    expect(method.protocolV2PreUnlockPinType).toBe(DeviceSessionPinType.Any);
     expect(typedCall).toHaveBeenNthCalledWith(1, 'FilesystemDirMake', 'Success', {
       path: 'vol1:/wallpapers',
     });
@@ -197,6 +235,7 @@ describe('DeviceUploadWallpaper', () => {
     expect(typedCall).toHaveBeenLastCalledWith('DeviceSettingsSet', 'Success', {
       settings: { wallpaper_path: result.path },
     });
+    expect(device.refreshProtocolV2SettingsAfterMutation).toHaveBeenCalledTimes(1);
     expect(typedCall.mock.calls.some(call => call[0] === 'SetWallpaper')).toBe(false);
     expect(result).toMatchObject({ colorFormat: 'RGB565', message: 'wallpaper applied' });
     const fileWriteCallCount = typedCall.mock.calls.filter(
@@ -225,32 +264,82 @@ describe('DeviceUploadWallpaper', () => {
       id: 1,
       payload: {
         method: 'deviceUploadWallpaper',
-        width: 604,
-        height: 1024,
-        rgba: new Uint8Array(604 * 1024 * 4),
+        jpegBase64: createJpegBase64(604, 1024),
       },
     });
-    (method as any).device = stubDevice({ commands: { typedCall } });
+    (method as any).device = stubWallpaperDevice({ commands: { typedCall } });
     method.init();
 
     await expect(method.run()).rejects.toThrow('write failed');
     expect(typedCall.mock.calls.some(call => call[0] === 'DeviceSettingsSet')).toBe(false);
   });
 
+  test('returns success when wallpaper read-back fails after apply', async () => {
+    const typedCall = jest.fn().mockImplementation((request, _response, params) => {
+      if (request === 'FilesystemDirMake') return { message: {} };
+      if (request === 'FilesystemFileWrite') {
+        const file = params.file as { data: Uint8Array; offset: number };
+        return { message: { processed_byte: file.offset + file.data.byteLength } };
+      }
+      if (request === 'DeviceSettingsSet') {
+        return { message: { message: 'wallpaper applied' } };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = new DeviceUploadWallpaper({
+      id: 1,
+      payload: {
+        method: 'deviceUploadWallpaper',
+        jpegBase64: createJpegBase64(604, 1024),
+      },
+    });
+    const device = stubWallpaperDevice({ commands: { typedCall } });
+    device.refreshProtocolV2SettingsAfterMutation.mockRejectedValueOnce(
+      new Error('settings read-back failed')
+    );
+    (method as any).device = device;
+    method.init();
+
+    await expect(method.run()).resolves.toMatchObject({ message: 'wallpaper applied' });
+    expect(device.refreshProtocolV2SettingsAfterMutation).toHaveBeenCalledTimes(1);
+  });
+
   test('rejects unsafe filenames before device communication', () => {
     const method = new DeviceUploadWallpaper({
       id: 1,
       payload: {
         method: 'deviceUploadWallpaper',
-        width: 604,
-        height: 1024,
-        rgba: new Uint8Array(604 * 1024 * 4),
+        jpegBase64: createJpegBase64(604, 1024),
         fileName: '../wallpaper.bin',
       },
     });
 
     expect(() => method.init()).toThrow('fileName');
   });
+
+  test('rejects unsupported firmware before creating or writing files', async () => {
+    const typedCall = jest.fn();
+    const method = new DeviceUploadWallpaper({
+      id: 1,
+      payload: {
+        method: 'deviceUploadWallpaper',
+        jpegBase64: createJpegBase64(604, 1024),
+      },
+    });
+    (method as any).device = stubDevice({
+      commands: { typedCall },
+      ensureProtocolV2RuntimeContext: jest.fn().mockResolvedValue({
+        version: 2,
+        supported_messages: [60805, 60809],
+      }),
+    });
+    method.init();
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
 });
 
 describe('UploadPortfolio', () => {
@@ -266,7 +355,6 @@ describe('UploadPortfolio', () => {
     });
 
   test('writes and applies the portfolio while the device is locked without unlocking', async () => {
-    const packageBytes = new Uint8Array([1, 2, 3]);
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { processed_byte: 3 } })
@@ -282,7 +370,7 @@ describe('UploadPortfolio', () => {
       id: 1,
       payload: {
         method: 'uploadPortfolio',
-        packageBytes,
+        packageBase64: 'AQID',
       },
     });
     (method as any).device = device;
@@ -314,7 +402,7 @@ describe('UploadPortfolio', () => {
       id: 1,
       payload: {
         method: 'uploadPortfolio',
-        packageBytes,
+        packageBase64: 'AQID',
       },
     });
     (method as any).device = stubPortfolioDevice({ commands: { typedCall } });
@@ -362,7 +450,7 @@ describe('UploadPortfolio', () => {
       id: 1,
       payload: {
         method: 'uploadPortfolio',
-        packageBytes: new Uint8Array([1]),
+        packageBase64: 'AQ==',
       },
     });
     (method as any).device = stubPortfolioDevice({ commands: { typedCall } });
@@ -384,7 +472,7 @@ describe('UploadPortfolio', () => {
       id: 1,
       payload: {
         method: 'uploadPortfolio',
-        packageBytes,
+        packageBase64: Buffer.from(packageBytes).toString('base64'),
       },
     });
     method.abortSignal = abortController.signal;
@@ -405,7 +493,7 @@ describe('UploadPortfolio', () => {
       id: 1,
       payload: {
         method: 'uploadPortfolio',
-        packageBytes: new Uint8Array([1]),
+        packageBase64: 'AQ==',
       },
     });
     (method as any).device = stubDevice({
@@ -423,6 +511,18 @@ describe('UploadPortfolio', () => {
     });
     expect(typedCall).not.toHaveBeenCalled();
   });
+
+  test('rejects non-canonical Base64 before device communication', () => {
+    const method = new UploadPortfolio({
+      id: 1,
+      payload: {
+        method: 'uploadPortfolio',
+        packageBase64: 'data:application/octet-stream;base64,AQID',
+      },
+    });
+
+    expect(() => method.init()).toThrow('canonical Base64');
+  });
 });
 
 const descriptor = {
@@ -456,6 +556,10 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
   const d = device as any;
   d.updateState ??= jest.fn();
   d.markProtocolV2Reboot ??= jest.fn();
+  d.setCancelableAction ??= jest.fn();
+  d.clearCancelableAction ??= jest.fn();
+  d.toMessageObject ??= jest.fn(() => ({ connectId: d.originalDescriptor?.id }));
+  d.createProtocolV2UiPhaseMetadata ??= jest.fn(() => undefined);
   d.isProtocolV2 ??= () => d.originalDescriptor?.protocolType === 'V2';
   d.isBootloader ??= () => d.features?.mode === 'bootloader';
   d.isRomloader ??= () => d.features?.mode === 'romloader';
@@ -555,7 +659,7 @@ const protocolV2BootloaderDeviceInfo: ProtocolV2DeviceInfo = {
   hw: {
     serial_no: 'PR9999999999',
   },
-  fw: {
+  main_mcu: {
     bootloader: {
       version: '0.0.1',
     },
@@ -619,8 +723,8 @@ describe('Protocol V2 feature adapter', () => {
     const deviceInfo: ProtocolV2DeviceInfo = {
       protocol_version: 1,
       hw: { serial_no: 'P2-STATIC' },
-      fw: { application: { version: '1.0.0' } },
-      coprocessor: { bt_adv_name: 'Pro2 STATIC' },
+      main_mcu: { application: { version: '1.0.0' } },
+      coprocessor: { bt_adv_name: 'Pro2 A1B2' },
     };
     const deviceStatus: DeviceStatus = {
       device_id: 'P2-DYNAMIC',
@@ -640,7 +744,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(features).toMatchObject({
       deviceId: 'P2-DYNAMIC',
       serialNo: 'P2-STATIC',
-      bleName: 'Pro2 STATIC',
+      bleName: 'Pro 2 A1B2',
       initialized: true,
       unlocked: true,
       passphraseProtection: true,
@@ -663,7 +767,7 @@ describe('Protocol V2 feature adapter', () => {
     const protocolV2 = buildProtocolV2FeaturesPayload({
       deviceInfo: {
         hw: { Device_type: DeviceType.PRO2, serial_no: 'P2-001' },
-        coprocessor: { bt_adv_name: 'Pro 2 BLE' },
+        coprocessor: { bt_adv_name: 'Pro 2 B1E2' },
       },
       deviceStatus: {
         device_id: 'v2-device',
@@ -680,7 +784,7 @@ describe('Protocol V2 feature adapter', () => {
     });
     expect(protocolV2).toMatchObject({
       device_id: 'v2-device',
-      ble_name: 'Pro 2 BLE',
+      ble_name: 'Pro 2 B1E2',
       onekey_device_type: 'PRO2',
       passphrase_protection: true,
     });
@@ -693,7 +797,7 @@ describe('Protocol V2 feature adapter', () => {
         Device_type: DeviceType.PRO2,
         serial_no: 'PR2SERIAL',
       },
-      fw: {
+      main_mcu: {
         romloader: {
           version: '0.1.0',
           build_id: 'rom-build',
@@ -721,7 +825,7 @@ describe('Protocol V2 feature adapter', () => {
           build_id: 'bt-build',
           hash: [12, 13],
         },
-        bt_adv_name: 'Pro2 BLE',
+        bt_adv_name: 'Pro2 B1E2',
       },
       se1: {
         application: {
@@ -761,7 +865,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(features.boardVersion).toBe('0.1.0');
     expect(features.verify?.boardBuildId).toBe('rom-build');
     expect(features.verify?.boardHash).toBe('0102ff');
-    expect(features.bleName).toBe('Pro2 BLE');
+    expect(features.bleName).toBe('Pro 2 B1E2');
     expect(features.bleVersion).toBe('4.5.6');
     expect(features.verify?.bleHash).toBe('0c0d');
     expect(features.se01Version).toBe('7.8.9');
@@ -783,7 +887,7 @@ describe('Protocol V2 feature adapter', () => {
       hw: {
         serial_no: 'PR2BOOT',
       },
-      fw: {
+      main_mcu: {
         bootloader: {
           version: '0.2.0',
         },
@@ -805,7 +909,7 @@ describe('Protocol V2 feature adapter', () => {
     const features = normalizeProtocolV2Features(descriptor as any, {
       protocol_version: 1,
       hw: { serial_no: 'PR2NORMAL' },
-      fw: { bootloader: { version: '0.2.0' } },
+      main_mcu: { bootloader: { version: '0.2.0' } },
     });
 
     expect(features.mode).toBe('normal');
@@ -818,7 +922,7 @@ describe('Protocol V2 feature adapter', () => {
       hw: {
         serial_no: 'PR2ROM',
       },
-      fw: {
+      main_mcu: {
         romloader: {
           version: '1.0.0',
         },
@@ -849,6 +953,34 @@ describe('Protocol V2 feature adapter', () => {
     ).toBeUndefined();
   });
 
+  test('infers legacy Protocol V2 loader mode from firmware image metadata', () => {
+    const legacyProtocolInfo = {
+      version: 1,
+      build_fingerprint: '',
+      supported_messages: [],
+      protobuf_definition: null,
+    };
+
+    expect(
+      getProtocolV2RuntimeMode(legacyProtocolInfo, {
+        main_mcu: { bootloader: { version: '0.2.0' } },
+      })
+    ).toBe('bootloader');
+    expect(
+      getProtocolV2RuntimeMode(legacyProtocolInfo, {
+        main_mcu: { romloader: { version: '1.0.0' } },
+      })
+    ).toBe('romloader');
+    expect(
+      getProtocolV2RuntimeMode(legacyProtocolInfo, {
+        main_mcu: {
+          application: { version: '1.2.3' },
+          bootloader: { version: '0.2.0' },
+        },
+      })
+    ).toBeUndefined();
+  });
+
   test('keeps the Protocol V2 main wallet on the default empty-passphrase context', async () => {
     const features = normalizeProtocolV2Features(descriptor as any);
     features.firmwareVersion = '1.2.3';
@@ -890,6 +1022,7 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'session-1',
       unlockedAttachPin: false,
       resumed: false,
+      walletStatusRefreshed: true,
     });
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
@@ -1153,6 +1286,7 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'main-wallet-session',
       unlockedAttachPin: undefined,
       resumed: false,
+      walletStatusRefreshed: true,
     });
 
     expect(promptPassphrase).toHaveBeenCalled();
@@ -1239,6 +1373,7 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'hidden-after-unlock-session',
       unlockedAttachPin: undefined,
       resumed: false,
+      walletStatusRefreshed: true,
     });
 
     expect(unlockDevice).not.toHaveBeenCalled();
@@ -1912,7 +2047,7 @@ describe('Protocol V2 feature adapter', () => {
       { ...descriptor, protocolType: 'V2' } as any,
       {
         protocol_version: 2,
-        fw: { application: { version: '1.2.3' } },
+        main_mcu: { application: { version: '1.2.3' } },
         se1: { application: { version: '4.5.6' } },
         status: { unlocked: false, passphrase_enabled: false },
       }
@@ -1949,7 +2084,7 @@ describe('Protocol V2 feature adapter', () => {
       deviceInfo: {
         protocol_version: 1,
         hw: { serial_no: 'PR9999999999' },
-        fw: { application: { version: '1.0.0' } },
+        main_mcu: { application: { version: '1.0.0' } },
       },
       deviceStatus: {
         device_id: 'firmware-reconnect-id',
@@ -2314,7 +2449,7 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features = {
       ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
         hw: { serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '4.15.0' } },
+        main_mcu: { application: { version: '4.15.0' } },
         status: { passphrase_enabled: true },
       }),
       unlocked: true,
@@ -2674,9 +2809,9 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(device.toMessageObject()).toMatchObject({
       serialNo: 'PR9999999999',
-      bleName: 'Pro2 6136',
-      name: 'Pro2 6136',
-      label: 'Pro2 6136',
+      bleName: 'Pro 2 6136',
+      name: 'Pro 2 6136',
+      label: 'Pro 2 6136',
     });
     expect(device.features?.label).toBeNull();
   });
@@ -2691,25 +2826,41 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(device.getCurrentDisplayName()).toBe('My Pro 2');
     expect(device.toMessageObject()).toMatchObject({
-      bleName: 'Pro2 6136',
-      name: 'Pro2 6136',
+      bleName: 'Pro 2 6136',
+      name: 'Pro 2 6136',
       label: 'My Pro 2',
     });
   });
 
-  test('syncs Protocol V2 cached features without cached profile', () => {
+  test('syncs Protocol V2 cached features and renegotiates the adopted command channel', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: protocolV2ApplicationInfo });
     const cached = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (cached as any).features = {
       ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
       deviceId: null,
       serialNo: 'CACHED-SERIAL',
     };
+    (cached as any).commands = { typedCall };
 
     const current = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    current.updateState(
+      {
+        raw: { protocolV2ProtocolInfo: protocolV2BootloaderInfo },
+        status: { mode: 'bootloader' },
+      },
+      'initialize'
+    );
     current.updateFromCache(cached);
 
+    await expect(current.ensureProtocolV2RuntimeContext()).resolves.toEqual(
+      protocolV2ApplicationInfo
+    );
+
     expect(current.getCurrentDeviceId()).toBeUndefined();
     expect(current.getCurrentSerialNo()).toBe('CACHED-SERIAL');
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
     expect(current.toMessageObject()).toMatchObject({
       serialNo: 'CACHED-SERIAL',
       uuid: 'CACHED-SERIAL',
@@ -2723,7 +2874,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-          fw: { application: { version: '1.2.3' } },
+          main_mcu: { application: { version: '1.2.3' } },
         },
       }),
     };
@@ -2744,7 +2895,7 @@ describe('Protocol V2 feature adapter', () => {
       {
         targets: {
           hw: true,
-          fw: true,
+          main_mcu: true,
           coprocessor: true,
         },
         types: {
@@ -2853,7 +3004,7 @@ describe('Protocol V2 feature adapter', () => {
     const device = stubDevice({
       originalDescriptor: { protocolType: 'V2' },
       features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
-        fw: {
+        main_mcu: {
           application: {
             version: '4.14.0',
           },
@@ -2907,7 +3058,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-          fw: { application: { version: '1.2.3' } },
+          main_mcu: { application: { version: '1.2.3' } },
         },
       })
       .mockResolvedValueOnce({
@@ -2942,7 +3093,7 @@ describe('Protocol V2 feature adapter', () => {
       {
         targets: {
           hw: true,
-          fw: true,
+          main_mcu: true,
           coprocessor: true,
         },
         types: {
@@ -2971,7 +3122,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
-          fw: { bootloader: { version: '0.2.0' } },
+          main_mcu: { bootloader: { version: '0.2.0' } },
           se1: {},
         },
       })
@@ -3021,7 +3172,7 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.probeProtocolV2RuntimeState({
       hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-      fw: { romloader: { version: '1.0.0' } },
+      main_mcu: { romloader: { version: '1.0.0' } },
     });
 
     expect(typedCall).toHaveBeenCalledTimes(1);
@@ -3049,7 +3200,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.probeProtocolV2RuntimeState({
         hw: { Device_type: DeviceType.PRO, serial_no: 'PRO-SERIAL' },
-        fw: { romloader: { version: '1.0.0' } },
+        main_mcu: { romloader: { version: '1.0.0' } },
       })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceInitializeFailed });
 
@@ -3074,7 +3225,7 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.probeProtocolV2RuntimeState({
       hw: { serial_no: 'PR2SERIAL' },
-      fw: { application: { version: '1.2.3' } },
+      main_mcu: { application: { version: '1.2.3' } },
     });
 
     expect(typedCall).toHaveBeenCalledTimes(1);
@@ -3106,7 +3257,7 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.probeProtocolV2RuntimeState({
       hw: { serial_no: 'PR2SERIAL' },
-      fw: { application: { version: '1.2.3' } },
+      main_mcu: { application: { version: '1.2.3' } },
     });
 
     expect(typedCall).toHaveBeenCalledTimes(2);
@@ -3134,7 +3285,7 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.probeProtocolV2RuntimeState({
       hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-      fw: { bootloader: { version: '0.2.0' } },
+      main_mcu: { bootloader: { version: '0.2.0' } },
     });
 
     expect(device.features).toMatchObject({
@@ -3163,7 +3314,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.probeProtocolV2RuntimeState({
         hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '1.2.3' } },
+        main_mcu: { application: { version: '1.2.3' } },
       })
     ).rejects.toBe(linkError);
 
@@ -3188,12 +3339,165 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.probeProtocolV2RuntimeState({
         hw: { serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '1.2.3' } },
+        main_mcu: { application: { version: '1.2.3' } },
       })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceInitializeFailed });
     expect(typedCall).toHaveBeenCalledTimes(1);
   });
 
+  test('initializes a legacy Protocol V2 bootloader without compatibility options', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceInfo',
+        message: {
+          hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
+          main_mcu: { bootloader: { version: '0.2.0' } },
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: {
+          version: 1,
+          build_fingerprint: '',
+          supported_messages: [],
+          protobuf_definition: null,
+        },
+      });
+    (device as any).commands = { typedCall };
+
+    await device.initialize();
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.features).toMatchObject({
+      mode: 'bootloader',
+      bootloaderMode: true,
+      initialized: null,
+    });
+  });
+
+  test('uses DeviceStatusGet to identify App mode for legacy ProtocolInfo', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: {
+          version: 1,
+          build_fingerprint: '',
+          supported_messages: [],
+          protobuf_definition: null,
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true, unlocked: true },
+      });
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState(
+      {
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
+        main_mcu: { application: { version: '1.2.3' } },
+      },
+      5000
+    );
+
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'ProtocolInfoRequest',
+      'ProtocolInfo',
+      { eventless_wallet_session: true },
+      { timeoutMs: 5000 }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'DeviceStatusGet',
+      'DeviceStatus',
+      {},
+      { timeoutMs: 5000 }
+    );
+    expect(device.features).toMatchObject({
+      mode: 'normal',
+      bootloaderMode: false,
+      initialized: true,
+      unlocked: true,
+    });
+  });
+
+  test('maps legacy bootloader metadata without calling DeviceStatusGet', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest.fn().mockResolvedValueOnce({
+      type: 'ProtocolInfo',
+      message: {
+        version: 1,
+        build_fingerprint: '',
+        supported_messages: [],
+        protobuf_definition: null,
+      },
+    });
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState({
+      hw: { Device_type: DeviceType.NEO, serial_no: 'NEOSERIAL' },
+      main_mcu: { bootloader: { version: '0.2.0' } },
+    });
+
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.features).toMatchObject({
+      deviceType: 'neo',
+      mode: 'bootloader',
+      bootloaderMode: true,
+      initialized: null,
+    });
+  });
+
+  test('maps legacy romloader metadata without calling DeviceStatusGet', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest.fn().mockResolvedValueOnce({
+      type: 'ProtocolInfo',
+      message: {
+        version: 1,
+        build_fingerprint: '',
+        supported_messages: [],
+        protobuf_definition: null,
+      },
+    });
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState({
+      hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
+      main_mcu: { romloader: { version: '1.0.0' } },
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.features).toMatchObject({
+      deviceType: 'pro2',
+      mode: 'romloader',
+      bootloaderMode: true,
+      initialized: null,
+    });
+  });
+
   test('does not reinterpret a state update error as runtime detection failure', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
@@ -3219,7 +3523,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.probeProtocolV2RuntimeState({
         hw: { serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '1.0.0' } },
+        main_mcu: { application: { version: '1.0.0' } },
       })
     ).rejects.toThrow('state update failed');
 
@@ -3244,7 +3548,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-          fw: { application: { version: '1.2.3' } },
+          main_mcu: { application: { version: '1.2.3' } },
         },
       })
       .mockResolvedValueOnce({
@@ -3259,7 +3563,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-          fw: { application: { version: '1.2.4' } },
+          main_mcu: { application: { version: '1.2.4' } },
         },
       })
       .mockResolvedValueOnce({
@@ -3291,7 +3595,7 @@ describe('Protocol V2 feature adapter', () => {
       {
         targets: {
           hw: true,
-          fw: true,
+          main_mcu: true,
           coprocessor: true,
         },
         types: {
@@ -3312,7 +3616,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
-          fw: { application: { version: '1.2.4' } },
+          main_mcu: { application: { version: '1.2.4' } },
         },
       })
       .mockResolvedValueOnce({
@@ -3389,7 +3693,7 @@ describe('Protocol V2 feature adapter', () => {
       { ...descriptor, protocolType: 'V2' } as any,
       {
         hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '1.2.3' } },
+        main_mcu: { application: { version: '1.2.3' } },
         status: { init_states: true },
       }
     );
@@ -3429,7 +3733,7 @@ describe('Protocol V2 feature adapter', () => {
       { ...descriptor, protocolType: 'V2' } as any,
       {
         hw: { serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '4.15.0' } },
+        main_mcu: { application: { version: '4.15.0' } },
         status: { passphrase_enabled: false },
       }
     );
@@ -3476,7 +3780,7 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
       {
-        fw: { application: { version: '1.2.3' } },
+        main_mcu: { application: { version: '1.2.3' } },
         status: { unlocked: false },
       }
     );
@@ -3890,7 +4194,7 @@ describe('Protocol V2 firmware update targets', () => {
     );
   });
 
-  test('uses Protocol V2 features after BLE final reconnect without V1 Initialize', async () => {
+  test('accepts uninitialized Protocol V2 features after BLE final reconnect', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -3905,7 +4209,7 @@ describe('Protocol V2 firmware update targets', () => {
           type: 'DeviceInfo',
           message: {
             hw: { serial_no: 'BLE-PRO2-SERIAL' },
-            fw: {
+            main_mcu: {
               bootloader: { version: '0.0.0' },
               application: { version: '0.0.0' },
             },
@@ -3918,7 +4222,7 @@ describe('Protocol V2 firmware update targets', () => {
       if (name === 'DeviceStatusGet') {
         return Promise.resolve({
           type: 'DeviceStatus',
-          message: { init_states: true, unlocked: true },
+          message: { init_states: false, unlocked: false },
         });
       }
       if (name === 'ProtocolInfoRequest') {
@@ -3939,7 +4243,7 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => commands,
       updateProtocolV2Features: jest.fn(() => ({
         bootloaderMode: false,
-        mode: 'normal',
+        mode: 'notInitialized',
         firmwareVersion: '0.0.0',
         bootloaderVersion: '0.0.0',
         bleVersion: '0.0.0',
@@ -3957,7 +4261,7 @@ describe('Protocol V2 firmware update targets', () => {
       {
         targets: {
           hw: true,
-          fw: true,
+          main_mcu: true,
           coprocessor: true,
           se1: true,
           se2: true,
@@ -4016,7 +4320,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
     (method as any).protocolV2Reboot = jest.fn();
     (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(true);
-    method.postTipMessage = jest.fn();
+    method.postMessage = jest.fn();
 
     await method.run();
 
@@ -4033,56 +4337,268 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('requires the external host to prepare manifest resources before bootloader entry', async () => {
+  test('filters unrequested binaries from a direct local Protocol V2 update', async () => {
+    const applicationP1Binary = new Uint8Array([1, 2, 3]).buffer;
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
-        targetsToUpdate: ['resource'],
+        targetsToUpdate: ['app_v1'],
+        applicationP1Binary,
+        bootloaderBinary: new Uint8Array([4, 5, 6]).buffer,
       },
     });
     method.init();
-
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
     (method as any).device = stubDevice({
-      originalDescriptor: { id: 'usb-id', path: 'app-path', protocolType: 'V2' },
+      originalDescriptor: { protocolType: 'V2' },
       features: {
         deviceType: 'pro2',
         firmwareVersion: '1.0.0',
-        mode: 'normal',
-        bootloaderMode: false,
         capabilities: [],
       },
       getCurrentDeviceType: () => 'pro2',
-      isBootloader: () => false,
-      isRomloader: () => false,
     });
-    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
-    (method as any).enterProtocolV2BootloaderMode = jest.fn();
+    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue('local-result');
     method.postTipMessage = jest.fn();
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.RuntimeError,
-      params: expect.objectContaining({
-        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-      }),
+    await expect(method.run()).resolves.toBe('local-result');
+    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
+      bootloaderBinary: null,
+      fwBinaryMap: [
+        {
+          fileName: 'application_p1.bin',
+          binary: applicationP1Binary,
+          targetId: 4,
+        },
+      ],
     });
-    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
   });
 
-  test('reboots Protocol V2 normal-mode device to bootloader before transfer', async () => {
+  test('uses the DeviceState identity for Protocol V2 firmware artifact lookups', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
+        platform: 'web',
       },
     });
+    method.init();
     (method as any).device = stubDevice({
-      originalDescriptor: { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
-      features: { bootloader_mode: false, capabilities: [] },
-      isBootloader: () => false,
-      probeProtocolV2RuntimeState: jest.fn().mockResolvedValue({
-        mode: 'bootloader',
+      originalDescriptor: { protocolType: 'V2' },
+      features: {
+        firmwareVersion: '1.0.0',
+        serialNo: 'device-without-model-prefix',
+      },
+      getCurrentDeviceType: () => EDeviceType.Pro2,
+      getCurrentFirmwareType: () => EFirmwareType.Universal,
+    });
+
+    await expect((method as any).getProtocolV2DeviceFeatures()).resolves.toEqual(
+      expect.objectContaining({
+        deviceType: EDeviceType.Pro2,
+        firmwareType: EFirmwareType.Universal,
+      })
+    );
+  });
+
+  test('keeps all local binaries when no target list was supplied', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        applicationP1Binary: new Uint8Array([1]).buffer,
+        bootloaderBinary: new Uint8Array([2]).buffer,
+        resourceArchiveBinary: new Uint8Array([3]).buffer,
+      },
+    });
+    method.init();
+
+    const availableInstallItems = (method as any).buildProtocolV2InstallItems({
+      bootloaderBinary: (method as any).prepareBootloaderBinary(),
+      fwBinaryMap: (method as any).collectExplicitTargetBinaries(),
+    });
+
+    expect((method as any).params.targetsToUpdate).toEqual(['resource']);
+    expect(
+      (method as any)
+        .filterProtocolV2LocalInstallItems(availableInstallItems)
+        .map((item: { targetId: number }) => item.targetId)
+    ).toEqual([3, 4]);
+  });
+
+  test('keeps external-only resource updates on the prepared host path', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['resource'],
+      },
+    });
+    method.init();
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('external-only' as never);
+
+    (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: [],
+      },
+      getCurrentDeviceType: () => 'pro2',
+      isBootloader: () => false,
+      isRomloader: () => false,
+    });
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+    (method as any).enterProtocolV2BootloaderMode = jest.fn();
+    method.postTipMessage = jest.fn();
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      params: expect.objectContaining({
+        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+      }),
+    });
+    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
+  });
+
+  test('downloads Protocol V2 resource archives in SDK-managed mode', async () => {
+    const resourceArchiveBinary = new Uint8Array([1, 2, 3, 4]).buffer;
+    const applicationP1Binary = new Uint8Array([5, 6, 7, 8]).buffer;
+    const applicationP1InstallItem = {
+      fileName: 'application_p1.bin',
+      binary: applicationP1Binary,
+      targetId: 4,
+      kind: 'firmware',
+    };
+    const resourceArchiveSha256 = bytesToHex(sha256(new Uint8Array(resourceArchiveBinary)));
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'ext',
+        targetsToUpdate: ['app_v1', '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: [],
+      },
+      getCurrentDeviceType: () => 'pro2',
+      isBootloader: () => false,
+      isRomloader: () => false,
+    });
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue({
+      bootloaderBinary: null,
+      fwBinaryMap: [
+        {
+          fileName: applicationP1InstallItem.fileName,
+          binary: applicationP1Binary,
+          targetId: applicationP1InstallItem.targetId,
+        },
+      ],
+      installItems: [applicationP1InstallItem],
+    });
+    (method as any).runProtocolV2DirectArtifacts = jest
+      .fn()
+      .mockResolvedValue('sdk-managed-resource-result');
+    method.postTipMessage = jest.fn();
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('sdk-managed' as never);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue({
+      archiveUrl: 'https://example.com/pro2-resource.zip',
+      archiveSize: resourceArchiveBinary.byteLength,
+      archiveSha256: resourceArchiveSha256,
+    });
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockResolvedValue({ binary: resourceArchiveBinary });
+
+    await expect(method.run()).resolves.toBe('sdk-managed-resource-result');
+
+    expect(forceReloadDataSpy).toHaveBeenCalledWith({
+      requireResources: true,
+      resourceDeviceType: EDeviceType.Pro2,
+    });
+    expect(getSysResourceBinarySpy).toHaveBeenCalledWith('https://example.com/pro2-resource.zip');
+    expect((method as any).params.resourceArchiveBinary).toBe(resourceArchiveBinary);
+    expect((method as any).runProtocolV2DirectArtifacts).toHaveBeenCalledWith({
+      availableInstallItems: [applicationP1InstallItem],
+      announceDownload: false,
+    });
+  });
+
+  test('preserves SDK-managed resource installation errors after preparation', async () => {
+    const resourceArchiveBinary = new Uint8Array([1, 2, 3, 4]).buffer;
+    const installError = ERRORS.TypedError(
+      HardwareErrorCode.FirmwareError,
+      'device rejected the prepared resource installation'
+    );
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'ext',
+        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: [],
+      },
+      getCurrentDeviceType: () => 'pro2',
+      isBootloader: () => false,
+      isRomloader: () => false,
+    });
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+    (method as any).downloadRemoteProtocolV2ResourceArchive = jest
+      .fn()
+      .mockResolvedValue(resourceArchiveBinary);
+    (method as any).runProtocolV2DirectArtifacts = jest.fn().mockRejectedValue(installError);
+    method.postTipMessage = jest.fn();
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('sdk-managed' as never);
+
+    await expect(method.run()).rejects.toBe(installError);
+
+    expect(forceReloadDataSpy).toHaveBeenCalledWith({
+      requireResources: true,
+      resourceDeviceType: EDeviceType.Pro2,
+    });
+    expect((method as any).runProtocolV2DirectArtifacts).toHaveBeenCalledTimes(1);
+  });
+
+  test('reboots Protocol V2 normal-mode device to bootloader before transfer', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
+      features: { bootloader_mode: false, capabilities: [] },
+      isBootloader: () => false,
+      probeProtocolV2RuntimeState: jest.fn().mockResolvedValue({
+        mode: 'bootloader',
         bootloaderMode: true,
       }),
     });
@@ -4307,6 +4823,23 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceInfoGet']);
   });
 
+  test('stops V4 bootloader reconnect polling on a stale BLE bond', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const staleBondError = ERRORS.TypedError(HardwareErrorCode.BlePeerRemovedPairingInformation);
+    const reconnectProtocolV2Device = jest.fn().mockRejectedValue(staleBondError);
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+
+    await expect((method as any).waitForProtocolV2BootloaderMode(60_000, 0)).rejects.toBe(
+      staleBondError
+    );
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+  });
+
   test('polls again when Protocol V2 bootloader serial is temporarily unavailable', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4388,6 +4921,87 @@ describe('Protocol V2 firmware update targets', () => {
     expect(initialize).not.toHaveBeenCalled();
   });
 
+  test('reacquires the same WebUSB device without a protocol probe during install recovery', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const acquire = jest.fn().mockResolvedValue('usb-path');
+    const enumerate = jest.fn().mockResolvedValue({
+      descriptors: [
+        { id: 'other-usb', path: 'other-usb', protocolType: 'V2' },
+        { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
+      ],
+    });
+    const commands = { disposed: true, mainId: '' };
+    const device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
+      deviceConnector: { acquire, enumerate },
+      updateDescriptor: jest.fn(),
+      acquire: jest.fn(),
+      commands,
+      getCommands: () => commands,
+      mainId: 'old-usb-path',
+    });
+    const getDevices = jest.spyOn(DevicePool, 'getDevices');
+    const isBrowserWebUsb = jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(false);
+    const isDesktopWebUsb = jest.spyOn(DataManager, 'isDesktopWebUsb').mockReturnValue(true);
+    (method as any).device = device;
+    (method as any).protocolV2ExpectedPath = 'usb-path';
+
+    try {
+      await (method as any).reconnectProtocolV2Device({ skipProtocolProbe: true });
+    } finally {
+      getDevices.mockRestore();
+      isBrowserWebUsb.mockRestore();
+      isDesktopWebUsb.mockRestore();
+    }
+
+    expect(getDevices).not.toHaveBeenCalled();
+    expect(acquire).toHaveBeenCalledWith(
+      'usb-path',
+      null,
+      undefined,
+      'V2',
+      undefined,
+      undefined,
+      true
+    );
+    expect(device.acquire).not.toHaveBeenCalled();
+    expect(commands.disposed).toBe(false);
+    expect(commands.mainId).toBe('usb-path');
+  });
+
+  test('reacquires the same BLE peripheral by id without scanning during install recovery', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
+    const enumerate = jest.fn().mockResolvedValue({
+      descriptors: [{ id: 'ble-id', name: 'OneKey Pro 2', protocolType: 'V2' }],
+    });
+    const commands = { disposed: true, mainId: '' };
+    (method as any).isBleReconnect = jest.fn(() => true);
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'ble-id', path: 'ble-path', protocolType: 'V2' },
+      deviceConnector: { acquire, enumerate },
+      commands,
+      getCommands: () => commands,
+    });
+
+    await (method as any).reconnectProtocolV2Device({ skipProtocolProbe: true });
+
+    expect(enumerate).not.toHaveBeenCalled();
+    expect(acquire).toHaveBeenCalledWith('ble-id', null, true, 'V2', undefined, undefined, true);
+    expect(commands.disposed).toBe(false);
+    expect(commands.mainId).toBe('ble-id');
+  });
+
   test('selects the matching physical device from multiple Protocol V2 USB reconnect candidates', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4632,7 +5246,7 @@ describe('Protocol V2 firmware update targets', () => {
       type: 'DeviceInfo',
       message: {
         hw: { serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '1.0.0' } },
+        main_mcu: { application: { version: '1.0.0' } },
       },
     });
     (method as any).protocolV2ExpectedSerialNumber = 'expected-serial';
@@ -4653,6 +5267,45 @@ describe('Protocol V2 firmware update targets', () => {
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
   });
 
+  test('refreshes ProtocolInfo while waiting for App after a firmware reboot', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const deviceInfo = {
+      hw: { serial_no: 'PRO2-PHYSICAL-1' },
+      main_mcu: { application: { version: '1.0.0' } },
+    };
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceInfo',
+      message: deviceInfo,
+    });
+    const probeProtocolV2RuntimeState = jest.fn(
+      (_deviceInfo, _timeout, options?: { forceRuntimeContextRefresh?: boolean }) =>
+        Promise.resolve({
+          mode: options?.forceRuntimeContextRefresh ? 'normal' : 'bootloader',
+          bootloaderMode: !options?.forceRuntimeContextRefresh,
+        })
+    );
+    (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-1';
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      probeProtocolV2RuntimeState,
+    });
+
+    await expect(
+      (method as any).waitForProtocolV2ReconnectAndFeatures(60_000)
+    ).resolves.toMatchObject({ mode: 'normal', bootloaderMode: false });
+
+    expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000, {
+      forceRuntimeContextRefresh: true,
+    });
+    expect((method as any).protocolV2LatestFinalDeviceInfo).toBe(deviceInfo);
+  });
+
   test('reboots Protocol V2 firmware flow back to normal without legacy switch-firmware prompt', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4738,28 +5391,30 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('treats Android BLE transport release during Protocol V2 reboot as expected', async () => {
+  test('treats a typed BLE disconnect during Protocol V2 normal reboot as expected', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest.fn().mockRejectedValue(new Error('React Native BLE transport released'));
+    const typedCall = jest
+      .fn()
+      .mockRejectedValue(ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected));
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
 
-    await expect((method as any).protocolV2Reboot(DeviceRebootType.Bootloader)).resolves.toEqual({
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Normal)).resolves.toEqual({
       message: 'Device rebooted successfully',
     });
     expect((method as any).device.markProtocolV2Reboot).toHaveBeenCalledWith(
-      DeviceRebootType.Bootloader
+      DeviceRebootType.Normal
     );
   });
 
-  test('requires an explicit Protocol V2 update ACK before entering install state', async () => {
+  test('uses a short timeout and continues after a BLE reboot response timeout', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -4769,40 +5424,180 @@ describe('Protocol V2 firmware update targets', () => {
     const typedCall = jest
       .fn()
       .mockRejectedValue(
-        Object.assign(
-          new Error("Failed to execute 'open' on 'USBDevice': The device was disconnected"),
-          { name: 'NotFoundError' }
+        ERRORS.TypedError(
+          HardwareErrorCode.BleTimeoutError,
+          'Lowlevel response timeout after 5000ms for DeviceReboot'
         )
       );
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
-    method.postTipMessage = jest.fn();
-    method.postProgressMessage = jest.fn();
-
-    await expect(
-      (method as any).protocolV2StartFirmwareUpdate({
-        targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
-      })
-    ).rejects.toThrow();
-
-    expect(method.postTipMessage).not.toHaveBeenCalled();
-    expect(method.postProgressMessage).not.toHaveBeenCalled();
-  });
 
-  test('does not poll Protocol V2 install status when the update ACK times out', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Normal)).resolves.toEqual({
+      message: 'Device rebooted successfully',
+    });
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceReboot',
+      'Success',
+      { reboot_type: DeviceRebootType.Normal },
+      { timeoutMs: 5000 }
+    );
+    expect((method as any).device.markProtocolV2Reboot).toHaveBeenCalledWith(
+      DeviceRebootType.Normal
+    );
+  });
+
+  test('continues after a USB Protocol V2 reboot response timeout', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const timeoutError = Object.assign(
+      new Error('Protocol V2 response timeout after 5000ms for DeviceReboot'),
+      { code: 'response-timeout' }
+    );
+    const typedCall = jest.fn().mockRejectedValue(timeoutError);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Normal)).resolves.toEqual({
+      message: 'Device rebooted successfully',
+    });
+    expect((method as any).device.markProtocolV2Reboot).toHaveBeenCalledWith(
+      DeviceRebootType.Normal
+    );
+  });
+
+  test('propagates non-transport errors from a Protocol V2 reboot', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const rebootError = new Error('Device rejected reboot');
+    const typedCall = jest.fn().mockRejectedValue(rebootError);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Normal)).rejects.toBe(
+      rebootError
+    );
+    expect((method as any).device.markProtocolV2Reboot).not.toHaveBeenCalled();
+  });
+
+  test('treats Android BLE transport release during Protocol V2 reboot as expected', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest.fn().mockRejectedValue(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
+    const typedCall = jest.fn().mockRejectedValue(new Error('React Native BLE transport released'));
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
+
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Bootloader)).resolves.toEqual({
+      message: 'Device rebooted successfully',
+    });
+    expect((method as any).device.markProtocolV2Reboot).toHaveBeenCalledWith(
+      DeviceRebootType.Bootloader
+    );
+  });
+
+  test('stages targets before sending the empty Protocol V2 install request', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const targets = [{ target_id: 4, path: 'vol1:firmware.bin' }];
+    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
+    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
+    const cancelDevice = jest.fn().mockResolvedValue(undefined);
+    let cancelableAction: (() => Promise<unknown>) | undefined;
+    const interaction = {
+      interactionId: 'firmware-update',
+      phaseId: 'firmware-update:phase-1',
+      sequence: 1,
+      phase: 'button',
+      transition: 'start',
+      protocol: 'V2',
+    };
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall, call, cancelDevice }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(interaction),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
+      setCancelableAction: jest.fn(action => {
+        cancelableAction = action;
+      }),
+    });
+    method.postMessage = jest.fn();
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (method as any).protocolV2StartFirmwareUpdate({ targets })
+    ).resolves.toBeUndefined();
+
+    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateStage', 'Success', { targets });
+    expect(method.postMessage).toHaveBeenCalledWith({
+      event: 'UI_EVENT',
+      type: UI_REQUEST.REQUEST_BUTTON,
+      payload: {
+        device: { connectId: 'pro2' },
+        source: 'method-lifecycle',
+        reason: 'firmware-update',
+        completion: 'operation-completed',
+        deviceOnly: true,
+        operation: 'firmwareUpdateV4',
+        interaction,
+      },
+    });
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
+    );
+    expect(typedCall.mock.invocationCallOrder[0]).toBeLessThan(call.mock.invocationCallOrder[0]);
+    expect((method.postMessage as jest.Mock).mock.invocationCallOrder[0]).toBeLessThan(
+      call.mock.invocationCallOrder[0]
+    );
+    expect(method.postTipMessage).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
+    await cancelableAction?.();
+    expect(cancelDevice).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not send the install request when Protocol V2 staging fails', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn().mockRejectedValue(new Error('stage failed'));
+    const call = jest.fn();
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall, call }),
+    });
+    method.postMessage = jest.fn();
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
 
@@ -4810,12 +5605,148 @@ describe('Protocol V2 firmware update targets', () => {
       (method as any).protocolV2StartFirmwareUpdate({
         targets: [{ target_id: 4, path: 'vol1:application_p1.bin' }],
       })
-    ).rejects.toThrow('LIBUSB_TRANSFER_TIMED_OUT');
+    ).rejects.toThrow('stage failed');
+
+    expect(call).not.toHaveBeenCalled();
+    expect(method.postMessage).not.toHaveBeenCalled();
+    expect(method.postTipMessage).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
+  });
+
+  test('does not enter install state when the empty request fails', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
+    const call = jest.fn().mockRejectedValue(new Error('request failed'));
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall, call }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
+    });
+    method.postMessage = jest.fn();
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (method as any).protocolV2StartFirmwareUpdate({
+        targets: [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+      })
+    ).rejects.toThrow('request failed');
 
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
+    );
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
+  test('continues to install polling when the empty request releases BLE transport', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
+    const call = jest.fn().mockRejectedValue(new Error('React Native BLE transport released'));
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall, call }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
+    });
+    (method as any).isBleReconnect = jest.fn(() => true);
+    method.postMessage = jest.fn();
+
+    await expect(
+      (method as any).protocolV2StartFirmwareUpdate({
+        targets: [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+      })
+    ).resolves.toBeUndefined();
+
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
+    );
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
+    expect((method as any).protocolV2InstallNeedsReconnect).toBe(true);
+  });
+
+  test.each([
+    { name: 'bootloader', targetId: 3, path: 'vol0:/bootloader.bin' },
+    { name: 'application', targetId: 4, path: 'vol0:/application_p1.bin' },
+    { name: 'secure element', targetId: 7, path: 'vol0:/se01.bin' },
+  ])(
+    'reconnects a released BLE install link before polling $name status without DeviceInfo',
+    async ({ targetId, path }) => {
+      const method = new FirmwareUpdateV4({
+        id: 1,
+        payload: {
+          method: 'firmwareUpdateV4',
+        },
+      });
+      const targets = [{ target_id: targetId, path }];
+      const typedCall = jest
+        .fn()
+        .mockResolvedValueOnce({
+          type: 'DeviceFirmwareUpdateStatus',
+          message: { records: [{ ...targets[0], status: 1, payload_version: 0 }] },
+        })
+        .mockResolvedValueOnce({
+          type: 'DeviceFirmwareUpdateStatus',
+          message: { records: [{ ...targets[0], status: 2, payload_version: 0x010000 }] },
+        });
+      const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+      const verifyProtocolV2ReconnectIdentity = jest.fn();
+      const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+        callback: () => void
+      ) => {
+        callback();
+        return 0 as any;
+      }) as typeof setTimeout);
+
+      (method as any).device = stubDevice({
+        getCommands: () => ({ typedCall }),
+      });
+      (method as any).isBleReconnect = jest.fn(() => true);
+      (method as any).protocolV2InstallNeedsReconnect = true;
+      (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+      (method as any).verifyProtocolV2ReconnectIdentity = verifyProtocolV2ReconnectIdentity;
+      method.postProgressMessage = jest.fn();
+
+      try {
+        await expect(
+          (method as any).waitForProtocolV2FirmwareUpdateComplete(targets, true)
+        ).resolves.toBeUndefined();
+      } finally {
+        setTimeoutSpy.mockRestore();
+      }
+
+      expect(reconnectProtocolV2Device).toHaveBeenCalledWith({ skipProtocolProbe: true });
+      expect(verifyProtocolV2ReconnectIdentity).not.toHaveBeenCalled();
+      expect(typedCall.mock.calls.map(callArgs => callArgs[0])).toEqual([
+        'DeviceFirmwareUpdateStatusGet',
+        'DeviceFirmwareUpdateStatusGet',
+      ]);
+    }
+  );
+
   test('polls only firmware status while Protocol V2 bootloader is installing', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4833,23 +5764,23 @@ describe('Protocol V2 firmware update targets', () => {
         type: 'DeviceFirmwareUpdateStatus',
         message: { records: [{ target_id: 4, status: 2 }] },
       });
-    const reconnectProtocolV2Device = jest
-      .fn()
-      .mockRejectedValueOnce(new Error('Device rebooting'))
-      .mockResolvedValue(undefined);
+    const reconnectProtocolV2Device = jest.fn();
+    const verifyProtocolV2ReconnectIdentity = jest.fn();
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
-    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = verifyProtocolV2ReconnectIdentity;
     method.postProgressMessage = jest.fn();
+    method.postTipMessage = jest.fn();
 
     await (method as any).waitForProtocolV2FirmwareUpdateComplete([
       { target_id: 4, path: 'vol0:/application_p1.bin' },
     ]);
 
-    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(2);
+    expect(reconnectProtocolV2Device).not.toHaveBeenCalled();
+    expect(verifyProtocolV2ReconnectIdentity).not.toHaveBeenCalled();
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
       'DeviceFirmwareUpdateStatusGet',
       'DeviceFirmwareUpdateStatusGet',
@@ -4859,7 +5790,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('accepts a missing firmware status handler only after confirming normal mode', async () => {
+  test('keeps polling after an empty status response until the target finishes', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -4868,44 +5799,527 @@ describe('Protocol V2 firmware update targets', () => {
     });
     const typedCall = jest
       .fn()
-      .mockRejectedValue(new Error('Failure: Handler not registered for this message'));
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 0 }] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 2 }] },
+      });
     const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
-    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
-    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
-    (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
     method.postProgressMessage = jest.fn();
 
-    await (method as any).waitForProtocolV2FirmwareUpdateComplete([
-      { target_id: 4, path: 'vol0:/application_p1.bin' },
+    try {
+      await (method as any).waitForProtocolV2FirmwareUpdateComplete([
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+      ]);
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(reconnectProtocolV2Device).not.toHaveBeenCalled();
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceFirmwareUpdateStatusGet',
+      'DeviceFirmwareUpdateStatusGet',
+      'DeviceFirmwareUpdateStatusGet',
+      'DeviceFirmwareUpdateStatusGet',
     ]);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+  });
+
+  test('keeps waiting while firmware status records are empty before user confirmation', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 0 }] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 2 }] },
+      });
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await (method as any).waitForProtocolV2FirmwareUpdateComplete(
+        [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+        true
+      );
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+  });
+
+  test('ignores stale finished records until the current install starts', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 2, path: 'vol0:/application_p1.bin' }] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 0, path: 'vol0:/application_p1.bin' }] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 2, path: 'vol0:/application_p1.bin' }] },
+      });
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await (method as any).waitForProtocolV2FirmwareUpdateComplete(
+        [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+        true
+      );
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+  });
+
+  test('does not count a stale finished target when only another target was live', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const assertProtocolV2TargetStatus = (method as any).assertProtocolV2TargetStatus.bind(method);
+    const expectedTargetIds = new Set([3, 4]);
+    const expectedPaths = new Map([
+      [3, 'vol0:/bootloader.bin'],
+      [4, 'vol0:/application_p1.bin'],
+    ]);
+    const liveTargetIds = new Set([4]);
+    method.postProgressMessage = jest.fn();
+
+    const completed = assertProtocolV2TargetStatus(
+      [
+        { target_id: 3, status: 2, path: 'vol0:/bootloader.bin' },
+        { target_id: 4, status: 2, path: 'vol0:/application_p1.bin' },
+      ],
+      expectedTargetIds,
+      expectedPaths,
+      liveTargetIds
+    );
+
+    expect(completed).toBe(false);
+    expect((method as any).protocolV2CompletedTargetIds).toEqual(new Set([4]));
+    expect(method.postProgressMessage).toHaveBeenCalledWith(50, 'installingFirmware');
+    expect(method.postProgressMessage).not.toHaveBeenCalledWith(100, 'installingFirmware');
+  });
+
+  test('ignores stale failed records until the current install starts', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 3 }] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 0 }] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 3 }] },
+      });
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+
+    try {
+      await expect(
+        (method as any).waitForProtocolV2FirmwareUpdateComplete(
+          [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+          true
+        )
+      ).rejects.toMatchObject({ errorCode: HardwareErrorCode.FirmwareError });
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(3);
+  });
+
+  test('ignores leftover failed records while another leftover target is still pending', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 3, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 0, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 2, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 2, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      });
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await (method as any).waitForProtocolV2FirmwareUpdateComplete(
+        [
+          { target_id: 3, path: 'vol0:/bootloader.bin' },
+          { target_id: 4, path: 'vol0:/application_p1.bin' },
+        ],
+        true
+      );
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+  });
+
+  test('reports failed only after that target was live in the current install', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 3, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 0, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 3, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      });
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+
+    try {
+      await expect(
+        (method as any).waitForProtocolV2FirmwareUpdateComplete(
+          [
+            { target_id: 3, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, path: 'vol0:/application_p1.bin' },
+          ],
+          true
+        )
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.FirmwareError,
+        message: 'Protocol V2 firmware install failed',
+      });
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(3);
+  });
+
+  test('waits five minutes before rejecting normal mode without install evidence', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValue(new Error('Failure: Handler not registered for this message'));
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    let now = 0;
+    jest.spyOn(Date, 'now').mockImplementation(() => now);
+    jest.spyOn(global, 'setTimeout').mockImplementation(((callback: () => void) => {
+      now += 60 * 1000;
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (method as any).waitForProtocolV2FirmwareUpdateComplete([
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+      ])
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareError,
+      message: 'Protocol V2 firmware install timed out',
+      params: { firmwareUpdateCode: 'FirmwareInstallTimeout' },
+    });
+
+    expect(method.postProgressMessage).not.toHaveBeenCalledWith(100, 'installingFirmware');
+    expect(typedCall).toHaveBeenCalledTimes(5);
+  });
+
+  test('preserves multi-app completion evidence when App mode replaces the status endpoint', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        targetsToUpdate: ['app_v1', 'app_v2'],
+        expectedTargetVersions: {
+          app_v1: '2.0.0',
+          app_v2: '2.0.0',
+        },
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValue(new Error('Failure: Handler not registered for this message'));
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    const probeProtocolV2RuntimeState = jest.fn().mockResolvedValue({
+      mode: 'normal',
+      bootloaderMode: false,
+      firmwareVersion: '2.0.0',
+    });
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      probeProtocolV2RuntimeState,
+    });
+    (method as any).protocolV2InstallBaselineVersions = new Map([
+      [4, '1.0.0'],
+      [5, '1.0.0'],
+    ]);
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (method as any).waitForProtocolV2FirmwareUpdateComplete([
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+        { target_id: 5, path: 'vol0:/application_p2.bin' },
+      ])
+    ).resolves.toBeUndefined();
+
+    expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+    expect(Array.from((method as any).protocolV2CompletedTargetIds)).toEqual([4, 5]);
+
+    (method as any).protocolV2LatestFinalFeatures = {
+      firmwareVersion: '2.0.0',
+    };
+    (method as any).protocolV2LatestFinalDeviceInfo = {
+      main_mcu: {
+        application: { version: '2.0.0' },
+      },
+    };
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
+  });
+
+  test('preserves all target completion evidence when status records disappear after reboot', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('Pro2 is rebooting'))
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [] },
+      });
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).protocolV2InstallTerminalSuccessObserved = true;
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await expect(
+        (method as any).waitForProtocolV2FirmwareUpdateComplete([
+          { target_id: 4, path: 'vol0:/application_p1.bin' },
+          { target_id: 5, path: 'vol0:/application_p2.bin' },
+        ])
+      ).resolves.toBeUndefined();
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
 
-    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceFirmwareUpdateStatusGet']);
-    expect((method as any).probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
+    expect(Array.from((method as any).protocolV2CompletedTargetIds)).toEqual([4, 5]);
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('accepts an empty firmware status dump only after confirming normal mode', async () => {
+  test('uses the confirmed install request as evidence after the same device returns', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceFirmwareUpdateStatus',
-      message: { records: [] },
-    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('The USB device was disconnected'))
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [] },
+      });
     const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
-    let now = 0;
-    jest.spyOn(Date, 'now').mockImplementation(() => now);
-    jest.spyOn(global, 'setTimeout').mockImplementation(((callback: () => void) => {
-      now += 31 * 1000;
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
       callback();
       return 0 as any;
     }) as typeof setTimeout);
@@ -4913,24 +6327,32 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
+    (method as any).protocolV2InstallTerminalSuccessObserved = true;
     (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
     (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
     (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
     method.postProgressMessage = jest.fn();
 
-    await expect(
-      (method as any).waitForProtocolV2FirmwareUpdateComplete([
-        { target_id: 4, path: 'vol0:/application_p1.bin' },
-      ])
-    ).resolves.toBeUndefined();
+    try {
+      await expect(
+        (method as any).waitForProtocolV2FirmwareUpdateComplete(
+          [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+          true
+        )
+      ).resolves.toBeUndefined();
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
 
-    expect(typedCall).toHaveBeenCalledTimes(1);
-    expect((method as any).probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
-    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+    expect((method as any).reconnectProtocolV2Device).toHaveBeenCalledWith({
+      skipProtocolProbe: true,
+    });
+    expect(method.postProgressMessage).toHaveBeenLastCalledWith(100, 'installingFirmware');
   });
 
   test.each([
     [{ mode: 'normal', bootloaderMode: false }, true],
+    [{ mode: 'notInitialized', bootloaderMode: false }, true],
     [{ mode: 'bootloader', bootloaderMode: true }, false],
   ])('derives firmware completion from the runtime-state probe: %o', async (features, expected) => {
     const method = new FirmwareUpdateV4({
@@ -4989,7 +6411,9 @@ describe('Protocol V2 firmware update targets', () => {
       'DeviceFirmwareUpdateStatusGet',
       'DeviceFirmwareUpdateStatusGet',
     ]);
-    expect((method as any).probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
+    expect((method as any).reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+    expect((method as any).verifyProtocolV2ReconnectIdentity).toHaveBeenCalledTimes(1);
+    expect((method as any).probeProtocolV2NormalMode).not.toHaveBeenCalled();
   });
 
   test('rejects a finished target whose payload version conflicts with the plan', () => {
@@ -5104,8 +6528,8 @@ describe('Protocol V2 firmware update targets', () => {
           { target_id: 4, path: 'vol0:/application_p1.bin' },
         ])
       ).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.RuntimeError,
-        message: 'Protocol V2 install status conflicts with target 4',
+        errorCode: HardwareErrorCode.FirmwareError,
+        message: 'Protocol V2 firmware install status conflict',
         params: {
           firmwareUpdateCode: 'FirmwareInstallStatusConflict',
         },
@@ -5118,7 +6542,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(1);
   });
 
-  test('does not fail a completed multi-app install when final app versions are unobservable', () => {
+  test('uses the device firmware version for P1 and install completion for unobservable P2', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5126,7 +6550,7 @@ describe('Protocol V2 firmware update targets', () => {
         platform: 'desktop',
         targetsToUpdate: ['app_v1', 'app_v2'],
         expectedTargetVersions: {
-          app_v1: '1.0.0',
+          app_v1: '3.0.0',
           app_v2: '2.0.0',
         },
       },
@@ -5137,12 +6561,41 @@ describe('Protocol V2 firmware update targets', () => {
       minor_version: 0,
       patch_version: 0,
     };
-    (method as any).protocolV2FinalStatusVerified = true;
+    (method as any).protocolV2CompletedTargetIds = new Set([4, 5]);
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
+  });
+
+  test('uses the firmware version for P1 and the optional DeviceInfo version for P2', () => {
+    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: 1,
+      minor_version: 0,
+      patch_version: 0,
+    };
+    (method as any).protocolV2LatestFinalDeviceInfo = {
+      main_mcu: {
+        application: { version: '9.9.9' },
+        application_data: { version: '2.0.0' },
+      },
+    };
 
     expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
   });
 
-  test('rejects unobservable final versions after the status endpoint fallback', () => {
+  test('rejects a mismatched final DeviceInfo application slot version', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5156,6 +6609,63 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     method.init();
+    (method as any).protocolV2LatestFinalFeatures = {
+      major_version: 1,
+      minor_version: 0,
+      patch_version: 0,
+    };
+    (method as any).protocolV2LatestFinalDeviceInfo = {
+      main_mcu: {
+        application: { version: '1.0.0' },
+        application_data: { version: '2.0.1' },
+      },
+    };
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).toThrow(
+      'target app_v2 reached 2.0.1, expected 2.0.0'
+    );
+  });
+
+  test('rejects an unobservable P2 version without P2 completion evidence', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        targetsToUpdate: ['app_v1', 'app_v2'],
+        expectedTargetVersions: {
+          app_v1: '3.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).protocolV2CompletedTargetIds = new Set([4]);
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).toThrow(
+      'target app_v2 has no observable final version after status fallback'
+    );
+  });
+
+  test('still rejects an unobservable non-app version after the status endpoint fallback', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        targetsToUpdate: ['se01'],
+        expectedTargetVersions: {
+          se01: '1.0.0',
+        },
+      },
+    });
+    method.init();
     (method as any).protocolV2LatestFinalFeatures = {
       major_version: 3,
       minor_version: 0,
@@ -5163,11 +6673,11 @@ describe('Protocol V2 firmware update targets', () => {
     };
 
     expect(() => (method as any).assertExpectedProtocolV2Versions()).toThrow(
-      'has no observable final version after status fallback'
+      'target se01 has no observable final version after status fallback'
     );
   });
 
-  test('polls target status after update ACK and finishes when all targets complete', async () => {
+  test('polls target status after the install request and finishes when all targets complete', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5199,7 +6709,7 @@ describe('Protocol V2 firmware update targets', () => {
       ])
     ).resolves.toBeUndefined();
 
-    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+    expect(reconnectProtocolV2Device).not.toHaveBeenCalled();
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
       'DeviceFirmwareUpdateStatus',
@@ -5209,7 +6719,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('fails clearly when a requested target stays absent from the full status dump', async () => {
+  test('keeps polling missing target records until the five-minute timeout', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5225,7 +6735,7 @@ describe('Protocol V2 firmware update targets', () => {
     let now = 0;
     jest.spyOn(Date, 'now').mockImplementation(() => now);
     jest.spyOn(global, 'setTimeout').mockImplementation(((callback: () => void) => {
-      now += 31 * 1000;
+      now += 60 * 1000;
       callback();
       return 0 as any;
     }) as typeof setTimeout);
@@ -5244,12 +6754,13 @@ describe('Protocol V2 firmware update targets', () => {
       ])
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.FirmwareError,
-      message: expect.stringContaining('targetIds=3'),
+      message: 'Protocol V2 firmware install timed out',
+      params: { firmwareUpdateCode: 'FirmwareInstallTimeout' },
     });
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(5);
   });
 
-  test('resets the missing-record grace period after a Pro2 reboot interruption', async () => {
+  test('keeps polling incomplete records after a Pro2 reboot interruption', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5298,11 +6809,11 @@ describe('Protocol V2 firmware update targets', () => {
         { target_id: 4, path: 'vol0:/application_p1.bin' },
       ])
     ).resolves.toBeUndefined();
-    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(2);
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
     expect(typedCall).toHaveBeenCalledTimes(4);
   });
 
-  test('uses an eight-minute Pro2 install status window', async () => {
+  test('uses a five-minute Pro2 install status window', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5312,13 +6823,17 @@ describe('Protocol V2 firmware update targets', () => {
     jest
       .spyOn(Date, 'now')
       .mockReturnValueOnce(0)
-      .mockReturnValue(8 * 60 * 1000);
+      .mockReturnValue(5 * 60 * 1000);
 
     await expect(
       (method as any).waitForProtocolV2FirmwareUpdateComplete([
         { target_id: 4, path: 'vol0:/application_p1.bin' },
       ])
-    ).rejects.toThrow('within 480s');
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareError,
+      message: 'Protocol V2 firmware install timed out',
+      params: { firmwareUpdateCode: 'FirmwareInstallTimeout' },
+    });
   });
 
   test('uses a 90-second Pro2 bootloader reconnect window', async () => {
@@ -5396,7 +6911,7 @@ describe('Protocol V2 firmware update targets', () => {
         ],
         new Set([4, 10])
       )
-    ).toThrow('Protocol V2 install status conflicts with target 4');
+    ).toThrow('Protocol V2 firmware install status conflict');
     expect(method.postProgressMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalledWith(100, 'installingFirmware');
 
@@ -5436,8 +6951,8 @@ describe('Protocol V2 firmware update targets', () => {
       throw new Error('Expected Protocol V2 failed firmware status to throw');
     } catch (error: any) {
       expect(error.errorCode).toBe(HardwareErrorCode.FirmwareError);
-      expect(error.message).toContain('FW_MGMT_UPDATER_TASK_STATUS_FAILED_VERIFY');
-      expect(error.message).toContain('vol0:/application_p1.bin');
+      expect(error.message).toBe('Protocol V2 firmware install failed');
+      expect(error.params).toEqual({ firmwareUpdateCode: 'FirmwareInstallFailed' });
     }
   });
 
@@ -5474,7 +6989,8 @@ describe('Protocol V2 firmware update targets', () => {
       ])
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.FirmwareError,
-      message: expect.stringContaining('vol0:/application_p1.bin'),
+      message: 'Protocol V2 firmware install failed',
+      params: { firmwareUpdateCode: 'FirmwareInstallFailed' },
     });
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
@@ -5482,6 +6998,8 @@ describe('Protocol V2 firmware update targets', () => {
       {
         fields: {
           status: true,
+          progress_percent: true,
+          phase_info: true,
           payload_version: true,
           path: true,
         },
@@ -5490,7 +7008,7 @@ describe('Protocol V2 firmware update targets', () => {
     );
   });
 
-  test('passes bootloader, coprocessor, SE and app files to DeviceFirmwareUpdate targets', async () => {
+  test('preserves component-first target order for the firmware-owned loader handoff', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5519,54 +7037,75 @@ describe('Protocol V2 firmware update targets', () => {
       .mockResolvedValue(undefined);
 
     await (method as any).executeProtocolV2Update({
-      bootloaderBinary: new Uint8Array([4, 5]).buffer,
-      fwBinaryMap: [
+      // The active bootloader installs its component runners in records order and
+      // leaves the bootloader record pending for romloader after reboot. Keep boot
+      // deliberately after components to prove Core does not synthesize boot-first.
+      installItems: [
         {
-          fileName: 'coprocessor.bin',
-          binary: new Uint8Array([6]).buffer,
-          targetId: 6,
+          fileName: 'application_p1.bin',
+          binary: new Uint8Array([8]).buffer,
+          targetId: 4,
+          kind: 'firmware',
         },
         {
           fileName: 'se01.bin',
           binary: new Uint8Array([7]).buffer,
           targetId: 7,
+          kind: 'firmware',
         },
         {
-          fileName: 'application_p1.bin',
-          binary: new Uint8Array([8]).buffer,
-          targetId: 4,
+          fileName: 'bootloader.bin',
+          binary: new Uint8Array([4, 5]).buffer,
+          targetId: 3,
+          kind: 'bootloader',
+        },
+        {
+          fileName: 'coprocessor.bin',
+          binary: new Uint8Array([6]).buffer,
+          targetId: 6,
+          kind: 'firmware',
         },
       ],
     });
 
     expect(writtenPaths).toEqual([
+      'vol0:/application_p1.bin',
+      'vol0:/se01.bin',
       'vol0:/bootloader.bin',
       'vol0:/coprocessor.bin',
-      'vol0:/se01.bin',
-      'vol0:/application_p1.bin',
     ]);
     expect((method as any).verifyProtocolV2StagedFile).toHaveBeenCalledTimes(4);
     expect((method as any).verifyProtocolV2StagedFile).toHaveBeenNthCalledWith(
       2,
-      'vol0:/coprocessor.bin',
+      'vol0:/se01.bin',
       1
     );
-    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, {
+    expect((method as any).enterProtocolV2BootloaderMode).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
       targets: [
-        { target_id: 6, path: 'vol0:/coprocessor.bin' },
-        { target_id: 7, path: 'vol0:/se01.bin' },
         { target_id: 4, path: 'vol0:/application_p1.bin' },
+        { target_id: 7, path: 'vol0:/se01.bin' },
+        { target_id: 3, path: 'vol0:/bootloader.bin' },
+        { target_id: 6, path: 'vol0:/coprocessor.bin' },
       ],
     });
+    expect((method as any).waitForProtocolV2FirmwareUpdateComplete).toHaveBeenCalledTimes(1);
+    expect((method as any).waitForProtocolV2FirmwareUpdateComplete).toHaveBeenCalledWith(
+      [
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+        { target_id: 7, path: 'vol0:/se01.bin' },
+        { target_id: 3, path: 'vol0:/bootloader.bin' },
+        { target_id: 6, path: 'vol0:/coprocessor.bin' },
+      ],
+      true
+    );
+    expect((method as any).exitProtocolV2BootloaderToNormal).not.toHaveBeenCalled();
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'transferData');
-    expect((method as any).waitForProtocolV2FirmwareUpdateComplete).toHaveBeenCalled();
+    expect((method as any).completeProtocolV2FinalVerification).toHaveBeenCalledTimes(1);
   });
 
-  test('announces separate resource and component transfer phases', async () => {
+  test('uses one global transfer range for resources and firmware', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5623,18 +7162,24 @@ describe('Protocol V2 firmware update targets', () => {
       ],
     });
 
-    expect(method.postTipMessage).toHaveBeenCalledTimes(3);
+    expect((method as any).enterProtocolV2BootloaderMode).toHaveBeenCalledTimes(1);
+    expect(method.postTipMessage).toHaveBeenCalledTimes(2);
     expect(method.postTipMessage).toHaveBeenNthCalledWith(1, 'StartTransferData');
-    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'StartTransferData');
-    expect(method.postTipMessage).toHaveBeenNthCalledWith(3, 'ConfirmOnDevice');
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'ConfirmOnDevice');
     expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenNthCalledWith(
       1,
-      expect.objectContaining({ processedSize: 0, totalSize: 2 })
+      expect.objectContaining({ processedSize: 0, totalSize: 3 })
     );
     expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenNthCalledWith(
       2,
-      expect.objectContaining({ processedSize: 0, totalSize: 1 })
+      expect.objectContaining({ processedSize: 2, totalSize: 3 })
     );
+    expect(method.postProgressMessage).toHaveBeenCalledTimes(1);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'transferData');
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
+      targets: [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+    });
     expect((method as any).isProtocolV2ResourceBundleUpToDate).toHaveBeenCalledWith(
       expect.objectContaining({
         version: [1, 2, 3],
@@ -5644,50 +7189,7 @@ describe('Protocol V2 firmware update targets', () => {
     );
   });
 
-  test('installs and verifies bootloader before syncing manifest resources', () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: { method: 'firmwareUpdateV4' },
-    });
-    const phases = (method as any).buildProtocolV2ExecutionPhases({
-      installSources: [{ kind: 'bootloader' }, { kind: 'component' }],
-      resourceSources: [{ kind: 'resource' }],
-    });
-
-    expect(phases.map((phase: { kind: string }) => phase.kind)).toEqual([
-      'bootloader-install',
-      'bootloader-verify',
-      'resource-sync',
-      'component-install',
-      'final-verify',
-    ]);
-  });
-
-  test('stages the mounted boot resource before any firmware install phase', () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: { method: 'firmwareUpdateV4' },
-    });
-    const bootResource = {
-      devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg',
-    };
-    const phases = (method as any).buildProtocolV2ExecutionPhases({
-      installSources: [{ kind: 'bootloader' }, { kind: 'component' }],
-      resourceSources: [bootResource, { devicePath: 'vol0:/resource/images/images.okpkg' }],
-    });
-
-    expect(phases.map((phase: { kind: string }) => phase.kind)).toEqual([
-      'resource-sync',
-      'bootloader-install',
-      'bootloader-verify',
-      'resource-sync',
-      'component-install',
-      'final-verify',
-    ]);
-    expect(phases[0].resourceSources).toEqual([bootResource]);
-  });
-
-  test('removes stale boot resource staging before a component-only reboot', async () => {
+  test('removes stale boot resource staging before the combined transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: { method: 'firmwareUpdateV4' },
@@ -5714,18 +7216,18 @@ describe('Protocol V2 firmware update targets', () => {
       events.push('transfer-component');
       return Promise.resolve();
     });
-    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockImplementation(() => {
-      events.push('reboot-normal');
-      return Promise.resolve();
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockImplementation(() => {
+      events.push('final-verify');
+      return Promise.resolve({});
     });
-    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
 
     await (method as any).executeProtocolV2SourceUpdate({
       installSources: [{ kind: 'firmware' }],
       resourceSources: [],
     });
 
-    expect(events).toEqual(['delete-stale-staging', 'transfer-component', 'reboot-normal']);
+    expect((method as any).enterProtocolV2BootloaderMode).toHaveBeenCalledTimes(1);
+    expect(events).toEqual(['delete-stale-staging', 'transfer-component', 'final-verify']);
     expect(typedCall).toHaveBeenNthCalledWith(2, 'FilesystemFileDelete', 'Success', {
       path: 'vol0:/loaders/bootloader/boot_resource.okpkg.staging',
     });
@@ -5911,41 +7413,51 @@ describe('Protocol V2 firmware update targets', () => {
           bootloader: {
             target: 'BOOTLOADER',
             url: 'https://example.com/bootloader.pp.bin',
+            version: [1, 0, 0],
             ...componentIntegrity('https://example.com/bootloader.pp.bin'),
           },
           applicationP1: {
             target: 'APPLICATION_P1',
             url: 'https://example.com/applicationP1.pp.bin',
+            version: [2, 0, 0],
             ...componentIntegrity('https://example.com/applicationP1.pp.bin'),
+            // Core treats the package as opaque; the device owns its internal format validation.
+            payloadHash: '00'.repeat(64),
           },
           applicationP2: {
             target: 'APPLICATION_P2',
             url: 'https://example.com/applicationP2.pp.bin',
+            version: [2, 0, 1],
             ...componentIntegrity('https://example.com/applicationP2.pp.bin'),
           },
           coprocessor: {
             target: 'COPROCESSOR',
             url: 'https://example.com/coprocessor.pp.bin',
+            version: [1, 1, 0],
             ...componentIntegrity('https://example.com/coprocessor.pp.bin'),
           },
           se01: {
             target: 'SE01',
             url: 'https://example.com/se01.pp.bin',
+            version: [1, 2, 1],
             ...componentIntegrity('https://example.com/se01.pp.bin'),
           },
           se02: {
             target: 'SE02',
             url: 'https://example.com/se02.pp.bin',
+            version: [1, 2, 2],
             ...componentIntegrity('https://example.com/se02.pp.bin'),
           },
           se03: {
             target: 'SE03',
             url: 'https://example.com/se03.pp.bin',
+            version: [1, 2, 3],
             ...componentIntegrity('https://example.com/se03.pp.bin'),
           },
           se04: {
             target: 'SE04',
             url: 'https://example.com/se04.pp.bin',
+            version: [1, 2, 4],
             ...componentIntegrity('https://example.com/se04.pp.bin'),
           },
         },
@@ -5983,6 +7495,16 @@ describe('Protocol V2 firmware update targets', () => {
       'https://example.com/se03.pp.bin',
       'https://example.com/se04.pp.bin',
     ]);
+    expect((method as any).params.expectedTargetVersions).toEqual({
+      boot: '1.0.0',
+      app_v1: '2.0.0',
+      app_v2: '2.0.1',
+      coprocessor: '1.1.0',
+      se01: '1.2.1',
+      se02: '1.2.2',
+      se03: '1.2.3',
+      se04: '1.2.4',
+    });
 
     getSysResourceBinarySpy.mockRestore();
     getFirmwareLatestReleaseSpy.mockRestore();
@@ -5997,6 +7519,9 @@ describe('Protocol V2 firmware update targets', () => {
         method: 'firmwareUpdateV4',
         platform: 'web',
         targetsToUpdate: ['app_v1', 'coprocessor'],
+        expectedTargetVersions: {
+          app_v1: '9.9.9',
+        },
       },
     });
     method.init();
@@ -6015,12 +7540,14 @@ describe('Protocol V2 firmware update targets', () => {
           applicationP1: {
             target: 'APPLICATION_P1',
             url: 'https://example.com/applicationP1.pp.bin',
+            version: [2, 0, 0],
             expectedSize: explicitApplicationBinary.byteLength,
             fingerprint: bytesToHex(sha256(new Uint8Array(explicitApplicationBinary))),
           },
           coprocessor: {
             target: 'COPROCESSOR',
             url: 'https://example.com/coprocessor.pp.bin',
+            version: [1, 1, 0],
             expectedSize: remoteCoprocessorBinary.byteLength,
             fingerprint: bytesToHex(sha256(new Uint8Array(remoteCoprocessorBinary))),
           },
@@ -6061,6 +7588,10 @@ describe('Protocol V2 firmware update targets', () => {
         kind: 'firmware',
       },
     ]);
+    expect((method as any).params.expectedTargetVersions).toEqual({
+      app_v1: '9.9.9',
+      coprocessor: '1.1.0',
+    });
 
     getSysResourceBinarySpy.mockRestore();
     getFirmwareLatestReleaseSpy.mockRestore();
@@ -6230,7 +7761,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('maps a prepared resource archive manifest to artifact-backed resource sources', async () => {
+  test('maps self-describing packages from a prepared resource archive', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6238,62 +7769,20 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     const imagesBinary = createProtocolV2OkppBinary();
-    const bootBinary = createProtocolV2OkppBinary({ payloadHashByte: 0x33 });
+    const bootBinary = createProtocolV2OkppBinary({
+      devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg.staging',
+      payloadHashByte: 0x33,
+    });
     const imagesSha256 = bytesToHex(sha256(new Uint8Array(imagesBinary)));
     const bootSha256 = bytesToHex(sha256(new Uint8Array(bootBinary)));
-    const manifest = {
-      schema: 1,
-      artifact_name: 'pro2-resource',
-      release_name: 'test-release',
-      variant: 'resource',
-      commit: 'abc123',
-      short_sha: 'abc123',
-      timestamp_utc: '2026-08-09T00:00:00Z',
-      core_version: '1.0.0',
-      key_set: 'production',
-      device_root: 'vol0:',
-      restore_mode: 'bootloader_update',
-      trees: [{ path: 'bundles', device: 'pro2' }],
-      files: [
-        {
-          archive_path: 'bundles/images/images.okpkg',
-          original_name: 'images.okpkg',
-          device_path: 'vol0:/bundles/images/images.okpkg',
-          size: imagesBinary.byteLength,
-          sha256: imagesSha256,
-          signed: true,
-          sig_algo: 'ed25519',
-          payload_version: '1.2.3',
-        },
-        {
-          archive_path: 'loaders/bootloader/boot_resource.okpkg',
-          original_name: 'boot_resource.okpkg',
-          device_path: 'vol0:/loaders/bootloader/boot_resource.okpkg',
-          size: bootBinary.byteLength,
-          sha256: bootSha256,
-          signed: true,
-          sig_algo: 'ed25519',
-          payload_version: '1.2.3',
-        },
-      ],
-    };
-    const manifestBinary = new TextEncoder().encode(JSON.stringify(manifest)).buffer;
     const zip = new JSZip();
-    zip.file('manifest.json', manifestBinary);
     zip.file('bundles/images/images.okpkg', imagesBinary);
     zip.file('loaders/bootloader/boot_resource.okpkg', bootBinary);
+    zip.file('manifest.json', '{"ignored":true}');
     const archiveBinary = await zip.generateAsync({ type: 'arraybuffer' });
     const preparedEntries = [
       {
-        entryName: 'manifest.json',
-        artifact: {
-          artifactRef: 'manifest',
-          size: manifestBinary.byteLength,
-          sha256: bytesToHex(sha256(new Uint8Array(manifestBinary))),
-        },
-      },
-      {
-        entryName: 'bundles/images/images.okpkg',
+        entryName: 'pro2-resource/bundles/images/images.okpkg',
         artifact: {
           artifactRef: 'images',
           size: imagesBinary.byteLength,
@@ -6301,13 +7790,21 @@ describe('Protocol V2 firmware update targets', () => {
         },
       },
       {
-        entryName: 'loaders/bootloader/boot_resource.okpkg',
+        entryName: 'pro2-resource/loaders/bootloader/boot_resource.okpkg',
         artifact: {
           artifactRef: 'boot',
           size: bootBinary.byteLength,
           sha256: bootSha256,
         },
       },
+      {
+        entryName: 'pro2-resource/build-info.txt',
+        artifact: {
+          artifactRef: 'build-info',
+          size: 1,
+          sha256: 'f'.repeat(64),
+        },
+      },
     ];
     const artifacts = new Map([['archive', archiveBinary]]);
     (method as any).params = {
@@ -6346,16 +7843,11 @@ describe('Protocol V2 firmware update targets', () => {
       }),
       expect.objectContaining({
         name: 'boot_resource.okpkg',
-        devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg',
+        devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg.staging',
         version: [1, 2, 3],
       }),
     ]);
     await Promise.all(sources.map(source => source.source.close()));
-
-    preparedEntries[1].artifact.sha256 = 'f'.repeat(64);
-    await expect((method as any).prepareProtocolV2ResourceArchiveSources()).rejects.toThrow(
-      'entries do not match the approved archive'
-    );
   });
 
   test('binds a prepared resource archive to the selected host generation', () => {
@@ -6397,9 +7889,9 @@ describe('Protocol V2 firmware update targets', () => {
           },
           materializedEntries: [
             {
-              entryName: 'manifest.json',
+              entryName: 'bundles/images/images.okpkg',
               artifact: {
-                artifactRef: 'resource-manifest',
+                artifactRef: 'resource-package',
                 size: 2,
                 sha256: 'b'.repeat(64),
               },
@@ -6463,7 +7955,7 @@ describe('Protocol V2 firmware update targets', () => {
     const componentArtifact = {
       artifactRef: 'prepared-bootloader',
       size: componentBinary.byteLength,
-      sha256: 'a'.repeat(64),
+      sha256: bytesToHex(sha256(new Uint8Array(componentBinary))),
     };
     const planWithoutDigest = {
       schemaVersion: 2 as const,
@@ -6599,9 +8091,9 @@ describe('Protocol V2 firmware update targets', () => {
           },
           materializedEntries: [
             {
-              entryName: 'manifest.json',
+              entryName: 'bundles/images/images.okpkg',
               artifact: {
-                artifactRef: 'prepared-resource-manifest',
+                artifactRef: 'prepared-resource-package',
                 size: 2,
                 sha256: 'b'.repeat(64),
               },
@@ -6657,51 +8149,20 @@ describe('Protocol V2 firmware update targets', () => {
     }
   });
 
-  test('converts a local resource ZIP into a local PreparedPlan without matching a remote release', async () => {
-    const imagesBinary = new Uint8Array([1, 2, 3]).buffer;
-    const bootResourceBinary = new Uint8Array([4, 5, 6]).buffer;
-    const manifest = {
-      schema: 1,
-      artifact_name: 'pro2-resource',
-      release_name: 'local-development',
-      variant: 'resource',
-      commit: 'local',
-      short_sha: 'local',
-      timestamp_utc: '2026-08-09T00:00:00Z',
-      core_version: '1.0.0',
-      key_set: 'development',
-      device_root: 'vol0:',
-      restore_mode: 'bootloader_update',
-      trees: [{ path: 'bundles', device: 'pro2' }],
-      files: [
-        {
-          archive_path: 'bundles/images/images.okpkg',
-          original_name: 'images.okpkg',
-          device_path: 'vol0:/bundles/images/images.okpkg',
-          size: imagesBinary.byteLength,
-          sha256: bytesToHex(sha256(new Uint8Array(imagesBinary))),
-          signed: true,
-          sig_algo: 'ed25519',
-          payload_version: '1.0.0',
-        },
-        {
-          archive_path: 'loaders/bootloader/boot_resource.okpkg',
-          original_name: 'boot_resource.okpkg',
-          device_path: 'vol0:/loaders/bootloader/boot_resource.okpkg',
-          size: bootResourceBinary.byteLength,
-          sha256: bytesToHex(sha256(new Uint8Array(bootResourceBinary))),
-          signed: true,
-          sig_algo: 'ed25519',
-          payload_version: '1.0.0',
-        },
-      ],
-    };
+  test('installs a local resource ZIP without matching a remote release', async () => {
+    const imagesBinary = createProtocolV2OkppBinary({ version: [1, 0, 0] });
+    const bootResourceBinary = createProtocolV2OkppBinary({
+      version: [1, 0, 0],
+      devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg.staging',
+    });
     const zip = new JSZip();
-    zip.file('manifest.json', JSON.stringify(manifest));
-    zip.file('bundles/images/images.okpkg', imagesBinary);
-    zip.file('loaders/bootloader/boot_resource.okpkg', bootResourceBinary);
+    zip.file('pro2-resource/bundles/images/images.okpkg', imagesBinary);
+    zip.file('pro2-resource/loaders/bootloader/boot_resource.okpkg', bootResourceBinary);
+    zip.file('pro2-resource/manifest.json', '{"ignored":true}');
+    zip.file('pro2-resource/build-info.txt', 'ignored');
     const resourceArchiveBinary = await zip.generateAsync({ type: 'arraybuffer' });
     const applicationP1Binary = new Uint8Array([7, 8, 9]).buffer;
+    const bootloaderBinary = new Uint8Array([10, 11, 12]).buffer;
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6709,6 +8170,7 @@ describe('Protocol V2 firmware update targets', () => {
         platform: 'web',
         targetsToUpdate: ['app_v1'],
         applicationP1Binary,
+        bootloaderBinary,
         resourceArchiveBinary,
       },
     });
@@ -6737,11 +8199,7 @@ describe('Protocol V2 firmware update targets', () => {
       await expect(method.run()).resolves.toBe('local-resource-result');
       expect(releaseSpy).not.toHaveBeenCalled();
       expect(reloadSpy).not.toHaveBeenCalled();
-      expect((method as any).params.preparedPlan).toMatchObject({
-        networkPolicy: 'forbid',
-        executor: 'v4',
-        targetsToUpdate: ['app_v1', 'resource'],
-      });
+      expect((method as any).params.preparedPlan).toBeUndefined();
       expect((method as any).executeProtocolV2SourceUpdate).toHaveBeenCalledWith(
         expect.objectContaining({
           installSources: [
@@ -6757,7 +8215,7 @@ describe('Protocol V2 firmware update targets', () => {
             }),
             expect.objectContaining({
               name: 'boot_resource.okpkg',
-              devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg',
+              devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg.staging',
             }),
           ],
         })
@@ -6768,51 +8226,78 @@ describe('Protocol V2 firmware update targets', () => {
     }
   });
 
-  test('rejects a local resource ZIP whose file hash does not match its manifest', async () => {
-    const resourceBinary = new Uint8Array([1, 2, 3]).buffer;
-    const bootResourceBinary = new Uint8Array([4, 5, 6]).buffer;
+  test('accepts every okpkg in a local resource ZIP and ignores other files', async () => {
+    const imagesBinary = createProtocolV2OkppBinary();
+    const bootResourceBinary = createProtocolV2OkppBinary({
+      devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg.staging',
+    });
     const zip = new JSZip();
+    zip.file('pro2-resource/bundles/images/images.okpkg', imagesBinary);
+    zip.file('pro2-resource/loaders/bootloader/boot_resource.okpkg', bootResourceBinary);
+    zip.file('pro2-resource/build-info.txt', 'ignored');
     zip.file(
-      'manifest.json',
-      JSON.stringify({
-        schema: 1,
-        artifact_name: 'pro2-resource',
-        release_name: 'local-development',
-        variant: 'resource',
-        commit: 'local',
-        short_sha: 'local',
-        timestamp_utc: '2026-08-09T00:00:00Z',
-        core_version: '1.0.0',
-        key_set: 'development',
-        device_root: 'vol0:',
-        restore_mode: 'bootloader_update',
-        trees: [{ path: 'bundles', device: 'pro2' }],
-        files: [
-          {
-            archive_path: 'bundles/images/images.okpkg',
-            original_name: 'images.okpkg',
-            device_path: 'vol0:/bundles/images/images.okpkg',
-            size: resourceBinary.byteLength,
-            sha256: '0'.repeat(64),
-            signed: true,
-            sig_algo: 'ed25519',
-            payload_version: '1.0.0',
-          },
-          {
-            archive_path: 'loaders/bootloader/boot_resource.okpkg',
-            original_name: 'boot_resource.okpkg',
-            device_path: 'vol0:/loaders/bootloader/boot_resource.okpkg',
-            size: bootResourceBinary.byteLength,
-            sha256: bytesToHex(sha256(new Uint8Array(bootResourceBinary))),
-            signed: true,
-            sig_algo: 'ed25519',
-            payload_version: '1.0.0',
-          },
-        ],
-      })
+      '__MACOSX/pro2-resource 2/bundles/._images.okpkg',
+      new Uint8Array([0x00, 0x05, 0x16, 0x07])
     );
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['resource'],
+      },
+    });
+    method.init();
+
+    await expect(
+      (method as any).prepareProtocolV2LocalResourceArchive(
+        await zip.generateAsync({ type: 'arraybuffer' })
+      )
+    ).resolves.toMatchObject({
+      resources: [
+        {
+          entryName: 'pro2-resource/bundles/images/images.okpkg',
+          binary: imagesBinary,
+          header: expect.objectContaining({
+            devicePath: 'vol0:/bundles/images/images.okpkg',
+          }),
+        },
+        {
+          entryName: 'pro2-resource/loaders/bootloader/boot_resource.okpkg',
+          binary: bootResourceBinary,
+          header: expect.objectContaining({
+            devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg.staging',
+          }),
+        },
+      ],
+    });
+  });
+
+  test('rejects a local resource ZIP with duplicate package device paths', async () => {
+    const resourceBinary = createProtocolV2OkppBinary();
+    const duplicateResourceBinary = createProtocolV2OkppBinary({ payloadHashByte: 0x44 });
+    const zip = new JSZip();
     zip.file('bundles/images/images.okpkg', resourceBinary);
-    zip.file('loaders/bootloader/boot_resource.okpkg', bootResourceBinary);
+    zip.file('copies/images.okpkg', duplicateResourceBinary);
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['resource'],
+      },
+    });
+    method.init();
+
+    await expect(
+      (method as any).prepareProtocolV2LocalResourceArchive(
+        await zip.generateAsync({ type: 'arraybuffer' })
+      )
+    ).rejects.toThrow('duplicate device path: vol0:/bundles/images/images.okpkg');
+  });
+
+  test('maps malformed resource ZIPs to a typed firmware preparation error', async () => {
+    const loadSpy = jest.spyOn(JSZip, 'loadAsync').mockRejectedValue(new Error('corrupt ZIP'));
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6823,29 +8308,38 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.init();
 
-    await expect(
-      (method as any).prepareProtocolV2LocalResourceArchive(
-        await zip.generateAsync({ type: 'arraybuffer' })
-      )
-    ).rejects.toThrow(
-      'Protocol V2 local resource file does not match manifest: bundles/images/images.okpkg'
-    );
+    try {
+      await expect(
+        (method as any).prepareProtocolV2LocalResourceArchive(new Uint8Array([1]).buffer)
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.RuntimeError,
+        params: { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' },
+      });
+    } finally {
+      loadSpy.mockRestore();
+    }
   });
 
   test('rejects an oversized ZIP entry before allocating its decompressed bytes', async () => {
     const extractEntry = jest.fn();
-    const loadSpy = jest.spyOn(JSZip, 'loadAsync').mockResolvedValue({
-      files: {
-        'manifest.json': {
-          name: 'manifest.json',
-          dir: false,
-          _data: {
-            compressedSize: 1,
-            uncompressedSize: 2 * 1024 * 1024,
-          },
-          async: extractEntry,
-        },
+    const oversizedFileSize = 257 * 1024 * 1024;
+    const zipFiles = {
+      'loaders/bootloader/boot_resource.okpkg': {
+        name: 'loaders/bootloader/boot_resource.okpkg',
+        dir: false,
+        _data: { compressedSize: 1, uncompressedSize: oversizedFileSize },
+        async: extractEntry,
+      },
+      'bundles/images/images.okpkg': {
+        name: 'bundles/images/images.okpkg',
+        dir: false,
+        _data: { compressedSize: 1, uncompressedSize: oversizedFileSize },
+        async: extractEntry,
       },
+    };
+    const loadSpy = jest.spyOn(JSZip, 'loadAsync').mockResolvedValue({
+      files: zipFiles,
+      file: (name: string) => zipFiles[name as keyof typeof zipFiles] ?? null,
     } as unknown as JSZip);
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -6860,7 +8354,7 @@ describe('Protocol V2 firmware update targets', () => {
     try {
       await expect(
         (method as any).prepareProtocolV2LocalResourceArchive(new Uint8Array([1]).buffer)
-      ).rejects.toThrow('declared size exceeds the allowed limit');
+      ).rejects.toThrow('resource package size is invalid');
       expect(extractEntry).not.toHaveBeenCalled();
     } finally {
       loadSpy.mockRestore();
@@ -7012,17 +8506,17 @@ describe('Protocol V2 firmware update targets', () => {
             readAt: jest.fn(),
             close: jest.fn(),
           },
-          devicePath: 'vol0:/resource/images/images.okpkg',
+          devicePath: 'vol0:/bundles/images/images.okpkg',
         },
       ],
     });
 
     expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenCalledTimes(1);
     expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenCalledWith(
-      expect.objectContaining({ filePath: 'vol0:/resource/images/images.okpkg' })
+      expect.objectContaining({ filePath: 'vol0:/bundles/images/images.okpkg' })
     );
     expect((method as any).verifyProtocolV2StagedFile).toHaveBeenCalledWith(
-      'vol0:/resource/images/images.okpkg',
+      'vol0:/bundles/images/images.okpkg',
       3
     );
     expect((method as any).protocolV2StartFirmwareUpdate).not.toHaveBeenCalled();
@@ -7041,6 +8535,9 @@ describe('Protocol V2 firmware update targets', () => {
     method.postProgressMessage = jest.fn();
     (method as any).protocolV2SourceUpdateProcess = jest.fn().mockResolvedValue(3);
     (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
+    (method as any).ensureProtocolV2BootResourceStagingIsEmpty = jest
+      .fn()
+      .mockResolvedValue(undefined);
     (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
 
@@ -7054,7 +8551,7 @@ describe('Protocol V2 firmware update targets', () => {
             readAt: jest.fn(),
             close: jest.fn(),
           },
-          devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg',
+          devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg.staging',
         },
       ],
     });
@@ -7066,7 +8563,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect((method as any).verifyProtocolV2StagedFile).toHaveBeenCalledWith(stagingPath, 3);
   });
 
-  test('rewrites the mounted boot resource staging file even when the final file is current', async () => {
+  test('skips boot resource staging when the live package hash matches', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -7087,7 +8584,7 @@ describe('Protocol V2 firmware update targets', () => {
         readAt: jest.fn(),
         close: jest.fn(),
       },
-      devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg',
+      devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg.staging',
       version: [1, 0, 0],
       payloadHash: '11'.repeat(64),
       headerHash: '22'.repeat(64),
@@ -7098,12 +8595,62 @@ describe('Protocol V2 firmware update targets', () => {
       resourceSources: [resource],
     });
 
-    const stagingPath = 'vol0:/loaders/bootloader/boot_resource.okpkg.staging';
-    expect((method as any).isProtocolV2ResourceBundleUpToDate).not.toHaveBeenCalled();
-    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenCalledWith(
-      expect.objectContaining({ source: resource.source, filePath: stagingPath, totalSize: 3 })
+    expect((method as any).isProtocolV2ResourceBundleUpToDate).toHaveBeenCalledWith(resource);
+    expect((method as any).protocolV2SourceUpdateProcess).not.toHaveBeenCalled();
+  });
+
+  test('compares boot resource staging against the live mounted package path', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+
+    expect(
+      (method as any).getProtocolV2ResourceComparePath(
+        'vol0:/loaders/bootloader/boot_resource.okpkg.staging'
+      )
+    ).toBe('vol0:/loaders/bootloader/boot_resource.okpkg');
+    expect((method as any).getProtocolV2ResourceComparePath('vol0:/bundles/images.okpkg')).toBe(
+      'vol0:/bundles/images.okpkg'
     );
-    expect((method as any).verifyProtocolV2StagedFile).toHaveBeenCalledWith(stagingPath, 3);
+  });
+
+  test('skips bootloader params staging when the on-device package is already current', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+    (method as any).isProtocolV2ResourceBundleUpToDate = jest.fn().mockResolvedValue(true);
+    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
+
+    const resource = {
+      name: 'params.okpkg',
+      source: {
+        size: 3,
+        readAt: jest.fn(),
+        close: jest.fn(),
+      },
+      devicePath: 'vol0:/loaders/bootloader/params.okpkg.staging',
+      version: [1, 0, 0],
+      payloadHash: '11'.repeat(64),
+      headerHash: '22'.repeat(64),
+    };
+
+    await (method as any).executeProtocolV2TransferPhase({
+      installSources: [],
+      resourceSources: [resource],
+    });
+
+    expect((method as any).isProtocolV2ResourceBundleUpToDate).toHaveBeenCalledWith(resource);
+    expect((method as any).protocolV2SourceUpdateProcess).not.toHaveBeenCalled();
   });
 
   test('uses absolute processed_byte offsets and disables append for firmware file writes', async () => {
@@ -7153,7 +8700,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([4000, 97]);
     expect(writePayloads.map(payload => payload.overwrite)).toEqual([true, false]);
     expect(writePayloads.every(payload => payload.append === false)).toBe(true);
-    expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 100]);
+    expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 99]);
     expect(method.postMessage).toHaveBeenLastCalledWith({
       event: 'UI_EVENT',
       type: UI_REQUEST.FIRMWARE_PROGRESS,
@@ -7167,6 +8714,176 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
+  test('does not retry or wrap a stale BLE bond during a V4 file transfer', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const staleBondError = ERRORS.TypedError(HardwareErrorCode.BlePeerRemovedPairingInformation);
+    (method as any).fileWriteChunk = jest.fn().mockRejectedValue(staleBondError);
+    const recoverProtocolV2FileTransfer = jest.fn();
+    (method as any).recoverProtocolV2FileTransfer = recoverProtocolV2FileTransfer;
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array([1]).buffer,
+    });
+
+    try {
+      await expect(
+        (method as any).protocolV2SourceUpdateProcess({
+          source,
+          filePath: 'vol1:firmware.bin',
+          processedSize: 0,
+          totalSize: 1,
+        })
+      ).rejects.toBe(staleBondError);
+    } finally {
+      await source?.close();
+    }
+    expect(recoverProtocolV2FileTransfer).not.toHaveBeenCalled();
+  });
+
+  test('throttles repeated transfer progress while preserving file completion', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn(
+      (
+        _name: string,
+        _resType: string,
+        params: { file: { offset: number; data: { byteLength: number } } }
+      ) =>
+        Promise.resolve({
+          type: 'FilesystemFile',
+          message: {
+            processed_byte: params.file.offset + params.file.data.byteLength,
+          },
+        })
+    );
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      getCurrentDeviceType: () => 'pro2',
+    });
+    (method as any).getProtocolV2FirmwareChunkSize = jest.fn().mockReturnValue(1000);
+    method.postProgressMessage = jest.fn();
+    const dateNowSpy = jest.spyOn(Date, 'now').mockReturnValue(10_000);
+
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(2500).buffer,
+    });
+    try {
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
+        filePath: 'vol0:/resource/images/images.okpkg',
+        processedSize: 0,
+        totalSize: 1_000_000,
+      });
+    } finally {
+      dateNowSpy.mockRestore();
+      await source?.close();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(method.postProgressMessage).toHaveBeenCalledTimes(2);
+    expect(method.postProgressMessage).toHaveBeenNthCalledWith(
+      1,
+      1,
+      'transferData',
+      expect.objectContaining({ transferredBytes: 1000 })
+    );
+    expect(method.postProgressMessage).toHaveBeenNthCalledWith(
+      2,
+      1,
+      'transferData',
+      expect.objectContaining({ transferredBytes: 2500 })
+    );
+  });
+
+  test('sends one monotonic device transfer progress range across multiple files', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn(
+      (
+        _name: string,
+        _resType: string,
+        params: { file: { offset: number; data: { byteLength: number } } }
+      ) =>
+        Promise.resolve({
+          type: 'FilesystemFile',
+          message: {
+            processed_byte: params.file.offset + params.file.data.byteLength,
+          },
+        })
+    );
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      getCurrentDeviceType: () => 'pro2',
+      toMessageObject: () => ({ connectId: 'firmware-device' }),
+    });
+    method.postMessage = jest.fn();
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+    (method as any).isProtocolV2ResourceBundleUpToDate = jest.fn().mockResolvedValue(false);
+    (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
+    (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
+      .fn()
+      .mockResolvedValue(undefined);
+
+    const resourceSource = await openFirmwareByteSource({
+      binary: new Uint8Array(4097).buffer,
+    });
+    const firmwareSource = await openFirmwareByteSource({
+      binary: new Uint8Array(4097).buffer,
+    });
+    try {
+      await (method as any).executeProtocolV2TransferPhase({
+        resourceSources: [
+          {
+            name: 'images.okpkg',
+            source: resourceSource,
+            devicePath: 'vol0:/resource/images/images.okpkg',
+          },
+        ],
+        installSources: [
+          {
+            fileName: 'application_p1.bin',
+            source: firmwareSource,
+            targetId: 4,
+            kind: 'firmware',
+          },
+        ],
+      });
+    } finally {
+      await resourceSource?.close();
+      await firmwareSource?.close();
+    }
+
+    const writePayloads = typedCall.mock.calls.map(call => call[2]);
+    const deviceProgress = writePayloads.map(payload => payload.ui_percentage);
+    expect(deviceProgress).toEqual([0, 50, 99, 99]);
+    expect(deviceProgress.filter(progress => progress === 0)).toHaveLength(1);
+    expect(deviceProgress.filter(progress => progress === 100)).toHaveLength(0);
+    expect(method.postTipMessage).toHaveBeenCalledTimes(2);
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(1, 'StartTransferData');
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'ConfirmOnDevice');
+    expect(
+      (method.postProgressMessage as jest.Mock).mock.calls.filter(
+        ([progress, progressType]) => progress === 100 && progressType === 'transferData'
+      )
+    ).toHaveLength(1);
+  });
+
   // TODO(#850/#855): PR #855 added resume-on-retry and per-chunk retry on the
   // writeProtocolV2File path. PR #850 replaced that path with FirmwareByteSource
   // streaming (protocolV2SourceUpdateProcess), which restarts a failed transfer from
@@ -7474,7 +9191,7 @@ describe('Protocol V2 firmware update targets', () => {
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
     expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 1800]);
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1800, 1]);
-    expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 100]);
+    expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 99]);
     expect(typedCall.mock.calls.map(call => call[3])).toEqual([
       expect.objectContaining({
         writeWithResponse: false,
@@ -7533,45 +9250,67 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1960, 1]);
   });
 
-  test('ends device confirmation and starts install progress only after Protocol V2 ACK', async () => {
+  test('keeps confirmation active after the Request write until terminal Success arrives', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    let resolveRequest: ((value: unknown) => void) | undefined;
-    const typedCall = jest.fn().mockImplementation(
-      () =>
-        new Promise(resolve => {
-          resolveRequest = resolve;
-        })
-    );
+    let onResponseAfterWrite:
+      | ((response: { type: string; message: Record<string, never> }) => void)
+      | undefined;
+    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
+    const call = jest.fn().mockImplementation((_type, _message, options) => {
+      onResponseAfterWrite = options.onResponseAfterWrite;
+      return Promise.resolve({ type: 'WriteCompleted', message: {} });
+    });
+    const clearCancelableAction = jest.fn();
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall }),
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
+      clearCancelableAction,
     });
+    method.postMessage = jest.fn();
     method.postProgressMessage = jest.fn();
     method.postTipMessage = jest.fn();
 
     const startPromise = (method as any).protocolV2StartFirmwareUpdate({
       targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
     });
-    await Promise.resolve();
+    await new Promise<void>(resolve => {
+      setImmediate(resolve);
+    });
 
-    expect(typedCall.mock.calls[0][1]).toBe('Success');
-    expect(typedCall.mock.calls[0][3]).toEqual(expect.objectContaining({ timeoutMs: 180_000 }));
+    expect(typedCall.mock.calls[0]).toEqual([
+      'DeviceFirmwareUpdateStage',
+      'Success',
+      { targets: [{ target_id: 4, path: 'vol1:firmware.bin' }] },
+    ]);
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
+    );
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
+    expect(clearCancelableAction).not.toHaveBeenCalled();
 
-    resolveRequest?.({ type: 'Success', message: { message: 'ok' } });
     await startPromise;
-    expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
-    expect(method.postProgressMessage).toHaveBeenCalledWith(0, 'installingFirmware');
-    expect(method.postTipMessage).toHaveBeenCalledTimes(1);
+    onResponseAfterWrite?.({ type: 'Success', message: {} });
+    expect(clearCancelableAction).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2InstallTerminalSuccessObserved).toBe(true);
+    expect(method.postTipMessage).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
-  test('requests only a Success ACK for Protocol V2 firmware install', async () => {
+  test('returns after the empty Protocol V2 firmware install request is written', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -7582,10 +9321,17 @@ describe('Protocol V2 firmware update targets', () => {
       type: 'Success',
       message: { message: 'accepted' },
     });
+    const call = jest.fn().mockResolvedValue({
+      type: 'WriteCompleted',
+      message: {},
+    });
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall }),
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
     });
+    method.postMessage = jest.fn();
     method.postProgressMessage = jest.fn();
     method.postTipMessage = jest.fn();
 
@@ -7593,13 +9339,23 @@ describe('Protocol V2 firmware update targets', () => {
       targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
     });
 
-    expect(typedCall.mock.calls[0][1]).toBe('Success');
-    expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
+    expect(typedCall.mock.calls[0][0]).toBe('DeviceFirmwareUpdateStage');
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
+    );
+    expect(method.postTipMessage).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 });
 
 describe('Protocol V2 firmware update method', () => {
-  test('returns DeviceFirmwareUpdateStatus from low-level update trigger', async () => {
+  test('stages targets before sending the empty low-level update trigger', async () => {
     const method = new DeviceFirmwareUpdate({
       id: 1,
       payload: {
@@ -7610,22 +9366,25 @@ describe('Protocol V2 firmware update method', () => {
     });
     method.init();
 
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceFirmwareUpdateStatus',
-      message: { records: [{ target_id: 4, status: 1 }] },
-    });
+    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
+    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
 
     (method as any).device = stubDevice({
-      commands: { typedCall },
+      commands: { typedCall, call },
     });
 
     await expect(method.run()).resolves.toEqual({
-      records: [{ target_id: 4, status: 1 }],
+      message: 'Device firmware update started',
     });
-    expect(typedCall.mock.calls[0][1]).toEqual(['Success', 'DeviceFirmwareUpdateStatus']);
-    expect(typedCall.mock.calls[0][2]).toEqual({
+    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateStage', 'Success', {
       targets: [{ target_id: 4, path: 'vol0:firmware.bin' }],
     });
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      { returnAfterWrite: true }
+    );
+    expect(typedCall.mock.invocationCallOrder[0]).toBeLessThan(call.mock.invocationCallOrder[0]);
   });
 
   test('treats WebUSB open NotFoundError from low-level update trigger as expected disconnect', async () => {
@@ -7724,6 +9483,7 @@ describe('Protocol V2 firmware update method', () => {
 
   test('accepts targetId alias inside firmware targets', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: {} });
+    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
     const method = new DeviceFirmwareUpdate({
       id: 1,
       payload: {
@@ -7739,7 +9499,7 @@ describe('Protocol V2 firmware update method', () => {
     });
     method.init();
     (method as any).device = stubDevice({
-      commands: { typedCall },
+      commands: { typedCall, call },
     });
 
     await method.run();
@@ -7750,6 +9510,7 @@ describe('Protocol V2 firmware update method', () => {
 
   test('accepts firmware target enum names from low-level update params', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: {} });
+    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
     const method = new DeviceFirmwareUpdate({
       id: 1,
       payload: {
@@ -7760,7 +9521,7 @@ describe('Protocol V2 firmware update method', () => {
     });
     method.init();
     (method as any).device = stubDevice({
-      commands: { typedCall },
+      commands: { typedCall, call },
     });
 
     await method.run();
@@ -7772,7 +9533,16 @@ describe('Protocol V2 firmware update method', () => {
   test('passes firmware update status fields through to Protocol V2', async () => {
     const typedCall = jest.fn().mockResolvedValue({
       message: {
-        records: [{ target_id: 4, status: 2, payload_version: 1, path: 'vol1:application_p1.bin' }],
+        records: [
+          {
+            target_id: 4,
+            status: 1,
+            progress_percent: 42,
+            phase_info: { phase: 1, progress_percent: 60 },
+            payload_version: 1,
+            path: 'vol1:application_p1.bin',
+          },
+        ],
       },
     });
     const method = new DeviceGetFirmwareUpdateStatus({
@@ -7781,6 +9551,8 @@ describe('Protocol V2 firmware update method', () => {
         method: 'deviceGetFirmwareUpdateStatus',
         fields: {
           status: true,
+          progress_percent: true,
+          phase_info: true,
           payload_version: true,
           path: true,
         },
@@ -7792,7 +9564,16 @@ describe('Protocol V2 firmware update method', () => {
     });
 
     await expect(method.run()).resolves.toEqual({
-      records: [{ target_id: 4, status: 2, payload_version: 1, path: 'vol1:application_p1.bin' }],
+      records: [
+        {
+          target_id: 4,
+          status: 1,
+          progress_percent: 42,
+          phase_info: { phase: 1, progress_percent: 60 },
+          payload_version: 1,
+          path: 'vol1:application_p1.bin',
+        },
+      ],
     });
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
@@ -7800,6 +9581,8 @@ describe('Protocol V2 firmware update method', () => {
       {
         fields: {
           status: true,
+          progress_percent: true,
+          phase_info: true,
           payload_version: true,
           path: true,
         },
@@ -7992,7 +9775,7 @@ describe('Protocol V2 firmware reconnect identity', () => {
     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 } });
+        return Promise.resolve({ message: { exist: true, directory: false, size: 0x5f91 } });
       }
       if (requestType === 'FilesystemFileRead') {
         readChunkLengths.push(request.chunk_len);
@@ -8159,6 +9942,8 @@ describe('Protocol V2 reboot methods', () => {
     const device = stubDevice({ commands: { typedCall } });
     (method as any).device = device;
 
+    expect(method.unlockPolicy).toBe('unlock-before-run');
+
     await method.run();
 
     expect(typedCall).toHaveBeenCalledWith('DeviceReboot', 'Success', {
@@ -8488,6 +10273,29 @@ describe('Protocol V2 protected method execution', () => {
     }
   );
 
+  test('skips DeviceStatus and unlock when Protocol V2 is not initialized', async () => {
+    const method = {
+      name: 'firmwareUpdateV4',
+      unlockPolicy: 'unlock-before-run',
+      run: jest.fn().mockResolvedValue({ message: 'updating' }),
+    };
+    const device = {
+      state: { status: { initialized: false } },
+      commands: { typedCall: jest.fn() },
+      isProtocolV2: () => true,
+      isBootloader: () => false,
+      isRomloader: () => false,
+      unlockDevice: jest.fn(),
+    };
+
+    await expect(runMethodWithUnlockPolicy(method as any, device as any)).resolves.toEqual({
+      message: 'updating',
+    });
+    expect(device.commands.typedCall).not.toHaveBeenCalled();
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+    expect(method.run).toHaveBeenCalledTimes(1);
+  });
+
   test('keeps Protocol V1 and lock-free methods outside the preflight path', async () => {
     for (const [isProtocolV2, unlockPolicy] of [
       [false, 'unlock-before-run'],
@@ -8667,7 +10475,7 @@ describe('Protocol V2 current low-level methods', () => {
       info: {
         version: undefined,
         serial_number: 'PR2SERIAL',
-        burn_in_completed: true,
+        factory_burn_in_completed: true,
         factory_test_completed: undefined,
         manufacture_time: undefined,
       },
@@ -8917,7 +10725,7 @@ describe('Protocol V2 raw device info method', () => {
       'DeviceInfoGet',
       'DeviceInfo',
       {
-        targets: { hw: true, fw: true, coprocessor: true },
+        targets: { hw: true, main_mcu: true, coprocessor: true },
         types: { version: true, specific: true },
       },
       { timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS }