@onekeyfe/hd-core 1.2.0-alpha.99 → 1.2.1-alpha.0

package/src/api/FirmwareUpdateV4.ts

@@ -1,7 +1,15 @@
-import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
+import {
+  EDeviceType,
+  ERRORS,
+  HardwareError,
+  HardwareErrorCode,
+  isBleStaleBondHardwareError,
+  wait,
+} from '@onekeyfe/hd-shared';
 import JSZip from 'jszip';
 import {
   DeviceRebootType,
+  DeviceSessionPinType,
   PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
   PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE,
   PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE,
@@ -9,7 +17,7 @@ import {
 } from '@onekeyfe/hd-transport';
 import { sha256 } from '@noble/hashes/sha256';
 
-import { FirmwareUpdateTipMessage, UI_REQUEST } from '../events/ui-request';
+import { FirmwareUpdateTipMessage, UI_REQUEST, createUiMessage } from '../events/ui-request';
 import { validateParams } from './helpers/paramsValidator';
 import {
   LoggerNames,
@@ -31,31 +39,30 @@ import {
 } from '../protocols/protocol-v2';
 import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
 import {
-  parseProtocolV2ResourceManifest,
-  selectProtocolV2ResourceManifestFiles,
+  PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH,
+  PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH,
+  PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE,
+  type ProtocolV2ResourcePackageHeader,
+  isProtocolV2ResourceArchiveEntryName,
+  parseProtocolV2ResourcePackage,
+  parseProtocolV2ResourcePackageHeader,
 } from '../protocols/protocol-v2/resources';
 import {
   getProtocolV2UnknownErrorText,
   isProtocolV2DeviceDisconnectedError,
 } from './protocol-v2/helpers';
+import { isProtocolV2ResponseTimeout } from './helpers/protocolV2FileWrite';
 import {
   openFirmwareByteSource,
   readFirmwareByteSourceFully,
   writeFirmwareByteSource,
 } from './firmware/FirmwareArtifactSource';
-import {
-  registerFirmwareUpdateHostBinding,
-  resolveFirmwareUpdateHostBinding,
-  unregisterFirmwareUpdateHostBinding,
-} from './firmware/FirmwareHostBinding';
+import { resolveFirmwareUpdateHostBinding } from './firmware/FirmwareHostBinding';
 import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
-  prepareFirmwareUpdatePlan,
   validateFirmwareUpdatePreparedPlan,
 } from './firmware/FirmwareUpdatePreparedPlan';
-import { prepareFirmwareUpdateV4MemoryHost } from './firmware/FirmwareMemoryHost';
-import { buildProtocolV2LocalFirmwareUpdatePlan } from './firmware/FirmwareUpdatePlan';
 
 import type {
   FirmwareArtifactReference,
@@ -70,13 +77,9 @@ import type {
   IFirmwareReleaseInfo,
   IProtocolV2FirmwareComponent,
   IVersionArray,
+  KnownDevice,
 } from '../types';
 import type { FirmwareByteSource } from './firmware/FirmwareArtifactSource';
-import type {
-  FirmwareMemoryArtifact,
-  FirmwareMemoryArtifactEntry,
-  FirmwareUpdateV4MemoryHost,
-} from './firmware/FirmwareMemoryHost';
 
 const Log = getLogger(LoggerNames.Method);
 
@@ -88,9 +91,9 @@ const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
 const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
 const PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
-const PROTOCOL_V2_START_UPDATE_TIMEOUT = 3 * 60 * 1000;
-const PROTOCOL_V2_INSTALL_TIMEOUT = 8 * 60 * 1000;
-const PROTOCOL_V2_MISSING_TARGET_STATUS_GRACE_TIMEOUT = 30 * 1000;
+const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
+const PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY = 1000;
+const PROTOCOL_V2_INSTALL_FINISHED_AFTER_DISCONNECT_POLLS = 4;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
@@ -103,12 +106,10 @@ const PROTOCOL_V2_CONNECT_POLL_INTERVAL = 500;
 const PROTOCOL_V2_CONNECT_SINGLE_TIMEOUT = 75 * 1000;
 const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 30 * 1000;
 const PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT = 3;
+const PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS = 1000;
 const PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE = 'FirmwareInstallStatusConflict';
-const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
-const PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET = 0x200;
-const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET = 0x240;
-const PROTOCOL_V2_OKPP_HASH_SIZE = 64;
-const PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES = 1024 * 1024;
+const PROTOCOL_V2_INSTALL_FAILED_CODE = 'FirmwareInstallFailed';
+const PROTOCOL_V2_INSTALL_TIMEOUT_CODE = 'FirmwareInstallTimeout';
 const PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT = 512;
 const PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES = 256 * 1024 * 1024;
 
@@ -151,6 +152,18 @@ export function assertProtocolV2FirmwareTargetsSupported(
   if (params.se04Binary && (!hasExplicitTargetSelection || requestedTargets.has('se04'))) {
     unsupportedTargets.add('se04');
   }
+  if (
+    params.componentArtifacts?.se03 &&
+    (!hasExplicitTargetSelection || requestedTargets.has('se03'))
+  ) {
+    unsupportedTargets.add('se03');
+  }
+  if (
+    params.componentArtifacts?.se04 &&
+    (!hasExplicitTargetSelection || requestedTargets.has('se04'))
+  ) {
+    unsupportedTargets.add('se04');
+  }
 
   if (!unsupportedTargets.size || deviceType === EDeviceType.Pro2) return;
 
@@ -168,26 +181,26 @@ const getProtocolV2DeviceTransferProgress = (
   totalBytes: number
 ) => {
   if (!Number.isFinite(totalBytes) || totalBytes <= 0) {
-    return 100;
+    return 0;
   }
   if (bytesBeforeChunk <= 0 && bytesAfterChunk < totalBytes) {
     return 0;
   }
-  if (bytesAfterChunk >= totalBytes) {
-    return 100;
-  }
   return Math.min(Math.max(Math.ceil((bytesAfterChunk / totalBytes) * 100), 1), 99);
 };
 
 type ProtocolV2FirmwareUpdateStatusTarget = {
   target_id: number | string;
   status?: number | string;
+  progress_percent?: number;
+  phase_info?: {
+    phase: number | string;
+    progress_percent: number;
+  };
   payload_version?: number;
   path?: string;
 };
 
-type ProtocolV2FirmwareUpdateStartResponse = TypedResponseMessage<'Success'>;
-
 type ProtocolV2TargetBinary = { fileName: string; binary: ArrayBuffer; targetId: number };
 type ProtocolV2InstallItem = ProtocolV2TargetBinary & {
   kind: ProtocolV2RemoteComponentTarget['kind'];
@@ -221,7 +234,11 @@ type ProtocolV2ResourceBundleSource = {
 
 type ProtocolV2LocalResourceArchive = {
   binary: ArrayBuffer;
-  materializedEntries: FirmwareMemoryArtifactEntry[];
+  resources: Array<{
+    entryName: string;
+    binary: ArrayBuffer;
+    header: ProtocolV2ResourcePackageHeader;
+  }>;
 };
 
 type JSZipSizedEntry = JSZip.JSZipObject & {
@@ -231,26 +248,11 @@ type JSZipSizedEntry = JSZip.JSZipObject & {
   };
 };
 
-type ProtocolV2ExecutionPhaseKind =
-  | 'resource-sync'
-  | 'bootloader-install'
-  | 'bootloader-verify'
-  | 'component-install'
-  | 'final-verify';
-
-type ProtocolV2ExecutionPhase = {
-  kind: ProtocolV2ExecutionPhaseKind;
+type ProtocolV2TransferBatch = {
   installSources: ProtocolV2InstallSource[];
   resourceSources: ProtocolV2ResourceBundleSource[];
 };
 
-type ProtocolV2OkppHeader = {
-  type: string;
-  version: IVersionArray;
-  payloadHash: string;
-  headerHash: string;
-};
-
 const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS: Readonly<
   Record<string, ProtocolV2RemoteComponentTarget>
 > = {
@@ -302,18 +304,9 @@ const PROTOCOL_V2_FIRMWARE_STAGING_PATHS = new Set(
   )
 );
 
-const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH = 'vol0:/loaders/bootloader/boot_resource.okpkg';
-const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH = `${PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH}.staging`;
-
 const isProtocolV2BootResourcePackagePath = (devicePath: string) =>
   typeof devicePath === 'string' &&
-  devicePath.replace(/^vol0:(?!\/)/i, 'vol0:/').toLowerCase() ===
-    PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH;
-
-const resolveProtocolV2ResourceWritePath = (devicePath: string) =>
-  isProtocolV2BootResourcePackagePath(devicePath)
-    ? PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH
-    : devicePath;
+  devicePath.toLowerCase() === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH;
 
 const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map<
   number,
@@ -381,11 +374,22 @@ const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
   );
 };
 
+const isProtocolV2InstallResponseTimeout = (error: unknown) => {
+  if (!error || typeof error !== 'object') return false;
+  const { code } = error as { code?: number | string };
+  return (
+    code === 'response-timeout' ||
+    /\bresponse timeout\b/i.test(getProtocolV2UnknownErrorText(error))
+  );
+};
+
 const isProtocolV2TerminalInstallStatusError = (error: unknown) =>
-  error instanceof HardwareError &&
-  (error.errorCode === HardwareErrorCode.FirmwareError ||
-    error.errorCode === HardwareErrorCode.FirmwareVerificationFailed ||
-    error.params?.firmwareUpdateCode === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE);
+  isBleStaleBondHardwareError(error) ||
+  (error instanceof HardwareError &&
+    (error.errorCode === HardwareErrorCode.ActionCancelled ||
+      error.errorCode === HardwareErrorCode.FirmwareError ||
+      error.errorCode === HardwareErrorCode.FirmwareVerificationFailed ||
+      error.params?.firmwareUpdateCode === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE));
 
 const isProtocolV2TargetStatusFinished = (status: ProtocolV2FirmwareUpdateStatusTarget['status']) =>
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_FINISHED;
@@ -422,6 +426,18 @@ const normalizeProtocolV2TargetStatus = (
   return undefined;
 };
 
+const PROTOCOL_V2_INSTALL_PHASE_BY_DECODED_VALUE = new Map<
+  number | string,
+  'prepare' | 'install' | 'verify'
+>([
+  [0, 'prepare'],
+  [1, 'install'],
+  [2, 'verify'],
+  ['FW_MGMT_UPDATER_PHASE_PREPARE', 'prepare'],
+  ['FW_MGMT_UPDATER_PHASE_INSTALL', 'install'],
+  ['FW_MGMT_UPDATER_PHASE_VERIFY', 'verify'],
+]);
+
 const normalizeProtocolV2Hex = (value?: string) => value?.replace(/^0x/i, '').toLowerCase();
 
 const versionArrayToNumber = (version?: IVersionArray) => {
@@ -479,40 +495,9 @@ const toProtocolV2FiniteNumber = (value: unknown) => {
   return undefined;
 };
 
-const readProtocolV2Ascii = (bytes: Uint8Array, offset: number, length: number) =>
-  Array.from(bytes.slice(offset, offset + length))
-    .map(byte => String.fromCharCode(byte))
-    .join('');
-
-const parseProtocolV2OkppHeader = (bytes: Uint8Array): ProtocolV2OkppHeader | null => {
-  if (bytes.byteLength < PROTOCOL_V2_OKPP_HEADER_SIZE) return null;
-  if (readProtocolV2Ascii(bytes, 0, 4) !== 'OKPP') return null;
-
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const headerLen = view.getUint32(0x0c, true);
-  if (headerLen !== PROTOCOL_V2_OKPP_HEADER_SIZE) return null;
-
-  const packedVersion = view.getUint32(0x10, true);
-  return {
-    type: readProtocolV2Ascii(bytes, 0x08, 4),
-    version: [
-      Math.floor(packedVersion / 0x10000) % 0x100,
-      Math.floor(packedVersion / 0x100) % 0x100,
-      packedVersion % 0x100,
-    ],
-    payloadHash: bytesToHex(
-      bytes.slice(
-        PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET,
-        PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE
-      )
-    ),
-    headerHash: bytesToHex(
-      bytes.slice(
-        PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET,
-        PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE
-      )
-    ),
-  };
+const normalizeProtocolV2ProgressPercent = (value: unknown) => {
+  const progress = toProtocolV2FiniteNumber(value);
+  return progress === undefined ? undefined : Math.min(100, Math.max(0, progress));
 };
 
 export const isProtocolV2FirmwareFingerprintValid = (
@@ -557,7 +542,7 @@ export const assertProtocolV2ReconnectIdentity = (
  *
  * It intentionally does not fall back to FirmwareUpdateV3/V1 behavior:
  * - upload uses FilesystemFileWrite
- * - install uses DeviceFirmwareUpdateRequest
+ * - install uses DeviceFirmwareUpdateStage followed by an empty DeviceFirmwareUpdateRequest
  * - completion waits for target status to finish, reboots to normal, then polls DeviceInfo
  */
 export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareUpdateV4Params> {
@@ -579,19 +564,56 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2CompletedTargetVersions = new Map<number, number>();
 
+  private protocolV2CompletedTargetIds = new Set<number>();
+
   private protocolV2LatestFinalFeatures?: Features;
 
-  private protocolV2FinalStatusVerified = false;
+  private protocolV2LatestFinalDeviceInfo?: ProtocolV2DeviceInfo;
+
+  private protocolV2InstallBaselineVersions = new Map<number, string>();
+
+  private protocolV2InstallNeedsReconnect = false;
+
+  private protocolV2InstallDisconnectObserved = false;
+
+  private protocolV2InstallTerminalSuccessObserved = false;
+
+  private protocolV2LastRuntimeProbeFeatures?: Features;
+
+  private protocolV2LastTransferProgress?: number;
+
+  private protocolV2LastTransferProgressAt = 0;
 
   init() {
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
     this.requireDeviceMode = [];
     this.unlockPolicy = 'unlock-before-run';
+    // Protocol V2 device-management actions are not wallet-scoped, so either
+    // the main PIN or an Attach PIN may authorize them.
+    this.protocolV2PreUnlockPinType = DeviceSessionPinType.Any;
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;
 
     const { payload } = this;
 
+    const removedResourceInputs = ['resourceFiles', 'resourceBundleArtifacts'].filter(input =>
+      Object.prototype.hasOwnProperty.call(payload, input)
+    );
+    if (removedResourceInputs.length > 0) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        `Protocol V2 ${removedResourceInputs.join(
+          ' and '
+        )} inputs are no longer supported; use resourceArchiveBinary for local updates or preparedPlan with hostBindingGeneration for remote updates`
+      );
+    }
+    if (payload.hostBindingGeneration !== undefined && !payload.preparedPlan) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Protocol V2 hostBindingGeneration requires preparedPlan for remote updates; use direct binaries or resourceArchiveBinary for local updates'
+      );
+    }
+
     this.protocolV2HasExplicitTargetSelection = payload.targetsToUpdate !== undefined;
 
     if (typeof payload.retryCount !== 'number') {
@@ -661,10 +683,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         payload.hostBindingGeneration,
         preparedPlan.preparedPlanDigest
       ).artifactReader;
-    } else if (payload.hostBindingGeneration !== undefined) {
-      artifactReader = resolveFirmwareUpdateHostBinding(
-        payload.hostBindingGeneration
-      ).artifactReader;
     }
     if (preparedPlan) {
       assertFirmwareUpdatePreparedPlanBinding({
@@ -787,6 +805,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async runProtocolV2() {
     await this.captureProtocolV2PhysicalIdentity();
     const deviceFeatures = await this.getProtocolV2DeviceFeatures();
+    this.protocolV2InstallBaselineVersions =
+      this.getProtocolV2ObservableTargetVersions(deviceFeatures);
+    this.protocolV2LastRuntimeProbeFeatures = undefined;
     const currentDeviceType = this.device.getCurrentDeviceType();
     const capabilityDeviceType =
       currentDeviceType === EDeviceType.Pro2 || currentDeviceType === EDeviceType.Neo
@@ -800,21 +821,14 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const deviceFirmwareType = getFirmwareType(deviceFeatures);
     const firmwareType = this.params.firmwareType ?? deviceFirmwareType;
     this.validateExpectedTargetVersions();
+    const wantsResources = !!this.params.targetsToUpdate?.includes('resource');
 
     if (
       !this.params.preparedPlan &&
       this.params.resourceArchiveBinary &&
       this.params.targetsToUpdate?.includes('resource')
     ) {
-      const localMemoryHost = await this.prepareProtocolV2LocalMemoryHost({
-        features: deviceFeatures,
-        firmwareType,
-      });
-      try {
-        return await this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
-      } finally {
-        localMemoryHost.release();
-      }
+      return this.runProtocolV2DirectArtifacts({});
     }
 
     const hasPreparedComponentArtifacts = Object.values(this.params.componentArtifacts ?? {}).some(
@@ -823,16 +837,16 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     if (this.params.preparedPlan || hasPreparedComponentArtifacts) {
       return this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
     }
-    const wantsResources = !!this.params.targetsToUpdate?.includes('resource');
 
     let fwBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
     let installItems: ProtocolV2InstallItem[] | undefined;
+    let explicitInstallItems: ProtocolV2InstallItem[] | undefined;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
       fwBinaryMap = this.collectExplicitTargetBinaries();
       bootloaderBinary = this.prepareBootloaderBinary();
-      const explicitInstallItems = this.buildProtocolV2InstallItems({
+      explicitInstallItems = this.buildProtocolV2InstallItems({
         bootloaderBinary,
         fwBinaryMap,
       });
@@ -840,17 +854,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       const needsRemoteFirmware = this.params.targetsToUpdate?.length
         ? missingFirmwareTargets.length > 0
         : explicitInstallItems.length === 0;
-      if (wantsResources) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Protocol V2 resource archive must be provided through a local or external PreparedPlan',
-          {
-            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-          }
-        );
-      }
+      const needsSdkManagedArtifacts = needsRemoteFirmware || wantsResources;
       if (
-        needsRemoteFirmware &&
+        needsSdkManagedArtifacts &&
         (this.params.artifactReader ||
           DataManager.getSettings('firmwareManifestMode') === 'external-only')
       ) {
@@ -862,9 +868,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           }
         );
       }
-      if (needsRemoteFirmware) {
+      if (needsSdkManagedArtifacts) {
         // Remote updates must use a freshly fetched config before any reboot or file write.
-        await DataManager.forceReloadData();
+        await DataManager.forceReloadData({
+          requireResources: wantsResources,
+          resourceDeviceType:
+            capabilityDeviceType === EDeviceType.Neo ? EDeviceType.Neo : EDeviceType.Pro2,
+        });
       }
       if (needsRemoteFirmware) {
         const remoteBinaries = await this.prepareRemoteProtocolV2Binaries(
@@ -887,6 +897,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             targetId: item.targetId,
           }));
       }
+      if (wantsResources) {
+        this.params.resourceArchiveBinary = await this.downloadRemoteProtocolV2ResourceArchive(
+          deviceFeatures,
+          firmwareType
+        );
+      }
       this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
     } catch (err) {
       if (
@@ -903,6 +919,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       throw normalizeFirmwarePreparationError(err);
     }
 
+    if (wantsResources && this.params.resourceArchiveBinary) {
+      return this.runProtocolV2DirectArtifacts({
+        availableInstallItems: installItems ?? explicitInstallItems,
+        announceDownload: false,
+      });
+    }
+
     if (!bootloaderBinary && fwBinaryMap.length === 0 && !installItems?.length) {
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareUpdateDownloadFailed,
@@ -1053,132 +1076,69 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return installSources;
   }
 
-  private async prepareProtocolV2LocalMemoryHost({
-    features,
-    firmwareType,
+  private async runProtocolV2DirectArtifacts({
+    availableInstallItems,
+    announceDownload = true,
   }: {
-    features: Features;
-    firmwareType: EFirmwareType;
-  }): Promise<FirmwareUpdateV4MemoryHost> {
-    const availableInstallItems = this.buildProtocolV2InstallItems({
-      bootloaderBinary: this.prepareBootloaderBinary(),
-      fwBinaryMap: this.collectExplicitTargetBinaries(),
-    });
-    const requestedComponentTargets = new Set(
-      (this.params.targetsToUpdate ?? []).filter(
-        (target): target is Exclude<FirmwareUpdateV4Target, 'resource' | 'boot_resources'> =>
-          target !== 'resource' && target !== 'boot_resources'
-      )
-    );
-    const localComponentTargets = new Set(
-      availableInstallItems.flatMap(item => {
-        const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
-        return target ? [target] : [];
-      })
-    );
-    const missingTarget = Array.from(requestedComponentTargets).find(
-      target => !localComponentTargets.has(target)
-    );
-    if (missingTarget) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `Protocol V2 local update has no binary for requested target ${missingTarget}`,
-        {
-          firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-          artifactName: missingTarget,
-        }
+    availableInstallItems?: ProtocolV2InstallItem[];
+    announceDownload?: boolean;
+  }) {
+    try {
+      if (announceDownload) {
+        this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
+      }
+      const installItems = this.filterProtocolV2LocalInstallItems(
+        availableInstallItems ??
+          this.buildProtocolV2InstallItems({
+            bootloaderBinary: this.prepareBootloaderBinary(),
+            fwBinaryMap: this.collectExplicitTargetBinaries(),
+          })
       );
-    }
-    const installItems = this.filterProtocolV2LocalInstallItems(availableInstallItems);
-
-    const planArtifacts: Parameters<typeof buildProtocolV2LocalFirmwareUpdatePlan>[0]['artifacts'] =
-      [];
-    const memoryArtifacts: FirmwareMemoryArtifact[] = [];
-    for (const item of installItems) {
-      const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
-      if (!target || item.binary.byteLength <= 0) {
+      const installSources = await Promise.all(
+        installItems.map(async item => ({
+          fileName: item.fileName,
+          source: await this.openProtocolV2MemorySource(item.binary),
+          targetId: item.targetId,
+          kind: item.kind,
+        }))
+      );
+      const resourceSources = this.params.resourceArchiveBinary
+        ? await this.createProtocolV2ResourceSourcesFromArchive(this.params.resourceArchiveBinary)
+        : [];
+      if (installSources.length === 0 && resourceSources.length === 0) {
         throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `Protocol V2 local firmware artifact is invalid: ${item.fileName}`,
-          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+          HardwareErrorCode.FirmwareUpdateDownloadFailed,
+          'No firmware to update'
         );
       }
-      const artifactId = `component:${target}`;
-      planArtifacts.push({
-        artifactId,
-        target,
-        container: 'raw',
-        logicalName: item.fileName,
-        expectedSize: item.binary.byteLength,
-        expectedSha256: bytesToHex(sha256(new Uint8Array(item.binary))),
-        ...(this.params.expectedTargetVersions?.[target]
-          ? { targetVersion: this.params.expectedTargetVersions[target] }
-          : {}),
+      if (announceDownload) {
+        this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      }
+      return await this.executeProtocolV2SourceUpdate({
+        installSources,
+        resourceSources,
       });
-      memoryArtifacts.push({ artifactId, binary: item.binary });
+    } finally {
+      await this.closeProtocolV2PreparedSources();
     }
+  }
 
-    const resourceArchive = await this.prepareProtocolV2LocalResourceArchive(
-      this.params.resourceArchiveBinary as ArrayBuffer
-    );
-    const resourceArtifactId = 'resource:archive';
-    planArtifacts.push({
-      artifactId: resourceArtifactId,
-      target: 'resource',
-      container: 'zip',
-      logicalName: 'protocol-v2-local-resource-archive',
-      expectedSize: resourceArchive.binary.byteLength,
-      expectedSha256: bytesToHex(sha256(new Uint8Array(resourceArchive.binary))),
-    });
-    memoryArtifacts.push({
-      artifactId: resourceArtifactId,
-      binary: resourceArchive.binary,
-      materializedEntries: resourceArchive.materializedEntries,
-    });
-
-    const plan = buildProtocolV2LocalFirmwareUpdatePlan({
-      features,
-      firmwareType,
-      platform: this.params.platform,
-      artifacts: planArtifacts,
-    });
-    let memoryHost: FirmwareUpdateV4MemoryHost | undefined;
-    try {
-      memoryHost = prepareFirmwareUpdateV4MemoryHost({
-        sdk: {
-          prepareFirmwareUpdatePlan,
-          registerFirmwareUpdateHostBinding,
-          unregisterFirmwareUpdateHostBinding,
-        },
-        plan,
-        artifacts: memoryArtifacts,
-      });
-      const preparedPlan = validateFirmwareUpdatePreparedPlan(memoryHost.preparedPlan);
-      assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan,
-        executor: 'v4',
-        platform: this.params.platform,
-        scopeTargets: [],
-        bindings: [],
-      });
-      assertFirmwareUpdatePreparedPlanDeviceIdentity({
-        preparedPlan,
-        deviceIdentity: this.protocolV2ExpectedSerialNumber,
-        deviceModel: this.getProtocolV2PreparedPlanDeviceModel(features),
+  private async createProtocolV2ResourceSourcesFromArchive(
+    binary: ArrayBuffer
+  ): Promise<ProtocolV2ResourceBundleSource[]> {
+    const archive = await this.prepareProtocolV2LocalResourceArchive(binary);
+    const sources: ProtocolV2ResourceBundleSource[] = [];
+    for (const resource of archive.resources) {
+      sources.push({
+        name: resource.entryName.split('/').pop() ?? resource.entryName,
+        source: await this.openProtocolV2MemorySource(resource.binary),
+        devicePath: resource.header.devicePath,
+        version: resource.header.version,
+        payloadHash: resource.header.payloadHash,
+        headerHash: resource.header.headerHash,
       });
-      const hostBinding = resolveFirmwareUpdateHostBinding(
-        memoryHost.hostBindingGeneration,
-        preparedPlan.preparedPlanDigest
-      );
-      this.params.preparedPlan = preparedPlan;
-      this.params.targetsToUpdate = [...preparedPlan.targetsToUpdate] as FirmwareUpdateV4Target[];
-      this.params.artifactReader = hostBinding.artifactReader;
-      this.params.componentArtifacts = undefined;
-      return memoryHost;
-    } catch (error) {
-      memoryHost?.release();
-      throw error;
     }
+    return sources;
   }
 
   private async prepareProtocolV2LocalResourceArchive(
@@ -1202,130 +1162,67 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       );
     }
     const zipEntries = Object.values(zip.files);
+    const resourceEntries = zipEntries.filter(
+      entry => !entry.dir && isProtocolV2ResourceArchiveEntryName(entry.name)
+    );
     if (
-      zipEntries.some(entry => entry.unsafeOriginalName && entry.unsafeOriginalName !== entry.name)
+      resourceEntries.length === 0 ||
+      resourceEntries.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT
     ) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
-        'Protocol V2 local resource ZIP contains an unsafe entry path',
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-    const entries = zipEntries.filter(entry => !entry.dir);
-    if (entries.length === 0 || entries.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT + 1) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 local resource ZIP entry set is invalid',
+        'Protocol V2 resource ZIP has no valid resource package set',
         { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
       );
     }
-    let declaredUncompressedSize = 0;
-    let declaredCompressedSize = 0;
-    for (const entry of entries) {
-      const sizes = getProtocolV2ZipEntrySizes(entry);
-      declaredCompressedSize += sizes.compressedSize;
-      declaredUncompressedSize += sizes.uncompressedSize;
-      const entryLimit =
-        entry.name === 'manifest.json'
-          ? PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
-          : PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES;
+
+    let totalSize = 0;
+    const resources: ProtocolV2LocalResourceArchive['resources'] = [];
+    const devicePaths = new Set<string>();
+    for (const entry of resourceEntries) {
+      const { compressedSize, uncompressedSize } = getProtocolV2ZipEntrySizes(entry);
+      totalSize += uncompressedSize;
       if (
-        sizes.uncompressedSize > entryLimit ||
-        declaredCompressedSize > binary.byteLength ||
-        declaredUncompressedSize >
-          PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES + PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
+        compressedSize > binary.byteLength ||
+        uncompressedSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES ||
+        totalSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES
       ) {
         throw ERRORS.TypedError(
           HardwareErrorCode.RuntimeError,
-          'Protocol V2 local resource ZIP declared size exceeds the allowed limit',
+          `Protocol V2 resource package size is invalid: ${entry.name}`,
           { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
         );
       }
-    }
-    const manifestEntry = zip.file('manifest.json');
-    if (!manifestEntry) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 local resource ZIP has no manifest.json',
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-    const manifestBinary = await manifestEntry.async('arraybuffer');
-    if (
-      manifestBinary.byteLength <= 0 ||
-      manifestBinary.byteLength > PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 local resource manifest size is invalid',
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-
-    let manifestValue: unknown;
-    try {
-      manifestValue = JSON.parse(new TextDecoder().decode(manifestBinary));
-    } catch (error) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `Protocol V2 local resource manifest is invalid: ${String(error)}`,
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-    const manifest = parseProtocolV2ResourceManifest(manifestValue);
-    const selectedFiles = selectProtocolV2ResourceManifestFiles({
-      manifest,
-      targetsToUpdate: this.params.targetsToUpdate ?? [],
-    });
-    const expectedEntryNames = new Set([
-      'manifest.json',
-      ...selectedFiles.map(file => file.archive_path),
-    ]);
-    if (
-      entries.length !== expectedEntryNames.size ||
-      entries.some(entry => !expectedEntryNames.has(entry.name))
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 local resource ZIP contains an unexpected entry',
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-
-    let totalSize = 0;
-    const materializedEntries: FirmwareMemoryArtifactEntry[] = [
-      { entryName: 'manifest.json', binary: manifestBinary },
-    ];
-    for (const file of selectedFiles) {
-      const entry = zip.file(file.archive_path);
-      if (!entry) {
+      const fileBinary = await entry.async('arraybuffer');
+      if (fileBinary.byteLength !== uncompressedSize) {
         throw ERRORS.TypedError(
           HardwareErrorCode.RuntimeError,
-          `Protocol V2 local resource ZIP is missing ${file.archive_path}`,
-          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+          `Protocol V2 resource package is incomplete: ${entry.name}`,
+          { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
         );
       }
-      const { uncompressedSize } = getProtocolV2ZipEntrySizes(entry);
-      totalSize += uncompressedSize;
-      if (uncompressedSize !== file.size || totalSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
+      let header: ProtocolV2ResourcePackageHeader;
+      try {
+        header = parseProtocolV2ResourcePackage(fileBinary);
+      } catch (error) {
         throw ERRORS.TypedError(
           HardwareErrorCode.RuntimeError,
-          `Protocol V2 local resource file declared size is invalid: ${file.archive_path}`,
+          `Protocol V2 resource package is invalid: ${entry.name}: ${String(error)}`,
           { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
         );
       }
-      const fileBinary = await entry.async('arraybuffer');
-      const digest = bytesToHex(sha256(new Uint8Array(fileBinary)));
-      if (fileBinary.byteLength !== file.size || digest !== file.sha256.toLowerCase()) {
+      const canonicalDevicePath = header.devicePath.toLowerCase();
+      if (devicePaths.has(canonicalDevicePath)) {
         throw ERRORS.TypedError(
           HardwareErrorCode.RuntimeError,
-          `Protocol V2 local resource file does not match manifest: ${file.archive_path}`,
-          { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
+          `Protocol V2 resource ZIP contains duplicate device path: ${header.devicePath}`,
+          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
         );
       }
-      materializedEntries.push({ entryName: file.archive_path, binary: fileBinary });
+      devicePaths.add(canonicalDevicePath);
+      resources.push({ entryName: entry.name, binary: fileBinary, header });
     }
-    return { binary, materializedEntries };
+    return { binary, resources };
   }
 
   private async prepareProtocolV2ResourceSources(): Promise<ProtocolV2ResourceBundleSource[]> {
@@ -1390,110 +1287,20 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       );
     }
 
-    // materializedEntries 由宿主生成，只有与获批 ZIP 的规范字节完全一致后才能使用。
-    const verifiedArchive = await this.prepareProtocolV2LocalResourceArchive(archiveBinary);
-    const entries = archiveArtifact.materializedEntries ?? [];
-    const entriesByName = new Map(entries.map(entry => [entry.entryName, entry] as const));
-    if (
-      entries.length !== verifiedArchive.materializedEntries.length ||
-      verifiedArchive.materializedEntries.some(entry => {
-        const preparedEntry = entriesByName.get(entry.entryName);
-        const digest = bytesToHex(sha256(new Uint8Array(entry.binary)));
-        return (
-          !preparedEntry ||
-          preparedEntry.artifact.size !== entry.binary.byteLength ||
-          preparedEntry.artifact.sha256.toLowerCase() !== digest
-        );
-      })
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 prepared resource entries do not match the approved archive',
-        { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
-      );
-    }
-
-    const verifiedEntriesByName = new Map(
-      verifiedArchive.materializedEntries.map(entry => [entry.entryName, entry.binary] as const)
-    );
-    const manifestBinary = verifiedEntriesByName.get('manifest.json');
-    if (!manifestBinary) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 prepared resource archive has no valid manifest.json',
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-
-    let manifestValue: unknown;
-    try {
-      manifestValue = JSON.parse(new TextDecoder().decode(manifestBinary));
-    } catch (error) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `Protocol V2 prepared resource manifest is invalid: ${String(error)}`,
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-    const manifest = parseProtocolV2ResourceManifest(manifestValue);
-    const selectedFiles = selectProtocolV2ResourceManifestFiles({
-      manifest,
-      targetsToUpdate: this.params.targetsToUpdate ?? [],
-    });
-    if (selectedFiles.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 prepared resource archive contains too many files',
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-
-    let totalSize = 0;
-    const sources: ProtocolV2ResourceBundleSource[] = [];
-    for (const [index, file] of selectedFiles.entries()) {
-      const binary = verifiedEntriesByName.get(file.archive_path);
-      if (!binary || binary.byteLength !== file.size) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `Protocol V2 prepared resource file does not match manifest: ${file.archive_path}`,
-          { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
-        );
-      }
-      totalSize += binary.byteLength;
-      if (totalSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Protocol V2 prepared resource archive exceeds the total size limit',
-          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-        );
-      }
-      // 使用从获批 ZIP 中提取的规范字节，避免宿主在校验后替换 entry reader 内容。
-      const source = await this.openProtocolV2MemorySource(binary);
-      const header =
-        source.size >= PROTOCOL_V2_OKPP_HEADER_SIZE
-          ? parseProtocolV2OkppHeader(
-              new Uint8Array(await source.readAt(0, PROTOCOL_V2_OKPP_HEADER_SIZE))
-            )
-          : null;
-      sources.push({
-        name: file.original_name || `resource-${index}`,
-        source,
-        devicePath: file.device_path,
-        ...(header
-          ? {
-              version: header.version,
-              payloadHash: header.payloadHash,
-              headerHash: header.headerHash,
-            }
-          : {}),
-      });
-    }
-    return sources;
+    // The verified ZIP bytes are authoritative. Non-okpkg entries are release
+    // metadata only; each RESOURCE package carries its own device path.
+    return this.createProtocolV2ResourceSourcesFromArchive(archiveBinary);
   }
 
-  private async runProtocolV2PreparedArtifacts(features: Features, firmwareType: EFirmwareType) {
+  private async runProtocolV2PreparedArtifacts(
+    features: Features,
+    firmwareType: EFirmwareType,
+    announceDownload = true
+  ) {
     try {
-      this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
+      if (announceDownload) {
+        this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
+      }
       const installSources = await this.prepareProtocolV2InstallSources(firmwareType, features);
       const resourceSources = await this.prepareProtocolV2ResourceSources();
       if (installSources.length === 0 && resourceSources.length === 0) {
@@ -1502,7 +1309,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           'No firmware to update'
         );
       }
-      this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      if (announceDownload) {
+        this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      }
 
       return await this.executeProtocolV2SourceUpdate({
         installSources,
@@ -1557,21 +1366,20 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const expected = this.params?.expectedTargetVersions;
     if (!expected) return;
     const features = this.protocolV2LatestFinalFeatures;
-    const requestedTargets = this.getProtocolV2RequestedTargets();
-    const applicationTargets = requestedTargets.filter(
-      target => target === 'app_v1' || target === 'app_v2'
-    );
+    const deviceInfo = this.protocolV2LatestFinalDeviceInfo;
     const visibleVersions: Partial<Record<FirmwareUpdateV4Target, string>> = {
       boot: features ? getDeviceBootloaderVersion(features).join('.') : undefined,
+      // Protocol V2 firmware exposes P1 as the device firmware version after reboot.
+      app_v1: features
+        ? getDeviceFirmwareVersion(features).join('.')
+        : deviceInfo?.main_mcu?.application?.version,
+      app_v2: deviceInfo?.main_mcu?.application_data?.version,
       coprocessor: features ? getDeviceBLEFirmwareVersion(features).join('.') : undefined,
       se01: features?.se01Version ?? undefined,
       se02: features?.se02Version ?? undefined,
       se03: features?.se03Version ?? undefined,
       se04: features?.se04Version ?? undefined,
     };
-    if (features && applicationTargets.length === 1) {
-      visibleVersions[applicationTargets[0]] = getDeviceFirmwareVersion(features).join('.');
-    }
     const expectedEntries = (
       Object.entries(expected) as Array<[FirmwareUpdateV4Target, string]>
     ).filter(([target]) => !targets || targets.includes(target));
@@ -1588,9 +1396,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               Math.floor(statusVersion / 0x100) % 0x100
             }.${statusVersion % 0x100}`;
       if (!observedVersion) {
-        if (this.protocolV2FinalStatusVerified) {
+        const hasCompleteTargetEvidence =
+          targetId !== undefined && this.protocolV2CompletedTargetIds.has(targetId);
+        if (hasCompleteTargetEvidence) {
           Log.warn(
-            `Protocol V2 target ${target} has no observable final version; completed target status is authoritative`
+            `Protocol V2 target ${target} has no observable final version; install completion is authoritative`
           );
         } else {
           throw ERRORS.TypedError(
@@ -1607,37 +1417,23 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
-  private getProtocolV2RequestedTargets(): FirmwareUpdateV4Target[] {
-    if (this.params.targetsToUpdate?.length) {
-      return [...new Set(this.params.targetsToUpdate)];
+  private async getProtocolV2DeviceFeatures(): Promise<Features> {
+    let { features } = this.device;
+    if (typeof this.device.getFeatures === 'function') {
+      features ??= await this.device.getFeatures();
     }
-    if (this.params.preparedPlan?.targetsToUpdate.length) {
-      return [...new Set(this.params.preparedPlan.targetsToUpdate)] as FirmwareUpdateV4Target[];
+    if (!features) {
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
     }
-    const targets = new Set<FirmwareUpdateV4Target>();
-    Object.keys(this.params.componentArtifacts ?? {}).forEach(target =>
-      targets.add(target as FirmwareUpdateV4Target)
-    );
-    if (this.params.bootloaderBinary) targets.add('boot');
-    if (this.params.applicationP1Binary) targets.add('app_v1');
-    if (this.params.applicationP2Binary) targets.add('app_v2');
-    if (this.params.coprocessorBinary) targets.add('coprocessor');
-    if (this.params.se01Binary) targets.add('se01');
-    if (this.params.se02Binary) targets.add('se02');
-    if (this.params.se03Binary) targets.add('se03');
-    if (this.params.se04Binary) targets.add('se04');
-    return Array.from(targets);
-  }
-
-  private async getProtocolV2DeviceFeatures(): Promise<Features> {
-    if (this.device.features) {
-      return this.device.features;
-    }
-    if (typeof this.device.getFeatures === 'function') {
-      const features = await this.device.getFeatures();
-      if (features) return features;
+    const deviceType = this.device.getCurrentDeviceType();
+    if (deviceType !== EDeviceType.Pro2 && deviceType !== EDeviceType.Neo) {
+      return features;
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
+    return {
+      ...features,
+      deviceType,
+      firmwareType: this.device.getCurrentFirmwareType(),
+    };
   }
 
   private getProtocolV2SerialNumber(deviceInfo: ProtocolV2DeviceInfo) {
@@ -1840,22 +1636,54 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         `Protocol V2 firmware fingerprint mismatch: ${key}/${component.target}`
       );
     }
-    const expectedPayloadHash = normalizeProtocolV2Hex(component.payloadHash);
-    if (expectedPayloadHash) {
-      const header = parseProtocolV2OkppHeader(toProtocolV2Bytes(binary));
-      if (!header || header.payloadHash !== expectedPayloadHash) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `Protocol V2 firmware payload hash mismatch: ${key}/${component.target}`
-        );
-      }
-    }
     return {
       ...target,
       binary,
     };
   }
 
+  private async downloadRemoteProtocolV2ResourceArchive(
+    features: Features,
+    firmwareType: EFirmwareType
+  ): Promise<ArrayBuffer> {
+    const deviceType = getDeviceType(features);
+    if (deviceType !== EDeviceType.Pro2 && deviceType !== EDeviceType.Neo) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 resource archive requires a Pro2 or Neo device'
+      );
+    }
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+    const source = DataManager.getProtocolV2ResourceSource(release);
+    const expectedSha256 = normalizeProtocolV2Hex(source?.archiveSha256);
+    if (
+      !source?.archiveUrl ||
+      !Number.isSafeInteger(source.archiveSize) ||
+      source.archiveSize <= 0 ||
+      source.archiveSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES ||
+      !expectedSha256 ||
+      !/^[0-9a-f]{64}$/u.test(expectedSha256)
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 resource archive integrity metadata is invalid',
+        { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+      );
+    }
+    const { binary } = await getSysResourceBinary(source.archiveUrl);
+    if (
+      binary.byteLength !== source.archiveSize ||
+      bytesToHex(sha256(new Uint8Array(binary))) !== expectedSha256
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 resource archive does not match the remote config',
+        { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
+      );
+    }
+    return binary;
+  }
+
   private async prepareRemoteProtocolV2Binaries(
     firmwareType: EFirmwareType,
     features: Features,
@@ -1899,8 +1727,14 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         : undefined;
       if (updateTarget && targetsToUpdate.has(updateTarget)) {
         const explicitInstallItem = explicitInstallItemByTargetId.get(target.targetId);
-        const installItem =
-          explicitInstallItem ?? (await this.downloadRemoteProtocolV2Component(key, component));
+        let installItem = explicitInstallItem;
+        if (!installItem) {
+          installItem = await this.downloadRemoteProtocolV2Component(key, component);
+          if (component.version) {
+            this.params.expectedTargetVersions ??= {};
+            this.params.expectedTargetVersions[updateTarget] = component.version.join('.');
+          }
+        }
         if (installItem.kind === 'bootloader') {
           bootloaderBinary = installItem.binary;
         } else {
@@ -1939,6 +1773,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return `vol0:/${path}`;
   }
 
+  private getProtocolV2ResourceComparePath(devicePath: string) {
+    return isProtocolV2BootResourcePackagePath(devicePath)
+      ? PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH
+      : devicePath;
+  }
+
   private async readProtocolV2DeviceFileHeader(path: string, expectedSize?: number) {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
     const filePath = this.getProtocolV2ResourceFilePath(path);
@@ -1950,7 +1790,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       !pathInfoRes.message?.exist ||
       pathInfoRes.message?.directory ||
       fileSize === undefined ||
-      fileSize < PROTOCOL_V2_OKPP_HEADER_SIZE ||
+      fileSize < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE ||
       (expectedSize !== undefined && fileSize !== expectedSize)
     ) {
       return null;
@@ -1959,8 +1799,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const chunkSize = this.getProtocolV2FirmwareChunkSize('read');
     const chunks: Uint8Array[] = [];
     let offset = 0;
-    while (offset < PROTOCOL_V2_OKPP_HEADER_SIZE) {
-      const readLen = Math.min(chunkSize, PROTOCOL_V2_OKPP_HEADER_SIZE - offset);
+    while (offset < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE) {
+      const readLen = Math.min(chunkSize, PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE - offset);
       const res = await typedCall('FilesystemFileRead', 'FilesystemFile', {
         file: {
           path: filePath,
@@ -1982,7 +1822,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       headerBytes.set(chunk, cursor);
       cursor += chunk.byteLength;
     });
-    return parseProtocolV2OkppHeader(headerBytes);
+    try {
+      return parseProtocolV2ResourcePackageHeader(headerBytes, fileSize);
+    } catch {
+      return null;
+    }
   }
 
   /** Compare the downloaded and installed okpkg headers before transferring a resource. */
@@ -1997,7 +1841,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     try {
       const header = await this.readProtocolV2DeviceFileHeader(
-        bundle.devicePath,
+        this.getProtocolV2ResourceComparePath(bundle.devicePath),
         bundle.source.size
       );
       if (!header) return false;
@@ -2012,6 +1856,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       if (!expectedHeaderHash || header.headerHash !== expectedHeaderHash) return false;
       return true;
     } catch (error) {
+      if (isBleStaleBondHardwareError(error)) {
+        throw error;
+      }
       Log.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
       return false;
     }
@@ -2041,21 +1888,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return this.device.features?.mode === 'romloader';
   }
 
-  async enterProtocolV2BootloaderMode() {
-    // romloader is the first update environment and forwards targets to bootloader.
-    // It rejects DeviceRebootType.Bootloader, so reuse the current connection.
-    if (this.isProtocolV2RomloaderMode()) {
-      Log.debug('Protocol V2 device is in romloader mode; start firmware update directly');
-      this.protocolV2ExecutionInLoader = true;
-      return false;
-    }
-    if (this.isProtocolV2BootloaderMode()) {
-      Log.debug('Protocol V2 device is already in bootloader mode, skip reboot');
-      this.protocolV2ExecutionInLoader = true;
-      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
-      return false;
-    }
-
+  private async rebootProtocolV2ToBootloader() {
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.AutoRebootToBootloader);
       await this.protocolV2Reboot(DeviceRebootType.Bootloader);
@@ -2073,6 +1906,24 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
+  async enterProtocolV2BootloaderMode() {
+    // romloader is the first update environment and forwards targets to bootloader.
+    // It rejects DeviceRebootType.Bootloader, so reuse the current connection.
+    if (this.isProtocolV2RomloaderMode()) {
+      Log.debug('Protocol V2 device is in romloader mode; start firmware update directly');
+      this.protocolV2ExecutionInLoader = true;
+      return false;
+    }
+    if (this.isProtocolV2BootloaderMode()) {
+      Log.debug('Protocol V2 device is already in bootloader mode, skip reboot');
+      this.protocolV2ExecutionInLoader = true;
+      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
+      return false;
+    }
+
+    return this.rebootProtocolV2ToBootloader();
+  }
+
   private async waitForProtocolV2BootloaderMode(
     timeout = PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT,
     retryInterval = 1000
@@ -2101,7 +1952,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         }
         lastError = new Error('Protocol V2 device is reachable but is not in bootloader mode');
       } catch (error) {
-        if (this.isProtocolV2ReconnectIdentityError(error)) {
+        if (isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
           throw error;
         }
         shouldReconnect = true;
@@ -2157,68 +2008,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return entries;
   }
 
-  private buildProtocolV2ExecutionPhases({
-    installSources,
-    resourceSources,
-  }: {
-    installSources: ProtocolV2InstallSource[];
-    resourceSources: ProtocolV2ResourceBundleSource[];
-  }): ProtocolV2ExecutionPhase[] {
-    const phases: ProtocolV2ExecutionPhase[] = [];
-    const bootResourceSources = resourceSources.filter(source =>
-      isProtocolV2BootResourcePackagePath(source.devicePath)
-    );
-    const remainingResourceSources = resourceSources.filter(
-      source => !isProtocolV2BootResourcePackagePath(source.devicePath)
-    );
-    // A previous interrupted run may have left a promotable staging file. Replace
-    // it with the current approved package before any firmware-triggered reboot.
-    if (bootResourceSources.length > 0) {
-      phases.push({
-        kind: 'resource-sync',
-        installSources: [],
-        resourceSources: bootResourceSources,
-      });
-    }
-    const bootloaderSources = installSources.filter(source => source.kind === 'bootloader');
-    if (bootloaderSources.length > 0) {
-      phases.push(
-        {
-          kind: 'bootloader-install',
-          installSources: bootloaderSources,
-          resourceSources: [],
-        },
-        {
-          kind: 'bootloader-verify',
-          installSources: [],
-          resourceSources: [],
-        }
-      );
-    }
-    if (remainingResourceSources.length > 0) {
-      phases.push({
-        kind: 'resource-sync',
-        installSources: [],
-        resourceSources: remainingResourceSources,
-      });
-    }
-    const componentSources = installSources.filter(source => source.kind !== 'bootloader');
-    if (componentSources.length > 0) {
-      phases.push({
-        kind: 'component-install',
-        installSources: componentSources,
-        resourceSources: [],
-      });
-    }
-    phases.push({
-      kind: 'final-verify',
-      installSources: [],
-      resourceSources: [],
-    });
-    return phases;
-  }
-
-  private async executeProtocolV2Phases({
+  private async executeProtocolV2SourceUpdate({
     installSources,
     resourceSources,
   }: {
@@ -2226,38 +2016,22 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     resourceSources: ProtocolV2ResourceBundleSource[];
   }) {
     this.protocolV2BootResourceStagingSafe = false;
-    const phases = this.buildProtocolV2ExecutionPhases({
-      installSources,
-      resourceSources,
-    });
-    for (const phase of phases) {
-      if (phase.kind === 'final-verify') {
-        return this.completeProtocolV2FinalVerification();
-      }
-      if (phase.kind === 'resource-sync') {
-        await this.enterProtocolV2BootloaderMode();
-        if (
-          !phase.resourceSources.some(source =>
-            isProtocolV2BootResourcePackagePath(source.devicePath)
-          )
-        ) {
-          await this.ensureProtocolV2BootResourceStagingIsEmpty();
-        }
-        await this.executeProtocolV2TransferPhase(phase);
-      } else if (phase.kind === 'bootloader-install' || phase.kind === 'component-install') {
-        await this.enterProtocolV2BootloaderMode();
-        await this.ensureProtocolV2BootResourceStagingIsEmpty();
-        await this.executeProtocolV2TransferPhase(phase);
-        await this.exitProtocolV2BootloaderToNormal();
-      } else if (phase.kind === 'bootloader-verify') {
-        await this.waitForProtocolV2FinalFeatures();
-        this.assertExpectedProtocolV2Versions(['boot']);
-      }
+    if (installSources.length > 0 || resourceSources.length > 0) {
+      await this.enterProtocolV2BootloaderMode();
+      // Clear stale boot-resource staging before writing any artifacts. The new
+      // boot resource, resources and firmware then share one transfer session,
+      // one global progress range and one multi-target install request.
+      // Preserve the approved source order instead of synthesizing a boot-first
+      // phase. Loader firmware owns the cross-stage handoff: bootloader runs its
+      // component targets and leaves boot pending for romloader, while pending
+      // runner-backed records always resume before the application boots.
+      await this.ensureProtocolV2BootResourceStagingIsEmpty();
+      await this.executeProtocolV2TransferPhase({
+        installSources,
+        resourceSources,
+      });
     }
-    throw ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Protocol V2 execution has no final verification phase'
-    );
+    return this.completeProtocolV2FinalVerification();
   }
 
   private async ensureProtocolV2BootResourceStagingIsEmpty() {
@@ -2289,19 +2063,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     this.protocolV2BootResourceStagingSafe = true;
   }
 
-  private async executeProtocolV2SourceUpdate({
-    installSources,
-    resourceSources,
-  }: {
-    installSources: ProtocolV2InstallSource[];
-    resourceSources: ProtocolV2ResourceBundleSource[];
-  }) {
-    return this.executeProtocolV2Phases({
-      installSources,
-      resourceSources,
-    });
-  }
-
   private async executeProtocolV2Update({
     fwBinaryMap,
     bootloaderBinary,
@@ -2326,7 +2087,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           kind: item.kind,
         }))
       );
-      return await this.executeProtocolV2Phases({
+      return await this.executeProtocolV2SourceUpdate({
         installSources,
         resourceSources: [],
       });
@@ -2338,15 +2099,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async executeProtocolV2TransferPhase({
     installSources,
     resourceSources,
-  }: ProtocolV2ExecutionPhase) {
+  }: ProtocolV2TransferBatch) {
     let totalSize = installSources.reduce((total, item) => total + item.source.size, 0);
     const resourcesToSync: ProtocolV2ResourceBundleSource[] = [];
     for (const resource of resourceSources) {
-      // Early boot promotes this mounted package's staging file. Always replace any
-      // stale staging bytes with the artifact approved by the current PreparedPlan,
-      // even when the mounted final file itself is already current.
-      const requiresFreshStaging = isProtocolV2BootResourcePackagePath(resource.devicePath);
-      if (!requiresFreshStaging && (await this.isProtocolV2ResourceBundleUpToDate(resource))) {
+      if (await this.isProtocolV2ResourceBundleUpToDate(resource)) {
         Log.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
       } else {
         resourcesToSync.push(resource);
@@ -2355,11 +2112,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+    this.protocolV2LastTransferProgress = undefined;
+    this.protocolV2LastTransferProgressAt = 0;
     let processedSize = 0;
     for (const resource of resourcesToSync) {
       // The bootloader keeps its live resource package mounted. FatFs rejects
       // replacing an open file, so early boot promotes this staging file before mounting it.
-      const writePath = resolveProtocolV2ResourceWritePath(resource.devicePath);
+      const writePath = resource.devicePath;
       processedSize = await this.protocolV2SourceUpdateProcess({
         source: resource.source,
         filePath: writePath,
@@ -2400,8 +2159,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       target_id: item.targetId,
       path: item.path,
     }));
-    await this.protocolV2StartFirmwareUpdate({ targets });
-    await this.waitForProtocolV2FirmwareUpdateComplete(targets);
+    try {
+      await this.protocolV2StartFirmwareUpdate({ targets });
+      await wait(PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY);
+      await this.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+    } finally {
+      this.device?.clearCancelableAction();
+    }
   }
 
   private async protocolV2SourceUpdateProcess({
@@ -2446,23 +2210,33 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               );
             }
             const transferredBytes = processedSize + chunkEnd;
-            const elapsedMs = Math.max(Date.now() - transferStartedAt, 0);
-            this.postProgressMessage(
-              Math.min(Math.ceil((transferredBytes / totalSize) * 100), 99),
-              'transferData',
-              {
+            const now = Date.now();
+            const elapsedMs = Math.max(now - transferStartedAt, 0);
+            const progress = Math.min(Math.ceil((transferredBytes / totalSize) * 100), 99);
+            const shouldPostProgress =
+              progress !== this.protocolV2LastTransferProgress ||
+              now - this.protocolV2LastTransferProgressAt >=
+                PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS ||
+              chunkEnd === source.size;
+            if (shouldPostProgress) {
+              this.protocolV2LastTransferProgress = progress;
+              this.protocolV2LastTransferProgressAt = now;
+              this.postProgressMessage(progress, 'transferData', {
                 transferredBytes,
                 totalBytes: totalSize,
                 rateBytesPerSecond:
                   elapsedMs > 0 ? Math.round((chunkEnd / elapsedMs) * 1000) : undefined,
                 elapsedMs,
-              }
-            );
+              });
+            }
             return length;
           },
         });
         return processedSize + source.size;
       } catch (error) {
+        if (isBleStaleBondHardwareError(error)) {
+          throw error;
+        }
         lastError = error;
         if (attempt < PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
           await this.recoverProtocolV2FileTransfer();
@@ -2492,19 +2266,41 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
+  private collectProtocolV2LiveTargetIds(
+    statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
+    expectedTargetIds: Set<number>,
+    liveTargetIds: Set<number>
+  ) {
+    statusTargets.forEach(target => {
+      const targetId = normalizeProtocolV2TargetId(target.target_id);
+      if (
+        targetId !== undefined &&
+        expectedTargetIds.has(targetId) &&
+        isProtocolV2TargetStatusInProgress(target.status)
+      ) {
+        liveTargetIds.add(targetId);
+      }
+    });
+  }
+
   private assertProtocolV2TargetStatus(
     statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
     expectedTargetIds: Set<number>,
-    expectedPaths = new Map<number, string>()
+    expectedPaths?: Map<number, string>,
+    liveTargetIds?: Set<number>
   ) {
+    const resolvedExpectedPaths = expectedPaths ?? new Map<number, string>();
     Log.log(
       `[FirmwareUpdateV4] DeviceFirmwareUpdateStatus records=${JSON.stringify(statusTargets)}`
     );
-    const failedTarget = statusTargets.find(
-      target =>
-        expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1) &&
-        isProtocolV2TargetStatusFailed(target.status)
-    );
+    const failedTarget = statusTargets.find(target => {
+      const targetId = normalizeProtocolV2TargetId(target.target_id) ?? -1;
+      return (
+        expectedTargetIds.has(targetId) &&
+        isProtocolV2TargetStatusFailed(target.status) &&
+        (!liveTargetIds || liveTargetIds.has(targetId))
+      );
+    });
     if (failedTarget) {
       const failedTargetDetails = JSON.stringify({
         targetId: failedTarget.target_id,
@@ -2515,13 +2311,33 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       Log.error(`[FirmwareUpdateV4] firmware install failed target=${failedTargetDetails}`);
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareError,
-        `Protocol V2 firmware target failed: target=${failedTarget.target_id} status=${
-          failedTarget.status ?? 'unknown'
-        } payloadVersion=${failedTarget.payload_version ?? 'unknown'} path=${
-          failedTarget.path ?? 'unknown'
-        }`
+        'Protocol V2 firmware install failed',
+        {
+          firmwareUpdateCode: PROTOCOL_V2_INSTALL_FAILED_CODE,
+        }
       );
     }
+    if (liveTargetIds) {
+      const staleFailedTargets = statusTargets.filter(target => {
+        const targetId = normalizeProtocolV2TargetId(target.target_id) ?? -1;
+        return (
+          expectedTargetIds.has(targetId) &&
+          isProtocolV2TargetStatusFailed(target.status) &&
+          !liveTargetIds.has(targetId)
+        );
+      });
+      if (staleFailedTargets.length > 0) {
+        Log.log(
+          `[FirmwareUpdateV4] ignoring stale failed firmware status until those targets start: ${JSON.stringify(
+            staleFailedTargets.map(target => ({
+              targetId: target.target_id,
+              status: target.status,
+              path: target.path,
+            }))
+          )}`
+        );
+      }
+    }
 
     const matchingTargets = statusTargets.filter(target =>
       expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1)
@@ -2529,14 +2345,21 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const seenTargetIds = new Set<number>();
     for (const target of matchingTargets) {
       const targetId = normalizeProtocolV2TargetId(target.target_id);
+      const pathConflictsWithCurrentInstall =
+        targetId !== undefined &&
+        Boolean(target.path) &&
+        Boolean(resolvedExpectedPaths.get(targetId)) &&
+        target.path !== resolvedExpectedPaths.get(targetId) &&
+        (!liveTargetIds || liveTargetIds.has(targetId));
       if (
         targetId === undefined ||
         seenTargetIds.has(targetId) ||
-        (target.path && expectedPaths.get(targetId) && target.path !== expectedPaths.get(targetId))
+        pathConflictsWithCurrentInstall
       ) {
+        Log.error(`[FirmwareUpdateV4] install status conflicts with target=${target.target_id}`);
         throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `Protocol V2 install status conflicts with target ${target.target_id}`,
+          HardwareErrorCode.FirmwareError,
+          'Protocol V2 firmware install status conflict',
           {
             firmwareUpdateCode: PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE,
           }
@@ -2544,14 +2367,19 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       }
       seenTargetIds.add(targetId);
     }
-    const completedTargets = matchingTargets.filter(target =>
-      isProtocolV2TargetStatusFinished(target.status)
-    );
+    const completedTargets = matchingTargets.filter(target => {
+      const targetId = normalizeProtocolV2TargetId(target.target_id);
+      return (
+        isProtocolV2TargetStatusFinished(target.status) &&
+        (!liveTargetIds || (targetId !== undefined && liveTargetIds.has(targetId)))
+      );
+    });
     const completedTargetIds = new Set<number>();
     completedTargets.forEach(target => {
       const targetId = normalizeProtocolV2TargetId(target.target_id);
       if (targetId !== undefined) {
         completedTargetIds.add(targetId);
+        this.protocolV2CompletedTargetIds.add(targetId);
       }
     });
     if (completedTargetIds.size === expectedTargetIds.size && expectedTargetIds.size > 0) {
@@ -2582,16 +2410,54 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     if (expectedTargetIds.size > 0 && matchingTargets.length > 0) {
-      const hasInProgressTarget = matchingTargets.some(target =>
-        isProtocolV2TargetStatusInProgress(target.status)
-      );
+      let detailedProgress = completedTargetIds.size * 100;
+      let installProgressMetadata:
+        | {
+            installTargetId: number;
+            installPhase: 'prepare' | 'install' | 'verify';
+            installPhaseProgress: number;
+          }
+        | undefined;
+      let hasInProgressTarget = false;
+      matchingTargets.forEach(target => {
+        const targetId = normalizeProtocolV2TargetId(target.target_id);
+        if (
+          targetId === undefined ||
+          completedTargetIds.has(targetId) ||
+          !isProtocolV2TargetStatusInProgress(target.status) ||
+          (liveTargetIds && !liveTargetIds.has(targetId))
+        ) {
+          return;
+        }
+        hasInProgressTarget = true;
+        detailedProgress += normalizeProtocolV2ProgressPercent(target.progress_percent) ?? 0;
+        const installPhase = target.phase_info
+          ? PROTOCOL_V2_INSTALL_PHASE_BY_DECODED_VALUE.get(target.phase_info.phase)
+          : undefined;
+        const installPhaseProgress = normalizeProtocolV2ProgressPercent(
+          target.phase_info?.progress_percent
+        );
+        if (installPhase && installPhaseProgress !== undefined && !installProgressMetadata) {
+          installProgressMetadata = {
+            installTargetId: targetId,
+            installPhase,
+            installPhaseProgress,
+          };
+        }
+      });
       const completedProgress = Math.floor(
         (completedTargetIds.size / expectedTargetIds.size) * 100
       );
-      // The protocol exposes no per-target percentage, so report coarse progress by
-      // completed targets and use 1% once work starts to keep the UI responsive.
-      const progress = Math.min(99, Math.max(completedProgress, hasInProgressTarget ? 1 : 0));
-      this.postProgressMessage(progress, 'installingFirmware');
+      const reportedProgress = Math.floor(detailedProgress / expectedTargetIds.size);
+      const progress = Math.min(
+        99,
+        Math.max(completedProgress, reportedProgress, hasInProgressTarget ? 1 : 0)
+      );
+      if (installProgressMetadata) {
+        this.postProgressMessage(progress, 'installingFirmware', installProgressMetadata);
+      } else {
+        this.postProgressMessage(progress, 'installingFirmware');
+      }
     }
 
     return false;
@@ -2611,31 +2477,107 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return Array.from(expectedTargetIds).filter(targetId => !reportedTargetIds.has(targetId));
   }
 
+  private getProtocolV2ObservableTargetVersions(features: Features) {
+    const versions = new Map<number, string>();
+    versions.set(
+      ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
+      getDeviceBootloaderVersion(features).join('.')
+    );
+    const applicationVersion = getDeviceFirmwareVersion(features).join('.');
+    versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1, applicationVersion);
+    versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2, applicationVersion);
+    versions.set(
+      ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR,
+      getDeviceBLEFirmwareVersion(features).join('.')
+    );
+    const secureElementVersions: Array<[number, string | null | undefined]> = [
+      [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01, features.se01Version],
+      [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02, features.se02Version],
+      [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03, features.se03Version],
+      [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04, features.se04Version],
+    ];
+    secureElementVersions.forEach(([targetId, version]) => {
+      if (version) versions.set(targetId, version);
+    });
+    return versions;
+  }
+
+  private hasProtocolV2InstallVersionChanged(expectedTargetIds: Set<number>) {
+    if (!this.protocolV2LastRuntimeProbeFeatures) return false;
+    const currentVersions = this.getProtocolV2ObservableTargetVersions(
+      this.protocolV2LastRuntimeProbeFeatures
+    );
+    return Array.from(expectedTargetIds).some(targetId => {
+      const previousVersion = this.protocolV2InstallBaselineVersions.get(targetId);
+      const currentVersion = currentVersions.get(targetId);
+      return (
+        previousVersion !== undefined &&
+        currentVersion !== undefined &&
+        previousVersion !== currentVersion
+      );
+    });
+  }
+
+  private recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds: Set<number>) {
+    expectedTargetIds.forEach(targetId => this.protocolV2CompletedTargetIds.add(targetId));
+  }
+
   private async waitForProtocolV2FirmwareUpdateComplete(
-    targets: Array<{ target_id: number; path: string }>
+    targets: Array<{ target_id: number; path: string }>,
+    requireCurrentInstallStatus = false
   ) {
-    this.protocolV2FinalStatusVerified = false;
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
     const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
+    const isBleInstall = this.isBleReconnect();
     const startTime = Date.now();
     let lastError: unknown;
-    let shouldReconnect = true;
+    // The loader may release either USB or BLE as installation starts. Recovery reconnects
+    // directly to status polling without generic Ping or DeviceInfo probes.
+    let shouldReconnect = this.protocolV2InstallNeedsReconnect;
+    this.protocolV2InstallNeedsReconnect = false;
     let deviceInfo: ProtocolV2DeviceInfo | undefined;
-    let missingTargetStatusSince: number | undefined;
-    let missingTargetStatusKey: string | undefined;
-    const resetMissingTargetStatusGrace = () => {
-      missingTargetStatusSince = undefined;
-      missingTargetStatusKey = undefined;
+    let bleInstallLinkReady = false;
+    let installStatusDisconnectObserved = isBleInstall && this.protocolV2InstallDisconnectObserved;
+    this.protocolV2InstallDisconnectObserved = false;
+    let installReconnectObserved = false;
+    let finishedStatusSnapshotKey: string | undefined;
+    let finishedStatusSnapshotPolls = 0;
+    let fastFinishedInstallProgressReported = false;
+    let installEvidenceObserved = this.protocolV2InstallTerminalSuccessObserved;
+    let currentInstallStatusObserved = false;
+    const liveTargetIds = new Set<number>();
+    const recordBleInstallDisconnect = (error: unknown) => {
+      if (
+        !isBleInstall ||
+        !isProtocolV2DeviceDisconnectedError(error) ||
+        isProtocolV2InstallResponseTimeout(error)
+      ) {
+        return;
+      }
+      installStatusDisconnectObserved = true;
+      installReconnectObserved = false;
+      finishedStatusSnapshotKey = undefined;
+      finishedStatusSnapshotPolls = 0;
     };
 
     while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
+      // A transport release caused by an explicit workflow cancellation must not
+      // be mistaken for the expected device reboot during installation.
+      this.throwIfAborted();
       try {
         if (shouldReconnect) {
-          await this.reconnectProtocolV2Device();
-          deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+          const isBleInstallReconnect = this.isBleReconnect();
+          await this.reconnectProtocolV2Device({ skipProtocolProbe: true });
+          bleInstallLinkReady = isBleInstallReconnect;
+          deviceInfo = isBleInstallReconnect
+            ? undefined
+            : await this.verifyProtocolV2ReconnectIdentity();
+          if (isBleInstallReconnect && installStatusDisconnectObserved) {
+            installReconnectObserved = true;
+          }
           shouldReconnect = false;
         }
-        const currentDeviceInfo = deviceInfo;
+        let currentDeviceInfo = deviceInfo;
         try {
           const statusResponse = await this.device.getCommands().typedCall(
             'DeviceFirmwareUpdateStatusGet',
@@ -2643,91 +2585,235 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             {
               fields: {
                 status: true,
+                progress_percent: true,
+                phase_info: true,
                 payload_version: true,
                 path: true,
               },
             },
             { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT }
           );
+          if (this.protocolV2InstallTerminalSuccessObserved) {
+            installEvidenceObserved = true;
+          }
           const statusTargets = (statusResponse.message.records ??
             []) as ProtocolV2FirmwareUpdateStatusTarget[];
-          if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths)) {
-            this.protocolV2FinalStatusVerified = true;
+          this.collectProtocolV2LiveTargetIds(statusTargets, expectedTargetIds, liveTargetIds);
+          if (liveTargetIds.size > 0) {
+            currentInstallStatusObserved = true;
+          }
+          const hasMatchingTargetStatus = statusTargets.some(target => {
+            const targetId = normalizeProtocolV2TargetId(target.target_id);
+            return targetId !== undefined && expectedTargetIds.has(targetId);
+          });
+          if (
+            hasMatchingTargetStatus &&
+            (!requireCurrentInstallStatus || currentInstallStatusObserved)
+          ) {
+            installEvidenceObserved = true;
+          }
+          const matchingStatusTargets = statusTargets.filter(target => {
+            const targetId = normalizeProtocolV2TargetId(target.target_id);
+            return targetId !== undefined && expectedTargetIds.has(targetId);
+          });
+          const matchingFinishedTargetIds = new Set<number>();
+          const matchingFinishedStatus = matchingStatusTargets
+            .map(target => {
+              const targetId = normalizeProtocolV2TargetId(target.target_id);
+              const expectedPath = targetId === undefined ? undefined : expectedPaths.get(targetId);
+              const expectedVersion =
+                targetId === undefined
+                  ? undefined
+                  : this.getExpectedProtocolV2TargetVersion(targetId);
+              const payloadVersion = toProtocolV2FiniteNumber(target.payload_version);
+              if (
+                targetId === undefined ||
+                matchingFinishedTargetIds.has(targetId) ||
+                !isProtocolV2TargetStatusFinished(target.status) ||
+                (Boolean(target.path) && Boolean(expectedPath) && target.path !== expectedPath) ||
+                (expectedVersion !== undefined &&
+                  payloadVersion !== undefined &&
+                  payloadVersion !== expectedVersion)
+              ) {
+                return undefined;
+              }
+              matchingFinishedTargetIds.add(targetId);
+              return [targetId, target.path ?? null, payloadVersion ?? null] as const;
+            })
+            .filter((target): target is readonly [number, string | null, number | null] => !!target)
+            .sort(([leftTargetId], [rightTargetId]) => leftTargetId - rightTargetId);
+          const hasCompleteMatchingFinishedStatus =
+            matchingFinishedStatus.length === expectedTargetIds.size &&
+            matchingFinishedTargetIds.size === expectedTargetIds.size &&
+            expectedTargetIds.size > 0;
+          if (
+            requireCurrentInstallStatus &&
+            installReconnectObserved &&
+            hasCompleteMatchingFinishedStatus
+          ) {
+            const nextSnapshotKey = JSON.stringify(matchingFinishedStatus);
+            if (nextSnapshotKey === finishedStatusSnapshotKey) {
+              finishedStatusSnapshotPolls += 1;
+            } else {
+              finishedStatusSnapshotKey = nextSnapshotKey;
+              finishedStatusSnapshotPolls = 1;
+            }
+          } else {
+            finishedStatusSnapshotKey = undefined;
+            finishedStatusSnapshotPolls = 0;
+          }
+          if (
+            requireCurrentInstallStatus &&
+            installReconnectObserved &&
+            hasCompleteMatchingFinishedStatus &&
+            !currentInstallStatusObserved &&
+            !this.protocolV2InstallTerminalSuccessObserved &&
+            !fastFinishedInstallProgressReported
+          ) {
+            // A fast BLE install may finish while disconnected, so IN_PROGRESS can be hidden.
+            // A status response timeout alone is not evidence that the install was accepted.
+            this.postProgressMessage(1, 'installingFirmware');
+            fastFinishedInstallProgressReported = true;
+          }
+          const finishedAfterDisconnectObserved =
+            finishedStatusSnapshotPolls >= PROTOCOL_V2_INSTALL_FINISHED_AFTER_DISCONNECT_POLLS;
+          const hasCurrentInstallEvidence =
+            currentInstallStatusObserved ||
+            this.protocolV2InstallTerminalSuccessObserved ||
+            finishedAfterDisconnectObserved;
+          if (hasCurrentInstallEvidence) {
+            installEvidenceObserved = true;
+          }
+          const shouldVerifyTargetCompletion =
+            !requireCurrentInstallStatus || hasCurrentInstallEvidence;
+          if (
+            shouldVerifyTargetCompletion &&
+            this.assertProtocolV2TargetStatus(
+              statusTargets,
+              expectedTargetIds,
+              expectedPaths,
+              requireCurrentInstallStatus &&
+                !this.protocolV2InstallTerminalSuccessObserved &&
+                !finishedAfterDisconnectObserved
+                ? liveTargetIds
+                : undefined
+            )
+          ) {
             return;
           }
 
+          if (!hasCurrentInstallEvidence) {
+            // A successful status poll clears DeviceCommands' cancel action. Keep cancellation
+            // available while UpdateRequest is still waiting for confirmation on the device.
+            this.device.setCancelableAction(() => this.device.getCommands().cancelDevice());
+          }
+
           if (
-            statusTargets.length === 0 &&
-            currentDeviceInfo &&
-            (await this.probeProtocolV2NormalMode(currentDeviceInfo))
+            requireCurrentInstallStatus &&
+            !hasCurrentInstallEvidence &&
+            matchingStatusTargets.length > 0
           ) {
-            Log.log(
-              '[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete'
+            lastError = new Error(
+              'Protocol V2 firmware status is stale; waiting for the current install to start'
             );
-            this.postProgressMessage(100, 'installingFirmware');
-            return;
           }
 
-          const missingTargetIds = this.getProtocolV2MissingTargetIds(
-            statusTargets,
-            expectedTargetIds
-          );
-          if (missingTargetIds.length > 0) {
-            const now = Date.now();
-            const missingKey = missingTargetIds.join(',');
-            if (missingTargetStatusSince === undefined || missingTargetStatusKey !== missingKey) {
-              missingTargetStatusSince = now;
-              missingTargetStatusKey = missingKey;
-            } else if (
-              now - missingTargetStatusSince >=
-              PROTOCOL_V2_MISSING_TARGET_STATUS_GRACE_TIMEOUT
+          if (
+            statusTargets.length === 0 &&
+            !currentDeviceInfo &&
+            bleInstallLinkReady &&
+            installEvidenceObserved
+          ) {
+            // BLE install reconnect skips generic probes because loaders may not answer Ping.
+            // Restore the verified identity only after current-install evidence disappears.
+            currentDeviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+            deviceInfo = currentDeviceInfo;
+          }
+
+          if (statusTargets.length === 0 && currentDeviceInfo) {
+            const isNormalMode = await this.probeProtocolV2NormalMode(currentDeviceInfo);
+            if (
+              isNormalMode &&
+              (installEvidenceObserved ||
+                this.hasProtocolV2InstallVersionChanged(expectedTargetIds))
             ) {
-              const reportedTargetIds = statusTargets
-                .map(target => normalizeProtocolV2TargetId(target.target_id))
-                .filter((targetId): targetId is number => targetId !== undefined);
-              throw ERRORS.TypedError(
-                HardwareErrorCode.FirmwareError,
-                `Protocol V2 firmware status is missing requested records: targetIds=${missingKey} reportedTargetIds=${reportedTargetIds.join(
-                  ','
-                )}`
+              Log.log(
+                '[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete'
               );
+              this.recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds);
+              this.postProgressMessage(100, 'installingFirmware');
+              return;
             }
+          }
+
+          if (statusTargets.length === 0) {
             lastError = new Error(
-              `Protocol V2 firmware status is temporarily missing targetIds=${missingKey}`
+              'Protocol V2 firmware update is waiting for user confirmation or target status'
             );
           } else {
-            resetMissingTargetStatusGrace();
-            lastError = new Error('Protocol V2 firmware targets are still installing');
+            const missingTargetIds = this.getProtocolV2MissingTargetIds(
+              statusTargets,
+              expectedTargetIds
+            );
+            if (missingTargetIds.length > 0) {
+              const missingKey = missingTargetIds.join(',');
+              lastError = new Error(
+                `Protocol V2 firmware status is temporarily missing targetIds=${missingKey}`
+              );
+            } else {
+              lastError = new Error('Protocol V2 firmware targets are still installing');
+            }
           }
         } catch (error) {
           if (isProtocolV2TerminalInstallStatusError(error)) {
             throw error;
           }
-          // Only consecutive full status dumps can prove that a record is absent.
-          // A reboot or transport interruption starts a fresh grace window.
-          resetMissingTargetStatusGrace();
           // App firmware does not register DeviceFirmwareUpdateStatusGet. Treat the
           // missing endpoint as completion only after the runtime probe confirms App mode.
           if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
             if (!currentDeviceInfo) {
+              if (!bleInstallLinkReady) {
+                throw ERRORS.TypedError(
+                  HardwareErrorCode.RuntimeError,
+                  'Protocol V2 device identity is unavailable during install polling'
+                );
+              }
+              deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+            }
+            const reconnectDeviceInfo = currentDeviceInfo ?? deviceInfo;
+            if (!reconnectDeviceInfo) {
               throw ERRORS.TypedError(
                 HardwareErrorCode.RuntimeError,
                 'Protocol V2 device identity is unavailable during install polling'
               );
             }
-            if (await this.probeProtocolV2NormalMode(currentDeviceInfo)) {
+            const isNormalMode = await this.probeProtocolV2NormalMode(reconnectDeviceInfo);
+            if (
+              isNormalMode &&
+              (installEvidenceObserved ||
+                this.hasProtocolV2InstallVersionChanged(expectedTargetIds))
+            ) {
               Log.log(
                 '[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot'
               );
+              this.recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds);
               this.postProgressMessage(100, 'installingFirmware');
               return;
             }
-            lastError = new Error(
-              'Protocol V2 firmware status endpoint is unavailable while the device remains in loader mode'
-            );
+            if (isNormalMode) {
+              lastError = new Error(
+                'Protocol V2 device is in normal mode but installation is not yet confirmed'
+              );
+            } else {
+              lastError = new Error(
+                'Protocol V2 firmware status endpoint is unavailable while the device remains in loader mode'
+              );
+            }
           } else {
+            recordBleInstallDisconnect(error);
             shouldReconnect = true;
             deviceInfo = undefined;
+            bleInstallLinkReady = false;
             lastError = error;
             Log.log(
               '[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ',
@@ -2749,20 +2835,27 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         ) {
           throw error;
         }
+        recordBleInstallDisconnect(error);
         shouldReconnect = true;
         deviceInfo = undefined;
-        resetMissingTargetStatusGrace();
+        bleInstallLinkReady = false;
         Log.log('Protocol V2 firmware install device readiness probe failed: ', error);
       }
       await wait(1000);
     }
 
-    throw ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      `Protocol V2 firmware update status not complete within ${
+    Log.error(
+      `[FirmwareUpdateV4] install timed out after ${
         PROTOCOL_V2_INSTALL_TIMEOUT / 1000
       }s: ${this.normalizeErrorMessage(lastError)}`
     );
+    throw ERRORS.TypedError(
+      HardwareErrorCode.FirmwareError,
+      'Protocol V2 firmware install timed out',
+      {
+        firmwareUpdateCode: PROTOCOL_V2_INSTALL_TIMEOUT_CODE,
+      }
+    );
   }
 
   private async exitProtocolV2BootloaderToNormal() {
@@ -2774,6 +2867,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         return;
       }
     } catch (error) {
+      if (isBleStaleBondHardwareError(error)) {
+        throw error;
+      }
       Log.log('[FirmwareUpdateV4] unable to confirm App mode before Normal reboot: ', error);
     }
     await this.protocolV2Reboot(DeviceRebootType.Normal);
@@ -2785,7 +2881,14 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       deviceInfo,
       PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
     );
-    return features.mode === 'normal' && !features.bootloaderMode;
+    this.protocolV2LastRuntimeProbeFeatures = features;
+    return this.isProtocolV2ApplicationMode(features);
+  }
+
+  private isProtocolV2ApplicationMode(features: Features) {
+    return (
+      (features.mode === 'normal' || features.mode === 'notInitialized') && !features.bootloaderMode
+    );
   }
 
   private async waitForProtocolV2FinalFeatures() {
@@ -2829,6 +2932,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const startTime = Date.now();
     let lastError: unknown;
     let shouldReconnect = true;
+    this.protocolV2LatestFinalDeviceInfo = undefined;
 
     while (Date.now() - startTime < timeout) {
       try {
@@ -2845,9 +2949,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
         const features = await this.device.probeProtocolV2RuntimeState(
           deviceInfo,
-          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+          { forceRuntimeContextRefresh: true }
         );
-        if (features.mode === 'normal' && !features.bootloaderMode) {
+        if (this.isProtocolV2ApplicationMode(features)) {
+          this.protocolV2LatestFinalDeviceInfo = deviceInfo;
           return features;
         }
         lastError = ERRORS.TypedError(
@@ -2855,7 +2961,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           'Protocol V2 device is still in bootloader mode'
         );
       } catch (error) {
-        if (this.isProtocolV2ReconnectIdentityError(error)) {
+        if (isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
           throw error;
         }
         shouldReconnect = true;
@@ -2873,19 +2979,53 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     );
   }
 
-  private async reconnectProtocolV2Device() {
+  private async reconnectProtocolV2Device(options?: { skipProtocolProbe?: boolean }) {
     if (this.isBleReconnect()) {
-      await this.acquireProtocolV2BleDevice();
+      await this.acquireProtocolV2BleDevice(options?.skipProtocolProbe);
       return;
     }
 
     const deviceDiff = await this.device.deviceConnector?.enumerate();
     const devicesDescriptor = deviceDiff?.descriptors ?? [];
+    const env = DataManager.getSettings('env');
+    const isWebUsb = DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env);
 
-    if (
-      DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
-      devicesDescriptor.length === 1
-    ) {
+    if (isWebUsb && options?.skipProtocolProbe) {
+      const expectedSerialNumber = this.protocolV2ExpectedSerialNumber?.trim();
+      const expectedPath = this.protocolV2ExpectedPath?.trim();
+      const reconnectDescriptor = devicesDescriptor.find(descriptor => {
+        const descriptorPath = descriptor.path?.trim();
+        return (
+          (!!expectedSerialNumber && descriptorPath === expectedSerialNumber) ||
+          (!!expectedPath && descriptorPath === expectedPath)
+        );
+      });
+      if (!reconnectDescriptor?.path) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
+      }
+      this.device.updateDescriptor(
+        {
+          ...reconnectDescriptor,
+          protocolType: PROTOCOL_V2_CONNECT_PROTOCOL,
+        },
+        true
+      );
+      const mainId = await this.device.deviceConnector?.acquire(
+        reconnectDescriptor.path,
+        null,
+        undefined,
+        PROTOCOL_V2_CONNECT_PROTOCOL,
+        undefined,
+        undefined,
+        true
+      );
+      this.device.mainId = typeof mainId === 'string' ? mainId : reconnectDescriptor.path;
+      this.device.commands.disposed = false;
+      this.device.getCommands().mainId = this.device.mainId;
+      return;
+    }
+
+    if (isWebUsb && devicesDescriptor.length === 1) {
       const descriptor = devicesDescriptor[0];
       if (!this.protocolV2ExpectedSerialNumber && descriptor.path !== this.protocolV2ExpectedPath) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
@@ -3003,13 +3143,24 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     await wait(2000);
   }
 
-  private async acquireProtocolV2BleDevice() {
-    await this.device.deviceConnector?.acquire(
-      this.device.originalDescriptor.id,
+  private async acquireProtocolV2BleDevice(skipProtocolProbe = false) {
+    const connector = this.device.deviceConnector;
+    const expectedId = this.device.originalDescriptor.id;
+    if (!skipProtocolProbe) {
+      await connector?.acquire(expectedId, null, true, PROTOCOL_V2_CONNECT_PROTOCOL);
+      return;
+    }
+    await connector?.acquire(
+      expectedId,
       null,
       true,
-      PROTOCOL_V2_CONNECT_PROTOCOL
+      PROTOCOL_V2_CONNECT_PROTOCOL,
+      undefined,
+      undefined,
+      skipProtocolProbe
     );
+    this.device.commands.disposed = false;
+    this.device.getCommands().mainId = expectedId;
   }
 
   private async protocolV2StartFirmwareUpdate({
@@ -3017,30 +3168,74 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }: {
     targets: Array<{ target_id: number; path: string }>;
   }) {
+    this.protocolV2LastRuntimeProbeFeatures = undefined;
+    this.protocolV2InstallNeedsReconnect = false;
+    this.protocolV2InstallDisconnectObserved = false;
+    this.protocolV2InstallTerminalSuccessObserved = false;
     const commands = this.device.getCommands();
-    const response: ProtocolV2FirmwareUpdateStartResponse = await commands.typedCall(
-      'DeviceFirmwareUpdateRequest',
-      'Success',
-      { targets },
-      { timeoutMs: PROTOCOL_V2_START_UPDATE_TIMEOUT }
+    await commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
+    this.device.setCancelableAction(() => this.device.getCommands().cancelDevice());
+    const interaction = this.device.createProtocolV2UiPhaseMetadata('button', 'start');
+    this.postMessage(
+      createUiMessage(UI_REQUEST.REQUEST_BUTTON, {
+        device: this.device.toMessageObject() as KnownDevice,
+        source: 'method-lifecycle',
+        reason: 'firmware-update',
+        completion: 'operation-completed',
+        deviceOnly: true,
+        operation: this.name,
+        ...(interaction ? { interaction } : {}),
+      })
     );
-    // Success acknowledges that the device accepted installation. End confirmation
-    // and begin status polling only after receiving this ACK.
-    this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdating);
-    this.postProgressMessage(0, 'installingFirmware');
-    return response;
+
+    try {
+      await commands.call(
+        'DeviceFirmwareUpdateRequest',
+        {},
+        {
+          returnAfterWrite: true,
+          expectedTypes: ['Success'],
+          onResponseAfterWrite: response => {
+            if (response.type !== 'Success') return;
+            this.protocolV2InstallTerminalSuccessObserved = true;
+            this.device.clearCancelableAction();
+            Log.log('[FirmwareUpdateV4] firmware install completed by device response');
+          },
+        }
+      );
+      Log.log('[FirmwareUpdateV4] firmware install request written; continue with status polling');
+    } catch (error) {
+      this.throwIfAborted();
+      if (!isProtocolV2DeviceDisconnectedError(error)) {
+        throw error;
+      }
+      Log.log(
+        '[FirmwareUpdateV4] transport released while writing install request; continue status polling'
+      );
+      this.protocolV2InstallNeedsReconnect = true;
+      this.protocolV2InstallDisconnectObserved = !isProtocolV2InstallResponseTimeout(error);
+    }
   }
 
   private async protocolV2Reboot(rebootType: DeviceRebootType) {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
     try {
-      const res = await typedCall('DeviceReboot', 'Success', {
-        reboot_type: rebootType,
-      });
+      const res = await typedCall(
+        'DeviceReboot',
+        'Success',
+        {
+          reboot_type: rebootType,
+        },
+        { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT }
+      );
       this.device.markProtocolV2Reboot(rebootType);
       return res.message;
     } catch (error) {
-      if (isProtocolV2DeviceDisconnectedError(error) || isProtocolV2ReconnectProbeError(error)) {
+      if (
+        isProtocolV2DeviceDisconnectedError(error) ||
+        isProtocolV2ReconnectProbeError(error) ||
+        isProtocolV2ResponseTimeout(error)
+      ) {
         this.device.markProtocolV2Reboot(rebootType);
         return { message: 'Device rebooted successfully' };
       }