Skip to content

Preserve bar space while the shell restarts - #11887

Open
jkarmel wants to merge 5 commits into
omacom:quattrofrom
jkarmel:fix/preserve-bar-space
Open

jkarmel wants to merge 5 commits into
omacom:quattrofrom
jkarmel:fix/preserve-bar-space

Conversation

@jkarmel

@jkarmel jkarmel commented Sep 15, 2026 •

Copy link
Copy Markdown

Restarting the shell drops the bar’s exclusive zone, expands tiled windows into that space, then shrinks them again when the bar returns. This PR keeps the built-in bar’s space reserved through shell restarts and crashes, with a status message in the strip until the shell returns.

A separate Quickshell configuration owns the reservation and loads no plugins or authentication services. The interactive bar occupies the same strip without reserving it twice. Bounded socket messages carry the current screens, edge, size, visibility, colors, and readiness. Explicit restarts, abnormal-exit retries, exhausted retries, and clean stops have distinct messages.

The launcher verifies host readiness before enabling reservation. An absent socket uses the normal bar immediately. Unsupported replacement snapshots release stale reservations without disturbing a live owner, and failed connections use fresh sockets with bounded exponential backoff, including on Quickshell 0.3.1.

Bar space preserved during shell restart

September 30 review fixes

The production follow-up, 089420cd, addresses the four automated review findings: the main bar keeps its fallback reservation until the host acknowledges ownership; live visibility snapshots override missed flag-watcher events; restart notifications and shell shutdown target the selected compositor's display; and bar sizes above 256 pixels remain supported.

A real SIGSEGV also exposed an inherited-socket failure: Quickshell's crash helper can hold the previous connection open while the shell re-execs. A token shared by one launcher and its recovery attempts lets the replacement reclaim its reservation without allowing another launcher to displace a live owner. Closing the inherited socket cannot evict the replacement.

Validation

  • Rebased onto quattro at 8b4eae66, preserving notification readiness during restart and allowing the independent companion in the shell IPC test.
  • QML lint, shell/Python syntax, protocol tests, actual offscreen QML lifecycle tests, launcher/restart tests, command style, and shell IPC tests passed. All 30 lifecycle checks also passed under Quickshell 0.3.1 in the VM. They cover delayed acknowledgments, missed hide/reveal events, inherited sockets, 300-pixel bars, and two hosts on different displays. The reported failures were reproduced before their fixes.
  • Disposable Omarchy 4.0.3 / Hyprland 0.56.2 / Quickshell 0.3.1 / Qt 6.11.2 VM with accelerated virtual graphics: 20 graphical recovery scenarios and 5,035 geometry samples, all retaining the tiled client's exact position and size and the compositor's reservation. Covers all four edges, planned outages, restart commands, SIGKILL, SIGSEGV, repeated restarts, hidden bars, transparency, host reconnection, and a 300-pixel bar.
  • Screenshots and a fresh 8.12-second recovery recording inspected. The current head, 0f9419e1, narrows acceptance cleanup to reporters carrying both Quickshell's crash-reporter marker and the launcher token from the test's deliberate crash. A focused check reproduces the previous cleanup killing an unrelated process; all nine checks pass after the fix, including preserving ordinary windows, unrelated/preexisting reporters, and the recovered shell. Python syntax and diff checks pass. This changes only the test harness; the graphical suite was not repeated for it.
  • Historical full-suite result on bc681021: seven of 288 shell test files failed, two files had skipped checks, and the CLI suite failed its VS Code theme assertion. The CLI failure and all seven shell failures reproduced on unchanged quattro at 8b4eae66 in the same VM. The shell failures are kernel-headers-migration, network-captive-portal, omarchy-kernel-migration, passwordless-grant-lifecycle, screenshot-sanity (missing omasnap), unowned-system-paths, and video-background. All changed-area tests passed. The full suite was not rerun for this follow-up.

Scope and tradeoffs

This protects the built-in bar and its hosted plugins. Full replacement bars retain their existing exclusive-zone behavior. The companion itself or the compositor dying can still cause a layout change; the main bar falls back to owning its own zone and reconnects when the companion returns. The extra Qt Quick process measured roughly 80 MiB PSS in the original QA VM.

The companion survives main-shell restarts, so changes to its own QML take effect at the next session start. Architecture, lifecycle, and reproducible acceptance-test instructions are in docs/bar-reservation.md.

@omarchybot omarchybot added the enhancement New feature or request label Sep 27, 2026
@llstrk

llstrk commented Sep 30, 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.

Outcome: A rejected new shell leaves the old reservation mapped beside its own.

A rejected new shell keeps the old reservation

reject() in the host releases the old snapshot only if the rejected connection owns it; after a restart nothing does. Impact: the old strip stays, and the new bar adds its own zone and retries each second. In practice this needs a bar over 256 px, or a protocol change the long-lived host rejects.

Suggested change: release in reject() without an owner, and back off after a rejection.

Reproducer (fails at 7b0df32)

Reproducer: a rejected new shell keeps the previous shell's reservation and retries forever

Reviewed head: 7b0df32b34ca48010b66d0f0e8c0cdaae1bc9a5e. Quickshell 0.3.1, Qt 6.11.2.

reject() in shell/bar-reservation/shell.qml releases the retained snapshot only when the rejected connection is the current owner. After a restart there is no owner (the previous shell's connection closed), so a new shell whose first snapshot fails State.parse is disconnected while the previous shell's reservation stays mapped, with ready: false and "Shell restarting…". BarReservation.qml then treats the shell as unmanaged (the bar goes back to ExclusionMode.Auto) and reconnects every second, and each attempt is rejected the same way. Hyprland arranges bottom-layer exclusive zones before top-layer ones (arrangeLayersForMonitor, v0.56.2), so the host's strip and the new bar both reserve space.

Today the rejected snapshot needs a bar thicker than 256 px (State.parse caps size at 256; Style.bar.sizeHorizontal has no upper bound). The same path is taken by any later protocol or validation change, because the host keeps running its old code across main-shell restarts and updates until the next login.

The script runs the PR's host and the PR's unchanged BarReservation.qml under Quickshell's offscreen platform, with a private HOME and XDG_RUNTIME_DIR. Offscreen has no layer shell, so the host copy swaps PanelWindow for FloatingWindow and drops anchors, exclusiveZone and the WlrLayershell properties. The socket, ownership, parsing and visibility code is the PR's text. surface mapped is the value of the production visible: binding, which decides whether the layer surface, and so its exclusive zone, exists.

Run: python3 repro_reject_after_restart.py <omarchy checkout at 7b0df32>

#!/usr/bin/env python3
"""Reproducer for omacom/omarchy#11887 at 7b0df32.

Runs the PR's reservation host (shell/bar-reservation/shell.qml) and the PR's
BarReservation.qml client under Quickshell's offscreen platform, each with a
private HOME and XDG_RUNTIME_DIR. Offscreen has no layer shell, so the host
copy swaps PanelWindow for FloatingWindow and drops the three layer-shell-only
properties (anchors, exclusiveZone, WlrLayershell); the socket, ownership,
parsing and visibility code is the PR's text.

1. Shell A connects and reserves the bar (26 px, as the running shell would).
2. omarchy-restart-shell announces the restart; A's connection closes.
3. Shell B (BarReservation.qml, unchanged) connects with a snapshot the host
   rejects: a 300 px bar (State.parse caps size at 256).
4. A raw client sends a future protocol version (version 2).

Usage: python3 repro_reject_after_restart.py <omarchy checkout>
"""
import json
import os
from pathlib import Path
import resource
import shutil
import signal
import socket
import subprocess
import sys
import tempfile
import time

repo = Path(sys.argv[1]).resolve()
resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
work = Path(tempfile.mkdtemp(prefix='bar-repro-'))
(work / 'run').mkdir(mode=0o700)
(work / 'home/.local/state/omarchy/toggles').mkdir(parents=True)
sock = work / 'bar.sock'
env = dict(PATH=os.environ['PATH'], HOME=str(work / 'home'), XDG_RUNTIME_DIR=str(work / 'run'),
  QT_QPA_PLATFORM='offscreen', QS_DISABLE_CRASH_HANDLER='1', QS_DISABLE_FILE_WATCHER='1',
  QS_NO_RELOAD_POPUP='1', OMARCHY_BAR_SOCKET=str(sock), LANG='C.UTF-8')
procs = []

host = work / 'host'
host.mkdir()
qml = (repo / 'shell/bar-reservation/shell.qml').read_text()
qml = qml.replace('import Quickshell.Wayland\n', '')
qml = qml.replace('    model: Quickshell.screens\n    delegate: PanelWindow {',
  '    id: surfaces\n    model: Quickshell.screens\n    delegate: FloatingWindow {')
start = qml.index('      anchors {')
qml = qml[:start] + qml[qml.index('      }\n', start) + 8:]
for line in ('      exclusiveZone: root.snapshot.size\n', '      WlrLayershell.layer: WlrLayer.Bottom\n',
    '      WlrLayershell.namespace: "omarchy-bar-reservation"\n'):
  assert line in qml
  qml = qml.replace(line, '')
qml = qml.rstrip()[:-1] + '''  IpcHandler {
    target: "repro"
    function mapped(): bool { return surfaces.instances[0].visible }
  }
}
'''
(host / 'shell.qml').write_text(qml)
shutil.copy(repo / 'shell/bar-reservation/State.js', host / 'State.js')

client = work / 'client'
client.mkdir()
shutil.copy(repo / 'shell/services/BarReservation.qml', client / 'BarReservation.qml')
(client / 'shell.qml').write_text('''import QtQuick
import Quickshell
import Quickshell.Io
ShellRoot {
  id: repro
  property var flips: []
  property QtObject fakeBar: QtObject {
    property string position: "top"
    property int barSize: 300
    property bool barHidden: false
    property bool hiddenStateKnown: true
    property color background: "#202020"
    property color foreground: "#ffffff"
  }
  property BarReservation reservation: BarReservation {
    bar: repro.fakeBar; supported: true; contentReady: true
    onManagedChanged: repro.flips = repro.flips.concat([managed])
  }
  IpcHandler {
    target: "repro"
    function state(): string { return JSON.stringify({ managed: repro.reservation.managed, flips: repro.flips }) }
  }
}
''')


def launch(directory):
  process = subprocess.Popen(['quickshell', '-p', str(directory)], env=env,
    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
  procs.append(process)
  return process


def ipc(directory, target, function):
  for _ in range(100):
    result = subprocess.run(['quickshell', 'ipc', '-p', str(directory), 'call', target, function],
      env=env, capture_output=True, text=True)
    if result.returncode == 0:
      return result.stdout.strip()
    time.sleep(.05)
  raise RuntimeError(result.stderr)


def connect():
  connection = socket.socket(socket.AF_UNIX)
  connection.settimeout(3)
  connection.connect(str(sock))
  return connection


def frame(**changes):
  value = {'version': 1, 'screens': [''], 'position': 'top', 'size': 26, 'hidden': False,
    'ready': True, 'background': '#111111', 'foreground': '#eeeeee'}  # offscreen screen name is ''
  value.update(changes)
  return (json.dumps(value) + '\n').encode()


def report(step):
  status = json.loads(ipc(host, 'reservation', 'status'))
  print(f'{step}: host ready={status["ready"]} message={status["message"]!r} '
    f'reserved size={status["snapshot"]["size"]} from background={status["snapshot"]["background"]} '
    f'surface mapped={ipc(host, "repro", "mapped")}')


try:
  launch(host)
  ipc(host, 'reservation', 'ping')

  shell_a = connect()
  shell_a.sendall(frame())
  shell_a.recv(8)
  report('1. shell A connected')

  ipc(host, 'reservation', 'restarting')
  shell_a.close()
  time.sleep(.5)
  report('2. restart announced, shell A gone')

  launch(client)
  time.sleep(6)
  state = json.loads(ipc(client, 'repro', 'state'))
  print(f'3. shell B (300 px bar) after 6 s: managed={state["managed"]} managed transitions={state["flips"]}')
  report('3. shell B (300 px bar) after 6 s')

  future = connect()
  future.sendall(frame(version=2))
  reply = future.recv(8)
  future.close()
  time.sleep(.3)
  report(f'4. version 2 client (reply {reply!r})')
finally:
  for process in procs:
    process.send_signal(signal.SIGTERM)
    process.wait(5)
  shutil.rmtree(work, ignore_errors=True)

Actual output:

1. shell A connected: host ready=True message='' reserved size=26 from background=#111111 surface mapped=true
2. restart announced, shell A gone: host ready=False message='Shell restarting…' reserved size=26 from background=#111111 surface mapped=true
3. shell B (300 px bar) after 6 s: managed=False managed transitions=[True, False, True, False, True, False, True, False, True, False, True, False]
3. shell B (300 px bar) after 6 s: host ready=False message='Shell restarting…' reserved size=26 from background=#111111 surface mapped=true
4. version 2 client (reply b''): host ready=False message='Shell restarting…' reserved size=26 from background=#111111 surface mapped=true

For comparison, the same flow with a 26 px shell B is accepted at once: managed becomes true once, the host clears the message, sets ready: true and replaces the snapshot with shell B's colors.

Without a host, the bar waits 2 s per start

Quickshell.env() returns null when unset, so configured (BarReservation.qml:10) stays true after the launcher unsets it; starting a host that fails to load also returns 0. Impact: either way the bar stays unmapped for 2 s.

Suggested change: use !!Quickshell.env(...), and ping the host before exporting the socket.

Reproducer: unset variable (fails at 7b0df32)

Reproducer: with OMARCHY_BAR_SOCKET unset, the bar still waits 2 s for a reservation host

Reviewed head: 7b0df32b34ca48010b66d0f0e8c0cdaae1bc9a5e. Quickshell 0.3.1, Qt 6.11.2.

omarchy-launch-shell falls back by running unset OMARCHY_BAR_SOCKET (host start timed out or exited non-zero, or no runtime dir, display or host config). Quickshell 0.3.1's Quickshell.env() returns null for an unset variable (src/core/qmlglobal.cpp, QuickshellGlobal::env), and shell/services/BarReservation.qml:10 tests Quickshell.env("OMARCHY_BAR_SOCKET") !== "". Since null !== "" is true, configured is true without any socket:

  • managed is false, so the bar keeps ExclusionMode.Auto, as intended.
  • waiting is true until the 2 s startupExpired timer fires, because no acknowledgement can arrive. Bar.qml:1243 therefore keeps the bar unmapped for 2 s on every shell start.
  • The one-second retry timer runs for the life of the shell. Each tick sets connected = true on a socket whose path is empty, which does nothing.

Before this PR, Bar.qml was visible: !remapGuard.remapping with exclusionMode: root.barHidden ? ExclusionMode.Ignore : ExclusionMode.Auto, so the bar mapped as soon as it was created. The script below runs the PR's unchanged BarReservation.qml under Quickshell's offscreen platform with a private HOME and XDG_RUNTIME_DIR. The bar's visible and exclusionMode expressions are copied from the PR's Bar.qml at run time, with remapGuard.remapping taken as false.

Run: python3 repro_unset_socket_env.py <omarchy checkout at 7b0df32> (both files in one directory).

common.py:

"""Shared helpers for the #11887 follow-up reproducers (offscreen Quickshell).

The host copy swaps PanelWindow for FloatingWindow (offscreen has no layer
shell) and drops anchors, exclusiveZone and the WlrLayershell properties; the
socket, ownership, parsing and visibility code is the PR's text. The client is
the PR's BarReservation.qml, unchanged, next to a stand-in for the built-in bar.
The bar's visible and exclusionMode expressions are copied from the PR's
Bar.qml at run time, with `remapGuard.remapping` taken as false and `root.`
pointing at the stand-in.
"""
import json
import os
from pathlib import Path
import re
import resource
import shutil
import signal
import socket
import subprocess
import tempfile
import time

resource.setrlimit(resource.RLIMIT_CORE, (0, 0))


class Lab:
  def __init__(self, repo):
    self.repo = Path(repo).resolve()
    self.work = Path(tempfile.mkdtemp(prefix='bar-repro-'))
    (self.work / 'run').mkdir(mode=0o700)
    (self.work / 'home/.local/state/omarchy/toggles').mkdir(parents=True)
    self.sock = self.work / 'bar.sock'
    self.procs = []
    self.base = dict(PATH=os.environ['PATH'], HOME=str(self.work / 'home'),
      XDG_RUNTIME_DIR=str(self.work / 'run'), QT_QPA_PLATFORM='offscreen',
      QS_DISABLE_CRASH_HANDLER='1', QS_DISABLE_FILE_WATCHER='1', QS_NO_RELOAD_POPUP='1', LANG='C.UTF-8')
    self.t0 = time.monotonic()

  def env(self, socket_value='default'):
    env = dict(self.base)
    if socket_value == 'default':
      env['OMARCHY_BAR_SOCKET'] = str(self.sock)
    elif socket_value is not None:
      env['OMARCHY_BAR_SOCKET'] = socket_value
    return env

  def stamp(self):
    return f'[{time.monotonic() - self.t0:5.1f}s]'

  # ------------------------------------------------------------ configs
  def make_host(self, name):
    directory = self.work / name
    directory.mkdir()
    qml = (self.repo / 'shell/bar-reservation/shell.qml').read_text()
    qml = qml.replace('import Quickshell.Wayland\n', '')
    qml = qml.replace('    model: Quickshell.screens\n    delegate: PanelWindow {',
      '    id: surfaces\n    model: Quickshell.screens\n    delegate: FloatingWindow {')
    start = qml.index('      anchors {')
    qml = qml[:start] + qml[qml.index('      }\n', start) + 8:]
    for line in ('      exclusiveZone: root.snapshot.size\n', '      WlrLayershell.layer: WlrLayer.Bottom\n',
        '      WlrLayershell.namespace: "omarchy-bar-reservation"\n'):
      assert line in qml
      qml = qml.replace(line, '')
    qml = qml.rstrip()[:-1] + '''  IpcHandler {
    target: "repro"
    function mapped(): bool { return surfaces.instances[0].visible }
  }
}
'''
    (directory / 'shell.qml').write_text(qml)
    shutil.copy(self.repo / 'shell/bar-reservation/State.js', directory / 'State.js')
    return directory

  def make_client(self, name):
    directory = self.work / name
    directory.mkdir()
    shutil.copy(self.repo / 'shell/services/BarReservation.qml', directory / 'BarReservation.qml')
    bar = (self.repo / 'shell/plugins/bar/Bar.qml').read_text()
    match = re.search(r'\n    visible: (!remapGuard\.remapping && [^\n]*)\n'
      r'    exclusionMode: ([^\n]*\n\s*\? ExclusionMode\.Ignore : ExclusionMode\.Auto)\n', bar)
    assert match, 'BarPanel bindings not found'
    visible = match.group(1).replace('remapGuard.remapping', 'false').replace('root.', 'harness.barRoot.')
    exclusion = match.group(2).replace('root.', 'harness.barRoot.')
    (directory / 'shell.qml').write_text('''import QtQuick
import Quickshell
import Quickshell.Io

ShellRoot {
  id: harness
  property real startedAt: Date.now()
  property real waitingEndedAt: -1
  property int retryTicks: 0
  property var retryTimer: null
  property QtObject bar: QtObject {
    property string position: "top"
    property int barSize: 26
    property bool barHidden: false
    property bool hiddenStateKnown: true
    property color background: "#202020"
    property color foreground: "#ffffff"
  }
  // shell.qml's `barReservation`, with supported and contentReady true.
  property BarReservation barReservation: BarReservation {
    bar: harness.bar
    supported: true
    contentReady: true
    onWaitingChanged: if (!waiting && harness.waitingEndedAt < 0) harness.waitingEndedAt = Date.now()
  }
  // Stand-in for Bar.qml's root: it reads root.barHidden and root.shell.barReservation.
  property QtObject barRoot: QtObject { property bool barHidden: false; property var shell: harness }
  readonly property bool barVisible: %s
  readonly property int barExclusion: %s
  Component.onCompleted: {
    var r = harness.barReservation.resources
    for (var i = 0; i < r.length; i++) {
      if (("triggeredOnStart" in r[i]) && r[i].interval === 1000 && r[i].repeat) {
        harness.retryTimer = r[i]
        r[i].triggered.connect(function() { harness.retryTicks++ })
      }
    }
  }
  IpcHandler {
    target: "repro"
    function state(): string {
      var s = harness.barReservation
      return JSON.stringify({ elapsedMs: Date.now() - harness.startedAt,
        env: Quickshell.env("OMARCHY_BAR_SOCKET"), configured: s.configured, managed: s.managed,
        waiting: s.waiting, barVisible: harness.barVisible,
        barExclusion: harness.barExclusion === ExclusionMode.Ignore ? "Ignore"
          : harness.barExclusion === ExclusionMode.Auto ? "Auto" : String(harness.barExclusion),
        retryTimerRunning: harness.retryTimer ? harness.retryTimer.running : null,
        retryTicks: harness.retryTicks,
        waitingEndedAfterMs: harness.waitingEndedAt < 0 ? null : harness.waitingEndedAt - harness.startedAt })
    }
  }
}
''' % (visible, exclusion))
    return directory, visible, exclusion

  # ------------------------------------------------------------ processes
  def launch(self, directory, env):
    process = subprocess.Popen(['quickshell', '-p', str(directory)], env=env,
      stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
    self.procs.append(process)
    return process

  def ipc(self, directory, target, function, env):
    for _ in range(200):
      result = subprocess.run(['quickshell', 'ipc', '-p', str(directory), 'call', target, function],
        env=env, capture_output=True, text=True)
      if result.returncode == 0:
        return result.stdout.strip()
      time.sleep(.05)
    raise RuntimeError(result.stderr)

  def state(self, client, env):
    return json.loads(self.ipc(client, 'repro', 'state', env))

  def host_view(self, host):
    status = json.loads(self.ipc(host, 'reservation', 'status', self.env()))
    return (f'host ready={status["ready"]} message={status["message"]!r} '
      f'snapshot screens={status["snapshot"]["screens"]} size={status["snapshot"]["size"]} '
      f'surface mapped={self.ipc(host, "repro", "mapped", self.env())}')

  def wait(self, predicate, timeout=10):
    deadline = time.monotonic() + timeout
    while time.monotonic() < deadline:
      if predicate():
        return True
      time.sleep(.05)
    return False

  def close(self):
    for process in self.procs:
      if process.poll() is None:
        process.send_signal(signal.SIGTERM)
        process.wait(5)
    shutil.rmtree(self.work, ignore_errors=True)


def short(state, keys):
  return ' '.join(f'{k}={json.dumps(state[k])}' for k in keys)

repro_unset_socket_env.py:

#!/usr/bin/env python3
"""Q1: BarReservation.qml when OMARCHY_BAR_SOCKET is unset (omarchy#11887 @ 7b0df32).

Quickshell 0.3.1's Quickshell.env() returns null for an unset variable, and
BarReservation.qml computes `configured: Quickshell.env("OMARCHY_BAR_SOCKET") !== ""`.
Three main-shell environments: variable unset (what omarchy-launch-shell leaves
after its `unset OMARCHY_BAR_SOCKET` fallback), set to "", and set with a
reservation host listening.

Usage: python3 repro_unset_socket_env.py <omarchy checkout>
"""
import sys
import time

sys.path.insert(0, __file__.rsplit('/', 1)[0])
from common import Lab, short

KEYS = ['env', 'configured', 'managed', 'waiting', 'barVisible', 'barExclusion', 'retryTimerRunning', 'retryTicks']
lab = Lab(sys.argv[1])
try:
  cases = [('unset', None), ('empty string', ''), ('set, host listening', 'default')]
  printed = False
  for index, (label, value) in enumerate(cases):
    if value == 'default':
      host = lab.make_host('host')
      lab.launch(host, lab.env())
      lab.ipc(host, 'reservation', 'ping', lab.env())
    client, visible, exclusion = lab.make_client(f'client-{index}')
    if not printed:
      print('Bar.qml visible (as evaluated):', visible)
      print('Bar.qml exclusionMode (as evaluated):', ' '.join(exclusion.split()))
      printed = True
    env = lab.env(value)
    lab.launch(client, env)
    print(f'== OMARCHY_BAR_SOCKET {label}')
    for at in (0.5, 1.5, 2.5, 5.0):
      lab.wait(lambda: lab.state(client, env)['elapsedMs'] >= at * 1000, timeout=10)
      state = lab.state(client, env)
      print(f'  t={state["elapsedMs"] / 1000:.1f}s {short(state, KEYS)}')
    state = lab.state(client, env)
    ended = state['waitingEndedAfterMs']
    print('  bar first visible after:', 'at start' if ended is None and not state['waiting'] else f'{ended / 1000:.2f}s')
finally:
  lab.close()

Actual output:

Bar.qml visible (as evaluated): !false && !(harness.barRoot.shell && harness.barRoot.shell.barReservation && harness.barRoot.shell.barReservation.waiting)
Bar.qml exclusionMode (as evaluated): harness.barRoot.barHidden || (harness.barRoot.shell && harness.barRoot.shell.barReservation && harness.barRoot.shell.barReservation.managed) ? ExclusionMode.Ignore : ExclusionMode.Auto
== OMARCHY_BAR_SOCKET unset
  t=0.6s env=null configured=true managed=false waiting=true barVisible=false barExclusion="Auto" retryTimerRunning=true retryTicks=0
  t=1.5s env=null configured=true managed=false waiting=true barVisible=false barExclusion="Auto" retryTimerRunning=true retryTicks=1
  t=2.6s env=null configured=true managed=false waiting=false barVisible=true barExclusion="Auto" retryTimerRunning=true retryTicks=2
  t=5.1s env=null configured=true managed=false waiting=false barVisible=true barExclusion="Auto" retryTimerRunning=true retryTicks=5
  bar first visible after: 2.00s
== OMARCHY_BAR_SOCKET empty string
  t=0.6s env="" configured=false managed=false waiting=false barVisible=true barExclusion="Auto" retryTimerRunning=false retryTicks=0
  t=1.6s env="" configured=false managed=false waiting=false barVisible=true barExclusion="Auto" retryTimerRunning=false retryTicks=0
  t=2.6s env="" configured=false managed=false waiting=false barVisible=true barExclusion="Auto" retryTimerRunning=false retryTicks=0
  t=5.0s env="" configured=false managed=false waiting=false barVisible=true barExclusion="Auto" retryTimerRunning=false retryTicks=0
  bar first visible after: at start
== OMARCHY_BAR_SOCKET set, host listening
  t=0.6s env="/tmp/bar-repro-pzh8stse/bar.sock" configured=true managed=true waiting=false barVisible=true barExclusion="Ignore" retryTimerRunning=false retryTicks=0
  t=1.6s env="/tmp/bar-repro-pzh8stse/bar.sock" configured=true managed=true waiting=false barVisible=true barExclusion="Ignore" retryTimerRunning=false retryTicks=0
  t=2.5s env="/tmp/bar-repro-pzh8stse/bar.sock" configured=true managed=true waiting=false barVisible=true barExclusion="Ignore" retryTimerRunning=false retryTicks=0
  t=5.0s env="/tmp/bar-repro-pzh8stse/bar.sock" configured=true managed=true waiting=false barVisible=true barExclusion="Ignore" retryTimerRunning=false retryTicks=0
  bar first visible after: 0.00s

The "set, host listening" row's 0.00s is the time to the host's acknowledgement.

Reproducer: exit status of a host that fails to load

Reproducer: quickshell -d -n reports success for a reservation host that fails to load

Reviewed head: 7b0df32b34ca48010b66d0f0e8c0cdaae1bc9a5e. Quickshell 0.3.1.

omarchy-launch-shell treats a non-zero status from quickshell -d -n -p …/bar-reservation as "Bar reservation host unavailable" and unsets OMARCHY_BAR_SOCKET. In Quickshell 0.3.1 the daemon child exits through exit(-1) when its configuration fails to load (RootWrapper), without writing to the daemon pipe, so the waiting parent reads end-of-file and returns 0. The launcher then exports a socket nothing listens on, logs nothing, and the main shell's BarReservation stays configured but unconnected: the bar is hidden for the 2-second startup window on every shell start before it falls back to its own zone. The launcher test models failure with a fake quickshell that exits 1, which the real binary does not do for this case.

#!/bin/bash
# Reproducer for omacom/omarchy#11887 at 7b0df32: `quickshell -d -n` (as
# omarchy-launch-shell starts the reservation host) exits 0 even when the
# configuration fails to load, so the launcher's "Bar reservation host
# unavailable" branch never runs for a broken host. Private HOME and
# XDG_RUNTIME_DIR; offscreen platform; core dumps off.
set -u
ulimit -c 0
t=$(mktemp -d)
mkdir -m 700 "$t/run" && mkdir -p "$t/home" "$t/broken"
export HOME=$t/home XDG_RUNTIME_DIR=$t/run QT_QPA_PLATFORM=offscreen QS_DISABLE_CRASH_HANDLER=1
printf 'import QtQuick\nimport Quickshell\nShellRoot {\n  NoSuchType { }\n}\n' >"$t/broken/shell.qml"
timeout --kill-after=1s 5s quickshell -d -n -p "$t/broken" >/dev/null 2>&1
echo "quickshell -d -n with a config that fails to load: exit status $?"
quickshell list -p "$t/broken" 2>&1 | head -n 1
rm -rf "$t"

Actual output:

quickshell -d -n with a config that fails to load: exit status 0
No running instances for "/tmp/tmp.ZYcmt8ncoU/broken/shell.qml"

A working configuration also returns 0, as does a duplicate start; only the timeout path (status 124) reaches the launcher's fallback branch.

More findings

Conflicts with current quattro

bin/omarchy-restart-shell conflicts with quattro's pre-kill block (keeping both resolves it). After the merge, shell-ipc-socket-test.sh fails, because it allows IpcHandler { only in shell/Commons/IpcRegistry.qml and shell/Commons/ShellIpc.qml.

Suggested change: when rebasing, add shell/bar-reservation/shell.qml to that list, or exclude shell/bar-reservation/, noting that the host deliberately avoids qs.Commons.

A host that returns late is never reconnected

On Quickshell 0.3.1 a failed connect leaves Socket holding the dead QLocalSocket, so later connected = true retries do nothing (fixed upstream after 0.3.1). If the host is not listening at the first retry after a disconnect, the main shell stays on its own zone for the rest of its life, and the next restart moves windows once.

Suggested change: recreate the Socket object on each retry, for example through a Loader.

Reproducer for the quattro conflict (fails on the merge with 8b4eae6)

Reproducer: merging into current quattro fails shell-ipc-socket-test.sh

Reviewed head: 7b0df32b34ca48010b66d0f0e8c0cdaae1bc9a5e. Current quattro: 8b4eae66da2938ba9559f103b18dbf85cdf28a70.

Since the PR branched, quattro added test/shell.d/shell-ipc-socket-test.sh (#13435, #13443). It asserts that the only files under shell/ containing IpcHandler { are shell/Commons/IpcRegistry.qml and shell/Commons/ShellIpc.qml. The new shell/bar-reservation/shell.qml declares a bare IpcHandler (and cannot use ShellIpc, which lives in the main shell's qs.Commons).

git clone https://github.com/omacom/omarchy && cd omarchy
git fetch origin pull/11887/head:pr-11887
git switch -c merge-check origin/quattro
git merge --no-edit pr-11887
# CONFLICT (content): Merge conflict in bin/omarchy-restart-shell
# Resolve by keeping both inserted blocks: quattro's notifications_ready block,
# then the PR's "Announce a deliberate restart" line. Then:
git add bin/omarchy-restart-shell && git commit --no-edit
bash test/shell.d/shell-ipc-socket-test.sh

Actual output (tail) on the merged tree:

ok - a stale socket with nothing listening falls back to qs ipc
ok - without the socket calls go through qs ipc
ok - a call for another display does not reach this shell's socket
expected: ["shell/Commons/IpcRegistry.qml","shell/Commons/ShellIpc.qml"]
actual:   ["shell/Commons/IpcRegistry.qml","shell/Commons/ShellIpc.qml","shell/bar-reservation/shell.qml"]
not ok - first-party IPC handlers register through ShellIpc

The same test passes on quattro alone:

ok - first-party IPC handlers register through ShellIpc
ok - the socket answers only declared functions with their exact argument count
ok - the shell names its socket after its config and display, as omarchy-shell does

Across the whole test/shell.d suite, the merged tree has exactly one failure that quattro alone does not have: this one.

Reproducer for the late host

Reproducer: a host that comes back after the main shell's first retry is never reconnected, and the next restart loses the reserved space

Reviewed head: 7b0df32b34ca48010b66d0f0e8c0cdaae1bc9a5e. Quickshell 0.3.1, Qt 6.11.2.

When the host goes away, the main shell's Socket gets a disconnect: onSocketDisconnected drops the QLocalSocket, and does not reconnect because targetConnected was cleared when the connection was made (Quickshell 0.3.1 src/io/socket.cpp:50,56-66). BarReservation.qml's one-second timer then sets connected = true, which starts one new connection attempt (socket.cpp:83). If nothing is listening at that moment, the attempt fails and the failed QLocalSocket stays in place, so every later tick does nothing (socket.cpp:68-71,83). This was fixed upstream after 0.3.1 in commit 41651d7. The main shell stays unmanaged and keeps its own zone for the rest of its life, even after the host returns. The returned host starts with an empty snapshot and ready: false. When the main shell is next restarted, nothing is reserved between the old shell's exit and the new shell's first snapshot.

The script runs the PR's host (PanelWindow swapped for FloatingWindow, layer-shell-only properties dropped) and the PR's unchanged BarReservation.qml under Quickshell's offscreen platform, with a private HOME and XDG_RUNTIME_DIR. surface mapped is the value of the host's production visible: binding, which decides whether its layer surface, and so its exclusive zone, exists.

Run: python3 repro_host_returns_after_retry.py <omarchy checkout at 7b0df32> (both files in one directory).

common.py:

"""Shared helpers for the #11887 follow-up reproducers (offscreen Quickshell).

The host copy swaps PanelWindow for FloatingWindow (offscreen has no layer
shell) and drops anchors, exclusiveZone and the WlrLayershell properties; the
socket, ownership, parsing and visibility code is the PR's text. The client is
the PR's BarReservation.qml, unchanged, next to a stand-in for the built-in bar.
The bar's visible and exclusionMode expressions are copied from the PR's
Bar.qml at run time, with `remapGuard.remapping` taken as false and `root.`
pointing at the stand-in.
"""
import json
import os
from pathlib import Path
import re
import resource
import shutil
import signal
import socket
import subprocess
import tempfile
import time

resource.setrlimit(resource.RLIMIT_CORE, (0, 0))


class Lab:
  def __init__(self, repo):
    self.repo = Path(repo).resolve()
    self.work = Path(tempfile.mkdtemp(prefix='bar-repro-'))
    (self.work / 'run').mkdir(mode=0o700)
    (self.work / 'home/.local/state/omarchy/toggles').mkdir(parents=True)
    self.sock = self.work / 'bar.sock'
    self.procs = []
    self.base = dict(PATH=os.environ['PATH'], HOME=str(self.work / 'home'),
      XDG_RUNTIME_DIR=str(self.work / 'run'), QT_QPA_PLATFORM='offscreen',
      QS_DISABLE_CRASH_HANDLER='1', QS_DISABLE_FILE_WATCHER='1', QS_NO_RELOAD_POPUP='1', LANG='C.UTF-8')
    self.t0 = time.monotonic()

  def env(self, socket_value='default'):
    env = dict(self.base)
    if socket_value == 'default':
      env['OMARCHY_BAR_SOCKET'] = str(self.sock)
    elif socket_value is not None:
      env['OMARCHY_BAR_SOCKET'] = socket_value
    return env

  def stamp(self):
    return f'[{time.monotonic() - self.t0:5.1f}s]'

  # ------------------------------------------------------------ configs
  def make_host(self, name):
    directory = self.work / name
    directory.mkdir()
    qml = (self.repo / 'shell/bar-reservation/shell.qml').read_text()
    qml = qml.replace('import Quickshell.Wayland\n', '')
    qml = qml.replace('    model: Quickshell.screens\n    delegate: PanelWindow {',
      '    id: surfaces\n    model: Quickshell.screens\n    delegate: FloatingWindow {')
    start = qml.index('      anchors {')
    qml = qml[:start] + qml[qml.index('      }\n', start) + 8:]
    for line in ('      exclusiveZone: root.snapshot.size\n', '      WlrLayershell.layer: WlrLayer.Bottom\n',
        '      WlrLayershell.namespace: "omarchy-bar-reservation"\n'):
      assert line in qml
      qml = qml.replace(line, '')
    qml = qml.rstrip()[:-1] + '''  IpcHandler {
    target: "repro"
    function mapped(): bool { return surfaces.instances[0].visible }
  }
}
'''
    (directory / 'shell.qml').write_text(qml)
    shutil.copy(self.repo / 'shell/bar-reservation/State.js', directory / 'State.js')
    return directory

  def make_client(self, name):
    directory = self.work / name
    directory.mkdir()
    shutil.copy(self.repo / 'shell/services/BarReservation.qml', directory / 'BarReservation.qml')
    bar = (self.repo / 'shell/plugins/bar/Bar.qml').read_text()
    match = re.search(r'\n    visible: (!remapGuard\.remapping && [^\n]*)\n'
      r'    exclusionMode: ([^\n]*\n\s*\? ExclusionMode\.Ignore : ExclusionMode\.Auto)\n', bar)
    assert match, 'BarPanel bindings not found'
    visible = match.group(1).replace('remapGuard.remapping', 'false').replace('root.', 'harness.barRoot.')
    exclusion = match.group(2).replace('root.', 'harness.barRoot.')
    (directory / 'shell.qml').write_text('''import QtQuick
import Quickshell
import Quickshell.Io

ShellRoot {
  id: harness
  property real startedAt: Date.now()
  property real waitingEndedAt: -1
  property int retryTicks: 0
  property var retryTimer: null
  property QtObject bar: QtObject {
    property string position: "top"
    property int barSize: 26
    property bool barHidden: false
    property bool hiddenStateKnown: true
    property color background: "#202020"
    property color foreground: "#ffffff"
  }
  // shell.qml's `barReservation`, with supported and contentReady true.
  property BarReservation barReservation: BarReservation {
    bar: harness.bar
    supported: true
    contentReady: true
    onWaitingChanged: if (!waiting && harness.waitingEndedAt < 0) harness.waitingEndedAt = Date.now()
  }
  // Stand-in for Bar.qml's root: it reads root.barHidden and root.shell.barReservation.
  property QtObject barRoot: QtObject { property bool barHidden: false; property var shell: harness }
  readonly property bool barVisible: %s
  readonly property int barExclusion: %s
  Component.onCompleted: {
    var r = harness.barReservation.resources
    for (var i = 0; i < r.length; i++) {
      if (("triggeredOnStart" in r[i]) && r[i].interval === 1000 && r[i].repeat) {
        harness.retryTimer = r[i]
        r[i].triggered.connect(function() { harness.retryTicks++ })
      }
    }
  }
  IpcHandler {
    target: "repro"
    function state(): string {
      var s = harness.barReservation
      return JSON.stringify({ elapsedMs: Date.now() - harness.startedAt,
        env: Quickshell.env("OMARCHY_BAR_SOCKET"), configured: s.configured, managed: s.managed,
        waiting: s.waiting, barVisible: harness.barVisible,
        barExclusion: harness.barExclusion === ExclusionMode.Ignore ? "Ignore"
          : harness.barExclusion === ExclusionMode.Auto ? "Auto" : String(harness.barExclusion),
        retryTimerRunning: harness.retryTimer ? harness.retryTimer.running : null,
        retryTicks: harness.retryTicks,
        waitingEndedAfterMs: harness.waitingEndedAt < 0 ? null : harness.waitingEndedAt - harness.startedAt })
    }
  }
}
''' % (visible, exclusion))
    return directory, visible, exclusion

  # ------------------------------------------------------------ processes
  def launch(self, directory, env):
    process = subprocess.Popen(['quickshell', '-p', str(directory)], env=env,
      stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
    self.procs.append(process)
    return process

  def ipc(self, directory, target, function, env):
    for _ in range(200):
      result = subprocess.run(['quickshell', 'ipc', '-p', str(directory), 'call', target, function],
        env=env, capture_output=True, text=True)
      if result.returncode == 0:
        return result.stdout.strip()
      time.sleep(.05)
    raise RuntimeError(result.stderr)

  def state(self, client, env):
    return json.loads(self.ipc(client, 'repro', 'state', env))

  def host_view(self, host):
    status = json.loads(self.ipc(host, 'reservation', 'status', self.env()))
    return (f'host ready={status["ready"]} message={status["message"]!r} '
      f'snapshot screens={status["snapshot"]["screens"]} size={status["snapshot"]["size"]} '
      f'surface mapped={self.ipc(host, "repro", "mapped", self.env())}')

  def wait(self, predicate, timeout=10):
    deadline = time.monotonic() + timeout
    while time.monotonic() < deadline:
      if predicate():
        return True
      time.sleep(.05)
    return False

  def close(self):
    for process in self.procs:
      if process.poll() is None:
        process.send_signal(signal.SIGTERM)
        process.wait(5)
    shutil.rmtree(self.work, ignore_errors=True)


def short(state, keys):
  return ' '.join(f'{k}={json.dumps(state[k])}' for k in keys)

repro_host_returns_after_retry.py:

#!/usr/bin/env python3
"""Q2: the reservation host dies and comes back while the main shell keeps running
(omarchy#11887 @ 7b0df32, Quickshell 0.3.1).

1. Host A and a main shell (the PR's BarReservation.qml) are connected.
2. Host A is killed (SIGKILL: its socket file stays behind, nothing listens).
3. Host B starts on the same socket either after the shell's first one-second
   retry has failed ("late") or before it ("early", the control).
4. The main shell is restarted as omarchy-restart-shell does: announce
   `restarting`, stop the shell, start a new one.

Usage: python3 repro_host_returns_after_retry.py <omarchy checkout>
"""
import os
import signal
import sys
import time

sys.path.insert(0, __file__.rsplit('/', 1)[0])
from common import Lab, short

KEYS = ['managed', 'barExclusion', 'retryTicks']


def scenario(repo, host_b_delay, label):
  lab = Lab(repo)
  env = lab.env()
  try:
    print(f'== {label}: host B starts {host_b_delay}s after host A dies')
    host_a = lab.make_host('host-a')
    a = lab.launch(host_a, env)
    lab.ipc(host_a, 'reservation', 'ping', env)
    shell_1 = lab.make_client('shell-1')[0]
    s1 = lab.launch(shell_1, env)
    lab.wait(lambda: lab.state(shell_1, env)['managed'])
    lab.wait(lambda: lab.ipc(host_a, 'repro', 'mapped', env) == 'true')
    print(f'  {lab.stamp()} shell 1 connected: {short(lab.state(shell_1, env), KEYS)}; host A: {lab.host_view(host_a)}')

    os.kill(a.pid, signal.SIGKILL)
    a.wait(5)
    print(f'  {lab.stamp()} host A killed; socket file left behind: {lab.sock.exists()}')
    time.sleep(host_b_delay)
    host_b = lab.make_host('host-b')
    lab.launch(host_b, env)
    lab.ipc(host_b, 'reservation', 'ping', env)
    print(f'  {lab.stamp()} host B listening')
    time.sleep(6)
    print(f'  {lab.stamp()} shell 1 six seconds later: {short(lab.state(shell_1, env), KEYS)}; host B: {lab.host_view(host_b)}')

    lab.ipc(host_b, 'reservation', 'restarting', env)
    s1.send_signal(signal.SIGTERM)
    s1.wait(5)
    time.sleep(.5)
    print(f'  {lab.stamp()} restart: shell 1 stopped, before shell 2 starts: {lab.host_view(host_b)}')
    shell_2 = lab.make_client('shell-2')[0]
    lab.launch(shell_2, env)
    lab.wait(lambda: lab.state(shell_2, env)['managed'])
    lab.wait(lambda: lab.ipc(host_b, 'repro', 'mapped', env) == 'true')
    print(f'  {lab.stamp()} shell 2 started: {short(lab.state(shell_2, env), KEYS)}; host B: {lab.host_view(host_b)}')
  finally:
    lab.close()


scenario(sys.argv[1], 3, 'late')
scenario(sys.argv[1], 0.2, 'early (control)')

Actual output:

== late: host B starts 3s after host A dies
  [  0.2s] shell 1 connected: managed=true barExclusion="Ignore" retryTicks=0; host A: host ready=True message='' snapshot screens=[''] size=26 surface mapped=true
  [  0.3s] host A killed; socket file left behind: True
  [  3.4s] host B listening
  [  9.4s] shell 1 six seconds later: managed=false barExclusion="Auto" retryTicks=9; host B: host ready=False message='Shell starting…' snapshot screens=[] size=0 surface mapped=false
  [ 10.0s] restart: shell 1 stopped, before shell 2 starts: host ready=False message='Shell restarting…' snapshot screens=[] size=0 surface mapped=false
  [ 10.2s] shell 2 started: managed=true barExclusion="Ignore" retryTicks=0; host B: host ready=True message='' snapshot screens=[''] size=26 surface mapped=true
== early (control): host B starts 0.2s after host A dies
  [  0.2s] shell 1 connected: managed=true barExclusion="Ignore" retryTicks=0; host A: host ready=True message='' snapshot screens=[''] size=26 surface mapped=true
  [  0.3s] host A killed; socket file left behind: True
  [  0.6s] host B listening
  [  6.6s] shell 1 six seconds later: managed=true barExclusion="Ignore" retryTicks=1; host B: host ready=True message='' snapshot screens=[''] size=26 surface mapped=true
  [  7.2s] restart: shell 1 stopped, before shell 2 starts: host ready=False message='Shell restarting…' snapshot screens=[''] size=26 surface mapped=true
  [  7.4s] shell 2 started: managed=true barExclusion="Ignore" retryTicks=0; host B: host ready=True message='' snapshot screens=[''] size=26 surface mapped=true

In the late case, retryTicks=9 counts timer ticks that start no connection. In the control, the first retry finds host B listening, and host B keeps the reservation through the restart.

Details

Verified (headless Quickshell 0.3.1 / Qt 6.11.2 sandbox, except items marked source):

  • The PR's changed tests pass at the head; the full test/shell.d failures at the head are unrelated to the PR.
  • Across a valid restart, the host keeps the old reservation with "Shell restarting…" and accepts the new shell at once.
  • A duplicate live owner is rejected without dropping the current reservation.
  • (source) quickshell kill -p "$CONFIG_DIR" matches only the main shell's config path, so restarts do not stop the host.
  • (source) ExclusionMode.Ignore gives exclusive zone -1, so the interactive bar overlays the host strip without adding to it.

Hypothesis, not reproduced: on SIGSEGV or SIGABRT, Quickshell's crash handler forks a core-dump child that keeps the old connection open, so the relaunched shell may be rejected as a duplicate and reserve its own zone until the next retry after the dump finishes. The same window already double-reserved before this PR, so this is a gap in the crash claim rather than a regression. The handler relaunches only after more than 10 s of uptime, and the acceptance test uses SIGKILL, which bypasses it. A kill -SEGV of the main shell after more than 10 s of uptime, in a VM with systemd-coredump, sampling geometry as the acceptance fixture does, would settle it.

Not reproduced (source only): omarchy-restart-shell:66 calls quickshell ipc -n without --any-display, so from an ssh session without the desktop's WAYLAND_DISPLAY the "restarting" announcement does not reach the host (the strip then reads "Shell unavailable").

Related open PRs: #13569 (floating bar) reserves barSize plus its floating gap, and #13138 adds the theme's edge margin, while the snapshot sends only barSize. #6501 (bar.screens) limits the bar to some monitors, but the snapshot lists every screen. #13628 reaps quickshell processes started without -p, which would include a crash-relaunched host.

Optional test improvement: 7 of 7 behavioural mutants pass the PR's tests (for example keeping the socket after a host failure, dropping the crashed/failed/restarting calls, or removing the duplicate-owner check); only the State.js control fails. Assertions on the logged ipc calls in the launcher and restart tests would cover the script mutants, and offscreen QML tests of BarReservation.qml and the host's ownership logic, as in the reproducers above, would cover the rest.


Review information

Test scope: Source, tests and headless sandbox runs at 7b0df32; no compositor or VM.

AI process: Opus 5.5 Medium coordination and synthesis, Opus 5.5 Xhigh technical review and final fact check, GPT 6 Sol Xhigh search for related issues, Opus 5.5 Medium editorial check.

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

@jkarmel
jkarmel force-pushed the fix/preserve-bar-space branch from 7b0df32 to bc68102 Compare September 30, 2026 21:06
@greptile-apps

greptile-apps Bot commented Sep 30, 2026 •

Copy link
Copy Markdown
Contributor

RetriggerConfidence Score: 5/5

[Medium risk] Adds bar space reservation during shell restart.

The PR appears safe to merge; no new actionable issue or outstanding previous finding was established.

Summary

The PR adds an independent reservation host so the built-in bar retains its exclusive zone while the interactive shell restarts. It also adds display-scoped restart handling, a bounded socket protocol, documentation, and lifecycle and graphical acceptance tests. The changes since the previous review narrow crash-reporter cleanup to the launcher exercised by the acceptance test.

Diagram
sequenceDiagram
  participant L as Shell launcher
  participant H as Reservation host
  participant B as Interactive bar
  L->>H: Start and verify readiness
  L->>B: Start with socket and launcher token
  B->>H: Publish bar snapshot
  H-->>B: Acknowledge reservation
  B->>B: Relinquish fallback zone
  B--xH: Disconnect during restart
  H->>H: Retain reservation
  L->>B: Relaunch interactive shell
  B->>H: Publish replacement snapshot
Loading

Reviews (3) · Last reviewed commit: "Limit acceptance cleanup to its own cras..."

Comment thread shell/services/BarReservation.qml Resolved
Comment thread shell/bar-reservation/shell.qml Resolved
Comment thread bin/omarchy-restart-shell Resolved
Comment thread shell/bar-reservation/State.js Resolved
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

enhancement New feature or request

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants