Skip to content

fix(plugins): suspend local watch during plugin update (#12859) - #13006

Open
kvnloo wants to merge 2 commits into
omacom:quattrofrom
kvnloo:tip/12859-plugin-update-watch
Open

kvnloo wants to merge 2 commits into
omacom:quattrofrom
kvnloo:tip/12859-plugin-update-watch

Conversation

@kvnloo

@kvnloo kvnloo commented Sep 23, 2026 •

Copy link
Copy Markdown
Contributor

Summary

Fixes #12859.

"omarchy plugin update" mutates a third-party plugin checkout while "PluginRegistry" recursively watches the same tree with "inotifywait".

A fast-forward can therefore emit a burst of filesystem events while QML files are only partially updated. The shell may begin "reloadPlugins()" during that burst and recreate components from an inconsistent tree.

This revision makes the update mutation an explicitly owned critical section:

  1. serialize concurrent updater processes;
  2. fetch and obtain confirmation while the watcher remains active;
  3. suspend the watcher immediately before filesystem mutation;
  4. fail before mutation if a reachable shell cannot suspend it;
  5. merge and validate the approved updates;
  6. request one explicit rescan while observation is still suspended;
  7. restore the watcher.

Ordinary local editing still uses a trailing reload debounce, now "500 ms".

Why the first revision was incomplete

The earlier version correctly stopped the watcher during one updater process, but two ownership gaps remained.

Watcher suspension was best-effort

The updater used:

omarchy-shell -q shell setLocalPluginWatch false >/dev/null || true

"-q" deliberately converts IPC failure into success.

That means a live older shell, missing method, timeout, or other suspension failure could leave the watcher active while the script continued modifying the tree.

This revision first checks whether a shell is reachable.

If it is, successful watcher suspension is now a prerequisite for mutation:

live shell
→ suspend succeeds
→ mutation allowed

versus:

live shell
→ suspension fails
→ abort before git HEAD moves

If no shell is running, there is no active shell watcher to suspend.

Concurrent updaters could fight over one global watcher

Two update processes could previously do:

A: suspend
B: suspend

A: merge
A: rescan
A: resume

B: still merging

At that point A has re-enabled observation while B is still mutating the plugin tree.

The updater now takes a per-user "flock" for the complete update session before fetching or modifying plugins.

A second updater cannot acquire watcher ownership or mutate a checkout until the first updater has completely finished.

Mutation lifecycle

The script now separates update preparation from filesystem mutation.

Preparation

For each target:

fetch
→ compare HEAD / FETCH_HEAD
→ show diff if interactive
→ obtain confirmation

The plugin watcher remains active during this potentially slow/user-interactive stage.

Approved plugin IDs are collected for the mutation phase.

If nothing needs to change, the script exits without touching watcher state.

Mutation

Only after preparation:

acquire/update-session ownership already held
→ probe shell
→ suspend watcher
→ fast-forward approved plugins
→ validate
→ rollback invalid updates
→ rescan once if anything changed
→ resume watcher

The "EXIT" cleanup path also attempts to restore the watcher if the updater exits unexpectedly after suspension.

Shell-side watcher behavior

While watcher observation is disabled:

  • the recursive "inotifywait" process is stopped;
  • automatic watcher restart is disabled;
  • the restart timer is stopped;
  • already-buffered paths are ignored;
  • the pending local-plugin reload timer is stopped.

Resuming watcher observation starts it again if necessary.

For normal edits outside "omarchy plugin update", the trailing reload debounce changes from "150 ms" to "500 ms" so short recursive write bursts have more time to settle.

Concurrent-update invariant

The required invariant is:

«At most one plugin updater may own the watcher/mutation lifecycle at a time.»

The new regression exercises two real updater processes.

The first updater:

acquires lock
→ suspends watcher
→ merges
→ blocks during validation

A second updater starts while the first is blocked.

The regression verifies that it cannot issue another watcher suspension or mutate the checkout.

After the first updater completes and releases ownership, the second proceeds, observes the already-updated checkout, and reports it as up to date.

Only one:

suspend → mutation → rescan → resume

cycle occurs.

Fail-closed regression

The test also models a reachable shell whose:

setLocalPluginWatch false

call fails.

It records the plugin's "HEAD" before the update and verifies:

  • updater exits non-zero;
  • watcher suspension was attempted;
  • "HEAD" remains unchanged;
  • no rescan is requested.

This pins the actual safety boundary rather than only checking source wiring.

Related work

#12859

The direct reproduction for this PR.

Thanks @tymurbogach for capturing the Quickshell crash, the event burst, and the "QQmlObjectCreator::finalize" stack. That made it clear the failure belongs to the host reload lifecycle rather than the plugin being updated.

#8583

@othavi0 independently measured the same broader mutation/watcher overlap earlier, including:

  • "408" watcher events during one plugin removal;
  • immediate explicit "rescanPlugins";
  • overlapping reload behavior after update/remove mutations.

#8583 was closed after Agent Bar added its own workaround, not because the host-level reload overlap disappeared. Its measurements are useful supporting evidence for the ownership model here.

This PR intentionally fixes the "plugin update" path required by #12859.

"plugin remove" has the same broader class of mutation/watcher interaction described in #8583 and should reuse this ownership primitive rather than growing a separate timing workaround.

"plugin add" is less severe because it stages in a hidden directory and exposes the completed tree with a single final move.

Regression coverage

"test/shell.d/plugin-update-watch-test.sh" now covers:

Normal update

ping
→ suspend
→ merge / validate
→ rescan
→ resume

Failed suspension

live shell
→ suspension fails
→ no mutation
→ no rescan

Concurrent update

updater A owns lock + watcher
updater B starts
→ B cannot suspend/mutate
A completes + resumes
→ B proceeds
→ sees plugin already up to date

The concurrency case uses two actual updater processes and the real "flock" primitive.

Verification status

Rebuilt as one commit on current "quattro":

head: 8cf1ce6
base: 28ceaae
ahead: 1
behind: 0

Final diff audit:

  • "bin/omarchy-plugin-update"
  • "shell/services/PluginRegistry.qml"
  • "shell/shell.qml"
  • "test/shell.d/plugin-update-watch-test.sh"

No unrelated file-mode changes.

The new regression tests were constructed against the production updater but have not been executed from this environment.

Final desktop acceptance remains:

  1. install/enable a third-party QML plugin;
  2. advance its remote;
  3. run "omarchy plugin update ";
  4. confirm no shell crash or intermediate reload;
  5. confirm exactly the updated plugin tree is visible after the final rescan.

Fixes #12859.

@llstrk

llstrk commented Sep 23, 2026

Copy link
Copy Markdown

No actionable regression identified in the single-updater source paths reviewed at 8cc39c0.

Verified by source inspection: the update pass requests watcher suspension before processing plugins, discards buffered watcher events while suspended, stops the pending reload timer, and prevents automatic watcher restarts until resumed. A successful update still requests a full plugin reload.

Path Before This PR
Working-tree writes during an update Watcher can schedule a reload Watcher events suppressed after successful suspension
Watcher exits while suspended Automatic restart Restart guarded by the suspended state
Update finishes Explicit reload after a successful update Explicit reload after a successful update, then EXIT-trap watch restoration

These are source-traced paths, not observed desktop behavior. The added test checks stubbed IPC call ordering, not the real watcher or QML recreation.

Scope limitation: suspension is best-effort. An older running shell or failed IPC can leave the watcher active. Overlapping updater processes are also not protected as a group: one can request a full reload while another is still writing. These are residual coverage limits, not new regressions or reproduced crashes.


Review information

Test scope: source-only comparison of the updater, IPC wrapper, watcher/reload logic and added test. No tests or live Quickshell crash reproduction were run; the reported SIGSEGV fix remains unverified on a running desktop.

Community review: Independent automated community review, unaffiliated with the Omarchy team, intended to help prepare PRs for their review.

Automated AI review: Astra Medium initial inspection, independent Opus 5.5 High and GPT 6 Sol Xhigh technical assessments, followed by Astra source-based adjudication.

@kvnloo
kvnloo force-pushed the tip/12859-plugin-update-watch branch from 8cc39c0 to 8cf1ce6 Compare September 24, 2026 00:02
@kvnloo

kvnloo commented Sep 24, 2026

Copy link
Copy Markdown
Contributor Author

Updated at "8cf1ce64" on current "quattro".

Thanks @tymurbogach for the #12859 crash report — the "inotify" burst plus the "QQmlObjectCreator::finalize" stack made the mutation/reload ownership problem very clear.

I also found @othavi0's earlier #8583 while doing the related-issue audit. Their measurements show the same broader race in both update and remove paths, including hundreds of watcher events during recursive removal, so I linked that history instead of treating this as an isolated update bug.

I tightened the update path in two places.

First, watcher suspension is no longer best-effort. If a shell is reachable, "setLocalPluginWatch false" must succeed before the checkout can move. The regression forces that IPC call to fail and verifies the plugin "HEAD" stays unchanged and no rescan occurs.

Second, concurrent updater processes are now serialized with a per-user "flock". One updater cannot resume the global watcher while another updater is still mutating. The regression starts two real updater processes, blocks the first during validation, and verifies the second cannot acquire watcher ownership until the first completes. Afterward it sees the checkout as already up to date, so there is only one "suspend → mutation → rescan → resume" cycle.

I also split preparation from mutation: fetch/diff/confirmation happens while the watcher stays active; suspension only covers the short filesystem mutation window.

The branch is one commit ahead / zero behind current "quattro".

The focused regressions are constructed but not executed from this environment; live Quickshell update validation is still pending.

@llstrk

llstrk commented Sep 24, 2026

Copy link
Copy Markdown

Automated AI review

Community review: Independent automated community review, unaffiliated with the Omarchy team, intended to help prepare PRs for their review.

Follow-up at 8cf1ce64, reassessing the earlier review after the author's update.

Verified: both scope limits from the earlier review are addressed for the updater itself. Two narrower gaps remain around the reachability probe and a failed suspend, and the new concurrency test does not detect removal of the lock.

Earlier point Status at 8cf1ce64
Suspension was best-effort (older shell or failed IPC) Resolved for the suspend call. A reachable shell that rejects or times out on setLocalPluginWatch false, including an older shell that answers "Function not found.", now stops the update before the checkout moves. The ping probe before it still fails open (below).
Overlapping updaters not protected as a group Resolved for omarchy plugin update processes sharing the per-user lock. omarchy-plugin-remove and omarchy-plugin-add still request rescans without the lock, which the PR description already names as follow-up work.
Earlier verified watcher behavior Still holds. The QML watcher logic is unchanged apart from comments. Suspension now starts after fetch, diff and confirmation. Fetch writes only under .git/, which the registry ignores.

Verified in isolated stub runs: the new regression test passes at this head (5 of 5 runs) and fails on the base and on the previously reviewed head. With stubbed shell IPC and two updaters on different plugins, this head keeps the second updater blocked while the first is mid-update. The previously reviewed head lets the second updater resume the watcher while the first is still writing.

Reachability probe treats a starting or unresponsive shell as absent

omarchy-shell shell ping >/dev/null 2>&1 sets SHELL_AVAILABLE=0 on any failure. The wrapper distinguishes "not running", "not ready" and "not responding" on stderr, but the updater discards stderr and treats all three as "no shell". Through the real bin/omarchy-shell over a stubbed qs:

qs reply to ping                       updater result
"Not ready to accept queries yet."  →  exit 0, checkout moved, only ping sent
no reply within the 2 s timeout     →  exit 0, checkout moved, only ping sent
"Function not found." on suspend    →  exit 1, checkout unchanged

Impact: a shell that has just started, including Quickshell relaunching itself after a crash, or one whose main thread is blocked for more than 2 s, gets no suspension and no explicit rescan. That case falls back to the pre-PR behavior for this update. The window is narrow, and it is not a new failure mode.

Suggested change: treat only the wrapper's "not running" result as "no shell", and fail closed (or retry briefly) on "not ready" or "not responding". Distinct wrapper exit codes, or checking the ping's stderr, would allow that.

Failed suspend request sends no compensating resume

WATCH_SUSPENDED=1 and trap cleanup EXIT are set only after setLocalPluginWatch false returns success. When that call times out, the updater exits with "not responding" and no resume request is sent (reproduced with a stubbed qs). By Quickshell's IPC server code, a stalled shell could still apply the queued suspension after the updater exits. That late application was not reproduced on a live shell.

Impact: if it happens, local plugin hot reload stays off until the shell restarts or a later update resumes it. No crash path was identified.

Suggested change: mark the suspension as attempted and arm the EXIT trap before sending the request, so every exit after an attempt sends a best-effort resume. setLocalPluginWatch(true) is idempotent in the QML.

Optional test improvement: the overlapping-update case in test/shell.d/plugin-update-watch-test.sh still passes 5 of 5 with exec 9> and flock 9 removed. The first updater has already merged before it blocks in validation, so an unlocked second updater sees "up to date", never suspends, and produces the asserted counts. Pointing the second updater at a different plugin, or asserting that flock -n "$OMARCHY_PLUGIN_UPDATE_LOCK" true fails while the first is blocked, makes the case fail without the lock.


Review information

Test scope: source comparison of the base, previously reviewed head and current head, plus the relevant Quickshell IPC and Process source (read at v0.2.1 and v0.3.1) and util-linux flock. Sandboxed runs used real git, flock and the updater, with stubbed shell IPC (the real omarchy-shell wrapper over a stubbed qs where stated) and a stubbed validator. No live Quickshell or desktop session was run, so the QML watcher path and the reported crash fix remain unverified at runtime.

AI process: Opus 5.5 Medium coordination and synthesis, independent Opus 5.5 Xhigh and GPT 6 Sol Xhigh technical assessments, Opus 5.5 Medium editorial check.

Opt out: To stop receiving these reviews, reply to this comment saying so.

The first updater has already merged when it blocks in validation, so a second updater reports "up to date" and never suspends whether or not the two are serialized: the case passed with the flock removed. Checking that the lock is held while the first updater is blocked makes it fail without one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Codex Medium <noreply@openai.com>
@omarchybot omarchybot added the verified Omarchy Triage has verified that this issue is ready for final review label Oct 3, 2026
@omarchybot

Copy link
Copy Markdown
Collaborator

Reviewed and reproduced. This fixes the crash in #12859.

Reproduction. On a VM installed from the Omarchy ISO (Quickshell 0.3.1, Qt 6.11.2), with the real plugin from the report: hardwarchy installed at 2.3.1 and updated to 2.3.2. A plain omarchy plugin update never crashed (0 of 26 rounds on quattro), and neither did omarchy-restart-shell on its own (0 of 6). The crash comes from what the plugin's own update button runs, omarchy plugin update followed straight away by omarchy-restart-shell:

Tree SIGSEGV
quattro 14 of 14, with the reported stack (__dynamic_cast → QQmlObjectCreator::finalize → QQmlIncubatorPrivate::incubate)
quattro with this PR 0 of 14
this PR's shell driven by quattro's updater 6 of 6

The last row shows that suspending the watcher in the updater is what fixes it; the 150 → 500 ms debounce does not. With the PR, the shell logged no watcher reload during the update, and the watcher fired again after it.

Tests, run on that VM against quattro with this PR merged in: ./test/cli and the plugin and shell IPC tests in test/shell.d/ pass, apart from failures that quattro has too (one VS Code theme case in ./test/cli, and three tests that need node, which the VM lacks). plugin-update-watch-test.sh fails against quattro's updater and passes here.

Pushed 40f4b7b to this branch. The overlapping-update case passed even with the flock removed: the first updater has already merged when it blocks in validation, so the second one reports "up to date" whether or not the two are serialized. The test now also asserts that the lock is held while the first updater is blocked. That assertion fails without the lock and passes with it.

Left as they are, none blocking:

  • If setLocalPluginWatch false times out after the shell has already applied it, the updater exits before arming its EXIT trap, so the watcher stays off. The error already says to restart the shell, and a restart turns it back on.
  • A ping that fails because the shell is still starting or busy counts as "no shell", so that one update runs exactly as it does on quattro today.
  • The 500 ms debounce does not contribute to this fix and could be its own PR. Coalesce plugin reloads and exclude .git from inotify #10705 changes the same timer to 1 s for a different report.

Second opinion: Codex Medium reviewed it over two rounds. It found the vacuous lock test independently of the earlier community review, and asked for the isolation run in the last table row. On this head it found nothing that blocks. It could read this review's working notes, so its agreement is not guaranteed to be independent.

ready is waiting on CI. After that, the merge is the maintainer's decision.

@greptile-apps

greptile-apps Bot commented Oct 3, 2026 •

Copy link
Copy Markdown
Contributor

RetriggerConfidence Score: 3/5

[Medium risk] Plugin update process now coordinates with file watcher.

The PR needs fixes before merging because a live shell can skip suspension and an existing reload can still overlap plugin writes.

Findings

  1. P1 Busy shell skips suspension ▶
  2. P1 Existing reload keeps running ▶
  3. P2 Failed request leaves watch disabled ▶
  4. P2 Security Another user blocks updates ▶
  5. P2 Failed update loses pending reload ▶

Summary

The PR serializes plugin updates and separates fetching and confirmation from file changes. It adds watcher suspension, a final rescan, cleanup, and a longer local-edit debounce.

  • Adds regressions for update order, rejected suspension, and concurrent updaters.
  • Two reload races remain: an unanswered live shell and work already running before suspension.
  • Cleanup, failed-update rescans, and the shared lock fallback also need attention.
Diagram
%%{init: {'theme': 'neutral'}}%%
flowchart TD
  A[Acquire update lock] --> B[Fetch and confirm]
  B --> C{Updates planned?}
  C -->|No| Z[Exit]
  C -->|Yes| D[Probe shell]
  D -->|Answers| E[Suspend watcher]
  D -->|Probe fails| F[Merge without suspension]
  E -->|Success| G[Merge and validate]
  E -->|Failure| Z
  G --> H{Any update succeeded?}
  H -->|Yes| I[Request rescan]
  H -->|No| J[Resume watcher]
  I --> J
  J --> Z
  K[Reload already running] -. continues during .-> G
Loading

Reviews (1) · Last reviewed commit: "Assert the update lock is held in the ov..."

Comment thread bin/omarchy-plugin-update
Comment on lines +111 to +114
SHELL_AVAILABLE=0
if omarchy-shell shell ping >/dev/null 2>&1; then
SHELL_AVAILABLE=1
fi

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P1 Busy shell skips suspension

ping failure does not prove the shell has stopped. omarchy-shell also fails when a live shell takes longer than its timeout to answer. This branch then skips suspension and allows the merge. If the shell recovers during the merge, its watcher can reload partially written plugins—the race this PR aims to fix.

Allow mutation without suspension only when the shell is confirmed absent. Abort on an unanswered live shell.

Knowledge Base Used: CLI command platform

Comment thread shell/shell.qml
Comment on lines +1599 to +1603
function setLocalPluginWatch(enabled: string): string {
var on = enabled === "true" || enabled === "1" || enabled === "on"
shell.pluginRegistry.setLocalPluginWatch(on)
if (!on) localPluginReloadTimer.stop()
return on ? "watching" : "suspended"

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P1 Existing reload keeps running

setLocalPluginWatch(false) stops new watch events, but it does not wait for a reload already in progress. A local edit during preparation can start reloadPlugins() before suspension. Its pending finishPluginReload, running scan, or asynchronous component load then continues while the updater merges files. This can still load an incomplete plugin tree and trigger the original crash.

The suspension call must wait for existing plugin reads and loads to finish, or refuse mutation until they finish.

Knowledge Base Used: Shell UI and desktop interactions

Comment thread bin/omarchy-plugin-update
Comment on lines +193 to +194
suspend_local_plugin_watch
trap cleanup EXIT

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 Failed request leaves watch disabled

Cleanup is installed only after the suspension request succeeds. The shell can apply setLocalPluginWatch false, but its reply can time out or the updater can be interrupted before it records success. The updater then exits without restoring the watcher, leaving local plugin reloads disabled until the shell restarts.

Install cleanup before requesting suspension and record that restoration may be needed before sending the request.

Comment thread bin/omarchy-plugin-update
Comment on lines +172 to +174
runtime_dir="${XDG_RUNTIME_DIR:-/tmp}"
lock_file="${OMARCHY_PLUGIN_UPDATE_LOCK:-$runtime_dir/omarchy-plugin-update-$UID.lock}"
exec 9>"$lock_file" || fail "cannot open update lock: $lock_file"

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 security Another user blocks updates

If XDG_RUNTIME_DIR is unset, the new lock uses a predictable file in /tmp. Another local user can create /tmp/omarchy-plugin-update-<victim UID>.lock without granting the victim write access. Opening the lock then fails, and the victim cannot remove the other user's file from sticky /tmp.

Use a private user-owned directory for the fallback.

How this was verified: The fallback opens an attacker-precreated shared-directory file for writing and aborts when that file denies write access.

Comment thread bin/omarchy-plugin-update
Comment on lines +200 to +202
if (( UPDATED_ANY )) && (( SHELL_AVAILABLE )); then
omarchy-shell shell rescanPlugins >/dev/null ||
echo "omarchy-plugin-update: warning: shell rescan failed; updated plugins will load on the next shell rescan" >&2

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 Failed update loses pending reload

Suspension stops localPluginReloadTimer and discards watch events, but the final rescan runs only after a successful update. If a local edit has a pending reload and every planned merge fails or rolls back, that reload is canceled and never replaced. The shell keeps showing the old plugin code until another edit or a manual reload.

Request a rescan after every suspended mutation phase, including failed updates, so existing edits are not lost.

@omarchybot

Copy link
Copy Markdown
Collaborator

Reviewed again after this branch stopped merging cleanly with quattro. On current quattro it no longer fixes the crash in #12859, so I took verified off and did not push the merge.

The conflict is in shell/services/PluginRegistry.qml. In #15299, quattro starts the watcher from a new watcherReaper process's onExited instead of from initProcess. Moving the localPluginWatchWanted guard into watcherReaper.onExited resolves it cleanly, and that is the tree I tested.

Reproduction, on a VM installed from the Omarchy ISO, with the shell linked to each tree. Each round puts the real Hardwarchy plugin back at 2.3.1, then runs the pair its update button runs, omarchy plugin update followed straight away by omarchy-restart-shell. The stack matches the report (__dynamic_cast → QQmlObjectCreator::finalize → QQmlIncubatorPrivate::incubate).

Tree SIGSEGV
quattro (256e05b) 13 of 30
quattro with this PR merged in 15 of 20
this PR, with the same update when there is nothing new to fetch 0 of 10
this PR, omarchy-restart-shell alone 0 of 10
this PR, omarchy-shell shell rescanPlugins then a restart 7 of 10 (quattro: 9 of 10)
this PR, its updater with the final rescanPlugins removed 0 of 12

The crash follows the explicit reload, not the watcher. bin/omarchy-plugin-update still ends with omarchy-shell shell rescanPlugins. That call returns before reloadPlugins() has finished, because the reload continues through Qt.callLater and asynchronous component loads. omarchy-restart-shell then stops the shell partway through that reload. Suspending the watcher removes the reload that inotify triggers, but not that one.

Why I did not push a fix: removing the rescan would stop the crash on the button path. It would also mean a plain omarchy plugin update, with no restart after it, no longer loads the new version until the shell restarts. The options are a mode of the updater that skips the reload for callers that restart anyway, a restart that waits for a reload in flight, or a Quickshell report upstream. Choosing between them is a design decision, not a contained defect fix.

Related: #15434 changes the same rescanPlugins call in bin/omarchy-plugin-update so panels stay open across plugin changes, and #10705 changes the same debounce timer. Neither addresses the restart overlap.

Second opinion: Codex Medium read the merge resolution and the measurements. It agrees the resolution keeps both sides intact, that the PR does not fix the update-button crash on current quattro, and that the fix is a design decision. It also noted that suspending the watcher does not cancel a reload already in flight, and that the startup rescan is unconditional. Its agreement may not be independent, because it can read this review's working notes.

Waiting on the maintainer to decide how the updater and the restart should coordinate. This PR then needs reworking to match.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

bug Something isn't working

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Shell segfaults (SIGSEGV) in hot-reload when plugin update replaces a plugin's files

3 participants