feat: integrate upstream PRs (TomBadash#171, TomBadash#180, TomBadash#181, TomBadash#184, TomBadash#185, TomBadash#191, TomBadash#193, TomBadash#195, TomBadash#196, TomBadash#198, TomBadash#216)

Merge and adapt the following upstream pull requests, resolving conflicts
with MX Master 4 haptic and Actions Ring features:

Clean merges:
- PR TomBadash#193: symlink-safe config save via os.path.realpath()
- PR TomBadash#198: fractional hscroll threshold (0.1 default, int/float compat)
- PR TomBadash#185: pass through OS mouse events when no Logitech device connected
- PR TomBadash#180: persist hardware-reported DPI across restarts
- PR TomBadash#181: memoize Backend list properties for QML UI performance
- PR TomBadash#195: ping-pong desktop cycling action (macOS Spaces)

Conflict-resolution merges:
- PR TomBadash#196: nested macOS app identity matching with tuple identities
- PR TomBadash#191: Shift+wheel horizontal scroll translation (cross-platform)
- PR TomBadash#216 (partial): phase-aware trackpad filter + 0.01 hscroll floor

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: David Noyes

core/app_detector.py

@@ -5,14 +5,119 @@
 macOS:   NSWorkspace.sharedWorkspace().frontmostApplication().
 """
 
+import functools
 import os
+import plistlib
 import sys
 import threading
 import time
 
 
+def _path_from_nsurl(url) -> str | None:
+    if url is None:
+        return None
+    try:
+        path_attr = getattr(url, "path", None)
+        path = path_attr() if callable(path_attr) else path_attr
+        return str(path) if path else None
+    except Exception:
+        return None
+
+
+def _call_ns_method(obj, name: str):
+    try:
+        attr = getattr(obj, name, None)
+        return attr() if callable(attr) else attr
+    except Exception:
+        return None
+
+
+def _dedupe_keep_order(values) -> tuple[str, ...]:
+    result = []
+    seen = set()
+    for value in values:
+        if value is None:
+            continue
+        text = str(value)
+        if not text:
+            continue
+        key = text.casefold()
+        if key in seen:
+            continue
+        seen.add(key)
+        result.append(text)
+    return tuple(result)
+
+
+def _single_identity(value: str | None) -> tuple[str, ...]:
+    return (value,) if value else ()
+
+
+def _macos_app_bundles_in_path(path: str | None) -> tuple[str, ...]:
+    """Return containing .app bundles ordered inner-most to outer-most."""
+    if not path:
+        return ()
+
+    normalized = os.path.abspath(path)
+    parts = normalized.split(os.sep)
+    bundles = []
+    for idx, part in enumerate(parts):
+        if part.endswith(".app"):
+            if normalized.startswith(os.sep):
+                bundles.append(os.path.join(os.sep, *parts[1:idx + 1]))
+            else:
+                bundles.append(os.path.join(*parts[:idx + 1]))
+    return tuple(reversed(bundles))
+
+
+@functools.lru_cache(maxsize=256)
+def _read_macos_bundle_identifier(app_path: str | None) -> str | None:
+    if not app_path:
+        return None
+    info_path = os.path.join(app_path, "Contents", "Info.plist")
+    try:
+        with open(info_path, "rb") as f:
+            info = plistlib.load(f)
+        ident = info.get("CFBundleIdentifier")
+        return str(ident) if ident else None
+    except (OSError, ValueError, TypeError):
+        return None
+
+
+def _macos_running_app_identities(app) -> tuple[str, ...]:
+    """Return profile-matching identities, ordered most-specific first."""
+    bundle_path = _path_from_nsurl(_call_ns_method(app, "bundleURL"))
+    executable_path = _path_from_nsurl(_call_ns_method(app, "executableURL"))
+    ident = _call_ns_method(app, "bundleIdentifier")
+    localized_name = _call_ns_method(app, "localizedName")
+
+    identities = []
+    if ident:
+        identities.append(str(ident))
+
+    bundles = _dedupe_keep_order([
+        *_macos_app_bundles_in_path(bundle_path),
+        *_macos_app_bundles_in_path(executable_path),
+    ])
+    for app_path in bundles:
+        bundle_ident = _read_macos_bundle_identifier(app_path)
+        if bundle_ident:
+            identities.append(bundle_ident)
+        identities.append(app_path)
+        identities.append(os.path.basename(app_path))
+        identities.append(os.path.splitext(os.path.basename(app_path))[0])
+
+    if executable_path:
+        identities.append(executable_path)
+        identities.append(os.path.basename(executable_path))
+    if localized_name:
+        identities.append(str(localized_name))
+
+    return _dedupe_keep_order(identities)
+
+
 # ==================================================================
-# Platform-specific get_foreground_exe()
+# Platform-specific foreground app identity resolution
 # ==================================================================
 
 if sys.platform == "win32":
@@ -133,39 +238,37 @@ def _enum_cb(hwnd, _lparam):
         user32.EnumWindows(WNDENUMPROC(_enum_cb), 0)
         return result[0]
 
-    def get_foreground_exe() -> str | None:
-        """Return the foreground app path on Windows, or None."""
+    def get_foreground_app_identity() -> tuple[str, ...]:
+        """Return the foreground app path on Windows, or an empty tuple."""
         hwnd = user32.GetForegroundWindow()
         if not hwnd:
-            return None
+            return ()
         pid = wt.DWORD()
         user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
         if pid.value == 0:
-            return None
+            return ()
         exe_path = _path_from_pid(pid.value)
         if not exe_path:
-            return None
+            return ()
         exe_lower = os.path.basename(exe_path).lower()
         if exe_lower == "applicationframehost.exe":
             real = _resolve_uwp_child(hwnd)
-            # If we can't resolve the real app (e.g. fullscreen UWP),
-            # return None so the detector keeps the last known profile.
-            return real
+            # If we can't resolve the real app (e.g. fullscreen UWP), return
+            # an empty tuple so the detector keeps the last known profile.
+            return _single_identity(real)
         if exe_lower == "explorer.exe":
             wc = _get_window_class(hwnd)
             if wc not in _EXPLORER_CLASSES:
                 title = _get_window_title(hwnd)
                 print(f"[AppDetect] FG: explorer.exe class={wc} title='{title}'")
                 real = _resolve_uwp_child(hwnd)
                 if real:
-                    return real
+                    return _single_identity(real)
                 real = _find_uwp_app_global()
-                return real  # None keeps last profile
-        return exe_path
+                return _single_identity(real)
+        return _single_identity(exe_path)
 
 elif sys.platform == "darwin":
-    import functools
-
     try:
         import objc as _objc
     except ImportError as exc:
@@ -182,22 +285,16 @@ def wrapper(*args, **kwargs):
         return wrapper
 
     @_autoreleased
-    def get_foreground_exe() -> str | None:
-        """Return a stable app identifier for the frontmost app on macOS."""
+    def get_foreground_app_identity() -> tuple[str, ...]:
+        """Return stable frontmost app identities on macOS."""
         try:
             from AppKit import NSWorkspace
             app = NSWorkspace.sharedWorkspace().frontmostApplication()
             if app is None:
-                return None
-            ident = app.bundleIdentifier()
-            if ident:
-                return ident
-            url = app.executableURL()
-            if url:
-                return os.path.basename(url.path())
-            return app.localizedName()
+                return ()
+            return _macos_running_app_identities(app)
         except Exception:
-            return None
+            return ()
 
 elif sys.platform == "linux":
     import subprocess as _subprocess
@@ -237,35 +334,37 @@ def _get_foreground_kdotool() -> str | None:
             pass
         return None
 
-    def get_foreground_exe() -> str | None:
+    def get_foreground_app_identity() -> tuple[str, ...]:
         """Return the foreground app executable path on Linux."""
         if _WAYLAND:
             if _KDE:
                 exe = _get_foreground_kdotool()
                 if exe:
-                    return exe
+                    return _single_identity(exe)
                 # Fall back to xdotool so XWayland apps still work when
                 # kdotool is unavailable or cannot resolve the active window.
-                return _get_foreground_xdotool()
+                exe = _get_foreground_xdotool()
+                return _single_identity(exe)
             # GNOME / other Wayland compositors: not yet supported
-            return None
-        return _get_foreground_xdotool()
+            return ()
+        exe = _get_foreground_xdotool()
+        return _single_identity(exe)
 
 else:
-    def get_foreground_exe() -> str | None:
-        return None
+    def get_foreground_app_identity() -> tuple[str, ...]:
+        return ()
 
 
 class AppDetector:
     """
     Polls the foreground window every *interval* seconds.
-    Calls ``on_change(exe_name: str)`` when the foreground app changes.
+    Calls ``on_change(app_identity)`` when the foreground app changes.
     """
 
     def __init__(self, on_change, interval: float = 0.3):
         self._on_change = on_change
         self._interval = interval
-        self._last_exe: str | None = None
+        self._last_app_identity: tuple[str, ...] | None = None
         self._stop = threading.Event()
         self._thread: threading.Thread | None = None
 
@@ -285,10 +384,10 @@ def stop(self):
     def _poll(self):
         while not self._stop.is_set():
             try:
-                exe = get_foreground_exe()
-                if exe and exe != self._last_exe:
-                    self._last_exe = exe
-                    self._on_change(exe)
+                app_identity = get_foreground_app_identity()
+                if app_identity and app_identity != self._last_app_identity:
+                    self._last_app_identity = app_identity
+                    self._on_change(app_identity)
             except Exception:
                 pass
             self._stop.wait(self._interval)

core/config.py

@@ -95,7 +95,7 @@
     "settings": {
         "start_minimized": True,
         "start_at_login": False,
-        "hscroll_threshold": 1,
+        "hscroll_threshold": 0.1,
         "invert_hscroll": False,  # swap horizontal scroll directions
         "invert_vscroll": False,  # swap vertical scroll directions
         "dpi": 1000,              # pointer speed / DPI setting
@@ -186,15 +186,20 @@ def load_config():
 def save_config(cfg):
     """Persist config to disk via atomic write with restrictive permissions."""
     ensure_config_dir()
-    fd, tmp_path = tempfile.mkstemp(suffix=".tmp", dir=CONFIG_DIR)
+    # Resolve symlinks so an atomic rename updates the link's target rather than
+    # clobbering the link itself — preserves setups like GNU stow that symlink
+    # config.json into a dotfiles repo.
+    target_path = os.path.realpath(CONFIG_FILE)
+    target_dir = os.path.dirname(target_path) or CONFIG_DIR
+    fd, tmp_path = tempfile.mkstemp(suffix=".tmp", dir=target_dir)
     try:
         with os.fdopen(fd, "w", encoding="utf-8") as f:
             json.dump(cfg, f, indent=2)
             f.flush()
             os.fsync(f.fileno())
         if sys.platform != "win32":
             os.chmod(tmp_path, stat.S_IRUSR | stat.S_IWUSR)
-        os.replace(tmp_path, CONFIG_FILE)
+        os.replace(tmp_path, target_path)
     except BaseException:
         try:
             os.unlink(tmp_path)
@@ -309,16 +314,67 @@ def resolve_app_for_config(spec: str):
     return app_catalog.resolve_app_spec(spec)
 
 
-def get_profile_for_app(cfg, exe_name):
-    """Return the profile name that matches the given executable, or 'default'."""
-    if not exe_name:
+def _dedupe_specs(candidates) -> list[str]:
+    result = []
+    seen = set()
+    for candidate in candidates:
+        if not candidate:
+            continue
+        candidate = str(candidate)
+        key = candidate.casefold()
+        if key in seen:
+            continue
+        seen.add(key)
+        result.append(candidate)
+    return result
+
+
+def _identity_specs(app_identity: tuple[str, ...] | None) -> list[str]:
+    return _dedupe_specs(app_identity or ())
+
+
+def _configured_app_specs(app_spec: str | None) -> list[str]:
+    return _dedupe_specs((app_spec,) if app_spec else ())
+
+
+def _app_identity_aliases(spec: str) -> set[str]:
+    if not spec:
+        return set()
+    entry = resolve_app_for_config(spec)
+    if not entry:
+        return {spec.casefold()}
+    aliases = [entry.get("id", ""), *entry.get("aliases", [])]
+    return {alias.casefold() for alias in aliases if alias}
+
+
+def get_profile_for_app_identity(cfg, app_identity: tuple[str, ...] | None) -> str:
+    """
+    Return the profile name that matches an app identity, or 'default'.
+
+    ``app_identity`` is an ordered tuple of identifiers. Identifiers are matched
+    most-specific first, allowing a nested app profile to win before falling
+    back to its host app profile.
+    """
+    identities = _identity_specs(app_identity)
+    if not identities:
         return "default"
-    entry = resolve_app_for_config(exe_name)
-    aliases = {a.lower() for a in ([entry["id"]] + entry.get("aliases", []))} if entry else {exe_name.lower()}
-    for pname, pdata in cfg.get("profiles", {}).items():
-        for app in pdata.get("apps", []):
-            if app.lower() in aliases:
-                return pname
+
+    alias_cache = {}
+
+    def aliases_for(spec: str) -> set[str]:
+        key = spec.casefold()
+        if key not in alias_cache:
+            alias_cache[key] = _app_identity_aliases(spec)
+        return alias_cache[key]
+
+    profiles = list(cfg.get("profiles", {}).items())
+    for identity in identities:
+        aliases = aliases_for(identity)
+        for pname, pdata in profiles:
+            for app in pdata.get("apps", []):
+                for app_spec in _configured_app_specs(app):
+                    if aliases & aliases_for(app_spec):
+                        return pname
     return "default"
 
 
@@ -453,6 +509,16 @@ def _merge_defaults(cfg, defaults):
     return cfg
 
 
+
+def _is_compatible_type(value, default_val):
+    """Return True for values that are safe despite differing exact types."""
+    return (
+        isinstance(default_val, float)
+        and isinstance(value, int)
+        and not isinstance(value, bool)
+    )
+
+
 def _validate_types(cfg, defaults, path=""):
     """Reset values whose type doesn't match the defaults template."""
     for key, default_val in defaults.items():
@@ -465,6 +531,8 @@ def _validate_types(cfg, defaults, path=""):
                 print(f"[Config] Type mismatch at {path}.{key}: "
                       f"expected dict, got {type(cfg[key]).__name__}")
                 cfg[key] = json.loads(json.dumps(default_val))
+        elif _is_compatible_type(cfg[key], default_val):
+            continue
         elif not isinstance(cfg[key], type(default_val)):
             print(f"[Config] Type mismatch at {path}.{key}: "
                   f"expected {type(default_val).__name__}, "