feat: mail finder

sims only invokes emacsclient (in modules/notmuch.py) and never the
full emacs binary. Bundling emacs onto the wrapper PATH was forcing
consumers to pull in an extra ~310M emacs closure (often a different
version from the user's actual editor). Rely on the consumer's
emacsclient via PATH, configurable via services.sims.settings.notmuch.emacsclient_command.

Makefile

@@ -0,0 +1,15 @@
+run:
+	python -m sims.main --config ./example-stylix-dev.yaml
+
+# Talk to the running sims daemon over DBus.
+# Usage: make cli list
+#        make cli finder
+#        make cli screenrec stop
+#        make cli ARGS="list --json"   # for flags (make eats leading dashes)
+ifeq (cli,$(firstword $(MAKECMDGOALS)))
+  CLI_ARGS := $(wordlist 2,$(words $(MAKECMDGOALS)),$(MAKECMDGOALS))
+  $(eval $(CLI_ARGS):;@:)
+endif
+
+cli:
+	@python -m sims.cli $(if $(ARGS),$(ARGS),$(CLI_ARGS))

README.md

@@ -1,3 +1,14 @@
 # Todo
+
+# Ideas
+## Org-mode integration
 - https://github.com/jlumpe/pyorg
 - https://github.com/jlumpe/ox-json
+## Emails not seen
+with notmuch
+## notch power bar
+- show the power around the notch
+- show watts charging/discharging in bar
+- https://lo.cafe/notchnook
+## Screenshot menu
+## Media Playing

bar/main.py

@@ -1,55 +0,0 @@
-from loguru import logger
-
-from fabric import Application
-from fabric.system_tray.widgets import SystemTray
-from fabric.widgets.wayland import WaylandWindow as Window
-from fabric.river.widgets import (
-    get_river_connection,
-)
-from fabric.utils import (
-    get_relative_path,
-)
-from .modules.bar import StatusBar
-from .modules.window_fuzzy import FuzzyWindowFinder
-
-
-tray = SystemTray(name="system-tray", spacing=4)
-river = get_river_connection()
-
-dummy = Window(visible=False)
-finder = FuzzyWindowFinder()
-
-bar_windows = []
-
-app = Application("bar", dummy, finder)
-app.set_stylesheet_from_file(get_relative_path("styles/main.css"))
-
-
-def spawn_bars():
-    logger.info("[Bar] Spawning bars after river ready")
-    outputs = river.outputs
-
-    if not outputs:
-        logger.warning("[Bar] No outputs found — skipping bar spawn")
-        return
-
-    output_ids = sorted(outputs.keys())
-
-    for i, output_id in enumerate(output_ids):
-        bar = StatusBar(display=output_id, tray=tray if i == 0 else None, monitor=i)
-        bar_windows.append(bar)
-
-    return False
-
-
-def main():
-    if river.ready:
-        spawn_bars()
-    else:
-        river.connect("notify::ready", lambda sender, pspec: spawn_bars())
-
-    app.run()
-
-
-if __name__ == "__main__":
-    main()

bar/modules/bar.py

@@ -1,133 +0,0 @@
-import psutil
-from fabric.widgets.box import Box
-from fabric.widgets.label import Label
-from fabric.widgets.overlay import Overlay
-from fabric.widgets.datetime import DateTime
-from fabric.widgets.centerbox import CenterBox
-from bar.modules.player import Player
-from bar.modules.vinyl import VinylButton
-from fabric.widgets.wayland import WaylandWindow as Window
-from fabric.system_tray.widgets import SystemTray
-from fabric.river.widgets import (
-    RiverWorkspaces,
-    RiverWorkspaceButton,
-    RiverActiveWindow,
-    get_river_connection,
-)
-from fabric.utils import (
-    invoke_repeater,
-)
-from fabric.widgets.circularprogressbar import CircularProgressBar
-
-from bar.config import VINYL
-
-
-class StatusBar(Window):
-    def __init__(
-        self,
-        display: int,
-        tray: SystemTray | None = None,
-        monitor: int = 1,
-        river_service=None,
-    ):
-        super().__init__(
-            name="bar",
-            layer="top",
-            anchor="left top right",
-            margin="0px 0px -2px 0px",
-            exclusivity="auto",
-            visible=False,
-            all_visible=False,
-            monitor=monitor,
-        )
-        if river_service:
-            self.river = river_service
-        else:
-            self.river = get_river_connection()
-
-        self.workspaces = RiverWorkspaces(
-            display,
-            name="workspaces",
-            spacing=4,
-            buttons_factory=lambda ws_id: RiverWorkspaceButton(id=ws_id, label=None),
-            river_service=self.river,
-        )
-        self.date_time = DateTime(name="date-time", formatters="%d %b - %H:%M")
-        self.system_tray = tray
-
-        self.active_window = RiverActiveWindow(
-            name="active-window",
-            max_length=50,
-            style="color: #ffffff; font-size: 14px; font-weight: bold;",
-        )
-
-        self.ram_progress_bar = CircularProgressBar(
-            name="ram-progress-bar", pie=True, size=24
-        )
-        self.cpu_progress_bar = CircularProgressBar(
-            name="cpu-progress-bar", pie=True, size=24
-        )
-
-        self.progress_label = Label(
-            "", style="margin: 0px 6px 0px 0px; font-size: 12px"
-        )
-        self.progress_bars_overlay = Overlay(
-            child=self.ram_progress_bar,
-            overlays=[self.cpu_progress_bar, self.progress_label],
-        )
-        self.player = Player()
-        self.vinyl = None
-        if VINYL["enable"]:
-            self.vinyl = VinylButton()
-
-        self.status_container = Box(
-            name="widgets-container",
-            spacing=4,
-            orientation="h",
-            children=self.progress_bars_overlay,
-        )
-
-        end_container_children = []
-
-        if self.vinyl:
-            end_container_children.append(self.vinyl)
-
-        end_container_children.append(self.status_container)
-        if self.system_tray:
-            end_container_children.append(self.system_tray)
-
-        end_container_children.append(self.date_time)
-
-        self.children = CenterBox(
-            name="bar-inner",
-            start_children=Box(
-                name="start-container",
-                spacing=6,
-                orientation="h",
-                children=[
-                    Label(name="nixos-label", markup=""),
-                    self.workspaces,
-                ],
-            ),
-            center_children=Box(
-                name="center-container",
-                spacing=4,
-                orientation="h",
-                children=[self.active_window],
-            ),
-            end_children=Box(
-                name="end-container",
-                spacing=4,
-                orientation="h",
-                children=end_container_children,
-            ),
-        )
-
-        invoke_repeater(1000, self.update_progress_bars)
-
-        self.show_all()
-
-    def update_progress_bars(self):
-        self.ram_progress_bar.value = psutil.virtual_memory().percent / 100
-        self.cpu_progress_bar.value = psutil.cpu_percent() / 100
-        return True

bar/modules/cavalcade.py

@@ -1,274 +0,0 @@
-import os
-import struct
-import subprocess
-import re
-import ctypes
-import signal
-
-from gi.repository import GLib, Gtk, Gdk
-from loguru import logger
-from math import pi
-
-from fabric.widgets.overlay import Overlay
-from fabric.utils.helpers import get_relative_path
-
-import configparser
-
-
-def get_bars(file_path):
-    config = configparser.ConfigParser()
-    config.read(file_path)
-    return int(config["general"]["bars"])
-
-
-CAVA_CONFIG = get_relative_path("../config/cavalcade/cava.ini")
-
-bars = get_bars(CAVA_CONFIG)
-
-
-def set_death_signal():
-    """
-    Set the death signal of the child process to SIGTERM so that if the parent
-    process is killed, the child (cava) is automatically terminated.
-    """
-    libc = ctypes.CDLL("libc.so.6")
-    PR_SET_PDEATHSIG = 1
-    libc.prctl(PR_SET_PDEATHSIG, signal.SIGTERM)
-
-
-class Cava:
-    """
-    CAVA wrapper.
-    Launch cava process with certain settings and read output.
-    """
-
-    NONE = 0
-    RUNNING = 1
-    RESTARTING = 2
-    CLOSING = 3
-
-    def __init__(self, mainapp):
-        self.bars = bars
-        self.path = "/tmp/cava.fifo"
-
-        self.cava_config_file = CAVA_CONFIG
-        self.data_handler = mainapp.draw.update
-        self.command = ["cava", "-p", self.cava_config_file]
-        self.state = self.NONE
-
-        self.env = dict(os.environ)
-        self.env["LC_ALL"] = "en_US.UTF-8"  # not sure if it's necessary
-
-        is_16bit = True
-        self.byte_type, self.byte_size, self.byte_norm = (
-            ("H", 2, 65535) if is_16bit else ("B", 1, 255)
-        )
-
-        if not os.path.exists(self.path):
-            os.mkfifo(self.path)
-
-        self.fifo_fd = None
-        self.fifo_dummy_fd = None
-        self.io_watch_id = None
-
-    def _run_process(self):
-        logger.debug("Launching cava process...")
-        try:
-            self.process = subprocess.Popen(
-                self.command,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                env=self.env,
-                preexec_fn=set_death_signal,  # Ensure cava gets killed when the parent dies.
-            )
-            logger.debug("cava successfully launched!")
-            self.state = self.RUNNING
-        except Exception:
-            logger.exception("Fail to launch cava")
-
-    def _start_io_reader(self):
-        logger.debug("Activating GLib IO watch for cava stream handler")
-        # Open FIFO in non-blocking mode for reading
-        self.fifo_fd = os.open(self.path, os.O_RDONLY | os.O_NONBLOCK)
-        # Open dummy write end to prevent getting an EOF on our FIFO
-        self.fifo_dummy_fd = os.open(self.path, os.O_WRONLY | os.O_NONBLOCK)
-        self.io_watch_id = GLib.io_add_watch(
-            self.fifo_fd, GLib.IO_IN, self._io_callback
-        )
-
-    def _io_callback(self, source, condition):
-        chunk = self.byte_size * self.bars  # number of bytes for given format
-        try:
-            data = os.read(self.fifo_fd, chunk)
-        except OSError as e:
-            # logger.error("Error reading FIFO: {}".format(e))
-            return False
-
-        # When no data is read, do not remove the IO watch immediately.
-        if len(data) < chunk:
-            # Instead of closing the FIFO, we log a warning and continue.
-            # logger.warning("Incomplete data packet received (expected {} bytes, got {}). Waiting for more data...".format(chunk, len(data)))
-            # Returning True keeps the IO watch active. A real EOF will only occur when the writer closes.
-            return True
-
-        fmt = self.byte_type * self.bars  # format string for struct.unpack
-        sample = [i / self.byte_norm for i in struct.unpack(fmt, data)]
-        GLib.idle_add(self.data_handler, sample)
-        return True
-
-    def _on_stop(self):
-        logger.debug("Cava stream handler deactivated")
-        if self.state == self.RESTARTING:
-            self.start()
-        elif self.state == self.RUNNING:
-            self.state = self.NONE
-            logger.error("Cava process was unexpectedly terminated.")
-            # self.restart()  # May cause infinity loop, need more check
-
-    def start(self):
-        """Launch cava"""
-        self._start_io_reader()
-        self._run_process()
-
-    def restart(self):
-        """Restart cava process"""
-        if self.state == self.RUNNING:
-            logger.debug("Restarting cava process (normal mode) ...")
-            self.state = self.RESTARTING
-            if self.process.poll() is None:
-                self.process.kill()
-        elif self.state == self.NONE:
-            logger.warning("Restarting cava process (after crash) ...")
-            self.start()
-
-    def close(self):
-        """Stop cava process"""
-        self.state = self.CLOSING
-        if self.process.poll() is None:
-            self.process.kill()
-        if self.io_watch_id:
-            GLib.source_remove(self.io_watch_id)
-        if self.fifo_fd:
-            os.close(self.fifo_fd)
-        if self.fifo_dummy_fd:
-            os.close(self.fifo_dummy_fd)
-        if os.path.exists(self.path):
-            os.remove(self.path)
-
-
-class AttributeDict(dict):
-    """Dictionary with keys as attributes. Does nothing but easy reading"""
-
-    def __getattr__(self, attr):
-        return self.get(attr, 3)
-
-    def __setattr__(self, attr, value):
-        self[attr] = value
-
-
-class Spectrum:
-    """Spectrum drawing"""
-
-    def __init__(self):
-        self.silence_value = 0
-        self.audio_sample = []
-        self.color = None
-
-        self.area = Gtk.DrawingArea()
-        self.area.connect("draw", self.redraw)
-        self.area.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
-
-        self.sizes = AttributeDict()
-        self.sizes.area = AttributeDict()
-        self.sizes.bar = AttributeDict()
-
-        self.silence = 10
-        self.max_height = 12
-
-        self.area.connect("configure-event", self.size_update)
-        self.color_update()
-
-    def is_silence(self, value):
-        """Check if volume level critically low during last iterations"""
-        self.silence_value = 0 if value > 0 else self.silence_value + 1
-        return self.silence_value > self.silence
-
-    def update(self, data):
-        """Audio data processing"""
-        self.color_update()
-        self.audio_sample = data
-        if not self.is_silence(self.audio_sample[0]):
-            self.area.queue_draw()
-        elif self.silence_value == (self.silence + 1):
-            self.audio_sample = [0] * self.sizes.number
-            self.area.queue_draw()
-
-    def redraw(self, widget, cr):
-        """Draw spectrum graph"""
-        cr.set_source_rgba(*self.color)
-        dx = 3
-
-        center_y = self.sizes.area.height / 2  # center vertical of the drawing area
-        for i, value in enumerate(self.audio_sample):
-            width = self.sizes.area.width / self.sizes.number - self.sizes.padding
-            radius = width / 2
-            height = max(self.sizes.bar.height * min(value, 1), self.sizes.zero) / 2
-            if height == self.sizes.zero / 2 + 1:
-                height *= 0.5
-
-            height = min(height, self.max_height)
-
-            # Draw rectangle and arcs for rounded ends
-            cr.rectangle(dx, center_y - height, width, height * 2)
-            cr.arc(dx + radius, center_y - height, radius, 0, 2 * pi)
-            cr.arc(dx + radius, center_y + height, radius, 0, 2 * pi)
-
-            cr.close_path()
-            dx += width + self.sizes.padding
-        cr.fill()
-
-    def size_update(self, *args):
-        """Update drawing geometry"""
-        self.sizes.number = bars
-        self.sizes.padding = 100 / bars
-        self.sizes.zero = 0
-
-        self.sizes.area.width = self.area.get_allocated_width()
-        self.sizes.area.height = self.area.get_allocated_height() - 2
-
-        tw = self.sizes.area.width - self.sizes.padding * (self.sizes.number - 1)
-        self.sizes.bar.width = max(int(tw / self.sizes.number), 1)
-        self.sizes.bar.height = self.sizes.area.height
-
-    def color_update(self):
-        """Set drawing color according to current settings by reading primary color from CSS"""
-        color = "#a5c8ff"  # default value
-        try:
-            with open(get_relative_path("../styles/colors.css"), "r") as f:
-                content = f.read()
-                m = re.search(r"--primary:\s*(#[0-9a-fA-F]{6})", content)
-                if m:
-                    color = m.group(1)
-        except Exception as e:
-            logger.error("Failed to read primary color: {}".format(e))
-        red = int(color[1:3], 16) / 255
-        green = int(color[3:5], 16) / 255
-        blue = int(color[5:7], 16) / 255
-        self.color = Gdk.RGBA(red=red, green=green, blue=blue, alpha=1.0)
-
-
-class SpectrumRender:
-    def __init__(self, mode=None, **kwargs):
-        super().__init__(**kwargs)
-        self.mode = mode
-
-        self.draw = Spectrum()
-        self.cava = Cava(self)
-        self.cava.start()
-
-    def get_spectrum_box(self):
-        # Get the spectrum box
-        box = Overlay(name="cavalcade", h_align="center", v_align="center")
-        box.set_size_request(180, 40)
-        box.add_overlay(self.draw.area)
-        return box

bar/modules/window_fuzzy.py

@@ -1,75 +0,0 @@
-import operator
-from fabric.widgets.wayland import WaylandWindow as Window
-from fabric.widgets.box import Box
-from fabric.widgets.label import Label
-from fabric.widgets.entry import Entry
-from fabric.utils import idle_add
-from gi.repository import Gdk
-
-
-class FuzzyWindowFinder(Window):
-    def __init__(
-        self,
-        monitor: int = 0,
-    ):
-        super().__init__(
-            name="finder",
-            anchor="center",
-            monitor=monitor,
-            keyboard_mode="on-demand",
-            type="popup",
-            visible=False,
-        )
-
-        self._all_windows = ["Test", "Uwu", "Tidal"]
-
-        self.viewport = Box(name="viewport", spacing=4, orientation="v")
-
-        self.search_entry = Entry(
-            name="search-entry",
-            placeholder="Search Windows...",
-            h_expand=True,
-            editable=True,
-            notify_text=self.notify_text,
-            on_activate=lambda entry, *_: self.on_search_entry_activate(
-                entry.get_text()
-            ),
-            on_key_press_event=self.on_search_entry_key_press,
-        )
-        self.picker_box = Box(
-            name="picker-box",
-            spacing=4,
-            orientation="v",
-            children=[self.search_entry, self.viewport],
-        )
-
-        self.add(self.picker_box)
-        self.arrange_viewport("")
-
-    def notify_text(self, entry, *_):
-        text = entry.get_text()
-        self.arrange_viewport(text)  # Update list on typing
-        print(text)
-
-    def on_search_entry_key_press(self, widget, event):
-        # if event.keyval in (Gdk.KEY_Up, Gdk.KEY_Down, Gdk.KEY_Left, Gdk.KEY_Right):
-        #     self.move_selection_2d(event.keyval)
-        #     return True
-        print(event.keyval)
-        if event.keyval in [Gdk.KEY_Escape, 103]:
-            self.hide()
-            return True
-        return False
-
-    def on_search_entry_activate(self, text):
-        print(f"activate {text}")
-
-    def arrange_viewport(self, query: str = ""):
-        self.viewport.children = []  # Clear previous entries
-
-        filtered = [w for w in self._all_windows if query.lower() in w.lower()]
-
-        for window in filtered:
-            self.viewport.add(
-                Box(name="slot-box", orientation="h", children=[Label(label=window)])
-            )

bar/styles/bar.css

@@ -1,51 +0,0 @@
-#bar-inner {
-    padding: 4px;
-    border-bottom: solid 2px;
-    border-color: var(--border-color);
-    background-color: var(--window-bg);
-    min-height: 28px;
-}
-
-#center-container {
-  color: var(--foreground);
-}
-
-.active-window {
-  color: var(--foreground);
-  font-weight: bold;
-}
-
-#cpu-progress-bar,
-#ram-progress-bar,
-#volume-progress-bar {
-    color: transparent;
-    background-color: transparent
-}
-
-#cpu-progress-bar {
-    border: solid 0px alpha(var(--violet), 0.8);
-}
-
-#ram-progress-bar,
-#volume-progress-bar {
-    border: solid 0px var(--blue);
-}
-
-#widgets-container {
-    background-color: var(--module-bg);
-    padding: 2px;
-}
-
-#nixos-label {
-    color: var(--blue);
-}
-
-tooltip {
-    border: solid 2px;
-    border-color: var(--border-color);
-    background-color: var(--window-bg);
-}
-
-tooltip>* {
-    padding: 2px 4px
-}

bar/styles/finder.css

@@ -1,29 +0,0 @@
-#picker-box {
-    padding: 12px;
-    background-color: rgba(40, 40, 40, 0.95);  /* darker for contrast */
-    border-radius: 8px;
-    font-family: sans-serif;
-    font-size: 14px;
-    color: white;
-}
-
-
-#viewport {
-    padding: 8px;
-    background-color: rgba(30, 30, 30, 0.9); /* dark background for contrast */
-    border-radius: 6px;
-    font-family: sans-serif;
-    font-size: 14px;
-    color: white; /* ensure contrast */
-}
-
-#viewport > * {
-    padding: 6px 10px;
-    margin-bottom: 4px;
-    border-radius: 4px;
-    background-color: rgba(255, 255, 255, 0.05);
-}
-
-#viewport:hover {
-    background-color: rgba(255, 255, 255, 0.15); /* hover feedback */
-}

bar/styles/vinyl.css

@@ -1,41 +0,0 @@
-/* Vinyl button styling */
-#vinyl-button {
-    padding: 0px 8px;
-    transition: padding 0.05s steps(8);
-    background-color: rgba(180, 180, 180, 0.2);
-    border-radius: 4px;
-    transition: all 0.2s ease;
-}
-
-/* Active state styling */
-.active #vinyl-button {
-    background-color: rgba(108, 158, 175, 0.7);
-    padding: 0px 32px;
-}
-
-/* Icon styling */
-#vinyl-icon {
-    color: #555555;
-    min-width: 36px;
-}
-
-/* Label styling */
-#vinyl-label {
-    color: #333333;
-}
-
-/* Active state changes for icon and label */
-.active #vinyl-icon,
-.active #vinyl-label {
-    color: var(--pink);
-    padding: 0px 32px;
-}
-
-/* Hover effect */
-#vinyl-button:hover {
-    background-color: rgba(180, 180, 180, 0.4);
-}
-
-.active #vinyl-button:hover {
-    background-color: rgba(108, 158, 175, 0.9);
-}

example-stylix-dev.yaml

@@ -0,0 +1,55 @@
+height: 42
+dev: true
+window_title:
+    enable: true
+vinyl:
+    enable: true
+battery:
+    enable: true
+calendar:
+    enable: true
+    khal_path: "khal"  # or full path like "/home/user/.nix-profile/bin/khal"
+notmuch:
+    enable: true
+    notmuch_path: "notmuch"  # or full path like "/home/user/.nix-profile/bin/notmuch"
+    emacsclient_command: "emacsclient"  # or full path like "/home/user/.nix-profile/bin/emacsclient"
+screenrec:
+    enable: true
+    output_dir: "~/Videos/wl-screenrec"
+notifications:
+    enable: true
+    anchor: "top center"
+    margin: "8px"
+    width: 360
+    timeout_ms: 10000
+    history_size: 50
+    image_max_px: 128
+    center_width: 380
+stylix:
+    enable: true
+    colors:
+        base00: "1e1e2e"  # background
+        base01: "313244"  # lighter background
+        base02: "45475a"  # selection background
+        base03: "585b70"  # comments
+        base04: "bac2de"  # dark foreground
+        base05: "cdd6f4"  # foreground
+        base06: "f5e0dc"  # light foreground
+        base07: "b4befe"  # light background
+        base08: "f38ba8"  # red
+        base09: "fab387"  # orange
+        base0A: "f9e2af"  # yellow
+        base0B: "a6e3a1"  # green
+        base0C: "94e2d5"  # cyan
+        base0D: "89b4fa"  # blue
+        base0E: "cba6f7"  # purple
+        base0F: "f2cdcd"  # brown
+    fonts:
+        sansSerif: "Inter"
+        serif: "Times New Roman"
+        monospace: "JetBrains Mono"
+        sizes:
+            desktop: 16
+            applications: 14
+            terminal: 16
+            popups: 14

example.yaml

@@ -1,2 +1,7 @@
+bar_height: 42
+window_title:
+    enable: false
 vinyl:
-    enabled: true
+    enable: true
+battery:
+    enable: true

flake.lock

@@ -6,15 +6,15 @@
         "utils": "utils"
       },
       "locked": {
-        "lastModified": 1747045720,
-        "narHash": "sha256-2Z0F4hnluJZunwRfx80EQXpjGLhunV2wrseT42nzh7M=",
-        "owner": "Makesesama",
+        "lastModified": 1770146720,
+        "narHash": "sha256-YVlwsUz4SLj8qYAb21ernT3lDB/piU1V6hTW/UjikWA=",
+        "owner": "Fabric-Development",
         "repo": "fabric",
-        "rev": "dae50c763e8bf2b4e5807b49b9e62425e0725cfa",
+        "rev": "fd2aabbd7e1859aa7c11c626a6c36a937aca736a",
         "type": "github"
       },
       "original": {
-        "owner": "Makesesama",
+        "owner": "Fabric-Development",
         "repo": "fabric",
         "type": "github"
       }

flake.nix

@@ -1,11 +1,11 @@
 {
-  description = "Fabric Bar Example";
+  description = "sims status bar (companion to fenster WM).";
 
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/24.11";
     unstable.url = "github:NixOS/nixpkgs/nixos-unstable";
     utils.url = "github:numtide/flake-utils";
-    fabric.url = "github:Makesesama/fabric";
+    fabric.url = "github:Fabric-Development/fabric";
     home-manager.url = "github:nix-community/home-manager";
     home-manager.inputs.nixpkgs.follows = "nixpkgs";
   };
@@ -32,20 +32,19 @@
       {
         formatter = pkgs.nixfmt-rfc-style;
         devShells.default = pkgs.callPackage ./nix/shell.nix { inherit pkgs; };
-        packages = {
+        packages = rec {
           default = pkgs.callPackage ./nix/derivation.nix { inherit (pkgs) lib python3Packages; };
-          makku = pkgs.writeShellScriptBin "makku" ''
-            dbus-send --session --print-reply --dest=org.Fabric.fabric.bar  /org/Fabric/fabric org.Fabric.fabric.Evaluate string:"finder.show()" > /dev/null 2>&1
-          '';
+          sims = default;
         };
         apps.default = {
           type = "app";
-          program = "${self.packages.${system}.default}/bin/bar";
+          program = "${self.packages.${system}.default}/bin/sims";
         };
       }
     )
     // {
-      homeManagerModules.makku-bar =
+      homeManagerModules = {
+        sims =
         {
           config,
           lib,
@@ -53,18 +52,18 @@
           ...
         }:
         let
-          cfg = config.services.makku-bar;
+          cfg = config.services.sims;
 
           settingsFormat = pkgs.formats.yaml { };
         in
         {
-          options.services.makku-bar = {
-            enable = lib.mkEnableOption "makku-bar status bar";
+          options.services.sims = {
+            enable = lib.mkEnableOption "sims status bar";
 
             package = lib.mkOption {
               type = lib.types.package;
               default = self.packages.${pkgs.system}.default;
-              description = "The makku-bar package to use.";
+              description = "The sims package to use.";
             };
 
             settings = lib.mkOption {
@@ -76,27 +75,211 @@
                       default = false;
                     };
                   };
+                  battery = {
+                    enable = lib.mkOption {
+                      type = lib.types.bool;
+                      default = false;
+                    };
+                  };
+                  height = lib.mkOption {
+                    type = lib.types.int;
+                    default = 40;
+                    description = "Height of the status bar in pixels";
+                  };
+                  logLevel = lib.mkOption {
+                    type = lib.types.enum [ "TRACE" "DEBUG" "INFO" "SUCCESS" "WARNING" "ERROR" "CRITICAL" ];
+                    default = "WARNING";
+                    description = "Log level for the status bar (loguru levels: TRACE, DEBUG, INFO, SUCCESS, WARNING, ERROR, CRITICAL)";
+                  };
+                  window_title = {
+                    enable = lib.mkOption {
+                      type = lib.types.bool;
+                      default = true;
+                      description = "Whether to show the window title in the center of the bar";
+                    };
+                  };
+                  stylix = lib.mkOption {
+                    type = lib.types.attrsOf lib.types.anything;
+                    default = { enable = false; };
+                    description = "Stylix configuration passed from the stylix module";
+                  };
+                  calendar = {
+                    enable = lib.mkOption {
+                      type = lib.types.bool;
+                      default = true;
+                      description = "Whether to enable the calendar widget";
+                    };
+                    khal_path = lib.mkOption {
+                      type = lib.types.str;
+                      default = "khal";
+                      description = "Path to the khal binary";
+                    };
+                  };
+                  notmuch = {
+                    enable = lib.mkOption {
+                      type = lib.types.bool;
+                      default = true;
+                      description = "Whether to enable the notmuch email widget";
+                    };
+                    notmuch_path = lib.mkOption {
+                      type = lib.types.str;
+                      default = "notmuch";
+                      description = "Path to the notmuch binary";
+                    };
+                    emacsclient_command = lib.mkOption {
+                      type = lib.types.str;
+                      default = "emacsclient";
+                      description = "Path to the emacsclient binary";
+                    };
+                    debt_query = lib.mkOption {
+                      type = lib.types.str;
+                      default = "tag:unread and date:..1w";
+                      description = "notmuch query whose count drives the mail-debt severity color on the bar widget";
+                    };
+                    debt_warn_at = lib.mkOption {
+                      type = lib.types.int;
+                      default = 1;
+                      description = "Debt count at which the widget switches to the warn (orange) color";
+                    };
+                    debt_alarm_at = lib.mkOption {
+                      type = lib.types.int;
+                      default = 6;
+                      description = "Debt count at which the widget switches to the alarm (red) color";
+                    };
+                    saved_searches = lib.mkOption {
+                      type = lib.types.listOf (lib.types.submodule {
+                        options = {
+                          name = lib.mkOption {
+                            type = lib.types.str;
+                            description = "Display label shown in the search launcher";
+                          };
+                          query = lib.mkOption {
+                            type = lib.types.str;
+                            description = "notmuch query to run when this saved search is activated";
+                          };
+                        };
+                      });
+                      default = [ ];
+                      description = "Saved searches shown in the notmuch search launcher when the entry is empty";
+                    };
+                  };
+                  screenrec = {
+                    enable = lib.mkOption {
+                      type = lib.types.bool;
+                      default = false;
+                      description = "Whether to enable the screenrec widget and menu";
+                    };
+                    output_dir = lib.mkOption {
+                      type = lib.types.str;
+                      default = "~/Videos/wl-screenrec";
+                      description = "Directory to save recordings into";
+                    };
+                  };
+                  power = {
+                    lock_command = lib.mkOption {
+                      type = lib.types.listOf lib.types.str;
+                      default = [ "waylock" ];
+                      description = "argv for the Lock action in the power menu";
+                    };
+                  };
+                  notifications = {
+                    enable = lib.mkOption {
+                      type = lib.types.bool;
+                      default = false;
+                      description = "Whether to enable the notification toast service. Owns org.freedesktop.Notifications, so other notification daemons (mako, dunst, swaync) must be disabled.";
+                    };
+                    anchor = lib.mkOption {
+                      type = lib.types.str;
+                      default = "top center";
+                      description = "Layer-shell anchor for the toast stack";
+                    };
+                    margin = lib.mkOption {
+                      type = lib.types.str;
+                      default = "8px";
+                      description = "Layer-shell margin for the toast stack";
+                    };
+                    width = lib.mkOption {
+                      type = lib.types.int;
+                      default = 360;
+                      description = "Width of each notification toast in pixels";
+                    };
+                    timeout_ms = lib.mkOption {
+                      type = lib.types.int;
+                      default = 10000;
+                      description = "Auto-close timeout for notifications in milliseconds";
+                    };
+                    history_size = lib.mkOption {
+                      type = lib.types.int;
+                      default = 50;
+                      description = "How many past notifications the in-memory center keeps";
+                    };
+                    image_max_px = lib.mkOption {
+                      type = lib.types.int;
+                      default = 128;
+                      description = "Max edge in pixels for stored notification thumbnails";
+                    };
+                    center_width = lib.mkOption {
+                      type = lib.types.int;
+                      default = 380;
+                      description = "Width of the notification center side rail in pixels";
+                    };
+                  };
                 };
               };
               default = {
                 vinyl.enable = false;
+                battery.enable = false;
+                height = 40;
+                logLevel = "WARNING";
+                window_title.enable = true;
+                stylix.enable = false;
+                calendar = {
+                  enable = true;
+                  khal_path = "khal";
+                };
+                notmuch = {
+                  enable = true;
+                  notmuch_path = "notmuch";
+                  emacsclient_command = "emacsclient";
+                  debt_query = "tag:unread and date:..1w";
+                  debt_warn_at = 1;
+                  debt_alarm_at = 6;
+                  saved_searches = [ ];
+                };
+                screenrec = {
+                  enable = false;
+                  output_dir = "~/Videos/wl-screenrec";
+                };
+                power = {
+                  lock_command = [ "waylock" ];
+                };
+                notifications = {
+                  enable = false;
+                  anchor = "top center";
+                  margin = "8px";
+                  width = 360;
+                  timeout_ms = 10000;
+                  history_size = 50;
+                  image_max_px = 128;
+                  center_width = 380;
+                };
               };
             };
           };
 
-          config = lib.mkIf config.services.makku-bar.enable {
-            systemd.user.services.makku-bar =
+          config = lib.mkIf config.services.sims.enable {
+            systemd.user.services.sims =
               let
                 configFile = settingsFormat.generate "config.yaml" cfg.settings;
               in
               {
                 Unit = {
-                  Description = "Makku Status Bar";
+                  Description = "sims status bar";
                   After = [ "graphical-session.target" ];
                 };
 
                 Service = {
-                  ExecStart = "${config.services.makku-bar.package}/bin/bar --config ${configFile}";
+                  ExecStart = "${config.services.sims.package}/bin/sims --config ${configFile}";
                   Restart = "on-failure";
                 };
 
@@ -106,5 +289,7 @@
               };
           };
         };
+        stylix-sims = import ./nix/stylix/hm.nix;
+      };
     };
 }

nix/derivation.nix

@@ -12,11 +12,14 @@
   wrapGAppsHook3,
   playerctl,
   webp-pixbuf-loader,
+  notmuch,
+  khal,
+  dbus,
   ...
 }:
 
 python3Packages.buildPythonApplication {
-  pname = "fabric-nix-example";
+  pname = "sims";
   version = "0.0.1";
   pyproject = true;
 
@@ -38,6 +41,8 @@ python3Packages.buildPythonApplication {
     gdk-pixbuf
     playerctl
     webp-pixbuf-loader
+    notmuch
+    khal
   ];
 
   dependencies = with python3Packages; [
@@ -53,24 +58,38 @@ python3Packages.buildPythonApplication {
     runHook preInstall
 
     mkdir -p $out/${python3Packages.python.sitePackages}
-    cp -r bar $out/${python3Packages.python.sitePackages}/
+    cp -r sims $out/${python3Packages.python.sitePackages}/
 
     # If you have any scripts to install
     mkdir -p $out/bin
-    cp scripts/launcher.py $out/bin/bar
-    chmod +x $out/bin/bar
+    cp scripts/launcher.py $out/bin/sims
+    chmod +x $out/bin/sims
+    cp scripts/cli_launcher.py $out/bin/sims-cli
+    chmod +x $out/bin/sims-cli
+
 
     runHook postInstall
   '';
 
   preFixup = ''
     makeWrapperArgs+=("''${gappsWrapperArgs[@]}")
+    makeWrapperArgs+=(--prefix PATH : ${
+      lib.makeBinPath [
+        khal
+        notmuch
+        dbus
+      ]
+    })
   '';
 
+  passthru = {
+    inherit khal notmuch;
+  };
+
   meta = {
     changelog = "";
     description = ''
-      Fabrix Bar Example
+      sims status bar (companion to fenster WM).
     '';
     homepage = "https://github.com/wholikeel/fabric";
     license = lib.licenses.agpl3Only;

nix/shell.nix

@@ -22,6 +22,7 @@ pkgs.mkShell {
     gobject-introspection
     libdbusmenu-gtk3
     gdk-pixbuf
+    librsvg
     gnome-bluetooth
     cinnamon-desktop
     wayland-scanner
@@ -46,4 +47,8 @@ pkgs.mkShell {
       ]
     ))
   ];
+
+  shellHook = ''
+    export GDK_PIXBUF_MODULE_FILE=${pkgs.librsvg}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
+  '';
 }

nix/stylix/hm.nix

@@ -0,0 +1,44 @@
+{ config, lib, ... }:
+
+let
+  cfg = config.stylix.targets.sims;
+in
+{
+  options.stylix.targets.sims.enable =
+    config.lib.stylix.mkEnableTarget "sims" true;
+
+  config = lib.mkIf (config.stylix.enable && cfg.enable) {
+    services.sims.settings.stylix = {
+      enable = true;
+      colors = {
+        base00 = config.lib.stylix.colors.base00; # background
+        base01 = config.lib.stylix.colors.base01; # lighter background
+        base02 = config.lib.stylix.colors.base02; # selection background
+        base03 = config.lib.stylix.colors.base03; # comments
+        base04 = config.lib.stylix.colors.base04; # dark foreground
+        base05 = config.lib.stylix.colors.base05; # foreground
+        base06 = config.lib.stylix.colors.base06; # light foreground
+        base07 = config.lib.stylix.colors.base07; # light background
+        base08 = config.lib.stylix.colors.base08; # red
+        base09 = config.lib.stylix.colors.base09; # orange
+        base0A = config.lib.stylix.colors.base0A; # yellow
+        base0B = config.lib.stylix.colors.base0B; # green
+        base0C = config.lib.stylix.colors.base0C; # cyan
+        base0D = config.lib.stylix.colors.base0D; # blue
+        base0E = config.lib.stylix.colors.base0E; # purple
+        base0F = config.lib.stylix.colors.base0F; # brown
+      };
+      fonts = {
+        serif = config.stylix.fonts.serif.name;
+        sansSerif = config.stylix.fonts.sansSerif.name;
+        monospace = config.stylix.fonts.monospace.name;
+        sizes = {
+          desktop = config.stylix.fonts.sizes.desktop;
+          applications = config.stylix.fonts.sizes.applications;
+          terminal = config.stylix.fonts.sizes.terminal;
+          popups = config.stylix.fonts.sizes.popups;
+        };
+      };
+    };
+  };
+}

nix/stylix/meta.nix

@@ -0,0 +1,6 @@
+{ lib }:
+{
+  name = "Makku Bar";
+  homepage = "https://github.com/Makesesama/makku-bar";
+  maintainers = [ ];
+}

pyproject.toml

@@ -3,14 +3,14 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "fabric-nix-example"
+name = "sims"
 version = "0.0.1"
 requires-python = ">= 3.11"
 authors = [
 ]
 maintainers = [
 ]
-description = "Fabric using Nix example."
+description = "sims status bar (companion to fenster WM)."
 readme = "README.md"
 license = {file = "LICENSE"}
 

scripts/cli_launcher.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+import os
+import sys
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+site_packages_dir = os.path.join(
+    script_dir,
+    os.pardir,
+    "lib",
+    f"python{sys.version_info.major}.{sys.version_info.minor}",
+    "site-packages",
+)
+
+if site_packages_dir not in sys.path:
+    sys.path.insert(0, site_packages_dir)
+
+from sims.cli import main
+
+sys.argv[0] = os.path.join(script_dir, os.path.basename(__file__))
+sys.exit(main())

scripts/launcher.py

@@ -15,7 +15,7 @@ if site_packages_dir not in sys.path:
     sys.path.insert(0, site_packages_dir)
 
 
-from bar.main import *
+from sims.main import *
 
 sys.argv[0] = os.path.join(script_dir, os.path.basename(__file__))
 sys.exit(main())

sims/cli.py

@@ -0,0 +1,171 @@
+"""sims-cli — talk to the running sims status bar over DBus."""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from typing import Callable
+
+DEST = "org.Fabric.fabric.sims"
+OBJ = "/org/Fabric/fabric"
+IFACE = "org.Fabric.fabric"
+
+
+def _dbus_send(*args: str) -> str:
+    proc = subprocess.run(
+        ["dbus-send", "--session", "--print-reply", f"--dest={DEST}", OBJ, *args],
+        capture_output=True,
+        text=True,
+    )
+    if proc.returncode != 0:
+        sys.stderr.write(proc.stderr)
+        sys.exit(proc.returncode)
+    return proc.stdout
+
+
+def invoke_action(action: str) -> None:
+    _dbus_send(f"{IFACE}.InvokeAction", f"string:{action}", "array:string:")
+
+
+_ACTION_RE = re.compile(r'dict entry\(\s*string "([^"]+)"')
+
+
+def list_actions() -> list[str]:
+    out = _dbus_send(
+        "org.freedesktop.DBus.Properties.Get",
+        f"string:{IFACE}",
+        "string:Actions",
+    )
+    return _ACTION_RE.findall(out)
+
+
+@dataclass
+class Command:
+    name: str
+    help: str
+    run: Callable[[argparse.Namespace], None]
+
+
+def _action(name: str) -> Callable[[argparse.Namespace], None]:
+    return lambda _ns: invoke_action(name)
+
+
+COMMANDS: list[Command] = [
+    Command("finder", "open window finder", _action("open-finder")),
+    Command("apps", "open application launcher", _action("open-app-launcher")),
+    Command("clipboard", "open clipboard history picker", _action("open-clipboard-menu")),
+    Command("power", "open power menu", _action("open-power-menu")),
+    Command("screenshot", "open screenshot menu", _action("open-screenshot-menu")),
+    Command("notmuch-refresh", "refresh unread mail count", _action("refresh-notmuch")),
+]
+
+
+def _cmd_screenrec(ns: argparse.Namespace) -> None:
+    mapping = {
+        "menu": "open-screenrec-menu",
+        "start-monitor": "screenrec-start-monitor",
+        "start-region": "screenrec-start-region",
+        "stop": "screenrec-stop",
+    }
+    invoke_action(mapping[ns.screenrec_cmd])
+
+
+def _cmd_mail(ns: argparse.Namespace) -> None:
+    mapping = {
+        "search": "open-notmuch-search",
+        "refresh": "refresh-notmuch",
+    }
+    invoke_action(mapping[ns.mail_cmd])
+
+
+def _cmd_corners(ns: argparse.Namespace) -> None:
+    mapping = {
+        "rounded": "set-bar-corners-rounded",
+        "flat": "set-bar-corners-flat",
+        "toggle": "toggle-bar-corners",
+    }
+    invoke_action(mapping[ns.corners_cmd])
+
+
+def _cmd_list(ns: argparse.Namespace) -> None:
+    actions = list_actions()
+    if ns.json:
+        json.dump(actions, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+    else:
+        for a in actions:
+            print(a)
+
+
+def _cmd_invoke(ns: argparse.Namespace) -> None:
+    invoke_action(ns.action)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="sims-cli",
+        description="Talk to the running sims status bar over DBus.",
+    )
+    sub = parser.add_subparsers(dest="cmd", required=True, metavar="COMMAND")
+
+    for cmd in COMMANDS:
+        p = sub.add_parser(cmd.name, help=cmd.help)
+        p.set_defaults(func=cmd.run)
+
+    rec = sub.add_parser("screenrec", help="screen recording controls")
+    rec_sub = rec.add_subparsers(dest="screenrec_cmd", required=True, metavar="ACTION")
+    for sub_name, sub_help in [
+        ("menu", "open screenrec menu (auto-detects state)"),
+        ("start-monitor", "start recording the focused monitor"),
+        ("start-region", "start recording a slurp-selected region"),
+        ("stop", "stop active recording"),
+    ]:
+        rec_sub.add_parser(sub_name, help=sub_help)
+    rec.set_defaults(func=_cmd_screenrec)
+
+    mail = sub.add_parser("mail", help="notmuch mail controls")
+    mail_sub = mail.add_subparsers(dest="mail_cmd", required=True, metavar="ACTION")
+    for sub_name, sub_help in [
+        ("search", "open the live notmuch search launcher"),
+        ("refresh", "refresh the bar's unread/debt counts"),
+    ]:
+        mail_sub.add_parser(sub_name, help=sub_help)
+    mail.set_defaults(func=_cmd_mail)
+
+    corners = sub.add_parser("corners", help="bar bottom-corner rounding")
+    corners_sub = corners.add_subparsers(
+        dest="corners_cmd", required=True, metavar="STATE"
+    )
+    for sub_name, sub_help in [
+        ("rounded", "round the bar's bottom corners"),
+        ("flat", "remove rounding (current default look)"),
+        ("toggle", "flip the current rounding state"),
+    ]:
+        corners_sub.add_parser(sub_name, help=sub_help)
+    corners.set_defaults(func=_cmd_corners)
+
+    lst = sub.add_parser("list", help="list registered actions")
+    lst.add_argument("--json", action="store_true", help="emit JSON array")
+    lst.set_defaults(func=_cmd_list)
+
+    inv = sub.add_parser(
+        "invoke",
+        help="invoke a raw action by name (escape hatch for actions without a dedicated subcommand)",
+    )
+    inv.add_argument("action", help="dbus action name, e.g. open-finder")
+    inv.set_defaults(func=_cmd_invoke)
+
+    return parser
+
+
+def main() -> None:
+    parser = build_parser()
+    ns = parser.parse_args()
+    ns.func(ns)
+
+
+if __name__ == "__main__":
+    main()

sims/config.py

@@ -4,7 +4,7 @@ from platformdirs import user_config_dir
 import argparse
 
 
-APP_NAME = "makku_bar"
+APP_NAME = "sims"
 
 XDG_CONFIG_HOME = user_config_dir(appname=APP_NAME)
 XDG_CONFIG_FILE = os.path.join(XDG_CONFIG_HOME, "config.yaml")
@@ -32,7 +32,7 @@ def load_config(config_path=XDG_CONFIG_FILE):
 
 
 def load_args():
-    parser = argparse.ArgumentParser(description="makku_bar")
+    parser = argparse.ArgumentParser(description="sims")
     parser.add_argument(
         "-c",
         "--config",
@@ -50,3 +50,29 @@ if app_config is None:
     raise Exception("Config file missing")
 
 VINYL = app_config.get("vinyl", {"enable": False})
+BATTERY = app_config.get("battery", {"enable": False})
+WINDOW_TITLE = app_config.get("window_title", {"enable": True})
+STYLIX = app_config.get("stylix", {"enable": False})
+CALENDAR = app_config.get("calendar", {"enable": True, "khal_path": "khal"})
+NOTMUCH = app_config.get("notmuch", {"enable": True, "notmuch_path": "notmuch", "emacsclient_command": "emacsclient", "saved_searches": []})
+NOTMUCH.setdefault("saved_searches", [])
+SCREENREC = app_config.get("screenrec", {
+    "enable": False,
+    "output_dir": "~/Videos/wl-screenrec",
+})
+POWER = app_config.get("power", {
+    "lock_command": ["waylock"],
+})
+NOTIFICATIONS = app_config.get("notifications", {
+    "enable": False,
+    "anchor": "top center",
+    "margin": "8px",
+    "width": 360,
+    "timeout_ms": 10_000,
+    "history_size": 50,
+    "image_max_px": 128,
+    "center_width": 380,
+})
+BAR_HEIGHT = app_config.get("height", 40)
+LOG_LEVEL = app_config.get("logLevel", "WARNING")
+DEV = app_config.get("dev", False)

sims/main.py

@@ -0,0 +1,244 @@
+from loguru import logger
+
+# Configure logging based on dev flag
+from .config import DEV, LOG_LEVEL
+if DEV:
+    # In dev mode, disable fabric logs but keep stylix and bar logs
+    logger.disable("fabric")
+else:
+    # In production, disable fabric logs but keep bar logs with configurable level
+    import sys
+    logger.disable("fabric")
+    logger.configure(handlers=[{"sink": sys.stderr, "level": LOG_LEVEL, "format": "{time} | {level} | {name}:{function}:{line} - {message}"}])
+
+from fabric import Application
+from sims.services.i3 import I3, I3MessageType
+from fabric.system_tray.widgets import SystemTray
+from fabric.widgets.wayland import WaylandWindow as Window
+from fabric.utils import (
+    get_relative_path,
+)
+from .modules.bar import StatusBar
+from .modules.window_fuzzy import FuzzyWindowFinder
+from .modules.launcher.apps import AppLauncher
+from .modules.launcher.clipboard import ClipboardMenu
+from .modules.launcher.notmuch_search import NotmuchSearchMenu
+from .modules.launcher.power import PowerMenu
+from .modules.launcher.screenrec import ScreenrecMenu
+from .modules.launcher.screenshot import ScreenshotMenu
+from .modules.calendar import CalendarService
+from .modules.control_center import ControlCenter
+from .modules.notifications import NotificationToasts
+from .modules.stylix import get_stylix_css_path
+from .modules.vinyl import VinylButton
+from .config import CALENDAR, NOTIFICATIONS, POWER, SCREENREC, STYLIX, VINYL
+from .services.fenster import get_i3_connection
+from .services.notification_history import NotificationHistoryService
+from .services.screenrec import ScreenrecService
+
+from fabric.notifications import Notifications
+
+
+tray = SystemTray(name="system-tray", spacing=4)
+get_i3_connection()
+
+dummy = Window(visible=False)
+finder = FuzzyWindowFinder()
+app_launcher = AppLauncher()
+clipboard_menu = ClipboardMenu()
+power_menu = PowerMenu(lock_command=POWER.get("lock_command", ["waylock"]))
+screenshot_menu = ScreenshotMenu()
+notmuch_search_menu = NotmuchSearchMenu()
+
+screenrec_service: ScreenrecService | None = None
+screenrec_menu = None
+if SCREENREC.get("enable", False):
+    screenrec_service = ScreenrecService(
+        output_dir=SCREENREC.get("output_dir", "~/Videos/wl-screenrec")
+    )
+    screenrec_menu = ScreenrecMenu(screenrec_service)
+
+notifications_service: Notifications | None = None
+notification_history: NotificationHistoryService | None = None
+notification_toasts: NotificationToasts | None = None
+if NOTIFICATIONS.get("enable", False):
+    notifications_service = Notifications()
+    notification_history = NotificationHistoryService(
+        notifications_service,
+        history_size=NOTIFICATIONS.get("history_size", 50),
+        image_max_px=NOTIFICATIONS.get("image_max_px", 128),
+    )
+    notification_toasts = NotificationToasts(
+        notifications_service,
+        monitor=0,
+        anchor=NOTIFICATIONS.get("anchor", "top center"),
+        margin=NOTIFICATIONS.get("margin", "8px"),
+        width=NOTIFICATIONS.get("width", 360),
+        timeout_ms=NOTIFICATIONS.get("timeout_ms", 10_000),
+    )
+
+vinyl_button: VinylButton | None = VinylButton() if VINYL.get("enable", False) else None
+calendar_service: CalendarService | None = (
+    CalendarService(update_interval=120000) if CALENDAR.get("enable", True) else None
+)
+
+control_center: ControlCenter | None = None
+if notification_history is not None:
+    control_center = ControlCenter(
+        history=notification_history,
+        calendar_service=calendar_service,
+        vinyl_button=vinyl_button,
+        monitor=0,
+        width=NOTIFICATIONS.get("center_width", 380),
+    )
+
+bar_windows = []
+notmuch_widget = None
+
+_app_windows = [dummy, finder, app_launcher, clipboard_menu, power_menu, screenshot_menu, notmuch_search_menu]
+if screenrec_menu is not None:
+    _app_windows.append(screenrec_menu)
+if notification_toasts is not None:
+    _app_windows.append(notification_toasts)
+if control_center is not None:
+    _app_windows.append(control_center)
+app = Application("sims", *_app_windows)
+
+
+@Application.action()
+def open_finder():
+    finder.show()
+
+
+@Application.action()
+def open_app_launcher():
+    app_launcher.show()
+
+
+@Application.action()
+def open_clipboard_menu():
+    clipboard_menu.show()
+
+
+@Application.action()
+def open_power_menu():
+    power_menu.show()
+
+
+@Application.action()
+def open_screenshot_menu():
+    screenshot_menu.show()
+
+
+@Application.action()
+def refresh_notmuch():
+    if notmuch_widget is not None:
+        notmuch_widget.service.update_counts()
+
+
+@Application.action()
+def open_notmuch_search():
+    notmuch_search_menu.show()
+
+
+@Application.action()
+def open_screenrec_menu():
+    if screenrec_menu is not None:
+        screenrec_menu.show()
+
+
+@Application.action()
+def screenrec_start_monitor():
+    if screenrec_service is not None:
+        screenrec_service.start_monitor("videos")
+
+
+@Application.action()
+def screenrec_start_region():
+    if screenrec_service is not None:
+        screenrec_service.start_region("videos")
+
+
+@Application.action()
+def screenrec_stop():
+    if screenrec_service is not None:
+        screenrec_service.stop()
+
+
+@Application.action()
+def toggle_control_center():
+    if control_center is not None:
+        control_center.toggle()
+
+
+def _set_all_bars_rounded(rounded: bool):
+    for bar in bar_windows:
+        bar.set_corners_rounded(rounded)
+
+
+@Application.action()
+def set_bar_corners_rounded():
+    _set_all_bars_rounded(True)
+
+
+@Application.action()
+def set_bar_corners_flat():
+    _set_all_bars_rounded(False)
+
+
+@Application.action()
+def toggle_bar_corners():
+    new_state = not any(bar.corners_rounded for bar in bar_windows)
+    _set_all_bars_rounded(new_state)
+
+# Load CSS - use Stylix if enabled, otherwise use default
+if STYLIX.get("enable", False):
+    stylix_css_path = get_stylix_css_path()
+    if stylix_css_path:
+        logger.info("[Bar] Using Stylix CSS")
+        app.set_stylesheet_from_file(get_relative_path("styles/main.css"))
+        app.set_stylesheet_from_file(stylix_css_path, append=True)
+    else:
+        logger.warning("[Bar] Stylix enabled but CSS generation failed, falling back to default")
+        app.set_stylesheet_from_file(get_relative_path("styles/main.css"))
+else:
+    logger.info("[Bar] Using default CSS")
+    app.set_stylesheet_from_file(get_relative_path("styles/main.css"))
+
+
+def spawn_bars():
+    global notmuch_widget
+    logger.info("[Bar] Spawning bars")
+    outputs_reply = I3.send_command("", I3MessageType.GET_OUTPUTS)
+
+    if not (outputs_reply.is_ok and isinstance(outputs_reply.reply, list)):
+        logger.warning("[Bar] Failed to get outputs — skipping bar spawn")
+        return
+
+    outputs = [o for o in outputs_reply.reply if o.get("active")]
+
+    if not outputs:
+        logger.warning("[Bar] No active outputs found — skipping bar spawn")
+        return
+
+    for i, output in enumerate(outputs):
+        output_name = output.get("name", f"Unknown-{i}")
+        bar = StatusBar(
+            display=output_name,
+            tray=tray if i == 0 else None,
+            monitor=i,
+            screenrec_service=screenrec_service if i == 0 else None,
+            control_center=control_center if i == 0 else None,
+        )
+        bar_windows.append(bar)
+        if i == 0 and bar.notmuch:
+            notmuch_widget = bar.notmuch
+
+
+def main():
+    spawn_bars()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

sims/modules/bar.py

@@ -0,0 +1,201 @@
+from fabric.widgets.box import Box
+from fabric.widgets.label import Label
+from fabric.widgets.image import Image
+from fabric.widgets.overlay import Overlay
+from fabric.widgets.datetime import DateTime
+from fabric.widgets.centerbox import CenterBox
+from sims.modules.player import Player, PlayerSmall
+from sims.modules.battery import Battery
+from sims.modules.control_center import ControlCenter
+from sims.modules.notmuch import NotmuchWidget
+from sims.modules.screenrec import ScreenrecWidget
+from fabric.widgets.wayland import WaylandWindow as Window
+from fabric.system_tray.widgets import SystemTray
+from sims.widgets.fenster import FensterWorkspaces, FensterActiveWindow
+from sims.services.screenrec import ScreenrecService
+from sims.services.smart_corners import get_smart_corners_service
+from fabric.widgets.button import Button
+from fabric.widgets.circularprogressbar import CircularProgressBar
+from sims.services.system_stats import SystemStatsService
+
+from sims.config import BATTERY, BAR_HEIGHT, WINDOW_TITLE, NOTMUCH
+
+
+class StatusBar(Window):
+    def __init__(
+        self,
+        display: str,
+        tray: SystemTray | None = None,
+        monitor: int = 1,
+        screenrec_service: ScreenrecService | None = None,
+        control_center: ControlCenter | None = None,
+    ):
+        super().__init__(
+            name="sims",
+            layer="top",
+            anchor="left top right",
+            margin="0px 0px -2px 0px",
+            exclusivity="auto",
+            visible=False,
+            all_visible=False,
+            monitor=monitor,
+        )
+        self.output = display
+        self._corners_rounded = False
+        self._right_flat = False
+
+        self.workspaces = FensterWorkspaces(
+            output=display,
+            name="workspaces",
+            spacing=4,
+        )
+
+        datetime_widget = DateTime(name="date-time", formatters="%d %b - %H:%M")
+        self.date_time = Button(
+            name="date-time-button",
+            child=datetime_widget,
+            on_clicked=self._on_date_time_clicked,
+            style="background: transparent; border: none; padding: 0; margin: 0; box-shadow: none;",
+        )
+        self.control_center = control_center
+
+        self.system_tray = tray
+
+        self.active_window = FensterActiveWindow(
+            name="active-window",
+            max_length=50,
+            style="color: #ffffff; font-size: 14px; font-weight: bold;",
+        )
+
+        self.ram_progress_bar = CircularProgressBar(
+            name="ram-progress-bar", pie=True, size=24
+        )
+        self.cpu_progress_bar = CircularProgressBar(
+            name="cpu-progress-bar", pie=True, size=24
+        )
+
+        self.progress_label = Label(
+            "", style="margin: 0px 6px 0px 0px; font-size: 12px"
+        )
+        self.progress_bars_overlay = Overlay(
+            child=self.ram_progress_bar,
+            overlays=[self.cpu_progress_bar, self.progress_label],
+        )
+        self.player = Player()
+        self.player_small = PlayerSmall()
+
+        self.battery = None
+        if BATTERY["enable"]:
+            self.battery = Battery()
+
+        self.notmuch = None
+        if NOTMUCH["enable"]:
+            self.notmuch = NotmuchWidget()
+
+        self.screenrec = None
+        if screenrec_service is not None:
+            self.screenrec = ScreenrecWidget(screenrec_service)
+
+        self.status_container = Box(
+            name="widgets-container",
+            spacing=4,
+            orientation="h",
+            children=self.progress_bars_overlay,
+        )
+
+        end_container_children = []
+
+        end_container_children.append(self.status_container)
+        if self.system_tray:
+            end_container_children.append(self.system_tray)
+
+        if self.battery:
+            end_container_children.append(self.battery)
+
+        if self.notmuch:
+            end_container_children.append(self.notmuch)
+
+        if self.screenrec:
+            end_container_children.append(self.screenrec)
+
+        end_container_children.append(self.date_time)
+
+        center_children = []
+        if WINDOW_TITLE["enable"]:
+            center_children.append(self.active_window)
+
+        self.inner = CenterBox(
+            name="sims-inner",
+            start_children=Box(
+                name="start-container",
+                spacing=6,
+                orientation="h",
+                children=[
+                    Image(name="nixos-label", icon_name="nix-snowflake-white", icon_size=20),
+                    self.workspaces,
+                    self.player_small,
+                ],
+            ),
+            center_children=Box(
+                name="center-container",
+                spacing=4,
+                orientation="h",
+                children=center_children,
+            ),
+            end_children=Box(
+                name="end-container",
+                spacing=4,
+                orientation="h",
+                children=end_container_children,
+            ),
+        )
+        self.children = self.inner
+
+        self.system_stats_service = SystemStatsService(update_interval=3000)
+        self.system_stats_service.connect("stats-changed", self.update_progress_bars)
+
+        self.set_size_request(-1, BAR_HEIGHT)
+
+        smart_corners = get_smart_corners_service()
+        smart_corners.connect("state-changed", self._on_smart_corners_changed)
+        self.set_corners_rounded(not smart_corners.get(display))
+
+        if self.control_center is not None:
+            self.control_center.add_visibility_listener(self.set_right_flat)
+
+        self.show_all()
+
+    @property
+    def corners_rounded(self) -> bool:
+        return self._corners_rounded
+
+    def set_corners_rounded(self, rounded: bool) -> None:
+        if rounded == self._corners_rounded:
+            return
+        if rounded:
+            self.inner.add_style_class("rounded-bottom")
+        else:
+            self.inner.remove_style_class("rounded-bottom")
+        self._corners_rounded = rounded
+
+    def _on_smart_corners_changed(self, _service, output: str, active: bool):
+        if output != self.output:
+            return
+        self.set_corners_rounded(not active)
+
+    def set_right_flat(self, flat: bool) -> None:
+        if flat == self._right_flat:
+            return
+        if flat:
+            self.inner.set_style("border-radius: 0 0 0 28px;")
+        else:
+            self.inner.set_style("")
+        self._right_flat = flat
+
+    def update_progress_bars(self, service, cpu_percent, memory_percent):
+        self.cpu_progress_bar.value = cpu_percent
+        self.ram_progress_bar.value = memory_percent
+
+    def _on_date_time_clicked(self, _button=None):
+        if self.control_center is not None:
+            self.control_center.toggle()

sims/modules/battery.py

@@ -0,0 +1,53 @@
+from gi.repository import GLib
+from fabric.widgets.box import Box
+from fabric.widgets.label import Label
+from fabric.widgets.image import Image
+from sims.services.battery import BatteryService
+
+
+class Battery(Box):
+    def __init__(self, **kwargs):
+        super().__init__(name="battery-widget", orientation="h", spacing=4, **kwargs)
+
+        self.bat_icon = Image(
+            name="bat-icon", icon_name="battery-full-symbolic", icon_size=16
+        )
+
+        self.bat_label = Label(name="bat-label", label="100%")
+
+        # Create battery service with signal-based updates
+        self.battery_service = BatteryService(update_interval=10000)  # Check every 10 seconds
+        self.battery_service.connect("battery-changed", self.update_battery)
+
+        self.children = [self.bat_icon, self.bat_label]
+        self.show_all()
+
+        # Initialize with current battery status
+        initial_percent = self.battery_service.percent
+        initial_charging = self.battery_service.charging
+        GLib.idle_add(self.update_battery, None, initial_percent, initial_charging)
+
+    def _icon_lookup(self, bat, charging):
+        # Round to nearest 10 for level-based icons
+        level = max(10, min(100, round(bat / 10) * 10))
+
+        if charging:
+            # Adwaita ships battery-level-100-charged-symbolic, not -charging.
+            suffix = "charged" if level == 100 else "charging"
+            return f"battery-level-{level}-{suffix}-symbolic"
+        else:
+            return f"battery-level-{level}-symbolic"
+
+    def update_battery(self, service, percent, charging):
+        """Update battery display when battery status changes"""
+        icon_name = self._icon_lookup(percent, charging)
+        self.bat_icon.set_property("icon-name", icon_name)
+
+        self.bat_label.set_text(f"{int(percent)}%")
+
+        if percent < 20 and not charging:
+            self.bat_label.add_style_class("battery-low")
+            self.bat_icon.add_style_class("battery-low")
+        else:
+            self.bat_label.remove_style_class("battery-low")
+            self.bat_icon.remove_style_class("battery-low")

sims/modules/calendar.py

@@ -0,0 +1,200 @@
+import json
+import os
+import subprocess
+import shutil
+from datetime import date
+
+# Add common binary paths to PATH for user binaries
+os.environ['PATH'] = '/run/current-system/sw/bin:/home/' + os.environ.get('USER', 'user') + '/.nix-profile/bin:' + os.environ.get('PATH', '')
+from loguru import logger
+from sims.config import CALENDAR
+
+# Try to import khal as a Python library
+try:
+    from khal.cli.main import main_khal
+    from khal.settings import get_config
+    from khal.khalendar import CalendarCollection
+    KHAL_AVAILABLE = True
+    logger.info("[Calendar] Using khal as Python library")
+except ImportError:
+    KHAL_AVAILABLE = False
+    logger.info("[Calendar] khal Python library not available, falling back to subprocess")
+
+
+class CalendarService:
+    def __init__(self, update_interval=300000):  # 5 minutes default
+        self.events = []
+        self.callbacks = []
+        self._update_interval = update_interval
+        self._timer_id = None
+
+        # Initial load
+        self.update_events()
+        # Start periodic updates
+        self.start_monitoring()
+
+    def connect(self, signal_name, callback):
+        """Simple callback system to replace signals"""
+        if signal_name == "events-changed":
+            self.callbacks.append(callback)
+
+    def emit_events_changed(self, events):
+        """Emit events changed to all callbacks"""
+        for callback in self.callbacks:
+            callback(self, events)
+
+    def start_monitoring(self):
+        """Start periodic event updates"""
+        if self._timer_id is None:
+            from fabric.utils import invoke_repeater
+
+            self._timer_id = invoke_repeater(
+                self._update_interval, self._periodic_update
+            )
+            logger.info(
+                f"[Calendar] Started periodic updates every {self._update_interval/1000/60:.1f} minutes"
+            )
+
+    def stop_monitoring(self):
+        """Stop periodic event updates"""
+        if self._timer_id is not None:
+            from gi.repository import GLib
+
+            GLib.source_remove(self._timer_id)
+            self._timer_id = None
+            logger.info("[Calendar] Stopped periodic updates")
+
+    def _periodic_update(self):
+        """Periodic update callback"""
+        logger.info("[Calendar] Performing periodic events update")
+        self.update_events()
+        return True  # Keep the timer running
+
+    def get_cached_events(self):
+        """Get cached events without triggering update"""
+        return self.events
+
+    def update_events_python_api(self):
+        """Fetch today's events using khal Python API"""
+        try:
+            # Get khal configuration
+            config = get_config()
+
+            # Create calendar collection
+            collection = CalendarCollection.from_calendars(
+                calendars=config['calendars'],
+                dbpath=config['sqlite']['path'],
+                locale=config['locale'],
+                color=config['default']['print_new'],
+                unicode_symbols=config['default']['unicode_symbols'],
+                default_calendar=config['default']['default_calendar'],
+                readonly=True
+            )
+
+            # Get today's events
+            today = date.today()
+            events = collection.get_events_on(today)
+
+            # Format events to match our expected structure
+            formatted_events = []
+            for event in events:
+                formatted_event = {
+                    'title': str(event.summary),
+                    'start': event.start.strftime('%m-%d %H:%M') if hasattr(event.start, 'strftime') else '',
+                    'end': event.end.strftime('%m-%d %H:%M') if hasattr(event.end, 'strftime') else '',
+                    'location': str(event.location) if event.location else ''
+                }
+                formatted_events.append(formatted_event)
+
+            # Sort by start time
+            formatted_events.sort(key=lambda e: e.get('start', ''))
+
+            self.events = formatted_events
+            logger.info(f"[Calendar] Found {len(self.events)} events using Python API")
+            self.emit_events_changed(self.events)
+
+        except Exception as e:
+            logger.error(f"[Calendar] Error using khal Python API: {e}")
+            # Fall back to subprocess method
+            self.update_events_subprocess()
+
+    def update_events_subprocess(self):
+        """Fetch today's events using khal subprocess (fallback)"""
+        # Get khal path from config
+        khal_path = CALENDAR.get("khal_path", "khal")
+
+        # Check if khal is available
+        if not shutil.which(khal_path):
+            logger.warning(f"[Calendar] khal not found at '{khal_path}'. Please install khal or configure the correct path.")
+            self.events = []
+            self.emit_events_changed(self.events)
+            return
+
+        try:
+            cmd = [
+                khal_path,
+                "list",
+                "--json",
+                "title",
+                "--json",
+                "start",
+                "--json",
+                "end",
+                "--json",
+                "location",
+                "today",
+            ]
+            logger.info(f"[Calendar] Running command: {' '.join(cmd)}")
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            logger.info(f"[Calendar] Command stdout: {result.stdout[:200]}...")
+            logger.info(f"[Calendar] Command stderr: {result.stderr[:200]}...")
+
+            if result.stdout.strip():
+                lines = result.stdout.strip().split("\n")
+                all_events = []
+
+                for line in lines:
+                    if line.strip():
+                        try:
+                            events = json.loads(line)
+                            all_events.extend(events)
+                        except json.JSONDecodeError:
+                            continue
+
+                self.events = all_events
+                logger.info(f"[Calendar] Found {len(self.events)} events using subprocess")
+                self.emit_events_changed(self.events)
+            else:
+                self.events = []
+                self.emit_events_changed(self.events)
+
+        except subprocess.CalledProcessError as e:
+            logger.error(f"[Calendar] Failed to fetch events: {e}")
+            self.events = []
+            self.emit_events_changed(self.events)
+        except Exception as e:
+            logger.error(f"[Calendar] Error processing events: {e}")
+            self.events = []
+            self.emit_events_changed(self.events)
+
+    def update_events(self):
+        """Fetch today's events from khal"""
+        # Check if calendar is enabled
+        if not CALENDAR.get("enable", True):
+            logger.info("[Calendar] Calendar is disabled in config")
+            self.events = []
+            self.emit_events_changed(self.events)
+            return
+
+        # Try Python API first, fall back to subprocess
+        if KHAL_AVAILABLE:
+            logger.info("[Calendar] Using khal Python API")
+            self.update_events_python_api()
+        else:
+            logger.info("[Calendar] Using khal subprocess")
+            self.update_events_subprocess()

sims/modules/control_center.py

@@ -0,0 +1,352 @@
+from datetime import datetime
+
+from fabric.widgets.box import Box
+from fabric.widgets.button import Button
+from fabric.widgets.image import Image
+from fabric.widgets.label import Label
+from fabric.widgets.scrolledwindow import ScrolledWindow
+from fabric.widgets.wayland import WaylandWindow as Window
+from gi.repository import Gdk
+
+from sims.modules.calendar import CalendarService
+from sims.modules.vinyl import VinylButton
+from sims.services.notification_history import NotificationHistoryService
+from sims.widgets.notification_history_entry import NotificationHistoryEntryWidget
+
+
+class ControlCenter(Window):
+    def __init__(
+        self,
+        history: NotificationHistoryService,
+        calendar_service: CalendarService | None = None,
+        vinyl_button: VinylButton | None = None,
+        monitor: int = 0,
+        width: int = 380,
+    ):
+        super().__init__(
+            name="control-center",
+            anchor="top right bottom",
+            monitor=monitor,
+            margin="0",
+            exclusivity="none",
+            keyboard_mode="on-demand",
+            visible=False,
+        )
+        self._history = history
+        self._calendar_service = calendar_service
+        self._vinyl_button = vinyl_button
+        self._width = width
+        self._visibility_listeners: list = []
+
+        close_button = Button(
+            name="control-center-close",
+            image=Image(icon_name="window-close-symbolic", icon_size=16),
+            on_clicked=lambda *_: self.hide(),
+        )
+        header = Box(
+            name="control-center-header",
+            orientation="h",
+            spacing=8,
+        )
+        header.pack_start(
+            Label(name="control-center-title", label="Control Center", h_align="start"),
+            True,
+            True,
+            0,
+        )
+        header.pack_end(close_button, False, False, 0)
+
+        sections: list = []
+
+        if vinyl_button is not None:
+            sections.append(self._build_settings_section())
+
+        if calendar_service is not None:
+            sections.append(self._build_calendar_section())
+
+        sections.append(self._build_notifications_section())
+
+        sections_box = Box(
+            name="control-center-sections",
+            orientation="v",
+            spacing=12,
+            children=sections,
+            h_expand=True,
+        )
+
+        scroll = ScrolledWindow(
+            name="control-center-scroll",
+            h_scrollbar_policy="never",
+            v_scrollbar_policy="automatic",
+            child=sections_box,
+            h_expand=True,
+            v_expand=True,
+        )
+
+        body = Box(
+            name="control-center-body",
+            orientation="v",
+            spacing=8,
+            children=[header, scroll],
+            h_expand=True,
+            v_expand=True,
+        )
+        body.set_size_request(self._width, -1)
+        self.add(body)
+        self.connect("key-press-event", self._on_key_press)
+
+        self._history.connect("changed", lambda *_: self._refresh_notifications())
+        if self._calendar_service is not None:
+            self._calendar_service.connect(
+                "events-changed",
+                lambda _service, events: self._refresh_calendar(events),
+            )
+
+        self._refresh_notifications()
+        if self._calendar_service is not None:
+            self._refresh_calendar(self._calendar_service.get_cached_events())
+
+    def _build_section(self, name: str, title: str | None) -> Box:
+        section = Box(
+            name=name,
+            orientation="v",
+            spacing=6,
+            h_expand=True,
+        )
+        if title is not None:
+            section.add(
+                Label(
+                    name="control-center-section-title",
+                    label=title,
+                    h_align="start",
+                )
+            )
+        return section
+
+    def _build_settings_section(self) -> Box:
+        section = self._build_section("control-center-settings", "Settings")
+
+        row = Box(
+            name="control-center-settings-row",
+            orientation="h",
+            spacing=8,
+        )
+        row.pack_start(
+            Label(
+                name="control-center-settings-label",
+                label="Vinyl Passthrough",
+                h_align="start",
+            ),
+            True,
+            True,
+            0,
+        )
+        row.pack_end(self._vinyl_button, False, False, 0)
+        section.add(row)
+        return section
+
+    def _build_calendar_section(self) -> Box:
+        section = self._build_section("control-center-calendar", "Calendar")
+        self._calendar_events_box = Box(
+            name="control-center-events",
+            orientation="v",
+            spacing=4,
+            h_expand=True,
+        )
+        section.add(self._calendar_events_box)
+        return section
+
+    def _build_notifications_section(self) -> Box:
+        section = self._build_section("control-center-notifications", None)
+
+        clear_button = Button(
+            name="control-center-notifications-clear",
+            label="Clear all",
+            on_clicked=lambda *_: self._history.clear(),
+        )
+        header = Box(
+            name="control-center-notifications-header",
+            orientation="h",
+            spacing=8,
+        )
+        header.pack_start(
+            Label(
+                name="control-center-section-title",
+                label="Notifications",
+                h_align="start",
+            ),
+            True,
+            True,
+            0,
+        )
+        header.pack_end(clear_button, False, False, 0)
+
+        self._notifications_empty = Label(
+            name="control-center-notifications-empty",
+            label="No notifications",
+            h_align="start",
+        )
+        self._notifications_list = Box(
+            name="control-center-notifications-list",
+            orientation="v",
+            spacing=6,
+            h_expand=True,
+        )
+
+        section.add(header)
+        section.add(self._notifications_list)
+        return section
+
+    def add_visibility_listener(self, callback) -> None:
+        self._visibility_listeners.append(callback)
+
+    def _notify_visibility(self, visible: bool) -> None:
+        for callback in self._visibility_listeners:
+            callback(visible)
+
+    def toggle(self) -> None:
+        if self.get_visible():
+            self.hide()
+        else:
+            self.show()
+
+    def show(self) -> None:  # type: ignore[override]
+        self._history.mark_all_seen()
+        super().show()
+        self.show_all()
+        self._notify_visibility(True)
+
+    def hide(self) -> None:  # type: ignore[override]
+        super().hide()
+        self._notify_visibility(False)
+
+    def _on_key_press(self, _widget, event):
+        if event.keyval == Gdk.KEY_Escape:
+            self.hide()
+            return True
+        return False
+
+    def _refresh_notifications(self) -> None:
+        for child in self._notifications_list.get_children():
+            self._notifications_list.remove(child)
+            if child is not self._notifications_empty:
+                child.destroy()
+        entries = self._history.entries
+        if not entries:
+            self._notifications_list.add(self._notifications_empty)
+            self._notifications_empty.show_all()
+            return
+        for entry in entries:
+            self._notifications_list.add(
+                NotificationHistoryEntryWidget(
+                    entry, on_dismiss=self._history.remove
+                )
+            )
+        self._notifications_list.show_all()
+
+    def _refresh_calendar(self, events) -> None:
+        for child in self._calendar_events_box.get_children():
+            self._calendar_events_box.remove(child)
+            child.destroy()
+
+        if not events:
+            self._calendar_events_box.add(
+                Label(
+                    name="control-center-no-events",
+                    label="No events today",
+                    h_align="start",
+                )
+            )
+            self._calendar_events_box.show_all()
+            return
+
+        now = datetime.now()
+        current_time = now.strftime("%H:%M")
+        current_time_added = False
+
+        for event in events:
+            title = event.get("title", "No title")
+            start_raw = event.get("start", "")
+            end_raw = event.get("end", "")
+            start_time = start_raw.split()[1] if start_raw else ""
+            end_time = end_raw.split()[1] if end_raw else ""
+            location = event.get("location", "")
+
+            if not current_time_added and start_time and start_time > current_time:
+                self._calendar_events_box.add(self._build_now_indicator(current_time))
+                current_time_added = True
+
+            if start_time and end_time:
+                time_str = f"{start_time} - {end_time}"
+            elif start_time:
+                time_str = start_time
+            else:
+                time_str = "All day"
+
+            event_box = Box(
+                name="event-item",
+                orientation="h",
+                spacing=12,
+                style_classes=["event-item"],
+            )
+            event_box.add(
+                Label(
+                    time_str,
+                    name="event-time",
+                    style_classes=["event-time"],
+                    style="min-width: 90px;",
+                )
+            )
+            content_box = Box(
+                name="event-content",
+                orientation="v",
+                spacing=2,
+            )
+            content_box.add(
+                Label(
+                    title,
+                    name="event-title",
+                    style_classes=["event-title"],
+                    h_align="start",
+                )
+            )
+            if location:
+                content_box.add(
+                    Label(
+                        f"📍 {location}",
+                        name="event-location",
+                        style_classes=["event-location"],
+                        h_align="start",
+                    )
+                )
+            event_box.add(content_box)
+            self._calendar_events_box.add(event_box)
+
+        if not current_time_added:
+            self._calendar_events_box.add(self._build_now_indicator(current_time))
+
+        self._calendar_events_box.show_all()
+
+    def _build_now_indicator(self, current_time: str) -> Box:
+        indicator = Box(
+            name="current-time-indicator",
+            orientation="h",
+            spacing=8,
+            style_classes=["current-time-indicator"],
+        )
+        indicator.add(
+            Label(
+                current_time,
+                name="current-time-label",
+                style_classes=["current-time-label"],
+                style="min-width: 90px; font-weight: bold;",
+            )
+        )
+        indicator.add(
+            Label(
+                "━━━ NOW",
+                name="current-time-line",
+                style_classes=["current-time-line"],
+            )
+        )
+        return indicator

sims/modules/launcher/__init__.py

@@ -0,0 +1,10 @@
+from .base import FuzzyMenu, LauncherProvider, StaticAction, StaticActionProvider
+from .windows import WindowProvider
+
+__all__ = [
+    "FuzzyMenu",
+    "LauncherProvider",
+    "StaticAction",
+    "StaticActionProvider",
+    "WindowProvider",
+]

sims/modules/launcher/apps.py

@@ -0,0 +1,87 @@
+import re
+import shlex
+import subprocess
+
+from fabric.utils.helpers import DesktopApp, get_desktop_applications
+from fabric.widgets.box import Box
+from fabric.widgets.image import Image
+from fabric.widgets.label import Label
+from gi.repository import Gtk
+
+from .base import FuzzyMenu
+
+
+ICON_SIZE = 32
+
+_FIELD_CODE_RE = re.compile(r"^%[fFuUickdDnNvm]$")
+
+
+class AppProvider:
+    def items(self) -> list[DesktopApp]:
+        return get_desktop_applications()
+
+    def filter(self, items: list[DesktopApp], query: str) -> list[DesktopApp]:
+        if not query:
+            return items
+        q = query.lower()
+        return [a for a in items if _matches(a, q)]
+
+    def render(self, item: DesktopApp) -> Gtk.Widget:
+        children: list[Gtk.Widget] = []
+
+        pixbuf = item.get_icon_pixbuf(size=ICON_SIZE)
+        if pixbuf is not None:
+            children.append(Image(pixbuf=pixbuf, name="app-icon"))
+
+        primary = item.display_name or item.name or ""
+        text_box = Box(name="app-text", orientation="v", spacing=0)
+        text_box.add(Label(label=primary, name="app-name", h_align="start"))
+        if item.generic_name and item.generic_name != primary:
+            text_box.add(
+                Label(label=item.generic_name, name="app-generic", h_align="start")
+            )
+        children.append(text_box)
+
+        return Box(name="slot-box", orientation="h", spacing=10, children=children)
+
+    def activate(self, item: DesktopApp) -> None:
+        # Launch in a transient systemd --user scope so the app gets its own
+        # cgroup instead of inheriting sims.service's. start_new_session alone
+        # only changes POSIX session/pgid; systemd tracks units by cgroup and
+        # would kill children with sims on stop (default KillMode=control-group).
+        if item.command_line:
+            argv = [
+                t for t in shlex.split(item.command_line) if not _FIELD_CODE_RE.match(t)
+            ]
+            if argv:
+                subprocess.Popen(
+                    [
+                        "systemd-run",
+                        "--quiet",
+                        "--user",
+                        "--scope",
+                        "--collect",
+                        "--",
+                        *argv,
+                    ],
+                    start_new_session=True,
+                )
+                return
+        item.launch()
+
+
+def _matches(app: DesktopApp, q: str) -> bool:
+    for field in (app.name, app.display_name, app.generic_name, app.executable):
+        if field and q in field.lower():
+            return True
+    return False
+
+
+def AppLauncher(monitor: int = 0) -> FuzzyMenu:
+    return FuzzyMenu(
+        provider=AppProvider(),
+        monitor=monitor,
+        placeholder="Search Apps...",
+        window_name="app-launcher",
+        max_results=8,
+    )

sims/modules/launcher/base.py

@@ -0,0 +1,205 @@
+from dataclasses import dataclass
+from typing import Any, Callable, Protocol
+
+from fabric.widgets.box import Box
+from fabric.widgets.entry import Entry
+from fabric.widgets.label import Label
+from fabric.widgets.wayland import WaylandWindow as Window
+from gi.repository import Gdk, Gtk
+
+from sims.services.fenster import focused_output_index
+
+
+class LauncherProvider(Protocol):
+    def items(self) -> list[Any]: ...
+    def filter(self, items: list[Any], query: str) -> list[Any]: ...
+    def render(self, item: Any) -> Gtk.Widget: ...
+    def activate(self, item: Any) -> None: ...
+
+
+@dataclass
+class StaticAction:
+    label: str
+    handler: Callable[[], None]
+
+
+class StaticActionProvider:
+    """Provider for menus whose items are a fixed list of (label, handler) pairs.
+
+    Pass either StaticAction instances or (label, handler) tuples; tuples are
+    coerced. items_factory lets the list re-evaluate on each open (e.g. for
+    state-dependent menus) — otherwise the list is captured at construction.
+    """
+
+    def __init__(
+        self,
+        actions: list[StaticAction | tuple[str, Callable[[], None]]] | None = None,
+        items_factory: Callable[[], list[StaticAction | tuple[str, Callable[[], None]]]] | None = None,
+    ):
+        if (actions is None) == (items_factory is None):
+            raise ValueError("pass exactly one of actions or items_factory")
+        self._static = [_coerce(a) for a in actions] if actions is not None else None
+        self._factory = items_factory
+
+    def items(self) -> list[StaticAction]:
+        if self._factory is not None:
+            return [_coerce(a) for a in self._factory()]
+        return list(self._static or [])
+
+    def filter(self, items: list[StaticAction], query: str) -> list[StaticAction]:
+        if not query:
+            return items
+        q = query.lower()
+        return [i for i in items if q in i.label.lower()]
+
+    def render(self, item: StaticAction) -> Gtk.Widget:
+        return Box(
+            name="slot-box",
+            orientation="h",
+            children=[Label(label=item.label, h_align="start")],
+        )
+
+    def activate(self, item: StaticAction) -> None:
+        item.handler()
+
+
+def _coerce(a: StaticAction | tuple[str, Callable[[], None]]) -> StaticAction:
+    if isinstance(a, StaticAction):
+        return a
+    label, handler = a
+    return StaticAction(label=label, handler=handler)
+
+
+class FuzzyMenu(Window):
+    def __init__(
+        self,
+        provider: LauncherProvider,
+        monitor: int = 0,
+        placeholder: str = "Search...",
+        window_name: str = "finder",
+        max_results: int | None = None,
+    ):
+        self._max_results = max_results
+        super().__init__(
+            name=window_name,
+            anchor="center",
+            monitor=monitor,
+            keyboard_mode="exclusive",
+            type="popup",
+            visible=False,
+        )
+        self._provider = provider
+        self._items: list[Any] = []
+        self._filtered: list[Any] = []
+        self._selected_index: int = 0
+        self._scroll_offset: int = 0
+
+        self.viewport = Box(name="viewport", spacing=4, orientation="v")
+
+        self.search_entry = Entry(
+            name="search-entry",
+            placeholder=placeholder,
+            h_expand=True,
+            editable=True,
+            notify_text=self._on_text_changed,
+        )
+        self.picker_box = Box(
+            name="picker-box",
+            spacing=4,
+            orientation="v",
+            children=[self.search_entry, self.viewport],
+        )
+
+        self.add(self.picker_box)
+        self.connect("key-press-event", self._on_key_press)
+        self._refresh_viewport("")
+
+    def show(self):
+        self._items = self._provider.items()
+        self.search_entry.set_text("")
+        self._selected_index = 0
+        self._scroll_offset = 0
+        self._refresh_viewport("")
+        self.monitor = focused_output_index()
+        super().show()
+        self.search_entry.grab_focus()
+
+    def _on_text_changed(self, entry, *_):
+        self._selected_index = 0
+        self._scroll_offset = 0
+        self._refresh_viewport(entry.get_text())
+
+    def _on_key_press(self, _widget, event):
+        ctrl = bool(event.state & Gdk.ModifierType.CONTROL_MASK)
+        keyval = event.keyval
+
+        if keyval == Gdk.KEY_Escape:
+            self.hide()
+            return True
+        if ctrl and keyval in (Gdk.KEY_g, Gdk.KEY_G):
+            self.hide()
+            return True
+        if keyval in (Gdk.KEY_Return, Gdk.KEY_KP_Enter):
+            self._activate_selected()
+            return True
+        if keyval == Gdk.KEY_Down or (ctrl and keyval in (Gdk.KEY_n, Gdk.KEY_N)):
+            self._move_selection(1)
+            return True
+        if keyval == Gdk.KEY_Up or (ctrl and keyval in (Gdk.KEY_p, Gdk.KEY_P)):
+            self._move_selection(-1)
+            return True
+        return False
+
+    def _window_size(self) -> int:
+        return self._max_results if self._max_results is not None else len(self._filtered)
+
+    def _move_selection(self, delta: int):
+        if not self._filtered:
+            return
+        new_index = self._selected_index + delta
+        new_index = max(0, min(new_index, len(self._filtered) - 1))
+        if new_index == self._selected_index:
+            return
+        self._selected_index = new_index
+        window = self._window_size()
+        if window <= 0:
+            self._scroll_offset = 0
+        elif self._selected_index < self._scroll_offset:
+            self._scroll_offset = self._selected_index
+        elif self._selected_index >= self._scroll_offset + window:
+            self._scroll_offset = self._selected_index - window + 1
+        self._render_visible()
+
+    def _refresh_viewport(self, query: str):
+        self._filtered = self._provider.filter(self._items, query)
+        if self._selected_index >= len(self._filtered):
+            self._selected_index = 0
+            self._scroll_offset = 0
+        self._render_visible()
+
+    def _render_visible(self):
+        window = self._window_size()
+        if window <= 0:
+            visible: list[Any] = []
+        else:
+            max_offset = max(0, len(self._filtered) - window)
+            self._scroll_offset = min(self._scroll_offset, max_offset)
+            visible = self._filtered[self._scroll_offset : self._scroll_offset + window]
+        self.viewport.children = []
+        for item in visible:
+            self.viewport.add(self._provider.render(item))
+        self._update_selection_highlight()
+
+    def _update_selection_highlight(self):
+        visible_index = self._selected_index - self._scroll_offset
+        for i, child in enumerate(self.viewport.get_children()):
+            ctx = child.get_style_context()
+            if i == visible_index:
+                ctx.add_class("selected")
+            else:
+                ctx.remove_class("selected")
+
+    def _activate_selected(self):
+        if self._filtered and 0 <= self._selected_index < len(self._filtered):
+            self._provider.activate(self._filtered[self._selected_index])
+        self.hide()

sims/modules/launcher/clipboard.py

@@ -0,0 +1,75 @@
+import subprocess
+from dataclasses import dataclass
+
+from fabric.widgets.box import Box
+from fabric.widgets.label import Label
+from gi.repository import Gtk
+
+from .base import FuzzyMenu
+
+
+@dataclass
+class ClipEntry:
+    raw: str  # full "<id>\t<preview>" line as emitted by cliphist
+    preview: str
+
+
+class ClipboardProvider:
+    def items(self) -> list[ClipEntry]:
+        proc = subprocess.run(
+            ["cliphist", "list"],
+            capture_output=True,
+            text=True,
+        )
+        if proc.returncode != 0:
+            return []
+        entries: list[ClipEntry] = []
+        for line in proc.stdout.splitlines():
+            if not line:
+                continue
+            _id, sep, preview = line.partition("\t")
+            if not sep:
+                continue
+            entries.append(ClipEntry(raw=line, preview=preview))
+        return entries
+
+    def filter(self, items: list[ClipEntry], query: str) -> list[ClipEntry]:
+        if not query:
+            return items
+        q = query.lower()
+        return [e for e in items if q in e.preview.lower()]
+
+    def render(self, item: ClipEntry) -> Gtk.Widget:
+        return Box(
+            name="slot-box",
+            orientation="h",
+            children=[
+                Label(
+                    label=item.preview,
+                    h_align="start",
+                    ellipsization="end",
+                    max_chars_width=120,
+                    name="clip-preview",
+                ),
+            ],
+        )
+
+    def activate(self, item: ClipEntry) -> None:
+        decoded = subprocess.run(
+            ["cliphist", "decode"],
+            input=item.raw.encode("utf-8"),
+            capture_output=True,
+        )
+        if decoded.returncode != 0:
+            return
+        subprocess.run(["wl-copy"], input=decoded.stdout)
+
+
+def ClipboardMenu(monitor: int = 0) -> FuzzyMenu:
+    return FuzzyMenu(
+        provider=ClipboardProvider(),
+        monitor=monitor,
+        placeholder="Clipboard...",
+        window_name="clipboard-menu",
+        max_results=12,
+    )

sims/modules/launcher/notmuch_search.py

@@ -0,0 +1,284 @@
+"""Live notmuch search launcher.
+
+A FuzzyMenu variant that runs `notmuch search` per keystroke (debounced),
+renders thread summaries, and on activation opens the thread in emacs notmuch.
+A bare-query handoff item is always appended so the user can defer to
+notmuch-search inside emacs without having a matching result selected.
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+from dataclasses import dataclass
+from typing import Any
+
+from fabric.widgets.box import Box
+from fabric.widgets.label import Label
+from gi.repository import GLib, Gtk
+from loguru import logger
+
+from sims.config import NOTMUCH
+
+from .base import FuzzyMenu
+
+
+DEBOUNCE_MS = 120
+MIN_QUERY_LEN = 2
+SEARCH_LIMIT = 30
+
+
+@dataclass
+class NotmuchHit:
+    thread: str
+    subject: str
+    authors: str
+    date_relative: str
+
+    @property
+    def query(self) -> str:
+        return f"thread:{self.thread}"
+
+
+@dataclass
+class SavedSearch:
+    name: str
+    query: str
+
+
+@dataclass
+class BareQueryHandoff:
+    query: str
+
+
+def _elisp_escape(s: str) -> str:
+    return s.replace("\\", "\\\\").replace('"', '\\"')
+
+
+class NotmuchSearchProvider:
+    def __init__(self):
+        self._notmuch_path = NOTMUCH.get("notmuch_path", "notmuch")
+        self._emacsclient = NOTMUCH.get("emacsclient_command", "emacsclient")
+        raw_saved = NOTMUCH.get("saved_searches", []) or []
+        self._saved: list[SavedSearch] = []
+        for entry in raw_saved:
+            query = (entry.get("query") or "").strip()
+            if not query:
+                continue
+            name = entry.get("name") or query
+            self._saved.append(SavedSearch(name=name, query=query))
+
+    def saved_searches(self) -> list[SavedSearch]:
+        return list(self._saved)
+
+    def search(self, query: str) -> list[NotmuchHit]:
+        cmd = [
+            self._notmuch_path,
+            "search",
+            "--format=json",
+            "--output=summary",
+            f"--limit={SEARCH_LIMIT}",
+            query,
+        ]
+        try:
+            proc = subprocess.run(
+                cmd, capture_output=True, text=True, check=True, timeout=2
+            )
+        except subprocess.CalledProcessError as e:
+            logger.warning(
+                f"[NotmuchSearch] search failed for {query!r}: {e.stderr.strip()}"
+            )
+            return []
+        except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+            logger.warning(f"[NotmuchSearch] {e}")
+            return []
+        try:
+            raw = json.loads(proc.stdout) or []
+        except json.JSONDecodeError:
+            return []
+        hits: list[NotmuchHit] = []
+        for r in raw:
+            hits.append(
+                NotmuchHit(
+                    thread=str(r.get("thread", "")),
+                    subject=r.get("subject") or "(no subject)",
+                    authors=r.get("authors") or "",
+                    date_relative=r.get("date_relative") or "",
+                )
+            )
+        return hits
+
+    def render_hit(self, hit: NotmuchHit) -> Gtk.Widget:
+        text = Box(name="notmuch-text", orientation="v", spacing=0, h_expand=True)
+        text.add(
+            Label(
+                label=hit.subject,
+                name="notmuch-subject",
+                h_align="start",
+                ellipsization="end",
+                max_chars_width=80,
+            )
+        )
+        text.add(
+            Label(
+                label=hit.authors,
+                name="notmuch-authors",
+                h_align="start",
+                ellipsization="end",
+                max_chars_width=80,
+            )
+        )
+        meta = Label(
+            label=hit.date_relative, name="notmuch-date", h_align="end"
+        )
+        return Box(
+            name="slot-box",
+            orientation="h",
+            spacing=10,
+            children=[text, meta],
+        )
+
+    def render_saved(self, item: SavedSearch) -> Gtk.Widget:
+        text = Box(name="notmuch-text", orientation="v", spacing=0, h_expand=True)
+        text.add(
+            Label(label=item.name, name="notmuch-saved-name", h_align="start")
+        )
+        text.add(
+            Label(
+                label=item.query,
+                name="notmuch-saved-query",
+                h_align="start",
+                ellipsization="end",
+                max_chars_width=80,
+            )
+        )
+        return Box(
+            name="slot-box", orientation="h", spacing=10, children=[text]
+        )
+
+    def render_bare(self, item: BareQueryHandoff) -> Gtk.Widget:
+        return Box(
+            name="slot-box",
+            orientation="h",
+            children=[
+                Label(
+                    label=f"→ Search '{item.query}' in emacs",
+                    name="notmuch-bare",
+                    h_align="start",
+                ),
+            ],
+        )
+
+    def open_thread(self, hit: NotmuchHit) -> None:
+        self._emacs_eval(f'(notmuch-show "{_elisp_escape(hit.query)}")')
+
+    def open_search(self, query: str) -> None:
+        self._emacs_eval(f'(notmuch-search "{_elisp_escape(query)}")')
+
+    def _emacs_eval(self, sexp: str) -> None:
+        try:
+            subprocess.Popen(
+                [self._emacsclient, "-c", "-e", sexp],
+                start_new_session=True,
+            )
+        except Exception as e:
+            logger.error(f"[NotmuchSearch] failed to launch emacsclient: {e}")
+
+
+class _MenuProvider:
+    """LauncherProvider that defers to NotmuchSearchProvider.
+
+    items() returns saved searches (shown when the entry is empty).
+    filter() is identity — NotmuchSearchMenu manages self._items directly
+    on every keystroke (live search instead of in-memory filtering).
+    """
+
+    def __init__(self, search: NotmuchSearchProvider):
+        self._search = search
+
+    def items(self) -> list[Any]:
+        return list(self._search.saved_searches())
+
+    def filter(self, items: list[Any], query: str) -> list[Any]:
+        return items
+
+    def render(self, item: Any) -> Gtk.Widget:
+        if isinstance(item, NotmuchHit):
+            return self._search.render_hit(item)
+        if isinstance(item, SavedSearch):
+            return self._search.render_saved(item)
+        if isinstance(item, BareQueryHandoff):
+            return self._search.render_bare(item)
+        return Box()
+
+    def activate(self, item: Any) -> None:
+        if isinstance(item, NotmuchHit):
+            self._search.open_thread(item)
+        elif isinstance(item, SavedSearch):
+            self._search.open_search(item.query)
+        elif isinstance(item, BareQueryHandoff):
+            self._search.open_search(item.query)
+
+
+class NotmuchSearchMenu(FuzzyMenu):
+    def __init__(self, monitor: int = 0):
+        self._search = NotmuchSearchProvider()
+        super().__init__(
+            provider=_MenuProvider(self._search),
+            monitor=monitor,
+            placeholder="notmuch search…",
+            window_name="notmuch-search",
+            max_results=12,
+        )
+        self._debounce_id: int | None = None
+
+    def show(self):
+        self._cancel_debounce()
+        super().show()
+
+    def hide(self):
+        self._cancel_debounce()
+        super().hide()
+
+    def _on_text_changed(self, entry, *_):
+        text = entry.get_text()
+        self._cancel_debounce()
+        self._selected_index = 0
+        self._scroll_offset = 0
+
+        if not text:
+            # Empty query: re-show saved searches via the provider.
+            self._items = self._search.saved_searches()
+            self._refresh_viewport(text)
+            return
+
+        if len(text) < MIN_QUERY_LEN:
+            # Too short to query notmuch; offer just the bare-query handoff.
+            self._items = [BareQueryHandoff(query=text)]
+            self._refresh_viewport(text)
+            return
+
+        # Show the bare-query handoff immediately while we wait for the search
+        # — gives the user a way to commit before the debounce fires.
+        self._items = [BareQueryHandoff(query=text)]
+        self._refresh_viewport(text)
+        self._debounce_id = GLib.timeout_add(
+            DEBOUNCE_MS, self._on_debounce_fire, text
+        )
+
+    def _cancel_debounce(self):
+        if self._debounce_id is not None:
+            GLib.source_remove(self._debounce_id)
+            self._debounce_id = None
+
+    def _on_debounce_fire(self, text: str):
+        self._debounce_id = None
+        if self.search_entry.get_text() != text:
+            return False
+        hits = self._search.search(text)
+        items: list[Any] = list(hits)
+        items.append(BareQueryHandoff(query=text))
+        self._items = items
+        self._selected_index = 0
+        self._scroll_offset = 0
+        self._refresh_viewport(text)
+        return False

sims/modules/launcher/power.py

@@ -0,0 +1,25 @@
+import subprocess
+
+from .base import FuzzyMenu, StaticActionProvider
+
+
+def _spawn(argv: list[str]) -> None:
+    subprocess.Popen(argv, start_new_session=True)
+
+
+def PowerMenu(monitor: int = 0, lock_command: list[str] | None = None) -> FuzzyMenu:
+    lock = lock_command or ["waylock"]
+    provider = StaticActionProvider(
+        actions=[
+            ("⏻ Poweroff", lambda: _spawn(["systemctl", "poweroff"])),
+            ("🔁 Reboot",  lambda: _spawn(["systemctl", "reboot"])),
+            ("⏾ Suspend", lambda: _spawn(["systemctl", "suspend"])),
+            ("Lock",       lambda: _spawn(lock)),
+        ]
+    )
+    return FuzzyMenu(
+        provider=provider,
+        monitor=monitor,
+        placeholder="Power Menu...",
+        window_name="power-menu",
+    )

sims/modules/launcher/screenrec.py

@@ -0,0 +1,30 @@
+from sims.services.screenrec import ScreenrecService
+
+from .base import FuzzyMenu, StaticActionProvider
+
+
+def _idle_actions(service: ScreenrecService):
+    return [
+        ("Monitor → Videos",     lambda: service.start_monitor("videos")),
+        ("Region → Videos",      lambda: service.start_region("videos")),
+        ("Monitor → Clipboard",  lambda: service.start_monitor("clipboard")),
+        ("Region → Clipboard",   lambda: service.start_region("clipboard")),
+    ]
+
+
+def ScreenrecProvider(service: ScreenrecService) -> StaticActionProvider:
+    def items():
+        if service.recording:
+            return [("Stop Recording", service.stop)]
+        return _idle_actions(service)
+
+    return StaticActionProvider(items_factory=items)
+
+
+def ScreenrecMenu(service: ScreenrecService, monitor: int = 0) -> FuzzyMenu:
+    return FuzzyMenu(
+        provider=ScreenrecProvider(service),
+        monitor=monitor,
+        placeholder="Screen Recording...",
+        window_name="screenrec-menu",
+    )

sims/modules/launcher/screenshot.py

@@ -0,0 +1,23 @@
+import subprocess
+
+from .base import FuzzyMenu, StaticActionProvider
+
+
+def _spawn(argv: list[str]) -> None:
+    subprocess.Popen(argv, start_new_session=True)
+
+
+def ScreenshotMenu(monitor: int = 0) -> FuzzyMenu:
+    provider = StaticActionProvider(
+        actions=[
+            ("Normal",        lambda: _spawn(["grimnorm"])),
+            ("To Clipboard",  lambda: _spawn(["grim2clip"])),
+            ("To Imv",        lambda: _spawn(["grim2imv"])),
+        ]
+    )
+    return FuzzyMenu(
+        provider=provider,
+        monitor=monitor,
+        placeholder="Screenshot...",
+        window_name="screenshot-menu",
+    )

sims/modules/launcher/windows.py

@@ -0,0 +1,60 @@
+from sims.services.i3 import I3, I3MessageType
+from fabric.widgets.box import Box
+from fabric.widgets.label import Label
+from gi.repository import Gtk
+
+
+class WindowProvider:
+    def items(self) -> list[dict]:
+        windows: list[dict] = []
+        tree_reply = I3.send_command("", I3MessageType.GET_TREE)
+        if not (tree_reply.is_ok and isinstance(tree_reply.reply, dict)):
+            return windows
+
+        tree = tree_reply.reply
+        for output_node in tree.get("nodes", []):
+            for ws_node in output_node.get("nodes", []):
+                ws_num = ws_node.get("num", 0)
+                for con in ws_node.get("nodes", []):
+                    if con.get("type") == "con":
+                        windows.append({
+                            "id": con.get("id"),
+                            "app_id": con.get("app_id") or "",
+                            "title": con.get("name") or "",
+                            "workspace": ws_num,
+                        })
+                for con in ws_node.get("floating_nodes", []):
+                    if con.get("type") == "con":
+                        windows.append({
+                            "id": con.get("id"),
+                            "app_id": con.get("app_id") or "",
+                            "title": con.get("name") or "",
+                            "workspace": ws_num,
+                        })
+        return windows
+
+    def filter(self, items: list[dict], query: str) -> list[dict]:
+        if not query:
+            return items
+        q = query.lower()
+        return [
+            w for w in items
+            if q in w.get("title", "").lower()
+            or q in w.get("app_id", "").lower()
+        ]
+
+    def render(self, item: dict) -> Gtk.Widget:
+        title = item.get("title", "")
+        app_id = item.get("app_id", "")
+        ws_num = item.get("workspace", 0)
+        text = f"[{ws_num}] {app_id}: {title}" if app_id else f"[{ws_num}] {title}"
+        return Box(
+            name="slot-box",
+            orientation="h",
+            children=[Label(label=text)],
+        )
+
+    def activate(self, item: dict) -> None:
+        window_id = item.get("id")
+        if window_id is not None:
+            I3.send_command(f"[con_id={window_id}] focus")

sims/modules/notifications.py

@@ -0,0 +1,54 @@
+from typing import cast
+
+from fabric.notifications import Notification, Notifications
+from fabric.widgets.box import Box
+from fabric.widgets.wayland import WaylandWindow as Window
+from loguru import logger
+
+from sims.widgets.notification import NotificationWidget
+
+
+class NotificationToasts(Window):
+    def __init__(
+        self,
+        service: Notifications,
+        monitor: int = 0,
+        anchor: str = "top center",
+        margin: str = "8px",
+        width: int = 360,
+        timeout_ms: int = 10_000,
+    ):
+        super().__init__(
+            name="notification-toasts",
+            anchor=anchor,
+            monitor=monitor,
+            margin=margin,
+            exclusivity="none",
+            visible=True,
+            all_visible=True,
+        )
+        self._width = width
+        self._timeout_ms = timeout_ms
+
+        self._stack = Box(
+            size=2,  # so the compositor doesn't optimize the empty surface away
+            spacing=4,
+            orientation="v",
+        )
+        self.add(self._stack)
+
+        self._service = service
+        self._service.connect("notification-added", self._on_added)
+
+    def _on_added(self, service: Notifications, nid: int):
+        notification = cast(Notification, service.get_notification_from_id(nid))
+        if notification is None:
+            logger.warning(f"[Notifications] no notification for id {nid}")
+            return
+        self._stack.add(
+            NotificationWidget(
+                notification,
+                width=self._width,
+                timeout_ms=self._timeout_ms,
+            )
+        )

sims/modules/notmuch.py

@@ -0,0 +1,208 @@
+import os
+import subprocess
+import shutil
+
+# Add common binary paths to PATH for user binaries
+os.environ['PATH'] = '/run/current-system/sw/bin:/home/' + os.environ.get('USER', 'user') + '/.nix-profile/bin:' + os.environ.get('PATH', '')
+from fabric.widgets.box import Box
+from fabric.widgets.label import Label
+from fabric.widgets.button import Button
+from fabric.widgets.image import Image
+from loguru import logger
+from sims.config import NOTMUCH
+
+
+DEFAULT_DEBT_QUERY = "tag:unread and date:..1w"
+DEFAULT_DEBT_WARN_AT = 1
+DEFAULT_DEBT_ALARM_AT = 6
+
+
+class NotmuchService:
+    def __init__(self, update_interval=60000):  # 1 minute default
+        self.unread_count = 0
+        self.debt_count = 0
+        self.callbacks = []
+        self._update_interval = update_interval
+        self._timer_id = None
+
+        # Initial load
+        self.update_counts()
+        # Start periodic updates
+        self.start_monitoring()
+
+    def connect(self, signal_name, callback):
+        """Simple callback system to replace signals"""
+        if signal_name == "counts-changed":
+            self.callbacks.append(callback)
+
+    def emit_counts_changed(self):
+        """Emit counts changed to all callbacks"""
+        for callback in self.callbacks:
+            callback(self, self.unread_count, self.debt_count)
+
+    def start_monitoring(self):
+        """Start periodic unread count updates"""
+        if self._timer_id is None:
+            from fabric.utils import invoke_repeater
+
+            self._timer_id = invoke_repeater(
+                self._update_interval, self._periodic_update
+            )
+            logger.info(
+                f"[Notmuch] Started periodic updates every {self._update_interval/1000} seconds"
+            )
+
+    def stop_monitoring(self):
+        """Stop periodic unread count updates"""
+        if self._timer_id is not None:
+            from gi.repository import GLib
+
+            GLib.source_remove(self._timer_id)
+            self._timer_id = None
+            logger.info("[Notmuch] Stopped periodic updates")
+
+    def _periodic_update(self):
+        """Periodic update callback"""
+        logger.info("[Notmuch] Performing periodic count update")
+        self.update_counts()
+        return True  # Keep the timer running
+
+    def get_cached_count(self):
+        """Get cached unread count without triggering update"""
+        return self.unread_count
+
+    def get_cached_debt_count(self):
+        """Get cached debt count without triggering update"""
+        return self.debt_count
+
+    def _run_count(self, notmuch_path, query):
+        cmd = [notmuch_path, "count", query]
+        logger.info(f"[Notmuch] Running command: {' '.join(cmd)}")
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        out = result.stdout.strip()
+        return int(out) if out else 0
+
+    def update_counts(self):
+        """Fetch unread + debt counts from notmuch"""
+        # Check if notmuch is enabled
+        if not NOTMUCH.get("enable", True):
+            logger.info("[Notmuch] Notmuch is disabled in config")
+            self.unread_count = 0
+            self.debt_count = 0
+            self.emit_counts_changed()
+            return
+
+        # Get notmuch path from config
+        notmuch_path = NOTMUCH.get("notmuch_path", "notmuch")
+
+        # Check if notmuch is available
+        if not shutil.which(notmuch_path):
+            logger.warning(f"[Notmuch] notmuch not found at '{notmuch_path}'. Please install notmuch or configure the correct path.")
+            self.unread_count = 0
+            self.debt_count = 0
+            self.emit_counts_changed()
+            return
+
+        debt_query = NOTMUCH.get("debt_query", DEFAULT_DEBT_QUERY)
+
+        try:
+            self.unread_count = self._run_count(notmuch_path, "tag:unread")
+            self.debt_count = self._run_count(notmuch_path, debt_query)
+            logger.info(
+                f"[Notmuch] {self.unread_count} unread, {self.debt_count} aging (debt query: {debt_query!r})"
+            )
+            self.emit_counts_changed()
+        except subprocess.CalledProcessError as e:
+            logger.error(f"[Notmuch] Failed to fetch counts: {e}")
+            self.unread_count = 0
+            self.debt_count = 0
+            self.emit_counts_changed()
+        except ValueError as e:
+            logger.error(f"[Notmuch] Error parsing count: {e}")
+            self.unread_count = 0
+            self.debt_count = 0
+            self.emit_counts_changed()
+        except Exception as e:
+            logger.error(f"[Notmuch] Error getting counts: {e}")
+            self.unread_count = 0
+            self.debt_count = 0
+            self.emit_counts_changed()
+
+
+class NotmuchWidget(Button):
+    def __init__(self, **kwargs):
+        # Create the widget content
+        self.icon = Image(icon_name="mail-unread-symbolic", icon_size=16)
+        self.label = Label("0", name="unread-count")
+
+        # Container for icon and label
+        container = Box(
+            orientation="h",
+            spacing=4,
+            children=[self.icon, self.label]
+        )
+
+        super().__init__(
+            name="notmuch-widget",
+            child=container,
+            on_clicked=self.open_email_client,
+            **kwargs,
+        )
+
+        # Initialize the service
+        self.service = NotmuchService()
+        self.service.connect("counts-changed", self.update_display)
+
+        logger.info("[Notmuch] Notmuch widget initialized")
+
+        # Initial update
+        self.update_display(
+            self.service, self.service.unread_count, self.service.debt_count
+        )
+
+    def open_email_client(self, button=None):
+        """Open notmuch in emacsclient"""
+        emacsclient_command = NOTMUCH.get("emacsclient_command", "emacsclient")
+
+        try:
+            # Open emacsclient with notmuch function
+            cmd = [emacsclient_command, "-c", "-e", "(notmuch)"]
+            logger.info(f"[Notmuch] Running emacsclient command: {' '.join(cmd)}")
+            subprocess.Popen(cmd, start_new_session=True)
+            logger.info(f"[Notmuch] Successfully started emacsclient process")
+        except Exception as e:
+            logger.error(f"[Notmuch] Failed to open notmuch in emacsclient '{emacsclient_command}': {e}")
+
+    def update_display(self, service, unread, debt):
+        """Update the widget display with unread + debt counts"""
+        warn_at = NOTMUCH.get("debt_warn_at", DEFAULT_DEBT_WARN_AT)
+        alarm_at = NOTMUCH.get("debt_alarm_at", DEFAULT_DEBT_ALARM_AT)
+
+        classes = ["notmuch-widget"]
+        if unread > 0:
+            self.label.set_text(str(unread))
+            self.label.set_visible(True)
+            self.icon.set_property("icon-name", "mail-unread-symbolic")
+            classes.append("has-unread")
+        else:
+            self.label.set_text("")
+            self.label.set_visible(False)
+            self.icon.set_property("icon-name", "mail-read-symbolic")
+            classes.append("no-unread")
+
+        if debt >= alarm_at:
+            classes.append("debt-alarm")
+        elif debt >= warn_at:
+            classes.append("debt-warn")
+
+        self.set_style_classes(classes)
+        self.set_tooltip_text(f"{unread} unread · {debt} aging")
+
+        logger.info(
+            f"[Notmuch] Updated display: {unread} unread, {debt} aging — classes={classes}"
+        )

sims/modules/player.py

@@ -1,20 +1,41 @@
+import contextlib
 import os
 import urllib.parse
 import urllib.request
 import tempfile
-from gi.repository import Gtk, GLib, Gio, Gdk
+from gi.repository import Gtk, GLib, Gio, Gdk, Pango
 from fabric.widgets.box import Box
 from fabric.widgets.centerbox import CenterBox
 from fabric.widgets.label import Label
 from fabric.widgets.button import Button
+from fabric.widgets.image import Image
 from fabric.widgets.circularprogressbar import CircularProgressBar
 from fabric.widgets.overlay import Overlay
 from fabric.widgets.stack import Stack
 from ..widgets.circle_image import CircleImage
-import bar.modules.icons as icons
-from bar.services.mpris import MprisPlayerManager, MprisPlayer
+import sims.modules.icons as icons
+from sims.services.mpris import MprisPlayerManager, MprisPlayer
+from fabric import Fabricator
 
-# from bar.modules.cavalcade import SpectrumRender
+# from sims.modules.cavalcade import SpectrumRender
+
+
+def get_player_progress(fabricator, mpris_player):
+    """Get player progress for Fabricator"""
+    if not mpris_player:
+        return (0, 0, 0.0)
+
+    try:
+        current = mpris_player.position
+    except Exception:
+        current = 0
+    try:
+        total = int(mpris_player.length or 0)
+    except Exception:
+        total = 0
+
+    progress = current / total if total > 0 else 0.0
+    return (current, total, progress)
 
 
 def get_player_icon_markup_by_name(player_name):
@@ -503,30 +524,52 @@ class Player(Box):
         return False
 
 
-class PlayerSmall(CenterBox):
+class PlayerSmall(Box):
+    PLAY_ICON = "media-playback-start-symbolic"
+    PAUSE_ICON = "media-playback-pause-symbolic"
+    PREV_ICON = "media-skip-backward-symbolic"
+    NEXT_ICON = "media-skip-forward-symbolic"
+    FALLBACK_ICON = "audio-x-generic-symbolic"
+    COVER_SIZE = 22
+
     def __init__(self):
         super().__init__(
-            name="player-small", orientation="h", h_align="fill", v_align="center"
+            name="player-small", orientation="h", v_align="center"
         )
-        self._show_artist = False  # toggle flag
-        self._display_options = ["cavalcade", "title", "artist"]
+        self._display_options = ["title", "artist"]
         self._display_index = 0
-        self._current_display = "cavalcade"
+        self._current_display = "title"
+        self._spin_timer_id = None
+        self._spin_step = 2  # deg per tick → ~9s per rotation at 50ms
+        self._spin_interval_ms = 50
+
+        self.cover = CircleImage(
+            name="compact-mpris-cover",
+            size=self.COVER_SIZE,
+            h_align="center",
+            v_align="center",
+        )
+        self.fallback_icon = Image(
+            name="compact-mpris-fallback",
+            icon_name=self.FALLBACK_ICON,
+            icon_size=16,
+        )
+        self.cover_stack = Stack(
+            name="compact-mpris-cover-stack",
+            transition_type="crossfade",
+            transition_duration=200,
+            children=[self.fallback_icon, self.cover],
+        )
+        self.cover_stack.set_visible_child(self.fallback_icon)
 
         self.mpris_icon = Button(
             name="compact-mpris-icon",
             h_align="center",
             v_align="center",
-            child=Label(name="compact-mpris-icon-label", markup=icons.disc),
+            child=self.cover_stack,
         )
-        # Remove scroll events; instead, add button press events.
         self.mpris_icon.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
         self.mpris_icon.connect("button-press-event", self._on_icon_button_press)
-        # Prevent the child from propagating events.
-        child = self.mpris_icon.get_child()
-        child.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
-        child.connect("button-press-event", lambda widget, event: True)
-        # Add hover effect
         add_hover_cursor(self.mpris_icon)
 
         self.mpris_label = Label(
@@ -536,36 +579,36 @@ class PlayerSmall(CenterBox):
             max_chars_width=26,
             h_align="center",
         )
+        self._width_tween_id = None
+        self._current_label_width_px = None
+        self._width_tween_duration_ms = 220
+
+        self.play_image = Image(
+            name="compact-mpris-button-icon",
+            icon_name=self.PLAY_ICON,
+            icon_size=16,
+        )
         self.mpris_button = Button(
             name="compact-mpris-button",
             h_align="center",
             v_align="center",
-            child=Label(name="compact-mpris-button-label", markup=icons.play),
+            child=self.play_image,
         )
         self.mpris_button.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
         self.mpris_button.connect(
             "button-press-event", self._on_play_pause_button_press
         )
-        # Add hover effect
         add_hover_cursor(self.mpris_button)
 
-        # self.cavalcade = SpectrumRender()
-        # self.cavalcade_box = self.cavalcade.get_spectrum_box()
-
         self.center_stack = Stack(
             name="compact-mpris",
             transition_type="crossfade",
             transition_duration=100,
             v_align="center",
             v_expand=False,
-            children=[
-                # self.cavalcade_box,
-                self.mpris_label,
-            ],
+            children=[self.mpris_label],
         )
-        # self.center_stack.set_visible_child(self.cavalcade_box)  # default to cavalcade
 
-        # Create additional compact view.
         self.mpris_small = CenterBox(
             name="compact-mpris",
             orientation="h",
@@ -574,7 +617,7 @@ class PlayerSmall(CenterBox):
             v_align="center",
             v_expand=False,
             start_children=self.mpris_icon,
-            center_children=self.center_stack,  # Changed to center_stack to handle stack switching
+            center_children=self.center_stack,
             end_children=self.mpris_button,
         )
 
@@ -582,157 +625,307 @@ class PlayerSmall(CenterBox):
 
         self.mpris_manager = MprisPlayerManager()
         self.mpris_player = None
-        # Almacenar el índice del reproductor actual
-        self.current_index = 0
+        self._players = {}
+        self._player_handlers = {}
+        self._last_status = {}
 
-        players = self.mpris_manager.players
-        if players:
-            mp = MprisPlayer(players[self.current_index])
-            self.mpris_player = mp
-            self._apply_mpris_properties()
-            self.mpris_player.connect("changed", self._on_mpris_changed)
-        else:
-            self._apply_mpris_properties()
+        for p in self.mpris_manager.players:
+            self._track_player(p)
+        self._select_initial_player()
+        self._apply_mpris_properties()
 
         self.mpris_manager.connect("player-appeared", self.on_player_appeared)
         self.mpris_manager.connect("player-vanished", self.on_player_vanished)
-        self.mpris_button.connect("clicked", self._on_play_pause_clicked)
+
+    def _char_width_px(self):
+        metrics = self.mpris_label.get_pango_context().get_metrics(None, None)
+        return max(1.0, metrics.get_approximate_char_width() / Pango.SCALE)
+
+    def _measure_text_width(self, text):
+        if not text:
+            return 0
+        layout = self.mpris_label.create_pango_layout(text)
+        text_width_px, _ = layout.get_pixel_size()
+        max_px = int(self._char_width_px() * 26)
+        return min(text_width_px, max_px)
+
+    def _apply_label_width(self, width_px):
+        if width_px <= 0:
+            self.mpris_label.set_size_request(0, -1)
+            if self.mpris_label.get_margin_start() != 0:
+                self.mpris_label.set_margin_start(0)
+                self.mpris_label.set_margin_end(0)
+            if self.mpris_label.get_visible():
+                self.mpris_label.set_visible(False)
+            self._current_label_width_px = 0
+            return
+
+        if not self.mpris_label.get_visible():
+            self.mpris_label.set_visible(True)
+        chars = max(1, int(round(width_px / self._char_width_px())))
+        if chars != self.mpris_label.get_max_width_chars():
+            self.mpris_label.set_max_width_chars(chars)
+        self.mpris_label.set_size_request(width_px, -1)
+        margin = min(6, width_px // 2)
+        if self.mpris_label.get_margin_start() != margin:
+            self.mpris_label.set_margin_start(margin)
+            self.mpris_label.set_margin_end(margin)
+        self._current_label_width_px = width_px
+
+    def _set_label_text(self, text):
+        target_text = text or ""
+        target_px = self._measure_text_width(target_text)
+
+        if self._width_tween_id is not None:
+            GLib.source_remove(self._width_tween_id)
+            self._width_tween_id = None
+
+        # First call — snap to target without animation.
+        if self._current_label_width_px is None:
+            self.mpris_label.set_text(target_text)
+            self._apply_label_width(target_px)
+            return
+
+        start_px = self._current_label_width_px
+
+        # Growing from collapsed: set new text first so it's ready to reveal.
+        # Cross-fading between two non-empty texts: also swap text immediately.
+        # Shrinking to empty: keep old text visible while it shrinks, clear at end.
+        if target_px > 0:
+            self.mpris_label.set_text(target_text)
+
+        if start_px == target_px:
+            self._apply_label_width(target_px)
+            return
+
+        duration_ms = self._width_tween_duration_ms
+        start_time = GLib.get_monotonic_time()
+
+        def tick():
+            elapsed_ms = (GLib.get_monotonic_time() - start_time) / 1000.0
+            progress = min(1.0, elapsed_ms / duration_ms)
+            t = 1 - (1 - progress) ** 3  # ease-out cubic
+            cur_px = int(start_px + (target_px - start_px) * t)
+            self._apply_label_width(cur_px)
+            if progress >= 1.0:
+                self._apply_label_width(target_px)
+                if target_px == 0:
+                    self.mpris_label.set_text("")
+                self._width_tween_id = None
+                return False
+            return True
+
+        self._width_tween_id = GLib.timeout_add(16, tick)
+
+    def _set_cover_from_path(self, image_path):
+        if image_path and os.path.isfile(image_path):
+            try:
+                self.cover.set_image_from_file(image_path)
+                self.cover_stack.set_visible_child(self.cover)
+                self._update_spin()
+                return False
+            except Exception:
+                pass
+        self.cover_stack.set_visible_child(self.fallback_icon)
+        self._update_spin()
+        return False
+
+    def _start_spin(self):
+        if self._spin_timer_id is None:
+            self._spin_timer_id = GLib.timeout_add(
+                self._spin_interval_ms, self._advance_spin
+            )
+
+    def _stop_spin(self):
+        if self._spin_timer_id is not None:
+            GLib.source_remove(self._spin_timer_id)
+            self._spin_timer_id = None
+
+    def _advance_spin(self):
+        self.cover.angle = (self.cover.angle + self._spin_step) % 360
+        return True
+
+    def _update_spin(self):
+        showing_cover = self.cover_stack.get_visible_child() is self.cover
+        is_playing = (
+            self.mpris_player is not None
+            and self.mpris_player.playback_status == "playing"
+        )
+        if showing_cover and is_playing:
+            self._start_spin()
+        else:
+            self._stop_spin()
+
+    def _download_artwork(self, arturl):
+        try:
+            parsed = urllib.parse.urlparse(arturl)
+            suffix = os.path.splitext(parsed.path)[1] or ".png"
+            with urllib.request.urlopen(arturl) as response:
+                data = response.read()
+            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
+            tmp.write(data)
+            tmp.close()
+            local_path = tmp.name
+        except Exception:
+            local_path = None
+        GLib.idle_add(self._set_cover_from_path, local_path)
+        return None
+
+    def _update_cover(self, mp):
+        if not mp or not mp.arturl:
+            self.cover_stack.set_visible_child(self.fallback_icon)
+            return
+        parsed = urllib.parse.urlparse(mp.arturl)
+        if parsed.scheme == "file":
+            self._set_cover_from_path(urllib.parse.unquote(parsed.path))
+        elif parsed.scheme in ("http", "https"):
+            GLib.Thread.new("compact-artwork", self._download_artwork, mp.arturl)
+        else:
+            self._set_cover_from_path(mp.arturl)
 
     def _apply_mpris_properties(self):
         if not self.mpris_player:
-            self.mpris_label.set_text("Nothing Playing")
-            self.mpris_button.get_child().set_markup(icons.stop)
-            self.mpris_icon.get_child().set_markup(icons.disc)
-            if self._current_display != "cavalcade":
-                self.center_stack.set_visible_child(
-                    self.mpris_label
-                )  # if was title or artist, keep showing label
-            # else:
-            # self.center_stack.set_visible_child(
-            #     self.cavalcade_box
-            # )  # default to cavalcade if no player
+            self._set_label_text("")
+            self.play_image.set_property("icon-name", self.PLAY_ICON)
+            self.cover_stack.set_visible_child(self.fallback_icon)
+            self.center_stack.set_visible_child(self.mpris_label)
+            self._update_spin()
             return
 
         mp = self.mpris_player
-
-        # Choose icon based on player name.
-        player_name = (
-            mp.player_name.lower()
-            if hasattr(mp, "player_name") and mp.player_name
-            else ""
-        )
-        icon_markup = get_player_icon_markup_by_name(player_name)
-        self.mpris_icon.get_child().set_markup(icon_markup)
+        self._update_cover(mp)
         self.update_play_pause_icon()
 
         if self._current_display == "title":
-            text = mp.title if mp.title and mp.title.strip() else "Nothing Playing"
-            self.mpris_label.set_text(text)
-            self.center_stack.set_visible_child(self.mpris_label)
-        elif self._current_display == "artist":
-            text = mp.artist if mp.artist else "Nothing Playing"
-            self.mpris_label.set_text(text)
-            self.center_stack.set_visible_child(self.mpris_label)
-        # else:  # default cavalcade
-        # self.center_stack.set_visible_child(self.cavalcade_box)
+            text = mp.title.strip() if mp.title and mp.title.strip() else ""
+        else:  # "artist"
+            text = mp.artist.strip() if mp.artist and mp.artist.strip() else ""
+        self._set_label_text(text)
+        self.center_stack.set_visible_child(self.mpris_label)
 
     def _on_icon_button_press(self, widget, event):
-        from gi.repository import Gdk
+        if event.type != Gdk.EventType.BUTTON_PRESS:
+            return True
 
-        if event.type == Gdk.EventType.BUTTON_PRESS:
-            players = self.mpris_manager.players
-            if not players:
+        if event.button == 2:
+            if not self.mpris_player:
                 return True
-
-            if event.button == 2:  # Middle-click: cycle display
-                self._display_index = (self._display_index + 1) % len(
-                    self._display_options
-                )
-                self._current_display = self._display_options[self._display_index]
-                self._apply_mpris_properties()  # Re-apply to update label/cavalcade
-                return True
-
-            # Cambiar de reproductor según el botón presionado.
-            if event.button == 1:  # Left-click: next player
-                self.current_index = (self.current_index + 1) % len(players)
-            elif event.button == 3:  # Right-click: previous player
-                self.current_index = (self.current_index - 1) % len(players)
-                if self.current_index < 0:
-                    self.current_index = len(players) - 1
-
-            mp_new = MprisPlayer(players[self.current_index])
-            self.mpris_player = mp_new
-            # Conectar el evento "changed" para que se actualice
-            self.mpris_player.connect("changed", self._on_mpris_changed)
+            self._display_index = (self._display_index + 1) % len(self._display_options)
+            self._current_display = self._display_options[self._display_index]
             self._apply_mpris_properties()
-            return True  # Se consume el evento
+            return True
+
+        players = list(self._players.values())
+        if not players:
+            return True
+
+        idx = players.index(self.mpris_player) if self.mpris_player in players else -1
+        if event.button == 1:
+            idx = (idx + 1) % len(players)
+        elif event.button == 3:
+            idx = (idx - 1) % len(players)
+        else:
+            return True
+
+        self.mpris_player = players[idx]
+        self._apply_mpris_properties()
         return True
 
     def _on_play_pause_button_press(self, widget, event):
-        if event.type == Gdk.EventType.BUTTON_PRESS:
-            if event.button == 1:  # Click izquierdo -> track anterior
-                if self.mpris_player:
-                    self.mpris_player.previous()
-                    self.mpris_button.get_child().set_markup(icons.prev)
-                    GLib.timeout_add(500, self._restore_play_pause_icon)
-            elif event.button == 3:  # Click derecho -> siguiente track
-                if self.mpris_player:
-                    self.mpris_player.next()
-                    self.mpris_button.get_child().set_markup(icons.next)
-                    GLib.timeout_add(500, self._restore_play_pause_icon)
-            elif event.button == 2:  # Click medio -> play/pausa
-                if self.mpris_player:
-                    self.mpris_player.play_pause()
-                    self.update_play_pause_icon()
+        if event.type != Gdk.EventType.BUTTON_PRESS or not self.mpris_player:
             return True
+        if event.button == 1:
+            self.mpris_player.play_pause()
+            self.update_play_pause_icon()
+        elif event.button == 3:
+            self.mpris_player.next()
+            self.play_image.set_property("icon-name", self.NEXT_ICON)
+            GLib.timeout_add(500, self._restore_play_pause_icon)
+        elif event.button == 2:
+            self.mpris_player.previous()
+            self.play_image.set_property("icon-name", self.PREV_ICON)
+            GLib.timeout_add(500, self._restore_play_pause_icon)
         return True
 
     def _restore_play_pause_icon(self):
         self.update_play_pause_icon()
         return False
 
-    def _on_icon_clicked(
-        self, widget
-    ):  # No longer used, logic moved to _on_icon_button_press
-        pass
-
     def update_play_pause_icon(self):
-        if self.mpris_player and self.mpris_player.playback_status == "playing":
-            self.mpris_button.get_child().set_markup(icons.pause)
-        else:
-            self.mpris_button.get_child().set_markup(icons.play)
+        playing = (
+            self.mpris_player
+            and self.mpris_player.playback_status == "playing"
+        )
+        self.play_image.set_property(
+            "icon-name", self.PAUSE_ICON if playing else self.PLAY_ICON
+        )
+        self._update_spin()
 
-    def _on_play_pause_clicked(self, button):
-        if self.mpris_player:
-            self.mpris_player.play_pause()
-            self.update_play_pause_icon()
+    def _track_player(self, playerctl_player):
+        mp = MprisPlayer(playerctl_player)
+        name = mp.player_name
+        handler_id = mp.connect("changed", self._on_any_player_changed)
+        self._players[name] = mp
+        self._player_handlers[name] = handler_id
+        self._last_status[name] = mp.playback_status
 
-    def _on_mpris_changed(self, *args):
-        # Update properties when the player's state changes.
-        self._apply_mpris_properties()
+    def _untrack_player(self, name):
+        mp = self._players.pop(name, None)
+        handler_id = self._player_handlers.pop(name, None)
+        self._last_status.pop(name, None)
+        if mp and handler_id is not None:
+            with contextlib.suppress(Exception):
+                mp.disconnect(handler_id)
+
+    def _select_initial_player(self):
+        for mp in self._players.values():
+            if mp.playback_status == "playing":
+                self.mpris_player = mp
+                return
+        if self._players:
+            self.mpris_player = next(iter(self._players.values()))
+
+    def _on_any_player_changed(self, player):
+        name = player.player_name
+        prev_status = self._last_status.get(name)
+        cur_status = player.playback_status
+        self._last_status[name] = cur_status
+
+        if player is self.mpris_player:
+            self._apply_mpris_properties()
+            return
+
+        # Auto-follow: only on a fresh transition into "playing", and only
+        # if the active player isn't already playing (so a manual selection
+        # of a paused player isn't overridden by the player it was already
+        # competing with).
+        if cur_status == "playing" and prev_status != "playing":
+            active_playing = (
+                self.mpris_player
+                and self.mpris_player.playback_status == "playing"
+            )
+            if not active_playing:
+                self.mpris_player = player
+                self._apply_mpris_properties()
 
     def on_player_appeared(self, manager, player):
-        # When a new player appears, use it if no player is active.
+        self._track_player(player)
         if not self.mpris_player:
-            mp = MprisPlayer(player)
-            self.mpris_player = mp
+            name = player.get_property("player-name")
+            self.mpris_player = self._players.get(name)
             self._apply_mpris_properties()
-            self.mpris_player.connect("changed", self._on_mpris_changed)
 
     def on_player_vanished(self, manager, player_name):
-        players = self.mpris_manager.players
-        if (
-            players
-            and self.mpris_player
-            and self.mpris_player.player_name == player_name
-        ):
-            if players:  # Check if players is not empty after vanishing
-                self.current_index = self.current_index % len(players)
-                new_player = MprisPlayer(players[self.current_index])
-                self.mpris_player = new_player
-                self.mpris_player.connect("changed", self._on_mpris_changed)
-            else:
-                self.mpris_player = None  # No players left
-        elif not players:
-            self.mpris_player = None
-        self._apply_mpris_properties()
+        was_active = (
+            self.mpris_player and self.mpris_player.player_name == player_name
+        )
+        self._untrack_player(player_name)
+        if was_active:
+            replacement = next(
+                (mp for mp in self._players.values() if mp.playback_status == "playing"),
+                None,
+            )
+            if replacement is None and self._players:
+                replacement = next(iter(self._players.values()))
+            self.mpris_player = replacement
+            self._apply_mpris_properties()

sims/modules/screenrec.py

@@ -0,0 +1,59 @@
+import time
+
+from fabric.utils import invoke_repeater
+from fabric.widgets.box import Box
+from fabric.widgets.button import Button
+from fabric.widgets.label import Label
+from gi.repository import GLib
+
+from sims.services.screenrec import ScreenrecService
+
+
+class ScreenrecWidget(Button):
+    def __init__(self, service: ScreenrecService, **kwargs):
+        self._service = service
+        self._timer_id: int | None = None
+
+        self._dot = Label(name="screenrec-dot", label="●")
+        self._elapsed = Label(name="screenrec-elapsed", label="00:00")
+
+        super().__init__(
+            name="screenrec-widget",
+            child=Box(
+                orientation="h",
+                spacing=6,
+                children=[self._dot, self._elapsed],
+            ),
+            on_clicked=lambda *_: self._service.stop(),
+            visible=False,
+            **kwargs,
+        )
+        self.set_no_show_all(True)
+
+        self._service.connect("recording-changed", self._on_recording_changed)
+        if self._service.recording:
+            self._on_recording_changed(self._service, True)
+
+    def _on_recording_changed(self, _service, recording: bool):
+        if recording:
+            self._update_elapsed()
+            self.set_visible(True)
+            if self._timer_id is None:
+                self._timer_id = invoke_repeater(1000, self._update_elapsed)
+        else:
+            self.set_visible(False)
+            if self._timer_id is not None:
+                try:
+                    GLib.source_remove(self._timer_id)
+                except Exception:
+                    pass
+                self._timer_id = None
+
+    def _update_elapsed(self) -> bool:
+        started = self._service.started_at
+        if started is None:
+            self._elapsed.set_text("00:00")
+            return True
+        secs = int(time.monotonic() - started)
+        self._elapsed.set_text(f"{secs // 60:02d}:{secs % 60:02d}")
+        return True

sims/modules/stylix.py

@@ -0,0 +1,475 @@
+from sims.config import STYLIX
+import tempfile
+import os
+
+
+def generate_stylix_css():
+    """Generate CSS using Stylix colors if enabled"""
+    if not STYLIX.get("enable", False):
+        return None
+
+    colors = STYLIX.get("colors", {})
+    fonts = STYLIX.get("fonts", {})
+
+    # Default colors if Stylix is not properly configured
+    default_colors = {
+        "base00": "1e1e2e",  # background
+        "base01": "313244",  # lighter background
+        "base02": "45475a",  # selection background
+        "base03": "585b70",  # comments
+        "base04": "bac2de",  # dark foreground
+        "base05": "cdd6f4",  # foreground
+        "base06": "f5e0dc",  # light foreground
+        "base07": "b4befe",  # light background
+        "base08": "f38ba8",  # red
+        "base09": "fab387",  # orange
+        "base0A": "f9e2af",  # yellow
+        "base0B": "a6e3a1",  # green
+        "base0C": "94e2d5",  # cyan
+        "base0D": "89b4fa",  # blue
+        "base0E": "cba6f7",  # purple
+        "base0F": "f2cdcd",  # brown
+    }
+
+    # Use Stylix colors or fallback to defaults
+    for key in default_colors:
+        if key not in colors:
+            colors[key] = default_colors[key]
+
+    # Default font
+    font_family = fonts.get("sansSerif", "sans-serif")
+    font_sizes = fonts.get("sizes", {})
+    # Use desktop font size for the bar, fallback to applications, then default
+    font_size = font_sizes.get("desktop", font_sizes.get("applications", 14))
+
+    # Calculate relative font sizes
+    small_font = max(int(font_size * 0.85), 10)  # Minimum 10px
+    large_font = int(font_size * 1.1)
+
+    # Debug logging
+    from loguru import logger
+    logger.info(f"[Stylix] Using font sizes - Base: {font_size}px, Small: {small_font}px, Large: {large_font}px")
+
+    # Generate GTK CSS with Stylix colors
+    css_content = f"""/* Stylix-generated theme */
+
+/* Apply Stylix font */
+* {{
+    font-family: "{font_family}", sans-serif;
+    font-size: {font_size}px;
+}}
+
+/* Bar styling */
+#sims-inner {{
+    padding: 4px;
+    border-bottom: solid 2px;
+    border-color: #{colors["base02"]};
+    background-color: #{colors["base00"]};
+    border-radius: 0;
+    transition: border-radius 200ms ease;
+}}
+
+#sims-inner.rounded-bottom {{
+    border-radius: 0 0 28px 28px;
+}}
+
+#center-container {{
+    color: #{colors["base05"]};
+}}
+
+.active-window {{
+    color: #{colors["base05"]};
+    font-weight: bold;
+}}
+
+/* Battery */
+#battery-widget {{
+    background-color: #{colors["base01"]};
+    padding: 4px 8px;
+    border-radius: 12px;
+}}
+
+#bat-icon {{
+    color: #{colors["base0D"]};
+    margin-right: 2px;
+}}
+
+#bat-label {{
+    color: #{colors["base05"]};
+    font-size: {font_size}px;
+}}
+
+#bat-label.battery-low {{
+    color: #{colors["base08"]};
+    font-weight: bold;
+}}
+
+/* Progress bars */
+#cpu-progress-bar,
+#ram-progress-bar,
+#volume-progress-bar {{
+    color: transparent;
+    background-color: transparent;
+}}
+
+#cpu-progress-bar {{
+    border: solid 0px alpha(#{colors["base0E"]}, 0.8);
+}}
+
+#ram-progress-bar,
+#volume-progress-bar {{
+    border: solid 0px #{colors["base0D"]};
+}}
+
+/* Widgets container */
+#widgets-container {{
+    background-color: #{colors["base01"]};
+    padding: 2px;
+    border-radius: 16px;
+}}
+
+/* NixOS label */
+#nixos-label {{
+    color: #{colors["base0D"]};
+}}
+
+/* Date time */
+#date-time {{
+    color: #{colors["base05"]};
+    background-color: #{colors["base01"]};
+    padding: 4px 8px;
+    border-radius: 12px;
+}}
+
+#date-time-button {{
+    background: transparent;
+    border: none;
+    padding: 0;
+    margin: 0;
+    box-shadow: none;
+}}
+
+/* Generic popup styling */
+.popup-window,
+#calendar-popup,
+#quick-menu {{
+    background-color: #{colors["base00"]};
+    border: solid 2px #{colors["base02"]};
+    border-radius: 12px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.4), 0 2px 8px rgba(0, 0, 0, 0.2);
+    animation: slide-down 200ms ease-out;
+    /* Add subtle inner glow for better depth perception */
+    outline: 1px solid rgba(255, 255, 255, 0.05);
+    outline-offset: -1px;
+}}
+
+@keyframes slide-down {{
+    from {{
+        opacity: 0;
+        margin-top: -20px;
+    }}
+    to {{
+        opacity: 1;
+        margin-top: 10px;
+    }}
+}}
+
+#calendar-title {{
+    color: #{colors["base05"]};
+    font-weight: bold;
+    font-size: {large_font}px;
+    margin-bottom: 8px;
+}}
+
+#events-box {{
+    background-color: #{colors["base00"]};
+    border: solid 1px #{colors["base02"]};
+    border-radius: 8px;
+    padding: 16px;
+}}
+
+#no-events {{
+    color: #{colors["base03"]};
+}}
+
+/* Calendar event items */
+.event-item {{
+    border-radius: 6px;
+    padding: 8px 12px;
+    margin: 4px 0px;
+    transition: background-color 0.15s ease;
+}}
+
+#event-content {{
+    margin-left: 8px;
+}}
+
+.event-item.upcoming {{
+    background-color: #{colors["base01"]};
+}}
+
+.event-item.past {{
+    background-color: #{colors["base01"]};
+    opacity: 0.6;
+}}
+
+.event-title {{
+    font-weight: bold;
+    font-size: {font_size}px;
+}}
+
+.event-title.upcoming {{
+    color: #{colors["base05"]};
+}}
+
+.event-title.past {{
+    color: #{colors["base04"]};
+}}
+
+.event-time {{
+    font-size: {small_font}px;
+}}
+
+.event-time.upcoming {{
+    color: #{colors["base04"]};
+}}
+
+.event-time.past {{
+    color: #{colors["base03"]};
+}}
+
+.event-location {{
+    font-size: {small_font}px;
+}}
+
+.event-location.upcoming {{
+    color: #{colors["base03"]};
+}}
+
+.event-location.past {{
+    color: #{colors["base03"]};
+    opacity: 0.8;
+}}
+
+/* Tooltips */
+tooltip {{
+    border: solid 2px;
+    border-color: #{colors["base02"]};
+    background-color: #{colors["base00"]};
+    color: #{colors["base05"]};
+    border-radius: 16px;
+}}
+
+tooltip>* {{
+    padding: 2px 4px;
+}}
+
+/* Workspaces */
+#workspaces {{
+    background-color: #{colors["base01"]};
+    padding: 6px 6px;
+    border-radius: 16px;
+}}
+
+#workspaces>button {{
+    background-color: #{colors["base05"]};
+}}
+
+#workspaces>button.empty:not(.active):not(.visible) {{
+    background-color: #{colors["base03"]};
+}}
+
+#workspaces>button.visible:not(.active) {{
+    background-color: #{colors["base0E"]};
+}}
+
+#workspaces>button.active {{
+    background-color: #{colors["base0D"]};
+}}
+
+#workspaces>button.urgent {{
+    background-color: #{colors["base08"]};
+}}
+
+/* Workspace shown on a different monitor than this bar — dim it. */
+#workspaces>button.foreign {{
+    opacity: 0.45;
+}}
+
+#workspaces>button>label {{
+    font-size: 0px;
+}}
+
+/* Compact MPRIS player */
+#player-small {{
+    background-color: #{colors["base01"]};
+    padding: 6px;
+    border-radius: 100px;
+}}
+
+#compact-mpris-icon,
+#compact-mpris-button {{
+    background: transparent;
+    border: none;
+    padding: 0 4px;
+    margin: 0;
+    box-shadow: none;
+    min-height: 0;
+    min-width: 0;
+}}
+
+#compact-mpris-button-icon,
+#compact-mpris-fallback {{
+    color: #{colors["base05"]};
+}}
+
+#compact-mpris-button:hover #compact-mpris-button-icon {{
+    color: #{colors["base0D"]};
+}}
+
+#compact-mpris-fallback {{
+    opacity: 0.7;
+}}
+
+#compact-mpris-label {{
+    color: #{colors["base05"]};
+    font-size: {font_size}px;
+    margin: 0 6px;
+}}
+
+/* Quick Menu styling */
+#quick-menu-container {{
+    background-color: #{colors["base00"]};
+    border-radius: 8px;
+}}
+
+#quick-menu-button {{
+    background: transparent;
+    border: none;
+    padding: 4px;
+    margin: 0;
+    box-shadow: none;
+    color: #{colors["base05"]};
+}}
+
+#quick-menu-button:hover {{
+    background-color: #{colors["base01"]};
+    border-radius: 8px;
+}}
+
+.quick-menu-item {{
+    border-radius: 6px;
+    transition: background-color 0.15s ease;
+}}
+
+.quick-menu-item:hover {{
+    background-color: #{colors["base01"]};
+}}
+
+.section-title {{
+    color: #{colors["base04"]};
+    font-weight: bold;
+    font-size: {small_font}px;
+}}
+
+/* Vinyl button styling */
+#vinyl-button {{
+    background-color: transparent;
+    color: #{colors["base05"]};
+    border: none;
+    padding: 4px;
+    margin: 0px;
+    border-radius: 8px;
+}}
+
+#vinyl-button.active {{
+    background-color: #{colors["base0B"]};
+    color: #{colors["base00"]};
+}}
+
+#vinyl-icon {{
+    color: inherit;
+}}
+
+/* Toggle switch styling for quick menu */
+.toggle-active {{
+    background-color: #{colors["base0B"]};
+}}
+
+.toggle-inactive {{
+    background-color: #{colors["base02"]};
+}}
+
+/* Launcher (FuzzyMenu — finder, app launcher, screenrec menu) */
+#picker-box {{
+    background-color: #{colors["base00"]};
+    border: solid 1px #{colors["base02"]};
+    border-radius: 8px;
+    padding: 12px;
+    color: #{colors["base05"]};
+}}
+
+#search-entry {{
+    background-color: #{colors["base01"]};
+    color: #{colors["base05"]};
+    border: solid 1px #{colors["base02"]};
+    border-radius: 6px;
+    padding: 6px 10px;
+}}
+
+#viewport {{
+    background-color: #{colors["base00"]};
+    border-radius: 6px;
+    padding: 4px;
+    color: #{colors["base05"]};
+}}
+
+#viewport > * {{
+    background-color: #{colors["base01"]};
+    border-left: 3px solid transparent;
+    border-radius: 4px;
+    padding: 8px 12px;
+    margin-bottom: 4px;
+    transition: background-color 80ms ease, border-color 80ms ease;
+}}
+
+#viewport > *.selected {{
+    background-color: alpha(#{colors["base0D"]}, 0.28);
+    border-left-color: #{colors["base0D"]};
+    color: #{colors["base05"]};
+    font-weight: 600;
+}}
+
+#viewport > *.selected label {{
+    color: #{colors["base05"]};
+}}
+
+#app-icon {{
+    margin-right: 4px;
+}}
+
+#app-name {{
+    color: #{colors["base05"]};
+    font-weight: 500;
+}}
+
+#app-generic {{
+    color: #{colors["base04"]};
+    font-size: {small_font}px;
+}}
+"""
+
+    # Write to temporary file
+    temp_fd, temp_path = tempfile.mkstemp(suffix=".css", prefix="stylix_")
+    try:
+        with os.fdopen(temp_fd, "w") as f:
+            f.write(css_content)
+        return temp_path
+    except Exception:
+        os.close(temp_fd)
+        return None
+
+
+def get_stylix_css_path():
+    """Get the path to the Stylix CSS file"""
+    return generate_stylix_css()

sims/modules/vinyl.py

@@ -1,12 +1,10 @@
-from fabric.widgets.box import Box
-from fabric.widgets.label import Label
-from fabric.widgets.eventbox import EventBox
-from fabric.widgets.overlay import Overlay
+from fabric.widgets.button import Button
+from fabric.widgets.image import Image
 from fabric.core.service import Property
 import subprocess
 
 
-class VinylButton(Box):
+class VinylButton(Button):
     @Property(bool, "read-write", default_value=False)
     def active(self) -> bool:
         return self._active
@@ -35,35 +33,26 @@ class VinylButton(Box):
         ],
         **kwargs,
     ):
-        super().__init__(**kwargs)
-
         # Initialize properties
         self._active = False
         self._active_command = active_command
         self._inactive_command = inactive_command
 
-        # Set up the icon
-        self.icon = Label(
-            label="",  # CD icon
+        # Set up the icon using GTK icon
+        self.icon = Image(
+            icon_name="folder-music-symbolic",
+            icon_size=16,
             name="vinyl-icon",
-            style="",
         )
 
-        # Set up event box to handle clicks
-        self.event_box = EventBox(
-            events="button-press",
-            child=Overlay(
-                child=self.icon,
-            ),
+        # Initialize the Button with the icon as child
+        super().__init__(
             name="vinyl-button",
+            child=self.icon,
+            on_clicked=self._on_clicked,
+            **kwargs,
         )
 
-        # Connect click event
-        self.event_box.connect("button-press-event", self._on_clicked)
-
-        # Add to parent box
-        self.add(self.event_box)
-
         # Initialize appearance
         self._update_appearance()
 
@@ -74,12 +63,10 @@ class VinylButton(Box):
         else:
             self.remove_style_class("active")
 
-    def _on_clicked(self, _, event):
+    def _on_clicked(self, button=None):
         """Handle button click event"""
-        if event.button == 1:  # Left click
-            # Toggle active state
-            self.active = not self.active
-        return True
+        # Toggle active state
+        self.active = not self.active
 
     def _execute_active_command(self):
         """Execute shell command when button is activated"""

sims/modules/window_fuzzy.py

@@ -0,0 +1,9 @@
+from sims.modules.launcher import FuzzyMenu, WindowProvider
+
+
+def FuzzyWindowFinder(monitor: int = 0) -> FuzzyMenu:
+    return FuzzyMenu(
+        provider=WindowProvider(),
+        monitor=monitor,
+        placeholder="Search Windows...",
+    )

sims/services/battery.py

@@ -0,0 +1,72 @@
+import psutil
+from fabric.core.service import Service, Signal
+from fabric.utils import invoke_repeater
+
+
+class BatteryService(Service):
+    @Signal
+    def battery_changed(self, percent: float, charging: bool) -> None:
+        """Signal emitted when battery status changes"""
+        pass
+
+    def __init__(self, update_interval=10000, **kwargs):  # Check every 10 seconds
+        super().__init__(**kwargs)
+        self._percent = 0.0
+        self._charging = False
+        self._update_interval = update_interval
+        self._timer_id = None
+
+        # Start periodic updates
+        self.start_monitoring()
+
+    def start_monitoring(self):
+        """Start monitoring battery status"""
+        if self._timer_id is None:
+            # Get initial values
+            self._update_battery()
+            # Set up periodic updates
+            self._timer_id = invoke_repeater(self._update_interval, self._update_battery)
+
+    def stop_monitoring(self):
+        """Stop monitoring battery status"""
+        if self._timer_id is not None:
+            from gi.repository import GLib
+            GLib.source_remove(self._timer_id)
+            self._timer_id = None
+
+    def _update_battery(self):
+        """Update battery status and emit signal if changed"""
+        try:
+            # Use the same pattern as the example
+            bat_sen = psutil.sensors_battery()
+            if not bat_sen:
+                # No battery sensor available (desktop systems)
+                new_percent = 100.0  # Assume plugged in
+                new_charging = True
+            else:
+                new_percent = bat_sen.percent
+                new_charging = bat_sen.power_plugged
+
+            # Only emit signal if values changed
+            percent_changed = abs(new_percent - self._percent) > 0.5
+            charging_changed = new_charging != self._charging
+
+            if percent_changed or charging_changed:
+                self._percent = new_percent
+                self._charging = new_charging
+                self.battery_changed(new_percent, new_charging)
+
+        except Exception as e:
+            print(f"Error updating battery status: {e}")
+
+        return True  # Keep the timer running
+
+    @property
+    def percent(self):
+        """Get current battery percentage"""
+        return self._percent
+
+    @property
+    def charging(self):
+        """Get current charging status"""
+        return self._charging

sims/services/fenster.py

@@ -0,0 +1,55 @@
+"""
+Fenster/Sway IPC connection helper.
+
+Provides a singleton I3 connection configured for Fenster's SWAYSOCK.
+"""
+
+import os
+from sims.services.i3 import I3, I3MessageType
+
+
+_connection: I3 | None = None
+
+
+def get_i3_connection() -> I3:
+    """Get the singleton I3 connection, configured for Fenster."""
+    global _connection
+    if _connection is None:
+        swaysock = os.environ.get("SWAYSOCK")
+        if swaysock:
+            I3.SOCKET_PATH = swaysock
+        elif not I3.SOCKET_PATH:
+            runtime_dir = os.environ.get(
+                "XDG_RUNTIME_DIR", f"/run/user/{os.getuid()}"
+            )
+            fallback = os.path.join(runtime_dir, "fenster.sock")
+            if os.path.exists(fallback):
+                I3.SOCKET_PATH = fallback
+        _connection = I3()
+    return _connection
+
+
+def focused_output_index() -> int:
+    """Index of the currently focused output in active GET_OUTPUTS order.
+
+    Matches the indexing main.spawn_bars uses for `monitor=` so layer-shell
+    windows opened with the same index land on the focused output. Returns 0
+    on any IPC failure or if the focused output cannot be located.
+    """
+    ws_reply = I3.send_command("", I3MessageType.GET_WORKSPACES)
+    if not (ws_reply.is_ok and isinstance(ws_reply.reply, list)):
+        return 0
+    focused_output = next(
+        (ws.get("output") for ws in ws_reply.reply if ws.get("focused")),
+        None,
+    )
+    if not focused_output:
+        return 0
+    out_reply = I3.send_command("", I3MessageType.GET_OUTPUTS)
+    if not (out_reply.is_ok and isinstance(out_reply.reply, list)):
+        return 0
+    active = [o for o in out_reply.reply if o.get("active")]
+    for i, o in enumerate(active):
+        if o.get("name") == focused_output:
+            return i
+    return 0

sims/services/i3.py

@@ -0,0 +1,245 @@
+"""Vendored i3/sway IPC client (originally from fabric.i3).
+
+Maintained in-tree so we can extend `I3MessageType` with fenster-specific
+event types without monkey-patching upstream fabric. To add a new event:
+
+1. Add a new `*_EVENT` member to `I3MessageType` with the wire type number
+   (`0x80000000 | <event_id>`).
+2. Make sure fenster broadcasts it under the matching atom and accepts the
+   subscription string (the auto-derived name = enum-name lowercased without
+   `_event`).
+3. Subscribers connect to `event::<name>` (or `event::<name>::<change>` for
+   sub-events).
+"""
+import os
+import json
+import socket
+import struct
+from enum import IntEnum
+from loguru import logger
+from typing import ParamSpec
+from dataclasses import dataclass
+from fabric.core.service import Service, Signal, Property
+from fabric.utils.helpers import exec_shell_command, idle_add
+from gi.repository import GLib
+
+P = ParamSpec("P")
+
+SOCKET_MAGIC = b"i3-ipc"
+
+
+# exceptions
+class I3Error(Exception): ...
+
+
+class I3SocketError(I3Error): ...
+
+
+class I3SocketNotFoundError(I3SocketError): ...
+
+
+class I3MessageType(IntEnum):
+    # commands
+    COMMAND = 0
+    GET_WORKSPACES = 1
+    SUBSCRIBE = 2
+    GET_OUTPUTS = 3
+    GET_TREE = 4
+    GET_MARKS = 5
+    GET_BAR_CONFIG = 6
+    GET_VERSION = 7
+    GET_BINDING_MODES = 8
+    GET_CONFIG = 9
+    SEND_TICK = 10
+    SYNC = 11
+    GET_BINDING_STATE = 12
+    # sway only
+    GET_INPUTS = 100
+    GET_SEATS = 101
+
+    # events
+    WORKSPACE_EVENT = 0x80000000
+    OUTPUT_EVENT = 0x80000001
+    MODE_EVENT = 0x80000002
+    WINDOW_EVENT = 0x80000003
+    BARCONFIG_UPDATE_EVENT = 0x80000004
+    BINDING_EVENT = 0x80000005
+    SHUTDOWN_EVENT = 0x80000006
+    TICK_EVENT = 0x80000007
+    # sway only
+    BAR_STATE_UPDATE_EVENT = 0x80000014
+    INPUT_EVENT = 0x80000015
+    # fenster extensions (event id 100+)
+    SMART_CORNERS_EVENT = 0x80000064
+
+
+@dataclass(frozen=True)
+class I3Event:
+    name: str
+    "the name of the received event"
+    data: dict
+    "the json data gotten from event's body"
+    raw_data: bytes
+    "the raw json data"
+
+
+@dataclass(frozen=True)
+class I3Reply:
+    command: str
+    "the passed in command"
+    reply: dict | list
+    "the raw reply from i3/sway as a dict or list"
+    is_ok: bool
+    "this indicates if the ran command has returned a success message"
+
+
+class I3(Service):
+    """
+    A connection to the i3/Sway's IPC socket.
+    This can be used for sending commands and receiving events.
+    """
+
+    SOCKET_PATH: str | None = None
+
+    @Property(bool, "readable", "is-ready", default_value=False)
+    def ready(self) -> bool:
+        return self._ready
+
+    @Signal("event", flags="detailed")
+    def event(self, event: object): ...
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self._ready = False
+        self.lookup_socket()
+
+        self.event_socket_thread = GLib.Thread.new(
+            "i3-socket-service",
+            self.event_socket_task,  # type: ignore
+            self.SOCKET_PATH,
+        )
+
+        self._ready = True
+        self.notify("ready")
+
+    @staticmethod
+    def lookup_socket() -> str:
+        if I3.SOCKET_PATH:
+            return I3.SOCKET_PATH
+
+        for cmd in ("sway", "i3"):
+            path = exec_shell_command(f"{cmd} --get-socketpath")
+            if not path or not (path := path.strip()) or not os.path.exists(path):
+                continue
+
+            I3.SOCKET_PATH = path
+
+            return I3.SOCKET_PATH
+
+        raise I3SocketNotFoundError(
+            "Couldn't find i3 or Sway socket, is either of them running?"
+        )
+
+    @staticmethod
+    def pack(message_type: I3MessageType, payload: str = "") -> bytes:
+        payload_bytes = payload.encode()
+        header = struct.pack("<II", len(payload_bytes), message_type.value)
+        return SOCKET_MAGIC + header + payload_bytes
+
+    @staticmethod
+    def unpack(connection: socket.socket) -> tuple[int, str]:
+        header = connection.recv(14)
+        if len(header) != 14:
+            raise I3SocketError("Failed to read IPC header")
+
+        magic, length, message_type = struct.unpack("<6sII", header)
+        if magic != SOCKET_MAGIC:
+            raise I3SocketError(f"Invalid IPC magic string ({magic}). Report this!")
+
+        return message_type, connection.recv(length).decode()
+
+    @staticmethod
+    def send_command(
+        command: str, message_type: I3MessageType = I3MessageType.COMMAND
+    ) -> I3Reply:
+        """
+        Sends a command to the i3/sway socket.
+
+        example usage:
+        ```python
+        # next workspace...
+        I3.send_command("workspace next")
+        ```
+        :param command: The command to send.
+        :type command: str
+        :param message_type: The type of message to send.
+        :type message_type: I3MessageType, optional
+        :return: A reply object containing the data from i3/sway.
+        :rtype: I3Reply
+        """
+        reply_data = {}
+        is_ok = False
+        try:
+            with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
+                sock.connect(I3.lookup_socket())
+                sock.sendall(I3.pack(message_type, command))
+
+                _, payload = I3.unpack(sock)
+                reply_data = json.loads(payload)
+
+                # results for any GET_* command is considered ok
+                # other commands a success reply is a list of dicts with {"success": True}
+                if (message_type != I3MessageType.COMMAND) or (
+                    isinstance(reply_data, list)
+                    and reply_data
+                    and reply_data[0].get("success")
+                ):
+                    is_ok = True
+
+        except Exception as e:
+            logger.error(
+                f"[I3Service] got error while sending command via socket ({e})"
+            )
+
+        return I3Reply(command=command, reply=reply_data, is_ok=is_ok)
+
+    def event_socket_task(self, socket_addr: str) -> bool:
+        try:
+            with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
+                sock.connect(socket_addr)
+
+                # subscribe to all events
+                sock.sendall(
+                    self.pack(
+                        I3MessageType.SUBSCRIBE,
+                        json.dumps(
+                            [
+                                evnt_name.replace("_event", "")
+                                for mt in I3MessageType
+                                if (evnt_name := mt.name.lower()).endswith("_event")
+                            ]
+                        ),
+                    )
+                )
+                self.unpack(sock)  # success reply
+
+                while True:
+                    idle_add(self.handle_raw_event, *self.unpack(sock))
+
+        except Exception as e:
+            logger.warning(f"[I3Service] events socket thread ended with an error: {e}")
+
+        return False
+
+    def handle_raw_event(self, message_type: int, payload: str):
+        event_data = json.loads(payload)
+        event_name = I3MessageType(message_type).name.lower().replace("_event", "")
+
+        if "change" in event_data:  # subevents
+            event_name = f"{event_name}::{event_data['change']}"
+
+        return self.emit(
+            f"event::{event_name}",
+            I3Event(event_name, event_data, payload.encode()),
+        )

sims/services/mpris.py

@@ -265,7 +265,11 @@ class MprisPlayerManager(Service):
 
     def on_name_appeard(self, manager, player_name: Playerctl.PlayerName):
         logger.info(f"[MprisPlayer] {player_name.name} appeared")
-        new_player = Playerctl.Player.new_from_name(player_name)
+        try:
+            new_player = Playerctl.Player.new_from_name(player_name)
+        except GLib.Error as e:
+            logger.warning(f"[MprisPlayer] could not attach to {player_name.name}: {e}")
+            return
         manager.manage_player(new_player)
         self.emit("player-appeared", new_player)  # type: ignore
 
@@ -275,7 +279,10 @@ class MprisPlayerManager(Service):
 
     def add_players(self):
         for player in self._manager.get_property("player-names"):  # type: ignore
-            self._manager.manage_player(Playerctl.Player.new_from_name(player))  # type: ignore
+            try:
+                self._manager.manage_player(Playerctl.Player.new_from_name(player))  # type: ignore
+            except GLib.Error as e:
+                logger.warning(f"[MprisPlayer] could not attach to {getattr(player, 'name', player)}: {e}")
 
     @Property(object, "readable")
     def players(self):

sims/services/notification_history.py

@@ -0,0 +1,106 @@
+"""In-memory notification history.
+
+Subscribes to a fabric Notifications service and snapshots each incoming
+notification before fabric drops it on close. Snapshots scale image pixbufs
+down to a bounded edge so a flood of high-res previews can't balloon memory.
+"""
+
+import time
+from collections import deque
+from dataclasses import dataclass
+
+from fabric.core.service import Service, Signal
+from fabric.notifications import Notification, Notifications
+from gi.repository import GdkPixbuf
+
+
+@dataclass
+class HistoryEntry:
+    id: int
+    summary: str
+    body: str
+    urgency: int
+    timestamp: float
+    pixbuf: GdkPixbuf.Pixbuf | None
+
+
+def _scale_pixbuf(
+    pixbuf: GdkPixbuf.Pixbuf | None, max_edge: int
+) -> GdkPixbuf.Pixbuf | None:
+    if pixbuf is None:
+        return None
+    w, h = pixbuf.get_width(), pixbuf.get_height()
+    if w <= max_edge and h <= max_edge:
+        return pixbuf
+    scale = max_edge / max(w, h)
+    return pixbuf.scale_simple(
+        max(1, int(w * scale)),
+        max(1, int(h * scale)),
+        GdkPixbuf.InterpType.BILINEAR,
+    )
+
+
+class NotificationHistoryService(Service):
+    @Signal
+    def changed(self) -> None: ...
+
+    def __init__(
+        self,
+        notifications: Notifications,
+        history_size: int = 50,
+        image_max_px: int = 128,
+    ):
+        super().__init__()
+        self._entries: deque[HistoryEntry] = deque(maxlen=history_size)
+        self._image_max_px = image_max_px
+        self._unseen_count = 0
+        notifications.connect("notification-added", self._on_added)
+
+    def _on_added(self, service: Notifications, nid: int) -> None:
+        notification: Notification | None = service.get_notification_from_id(nid)
+        if notification is None:
+            return
+        self._entries.appendleft(
+            HistoryEntry(
+                id=nid,
+                summary=notification.summary or "",
+                body=notification.body or "",
+                urgency=notification.urgency,
+                timestamp=time.time(),
+                pixbuf=_scale_pixbuf(
+                    notification.image_pixbuf, self._image_max_px
+                ),
+            )
+        )
+        self._unseen_count += 1
+        self.changed()
+
+    @property
+    def entries(self) -> list[HistoryEntry]:
+        return list(self._entries)
+
+    @property
+    def unseen_count(self) -> int:
+        return self._unseen_count
+
+    def mark_all_seen(self) -> None:
+        if self._unseen_count == 0:
+            return
+        self._unseen_count = 0
+        self.changed()
+
+    def remove(self, entry_id: int) -> None:
+        before = len(self._entries)
+        self._entries = deque(
+            (e for e in self._entries if e.id != entry_id),
+            maxlen=self._entries.maxlen,
+        )
+        if len(self._entries) != before:
+            self.changed()
+
+    def clear(self) -> None:
+        if not self._entries:
+            return
+        self._entries.clear()
+        self._unseen_count = 0
+        self.changed()

sims/services/screenrec.py

@@ -0,0 +1,230 @@
+"""wl-screenrec process manager.
+
+Owns the wl-screenrec subprocess so the bar reflects real recording state
+without polling. Survives bar restarts via orphan adoption.
+"""
+
+import os
+import signal
+import subprocess
+import time
+from datetime import datetime
+from typing import Literal
+
+from fabric.core.service import Service, Signal
+from sims.services.i3 import I3, I3MessageType
+from gi.repository import GLib
+from loguru import logger
+
+Destination = Literal["videos", "clipboard"]
+
+
+class ScreenrecService(Service):
+    @Signal
+    def recording_changed(self, recording: bool) -> None: ...
+
+    def __init__(self, output_dir: str = "~/Videos/wl-screenrec"):
+        super().__init__()
+        self._output_dir = os.path.expanduser(output_dir)
+        self._proc: subprocess.Popen | None = None
+        self._adopted_pid: int | None = None
+        self._started_at: float | None = None
+        self._output_path: str | None = None
+        self._destination: Destination | None = None
+        self._watch_id: int | None = None
+
+        self._adopt_orphan_if_running()
+
+    @property
+    def recording(self) -> bool:
+        return self._proc is not None or self._adopted_pid is not None
+
+    @property
+    def started_at(self) -> float | None:
+        return self._started_at
+
+    def start_monitor(self, dest: Destination = "videos", output: str | None = None) -> None:
+        if self.recording:
+            logger.warning("[Screenrec] start_monitor: already recording")
+            return
+        path = self._make_output_path(dest)
+
+        # Prefer an explicit output name when the caller passes one, but fenster's
+        # IPC reports synthetic names ("Unknown-XXXX") that wl-screenrec can't
+        # resolve. Fall back to the focused output's geometry, which works
+        # across i3/sway/fenster.
+        if output and not output.startswith("Unknown-"):
+            self._spawn(["wl-screenrec", "-o", output, "-f", path], path, dest)
+            return
+
+        geom = self._focused_output_geometry()
+        if not geom:
+            logger.error("[Screenrec] no focused output found")
+            return
+        self._spawn(["wl-screenrec", "-g", geom, "-f", path], path, dest)
+
+    def start_region(self, dest: Destination = "videos") -> None:
+        if self.recording:
+            logger.warning("[Screenrec] start_region: already recording")
+            return
+        geom = self._slurp_region()
+        if not geom:
+            logger.info("[Screenrec] region selection cancelled")
+            return
+        path = self._make_output_path(dest)
+        self._spawn(["wl-screenrec", "-g", geom, "-f", path], path, dest)
+
+    def stop(self) -> None:
+        if self._proc is not None:
+            logger.info("[Screenrec] sending SIGINT to wl-screenrec")
+            try:
+                self._proc.send_signal(signal.SIGINT)
+            except ProcessLookupError:
+                self._on_exit(self._proc.pid, 0)
+            return
+        if self._adopted_pid is not None:
+            logger.info(f"[Screenrec] sending SIGINT to adopted pid {self._adopted_pid}")
+            try:
+                os.kill(self._adopted_pid, signal.SIGINT)
+            except ProcessLookupError:
+                pass
+            self._poll_adopted_until_gone()
+
+    def _spawn(self, argv: list[str], path: str, dest: Destination) -> None:
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        logger.info(f"[Screenrec] spawning: {' '.join(argv)}")
+        try:
+            self._proc = subprocess.Popen(
+                argv,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+        except FileNotFoundError:
+            logger.error("[Screenrec] wl-screenrec not found on PATH")
+            return
+        self._output_path = path
+        self._destination = dest
+        self._started_at = time.monotonic()
+        self._watch_id = GLib.child_watch_add(
+            GLib.PRIORITY_DEFAULT, self._proc.pid, self._on_exit
+        )
+        self.recording_changed(True)
+
+    def _on_exit(self, pid: int, status: int) -> None:
+        logger.info(f"[Screenrec] wl-screenrec exited (pid={pid} status={status})")
+        path = self._output_path
+        dest = self._destination
+        self._reset_state()
+        if dest == "clipboard" and path and os.path.exists(path):
+            self._copy_to_clipboard(path)
+        self.recording_changed(False)
+
+    def _reset_state(self) -> None:
+        self._proc = None
+        self._adopted_pid = None
+        self._started_at = None
+        self._output_path = None
+        self._destination = None
+        if self._watch_id is not None:
+            try:
+                GLib.source_remove(self._watch_id)
+            except Exception:
+                pass
+            self._watch_id = None
+
+    def _copy_to_clipboard(self, path: str) -> None:
+        try:
+            with open(path, "rb") as f:
+                subprocess.Popen(
+                    ["wl-copy", "-t", "video/mp4"],
+                    stdin=f,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    start_new_session=True,
+                )
+            logger.info(f"[Screenrec] copied {path} to clipboard as video/mp4")
+        except FileNotFoundError:
+            logger.error("[Screenrec] wl-copy not found on PATH")
+
+    def _slurp_region(self) -> str | None:
+        try:
+            result = subprocess.run(
+                ["slurp"], capture_output=True, text=True, check=False
+            )
+        except FileNotFoundError:
+            logger.error("[Screenrec] slurp not found on PATH")
+            return None
+        geom = result.stdout.strip()
+        return geom or None
+
+    def _focused_output(self) -> str | None:
+        reply = I3.send_command("", I3MessageType.GET_WORKSPACES)
+        if not (reply.is_ok and isinstance(reply.reply, list)):
+            return None
+        for ws in reply.reply:
+            if ws.get("focused"):
+                return ws.get("output")
+        return None
+
+    def _focused_output_geometry(self) -> str | None:
+        """Return the focused output's geometry as 'X,Y WxH' (slurp format).
+
+        Used as a portable fallback when the IPC's output names aren't real
+        wl_output names (e.g. fenster reports 'Unknown-XXXX').
+        """
+        reply = I3.send_command("", I3MessageType.GET_WORKSPACES)
+        if not (reply.is_ok and isinstance(reply.reply, list)):
+            return None
+        for ws in reply.reply:
+            if ws.get("focused"):
+                rect = ws.get("rect") or {}
+                x = rect.get("x")
+                y = rect.get("y")
+                w = rect.get("width")
+                h = rect.get("height")
+                if None in (x, y, w, h) or w <= 0 or h <= 0:
+                    return None
+                return f"{x},{y} {w}x{h}"
+        return None
+
+    def _make_output_path(self, dest: Destination) -> str:
+        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        if dest == "clipboard":
+            tmp = os.path.join(GLib.get_tmp_dir(), f"sims-screenrec-{stamp}.mp4")
+            return tmp
+        return os.path.join(self._output_dir, f"{stamp}.mp4")
+
+    def _adopt_orphan_if_running(self) -> None:
+        try:
+            result = subprocess.run(
+                ["pgrep", "-x", "wl-screenrec"], capture_output=True, text=True
+            )
+        except FileNotFoundError:
+            return
+        pid_str = result.stdout.strip().split("\n")[0] if result.stdout.strip() else ""
+        if not pid_str:
+            return
+        try:
+            self._adopted_pid = int(pid_str)
+        except ValueError:
+            return
+        logger.info(f"[Screenrec] adopted orphan wl-screenrec pid={self._adopted_pid}")
+        self._started_at = time.monotonic()
+        self.recording_changed(True)
+
+    def _poll_adopted_until_gone(self) -> None:
+        def check() -> bool:
+            if self._adopted_pid is None:
+                return False
+            try:
+                os.kill(self._adopted_pid, 0)
+            except ProcessLookupError:
+                logger.info("[Screenrec] adopted wl-screenrec finished")
+                self._reset_state()
+                self.recording_changed(False)
+                return False
+            return True
+
+        GLib.timeout_add(250, check)

sims/services/smart_corners.py

@@ -0,0 +1,49 @@
+"""Smart-corners IPC subscriber.
+
+Listens to fenster's `:smart_corners` event and emits a per-output signal
+when the WM's smart-corners state flips. Caches the latest state per output
+so widgets created after the event can ask for the current value.
+"""
+from fabric.core.service import Service, Signal
+from loguru import logger
+
+from sims.services.fenster import get_i3_connection
+
+
+_service: "SmartCornersService | None" = None
+
+
+class SmartCornersService(Service):
+    @Signal
+    def state_changed(self, output: str, active: bool) -> None:
+        """Emitted when a fenster output flips smart-corners state."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._state: dict[str, bool] = {}
+        i3 = get_i3_connection()
+        i3.connect("event::smart_corners::active", self._on_event)
+        i3.connect("event::smart_corners::inactive", self._on_event)
+
+    def get(self, output: str) -> bool:
+        """Latest known state for an output, or False if unseen."""
+        return self._state.get(output, False)
+
+    def _on_event(self, _i3, event):
+        change = event.data.get("change")
+        output = event.data.get("output")
+        if not isinstance(output, str) or change not in ("active", "inactive"):
+            logger.warning(f"[SmartCorners] unexpected event payload: {event.data!r}")
+            return
+        active = change == "active"
+        if self._state.get(output) == active:
+            return
+        self._state[output] = active
+        self.state_changed(output, active)
+
+
+def get_smart_corners_service() -> SmartCornersService:
+    global _service
+    if _service is None:
+        _service = SmartCornersService()
+    return _service

sims/services/system_stats.py

@@ -0,0 +1,66 @@
+import psutil
+from fabric.core.service import Service, Signal
+from fabric.utils import invoke_repeater
+
+
+class SystemStatsService(Service):
+    @Signal
+    def stats_changed(self, cpu_percent: float, memory_percent: float) -> None:
+        """Signal emitted when system stats change"""
+        pass
+
+    def __init__(self, update_interval=3000, **kwargs):
+        super().__init__(**kwargs)
+        self._cpu_percent = 0.0
+        self._memory_percent = 0.0
+        self._update_interval = update_interval
+        self._timer_id = None
+
+        # Start periodic updates
+        self.start_monitoring()
+
+    def start_monitoring(self):
+        """Start monitoring system stats"""
+        if self._timer_id is None:
+            # Get initial values
+            self._update_stats()
+            # Set up periodic updates
+            self._timer_id = invoke_repeater(self._update_interval, self._update_stats)
+
+    def stop_monitoring(self):
+        """Stop monitoring system stats"""
+        if self._timer_id is not None:
+            from gi.repository import GLib
+
+            GLib.source_remove(self._timer_id)
+            self._timer_id = None
+
+    def _update_stats(self):
+        """Update system stats and emit signal if changed"""
+        try:
+            new_cpu = psutil.cpu_percent()
+            new_memory = psutil.virtual_memory().percent
+
+            # Only emit signal if values changed significantly (reduce noise)
+            cpu_changed = abs(new_cpu - self._cpu_percent) > 1.0
+            memory_changed = abs(new_memory - self._memory_percent) > 1.0
+
+            if cpu_changed or memory_changed:
+                self._cpu_percent = new_cpu
+                self._memory_percent = new_memory
+                self.stats_changed(new_cpu / 100, new_memory / 100)
+
+        except Exception as e:
+            print(f"Error updating system stats: {e}")
+
+        return True  # Keep the timer running
+
+    @property
+    def cpu_percent(self):
+        """Get current CPU percentage"""
+        return self._cpu_percent / 100
+
+    @property
+    def memory_percent(self):
+        """Get current memory percentage"""
+        return self._memory_percent / 100

sims/styles/bar.css

@@ -0,0 +1,130 @@
+#sims-inner {
+    padding: 4px;
+    border-bottom: solid 2px;
+    border-color: var(--border-color);
+    background-color: var(--window-bg);
+    border-radius: 0;
+    transition: border-radius 200ms ease;
+}
+
+#sims-inner.rounded-bottom {
+    border-radius: 0 0 28px 28px;
+}
+
+#center-container {
+  color: var(--foreground);
+}
+
+.active-window {
+  color: var(--foreground);
+  font-weight: bold;
+}
+
+#battery-widget {
+    background-color: var(--module-bg);
+    padding: 4px 8px;
+    border-radius: 4px;
+}
+
+#bat-icon {
+    color: var(--blue);
+    margin-right: 2px;
+}
+
+#bat-label {
+    color: var(--foreground);
+    font-size: 14px;
+}
+
+#bat-label.battery-low {
+    color: var(--red);
+    font-weight: bold;
+}
+
+#cpu-progress-bar,
+#ram-progress-bar,
+#volume-progress-bar {
+    color: transparent;
+    background-color: transparent
+}
+
+#cpu-progress-bar {
+    border: solid 0px alpha(var(--violet), 0.8);
+}
+
+#ram-progress-bar,
+#volume-progress-bar {
+    border: solid 0px var(--blue);
+}
+
+#widgets-container {
+    background-color: var(--module-bg);
+    padding: 2px;
+}
+
+#player-small {
+    background-color: var(--module-bg);
+    padding: 6px;
+    border-radius: 100px;
+}
+
+#compact-mpris-icon,
+#compact-mpris-button {
+    background: transparent;
+    border: none;
+    padding: 0 4px;
+    margin: 0;
+    box-shadow: none;
+    min-height: 0;
+    min-width: 0;
+}
+
+#compact-mpris-button-icon {
+    color: var(--foreground);
+}
+
+#compact-mpris-button:hover #compact-mpris-button-icon {
+    color: var(--blue);
+}
+
+#compact-mpris-fallback {
+    color: var(--foreground);
+    opacity: 0.7;
+}
+
+#compact-mpris-label {
+    color: var(--foreground);
+    font-size: 13px;
+}
+
+#nixos-label {
+    color: var(--blue);
+}
+
+#screenrec-widget {
+    background: transparent;
+    border: none;
+    padding: 0 6px;
+    margin: 0;
+    box-shadow: none;
+}
+
+#screenrec-dot {
+    color: #ff4444;
+    font-size: 14px;
+}
+
+#screenrec-elapsed {
+    font-size: 12px;
+    font-family: monospace;
+}
+
+tooltip {
+    border: solid 2px;
+    border-color: var(--border-color);
+    background-color: var(--window-bg);
+}
+
+tooltip>* {
+    padding: 2px 4px
+}

sims/styles/calendar.css

@@ -0,0 +1,60 @@
+/* Calendar widget styling */
+
+/* Date time button */
+#date-time-button {
+    background: transparent;
+    border: none;
+    padding: 0;
+    margin: 0;
+    box-shadow: none;
+}
+
+#date-time {
+    color: var(--foreground);
+    background-color: var(--module-bg);
+    padding: 4px 8px;
+    border-radius: 12px;
+}
+
+/* Calendar event items */
+.event-item {
+    border-radius: 8px;
+    padding: 8px 10px;
+    margin: 2px 0px;
+    background-color: var(--light-bg);
+    border: none;
+    transition: background-color 0.15s ease;
+}
+
+#event-content {
+    margin-left: 8px;
+}
+
+.event-title {
+    font-weight: bold;
+    color: var(--foreground);
+}
+
+.event-time {
+    color: var(--dark-fg);
+}
+
+.event-location {
+    color: var(--light-grey);
+}
+
+/* Current time indicator */
+.current-time-indicator {
+    margin: 8px 0px;
+    padding: 4px 0px;
+}
+
+#current-time-label {
+    color: var(--blue);
+    font-weight: bold;
+}
+
+#current-time-line {
+    color: var(--blue);
+    font-weight: bold;
+}

sims/styles/colors.css

@@ -20,8 +20,9 @@
     --window-bg: alpha(var(--background), 0.9);
     --module-bg: alpha(var(--mid-bg), 0.8);
     --border-color: var(--light-bg);
-    --ws-active: var(--pink);
-    --ws-inactive: var(--blue);
+    --ws-active: var(--blue);
+    --ws-visible: var(--violet);
+    --ws-inactive: var(--light-grey);
     --ws-empty: var(--dark-grey);
     --ws-hover: var(--turquoise);
     --ws-urgent: var(--red);

sims/styles/launcher.css

@@ -0,0 +1,92 @@
+/* Shared styles for the fuzzy-menu launcher (window finder, app launcher,
+   screenrec menu, and any future provider built on FuzzyMenu).
+   Element IDs come from sims/modules/launcher/base.py. */
+
+#picker-box {
+    padding: 12px;
+    background-color: rgba(40, 40, 40, 0.95);
+    border-radius: 8px;
+    font-family: sans-serif;
+    font-size: 14px;
+    color: white;
+    min-width: 720px;
+}
+
+#viewport {
+    padding: 8px;
+    background-color: rgba(30, 30, 30, 0.9);
+    border-radius: 6px;
+    font-family: sans-serif;
+    font-size: 14px;
+    color: white;
+}
+
+#viewport > * {
+    padding: 8px 12px;
+    margin-bottom: 4px;
+    border-radius: 4px;
+    background-color: rgba(255, 255, 255, 0.04);
+    border-left: 3px solid transparent;
+    transition: background-color 80ms ease, border-color 80ms ease;
+}
+
+#viewport > *.selected {
+    background-color: rgba(137, 180, 250, 0.28);
+    border-left-color: #89b4fa;
+    color: #ffffff;
+    font-weight: 600;
+}
+
+#viewport > *.selected label {
+    color: #ffffff;
+}
+
+/* Provider-specific tweaks (apps launcher) */
+#app-icon {
+    margin-right: 4px;
+}
+
+#app-name {
+    font-weight: 500;
+}
+
+#app-generic {
+    font-size: 11px;
+    opacity: 0.6;
+}
+
+/* Provider-specific tweaks (notmuch search) */
+#notmuch-text {
+    /* Let the date column hug the right edge */
+    margin-right: 8px;
+}
+
+#notmuch-subject {
+    font-weight: 500;
+}
+
+#notmuch-authors {
+    font-size: 11px;
+    opacity: 0.7;
+}
+
+#notmuch-date {
+    font-size: 11px;
+    opacity: 0.6;
+}
+
+#notmuch-saved-name {
+    font-weight: 500;
+}
+
+#notmuch-saved-query {
+    font-size: 11px;
+    opacity: 0.6;
+    font-family: monospace;
+}
+
+#notmuch-bare {
+    font-style: italic;
+    opacity: 0.7;
+}
+

sims/styles/main.css

@@ -3,7 +3,10 @@
 @import url("./menu.css");
 @import url("./vinyl.css");
 @import url("./bar.css");
-@import url("./finder.css");
+@import url("./launcher.css");
+@import url("./calendar.css");
+@import url("./notmuch.css");
+@import url("./notifications.css");
 
 
 /* unset so we can style everything from the ground up. */

sims/styles/notifications.css

@@ -0,0 +1,179 @@
+#notification {
+    padding: 0.8rem;
+    border: solid 1px var(--border-color);
+    border-radius: 1rem;
+    background-color: var(--mid-bg);
+}
+
+#notification .summary {
+    font-size: 18px;
+    font-weight: bold;
+}
+
+#notification .body {
+    color: var(--mid-fg);
+    font-weight: normal;
+}
+
+#notification button {
+    padding: 0.4rem 0.8rem;
+    font-weight: 600;
+    border-radius: 0.6rem;
+    background-color: var(--light-bg);
+}
+
+#notification button:hover {
+    background-color: var(--dark-grey);
+}
+
+#notification.urgency-low {
+    border-color: var(--dark-grey);
+}
+
+#notification.urgency-low .summary {
+    color: var(--mid-fg);
+}
+
+#notification.urgency-critical {
+    border-color: var(--red);
+    border-width: 2px;
+}
+
+#notification.urgency-critical .summary {
+    color: var(--red);
+}
+
+/* Control center side rail */
+
+#control-center {
+    background-color: transparent;
+}
+
+#control-center-body {
+    background-color: var(--background);
+    border-left: solid 2px var(--border-color);
+    border-bottom: solid 2px var(--border-color);
+    border-bottom-left-radius: 28px;
+    padding: 50px 12px 12px 12px;
+}
+
+#control-center-header {
+    padding: 4px 8px 12px 8px;
+    border-bottom: solid 1px var(--border-color);
+}
+
+#control-center-title {
+    font-size: 18px;
+    font-weight: bold;
+    color: var(--foreground);
+}
+
+#control-center-close {
+    padding: 4px 8px;
+    border-radius: 12px;
+    background-color: var(--module-bg);
+}
+
+#control-center-close:hover {
+    background-color: var(--light-bg);
+}
+
+#control-center-sections {
+    padding: 8px 0;
+}
+
+#control-center-settings,
+#control-center-calendar,
+#control-center-notifications {
+    padding: 8px;
+    background-color: var(--module-bg);
+    border-radius: 12px;
+}
+
+#control-center-section-title {
+    font-size: 12px;
+    font-weight: bold;
+    color: var(--light-grey);
+    padding: 4px 4px 8px 4px;
+}
+
+#control-center-settings-row {
+    padding: 4px 4px;
+}
+
+#control-center-settings-label {
+    font-size: 14px;
+    color: var(--foreground);
+}
+
+#control-center-events {
+    padding: 0 4px;
+}
+
+#control-center-no-events {
+    color: var(--light-grey);
+    padding: 6px 4px;
+}
+
+#control-center-notifications-header {
+    padding: 0 4px 6px 4px;
+}
+
+#control-center-notifications-clear {
+    padding: 2px 10px;
+    border-radius: 8px;
+    background-color: var(--light-bg);
+    font-size: 12px;
+}
+
+#control-center-notifications-clear:hover {
+    background-color: var(--dark-grey);
+}
+
+#control-center-notifications-list {
+    padding: 0 4px;
+}
+
+#control-center-notifications-empty {
+    color: var(--light-grey);
+    padding: 8px 4px;
+}
+
+#notification-history-entry {
+    padding: 10px;
+    border: solid 1px var(--border-color);
+    border-radius: 0.75rem;
+    background-color: var(--light-bg);
+}
+
+#notification-history-entry .summary {
+    font-weight: bold;
+}
+
+#notification-history-entry .body {
+    color: var(--mid-fg);
+}
+
+#notification-history-entry .timestamp {
+    color: var(--light-grey);
+    font-size: 12px;
+    padding-left: 8px;
+}
+
+#notification-history-entry.urgency-critical {
+    border-color: var(--red);
+}
+
+#notification-history-entry.urgency-critical .summary {
+    color: var(--red);
+}
+
+#notification-history-dismiss {
+    padding: 2px;
+    border-radius: 0.5rem;
+}
+
+#notification-history-dismiss:hover {
+    background-color: var(--dark-grey);
+}
+

sims/styles/notmuch.css

@@ -0,0 +1,53 @@
+/* Notmuch email widget styling */
+
+#notmuch-widget {
+    background-color: var(--module-bg);
+    padding: 4px 8px;
+    border-radius: 12px;
+    transition: background-color 0.2s ease;
+}
+
+#notmuch-widget:hover {
+    background-color: var(--light-bg);
+}
+
+#notmuch-widget.has-unread {
+    background-color: var(--blue);
+}
+
+#notmuch-widget.has-unread:hover {
+    background-color: var(--turquoise);
+}
+
+#notmuch-widget.no-unread {
+    background-color: var(--module-bg);
+}
+
+#notmuch-widget.debt-warn {
+    background-color: var(--orange);
+}
+
+#notmuch-widget.debt-warn:hover {
+    background-color: var(--gold);
+}
+
+#notmuch-widget.debt-alarm {
+    background-color: var(--red);
+}
+
+#notmuch-widget.debt-alarm:hover {
+    background-color: var(--pink);
+}
+
+#unread-count {
+    color: var(--foreground);
+    font-size: 14px;
+    font-weight: bold;
+    min-width: 16px;
+}
+
+#notmuch-widget.has-unread #unread-count,
+#notmuch-widget.debt-warn #unread-count,
+#notmuch-widget.debt-alarm #unread-count {
+    color: var(--background);
+}

sims/styles/vinyl.css

@@ -0,0 +1,29 @@
+/* Vinyl button styling */
+#vinyl-button {
+    background-color: var(--module-bg);
+    padding: 4px 8px;
+    border-radius: 12px;
+    transition: background-color 0.2s ease;
+}
+
+#vinyl-button:hover {
+    background-color: var(--light-bg);
+}
+
+/* Active state styling */
+#vinyl-button.active {
+    background-color: var(--pink);
+}
+
+#vinyl-button.active:hover {
+    background-color: var(--turquoise);
+}
+
+/* Icon styling */
+#vinyl-icon {
+    color: var(--foreground);
+}
+
+#vinyl-button.active #vinyl-icon {
+    color: var(--background);
+}

sims/styles/workspaces.css

@@ -5,9 +5,9 @@
 }
 
 #workspaces>button {
-    padding: 0px 8px;
-    transition: padding 0.05s steps(8);
-    background-color: var(--foreground);
+    padding: 8px;
+    transition: padding 0.05s steps(8), background-color 0.15s ease;
+    background-color: var(--ws-inactive);
     border-radius: 100px;
 }
 
@@ -15,28 +15,36 @@
     font-size: 0px;
 }
 
-#workspaces button.hover {
+#workspaces>button:hover {
     background-color: var(--ws-hover);
 }
 
-#workspaces button.urgent {
+#workspaces>button.empty {
+    background-color: var(--ws-empty);
+}
+
+#workspaces>button.visible {
+    background-color: var(--ws-visible);
+}
+
+#workspaces>button.active {
+    padding: 8px 32px;
+    background-color: var(--ws-active);
+}
+
+#workspaces>button.urgent {
     background-color: var(--ws-urgent);
     color: var(--foreground);
     font-weight: bold;
     animation: urgent-blink 1s infinite;
 }
 
+#workspaces>button.foreign {
+    opacity: 0.45;
+}
+
 @keyframes urgent-blink {
     0% { opacity: 1.0; }
     50% { opacity: 0.5; }
     100% { opacity: 1.0; }
 }
-
-#workspaces>button.empty {
-    background-color: var(--ws-empty);
-}
-
-#workspaces>button.active {
-    padding: 0px 32px;
-    background-color: var(--ws-active);
-}

sims/utils/markup.py

@@ -0,0 +1,28 @@
+import re
+from html import escape as html_escape
+
+import gi
+
+gi.require_version("Pango", "1.0")
+from gi.repository import GLib, Pango
+
+# Pango cannot render <img ...> from the freedesktop notification spec; strip it.
+_IMG_RE = re.compile(r"<img\b[^>]*/?>", re.IGNORECASE)
+
+
+def render_body_markup(body: str) -> tuple[str, bool]:
+    """Return ``(text, is_markup)`` for a notification body.
+
+    If the body parses as Pango markup, ``text`` is the cleaned-up markup
+    string and ``is_markup`` is True. Otherwise ``text`` is the XML-escaped
+    plain text and ``is_markup`` is False.
+    """
+    if not body:
+        return "", False
+
+    candidate = _IMG_RE.sub("", body)
+    try:
+        Pango.parse_markup(candidate, -1, "\0")
+    except GLib.Error:
+        return html_escape(body, quote=False), False
+    return candidate, True

sims/widgets/fenster.py

@@ -0,0 +1,240 @@
+"""
+Fenster widgets for workspace and window management via sway IPC.
+"""
+
+from gi.repository import GLib
+
+from sims.services.i3 import I3, I3Event, I3MessageType
+from fabric.utils.helpers import bulk_connect
+from fabric.widgets.box import Box
+from fabric.widgets.button import Button
+from fabric.widgets.label import Label
+from sims.services.fenster import get_i3_connection
+
+
+class FensterWorkspaceButton(Button):
+    """Button representing a single workspace"""
+
+    def __init__(
+        self,
+        workspace_num: int,
+        i3: I3 | None = None,
+        label: str | None = None,
+        **kwargs,
+    ):
+        self._workspace_num = workspace_num
+        self._i3 = i3 or get_i3_connection()
+
+        display_label = label if label is not None else str(workspace_num)
+
+        super().__init__(
+            name=f"workspace-button-{workspace_num}",
+            child=Label(label=display_label),
+            on_clicked=self._on_clicked,
+            **kwargs,
+        )
+
+        self.add_style_class("workspace-button")
+
+    @property
+    def workspace_num(self) -> int:
+        return self._workspace_num
+
+    def _on_clicked(self, *args):
+        self._i3.send_command(f"workspace {self._workspace_num}")
+
+    def _toggle_class(self, name: str, on: bool):
+        if on:
+            self.add_style_class(name)
+        else:
+            self.remove_style_class(name)
+
+    def set_active(self, active: bool):
+        self._toggle_class("active", active)
+
+    def set_visible_other(self, visible: bool):
+        self._toggle_class("visible", visible)
+
+    def set_empty(self, empty: bool):
+        self._toggle_class("empty", empty)
+
+    def set_urgent(self, urgent: bool):
+        self._toggle_class("urgent", urgent)
+
+    def set_foreign(self, foreign: bool):
+        self._toggle_class("foreign", foreign)
+
+
+class FensterWorkspaces(Box):
+    """Container widget showing a fixed set of workspace bubbles (1..N)."""
+
+    def __init__(
+        self,
+        output: str | None = None,
+        i3: I3 | None = None,
+        buttons_factory=None,
+        workspace_count: int = 9,
+        **kwargs,
+    ):
+        super().__init__(
+            name=kwargs.pop("name", "workspaces"),
+            spacing=kwargs.pop("spacing", 4),
+            orientation="h",
+            **kwargs,
+        )
+
+        self._output = output
+        self._workspace_count = workspace_count
+        self._i3 = i3 or get_i3_connection()
+        self._buttons_factory = buttons_factory or self._default_button_factory
+        self._buttons: dict[int, FensterWorkspaceButton] = {}
+        self._refresh_pending = False
+
+        # Pre-create one button per workspace slot so position N always means workspace N.
+        for n in range(1, workspace_count + 1):
+            button = self._buttons_factory(n)
+            self._buttons[n] = button
+            self.add(button)
+
+        bulk_connect(
+            self._i3,
+            {
+                "event::workspace::focus": self._on_event,
+                "event::workspace::init": self._on_event,
+                "event::workspace::empty": self._on_event,
+                "event::workspace::urgent": self._on_event,
+                "event::workspace::move": self._on_event,
+                "event::window::focus": self._on_event,
+                "event::window::new": self._on_event,
+                "event::window::close": self._on_event,
+            },
+        )
+
+        if self._i3.ready:
+            # Initial state is already current — no need to defer.
+            self._refresh_workspaces()
+        else:
+            self._i3.connect("notify::ready", lambda *_: self._schedule_refresh())
+
+    def _default_button_factory(self, workspace_num: int) -> FensterWorkspaceButton:
+        return FensterWorkspaceButton(workspace_num=workspace_num, i3=self._i3)
+
+    def _on_event(self, _, event: I3Event):
+        self._schedule_refresh()
+
+    def _schedule_refresh(self):
+        # Defer to the next idle tick — fenster's internal state is not always
+        # updated synchronously when an event fires, so querying GET_WORKSPACES
+        # immediately can return the pre-event view.
+        if self._refresh_pending:
+            return
+        self._refresh_pending = True
+        GLib.idle_add(self._refresh_idle)
+
+    def _refresh_idle(self):
+        self._refresh_pending = False
+        self._refresh_workspaces()
+        return False
+
+    def _refresh_workspaces(self):
+        reply = I3.send_command("", I3MessageType.GET_WORKSPACES)
+        if reply.is_ok and isinstance(reply.reply, list):
+            self._update_workspaces(reply.reply)
+
+    def _update_workspaces(self, workspaces: list):
+        ws_by_num = {
+            ws["num"]: ws for ws in workspaces if ws.get("num") is not None
+        }
+
+        for n, button in self._buttons.items():
+            ws = ws_by_num.get(n)
+            if ws is None:
+                button.set_active(False)
+                button.set_visible_other(False)
+                button.set_urgent(False)
+                button.set_empty(True)
+                button.set_foreign(False)
+                continue
+
+            focused = bool(ws.get("focused"))
+            visible = bool(ws.get("visible"))
+            urgent = bool(ws.get("urgent"))
+            ws_output = ws.get("output")
+            window_count = ws.get("window_count", 0)
+
+            button.set_active(focused)
+            # Visible on its output but not the focused one → shown on another monitor.
+            button.set_visible_other(visible and not focused)
+            button.set_urgent(urgent)
+            button.set_empty(window_count == 0)
+            # Workspace currently shown on a different output than this bar's.
+            button.set_foreign(
+                self._output is not None
+                and ws_output is not None
+                and ws_output != self._output
+            )
+
+        self.show_all()
+
+
+class FensterActiveWindow(Label):
+    """Label showing the title of the focused window"""
+
+    def __init__(
+        self,
+        i3: I3 | None = None,
+        max_length: int = 50,
+        **kwargs,
+    ):
+        super().__init__(
+            name=kwargs.pop("name", "active-window"),
+            label="",
+            **kwargs,
+        )
+
+        self._i3 = i3 or get_i3_connection()
+        self._max_length = max_length
+
+        bulk_connect(
+            self._i3,
+            {
+                "event::window::focus": self._on_window_event,
+                "event::window::title": self._on_window_event,
+                "event::window::close": self._on_window_close,
+            },
+        )
+
+        if self._i3.ready:
+            self._initialize()
+        else:
+            self._i3.connect("notify::ready", lambda *_: self._initialize())
+
+    def _initialize(self):
+        tree_reply = I3.send_command("", I3MessageType.GET_TREE)
+        if tree_reply.is_ok and isinstance(tree_reply.reply, dict):
+            focused = self._find_focused(tree_reply.reply)
+            if focused:
+                self._set_title(focused.get("name") or "")
+                return
+        self.set_label("")
+
+    def _find_focused(self, node: dict) -> dict | None:
+        if node.get("focused") and node.get("type") == "con":
+            return node
+        for child in node.get("nodes", []) + node.get("floating_nodes", []):
+            result = self._find_focused(child)
+            if result:
+                return result
+        return None
+
+    def _on_window_event(self, _, event: I3Event):
+        container = event.data.get("container", {})
+        self._set_title(container.get("name") or "")
+
+    def _on_window_close(self, _, event: I3Event):
+        self._initialize()
+
+    def _set_title(self, title: str):
+        if len(title) > self._max_length:
+            title = title[: self._max_length - 3] + "..."
+        self.set_label(title)

sims/widgets/notification.py

@@ -0,0 +1,136 @@
+from fabric.notifications import Notification
+from fabric.utils import invoke_repeater
+from fabric.widgets.box import Box
+from fabric.widgets.button import Button
+from fabric.widgets.image import Image
+from fabric.widgets.label import Label
+from gi.repository import GdkPixbuf
+
+from sims.utils.markup import render_body_markup
+
+NOTIFICATION_IMAGE_SIZE = 64
+
+
+class NotificationWidget(Box):
+    def __init__(
+        self,
+        notification: Notification,
+        width: int = 360,
+        timeout_ms: int = 10_000,
+        **kwargs,
+    ):
+        super().__init__(
+            size=(width, -1),
+            name="notification",
+            spacing=8,
+            orientation="v",
+            **kwargs,
+        )
+
+        self._notification = notification
+
+        urgency_class = {0: "urgency-low", 1: "urgency-normal", 2: "urgency-critical"}.get(
+            notification.urgency, "urgency-normal"
+        )
+        self.get_style_context().add_class(urgency_class)
+
+        body_container = Box(spacing=4, orientation="h")
+
+        if image_pixbuf := self._notification.image_pixbuf:
+            body_container.add(
+                Image(
+                    pixbuf=image_pixbuf.scale_simple(
+                        NOTIFICATION_IMAGE_SIZE,
+                        NOTIFICATION_IMAGE_SIZE,
+                        GdkPixbuf.InterpType.BILINEAR,
+                    )
+                )
+            )
+
+        text_children = []
+        summary = self._notification.summary or ""
+        body = self._notification.body or ""
+
+        text_children.append(
+            Box(
+                orientation="h",
+                children=[
+                    Label(label=summary, ellipsization="middle")
+                    .build()
+                    .add_style_class("summary")
+                    .unwrap(),
+                ],
+                h_expand=True,
+                v_expand=True,
+            ).build(
+                lambda box, _: box.pack_end(
+                    Button(
+                        image=Image(icon_name="window-close-symbolic", icon_size=18),
+                        v_align="center",
+                        h_align="end",
+                        on_clicked=lambda *_: self._notification.close(),
+                    ),
+                    False,
+                    False,
+                    0,
+                )
+            )
+        )
+
+        if body:
+            body_text, body_is_markup = render_body_markup(body)
+            body_kwargs = {"markup": body_text} if body_is_markup else {"label": body_text}
+            text_children.append(
+                Label(
+                    **body_kwargs,
+                    line_wrap="word-char",
+                    v_align="start",
+                    h_align="start",
+                )
+                .build()
+                .add_style_class("body")
+                .unwrap()
+            )
+
+        body_container.add(
+            Box(
+                spacing=4,
+                orientation="v",
+                children=text_children,
+                h_expand=True,
+                v_expand=True,
+            )
+        )
+
+        self.add(body_container)
+
+        if actions := self._notification.actions:
+            self.add(
+                Box(
+                    spacing=4,
+                    orientation="h",
+                    children=[
+                        Button(
+                            h_expand=True,
+                            v_expand=True,
+                            label=action.label,
+                            on_clicked=lambda *_, action=action: action.invoke(),
+                        )
+                        for action in actions
+                    ],
+                )
+            )
+
+        self._notification.connect(
+            "closed",
+            lambda *_: (
+                parent.remove(self) if (parent := self.get_parent()) else None,  # type: ignore
+                self.destroy(),
+            ),
+        )
+
+        invoke_repeater(
+            timeout_ms,
+            lambda: self._notification.close("expired"),
+            initial_call=False,
+        )

sims/widgets/notification_history_entry.py

@@ -0,0 +1,103 @@
+import time
+from typing import Callable
+
+from fabric.widgets.box import Box
+from fabric.widgets.button import Button
+from fabric.widgets.image import Image
+from fabric.widgets.label import Label
+
+from sims.services.notification_history import HistoryEntry
+from sims.utils.markup import render_body_markup
+
+
+def _time_ago(ts: float, now: float | None = None) -> str:
+    delta = int((now if now is not None else time.time()) - ts)
+    if delta < 60:
+        return "just now"
+    if delta < 3600:
+        return f"{delta // 60}m ago"
+    if delta < 86400:
+        return f"{delta // 3600}h ago"
+    return f"{delta // 86400}d ago"
+
+
+class NotificationHistoryEntryWidget(Box):
+    THUMB_SIZE = 40
+
+    def __init__(
+        self,
+        entry: HistoryEntry,
+        on_dismiss: Callable[[int], None],
+        **kwargs,
+    ):
+        super().__init__(
+            name="notification-history-entry",
+            spacing=8,
+            orientation="h",
+            **kwargs,
+        )
+        urgency_class = {0: "urgency-low", 1: "urgency-normal", 2: "urgency-critical"}.get(
+            entry.urgency, "urgency-normal"
+        )
+        self.get_style_context().add_class(urgency_class)
+
+        if entry.pixbuf is not None:
+            self.add(Image(pixbuf=entry.pixbuf, h_align="start", v_align="start"))
+
+        text_children: list = []
+
+        header = Box(orientation="h", h_expand=True)
+        header.pack_start(
+            Label(
+                label=entry.summary,
+                ellipsization="end",
+                h_align="start",
+            )
+            .build()
+            .add_style_class("summary")
+            .unwrap(),
+            True,
+            True,
+            0,
+        )
+        header.pack_end(
+            Label(label=_time_ago(entry.timestamp), h_align="end")
+            .build()
+            .add_style_class("timestamp")
+            .unwrap(),
+            False,
+            False,
+            0,
+        )
+        text_children.append(header)
+
+        if entry.body:
+            body_text, body_is_markup = render_body_markup(entry.body)
+            body_kwargs = {"markup": body_text} if body_is_markup else {"label": body_text}
+            text_children.append(
+                Label(
+                    **body_kwargs,
+                    line_wrap="word-char",
+                    h_align="start",
+                    v_align="start",
+                )
+                .build()
+                .add_style_class("body")
+                .unwrap()
+            )
+
+        text_box = Box(orientation="v", spacing=2, children=text_children, h_expand=True)
+        self.add(text_box)
+
+        self.pack_end(
+            Button(
+                name="notification-history-dismiss",
+                image=Image(icon_name="window-close-symbolic", icon_size=14),
+                v_align="start",
+                h_align="end",
+                on_clicked=lambda *_: on_dismiss(entry.id),
+            ),
+            False,
+            False,
+            0,
+        )