From 92ce5c39b0f2e33f59fb22f6679d2e43112ca4ec Mon Sep 17 00:00:00 2001
From: Karel Tucek <kareltucek@centrum.cz>
Date: Thu, 8 Oct 2026 14:29:15 +0200
Subject: [PATCH] feat: detect broken bonds and offer re-pairing

Show a top notification panel when the bond between the keyboard halves
is broken (GetDeviceState byte 2 bit 4) and offer to re-pair them. After
a successful re-pair keep the progress state until the device reports a
healthy bond or 5 seconds elapse. On failure navigate to the advanced
settings page where the pairing log is visible.

Report the dongle bond health too (IsPaired response byte 2), re-checked
periodically, and treat a bond known to only one of the devices as
broken. The dongle pairing panel shows a re-pair message in these cases.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../uhk-agent/src/services/device.service.ts  | 36 ++++++++++++++++++-
 .../src/models/device-connection-state.ts     |  4 +++
 packages/uhk-common/src/models/dongle.ts      |  5 +++
 packages/uhk-usb/src/models/bond-state.ts     |  7 ++++
 packages/uhk-usb/src/models/device-state.ts   |  1 +
 packages/uhk-usb/src/models/index.ts          |  1 +
 packages/uhk-usb/src/uhk-hid-device.ts        | 19 ++++++++--
 packages/uhk-web/src/app/app.component.html   |  6 ++++
 packages/uhk-web/src/app/app.component.scss   |  1 +
 packages/uhk-web/src/app/app.component.ts     | 17 ++++++++-
 .../dongle-pairing-panel.component.html       |  6 +++-
 .../dongle-pairing-panel.component.ts         |  1 +
 .../halves-pairing-panel.component.html       |  9 +++++
 .../halves-pairing-panel.component.scss       | 21 +++++++++++
 .../halves-pairing-panel.component.ts         | 17 +++++++++
 .../src/app/models/dongle-pairing-state.ts    |  1 +
 .../src/app/models/halves-pairing-state.ts    |  4 +++
 packages/uhk-web/src/app/models/index.ts      |  1 +
 packages/uhk-web/src/app/shared.module.ts     |  2 ++
 .../store/actions/advance-settings.action.ts  |  6 ++++
 .../effects/advanced-settings.effects.ts      | 27 +++++++++++++-
 packages/uhk-web/src/app/store/index.ts       | 25 ++++++++++++-
 .../reducers/advanced-settings.reducer.ts     | 31 +++++++++++++---
 .../uhk-web/src/app/store/reducers/device.ts  |  4 +++
 24 files changed, 240 insertions(+), 12 deletions(-)
 create mode 100644 packages/uhk-usb/src/models/bond-state.ts
 create mode 100644 packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.html
 create mode 100644 packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.scss
 create mode 100644 packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.ts
 create mode 100644 packages/uhk-web/src/app/models/halves-pairing-state.ts

diff --git a/packages/uhk-agent/src/services/device.service.ts b/packages/uhk-agent/src/services/device.service.ts
index 5a3cdfc7154..472e8ee2ed7 100644
--- a/packages/uhk-agent/src/services/device.service.ts
+++ b/packages/uhk-agent/src/services/device.service.ts
@@ -100,6 +100,9 @@ import {
 import { QueueManager } from './queue-manager';
 import { ZephyrLogService } from './zephyr-log.service';
 
+// the poller iterates at most every 250ms, so it is at least 10 seconds
+const DONGLE_BOND_POLL_ITERATIONS = 40;
+
 /**
  * IpcMain pair of the UHK Communication
  * Functionality:
@@ -1231,6 +1234,8 @@ export class DeviceService {
     private async uhkDevicePoller(): Promise<void> {
         let deviceProtocolVersion: string;
         let iterationCount = 0;
+        // set only while a dongle that can be queried is connected
+        let dongleBond: { deviceBleAddress: number[], isBondBroken: boolean };
 
         while (true) {
             if (this._pollerAllowed) {
@@ -1241,6 +1246,7 @@ export class DeviceService {
                     const state = await this.device.getDeviceConnectionStateAsync();
                     if (!isEqual(state, this.savedState)) {
                         const newState = cloneDeep(state);
+                        dongleBond = undefined;
 
                         if (state.hasPermission && state.communicationInterfaceAvailable) {
                             state.hardwareModules = await this.getHardwareModules(false);
@@ -1264,7 +1270,10 @@ export class DeviceService {
                                     dongleUhkDevice = new UhkHidDevice(this.logService, this.options, this.rootDir, dongle);
                                     const dongleBleAddress = await dongleUhkDevice.getBleAddress();
                                     state.dongle.bleAddress = convertBleAddressArrayToString(dongleBleAddress);
-                                    state.dongle.isPairedWithKeyboard = await dongleUhkDevice.isPairedWith(deviceBleAddress);
+                                    const dongleBondState = await dongleUhkDevice.getBondState(deviceBleAddress);
+                                    state.dongle.isPairedWithKeyboard = dongleBondState.isPaired;
+                                    state.dongle.isBondBroken = dongleBondState.isBondBroken;
+                                    dongleBond = { deviceBleAddress, isBondBroken: dongleBondState.isBondBroken };
                                     state.isPairedWithDongle = await this.device.isPairedWith(dongleBleAddress);
                                     const dongleOperations = new UhkOperations(this.logService, dongleUhkDevice);
                                     state.dongle.versionInfo = await dongleOperations.getDeviceVersionInfo();
@@ -1299,6 +1308,13 @@ export class DeviceService {
 
                         this.logService.misc('[DeviceService] Device connection state changed to:', JSON.stringify(state, null, 2));
                     }
+                    else if (dongleBond && iterationCount % DONGLE_BOND_POLL_ITERATIONS === 0) {
+                        // The dongle is queried only when the connection state changes, but its bond can break at any time.
+                        const isBondBroken = await this.isDongleBondBroken(dongleBond.deviceBleAddress);
+                        if (isBondBroken !== dongleBond.isBondBroken) {
+                            this.savedState = undefined;
+                        }
+                    }
 
                     if (state.isMacroStatusDirty) {
                         this._checkStatusBuffer = true;
@@ -1327,6 +1343,24 @@ export class DeviceService {
         }
     }
 
+    private async isDongleBondBroken(deviceBleAddress: number[]): Promise<boolean> {
+        await this.dongleZephyrLogService.disable();
+        let dongleUhkDevice: UhkHidDevice;
+        try {
+            const dongle = await getCurrentUhkDongleHID();
+            dongleUhkDevice = new UhkHidDevice(this.logService, this.options, this.rootDir, dongle);
+            const bondState = await dongleUhkDevice.getBondState(deviceBleAddress);
+
+            return bondState.isBondBroken;
+        }
+        finally {
+            if (dongleUhkDevice) {
+                await dongleUhkDevice.close();
+            }
+            await this.dongleZephyrLogService.enable();
+        }
+    }
+
     private async pollDebugInfo(iterationCount: number): Promise<void> {
         if(!this.isI2cDebuggingEnabled) {
             return;
diff --git a/packages/uhk-common/src/models/device-connection-state.ts b/packages/uhk-common/src/models/device-connection-state.ts
index f64705651af..e875737d0fb 100644
--- a/packages/uhk-common/src/models/device-connection-state.ts
+++ b/packages/uhk-common/src/models/device-connection-state.ts
@@ -18,6 +18,10 @@ export interface DeviceConnectionState {
     dongle: Dongle;
     leftHalfBootloaderActive: boolean;
     hasPermission: boolean;
+    /**
+     * The left half rejected the bond of the right half (GetDeviceState byte 2 bit 4).
+     */
+    isHalvesBondBroken: boolean;
     bootloaderActive: boolean;
     isMacroStatusDirty: boolean;
     isZephyrLogAvailable: boolean;
diff --git a/packages/uhk-common/src/models/dongle.ts b/packages/uhk-common/src/models/dongle.ts
index ca9904deae2..aacb209cf16 100644
--- a/packages/uhk-common/src/models/dongle.ts
+++ b/packages/uhk-common/src/models/dongle.ts
@@ -5,6 +5,11 @@ export interface Dongle {
 
     bootloaderActive: boolean;
 
+    /**
+     * The keyboard rejected the bond of the dongle.
+     */
+    isBondBroken?: boolean;
+
     isPairedWithKeyboard?: boolean;
     /**
      * True if more than 1 UHK dongle connected.
diff --git a/packages/uhk-usb/src/models/bond-state.ts b/packages/uhk-usb/src/models/bond-state.ts
new file mode 100644
index 00000000000..b2909966d20
--- /dev/null
+++ b/packages/uhk-usb/src/models/bond-state.ts
@@ -0,0 +1,7 @@
+export interface BondState {
+    isPaired: boolean;
+    /**
+     * The peer rejected the bond (IsPaired response byte 2).
+     */
+    isBondBroken: boolean;
+}
diff --git a/packages/uhk-usb/src/models/device-state.ts b/packages/uhk-usb/src/models/device-state.ts
index 952a8d5e387..9ef8a6fa6d8 100644
--- a/packages/uhk-usb/src/models/device-state.ts
+++ b/packages/uhk-usb/src/models/device-state.ts
@@ -1,6 +1,7 @@
 export interface DeviceState {
     isEepromBusy: boolean;
     isMacroStatusDirty: boolean;
+    isPeerBondBroken: boolean;
     isZephyrLogAvailable: boolean;
     areHalvesMerged: boolean;
     isLeftHalfConnected: boolean;
diff --git a/packages/uhk-usb/src/models/index.ts b/packages/uhk-usb/src/models/index.ts
index 75cbf676657..d56a86fb5f0 100644
--- a/packages/uhk-usb/src/models/index.ts
+++ b/packages/uhk-usb/src/models/index.ts
@@ -1,3 +1,4 @@
+export * from './bond-state.js';
 export * from './debug-info.js';
 export * from './device-state.js';
 export * from './duration.js';
diff --git a/packages/uhk-usb/src/uhk-hid-device.ts b/packages/uhk-usb/src/uhk-hid-device.ts
index 26922d87970..9522d6462ac 100644
--- a/packages/uhk-usb/src/uhk-hid-device.ts
+++ b/packages/uhk-usb/src/uhk-hid-device.ts
@@ -43,6 +43,7 @@ import {
     UsbCommand
 } from './constants.js';
 import {
+    BondState,
     DeviceState,
     PairingInfo,
     ReenumerateOption,
@@ -229,6 +230,12 @@ export class UhkHidDevice {
     }
 
     public async isPairedWith(address: number[]): Promise<boolean> {
+        const bondState = await this.getBondState(address);
+
+        return bondState.isPaired;
+    }
+
+    public async getBondState(address: number[]): Promise<BondState> {
         await this.assertDeviceSupportWirelessUSBCommands();
 
         this.logService.usbOps('[UhkHidDevice] USB[T]: is paired with');
@@ -237,10 +244,13 @@ export class UhkHidDevice {
             ...address,
         ]);
         const responseBuffer = await this.write(buffer);
-        // 1st byte is the status code we skip it
-        const response = responseBuffer.readUInt8(1);
 
-        return response === 1;
+        // 1st byte is the status code we skip it
+        return {
+            isPaired: responseBuffer.readUInt8(1) === 1,
+            // older firmwares always send 0
+            isBondBroken: responseBuffer.readUInt8(2) === 1,
+        };
     }
 
     public async pairCentral(): Promise<void> {
@@ -328,6 +338,7 @@ export class UhkHidDevice {
                 rightModuleSlot: RightSlotModules.NoModule
             },
             hardwareModules: {},
+            isHalvesBondBroken: false,
             isMacroStatusDirty: false,
             isZephyrLogAvailable: false,
             leftHalfDetected: false,
@@ -410,6 +421,7 @@ export class UhkHidDevice {
             const deviceState = await this.getDeviceState();
             result.activeKeymapIndex = deviceState.activeKeymapIndex;
             result.halvesInfo = calculateHalvesState(deviceState);
+            result.isHalvesBondBroken = deviceState.isPeerBondBroken;
             result.isMacroStatusDirty = deviceState.isMacroStatusDirty;
             result.isZephyrLogAvailable = deviceState.isZephyrLogAvailable;
 
@@ -635,6 +647,7 @@ export class UhkHidDevice {
             leftModuleSlot: MODULE_ID_TO_STRING[buffer[4]],
             newPairedDevice: isBitSet(buffer[2], 2),
             isZephyrLogAvailable: isBitSet(buffer[2], 3),
+            isPeerBondBroken: isBitSet(buffer[2], 4),
             rightModuleSlot: MODULE_ID_TO_STRING[buffer[5]]
         };
     }
diff --git a/packages/uhk-web/src/app/app.component.html b/packages/uhk-web/src/app/app.component.html
index 5e7fd7c7f92..e5805258583 100644
--- a/packages/uhk-web/src/app/app.component.html
+++ b/packages/uhk-web/src/app/app.component.html
@@ -13,8 +13,14 @@
     <dongle-pairing-panel *ngIf="donglePairingState?.showDonglePairingPanel"
                           [@topNotificationPanelVisible]
                           [state]="donglePairingState.state"
+                          [isBondBroken]="donglePairingState.isBondBroken"
                           (pairDongle)="startDonglePairing()"
     />
+    <halves-pairing-panel *ngIf="halvesPairingState?.showHalvesPairingPanel"
+                          [@topNotificationPanelVisible]
+                          [isPairing]="halvesPairingState.isPairing"
+                          (pairHalves)="startHalvesPairing()"
+    />
     <firmware-upgrade-panel *ngIf="showFirmwareUpgradePanel"
                             [@topNotificationPanelVisible]
                             (updateFirmware)="updateFirmware()"
diff --git a/packages/uhk-web/src/app/app.component.scss b/packages/uhk-web/src/app/app.component.scss
index 8649aba2919..5e2d3bf94f4 100644
--- a/packages/uhk-web/src/app/app.component.scss
+++ b/packages/uhk-web/src/app/app.component.scss
@@ -53,6 +53,7 @@
 
 ble-pairing-panel,
 dongle-pairing-panel,
+halves-pairing-panel,
 firmware-upgrade-panel,
 app-update-available,
 shared-config-change-panel {
diff --git a/packages/uhk-web/src/app/app.component.ts b/packages/uhk-web/src/app/app.component.ts
index d632976963c..e0cdf24a6b9 100644
--- a/packages/uhk-web/src/app/app.component.ts
+++ b/packages/uhk-web/src/app/app.component.ts
@@ -17,6 +17,7 @@ import { EnableUsbStackTestAction, UpdateFirmwareAction } from './store/actions/
 import {
     AppState,
     getDonglePairingState,
+    getHalvesPairingState,
     getNewPairedDevicesState,
     getErrorPanelHeight,
     getShowAppUpdateAvailable,
@@ -32,6 +33,7 @@ import {
     getShowFirmwareUpgradePanel,
     getSharedConfigChange
 } from './store';
+import { StartLeftHalfPairingAction } from './store/actions/advance-settings.action';
 import { StartDonglePairingAction } from './store/actions/dongle-pairing.action';
 import { AddNewPairedDevicesToHostConnectionsAction } from './store/actions/user-config';
 import { ProgressButtonState } from './store/reducers/progress-button-state';
@@ -45,7 +47,7 @@ import {
     ApplySharedConfigChangeAction,
     DismissSharedConfigChangeAction,
 } from './store/actions/app';
-import { BleAddingState, DonglePairingState, OutOfSpaceWarningData } from './models';
+import { BleAddingState, DonglePairingState, HalvesPairingState, OutOfSpaceWarningData } from './models';
 import { filter } from 'rxjs/operators';
 import { SecondSideMenuContainerComponent } from './components/side-menu';
 
@@ -114,6 +116,7 @@ export class MainAppComponent implements OnDestroy {
     @ViewChild('manuallyUpdateNotification', { static: true }) manuallyUpdateNotificationTmpl;
 
     donglePairingState: DonglePairingState;
+    halvesPairingState: HalvesPairingState;
     newPairedDevicesState: BleAddingState;
     showFirmwareUpgradePanel: boolean;
     showUpdateAvailable: boolean;
@@ -135,6 +138,7 @@ export class MainAppComponent implements OnDestroy {
     private actionsSubscription: Subscription;
     private readonly cdRef = inject(ChangeDetectorRef);
     private donglePairingStateSubscription: Subscription;
+    private halvesPairingStateSubscription: Subscription;
     private newPairedDevicesStateSubscription: Subscription;
     private errorPanelHeightSubscription: Subscription;
     private readonly keyboardSvgExportService = inject(KeyboardSvgExportService);
@@ -172,6 +176,11 @@ export class MainAppComponent implements OnDestroy {
                 this.donglePairingState = data;
                 this.cdRef.markForCheck();
             });
+        this.halvesPairingStateSubscription = this.store.select(getHalvesPairingState)
+            .subscribe(data => {
+                this.halvesPairingState = data;
+                this.cdRef.markForCheck();
+            });
         this.newPairedDevicesStateSubscription = this.store.select(getNewPairedDevicesState)
             .subscribe(data => {
                 this.newPairedDevicesState = data;
@@ -248,6 +257,7 @@ export class MainAppComponent implements OnDestroy {
     ngOnDestroy(): void {
         this.actionsSubscription.unsubscribe();
         this.donglePairingStateSubscription.unsubscribe();
+        this.halvesPairingStateSubscription.unsubscribe();
         this.newPairedDevicesStateSubscription.unsubscribe();
         this.errorPanelHeightSubscription.unsubscribe();
         this.saveToKeyboardStateSubscription.unsubscribe();
@@ -338,6 +348,7 @@ export class MainAppComponent implements OnDestroy {
         return this.showFirmwareUpgradePanel
             || this.showUpdateAvailable
             || this.donglePairingState?.showDonglePairingPanel
+            || this.halvesPairingState?.showHalvesPairingPanel
             || this.newPairedDevicesState?.showNewPairedDevicesPanel
             || !!this.sharedConfigChange;
     }
@@ -356,6 +367,10 @@ export class MainAppComponent implements OnDestroy {
         this.store.dispatch(new UpdateFirmwareAction(false));
     }
 
+    startHalvesPairing(): void {
+        this.store.dispatch(new StartLeftHalfPairingAction());
+    }
+
     startDonglePairing(): void {
         this.store.dispatch(new StartDonglePairingAction());
     }
diff --git a/packages/uhk-web/src/app/components/device/dongle-pairing-panel/dongle-pairing-panel.component.html b/packages/uhk-web/src/app/components/device/dongle-pairing-panel/dongle-pairing-panel.component.html
index 373f2f77ec8..9fda0c2c946 100644
--- a/packages/uhk-web/src/app/components/device/dongle-pairing-panel/dongle-pairing-panel.component.html
+++ b/packages/uhk-web/src/app/components/device/dongle-pairing-panel/dongle-pairing-panel.component.html
@@ -1,5 +1,9 @@
 <div class="dongle-pairing-panel-wrapper" role="alert">
-    <span *ngIf="state === DonglePairingStates.Idle">
+    <span *ngIf="state === DonglePairingStates.Idle && isBondBroken">
+        The pairing of the dongle is broken. <a routerLink="/device/host-connections" (click)="pairDongle.emit()">Re-pair it</a> with this keyboard.
+    </span>
+
+    <span *ngIf="state === DonglePairingStates.Idle && !isBondBroken">
         A dongle is detected. <a routerLink="/device/host-connections" (click)="pairDongle.emit()">Pair it</a> with this keyboard.
     </span>
 
diff --git a/packages/uhk-web/src/app/components/device/dongle-pairing-panel/dongle-pairing-panel.component.ts b/packages/uhk-web/src/app/components/device/dongle-pairing-panel/dongle-pairing-panel.component.ts
index 2735658ba54..9978e2bb959 100644
--- a/packages/uhk-web/src/app/components/device/dongle-pairing-panel/dongle-pairing-panel.component.ts
+++ b/packages/uhk-web/src/app/components/device/dongle-pairing-panel/dongle-pairing-panel.component.ts
@@ -12,6 +12,7 @@ import { DonglePairingStates } from '../../../models';
 })
 export class DonglePairingPanelComponent {
     @Input() state: DonglePairingStates;
+    @Input() isBondBroken: boolean;
 
     @Output() pairDongle = new EventEmitter<void>();
 
diff --git a/packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.html b/packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.html
new file mode 100644
index 00000000000..2d8869cecfa
--- /dev/null
+++ b/packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.html
@@ -0,0 +1,9 @@
+<div class="halves-pairing-panel-wrapper" role="alert">
+    <span *ngIf="!isPairing">
+        The pairing of the keyboard halves is broken. Connect both halves via USB and <a href="#" (click)="$event.preventDefault(); pairHalves.emit()">re-pair them</a>.
+    </span>
+
+    <span *ngIf="isPairing">
+        Pairing keyboard halves... <fa-icon [icon]="faSpinner" animation="spin"></fa-icon>
+    </span>
+</div>
diff --git a/packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.scss b/packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.scss
new file mode 100644
index 00000000000..54405accad4
--- /dev/null
+++ b/packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.scss
@@ -0,0 +1,21 @@
+@import '../../../../styles/variables';
+
+.halves-pairing-panel-wrapper {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    height: $main-content-top-margin-on-update;
+    margin: 0;
+    padding-top: 5px;
+    padding-bottom: 5px;
+
+    background-color: var(--color-firmware-upgrade-panel-bg);
+    color: var(--color-firmware-upgrade-panel-text);
+    border-radius: 0;
+    border-width: 0;
+
+    a {
+        color: var(--color-firmware-upgrade-panel-text);
+        text-decoration: underline;
+    }
+}
diff --git a/packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.ts b/packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.ts
new file mode 100644
index 00000000000..8b8f00f923e
--- /dev/null
+++ b/packages/uhk-web/src/app/components/device/halves-pairing-panel/halves-pairing-panel.component.ts
@@ -0,0 +1,17 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { faSpinner } from '@fortawesome/free-solid-svg-icons';
+
+@Component({
+    selector: 'halves-pairing-panel',
+    changeDetection: ChangeDetectionStrategy.OnPush,
+    standalone: false,
+    templateUrl: './halves-pairing-panel.component.html',
+    styleUrls: ['./halves-pairing-panel.component.scss']
+})
+export class HalvesPairingPanelComponent {
+    @Input() isPairing: boolean;
+
+    @Output() pairHalves = new EventEmitter<void>();
+
+    protected readonly faSpinner = faSpinner;
+}
diff --git a/packages/uhk-web/src/app/models/dongle-pairing-state.ts b/packages/uhk-web/src/app/models/dongle-pairing-state.ts
index 1ca1fd8e459..4d29ef9ceb8 100644
--- a/packages/uhk-web/src/app/models/dongle-pairing-state.ts
+++ b/packages/uhk-web/src/app/models/dongle-pairing-state.ts
@@ -17,6 +17,7 @@ export enum DongleOperations {
 
 export interface DonglePairingState {
     showDonglePairingPanel: boolean;
+    isBondBroken: boolean;
     operation: DongleOperations;
     state: DonglePairingStates;
 }
diff --git a/packages/uhk-web/src/app/models/halves-pairing-state.ts b/packages/uhk-web/src/app/models/halves-pairing-state.ts
new file mode 100644
index 00000000000..ab1ffb00eef
--- /dev/null
+++ b/packages/uhk-web/src/app/models/halves-pairing-state.ts
@@ -0,0 +1,4 @@
+export interface HalvesPairingState {
+    showHalvesPairingPanel: boolean;
+    isPairing: boolean;
+}
diff --git a/packages/uhk-web/src/app/models/index.ts b/packages/uhk-web/src/app/models/index.ts
index 88764171cae..e692c75125a 100644
--- a/packages/uhk-web/src/app/models/index.ts
+++ b/packages/uhk-web/src/app/models/index.ts
@@ -7,6 +7,7 @@ export * from './copied-layer-origin';
 export * from './delete-host-connection-payload';
 export * from './device-ui-states';
 export * from './dongle-pairing-state';
+export * from './halves-pairing-state';
 export * from './duplicate-macro-action-payload';
 export * from './erase-ble-settings-button-state';
 export * from './exchange-keys-action.model';
diff --git a/packages/uhk-web/src/app/shared.module.ts b/packages/uhk-web/src/app/shared.module.ts
index 96c9f118bbe..e94521f6898 100644
--- a/packages/uhk-web/src/app/shared.module.ts
+++ b/packages/uhk-web/src/app/shared.module.ts
@@ -23,6 +23,7 @@ import CircleTooltipComponent from './components/circle-tooltip/circle-tooltip.c
 import { BlePairingPanelComponent } from './components/device/ble-pairing-panel/ble-pairing-panel.component';
 import { FadeTimeoutSliderComponent } from './components/device/led-settings/fade-timeout-slider.component';
 import { DonglePairingPanelComponent } from './components/device/dongle-pairing-panel/dongle-pairing-panel.component';
+import { HalvesPairingPanelComponent } from './components/device/halves-pairing-panel/halves-pairing-panel.component';
 import { SharedConfigChangePanelComponent } from './components/shared-config-change-panel/shared-config-change-panel.component';
 import { KeyboardSliderComponent } from './components/keyboard/slider';
 import {
@@ -204,6 +205,7 @@ import appInitFactory from './services/app-init-factory';
         KeymapHeaderComponent,
         NotificationComponent,
         DonglePairingPanelComponent,
+        HalvesPairingPanelComponent,
         SharedConfigChangePanelComponent,
         SvgIconTextKeyComponent,
         SvgKeyboardKeyComponent,
diff --git a/packages/uhk-web/src/app/store/actions/advance-settings.action.ts b/packages/uhk-web/src/app/store/actions/advance-settings.action.ts
index 7f87bf72925..f4fcad0aa79 100644
--- a/packages/uhk-web/src/app/store/actions/advance-settings.action.ts
+++ b/packages/uhk-web/src/app/store/actions/advance-settings.action.ts
@@ -12,6 +12,7 @@ export enum ActionTypes {
     startLeftHalfPairing = '[advanceSettings] start left half pairing',
     leftHalfPairingSuccess = '[advanceSettings] left half pairing success',
     leftHalfPairingFailed = '[advanceSettings] left half pairing failed',
+    halvesBondCheckTimeout = '[advanceSettings] halves bond check timeout',
     toggleI2CDebugging = '[advanceSettings] toggle I2c debugging',
     toggleI2CDebuggingRingBell = '[advanceSettings] toggle I2c debugging ring bell',
     toggleDongleZephyrLogging = '[advanceSettings] toggle left dongle zephyr logging',
@@ -100,6 +101,10 @@ export class LeftHalfPairingFailedAction implements Action {
     constructor(public payload: string) {}
 }
 
+export class HalvesBondCheckTimeoutAction implements Action {
+    type = ActionTypes.halvesBondCheckTimeout;
+}
+
 export class ShowAdvancedSettingsMenuAction implements Action {
     type = ActionTypes.showAdvancedSettingsMenu;
 }
@@ -135,5 +140,6 @@ export type Actions =
     | StartLeftHalfPairingAction
     | LeftHalfPairingSuccessAction
     | LeftHalfPairingFailedAction
+    | HalvesBondCheckTimeoutAction
     | ZephyrLogAction
     ;
diff --git a/packages/uhk-web/src/app/store/effects/advanced-settings.effects.ts b/packages/uhk-web/src/app/store/effects/advanced-settings.effects.ts
index f02f2bb5497..6600a0885ff 100644
--- a/packages/uhk-web/src/app/store/effects/advanced-settings.effects.ts
+++ b/packages/uhk-web/src/app/store/effects/advanced-settings.effects.ts
@@ -1,11 +1,14 @@
 import { Injectable, inject } from '@angular/core';
+import { Router } from '@angular/router';
 import { Actions, createEffect, ofType } from '@ngrx/effects';
 import { Store } from '@ngrx/store';
-import { mergeMap, tap, withLatestFrom } from 'rxjs/operators';
+import { timer } from 'rxjs';
+import { map, mergeMap, switchMap, tap, withLatestFrom } from 'rxjs/operators';
 
 import { DeviceRendererService } from '../../services/device-renderer.service';
 import {
     ActionTypes,
+    HalvesBondCheckTimeoutAction,
     IsDongleZephyrLoggingEnabledAction,
     IsLeftHalfZephyrLoggingEnabledAction,
     IsRightHalfZephyrLoggingEnabledAction,
@@ -19,10 +22,13 @@ import {
 } from '../index';
 import { ActiveButton } from '../reducers/advanced-settings.reducer';
 
+const HALVES_BOND_CHECK_TIMEOUT_MS = 5000;
+
 @Injectable()
 export class AdvancedSettingsEffects {
     private readonly actions$ = inject(Actions);
     private readonly deviceRendererService = inject(DeviceRendererService);
+    private readonly router = inject(Router);
     private readonly store = inject<Store<AppState>>(Store);
 
     isDongleZephyrLoggingEnabled$ = createEffect(() => this.actions$
@@ -130,4 +136,23 @@ export class AdvancedSettingsEffects {
         ),
     {dispatch: false},
     );
+
+    halvesBondCheckTimeout$ = createEffect(() => this.actions$
+        .pipe(
+            ofType(ActionTypes.leftHalfPairingSuccess),
+            switchMap(() => timer(HALVES_BOND_CHECK_TIMEOUT_MS)),
+            map(() => new HalvesBondCheckTimeoutAction()),
+        )
+    );
+
+    // the pairing log is visible only on the advanced settings page
+    leftHalfPairingFailed$ = createEffect(() => this.actions$
+        .pipe(
+            ofType(ActionTypes.leftHalfPairingFailed),
+            tap(()=> {
+                this.router.navigate(['/device/advanced-settings']);
+            })
+        ),
+    {dispatch: false},
+    );
 }
diff --git a/packages/uhk-web/src/app/store/index.ts b/packages/uhk-web/src/app/store/index.ts
index 48181426b50..3207e5b64c6 100644
--- a/packages/uhk-web/src/app/store/index.ts
+++ b/packages/uhk-web/src/app/store/index.ts
@@ -44,6 +44,7 @@ import {
     DonglePairingStates,
     EraseBleSettingsButtonState,
     FirmwareUpgradeState,
+    HalvesPairingState,
     HistoryFileInfo,
     MacroMenuItem,
     MacroMenuTreeNode,
@@ -121,6 +122,7 @@ export const advanceSettingsState = (state: AppState) => state.advanceSettings;
 export const getIsAdvancedSettingsMenuVisible = createSelector(advanceSettingsState, fromAdvancedSettings.isAdvancedSettingsMenuVisible);
 export const getAlwaysEnableAdvancedMode = createSelector(advanceSettingsState, fromAdvancedSettings.isAlwaysEnableAdvancedMode);
 export const isLeftHalfPairing = createSelector(advanceSettingsState, fromAdvancedSettings.isLeftHalfPairing);
+export const isCheckingHalvesBond = createSelector(advanceSettingsState, fromAdvancedSettings.isCheckingHalvesBond);
 export const getIsI2cDebuggingEnabled = createSelector(advanceSettingsState, fromAdvancedSettings.isI2cDebuggingEnabled);
 export const isI2cDebuggingRingBellEnabled = createSelector(advanceSettingsState, fromAdvancedSettings.isI2cDebuggingRingBellEnabled);
 
@@ -586,6 +588,7 @@ export const getDonglePairingState = createSelector(
                 operation: dongleState.operation,
                 state: DonglePairingStates.Idle,
                 showDonglePairingPanel: false,
+                isBondBroken: false,
             };
         }
 
@@ -595,13 +598,33 @@ export const getDonglePairingState = createSelector(
             });
 
         const isBleAddressMismatches = dongleState.dongle?.bleAddress && (!devicePairedWithDongle || !dongleState.dongle.isPairedWithKeyboard);
+        // a bond that only one of the devices knows about is broken too
+        const isBondOneSided = !!dongleState.dongle?.bleAddress && !!devicePairedWithDongle !== !!dongleState.dongle.isPairedWithKeyboard;
+        const isBondBroken = !!dongleState.dongle?.isBondBroken || isBondOneSided;
 
         return {
             operation: dongleState.operation,
             state: dongleState.state === DonglePairingStates.DeletingSuccess
                 ? DonglePairingStates.Idle
                 : dongleState.state,
-            showDonglePairingPanel: deviceConfigLoaded && (isDongleBleMissingFromHostConnections || isBleAddressMismatches || dongleState.operation === DongleOperations.Pairing),
+            showDonglePairingPanel: deviceConfigLoaded
+                && (isDongleBleMissingFromHostConnections || isBleAddressMismatches || isBondBroken || dongleState.operation === DongleOperations.Pairing),
+            isBondBroken,
+        };
+    }
+);
+
+export const isHalvesBondBroken = createSelector(deviceState, fromDevice.isHalvesBondBroken);
+export const getHalvesPairingState = createSelector(
+    runningInElectron,
+    getConnectedDevice,
+    isHalvesBondBroken,
+    isLeftHalfPairing,
+    isCheckingHalvesBond,
+    (isRunningInElectron, connectedDevice, halvesBondBroken, leftHalfPairing, checkingHalvesBond): HalvesPairingState => {
+        return {
+            showHalvesPairingPanel: isRunningInElectron && connectedDevice?.id === UHK_80_DEVICE.id && halvesBondBroken,
+            isPairing: leftHalfPairing || checkingHalvesBond,
         };
     }
 );
diff --git a/packages/uhk-web/src/app/store/reducers/advanced-settings.reducer.ts b/packages/uhk-web/src/app/store/reducers/advanced-settings.reducer.ts
index c6a2852843e..2aa64c61306 100644
--- a/packages/uhk-web/src/app/store/reducers/advanced-settings.reducer.ts
+++ b/packages/uhk-web/src/app/store/reducers/advanced-settings.reducer.ts
@@ -28,6 +28,8 @@ export interface State {
     i2cDebuggingRingBellEnabled: boolean,
     i2cLogs: Array<XtermLog>;
     isLeftHalfPairing: boolean;
+    // After a successful pairing, until the device reports a healthy bond or the check times out.
+    isCheckingHalvesBond: boolean;
     isDongleZephyrLoggingEnabled: boolean;
     isLeftHalfZephyrLoggingEnabled: boolean;
     isRightHalfZephyrLoggingEnabled: boolean;
@@ -45,6 +47,7 @@ export const initialState = (): State => ({
     isLeftHalfZephyrLoggingEnabled: false,
     isRightHalfZephyrLoggingEnabled: false,
     isLeftHalfPairing: false,
+    isCheckingHalvesBond: false,
     menuVisible: false,
     zephyrLogs: [],
 });
@@ -96,16 +99,21 @@ export function reducer(state = initialState(), action: Actions | App.Actions |
 
         case Device.ActionTypes.ConnectionStateChanged: {
             const payload = (action as Device.ConnectionStateChangedAction).payload;
+            const newState = {
+                ...state,
+                isCheckingHalvesBond: state.isCheckingHalvesBond && payload.isHalvesBondBroken,
+            };
+
             if (!payload.connectedDevice) {
-                return state;
+                return newState;
             }
 
             if (payload.connectedDevice?.id === state.lastConnectedDevice?.id) {
-                return state;
+                return newState;
             }
 
             return {
-                ...state,
+                ...newState,
                 activeButton: ActiveButton.None,
                 i2cLogs: [],
                 lastConnectedDevice: payload.connectedDevice,
@@ -157,7 +165,14 @@ export function reducer(state = initialState(), action: Actions | App.Actions |
             };
         }
 
-        case ActionTypes.leftHalfPairingSuccess:
+        case ActionTypes.leftHalfPairingSuccess: {
+            return {
+                ...state,
+                isLeftHalfPairing: false,
+                isCheckingHalvesBond: true,
+            };
+        }
+
         case ActionTypes.leftHalfPairingFailed: {
             return {
                 ...state,
@@ -165,6 +180,13 @@ export function reducer(state = initialState(), action: Actions | App.Actions |
             };
         }
 
+        case ActionTypes.halvesBondCheckTimeout: {
+            return {
+                ...state,
+                isCheckingHalvesBond: false,
+            };
+        }
+
         case ActionTypes.toggleI2CDebugging: {
             const newState = {
                 ...state,
@@ -266,5 +288,6 @@ export function reducer(state = initialState(), action: Actions | App.Actions |
 export const isAdvancedSettingsMenuVisible = (state: State): boolean => state.menuVisible;
 export const isAlwaysEnableAdvancedMode = (state: State): boolean => state.alwaysEnableAdvancedMode;
 export const isLeftHalfPairing = (state: State): boolean => state.isLeftHalfPairing;
+export const isCheckingHalvesBond = (state: State): boolean => state.isCheckingHalvesBond;
 export const isI2cDebuggingEnabled = (state: State): boolean => state.activeButton === ActiveButton.I2CRecoveryDebugging;
 export const isI2cDebuggingRingBellEnabled = (state: State): boolean => state.i2cDebuggingRingBellEnabled;
diff --git a/packages/uhk-web/src/app/store/reducers/device.ts b/packages/uhk-web/src/app/store/reducers/device.ts
index 0b82dffdbc2..f796fc88211 100644
--- a/packages/uhk-web/src/app/store/reducers/device.ts
+++ b/packages/uhk-web/src/app/store/reducers/device.ts
@@ -40,6 +40,7 @@ export interface State {
     deviceConnectionStateLoaded: boolean;
     hostConnectionPairState: Record<string, boolean>;
     isErasingBleSettings: boolean;
+    isHalvesBondBroken: boolean;
     keyboardHalvesAlwaysJoined: boolean;
     leftHalfBootloaderActive: boolean;
     leftHalfDetected: boolean;
@@ -70,6 +71,7 @@ export const initialState: State = {
     hideStatusBufferError: false,
     hostConnectionPairState: {},
     isErasingBleSettings: false,
+    isHalvesBondBroken: false,
     keyboardHalvesAlwaysJoined: false,
     leftHalfBootloaderActive: false,
     leftHalfDetected: false,
@@ -155,6 +157,7 @@ export function reducer(state = initialState, action: Action): State {
                 bleDeviceConnected: data.bleDeviceConnected,
                 dongle: data.dongle,
                 isPairedWithDongle: data.isPairedWithDongle,
+                isHalvesBondBroken: data.isHalvesBondBroken,
                 activeKeymapIndex: data.activeKeymapIndex,
                 connectedDevice: data.connectedDevice,
                 deviceConnectionStateLoaded: true,
@@ -373,6 +376,7 @@ export function reducer(state = initialState, action: Action): State {
 export const hasDevicePermission = (state: State) => state.hasPermission && state.udevRuleInfo === UdevRulesInfo.Ok;
 export const getDeviceBleAddress = (state: State): string => state.bleAddress;
 export const getDevicePairedWithDongle = (state: State): boolean => state.isPairedWithDongle;
+export const isHalvesBondBroken = (state: State): boolean => state.isHalvesBondBroken;
 export const getMissingDeviceState = (state: State): MissingDeviceState => {
     if (!state.deviceConnectionStateLoaded) {
         return {