### System details

Omarchy 4.0.4-1, Hyprland 0.56.2, Quickshell 0.3.1, i5-12500H, x86_64.

### What's wrong

`omarchy plugin enable <id> <section>` reports **success** for a third-party
bar-widget that is already registered in `plugins[]`, but does not put it on the
bar. The widget stays exactly where it was, and `omarchy plugin list` keeps
reporting it as `disabled`. The command exits **0**, so scripts cannot detect
the failure. The same no-op happens through the `putBarWidget` IPC route.

Concretely: any bar-widget that a user has registered in `plugins[]` (the way
`omarchy plugin add` and `drawer-ctl`-style tooling do) cannot be turned on
with the documented command.

### Steps to reproduce

Start from a widget that is in `plugins[]` but has no `bar.layout` slot:

```
$ jq -r '[.bar.layout.left[],.bar.layout.center[],.bar.layout.right[]] | map(select(.id=="im0001gt.screens")) | length' ~/.config/omarchy/shell.json
0
$ jq -r '[.plugins[].id] | index("im0001gt.screens") != null' ~/.config/omarchy/shell.json
true

$ omarchy plugin enable im0001gt.screens right
Enabled and moved im0001gt.screens        # <- claims success, exit 0

$ jq -r '[.bar.layout.left[],.bar.layout.center[],.bar.layout.right[]] | map(select(.id=="im0001gt.screens")) | length' ~/.config/omarchy/shell.json
0                                              # <- not on the bar

$ omarchy plugin list | grep im0001gt.screens
im0001gt.screens   disabled   third-party bar-widget,service   Screens
```

`omarchy-shell shell putBarWidget im0001gt.screens '{"section":"right"}'`
returns `ok` and is equally a no-op.

### Expected

Either the widget lands on the bar, or the command fails loudly (non-zero,
message naming the widget) instead of reporting success. `plugins[]` membership
should not be a hidden obstacle to putting a bar-widget on the bar.

### Root cause

In `services/PluginRegistry.qml`, `setEnabled()` computes `location` **before**
mutating anything (line ~521), then:

```js
if (!location.found && isBarWidget) {
  // ... splice the entry into bar.layout  -> only runs when NOT already in plugins[]
  insertedWithPlacement = true
} else if (!location.found && !isFirstParty) {
  config.plugins.push(entry)
}

if (isBarWidget && !insertedWithPlacement && placement && Object.keys(placement).length)
  moveBarEntry(config, key, placement)     // line 543-544
```

For a bar-widget already in `plugins[]`, `location.found` is true, so both
insert branches are skipped and control reaches `moveBarEntry()`. That is the
wrong verb: `moveBarEntry` is for a widget **already in the bar** (it returns
`"could not find widget " + key` when it is not — line 293). Worse, its return
value is discarded, so `lastEnableError` stays empty and `setEnabled()` returns
`true`, which is what makes `omarchy-plugin-enable` print "Enabled and moved".

`putBarWidget()` funnels into the same `setEnabled()`, so it inherits the bug.

Note the asymmetry: a widget **not** in `plugins[]` is handled correctly by the
splice branch, which is why this only bites widgets that are already loaded —
and that is the common case for anything added by tooling rather than clicked
into place.

### Suggested fix

In `setEnabled()`, treat "registered in `plugins[]` but absent from the bar" as
a placement, not a move. The minimal correction is to propagate `moveBarEntry`'s
error so the failure is at least visible:

```js
if (isBarWidget && !insertedWithPlacement && placement && Object.keys(placement).length) {
  var moveError = moveBarEntry(config, key, placement)
  if (moveError) lastEnableError = moveError
}
```

Better still, insert into the bar layout when the widget is a bar-widget that is
not currently in the bar, regardless of whether `plugins[]` already lists it —
and, if it is being moved from the bar, drop the now-redundant `plugins[]` entry
so a widget is not both loaded and placed. (`omarchy-plugin-list` reports
bar-widgets by `inBar()`, so `plugins[]` membership alone does not make one
enabled.)

### Impact

Silently wrong: the command reports success, so this is not recoverable by the
user or by a script without diffing `shell.json` before and after. It affects
any plugin-management tooling that leans on `omarchy plugin enable`, including
the plugin manager UI.