## Summary

User plugin code under `~/.config/omarchy/plugins/<id>/` does not actually hot-reload on save. The shell detects the change, logs `Local plugin changed, reloading: <id>` and re-instantiates the plugin — but the recreated instance is compiled from the **old** QML. Edits only take effect after a full shell restart.

## Expected

Per the documented design "user plugin code under `~/.config/omarchy/plugins/` hot-reload on save": saving a plugin QML file should reload that plugin with the new code.

## What actually happens

1. Edit a plugin QML (e.g. add `Component.onCompleted: console.log("V2MARKER")` to `BarWidget.qml`).
2. The shell logs `Local plugin changed, reloading: KryakeN.Omarchy.Vless` and re-creates the plugin — the Panel's `Component.onCompleted` debug line fires again (`[KryakeN.Omarchy.Vless] completed: ...`).
3. The new code (`V2MARKER`) is **never** executed after the in-place reload.
4. Only a full restart (e.g. `pkill -x quickshell`) loads the edited QML — the marker prints within ~100 ms of boot.

## Evidence

Journal excerpt — in-place reload fired and re-instantiated the panel, but the marker added to the file on disk did not run:

```
Aug 31 03:56:58 omarchy-pc omarchy-shell[2606419]:  DEBUG qml: Local plugin changed, reloading: KryakeN.Omarchy.Vless
Aug 31 03:56:59 omarchy-pc omarchy-shell[2606419]:  DEBUG qml: [KryakeN.Omarchy.Vless] completed: testProcess=Process(...) statusProcess=Process(...) isTesting=false
# grep V2MARKER over this window: no output
```

After restart, the marker printed immediately. Additionally, no new entry was written under `~/.cache/quickshell/qmlcache/` after the save+reload — the loader served a cached compiled type instead of recompiling from the edited source.

Root-cause probe (runtime test against Quickshell 0.3.1):

```
console.log(typeof Qt.clearComponentCache)  // => "undefined"
```

## Suspected cause

`shell.qml` in `finishPluginReload()` does:

```qml
if (typeof Qt.clearComponentCache === "function") Qt.clearComponentCache()
```

Quickshell does not expose `Qt.clearComponentCache` (the symbol exists only as the **private** Qt API `QQmlEngine::clearComponentCache()` in `libQt6Qml.so`), so the `typeof` guard silently never fires and the in-memory QML component cache is never flushed. After `unloadPanels()`/`unloadPluginWidgets()`, `Qt.createComponent(url)` in `loadPluginWidget()` therefore returns the previously compiled type for the same URL. Secondary stale path: `syncPluginWidgets()` re-registers the *same* `existing.component` when the registry key already exists.

Worth noting: this same reload-under-load path is a plausible contributor to the `QQmlComponent::createWithProperties → __dynamic_cast → SIGSEGV` crashes seen when iterating on plugin code (reload destroying a stale instance mid-signal-chain).

## Suggested direction for a fix

- On local plugin change, force a fresh compilation of that plugin's QML instead of relying on `Qt.clearComponentCache` (which Quickshell doesn't provide): e.g. purge `~/.cache/quickshell/qmlcache` / the engine entry for the plugin URLs, or
- If fresh components cannot be guaranteed within the running process, do a full shell restart instead of logging a misleading "reloading".

## Environment

- Omarchy 4.0.1-1 (Arch Linux), `omarchy version`
- quickshell 0.3.1 (Arch package)
- Hyprland under uwsm (Wayland), Intel i7-8700, VMware SVGA