### What's wrong?

With Omarchy's default `shift:both_capslock_cancel` option and Fcitx5 running, switching focus from a native Wayland input-method client to a native Wayland Qt/Fcitx client can make the destination type English although Russian is selected. The first ordinary letter after the focus change triggers the failure. Switching EN/RU inside the destination repairs it; clicking its text field did not reliably repair it.

This was observed with kitty -> Telegram Desktop and reproduced outside Telegram with two small Qt `QLineEdit` applications. Neither pressing Shift nor toggling Caps Lock is required.

Related: #9552 (layout indicator/input mismatch), #10545 and #7440 (other failures involving the same default option). PR #10565 proposes removing this option. This report adds a **native Wayland layout-reset** failure, a standalone XKB round-trip reproducer, and before/after protocol evidence.

### System details

| Component | Installed version |
|---|---|
| Omarchy | 4.0.4-1 |
| Hyprland | 0.56.2-3 |
| Qt base / Wayland | 6.11.2-3 / 6.11.2-1 |
| Fcitx5 / Fcitx5 Qt | 5.1.22-1 / 5.1.15-1 |
| libxkbcommon | 1.13.2-1 |
| xkeyboard-config | 2.48-1 |
| Telegram Desktop | 7.2.8-1 |

Wayland session. Telegram was a native Wayland client with `QT_IM_MODULE=fcitx`, not an XWayland client. The tested layout list was `us,ru,es,jp`. Fcitx remained running throughout the controlled comparison.

### Reproduction

Relevant configuration:

```lua
hl.config({
  input = {
    kb_layout = "us,ru,es,jp",
    kb_options = "compose:caps,shift:both_capslock_cancel,grp:alts_toggle",
    follow_mouse = 1,
  },
})
```

1. Use a source text field on the native Wayland input-method path and a destination on Qt's Fcitx input-context path. The two-process Qt example below avoids needing a Telegram account.
2. In the source, select Russian and type the physical A key; verify `ф`. This typing step matters: it makes the Fcitx virtual keyboard the active seat keyboard.
3. Move the pointer into the destination so that it receives keyboard focus.
4. Press the physical A key without an intervening modifier/layout switch. It produces `a`, and a second press also produces `a`.
5. Switch EN/RU inside the destination. The same key now produces `ф`.

Expected: the destination preserves the selected Russian layout from its first character.

For a controlled reproduction, `PersistentVirtualKeyboard=True` was set in `~/.config/fcitx5/conf/waylandim.conf` and held constant in both before/after runs. That option alone did **not** solve this failure.

### Controlled before/after result

The comparison changed only `kb_options`, removing `shift:both_capslock_cancel`. Test letters entered through a temporary **kernel uinput keyboard**, going through Hyprland and Fcitx, and were delivered only to the diagnostic windows.

| Step in Qt/Fcitx destination | With default option | With option removed |
|---|---|---|
| English selected in destination | `a` | `a` |
| Russian selected and typed in source; first key after returning | **`a`** | `ф` |
| Second key, no extra action | **`a`** | `ф` |
| EN/RU switched inside destination | `ф` | `ф` |

After saving the override and reloading Hyprland, a further check covered six transitions, RU -> EN -> RU in both input-path directions. All 18 characters matched the expected sequences. The original kitty -> Telegram scenario was then confirmed to work in normal use.

<details>
<summary>Final observed and expected sequences</summary>

Each destination was tested in both roles (source and destination), hence nine recorded characters per process.

```text
fcitx: observed ['ф', 'ф', 'a', 'a', 'ф', 'ф', 'ф', 'a', 'ф']
fcitx: expected ['ф', 'ф', 'a', 'a', 'ф', 'ф', 'ф', 'a', 'ф']
wayland: observed ['ф', 'a', 'ф', 'ф', 'ф', 'a', 'a', 'ф', 'ф']
wayland: expected ['ф', 'a', 'ф', 'ф', 'ф', 'a', 'a', 'ф', 'ф']
```

</details>

### Evidence: a different keymap arrives without the layout state

In the failing run, the physical keyboard's serialized keymap was 43515 bytes and Fcitx's virtual keyboard's was 43507 bytes. Their only textual difference was:

```diff
--- physical-keyboard
+++ fcitx-virtual-keyboard
@@ -1837,3 +1837,3 @@
 	key <I709> {	[ 0x100812bd ] };
-	modifier_map Shift { <LFSH>, <RTSH> };
+	modifier_map Shift { <RTSH> };
 	modifier_map Lock { <LFSH> };
```

<details>
<summary>Normalized Wayland trace: failing case</summary>

This is extracted from the Qt/Fcitx diagnostic client's actual Wayland log. Timestamps, serials, object IDs and FD numbers are redacted; keyboard-event order and relevant numeric values are retained. The keymap before focus is included for context. `group=1` is Russian, `key=30` is the physical A key, and key states 1/0 mean press/release.

```text
wl_keyboard<K>.keymap(format=1, fd=<redacted>, size=43507)
wl_keyboard<K>.enter(serial=<redacted>, surface=<S>, pressed=[])
wl_keyboard<K>.modifiers(serial=<redacted>, depressed=0, latched=0, locked=16, group=1)
wl_keyboard<K>.keymap(format=1, fd=<redacted>, size=43515)
wl_keyboard<K>.key(serial=<redacted>, time=<redacted>, key=30, state=1)
wl_keyboard<K>.key(serial=<redacted>, time=<redacted>, key=30, state=0)
wl_keyboard<K>.key(serial=<redacted>, time=<redacted>, key=30, state=1)
wl_keyboard<K>.key(serial=<redacted>, time=<redacted>, key=30, state=0)
```

The new 43515-byte keymap arrives after `group=1` and immediately before the first key. There is no intervening `modifiers` event restoring group 1. The corresponding Qt key events resolve to keysym 97 / text `a`, rather than keysym 1734 / text `ф`.

</details>

<details>
<summary>Normalized Wayland trace: option removed</summary>

The physical and Fcitx virtual keymaps now serialize identically (43528 bytes). There is no replacement keymap between the Russian modifiers event and the first letter; both letters resolve to `ф`.

```text
wl_keyboard<K>.keymap(format=1, fd=<redacted>, size=43528)
wl_keyboard<K>.enter(serial=<redacted>, surface=<S>, pressed=[])
wl_keyboard<K>.modifiers(serial=<redacted>, depressed=0, latched=0, locked=16, group=1)
wl_keyboard<K>.key(serial=<redacted>, time=<redacted>, key=30, state=1)
wl_keyboard<K>.key(serial=<redacted>, time=<redacted>, key=30, state=0)
wl_keyboard<K>.key(serial=<redacted>, time=<redacted>, key=30, state=1)
wl_keyboard<K>.key(serial=<redacted>, time=<redacted>, key=30, state=0)
```

</details>

### Standalone reproducer for the keymap difference

This read-only Python script requires `xkbcli`. It does not require Telegram, Fcitx, or a running graphical session, and does not change the active keyboard configuration. The smaller `us,ru` layout list reproduces the same modifier-map loss:

```python
import difflib
import subprocess

for label, options in [
    ("default", "compose:caps,shift:both_capslock_cancel,grp:alts_toggle"),
    ("without-two-shift-caps", "compose:caps,grp:alts_toggle"),
]:
    original = subprocess.check_output([
        "xkbcli", "compile-keymap", "--output-format", "1",
        "--layout", "us,ru", "--options", options,
    ], text=True)
    roundtrip = subprocess.check_output([
        "xkbcli", "compile-keymap", "--format", "1", "--keymap", "-",
    ], input=original, text=True)
    print(f"{label}: roundtrip identical = {original == roundtrip}")
    if original != roundtrip:
        print("".join(difflib.unified_diff(
            original.splitlines(True), roundtrip.splitlines(True),
            fromfile="original", tofile="roundtrip", n=1,
        )), end="")
```

<details>
<summary>Actual output with libxkbcommon 1.13.2 / xkeyboard-config 2.48</summary>

```text
default: roundtrip identical = False
--- original
+++ roundtrip
@@ -2236,3 +2236,3 @@
 	key <I709>               {	[ XF86PerformanceMode ] };
-	modifier_map Shift { <LFSH>, <RTSH> };
+	modifier_map Shift { <RTSH> };
 	modifier_map Lock { <LFSH> };
without-two-shift-caps: roundtrip identical = True
```

</details>

### Small Qt text-field example

<details>
<summary>Source and launch commands</summary>

This is a simplified manual-input version of the diagnostic field, with the same key/input-method logging. It has been compile-checked; the automated results above came from the instrumented variant with kernel uinput delivery.

Save as `layout-probe.cpp`:

```cpp
#include <QApplication>
#include <QLineEdit>
#include <QKeyEvent>
#include <QInputMethodEvent>
#include <QJsonDocument>
#include <QJsonObject>
#include <iostream>

class Probe : public QLineEdit {
public:
    void keyPressEvent(QKeyEvent *event) override {
        QJsonObject entry{{"kind", "key"}, {"text", event->text()},
            {"nativeScanCode", static_cast<int>(event->nativeScanCode())},
            {"nativeVirtualKey", static_cast<int>(event->nativeVirtualKey())}};
        std::cout << QJsonDocument(entry).toJson(QJsonDocument::Compact).constData() << std::endl;
        QLineEdit::keyPressEvent(event);
    }
    void inputMethodEvent(QInputMethodEvent *event) override {
        QJsonObject entry{{"kind", "inputMethod"}, {"commit", event->commitString()}};
        std::cout << QJsonDocument(entry).toJson(QJsonDocument::Compact).constData() << std::endl;
        QLineEdit::inputMethodEvent(event);
    }
};

int main(int argc, char **argv) {
    QApplication app(argc, argv);
    app.setApplicationName(argc > 1 ? argv[1] : "layout-probe");
    app.setDesktopFileName(app.applicationName());
    Probe field;
    field.setWindowTitle(app.applicationName());
    field.resize(500, 150);
    field.setMinimumSize(200, 60);
    field.show();
    field.setFocus();
    return app.exec();
}
```

Build:

```bash
g++ -std=c++17 -fPIC layout-probe.cpp -o layout-probe $(pkg-config --cflags --libs Qt6Widgets)
```

Launch these separately, then follow the source -> destination steps above:

```bash
env -u QT_IM_MODULES QT_QPA_PLATFORM=wayland QT_IM_MODULE=wayland WAYLAND_DEBUG=client ./layout-probe layout-source > source-keys.log 2> source-wayland.log
```

```bash
env -u QT_IM_MODULES QT_QPA_PLATFORM=wayland QT_IM_MODULE=fcitx WAYLAND_DEBUG=client ./layout-probe layout-destination > destination-keys.log 2> destination-wayland.log
```

Use real key input through the compositor. Calling Qt's key handler directly misses the physical/virtual keyboard transition and can incorrectly pass this test.

</details>

### Interpretation and workaround

The traces establish the missing modifiers event after the replacement keymap. This agrees with the installed-version source paths:

- Hyprland [`CSeatManager::setKeyboard` / `updateActiveKeyboardData`](https://github.com/hyprwm/Hyprland/blob/v0.56.2/src/managers/SeatManager.cpp) updates the keymap without sending the current modifiers/group in that path.
- Hyprland [`CWLKeyboardResource::sendKeymap`](https://github.com/hyprwm/Hyprland/blob/v0.56.2/src/protocols/core/Seat.cpp) compares the serialized keymap text, so the modifier-map difference causes a replacement event.
- Qt [`Keyboard::keyboard_keymap`](https://github.com/qt/qtbase/blob/v6.11.2/src/plugins/platforms/wayland/qwaylandinputdevice.cpp) creates a new `xkb_state`; without the following layout state it starts in group 0, English in this configuration.

Working user override in `~/.config/hypr/input.lua`:

```lua
hl.config({
  input = {
    kb_options = "compose:caps,grp:alts_toggle",
  },
})
```

Then run `hyprctl reload` and check `hyprctl configerrors`. Fcitx remained enabled and the Compose key assignment was retained. Removing the option also removes Caps Lock via both Shift keys. `PersistentVirtualKeyboard=True` was retained to avoid a separate keyboard-destruction path; the comparison does not claim that removing the Caps option alone covers every Fcitx lifecycle case.

The same default option is still present in [Omarchy's default input configuration](https://github.com/omacom/omarchy/blob/393a43d469d2256f517cdce3b4f74115daed929a/default/hypr/input.lua). This is additional evidence for the approach in #10565, while the missing state after a changed keymap also merits an upstream Hyprland fix.

The live Telegram process was not instrumented; protocol-level evidence comes from the Qt reproducer, and Telegram's behavior was checked in normal use. All published diagnostics are focused, anonymized extracts: no usernames, hostnames, physical device names/IDs, private paths, window titles, conversations, or unrelated session logs are included.