diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index e62f7108..2cb69798 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -45,7 +45,7 @@ jobs:
         if: runner.os == 'Linux'
         run: |
           sudo apt-get update
-          sudo apt-get install libx11-dev libxtst-dev libadwaita-1-dev libgtk-4-dev
+          sudo apt-get install libx11-dev libxtst-dev libadwaita-1-dev libgtk-4-dev libdbus-1-dev
       - name: Install macOS dependencies
         if: runner.os == 'macOS'
         run: brew install gtk4 libadwaita imagemagick
diff --git a/.gitignore b/.gitignore
index b3fbd05e..05b1199d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 /target
+.claude/
 .gdbinit
 .idea/
 .vs/
diff --git a/Cargo.lock b/Cargo.lock
index b241e014..c678d13d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,12 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
 [[package]]
 name = "aead"
 version = "0.5.2"
@@ -55,6 +61,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "ansi_term"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "anstream"
 version = "1.0.0"
@@ -111,6 +126,27 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
+[[package]]
+name = "arboard"
+version = "3.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
+dependencies = [
+ "clipboard-win",
+ "image",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "parking_lot",
+ "percent-encoding",
+ "windows-sys 0.60.2",
+ "wl-clipboard-rs",
+ "x11rb",
+]
+
 [[package]]
 name = "arraydeque"
 version = "0.5.1"
@@ -147,7 +183,7 @@ dependencies = [
  "asn1-rs-derive",
  "asn1-rs-impl",
  "displaydoc",
- "nom",
+ "nom 7.1.3",
  "num-traits",
  "rusticata-macros",
  "thiserror 1.0.69",
@@ -201,6 +237,24 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "async-io"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite",
+ "parking",
+ "polling",
+ "rustix 1.1.4",
+ "slab",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "async-recursion"
 version = "1.1.1"
@@ -223,6 +277,17 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi 0.1.19",
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -286,18 +351,39 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "block2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
+dependencies = [
+ "objc2",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
 [[package]]
 name = "byteorder"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
 [[package]]
 name = "bytes"
 version = "1.11.1"
@@ -409,6 +495,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
 [[package]]
 name = "cipher"
 version = "0.4.4"
@@ -419,6 +511,21 @@ dependencies = [
  "inout",
 ]
 
+[[package]]
+name = "clap"
+version = "2.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags 1.3.2",
+ "strsim 0.8.0",
+ "textwrap",
+ "unicode-width",
+ "vec_map",
+]
+
 [[package]]
 name = "clap"
 version = "4.6.0"
@@ -438,7 +545,7 @@ dependencies = [
  "anstream",
  "anstyle",
  "clap_lex",
- "strsim",
+ "strsim 0.11.1",
 ]
 
 [[package]]
@@ -459,6 +566,15 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 
+[[package]]
+name = "clipboard-win"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"
+dependencies = [
+ "error-code",
+]
+
 [[package]]
 name = "colorchoice"
 version = "1.0.5"
@@ -500,6 +616,16 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.10.1"
@@ -523,7 +649,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97"
 dependencies = [
  "bitflags 2.11.0",
- "core-foundation",
+ "core-foundation 0.10.1",
  "core-graphics-types",
  "foreign-types",
  "libc",
@@ -536,7 +662,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
 dependencies = [
  "bitflags 2.11.0",
- "core-foundation",
+ "core-foundation 0.10.1",
  "libc",
 ]
 
@@ -550,27 +676,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "critical-section"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
-
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
+name = "crc32fast"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
- "crossbeam-utils",
+ "cfg-if",
 ]
 
 [[package]]
@@ -579,6 +690,12 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
 [[package]]
 name = "crypto-bigint"
 version = "0.5.5"
@@ -586,7 +703,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
 dependencies = [
  "generic-array",
- "rand_core 0.6.4",
+ "rand_core",
  "subtle",
  "zeroize",
 ]
@@ -598,7 +715,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
- "rand_core 0.6.4",
+ "rand_core",
  "typenum",
 ]
 
@@ -643,6 +760,37 @@ version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
 
+[[package]]
+name = "dbus"
+version = "0.9.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b942602992bb7acfd1f51c49811c58a610ef9181b6e66f3e519d79b540a3bf73"
+dependencies = [
+ "libc",
+ "libdbus-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dbus-codegen"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a49da9fdfbe872d4841d56605dc42efa5e6ca3291299b87f44e1cde91a28617c"
+dependencies = [
+ "clap 2.34.0",
+ "dbus",
+ "xml-rs",
+]
+
+[[package]]
+name = "dbus-tree"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f456e698ae8e54575e19ddb1f9b7bce2298568524f215496b248eb9498b4f508"
+dependencies = [
+ "dbus",
+]
+
 [[package]]
 name = "der"
 version = "0.7.10"
@@ -662,7 +810,7 @@ checksum = "5cd0a5c643689626bec213c4d8bd4d96acc8ffdb4ad4bb6bc16abf27d5f4b553"
 dependencies = [
  "asn1-rs",
  "displaydoc",
- "nom",
+ "nom 7.1.3",
  "num-bigint",
  "num-traits",
  "rusticata-macros",
@@ -689,6 +837,18 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "dispatch2"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "libc",
+ "objc2",
+]
+
 [[package]]
 name = "displaydoc"
 version = "0.2.5"
@@ -700,6 +860,17 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "dlopen2"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e2c5bd4158e66d1e215c49b837e11d62f3267b30c92f1d171c4d3105e3dc4d4"
+dependencies = [
+ "libc",
+ "once_cell",
+ "winapi",
+]
+
 [[package]]
 name = "downcast-rs"
 version = "1.2.1"
@@ -735,7 +906,7 @@ dependencies = [
  "hkdf",
  "pem-rfc7468",
  "pkcs8",
- "rand_core 0.6.4",
+ "rand_core",
  "sec1",
  "subtle",
  "zeroize",
@@ -747,18 +918,6 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
 
-[[package]]
-name = "enum-as-inner"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "enumflags2"
 version = "0.7.12"
@@ -819,6 +978,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "error-code"
+version = "3.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dea2df4cf52843e0452895c455a1a2cfbb842a1e7329671acf418fdc53ed4c59"
+
 [[package]]
 name = "event-listener"
 version = "5.4.1"
@@ -846,13 +1011,28 @@ version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
+[[package]]
+name = "fax"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a"
+
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
 [[package]]
 name = "ff"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
 dependencies = [
- "rand_core 0.6.4",
+ "rand_core",
  "subtle",
 ]
 
@@ -878,6 +1058,39 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "flume"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "spin",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
 [[package]]
 name = "foldhash"
 version = "0.1.5"
@@ -1098,6 +1311,16 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "gethostname"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8"
+dependencies = [
+ "rustix 1.1.4",
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -1281,7 +1504,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
 dependencies = [
  "ff",
- "rand_core 0.6.4",
+ "rand_core",
  "subtle",
 ]
 
@@ -1368,6 +1591,17 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "zerocopy",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.15.5"
@@ -1390,56 +1624,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
-name = "hex"
-version = "0.4.3"
+name = "hermit-abi"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
 
 [[package]]
-name = "hickory-proto"
-version = "0.25.2"
+name = "hermit-abi"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8a6fe56c0038198998a6f217ca4e7ef3a5e51f46163bd6dd60b5c71ca6c6502"
-dependencies = [
- "async-trait",
- "cfg-if",
- "data-encoding",
- "enum-as-inner",
- "futures-channel",
- "futures-io",
- "futures-util",
- "idna",
- "ipnet",
- "once_cell",
- "rand 0.9.2",
- "ring",
- "thiserror 2.0.18",
- "tinyvec",
- "tokio",
- "tracing",
- "url",
-]
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
 [[package]]
-name = "hickory-resolver"
-version = "0.25.2"
+name = "hex"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc62a9a99b0bfb44d2ab95a7208ac952d31060efc16241c87eaf36406fecf87a"
-dependencies = [
- "cfg-if",
- "futures-util",
- "hickory-proto",
- "ipconfig",
- "moka",
- "once_cell",
- "parking_lot",
- "rand 0.9.2",
- "resolv-conf",
- "smallvec",
- "thiserror 2.0.18",
- "tokio",
- "tracing",
-]
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hkdf"
@@ -1603,6 +1806,63 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "if-addrs"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69b2eeee38fef3aa9b4cc5f1beea8a2444fc00e7377cafae396de3f5c2065e24"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "if-addrs"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0a05c691e1fae256cf7013d99dad472dc52d5543322761f83ec8d47eab40d2b"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "if-watch"
+version = "3.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71c02a5161c313f0cbdbadc511611893584a10a7b6153cb554bdf83ddce99ec2"
+dependencies = [
+ "async-io",
+ "core-foundation 0.9.4",
+ "fnv",
+ "futures",
+ "if-addrs 0.15.0",
+ "ipnet",
+ "log",
+ "netlink-packet-core",
+ "netlink-packet-route 0.28.0",
+ "netlink-proto",
+ "netlink-sys",
+ "rtnetlink",
+ "system-configuration",
+ "tokio",
+ "windows 0.62.2",
+]
+
+[[package]]
+name = "image"
+version = "0.25.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "moxcms",
+ "num-traits",
+ "png",
+ "tiff",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.13.1"
@@ -1649,21 +1909,27 @@ dependencies = [
 name = "input-capture"
 version = "0.3.0"
 dependencies = [
+ "arboard",
  "ashpd",
  "async-trait",
  "bitflags 2.11.0",
- "core-foundation",
+ "core-foundation 0.10.1",
  "core-foundation-sys",
  "core-graphics",
  "futures",
  "futures-core",
  "input-event",
  "keycode",
+ "lan-mouse-ipc",
  "libc",
  "log",
  "memmap",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
  "once_cell",
  "reis",
+ "serde_json",
  "tempfile",
  "thiserror 2.0.18",
  "tokio",
@@ -1671,18 +1937,20 @@ dependencies = [
  "wayland-client",
  "wayland-protocols",
  "wayland-protocols-wlr",
- "windows",
+ "windows 0.61.3",
  "x11",
+ "x11rb",
 ]
 
 [[package]]
 name = "input-emulation"
 version = "0.3.0"
 dependencies = [
+ "arboard",
  "ashpd",
  "async-trait",
  "bitflags 2.11.0",
- "core-foundation",
+ "core-foundation 0.10.1",
  "core-foundation-sys",
  "core-graphics",
  "futures",
@@ -1697,7 +1965,7 @@ dependencies = [
  "wayland-protocols",
  "wayland-protocols-misc",
  "wayland-protocols-wlr",
- "windows",
+ "windows 0.61.3",
  "x11",
 ]
 
@@ -1713,19 +1981,6 @@ dependencies = [
  "thiserror 2.0.18",
 ]
 
-[[package]]
-name = "ipconfig"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d40460c0ce33d6ce4b0630ad68ff63d6661961c48b6dba35e5a4d81cfb48222"
-dependencies = [
- "socket2",
- "widestring",
- "windows-registry",
- "windows-result 0.4.1",
- "windows-sys 0.61.2",
-]
-
 [[package]]
 name = "ipnet"
 version = "2.12.0"
@@ -1838,14 +2093,28 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "ksni"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4934310bdd016e55725482b8d35ac0c16fd058c1b955d8959aa2d953b918c85b"
+dependencies = [
+ "dbus",
+ "dbus-codegen",
+ "dbus-tree",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "lan-mouse"
 version = "0.10.0"
 dependencies = [
- "clap",
+ "clap 4.6.0",
  "env_logger",
  "futures",
- "hickory-resolver",
+ "hostname",
+ "if-addrs 0.13.4",
+ "if-watch",
  "input-capture",
  "input-emulation",
  "input-event",
@@ -1856,6 +2125,8 @@ dependencies = [
  "libc",
  "local-channel",
  "log",
+ "mdns-sd",
+ "netdev",
  "notify",
  "rcgen",
  "rustls",
@@ -1877,7 +2148,7 @@ dependencies = [
 name = "lan-mouse-cli"
 version = "0.2.0"
 dependencies = [
- "clap",
+ "clap 4.6.0",
  "futures",
  "lan-mouse-ipc",
  "thiserror 2.0.18",
@@ -1892,6 +2163,8 @@ dependencies = [
  "glib-build-tools",
  "gtk4",
  "hostname",
+ "input-capture",
+ "ksni",
  "lan-mouse-ipc",
  "libadwaita",
  "log",
@@ -1970,6 +2243,15 @@ version = "0.2.184"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af"
 
+[[package]]
+name = "libdbus-sys"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "328c4789d42200f1eeec05bd86c9c13c7f091d2ba9a6ea35acdf51f31bc0f043"
+dependencies = [
+ "pkg-config",
+]
+
 [[package]]
 name = "libgit2-sys"
 version = "0.18.3+1.9.2"
@@ -2044,6 +2326,27 @@ version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
+[[package]]
+name = "mac-addr"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3d25b0e0b648a86960ac23b7ad4abb9717601dec6f66c165f5b037f3f03065f"
+
+[[package]]
+name = "mdns-sd"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2bb8ce26633738d98ffcef71ec58bff967c6675be50229823c2835f6316e67e"
+dependencies = [
+ "fastrand",
+ "flume",
+ "if-addrs 0.15.0",
+ "log",
+ "mio",
+ "socket-pktinfo",
+ "socket2",
+]
+
 [[package]]
 name = "memchr"
 version = "2.8.0"
@@ -2084,6 +2387,16 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
 [[package]]
 name = "mio"
 version = "1.2.0"
@@ -2097,20 +2410,97 @@ dependencies = [
 ]
 
 [[package]]
-name = "moka"
-version = "0.12.15"
+name = "moxcms"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "957228ad12042ee839f93c8f257b62b4c0ab5eaae1d4fa60de53b27c9d7c5046"
+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
 dependencies = [
- "crossbeam-channel",
- "crossbeam-epoch",
- "crossbeam-utils",
- "equivalent",
- "parking_lot",
- "portable-atomic",
- "smallvec",
- "tagptr",
- "uuid",
+ "num-traits",
+ "pxfm",
+]
+
+[[package]]
+name = "netdev"
+version = "0.43.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57bacaf873ee4eab5646f99b381b271ec75e716902a67cf962c0f328c5eb5bfb"
+dependencies = [
+ "block2",
+ "dispatch2",
+ "dlopen2",
+ "ipnet",
+ "libc",
+ "mac-addr",
+ "netlink-packet-core",
+ "netlink-packet-route 0.29.0",
+ "netlink-sys",
+ "objc2-core-foundation",
+ "objc2-core-wlan",
+ "objc2-foundation",
+ "objc2-system-configuration",
+ "once_cell",
+ "plist",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "netlink-packet-core"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3463cbb78394cb0141e2c926b93fc2197e473394b761986eca3b9da2c63ae0f4"
+dependencies = [
+ "paste",
+]
+
+[[package]]
+name = "netlink-packet-route"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ce3636fa715e988114552619582b530481fd5ef176a1e5c1bf024077c2c9445"
+dependencies = [
+ "bitflags 2.11.0",
+ "libc",
+ "log",
+ "netlink-packet-core",
+]
+
+[[package]]
+name = "netlink-packet-route"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9854ea6ad14e3f4698a7f03b65bce0833dd2d81d594a0e4a984170537146b6"
+dependencies = [
+ "bitflags 2.11.0",
+ "libc",
+ "log",
+ "netlink-packet-core",
+]
+
+[[package]]
+name = "netlink-proto"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b65d130ee111430e47eed7896ea43ca693c387f097dd97376bffafbf25812128"
+dependencies = [
+ "bytes",
+ "futures",
+ "log",
+ "netlink-packet-core",
+ "netlink-sys",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "netlink-sys"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd6c30ed10fa69cc491d491b85cc971f6bdeb8e7367b7cde2ee6cc878d583fae"
+dependencies = [
+ "bytes",
+ "futures-util",
+ "libc",
+ "log",
+ "tokio",
 ]
 
 [[package]]
@@ -2126,6 +2516,18 @@ dependencies = [
  "pin-utils",
 ]
 
+[[package]]
+name = "nix"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
+dependencies = [
+ "bitflags 2.11.0",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
 [[package]]
 name = "nom"
 version = "7.1.3"
@@ -2136,6 +2538,15 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "notify"
 version = "8.2.0"
@@ -2208,24 +2619,227 @@ dependencies = [
 ]
 
 [[package]]
-name = "num_enum_derive"
-version = "0.7.6"
+name = "num_enum_derive"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "num_threads"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "objc2"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
+dependencies = [
+ "objc2-encode",
+]
+
+[[package]]
+name = "objc2-app-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "libc",
+ "objc2",
+ "objc2-cloud-kit",
+ "objc2-core-data",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-core-image",
+ "objc2-core-text",
+ "objc2-core-video",
+ "objc2-foundation",
+ "objc2-quartz-core",
+]
+
+[[package]]
+name = "objc2-cloud-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-data"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "dispatch2",
+ "libc",
+ "objc2",
+]
+
+[[package]]
+name = "objc2-core-graphics"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
+dependencies = [
+ "bitflags 2.11.0",
+ "dispatch2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-io-surface",
+]
+
+[[package]]
+name = "objc2-core-image"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-text"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+]
+
+[[package]]
+name = "objc2-core-video"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d425caf1df73233f29fd8a5c3e5edbc30d2d4307870f802d18f00d83dc5141a6"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-io-surface",
+]
+
+[[package]]
+name = "objc2-core-wlan"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c71e34919aba0d701380d911702455038a8a3587467fe0141d6a71501e7ffe48"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "objc2-security",
+ "objc2-security-foundation",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
+[[package]]
+name = "objc2-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "libc",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-io-surface"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-quartz-core"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-security"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "709fe137109bd1e8b5a99390f77a7d8b2961dafc1a1c5db8f2e60329ad6d895a"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-security-foundation"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
+checksum = "ef76382e9cedd18123099f17638715cc3d81dba3637d4c0d39ab69df2ef345a5"
 dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn",
+ "objc2",
+ "objc2-foundation",
 ]
 
 [[package]]
-name = "num_threads"
-version = "0.1.7"
+name = "objc2-system-configuration"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
+checksum = "7216bd11cbda54ccabcab84d523dc93b858ec75ecfb3a7d89513fa22464da396"
 dependencies = [
+ "bitflags 2.11.0",
+ "dispatch2",
  "libc",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-security",
 ]
 
 [[package]]
@@ -2242,10 +2856,6 @@ name = "once_cell"
 version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
-dependencies = [
- "critical-section",
- "portable-atomic",
-]
 
 [[package]]
 name = "once_cell_polyfill"
@@ -2269,6 +2879,16 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "os_pipe"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "p256"
 version = "0.13.2"
@@ -2377,6 +2997,17 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
+[[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.17"
@@ -2405,6 +3036,46 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 
+[[package]]
+name = "plist"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "092791278e026273c1b65bbdcfbba3a300f2994c896bd01ab01da613c29c46f1"
+dependencies = [
+ "base64",
+ "indexmap",
+ "quick-xml",
+ "serde",
+ "time",
+]
+
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags 2.11.0",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "polling"
+version = "3.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi 0.5.2",
+ "pin-project-lite",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "polyval"
 version = "0.6.2"
@@ -2493,6 +3164,18 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "pxfm"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
 [[package]]
 name = "quick-xml"
 version = "0.39.2"
@@ -2530,18 +3213,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
- "rand_chacha 0.3.1",
- "rand_core 0.6.4",
-]
-
-[[package]]
-name = "rand"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
-dependencies = [
- "rand_chacha 0.9.0",
- "rand_core 0.9.5",
+ "rand_chacha",
+ "rand_core",
 ]
 
 [[package]]
@@ -2551,17 +3224,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.6.4",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.9.5",
+ "rand_core",
 ]
 
 [[package]]
@@ -2573,15 +3236,6 @@ dependencies = [
  "getrandom 0.2.17",
 ]
 
-[[package]]
-name = "rand_core"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
-dependencies = [
- "getrandom 0.3.4",
-]
-
 [[package]]
 name = "rcgen"
 version = "0.13.2"
@@ -2644,12 +3298,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "resolv-conf"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e061d1b48cb8d38042de4ae0a7a6401009d6143dc80d2e2d6f31f0bdd6470c7"
-
 [[package]]
 name = "rfc6979"
 version = "0.4.0"
@@ -2674,6 +3322,24 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "rtnetlink"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b960d5d873a75b5be9761b1e73b146f52dddcd27bac75263f40fba686d4d7b5"
+dependencies = [
+ "futures-channel",
+ "futures-util",
+ "log",
+ "netlink-packet-core",
+ "netlink-packet-route 0.28.0",
+ "netlink-proto",
+ "netlink-sys",
+ "nix 0.30.1",
+ "thiserror 1.0.69",
+ "tokio",
+]
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -2689,7 +3355,7 @@ version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632"
 dependencies = [
- "nom",
+ "nom 7.1.3",
 ]
 
 [[package]]
@@ -2929,9 +3595,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
 dependencies = [
  "digest",
- "rand_core 0.6.4",
+ "rand_core",
 ]
 
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -2944,6 +3616,17 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
+[[package]]
+name = "socket-pktinfo"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "927136cc2ae6a1b0e66ac6b1210902b75c3f726db004a73bc18686dcd0dcd22f"
+dependencies = [
+ "libc",
+ "socket2",
+ "windows-sys 0.60.2",
+]
+
 [[package]]
 name = "socket2"
 version = "0.6.3"
@@ -2954,6 +3637,15 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api",
+]
+
 [[package]]
 name = "spki"
 version = "0.7.3"
@@ -2970,6 +3662,12 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
+[[package]]
+name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -3004,6 +3702,27 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "system-configuration"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
+dependencies = [
+ "bitflags 2.11.0",
+ "core-foundation 0.9.4",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "system-deps"
 version = "7.0.8"
@@ -3017,12 +3736,6 @@ dependencies = [
  "version-compare",
 ]
 
-[[package]]
-name = "tagptr"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
-
 [[package]]
 name = "target-lexicon"
 version = "0.13.3"
@@ -3042,6 +3755,15 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -3082,6 +3804,20 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "tiff"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52"
+dependencies = [
+ "fax",
+ "flate2",
+ "half",
+ "quick-error",
+ "weezl",
+ "zune-jpeg",
+]
+
 [[package]]
 name = "time"
 version = "0.3.47"
@@ -3125,21 +3861,6 @@ dependencies = [
  "zerovec",
 ]
 
-[[package]]
-name = "tinyvec"
-version = "1.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
-
 [[package]]
 name = "tokio"
 version = "1.51.1"
@@ -3316,6 +4037,17 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "tree_magic_mini"
+version = "3.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
+dependencies = [
+ "memchr",
+ "nom 8.0.0",
+ "petgraph",
+]
+
 [[package]]
 name = "typenum"
 version = "1.19.0"
@@ -3365,6 +4097,12 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
 [[package]]
 name = "unicode-xid"
 version = "0.2.6"
@@ -3417,7 +4155,6 @@ version = "1.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ac8b6f42ead25368cf5b098aeb3dc8a1a2c05a3eee8a9a1a68c640edbfc79d9"
 dependencies = [
- "getrandom 0.4.2",
  "js-sys",
  "serde_core",
  "wasm-bindgen",
@@ -3429,6 +4166,12 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
+[[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+
 [[package]]
 name = "version-compare"
 version = "0.2.1"
@@ -3658,8 +4401,8 @@ dependencies = [
  "p384",
  "pem",
  "portable-atomic",
- "rand 0.8.5",
- "rand_core 0.6.4",
+ "rand",
+ "rand_core",
  "rcgen",
  "ring",
  "rustls",
@@ -3688,19 +4431,19 @@ dependencies = [
  "lazy_static",
  "libc",
  "log",
- "nix",
+ "nix 0.26.4",
  "portable-atomic",
- "rand 0.8.5",
+ "rand",
  "thiserror 1.0.69",
  "tokio",
  "winapi",
 ]
 
 [[package]]
-name = "widestring"
-version = "1.2.1"
+name = "weezl"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
 
 [[package]]
 name = "winapi"
@@ -3739,11 +4482,23 @@ version = "0.61.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
 dependencies = [
- "windows-collections",
+ "windows-collections 0.2.0",
  "windows-core 0.61.2",
- "windows-future",
+ "windows-future 0.2.1",
  "windows-link 0.1.3",
- "windows-numerics",
+ "windows-numerics 0.2.0",
+]
+
+[[package]]
+name = "windows"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
+dependencies = [
+ "windows-collections 0.3.2",
+ "windows-core 0.62.2",
+ "windows-future 0.3.2",
+ "windows-numerics 0.3.1",
 ]
 
 [[package]]
@@ -3755,6 +4510,15 @@ dependencies = [
  "windows-core 0.61.2",
 ]
 
+[[package]]
+name = "windows-collections"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
+dependencies = [
+ "windows-core 0.62.2",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.61.2"
@@ -3789,7 +4553,18 @@ checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
 dependencies = [
  "windows-core 0.61.2",
  "windows-link 0.1.3",
- "windows-threading",
+ "windows-threading 0.1.0",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
+dependencies = [
+ "windows-core 0.62.2",
+ "windows-link 0.2.1",
+ "windows-threading 0.2.1",
 ]
 
 [[package]]
@@ -3837,14 +4612,13 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows-registry"
-version = "0.6.1"
+name = "windows-numerics"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
 dependencies = [
+ "windows-core 0.62.2",
  "windows-link 0.2.1",
- "windows-result 0.4.1",
- "windows-strings 0.5.1",
 ]
 
 [[package]]
@@ -3961,6 +4735,15 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-threading"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
@@ -4163,6 +4946,24 @@ dependencies = [
  "wasmparser",
 ]
 
+[[package]]
+name = "wl-clipboard-rs"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9651471a32e87d96ef3a127715382b2d11cc7c8bb9822ded8a7cc94072eb0a3"
+dependencies = [
+ "libc",
+ "log",
+ "os_pipe",
+ "rustix 1.1.4",
+ "thiserror 2.0.18",
+ "tree_magic_mini",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.3"
@@ -4179,6 +4980,23 @@ dependencies = [
  "pkg-config",
 ]
 
+[[package]]
+name = "x11rb"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414"
+dependencies = [
+ "gethostname",
+ "rustix 1.1.4",
+ "x11rb-protocol",
+]
+
+[[package]]
+name = "x11rb-protocol"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
+
 [[package]]
 name = "x25519-dalek"
 version = "2.0.1"
@@ -4186,7 +5004,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"
 dependencies = [
  "curve25519-dalek",
- "rand_core 0.6.4",
+ "rand_core",
  "serde",
  "zeroize",
 ]
@@ -4201,13 +5019,19 @@ dependencies = [
  "data-encoding",
  "der-parser",
  "lazy_static",
- "nom",
+ "nom 7.1.3",
  "oid-registry",
  "rusticata-macros",
  "thiserror 1.0.69",
  "time",
 ]
 
+[[package]]
+name = "xml-rs"
+version = "0.8.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ae8337f8a065cfc972643663ea4279e04e7256de865aa66fe25cec5fb912d3f"
+
 [[package]]
 name = "yasna"
 version = "0.5.2"
@@ -4396,6 +5220,21 @@ version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
 
+[[package]]
+name = "zune-core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"
+
+[[package]]
+name = "zune-jpeg"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
+dependencies = [
+ "zune-core",
+]
+
 [[package]]
 name = "zvariant"
 version = "5.10.0"
diff --git a/Cargo.toml b/Cargo.toml
index dc673fac..e4923d14 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,6 @@ lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.2.0" }
 lan-mouse-proto = { path = "lan-mouse-proto", version = "0.2.0" }
 shadow-rs = { version = "1.2.0", features = ["metadata"] }
 
-hickory-resolver = "0.25.2"
 toml = "0.8"
 toml_edit = { version = "0.22", features = ["serde"] }
 serde = { version = "1.0", features = ["derive"] }
@@ -68,6 +67,11 @@ rustls = { version = "0.23.12", default-features = false, features = [
 rcgen = "0.13.1"
 sha2 = "0.10.8"
 notify = "8.2.0"
+if-addrs = "0.13"
+if-watch = { version = "3.2", features = ["tokio"] }
+mdns-sd = "0.19"
+netdev = "0.43"
+hostname = "0.4"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"
diff --git a/README.md b/README.md
index 78834c3f..ca6902f5 100644
--- a/README.md
+++ b/README.md
@@ -415,6 +415,50 @@ port = 4242
 
 Where `left` can be either `left`, `right`, `top` or `bottom`.
 
+## Clipboard Sync
+
+Optional bi-directional clipboard text sync between paired peers. Disabled by default; enable per pair from the GUI or by editing `config.toml`.
+
+### Per-pair gates
+
+Each direction is independently gated. Both ends must opt in for clipboard text to flow that way:
+
+- **Outgoing**: `clipboard_send` on each `[[clients]]` entry — when true, copies on this device propagate to that peer.
+- **Incoming**: `clipboard_receive` on each `[authorized_fingerprints]` entry — when true, clipboard text from that peer is applied to this device's clipboard.
+
+Defaults are `false`. Existing pairs see no behavior change on upgrade.
+
+### Limitations
+
+- **Text only**. No images, files, RTF/HTML, or multi-format pasteboard.
+- **4 KiB max payload** (originator fingerprint + content + length prefixes, conservative against typical UDP MTU). Larger copies are dropped at the sender with a debug log; the local clipboard is unaffected.
+- **UTF-8 only**. Invalid byte sequences are rejected.
+- Polling-based change detection (no native pasteboard event API exists on macOS), so very rapid recopies within a single poll tick may be coalesced.
+
+### App-source suppression
+
+A per-OS suppression list lets you mark applications whose clipboard contents must never propagate (password managers, sensitive editors, Apple Messages, etc.). The frontmost app at the moment of copy is checked against the host-OS slot of `clipboard_suppress_apps`:
+
+```toml
+[clipboard_suppress_apps]
+macos = ["com.1password.1password", "com.apple.MobileSMS"]
+windows = ["1Password.exe"]
+linux_wayland = ["org.keepassxc.KeePassXC"]
+linux_x11 = ["KeePassXC"]
+```
+
+Each machine reads/writes only the slot matching its own OS — the others round-trip untouched, so a single config can be shared across machines (dotfiles / Syncthing / etc.) without any one machine bleeding identifiers into the wrong section.
+
+The GUI exposes this via **Clipboard Privacy → Manage**: a searchable picker of the apps currently running on this device (with name + icon), plus a list of currently-suppressed apps with one-click removal.
+
+### Automatic suppression on macOS
+
+In addition to the user list, macOS clipboards stamped with the [`org.nspasteboard.ConcealedType`](https://nspasteboard.org/) UTI (the community convention used by 1Password, Bitwarden, KeePassXC, and most modern password managers) are auto-suppressed without needing a manual entry.
+
+### Loop prevention for 3+ peer fan-out
+
+The wire frame carries the originator's TLS certificate fingerprint. The Service tracks `(originator_fp, content_hash)` for 1 second to prevent rebroadcast cycles in N-peer topologies (A→B→C won't echo back to A).
+
 ## Roadmap
 - [x] Graphical frontend (gtk + libadwaita)
 - [x] respect xdg-config-home for config file location.
@@ -429,7 +473,7 @@ Where `left` can be either `left`, `right`, `top` or `bottom`.
 - [ ] X11 Input Capture
 - [ ] Latency measurement and visualization
 - [ ] Bandwidth usage measurement and visualization
-- [ ] Clipboard support
+- [x] Clipboard support (text, per-pair, with app-source suppression)
 
 
 ## Detailed OS Support
diff --git a/flake.nix b/flake.nix
index 5cf260f1..19058ce2 100644
--- a/flake.nix
+++ b/flake.nix
@@ -83,6 +83,7 @@
               ++ lib.optionals pkgs.stdenv.isLinux [
                 libX11
                 libXtst
+                dbus
               ];
             env.RUST_SRC_PATH = "${rustToolchain}/lib/rustlib/src/rust/library";
           };
diff --git a/input-capture/Cargo.toml b/input-capture/Cargo.toml
index 9b8d5985..92e2f409 100644
--- a/input-capture/Cargo.toml
+++ b/input-capture/Cargo.toml
@@ -28,6 +28,9 @@ tokio = { version = "1.32.0", features = [
 once_cell = "1.19.0"
 async-trait = "0.1.81"
 tokio-util = "0.7.11"
+arboard = { version = "3.4", features = ["wayland-data-control"] }
+lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
+serde_json = "1.0"
 
 
 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
@@ -46,6 +49,11 @@ ashpd = { version = "0.13.9", default-features = false, features = [
     "tokio",
 ], optional = true }
 reis = { version = "0.5.0", features = ["tokio"], optional = true }
+# Used unconditionally on Linux for frontmost-app detection in
+# `frontmost_app::linux_x11`. Already pulled in transitively via
+# arboard's wayland-data-control feature, so listing it here just
+# pins it as a direct dep.
+x11rb = "0.13"
 
 [target.'cfg(target_os="macos")'.dependencies]
 core-graphics = { version = "0.25.0", features = ["highsierra"] }
@@ -54,10 +62,17 @@ core-foundation-sys = "0.8.6"
 libc = "0.2.155"
 keycode = "1.0.0"
 bitflags = "2.6.0"
+# Used by `frontmost_app::macos` and `clipboard::is_concealed_clipboard`
+# to call NSWorkspace / NSPasteboard. Already pulled in transitively
+# via arboard, so listed here as direct deps.
+objc2 = "0.6"
+objc2-app-kit = { version = "0.3", features = ["NSWorkspace", "NSRunningApplication", "NSPasteboard", "NSImage", "NSImageRep", "NSBitmapImageRep", "NSGraphics"] }
+objc2-foundation = { version = "0.3", features = ["NSString", "NSArray", "NSData", "NSDictionary", "NSGeometry", "NSURL"] }
 
 [target.'cfg(windows)'.dependencies]
 windows = { version = "0.61.2", features = [
     "Win32_System_LibraryLoader",
+    "Win32_System_RemoteDesktop",
     "Win32_System_Threading",
     "Win32_Foundation",
     "Win32_Graphics",
diff --git a/input-capture/src/clipboard.rs b/input-capture/src/clipboard.rs
new file mode 100644
index 00000000..6b8b4abf
--- /dev/null
+++ b/input-capture/src/clipboard.rs
@@ -0,0 +1,533 @@
+use arboard::Clipboard;
+use input_event::{ClipboardEvent, Event};
+use lan_mouse_ipc::AppIdent;
+use std::collections::HashSet;
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+use tokio::sync::mpsc::{self, Receiver, Sender};
+use tokio::task::spawn_blocking;
+use tokio::time::interval;
+
+use crate::frontmost_app;
+use crate::{CaptureError, CaptureEvent};
+
+/// Shared, mutable suppression list. Service owns the canonical
+/// `Arc<Mutex<HashSet<AppIdent>>>` and clones the handle into each
+/// freshly-spawned [`ClipboardMonitor`]; mutations from
+/// `Add/RemoveSuppressedApp` requests take effect immediately on
+/// the next clipboard poll.
+pub type SuppressionList = Arc<Mutex<HashSet<AppIdent>>>;
+
+/// Clipboard monitor that watches for clipboard changes
+pub struct ClipboardMonitor {
+    event_rx: Receiver<CaptureEvent>,
+    _event_tx: Sender<CaptureEvent>,
+    last_content: Arc<Mutex<Option<String>>>,
+    last_change: Arc<Mutex<Option<Instant>>>,
+    enabled: Arc<Mutex<bool>>,
+}
+
+impl ClipboardMonitor {
+    /// Construct without app-source suppression. Equivalent to
+    /// `with_suppression(Default::default())` — provided as a
+    /// convenience for callers that don't care about suppression
+    /// (CLI smoke tests, future per-platform unit tests).
+    pub fn new() -> Result<Self, CaptureError> {
+        Self::with_suppression(SuppressionList::default())
+    }
+
+    /// Construct a monitor that consults `suppression` on every
+    /// detected clipboard change and skips both the emit AND the
+    /// `last_content` update when [`frontmost_app::frontmost_app()`]
+    /// reports an app whose [`AppIdent`] is in the list. Skipping
+    /// the `last_content` update is intentional: it keeps the
+    /// monitor "blind" to the suppressed content so a later non-
+    /// suppressed copy of the same string still emits normally.
+    pub fn with_suppression(suppression: SuppressionList) -> Result<Self, CaptureError> {
+        let (event_tx, event_rx) = mpsc::channel(16);
+        let last_content: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
+        let last_change: Arc<Mutex<Option<Instant>>> = Arc::new(Mutex::new(None));
+        let enabled = Arc::new(Mutex::new(true));
+
+        let last_content_clone = last_content.clone();
+        let last_change_clone = last_change.clone();
+        let enabled_clone = enabled.clone();
+        let event_tx_clone = event_tx.clone();
+        let suppression_clone = suppression.clone();
+
+        // Spawn monitoring task. Cadence: 100 ms on macOS (cheap
+        // because `pasteboard_change_count_advanced` short-circuits
+        // 99% of ticks via a single integer compare); 500 ms
+        // elsewhere (no cheap precheck, full content read every
+        // tick). Tighter cadence on macOS shrinks the
+        // frontmost-app suppression race window from 500 ms →
+        // 100 ms — the user would have to Cmd+Tab faster than
+        // human reaction time after copying to defeat the check.
+        #[cfg(target_os = "macos")]
+        const POLL_MS: u64 = 100;
+        #[cfg(not(target_os = "macos"))]
+        const POLL_MS: u64 = 500;
+
+        tokio::spawn(async move {
+            let mut check_interval = interval(Duration::from_millis(POLL_MS));
+
+            loop {
+                check_interval.tick().await;
+
+                // Check if enabled
+                let is_enabled = {
+                    let enabled = enabled_clone.lock().unwrap();
+                    *enabled
+                };
+
+                if !is_enabled {
+                    continue;
+                }
+
+                // macOS: skip the expensive content-read entirely
+                // when NSPasteboard.changeCount hasn't advanced
+                // since last tick. This is the canonical clipboard-
+                // monitor optimization (Maccy / Alfred / Paste all
+                // do it). Single integer compare per idle tick.
+                #[cfg(target_os = "macos")]
+                if !pasteboard_change_count_advanced() {
+                    continue;
+                }
+
+                // Read clipboard in blocking task
+                let last_content_clone2 = last_content_clone.clone();
+                let last_change_clone2 = last_change_clone.clone();
+                let event_tx_clone2 = event_tx_clone.clone();
+                let suppression_clone2 = suppression_clone.clone();
+
+                let _ = spawn_blocking(move || {
+                    // Create clipboard instance
+                    let mut clipboard = match Clipboard::new() {
+                        Ok(c) => c,
+                        Err(e) => {
+                            log::debug!("Failed to create clipboard: {e}");
+                            return;
+                        }
+                    };
+
+                    // Get current clipboard text
+                    let current_text = match clipboard.get_text() {
+                        Ok(text) => {
+                            log::trace!("Clipboard text read: {} bytes", text.len());
+                            text
+                        }
+                        Err(e) => {
+                            // Clipboard might be empty or contain non-text data
+                            log::trace!("Failed to get clipboard text: {e}");
+                            return;
+                        }
+                    };
+
+                    // Check if content changed
+                    let mut last_content = last_content_clone2.lock().unwrap();
+                    let mut last_change = last_change_clone2.lock().unwrap();
+
+                    let last_change_elapsed = last_change.map(|t| t.elapsed());
+                    // App-source suppression. Frontmost-app lookup
+                    // and the macOS concealed-pasteboard probe both
+                    // run only after we've decided the content
+                    // actually changed (see PollDecision::classify).
+                    // Pre-compute the inputs here so the classifier
+                    // stays a pure function.
+                    let needs_decision = PollDecision::content_might_emit(
+                        &current_text,
+                        last_content.as_deref(),
+                        last_change_elapsed,
+                    );
+                    let (concealed, suppressed) = if needs_decision {
+                        let concealed = is_concealed_clipboard();
+                        let suppressed = if concealed {
+                            None
+                        } else {
+                            is_suppressed(&suppression_clone2)
+                        };
+                        (concealed, suppressed)
+                    } else {
+                        (false, None)
+                    };
+                    let decision = PollDecision::classify(
+                        &current_text,
+                        last_content.as_deref(),
+                        last_change_elapsed,
+                        concealed,
+                        suppressed.is_some(),
+                    );
+                    // Always advance `last_content` after a state-
+                    // changing decision (Suppressed or Emit),
+                    // regardless of which suppression branch
+                    // fired. The earlier "blind to suppressed
+                    // value" approach left `last_content` at the
+                    // previous emitted value, which made every
+                    // subsequent 500ms poll see the SAME
+                    // suppressed content as "changed" and re-run
+                    // the suppression check. Any focus shift
+                    // between polls (user alt-tabs after copying
+                    // a password) would then find a non-
+                    // suppressed frontmost and leak the password.
+                    // PollDecision::advances_state pins this
+                    // contract — see the unit tests at the
+                    // bottom of this file.
+                    if decision.advances_state() {
+                        *last_content = Some(current_text.clone());
+                        *last_change = Some(Instant::now());
+                    }
+                    match decision {
+                        PollDecision::Unchanged => {}
+                        PollDecision::Debounced => {
+                            log::trace!("Clipboard changed but debounced (too recent)");
+                        }
+                        PollDecision::Suppressed if concealed => {
+                            log::debug!("clipboard change suppressed (concealed pasteboard type)");
+                        }
+                        PollDecision::Suppressed => {
+                            if let Some(app) = suppressed.as_ref() {
+                                log::debug!(
+                                    "clipboard change suppressed (frontmost app `{}`)",
+                                    app.label()
+                                );
+                            }
+                        }
+                        PollDecision::Emit => {
+                            log::info!("Clipboard changed, length: {} bytes", current_text.len());
+                            let event = CaptureEvent::Input(Event::Clipboard(
+                                ClipboardEvent::Text(current_text),
+                            ));
+                            let _ = event_tx_clone2.blocking_send(event);
+                        }
+                    }
+                })
+                .await;
+            }
+        });
+
+        Ok(Self {
+            event_rx,
+            _event_tx: event_tx,
+            last_content,
+            last_change,
+            enabled,
+        })
+    }
+
+    /// Receive the next clipboard event
+    pub async fn recv(&mut self) -> Option<CaptureEvent> {
+        self.event_rx.recv().await
+    }
+
+    /// Enable clipboard monitoring
+    pub fn enable(&self) {
+        let mut enabled = self.enabled.lock().unwrap();
+        *enabled = true;
+        log::info!("Clipboard monitoring enabled");
+    }
+
+    /// Disable clipboard monitoring
+    pub fn disable(&self) {
+        let mut enabled = self.enabled.lock().unwrap();
+        *enabled = false;
+        log::info!("Clipboard monitoring disabled");
+    }
+
+    /// Update the last known clipboard content (called when we set the clipboard)
+    /// This prevents detecting our own clipboard changes as external changes
+    pub fn update_last_content(&self, content: String) {
+        let mut last_content = self.last_content.lock().unwrap();
+        let mut last_change = self.last_change.lock().unwrap();
+        *last_content = Some(content);
+        *last_change = Some(Instant::now());
+    }
+}
+
+/// macOS password managers stamp `org.nspasteboard.ConcealedType`
+/// on the general pasteboard so cooperating apps skip syncing
+/// passwords. Returns `true` when that UTI is present on the
+/// current pasteboard contents. Always `false` on non-macOS.
+///
+/// This is the standard "nspasteboard.com" convention — see
+/// <https://nspasteboard.org/>.
+#[cfg(target_os = "macos")]
+fn is_concealed_clipboard() -> bool {
+    use objc2_app_kit::NSPasteboard;
+    use objc2_foundation::NSString;
+
+    let pasteboard = NSPasteboard::generalPasteboard();
+    let Some(types) = pasteboard.types() else {
+        return false;
+    };
+    let concealed = NSString::from_str("org.nspasteboard.ConcealedType");
+    types.iter().any(|t| t.isEqualToString(&concealed))
+}
+
+#[cfg(not(target_os = "macos"))]
+fn is_concealed_clipboard() -> bool {
+    false
+}
+
+/// If [`frontmost_app::frontmost_app()`] reports an app whose ident
+/// is in the suppression list, return that ident. Otherwise return
+/// `None`. Snapshotting the lock guard short keeps us from holding
+/// the mutex across the platform call (which on Linux can shell
+/// out to hyprctl/swaymsg).
+fn is_suppressed(list: &SuppressionList) -> Option<AppIdent> {
+    let snapshot: Vec<AppIdent> = {
+        let Ok(guard) = list.lock() else {
+            log::debug!("clipboard suppression: lock poisoned");
+            return None;
+        };
+        if guard.is_empty() {
+            log::debug!("clipboard suppression: list is empty");
+            return None;
+        }
+        guard.iter().cloned().collect()
+    };
+    let active = frontmost_app::frontmost_app();
+    log::debug!("clipboard suppression check: list={snapshot:?} active={active:?}");
+    let active = active?;
+    snapshot.into_iter().find(|s| s.matches(&active))
+}
+
+/// Returns `true` the first time it's called, and on every later
+/// call where `NSPasteboard.generalPasteboard.changeCount` has
+/// advanced since the previous call. Used as a cheap precheck so
+/// the polling loop only invokes `arboard::Clipboard::get_text`
+/// (which round-trips through `pboardd` via XPC) on ticks where
+/// the pasteboard actually mutated.
+///
+/// `changeCount` reads are an Apple-blessed background-thread
+/// operation — the property is designed for exactly this kind of
+/// polling. No autorelease pool needed: the return value is a
+/// primitive `NSInteger`, not an Objective-C object.
+#[cfg(target_os = "macos")]
+fn pasteboard_change_count_advanced() -> bool {
+    use objc2_app_kit::NSPasteboard;
+    use std::sync::atomic::{AtomicI64, Ordering};
+
+    // Initial sentinel `i64::MIN` ensures the first call always
+    // returns `true` so we read once at startup to seed the
+    // diff-against-`last_content` machinery downstream.
+    static LAST: AtomicI64 = AtomicI64::new(i64::MIN);
+
+    let pb = NSPasteboard::generalPasteboard();
+    let now = pb.changeCount() as i64;
+    let prev = LAST.swap(now, Ordering::Relaxed);
+    prev != now
+}
+
+/// Outcome of a single clipboard-poll cycle. Pulled into a pure
+/// function so the focus-race invariant — "advance `last_content`
+/// on every state-changing decision, even when we suppress" — is
+/// pinned by unit tests rather than implicit in the closure
+/// body.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum PollDecision {
+    /// Current text equals last recorded — nothing to do.
+    Unchanged,
+    /// Content changed but the 200 ms debounce window from the
+    /// previous advance hasn't elapsed yet.
+    Debounced,
+    /// Content changed, debounce passed, but suppression
+    /// (concealed pasteboard or app-list match) tells us not to
+    /// emit. State must still advance so subsequent polls don't
+    /// re-check the same content and leak on a focus shift.
+    Suppressed,
+    /// Content changed, debounce passed, suppression cleared.
+    /// Caller emits the event and advances state.
+    Emit,
+}
+
+impl PollDecision {
+    /// Cheap pre-flight: `true` when the next call to
+    /// [`PollDecision::classify`] could return `Suppressed` or
+    /// `Emit`. The poll loop uses this to skip the relatively
+    /// expensive `is_concealed_clipboard()` / `frontmost_app()` /
+    /// `is_suppressed()` calls when the content hasn't changed
+    /// or the debounce window blocks emission anyway.
+    fn content_might_emit(
+        current_text: &str,
+        last_content: Option<&str>,
+        last_change_elapsed: Option<Duration>,
+    ) -> bool {
+        if last_content == Some(current_text) {
+            return false;
+        }
+        last_change_elapsed.is_none_or(|d| d > Duration::from_millis(200))
+    }
+
+    /// Decide what to do with this poll cycle. Pure function — no
+    /// I/O, no global state — so the focus-race invariant is
+    /// expressible as a series of `assert_eq!` calls.
+    fn classify(
+        current_text: &str,
+        last_content: Option<&str>,
+        last_change_elapsed: Option<Duration>,
+        concealed: bool,
+        suppressed_match: bool,
+    ) -> Self {
+        if last_content == Some(current_text) {
+            return Self::Unchanged;
+        }
+        let debounce_passed = last_change_elapsed.is_none_or(|d| d > Duration::from_millis(200));
+        if !debounce_passed {
+            return Self::Debounced;
+        }
+        if concealed || suppressed_match {
+            Self::Suppressed
+        } else {
+            Self::Emit
+        }
+    }
+
+    /// True when this decision must advance `last_content` /
+    /// `last_change` in the caller. Both `Suppressed` and `Emit`
+    /// are state-changing — the focus-race fix lives here.
+    fn advances_state(self) -> bool {
+        matches!(self, Self::Suppressed | Self::Emit)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn classify_unchanged_when_text_matches_last_content() {
+        let d = PollDecision::classify(
+            "secret",
+            Some("secret"),
+            Some(Duration::from_secs(60)),
+            false,
+            false,
+        );
+        assert_eq!(d, PollDecision::Unchanged);
+        assert!(!d.advances_state());
+    }
+
+    #[test]
+    fn classify_debounced_when_recent_change() {
+        // Content differs but only 100ms since last advance —
+        // hold off so a peer's set_clipboard echo doesn't bounce
+        // back as a fresh local emit.
+        let d = PollDecision::classify(
+            "new",
+            Some("old"),
+            Some(Duration::from_millis(100)),
+            false,
+            false,
+        );
+        assert_eq!(d, PollDecision::Debounced);
+        assert!(!d.advances_state());
+    }
+
+    #[test]
+    fn classify_emit_when_changed_unsuppressed() {
+        let d = PollDecision::classify(
+            "new",
+            Some("old"),
+            Some(Duration::from_secs(1)),
+            false,
+            false,
+        );
+        assert_eq!(d, PollDecision::Emit);
+        assert!(d.advances_state());
+    }
+
+    #[test]
+    fn classify_emit_on_first_change() {
+        // No prior advance: the first poll always falls through
+        // to Emit (assuming nothing's suppressed) so the very
+        // first clipboard read after startup is broadcast.
+        let d = PollDecision::classify("first", None, None, false, false);
+        assert_eq!(d, PollDecision::Emit);
+    }
+
+    #[test]
+    fn classify_suppressed_when_concealed() {
+        let d = PollDecision::classify(
+            "password",
+            Some("plain"),
+            Some(Duration::from_secs(1)),
+            true,
+            false,
+        );
+        assert_eq!(d, PollDecision::Suppressed);
+    }
+
+    #[test]
+    fn classify_suppressed_when_app_list_matches() {
+        let d = PollDecision::classify(
+            "password",
+            Some("plain"),
+            Some(Duration::from_secs(1)),
+            false,
+            true,
+        );
+        assert_eq!(d, PollDecision::Suppressed);
+    }
+
+    /// The focus-race invariant: a Suppressed decision MUST tell
+    /// the caller to advance `last_content`. If this assert
+    /// fails, the regression we hit live (1Password password
+    /// leaks on Ghostty alt-tab after copy) is back.
+    #[test]
+    fn suppressed_decision_advances_state() {
+        let d = PollDecision::classify(
+            "password",
+            Some("plain"),
+            Some(Duration::from_secs(1)),
+            false,
+            true,
+        );
+        assert!(
+            d.advances_state(),
+            "Suppressed must advance last_content; otherwise the \
+             same content gets re-checked on the next poll and a \
+             focus shift between polls will leak the password."
+        );
+    }
+
+    /// Companion: Unchanged and Debounced must NOT advance state.
+    /// Advancing on Debounced would defeat the 200 ms window and
+    /// turn every peer-driven clipboard sync into a fresh local
+    /// emit (echo loop).
+    #[test]
+    fn non_state_changing_decisions_do_not_advance() {
+        for (current, last, elapsed) in [
+            ("same", Some("same"), Some(Duration::from_secs(1))),
+            ("new", Some("old"), Some(Duration::from_millis(50))),
+        ] {
+            let d = PollDecision::classify(current, last, elapsed, false, false);
+            assert!(
+                !d.advances_state(),
+                "{d:?} should not advance state (current={current:?} last={last:?} elapsed={elapsed:?})"
+            );
+        }
+    }
+
+    #[test]
+    fn content_might_emit_skips_unchanged_and_debounced() {
+        // Used by the poll loop to short-circuit the expensive
+        // suppression probes. Same matrix as `classify`'s "no
+        // emission possible" cases.
+        assert!(!PollDecision::content_might_emit(
+            "same",
+            Some("same"),
+            None
+        ));
+        assert!(!PollDecision::content_might_emit(
+            "new",
+            Some("old"),
+            Some(Duration::from_millis(50))
+        ));
+        assert!(PollDecision::content_might_emit(
+            "new",
+            Some("old"),
+            Some(Duration::from_secs(1))
+        ));
+        assert!(PollDecision::content_might_emit("new", None, None));
+    }
+}
diff --git a/input-capture/src/desktop_entries.rs b/input-capture/src/desktop_entries.rs
new file mode 100644
index 00000000..17ac8f82
--- /dev/null
+++ b/input-capture/src/desktop_entries.rs
@@ -0,0 +1,628 @@
+//! Discover and parse freedesktop `.desktop` files for the
+//! clipboard-suppression picker on Linux.
+//!
+//! Two responsibilities:
+//!
+//! 1. Build a map from a runtime identifier (Hyprland `class`,
+//!    Sway `app_id`, X11 `WM_CLASS` — all lowercased) to a
+//!    [`DesktopAppMetadata`] record. The map is keyed both by the
+//!    `.desktop` filename stem and by `StartupWMClass=` so the
+//!    common cases — `firefox.desktop` matching a `firefox` class
+//!    and `1password.desktop` (StartupWMClass=`1Password`) matching
+//!    a `1Password` class — both resolve.
+//!
+//! 2. Resolve a freedesktop icon *name* (e.g. `firefox`) into
+//!    raster bytes that GTK can load via `gdk::Texture::from_bytes`.
+//!    PNG is preferred; SVG falls through to gdk-pixbuf's librsvg
+//!    loader on the GTK side. The picker target is ~64–128 px so
+//!    we prefer those sizes and degrade gracefully when only
+//!    larger or scalable variants exist.
+//!
+//! Scope is intentionally narrow: this module exists to make the
+//! suppression-list modal show "Firefox" with its real icon
+//! instead of `firefox` as bare text. It does NOT replace the
+//! runtime suppression check itself, which still keys on
+//! [`crate::frontmost_app::frontmost_app`] returning a host-OS
+//! identifier.
+
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+/// One installed application learned from a `.desktop` file.
+#[derive(Debug, Clone)]
+pub struct DesktopAppMetadata {
+    /// `Name=` field — the human-readable display name. Falls back
+    /// to the .desktop filename stem when `Name=` is absent or
+    /// empty.
+    pub display_name: String,
+    /// `Icon=` field. May be a bare freedesktop icon name (typical:
+    /// `firefox`) or an absolute path. `None` if the .desktop file
+    /// has no `Icon=` line or the value is empty.
+    pub icon_name: Option<String>,
+}
+
+/// Result of [`discover_apps`]: two indices over the same set of
+/// installed `.desktop` entries.
+///
+/// - `by_identifier`: keyed by lowercased filename stem AND
+///   `StartupWMClass` so a runtime class / app_id resolves directly
+///   to its installed metadata (the common case).
+/// - `by_webapp_host`: keyed by lowercased hostname extracted from
+///   any `https?://…` token in the entry's `Exec=` line. Used to
+///   resolve Chrome / Chromium `--app=URL` PWAs whose runtime class
+///   is `chrome-<host>__<path>-<Profile>`. The omarchy
+///   `omarchy-launch-webapp <url>` flow falls into this bucket: the
+///   `.desktop` has Name + Icon + Exec=URL but no `StartupWMClass`,
+///   so the direct index can't see it.
+#[derive(Debug, Default)]
+pub struct AppDirectory {
+    pub by_identifier: HashMap<String, DesktopAppMetadata>,
+    pub by_webapp_host: HashMap<String, DesktopAppMetadata>,
+}
+
+impl AppDirectory {
+    /// Resolve a runtime class / app_id to its installed metadata.
+    /// Tries the direct index first, then falls back to parsing
+    /// the class as a Chrome `--app=` PWA and matching the host
+    /// against `by_webapp_host`. Returns `None` when nothing
+    /// matches; the caller renders the raw identifier as the
+    /// display name.
+    pub fn lookup(&self, identifier: &str) -> Option<DesktopAppMetadata> {
+        let lower = identifier.to_lowercase();
+        if let Some(m) = self.by_identifier.get(&lower) {
+            return Some(m.clone());
+        }
+        if let Some(host) = parse_chrome_pwa_host(&lower) {
+            if let Some(m) = self.by_webapp_host.get(host) {
+                return Some(m.clone());
+            }
+        }
+        None
+    }
+}
+
+/// Scan every standard `.desktop` location, returning the two-way
+/// [`AppDirectory`]. Apps with `Type != Application` /
+/// `Hidden=true` / `NoDisplay=true` are dropped so the picker
+/// doesn't fill up with `xdg-open`-style helper entries the user
+/// can't actually focus.
+pub fn discover_apps() -> AppDirectory {
+    let mut by_identifier: HashMap<String, DesktopAppMetadata> = HashMap::new();
+    let mut by_webapp_host: HashMap<String, DesktopAppMetadata> = HashMap::new();
+    for dir in standard_app_dirs() {
+        let entries = match fs::read_dir(&dir) {
+            Ok(e) => e,
+            Err(_) => continue,
+        };
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.extension().and_then(|s| s.to_str()) != Some("desktop") {
+                continue;
+            }
+            let Some(stem) = path.file_stem().and_then(|s| s.to_str()) else {
+                continue;
+            };
+            let Ok(contents) = fs::read_to_string(&path) else {
+                continue;
+            };
+            let Some(parsed) = parse_desktop_entry(&contents) else {
+                continue;
+            };
+            let display_name = parsed
+                .name
+                .filter(|s| !s.is_empty())
+                .unwrap_or_else(|| stem.to_owned());
+            let metadata = DesktopAppMetadata {
+                display_name,
+                icon_name: parsed.icon.filter(|s| !s.is_empty()),
+            };
+            // Index by .desktop filename stem (matches the common
+            // case where WM_CLASS / app_id matches the app's binary
+            // name — `firefox.desktop` ↔ `firefox`).
+            by_identifier
+                .entry(stem.to_lowercase())
+                .or_insert_with(|| metadata.clone());
+            // ALSO index by StartupWMClass when present — that's
+            // the explicit hint the .desktop author published for
+            // matching against window classes that disagree with
+            // the filename stem (`1password.desktop` →
+            // `StartupWMClass=1Password`).
+            if let Some(wmclass) = parsed.startup_wm_class.as_deref().filter(|s| !s.is_empty()) {
+                by_identifier
+                    .entry(wmclass.to_lowercase())
+                    .or_insert_with(|| metadata.clone());
+            }
+            // Webapp index: every host that appears in an http(s)://
+            // URL token in the Exec= line. Lets Chrome `--app=URL`
+            // PWAs fall back to this entry's Name + Icon when the
+            // direct index misses (typical of .desktop files that
+            // don't bother setting `StartupWMClass`).
+            if let Some(exec) = parsed.exec.as_deref() {
+                for host in extract_hosts_from_exec(exec) {
+                    by_webapp_host
+                        .entry(host)
+                        .or_insert_with(|| metadata.clone());
+                }
+            }
+        }
+    }
+    AppDirectory {
+        by_identifier,
+        by_webapp_host,
+    }
+}
+
+/// Resolve an icon name to PNG or SVG bytes. Prefers raster sizes
+/// in the 64–128 px window where the picker actually displays them;
+/// falls through to scalable SVG and finally to `/usr/share/pixmaps`
+/// when the freedesktop hicolor theme doesn't have an entry.
+///
+/// Absolute paths bypass the search and read directly. Returns
+/// `None` when no matching file is found or the read fails.
+pub fn icon_bytes_for_name(icon_name: &str) -> Option<Vec<u8>> {
+    if icon_name.is_empty() {
+        return None;
+    }
+    // Absolute path → just read it.
+    let direct = Path::new(icon_name);
+    if direct.is_absolute() {
+        return fs::read(direct).ok();
+    }
+    // Preferred raster sizes, picker-friendly first. Larger sizes
+    // serve HiDPI; smaller are the last raster fallback before SVG.
+    const RASTER_SIZES: &[&str] = &[
+        "128x128", "256x256", "64x64", "96x96", "192x192", "48x48", "32x32",
+    ];
+    for base in icon_search_dirs() {
+        for size in RASTER_SIZES {
+            let p = base
+                .join(size)
+                .join("apps")
+                .join(format!("{icon_name}.png"));
+            if let Ok(bytes) = fs::read(&p) {
+                return Some(bytes);
+            }
+        }
+        // Scalable (SVG) fallback. gdk-pixbuf with librsvg loaded
+        // can render this directly via gdk::Texture::from_bytes.
+        let svg = base
+            .join("scalable")
+            .join("apps")
+            .join(format!("{icon_name}.svg"));
+        if let Ok(bytes) = fs::read(&svg) {
+            return Some(bytes);
+        }
+    }
+    // /usr/share/pixmaps/<name>.{png,svg} as a final fallback —
+    // the legacy "no theme" icon directory.
+    for ext in ["png", "svg"] {
+        let p = PathBuf::from("/usr/share/pixmaps").join(format!("{icon_name}.{ext}"));
+        if let Ok(bytes) = fs::read(&p) {
+            return Some(bytes);
+        }
+    }
+    None
+}
+
+/// Application directories per the XDG Base Directory spec, in
+/// lookup-priority order: user-local first, then system. Apps in
+/// later directories are silently shadowed by earlier ones with
+/// matching `.desktop` filenames (`HashMap::entry().or_insert_with`).
+fn standard_app_dirs() -> Vec<PathBuf> {
+    let mut dirs: Vec<PathBuf> = Vec::new();
+    if let Some(home) = std::env::var_os("XDG_DATA_HOME").filter(|v| !v.is_empty()) {
+        dirs.push(PathBuf::from(home).join("applications"));
+    } else if let Some(home) = std::env::var_os("HOME") {
+        dirs.push(PathBuf::from(home).join(".local/share/applications"));
+    }
+    let data_dirs = std::env::var("XDG_DATA_DIRS")
+        .ok()
+        .filter(|v| !v.is_empty());
+    let data_dirs = data_dirs.unwrap_or_else(|| "/usr/local/share:/usr/share".to_owned());
+    for d in data_dirs.split(':').filter(|s| !s.is_empty()) {
+        dirs.push(PathBuf::from(d).join("applications"));
+    }
+    // Flatpak system & user exports — these aren't always present
+    // in $XDG_DATA_DIRS depending on distro / flatpak version.
+    if let Some(home) = std::env::var_os("HOME") {
+        dirs.push(PathBuf::from(&home).join(".local/share/flatpak/exports/share/applications"));
+    }
+    dirs.push(PathBuf::from("/var/lib/flatpak/exports/share/applications"));
+    dirs
+}
+
+/// Hicolor theme search roots. We don't consult the user's selected
+/// theme on purpose — the suppression picker works just fine with
+/// the universal hicolor fallback, and per-theme lookup adds cost
+/// (parse `index.theme`, walk inheritance) that doesn't pay back
+/// for a one-shot list of apps.
+fn icon_search_dirs() -> Vec<PathBuf> {
+    let mut dirs: Vec<PathBuf> = Vec::new();
+    if let Some(home) = std::env::var_os("XDG_DATA_HOME").filter(|v| !v.is_empty()) {
+        dirs.push(PathBuf::from(home).join("icons/hicolor"));
+    } else if let Some(home) = std::env::var_os("HOME") {
+        dirs.push(PathBuf::from(home).join(".local/share/icons/hicolor"));
+    }
+    let data_dirs = std::env::var("XDG_DATA_DIRS")
+        .ok()
+        .filter(|v| !v.is_empty());
+    let data_dirs = data_dirs.unwrap_or_else(|| "/usr/local/share:/usr/share".to_owned());
+    for d in data_dirs.split(':').filter(|s| !s.is_empty()) {
+        dirs.push(PathBuf::from(d).join("icons/hicolor"));
+    }
+    dirs
+}
+
+#[derive(Default, Debug)]
+struct ParsedDesktopEntry {
+    name: Option<String>,
+    icon: Option<String>,
+    startup_wm_class: Option<String>,
+    exec: Option<String>,
+}
+
+/// Parse the `[Desktop Entry]` section of a `.desktop` file. Stops
+/// at the first blank line or at the first non-`[Desktop Entry]`
+/// section header — we don't need locale-specific `Name[xx]=`
+/// variants for the picker's English-only display today.
+///
+/// Returns `None` when the entry is `Type=Application`-incompatible
+/// (anything other than Application, including missing Type),
+/// `Hidden=true`, or `NoDisplay=true`. The caller treats that as
+/// "skip this app" rather than rendering an unfocusable shell.
+fn parse_desktop_entry(contents: &str) -> Option<ParsedDesktopEntry> {
+    let mut in_section = false;
+    let mut entry = ParsedDesktopEntry::default();
+    let mut entry_type: Option<String> = None;
+    let mut hidden = false;
+    let mut no_display = false;
+    for line in contents.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        if line.starts_with('[') && line.ends_with(']') {
+            // First [Desktop Entry] header switches us in; any other
+            // header (e.g. [Desktop Action xyz]) ends parsing for our
+            // purposes.
+            in_section = line == "[Desktop Entry]";
+            if !in_section {
+                break;
+            }
+            continue;
+        }
+        if !in_section {
+            continue;
+        }
+        let Some((key, value)) = line.split_once('=') else {
+            continue;
+        };
+        let key = key.trim();
+        let value = value.trim();
+        match key {
+            "Name" => entry.name = Some(value.to_owned()),
+            "Icon" => entry.icon = Some(value.to_owned()),
+            "StartupWMClass" => entry.startup_wm_class = Some(value.to_owned()),
+            "Exec" => entry.exec = Some(value.to_owned()),
+            "Type" => entry_type = Some(value.to_owned()),
+            "Hidden" => hidden = value.eq_ignore_ascii_case("true"),
+            "NoDisplay" => no_display = value.eq_ignore_ascii_case("true"),
+            _ => {}
+        }
+    }
+    if entry_type.as_deref() != Some("Application") || hidden || no_display {
+        return None;
+    }
+    Some(entry)
+}
+
+/// Extract the host portion of every `https?://…` token in an
+/// `Exec=` line. Hosts are lowercased to match Chrome's class-
+/// derivation convention. A single Exec line can have multiple
+/// URLs (rare but legal); we capture them all so a future tab/PWA
+/// launch with any of those URLs still resolves.
+fn extract_hosts_from_exec(exec: &str) -> Vec<String> {
+    let mut hosts = Vec::new();
+    for token in exec.split_whitespace() {
+        // Strip surrounding quotes (Exec= can have quoted args).
+        let token = token.trim_matches(|c| c == '"' || c == '\'');
+        let after = match token
+            .strip_prefix("https://")
+            .or_else(|| token.strip_prefix("http://"))
+        {
+            Some(s) => s,
+            None => continue,
+        };
+        // Host runs until the first /, ?, #, : (port), or
+        // end-of-token.
+        let host_end = after.find(['/', '?', '#', ':']).unwrap_or(after.len());
+        let host = &after[..host_end];
+        if host.is_empty() || !host.contains('.') {
+            continue;
+        }
+        hosts.push(host.to_lowercase());
+    }
+    hosts
+}
+
+/// Parse a Chrome / Chromium `--app=URL` window class string and
+/// return the host portion of the URL it was derived from.
+///
+/// Chrome's class encoding for `--app=https://<host>/<path>` is
+/// `chrome-<host>__<path-with-/-replaced-by-_>-<Profile>`. The
+/// `__` always separates host from path; everything before it is
+/// the host. For URLs without a path
+/// (`--app=https://<host>/`), the class collapses to
+/// `chrome-<host>-<Profile>` so we also strip a trailing
+/// `-default` / `-profile_N` segment as a fallback.
+///
+/// Returns `None` for non-Chrome classes, classes whose host has
+/// no `.` (almost certainly an extension ID — `crx_…` /
+/// `chrome-<extension-id>-default` already get matched by the
+/// direct .desktop index, so the webapp fallback is redundant for
+/// them), or empty hosts.
+fn parse_chrome_pwa_host(class_lowercased: &str) -> Option<&str> {
+    let after = class_lowercased.strip_prefix("chrome-")?;
+    // Path-bearing form: `<host>__<path>-<profile>`. The path
+    // separator is unambiguous so we stop at the first `__`.
+    let host = if let Some(idx) = after.find("__") {
+        &after[..idx]
+    } else {
+        // Path-less form: `<host>-<profile>`. Strip a single
+        // known profile suffix; default and `profile_N` cover the
+        // standard Chrome multi-profile setup. `-default` is also
+        // what Brave / Vivaldi / Edge use.
+        let mut trimmed = after;
+        for suffix in [
+            "-default",
+            "-profile_1",
+            "-profile_2",
+            "-profile_3",
+            "-profile_4",
+        ] {
+            if let Some(s) = trimmed.strip_suffix(suffix) {
+                trimmed = s;
+                break;
+            }
+        }
+        // If we couldn't identify a profile suffix the class is
+        // probably not a webapp — bail.
+        if trimmed == after {
+            return None;
+        }
+        trimmed
+    };
+    if host.is_empty() || !host.contains('.') {
+        return None;
+    }
+    Some(host)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_minimal_application_entry() {
+        let raw = "[Desktop Entry]\nName=Firefox\nIcon=firefox\nType=Application\n";
+        let parsed = parse_desktop_entry(raw).expect("application entry");
+        assert_eq!(parsed.name.as_deref(), Some("Firefox"));
+        assert_eq!(parsed.icon.as_deref(), Some("firefox"));
+        assert_eq!(parsed.startup_wm_class, None);
+    }
+
+    #[test]
+    fn captures_startup_wm_class() {
+        let raw = "[Desktop Entry]\nName=1Password\nIcon=1password\n\
+                   Type=Application\nStartupWMClass=1Password\n";
+        let parsed = parse_desktop_entry(raw).expect("application entry");
+        assert_eq!(parsed.startup_wm_class.as_deref(), Some("1Password"));
+    }
+
+    #[test]
+    fn rejects_link_type() {
+        let raw = "[Desktop Entry]\nName=Some Bookmark\nType=Link\nURL=https://x/\n";
+        assert!(parse_desktop_entry(raw).is_none());
+    }
+
+    #[test]
+    fn rejects_missing_type() {
+        // Missing Type= is equivalent to "this isn't an
+        // Application", so the picker should skip it.
+        let raw = "[Desktop Entry]\nName=Whatever\nIcon=x\n";
+        assert!(parse_desktop_entry(raw).is_none());
+    }
+
+    #[test]
+    fn rejects_hidden_entry() {
+        let raw = "[Desktop Entry]\nName=Hidden\nIcon=x\nType=Application\nHidden=true\n";
+        assert!(parse_desktop_entry(raw).is_none());
+    }
+
+    #[test]
+    fn rejects_no_display_entry() {
+        let raw = "[Desktop Entry]\nName=Helper\nIcon=x\nType=Application\nNoDisplay=true\n";
+        assert!(parse_desktop_entry(raw).is_none());
+    }
+
+    #[test]
+    fn stops_at_subsequent_section_header() {
+        // Locale-specific Name[de_DE]= keys are interleaved between
+        // [Desktop Entry] and [Desktop Action xyz] headers in some
+        // .desktop files. We only care about the primary section.
+        let raw = "[Desktop Entry]\nName=Foo\nType=Application\n\
+                   [Desktop Action New]\nName=New Window\n";
+        let parsed = parse_desktop_entry(raw).unwrap();
+        assert_eq!(parsed.name.as_deref(), Some("Foo"));
+    }
+
+    #[test]
+    fn ignores_comments_and_blank_lines() {
+        let raw = "# leading comment\n\n[Desktop Entry]\n# inside\nName=Foo\n\nType=Application\n";
+        let parsed = parse_desktop_entry(raw).unwrap();
+        assert_eq!(parsed.name.as_deref(), Some("Foo"));
+    }
+
+    #[test]
+    fn discover_apps_smoke_test() {
+        // Best-effort: this test runs anywhere `cargo test` runs, so
+        // we only assert the function doesn't panic. On a desktop
+        // box it'll typically return dozens of entries; on CI it
+        // may be empty.
+        let _ = discover_apps();
+    }
+
+    #[test]
+    fn extract_hosts_handles_simple_https_url() {
+        let hosts =
+            extract_hosts_from_exec("omarchy-launch-webapp https://discord.com/channels/@me");
+        assert_eq!(hosts, vec!["discord.com"]);
+    }
+
+    #[test]
+    fn extract_hosts_handles_quoted_and_multiple_urls() {
+        let hosts = extract_hosts_from_exec(
+            "browser \"https://gmail.com/u/0\" https://calendar.google.com/r",
+        );
+        assert_eq!(hosts, vec!["gmail.com", "calendar.google.com"]);
+    }
+
+    #[test]
+    fn extract_hosts_skips_non_url_tokens() {
+        let hosts = extract_hosts_from_exec("firefox %U");
+        assert!(hosts.is_empty());
+    }
+
+    #[test]
+    fn extract_hosts_strips_port_and_query() {
+        let hosts = extract_hosts_from_exec("open https://example.com:8080/path?q=1#frag");
+        assert_eq!(hosts, vec!["example.com"]);
+    }
+
+    #[test]
+    fn parse_chrome_pwa_host_handles_path_form() {
+        // The omarchy --app=URL case the user reported: Hyprland
+        // class `chrome-discord.com__channels_@me-Default`.
+        // (We're matching against the lowercased form.)
+        assert_eq!(
+            parse_chrome_pwa_host("chrome-discord.com__channels_@me-default"),
+            Some("discord.com")
+        );
+    }
+
+    #[test]
+    fn parse_chrome_pwa_host_handles_pathless_form() {
+        // `--app=https://example.com/` (no path beyond root) →
+        // `chrome-example.com-default`.
+        assert_eq!(
+            parse_chrome_pwa_host("chrome-example.com-default"),
+            Some("example.com")
+        );
+    }
+
+    #[test]
+    fn parse_chrome_pwa_host_handles_alt_profiles() {
+        assert_eq!(
+            parse_chrome_pwa_host("chrome-example.com__app_-profile_2"),
+            Some("example.com")
+        );
+        assert_eq!(
+            parse_chrome_pwa_host("chrome-example.com-profile_1"),
+            Some("example.com")
+        );
+    }
+
+    #[test]
+    fn parse_chrome_pwa_host_rejects_non_chrome_classes() {
+        assert!(parse_chrome_pwa_host("firefox").is_none());
+        assert!(parse_chrome_pwa_host("chromium").is_none());
+        // `chrome-` prefix but the trailing portion has no dot, so
+        // it's almost certainly an extension ID
+        // (`chrome-<id>-default`) — the direct .desktop index
+        // already covers those, so the webapp fallback should not
+        // claim them.
+        assert!(parse_chrome_pwa_host("chrome-mjoklplbddabcmpepnokjaffbmgbkkgg-default").is_none());
+    }
+
+    #[test]
+    fn parse_chrome_pwa_host_rejects_unknown_profile_suffix() {
+        // No `__` and no recognized `-default` / `-profile_N`
+        // suffix — could be anything.
+        assert!(parse_chrome_pwa_host("chrome-example.com-something").is_none());
+    }
+
+    #[test]
+    fn app_directory_lookup_falls_back_to_webapp_host() {
+        // End-to-end: a .desktop with `Exec=… https://discord.com/…`
+        // and no StartupWMClass should still resolve the
+        // omarchy `--app=` PWA class via the host index.
+        let mut by_id: HashMap<String, DesktopAppMetadata> = HashMap::new();
+        let mut by_host: HashMap<String, DesktopAppMetadata> = HashMap::new();
+        by_id.insert(
+            "discord".to_owned(),
+            DesktopAppMetadata {
+                display_name: "Discord".into(),
+                icon_name: Some("/path/to/discord.png".into()),
+            },
+        );
+        by_host.insert(
+            "discord.com".to_owned(),
+            DesktopAppMetadata {
+                display_name: "Discord".into(),
+                icon_name: Some("/path/to/discord.png".into()),
+            },
+        );
+        let dir = AppDirectory {
+            by_identifier: by_id,
+            by_webapp_host: by_host,
+        };
+        // Direct hit by stem.
+        assert_eq!(
+            dir.lookup("discord").map(|m| m.display_name),
+            Some("Discord".into())
+        );
+        // Webapp fallback for the omarchy class.
+        assert_eq!(
+            dir.lookup("chrome-discord.com__channels_@me-Default")
+                .map(|m| m.display_name),
+            Some("Discord".into())
+        );
+        // Unknown class falls through to None.
+        assert!(dir.lookup("chrome-unknown.com-default").is_none());
+    }
+
+    /// Local-development convenience. Run with
+    /// `cargo test -p input-capture -- --ignored --nocapture
+    /// discover_apps_dump` to see what the .desktop scanner finds
+    /// on the current box. Pinned `#[ignore]` so CI / casual `cargo
+    /// test` doesn't print to stdout.
+    #[test]
+    #[ignore]
+    fn discover_apps_dump() {
+        let dir = discover_apps();
+        println!(
+            "discovered {} direct entries, {} webapp hosts",
+            dir.by_identifier.len(),
+            dir.by_webapp_host.len()
+        );
+        let mut keys: Vec<&String> = dir.by_identifier.keys().collect();
+        keys.sort();
+        for k in keys {
+            let m = &dir.by_identifier[k];
+            println!(
+                "  id  {k:40} → name={:?} icon={:?}",
+                m.display_name, m.icon_name
+            );
+        }
+        let mut hosts: Vec<&String> = dir.by_webapp_host.keys().collect();
+        hosts.sort();
+        for h in hosts {
+            let m = &dir.by_webapp_host[h];
+            println!(
+                "  web {h:40} → name={:?} icon={:?}",
+                m.display_name, m.icon_name
+            );
+        }
+    }
+}
diff --git a/input-capture/src/dummy.rs b/input-capture/src/dummy.rs
index 3a2a734e..b2296d9d 100644
--- a/input-capture/src/dummy.rs
+++ b/input-capture/src/dummy.rs
@@ -42,7 +42,7 @@ impl Capture for DummyInputCapture {
         Ok(())
     }
 
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    async fn release(&mut self, _warp_target: Option<(i32, i32)>) -> Result<(), CaptureError> {
         Ok(())
     }
 
@@ -62,7 +62,7 @@ impl Stream for DummyInputCapture {
         let event = match self.start {
             None => {
                 self.start.replace(current);
-                CaptureEvent::Begin
+                CaptureEvent::Begin { cursor: None }
             }
             Some(start) => {
                 let elapsed = start.elapsed();
diff --git a/input-capture/src/frontmost_app.rs b/input-capture/src/frontmost_app.rs
new file mode 100644
index 00000000..692fec8a
--- /dev/null
+++ b/input-capture/src/frontmost_app.rs
@@ -0,0 +1,778 @@
+//! Cross-platform "what's the frontmost app right now?" lookup.
+//!
+//! Used by [`crate::clipboard::ClipboardMonitor`] to consult a
+//! user-maintained suppression list before broadcasting a clipboard
+//! change: when the active app at the moment of capture matches an
+//! entry in the list (e.g. `1Password.app`), the change is dropped
+//! locally rather than going on the wire.
+//!
+//! Each platform returns a `Some(AppIdent)` whose variant matches
+//! the OS — see [`AppIdent`] in `lan-mouse-ipc`. None means we
+//! couldn't determine the active app (no compositor support, no
+//! permissions, transient race, …); the caller treats that as "not
+//! suppressed."
+//!
+//! # macOS
+//!
+//! Implemented via `objc2-app-kit` against `NSWorkspace`:
+//!
+//! - `frontmost_app()` →
+//!   `NSWorkspace.sharedWorkspace.frontmostApplication.bundleIdentifier`
+//!   wrapped in `AppIdent::MacBundle`.
+//! - `list_running_apps()` →
+//!   `NSWorkspace.runningApplications` map → bundle ID. Apps with
+//!   no bundle ID (anonymous helpers) are skipped.
+//!
+//! Concealed-type pasteboard detection lives in
+//! [`crate::clipboard`] (`is_concealed_clipboard`) and uses the
+//! same objc bridge to check `NSPasteboard.types` for
+//! `org.nspasteboard.ConcealedType`.
+
+use lan_mouse_ipc::{AppIdent, RunningApp};
+
+/// Helpers used by the Linux backend and exercised by Linux-only
+/// unit tests. Module-scoped (rather than nested inside the
+/// `#[cfg]`-gated Linux `backend` mod) so the test suite can
+/// reach it without duplicating cfg gates. Compiled only on
+/// non-macOS unixes — on macOS / Windows it would be dead code
+/// and clippy's `-D dead-code` would fail the build.
+#[cfg(all(unix, not(target_os = "macos")))]
+pub(crate) mod backend_helpers {
+    /// Detect Wayland via `WAYLAND_DISPLAY` env var. Used by the
+    /// Linux backend and a unit test that pins the precedence
+    /// rule so a regression in env-var detection surfaces with a
+    /// clear failure rather than a silent compositor-mismatch.
+    pub fn is_wayland_for_test() -> bool {
+        std::env::var_os("WAYLAND_DISPLAY")
+            .map(|v| !v.is_empty())
+            .unwrap_or(false)
+    }
+}
+
+pub use lan_mouse_ipc::AppIdent as AppIdentRe;
+
+/// Best-effort lookup of the application whose window is currently
+/// frontmost. Returns `None` when the platform doesn't support the
+/// query (or when the lookup transiently fails — caller should
+/// treat that as "not suppressed", not as "suppressed").
+pub fn frontmost_app() -> Option<AppIdent> {
+    backend::frontmost_app()
+}
+
+/// Best-effort enumeration of currently-running apps suitable for
+/// the suppression-list picker. Each entry pairs a human-readable
+/// display name with the host-OS identifier used by the runtime
+/// suppression check. Empty when the platform can't enumerate
+/// (no compositor support, missing permissions, transient race).
+pub fn list_running_apps() -> Vec<RunningApp> {
+    backend::list_running_apps()
+}
+
+/// Resolve a host-OS identifier (e.g. macOS bundle ID) into a
+/// `RunningApp` with display name + icon, even when the app isn't
+/// currently running. Used by the GUI to render the suppressed-
+/// apps list — the user added entries by bundle ID and we want to
+/// show "1Password" with the 1Password icon, not the raw
+/// `com.1password.1password` string.
+///
+/// Returns `None` when the identifier doesn't resolve to an
+/// installed app (e.g. uninstalled since being added) or on
+/// platforms without a per-platform implementation. Callers
+/// should fall back to displaying the identifier verbatim.
+pub fn lookup_app_metadata(identifier: &str) -> Option<RunningApp> {
+    backend::lookup_app_metadata(identifier)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Smoke test: the lookup must not panic even when no compositor
+    /// is reachable (CI sandboxes, headless `cargo test`, etc.). A
+    /// `None` return is a perfectly valid outcome — the caller
+    /// treats that as "not suppressed."
+    #[test]
+    fn frontmost_app_does_not_panic() {
+        let _ = frontmost_app();
+    }
+
+    #[test]
+    fn list_running_apps_does_not_panic() {
+        let _ = list_running_apps();
+    }
+
+    #[cfg(all(unix, not(target_os = "macos")))]
+    #[test]
+    fn wayland_detection_uses_wayland_display_env_var() {
+        // We can't actually mutate process env safely from a
+        // multi-threaded test runner, so just exercise the helper
+        // and verify it returns a deterministic bool. Pinning the
+        // mechanism here means a refactor to (e.g.)
+        // `XDG_SESSION_TYPE`-only detection would surface as a
+        // failed test instead of a silent compositor-mismatch.
+        let _ = backend_helpers::is_wayland_for_test();
+    }
+}
+
+#[cfg(target_os = "macos")]
+mod backend {
+    use super::{AppIdent, RunningApp};
+    use objc2_app_kit::{NSBitmapImageFileType, NSBitmapImageRep, NSImage, NSWorkspace};
+    use objc2_foundation::{NSDictionary, NSString};
+    use std::collections::HashMap;
+    use std::process::Command;
+    use std::sync::{Mutex, OnceLock};
+
+    /// Return the bundle ID of the frontmost app via osascript →
+    /// System Events. `NSWorkspace.frontmostApplication` from the
+    /// daemon process is silently scoped to the caller's
+    /// loginwindow / Aqua session and returns `nil` for plain
+    /// Cocoa apps the daemon doesn't share a Mach connection with
+    /// (Messages, Notes, most Apple system apps). System Events is
+    /// fully session-attached so it sees the real frontmost
+    /// regardless. ~50 ms per call but only fires when the
+    /// clipboard polling loop notices a change, so latency is
+    /// acceptable.
+    pub fn frontmost_app() -> Option<AppIdent> {
+        const SCRIPT: &str = "tell application \"System Events\" to get bundle identifier of first application process whose frontmost is true";
+        let output = Command::new("/usr/bin/osascript")
+            .args(["-e", SCRIPT])
+            .output()
+            .ok()?;
+        if !output.status.success() {
+            return None;
+        }
+        let bundle_id = String::from_utf8(output.stdout).ok()?.trim().to_owned();
+        if bundle_id.is_empty() {
+            return None;
+        }
+        Some(AppIdent::MacBundle(bundle_id))
+    }
+
+    /// Enumerate user-visible apps via `osascript` → System Events.
+    ///
+    /// Three direct AppKit APIs all silently scope to the caller's
+    /// loginwindow / Aqua session — a non-Cocoa GTK process running
+    /// as the .app's main process does NOT have a full session, so
+    /// `NSWorkspace.runningApplications`, `NSRunningApplication
+    /// .runningApplicationWithProcessIdentifier`, and
+    /// `CGWindowListCopyWindowInfo` only return apps with which
+    /// our process happens to share a Mach connection (XPC services
+    /// we use, accessibility agents, recently-activated panes,
+    /// pasteboard peers). Real Cocoa apps the user is using stay
+    /// invisible.
+    ///
+    /// System Events is itself fully session-attached and returns
+    /// the complete process list. We talk to it through the
+    /// already-permissioned Apple Events channel
+    /// (`NSAppleEventsUsageDescription` is declared, the user has
+    /// already granted automation control for input emulation).
+    /// The script returns one tab-separated row per visible app:
+    /// `bundle_id\tposix_path\tname`. Helpers / XPC services /
+    /// preference-pane extensions are excluded by System Events'
+    /// own definition of `background only is false`.
+    pub fn list_running_apps() -> Vec<RunningApp> {
+        let raw = match query_visible_apps_via_system_events() {
+            Some(s) => s,
+            None => {
+                log::debug!("list_running_apps: System Events query failed");
+                return Vec::new();
+            }
+        };
+        let mut out: Vec<RunningApp> = Vec::with_capacity(32);
+        for line in raw.lines() {
+            let mut parts = line.splitn(3, '\t');
+            let identifier = parts.next().unwrap_or("").trim();
+            let path = parts.next().unwrap_or("").trim();
+            let display_name = parts.next().unwrap_or("").trim();
+            if identifier.is_empty() || path.is_empty() || display_name.is_empty() {
+                continue;
+            }
+            // Hide our own bundle — suppressing your own clipboard
+            // app makes no sense (we ARE the clipboard sender).
+            if identifier == "de.feschber.LanMouse" {
+                continue;
+            }
+            let icon_png = cached_or_encoded_icon(identifier, path);
+            out.push(RunningApp {
+                display_name: display_name.to_owned(),
+                identifier: identifier.to_owned(),
+                icon_png,
+            });
+        }
+        out.sort_by_key(|a| a.display_name.to_lowercase());
+        out.dedup_by(|a, b| a.identifier == b.identifier);
+        log::debug!(
+            "list_running_apps: {} visible apps via System Events",
+            out.len()
+        );
+        out
+    }
+
+    /// Spawn `osascript` with an inline AppleScript that asks
+    /// System Events for every non-background process and returns
+    /// `bundle_id\tposix_path\tname` per line. Inner try-catches
+    /// silently skip processes whose bundle ID or file we can't
+    /// resolve (rare system processes), so the result is always
+    /// well-formed. Returns `None` only if osascript itself fails
+    /// — typically because the user hasn't granted Apple Events
+    /// permission yet, in which case the picker stays empty until
+    /// they accept the system prompt.
+    fn query_visible_apps_via_system_events() -> Option<String> {
+        const SCRIPT: &str = r#"
+tell application "System Events"
+    set out to ""
+    try
+        set procs to (every process where background only is false)
+        repeat with p in procs
+            try
+                set bid to bundle identifier of p
+                set fp to POSIX path of ((file of p) as alias)
+                set nm to name of p
+                set out to out & bid & tab & fp & tab & nm & linefeed
+            end try
+        end repeat
+    end try
+    return out
+end tell
+"#;
+        let output = Command::new("/usr/bin/osascript")
+            .args(["-e", SCRIPT])
+            .output()
+            .ok()?;
+        if !output.status.success() {
+            log::debug!(
+                "osascript failed (exit {:?}): {}",
+                output.status.code(),
+                String::from_utf8_lossy(&output.stderr)
+            );
+            return None;
+        }
+        String::from_utf8(output.stdout).ok()
+    }
+
+    /// Cache PNG icon bytes by bundle identifier. The 5-second
+    /// auto-refresh would otherwise re-encode every icon on every
+    /// tick, which adds up to tens of milliseconds of main-thread
+    /// work per refresh. Icons rarely change while an app is
+    /// running, so caching by bundle ID is a clean trade.
+    fn cached_or_encoded_icon(bundle_id: &str, app_path: &str) -> Option<Vec<u8>> {
+        static CACHE: OnceLock<Mutex<HashMap<String, Option<Vec<u8>>>>> = OnceLock::new();
+        let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new()));
+        if let Ok(guard) = cache.lock() {
+            if let Some(hit) = guard.get(bundle_id) {
+                return hit.clone();
+            }
+        }
+        let png = encode_icon_for_app_path(app_path);
+        if let Ok(mut guard) = cache.lock() {
+            guard.insert(bundle_id.to_owned(), png.clone());
+        }
+        png
+    }
+
+    fn encode_icon_for_app_path(app_path: &str) -> Option<Vec<u8>> {
+        let workspace = NSWorkspace::sharedWorkspace();
+        let path_str = NSString::from_str(app_path);
+        let icon = workspace.iconForFile(&path_str);
+        encode_nsimage_to_small_png(&icon)
+    }
+
+    /// Look up display name + icon for an installed app by bundle
+    /// ID, even if it's not currently running. Uses Launch
+    /// Services (`URLForApplicationWithBundleIdentifier`) to find
+    /// the .app's path on disk, then derives the display name from
+    /// the bundle's file name (`/Applications/1Password.app` →
+    /// `1Password`) and loads its icon via `iconForFile:`. Both
+    /// APIs are path-based and session-independent.
+    pub(super) fn lookup_app_metadata(identifier: &str) -> Option<RunningApp> {
+        let workspace = NSWorkspace::sharedWorkspace();
+        let bid_str = NSString::from_str(identifier);
+        let url = workspace.URLForApplicationWithBundleIdentifier(&bid_str)?;
+        let path_ns = url.path()?;
+        let path_str = path_ns.to_string();
+        let display_name = std::path::Path::new(&path_str)
+            .file_stem()
+            .and_then(|s| s.to_str())
+            .map(String::from)
+            .unwrap_or_else(|| identifier.to_owned());
+        let icon_png = cached_or_encoded_icon(identifier, &path_str);
+        Some(RunningApp {
+            display_name,
+            identifier: identifier.to_owned(),
+            icon_png,
+        })
+    }
+
+    fn encode_nsimage_to_small_png(icon: &NSImage) -> Option<Vec<u8>> {
+        // Pick the rep that's closest-but-no-smaller than 64 px.
+        // .icns files typically include 16/32/64/128/256/512/1024;
+        // anything bigger ships hundreds of KB of PNG over IPC for
+        // no display benefit.
+        let target_px: f64 = 64.0;
+        let reps = icon.representations();
+        let mut best_idx: Option<usize> = None;
+        let mut best_w: f64 = f64::INFINITY;
+        for (i, rep) in reps.iter().enumerate() {
+            let w = rep.size().width;
+            if w >= target_px && w < best_w {
+                best_idx = Some(i);
+                best_w = w;
+            }
+        }
+        if best_idx.is_none() {
+            let mut max_w: f64 = 0.0;
+            for (i, rep) in reps.iter().enumerate() {
+                let w = rep.size().width;
+                if w > max_w {
+                    best_idx = Some(i);
+                    max_w = w;
+                }
+            }
+        }
+        let bitmap_rep = if let Some(i) = best_idx {
+            reps.objectAtIndex(i)
+                .downcast::<NSBitmapImageRep>()
+                .ok()
+                .or_else(|| {
+                    let tiff = icon.TIFFRepresentation()?;
+                    NSBitmapImageRep::imageRepWithData(&tiff)
+                })
+        } else {
+            let tiff = icon.TIFFRepresentation()?;
+            NSBitmapImageRep::imageRepWithData(&tiff)
+        }?;
+        let empty = NSDictionary::<NSString>::dictionary();
+        let png = unsafe {
+            bitmap_rep.representationUsingType_properties(NSBitmapImageFileType::PNG, &empty)
+        }?;
+        let bytes = unsafe { png.as_bytes_unchecked() };
+        Some(bytes.to_vec())
+    }
+}
+
+#[cfg(windows)]
+mod backend {
+    use super::{AppIdent, RunningApp};
+    use windows::Win32::Foundation::{CloseHandle, FALSE, HWND, LPARAM};
+    use windows::Win32::System::Threading::{
+        OpenProcess, PROCESS_NAME_WIN32, PROCESS_QUERY_LIMITED_INFORMATION,
+        QueryFullProcessImageNameW,
+    };
+    use windows::Win32::UI::WindowsAndMessaging::{
+        EnumWindows, GetForegroundWindow, GetWindowThreadProcessId, IsWindowVisible,
+    };
+    use windows::core::{BOOL, PWSTR};
+
+    fn process_basename(pid: u32) -> Option<String> {
+        if pid == 0 {
+            return None;
+        }
+        unsafe {
+            let handle = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid).ok()?;
+            let mut buf = [0u16; 1024];
+            let mut len = buf.len() as u32;
+            let result = QueryFullProcessImageNameW(
+                handle,
+                PROCESS_NAME_WIN32,
+                PWSTR(buf.as_mut_ptr()),
+                &mut len,
+            );
+            let _ = CloseHandle(handle);
+            result.ok()?;
+            let path = String::from_utf16_lossy(&buf[..len as usize]);
+            std::path::Path::new(&path)
+                .file_name()
+                .and_then(|n| n.to_str())
+                .map(|s| s.to_lowercase())
+        }
+    }
+
+    pub fn frontmost_app() -> Option<AppIdent> {
+        unsafe {
+            let hwnd = GetForegroundWindow();
+            if hwnd == HWND::default() {
+                return None;
+            }
+            let mut pid: u32 = 0;
+            GetWindowThreadProcessId(hwnd, Some(&mut pid));
+            process_basename(pid).map(AppIdent::WindowsExe)
+        }
+    }
+
+    pub fn list_running_apps() -> Vec<RunningApp> {
+        // Walk every visible top-level window, dedup by process
+        // basename. Closures captured via LPARAM pointer to a Vec.
+        let mut basenames: Vec<String> = Vec::new();
+        unsafe extern "system" fn enum_proc(hwnd: HWND, lparam: LPARAM) -> BOOL {
+            unsafe {
+                if IsWindowVisible(hwnd) == FALSE {
+                    return BOOL(1); // continue
+                }
+                let mut pid: u32 = 0;
+                GetWindowThreadProcessId(hwnd, Some(&mut pid));
+                let Some(name) = process_basename(pid) else {
+                    return BOOL(1);
+                };
+                let v: &mut Vec<String> = &mut *(lparam.0 as *mut Vec<String>);
+                if !v.iter().any(|n| n == &name) {
+                    v.push(name);
+                }
+                BOOL(1)
+            }
+        }
+        unsafe {
+            let _ = EnumWindows(Some(enum_proc), LPARAM(&mut basenames as *mut _ as isize));
+        }
+        let mut out: Vec<RunningApp> = basenames
+            .into_iter()
+            .map(|name| RunningApp {
+                display_name: name.clone(),
+                identifier: name,
+                icon_png: None,
+            })
+            .collect();
+        out.sort_by(|a, b| a.display_name.cmp(&b.display_name));
+        out
+    }
+
+    pub(super) fn lookup_app_metadata(_identifier: &str) -> Option<RunningApp> {
+        // No installed-app metadata source on Windows yet.
+        None
+    }
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+mod backend {
+    use super::{AppIdent, RunningApp};
+    use crate::desktop_entries::{self, AppDirectory};
+    use std::process::Command;
+
+    /// Detect compositor flavor via env vars. Wayland sessions set
+    /// `WAYLAND_DISPLAY`; X11 sessions don't. `XDG_SESSION_TYPE` is
+    /// the modern signal but isn't always set on tiling WMs (Sway,
+    /// Hyprland) so we treat presence of `WAYLAND_DISPLAY` as
+    /// authoritative for Wayland.
+    fn is_wayland() -> bool {
+        super::backend_helpers::is_wayland_for_test()
+    }
+
+    pub fn frontmost_app() -> Option<AppIdent> {
+        if is_wayland() {
+            hyprland_active()
+                .or_else(sway_active)
+                .map(|s| AppIdent::LinuxWayland(s.to_lowercase()))
+        } else {
+            x11_active().map(|s| AppIdent::LinuxX11(s.to_lowercase()))
+        }
+    }
+
+    pub fn list_running_apps() -> Vec<RunningApp> {
+        let mut idents: Vec<String> = if is_wayland() {
+            // Hyprland's `clients -j` returns every mapped client;
+            // sway's `get_tree` returns the whole tree. Either way
+            // we extract `class` / `app_id`, dedup, and sort for
+            // stable display in the GUI.
+            hyprland_clients()
+                .into_iter()
+                .chain(sway_clients())
+                .collect()
+        } else {
+            x11_client_list()
+        };
+        idents.sort();
+        idents.dedup();
+        // Enrich each runtime identifier with its installed-app
+        // metadata (display name + icon bytes) when a .desktop
+        // entry can be matched. Apps with no .desktop hit fall
+        // through to the raw-string display path so an unknown
+        // class still shows up in the picker.
+        let directory = desktop_entries::discover_apps();
+        let mut out: Vec<RunningApp> = idents
+            .into_iter()
+            .map(|raw| build_running_app(&directory, raw))
+            .collect();
+        // Re-sort by display name now that .desktop enrichment may
+        // have rewritten "firefox" → "Firefox", etc., so the picker
+        // shows entries in human-readable order.
+        out.sort_by(|a, b| {
+            a.display_name
+                .to_lowercase()
+                .cmp(&b.display_name.to_lowercase())
+        });
+        out
+    }
+
+    /// Resolve a stored host-OS identifier (a lowercased class /
+    /// app_id) back to a [`RunningApp`] using the same .desktop
+    /// scan the picker uses. Lets the GUI render a previously-
+    /// added entry as `1Password` with its icon even when the app
+    /// isn't currently running.
+    pub(super) fn lookup_app_metadata(identifier: &str) -> Option<RunningApp> {
+        let directory = desktop_entries::discover_apps();
+        let app = build_running_app(&directory, identifier.to_owned());
+        // build_running_app always returns Something; only treat
+        // it as "found" when the .desktop scan actually contributed
+        // metadata (display name differs from the identifier, or
+        // we got an icon).
+        if app.display_name.eq_ignore_ascii_case(identifier) && app.icon_png.is_none() {
+            None
+        } else {
+            Some(app)
+        }
+    }
+
+    /// Assemble a [`RunningApp`] from a runtime identifier plus
+    /// the [`AppDirectory`]. The identifier is lowercased so the
+    /// direct + Chrome-PWA-fallback lookups in
+    /// [`AppDirectory::lookup`] hit the same case the indexer
+    /// inserted under.
+    fn build_running_app(directory: &AppDirectory, raw_identifier: String) -> RunningApp {
+        let lower = raw_identifier.to_lowercase();
+        if let Some(meta) = directory.lookup(&lower) {
+            let icon_png = meta
+                .icon_name
+                .as_deref()
+                .and_then(desktop_entries::icon_bytes_for_name);
+            return RunningApp {
+                display_name: meta.display_name,
+                identifier: lower,
+                icon_png,
+            };
+        }
+        RunningApp {
+            display_name: raw_identifier,
+            identifier: lower,
+            icon_png: None,
+        }
+    }
+
+    fn run_capture(cmd: &str, args: &[&str]) -> Option<String> {
+        let out = Command::new(cmd).args(args).output().ok()?;
+        if !out.status.success() {
+            return None;
+        }
+        String::from_utf8(out.stdout).ok()
+    }
+
+    fn hyprland_active() -> Option<String> {
+        let json = run_capture("hyprctl", &["activewindow", "-j"])?;
+        let parsed: serde_json::Value = serde_json::from_str(&json).ok()?;
+        // Hyprland reports the X11 WM_CLASS-equivalent as `class`.
+        // `initialClass` is the value the toplevel registered with;
+        // prefer it when present so a renamed window doesn't slip
+        // suppression by changing its title.
+        let class = parsed
+            .get("initialClass")
+            .and_then(|v| v.as_str())
+            .or_else(|| parsed.get("class").and_then(|v| v.as_str()))?;
+        let class = class.trim();
+        if class.is_empty() {
+            return None;
+        }
+        Some(class.to_owned())
+    }
+
+    fn hyprland_clients() -> Vec<String> {
+        let Some(json) = run_capture("hyprctl", &["clients", "-j"]) else {
+            return Vec::new();
+        };
+        let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&json) else {
+            return Vec::new();
+        };
+        parsed
+            .as_array()
+            .map(|arr| {
+                arr.iter()
+                    .filter_map(|c| {
+                        c.get("initialClass")
+                            .and_then(|v| v.as_str())
+                            .or_else(|| c.get("class").and_then(|v| v.as_str()))
+                    })
+                    .map(str::to_owned)
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
+    fn sway_active() -> Option<String> {
+        let json = run_capture("swaymsg", &["-t", "get_tree"])?;
+        let tree: serde_json::Value = serde_json::from_str(&json).ok()?;
+        find_focused_app_id(&tree)
+    }
+
+    fn sway_clients() -> Vec<String> {
+        let Some(json) = run_capture("swaymsg", &["-t", "get_tree"]) else {
+            return Vec::new();
+        };
+        let Ok(tree) = serde_json::from_str::<serde_json::Value>(&json) else {
+            return Vec::new();
+        };
+        let mut acc = Vec::new();
+        collect_app_ids(&tree, &mut acc);
+        acc
+    }
+
+    /// Walk the sway/i3 tree depth-first looking for the node with
+    /// `focused == true` and a non-empty `app_id` (Wayland clients)
+    /// or `window_properties.class` (XWayland fallback).
+    fn find_focused_app_id(node: &serde_json::Value) -> Option<String> {
+        if node.get("focused").and_then(|v| v.as_bool()) == Some(true) {
+            if let Some(s) = node.get("app_id").and_then(|v| v.as_str()) {
+                if !s.is_empty() {
+                    return Some(s.to_owned());
+                }
+            }
+            if let Some(s) = node
+                .get("window_properties")
+                .and_then(|wp| wp.get("class"))
+                .and_then(|v| v.as_str())
+            {
+                if !s.is_empty() {
+                    return Some(s.to_owned());
+                }
+            }
+        }
+        for key in ["nodes", "floating_nodes"] {
+            if let Some(arr) = node.get(key).and_then(|v| v.as_array()) {
+                for child in arr {
+                    if let Some(found) = find_focused_app_id(child) {
+                        return Some(found);
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    fn collect_app_ids(node: &serde_json::Value, acc: &mut Vec<String>) {
+        if let Some(s) = node.get("app_id").and_then(|v| v.as_str()) {
+            if !s.is_empty() {
+                acc.push(s.to_owned());
+            }
+        }
+        if let Some(s) = node
+            .get("window_properties")
+            .and_then(|wp| wp.get("class"))
+            .and_then(|v| v.as_str())
+        {
+            if !s.is_empty() {
+                acc.push(s.to_owned());
+            }
+        }
+        for key in ["nodes", "floating_nodes"] {
+            if let Some(arr) = node.get(key).and_then(|v| v.as_array()) {
+                for child in arr {
+                    collect_app_ids(child, acc);
+                }
+            }
+        }
+    }
+
+    fn x11_active() -> Option<String> {
+        use x11rb::connection::Connection;
+        use x11rb::protocol::xproto::{AtomEnum, ConnectionExt};
+
+        let (conn, screen_num) = x11rb::connect(None).ok()?;
+        let root = conn.setup().roots[screen_num].root;
+        let net_active = conn
+            .intern_atom(false, b"_NET_ACTIVE_WINDOW")
+            .ok()?
+            .reply()
+            .ok()?
+            .atom;
+        let prop = conn
+            .get_property(false, root, net_active, AtomEnum::WINDOW, 0, 1)
+            .ok()?
+            .reply()
+            .ok()?;
+        let window_id = prop.value32()?.next()?;
+        if window_id == 0 {
+            return None;
+        }
+        let class_prop = conn
+            .get_property(
+                false,
+                window_id,
+                AtomEnum::WM_CLASS,
+                AtomEnum::STRING,
+                0,
+                1024,
+            )
+            .ok()?
+            .reply()
+            .ok()?;
+        // WM_CLASS is two NUL-separated strings: instance, class.
+        // Prefer the second (class) since it tends to be the more
+        // stable identifier.
+        let raw = class_prop.value;
+        let mut parts = raw.split(|&b| b == 0).filter(|s| !s.is_empty());
+        let _instance = parts.next();
+        let class = parts.next();
+        let bytes = class.or_else(|| {
+            // Single-string fallback (some toolkits put the same
+            // value in both fields without a separator).
+            raw.split(|&b| b == 0).find(|s| !s.is_empty())
+        })?;
+        let s = String::from_utf8_lossy(bytes).into_owned();
+        if s.is_empty() {
+            return None;
+        }
+        Some(s)
+    }
+
+    fn x11_client_list() -> Vec<String> {
+        use x11rb::connection::Connection;
+        use x11rb::protocol::xproto::{AtomEnum, ConnectionExt};
+
+        let Ok((conn, screen_num)) = x11rb::connect(None) else {
+            return Vec::new();
+        };
+        let root = conn.setup().roots[screen_num].root;
+        let Ok(reply) = conn.intern_atom(false, b"_NET_CLIENT_LIST") else {
+            return Vec::new();
+        };
+        let Ok(net_client_list) = reply.reply() else {
+            return Vec::new();
+        };
+        let net_client_list = net_client_list.atom;
+        let Ok(prop_req) =
+            conn.get_property(false, root, net_client_list, AtomEnum::WINDOW, 0, u32::MAX)
+        else {
+            return Vec::new();
+        };
+        let Ok(prop) = prop_req.reply() else {
+            return Vec::new();
+        };
+        let Some(values) = prop.value32() else {
+            return Vec::new();
+        };
+        let mut out = Vec::new();
+        for window_id in values {
+            if window_id == 0 {
+                continue;
+            }
+            let Ok(req) = conn.get_property(
+                false,
+                window_id,
+                AtomEnum::WM_CLASS,
+                AtomEnum::STRING,
+                0,
+                1024,
+            ) else {
+                continue;
+            };
+            let Ok(class_prop) = req.reply() else {
+                continue;
+            };
+            let raw = class_prop.value;
+            let mut parts = raw.split(|&b| b == 0).filter(|s| !s.is_empty());
+            let _instance = parts.next();
+            let class = parts.next();
+            if let Some(bytes) = class.or_else(|| raw.split(|&b| b == 0).find(|s| !s.is_empty())) {
+                out.push(String::from_utf8_lossy(bytes).into_owned());
+            }
+        }
+        out
+    }
+}
diff --git a/input-capture/src/layer_shell.rs b/input-capture/src/layer_shell.rs
index 698c5849..68436b39 100644
--- a/input-capture/src/layer_shell.rs
+++ b/input-capture/src/layer_shell.rs
@@ -149,6 +149,13 @@ struct Window {
     surface: WlSurface,
     layer_surface: ZwlrLayerSurfaceV1,
     pos: Position,
+    /// Output's top-left corner in compositor coordinate space —
+    /// used together with `wl_pointer::Enter`'s surface-local coords
+    /// to recover the host screen-space cursor position at the moment
+    /// of crossing, so we can populate `CaptureEvent::Begin { cursor }`
+    /// for cross-axis preservation.
+    output_pos: (i32, i32),
+    output_size: (i32, i32),
 }
 
 impl Window {
@@ -157,6 +164,7 @@ impl Window {
         qh: &QueueHandle<State>,
         output: &WlOutput,
         pos: Position,
+        output_pos: (i32, i32),
         size: (i32, i32),
     ) -> Window {
         log::debug!("creating window output: {output:?}, size: {size:?}");
@@ -208,6 +216,8 @@ impl Window {
             buffer,
             surface,
             layer_surface,
+            output_pos,
+            output_size: size,
         }
     }
 }
@@ -221,6 +231,22 @@ impl Drop for Window {
     }
 }
 
+/// Translate `wl_pointer.enter` surface-local coords into the host's
+/// compositor coordinate space, using the layer-surface's anchor edge
+/// and the output it's attached to. Layer surfaces here are 1 px on
+/// the on-axis dimension and span the cross-axis, so the surface-local
+/// cross-axis coord is the screen offset directly.
+fn surface_to_screen(window: &Window, surface_x: f64, surface_y: f64) -> (i32, i32) {
+    let (ox, oy) = window.output_pos;
+    let (ow, oh) = window.output_size;
+    match window.pos {
+        Position::Left => (ox, oy + surface_y as i32),
+        Position::Right => (ox + ow.saturating_sub(1), oy + surface_y as i32),
+        Position::Top => (ox + surface_x as i32, oy),
+        Position::Bottom => (ox + surface_x as i32, oy + oh.saturating_sub(1)),
+    }
+}
+
 fn get_edges(outputs: &[Output], pos: Position) -> Vec<(Output, i32)> {
     outputs
         .iter()
@@ -525,7 +551,8 @@ impl State {
         );
         outputs.iter().for_each(|o| {
             if let Some(info) = o.info.as_ref() {
-                let window = Window::new(self, &self.qh, &o.wl_output, pos, info.size);
+                let window =
+                    Window::new(self, &self.qh, &o.wl_output, pos, info.position, info.size);
                 let window = Arc::new(window);
                 self.active_windows.push(window);
             }
@@ -628,7 +655,7 @@ impl Capture for LayerShellInputCapture {
         Ok(inner.flush_events()?)
     }
 
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    async fn release(&mut self, _warp_target: Option<(i32, i32)>) -> Result<(), CaptureError> {
         log::debug!("releasing pointer");
         let inner = self.0.get_mut();
         inner.state.ungrab();
@@ -638,6 +665,28 @@ impl Capture for LayerShellInputCapture {
     async fn terminate(&mut self) -> Result<(), CaptureError> {
         Ok(())
     }
+
+    fn display_bounds(&self) -> Option<(u32, u32)> {
+        // Union of every active output's rectangle in compositor
+        // coords. Mirrors the macOS impl so MotionAbsolute scaling
+        // stays consistent: cursor coords reported in this same
+        // space normalize cleanly against the returned dimensions.
+        let outputs = &self.0.get_ref().state.outputs;
+        let mut xmin = i32::MAX;
+        let mut ymin = i32::MAX;
+        let mut xmax = i32::MIN;
+        let mut ymax = i32::MIN;
+        for info in outputs.iter().filter_map(|o| o.info.as_ref()) {
+            xmin = xmin.min(info.position.0);
+            ymin = ymin.min(info.position.1);
+            xmax = xmax.max(info.position.0 + info.size.0);
+            ymax = ymax.max(info.position.1 + info.size.1);
+        }
+        if xmax <= xmin || ymax <= ymin {
+            return None;
+        }
+        Some(((xmax - xmin) as u32, (ymax - ymin) as u32))
+    }
 }
 
 impl Stream for LayerShellInputCapture {
@@ -735,25 +784,26 @@ impl Dispatch<WlPointer, ()> for State {
             wl_pointer::Event::Enter {
                 serial,
                 surface,
-                surface_x: _,
-                surface_y: _,
+                surface_x,
+                surface_y,
             } => {
-                // get client corresponding to the focused surface
-                {
-                    if let Some(window) = app.active_windows.iter().find(|w| w.surface == surface) {
-                        app.focused = Some(window.clone());
-                        app.grab(&surface, pointer, serial, qh);
-                    } else {
-                        return;
-                    }
-                }
-                let pos = app
+                let Some(window) = app
                     .active_windows
                     .iter()
                     .find(|w| w.surface == surface)
-                    .map(|w| w.pos)
-                    .unwrap();
-                app.pending_events.push_back((pos, CaptureEvent::Begin));
+                    .cloned()
+                else {
+                    return;
+                };
+                app.focused = Some(window.clone());
+                app.grab(&surface, pointer, serial, qh);
+                let cursor = surface_to_screen(&window, surface_x, surface_y);
+                app.pending_events.push_back((
+                    window.pos,
+                    CaptureEvent::Begin {
+                        cursor: Some(cursor),
+                    },
+                ));
             }
             wl_pointer::Event::Leave { .. } => {
                 /* There are rare cases, where when a window is opened in
diff --git a/input-capture/src/lib.rs b/input-capture/src/lib.rs
index b1ef6c0b..ec47e4b0 100644
--- a/input-capture/src/lib.rs
+++ b/input-capture/src/lib.rs
@@ -1,19 +1,27 @@
 use std::{
     collections::{HashMap, HashSet, VecDeque},
     fmt::Display,
+    future::Future,
     mem::swap,
+    pin::Pin,
     task::{Poll, ready},
+    time::Duration,
 };
 
 use async_trait::async_trait;
 use futures::StreamExt;
 use futures_core::Stream;
+use tokio::time::Sleep;
 
-use input_event::{Event, KeyboardEvent, scancode};
+use input_event::{Event, KeyboardEvent, PointerEvent, scancode};
 
 pub use error::{CaptureCreationError, CaptureError, InputCaptureError};
 
+pub mod clipboard;
+#[cfg(all(unix, not(target_os = "macos")))]
+pub mod desktop_entries;
 pub mod error;
+pub mod frontmost_app;
 
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 mod libei;
@@ -35,19 +43,37 @@ mod dummy;
 
 pub type CaptureHandle = u64;
 
-#[derive(Copy, Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum CaptureEvent {
-    /// capture on this capture handle is now active
-    Begin,
+    /// Capture on this handle is now active. `cursor`, when present,
+    /// is the host's screen-space cursor position (in pixels) at the
+    /// instant of the edge crossing — the capture loop normalizes it
+    /// against the host's display bounds and forwards it to the peer
+    /// as a [`ProtoEvent::CursorPos`] so the guest's cursor lands at
+    /// the visually-corresponding point on its own screen. Backends
+    /// that can't report cursor position emit `None`; the peer's
+    /// cursor stays where it was on remote-takeover (no forced
+    /// midpoint warp — that masquerades as a mid-screen crossing on
+    /// fast re-crosses).
+    Begin { cursor: Option<(i32, i32)> },
     /// input event coming from capture handle
     Input(Event),
+    /// the capture wrapper detected sustained back-toward-host motion
+    /// past the configured threshold (the user has pinned the cursor
+    /// at the host-adjacent edge of the guest and kept pushing). The
+    /// capture loop should treat this like a release-bind chord.
+    AutoRelease,
 }
 
 impl Display for CaptureEvent {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            CaptureEvent::Begin => write!(f, "begin capture"),
+            CaptureEvent::Begin { cursor: None } => write!(f, "begin capture"),
+            CaptureEvent::Begin {
+                cursor: Some((x, y)),
+            } => write!(f, "begin capture @ ({x}, {y})"),
             CaptureEvent::Input(e) => write!(f, "{e}"),
+            CaptureEvent::AutoRelease => write!(f, "auto-release"),
         }
     }
 }
@@ -127,6 +153,98 @@ pub struct InputCapture {
     id_map: HashMap<CaptureHandle, Position>,
     /// pending events
     pending: VecDeque<(CaptureHandle, CaptureEvent)>,
+    /// pixel threshold for the cross-platform auto-release-on-wall-
+    /// press fallback. 0 disables. See `track_wall_press`.
+    release_threshold_px: u32,
+    /// position the cursor is currently captured into, if any. Tracks
+    /// `Begin`/release transitions so the wall-press accumulator
+    /// resets correctly across capture sessions.
+    capture_pos: Option<Position>,
+    /// Modeled cursor position on the guest along the entry axis,
+    /// relative to the host-adjacent edge. 0 = at the entry edge,
+    /// growing values = further into the guest. Clamped at 0 from
+    /// below; clamped at the cached peer extent from above when
+    /// available, otherwise unbounded (degraded fallback).
+    virtual_pos: f64,
+    /// Pixels of back-toward-host motion that the modeled cursor
+    /// could not absorb (proposed virtual_pos < 0). Resets whenever
+    /// the cursor is back in the interior or moving deeper.
+    wall_pressure: f64,
+    /// Modeled guest cursor position in the guest's screen space,
+    /// updated by accumulating Motion deltas while captured. Seeded
+    /// on `Begin` from the cross-axis warp target (if peer bounds
+    /// are known) or the entry-edge midpoint otherwise — i.e. wherever
+    /// the guest's cursor visually lands at Enter. Read on release
+    /// to compute a host-side warp so the local cursor reappears at
+    /// the matching point on the host's screen instead of jumping
+    /// back to where capture started.
+    virtual_cursor: Option<(f64, f64)>,
+    /// Host-coord cursor at the moment of `Begin`, retained until
+    /// `peer_bounds` arrives so we can retroactively seed
+    /// `virtual_cursor` once the round-trip completes. Without this,
+    /// a `Begin` that fires before the peer's `Bounds` reply leaves
+    /// `virtual_cursor` stuck at `None` for the rest of the session
+    /// — the wall-press accumulator skips updates and the
+    /// release-time warp falls back to the original crossing
+    /// y-value instead of where the cursor visually was on the peer.
+    pending_begin_cursor: Option<(i32, i32)>,
+    /// Motion deltas that arrived while `virtual_cursor` was still
+    /// `None` (between `Begin` and the late-arriving
+    /// `set_peer_bounds`). Drained into the freshly-seeded
+    /// `virtual_cursor` when the bootstrap completes so deltas
+    /// during the round-trip aren't lost.
+    pending_motion: (f64, f64),
+    /// Per-position cache of peer display geometry. Populated when
+    /// the peer responds with a `ProtoEvent::Bounds` event after
+    /// Ack. Used as the upper clamp for `virtual_pos` so that
+    /// pushing past the guest's actual far edge doesn't make the
+    /// model run away. Only the entry-axis dimension is consulted.
+    peer_bounds: HashMap<Position, (u32, u32)>,
+    /// Per-position cached sensitivity multiplier the receiver
+    /// applies to forwarded motion deltas before injection. Sent
+    /// by the receiving peer via [`ProtoEvent::ReceiverSensitivity`]
+    /// after Ack-on-Enter. The host's wall-press auto-release model
+    /// scales each delta by this value so its model of "where the
+    /// receiver's cursor would be" stays in sync with the receiver's
+    /// actual cursor — without it, a sub-1.0 multiplier would let
+    /// `wall_pressure` accumulate faster than reality and trigger
+    /// AutoRelease before the receiver hit the wall. Default is
+    /// 1.0; old peers that don't send this event leave the entry
+    /// unset, matching the previous behavior.
+    peer_sensitivity: HashMap<Position, f64>,
+    /// True when wall_pressure has crossed `release_threshold_px` and
+    /// `wall_press_timer` has been armed but not yet either elapsed
+    /// or been cancelled. Cleared when the peer's handover Leave
+    /// arrives (which routes through `release_no_host_warp` →
+    /// `reset_wall_press_state`) or when the cursor moves back into
+    /// the interior. The wall-press auto-release fires only after
+    /// `wall_press_deadline` elapses without this being cleared —
+    /// turning the historically race-y "wall-press vs peer-Leave"
+    /// into an explicit fallback that only kicks in when the peer
+    /// can't deliver a Leave (lock screen, restricted DE, dead peer).
+    wall_press_pending: bool,
+    /// Window after the threshold is crossed during which a peer
+    /// Leave can cancel the deferred AutoRelease. Sized so a
+    /// healthy LAN round-trip beats it comfortably.
+    wall_press_deadline: Duration,
+    /// Timer driving the deferred fire. Reset to deadline-from-now
+    /// on first threshold crossing; polled in `poll_next` so the
+    /// fire happens even when no further backend events arrive
+    /// (the user pinned the cursor against the wall and stopped).
+    wall_press_timer: Pin<Box<Sleep>>,
+}
+
+/// Project a motion delta onto the entry axis. Positive return =
+/// "into guest", so virtual_pos increases as the user pushes deeper.
+fn entry_axis_delta(position: Position, dx: f64, dy: f64) -> f64 {
+    match position {
+        // Position::Left = guest is to the LEFT of host. User entered
+        // by moving left (-dx). Convention: positive = into guest.
+        Position::Left => -dx,
+        Position::Right => dx,
+        Position::Top => -dy,
+        Position::Bottom => dy,
+    }
 }
 
 impl InputCapture {
@@ -167,8 +285,433 @@ impl InputCapture {
 
     /// release mouse
     pub async fn release(&mut self) -> Result<(), CaptureError> {
+        // Compute the host-side warp target before resetting the
+        // wall-press / virtual_cursor state — once those are cleared
+        // we lose the data needed to figure out where the guest's
+        // cursor visually was.
+        let warp_target = self
+            .capture_pos
+            .and_then(|pos| self.host_warp_target_on_release(pos));
+        log::info!(
+            "[release-warp] capture_pos={:?} virtual_cursor={:?} peer_bounds={:?} display_bounds={:?} → warp_target={warp_target:?}",
+            self.capture_pos,
+            self.virtual_cursor,
+            self.capture_pos
+                .and_then(|p| self.peer_bounds.get(&p).copied()),
+            self.capture.display_bounds(),
+        );
+        self.pressed_keys.clear();
+        self.reset_wall_press_state();
+        self.capture.release(warp_target).await
+    }
+
+    /// Release without applying a host-side cursor warp. Used when
+    /// the remote peer is taking over (it just sent us Enter +
+    /// CursorPos): the proportional warp from CursorPos is the
+    /// authoritative final position for our shared cursor, and the
+    /// stale `virtual_cursor`-derived warp would race against it
+    /// and frequently win — clobbering the proportional landing
+    /// with whatever position Linux *thought* the peer's cursor was
+    /// at before the user moved it.
+    pub async fn release_no_host_warp(&mut self) -> Result<(), CaptureError> {
+        log::info!(
+            "[release-warp] handover release: capture_pos={:?} — skipping host warp, peer's CursorPos is authoritative",
+            self.capture_pos,
+        );
         self.pressed_keys.clear();
-        self.capture.release().await
+        self.reset_wall_press_state();
+        self.capture.release(None).await
+    }
+
+    /// Configure the wall-press auto-release pixel threshold.
+    /// 0 disables. Effective immediately for the next motion event;
+    /// no need to recreate the backend.
+    pub fn set_release_threshold(&mut self, threshold: u32) {
+        self.release_threshold_px = threshold;
+    }
+
+    /// Cache the peer's display geometry for a position. Used by
+    /// the wall-press tracker as the upper bound for `virtual_pos`
+    /// so the model can't run away when the user pushes past the
+    /// peer's actual far edge.
+    ///
+    /// If `Begin` fired before this arrived (the round-trip
+    /// bootstrap case — `Bounds` is sent in response to `Enter`,
+    /// which is sent by the host AFTER `Begin` fires), seed
+    /// `virtual_cursor` retroactively so the wall-press / release
+    /// machinery has a baseline to track from. Drains any motion
+    /// that piled up in `pending_motion` so deltas during the
+    /// round-trip aren't lost.
+    pub fn set_peer_bounds(&mut self, pos: Position, width: u32, height: u32) {
+        log::debug!("peer at {pos} reports bounds {width}x{height}");
+        self.peer_bounds.insert(pos, (width, height));
+
+        if self.virtual_cursor.is_none()
+            && self.capture_pos == Some(pos)
+            && self.pending_begin_cursor.is_some()
+        {
+            let begin_cursor = self.pending_begin_cursor;
+            let seeded = self.initial_virtual_cursor(pos, begin_cursor);
+            if let Some((sx, sy)) = seeded {
+                let (mx, my) = self.pending_motion;
+                let peer_w = width as f64;
+                let peer_h = height as f64;
+                self.virtual_cursor =
+                    Some(((sx + mx).clamp(0.0, peer_w), (sy + my).clamp(0.0, peer_h)));
+                self.pending_motion = (0.0, 0.0);
+                log::info!(
+                    "[bootstrap] seeded virtual_cursor={:?} after late peer_bounds at {pos} (drained pending_motion=({mx:.1}, {my:.1}))",
+                    self.virtual_cursor
+                );
+            }
+        }
+    }
+
+    /// Forget the cached peer geometry for a position. Called when
+    /// the corresponding capture is destroyed so re-adding the same
+    /// peer later (potentially with new geometry) starts fresh.
+    pub fn clear_peer_bounds(&mut self, pos: Position) {
+        self.peer_bounds.remove(&pos);
+    }
+
+    /// Cache the receiver's per-pair motion-sensitivity multiplier
+    /// for the given position. Used to scale the wall-press
+    /// auto-release model's accumulator so it tracks the receiver's
+    /// actual cursor advance instead of the raw deltas the host
+    /// emits. Out-of-range / non-finite values are ignored to keep
+    /// the model from diverging on a rogue peer.
+    pub fn set_peer_sensitivity(&mut self, pos: Position, mouse_sensitivity: f64) {
+        if !mouse_sensitivity.is_finite() || mouse_sensitivity <= 0.0 {
+            log::warn!(
+                "ignoring non-finite/non-positive peer sensitivity {mouse_sensitivity} for {pos}"
+            );
+            return;
+        }
+        log::debug!("peer at {pos} reports sensitivity {mouse_sensitivity:.3}");
+        self.peer_sensitivity.insert(pos, mouse_sensitivity);
+    }
+
+    /// Drop the cached receiver sensitivity for a position. Mirrors
+    /// `clear_peer_bounds` — called on capture destroy so a re-add
+    /// starts at the 1.0 default until a fresh
+    /// [`ProtoEvent::ReceiverSensitivity`] arrives.
+    pub fn clear_peer_sensitivity(&mut self, pos: Position) {
+        self.peer_sensitivity.remove(&pos);
+    }
+
+    /// Host's own display geometry — width and height in pixels of
+    /// the union of all displays. Returns `None` when the active
+    /// backend can't query its own bounds (e.g. xdg-desktop-portal,
+    /// dummy). Used by `host_normalized_cursor` to compute the
+    /// [`ProtoEvent::CursorPos`] fraction the guest scales against
+    /// its own bounds on Enter.
+    pub fn display_bounds(&self) -> Option<(u32, u32)> {
+        self.capture.display_bounds()
+    }
+
+    /// Top-left corner of the host's display union in pointer-event
+    /// coordinate space. See `Capture::display_origin` for why this
+    /// matters on multi-monitor macOS hosts.
+    fn display_origin(&self) -> (i32, i32) {
+        self.capture.display_origin()
+    }
+
+    /// Host's screen-space cursor position normalized to the host's
+    /// own display bounds (each axis in 0..1, clamped). Returns
+    /// `None` when the active backend can't report its own bounds.
+    /// Used for the self-sufficient `ProtoEvent::CursorPos` event
+    /// (the receiver scales the normalized fraction against its
+    /// own bounds and pins the entry axis to the matching edge), so
+    /// the first crossing isn't blocked by the bootstrap problem
+    /// `peer_warp_target` has — that variant requires a prior
+    /// `Bounds` round-trip from the peer, which can't have happened
+    /// yet on the very first Enter.
+    pub fn host_normalized_cursor(&self, cursor: (i32, i32)) -> Option<(f32, f32)> {
+        let (host_w, host_h) = self.display_bounds()?;
+        if host_w == 0 || host_h == 0 {
+            return None;
+        }
+        let (origin_x, origin_y) = self.display_origin();
+        let (cx, cy) = cursor;
+        // Subtract the union origin before normalizing so that
+        // points on a non-origin display (e.g. a macOS external
+        // monitor positioned to the left of the primary, where
+        // cursor x is negative) map correctly. Without this, the
+        // clamp masks every off-primary point as the screen edge.
+        let nx = ((cx - origin_x) as f32 / host_w as f32).clamp(0.0, 1.0);
+        let ny = ((cy - origin_y) as f32 / host_h as f32).clamp(0.0, 1.0);
+        Some((nx, ny))
+    }
+
+    /// Cursor warp target on the peer for a transition at `pos`,
+    /// given the host's screen-space cursor position at the moment
+    /// of crossing. Returns `None` when either the host's own
+    /// `display_bounds` or the cached peer geometry is unavailable —
+    /// in that case there's no warp target to compute and the peer's
+    /// cursor stays wherever the most recent `CursorPos` (or, if none
+    /// arrived this session, where it was) put it.
+    ///
+    /// Coordinates returned are pixels in the peer's screen space:
+    /// the cross-axis is preserved as a normalized fraction of the
+    /// host screen (so a host_y near the top maps to a peer_y near
+    /// the top regardless of resolution mismatch), the on-axis is
+    /// pinned to the peer's far edge for the entering side.
+    pub fn peer_warp_target(&self, pos: Position, cursor: (i32, i32)) -> Option<(i32, i32)> {
+        let (host_w, host_h) = self.display_bounds()?;
+        let &(peer_w, peer_h) = self.peer_bounds.get(&pos)?;
+        let (origin_x, origin_y) = self.display_origin();
+        let (cx, cy) = cursor;
+        // Subtract the union origin before normalizing — same
+        // rationale as in host_normalized_cursor.
+        let nx = ((cx - origin_x) as f64 / host_w as f64).clamp(0.0, 1.0);
+        let ny = ((cy - origin_y) as f64 / host_h as f64).clamp(0.0, 1.0);
+        let peer_w_i = peer_w as i32;
+        let peer_h_i = peer_h as i32;
+        let target = match pos {
+            // Peer to our Left → cursor exits on left, enters peer on right
+            Position::Left => (peer_w_i.saturating_sub(1), (ny * peer_h as f64) as i32),
+            // Peer to our Right → cursor enters peer on left
+            Position::Right => (0, (ny * peer_h as f64) as i32),
+            // Peer above → cursor enters peer on bottom
+            Position::Top => ((nx * peer_w as f64) as i32, peer_h_i.saturating_sub(1)),
+            // Peer below → cursor enters peer on top
+            Position::Bottom => ((nx * peer_w as f64) as i32, 0),
+        };
+        Some(target)
+    }
+
+    /// Returns the upper-clamp value (along the entry axis) for the
+    /// given position, or `f64::INFINITY` if the peer hasn't reported
+    /// bounds yet.
+    fn peer_extent(&self, pos: Position) -> f64 {
+        let Some(&(w, h)) = self.peer_bounds.get(&pos) else {
+            return f64::INFINITY;
+        };
+        match pos {
+            Position::Left | Position::Right => f64::from(w),
+            Position::Top | Position::Bottom => f64::from(h),
+        }
+    }
+
+    fn reset_wall_press_state(&mut self) {
+        self.capture_pos = None;
+        self.virtual_pos = 0.0;
+        self.wall_pressure = 0.0;
+        self.virtual_cursor = None;
+        self.pending_begin_cursor = None;
+        self.pending_motion = (0.0, 0.0);
+        // Cancel any deferred AutoRelease — release() / handover have
+        // taken responsibility for the transition.
+        self.wall_press_pending = false;
+    }
+
+    /// Initial guest-space cursor position for a freshly-started
+    /// capture. Mirrors what the guest's emulation will visibly do on
+    /// the corresponding `Enter`: the `CursorPos` proportional warp
+    /// target if the host can compute one (capture backend reports
+    /// cursor), otherwise the entry-edge midpoint as a fallback for
+    /// the wall-press model's starting position.
+    fn initial_virtual_cursor(
+        &self,
+        pos: Position,
+        host_cursor: Option<(i32, i32)>,
+    ) -> Option<(f64, f64)> {
+        if let Some(host_cursor) = host_cursor {
+            if let Some((x, y)) = self.peer_warp_target(pos, host_cursor) {
+                return Some((x as f64, y as f64));
+            }
+        }
+        let &(peer_w, peer_h) = self.peer_bounds.get(&pos)?;
+        let pw = peer_w as f64;
+        let ph = peer_h as f64;
+        Some(match pos {
+            Position::Left => (0.0, ph / 2.0),
+            Position::Right => ((pw - 1.0).max(0.0), ph / 2.0),
+            Position::Top => (pw / 2.0, 0.0),
+            Position::Bottom => (pw / 2.0, (ph - 1.0).max(0.0)),
+        })
+    }
+
+    /// Where on the host's own screen the cursor should land when
+    /// capture is released, given the modeled guest cursor position
+    /// at the moment of release. Symmetric inverse of
+    /// `peer_warp_target`: cross-axis is preserved as a normalized
+    /// fraction of the peer's screen, on-axis is pinned to the
+    /// host's far edge for the side the guest is on so the cursor
+    /// reappears at the boundary it just crossed back through.
+    fn host_warp_target_on_release(&self, pos: Position) -> Option<(i32, i32)> {
+        let (gx, gy) = self.virtual_cursor?;
+        let &(peer_w, peer_h) = self.peer_bounds.get(&pos)?;
+        let (host_w, host_h) = self.capture.display_bounds()?;
+        if peer_w == 0 || peer_h == 0 || host_w == 0 || host_h == 0 {
+            return None;
+        }
+        let (origin_x, origin_y) = self.display_origin();
+        let nx = (gx / peer_w as f64).clamp(0.0, 1.0);
+        let ny = (gy / peer_h as f64).clamp(0.0, 1.0);
+        let host_w_i = host_w as i32;
+        let host_h_i = host_h as i32;
+        // Add the union origin back so the result is in pointer-event
+        // coordinate space (which is what `CGDisplay::warp_mouse_cursor_position`
+        // and friends consume), not "0..host_w" of the union rectangle.
+        // Matters on macOS hosts whose primary isn't anchored at (0, 0)
+        // — `display_bounds` returns just the size of the union, so the
+        // origin needs to be reapplied to recover absolute coords.
+        Some(match pos {
+            // Peer to our Left → cursor returns through host's left edge
+            Position::Left => (origin_x, origin_y + (ny * host_h as f64) as i32),
+            // Peer to our Right → cursor returns through host's right edge
+            Position::Right => (
+                origin_x + host_w_i.saturating_sub(1),
+                origin_y + (ny * host_h as f64) as i32,
+            ),
+            // Peer above → cursor returns through host's top edge
+            Position::Top => (origin_x + (nx * host_w as f64) as i32, origin_y),
+            // Peer below → cursor returns through host's bottom edge
+            Position::Bottom => (
+                origin_x + (nx * host_w as f64) as i32,
+                origin_y + host_h_i.saturating_sub(1),
+            ),
+        })
+    }
+
+    /// Update the wall-press accumulator from one event coming up
+    /// from the backend. Sets `wall_press_pending` (and arms the
+    /// timer) when the threshold is first crossed; the actual
+    /// `AutoRelease` synthesis happens in `poll_next` once the
+    /// deadline elapses without a peer Leave clearing the flag.
+    fn track_wall_press(&mut self, pos: Position, event: &CaptureEvent) {
+        match event {
+            CaptureEvent::Begin { cursor } => {
+                self.capture_pos = Some(pos);
+                self.virtual_pos = 0.0;
+                self.wall_pressure = 0.0;
+                self.virtual_cursor = self.initial_virtual_cursor(pos, *cursor);
+                // Stash the host-coord cursor so set_peer_bounds can
+                // retroactively seed virtual_cursor if peer_bounds
+                // arrives after Begin.
+                self.pending_begin_cursor = *cursor;
+                self.pending_motion = (0.0, 0.0);
+                log::info!(
+                    "[wp-begin] pos={pos} cursor={cursor:?} peer_bounds={:?} virtual_cursor={:?}",
+                    self.peer_bounds.get(&pos).copied(),
+                    self.virtual_cursor,
+                );
+            }
+            CaptureEvent::AutoRelease => {
+                // Don't reset virtual_cursor here — release() needs it
+                // to compute the host-side warp target. The wrapper's
+                // release() resets state after consuming it.
+            }
+            CaptureEvent::Input(Event::Pointer(PointerEvent::Motion { dx, dy, .. })) => {
+                let Some(active_pos) = self.capture_pos else {
+                    return;
+                };
+                if active_pos != pos {
+                    return;
+                }
+
+                // Track guest-space cursor for the on-release warp
+                // back to the host. Clamped to the peer's bounds so
+                // the model doesn't drift past the guest's screen
+                // when the user pushes obliviously.
+                match (
+                    self.virtual_cursor.as_mut(),
+                    self.peer_bounds.get(&active_pos),
+                ) {
+                    (Some(vc), Some(&(peer_w, peer_h))) => {
+                        vc.0 = (vc.0 + *dx).clamp(0.0, peer_w as f64);
+                        vc.1 = (vc.1 + *dy).clamp(0.0, peer_h as f64);
+                    }
+                    // virtual_cursor not yet seeded (peer_bounds was
+                    // None at Begin time and the round-trip hasn't
+                    // completed yet). Buffer the deltas so they can
+                    // be applied retroactively in set_peer_bounds
+                    // once the bootstrap finishes — otherwise the
+                    // motion that happened during the round-trip is
+                    // silently lost and the release-time warp picks
+                    // the wrong y.
+                    (None, _) => {
+                        self.pending_motion.0 += *dx;
+                        self.pending_motion.1 += *dy;
+                        log::debug!(
+                            "[wp-motion] deferred dx={dx:.1} dy={dy:.1} (peer_bounds for {active_pos}: {:?})",
+                            self.peer_bounds.get(&active_pos).copied(),
+                        );
+                    }
+                    _ => {}
+                }
+
+                if self.release_threshold_px == 0 {
+                    return;
+                }
+
+                // Scale the entry-axis delta by the receiver's
+                // sensitivity for this position so the model tracks
+                // the receiver's actual cursor advance, not the raw
+                // delta the host wire-emits. Defaults to 1.0 when
+                // the peer hasn't sent a `ReceiverSensitivity` yet
+                // (older builds, pre-Ack window).
+                let raw_delta = entry_axis_delta(active_pos, *dx, *dy);
+                let sensitivity = self
+                    .peer_sensitivity
+                    .get(&active_pos)
+                    .copied()
+                    .unwrap_or(1.0);
+                let delta = raw_delta * sensitivity;
+                let proposed = self.virtual_pos + delta;
+                let upper = self.peer_extent(active_pos);
+                // Clamp at 0 from below (host-adjacent edge — wall
+                // pressure accumulates here) and at the peer's
+                // entry-axis extent from above when known. The upper
+                // clamp prevents the model from running away if the
+                // user obliviously pushes their physical mouse past
+                // the guest's actual far edge. When the peer hasn't
+                // reported bounds yet (older peer, or pre-Ack
+                // window), `upper` is INFINITY and we fall back to
+                // the heuristic behavior.
+                self.virtual_pos = proposed.clamp(0.0, upper);
+
+                if proposed < 0.0 {
+                    // Motion overshot the host-adjacent edge —
+                    // accumulate the unabsorbed amount as wall
+                    // pressure.
+                    self.wall_pressure += -proposed;
+                } else {
+                    // Cursor moved into the interior or further in;
+                    // reset so a brief bump against the wall followed
+                    // by motion deeper into the guest doesn't combine
+                    // with a later wall-press to fire spuriously.
+                    self.wall_pressure = 0.0;
+                    if std::mem::take(&mut self.wall_press_pending) {
+                        log::info!(
+                            "wall-press deferred AutoRelease cancelled (cursor moved away from entry edge)"
+                        );
+                    }
+                }
+
+                if self.wall_pressure >= f64::from(self.release_threshold_px)
+                    && !self.wall_press_pending
+                {
+                    self.wall_press_pending = true;
+                    self.wall_press_timer
+                        .as_mut()
+                        .reset(tokio::time::Instant::now() + self.wall_press_deadline);
+                    log::info!(
+                        "wall-press threshold reached ({:.0}px past entry edge, {}px threshold) — \
+                         deferring AutoRelease for {}ms pending peer Leave",
+                        self.wall_pressure,
+                        self.release_threshold_px,
+                        self.wall_press_deadline.as_millis(),
+                    );
+                }
+                // Fire is now driven by the timer in `poll_next`, not
+                // directly from this event — keeps the behavior gated
+                // on "peer didn't claim handover in time" instead of
+                // racing the peer's Leave.
+            }
+            _ => {}
+        }
     }
 
     /// Drain and return every key the capture has forwarded as
@@ -198,6 +741,18 @@ impl InputCapture {
             pending: Default::default(),
             position_map: Default::default(),
             pressed_keys: HashSet::new(),
+            release_threshold_px: 0,
+            capture_pos: None,
+            virtual_pos: 0.0,
+            wall_pressure: 0.0,
+            virtual_cursor: None,
+            pending_begin_cursor: None,
+            pending_motion: (0.0, 0.0),
+            peer_bounds: HashMap::new(),
+            peer_sensitivity: HashMap::new(),
+            wall_press_pending: false,
+            wall_press_deadline: Duration::from_millis(150),
+            wall_press_timer: Box::pin(tokio::time::sleep(Duration::from_secs(0))),
         })
     }
 
@@ -228,6 +783,33 @@ impl Stream for InputCapture {
             return Poll::Ready(Some(Ok(e)));
         }
 
+        // Deferred wall-press fallback. If the threshold was crossed
+        // and the deadline elapsed without a peer Leave clearing
+        // `wall_press_pending` (release_no_host_warp →
+        // reset_wall_press_state), synthesize AutoRelease for every
+        // capture handle at the active position. Polled before the
+        // backend so a fire still happens when the user pinned the
+        // cursor against the wall and stopped moving (no further
+        // backend events, but the deadline still has to elapse).
+        if self.wall_press_pending && self.wall_press_timer.as_mut().poll(cx).is_ready() {
+            self.wall_press_pending = false;
+            log::info!(
+                "wall-press deadline elapsed ({}ms) — firing AutoRelease (no peer Leave; \
+                 assuming peer-side capture is unavailable, e.g. lock screen)",
+                self.wall_press_deadline.as_millis(),
+            );
+            if let Some(pos) = self.capture_pos {
+                if let Some(ids) = self.position_map.get(&pos).cloned() {
+                    for id in ids {
+                        self.pending.push_back((id, CaptureEvent::AutoRelease));
+                    }
+                }
+            }
+            if let Some(e) = self.pending.pop_front() {
+                return Poll::Ready(Some(Ok(e)));
+            }
+        }
+
         // ready
         let event = ready!(self.capture.poll_next_unpin(cx));
 
@@ -244,10 +826,18 @@ impl Stream for InputCapture {
         };
 
         // handle key presses
-        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })) = event {
-            self.update_pressed_keys(key, state);
+        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })) = &event
+        {
+            self.update_pressed_keys(*key, *state);
         }
 
+        // wall-press auto-release tracking. Runs against every event
+        // before routing so a single global accumulator stays consistent
+        // regardless of how many handles exist at this position. The
+        // fire itself is deferred and driven by `wall_press_timer`
+        // above so the peer's Leave can cancel it.
+        self.track_wall_press(pos, &event);
+
         let len = self
             .position_map
             .get(&pos)
@@ -256,16 +846,16 @@ impl Stream for InputCapture {
 
         match len {
             0 => Poll::Pending,
-            1 => Poll::Ready(Some(Ok((
-                self.position_map.get(&pos).expect("no id")[0],
-                event,
-            )))),
+            1 => {
+                let id = self.position_map.get(&pos).expect("no id")[0];
+                Poll::Ready(Some(Ok((id, event))))
+            }
             _ => {
                 let mut position_map = HashMap::new();
                 swap(&mut self.position_map, &mut position_map);
                 {
                     for &id in position_map.get(&pos).expect("position") {
-                        self.pending.push_back((id, event));
+                        self.pending.push_back((id, event.clone()));
                     }
                 }
                 swap(&mut self.position_map, &mut position_map);
@@ -284,11 +874,39 @@ trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + U
     /// destroy the client with the given id, if it exists
     async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError>;
 
-    /// release mouse
-    async fn release(&mut self) -> Result<(), CaptureError>;
+    /// release mouse. `warp_target`, when present, is a screen-space
+    /// pixel point on the host's own display where the local cursor
+    /// should be placed before becoming visible again — used to
+    /// preserve cross-axis continuity when capture ends so the cursor
+    /// reappears next to where it visually was on the guest, not at
+    /// the spot where capture started. Backends that don't hide the
+    /// system cursor or can't warp it can ignore the parameter.
+    async fn release(&mut self, warp_target: Option<(i32, i32)>) -> Result<(), CaptureError>;
 
     /// destroy the input capture
     async fn terminate(&mut self) -> Result<(), CaptureError>;
+
+    /// Host's own display geometry. Default implementation returns
+    /// `None`; backends that can query their own dimensions override
+    /// (currently macOS via CGDisplay; others may add this later).
+    fn display_bounds(&self) -> Option<(u32, u32)> {
+        None
+    }
+
+    /// Top-left corner of the union of all displays in the host's
+    /// global pointer-coordinate system. Defaults to (0, 0) — fine
+    /// for any backend whose primary display is the origin (Windows,
+    /// most X11/Wayland setups). Returns the actual `(xmin, ymin)`
+    /// on macOS, where the global coordinate system is anchored at
+    /// the primary's top-left and a left-attached external display
+    /// occupies negative x. Used by `host_normalized_cursor` and
+    /// `peer_warp_target` to correctly normalize cursor positions
+    /// outside the primary display — without this, the
+    /// `clamp(0.0, 1.0)` in those helpers silently maps every point
+    /// on a non-origin display to the screen edge.
+    fn display_origin(&self) -> (i32, i32) {
+        (0, 0)
+    }
 }
 
 async fn create_backend(
diff --git a/input-capture/src/libei.rs b/input-capture/src/libei.rs
index fa168957..15b39384 100644
--- a/input-capture/src/libei.rs
+++ b/input-capture/src/libei.rs
@@ -417,7 +417,10 @@ async fn do_capture_session(
                     current_pos.replace(Some(pos));
 
                     // client entered => send event
-                    event_tx.send((pos, CaptureEvent::Begin)).await.expect("no channel");
+                    event_tx
+                        .send((pos, CaptureEvent::Begin { cursor: None }))
+                        .await
+                        .expect("no channel");
 
                     tokio::select! {
                         _ = notify_release.notified() => { /* capture release */
@@ -589,7 +592,7 @@ impl LanMouseInputCapture for LibeiInputCapture {
         Ok(())
     }
 
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    async fn release(&mut self, _warp_target: Option<(i32, i32)>) -> Result<(), CaptureError> {
         self.notify_release.notify_waiters();
         Ok(())
     }
diff --git a/input-capture/src/macos.rs b/input-capture/src/macos.rs
index dc941b28..97df0da7 100644
--- a/input-capture/src/macos.rs
+++ b/input-capture/src/macos.rs
@@ -5,11 +5,11 @@ use core_foundation::{
     base::{CFRelease, TCFType, kCFAllocatorDefault},
     date::CFTimeInterval,
     number::{CFBooleanRef, kCFBooleanTrue},
-    runloop::{CFRunLoop, CFRunLoopSource, kCFRunLoopCommonModes},
+    runloop::{CFRunLoop, CFRunLoopSource, CFRunLoopSourceRef, kCFRunLoopCommonModes},
     string::{CFStringCreateWithCString, CFStringRef, kCFStringEncodingUTF8},
 };
 use core_graphics::{
-    base::{CGError, kCGErrorSuccess},
+    base::{CGError, CGFloat, kCGErrorSuccess},
     display::{CGDisplay, CGPoint},
     event::{
         CGEvent, CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions,
@@ -62,7 +62,14 @@ struct InputCaptureState {
 
 #[derive(Debug)]
 enum ProducerEvent {
-    Release,
+    /// `warp_target`, when present, is a screen-space (Quartz) point
+    /// at which to warp the local cursor before showing it. Used to
+    /// preserve cross-axis continuity on release: the visible cursor
+    /// reappears at the host point matching where it visually was on
+    /// the guest, instead of snapping back to the capture-start edge.
+    Release {
+        warp_target: Option<(i32, i32)>,
+    },
     Create(Position),
     Destroy(Position),
     Grab(Position),
@@ -153,8 +160,26 @@ impl InputCaptureState {
     ) -> Result<(), CaptureError> {
         log::debug!("handling event: {producer_event:?}");
         match producer_event {
-            ProducerEvent::Release => {
+            ProducerEvent::Release { warp_target } => {
+                log::info!(
+                    "[release-warp] handle_producer_event Release: current_pos={:?} warp_target={warp_target:?}",
+                    self.current_pos
+                );
                 if self.current_pos.is_some() {
+                    // Warp BEFORE clearing current_pos so the
+                    // event-tap callback can't see Some(pos) and
+                    // re-snap the cursor to the entry edge before we
+                    // make it visible again. Then show_cursor() reveals
+                    // it at the warped point.
+                    if let Some((x, y)) = warp_target {
+                        log::info!("[release-warp] warping local cursor to ({x}, {y})");
+                        if let Err(e) = CGDisplay::warp_mouse_cursor_position(CGPoint {
+                            x: x as CGFloat,
+                            y: y as CGFloat,
+                        }) {
+                            log::warn!("[release-warp] warp_mouse_cursor_position failed: {e:?}");
+                        }
+                    }
                     self.show_cursor()?;
                     self.current_pos = None;
                 }
@@ -186,6 +211,25 @@ impl InputCaptureState {
                     self.show_cursor()?;
                     self.current_pos = None;
                 }
+                // Distinguish AX revocation from a recoverable cause
+                // (secure-input mode while typing in a password field
+                // also fires TapDisabledByUserInput). If AX is gone,
+                // the tap can't be recreated and the GUI's polling
+                // watcher may not flip for a while when the user
+                // *removed* the entry from System Settings → Privacy
+                // & Security → Accessibility (vs just toggling it
+                // off — removal can leave AXIsProcessTrusted reporting
+                // cached-true in already-running processes). Exit
+                // the daemon process directly: the GUI will see its
+                // IPC connection drop and trigger its own
+                // quit-with-backstop path. This is the only reliable
+                // way to tear down a wedged HID-level tap quickly.
+                if !unsafe { AXIsProcessTrusted() } {
+                    log::error!(
+                        "CGEventTap disabled and Accessibility no longer granted — daemon exiting"
+                    );
+                    std::process::exit(0);
+                }
                 return Err(CaptureError::EventTapDisabled);
             }
             ProducerEvent::DisplayReconfigured => {
@@ -357,11 +401,41 @@ fn get_events(
             })))
         }
         CGEventType::ScrollWheel => {
+            // Emit scroll deltas in the *classic* mouse-wheel convention
+            // (the historical baseline that predates natural scrolling)
+            // regardless of the user's macOS Natural Scrolling
+            // preference. Rationale:
+            //
+            //   1. Classic was the canonical scroll convention when
+            //      the scroll wheel was invented; using it as the
+            //      wire format keeps Lan Mouse predictable for any
+            //      receiver, including non-natural-aware peers.
+            //   2. Receivers opt into natural-feel via their own
+            //      `natural_scroll` config, mirroring how libinput's
+            //      natural_scroll knob works for physical input.
+            //   3. macOS Natural Scrolling pre-flips POINT_DELTA at
+            //      the OS layer; CGEventTap at Session placement sees
+            //      events after that flip. So:
+            //        Natural ON: POINT_DELTA already flipped (away
+            //          from classic) → re-flip back to classic by
+            //          NOT flipping in our code (sign = +1).
+            //        Natural OFF: POINT_DELTA already in classic →
+            //          flip once to invert away from raw and… wait,
+            //          actually we want to land on classic regardless.
+            //          With Natural OFF the OS gives us "raw classic"
+            //          *as-the-mac-sees-it*; our peers' wl_pointer
+            //          treats positive Y as "document moves down on
+            //          screen" (natural-feel). To present classic
+            //          feel on the wire we negate (sign = -1).
+            //
+            // Net result: wire is consistently classic-feel regardless
+            // of the Mac's preference. Receivers can re-invert.
+            let sign: i64 = if natural_scrolling_enabled() { 1 } else { -1 };
             if ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_IS_CONTINUOUS) != 0 {
-                let v =
-                    ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_1);
-                let h =
-                    ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_2);
+                let v = sign
+                    * ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_1);
+                let h = sign
+                    * ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_2);
                 if v != 0 {
                     result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
                         time: 0,
@@ -378,10 +452,23 @@ fn get_events(
                 }
             } else {
                 // line based scrolling
-                const LINES_PER_STEP: i32 = 3;
+                //
+                // macOS already amplifies SCROLL_WHEEL_EVENT_DELTA based
+                // on wheel velocity — a slow notch on a notched wheel
+                // (e.g. MX Master 4) reports DELTA=1, a fast flick
+                // reports DELTA=10+ per event. The wl_pointer v120
+                // protocol expects one physical wheel click = 120
+                // units, so map one macOS DELTA line to one full v120
+                // tick. (The previous 3-lines-per-step ratio caused
+                // single notches to truncate to discrete=0 on the
+                // receiver, leaving Slack/Alacritty unscrollable until
+                // 3+ notches accumulated.)
+                const LINES_PER_STEP: i32 = 1;
                 const V120_STEPS_PER_LINE: i32 = 120 / LINES_PER_STEP;
-                let v = ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_DELTA_AXIS_1);
-                let h = ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_DELTA_AXIS_2);
+                let v =
+                    sign * ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_DELTA_AXIS_1);
+                let h =
+                    sign * ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_DELTA_AXIS_2);
                 if v != 0 {
                     result.push(CaptureEvent::Input(Event::Pointer(
                         PointerEvent::AxisDiscrete120 {
@@ -518,22 +605,42 @@ fn create_event_tap<'a>(
         } else if matches!(event_type, CGEventType::MouseMoved) {
             // Did we cross a barrier?
             if let Some(new_pos) = state.crossed(cg_ev) {
-                capture_position = Some(new_pos);
-                state
-                    .start_capture(cg_ev, new_pos)
-                    .unwrap_or_else(|e| log::warn!("{e}"));
-                res_events.push(CaptureEvent::Begin);
-                notify_tx
-                    .blocking_send(ProducerEvent::Grab(new_pos))
-                    .expect("Failed to send notification");
+                // About to commit the cross — final gate: skip if the
+                // host is locked, since the lock screen consumes
+                // keyboard before our tap sees it and allowing the
+                // cursor to leave would produce a mouse-only-on-peer
+                // half-broken state. Polling CGSession only at this
+                // commit point (rather than every MouseMoved) keeps
+                // the per-event cost zero — `is_screen_locked()` is
+                // an XPC to WindowServer (~10–50µs); a typical user
+                // crosses a wall a few times per minute.
+                if is_screen_locked() {
+                    log::info!("host screen locked; suppressing cross to {new_pos:?}");
+                } else {
+                    capture_position = Some(new_pos);
+                    // Snapshot the cursor's screen-space position at the
+                    // instant of crossing — before start_capture's
+                    // reset_cursor() snaps it to the edge. The peer uses
+                    // this for the visually-corresponding warp on Enter
+                    // so the cursor doesn't jump to the entry-edge midpoint.
+                    let cross_loc = cg_ev.location();
+                    let cursor = Some((cross_loc.x as i32, cross_loc.y as i32));
+                    state
+                        .start_capture(cg_ev, new_pos)
+                        .unwrap_or_else(|e| log::warn!("{e}"));
+                    res_events.push(CaptureEvent::Begin { cursor });
+                    notify_tx
+                        .blocking_send(ProducerEvent::Grab(new_pos))
+                        .expect("Failed to send notification");
+                }
             }
         }
 
         if let Some(pos) = capture_position {
-            res_events.iter().for_each(|e| {
+            res_events.into_iter().for_each(|e| {
                 // error must be ignored, since the event channel
                 // may already be closed when the InputCapture instance is dropped.
-                let _ = event_tx.blocking_send((pos, *e));
+                let _ = event_tx.blocking_send((pos, e));
             });
             // Returning Drop should stop the event from being processed
             // but core fundation still returns the event
@@ -600,7 +707,7 @@ fn event_tap_thread(
     // callback runs on this thread's CFRunLoop. Box-leak the sender
     // so the C side has a stable user_info pointer; reclaim it after
     // the run loop exits.
-    let display_user_info = Box::into_raw(Box::new(display_notify_tx)) as *mut c_void;
+    let display_user_info = Box::into_raw(Box::new(display_notify_tx.clone())) as *mut c_void;
     unsafe {
         CGDisplayRegisterReconfigurationCallback(
             display_reconfiguration_callback,
@@ -608,6 +715,39 @@ fn event_tap_thread(
         );
     }
 
+    // Also subscribe to system-power events so we recover from
+    // sleep/wake, where the Quartz reconfigure callback may not
+    // fire (or fires before our run loop is processing again, e.g.
+    // clamshell-disconnect → lid-open). On wake we send the same
+    // DisplayReconfigured event the existing handler consumes, so
+    // bounds get refreshed for free.
+    let mut power_notifier_object: u32 = 0;
+    let mut power_notification_port: *mut c_void = std::ptr::null_mut();
+    let power_ctx = Box::into_raw(Box::new(PowerCtx {
+        sender: display_notify_tx,
+        root_port: 0,
+    }));
+    let power_root_port = unsafe {
+        let port = IORegisterForSystemPower(
+            power_ctx as *mut c_void,
+            &mut power_notification_port,
+            power_callback,
+            &mut power_notifier_object,
+        );
+        // Stash the root port for the callback's IOAllowPowerChange
+        // ack — we couldn't know it at Box-construction time because
+        // it's the registration's return value.
+        (*power_ctx).root_port = port;
+        if !power_notification_port.is_null() {
+            let src_ref = IONotificationPortGetRunLoopSource(power_notification_port);
+            if !src_ref.is_null() {
+                let src = CFRunLoopSource::wrap_under_get_rule(src_ref);
+                CFRunLoop::get_current().add_source(&src, kCFRunLoopCommonModes);
+            }
+        }
+        port
+    };
+
     log::debug!("running CFRunLoop...");
     CFRunLoop::run_current();
     log::debug!("event tap thread exiting!...");
@@ -619,11 +759,110 @@ fn event_tap_thread(
         drop(Box::from_raw(
             display_user_info as *mut Sender<ProducerEvent>,
         ));
+
+        if power_notifier_object != 0 {
+            let _ = IODeregisterForSystemPower(&mut power_notifier_object);
+        }
+        if !power_notification_port.is_null() {
+            IONotificationPortDestroy(power_notification_port);
+        }
+        let _ = power_root_port;
+        drop(Box::from_raw(power_ctx));
     }
 
     let _ = exit.send(());
 }
 
+/// Query whether the host's screen is locked. Asks the WindowServer
+/// for the current login session dictionary and looks up the
+/// `CGSSessionScreenIsLocked` key. The key is `kCFBooleanTrue` when
+/// locked; on Sequoia 15+ it's typically absent when unlocked rather
+/// than `kCFBooleanFalse`, so missing-or-nil is treated as unlocked.
+/// Costs ~10–50µs per call (an XPC round-trip to WindowServer);
+/// called from the event tap callback only on `MouseMoved`, so the
+/// amortized cost is negligible (<2% CPU at typical mouse rates).
+fn is_screen_locked() -> bool {
+    let key = unsafe {
+        let cstr = CString::new("CGSSessionScreenIsLocked").unwrap();
+        CFStringCreateWithCString(
+            kCFAllocatorDefault,
+            cstr.as_ptr() as *const c_char,
+            kCFStringEncodingUTF8,
+        )
+    };
+    let dict = unsafe { CGSessionCopyCurrentDictionary() };
+    if dict.is_null() {
+        unsafe { CFRelease(key as *const c_void) };
+        return false;
+    }
+    let value = unsafe { CFDictionaryGetValue(dict, key as *const c_void) };
+    let locked = !value.is_null() && unsafe { CFBooleanGetValue(value as CFBooleanRef) };
+    unsafe {
+        CFRelease(dict as *const c_void);
+        CFRelease(key as *const c_void);
+    }
+    locked
+}
+
+/// Refcon for the IOKit system-power callback. Bundles the channel
+/// sender (so the callback can post `DisplayReconfigured` on wake)
+/// and the `io_connect_t` root port (so the callback can ack
+/// sleep-related messages with `IOAllowPowerChange`). Built on the
+/// event-tap thread, used only by the callback on the same thread —
+/// never crosses thread boundaries, so no Send/Sync needed.
+struct PowerCtx {
+    sender: Sender<ProducerEvent>,
+    root_port: u32,
+}
+
+/// IOKit system-power callback. Fires for every power-management
+/// transition (CanSleep, WillSleep, WillPowerOn, HasPoweredOn).
+/// We only care about `kIOMessageSystemHasPoweredOn` (post-wake);
+/// for the sleep-pending messages we just ack so the kernel doesn't
+/// hold the system in its "waiting for clients" state for the full
+/// 30-second timeout.
+extern "C" fn power_callback(
+    refcon: *mut c_void,
+    _service: u32,
+    msg_type: u32,
+    msg_arg: *mut c_void,
+) {
+    const K_IO_MESSAGE_CAN_SYSTEM_SLEEP: u32 = 0xE000_0270;
+    const K_IO_MESSAGE_SYSTEM_WILL_SLEEP: u32 = 0xE000_0280;
+    const K_IO_MESSAGE_SYSTEM_HAS_POWERED_ON: u32 = 0xE000_0300;
+
+    if refcon.is_null() {
+        return;
+    }
+    // SAFETY: `refcon` is `Box::into_raw(Box::new(PowerCtx))` owned by
+    // `event_tap_thread`; valid until the run loop exits and the box
+    // is reclaimed. The callback only fires while the run loop runs
+    // on that thread, so the box is live here.
+    let ctx = unsafe { &*(refcon as *const PowerCtx) };
+    match msg_type {
+        K_IO_MESSAGE_CAN_SYSTEM_SLEEP | K_IO_MESSAGE_SYSTEM_WILL_SLEEP => {
+            // Ack so the OS doesn't stall on its 30s default timeout.
+            // `msg_arg` carries the notification ID (an `intptr_t`);
+            // pass it through verbatim.
+            unsafe {
+                IOAllowPowerChange(ctx.root_port, msg_arg as isize);
+            }
+        }
+        K_IO_MESSAGE_SYSTEM_HAS_POWERED_ON => {
+            // Bounce a DisplayReconfigured into the producer so
+            // `update_bounds()` runs. Covers the case where Quartz's
+            // own reconfigure callback didn't fire (or fired during
+            // the sleep window) — e.g. clamshell-disconnect →
+            // lid-open transitions.
+            log::info!("system woke from sleep; refreshing display bounds");
+            if let Err(e) = ctx.sender.blocking_send(ProducerEvent::DisplayReconfigured) {
+                log::warn!("failed to post wake → DisplayReconfigured: {e}");
+            }
+        }
+        _ => {}
+    }
+}
+
 /// Quartz display-reconfiguration callback. Fires twice per change:
 /// once with `kCGDisplayBeginConfigurationFlag` set (BEFORE the
 /// change is applied — the bounds are still stale at this point),
@@ -772,11 +1011,12 @@ impl Capture for MacOSInputCapture {
         Ok(())
     }
 
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    async fn release(&mut self, warp_target: Option<(i32, i32)>) -> Result<(), CaptureError> {
+        log::info!("[release-warp] macOS backend release(warp_target={warp_target:?})");
         let notify_tx = self.notify_tx.clone();
         tokio::task::spawn_local(async move {
             log::debug!("notifying Release");
-            let _ = notify_tx.send(ProducerEvent::Release).await;
+            let _ = notify_tx.send(ProducerEvent::Release { warp_target }).await;
         });
         Ok(())
     }
@@ -784,6 +1024,54 @@ impl Capture for MacOSInputCapture {
     async fn terminate(&mut self) -> Result<(), CaptureError> {
         Ok(())
     }
+
+    fn display_bounds(&self) -> Option<(u32, u32)> {
+        // Mirror the InputEmulation-side implementation: the union of
+        // every active display's rectangle, in points (which match
+        // the units used by CGEvent.location() so the
+        // MotionAbsolute math stays internally consistent).
+        let displays = CGDisplay::active_displays().ok()?;
+        let mut xmin = f64::INFINITY;
+        let mut xmax = f64::NEG_INFINITY;
+        let mut ymin = f64::INFINITY;
+        let mut ymax = f64::NEG_INFINITY;
+        for id in displays {
+            let bounds = CGDisplay::new(id).bounds();
+            xmin = xmin.min(bounds.origin.x);
+            xmax = xmax.max(bounds.origin.x + bounds.size.width);
+            ymin = ymin.min(bounds.origin.y);
+            ymax = ymax.max(bounds.origin.y + bounds.size.height);
+        }
+        if xmax <= xmin || ymax <= ymin {
+            return None;
+        }
+        Some(((xmax - xmin) as u32, (ymax - ymin) as u32))
+    }
+
+    fn display_origin(&self) -> (i32, i32) {
+        // Top-left of the union of all active displays. Matters when
+        // a secondary monitor is positioned LEFT of (or ABOVE) the
+        // primary — the global pointer-coordinate system is anchored
+        // at the primary's top-left, so a left-attached external
+        // gives cursor x ∈ [-w, 0). Without this offset,
+        // host_normalized_cursor / peer_warp_target's clamp(0, 1)
+        // silently maps every point on the external to "left edge"
+        // and the receiver warps to the wrong column.
+        let Ok(displays) = CGDisplay::active_displays() else {
+            return (0, 0);
+        };
+        let mut xmin = f64::INFINITY;
+        let mut ymin = f64::INFINITY;
+        for id in displays {
+            let bounds = CGDisplay::new(id).bounds();
+            xmin = xmin.min(bounds.origin.x);
+            ymin = ymin.min(bounds.origin.y);
+        }
+        if xmin.is_infinite() || ymin.is_infinite() {
+            return (0, 0);
+        }
+        (xmin as i32, ymin as i32)
+    }
 }
 
 impl Stream for MacOSInputCapture {
@@ -810,6 +1098,19 @@ extern "C" {
     fn _CGSDefaultConnection() -> CGSConnectionID;
 }
 
+type CFDictionaryRef = *mut c_void;
+
+#[link(name = "CoreGraphics", kind = "framework")]
+extern "C" {
+    fn CGSessionCopyCurrentDictionary() -> CFDictionaryRef;
+}
+
+#[link(name = "CoreFoundation", kind = "framework")]
+extern "C" {
+    fn CFDictionaryGetValue(dict: CFDictionaryRef, key: *const c_void) -> *const c_void;
+    fn CFBooleanGetValue(boolean: CFBooleanRef) -> bool;
+}
+
 extern "C" {
     fn CGEventSourceSetLocalEventsSuppressionInterval(
         event_source: CGEventSource,
@@ -836,11 +1137,73 @@ extern "C" {
     ) -> CGError;
 }
 
+#[link(name = "IOKit", kind = "framework")]
+extern "C" {
+    /// Register the calling process for system-power notifications.
+    /// Returns the `io_connect_t` root power port (used later in
+    /// `IOAllowPowerChange` to ack sleep-related messages) and writes
+    /// the notification port + an `io_object_t` notifier through the
+    /// out-pointers. The returned notification port carries a
+    /// CFRunLoopSource we attach to this thread's run loop so the
+    /// callback fires inline with the existing event-tap loop.
+    fn IORegisterForSystemPower(
+        refcon: *mut c_void,
+        port_ref: *mut *mut c_void,
+        callback: extern "C" fn(*mut c_void, u32, u32, *mut c_void),
+        notifier: *mut u32,
+    ) -> u32;
+    fn IODeregisterForSystemPower(notifier: *mut u32) -> i32;
+    fn IONotificationPortGetRunLoopSource(notify: *mut c_void) -> CFRunLoopSourceRef;
+    fn IONotificationPortDestroy(notify: *mut c_void);
+    /// Ack a kIOMessageCanSystemSleep / kIOMessageSystemWillSleep so
+    /// the OS doesn't stall on its 30s default timeout waiting for us.
+    /// Required even when we have no objection — silence is treated as
+    /// "still thinking" by the kernel.
+    fn IOAllowPowerChange(kernel_port: u32, notification_id: isize) -> i32;
+}
+
 #[link(name = "ApplicationServices", kind = "framework")]
 extern "C" {
     fn AXIsProcessTrusted() -> bool;
 }
 
+/// Read `com.apple.swipescrolldirection` from the global preferences
+/// domain. Returns `true` when Natural Scrolling is enabled (the
+/// modern macOS default) — the same default macOS uses if the key
+/// is unset. Used to decide whether to invert scroll deltas before
+/// forwarding them to a peer that has its own fixed convention.
+fn natural_scrolling_enabled() -> bool {
+    unsafe {
+        let key_cstr = CString::new("com.apple.swipescrolldirection").unwrap();
+        let key = CFStringCreateWithCString(
+            kCFAllocatorDefault,
+            key_cstr.as_ptr() as *const c_char,
+            kCFStringEncodingUTF8,
+        );
+        if key.is_null() {
+            return true;
+        }
+        let value = CFPreferencesCopyAppValue(key, kCFPreferencesAnyApplication);
+        CFRelease(key as *const c_void);
+        if value.is_null() {
+            // Key absent → modern macOS default is enabled.
+            return true;
+        }
+        // The preference is stored as a CFBoolean; kCFBooleanTrue
+        // and kCFBooleanFalse are singleton instances, so a pointer
+        // compare is correct and sufficient.
+        let is_true = (value as CFBooleanRef) == kCFBooleanTrue;
+        CFRelease(value);
+        is_true
+    }
+}
+
+#[link(name = "CoreFoundation", kind = "framework")]
+extern "C" {
+    fn CFPreferencesCopyAppValue(key: CFStringRef, application_id: CFStringRef) -> *const c_void;
+    static kCFPreferencesAnyApplication: CFStringRef;
+}
+
 unsafe fn configure_cf_settings() -> Result<(), MacosCaptureCreationError> {
     // When we warp the cursor using CGWarpMouseCursorPosition local events are suppressed for a short time
     // this leeds to the cursor not flowing when crossing back from a clinet, set this to to 0 stops the warp
diff --git a/input-capture/src/windows.rs b/input-capture/src/windows.rs
index 0d0ed7c2..059abe48 100644
--- a/input-capture/src/windows.rs
+++ b/input-capture/src/windows.rs
@@ -29,7 +29,7 @@ impl Capture for WindowsInputCapture {
         Ok(())
     }
 
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    async fn release(&mut self, _warp_target: Option<(i32, i32)>) -> Result<(), CaptureError> {
         self.event_thread.release_capture();
         Ok(())
     }
diff --git a/input-capture/src/windows/event_thread.rs b/input-capture/src/windows/event_thread.rs
index 2a44c0fc..a4711023 100644
--- a/input-capture/src/windows/event_thread.rs
+++ b/input-capture/src/windows/event_thread.rs
@@ -14,6 +14,9 @@ use windows::Win32::Graphics::Gdi::{
     EnumDisplayDevicesW, EnumDisplaySettingsW,
 };
 use windows::Win32::System::LibraryLoader::GetModuleHandleW;
+use windows::Win32::System::RemoteDesktop::{
+    NOTIFY_FOR_THIS_SESSION, WTSRegisterSessionNotification, WTSUnRegisterSessionNotification,
+};
 use windows::Win32::System::Threading::GetCurrentThreadId;
 use windows::core::{PCWSTR, w};
 
@@ -23,7 +26,8 @@ use windows::Win32::UI::WindowsAndMessaging::{
     RegisterClassW, SetWindowsHookExW, TranslateMessage, WH_KEYBOARD_LL, WH_MOUSE_LL, WINDOW_STYLE,
     WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MBUTTONDOWN,
     WM_MBUTTONUP, WM_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_RBUTTONDOWN, WM_RBUTTONUP,
-    WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_XBUTTONDOWN, WM_XBUTTONUP, WNDCLASSW, WNDPROC,
+    WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_WTSSESSION_CHANGE, WM_XBUTTONDOWN, WM_XBUTTONUP,
+    WNDCLASSW, WNDPROC, WTS_SESSION_LOCK, WTS_SESSION_UNLOCK,
 };
 
 use input_event::{
@@ -122,6 +126,14 @@ thread_local! {
     static PREV_POS: Cell<Option<(i32, i32)>> = const { Cell::new(None) };
     /// displays and generation counter
     static DISPLAYS: RefCell<(Vec<RECT>, i32)> = const { RefCell::new((Vec::new(), 0)) };
+    /// True while the host's session is locked. Set/cleared from the
+    /// `WM_WTSSESSION_CHANGE` window message. While true, barrier
+    /// crossings are suppressed and any active capture is released —
+    /// matches macOS's lock-screen suppression and what Wayland does
+    /// for free on locked Linux. Without this, low-level mouse hooks
+    /// would happily forward motion to the peer while the lock screen
+    /// consumes keyboard events, leaving a half-broken state.
+    static HOST_LOCKED: Cell<bool> = const { Cell::new(false) };
 }
 
 fn get_msg() -> Option<MSG> {
@@ -202,8 +214,10 @@ fn start_routine(
         }
     }
 
-    /* window is used ro receive WM_DISPLAYCHANGE messages */
-    unsafe {
+    /* window is used to receive WM_DISPLAYCHANGE and
+     * WM_WTSSESSION_CHANGE messages. Keep the HWND so we can register
+     * for session notifications and unregister on exit. */
+    let msg_window = unsafe {
         CreateWindowExW(
             Default::default(),
             w!("lan-mouse-message-window-class"),
@@ -218,15 +232,25 @@ fn start_routine(
             Some(instance),
             None,
         )
-        .expect("CreateWindowExW");
+        .expect("CreateWindowExW")
+    };
+
+    /* register for WM_WTSSESSION_CHANGE notifications so we can
+     * detect lock/unlock and suppress crossings while locked. Failure
+     * is logged but non-fatal — the rest of the capture still works,
+     * we just lose the lock-screen suppression. */
+    unsafe {
+        if let Err(e) = WTSRegisterSessionNotification(msg_window, NOTIFY_FOR_THIS_SESSION) {
+            log::warn!(
+                "WTSRegisterSessionNotification failed: {e:?} — host-lock suppression disabled"
+            );
+        }
     }
 
-    /* run message loop */
-    loop {
-        // mouse / keybrd proc do not actually return a message
-        let Some(msg) = get_msg() else {
-            break;
-        };
+    /* run message loop. mouse / keybrd procs don't actually return
+     * a message, so `get_msg() == None` ends the loop; an Exit-typed
+     * thread message breaks out from inside the body. */
+    while let Some(msg) = get_msg() {
         if msg.hwnd.0.is_null() {
             /* messages sent via PostThreadMessage */
             match msg.wParam.0 {
@@ -258,6 +282,11 @@ fn start_routine(
             }
         }
     }
+
+    /* unregister session-notification before the window goes away. */
+    unsafe {
+        let _ = WTSUnRegisterSessionNotification(msg_window);
+    }
 }
 
 fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
@@ -277,6 +306,14 @@ fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
         return ret;
     }
 
+    /* host session locked — don't let the cursor leave the lock
+     * screen. The lock screen consumes keyboard before our hook sees
+     * it; allowing a cross would put the mouse on the peer with no
+     * keyboard, a confusing half-broken state. */
+    if HOST_LOCKED.get() {
+        return ret;
+    }
+
     /* check if a client was activated */
     let entered = DISPLAYS.with_borrow_mut(|(displays, generation)| {
         update_display_regions(displays, generation);
@@ -302,7 +339,7 @@ fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
     /* notify main thread */
     log::debug!("ENTERED @ {prev_pos:?} -> {curr_pos:?}");
     let active = ACTIVE_CLIENT.get().expect("active client");
-    blocking_send_event(active, CaptureEvent::Begin);
+    blocking_send_event(active, CaptureEvent::Begin { cursor: None });
 
     ret
 }
@@ -356,12 +393,29 @@ unsafe extern "system" fn kybrd_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
 unsafe extern "system" fn window_proc(
     _hwnd: HWND,
     uint: u32,
-    _wparam: WPARAM,
+    wparam: WPARAM,
     _lparam: LPARAM,
 ) -> LRESULT {
     if uint == WM_DISPLAYCHANGE {
         log::debug!("display resolution changed");
         DISPLAY_RESOLUTION_GENERATION.fetch_add(1, Ordering::Release);
+    } else if uint == WM_WTSSESSION_CHANGE {
+        match wparam.0 as u32 {
+            WTS_SESSION_LOCK => {
+                HOST_LOCKED.set(true);
+                if let Some(pos) = ACTIVE_CLIENT.take() {
+                    log::info!("host session locked mid-capture; releasing");
+                    let _ = try_send_event(pos, CaptureEvent::AutoRelease);
+                } else {
+                    log::info!("host session locked");
+                }
+            }
+            WTS_SESSION_UNLOCK => {
+                HOST_LOCKED.set(false);
+                log::info!("host session unlocked");
+            }
+            _ => {}
+        }
     }
     LRESULT(1)
 }
diff --git a/input-capture/src/x11.rs b/input-capture/src/x11.rs
index 6fc917ec..cf74940d 100644
--- a/input-capture/src/x11.rs
+++ b/input-capture/src/x11.rs
@@ -23,7 +23,7 @@ impl Capture for X11InputCapture {
         Ok(())
     }
 
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    async fn release(&mut self, _warp_target: Option<(i32, i32)>) -> Result<(), CaptureError> {
         Ok(())
     }
 
diff --git a/input-emulation/Cargo.toml b/input-emulation/Cargo.toml
index 38391223..cfee168c 100644
--- a/input-emulation/Cargo.toml
+++ b/input-emulation/Cargo.toml
@@ -24,6 +24,7 @@ tokio = { version = "1.32.0", features = [
     "time"
 ] }
 once_cell = "1.19.0"
+arboard = { version = "3.4", features = ["wayland-data-control"] }
 
 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
 bitflags = "2.6.0"
diff --git a/input-emulation/src/clipboard.rs b/input-emulation/src/clipboard.rs
new file mode 100644
index 00000000..326b8c20
--- /dev/null
+++ b/input-emulation/src/clipboard.rs
@@ -0,0 +1,105 @@
+use arboard::Clipboard;
+use input_event::ClipboardEvent;
+use std::sync::{Arc, Mutex};
+use thiserror::Error;
+use tokio::task::spawn_blocking;
+
+#[derive(Debug, Error)]
+pub enum ClipboardError {
+    #[error("Failed to access clipboard: {0}")]
+    Access(String),
+    #[error("Failed to set clipboard: {0}")]
+    Set(String),
+}
+
+/// Clipboard emulation that sets clipboard content
+#[derive(Clone)]
+pub struct ClipboardEmulation {
+    // Use Arc<Mutex<>> to share clipboard across threads
+    clipboard: Arc<Mutex<Option<Clipboard>>>,
+}
+
+impl ClipboardEmulation {
+    pub fn new() -> Result<Self, ClipboardError> {
+        // Try to create initial clipboard instance
+        let clipboard = match Clipboard::new() {
+            Ok(c) => Some(c),
+            Err(e) => {
+                log::warn!("Failed to create clipboard instance: {e}");
+                None
+            }
+        };
+
+        Ok(Self {
+            clipboard: Arc::new(Mutex::new(clipboard)),
+        })
+    }
+
+    /// Set clipboard content from a clipboard event
+    pub async fn set(&self, event: ClipboardEvent) -> Result<(), ClipboardError> {
+        match event {
+            ClipboardEvent::Text(text) => {
+                let clipboard_arc = self.clipboard.clone();
+
+                spawn_blocking(move || {
+                    let mut clipboard_guard = clipboard_arc.lock().unwrap();
+
+                    // Try to get or create clipboard
+                    let clipboard = match clipboard_guard.as_mut() {
+                        Some(c) => c,
+                        None => {
+                            // Try to create a new clipboard instance
+                            match Clipboard::new() {
+                                Ok(c) => {
+                                    *clipboard_guard = Some(c);
+                                    clipboard_guard.as_mut().unwrap()
+                                }
+                                Err(e) => {
+                                    return Err(ClipboardError::Access(format!("{e}")));
+                                }
+                            }
+                        }
+                    };
+
+                    // Set clipboard text
+                    clipboard
+                        .set_text(text.clone())
+                        .map_err(|e| ClipboardError::Set(format!("{e}")))?;
+
+                    log::debug!("Clipboard set, length: {} bytes", text.len());
+                    Ok(())
+                })
+                .await
+                .map_err(|e| ClipboardError::Access(format!("Task join error: {e}")))?
+            }
+        }
+    }
+
+    /// Get current clipboard content (for testing/verification)
+    pub async fn get(&self) -> Result<String, ClipboardError> {
+        let clipboard_arc = self.clipboard.clone();
+
+        spawn_blocking(move || {
+            let mut clipboard_guard = clipboard_arc.lock().unwrap();
+
+            let clipboard = match clipboard_guard.as_mut() {
+                Some(c) => c,
+                None => match Clipboard::new() {
+                    Ok(c) => {
+                        *clipboard_guard = Some(c);
+                        clipboard_guard.as_mut().unwrap()
+                    }
+                    Err(e) => {
+                        return Err(ClipboardError::Access(format!("{e}")));
+                    }
+                },
+            };
+
+            clipboard
+                .get_text()
+                .map_err(|e| ClipboardError::Access(format!("{e}")))
+        })
+        .await
+        .map_err(|e| ClipboardError::Access(format!("Task join error: {e}")))?
+    }
+}
diff --git a/input-emulation/src/lib.rs b/input-emulation/src/lib.rs
index 930695f9..07ac93a0 100644
--- a/input-emulation/src/lib.rs
+++ b/input-emulation/src/lib.rs
@@ -4,7 +4,9 @@ use std::{
     fmt::Display,
 };
 
-use input_event::{Event, KeyboardEvent};
+use input_event::{ClipboardEvent, Event, KeyboardEvent, PointerEvent};
+
+use crate::clipboard::ClipboardEmulation;
 
 pub use self::error::{EmulationCreationError, EmulationError, InputEmulationError};
 
@@ -26,6 +28,7 @@ mod libei;
 #[cfg(target_os = "macos")]
 mod macos;
 
+pub mod clipboard;
 /// fallback input emulation (logs events)
 mod dummy;
 mod error;
@@ -69,10 +72,43 @@ impl Display for Backend {
     }
 }
 
+/// Per-handle receive-side post-processing applied to forwarded
+/// events before they reach the platform emulation backend.
+///
+/// `lan-mouse-ipc::IncomingPeerConfig` is the persistent form of
+/// these preferences (keyed by TLS fingerprint). The conversion
+/// happens in `src/emulation.rs`, so this crate stays decoupled
+/// from the IPC layer.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ReceivePostProcessing {
+    /// Sign-flip scroll deltas before injection.
+    pub natural_scroll: bool,
+    /// Linear multiplier on motion deltas. 1.0 = passthrough.
+    pub mouse_sensitivity: f64,
+}
+
+impl Default for ReceivePostProcessing {
+    fn default() -> Self {
+        Self {
+            natural_scroll: false,
+            mouse_sensitivity: 1.0,
+        }
+    }
+}
+
 pub struct InputEmulation {
     emulation: Box<dyn Emulation>,
     handles: HashSet<EmulationHandle>,
     pressed_keys: HashMap<EmulationHandle, HashSet<u32>>,
+    /// Per-handle receive-side post-processing. Populated by the
+    /// upper layer before each event is consumed; missing entries
+    /// resolve to `ReceivePostProcessing::default()` (passthrough).
+    post_processing: HashMap<EmulationHandle, ReceivePostProcessing>,
+    /// Cross-platform clipboard sink. Populated lazily on first
+    /// access; backends don't need to know clipboards exist.
+    /// `None` when the platform clipboard couldn't be opened (e.g.
+    /// headless CI, Wayland session without compositor support).
+    clipboard: Option<ClipboardEmulation>,
 }
 
 impl InputEmulation {
@@ -92,10 +128,19 @@ impl InputEmulation {
             Backend::MacOs => Box::new(macos::MacOSEmulation::new()?),
             Backend::Dummy => Box::new(dummy::DummyEmulation::new()),
         };
+        let clipboard = match ClipboardEmulation::new() {
+            Ok(c) => Some(c),
+            Err(e) => {
+                log::warn!("clipboard emulation unavailable: {e}");
+                None
+            }
+        };
         Ok(Self {
             emulation,
             handles: HashSet::new(),
             pressed_keys: HashMap::new(),
+            post_processing: HashMap::new(),
+            clipboard,
         })
     }
 
@@ -141,6 +186,54 @@ impl InputEmulation {
         event: Event,
         handle: EmulationHandle,
     ) -> Result<(), EmulationError> {
+        // Clipboard events route through the cross-platform
+        // `ClipboardEmulation` sink, not the per-backend pointer /
+        // keyboard pipeline. Per-backend `consume` impls treat
+        // `Event::Clipboard` as a no-op, so handling it here keeps
+        // the dispatch in one place.
+        if let Event::Clipboard(ClipboardEvent::Text(text)) = &event {
+            if let Some(clipboard) = self.clipboard.as_ref() {
+                if let Err(e) = clipboard.set(ClipboardEvent::Text(text.clone())).await {
+                    log::warn!("failed to set clipboard: {e}");
+                }
+            }
+            return Ok(());
+        }
+        // Apply per-handle receive-side post-processing in a single
+        // place rather than per-backend. Backends stay
+        // platform-mechanics-only and are spared duplicate sign-flip
+        // / multiplier code. Algorithm pattern (mutate-event-and-
+        // forward) borrowed from #347.
+        let pp = self
+            .post_processing
+            .get(&handle)
+            .copied()
+            .unwrap_or_default();
+        let event = match event {
+            Event::Pointer(PointerEvent::Motion { time, dx, dy })
+                if pp.mouse_sensitivity != 1.0 =>
+            {
+                Event::Pointer(PointerEvent::Motion {
+                    time,
+                    dx: dx * pp.mouse_sensitivity,
+                    dy: dy * pp.mouse_sensitivity,
+                })
+            }
+            Event::Pointer(PointerEvent::Axis { time, axis, value }) if pp.natural_scroll => {
+                Event::Pointer(PointerEvent::Axis {
+                    time,
+                    axis,
+                    value: -value,
+                })
+            }
+            Event::Pointer(PointerEvent::AxisDiscrete120 { axis, value }) if pp.natural_scroll => {
+                Event::Pointer(PointerEvent::AxisDiscrete120 {
+                    axis,
+                    value: -value,
+                })
+            }
+            other => other,
+        };
         match event {
             Event::Keyboard(KeyboardEvent::Key { key, state, .. }) => {
                 // prevent double pressed / released keys
@@ -153,6 +246,17 @@ impl InputEmulation {
         }
     }
 
+    /// Set the receive-side post-processing for a specific handle.
+    /// Subsequent `consume()` calls for this handle apply the
+    /// `natural_scroll` and `mouse_sensitivity` transforms.
+    pub fn set_post_processing(
+        &mut self,
+        handle: EmulationHandle,
+        post_processing: ReceivePostProcessing,
+    ) {
+        self.post_processing.insert(handle, post_processing);
+    }
+
     pub async fn create(&mut self, handle: EmulationHandle) -> bool {
         if self.handles.insert(handle) {
             self.pressed_keys.insert(handle, HashSet::new());
@@ -167,6 +271,7 @@ impl InputEmulation {
         let _ = self.release_keys(handle).await;
         if self.handles.remove(&handle) {
             self.pressed_keys.remove(&handle);
+            self.post_processing.remove(&handle);
             self.emulation.destroy(handle).await
         }
     }
@@ -178,6 +283,19 @@ impl InputEmulation {
         self.emulation.terminate().await
     }
 
+    /// Display geometry of this device (union of all active
+    /// displays), if the backend can report it. See
+    /// `Emulation::display_bounds`.
+    pub fn display_bounds(&self) -> Option<(u32, u32)> {
+        self.emulation.display_bounds()
+    }
+
+    /// Warp the local cursor to the given absolute position. See
+    /// `Emulation::warp_cursor`.
+    pub async fn warp_cursor(&mut self, x: i32, y: i32) -> Result<(), EmulationError> {
+        self.emulation.warp_cursor(x, y).await
+    }
+
     pub async fn release_keys(&mut self, handle: EmulationHandle) -> Result<(), EmulationError> {
         if let Some(keys) = self.pressed_keys.get_mut(&handle) {
             let keys = keys.drain().collect::<Vec<_>>();
@@ -237,4 +355,27 @@ trait Emulation: Send {
     async fn create(&mut self, handle: EmulationHandle);
     async fn destroy(&mut self, handle: EmulationHandle);
     async fn terminate(&mut self);
+
+    /// Geometry (width, height) of the union of this device's
+    /// active displays in pixels. Used by the protocol-level
+    /// `Bounds` event so a capturing peer can model the guest
+    /// cursor's position. Backends that can't report geometry
+    /// should leave the default `None` and the wall-press
+    /// auto-release fallback will degrade to "no upper clamp"
+    /// behavior on the host.
+    fn display_bounds(&self) -> Option<(u32, u32)> {
+        None
+    }
+
+    /// Warp the cursor to an absolute position on the receiving
+    /// device's primary display, if the backend supports absolute
+    /// positioning. Called when an `Enter` event arrives so the
+    /// guest cursor lands at the entry edge instead of staying
+    /// wherever the previous capture session left it. Backends
+    /// without absolute positioning can leave the default no-op
+    /// — the wall-press auto-release will be inaccurate but the
+    /// connection still works.
+    async fn warp_cursor(&mut self, _x: i32, _y: i32) -> Result<(), EmulationError> {
+        Ok(())
+    }
 }
diff --git a/input-emulation/src/libei.rs b/input-emulation/src/libei.rs
index 3ac6e899..751e3d48 100644
--- a/input-emulation/src/libei.rs
+++ b/input-emulation/src/libei.rs
@@ -19,8 +19,8 @@ use async_trait::async_trait;
 
 use reis::{
     ei::{
-        self, Button, Keyboard, Pointer, Scroll, button::ButtonState, handshake::ContextType,
-        keyboard::KeyState,
+        self, Button, Keyboard, Pointer, PointerAbsolute, Scroll, button::ButtonState,
+        handshake::ContextType, keyboard::KeyState,
     },
     event::{self, Connection, DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
     tokio::EiConvertEventStream,
@@ -35,6 +35,7 @@ use super::{Emulation, EmulationHandle, error::LibeiEmulationCreationError};
 #[derive(Clone, Default)]
 struct Devices {
     pointer: Arc<RwLock<Option<(ei::Device, ei::Pointer)>>>,
+    pointer_abs: Arc<RwLock<Option<(ei::Device, ei::PointerAbsolute)>>>,
     scroll: Arc<RwLock<Option<(ei::Device, ei::Scroll)>>>,
     button: Arc<RwLock<Option<(ei::Device, ei::Button)>>>,
     keyboard: Arc<RwLock<Option<(ei::Device, ei::Keyboard)>>>,
@@ -247,6 +248,10 @@ impl Emulation for LibeiEmulation {
                 }
                 KeyboardEvent::Modifiers { .. } => {}
             },
+            Event::Clipboard(_) => {
+                // Clipboard injection is handled by the cross-
+                // platform `ClipboardEmulation` sink, not libei.
+            }
         }
         self.context
             .flush()
@@ -261,6 +266,37 @@ impl Emulation for LibeiEmulation {
         let _ = self.session.close().await;
         self.ei_task.abort();
     }
+
+    fn display_bounds(&self) -> Option<(u32, u32)> {
+        // TODO: derive from ei::Region events on the
+        // PointerAbsolute device, or query wl_output via a side
+        // wayland-client connection. For now we return None and
+        // the host falls back to the no-upper-clamp heuristic.
+        None
+    }
+
+    async fn warp_cursor(&mut self, x: i32, y: i32) -> Result<(), EmulationError> {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_micros() as u64;
+        let pointer_abs = self.devices.pointer_abs.read().unwrap();
+        if let Some((device, pointer_abs)) = pointer_abs.as_ref() {
+            pointer_abs.motion_absolute(x as f32, y as f32);
+            device.frame(self.conn.serial(), now);
+            self.context
+                .flush()
+                .map_err(|e| io::Error::new(e.kind(), e))?;
+        } else {
+            // Compositor didn't grant a PointerAbsolute device.
+            // Nothing we can do to warp the cursor; the host's
+            // wall-press model will be off by however far the
+            // user pushed forward in the prior session, but
+            // operation continues.
+            log::debug!("warp_cursor: no PointerAbsolute device available, skipping");
+        }
+        Ok(())
+    }
 }
 
 async fn ei_task(
@@ -323,6 +359,13 @@ async fn ei_event_handler(
                         .unwrap()
                         .replace((device.device().clone(), pointer));
                 }
+                if let Some(pointer_abs) = e.device().interface::<PointerAbsolute>() {
+                    devices
+                        .pointer_abs
+                        .write()
+                        .unwrap()
+                        .replace((device.device().clone(), pointer_abs));
+                }
                 if let Some(keyboard) = e.device().interface::<Keyboard>() {
                     devices
                         .keyboard
diff --git a/input-emulation/src/macos.rs b/input-emulation/src/macos.rs
index 881fc229..ca18052b 100644
--- a/input-emulation/src/macos.rs
+++ b/input-emulation/src/macos.rs
@@ -1,9 +1,11 @@
 use super::{Emulation, EmulationHandle, error::EmulationError};
 use async_trait::async_trait;
 use bitflags::bitflags;
+use core_foundation::base::{CFRelease, kCFAllocatorDefault};
+use core_foundation::string::{CFStringCreateWithCString, CFStringRef, kCFStringEncodingUTF8};
 use core_graphics::base::CGFloat;
 use core_graphics::display::{
-    CGDirectDisplayID, CGDisplayBounds, CGGetDisplaysWithRect, CGPoint, CGRect, CGSize,
+    CGDirectDisplayID, CGDisplay, CGDisplayBounds, CGGetDisplaysWithRect, CGPoint, CGRect, CGSize,
 };
 use core_graphics::event::{
     CGEvent, CGEventFlags, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField,
@@ -17,6 +19,7 @@ use input_event::{
 use keycode::{KeyMap, KeyMapping};
 use std::cell::Cell;
 use std::collections::HashSet;
+use std::ffi::{CString, c_char, c_int, c_void};
 use std::rc::Rc;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -45,6 +48,17 @@ pub(crate) struct MacOSEmulation {
     modifier_state: Rc<Cell<XMods>>,
     /// notify to cancel key repeats
     notify_repeat_task: Arc<Notify>,
+    /// IOPMAssertionID returned by the most recent
+    /// `IOPMAssertionDeclareUserActivity` call, kept for re-use within
+    /// the system's 5-second coalesce window. Without this, a CGEvent
+    /// posted while the host's display is asleep wakes nothing — the
+    /// kernel power-manager only treats USB/Bluetooth HID interrupts
+    /// as wake-worthy, not synthesized events. Declaring user
+    /// activity is Apple's documented "treat this as real user input
+    /// for power purposes" signal: it wakes the display and resets
+    /// the idle timer. Initialized to 0; the first call returns a
+    /// real ID, subsequent calls within 5s return the same ID.
+    user_activity_assertion: Cell<u32>,
 }
 
 /// Maps an evdev button code to the CGEventType used for drag events.
@@ -74,9 +88,39 @@ impl MacOSEmulation {
             repeat_task: None,
             notify_repeat_task: Arc::new(Notify::new()),
             modifier_state: Rc::new(Cell::new(XMods::empty())),
+            user_activity_assertion: Cell::new(0),
         })
     }
 
+    /// Tell the macOS power-manager that real user input is arriving
+    /// from this process. Wakes the display if asleep and resets the
+    /// idle timer. Cheap to call on every event — the system itself
+    /// coalesces calls within a 5-second window (returns the same
+    /// IOPMAssertionID), so we just stash the most recent ID in a
+    /// `Cell` and pass it back in. Required because plain
+    /// `CGEventPost` doesn't trigger display wake on its own.
+    fn declare_user_activity(&self) {
+        let cstr = match CString::new("Lan Mouse: remote input") {
+            Ok(c) => c,
+            Err(_) => return,
+        };
+        let reason = unsafe {
+            CFStringCreateWithCString(
+                kCFAllocatorDefault,
+                cstr.as_ptr() as *const c_char,
+                kCFStringEncodingUTF8,
+            )
+        };
+        if reason.is_null() {
+            return;
+        }
+        let mut id = self.user_activity_assertion.get();
+        let _ret =
+            unsafe { IOPMAssertionDeclareUserActivity(reason, K_IOPM_USER_ACTIVE_LOCAL, &mut id) };
+        self.user_activity_assertion.set(id);
+        unsafe { CFRelease(reason as *const c_void) };
+    }
+
     fn get_mouse_location(&self) -> Option<CGPoint> {
         let event: CGEvent = CGEvent::new(self.event_source.clone()).ok()?;
         Some(event.location())
@@ -157,6 +201,21 @@ extern "C" {
     fn AXIsProcessTrusted() -> bool;
 }
 
+#[link(name = "IOKit", kind = "framework")]
+extern "C" {
+    fn IOPMAssertionDeclareUserActivity(
+        assertion_name: CFStringRef,
+        user_type: c_int,
+        out_id: *mut u32,
+    ) -> i32;
+}
+
+/// `kIOPMUserActiveLocal` — local mouse / keyboard activity (the
+/// other variant, `kIOPMUserActiveRemote = 1`, is for screen-sharing
+/// servers acting on behalf of a remote user; "local" is correct
+/// here since we ARE the source generating local HID-style input).
+const K_IOPM_USER_ACTIVE_LOCAL: c_int = 0;
+
 fn key_event(event_source: CGEventSource, key: u16, state: u8, modifiers: XMods) {
     let event = match CGEvent::new_keyboard_event(event_source, key, state != 0) {
         Ok(e) => e,
@@ -261,6 +320,13 @@ impl Emulation for MacOSEmulation {
         _handle: EmulationHandle,
     ) -> Result<(), EmulationError> {
         log::trace!("{event:?}");
+        // Wake the display + reset idle timer for every incoming
+        // event. CGEventPost-synthesized events alone don't trigger
+        // display wake on macOS — the kernel power-manager only
+        // treats USB/Bluetooth HID interrupts as wake-worthy. The
+        // system coalesces these calls within a 5-second window, so
+        // calling on every event is essentially free.
+        self.declare_user_activity();
         match event {
             Event::Pointer(pointer_event) => {
                 match pointer_event {
@@ -479,6 +545,11 @@ impl Emulation for MacOSEmulation {
                     modifier_event(self.event_source.clone(), self.modifier_state.get());
                 }
             },
+            Event::Clipboard(_) => {
+                // Clipboard injection is handled by the cross-
+                // platform `ClipboardEmulation` sink, not the macOS
+                // emulation backend.
+            }
         }
         // FIXME
         Ok(())
@@ -489,6 +560,39 @@ impl Emulation for MacOSEmulation {
     async fn destroy(&mut self, _handle: EmulationHandle) {}
 
     async fn terminate(&mut self) {}
+
+    fn display_bounds(&self) -> Option<(u32, u32)> {
+        // Union of every active display's rectangle. Matches the
+        // shape used on the input-capture side so the host's
+        // wall-press model is consistent across both ends.
+        let displays = CGDisplay::active_displays().ok()?;
+        let mut xmin = f64::INFINITY;
+        let mut xmax = f64::NEG_INFINITY;
+        let mut ymin = f64::INFINITY;
+        let mut ymax = f64::NEG_INFINITY;
+        for id in displays {
+            let bounds = CGDisplay::new(id).bounds();
+            xmin = xmin.min(bounds.origin.x);
+            xmax = xmax.max(bounds.origin.x + bounds.size.width);
+            ymin = ymin.min(bounds.origin.y);
+            ymax = ymax.max(bounds.origin.y + bounds.size.height);
+        }
+        if xmax <= xmin || ymax <= ymin {
+            return None;
+        }
+        Some(((xmax - xmin) as u32, (ymax - ymin) as u32))
+    }
+
+    async fn warp_cursor(&mut self, x: i32, y: i32) -> Result<(), EmulationError> {
+        let pt = CGPoint {
+            x: x as CGFloat,
+            y: y as CGFloat,
+        };
+        // CGDisplay::warp_mouse_cursor_position is a global Quartz
+        // call; it doesn't matter which CGDisplay receiver we use.
+        let _ = CGDisplay::warp_mouse_cursor_position(pt);
+        Ok(())
+    }
 }
 
 fn update_modifiers(modifiers: &Cell<XMods>, key: u32, state: u8) -> bool {
diff --git a/input-emulation/src/windows.rs b/input-emulation/src/windows.rs
index 6610ec25..48239944 100644
--- a/input-emulation/src/windows.rs
+++ b/input-emulation/src/windows.rs
@@ -17,7 +17,9 @@ use windows::Win32::UI::Input::KeyboardAndMouse::{
 use windows::Win32::UI::Input::KeyboardAndMouse::{
     INPUT_0, KEYEVENTF_EXTENDEDKEY, MOUSEEVENTF_XDOWN, MOUSEEVENTF_XUP, SendInput,
 };
-use windows::Win32::UI::WindowsAndMessaging::{XBUTTON1, XBUTTON2};
+use windows::Win32::UI::WindowsAndMessaging::{
+    GetSystemMetrics, SM_CXVIRTUALSCREEN, SM_CYVIRTUALSCREEN, SetCursorPos, XBUTTON1, XBUTTON2,
+};
 
 use super::{Emulation, EmulationHandle};
 
@@ -70,6 +72,10 @@ impl Emulation for WindowsEmulation {
                 }
                 KeyboardEvent::Modifiers { .. } => {}
             },
+            Event::Clipboard(_) => {
+                // Clipboard injection is handled by the cross-
+                // platform `ClipboardEmulation` sink.
+            }
         }
         // FIXME
         Ok(())
@@ -80,6 +86,27 @@ impl Emulation for WindowsEmulation {
     async fn destroy(&mut self, _handle: EmulationHandle) {}
 
     async fn terminate(&mut self) {}
+
+    fn display_bounds(&self) -> Option<(u32, u32)> {
+        // Virtual-screen metrics cover the union of every monitor
+        // attached to the system, matching the host-side capture
+        // model that uses the union of all displays.
+        unsafe {
+            let w = GetSystemMetrics(SM_CXVIRTUALSCREEN);
+            let h = GetSystemMetrics(SM_CYVIRTUALSCREEN);
+            if w <= 0 || h <= 0 {
+                return None;
+            }
+            Some((w as u32, h as u32))
+        }
+    }
+
+    async fn warp_cursor(&mut self, x: i32, y: i32) -> Result<(), EmulationError> {
+        unsafe {
+            let _ = SetCursorPos(x, y);
+        }
+        Ok(())
+    }
 }
 
 impl WindowsEmulation {
diff --git a/input-emulation/src/wlroots.rs b/input-emulation/src/wlroots.rs
index f79f8d9e..7cca09e2 100644
--- a/input-emulation/src/wlroots.rs
+++ b/input-emulation/src/wlroots.rs
@@ -8,12 +8,18 @@ use std::io;
 use std::os::fd::{AsFd, OwnedFd};
 use std::sync::{Arc, Mutex};
 use std::time::{SystemTime, UNIX_EPOCH};
+use wayland_client::Proxy;
 use wayland_client::WEnum;
 use wayland_client::backend::WaylandError;
 
 use wayland_client::protocol::wl_keyboard::{self, WlKeyboard};
+use wayland_client::protocol::wl_output::{self, WlOutput};
 use wayland_client::protocol::wl_pointer::{Axis, AxisSource, ButtonState};
 use wayland_client::protocol::wl_seat::WlSeat;
+use wayland_protocols::xdg::xdg_output::zv1::client::{
+    zxdg_output_manager_v1::ZxdgOutputManagerV1,
+    zxdg_output_v1::{self, ZxdgOutputV1},
+};
 use wayland_protocols_wlr::virtual_pointer::v1::client::{
     zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1 as VpManager,
     zwlr_virtual_pointer_v1::ZwlrVirtualPointerV1 as Vp,
@@ -42,6 +48,38 @@ struct State {
     qh: QueueHandle<Self>,
     vpm: VpManager,
     vkm: VkManager,
+    /// All wl_outputs the compositor advertises, keyed by their
+    /// proxy id. Updated via Geometry/Mode events. We keep the
+    /// `WlOutput` proxy alive in the value so events keep flowing.
+    outputs: HashMap<u32, (WlOutput, OutputInfo, Option<ZxdgOutputV1>)>,
+    /// Dedicated virtual pointer used only for absolute-position
+    /// warps on `Enter`. Separate from per-handle pointers so warp
+    /// works regardless of which client is active.
+    warp_pointer: Vp,
+}
+
+#[derive(Default, Clone, Copy)]
+struct OutputInfo {
+    /// Position in the compositor's global coordinate space, from
+    /// wl_output::Event::Geometry. Raw-pixel coordinates.
+    x: i32,
+    y: i32,
+    /// Pixel dimensions of the active mode, from wl_output::Event::Mode.
+    width: i32,
+    height: i32,
+    /// Logical position in the compositor's coordinate space, from
+    /// zxdg_output_v1::Event::LogicalPosition. Reflects software
+    /// scaling (e.g. fractional or HiDPI). Falls back to (x, y) when
+    /// xdg-output isn't available.
+    logical_x: Option<i32>,
+    logical_y: Option<i32>,
+    /// Logical dimensions, from zxdg_output_v1::Event::LogicalSize.
+    /// This is the coordinate space the compositor uses for cursor
+    /// positions and the same one the capture side uses, so we
+    /// prefer it for `display_bounds()` to keep both sides in sync.
+    /// Falls back to (width, height) when xdg-output isn't available.
+    logical_width: Option<i32>,
+    logical_height: Option<i32>,
 }
 
 // App State, implements Dispatch event handlers
@@ -67,6 +105,39 @@ impl WlrootsEmulation {
         let vkm: VkManager = globals
             .bind(&qh, 1..=1, ())
             .map_err(|e| WaylandBindError::new(e, "virtual-keyboard-unstable-v1"))?;
+        // xdg-output gives us LogicalSize/LogicalPosition — the
+        // coordinate space the compositor actually uses (with
+        // software/fractional scaling applied). The capture side
+        // already reports bounds in this space, so emulation needs
+        // it too or warps land on different proportions than the
+        // sender computed. Optional: if the compositor doesn't
+        // advertise xdg_output_manager we fall back to wl_output's
+        // raw mode dimensions.
+        let xdg_output_manager: Option<ZxdgOutputManagerV1> = globals.bind(&qh, 1..=3, ()).ok();
+
+        // Bind every advertised wl_output so we receive Geometry +
+        // Mode events for each one. Used to compute display_bounds.
+        let mut outputs: HashMap<u32, (WlOutput, OutputInfo, Option<ZxdgOutputV1>)> =
+            HashMap::new();
+        for global in globals.contents().clone_list() {
+            if global.interface == "wl_output" {
+                // version 2 is enough for Geometry + Mode events.
+                let output: WlOutput =
+                    globals
+                        .registry()
+                        .bind(global.name, global.version.min(2), &qh, ());
+                let id = output.id().protocol_id();
+                let xdg_output = xdg_output_manager
+                    .as_ref()
+                    .map(|mgr| mgr.get_xdg_output(&output, &qh, id));
+                outputs.insert(id, (output, OutputInfo::default(), xdg_output));
+            }
+        }
+
+        // Dedicated warp pointer — used only for motion_absolute on
+        // Enter, so warp works even when no per-handle virtual
+        // pointer is currently active.
+        let warp_pointer: Vp = vpm.create_virtual_pointer(None, &qh, ());
 
         let input_for_client: HashMap<EmulationHandle, VirtualInput> = HashMap::new();
 
@@ -79,6 +150,8 @@ impl WlrootsEmulation {
                 vpm,
                 vkm,
                 qh,
+                outputs,
+                warp_pointer,
             },
             queue,
         };
@@ -119,6 +192,39 @@ impl State {
             input.keyboard.destroy();
         }
     }
+
+    /// Bounding rectangle of every active wl_output in the
+    /// compositor's logical coordinate space (with software /
+    /// fractional scaling applied). Falls back per-output to raw
+    /// mode dimensions when xdg-output is unavailable. Returns
+    /// None if no output has reported usable size info yet.
+    fn union_bounds(&self) -> Option<(u32, u32)> {
+        let mut xmin = i32::MAX;
+        let mut ymin = i32::MAX;
+        let mut xmax = i32::MIN;
+        let mut ymax = i32::MIN;
+        let mut any = false;
+        for (_, o, _) in self.outputs.values() {
+            let w = o.logical_width.unwrap_or(o.width);
+            let h = o.logical_height.unwrap_or(o.height);
+            if w <= 0 || h <= 0 {
+                continue;
+            }
+            let ox = o.logical_x.unwrap_or(o.x);
+            let oy = o.logical_y.unwrap_or(o.y);
+            any = true;
+            xmin = xmin.min(ox);
+            ymin = ymin.min(oy);
+            xmax = xmax.max(ox + w);
+            ymax = ymax.max(oy + h);
+        }
+        if !any {
+            return None;
+        }
+        let w = (xmax - xmin) as u32;
+        let h = (ymax - ymin) as u32;
+        Some((w, h))
+    }
 }
 
 #[async_trait]
@@ -143,13 +249,14 @@ impl Emulation for WlrootsEmulation {
                     _ => {}
                 }
             }
+            let event_debug = format!("{event:?}");
             virtual_input
                 .consume_event(event)
-                .unwrap_or_else(|_| panic!("failed to convert event: {event:?}"));
+                .unwrap_or_else(|_| panic!("failed to convert event: {event_debug}"));
             match self.queue.flush() {
                 Err(WaylandError::Io(e)) if e.kind() == io::ErrorKind::WouldBlock => {
                     self.last_flush_failed = true;
-                    log::warn!("can't keep up, discarding event: ({handle}) - {event:?}");
+                    log::warn!("can't keep up, discarding event: ({handle}) - {event_debug}");
                 }
                 Err(WaylandError::Protocol(e)) => panic!("wayland protocol violation: {e}"),
                 Ok(()) => self.last_flush_failed = false,
@@ -172,7 +279,31 @@ impl Emulation for WlrootsEmulation {
         }
     }
     async fn terminate(&mut self) {
-        /* nothing to do */
+        self.state.warp_pointer.destroy();
+    }
+
+    fn display_bounds(&self) -> Option<(u32, u32)> {
+        self.state.union_bounds()
+    }
+
+    async fn warp_cursor(&mut self, x: i32, y: i32) -> Result<(), EmulationError> {
+        let Some((width, height)) = self.state.union_bounds() else {
+            return Ok(());
+        };
+        let now: u32 = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_millis() as u32;
+        let cx = x.clamp(0, width as i32) as u32;
+        let cy = y.clamp(0, height as i32) as u32;
+        self.state
+            .warp_pointer
+            .motion_absolute(now, cx, cy, width, height);
+        self.state.warp_pointer.frame();
+        if let Err(e) = self.queue.flush() {
+            log::warn!("warp_cursor flush failed: {e}");
+        }
+        Ok(())
     }
 }
 
@@ -201,9 +332,24 @@ impl VirtualInput {
                         let state: ButtonState = state.try_into()?;
                         self.pointer.button(time, button, state);
                     }
-                    PointerEvent::Axis { time, axis, value } => {
+                    PointerEvent::Axis {
+                        time: _,
+                        axis,
+                        value,
+                    } => {
+                        // wl_pointer requires `axis_source` to be sent
+                        // alongside the axis event; without it many
+                        // compositors (Hyprland, Sway, …) silently
+                        // drop continuous scroll. AxisSource::Finger
+                        // matches a Mac trackpad gesture, which is the
+                        // typical source for continuous scroll
+                        // forwarded by Lan Mouse. We also use the
+                        // local `now` timestamp because the upstream
+                        // CGEventTap path passes time=0 and some
+                        // compositors filter zero-time events.
                         let axis: Axis = (axis as u32).try_into()?;
-                        self.pointer.axis(time, axis, value);
+                        self.pointer.axis(now, axis, value);
+                        self.pointer.axis_source(AxisSource::Finger);
                         self.pointer.frame();
                     }
                     PointerEvent::AxisDiscrete120 { axis, value } => {
@@ -245,6 +391,10 @@ impl VirtualInput {
                         .modifiers(mods_depressed, mods_latched, mods_locked, group);
                 }
             },
+            Event::Clipboard(_) => {
+                // Clipboard injection is handled by the cross-
+                // platform `ClipboardEmulation` sink, not wlroots.
+            }
         }
         Ok(())
     }
@@ -254,6 +404,33 @@ delegate_noop!(State: Vp);
 delegate_noop!(State: Vk);
 delegate_noop!(State: VpManager);
 delegate_noop!(State: VkManager);
+delegate_noop!(State: ZxdgOutputManagerV1);
+
+impl Dispatch<ZxdgOutputV1, u32> for State {
+    fn event(
+        state: &mut Self,
+        _: &ZxdgOutputV1,
+        event: <ZxdgOutputV1 as wayland_client::Proxy>::Event,
+        id: &u32,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        let Some((_, info, _)) = state.outputs.get_mut(id) else {
+            return;
+        };
+        match event {
+            zxdg_output_v1::Event::LogicalPosition { x, y } => {
+                info.logical_x = Some(x);
+                info.logical_y = Some(y);
+            }
+            zxdg_output_v1::Event::LogicalSize { width, height } => {
+                info.logical_width = Some(width);
+                info.logical_height = Some(height);
+            }
+            _ => {}
+        }
+    }
+}
 
 impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for State {
     fn event(
@@ -282,6 +459,38 @@ impl Dispatch<WlKeyboard, ()> for State {
     }
 }
 
+impl Dispatch<WlOutput, ()> for State {
+    fn event(
+        state: &mut Self,
+        output: &WlOutput,
+        event: <WlOutput as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        let id = output.id().protocol_id();
+        let Some((_, info, _)) = state.outputs.get_mut(&id) else {
+            return;
+        };
+        match event {
+            wl_output::Event::Geometry { x, y, .. } => {
+                info.x = x;
+                info.y = y;
+            }
+            wl_output::Event::Mode {
+                flags: WEnum::Value(flags),
+                width,
+                height,
+                ..
+            } if flags.contains(wl_output::Mode::Current) => {
+                info.width = width;
+                info.height = height;
+            }
+            _ => {}
+        }
+    }
+}
+
 impl Dispatch<WlSeat, ()> for State {
     fn event(
         _: &mut Self,
diff --git a/input-emulation/src/x11.rs b/input-emulation/src/x11.rs
index aadca294..d62e1cda 100644
--- a/input-emulation/src/x11.rs
+++ b/input-emulation/src/x11.rs
@@ -151,4 +151,31 @@ impl Emulation for X11Emulation {
     async fn terminate(&mut self) {
         /* nothing to do */
     }
+
+    fn display_bounds(&self) -> Option<(u32, u32)> {
+        unsafe {
+            // DisplayWidth/DisplayHeight on the default screen
+            // returns the union extent of the X server's logical
+            // screen across all monitors (Xinerama / RandR).
+            let screen = xlib::XDefaultScreen(self.display);
+            let w = xlib::XDisplayWidth(self.display, screen);
+            let h = xlib::XDisplayHeight(self.display, screen);
+            if w <= 0 || h <= 0 {
+                return None;
+            }
+            Some((w as u32, h as u32))
+        }
+    }
+
+    async fn warp_cursor(&mut self, x: i32, y: i32) -> Result<(), EmulationError> {
+        unsafe {
+            let root = xlib::XDefaultRootWindow(self.display);
+            // XWarpPointer with src_w = 0 means "no source window",
+            // so the cursor moves to (x, y) relative to dest_w
+            // (the root window) regardless of where it currently is.
+            xlib::XWarpPointer(self.display, 0, root, 0, 0, 0, 0, x, y);
+            xlib::XFlush(self.display);
+        }
+        Ok(())
+    }
 }
diff --git a/input-emulation/src/xdg_desktop_portal.rs b/input-emulation/src/xdg_desktop_portal.rs
index 7c2d133c..bb78d859 100644
--- a/input-emulation/src/xdg_desktop_portal.rs
+++ b/input-emulation/src/xdg_desktop_portal.rs
@@ -12,7 +12,7 @@ use async_trait::async_trait;
 
 use futures::FutureExt;
 use input_event::{
-    Event::{Keyboard, Pointer},
+    Event::{self, Keyboard, Pointer},
     KeyboardEvent, PointerEvent,
 };
 
@@ -147,12 +147,18 @@ impl Emulation for DesktopPortalEmulation {
                     }
                 }
             }
+            Event::Clipboard(_) => {
+                // Clipboard injection is handled by the cross-
+                // platform `ClipboardEmulation` sink, not the
+                // desktop portal backend.
+            }
         }
         Ok(())
     }
 
     async fn create(&mut self, _client: EmulationHandle) {}
     async fn destroy(&mut self, _client: EmulationHandle) {}
+
     async fn terminate(&mut self) {
         if let Err(e) = self.session.close().await {
             log::warn!("session.close(): {e}");
diff --git a/input-event/src/lib.rs b/input-event/src/lib.rs
index 1d8c9ffb..640d6918 100644
--- a/input-event/src/lib.rs
+++ b/input-event/src/lib.rs
@@ -38,12 +38,20 @@ pub enum KeyboardEvent {
     },
 }
 
-#[derive(PartialEq, Debug, Clone, Copy)]
+#[derive(Debug, PartialEq, Clone)]
+pub enum ClipboardEvent {
+    /// text content from clipboard
+    Text(String),
+}
+
+#[derive(PartialEq, Debug, Clone)]
 pub enum Event {
     /// pointer event (motion / button / axis)
     Pointer(PointerEvent),
     /// keyboard events (key / modifiers)
     Keyboard(KeyboardEvent),
+    /// clipboard events (cross-peer clipboard sync)
+    Clipboard(ClipboardEvent),
 }
 
 impl Display for PointerEvent {
@@ -109,11 +117,27 @@ impl Display for KeyboardEvent {
     }
 }
 
+impl Display for ClipboardEvent {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ClipboardEvent::Text(text) => {
+                let preview = if text.len() > 50 {
+                    format!("{}...", &text[..50])
+                } else {
+                    text.clone()
+                };
+                write!(f, "clipboard(text: {preview})")
+            }
+        }
+    }
+}
+
 impl Display for Event {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Event::Pointer(p) => write!(f, "{p}"),
             Event::Keyboard(k) => write!(f, "{k}"),
+            Event::Clipboard(c) => write!(f, "{c}"),
         }
     }
 }
diff --git a/input-event/src/libei.rs b/input-event/src/libei.rs
index f7904898..3c85a7fd 100644
--- a/input-event/src/libei.rs
+++ b/input-event/src/libei.rs
@@ -46,7 +46,7 @@ impl Iterator for EventIterator {
         let res = if self.pos >= self.events.len() {
             None
         } else {
-            self.events[self.pos]
+            self.events[self.pos].clone()
         };
         self.pos += 1;
         res
diff --git a/lan-mouse-gtk/Cargo.toml b/lan-mouse-gtk/Cargo.toml
index 4a1a2027..46dc5338 100644
--- a/lan-mouse-gtk/Cargo.toml
+++ b/lan-mouse-gtk/Cargo.toml
@@ -7,13 +7,17 @@ license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
 
 [dependencies]
-gtk = { package = "gtk4", version = "0.9.0", features = ["v4_2"] }
+gtk = { package = "gtk4", version = "0.9.0", features = ["v4_6"] }
 adw = { package = "libadwaita", version = "0.7.0", features = ["v1_1"] }
 async-channel = { version = "2.1.1" }
 hostname = "0.4.0"
 log = "0.4.20"
 lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
+input-capture = { path = "../input-capture", version = "0.3.0", default-features = false }
 thiserror = "2.0.0"
 
+[target.'cfg(target_os = "linux")'.dependencies]
+ksni = "0.2"
+
 [build-dependencies]
 glib-build-tools = { version = "0.20.0" }
diff --git a/lan-mouse-gtk/resources/authorization_window.ui b/lan-mouse-gtk/resources/authorization_window.ui
index 49f0c26a..1acf4ade 100644
--- a/lan-mouse-gtk/resources/authorization_window.ui
+++ b/lan-mouse-gtk/resources/authorization_window.ui
@@ -4,98 +4,94 @@
   <requires lib="libadwaita" version="1.0"/>
   <template class="AuthorizationWindow" parent="AdwWindow">
     <property name="modal">True</property>
-    <property name="width-request">180</property>
-    <property name="default-width">180</property>
-    <property name="height-request">180</property>
-    <property name="default-height">180</property>
+    <property name="resizable">False</property>
+    <property name="width-request">280</property>
+    <property name="default-width">460</property>
     <property name="title" translatable="yes">Unauthorized Device</property>
     <property name="content">
-      <object class="GtkBox">
-        <property name="orientation">vertical</property>
-        <property name="vexpand">True</property>
+      <object class="AdwToolbarView">
         <child type="top">
-          <object class="AdwHeaderBar">
-            <style>
-              <class name="flat"/>
-            </style>
-          </object>
+            <object class="AdwHeaderBar">
+              <style>
+                <class name="flat"/>
+              </style>
+            </object>
         </child>
-        <child>
-          <object class="GtkBox">
-            <property name="orientation">vertical</property>
-            <property name="spacing">30</property>
-            <property name="margin-start">30</property>
-            <property name="margin-end">30</property>
-            <property name="margin-top">30</property>
-            <property name="margin-bottom">30</property>
-            <child>
-              <object class="GtkLabel">
-                <property name="label">An unauthorized Device is trying to connect. Do you want to authorize this Device?</property>
-                <property name="width-request">100</property>
-                <property name="wrap">word-wrap</property>
-              </object>
-            </child>
-            <child>
-              <object class="AdwPreferencesGroup">
-                <property name="title">sha256 fingerprint</property>
+        <property name="content">
+          <object class="AdwClamp">
+            <property name="maximum-size">800</property>
+            <property name="tightening-threshold">0</property>
+            <property name="valign">start</property>
+            <property name="child">
+              <object class="GtkBox">
+                <property name="orientation">vertical</property>
+                <property name="spacing">18</property>
+                <property name="margin-start">12</property>
+                <property name="margin-end">12</property>
+                <property name="margin-top">12</property>
+                <property name="margin-bottom">12</property>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="label">An unauthorized Device is trying to connect. Do you want to authorize this Device?</property>
+                    <property name="wrap">True</property>
+                    <property name="wrap-mode">word-char</property>
+                    <property name="xalign">0</property>
+                  </object>
+                </child>
                 <child>
-                  <object class="AdwActionRow">
-                    <property name="child">
-                      <object class="GtkLabel" id="fingerprint">
-                        <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-                        <property name="vexpand">True</property>
-                        <property name="hexpand">False</property>
-                        <property name="wrap">True</property>
-                        <property name="wrap-mode">word-char</property>
-                        <property name="justify">center</property>
-                        <property name="xalign">0.5</property>
-                        <property name="margin-top">10</property>
-                        <property name="margin-bottom">10</property>
-                        <property name="margin-start">10</property>
-                        <property name="margin-end">10</property>
-                        <property name="width-chars">64</property>
+                  <object class="GtkBox">
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">6</property>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="label">SHA-256 Fingerprint</property>
+                        <property name="xalign">0</property>
+                        <style>
+                          <class name="heading"/>
+                        </style>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="fingerprint">
+                        <property name="editable">False</property>
+                        <property name="can-focus">True</property>
+                        <property name="hexpand">True</property>
                       </object>
-                    </property>
+                    </child>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="orientation">horizontal</property>
+                    <property name="spacing">12</property>
+                    <property name="halign">center</property>
+                    <child>
+                      <object class="GtkButton" id="cancel_button">
+                        <signal name="clicked" handler="handle_cancel" swapped="true"/>
+                        <property name="label" translatable="yes">Cancel</property>
+                        <property name="can-shrink">True</property>
+                        <style>
+                          <class name="pill"/>
+                        </style>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkButton" id="confirm_button">
+                        <signal name="clicked" handler="handle_confirm" swapped="true"/>
+                        <property name="label" translatable="yes">Authorize</property>
+                        <property name="can-shrink">True</property>
+                        <style>
+                          <class name="pill"/>
+                          <class name="destructive-action"/>
+                        </style>
+                      </object>
+                    </child>
                   </object>
                 </child>
               </object>
-            </child>
-          </object>
-        </child>
-        <child>
-          <object class="GtkBox">
-            <property name="margin-start">30</property>
-            <property name="margin-end">30</property>
-            <property name="margin-top">30</property>
-            <property name="margin-bottom">30</property>
-            <property name="orientation">horizontal</property>
-            <property name="spacing">30</property>
-            <property name="hexpand">True</property>
-            <property name="vexpand">True</property>
-            <property name="valign">end</property>
-            <child>
-              <object class="GtkButton" id="cancel_button">
-                <signal name="clicked" handler="handle_cancel" swapped="true"/>
-                <property name="label" translatable="yes">Cancel</property>
-                <property name="can-shrink">True</property>
-                <property name="height-request">50</property>
-                <property name="hexpand">True</property>
-              </object>
-            </child>
-            <child>
-              <object class="GtkButton" id="confirm_button">
-                <signal name="clicked" handler="handle_confirm" swapped="true"/>
-                <property name="label" translatable="yes">Authorize</property>
-                <property name="can-shrink">True</property>
-                <property name="height-request">50</property>
-                <property name="hexpand">True</property>
-                <style>
-                  <class name="destructive-action"/>
-                </style>
-              </object>
-            </child>
+            </property>
           </object>
-        </child>
+        </property>
       </object>
     </property>
   </template>
diff --git a/lan-mouse-gtk/resources/client_row.ui b/lan-mouse-gtk/resources/client_row.ui
index 87c8e0fc..466365f1 100644
--- a/lan-mouse-gtk/resources/client_row.ui
+++ b/lan-mouse-gtk/resources/client_row.ui
@@ -1,13 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
 	<template class="ClientRow" parent="AdwExpanderRow">
-		<property name="title">hostname</property>
+		<property name="title">Hostname</property>
 		<!-- enabled -->
 		<child type="prefix">
 			<object class="GtkSwitch" id="enable_switch">
 				<property name="valign">center</property>
 				<property name="halign">end</property>
-				<property name="tooltip-text" translatable="yes">enable</property>
+				<property name="tooltip-text" translatable="yes">Enable</property>
 			</object>
 		</child>
 		<child type="suffix">
@@ -17,33 +17,35 @@
 				<property name="icon-name">network-wired-symbolic</property>
 				<property name="valign">center</property>
 				<property name="halign">end</property>
-				<property name="tooltip-text" translatable="yes">resolve host</property>
+				<property name="tooltip-text" translatable="yes">Resolve host</property>
 			</object>
 		</child>
 		<child type="suffix">
 			<object class="GtkSpinner" id="dns_loading_indicator">
 			</object>
 		</child>
-		<!-- host -->
+		<!-- hostname -->
 		<child>
 			<object class="AdwActionRow">
-				<property name="title">hostname</property>
-				<property name="subtitle">port</property>
-				<!-- hostname -->
+				<property name="title" translatable="yes">Hostname</property>
+				<property name="subtitle" translatable="yes">IP address or DNS hostname</property>
 				<child>
 					<object class="GtkEntry" id="hostname">
-						<!-- <property name="title" translatable="yes">hostname</property> -->
 						<property name="xalign">0.5</property>
 						<property name="valign">center</property>
-						<property name="placeholder-text">hostname</property>
+						<property name="placeholder-text">192.168.1.42</property>
 						<property name="width-chars">-1</property>
 					</object>
 				</child>
-				<!-- port -->
+			</object>
+		</child>
+		<!-- port -->
+		<child>
+			<object class="AdwActionRow">
+				<property name="title" translatable="yes">Port</property>
 				<child>
 					<object class="GtkEntry" id="port">
-						<!-- <property name="title" translatable="yes">port</property> -->
-                        <property name="max-width-chars">5</property>
+						<property name="max-width-chars">5</property>
 						<property name="input_purpose">GTK_INPUT_PURPOSE_NUMBER</property>
 						<property name="xalign">0.5</property>
 						<property name="valign">center</property>
@@ -56,7 +58,8 @@
 		<!-- position -->
 		<child>
 			<object class="AdwComboRow" id="position">
-				<property name="title" translatable="yes">position</property>
+				<property name="title" translatable="yes">Position</property>
+				<property name="subtitle" translatable="yes">Where this device sits relative to your screen.</property>
 				<property name="model">
 					<object class="GtkStringList">
 						<items>
@@ -69,10 +72,26 @@
 				</property>
 			</object>
 		</child>
+		<!-- clipboard send toggle -->
+		<child>
+			<object class="AdwActionRow">
+				<property name="title" translatable="yes">Share Clipboard With This Peer</property>
+				<property name="subtitle" translatable="yes">When you copy text on this device, send it to this peer.</property>
+				<!-- non-activatable so a click on the row doesn't
+				     collapse the surrounding AdwExpanderRow; the inner
+				     GtkSwitch handles its own clicks. -->
+				<property name="activatable">false</property>
+				<child type="suffix">
+					<object class="GtkSwitch" id="clipboard_send_switch">
+						<property name="valign">center</property>
+					</object>
+				</child>
+			</object>
+		</child>
 		<!-- delete button -->
 		<child>
 			<object class="AdwActionRow" id="delete_row">
-				<property name="title">delete this client</property>
+				<property name="title">Delete This Client</property>
 				<child>
 					<object class="GtkButton" id="delete_button">
 						<signal name="activate" handler="handle_client_delete" object="delete_row" swapped="true"/>
diff --git a/lan-mouse-gtk/resources/clipboard_privacy_window.ui b/lan-mouse-gtk/resources/clipboard_privacy_window.ui
new file mode 100644
index 00000000..2ed7f515
--- /dev/null
+++ b/lan-mouse-gtk/resources/clipboard_privacy_window.ui
@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <requires lib="gtk" version="4.0"/>
+  <requires lib="libadwaita" version="1.0"/>
+  <template class="ClipboardPrivacyWindow" parent="AdwWindow">
+    <property name="modal">True</property>
+    <property name="hide-on-close">True</property>
+    <property name="default-width">560</property>
+    <property name="default-height">600</property>
+    <property name="title" translatable="yes">Clipboard Privacy</property>
+    <property name="content">
+      <object class="AdwToolbarView">
+        <child type="top">
+          <object class="AdwHeaderBar">
+            <style>
+              <class name="flat"/>
+            </style>
+          </object>
+        </child>
+        <property name="content">
+          <object class="GtkScrolledWindow">
+            <property name="vexpand">true</property>
+            <property name="hscrollbar-policy">never</property>
+            <child>
+              <object class="AdwClamp">
+                <property name="maximum-size">800</property>
+                <property name="tightening-threshold">0</property>
+                <property name="child">
+                  <object class="GtkBox">
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">18</property>
+                    <property name="margin-start">12</property>
+                    <property name="margin-end">12</property>
+                    <property name="margin-top">12</property>
+                    <property name="margin-bottom">12</property>
+                    <child>
+                      <object class="AdwPreferencesGroup">
+                        <property name="title" translatable="yes">Suppressed Apps</property>
+                        <property name="description" translatable="yes">When the frontmost app on this device matches an entry below, its clipboard contents will not be broadcast to peers.</property>
+                        <child>
+                          <object class="GtkListBox" id="entries_list">
+                            <property name="selection-mode">none</property>
+                            <style>
+                              <class name="boxed-list"/>
+                            </style>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="empty_placeholder">
+                            <property name="label" translatable="yes">No apps suppressed yet — add one below.</property>
+                            <property name="visible">false</property>
+                            <property name="margin-top">12</property>
+                            <property name="margin-bottom">12</property>
+                            <style>
+                              <class name="dim-label"/>
+                            </style>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="AdwPreferencesGroup" id="add_group">
+                        <property name="title" translatable="yes">Add an App</property>
+                        <child>
+                          <object class="AdwComboRow" id="app_picker">
+                            <property name="title" translatable="yes">Running App</property>
+                            <property name="enable-search">true</property>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="AdwActionRow">
+                            <child type="suffix">
+                              <object class="GtkButton" id="add_button">
+                                <property name="label" translatable="yes">Add to Suppression List</property>
+                                <property name="valign">center</property>
+                                <style>
+                                  <class name="suggested-action"/>
+                                </style>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                  </object>
+                </property>
+              </object>
+            </child>
+          </object>
+        </property>
+      </object>
+    </property>
+  </template>
+</interface>
diff --git a/lan-mouse-gtk/resources/fingerprint_window.ui b/lan-mouse-gtk/resources/fingerprint_window.ui
index 35d272f9..8ab8b10a 100644
--- a/lan-mouse-gtk/resources/fingerprint_window.ui
+++ b/lan-mouse-gtk/resources/fingerprint_window.ui
@@ -4,72 +4,87 @@
   <requires lib="libadwaita" version="1.0"/>
   <template class="FingerprintWindow" parent="AdwWindow">
     <property name="modal">True</property>
-    <property name="width-request">880</property>
-    <property name="default-width">880</property>
-    <property name="height-request">380</property>
-    <property name="default-height">380</property>
+    <property name="resizable">False</property>
+    <property name="width-request">280</property>
+    <property name="default-width">460</property>
     <property name="title" translatable="yes">Add Certificate Fingerprint</property>
     <property name="content">
       <object class="AdwToolbarView">
         <child type="top">
-            <object class="AdwHeaderBar"/>
+            <object class="AdwHeaderBar">
+              <style>
+                <class name="flat"/>
+              </style>
+            </object>
         </child>
         <property name="content">
           <object class="AdwClamp">
-            <property name="maximum-size">770</property>
+            <property name="maximum-size">800</property>
             <property name="tightening-threshold">0</property>
+            <property name="valign">start</property>
             <property name="child">
               <object class="GtkBox">
                 <property name="orientation">vertical</property>
                 <property name="spacing">18</property>
+                <property name="margin-start">12</property>
+                <property name="margin-end">12</property>
+                <property name="margin-top">12</property>
+                <property name="margin-bottom">12</property>
                 <child>
                   <object class="GtkLabel">
                     <property name="label">The certificate fingerprint serves as a unique identifier for your device.</property>
+                    <property name="wrap">True</property>
+                    <property name="wrap-mode">word-char</property>
+                    <property name="xalign">0</property>
                   </object>
                 </child>
                 <child>
                   <object class="GtkLabel">
-                    <property name="label">You can find it under the `General` section of the device you want to connect</property>
+                    <property name="label">You can find it under the `General` section of the device you want to connect.</property>
+                    <property name="wrap">True</property>
+                    <property name="wrap-mode">word-char</property>
+                    <property name="xalign">0</property>
                   </object>
                 </child>
                 <child>
-                  <object class="AdwPreferencesGroup">
-                    <property name="title">description</property>
+                  <object class="GtkBox">
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">6</property>
+                    <property name="margin-top">12</property>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="label">Description</property>
+                        <property name="xalign">0</property>
+                        <style>
+                          <class name="heading"/>
+                        </style>
+                      </object>
+                    </child>
                     <child>
-                      <object class="AdwActionRow">
-                        <property name="child">
-                          <object class="GtkText" id="description">
-                            <property name="margin-top">10</property>
-                            <property name="margin-bottom">10</property>
-                            <property name="margin-start">10</property>
-                            <property name="margin-end">10</property>
-                            <property name="enable-undo">True</property>
-                            <property name="hexpand">True</property>
-                            <property name="vexpand">True</property>
-                            <property name="max-length">0</property>
-                          </object>
-                        </property>
+                      <object class="GtkEntry" id="description">
+                        <property name="enable-undo">True</property>
+                        <property name="hexpand">True</property>
                       </object>
                     </child>
                   </object>
                 </child>
                 <child>
-                  <object class="AdwPreferencesGroup">
-                    <property name="title">sha256 fingerprint</property>
+                  <object class="GtkBox">
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">6</property>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="label">SHA-256 Fingerprint</property>
+                        <property name="xalign">0</property>
+                        <style>
+                          <class name="heading"/>
+                        </style>
+                      </object>
+                    </child>
                     <child>
-                      <object class="AdwActionRow">
-                        <property name="child">
-                          <object class="GtkText" id="fingerprint">
-                            <property name="margin-top">10</property>
-                            <property name="margin-bottom">10</property>
-                            <property name="margin-start">10</property>
-                            <property name="margin-end">10</property>
-                            <property name="enable-undo">True</property>
-                            <property name="hexpand">True</property>
-                            <property name="vexpand">True</property>
-                            <property name="max-length">0</property>
-                          </object>
-                        </property>
+                      <object class="GtkEntry" id="fingerprint">
+                        <property name="enable-undo">True</property>
+                        <property name="hexpand">True</property>
                       </object>
                     </child>
                   </object>
diff --git a/lan-mouse-gtk/resources/icons/lan-mouse-tray.svg b/lan-mouse-gtk/resources/icons/lan-mouse-tray.svg
new file mode 100644
index 00000000..465fe81f
--- /dev/null
+++ b/lan-mouse-gtk/resources/icons/lan-mouse-tray.svg
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Tray-only glyph for the StatusNotifierItem. Distinct from
+  de.feschber.LanMouse.svg, which is the full-detail desktop icon —
+  at tray sizes (12-22 px) the desktop icon's background and detail
+  become unreadable. This silhouette is designed to read clearly at
+  the smallest tray sizes while keeping the same mouse motif as the
+  desktop icon.
+-->
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16">
+  <!-- Mouse body silhouette. Filled so the host's theme tinting (or
+       lack thereof) renders predictably. Light grey reads well on
+       dark waybar/Plasma panels and is still visible on light ones. -->
+  <path d="M 8 1.4
+           C 4.9 1.4 3.1 3.3 3.1 6.2
+           V 11.4
+           C 3.1 13.8 5.2 14.6 8 14.6
+           C 10.8 14.6 12.9 13.8 12.9 11.4
+           V 6.2
+           C 12.9 3.3 11.1 1.4 8 1.4 Z"
+        fill="#e6e6e6"/>
+  <!-- Scroll-wheel slot: a small dark capsule near the top centre.
+       Doubles as the visual anchor that says "this is a mouse" at
+       sizes where the body outline alone could read as a pill. -->
+  <rect x="7.25" y="3.6" width="1.5" height="2.4" rx="0.75" fill="#2a2a2a"/>
+</svg>
diff --git a/lan-mouse-gtk/resources/key_row.ui b/lan-mouse-gtk/resources/key_row.ui
index 48406756..864bdd9c 100644
--- a/lan-mouse-gtk/resources/key_row.ui
+++ b/lan-mouse-gtk/resources/key_row.ui
@@ -1,16 +1,117 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
-	<template class="KeyRow" parent="AdwActionRow">
-		<child type="prefix">
-			<object class="GtkButton" id="delete_button">
+	<template class="KeyRow" parent="AdwExpanderRow">
+		<!-- compact summary of non-default settings, shown in the
+		     title-row suffix area so the user can scan a collapsed
+		     row and see what's been customized for this peer.
+		     Visibility flips on at runtime when either setting
+		     differs from its default. -->
+		<child type="suffix">
+			<object class="GtkLabel" id="settings_summary">
 				<property name="valign">center</property>
-				<property name="halign">end</property>
-				<property name="tooltip-text" translatable="yes">revoke authorization</property>
-                <property name="icon-name">edit-delete-symbolic</property>
+				<property name="visible">false</property>
 				<style>
-                    <class name="flat"/>
+					<class name="dim-label"/>
+					<class name="caption"/>
 				</style>
 			</object>
 		</child>
+		<!-- TLS fingerprint as the first row inside the expansion.
+		     Subtitle holds the actual hash so it stays selectable
+		     even though the row itself isn't activatable. The copy
+		     button writes the fingerprint to the clipboard. -->
+		<child>
+			<object class="AdwActionRow" id="fingerprint_row">
+				<property name="title" translatable="yes">Fingerprint</property>
+				<property name="activatable">false</property>
+				<property name="subtitle-selectable">true</property>
+				<style>
+					<class name="property"/>
+				</style>
+				<child type="suffix">
+					<object class="GtkButton" id="copy_fingerprint_button">
+						<property name="valign">center</property>
+						<property name="icon-name">edit-copy-symbolic</property>
+						<property name="tooltip-text" translatable="yes">Copy fingerprint to clipboard</property>
+						<style>
+							<class name="flat"/>
+						</style>
+					</object>
+				</child>
+			</object>
+		</child>
+		<!-- natural-scroll toggle -->
+		<child>
+			<object class="AdwActionRow">
+				<property name="title" translatable="yes">Natural Scrolling</property>
+				<property name="subtitle" translatable="yes">Invert the direction of forwarded scroll events.</property>
+				<!-- non-activatable so clicks don't bubble up and
+				     collapse the surrounding AdwExpanderRow. The inner
+				     GtkSwitch handles its own clicks just fine. -->
+				<property name="activatable">false</property>
+				<child type="suffix">
+					<object class="GtkSwitch" id="natural_scroll_switch">
+						<property name="valign">center</property>
+					</object>
+				</child>
+			</object>
+		</child>
+		<!-- mouse-sensitivity numeric -->
+		<child>
+			<object class="AdwActionRow">
+				<property name="title" translatable="yes">Mouse Sensitivity</property>
+				<property name="subtitle" translatable="yes">Adjust the speed of forwarded mouse movement.</property>
+				<property name="activatable">false</property>
+				<child type="suffix">
+					<object class="GtkSpinButton" id="sensitivity_spin">
+						<property name="valign">center</property>
+						<property name="numeric">true</property>
+						<property name="digits">2</property>
+						<property name="adjustment">
+							<object class="GtkAdjustment">
+								<property name="lower">0.1</property>
+								<property name="upper">5.0</property>
+								<property name="step-increment">0.1</property>
+								<property name="page-increment">0.5</property>
+								<property name="value">1.0</property>
+							</object>
+						</property>
+					</object>
+				</child>
+			</object>
+		</child>
+		<!-- clipboard receive toggle -->
+		<child>
+			<object class="AdwActionRow">
+				<property name="title" translatable="yes">Accept Clipboard From This Peer</property>
+				<property name="subtitle" translatable="yes">Apply text this peer copies to your clipboard.</property>
+				<property name="activatable">false</property>
+				<child type="suffix">
+					<object class="GtkSwitch" id="clipboard_receive_switch">
+						<property name="valign">center</property>
+					</object>
+				</child>
+			</object>
+		</child>
+		<!-- revoke authorization (mirrors ClientRow's delete row at
+		     the bottom of its expansion body — destructive action,
+		     hidden behind the expander to avoid fat-finger reaches) -->
+		<child>
+			<object class="AdwActionRow" id="delete_row">
+				<property name="title" translatable="yes">Revoke Authorization</property>
+				<property name="activatable">false</property>
+				<child>
+					<object class="GtkButton" id="delete_button">
+						<property name="icon-name">user-trash-symbolic</property>
+						<property name="valign">center</property>
+						<property name="halign">center</property>
+						<property name="tooltip-text" translatable="yes">Revoke authorization</property>
+						<style>
+							<class name="error"/>
+						</style>
+					</object>
+				</child>
+			</object>
+		</child>
 	</template>
 </interface>
diff --git a/lan-mouse-gtk/resources/resources.gresource.xml b/lan-mouse-gtk/resources/resources.gresource.xml
index d3820741..61fb99a2 100644
--- a/lan-mouse-gtk/resources/resources.gresource.xml
+++ b/lan-mouse-gtk/resources/resources.gresource.xml
@@ -6,9 +6,11 @@
     <file compressed="true" preprocess="xml-stripblanks">fingerprint_window.ui</file>
     <file compressed="true" preprocess="xml-stripblanks">client_row.ui</file>
     <file compressed="true" preprocess="xml-stripblanks">key_row.ui</file>
+    <file compressed="true" preprocess="xml-stripblanks">clipboard_privacy_window.ui</file>
   </gresource>
   <gresource prefix="/de/feschber/LanMouse/icons">
     <file compressed="true" preprocess="xml-stripblanks">de.feschber.LanMouse.svg</file>
+    <file compressed="true" preprocess="xml-stripblanks" alias="lan-mouse-tray.svg">icons/lan-mouse-tray.svg</file>
     <!--
       Bundled Adwaita symbolic icons so the GTK frontend has a complete icon set
       on platforms (notably macOS) where the Adwaita icon theme is not installed.
diff --git a/lan-mouse-gtk/resources/window.ui b/lan-mouse-gtk/resources/window.ui
index 609ea4e8..c12b8bb8 100644
--- a/lan-mouse-gtk/resources/window.ui
+++ b/lan-mouse-gtk/resources/window.ui
@@ -2,15 +2,9 @@
 <interface>
   <requires lib="gtk" version="4.0"/>
   <requires lib="libadwaita" version="1.0"/>
-  <menu id="main-menu">
-    <item>
-      <attribute name="label" translatable="yes">_Close window</attribute>
-      <attribute name="action">window.close</attribute>
-    </item>
-  </menu>
   <template class="LanMouseWindow" parent="AdwApplicationWindow">
-    <property name="width-request">600</property>
-    <property name="height-request">700</property>
+    <property name="default-width">600</property>
+    <property name="default-height">1400</property>
     <property name="title" translatable="yes">Lan Mouse</property>
     <property name="show-menubar">True</property>
     <property name="content">
@@ -18,12 +12,6 @@
         <property name="orientation">vertical</property>
         <child type="top">
           <object class="AdwHeaderBar">
-            <child type ="end">
-              <object class="GtkMenuButton">
-                <property name="icon-name">open-menu-symbolic</property>
-                <property name="menu-model">main-menu</property>
-              </object>
-            </child>
             <style>
               <class name="flat"/>
             </style>
@@ -32,25 +20,33 @@
         <child>
           <object class="AdwToastOverlay" id="toast_overlay">
             <child>
-              <object class="AdwStatusPage">
-                <property name="title" translatable="yes">Lan Mouse</property>
-                <property name="description" translatable="yes">easily use your mouse and keyboard on multiple computers</property>
-                <property name="icon-name">de.feschber.LanMouse</property>
-                <property name="child">
+              <object class="GtkScrolledWindow">
+                <property name="vexpand">true</property>
+                <property name="hexpand">true</property>
+                <property name="hscrollbar-policy">never</property>
+                <property name="vscrollbar-policy">automatic</property>
+                <property name="propagate-natural-height">true</property>
+                <child>
+                  <object class="AdwStatusPage">
+                    <property name="title" translatable="yes">Lan Mouse</property>
+                    <property name="description" translatable="yes">Easily use your mouse and keyboard on multiple computers.</property>
+                    <property name="icon-name">de.feschber.LanMouse</property>
+                    <property name="child">
                   <object class="AdwClamp">
-                  <property name="maximum-size">600</property>
+                  <property name="maximum-size">800</property>
                   <property name="tightening-threshold">0</property>
                   <property name="child">
                     <object class="GtkBox">
                     <property name="orientation">vertical</property>
-                    <property name="spacing">12</property>
+                    <property name="spacing">24</property>
+                    <property name="margin-bottom">36</property>
                     <child>
                       <object class="AdwPreferencesGroup" id="capture_emulation_group">
                       <property name="title" translatable="yes">Capture / Emulation Status</property>
                         <child>
                           <object class="AdwActionRow" id="capture_status_row">
-                            <property name="title">input capture is disabled</property>
-                            <property name="subtitle">required for outgoing and incoming connections</property>
+                            <property name="title">Input Capture Disabled</property>
+                            <property name="subtitle">Required for outgoing and incoming connections.</property>
                             <property name="icon-name">dialog-warning-symbolic</property>
                             <child>
                               <object class="GtkButton" id="input_capture_button">
@@ -75,8 +71,8 @@
                         </child>
                         <child>
                           <object class="AdwActionRow" id="emulation_status_row">
-                            <property name="title">input emulation is disabled</property>
-                            <property name="subtitle">required for incoming connections</property>
+                            <property name="title">Input Emulation Disabled</property>
+                            <property name="subtitle">Required for incoming connections.</property>
                             <property name="icon-name">dialog-warning-symbolic</property>
                             <child>
                               <object class="GtkButton" id="input_emulation_button">
@@ -121,7 +117,7 @@
                         -->
                         <child>
                           <object class="AdwActionRow">
-                            <property name="title">hostname &#38;amp; port</property>
+                            <property name="title">Hostname &#38;amp; Port</property>
                             <child>
                               <object class="GtkButton" id="copy-hostname-button">
                                     <!--<property name="icon-name">edit-copy-symbolic</property>-->
@@ -185,7 +181,7 @@
                         </child>
                         <child>
                           <object class="AdwActionRow" id="fingerprint_row">
-                            <property name="title">certificate fingerprint</property>
+                            <property name="title">Certificate Fingerprint</property>
                             <property name="icon-name">auth-fingerprint-symbolic</property>
                             <child>
                               <object class="GtkButton" id="copy-fingerprint-button">
@@ -200,7 +196,56 @@
                     </child>
                     <child>
                       <object class="AdwPreferencesGroup">
-                        <property name="title" translatable="yes">Connections</property>
+                        <property name="title" translatable="yes">Outgoing Auto-Release</property>
+                        <property name="description" translatable="yes">Fallback release when the peer can't tell us the cursor reached its edge — typically because the peer's screen is locked. No effect on peers that release themselves; the cursor-release keybind still works either way.</property>
+                        <child>
+                          <object class="AdwActionRow" id="release_threshold_row">
+                            <property name="title" translatable="yes">Release Threshold</property>
+                            <property name="subtitle" translatable="yes">Pixels of wall-press past the entry edge before auto-release fires.</property>
+                            <child type="suffix">
+                              <object class="GtkLabel" id="release_threshold_value">
+                                <property name="label">Disabled</property>
+                                <property name="valign">center</property>
+                                <property name="width-chars">8</property>
+                                <property name="xalign">1.0</property>
+                                <style>
+                                  <class name="dim-label"/>
+                                  <class name="numeric"/>
+                                </style>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="GtkScale" id="release_threshold_scale">
+                            <property name="orientation">horizontal</property>
+                            <property name="hexpand">true</property>
+                            <property name="draw-value">false</property>
+                            <property name="round-digits">0</property>
+                            <property name="margin-top">12</property>
+                            <property name="adjustment">
+                              <object class="GtkAdjustment" id="release_threshold_adjustment">
+                                <property name="lower">0</property>
+                                <property name="upper">500</property>
+                                <property name="step-increment">10</property>
+                                <property name="page-increment">50</property>
+                                <property name="value">0</property>
+                              </object>
+                            </property>
+                            <marks>
+                              <mark value="0" position="bottom">off</mark>
+                              <mark value="50" position="bottom">50</mark>
+                              <mark value="100" position="bottom">100</mark>
+                              <mark value="200" position="bottom">200</mark>
+                              <mark value="500" position="bottom">500</mark>
+                            </marks>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="AdwPreferencesGroup">
+                        <property name="title" translatable="yes">Outgoing Connections</property>
                         <property name="header-suffix">
                           <object class="GtkButton">
                             <signal name="clicked" handler="handle_add_client_pressed" swapped="true"/>
@@ -220,8 +265,8 @@
                             <property name="selection-mode">none</property>
                             <child type="placeholder">
                               <object class="AdwActionRow" id="client_placeholder">
-                                <property name="title">No connections!</property>
-                                <property name="subtitle">add a new client via the + button</property>
+                                <property name="title">No Connections</property>
+                                <property name="subtitle">Add a new client via the + button.</property>
                               </object>
                             </child>
                             <style>
@@ -253,8 +298,8 @@
                             <property name="selection-mode">none</property>
                             <child type="placeholder">
                               <object class="AdwActionRow" id="authorized_placeholder">
-                                <property name="title">no devices registered!</property>
-                                <property name="subtitle">authorize a new device via the "Authorize" button</property>
+                                <property name="title">No Devices Registered</property>
+                                <property name="subtitle">Authorize a new device via the "Authorize" button.</property>
                               </object>
                             </child>
                             <style>
@@ -264,11 +309,51 @@
                         </child>
                       </object>
                     </child>
+                    <child>
+                      <object class="AdwPreferencesGroup">
+                        <property name="title" translatable="yes">Network Discovery</property>
+                        <property name="description" translatable="yes">Advertise (and consume) Bonjour records so peers can pick the OS-preferred interface on multi-homed hosts. Turn off on networks where mDNS multicast is firewalled.</property>
+                        <child>
+                          <object class="AdwActionRow" id="mdns_discovery_row">
+                            <property name="title" translatable="yes">mDNS Discovery</property>
+                            <property name="subtitle" translatable="yes">Use _lan-mouse._udp.local. for service order hints.</property>
+                            <child type="suffix">
+                              <object class="GtkSwitch" id="mdns_discovery_switch">
+                                <property name="valign">center</property>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="AdwPreferencesGroup">
+                        <property name="title" translatable="yes">Clipboard Privacy</property>
+                        <property name="description" translatable="yes">Apps in this list never share their clipboard with peers — useful for password managers and other tools whose clipboard you don't want syncing.</property>
+                        <child>
+                          <object class="AdwActionRow" id="clipboard_privacy_row">
+                            <property name="title" translatable="yes">Suppressed Apps</property>
+                            <property name="subtitle" translatable="yes">0 apps</property>
+                            <child type="suffix">
+                              <object class="GtkButton" id="clipboard_privacy_button">
+                                <property name="label" translatable="yes">Manage</property>
+                                <property name="valign">center</property>
+                                <style>
+                                  <class name="flat"/>
+                                </style>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
                     </object>
                   </property>
                   </object>
                 </property>
               </object>
+                </child>
+              </object>
             </child>
           </object>
         </child>
diff --git a/lan-mouse-gtk/src/authorization_window/imp.rs b/lan-mouse-gtk/src/authorization_window/imp.rs
index 69b15046..cbe728dd 100644
--- a/lan-mouse-gtk/src/authorization_window/imp.rs
+++ b/lan-mouse-gtk/src/authorization_window/imp.rs
@@ -4,7 +4,7 @@ use adw::prelude::*;
 use adw::subclass::prelude::*;
 use glib::subclass::InitializingObject;
 use gtk::{
-    Button, CompositeTemplate, Label,
+    Button, CompositeTemplate, Entry,
     glib::{self, subclass::Signal},
     template_callbacks,
 };
@@ -13,7 +13,7 @@ use gtk::{
 #[template(resource = "/de/feschber/LanMouse/authorization_window.ui")]
 pub struct AuthorizationWindow {
     #[template_child]
-    pub fingerprint: TemplateChild<Label>,
+    pub fingerprint: TemplateChild<Entry>,
     #[template_child]
     pub cancel_button: TemplateChild<Button>,
     #[template_child]
@@ -68,6 +68,14 @@ impl ObjectImpl for AuthorizationWindow {
             ]
         })
     }
+
+    fn constructed(&self) {
+        self.parent_constructed();
+
+        // Esc + Cmd/Ctrl+W close the modal.
+        let obj = self.obj();
+        crate::modal_keys::wire_close_shortcuts(&*obj);
+    }
 }
 
 impl WidgetImpl for AuthorizationWindow {}
diff --git a/lan-mouse-gtk/src/client_object.rs b/lan-mouse-gtk/src/client_object.rs
index 9f148fdc..18e12b51 100644
--- a/lan-mouse-gtk/src/client_object.rs
+++ b/lan-mouse-gtk/src/client_object.rs
@@ -26,6 +26,8 @@ impl ClientObject {
                     .collect::<Vec<_>>(),
             )
             .property("resolving", state.resolving)
+            .property("peer-commit", peer_commit_to_string(state.peer_commit))
+            .property("clipboard-send", client.clipboard_send)
             .build()
     }
 
@@ -34,6 +36,14 @@ impl ClientObject {
     }
 }
 
+/// Render the 8-byte ASCII commit hash carried in
+/// [`lan_mouse_ipc::ClientState::peer_commit`] as a `String`. `None`
+/// in → `None` out (peer hasn't sent a Hello yet, or speaks an older
+/// proto).
+pub fn peer_commit_to_string(commit: Option<[u8; 8]>) -> Option<String> {
+    commit.and_then(|c| std::str::from_utf8(&c).ok().map(str::to_string))
+}
+
 #[derive(Default, Clone)]
 pub struct ClientData {
     pub handle: ClientHandle,
@@ -43,4 +53,6 @@ pub struct ClientData {
     pub position: String,
     pub resolving: bool,
     pub ips: Vec<String>,
+    pub peer_commit: Option<String>,
+    pub clipboard_send: bool,
 }
diff --git a/lan-mouse-gtk/src/client_object/imp.rs b/lan-mouse-gtk/src/client_object/imp.rs
index 016ae8c8..4ca9520a 100644
--- a/lan-mouse-gtk/src/client_object/imp.rs
+++ b/lan-mouse-gtk/src/client_object/imp.rs
@@ -19,6 +19,8 @@ pub struct ClientObject {
     #[property(name = "position", get, set, type = String, member = position)]
     #[property(name = "resolving", get, set, type = bool, member = resolving)]
     #[property(name = "ips", get, set, type = Vec<String>, member = ips)]
+    #[property(name = "peer-commit", get, set, type = Option<String>, member = peer_commit)]
+    #[property(name = "clipboard-send", get, set, type = bool, member = clipboard_send)]
     pub data: RefCell<ClientData>,
 }
 
diff --git a/lan-mouse-gtk/src/client_row.rs b/lan-mouse-gtk/src/client_row.rs
index cd3d02b3..a76dfe04 100644
--- a/lan-mouse-gtk/src/client_row.rs
+++ b/lan-mouse-gtk/src/client_row.rs
@@ -8,6 +8,16 @@ use lan_mouse_ipc::{DEFAULT_PORT, Position};
 
 use super::ClientObject;
 
+const NO_HOSTNAME_MARKUP: &str =
+    "<span font_style=\"italic\" font_weight=\"light\" foreground=\"darkgrey\">No Hostname</span>";
+
+fn collapsed_title(hostname: Option<String>, port: u32) -> String {
+    match hostname.as_deref() {
+        Some(h) if !h.is_empty() => format!("{h}:{port}"),
+        _ => NO_HOSTNAME_MARKUP.to_string(),
+    }
+}
+
 glib::wrapper! {
     pub struct ClientRow(ObjectSubclass<imp::ClientRow>)
     @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ExpanderRow,
@@ -53,13 +63,6 @@ impl ClientRow {
             .sync_create()
             .build();
 
-        // bind hostname to title
-        let title_binding = client_object
-            .bind_property("hostname", self, "title")
-            .transform_to(|_, v: Option<String>| v.or(Some("<span font_style=\"italic\" font_weight=\"light\" foreground=\"darkgrey\">no hostname!</span>".to_string())))
-            .sync_create()
-            .build();
-
         // bind port to port edit field
         let port_binding = client_object
             .bind_property("port", &self.imp().port.get(), "text")
@@ -73,11 +76,29 @@ impl ClientRow {
             .sync_create()
             .build();
 
-        // bind port to subtitle
-        let subtitle_binding = client_object
-            .bind_property("port", self, "subtitle")
-            .sync_create()
-            .build();
+        // collapsed title: "hostname:port" (or markup fallback when hostname is empty)
+        let row_for_hostname = self.clone();
+        let hostname_title_handler =
+            client_object.connect_notify_local(Some("hostname"), move |obj, _| {
+                let hostname: Option<String> = obj.property("hostname");
+                let port: u32 = obj.property("port");
+                row_for_hostname.set_title(&collapsed_title(hostname, port));
+            });
+        let row_for_port = self.clone();
+        let port_title_handler = client_object.connect_notify_local(Some("port"), move |obj, _| {
+            let hostname: Option<String> = obj.property("hostname");
+            let port: u32 = obj.property("port");
+            row_for_port.set_title(&collapsed_title(hostname, port));
+        });
+        self.set_title(&collapsed_title(
+            client_object.property::<Option<String>>("hostname"),
+            client_object.property::<u32>("port"),
+        ));
+        self.set_subtitle("");
+        self.imp()
+            .title_handlers
+            .borrow_mut()
+            .extend([hostname_title_handler, port_title_handler]);
 
         // bind position to selected position
         let position_binding = client_object
@@ -114,21 +135,50 @@ impl ClientRow {
             .sync_create()
             .build();
 
+        // bind clipboard-send to switch state
+        let clipboard_send_state_binding = client_object
+            .bind_property(
+                "clipboard-send",
+                &self.imp().clipboard_send_switch.get(),
+                "state",
+            )
+            .sync_create()
+            .build();
+        let clipboard_send_active_binding = client_object
+            .bind_property(
+                "clipboard-send",
+                &self.imp().clipboard_send_switch.get(),
+                "active",
+            )
+            .sync_create()
+            .build();
+
         bindings.push(active_binding);
         bindings.push(switch_position_binding);
         bindings.push(hostname_binding);
-        bindings.push(title_binding);
         bindings.push(port_binding);
-        bindings.push(subtitle_binding);
         bindings.push(position_binding);
         bindings.push(resolve_binding);
         bindings.push(ip_binding);
+        bindings.push(clipboard_send_state_binding);
+        bindings.push(clipboard_send_active_binding);
+
+        // Render the initial collapsed subtitle from whatever
+        // peer_commit the ClientObject was created with. Subsequent
+        // changes are pushed by `Window::update_client_state` calling
+        // `refresh_version_status` after writing the new property.
+        self.refresh_version_status();
     }
 
     pub fn unbind(&self) {
         for binding in self.imp().bindings.borrow_mut().drain(..) {
             binding.unbind();
         }
+        if let Some(client_object) = self.imp().client_object.borrow().as_ref() {
+            for handler in self.imp().title_handlers.borrow_mut().drain(..) {
+                client_object.disconnect(handler);
+            }
+        }
     }
 
     pub fn set_active(&self, active: bool) {
@@ -150,4 +200,38 @@ impl ClientRow {
     pub fn set_dns_state(&self, resolved: bool) {
         self.imp().set_dns_state(resolved);
     }
+
+    pub fn set_clipboard_send(&self, value: bool) {
+        self.imp().set_clipboard_send(value);
+    }
+
+    /// Recompute the collapsed subtitle (Pango markup) based on the
+    /// current `peer-commit` property and the local build's commit.
+    /// Soft-warn semantics: a missing or mismatched peer commit
+    /// surfaces as orange text but never blocks traffic. Called by
+    /// the window after `update_client_state` writes the new
+    /// `peer-commit`. The dns-status icon is left to its existing
+    /// `set_dns_state` handler so the two indicators don't fight
+    /// for the same CSS class.
+    pub fn refresh_version_status(&self) {
+        let peer: Option<String> = self
+            .imp()
+            .client_object
+            .borrow()
+            .as_ref()
+            .and_then(|co| co.property::<Option<String>>("peer-commit"));
+        let local = crate::local_commit_str();
+        let markup = match peer.as_deref() {
+            None => format!(
+                r##"<span foreground="#ffaa33">Peer version: unknown · Ours: {local}</span>"##
+            ),
+            Some(p) if p == local.as_str() => {
+                format!(r##"<span foreground="#33cc66">Peer version: {p} · matched</span>"##)
+            }
+            Some(p) => {
+                format!(r##"<span foreground="#ffaa33">Peer version: {p} · Ours: {local}</span>"##)
+            }
+        };
+        self.set_subtitle(&markup);
+    }
 }
diff --git a/lan-mouse-gtk/src/client_row/imp.rs b/lan-mouse-gtk/src/client_row/imp.rs
index 67e9034b..8790422e 100644
--- a/lan-mouse-gtk/src/client_row/imp.rs
+++ b/lan-mouse-gtk/src/client_row/imp.rs
@@ -17,6 +17,8 @@ pub struct ClientRow {
     #[template_child]
     pub enable_switch: TemplateChild<gtk::Switch>,
     #[template_child]
+    pub clipboard_send_switch: TemplateChild<gtk::Switch>,
+    #[template_child]
     pub dns_button: TemplateChild<gtk::Button>,
     #[template_child]
     pub hostname: TemplateChild<gtk::Entry>,
@@ -31,10 +33,12 @@ pub struct ClientRow {
     #[template_child]
     pub dns_loading_indicator: TemplateChild<gtk::Spinner>,
     pub bindings: RefCell<Vec<Binding>>,
+    pub title_handlers: RefCell<Vec<SignalHandlerId>>,
     hostname_change_handler: RefCell<Option<SignalHandlerId>>,
     port_change_handler: RefCell<Option<SignalHandlerId>>,
     position_change_handler: RefCell<Option<SignalHandlerId>>,
     set_state_handler: RefCell<Option<SignalHandlerId>>,
+    pub clipboard_send_handler: RefCell<Option<SignalHandlerId>>,
     pub client_object: RefCell<Option<ClientObject>>,
 }
 
@@ -102,6 +106,18 @@ impl ObjectImpl for ClientRow {
             }
         ));
         self.set_state_handler.replace(Some(handler));
+        let handler = self.clipboard_send_switch.connect_state_set(clone!(
+            #[weak(rename_to = row)]
+            self,
+            #[upgrade_or]
+            glib::Propagation::Proceed,
+            move |_, state| {
+                row.obj()
+                    .emit_by_name::<()>("request-clipboard-send-change", &[&state]);
+                glib::Propagation::Proceed
+            }
+        ));
+        self.clipboard_send_handler.replace(Some(handler));
     }
 
     fn signals() -> &'static [glib::subclass::Signal] {
@@ -122,6 +138,9 @@ impl ObjectImpl for ClientRow {
                 Signal::builder("request-position-change")
                     .param_types([u32::static_type()])
                     .build(),
+                Signal::builder("request-clipboard-send-change")
+                    .param_types([bool::static_type()])
+                    .build(),
             ]
         })
     }
@@ -221,6 +240,22 @@ impl ClientRow {
             self.dns_button.set_css_classes(&["warning"])
         }
     }
+
+    /// Push a server-originated `clipboard-send` value into the
+    /// switch without retriggering the user-change signal — same
+    /// block/unblock pattern as `set_active` for the activate
+    /// switch.
+    pub(super) fn set_clipboard_send(&self, value: bool) {
+        let handler = self.clipboard_send_handler.borrow();
+        let handler = handler.as_ref().expect("signal handler");
+        self.clipboard_send_switch.block_signal(handler);
+        self.client_object
+            .borrow_mut()
+            .as_mut()
+            .expect("client object")
+            .set_clipboard_send(value);
+        self.clipboard_send_switch.unblock_signal(handler);
+    }
 }
 
 impl WidgetImpl for ClientRow {}
diff --git a/lan-mouse-gtk/src/clipboard_privacy_window.rs b/lan-mouse-gtk/src/clipboard_privacy_window.rs
new file mode 100644
index 00000000..5358798d
--- /dev/null
+++ b/lan-mouse-gtk/src/clipboard_privacy_window.rs
@@ -0,0 +1,54 @@
+mod imp;
+
+use glib::Object;
+use gtk::{gio, glib, subclass::prelude::*};
+use lan_mouse_ipc::RunningApp;
+
+glib::wrapper! {
+    pub struct ClipboardPrivacyWindow(ObjectSubclass<imp::ClipboardPrivacyWindow>)
+    @extends adw::Window, gtk::Window, gtk::Widget,
+    @implements gio::ActionGroup, gio::ActionMap, gtk::Accessible, gtk::Buildable,
+                gtk::ConstraintTarget, gtk::Native, gtk::Root, gtk::ShortcutManager;
+}
+
+impl ClipboardPrivacyWindow {
+    pub fn new() -> Self {
+        Object::builder().build()
+    }
+
+    /// Replace the displayed list with the host-OS strings `apps`
+    /// and rebuild the UI. Called from `Window::set_suppressed_apps`
+    /// when the daemon pushes
+    /// [`lan_mouse_ipc::FrontendEvent::SuppressedAppsUpdated`].
+    /// Also re-applies the picker filter against the cached
+    /// running-apps snapshot so a removed app reappears in the
+    /// picker immediately, instead of waiting for the 5 s
+    /// auto-refresh tick.
+    pub fn set_apps(&self, apps: Vec<String>) {
+        self.imp().apps.replace(apps);
+        self.imp().rebuild_list();
+        let cached = self.imp().last_running.borrow().clone();
+        if !cached.is_empty() {
+            self.imp().set_running_apps(cached);
+        }
+    }
+
+    /// Replace the picker contents with the daemon-supplied
+    /// running-apps snapshot.
+    pub fn set_running_apps(&self, running: Vec<RunningApp>) {
+        self.imp().set_running_apps(running);
+    }
+
+    /// True when the picker's popover is open. Used by the
+    /// auto-refresh timer to skip thrashing the user's selection
+    /// while they're interacting with the dropdown.
+    pub fn picker_is_open(&self) -> bool {
+        self.imp().picker_is_open()
+    }
+}
+
+impl Default for ClipboardPrivacyWindow {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/lan-mouse-gtk/src/clipboard_privacy_window/imp.rs b/lan-mouse-gtk/src/clipboard_privacy_window/imp.rs
new file mode 100644
index 00000000..7e4e2ae3
--- /dev/null
+++ b/lan-mouse-gtk/src/clipboard_privacy_window/imp.rs
@@ -0,0 +1,391 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::sync::OnceLock;
+
+use adw::ComboRow;
+use adw::PreferencesGroup;
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use gio::ListStore;
+use glib::object::Cast;
+use glib::subclass::InitializingObject;
+use gtk::{
+    Box as GtkBox, Button, CompositeTemplate, Image, Label, ListBox, ListItem, Orientation,
+    SignalListItemFactory, gdk, gio,
+    glib::{self, subclass::Signal},
+    template_callbacks,
+};
+use lan_mouse_ipc::{HostKind, RunningApp};
+
+use crate::running_app_object::RunningAppObject;
+
+/// Cached display name + icon texture for one identifier. Used to
+/// render the suppressed-apps list with the same icon+name
+/// treatment as the picker; the cache lets the rebuild reuse the
+/// running-apps icons without re-decoding the PNG bytes per row.
+pub struct AppMetadata {
+    display_name: String,
+    icon: Option<gdk::Texture>,
+}
+
+#[derive(CompositeTemplate, Default)]
+#[template(resource = "/de/feschber/LanMouse/clipboard_privacy_window.ui")]
+pub struct ClipboardPrivacyWindow {
+    #[template_child]
+    pub entries_list: TemplateChild<ListBox>,
+    #[template_child]
+    pub empty_placeholder: TemplateChild<Label>,
+    #[template_child]
+    pub add_group: TemplateChild<PreferencesGroup>,
+    #[template_child]
+    pub app_picker: TemplateChild<ComboRow>,
+    #[template_child]
+    pub add_button: TemplateChild<Button>,
+    /// Latest server-confirmed list (host-OS strings only). Rebuilt
+    /// from scratch on every update — the list is small enough that
+    /// diffing isn't worth the complexity.
+    pub apps: RefCell<Vec<String>>,
+    /// Last running-apps snapshot from
+    /// `frontmost_app::list_running_apps`. Cached so a change to
+    /// the suppression list (add/remove) can immediately re-apply
+    /// the "filter out already-suppressed entries" rule against
+    /// the picker, instead of waiting for the 5 s auto-refresh.
+    pub last_running: RefCell<Vec<RunningApp>>,
+    /// Display-name + icon-texture lookup keyed by identifier.
+    /// Populated whenever `set_running_apps` runs (covers
+    /// currently-running apps) and lazily extended via
+    /// `input_capture::frontmost_app::lookup_app_metadata` when
+    /// the suppressed-apps rebuild encounters an identifier we
+    /// haven't seen before — typically apps the user added but
+    /// aren't running right now.
+    pub metadata: RefCell<HashMap<String, AppMetadata>>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for ClipboardPrivacyWindow {
+    const NAME: &'static str = "ClipboardPrivacyWindow";
+    const ABSTRACT: bool = false;
+
+    type Type = super::ClipboardPrivacyWindow;
+    type ParentType = adw::Window;
+
+    fn class_init(klass: &mut Self::Class) {
+        klass.bind_template();
+        klass.bind_template_callbacks();
+    }
+
+    fn instance_init(obj: &InitializingObject<Self>) {
+        obj.init_template();
+    }
+}
+
+#[template_callbacks]
+impl ClipboardPrivacyWindow {}
+
+impl ObjectImpl for ClipboardPrivacyWindow {
+    fn signals() -> &'static [Signal] {
+        static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
+        SIGNALS.get_or_init(|| {
+            vec![
+                Signal::builder("request-add")
+                    .param_types([String::static_type()])
+                    .build(),
+                Signal::builder("request-remove")
+                    .param_types([String::static_type()])
+                    .build(),
+            ]
+        })
+    }
+
+    fn constructed(&self) {
+        self.parent_constructed();
+
+        // Picker title; subtitle gets rendered by the expression
+        // (selected app's display name).
+        let _ = HostKind::current();
+        self.app_picker.set_title("App");
+        self.add_group
+            .set_description(Some("Pick a running app to suppress."));
+
+        // Selected-display: use a closure expression that pulls
+        // display_name off the RunningAppObject. Without this the
+        // row's subtitle would be the GObject's debug repr.
+        let expression = gtk::ClosureExpression::new::<String>(
+            &[] as &[gtk::Expression],
+            glib::closure!(|obj: Option<glib::Object>| {
+                obj.and_then(|o| o.downcast::<RunningAppObject>().ok())
+                    .map(|app| app.display_name())
+                    .unwrap_or_default()
+            }),
+        );
+        self.app_picker.set_expression(Some(&expression));
+
+        // Popover rows: icon + label, single line. Each row has a
+        // fixed minimum width (320 px) so the popover doesn't
+        // shrink horizontally as the user types into the search
+        // field — without this, filtering down to one short name
+        // collapses the popover to ~120 px which is jarring.
+        let factory = SignalListItemFactory::new();
+        factory.connect_setup(|_, list_item| {
+            let row = GtkBox::new(Orientation::Horizontal, 10);
+            row.set_hexpand(true);
+            row.set_size_request(320, -1);
+            let image = Image::new();
+            image.set_pixel_size(20);
+            let label = Label::new(None);
+            label.set_xalign(0.0);
+            label.set_hexpand(true);
+            label.set_ellipsize(gtk::pango::EllipsizeMode::End);
+            row.append(&image);
+            row.append(&label);
+            list_item
+                .downcast_ref::<ListItem>()
+                .expect("ListItem")
+                .set_child(Some(&row));
+        });
+        factory.connect_bind(|_, list_item| {
+            let item = list_item.downcast_ref::<ListItem>().expect("ListItem");
+            let Some(obj) = item.item() else { return };
+            let Ok(app) = obj.downcast::<RunningAppObject>() else {
+                return;
+            };
+            let Some(child) = item.child() else { return };
+            let Ok(row) = child.downcast::<GtkBox>() else {
+                return;
+            };
+            // first child = Image, next = Label
+            let Some(first) = row.first_child() else {
+                return;
+            };
+            let Some(second) = first.next_sibling() else {
+                return;
+            };
+            if let Ok(image) = first.downcast::<Image>() {
+                if let Some(texture) = app.icon() {
+                    image.set_paintable(Some(&texture));
+                } else {
+                    image.set_icon_name(Some("application-x-executable"));
+                }
+            }
+            if let Ok(label) = second.downcast::<Label>() {
+                label.set_label(&app.display_name());
+            }
+        });
+        self.app_picker.set_factory(Some(&factory));
+
+        // Empty model + disabled state until the daemon answers
+        // ListRunningApps.
+        let empty: ListStore = ListStore::new::<RunningAppObject>();
+        self.app_picker.set_model(Some(&empty));
+        self.app_picker.set_sensitive(false);
+        self.add_button.set_sensitive(false);
+
+        // Esc + Cmd/Ctrl+W close the modal. Bubble phase lets the
+        // picker's popover swallow Esc first if it's open.
+        let obj = self.obj();
+        crate::modal_keys::wire_close_shortcuts(&*obj);
+
+        let weak_self = obj.downgrade();
+        self.add_button.connect_clicked(move |_| {
+            if let Some(window) = weak_self.upgrade() {
+                window.imp().handle_add_clicked();
+            }
+        });
+    }
+}
+
+impl WidgetImpl for ClipboardPrivacyWindow {}
+impl WindowImpl for ClipboardPrivacyWindow {}
+impl AdwWindowImpl for ClipboardPrivacyWindow {}
+
+impl ClipboardPrivacyWindow {
+    fn handle_add_clicked(&self) {
+        let Some(obj) = self.app_picker.selected_item() else {
+            return;
+        };
+        let Ok(app) = obj.downcast::<RunningAppObject>() else {
+            return;
+        };
+        let value = app.identifier();
+        if value.is_empty() {
+            return;
+        }
+        self.obj().emit_by_name::<()>("request-add", &[&value]);
+    }
+
+    pub(super) fn rebuild_list(&self) {
+        while let Some(child) = self.entries_list.first_child() {
+            self.entries_list.remove(&child);
+        }
+        let apps = self.apps.borrow();
+        if apps.is_empty() {
+            self.empty_placeholder.set_visible(true);
+            self.entries_list.set_visible(false);
+            return;
+        }
+        self.empty_placeholder.set_visible(false);
+        self.entries_list.set_visible(true);
+        for value in apps.iter() {
+            self.ensure_metadata_for(value);
+            let metadata = self.metadata.borrow();
+            let entry = metadata.get(value);
+            let title = entry
+                .map(|m| m.display_name.clone())
+                .unwrap_or_else(|| value.clone());
+            let row = adw::ActionRow::builder().title(&title).build();
+            let icon_widget = Image::new();
+            icon_widget.set_pixel_size(20);
+            if let Some(texture) = entry.and_then(|m| m.icon.clone()) {
+                icon_widget.set_paintable(Some(&texture));
+            } else {
+                icon_widget.set_icon_name(Some("application-x-executable"));
+            }
+            row.add_prefix(&icon_widget);
+            let delete = Button::builder()
+                .icon_name("user-trash-symbolic")
+                .valign(gtk::Align::Center)
+                .halign(gtk::Align::Center)
+                .tooltip_text("Remove from suppression list")
+                .build();
+            delete.add_css_class("error");
+            let weak_self = self.obj().downgrade();
+            let value_clone = value.clone();
+            delete.connect_clicked(move |_| {
+                let Some(window) = weak_self.upgrade() else {
+                    return;
+                };
+                window.emit_by_name::<()>("request-remove", &[&value_clone]);
+            });
+            row.add_suffix(&delete);
+            self.entries_list.append(&row);
+        }
+    }
+
+    /// Make sure the metadata cache has an entry for `identifier`.
+    /// Cache hits are free; misses query Launch Services via
+    /// `input_capture::frontmost_app::lookup_app_metadata` to find
+    /// the .app on disk, derive a display name + icon, and store
+    /// the result. If the identifier doesn't resolve (uninstalled
+    /// app, unsupported platform), no entry is inserted and the
+    /// caller falls back to displaying the raw identifier.
+    fn ensure_metadata_for(&self, identifier: &str) {
+        if self.metadata.borrow().contains_key(identifier) {
+            return;
+        }
+        let Some(app) = input_capture::frontmost_app::lookup_app_metadata(identifier) else {
+            return;
+        };
+        let icon = app.icon_png.as_ref().and_then(|bytes| {
+            let glib_bytes = glib::Bytes::from(bytes);
+            gdk::Texture::from_bytes(&glib_bytes).ok()
+        });
+        self.metadata.borrow_mut().insert(
+            identifier.to_owned(),
+            AppMetadata {
+                display_name: app.display_name,
+                icon,
+            },
+        );
+    }
+
+    /// True when the picker's popover is currently presented to
+    /// the user. The auto-refresh timer skips updates in that
+    /// state so the popover doesn't redraw mid-search and steal
+    /// keyboard focus.
+    pub(super) fn picker_is_open(&self) -> bool {
+        // Walk the AdwComboRow's descendants for a Popover that's
+        // mapped + visible. AdwComboRow doesn't expose its
+        // internal popover directly so we discover it by traversal.
+        fn find_open_popover(widget: &gtk::Widget) -> bool {
+            if let Ok(popover) = widget.clone().downcast::<gtk::Popover>() {
+                if popover.is_visible() {
+                    return true;
+                }
+            }
+            let mut child = widget.first_child();
+            while let Some(c) = child {
+                if find_open_popover(&c) {
+                    return true;
+                }
+                child = c.next_sibling();
+            }
+            false
+        }
+        find_open_popover(self.app_picker.upcast_ref::<gtk::Widget>())
+    }
+
+    /// Refill the picker model with `running`. Already-suppressed
+    /// apps are filtered so the user can't add a duplicate, and
+    /// the previously-selected app (if it's still present) stays
+    /// selected across refreshes so the auto-refresh timer doesn't
+    /// reset the user's choice mid-click.
+    pub(super) fn set_running_apps(&self, running: Vec<RunningApp>) {
+        // Cache the snapshot so a later suppression-list change
+        // (add/remove) can re-apply the picker filter without
+        // waiting for the next auto-refresh tick.
+        self.last_running.replace(running.clone());
+        // Mirror running-apps metadata into the suppressed-list
+        // cache so the entries list can render their icons + names
+        // without a separate Launch Services round-trip per row.
+        {
+            let mut metadata = self.metadata.borrow_mut();
+            for app in &running {
+                let icon = app.icon_png.as_ref().and_then(|bytes| {
+                    let glib_bytes = glib::Bytes::from(bytes);
+                    gdk::Texture::from_bytes(&glib_bytes).ok()
+                });
+                metadata.insert(
+                    app.identifier.clone(),
+                    AppMetadata {
+                        display_name: app.display_name.clone(),
+                        icon,
+                    },
+                );
+            }
+        }
+        // Re-render the suppressed list so any rows missing icon /
+        // name pick up the freshly cached metadata.
+        self.rebuild_list();
+        let suppressed_lc: Vec<String> = self
+            .apps
+            .borrow()
+            .iter()
+            .map(|s| s.to_lowercase())
+            .collect();
+        let filtered: Vec<RunningApp> = running
+            .into_iter()
+            .filter(|a| {
+                !suppressed_lc
+                    .iter()
+                    .any(|s| s == &a.identifier.to_lowercase())
+            })
+            .collect();
+
+        // Remember selected identifier so we can reselect after refill.
+        let prev_selected: Option<String> = self
+            .app_picker
+            .selected_item()
+            .and_then(|o| o.downcast::<RunningAppObject>().ok())
+            .map(|a| a.identifier());
+
+        let store: ListStore = ListStore::new::<RunningAppObject>();
+        for app in &filtered {
+            store.append(&RunningAppObject::new(app));
+        }
+        self.app_picker.set_model(Some(&store));
+
+        if filtered.is_empty() {
+            self.app_picker.set_sensitive(false);
+            self.add_button.set_sensitive(false);
+            return;
+        }
+        self.app_picker.set_sensitive(true);
+        self.add_button.set_sensitive(true);
+
+        if let Some(prev) = prev_selected {
+            if let Some(idx) = filtered.iter().position(|a| a.identifier == prev) {
+                self.app_picker.set_selected(idx as u32);
+            }
+        }
+    }
+}
diff --git a/lan-mouse-gtk/src/fingerprint_window/imp.rs b/lan-mouse-gtk/src/fingerprint_window/imp.rs
index 943b68a2..c76c9e5e 100644
--- a/lan-mouse-gtk/src/fingerprint_window/imp.rs
+++ b/lan-mouse-gtk/src/fingerprint_window/imp.rs
@@ -4,7 +4,7 @@ use adw::prelude::*;
 use adw::subclass::prelude::*;
 use glib::subclass::InitializingObject;
 use gtk::{
-    Button, CompositeTemplate, Text,
+    Button, CompositeTemplate, Entry,
     glib::{self, subclass::Signal},
     template_callbacks,
 };
@@ -13,9 +13,9 @@ use gtk::{
 #[template(resource = "/de/feschber/LanMouse/fingerprint_window.ui")]
 pub struct FingerprintWindow {
     #[template_child]
-    pub description: TemplateChild<Text>,
+    pub description: TemplateChild<Entry>,
     #[template_child]
-    pub fingerprint: TemplateChild<Text>,
+    pub fingerprint: TemplateChild<Entry>,
     #[template_child]
     pub confirm_button: TemplateChild<Button>,
 }
@@ -44,10 +44,27 @@ impl FingerprintWindow {
     fn handle_confirm(&self, _button: Button) {
         let desc = self.description.text().as_str().trim().to_owned();
         let fp = self.fingerprint.text().as_str().trim().to_owned();
+        // Defensive guard: the button is wired to be insensitive while
+        // either field is empty (see `constructed`), but a user could
+        // theoretically trigger the action via the keyboard accelerator
+        // before the validity recompute finishes. Drop empty submits.
+        if desc.is_empty() || fp.is_empty() {
+            return;
+        }
         self.obj().emit_by_name("confirm-clicked", &[&desc, &fp])
     }
 }
 
+impl FingerprintWindow {
+    fn both_filled(&self) -> bool {
+        !self.description.text().trim().is_empty() && !self.fingerprint.text().trim().is_empty()
+    }
+
+    fn refresh_confirm_sensitivity(&self) {
+        self.confirm_button.set_sensitive(self.both_filled());
+    }
+}
+
 impl ObjectImpl for FingerprintWindow {
     fn signals() -> &'static [Signal] {
         static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
@@ -59,6 +76,32 @@ impl ObjectImpl for FingerprintWindow {
             ]
         })
     }
+
+    fn constructed(&self) {
+        self.parent_constructed();
+
+        // Confirm is disabled while either Description or
+        // SHA-256 Fingerprint is empty (after trim). Recompute on
+        // every keystroke via the GtkEditable `changed` signal.
+        self.refresh_confirm_sensitivity();
+
+        let obj = self.obj();
+
+        // Esc + Cmd/Ctrl+W close the modal.
+        crate::modal_keys::wire_close_shortcuts(&*obj);
+        let weak_desc = obj.downgrade();
+        self.description.connect_changed(move |_| {
+            if let Some(o) = weak_desc.upgrade() {
+                o.imp().refresh_confirm_sensitivity();
+            }
+        });
+        let weak_fp = obj.downgrade();
+        self.fingerprint.connect_changed(move |_| {
+            if let Some(o) = weak_fp.upgrade() {
+                o.imp().refresh_confirm_sensitivity();
+            }
+        });
+    }
 }
 
 impl WidgetImpl for FingerprintWindow {}
diff --git a/lan-mouse-gtk/src/key_object.rs b/lan-mouse-gtk/src/key_object.rs
index 17172438..d22a0e43 100644
--- a/lan-mouse-gtk/src/key_object.rs
+++ b/lan-mouse-gtk/src/key_object.rs
@@ -2,16 +2,22 @@ mod imp;
 
 use adw::subclass::prelude::*;
 use gtk::glib::{self, Object};
+use lan_mouse_ipc::IncomingPeerConfig;
 
 glib::wrapper! {
     pub struct KeyObject(ObjectSubclass<imp::KeyObject>);
 }
 
 impl KeyObject {
-    pub fn new(desc: String, fp: String) -> Self {
+    pub fn new(fingerprint: String, peer: IncomingPeerConfig) -> Self {
         Object::builder()
-            .property("description", desc)
-            .property("fingerprint", fp)
+            .property("description", peer.description)
+            .property("fingerprint", fingerprint)
+            .property("natural-scroll", peer.natural_scroll)
+            .property("mouse-sensitivity", peer.mouse_sensitivity)
+            .property("last-addr", peer.last_addr.unwrap_or_default())
+            .property("last-hostname", peer.last_hostname.unwrap_or_default())
+            .property("clipboard-receive", peer.clipboard_receive)
             .build()
     }
 
diff --git a/lan-mouse-gtk/src/key_object/imp.rs b/lan-mouse-gtk/src/key_object/imp.rs
index e3b6ee45..b21c013e 100644
--- a/lan-mouse-gtk/src/key_object/imp.rs
+++ b/lan-mouse-gtk/src/key_object/imp.rs
@@ -1,17 +1,50 @@
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
 
 use glib::Properties;
 use gtk::glib;
 use gtk::prelude::*;
 use gtk::subclass::prelude::*;
 
-#[derive(Properties, Default)]
+#[derive(Properties)]
 #[properties(wrapper_type = super::KeyObject)]
 pub struct KeyObject {
     #[property(name = "description", get, set, type = String)]
     pub description: RefCell<String>,
     #[property(name = "fingerprint", get, set, type = String)]
     pub fingerprint: RefCell<String>,
+    #[property(name = "natural-scroll", get, set, type = bool)]
+    pub natural_scroll: Cell<bool>,
+    #[property(name = "mouse-sensitivity", get, set, type = f64)]
+    pub mouse_sensitivity: Cell<f64>,
+    /// Most recent IP this peer connected from (or empty when
+    /// they've never connected). Empty string is the GObject-
+    /// idiomatic stand-in for `Option::None` since the property
+    /// macro doesn't support `Option`.
+    #[property(name = "last-addr", get, set, type = String)]
+    pub last_addr: RefCell<String>,
+    /// mDNS-discovered hostname for `last_addr`, if known. Empty
+    /// = no hostname resolution available.
+    #[property(name = "last-hostname", get, set, type = String)]
+    pub last_hostname: RefCell<String>,
+    /// Whether this peer's clipboard text should be applied to
+    /// the local clipboard. Mirrors
+    /// [`lan_mouse_ipc::IncomingPeerConfig::clipboard_receive`].
+    #[property(name = "clipboard-receive", get, set, type = bool)]
+    pub clipboard_receive: Cell<bool>,
+}
+
+impl Default for KeyObject {
+    fn default() -> Self {
+        Self {
+            description: RefCell::new(String::new()),
+            fingerprint: RefCell::new(String::new()),
+            natural_scroll: Cell::new(false),
+            mouse_sensitivity: Cell::new(1.0),
+            last_addr: RefCell::new(String::new()),
+            last_hostname: RefCell::new(String::new()),
+            clipboard_receive: Cell::new(false),
+        }
+    }
 }
 
 #[glib::object_subclass]
diff --git a/lan-mouse-gtk/src/key_row.rs b/lan-mouse-gtk/src/key_row.rs
index 6c506547..d036a407 100644
--- a/lan-mouse-gtk/src/key_row.rs
+++ b/lan-mouse-gtk/src/key_row.rs
@@ -2,13 +2,13 @@ mod imp;
 
 use adw::prelude::*;
 use adw::subclass::prelude::*;
-use gtk::glib::{self, Object};
+use gtk::glib::{self, Object, clone};
 
 use super::KeyObject;
 
 glib::wrapper! {
     pub struct KeyRow(ObjectSubclass<imp::KeyRow>)
-    @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ActionRow,
+    @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ActionRow, adw::ExpanderRow,
     @implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
 }
 
@@ -30,19 +30,224 @@ impl KeyRow {
             .bind_property("description", self, "title")
             .sync_create()
             .build();
+        bindings.push(title_binding);
 
-        let subtitle_binding = key_object
-            .bind_property("fingerprint", self, "subtitle")
+        // The fingerprint moves from the title-row subtitle to a
+        // dedicated row inside the expansion. The title-row subtitle
+        // is now computed from last_hostname/last_addr (mDNS-resolved
+        // identity) so users see something more useful at a glance.
+        let fp_binding = key_object
+            .bind_property("fingerprint", &self.imp().fingerprint_row.get(), "subtitle")
             .sync_create()
             .build();
+        bindings.push(fp_binding);
+        drop(bindings);
 
-        bindings.push(title_binding);
-        bindings.push(subtitle_binding);
+        // Initial widget state from KeyObject without firing the
+        // user-change signals (no ping-pong on bind).
+        self.refresh_natural_scroll_widget(key_object.natural_scroll());
+        self.refresh_sensitivity_widget(key_object.mouse_sensitivity());
+        self.refresh_clipboard_receive_widget(key_object.clipboard_receive());
+        self.refresh_summary(
+            key_object.natural_scroll(),
+            key_object.mouse_sensitivity(),
+            key_object.clipboard_receive(),
+        );
+        self.refresh_identity_subtitle(&key_object.last_hostname(), &key_object.last_addr());
+
+        // Wire the copy-to-clipboard button. The handler reads the
+        // fingerprint live from the KeyObject so an in-place
+        // mutation (rare for fingerprint, but possible) is honored.
+        let key_object_weak = key_object.downgrade();
+        self.imp()
+            .copy_fingerprint_button
+            .connect_clicked(move |_| {
+                let Some(obj) = key_object_weak.upgrade() else {
+                    return;
+                };
+                if let Some(display) = gtk::gdk::Display::default() {
+                    display.clipboard().set_text(&obj.fingerprint());
+                }
+            });
+
+        // Track in-place mutations on KeyObject — `set_authorized_keys`
+        // updates existing KeyObjects rather than rebuilding the list,
+        // so we need to react to property-notify, not just bind-time
+        // values.
+        let mut handlers = self.imp().key_object_handlers.borrow_mut();
+        let h = key_object.connect_natural_scroll_notify(clone!(
+            #[weak(rename_to = row)]
+            self,
+            move |obj| {
+                row.refresh_natural_scroll_widget(obj.natural_scroll());
+                row.refresh_summary(
+                    obj.natural_scroll(),
+                    obj.mouse_sensitivity(),
+                    obj.clipboard_receive(),
+                );
+            }
+        ));
+        handlers.push((key_object.clone(), h));
+
+        let h = key_object.connect_mouse_sensitivity_notify(clone!(
+            #[weak(rename_to = row)]
+            self,
+            move |obj| {
+                row.refresh_sensitivity_widget(obj.mouse_sensitivity());
+                row.refresh_summary(
+                    obj.natural_scroll(),
+                    obj.mouse_sensitivity(),
+                    obj.clipboard_receive(),
+                );
+            }
+        ));
+        handlers.push((key_object.clone(), h));
+
+        let h = key_object.connect_clipboard_receive_notify(clone!(
+            #[weak(rename_to = row)]
+            self,
+            move |obj| {
+                row.refresh_clipboard_receive_widget(obj.clipboard_receive());
+                row.refresh_summary(
+                    obj.natural_scroll(),
+                    obj.mouse_sensitivity(),
+                    obj.clipboard_receive(),
+                );
+            }
+        ));
+        handlers.push((key_object.clone(), h));
+
+        let h = key_object.connect_last_hostname_notify(clone!(
+            #[weak(rename_to = row)]
+            self,
+            move |obj| {
+                row.refresh_identity_subtitle(&obj.last_hostname(), &obj.last_addr());
+            }
+        ));
+        handlers.push((key_object.clone(), h));
+
+        let h = key_object.connect_last_addr_notify(clone!(
+            #[weak(rename_to = row)]
+            self,
+            move |obj| {
+                row.refresh_identity_subtitle(&obj.last_hostname(), &obj.last_addr());
+            }
+        ));
+        handlers.push((key_object.clone(), h));
     }
 
     pub fn unbind(&self) {
         for binding in self.imp().bindings.borrow_mut().drain(..) {
             binding.unbind();
         }
+        for (obj, id) in self.imp().key_object_handlers.borrow_mut().drain(..) {
+            obj.disconnect(id);
+        }
+    }
+
+    fn refresh_natural_scroll_widget(&self, value: bool) {
+        let imp = self.imp();
+        let switch = &imp.natural_scroll_switch;
+        let handler = imp.natural_scroll_handler.borrow();
+        if let Some(id) = handler.as_ref() {
+            switch.block_signal(id);
+        }
+        switch.set_active(value);
+        switch.set_state(value);
+        if let Some(id) = handler.as_ref() {
+            switch.unblock_signal(id);
+        }
+    }
+
+    fn refresh_sensitivity_widget(&self, value: f64) {
+        let imp = self.imp();
+        let spin = &imp.sensitivity_spin;
+        let handler = imp.sensitivity_handler.borrow();
+        if let Some(id) = handler.as_ref() {
+            spin.block_signal(id);
+        }
+        spin.set_value(value);
+        if let Some(id) = handler.as_ref() {
+            spin.unblock_signal(id);
+        }
     }
+
+    fn refresh_clipboard_receive_widget(&self, value: bool) {
+        let imp = self.imp();
+        let switch = &imp.clipboard_receive_switch;
+        let handler = imp.clipboard_receive_handler.borrow();
+        if let Some(id) = handler.as_ref() {
+            switch.block_signal(id);
+        }
+        switch.set_active(value);
+        switch.set_state(value);
+        if let Some(id) = handler.as_ref() {
+            switch.unblock_signal(id);
+        }
+    }
+
+    /// Compute the title-row subtitle from the peer's most recent
+    /// connection identity. mDNS gives us a hostname most of the
+    /// time, falling back to a bare IP, falling back to a "never
+    /// connected" placeholder for pre-shared-trust authorizations
+    /// that haven't been used yet.
+    fn refresh_identity_subtitle(&self, hostname: &str, addr: &str) {
+        let s = match (hostname.is_empty(), addr.is_empty()) {
+            (true, true) => "(not yet connected)".to_owned(),
+            (true, false) => addr.to_owned(),
+            (false, true) => hostname.to_owned(),
+            (false, false) => format!("{hostname} ({addr})"),
+        };
+        // Bypass trait-name ambiguity (both ActionRow and ExpanderRow
+        // define `set_subtitle`) by going through GObject property
+        // dispatch. `subtitle` resolves to ExpanderRow's title-row
+        // subtitle, which is what we want.
+        self.set_property("subtitle", s);
+    }
+
+    /// Update the title-row summary label so a collapsed row hints
+    /// at non-default settings. Hidden when every field is at
+    /// default so a freshly-authorized peer's row is uncluttered.
+    fn refresh_summary(&self, natural_scroll: bool, sensitivity: f64, clipboard_receive: bool) {
+        let label = &self.imp().settings_summary;
+        let parts = format_summary_parts(natural_scroll, sensitivity, clipboard_receive);
+        if parts.is_empty() {
+            label.set_visible(false);
+            label.set_text("");
+        } else {
+            label.set_text(&parts.join(" · "));
+            label.set_visible(true);
+        }
+    }
+}
+
+/// Render the non-default settings as short tokens (e.g. `Natural`,
+/// `1.5×`, `Clipboard`). Returns an empty Vec when every field is
+/// at default.
+fn format_summary_parts(
+    natural_scroll: bool,
+    sensitivity: f64,
+    clipboard_receive: bool,
+) -> Vec<String> {
+    let mut parts = Vec::new();
+    if natural_scroll {
+        parts.push("Natural".to_owned());
+    }
+    if (sensitivity - 1.0).abs() > 1e-6 {
+        parts.push(format_sensitivity(sensitivity));
+    }
+    if clipboard_receive {
+        parts.push("Clipboard".to_owned());
+    }
+    parts
+}
+
+fn format_sensitivity(v: f64) -> String {
+    // Match the spin-button's 2-digit precision but trim trailing
+    // zeros and a dangling decimal point so 1.50 → "1.5×" and
+    // 0.85 → "0.85×". 1.0 never reaches here (filtered above).
+    let s = format!("{v:.2}");
+    let s = s.trim_end_matches('0');
+    let s = s.trim_end_matches('.');
+    format!("{s}×")
 }
diff --git a/lan-mouse-gtk/src/key_row/imp.rs b/lan-mouse-gtk/src/key_row/imp.rs
index 57529aed..0264e87f 100644
--- a/lan-mouse-gtk/src/key_row/imp.rs
+++ b/lan-mouse-gtk/src/key_row/imp.rs
@@ -1,29 +1,55 @@
 use std::cell::RefCell;
 
+use adw::ActionRow;
 use adw::subclass::prelude::*;
-use adw::{ActionRow, prelude::*};
+use adw::{ExpanderRow, prelude::*};
 use glib::{Binding, subclass::InitializingObject};
 use gtk::glib::clone;
 use gtk::glib::subclass::Signal;
-use gtk::{Button, CompositeTemplate, glib};
+use gtk::{Button, CompositeTemplate, Label, SpinButton, Switch, glib};
 use std::sync::OnceLock;
 
+use super::super::KeyObject;
+
 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/de/feschber/LanMouse/key_row.ui")]
 pub struct KeyRow {
     #[template_child]
-    pub delete_button: TemplateChild<gtk::Button>,
+    pub delete_button: TemplateChild<Button>,
+    #[template_child]
+    pub natural_scroll_switch: TemplateChild<Switch>,
+    #[template_child]
+    pub sensitivity_spin: TemplateChild<SpinButton>,
+    #[template_child]
+    pub clipboard_receive_switch: TemplateChild<Switch>,
+    #[template_child]
+    pub settings_summary: TemplateChild<Label>,
+    #[template_child]
+    pub fingerprint_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub copy_fingerprint_button: TemplateChild<Button>,
     pub bindings: RefCell<Vec<Binding>>,
+    /// Signal-handler IDs for the per-row controls. Used to
+    /// `block_signal` while pushing daemon-driven state into the
+    /// widgets so we don't ping-pong a server-originated update
+    /// back as a fresh user request.
+    pub natural_scroll_handler: RefCell<Option<glib::SignalHandlerId>>,
+    pub sensitivity_handler: RefCell<Option<glib::SignalHandlerId>>,
+    pub clipboard_receive_handler: RefCell<Option<glib::SignalHandlerId>>,
+    /// Property-notify handlers we connect on the bound KeyObject
+    /// so per-row widget state tracks in-place mutations from
+    /// `Window::set_authorized_keys`. Disconnected in `unbind` to
+    /// avoid leaking handlers when a peer is revoked.
+    pub key_object_handlers: RefCell<Vec<(KeyObject, glib::SignalHandlerId)>>,
 }
 
 #[glib::object_subclass]
 impl ObjectSubclass for KeyRow {
-    // `NAME` needs to match `class` attribute of template
     const NAME: &'static str = "KeyRow";
     const ABSTRACT: bool = false;
 
     type Type = super::KeyRow;
-    type ParentType = ActionRow;
+    type ParentType = ExpanderRow;
 
     fn class_init(klass: &mut Self::Class) {
         klass.bind_template();
@@ -38,6 +64,7 @@ impl ObjectSubclass for KeyRow {
 impl ObjectImpl for KeyRow {
     fn constructed(&self) {
         self.parent_constructed();
+
         self.delete_button.connect_clicked(clone!(
             #[weak(rename_to = row)]
             self,
@@ -45,11 +72,62 @@ impl ObjectImpl for KeyRow {
                 row.handle_delete(button);
             }
         ));
+
+        let natural_scroll_handler = self.natural_scroll_switch.connect_state_set(clone!(
+            #[weak(rename_to = row)]
+            self,
+            #[upgrade_or]
+            glib::Propagation::Proceed,
+            move |_, state| {
+                row.obj()
+                    .emit_by_name::<()>("request-natural-scroll-change", &[&state]);
+                glib::Propagation::Proceed
+            }
+        ));
+        self.natural_scroll_handler
+            .replace(Some(natural_scroll_handler));
+
+        let sensitivity_handler = self.sensitivity_spin.connect_value_changed(clone!(
+            #[weak(rename_to = row)]
+            self,
+            move |spin| {
+                row.obj()
+                    .emit_by_name::<()>("request-sensitivity-change", &[&spin.value()]);
+            }
+        ));
+        self.sensitivity_handler.replace(Some(sensitivity_handler));
+
+        let clipboard_receive_handler = self.clipboard_receive_switch.connect_state_set(clone!(
+            #[weak(rename_to = row)]
+            self,
+            #[upgrade_or]
+            glib::Propagation::Proceed,
+            move |_, state| {
+                row.obj()
+                    .emit_by_name::<()>("request-clipboard-receive-change", &[&state]);
+                glib::Propagation::Proceed
+            }
+        ));
+        self.clipboard_receive_handler
+            .replace(Some(clipboard_receive_handler));
     }
 
     fn signals() -> &'static [glib::subclass::Signal] {
         static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
-        SIGNALS.get_or_init(|| vec![Signal::builder("request-delete").build()])
+        SIGNALS.get_or_init(|| {
+            vec![
+                Signal::builder("request-delete").build(),
+                Signal::builder("request-natural-scroll-change")
+                    .param_types([bool::static_type()])
+                    .build(),
+                Signal::builder("request-sensitivity-change")
+                    .param_types([f64::static_type()])
+                    .build(),
+                Signal::builder("request-clipboard-receive-change")
+                    .param_types([bool::static_type()])
+                    .build(),
+            ]
+        })
     }
 }
 
@@ -65,4 +143,4 @@ impl WidgetImpl for KeyRow {}
 impl BoxImpl for KeyRow {}
 impl ListBoxRowImpl for KeyRow {}
 impl PreferencesRowImpl for KeyRow {}
-impl ActionRowImpl for KeyRow {}
+impl ExpanderRowImpl for KeyRow {}
diff --git a/lan-mouse-gtk/src/lib.rs b/lan-mouse-gtk/src/lib.rs
index ecdd7080..5475a081 100644
--- a/lan-mouse-gtk/src/lib.rs
+++ b/lan-mouse-gtk/src/lib.rs
@@ -1,19 +1,41 @@
 mod authorization_window;
 mod client_object;
 mod client_row;
+mod clipboard_privacy_window;
 mod fingerprint_window;
 mod key_object;
 mod key_row;
+#[cfg(target_os = "linux")]
+mod linux_tray;
 #[cfg(target_os = "macos")]
 mod macos_privacy;
 #[cfg(target_os = "macos")]
 mod macos_status_item;
+mod modal_keys;
+mod running_app_object;
 mod window;
 
-use std::{env, process, str};
+use std::{env, process, str, sync::OnceLock};
 
 use window::Window;
 
+/// Local build's commit hash, set once by [`run`] before the GTK
+/// main loop starts. Read by per-row UI to compare against each
+/// peer's [`lan_mouse_ipc::ClientState::peer_commit`] for the
+/// soft-warn version-mismatch indicator.
+pub(crate) static LOCAL_COMMIT: OnceLock<[u8; 8]> = OnceLock::new();
+
+/// Convenience: returns the local commit as an 8-char ASCII string,
+/// or a placeholder if unset (which would indicate a programmer
+/// error since [`run`] always sets it).
+pub(crate) fn local_commit_str() -> String {
+    LOCAL_COMMIT
+        .get()
+        .and_then(|c| std::str::from_utf8(c).ok())
+        .unwrap_or("????????")
+        .to_string()
+}
+
 use lan_mouse_ipc::FrontendEvent;
 
 use adw::Application;
@@ -31,8 +53,48 @@ pub enum GtkError {
     NonZeroExitCode(i32),
 }
 
-pub fn run() -> Result<(), GtkError> {
+/// Arm a process-level force-exit backstop and request a normal app
+/// quit. macOS-only because shutdown wedges (GTK main loop pumping
+/// pending events while the daemon is also being torn down, a
+/// CGEventTap that hasn't been removed yet, an outgoing IPC write
+/// blocked on a closing socket) only show up on macOS in practice.
+///
+/// The backstop thread sleeps outside the GTK main loop so it fires
+/// even if the loop itself is the thing that's wedged. If normal
+/// cleanup completes first (the usual case) the process exits via
+/// `main` returning and the sleeping backstop thread is killed by
+/// the OS along with everything else — the timer never fires.
+///
+/// Calling this twice in quick succession is a no-op on the second
+/// call so we don't spawn multiple backstops.
+#[cfg(target_os = "macos")]
+pub(crate) fn request_quit_with_backstop(app: &adw::Application) {
+    use std::sync::OnceLock;
+    use std::sync::atomic::{AtomicBool, Ordering};
+    static ARMED: OnceLock<AtomicBool> = OnceLock::new();
+    let armed = ARMED.get_or_init(|| AtomicBool::new(false));
+    if armed.swap(true, Ordering::SeqCst) {
+        app.quit();
+        return;
+    }
+
+    std::thread::Builder::new()
+        .name("lan-mouse-quit-backstop".into())
+        .spawn(|| {
+            std::thread::sleep(std::time::Duration::from_secs(5));
+            log::warn!("quit cleanup did not complete in 5s — force-exiting");
+            std::process::exit(0);
+        })
+        .ok();
+    app.quit();
+}
+
+pub fn run(local_commit: [u8; 8]) -> Result<(), GtkError> {
     log::debug!("running gtk frontend");
+    LOCAL_COMMIT
+        .set(local_commit)
+        .expect("local_commit set once");
+
     #[cfg(windows)]
     let ret = std::thread::Builder::new()
         .stack_size(8 * 1024 * 1024) // https://gitlab.gnome.org/GNOME/gtk/-/commit/52dbb3f372b2c3ea339e879689c1de535ba2c2c3 -> caused crash on windows
@@ -146,10 +208,31 @@ fn setup_actions(app: &adw::Application) {
     quit_action.connect_activate({
         let app = app.clone();
         move |_, _| {
+            #[cfg(target_os = "macos")]
+            request_quit_with_backstop(&app);
+            #[cfg(not(target_os = "macos"))]
             app.quit();
         }
     });
     app.add_action(&quit_action);
+
+    // Cmd+W → close the front window. GtkWindow's built-in `close`
+    // action fires `close-request`, which on macOS we've hooked to
+    // hide the window instead of destroying it (see `build_ui`). The
+    // window's connect_hide handler then flips the activation policy
+    // to Accessory — net effect is that Cmd+W collapses the GUI to a
+    // menu-bar-only background helper, freeing focus for whatever the
+    // user does next. Wired only on macOS so we don't override the
+    // native Ctrl+W behavior on Linux/Windows.
+    #[cfg(target_os = "macos")]
+    app.set_accels_for_action("window.close", &["<Meta>w"]);
+
+    // Super+W → hide the window on Linux. The Linux close-request
+    // handler in `build_ui` intercepts the resulting close action and
+    // hides the window rather than destroying it; the tray's hold
+    // guard keeps the app alive in the background.
+    #[cfg(target_os = "linux")]
+    app.set_accels_for_action("window.close", &["<Super>w"]);
 }
 
 // Set up a global menu
@@ -159,6 +242,7 @@ fn setup_menu(app: &adw::Application) {
     let menu = gio::Menu::new();
 
     let file_menu = gio::Menu::new();
+    file_menu.append(Some("Close Window"), Some("window.close"));
     file_menu.append(Some("Quit"), Some("app.quit"));
     menu.append_submenu(Some("_File"), &file_menu);
 
@@ -191,12 +275,49 @@ fn build_ui(app: &Application) {
     });
 
     let window = Window::new(app, frontend_tx);
+    #[cfg(target_os = "linux")]
+    {
+        // Hide-on-close: the X button, GTK's `window.close` action
+        // (bound to Super+W above), and any WM-level close request
+        // (Hyprland's Super+W if mapped, an `hyprctl dispatch
+        // killactive`, etc.) all funnel through `close-request`.
+        // Returning `Stop` keeps the GtkWindow alive so the tray's
+        // "Open Lan Mouse" can re-present it without rebuilding state.
+        window.connect_close_request(|window| {
+            window.set_visible(false);
+            glib::Propagation::Stop
+        });
+        // Stash the hold guard for the lifetime of the process so the
+        // GtkApplication does not exit when the last visible window
+        // closes — the tray needs to outlive the GUI.
+        thread_local! {
+            static TRAY_HOLD: std::cell::OnceCell<gio::ApplicationHoldGuard> =
+                const { std::cell::OnceCell::new() };
+        }
+        let hold = linux_tray::setup(app, &window);
+        TRAY_HOLD.with(|cell| {
+            let _ = cell.set(hold);
+        });
+    }
     #[cfg(target_os = "macos")]
     {
         window.connect_close_request(|window| {
             window.set_visible(false);
             glib::Propagation::Stop
         });
+        // Toggle the Dock icon based on the window's visibility:
+        // Regular while the window is open (Dock icon shown so the
+        // user has a familiar way back to the app), Accessory while
+        // the window is hidden and only the menu-bar item is around
+        // (matches the LSUIElement-style background-helper feel).
+        window.connect_show(|_| {
+            macos_status_item::set_activation_policy(macos_status_item::ACTIVATION_POLICY_REGULAR);
+        });
+        window.connect_hide(|_| {
+            macos_status_item::set_activation_policy(
+                macos_status_item::ACTIVATION_POLICY_ACCESSORY,
+            );
+        });
         macos_status_item::setup(app, &window);
         // First-launch TCC prompts. No-op when already granted.
         macos_privacy::fire_initial_prompts();
@@ -221,7 +342,7 @@ fn build_ui(app: &Application) {
             macos_privacy::AccessibilityChange::Revoked => {
                 log::warn!("Accessibility revoked — quitting to avoid wedging system input");
                 if let Some(app) = app_weak.upgrade() {
-                    app.quit();
+                    request_quit_with_backstop(&app);
                 }
             }
         });
@@ -269,6 +390,18 @@ fn build_ui(app: &Application) {
                     FrontendEvent::IncomingDisconnected(addr) => {
                         window.show_toast(format!("{addr} disconnected").as_str());
                     }
+                    FrontendEvent::ReleaseThreshold(threshold) => {
+                        window.set_release_threshold(threshold);
+                    }
+                    FrontendEvent::MdnsDiscovery(enabled) => {
+                        window.set_mdns_discovery(enabled);
+                    }
+                    FrontendEvent::SuppressedAppsUpdated(apps) => {
+                        window.set_suppressed_apps(apps);
+                    }
+                    FrontendEvent::RunningApps(apps) => {
+                        window.set_running_apps(apps);
+                    }
                 }
             }
         }
diff --git a/lan-mouse-gtk/src/linux_tray.rs b/lan-mouse-gtk/src/linux_tray.rs
new file mode 100644
index 00000000..16b0b2a9
--- /dev/null
+++ b/lan-mouse-gtk/src/linux_tray.rs
@@ -0,0 +1,298 @@
+//! Linux system tray (StatusNotifierItem) — keeps the daemon visible
+//! and reachable when the GUI is hidden.
+//!
+//! Mirrors the role of [`crate::macos_status_item`] on macOS: holds an
+//! [`gio::ApplicationHoldGuard`] so the GtkApplication survives the
+//! main window being closed, exposes Open / Quit menu actions, and
+//! toggles the window on left-click.
+//!
+//! Communication: ksni runs its own thread (spawned via
+//! `TrayService::spawn`). Menu callbacks fire on that thread, so they
+//! push commands through an `async_channel` consumed by a
+//! `glib::spawn_future_local` task on the GTK main loop.
+use std::time::{Duration, Instant};
+
+use adw::prelude::*;
+use async_channel::Sender;
+use gtk::{gdk_pixbuf::Pixbuf, gio, glib};
+use ksni::{
+    Icon, Tray, TrayService,
+    menu::{MenuItem, StandardItem},
+};
+
+use crate::window::Window;
+
+#[derive(Debug)]
+enum TrayCmd {
+    TogglePresent,
+    Quit,
+}
+
+/// waybar (and a few other SNI hosts) can fire two `Activate`
+/// signals for a single physical click — so without this, every
+/// click toggles twice and the window briefly flashes back to its
+/// previous state. 300 ms is comfortably below human double-click
+/// cadence while still swallowing the duplicates we see in practice.
+const ACTIVATE_DEBOUNCE: Duration = Duration::from_millis(300);
+
+struct LanMouseTray {
+    tx: Sender<TrayCmd>,
+    last_toggle: Option<Instant>,
+    icon_pixmaps: Vec<Icon>,
+}
+
+impl LanMouseTray {
+    fn try_emit_toggle(&mut self, source: &str) {
+        let now = Instant::now();
+        if let Some(prev) = self.last_toggle {
+            if now.duration_since(prev) < ACTIVATE_DEBOUNCE {
+                log::info!("linux_tray: dropped duplicate {source} within debounce window");
+                return;
+            }
+        }
+        self.last_toggle = Some(now);
+        let _ = self.tx.send_blocking(TrayCmd::TogglePresent);
+    }
+}
+
+impl Tray for LanMouseTray {
+    fn id(&self) -> String {
+        "de.feschber.LanMouse".into()
+    }
+
+    fn title(&self) -> String {
+        "Lan Mouse".into()
+    }
+
+    // The icon name is still advertised so accessibility tools can
+    // identify the item, but the actual rendering happens via
+    // `icon_pixmap` below — we ship our own ARGB32 pixels so the icon
+    // doesn't depend on the icon theme being installed and so the
+    // glyph fills more of the host's tray slot than typical theme
+    // icons (which carry their own internal padding).
+    fn icon_name(&self) -> String {
+        "de.feschber.LanMouse".into()
+    }
+
+    fn icon_pixmap(&self) -> Vec<Icon> {
+        self.icon_pixmaps.clone()
+    }
+
+    fn icon_theme_path(&self) -> String {
+        String::new()
+    }
+
+    fn tool_tip(&self) -> ksni::ToolTip {
+        ksni::ToolTip {
+            title: "Lan Mouse".into(),
+            description: String::new(),
+            icon_name: String::new(),
+            icon_pixmap: self.icon_pixmaps.clone(),
+        }
+    }
+
+    fn activate(&mut self, x: i32, y: i32) {
+        log::info!("linux_tray: tray Activate at ({x},{y}) — toggling window");
+        self.try_emit_toggle("Activate");
+    }
+
+    // Some tray hosts (older waybar, certain Plasma versions) treat
+    // middle-click as the only "primary" interaction. Map it to the
+    // same toggle so the icon is responsive regardless of which
+    // event the host emits.
+    fn secondary_activate(&mut self, x: i32, y: i32) {
+        log::info!("linux_tray: tray SecondaryActivate at ({x},{y}) — toggling window");
+        self.try_emit_toggle("SecondaryActivate");
+    }
+
+    fn menu(&self) -> Vec<MenuItem<Self>> {
+        vec![
+            StandardItem {
+                label: "Open Lan Mouse".into(),
+                activate: Box::new(|tray: &mut Self| {
+                    let _ = tray.tx.send_blocking(TrayCmd::TogglePresent);
+                }),
+                ..Default::default()
+            }
+            .into(),
+            MenuItem::Separator,
+            StandardItem {
+                label: "Quit Lan Mouse".into(),
+                activate: Box::new(|tray: &mut Self| {
+                    let _ = tray.tx.send_blocking(TrayCmd::Quit);
+                }),
+                ..Default::default()
+            }
+            .into(),
+        ]
+    }
+}
+
+/// Render the bundled SVG into a set of ARGB32 pixmaps the tray host
+/// can pick from. For each target size we render the SVG at 4× that
+/// size, scan the actual non-transparent bounding box, and crop to
+/// it (with a tiny edge margin so anti-aliased pixels aren't shaved
+/// off). The host then scales the pixmap to its own `icon-size`;
+/// because our pixmap is exactly the glyph with no surrounding
+/// padding, the rendered icon fills the slot edge-to-edge — visibly
+/// larger than neighbouring icons that include theme padding.
+fn render_tray_pixmaps() -> Vec<Icon> {
+    // Distinct from the desktop icon — see comments in
+    // resources/icons/lan-mouse-tray.svg. Tight viewBox + simple
+    // silhouette so the glyph remains readable at 12-22 px.
+    const SVG_RESOURCE: &str = "/de/feschber/LanMouse/icons/lan-mouse-tray.svg";
+    // High-density render so the alpha bbox scan operates on a
+    // reasonably anti-aliased pixmap; the result is then cropped and
+    // resampled by the host.
+    const RENDER_OVERSAMPLE: i32 = 4;
+    // Provide a few common host sizes; SNI hosts pick the closest fit
+    // and downscale, which is much sharper than upscaling a single
+    // tiny pixmap.
+    const TARGET_SIZES: &[i32] = &[16, 22, 32, 48, 64];
+
+    let mut icons = Vec::with_capacity(TARGET_SIZES.len());
+    for &target in TARGET_SIZES {
+        let render = target * RENDER_OVERSAMPLE;
+        let Ok(pixbuf) = Pixbuf::from_resource_at_scale(SVG_RESOURCE, render, render, true) else {
+            log::warn!("linux_tray: failed to render SVG at {render}px");
+            continue;
+        };
+        let Some(icon) = pixbuf_bbox_crop_argb32(&pixbuf) else {
+            continue;
+        };
+        log::debug!(
+            "linux_tray: tray pixmap target={target} → cropped {}x{}",
+            icon.width,
+            icon.height
+        );
+        icons.push(icon);
+    }
+    if icons.is_empty() {
+        log::warn!("linux_tray: no pixmaps rendered; tray will fall back to icon name");
+    }
+    icons
+}
+
+/// Scan the alpha channel for the bounding box of visible pixels,
+/// crop the pixbuf to that bbox (as a square so the host doesn't
+/// letterbox) and convert to ARGB32 in network byte order — the
+/// encoding the StatusNotifierItem spec requires for `IconPixmap`.
+///
+/// Adds a 1-pixel transparent margin so soft-edged anti-aliased
+/// pixels at the rim aren't clipped to a hard edge by aggressive
+/// host downscaling.
+fn pixbuf_bbox_crop_argb32(pixbuf: &Pixbuf) -> Option<Icon> {
+    if pixbuf.n_channels() != 4 || pixbuf.bits_per_sample() != 8 {
+        return None;
+    }
+    let w = pixbuf.width();
+    let h = pixbuf.height();
+    let rowstride = pixbuf.rowstride() as usize;
+    let bytes = pixbuf.read_pixel_bytes();
+    let pixels = bytes.as_ref();
+
+    // Anything below this alpha is treated as background — guards
+    // against a few stray sub-1% alpha pixels (Inkscape's renderer
+    // sometimes emits them outside the visible glyph) anchoring the
+    // bbox to the canvas edges.
+    const ALPHA_THRESHOLD: u8 = 8;
+
+    let (mut min_x, mut min_y, mut max_x, mut max_y) = (w, h, -1i32, -1i32);
+    for y in 0..h {
+        for x in 0..w {
+            let i = (y as usize) * rowstride + (x as usize) * 4;
+            if pixels[i + 3] >= ALPHA_THRESHOLD {
+                if x < min_x {
+                    min_x = x;
+                }
+                if y < min_y {
+                    min_y = y;
+                }
+                if x > max_x {
+                    max_x = x;
+                }
+                if y > max_y {
+                    max_y = y;
+                }
+            }
+        }
+    }
+    if max_x < 0 || max_y < 0 {
+        return None;
+    }
+
+    // 1-px breathing room on each side, then square up by padding
+    // the shorter axis so the host doesn't letterbox.
+    let pad = 1;
+    let x0 = (min_x - pad).max(0);
+    let y0 = (min_y - pad).max(0);
+    let x1 = (max_x + pad + 1).min(w);
+    let y1 = (max_y + pad + 1).min(h);
+    let crop_w = x1 - x0;
+    let crop_h = y1 - y0;
+    let side = crop_w.max(crop_h);
+    let off_x = (side - crop_w) / 2;
+    let off_y = (side - crop_h) / 2;
+
+    let mut data = vec![0u8; (side * side * 4) as usize];
+    for sy in 0..crop_h {
+        for sx in 0..crop_w {
+            let src = ((y0 + sy) as usize) * rowstride + ((x0 + sx) as usize) * 4;
+            let dst = (((off_y + sy) * side + (off_x + sx)) * 4) as usize;
+            // gdk-pixbuf RGBA → SNI ARGB32 (network byte order).
+            data[dst] = pixels[src + 3];
+            data[dst + 1] = pixels[src];
+            data[dst + 2] = pixels[src + 1];
+            data[dst + 3] = pixels[src + 2];
+        }
+    }
+    Some(Icon {
+        width: side,
+        height: side,
+        data,
+    })
+}
+
+/// Register the tray and arm the lifetime hold. The returned guard
+/// MUST be kept alive for as long as the tray should run — we stash
+/// it in a thread-local at the call site, mirroring the macOS code.
+pub(crate) fn setup(app: &adw::Application, window: &Window) -> gio::ApplicationHoldGuard {
+    let hold = app.hold();
+    let (tx, rx) = async_channel::bounded::<TrayCmd>(8);
+    let icon_pixmaps = render_tray_pixmaps();
+
+    let service = TrayService::new(LanMouseTray {
+        tx,
+        last_toggle: None,
+        icon_pixmaps,
+    });
+    service.spawn();
+    log::debug!("linux_tray: StatusNotifierItem registered");
+
+    let app = app.clone();
+    let window = window.clone();
+    glib::spawn_future_local(async move {
+        while let Ok(cmd) = rx.recv().await {
+            match cmd {
+                TrayCmd::TogglePresent => {
+                    let visible = window.is_visible();
+                    log::info!(
+                        "linux_tray: TogglePresent — currently visible={visible}, will {}",
+                        if visible { "hide" } else { "present" }
+                    );
+                    if visible {
+                        window.set_visible(false);
+                    } else {
+                        window.present();
+                    }
+                }
+                TrayCmd::Quit => {
+                    log::debug!("linux_tray: quit requested via tray menu");
+                    app.quit();
+                }
+            }
+        }
+    });
+
+    hold
+}
diff --git a/lan-mouse-gtk/src/macos_status_item.rs b/lan-mouse-gtk/src/macos_status_item.rs
index 663ec2e2..a6271760 100644
--- a/lan-mouse-gtk/src/macos_status_item.rs
+++ b/lan-mouse-gtk/src/macos_status_item.rs
@@ -241,6 +241,23 @@ fn present_window() {
     });
 }
 
+/// macOS NSApplicationActivationPolicy values.
+/// - `Regular` (0): standard app, Dock icon visible.
+/// - `Accessory` (1): no Dock icon, can have menu-bar item.
+pub(crate) const ACTIVATION_POLICY_REGULAR: usize = 0;
+pub(crate) const ACTIVATION_POLICY_ACCESSORY: usize = 1;
+
+/// Set NSApp's activation policy. Toggle between Regular (Dock
+/// icon shown — used while the main window is visible) and
+/// Accessory (no Dock icon — used while only the menu bar is
+/// visible).
+pub(crate) fn set_activation_policy(policy: usize) {
+    unsafe {
+        let ns_app = msg_send_id(class(c"NSApplication"), sel(c"sharedApplication"));
+        msg_send_bool_usize(ns_app, sel(c"setActivationPolicy:"), policy);
+    }
+}
+
 // Register the status-item delegate as the handler for the
 // kAEReopenApplication Apple Event ('aevt'/'rapp'). NSApplication
 // installs a default handler at -finishLaunching that just delegates to
@@ -273,7 +290,7 @@ unsafe fn install_reopen_handler(delegate: Id) {
 extern "C" fn quit_lan_mouse(_this: Id, _cmd: Sel, _sender: Id) {
     STATUS_ITEM.with(|item| {
         if let Some(app) = item.borrow().as_ref().and_then(|item| item.app.upgrade()) {
-            app.quit();
+            crate::request_quit_with_backstop(&app);
         }
     });
 }
diff --git a/lan-mouse-gtk/src/modal_keys.rs b/lan-mouse-gtk/src/modal_keys.rs
new file mode 100644
index 00000000..47793e52
--- /dev/null
+++ b/lan-mouse-gtk/src/modal_keys.rs
@@ -0,0 +1,50 @@
+//! Shared keyboard shortcuts for modal windows: `Escape` and
+//! `Cmd+W` (macOS) / `Ctrl+W` (Linux/Windows) both dismiss the
+//! modal.
+//!
+//! Application-level accelerators (`app.set_accels_for_action`)
+//! only deliver to GtkApplicationWindow children. Our modals are
+//! plain AdwWindow, so without an explicit per-modal key
+//! controller, `Cmd+W` falls through to the focused
+//! ApplicationWindow (the main window) and closes that instead of
+//! the modal — exactly the wrong UX.
+//!
+//! Both shortcuts run in the bubble phase (the
+//! `EventControllerKey` default), so a child widget that handles
+//! the key first — open AdwComboRow popover, focused search
+//! entry, etc. — consumes it and our handler doesn't fire. That's
+//! intentional: pressing Escape with the picker open dismisses
+//! the picker, not the whole modal.
+
+use gtk::{
+    EventControllerKey, gdk,
+    glib::{Propagation, object::IsA},
+    prelude::*,
+};
+
+pub fn wire_close_shortcuts(window: &impl IsA<gtk::Window>) {
+    let window: gtk::Window = window.clone().upcast();
+    let key = EventControllerKey::new();
+    let weak = window.downgrade();
+    key.connect_key_pressed(move |_, keyval, _, modifier| {
+        let Some(w) = weak.upgrade() else {
+            return Propagation::Proceed;
+        };
+        if keyval == gdk::Key::Escape {
+            w.close();
+            return Propagation::Stop;
+        }
+        let key_is_w = keyval == gdk::Key::w || keyval == gdk::Key::W;
+        let close_modifier = if cfg!(target_os = "macos") {
+            modifier.contains(gdk::ModifierType::META_MASK)
+        } else {
+            modifier.contains(gdk::ModifierType::CONTROL_MASK)
+        };
+        if key_is_w && close_modifier {
+            w.close();
+            return Propagation::Stop;
+        }
+        Propagation::Proceed
+    });
+    window.add_controller(key);
+}
diff --git a/lan-mouse-gtk/src/running_app_object.rs b/lan-mouse-gtk/src/running_app_object.rs
new file mode 100644
index 00000000..75d36bc1
--- /dev/null
+++ b/lan-mouse-gtk/src/running_app_object.rs
@@ -0,0 +1,55 @@
+use std::cell::RefCell;
+
+use glib::Object;
+use gtk::{gdk, glib, subclass::prelude::*};
+use lan_mouse_ipc::RunningApp;
+
+mod imp {
+    use super::*;
+
+    #[derive(Default)]
+    pub struct RunningAppObject {
+        pub display_name: RefCell<String>,
+        pub identifier: RefCell<String>,
+        pub icon: RefCell<Option<gdk::Texture>>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for RunningAppObject {
+        const NAME: &'static str = "LanMouseRunningAppObject";
+        type Type = super::RunningAppObject;
+    }
+
+    impl ObjectImpl for RunningAppObject {}
+}
+
+glib::wrapper! {
+    pub struct RunningAppObject(ObjectSubclass<imp::RunningAppObject>);
+}
+
+impl RunningAppObject {
+    pub fn new(app: &RunningApp) -> Self {
+        let obj: Self = Object::builder().build();
+        obj.imp().display_name.replace(app.display_name.clone());
+        obj.imp().identifier.replace(app.identifier.clone());
+        if let Some(bytes) = &app.icon_png {
+            let glib_bytes = glib::Bytes::from(bytes);
+            if let Ok(texture) = gdk::Texture::from_bytes(&glib_bytes) {
+                obj.imp().icon.replace(Some(texture));
+            }
+        }
+        obj
+    }
+
+    pub fn display_name(&self) -> String {
+        self.imp().display_name.borrow().clone()
+    }
+
+    pub fn identifier(&self) -> String {
+        self.imp().identifier.borrow().clone()
+    }
+
+    pub fn icon(&self) -> Option<gdk::Texture> {
+        self.imp().icon.borrow().clone()
+    }
+}
diff --git a/lan-mouse-gtk/src/window.rs b/lan-mouse-gtk/src/window.rs
index f6501572..5d0c4dca 100644
--- a/lan-mouse-gtk/src/window.rs
+++ b/lan-mouse-gtk/src/window.rs
@@ -16,8 +16,8 @@ use lan_mouse_ipc::{
 };
 
 use crate::{
-    authorization_window::AuthorizationWindow, fingerprint_window::FingerprintWindow,
-    key_object::KeyObject, key_row::KeyRow,
+    authorization_window::AuthorizationWindow, clipboard_privacy_window::ClipboardPrivacyWindow,
+    fingerprint_window::FingerprintWindow, key_object::KeyObject, key_row::KeyRow,
 };
 
 use super::{client_object::ClientObject, client_row::ClientRow};
@@ -110,6 +110,59 @@ impl Window {
                             }
                         ),
                     );
+                    row.connect_closure(
+                        "request-natural-scroll-change",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: KeyRow, natural_scroll: bool| {
+                                if let Some(key_obj) = window.authorized_by_idx(row.index() as u32)
+                                {
+                                    window.request(FrontendRequest::SetIncomingPeerNaturalScroll(
+                                        key_obj.get_fingerprint(),
+                                        natural_scroll,
+                                    ));
+                                }
+                            }
+                        ),
+                    );
+                    row.connect_closure(
+                        "request-sensitivity-change",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: KeyRow, sensitivity: f64| {
+                                if let Some(key_obj) = window.authorized_by_idx(row.index() as u32)
+                                {
+                                    window.request(FrontendRequest::SetIncomingPeerSensitivity(
+                                        key_obj.get_fingerprint(),
+                                        sensitivity,
+                                    ));
+                                }
+                            }
+                        ),
+                    );
+                    row.connect_closure(
+                        "request-clipboard-receive-change",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: KeyRow, clipboard_receive: bool| {
+                                if let Some(key_obj) = window.authorized_by_idx(row.index() as u32)
+                                {
+                                    window.request(
+                                        FrontendRequest::SetIncomingPeerClipboardReceive(
+                                            key_obj.get_fingerprint(),
+                                            clipboard_receive,
+                                        ),
+                                    );
+                                }
+                            }
+                        ),
+                    );
                     row.upcast()
                 }
             ),
@@ -238,6 +291,22 @@ impl Window {
                             }
                         ),
                     );
+                    row.connect_closure(
+                        "request-clipboard-send-change",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: ClientRow, clipboard_send: bool| {
+                                if let Some(client) = window.client_by_idx(row.index() as u32) {
+                                    window.request(FrontendRequest::SetClientClipboardSend(
+                                        client.handle(),
+                                        clipboard_send,
+                                    ));
+                                }
+                            }
+                        ),
+                    );
                     row.upcast()
                 }
             ),
@@ -340,6 +409,7 @@ impl Window {
         row.set_hostname(client.hostname);
         row.set_port(client.port);
         row.set_position(client.pos);
+        row.set_clipboard_send(client.clipboard_send);
     }
 
     pub(super) fn update_client_state(&self, handle: ClientHandle, state: ClientState) {
@@ -365,6 +435,13 @@ impl Window {
             .map(|ip| ip.to_string())
             .collect::<Vec<_>>();
         client_object.set_ips(ips);
+
+        /* peer build version (drives the version-match indicator) */
+        client_object.set_property(
+            "peer-commit",
+            crate::client_object::peer_commit_to_string(state.peer_commit),
+        );
+        row.refresh_version_status();
     }
 
     fn client_object_for_handle(&self, handle: ClientHandle) -> Option<ClientObject> {
@@ -407,9 +484,134 @@ impl Window {
         self.request(FrontendRequest::Create);
     }
 
+    pub(super) fn request_release_threshold(&self, threshold: u32) {
+        self.request(FrontendRequest::SetReleaseThreshold(threshold));
+    }
+
+    pub(super) fn request_mdns_discovery(&self, enabled: bool) {
+        self.request(FrontendRequest::SetMdnsDiscovery(enabled));
+    }
+
+    /// Forward the daemon's running-apps snapshot to the modal (if
+    /// it's been created). No-op when the user hasn't opened the
+    /// privacy window yet, since the picker is built lazily.
+    pub(super) fn set_running_apps(&self, apps: Vec<lan_mouse_ipc::RunningApp>) {
+        if let Some(window) = self.imp().clipboard_privacy_window.borrow().as_ref() {
+            window.set_running_apps(apps);
+        }
+    }
+
+    /// Replace the cached suppression list (host-OS strings) and
+    /// update both the main-window subtitle and the modal (if
+    /// open).
+    pub(super) fn set_suppressed_apps(&self, apps: Vec<String>) {
+        let imp = self.imp();
+        imp.suppressed_apps.replace(apps.clone());
+        let count = apps.len();
+        let subtitle = match count {
+            0 => "0 apps".to_owned(),
+            1 => "1 app".to_owned(),
+            n => format!("{n} apps"),
+        };
+        imp.clipboard_privacy_row.set_subtitle(&subtitle);
+        if let Some(window) = imp.clipboard_privacy_window.borrow().as_ref() {
+            window.set_apps(apps);
+        }
+    }
+
+    /// Show (or re-present) the clipboard-privacy modal, populating
+    /// it with the current suppression list. The modal is created
+    /// on first open and reused thereafter so the user's in-progress
+    /// edits aren't blown away by the every-toggle
+    /// SuppressedAppsUpdated round-trip.
+    pub(super) fn open_clipboard_privacy_window(&self) {
+        let imp = self.imp();
+        if imp.clipboard_privacy_window.borrow().is_none() {
+            let window = ClipboardPrivacyWindow::new();
+            window.set_transient_for(Some(self));
+            // Match the parent-relative sizing the other dialogs use.
+            let parent_w = self.width();
+            if parent_w > 0 {
+                let popup_w = (parent_w - 40).clamp(280, 700);
+                window.set_default_width(popup_w);
+            }
+            window.connect_closure(
+                "request-add",
+                false,
+                closure_local!(
+                    #[strong(rename_to = parent)]
+                    self,
+                    move |_w: ClipboardPrivacyWindow, value: String| {
+                        parent.request(FrontendRequest::AddSuppressedApp(value));
+                    }
+                ),
+            );
+            window.connect_closure(
+                "request-remove",
+                false,
+                closure_local!(
+                    #[strong(rename_to = parent)]
+                    self,
+                    move |_w: ClipboardPrivacyWindow, value: String| {
+                        parent.request(FrontendRequest::RemoveSuppressedApp(value));
+                    }
+                ),
+            );
+            window.set_apps(imp.suppressed_apps.borrow().clone());
+            // The daemon (a forked LSUIElement child) can't see
+            // other apps via NSWorkspace / NSRunningApplication —
+            // those APIs are scoped to the caller's loginwindow
+            // session and the daemon doesn't fully inherit one.
+            // The GUI process IS Aqua-attached, so we enumerate
+            // here and skip the IPC roundtrip entirely.
+            window.set_running_apps(input_capture::frontmost_app::list_running_apps());
+            // Auto-refresh every 5s while the modal is visible so
+            // launches/quits surface eventually without thrashing
+            // the main thread (each refresh re-encodes ~30 PNG
+            // icons). Skip refresh while the picker's popover is
+            // open so the user's selection / search doesn't
+            // disappear mid-interaction. Timer self-detaches when
+            // the window is dropped.
+            let window_weak = window.downgrade();
+            glib::source::timeout_add_local(std::time::Duration::from_secs(5), move || {
+                let Some(window) = window_weak.upgrade() else {
+                    return glib::ControlFlow::Break;
+                };
+                if !window.is_visible() {
+                    return glib::ControlFlow::Continue;
+                }
+                if window.picker_is_open() {
+                    return glib::ControlFlow::Continue;
+                }
+                window.set_running_apps(input_capture::frontmost_app::list_running_apps());
+                glib::ControlFlow::Continue
+            });
+            imp.clipboard_privacy_window.replace(Some(window));
+        } else if let Some(window) = imp.clipboard_privacy_window.borrow().as_ref() {
+            // Refresh both the suppressed-apps list and the
+            // running-apps picker in case they changed while the
+            // modal was hidden.
+            window.set_apps(imp.suppressed_apps.borrow().clone());
+            window.set_running_apps(input_capture::frontmost_app::list_running_apps());
+        }
+        if let Some(window) = imp.clipboard_privacy_window.borrow().as_ref() {
+            window.present();
+        }
+    }
+
     fn open_fingerprint_dialog(&self, fp: Option<String>) {
         let window = FingerprintWindow::new(fp);
         window.set_transient_for(Some(self));
+        // Size the popup 40 px narrower than the parent so it stays
+        // fully visible when the parent has been tiled into a narrow
+        // split (Hyprland and similar). Falls back to the XML default
+        // (460 px) when the parent's allocated width isn't yet known
+        // and clamps to the XML width-request floor.
+        let parent_w = self.width();
+        if parent_w > 0 {
+            let popup_w = (parent_w - 40).clamp(280, 460);
+            window.set_default_width(popup_w);
+        }
         window.connect_closure(
             "confirm-clicked",
             false,
@@ -461,6 +663,42 @@ impl Window {
         self.update_capture_emulation_status();
     }
 
+    pub(super) fn set_mdns_discovery(&self, enabled: bool) {
+        let imp = self.imp();
+        let switch = &imp.mdns_discovery_switch;
+        let handler = imp.mdns_discovery_handler.borrow();
+        if let Some(id) = handler.as_ref() {
+            switch.block_signal(id);
+        }
+        switch.set_active(enabled);
+        switch.set_state(enabled);
+        if let Some(id) = handler.as_ref() {
+            switch.unblock_signal(id);
+        }
+    }
+
+    pub(super) fn set_release_threshold(&self, threshold: u32) {
+        let imp = self.imp();
+        // Block the value-changed handler so programmatically setting
+        // the slider value (e.g. on Sync from the daemon) doesn't
+        // ricochet back as a SetReleaseThreshold request.
+        let scale = &imp.release_threshold_scale;
+        let handler_id = imp.release_threshold_handler.borrow();
+        if let Some(id) = handler_id.as_ref() {
+            scale.block_signal(id);
+        }
+        scale.set_value(threshold as f64);
+        if let Some(id) = handler_id.as_ref() {
+            scale.unblock_signal(id);
+        }
+        let label = if threshold == 0 {
+            "Disabled".to_string()
+        } else {
+            format!("{threshold} px")
+        };
+        imp.release_threshold_value.set_label(&label);
+    }
+
     #[cfg(target_os = "macos")]
     pub(super) fn refresh_capture_emulation_status(&self) {
         self.update_capture_emulation_status();
@@ -507,24 +745,54 @@ impl Window {
             // AX granted but capture/emulation still off → the daemon
             // subprocess bailed at startup and needs a fresh process to
             // re-initialize with the new grant in place.
-            row.set_title("relaunch required");
-            row.set_subtitle("Accessibility granted — restart to activate capture and emulation");
+            row.set_title("Relaunch Required");
+            row.set_subtitle("Accessibility granted — restart to activate capture and emulation.");
             set_button_content_label(button, "Relaunch");
         } else {
             // AX missing → send the user to System Settings.
-            row.set_title("input capture is disabled");
-            row.set_subtitle("grant Accessibility permission to enable");
+            row.set_title("Input Capture Disabled");
+            row.set_subtitle("Grant accessibility permission to enable.");
             set_button_content_label(button, "Grant");
         }
     }
 
-    pub(super) fn set_authorized_keys(&self, fingerprints: HashMap<String, String>) {
+    pub(super) fn set_authorized_keys(
+        &self,
+        mut fingerprints: HashMap<String, lan_mouse_ipc::IncomingPeerConfig>,
+    ) {
         let authorized = self.authorized();
-        // clear list
-        authorized.remove_all();
-        // insert fingerprints
-        for (fingerprint, description) in fingerprints {
-            let key_obj = KeyObject::new(description, fingerprint);
+        // In-place diff: a full `remove_all` + rebuild would collapse
+        // every expanded row whenever any setting changes (each
+        // setting toggle round-trips back as `AuthorizedUpdated`).
+        // Instead, walk the existing rows backward (so removals don't
+        // shift indices), update matching KeyObjects in place, drop
+        // entries no longer in the new map, and append anything
+        // unmatched at the end. KeyRow tracks property-notify on the
+        // KeyObject so the per-row widgets reflect the updates.
+        let mut idx = authorized.n_items();
+        while idx > 0 {
+            idx -= 1;
+            let Some(obj) = authorized.item(idx) else {
+                continue;
+            };
+            let Ok(key_obj) = obj.downcast::<KeyObject>() else {
+                continue;
+            };
+            let fp = key_obj.get_fingerprint();
+            if let Some(peer) = fingerprints.remove(&fp) {
+                key_obj.set_description(peer.description);
+                key_obj.set_natural_scroll(peer.natural_scroll);
+                key_obj.set_mouse_sensitivity(peer.mouse_sensitivity);
+                key_obj.set_last_addr(peer.last_addr.unwrap_or_default());
+                key_obj.set_last_hostname(peer.last_hostname.unwrap_or_default());
+                key_obj.set_clipboard_receive(peer.clipboard_receive);
+            } else {
+                authorized.remove(idx);
+            }
+        }
+        // Anything still in `fingerprints` is newly authorized.
+        for (fingerprint, peer) in fingerprints {
+            let key_obj = KeyObject::new(fingerprint, peer);
             authorized.append(&key_obj);
         }
         self.update_auth_placeholder_visibility();
@@ -540,6 +808,15 @@ impl Window {
         }
         let window = AuthorizationWindow::new(fingerprint);
         window.set_transient_for(Some(self));
+        // Same parent-relative sizing as the fingerprint dialog —
+        // 40 px narrower than the parent, capped at 460 to match the
+        // Add-Certificate modal, floored at 280 so it doesn't shrink
+        // under content.
+        let parent_w = self.width();
+        if parent_w > 0 {
+            let popup_w = (parent_w - 40).clamp(280, 460);
+            window.set_default_width(popup_w);
+        }
         window.connect_closure(
             "confirm-clicked",
             false,
diff --git a/lan-mouse-gtk/src/window/imp.rs b/lan-mouse-gtk/src/window/imp.rs
index bb7d48cb..404b4f94 100644
--- a/lan-mouse-gtk/src/window/imp.rs
+++ b/lan-mouse-gtk/src/window/imp.rs
@@ -4,11 +4,15 @@ use adw::subclass::prelude::*;
 use adw::{ActionRow, PreferencesGroup, ToastOverlay, prelude::*};
 use glib::subclass::InitializingObject;
 use gtk::glib::clone;
-use gtk::{Button, CompositeTemplate, Entry, Image, Label, ListBox, gdk, gio, glib};
+use gtk::{
+    Button, CompositeTemplate, Entry, EventControllerScroll, EventControllerScrollFlags, Image,
+    Label, ListBox, PropagationPhase, Scale, ScrolledWindow, Switch, gdk, gio, glib,
+};
 
 use lan_mouse_ipc::{DEFAULT_PORT, FrontendRequestWriter};
 
 use crate::authorization_window::AuthorizationWindow;
+use crate::clipboard_privacy_window::ClipboardPrivacyWindow;
 
 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/de/feschber/LanMouse/window.ui")]
@@ -45,6 +49,20 @@ pub struct Window {
     pub input_capture_button: TemplateChild<Button>,
     #[template_child]
     pub authorized_list: TemplateChild<ListBox>,
+    #[template_child]
+    pub release_threshold_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub release_threshold_scale: TemplateChild<Scale>,
+    #[template_child]
+    pub release_threshold_value: TemplateChild<Label>,
+    #[template_child]
+    pub mdns_discovery_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub mdns_discovery_switch: TemplateChild<Switch>,
+    #[template_child]
+    pub clipboard_privacy_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub clipboard_privacy_button: TemplateChild<Button>,
     pub clients: RefCell<Option<gio::ListStore>>,
     pub authorized: RefCell<Option<gio::ListStore>>,
     pub frontend_request_writer: RefCell<Option<FrontendRequestWriter>>,
@@ -52,6 +70,20 @@ pub struct Window {
     pub capture_active: Cell<bool>,
     pub emulation_active: Cell<bool>,
     pub authorization_window: RefCell<Option<AuthorizationWindow>>,
+    /// Connected handler for the auto-release-threshold scale's
+    /// value-changed signal, so we can block it when programmatically
+    /// updating the slider in response to a Sync event.
+    pub release_threshold_handler: RefCell<Option<glib::SignalHandlerId>>,
+    /// Same pattern for the mDNS-discovery switch.
+    pub mdns_discovery_handler: RefCell<Option<glib::SignalHandlerId>>,
+    /// Long-lived clipboard-privacy modal. Kept alive (rather than
+    /// rebuilt on every open) so its `set_apps` calls can run from
+    /// the SuppressedAppsUpdated event handler regardless of
+    /// whether the window is currently presented.
+    pub clipboard_privacy_window: RefCell<Option<ClipboardPrivacyWindow>>,
+    /// Latest server-confirmed host-OS suppression list. Cached so
+    /// the main-window subtitle stays in sync without re-querying.
+    pub suppressed_apps: RefCell<Vec<String>>,
 }
 
 #[glib::object_subclass]
@@ -200,6 +232,92 @@ impl ObjectImpl for Window {
         obj.setup_icon();
         obj.setup_clients();
         obj.setup_authorized();
+
+        // Connect the auto-release threshold slider. Stash the handler
+        // id so set_release_threshold() can block the signal when the
+        // daemon-driven Sync sets the value programmatically.
+        let scale = self.release_threshold_scale.clone();
+        let handler_id = scale.connect_value_changed(clone!(
+            #[weak(rename_to = window)]
+            obj,
+            move |scale| {
+                let value = scale.value().round() as u32;
+                let label = if value == 0 {
+                    "Disabled".to_string()
+                } else {
+                    format!("{value} px")
+                };
+                window.imp().release_threshold_value.set_label(&label);
+                window.request_release_threshold(value);
+            }
+        ));
+        self.release_threshold_handler.replace(Some(handler_id));
+
+        // Pass scroll-wheel events on the threshold slider through to
+        // the ancestor ScrolledWindow instead of letting GtkScale's
+        // default handler treat them as increment / decrement (which
+        // would drift the threshold any time the user scrolls past
+        // the slider). Returning `Stop` from a capture-phase handler
+        // suppresses the scale's own scroll-to-adjust handler, but
+        // also stops propagation to the parent — so we additionally
+        // bump the parent ScrolledWindow's vadjustment by hand to
+        // mimic native scroll-passthrough.
+        let scroll_forward = EventControllerScroll::new(
+            EventControllerScrollFlags::VERTICAL | EventControllerScrollFlags::HORIZONTAL,
+        );
+        scroll_forward.set_propagation_phase(PropagationPhase::Capture);
+        scroll_forward.connect_scroll(clone!(
+            #[weak(rename_to = scale)]
+            self.release_threshold_scale,
+            #[upgrade_or]
+            glib::Propagation::Stop,
+            move |_, _dx, dy| {
+                let mut walker = scale.parent();
+                while let Some(w) = walker {
+                    if let Some(scrolled) = w.downcast_ref::<ScrolledWindow>() {
+                        let vadj = scrolled.vadjustment();
+                        // step_increment is the "wheel tick" unit; if
+                        // unset (rare), fall back to a sensible
+                        // pixel default so a single tick still moves.
+                        let step = if vadj.step_increment() > 0.0 {
+                            vadj.step_increment()
+                        } else {
+                            40.0
+                        };
+                        let target = (vadj.value() + dy * step)
+                            .clamp(vadj.lower(), vadj.upper() - vadj.page_size());
+                        vadj.set_value(target);
+                        break;
+                    }
+                    walker = w.parent();
+                }
+                glib::Propagation::Stop
+            }
+        ));
+        self.release_threshold_scale.add_controller(scroll_forward);
+
+        // mDNS-discovery switch — identical pattern.
+        let mdns_switch = self.mdns_discovery_switch.clone();
+        let mdns_handler = mdns_switch.connect_state_set(clone!(
+            #[weak(rename_to = window)]
+            obj,
+            #[upgrade_or]
+            glib::Propagation::Proceed,
+            move |_, state| {
+                window.request_mdns_discovery(state);
+                glib::Propagation::Proceed
+            }
+        ));
+        self.mdns_discovery_handler.replace(Some(mdns_handler));
+
+        // Clipboard-privacy "Manage" button → open the modal.
+        self.clipboard_privacy_button.connect_clicked(clone!(
+            #[weak(rename_to = window)]
+            obj,
+            move |_| {
+                window.open_clipboard_privacy_window();
+            }
+        ));
     }
 }
 
diff --git a/lan-mouse-ipc/src/lib.rs b/lan-mouse-ipc/src/lib.rs
index a2c71126..e05940c3 100644
--- a/lan-mouse-ipc/src/lib.rs
+++ b/lan-mouse-ipc/src/lib.rs
@@ -58,6 +58,183 @@ pub enum IpcError {
 
 pub const DEFAULT_PORT: u16 = 4242;
 
+/// Cross-platform identifier for an application whose clipboard
+/// should not be shared with peers. The variant captures the
+/// platform-specific string the OS surfaces for "this is app X":
+/// macOS bundle ID, Windows executable basename, X11 `WM_CLASS`,
+/// Wayland `xdg-toplevel.app_id`. Comparison is case-insensitive
+/// within the same variant; cross-variant comparisons are always
+/// `false` so a `LinuxX11("Chromium")` entry does not unexpectedly
+/// suppress a Mac peer's `MacBundle("org.chromium.Chromium")`.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(tag = "kind", content = "value", rename_all = "snake_case")]
+pub enum AppIdent {
+    /// macOS bundle identifier, e.g. `com.1password.1password7`.
+    MacBundle(String),
+    /// Windows executable basename (lowercased), e.g.
+    /// `1password.exe`.
+    WindowsExe(String),
+    /// X11 `WM_CLASS` instance/name (lowercased), e.g. `firefox`.
+    LinuxX11(String),
+    /// Wayland `xdg-toplevel.app_id` (lowercased), e.g.
+    /// `org.mozilla.firefox`.
+    LinuxWayland(String),
+}
+
+impl AppIdent {
+    /// Case-insensitive equality within the same variant.
+    pub fn matches(&self, other: &AppIdent) -> bool {
+        match (self, other) {
+            (AppIdent::MacBundle(a), AppIdent::MacBundle(b))
+            | (AppIdent::WindowsExe(a), AppIdent::WindowsExe(b))
+            | (AppIdent::LinuxX11(a), AppIdent::LinuxX11(b))
+            | (AppIdent::LinuxWayland(a), AppIdent::LinuxWayland(b)) => a.eq_ignore_ascii_case(b),
+            _ => false,
+        }
+    }
+
+    /// Human-readable rendering: `value (kind)` so the GUI can show
+    /// `1password.exe (Windows)` rather than the raw enum.
+    pub fn label(&self) -> String {
+        match self {
+            AppIdent::MacBundle(v) => format!("{v} (macOS bundle)"),
+            AppIdent::WindowsExe(v) => format!("{v} (Windows)"),
+            AppIdent::LinuxX11(v) => format!("{v} (X11)"),
+            AppIdent::LinuxWayland(v) => format!("{v} (Wayland)"),
+        }
+    }
+}
+
+/// Per-OS clipboard suppression lists. Each host machine reads and
+/// writes only the field that matches its own OS (`host()` /
+/// `host_mut()`); the remaining fields round-trip through
+/// `config.toml` untouched, so a single config file shipped across
+/// machines (dotfiles, Syncthing, …) keeps each machine's
+/// suppressed-app list intact. Strings are opaque platform
+/// identifiers in the section's natural shape — bundle ID for
+/// macOS, exe basename for Windows, etc.
+#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ClipboardSuppression {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub macos: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub windows: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub linux_wayland: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub linux_x11: Vec<String>,
+}
+
+impl ClipboardSuppression {
+    /// Borrow the host machine's slot — the only one the GUI/CLI on
+    /// this device ever interacts with. On Linux the choice between
+    /// `linux_wayland` and `linux_x11` is decided at runtime via
+    /// `WAYLAND_DISPLAY` so a single binary serves both session
+    /// types correctly.
+    pub fn host(&self) -> &Vec<String> {
+        match HostKind::current() {
+            HostKind::MacBundle => &self.macos,
+            HostKind::WindowsExe => &self.windows,
+            HostKind::LinuxWayland => &self.linux_wayland,
+            HostKind::LinuxX11 => &self.linux_x11,
+        }
+    }
+
+    /// Mutable borrow of [`Self::host`] for add/remove operations.
+    pub fn host_mut(&mut self) -> &mut Vec<String> {
+        match HostKind::current() {
+            HostKind::MacBundle => &mut self.macos,
+            HostKind::WindowsExe => &mut self.windows,
+            HostKind::LinuxWayland => &mut self.linux_wayland,
+            HostKind::LinuxX11 => &mut self.linux_x11,
+        }
+    }
+
+    /// True when every per-OS slot is empty — used by the config
+    /// writer to drop the key entirely instead of writing an empty
+    /// table on save.
+    pub fn is_empty(&self) -> bool {
+        self.macos.is_empty()
+            && self.windows.is_empty()
+            && self.linux_wayland.is_empty()
+            && self.linux_x11.is_empty()
+    }
+}
+
+/// The [`AppIdent`] variant that this binary's host OS produces.
+/// Computed once per call (cheap) so a Wayland session that
+/// starts/stops mid-process picks up the change at the next
+/// suppression check.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum HostKind {
+    MacBundle,
+    WindowsExe,
+    LinuxWayland,
+    LinuxX11,
+}
+
+impl HostKind {
+    pub fn current() -> Self {
+        #[cfg(target_os = "macos")]
+        {
+            HostKind::MacBundle
+        }
+        #[cfg(windows)]
+        {
+            HostKind::WindowsExe
+        }
+        #[cfg(all(unix, not(target_os = "macos")))]
+        {
+            if std::env::var_os("WAYLAND_DISPLAY")
+                .map(|v| !v.is_empty())
+                .unwrap_or(false)
+            {
+                HostKind::LinuxWayland
+            } else {
+                HostKind::LinuxX11
+            }
+        }
+    }
+
+    /// Wrap a host-OS identifier string in the matching [`AppIdent`]
+    /// variant for the runtime suppression check.
+    pub fn make_ident(self, value: String) -> AppIdent {
+        match self {
+            HostKind::MacBundle => AppIdent::MacBundle(value),
+            HostKind::WindowsExe => AppIdent::WindowsExe(value),
+            HostKind::LinuxWayland => AppIdent::LinuxWayland(value),
+            HostKind::LinuxX11 => AppIdent::LinuxX11(value),
+        }
+    }
+
+    /// Short noun used in GUI prompts ("Bundle ID", "Executable
+    /// name", "WM_CLASS", …).
+    pub fn entry_noun(self) -> &'static str {
+        match self {
+            HostKind::MacBundle => "Bundle ID",
+            HostKind::WindowsExe => "Executable name",
+            HostKind::LinuxWayland => "App ID",
+            HostKind::LinuxX11 => "WM_CLASS",
+        }
+    }
+
+    /// Placeholder shown inside the GUI's add-an-app text field.
+    pub fn placeholder(self) -> &'static str {
+        match self {
+            HostKind::MacBundle => "e.g. com.1password.1password7",
+            HostKind::WindowsExe => "e.g. 1Password.exe",
+            HostKind::LinuxWayland => "e.g. org.keepassxc.KeePassXC",
+            HostKind::LinuxX11 => "e.g. KeePassXC",
+        }
+    }
+}
+
+/// Convenience: wrap `value` in the host-OS [`AppIdent`] variant.
+/// Equivalent to `HostKind::current().make_ident(value)`.
+pub fn host_app_ident(value: String) -> AppIdent {
+    HostKind::current().make_ident(value)
+}
+
 #[derive(Debug, Default, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum Position {
@@ -140,6 +317,14 @@ pub struct ClientConfig {
     pub pos: Position,
     /// enter hook
     pub cmd: Option<String>,
+    /// Whether changes to this device's clipboard should be
+    /// propagated to this peer. Per-pair gate on the *send* side;
+    /// the receiving peer's `IncomingPeerConfig::clipboard_receive`
+    /// is the matching gate on the receive side. Both must be true
+    /// for clipboard text to flow. Defaults to `false` — clipboard
+    /// is a meaningfully different trust scope than mouse/keyboard.
+    #[serde(default)]
+    pub clipboard_send: bool,
 }
 
 impl Default for ClientConfig {
@@ -150,12 +335,119 @@ impl Default for ClientConfig {
             fix_ips: Default::default(),
             pos: Default::default(),
             cmd: None,
+            clipboard_send: false,
         }
     }
 }
 
 pub type ClientHandle = u64;
 
+/// Per-incoming-peer settings, keyed on the peer's TLS certificate
+/// fingerprint in `Config::authorized_fingerprints`. Holds the
+/// human-readable description plus receive-side post-processing
+/// preferences applied to events forwarded from this peer.
+///
+/// Wire format is forward-compatible: legacy configs that store a
+/// bare string per fingerprint deserialize as
+/// `IncomingPeerConfig { description: <string>, .. defaults }`. The
+/// custom `Deserialize` impl handles both shapes so users upgrading
+/// from older versions don't lose their authorizations.
+#[derive(Debug, Clone, PartialEq, Serialize)]
+pub struct IncomingPeerConfig {
+    pub description: String,
+    /// Sign-flip scroll deltas before injection. Mirrors the
+    /// libinput natural-scroll concept, but applies only to
+    /// virtual-pointer events forwarded from this specific peer
+    /// (which bypass libinput entirely on Wayland).
+    pub natural_scroll: bool,
+    /// Linear multiplier applied to motion deltas before injection.
+    /// 1.0 = passthrough. Useful when senders capture motion at
+    /// different scales (e.g. a Mac trackpad's small floating-point
+    /// deltas vs a Windows high-DPI mouse's count deltas).
+    pub mouse_sensitivity: f64,
+    /// Most recent IP this peer connected from. Stored as a plain
+    /// string (no port) so reconnects from the same machine on a
+    /// new ephemeral port don't churn the value. Persists across
+    /// daemon restarts so the GUI has something to show even when
+    /// the peer is currently offline.
+    pub last_addr: Option<String>,
+    /// mDNS-resolved hostname for `last_addr` at the time of last
+    /// connect, recovered from the discovery layer's
+    /// `hostname → ip` cache. `None` if discovery wasn't running
+    /// on either side or the peer's mDNS record didn't match the
+    /// IP it connected from.
+    pub last_hostname: Option<String>,
+    /// Whether clipboard text propagated by this peer should be
+    /// applied to the local clipboard. Per-pair gate on the
+    /// *receive* side; the sending peer's
+    /// `ClientConfig::clipboard_send` is the matching gate on the
+    /// send side. Both must be true for clipboard text to flow.
+    /// Defaults to `false`.
+    pub clipboard_receive: bool,
+}
+
+impl Default for IncomingPeerConfig {
+    fn default() -> Self {
+        Self {
+            description: String::new(),
+            natural_scroll: false,
+            mouse_sensitivity: 1.0,
+            last_addr: None,
+            last_hostname: None,
+            clipboard_receive: false,
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncomingPeerConfig {
+    fn deserialize<D: serde::Deserializer<'de>>(de: D) -> Result<Self, D::Error> {
+        // Legacy: a bare string is just the description.
+        // Current: a struct with description + post-processing fields.
+        #[derive(Deserialize)]
+        #[serde(untagged)]
+        enum Repr {
+            Legacy(String),
+            Full {
+                description: String,
+                #[serde(default)]
+                natural_scroll: bool,
+                #[serde(default = "default_sensitivity")]
+                mouse_sensitivity: f64,
+                #[serde(default)]
+                last_addr: Option<String>,
+                #[serde(default)]
+                last_hostname: Option<String>,
+                #[serde(default)]
+                clipboard_receive: bool,
+            },
+        }
+        fn default_sensitivity() -> f64 {
+            1.0
+        }
+        Ok(match Repr::deserialize(de)? {
+            Repr::Legacy(description) => Self {
+                description,
+                ..Self::default()
+            },
+            Repr::Full {
+                description,
+                natural_scroll,
+                mouse_sensitivity,
+                last_addr,
+                last_hostname,
+                clipboard_receive,
+            } => Self {
+                description,
+                natural_scroll,
+                mouse_sensitivity,
+                last_addr,
+                last_hostname,
+                clipboard_receive,
+            },
+        })
+    }
+}
+
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct ClientState {
     /// events should be sent to and received from the client
@@ -176,6 +468,12 @@ pub struct ClientState {
     pub has_pressed_keys: bool,
     /// dns resolving in progress
     pub resolving: bool,
+    /// Peer's build short commit hash from the [`Hello`] proto
+    /// event. `None` means we haven't received a Hello yet — either
+    /// the connection is fresh, or the peer is on an older build
+    /// that predates the Hello event. The frontend uses this to
+    /// soft-warn on version mismatch.
+    pub peer_commit: Option<[u8; 8]>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -198,8 +496,10 @@ pub enum FrontendEvent {
     CaptureStatus(Status),
     /// emulation status
     EmulationStatus(Status),
-    /// authorized public key fingerprints have been updated
-    AuthorizedUpdated(HashMap<String, String>),
+    /// authorized public key fingerprints have been updated.
+    /// The map's value carries each peer's per-pair receive-side
+    /// post-processing preferences alongside its description.
+    AuthorizedUpdated(HashMap<String, IncomingPeerConfig>),
     /// public key fingerprint of this device
     PublicKeyFingerprint(String),
     /// new device connected
@@ -217,9 +517,51 @@ pub enum FrontendEvent {
     IncomingDisconnected(SocketAddr),
     /// failed connection attempt (approval for fingerprint required)
     ConnectionAttempt { fingerprint: String },
+    /// pixel threshold for the wall-press auto-release fallback.
+    /// 0 means disabled.
+    ReleaseThreshold(u32),
+    /// whether mDNS-SD discovery is on. When true, lan-mouse
+    /// advertises a `_lan-mouse._udp.local.` Bonjour service whose
+    /// TXT record's `primary=` field hints at the OS-preferred
+    /// interface (Mac service order / Linux default route), so
+    /// peers can bias their connection attempts toward the right
+    /// interface on multi-homed hosts.
+    MdnsDiscovery(bool),
+    /// Snapshot of the host-OS clipboard-suppression list. Pushed
+    /// on Sync and after every Add/Remove so the GUI never has to
+    /// query. The strings are opaque platform identifiers in the
+    /// host's natural shape — bundle ID on macOS, exe basename on
+    /// Windows, `xdg-toplevel.app_id` on Wayland, `WM_CLASS` on
+    /// X11. Other-OS sections in `config.toml` are intentionally
+    /// not surfaced — you edit those by sitting in front of that
+    /// machine.
+    SuppressedAppsUpdated(Vec<String>),
+    /// Reply to [`FrontendRequest::ListRunningApps`]: best-effort
+    /// list of apps currently running on this device. Empty when
+    /// enumeration isn't reachable (no compositor support, missing
+    /// permissions, transient race).
+    RunningApps(Vec<RunningApp>),
 }
 
-#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
+/// One running-app candidate for the suppression-list picker. The
+/// `identifier` is the host-OS string the runtime suppression check
+/// compares against (bundle ID on macOS, exe basename on Windows,
+/// `xdg-toplevel.app_id` on Wayland, `WM_CLASS` on X11). The
+/// `display_name` is what we show in the dropdown — usually the
+/// app's localized name on macOS, or just the identifier on
+/// platforms where there's no separate user-facing label.
+/// `icon_png` is an optional PNG-encoded icon (~32×32) the GUI can
+/// render alongside the name; `None` on platforms where icon
+/// extraction isn't implemented or when the OS reports no icon.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RunningApp {
+    pub display_name: String,
+    pub identifier: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub icon_png: Option<Vec<u8>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum FrontendRequest {
     /// activate/deactivate client
     Activate(ClientHandle, bool),
@@ -255,6 +597,38 @@ pub enum FrontendRequest {
     UpdateEnterHook(u64, Option<String>),
     /// save config file
     SaveConfiguration,
+    /// set the wall-press auto-release pixel threshold (0 = disabled)
+    SetReleaseThreshold(u32),
+    /// set whether forwarded scroll events from a specific
+    /// authorized peer should be sign-inverted on injection.
+    /// Keyed on the peer's TLS certificate fingerprint.
+    SetIncomingPeerNaturalScroll(String, bool),
+    /// set the linear motion-sensitivity multiplier for events
+    /// forwarded from a specific authorized peer. 1.0 = passthrough.
+    /// Keyed on the peer's TLS certificate fingerprint.
+    SetIncomingPeerSensitivity(String, f64),
+    /// turn mDNS-SD discovery on or off
+    SetMdnsDiscovery(bool),
+    /// Toggle whether clipboard changes on this device propagate to
+    /// the given outgoing client. Per-pair send-side gate.
+    SetClientClipboardSend(ClientHandle, bool),
+    /// Toggle whether clipboard text from the given authorized peer
+    /// is applied to this device's clipboard. Per-pair receive-side
+    /// gate, keyed on the peer's TLS certificate fingerprint.
+    SetIncomingPeerClipboardReceive(String, bool),
+    /// Add a host-OS app identifier to the clipboard suppression
+    /// list — that app's clipboard contents will never be
+    /// broadcast to peers. The kind is implicit from the OS the
+    /// daemon is running on (see [`host_app_ident`]). Idempotent.
+    AddSuppressedApp(String),
+    /// Remove a host-OS app identifier from the clipboard
+    /// suppression list. Idempotent.
+    RemoveSuppressedApp(String),
+    /// Ask the daemon to enumerate currently-running apps so the
+    /// "From running apps" tab in the suppression-list modal can be
+    /// populated. The daemon replies with a
+    /// [`FrontendEvent::RunningApps`].
+    ListRunningApps,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Serialize, Deserialize)]
@@ -299,3 +673,161 @@ pub fn default_socket_path() -> Result<PathBuf, SocketPathError> {
         .join("Caches")
         .join(LAN_MOUSE_SOCKET_NAME))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn app_ident_matches_within_variant_case_insensitive() {
+        let entry = AppIdent::WindowsExe("1Password.exe".into());
+        let detected = AppIdent::WindowsExe("1password.exe".into());
+        assert!(entry.matches(&detected));
+        assert!(detected.matches(&entry));
+    }
+
+    #[test]
+    fn app_ident_matches_rejects_value_mismatch() {
+        let a = AppIdent::LinuxX11("firefox".into());
+        let b = AppIdent::LinuxX11("chromium".into());
+        assert!(!a.matches(&b));
+    }
+
+    #[test]
+    fn app_ident_matches_rejects_cross_variant() {
+        // A Mac entry for `org.mozilla.firefox` must NOT suppress a
+        // Linux peer that reports `firefox` as its WM_CLASS — same
+        // semantic app, different platform identifiers, and the
+        // suppression list lives on the device that captures the
+        // clipboard, not the device that displays the window.
+        let mac = AppIdent::MacBundle("org.mozilla.firefox".into());
+        let linux = AppIdent::LinuxX11("firefox".into());
+        assert!(!mac.matches(&linux));
+    }
+
+    #[test]
+    fn app_ident_serde_round_trip_json() {
+        let cases = [
+            AppIdent::MacBundle("com.1password.1password7".into()),
+            AppIdent::WindowsExe("1password.exe".into()),
+            AppIdent::LinuxX11("firefox".into()),
+            AppIdent::LinuxWayland("org.mozilla.firefox".into()),
+        ];
+        for original in cases {
+            let s = serde_json::to_string(&original).expect("encode");
+            let decoded: AppIdent = serde_json::from_str(&s).expect("decode");
+            assert_eq!(original, decoded, "round-trip mismatch: {s}");
+        }
+    }
+
+    #[test]
+    fn app_ident_serde_kind_tag_is_snake_case() {
+        // Pin the tag rendering — config.toml + IPC consumers depend
+        // on these strings, so an accidental rename in a serde
+        // attribute would silently break legacy configs.
+        let mac = AppIdent::MacBundle("x".into());
+        assert_eq!(
+            serde_json::to_string(&mac).unwrap(),
+            r#"{"kind":"mac_bundle","value":"x"}"#
+        );
+        let exe = AppIdent::WindowsExe("y".into());
+        assert_eq!(
+            serde_json::to_string(&exe).unwrap(),
+            r#"{"kind":"windows_exe","value":"y"}"#
+        );
+        let x11 = AppIdent::LinuxX11("z".into());
+        assert_eq!(
+            serde_json::to_string(&x11).unwrap(),
+            r#"{"kind":"linux_x11","value":"z"}"#
+        );
+        let wl = AppIdent::LinuxWayland("w".into());
+        assert_eq!(
+            serde_json::to_string(&wl).unwrap(),
+            r#"{"kind":"linux_wayland","value":"w"}"#
+        );
+    }
+
+    #[test]
+    fn app_ident_label_includes_platform() {
+        assert!(
+            AppIdent::MacBundle("com.x.y".into())
+                .label()
+                .contains("macOS bundle")
+        );
+        assert!(
+            AppIdent::WindowsExe("z.exe".into())
+                .label()
+                .contains("Windows")
+        );
+        assert!(AppIdent::LinuxX11("z".into()).label().contains("X11"));
+        assert!(
+            AppIdent::LinuxWayland("z".into())
+                .label()
+                .contains("Wayland")
+        );
+    }
+
+    #[test]
+    fn incoming_peer_legacy_string_deserializes() {
+        // Configs from before the per-pair scroll/sensitivity work
+        // store each authorized peer as a bare description string.
+        // Custom Deserialize must accept that shape so upgrading
+        // doesn't silently drop authorizations.
+        let json = r#""my laptop""#;
+        let peer: IncomingPeerConfig = serde_json::from_str(json).unwrap();
+        assert_eq!(peer.description, "my laptop");
+        assert!(!peer.natural_scroll);
+        assert!(!peer.clipboard_receive);
+        assert_eq!(peer.mouse_sensitivity, 1.0);
+    }
+
+    #[test]
+    fn incoming_peer_full_with_clipboard_receive_round_trips() {
+        let original = IncomingPeerConfig {
+            description: "laptop".into(),
+            natural_scroll: true,
+            mouse_sensitivity: 1.5,
+            last_addr: Some("10.0.0.1".into()),
+            last_hostname: Some("foo.local".into()),
+            clipboard_receive: true,
+        };
+        let s = serde_json::to_string(&original).unwrap();
+        let decoded: IncomingPeerConfig = serde_json::from_str(&s).unwrap();
+        assert_eq!(decoded, original);
+    }
+
+    #[test]
+    fn incoming_peer_legacy_full_without_clipboard_receive_defaults_false() {
+        // A v0 "Full" entry (struct shape but no clipboard_receive
+        // field) must default the new field to false rather than
+        // refusing to decode.
+        let json = r#"{
+            "description": "laptop",
+            "natural_scroll": true,
+            "mouse_sensitivity": 1.5,
+            "last_addr": "10.0.0.1",
+            "last_hostname": "foo.local"
+        }"#;
+        let peer: IncomingPeerConfig = serde_json::from_str(json).unwrap();
+        assert_eq!(peer.description, "laptop");
+        assert!(peer.natural_scroll);
+        assert_eq!(peer.mouse_sensitivity, 1.5);
+        assert!(!peer.clipboard_receive);
+    }
+
+    #[test]
+    fn client_config_clipboard_send_defaults_false() {
+        // ClientConfig uses derive(Deserialize) with
+        // #[serde(default)] on clipboard_send — a JSON object that
+        // omits the field should still decode and produce false.
+        let json = r#"{
+            "hostname": null,
+            "fix_ips": [],
+            "port": 4242,
+            "pos": "left",
+            "cmd": null
+        }"#;
+        let cfg: ClientConfig = serde_json::from_str(json).unwrap();
+        assert!(!cfg.clipboard_send);
+    }
+}
diff --git a/lan-mouse-proto/src/lib.rs b/lan-mouse-proto/src/lib.rs
index 41f2efbf..b840b976 100644
--- a/lan-mouse-proto/src/lib.rs
+++ b/lan-mouse-proto/src/lib.rs
@@ -1,4 +1,4 @@
-use input_event::{Event as InputEvent, KeyboardEvent, PointerEvent};
+use input_event::{ClipboardEvent, Event as InputEvent, KeyboardEvent, PointerEvent};
 use num_enum::{IntoPrimitive, TryFromPrimitive, TryFromPrimitiveError};
 use paste::paste;
 use std::{
@@ -7,11 +7,18 @@ use std::{
 };
 use thiserror::Error;
 
-/// defines the maximum size an encoded event can take up
-/// this is currently the pointer motion event
-/// type: u8, time: u32, dx: f64, dy: f64
+/// defines the maximum size a fixed-buffer encoded event can take up.
+/// All non-clipboard events fit in this size; clipboard events use the
+/// variable-length [`encode_clipboard_event`] / [`decode_clipboard_event`]
+/// helpers because their payload (originator fingerprint + content)
+/// vastly exceeds the fixed buffer's capacity.
 pub const MAX_EVENT_SIZE: usize = size_of::<u8>() + size_of::<u32>() + 2 * size_of::<f64>();
 
+/// Maximum total clipboard payload size on the wire (originator
+/// fingerprint + content + length prefixes). 4 KiB is conservative
+/// against typical UDP MTU.
+pub const MAX_CLIPBOARD_SIZE: usize = 4 * 1024;
+
 /// error type for protocol violations
 #[derive(Debug, Error)]
 pub enum ProtocolError {
@@ -21,6 +28,15 @@ pub enum ProtocolError {
     /// position type does not exist
     #[error("invalid event id: `{0}`")]
     InvalidPosition(#[from] TryFromPrimitiveError<Position>),
+    /// clipboard payload exceeds [`MAX_CLIPBOARD_SIZE`]
+    #[error("clipboard payload too large: {0} bytes")]
+    ClipboardTooLarge(usize),
+    /// clipboard text is not valid UTF-8
+    #[error("invalid UTF-8 in clipboard payload")]
+    InvalidUtf8(#[from] std::string::FromUtf8Error),
+    /// not enough bytes left in the buffer
+    #[error("buffer too small for clipboard payload")]
+    BufferTooSmall,
 }
 
 /// Position of a client
@@ -46,7 +62,7 @@ impl Display for Position {
 }
 
 /// main lan-mouse protocol event type
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub enum ProtoEvent {
     /// notify a client that the cursor entered its region at the given position
     /// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
@@ -63,6 +79,64 @@ pub enum ProtoEvent {
     Ping,
     /// Response to [`ProtoEvent::Ping`], true if emulation is enabled / available
     Pong(bool),
+    /// Display geometry of the receiving device. Sent by the
+    /// emulation side immediately after the [`ProtoEvent::Ack`] of
+    /// an [`ProtoEvent::Enter`] so the capturing peer can model the
+    /// guest cursor's position along the entry axis. Width and
+    /// height are in pixels of the union of all displays on the
+    /// emulating device.
+    Bounds { width: u32, height: u32 },
+    /// Absolute cursor warp on the receiving device. Sent by the
+    /// capturing peer after [`ProtoEvent::Enter`] so the guest's
+    /// cursor lands at the position that visually corresponds to
+    /// where the user's physical cursor was at the moment of
+    /// crossing. `x` and `y` are pixel coordinates in the receiver's
+    /// screen space, computed by the capturing peer using its own
+    /// display bounds and the receiver-supplied [`ProtoEvent::Bounds`]
+    /// from a prior Enter.
+    MotionAbsolute { x: i32, y: i32 },
+    /// Self-sufficient counterpart to [`ProtoEvent::MotionAbsolute`].
+    /// Carries the host's cursor position normalized to the host's
+    /// own display bounds (0..1 along each axis) plus the entry
+    /// side from the receiver's frame. The receiver scales nx/ny
+    /// against its own bounds and pins the on-axis dimension to
+    /// the entry edge, eliminating the bootstrap problem where
+    /// MotionAbsolute couldn't be sent on the first crossing
+    /// because the host had no cached peer geometry.
+    CursorPos { pos: Position, nx: f32, ny: f32 },
+    /// Build identification for the sending peer. Sent by the
+    /// connect side once after the connection authenticates, and
+    /// echoed back by the listen side in reply, so each end can
+    /// display the peer's build hash and warn (soft) on mismatch.
+    /// `commit` is the 8-byte ASCII short commit hash from
+    /// `shadow_rs`'s `SHORT_COMMIT`. Old peers that don't
+    /// recognize the event type silently skip it per the
+    /// forward-compat handling in the receive loop.
+    Hello { commit: [u8; 8] },
+    /// The receiver's per-pair motion-sensitivity multiplier.
+    /// Sent by the emulating peer immediately after the
+    /// [`ProtoEvent::Ack`] of an [`ProtoEvent::Enter`] so the
+    /// capturing peer can scale its wall-press auto-release model
+    /// to match. Without this, a sensitivity multiplier below 1.0
+    /// would make the host's model accumulate "wall pressure"
+    /// faster than the receiver's actual cursor moves, firing
+    /// AutoRelease before the cursor has reached the edge. Old
+    /// peers that don't recognize the event type silently skip it
+    /// per the existing forward-compat handling.
+    ReceiverSensitivity { mouse_sensitivity: f64 },
+    /// Clipboard text content propagated from the originating peer.
+    /// `from_fingerprint` is the TLS fingerprint of the peer that
+    /// originally read the clipboard (not necessarily the sender —
+    /// intermediate peers preserve the originator field when they
+    /// fan-out to other peers). The receiver uses it to short-circuit
+    /// the N-peer forwarding loop along with a recent-content cache.
+    /// `content` is the clipboard text. Encoded with the variable-
+    /// length [`encode_clipboard_event`] / [`decode_clipboard_event`]
+    /// helpers; the fixed-buffer codec panics on this variant.
+    Clipboard {
+        from_fingerprint: String,
+        content: String,
+    },
 }
 
 impl Display for ProtoEvent {
@@ -80,11 +154,40 @@ impl Display for ProtoEvent {
                     if *alive { "alive" } else { "not available" }
                 )
             }
+            ProtoEvent::Bounds { width, height } => write!(f, "Bounds({width}x{height})"),
+            ProtoEvent::MotionAbsolute { x, y } => write!(f, "MotionAbsolute({x}, {y})"),
+            ProtoEvent::CursorPos { pos, nx, ny } => {
+                write!(f, "CursorPos({pos}, {nx:.4}, {ny:.4})")
+            }
+            ProtoEvent::ReceiverSensitivity { mouse_sensitivity } => {
+                write!(f, "ReceiverSensitivity({mouse_sensitivity:.2})")
+            }
+            ProtoEvent::Hello { commit } => {
+                let s = std::str::from_utf8(commit).unwrap_or("????????");
+                write!(f, "Hello({s})")
+            }
+            ProtoEvent::Clipboard {
+                from_fingerprint,
+                content,
+            } => {
+                let head: String = content.chars().take(40).collect();
+                let preview = if head.len() < content.len() {
+                    format!("{head}…")
+                } else {
+                    head
+                };
+                write!(
+                    f,
+                    "Clipboard(from={}…, {}b: {preview})",
+                    &from_fingerprint[..from_fingerprint.len().min(8)],
+                    content.len(),
+                )
+            }
         }
     }
 }
 
-#[derive(TryFromPrimitive, IntoPrimitive)]
+#[derive(TryFromPrimitive, IntoPrimitive, Debug)]
 #[repr(u8)]
 pub enum EventType {
     PointerMotion,
@@ -98,6 +201,15 @@ pub enum EventType {
     Enter,
     Leave,
     Ack,
+    Bounds,
+    MotionAbsolute,
+    CursorPos,
+    Hello,
+    ReceiverSensitivity,
+    /// Variable-length clipboard frame; not decodable through the
+    /// fixed-size [`MAX_EVENT_SIZE`] buffer path. See
+    /// [`decode_clipboard_event`].
+    Clipboard,
 }
 
 impl ProtoEvent {
@@ -114,12 +226,21 @@ impl ProtoEvent {
                     KeyboardEvent::Key { .. } => EventType::KeyboardKey,
                     KeyboardEvent::Modifiers { .. } => EventType::KeyboardModifiers,
                 },
+                InputEvent::Clipboard(c) => match c {
+                    ClipboardEvent::Text(_) => EventType::Clipboard,
+                },
             },
             ProtoEvent::Ping => EventType::Ping,
             ProtoEvent::Pong(_) => EventType::Pong,
             ProtoEvent::Enter(_) => EventType::Enter,
             ProtoEvent::Leave(_) => EventType::Leave,
             ProtoEvent::Ack(_) => EventType::Ack,
+            ProtoEvent::Bounds { .. } => EventType::Bounds,
+            ProtoEvent::MotionAbsolute { .. } => EventType::MotionAbsolute,
+            ProtoEvent::CursorPos { .. } => EventType::CursorPos,
+            ProtoEvent::Hello { .. } => EventType::Hello,
+            ProtoEvent::ReceiverSensitivity { .. } => EventType::ReceiverSensitivity,
+            ProtoEvent::Clipboard { .. } => EventType::Clipboard,
         }
     }
 }
@@ -174,6 +295,33 @@ impl TryFrom<[u8; MAX_EVENT_SIZE]> for ProtoEvent {
             EventType::Enter => Ok(Self::Enter(decode_u8(&mut buf)?.try_into()?)),
             EventType::Leave => Ok(Self::Leave(decode_u32(&mut buf)?)),
             EventType::Ack => Ok(Self::Ack(decode_u32(&mut buf)?)),
+            EventType::Bounds => Ok(Self::Bounds {
+                width: decode_u32(&mut buf)?,
+                height: decode_u32(&mut buf)?,
+            }),
+            EventType::MotionAbsolute => Ok(Self::MotionAbsolute {
+                x: decode_i32(&mut buf)?,
+                y: decode_i32(&mut buf)?,
+            }),
+            EventType::CursorPos => Ok(Self::CursorPos {
+                pos: decode_u8(&mut buf)?.try_into()?,
+                nx: decode_f32(&mut buf)?,
+                ny: decode_f32(&mut buf)?,
+            }),
+            EventType::Hello => {
+                let mut commit = [0u8; 8];
+                for b in commit.iter_mut() {
+                    *b = decode_u8(&mut buf)?;
+                }
+                Ok(Self::Hello { commit })
+            }
+            EventType::ReceiverSensitivity => Ok(Self::ReceiverSensitivity {
+                mouse_sensitivity: decode_f64(&mut buf)?,
+            }),
+            // Clipboard frames are variable-length and never arrive
+            // through the fixed-size buffer path; the connect/listen
+            // layer routes them through `decode_clipboard_event`.
+            EventType::Clipboard => Err(ProtocolError::BufferTooSmall),
         }
     }
 }
@@ -232,12 +380,45 @@ impl From<ProtoEvent> for ([u8; MAX_EVENT_SIZE], usize) {
                             encode_u32(buf, len, group);
                         }
                     },
+                    InputEvent::Clipboard(_) => {
+                        panic!(
+                            "ProtoEvent::Input(Clipboard) cannot use the fixed-buffer \
+                             encoder; route via encode_clipboard_event"
+                        );
+                    }
                 },
                 ProtoEvent::Ping => {}
                 ProtoEvent::Pong(alive) => encode_u8(buf, len, alive as u8),
                 ProtoEvent::Enter(pos) => encode_u8(buf, len, pos as u8),
                 ProtoEvent::Leave(serial) => encode_u32(buf, len, serial),
                 ProtoEvent::Ack(serial) => encode_u32(buf, len, serial),
+                ProtoEvent::Bounds { width, height } => {
+                    encode_u32(buf, len, width);
+                    encode_u32(buf, len, height);
+                }
+                ProtoEvent::MotionAbsolute { x, y } => {
+                    encode_i32(buf, len, x);
+                    encode_i32(buf, len, y);
+                }
+                ProtoEvent::CursorPos { pos, nx, ny } => {
+                    encode_u8(buf, len, pos as u8);
+                    encode_f32(buf, len, nx);
+                    encode_f32(buf, len, ny);
+                }
+                ProtoEvent::Hello { commit } => {
+                    for b in commit.iter() {
+                        encode_u8(buf, len, *b);
+                    }
+                }
+                ProtoEvent::ReceiverSensitivity { mouse_sensitivity } => {
+                    encode_f64(buf, len, mouse_sensitivity);
+                }
+                ProtoEvent::Clipboard { .. } => {
+                    panic!(
+                        "ProtoEvent::Clipboard cannot use the fixed-buffer encoder; \
+                         route via encode_clipboard_event"
+                    );
+                }
             }
         }
         (buf, len)
@@ -259,6 +440,7 @@ macro_rules! decode_impl {
 decode_impl!(u8);
 decode_impl!(u32);
 decode_impl!(i32);
+decode_impl!(f32);
 decode_impl!(f64);
 
 macro_rules! encode_impl {
@@ -279,4 +461,141 @@ macro_rules! encode_impl {
 encode_impl!(u8);
 encode_impl!(u32);
 encode_impl!(i32);
+encode_impl!(f32);
 encode_impl!(f64);
+
+/// Wire format for clipboard frames:
+/// `[event_type: u8][fp_len: u32 BE][fp: utf8][text_len: u32 BE][text: utf8]`
+///
+/// Returns the encoded bytes ready for transmission. The total
+/// length is bounded by [`MAX_CLIPBOARD_SIZE`].
+pub fn encode_clipboard_event(event: &ProtoEvent) -> Result<Vec<u8>, ProtocolError> {
+    let (from_fingerprint, content) = match event {
+        ProtoEvent::Clipboard {
+            from_fingerprint,
+            content,
+        } => (from_fingerprint.as_str(), content.as_str()),
+        ProtoEvent::Input(InputEvent::Clipboard(ClipboardEvent::Text(content))) => {
+            // Convenience: capture-side callers carry only the text;
+            // the originator fingerprint is empty until the service
+            // layer stamps it in. Phase 2 wires the stamp.
+            ("", content.as_str())
+        }
+        _ => panic!("encode_clipboard_event called on non-clipboard event"),
+    };
+    let fp_bytes = from_fingerprint.as_bytes();
+    let text_bytes = content.as_bytes();
+    let total = 1 + 4 + fp_bytes.len() + 4 + text_bytes.len();
+    if total > MAX_CLIPBOARD_SIZE {
+        return Err(ProtocolError::ClipboardTooLarge(total));
+    }
+    let mut buf = Vec::with_capacity(total);
+    buf.push(EventType::Clipboard as u8);
+    buf.extend_from_slice(&(fp_bytes.len() as u32).to_be_bytes());
+    buf.extend_from_slice(fp_bytes);
+    buf.extend_from_slice(&(text_bytes.len() as u32).to_be_bytes());
+    buf.extend_from_slice(text_bytes);
+    Ok(buf)
+}
+
+/// Decode a clipboard frame produced by [`encode_clipboard_event`].
+pub fn decode_clipboard_event(buf: &[u8]) -> Result<ProtoEvent, ProtocolError> {
+    if buf.len() > MAX_CLIPBOARD_SIZE {
+        return Err(ProtocolError::ClipboardTooLarge(buf.len()));
+    }
+    if buf.is_empty() {
+        return Err(ProtocolError::BufferTooSmall);
+    }
+    let tag = buf[0];
+    let event_type = EventType::try_from(tag)?;
+    if !matches!(event_type, EventType::Clipboard) {
+        // Wrong-type tag in the clipboard channel — treat as a buffer
+        // mismatch rather than silently producing some other variant.
+        return Err(ProtocolError::BufferTooSmall);
+    }
+    let mut cursor = 1usize;
+    if buf.len() < cursor + 4 {
+        return Err(ProtocolError::BufferTooSmall);
+    }
+    let fp_len = u32::from_be_bytes([
+        buf[cursor],
+        buf[cursor + 1],
+        buf[cursor + 2],
+        buf[cursor + 3],
+    ]) as usize;
+    cursor += 4;
+    if buf.len() < cursor + fp_len + 4 {
+        return Err(ProtocolError::BufferTooSmall);
+    }
+    let from_fingerprint = String::from_utf8(buf[cursor..cursor + fp_len].to_vec())?;
+    cursor += fp_len;
+    let text_len = u32::from_be_bytes([
+        buf[cursor],
+        buf[cursor + 1],
+        buf[cursor + 2],
+        buf[cursor + 3],
+    ]) as usize;
+    cursor += 4;
+    if buf.len() < cursor + text_len {
+        return Err(ProtocolError::BufferTooSmall);
+    }
+    let content = String::from_utf8(buf[cursor..cursor + text_len].to_vec())?;
+    Ok(ProtoEvent::Clipboard {
+        from_fingerprint,
+        content,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn clipboard_round_trip() {
+        let event = ProtoEvent::Clipboard {
+            from_fingerprint: "abcd1234".into(),
+            content: "hello, world".into(),
+        };
+        let bytes = encode_clipboard_event(&event).expect("encode");
+        let decoded = decode_clipboard_event(&bytes).expect("decode");
+        match decoded {
+            ProtoEvent::Clipboard {
+                from_fingerprint,
+                content,
+            } => {
+                assert_eq!(from_fingerprint, "abcd1234");
+                assert_eq!(content, "hello, world");
+            }
+            other => panic!("expected Clipboard, got {other}"),
+        }
+    }
+
+    #[test]
+    fn clipboard_too_large_rejected() {
+        let event = ProtoEvent::Clipboard {
+            from_fingerprint: "fp".into(),
+            content: "x".repeat(MAX_CLIPBOARD_SIZE),
+        };
+        assert!(matches!(
+            encode_clipboard_event(&event),
+            Err(ProtocolError::ClipboardTooLarge(_))
+        ));
+    }
+
+    #[test]
+    fn clipboard_decode_truncated() {
+        // Encode then truncate the trailing content bytes; decoder
+        // must surface BufferTooSmall instead of returning a bogus
+        // string with random capture from the underlying memory.
+        let event = ProtoEvent::Clipboard {
+            from_fingerprint: "fp".into(),
+            content: "some text".into(),
+        };
+        let bytes = encode_clipboard_event(&event).expect("encode");
+        let truncated = &bytes[..bytes.len() - 1];
+        assert!(matches!(
+            decode_clipboard_event(truncated),
+            Err(ProtocolError::BufferTooSmall)
+        ));
+    }
+}
diff --git a/nix/default.nix b/nix/default.nix
index 54d47896..3556851e 100644
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -10,6 +10,7 @@
   wrapGAppsHook4,
   librsvg,
   git,
+  dbus,
 }:
 let
   cargoToml = fromTOML (builtins.readFile ../Cargo.toml);
@@ -34,6 +35,7 @@ rustPlatform.buildRustPackage {
   ++ lib.optionals stdenv.isLinux [
     libX11
     libXtst
+    dbus
   ];
 
   src = builtins.path {
diff --git a/src/capture.rs b/src/capture.rs
index 8f739bd2..959d83e6 100644
--- a/src/capture.rs
+++ b/src/capture.rs
@@ -37,6 +37,19 @@ pub(crate) enum ICaptureEvent {
     /// either the remote client leaving its device region,
     /// a new device entering the screen or the release bind.
     ClientEntered(u64),
+    /// The connect-side received the peer's `Hello` echo and
+    /// updated `client_manager.peer_commit` for `handle`. Forwarded
+    /// upward so Service can broadcast `FrontendEvent::State` and
+    /// the GUI's per-row version-status indicator picks up the new
+    /// value. The listen-side path independently emits
+    /// [`crate::emulation::EmulationEvent::PeerHello`], but it
+    /// races with `active_addr` population — when an incoming
+    /// `Hello` arrives before our outbound dial completes, the
+    /// listen path's `get_client(addr)` returns `None` and the
+    /// commit silently goes unsurfaced. The connect-side path
+    /// fires later but reliably, so it carries the broadcast as a
+    /// belt-and-suspenders fallback.
+    PeerCommitUpdated(CaptureHandle),
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -51,8 +64,11 @@ pub(crate) enum CaptureType {
 
 #[derive(Clone, Debug)]
 enum CaptureRequest {
-    /// capture must release the mouse
-    Release,
+    /// release because the remote peer is taking over (they sent
+    /// Enter+CursorPos). Skips the host-side warp so the peer's
+    /// proportional CursorPos warp doesn't get clobbered by a
+    /// racing local warp computed from stale virtual_cursor state.
+    ReleaseForHandover,
     /// add a capture client
     Create(CaptureHandle, Position, CaptureType),
     /// destory a capture client
@@ -61,6 +77,8 @@ enum CaptureRequest {
     Reenable,
     /// set release bind
     SetReleaseBind(Vec<scancode::Linux>),
+    /// set the auto-release pixel threshold (macOS only). 0 disables.
+    SetReleaseThreshold(u32),
 }
 
 impl Capture {
@@ -68,6 +86,7 @@ impl Capture {
         backend: Option<input_capture::Backend>,
         conn: LanMouseConnection,
         release_bind: Vec<scancode::Linux>,
+        release_threshold_px: u32,
     ) -> Self {
         let (request_tx, request_rx) = channel();
         let (event_tx, event_rx) = channel();
@@ -81,6 +100,7 @@ impl Capture {
             event_tx,
             request_rx,
             release_bind: Rc::new(RefCell::new(release_bind)),
+            release_threshold_px: Rc::new(RefCell::new(release_threshold_px)),
             state: Default::default(),
         };
         let task = spawn_local(capture_task.run());
@@ -124,9 +144,9 @@ impl Capture {
             .expect("channel closed");
     }
 
-    pub(crate) fn release(&self) {
+    pub(crate) fn release_for_handover(&self) {
         self.request_tx
-            .send(CaptureRequest::Release)
+            .send(CaptureRequest::ReleaseForHandover)
             .expect("channel closed");
     }
 
@@ -137,6 +157,12 @@ impl Capture {
     pub(crate) fn set_release_bind(&mut self, bind: Vec<scancode::Linux>) {
         let _ = self.request_tx.send(CaptureRequest::SetReleaseBind(bind));
     }
+
+    pub(crate) fn set_release_threshold(&mut self, threshold: u32) {
+        let _ = self
+            .request_tx
+            .send(CaptureRequest::SetReleaseThreshold(threshold));
+    }
 }
 
 /// debounce a statement `$st`, i.e. the statement is executed only if the
@@ -164,6 +190,7 @@ struct CaptureTask {
     conn: LanMouseConnection,
     event_tx: Sender<ICaptureEvent>,
     release_bind: Rc<RefCell<Vec<scancode::Linux>>>,
+    release_threshold_px: Rc<RefCell<u32>>,
     request_rx: Receiver<CaptureRequest>,
     state: State,
 }
@@ -210,10 +237,13 @@ impl CaptureTask {
                         CaptureRequest::Reenable => break,
                         CaptureRequest::Create(h, p, t) => self.add_capture(h, p, t),
                         CaptureRequest::Destroy(h) => self.remove_capture(h),
-                        CaptureRequest::Release => { /* nothing to do */ }
+                        CaptureRequest::ReleaseForHandover => { /* nothing to do */ }
                         CaptureRequest::SetReleaseBind(bind) => {
                             self.release_bind.borrow_mut().clone_from(&bind);
                         }
+                        CaptureRequest::SetReleaseThreshold(threshold) => {
+                            *self.release_threshold_px.borrow_mut() = threshold;
+                        }
                     },
                     _ = self.cancellation_token.cancelled() => return,
                 }
@@ -241,6 +271,11 @@ impl CaptureTask {
             return Err(e.into());
         }
 
+        // Push the configured auto-release threshold to the freshly
+        // created InputCapture. The wall-press detection is
+        // cross-platform — every backend benefits.
+        capture.set_release_threshold(*self.release_threshold_px.borrow());
+
         let r = self.do_capture_session(&mut capture).await;
 
         // FIXME replace with async drop when stabilized
@@ -285,28 +320,79 @@ impl CaptureTask {
                             log::info!("client {handle} acknowledged the connection!");
                             self.state = State::Sending;
                         }
-                        // client disconnected
+                        // Peer sent Leave — either they just released
+                        // their own outbound capture, or they're
+                        // taking over and want us to stop sending to
+                        // them. The "taking over" case is the common
+                        // one (CaptureBegin on the peer triggers a
+                        // send_leave_event to every incoming address)
+                        // and is followed by Enter+CursorPos from the
+                        // peer. Use the handover release so the local
+                        // host warp doesn't race against the peer's
+                        // upcoming proportional CursorPos warp on our
+                        // shared cursor.
                         ProtoEvent::Leave(_) => {
                             log::info!("releasing capture: left remote client device region");
-                            self.release_capture(capture).await?;
+                            self.release_capture_handover(capture).await?;
                         },
+                        // Peer reported its display geometry — cache it
+                        // so the wall-press model has a real upper
+                        // clamp on virtual_pos for this position.
+                        ProtoEvent::Bounds { width, height } => {
+                            let pos = self.get_pos(handle);
+                            capture.set_peer_bounds(pos, width, height);
+                        }
+                        // Peer reported its per-pair receive-side
+                        // sensitivity multiplier — feed it into the
+                        // wall-press model so its delta accumulator
+                        // tracks the receiver's actual cursor advance.
+                        // Without this, a sub-1.0 multiplier on the
+                        // receiver makes the host's auto-release model
+                        // fire before the cursor reaches the wall.
+                        ProtoEvent::ReceiverSensitivity { mouse_sensitivity } => {
+                            let pos = self.get_pos(handle);
+                            capture.set_peer_sensitivity(pos, mouse_sensitivity);
+                        }
+                        // Peer's commit hash arrived on the outgoing
+                        // DTLS connection. The connect-side
+                        // receive_loop already wrote it to
+                        // `client_manager`; bubble up to Service so
+                        // the GUI's version-status row refreshes.
+                        ProtoEvent::Hello { .. } => {
+                            self.event_tx
+                                .send(ICaptureEvent::PeerCommitUpdated(handle))
+                                .expect("channel closed");
+                        }
                         _ => {}
                     }
                 },
                 e = self.request_rx.recv() => match e.expect("channel closed") {
                     CaptureRequest::Reenable => { /* already active */ },
-                    CaptureRequest::Release => self.release_capture(capture).await?,
+                    CaptureRequest::ReleaseForHandover => self.release_capture_handover(capture).await?,
                     CaptureRequest::Create(h, p, t) => {
                         self.add_capture(h, p, t);
                         capture.create(h, p).await?;
                     }
                     CaptureRequest::Destroy(h) => {
+                        let pos = self.get_pos(h);
                         self.remove_capture(h);
                         capture.destroy(h).await?;
+                        // Drop the cached geometry — the next client
+                        // added at this position may report different
+                        // bounds.
+                        capture.clear_peer_bounds(pos);
+                        // Same lifecycle for the cached sensitivity
+                        // — re-add starts at the 1.0 default until a
+                        // fresh ReceiverSensitivity arrives.
+                        capture.clear_peer_sensitivity(pos);
                     }
                     CaptureRequest::SetReleaseBind(bind) => {
                         self.release_bind.borrow_mut().clone_from(&bind);
                     }
+                    CaptureRequest::SetReleaseThreshold(threshold) => {
+                        *self.release_threshold_px.borrow_mut() = threshold;
+                        capture.set_release_threshold(threshold);
+                    }
                 },
                 _ = self.cancellation_token.cancelled() => break,
             }
@@ -327,7 +413,16 @@ impl CaptureTask {
             return self.release_capture(capture).await;
         }
 
-        if event == CaptureEvent::Begin {
+        // Backend self-released (currently only macOS, when sustained
+        // back-toward-host motion crosses the configured threshold).
+        // Drive the same teardown path as the release-bind chord so
+        // the peer gets a Leave + key-up flush.
+        if matches!(event, CaptureEvent::AutoRelease) {
+            log::info!("releasing capture: backend auto-release");
+            return self.release_capture(capture).await;
+        }
+
+        if matches!(event, CaptureEvent::Begin { .. }) {
             self.event_tx
                 .send(ICaptureEvent::CaptureBegin(handle))
                 .expect("channel closed");
@@ -346,7 +441,7 @@ impl CaptureTask {
         }
 
         // activated a new client
-        if event == CaptureEvent::Begin && Some(handle) != self.active_client {
+        if matches!(event, CaptureEvent::Begin { .. }) && Some(handle) != self.active_client {
             self.state = State::WaitingForAck;
             self.active_client.replace(handle);
             self.event_tx
@@ -356,24 +451,84 @@ impl CaptureTask {
 
         let opposite_pos = to_proto_pos(self.get_pos(handle).opposite());
 
-        let event = match event {
-            CaptureEvent::Begin => ProtoEvent::Enter(opposite_pos),
+        // If we're starting a fresh capture and the backend reported
+        // a cursor position at the moment of crossing, send a
+        // `CursorPos` (host-normalized fraction + entry side from the
+        // peer's frame) right after Enter. The peer scales against
+        // its own live bounds and pins the on-axis dimension to the
+        // matching edge — self-sufficient, no prior `Bounds`
+        // round-trip needed, so the very first crossing also lands
+        // the cursor at the visually-corresponding point.
+        let cursor_pos = if let CaptureEvent::Begin {
+            cursor: Some(cursor),
+        } = event
+        {
+            let pos = self.get_pos(handle);
+            capture.host_normalized_cursor(cursor).map(|(nx, ny)| {
+                let proto_pos = to_proto_pos(pos.opposite());
+                (proto_pos, nx, ny)
+            })
+        } else {
+            None
+        };
+
+        let proto_event = match &event {
+            CaptureEvent::Begin { .. } => ProtoEvent::Enter(opposite_pos),
             CaptureEvent::Input(e) => match self.state {
                 // connection not acknowledged, repeat `Enter` event
                 State::WaitingForAck => ProtoEvent::Enter(opposite_pos),
-                State::Sending => ProtoEvent::Input(e),
+                State::Sending => ProtoEvent::Input(e.clone()),
             },
+            CaptureEvent::AutoRelease => unreachable!("handled in early return above"),
         };
 
-        if let Err(e) = self.conn.send(event, handle).await {
+        if let Err(e) = self.conn.send(proto_event, handle).await {
             const DUR: Duration = Duration::from_millis(500);
             debounce!(PREV_LOG, DUR, log::warn!("releasing capture: {e}"));
             capture.release().await?;
+            return Ok(());
+        }
+
+        // Send CursorPos right after Enter so the receiver can warp
+        // its cursor to the visually-corresponding point on its own
+        // screen — overrides the entry-edge-midpoint warp the
+        // receiver otherwise applies on Enter.
+        if let Some((pos, nx, ny)) = cursor_pos {
+            log::info!("[cursor-pos] send pos={pos:?} nx={nx:.3} ny={ny:.3}");
+            if let Err(e) = self
+                .conn
+                .send(ProtoEvent::CursorPos { pos, nx, ny }, handle)
+                .await
+            {
+                log::warn!("CursorPos send failed: {e}");
+            }
+        } else if matches!(event, CaptureEvent::Begin { .. }) {
+            log::info!(
+                "[cursor-pos] send skipped — Begin had no cursor or host_normalized_cursor returned None"
+            );
         }
         Ok(())
     }
 
     async fn release_capture(&mut self, capture: &mut InputCapture) -> Result<(), CaptureError> {
+        self.notify_peer_of_leave(capture).await;
+        capture.release().await
+    }
+
+    /// Release path used when the peer is taking over (they sent
+    /// Enter+CursorPos). Same teardown — synthesize key-ups, reset
+    /// mods, send Leave — but skip the host-side cursor warp so it
+    /// doesn't race against the peer's authoritative CursorPos
+    /// warp on our shared cursor.
+    async fn release_capture_handover(
+        &mut self,
+        capture: &mut InputCapture,
+    ) -> Result<(), CaptureError> {
+        self.notify_peer_of_leave(capture).await;
+        capture.release_no_host_warp().await
+    }
+
+    async fn notify_peer_of_leave(&mut self, capture: &mut InputCapture) {
         // If we have an active client, notify them we're leaving
         if let Some(handle) = self.active_client.take() {
             // Synthesize key-up events for every key still held in the
@@ -416,7 +571,6 @@ impl CaptureTask {
                 log::warn!("failed to send Leave to client {handle}: {e}");
             }
         }
-        capture.release().await
     }
 }
 
diff --git a/src/client.rs b/src/client.rs
index 3229c8c6..dc8176b6 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -33,6 +33,7 @@ impl ClientManager {
             port: config_client.port,
             pos: config_client.pos,
             cmd: config_client.enter_hook,
+            clipboard_send: config_client.clipboard_send,
         };
         let state = ClientState {
             active: config_client.active,
@@ -91,6 +92,15 @@ impl ClientManager {
     }
 
     /// find a client by its address
+    ///
+    /// Matches against the union of (a) the client's known ip set
+    /// `s.ips` (`fix_ips` plus DNS-resolved addresses), and (b) the
+    /// client's currently-active outbound DTLS address. The
+    /// `active_addr` fallback covers mDNS-primary scenarios where
+    /// the dialer picked an address that wasn't in DNS — the
+    /// listen-side counterpart of that connection arrives from the
+    /// same IP, which we'd otherwise drop on the floor (silently
+    /// breaking peer-version display, among other things).
     pub fn get_client(&self, addr: SocketAddr) -> Option<ClientHandle> {
         // since there shouldn't be more than a handful of clients at any given
         // time this is likely faster than using a HashMap
@@ -98,7 +108,12 @@ impl ClientManager {
             .borrow()
             .iter()
             .find_map(|(k, (_, s))| {
-                if s.active && s.ips.contains(&addr.ip()) {
+                if !s.active {
+                    return None;
+                }
+                let ip = addr.ip();
+                let active_match = s.active_addr.is_some_and(|a| a.ip() == ip);
+                if s.ips.contains(&ip) || active_match {
                     Some(k)
                 } else {
                     None
@@ -282,6 +297,12 @@ impl ClientManager {
         }
     }
 
+    pub(crate) fn set_peer_commit(&self, handle: ClientHandle, commit: Option<[u8; 8]>) {
+        if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
+            s.peer_commit = commit;
+        }
+    }
+
     pub(crate) fn active_addr(&self, handle: ClientHandle) -> Option<SocketAddr> {
         self.clients
             .borrow()
@@ -310,4 +331,30 @@ impl ClientManager {
             .get(handle as usize)
             .map(|(_, s)| s.ips.clone())
     }
+
+    /// Update the per-pair clipboard-send gate for the given client.
+    /// Returns `true` when the value changed (so callers can avoid
+    /// no-op config writes / frontend broadcasts).
+    pub(crate) fn set_clipboard_send(&self, handle: ClientHandle, enabled: bool) -> bool {
+        match self.clients.borrow_mut().get_mut(handle as usize) {
+            Some((c, _)) if c.clipboard_send != enabled => {
+                c.clipboard_send = enabled;
+                true
+            }
+            _ => false,
+        }
+    }
+
+    /// Snapshot of every client whose `clipboard_send` is true and
+    /// whose state is `active`. Used by Service to fan-out a local
+    /// clipboard change without holding the manager's borrow across
+    /// async sends.
+    pub(crate) fn clipboard_send_targets(&self) -> Vec<ClientHandle> {
+        self.clients
+            .borrow()
+            .iter()
+            .filter(|(_, (c, s))| c.clipboard_send && s.active)
+            .map(|(k, _)| k as ClientHandle)
+            .collect()
+    }
 }
diff --git a/src/config.rs b/src/config.rs
index 3faa59bf..f17de29f 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -16,7 +16,7 @@ use toml;
 use toml_edit::{self, DocumentMut};
 
 use lan_mouse_cli::CliArgs;
-use lan_mouse_ipc::{DEFAULT_PORT, Position};
+use lan_mouse_ipc::{ClipboardSuppression, DEFAULT_PORT, IncomingPeerConfig, Position};
 
 use input_event::scancode::{
     self,
@@ -27,6 +27,18 @@ use shadow_rs::shadow;
 
 shadow!(build);
 
+/// Local build's 8-byte ASCII short commit hash, suitable for use
+/// in [`lan_mouse_proto::ProtoEvent::Hello`]. Pads with `'?'` if
+/// shadow_rs returns an unexpected length so the field is always
+/// well-formed on the wire.
+pub fn local_commit() -> [u8; 8] {
+    let bytes = build::SHORT_COMMIT.as_bytes();
+    let mut out = [b'?'; 8];
+    let n = bytes.len().min(8);
+    out[..n].copy_from_slice(&bytes[..n]);
+    out
+}
+
 const CONFIG_FILE_NAME: &str = "config.toml";
 const CERT_FILE_NAME: &str = "lan-mouse.pem";
 
@@ -53,9 +65,28 @@ struct ConfigToml {
     emulation_backend: Option<EmulationBackend>,
     port: Option<u16>,
     release_bind: Option<Vec<scancode::Linux>>,
+    /// pixel threshold for the wall-press auto-release fallback.
+    /// 0 (or absent) disables it; the cursor only releases on the
+    /// release-bind chord or a peer-side `Leave`.
+    release_threshold_px: Option<u32>,
+    /// Advertise (and consume) `_lan-mouse._udp.local.` Bonjour
+    /// service records. The TXT record's `primary=` field tells the
+    /// dialer which interface IP the OS prefers (macOS service order
+    /// / Linux default route), so when a peer is multi-homed the
+    /// dialer biases toward the right interface instead of racing
+    /// blindly. Default true; turn off on networks where mDNS
+    /// multicast (224.0.0.251) is firewalled.
+    mdns_discovery: Option<bool>,
     cert_path: Option<PathBuf>,
     clients: Option<Vec<TomlClient>>,
-    authorized_fingerprints: Option<HashMap<String, String>>,
+    authorized_fingerprints: Option<HashMap<String, IncomingPeerConfig>>,
+    /// Per-OS clipboard suppression lists. Each host machine reads
+    /// and writes only its own OS's slot; the rest round-trip
+    /// untouched so a single config can be shared across machines.
+    /// `None` / empty means no suppression — the user list is
+    /// purely additive on top of platform-specific automatic
+    /// detection (e.g. macOS `org.nspasteboard.ConcealedType`).
+    clipboard_suppress_apps: Option<ClipboardSuppression>,
 }
 
 #[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
@@ -67,6 +98,10 @@ struct TomlClient {
     position: Option<Position>,
     activate_on_startup: Option<bool>,
     enter_hook: Option<String>,
+    /// Per-pair clipboard send gate. Absent in legacy configs;
+    /// defaults to `false` so existing pairs don't start
+    /// transmitting clipboard text on upgrade.
+    clipboard_send: Option<bool>,
 }
 
 impl ConfigToml {
@@ -114,6 +149,14 @@ pub enum Command {
     Cli(CliArgs),
     /// run in daemon mode
     Daemon,
+    /// macOS-only: probe Accessibility permission in a fresh process
+    /// (which bypasses the cached TCC trust state in already-running
+    /// processes). Exits with status 0 if granted, 1 if not. Used by
+    /// the daemon's TCC.db watcher to detect "remove from list" cases
+    /// where AXIsProcessTrusted in the parent process keeps reporting
+    /// cached-true even after the entry is removed.
+    #[cfg(target_os = "macos")]
+    AxProbe,
 }
 
 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
@@ -262,6 +305,7 @@ pub struct ConfigClient {
     pub pos: Position,
     pub active: bool,
     pub enter_hook: Option<String>,
+    pub clipboard_send: bool,
 }
 
 impl From<TomlClient> for ConfigClient {
@@ -272,6 +316,7 @@ impl From<TomlClient> for ConfigClient {
         let ips = HashSet::from_iter(toml.ips.into_iter().flatten());
         let port = toml.port.unwrap_or(DEFAULT_PORT);
         let pos = toml.position.unwrap_or_default();
+        let clipboard_send = toml.clipboard_send.unwrap_or(false);
         Self {
             ips,
             hostname,
@@ -279,6 +324,7 @@ impl From<TomlClient> for ConfigClient {
             pos,
             active,
             enter_hook,
+            clipboard_send,
         }
     }
 }
@@ -298,6 +344,14 @@ impl From<ConfigClient> for TomlClient {
         let position = Some(client.pos);
         let activate_on_startup = if client.active { Some(true) } else { None };
         let enter_hook = client.enter_hook;
+        // Persist `clipboard_send = true` only when the user has
+        // opted in. Default-false stays implicit so configs upgraded
+        // from older builds don't gain a new field on every save.
+        let clipboard_send = if client.clipboard_send {
+            Some(true)
+        } else {
+            None
+        };
         Self {
             hostname,
             host_name,
@@ -306,6 +360,7 @@ impl From<ConfigClient> for TomlClient {
             position,
             activate_on_startup,
             enter_hook,
+            clipboard_send,
         }
     }
 }
@@ -424,8 +479,9 @@ impl Config {
         &self.config_path
     }
 
-    /// public key fingerprints authorized for connection
-    pub fn authorized_fingerprints(&self) -> HashMap<String, String> {
+    /// public key fingerprints authorized for connection, with each
+    /// peer's per-pair receive-side post-processing preferences.
+    pub fn authorized_fingerprints(&self) -> HashMap<String, IncomingPeerConfig> {
         self.config_toml
             .as_ref()
             .and_then(|c| c.authorized_fingerprints.clone())
@@ -479,6 +535,41 @@ impl Config {
             .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()))
     }
 
+    /// Pixel threshold for the wall-press auto-release fallback.
+    /// 0 disables it.
+    pub fn release_threshold_px(&self) -> u32 {
+        self.config_toml
+            .as_ref()
+            .and_then(|c| c.release_threshold_px)
+            .unwrap_or(0)
+    }
+
+    pub fn set_release_threshold_px(&mut self, threshold: u32) {
+        if self.config_toml.is_none() {
+            self.config_toml = Some(Default::default());
+        }
+        self.config_toml
+            .as_mut()
+            .expect("config")
+            .release_threshold_px = Some(threshold);
+    }
+
+    /// Whether mDNS-SD discovery is enabled. Defaults to true when
+    /// the key is absent.
+    pub fn mdns_discovery(&self) -> bool {
+        self.config_toml
+            .as_ref()
+            .and_then(|c| c.mdns_discovery)
+            .unwrap_or(true)
+    }
+
+    pub fn set_mdns_discovery(&mut self, enabled: bool) {
+        if self.config_toml.is_none() {
+            self.config_toml = Some(Default::default());
+        }
+        self.config_toml.as_mut().expect("config").mdns_discovery = Some(enabled);
+    }
+
     /// set configured clients
     pub fn set_clients(&mut self, clients: Vec<ConfigClient>) {
         if clients.is_empty() {
@@ -492,7 +583,7 @@ impl Config {
     }
 
     /// set authorized keys
-    pub fn set_authorized_keys(&mut self, fingerprints: HashMap<String, String>) {
+    pub fn set_authorized_keys(&mut self, fingerprints: HashMap<String, IncomingPeerConfig>) {
         if self.config_toml.is_none() {
             self.config_toml = Some(Default::default());
         }
@@ -502,6 +593,31 @@ impl Config {
             .authorized_fingerprints = Some(fingerprints);
     }
 
+    /// Snapshot of the persisted per-OS suppression lists.
+    pub fn clipboard_suppression(&self) -> ClipboardSuppression {
+        self.config_toml
+            .as_ref()
+            .and_then(|c| c.clipboard_suppress_apps.clone())
+            .unwrap_or_default()
+    }
+
+    /// Replace the persisted per-OS suppression lists. `None` is
+    /// written when every slot is empty so a fresh config doesn't
+    /// gain a new top-level key on every save.
+    pub fn set_clipboard_suppression(&mut self, suppression: ClipboardSuppression) {
+        if self.config_toml.is_none() {
+            self.config_toml = Some(Default::default());
+        }
+        self.config_toml
+            .as_mut()
+            .expect("config")
+            .clipboard_suppress_apps = if suppression.is_empty() {
+            None
+        } else {
+            Some(suppression)
+        };
+    }
+
     pub fn read_from_disk(&mut self) -> Result<bool, io::Error> {
         log::info!("reading config from {:?}", &self.config_path);
 
diff --git a/src/connect.rs b/src/connect.rs
index cc067f7c..f696a4db 100644
--- a/src/connect.rs
+++ b/src/connect.rs
@@ -1,15 +1,20 @@
 use crate::client::ClientManager;
+use crate::config::local_commit;
+use crate::discovery::{PrimaryCache, normalize_mdns_name};
 use lan_mouse_ipc::{ClientHandle, DEFAULT_PORT};
-use lan_mouse_proto::{MAX_EVENT_SIZE, ProtoEvent};
+use lan_mouse_proto::{
+    MAX_CLIPBOARD_SIZE, MAX_EVENT_SIZE, ProtoEvent, decode_clipboard_event, encode_clipboard_event,
+};
 use local_channel::mpsc::{Receiver, Sender, channel};
 use std::{
     cell::RefCell,
     collections::{HashMap, HashSet},
+    hash::{DefaultHasher, Hash, Hasher},
     io,
-    net::SocketAddr,
+    net::{IpAddr, SocketAddr},
     rc::Rc,
     sync::Arc,
-    time::Duration,
+    time::{Duration, Instant},
 };
 use thiserror::Error;
 use tokio::{
@@ -42,6 +47,58 @@ pub(crate) enum LanMouseConnectionError {
 
 const DEFAULT_CONNECTION_TIMEOUT: Duration = Duration::from_secs(5);
 
+/// Initial backoff between connect attempts that find no usable address
+/// (no static IPs, no DNS-resolved IPs, no mDNS primary hint). Doubles
+/// on each subsequent failure up to [`MAX_RETRY_BACKOFF`]. The backoff
+/// is bypassed entirely when the input set changes (e.g. mDNS browse
+/// resolves a primary, DNS lookup returns IPs) so a peer that comes
+/// back online reconnects on the next mouse event without waiting.
+const INITIAL_RETRY_BACKOFF: Duration = Duration::from_secs(1);
+const MAX_RETRY_BACKOFF: Duration = Duration::from_secs(30);
+
+/// Per-handle gate that throttles repeat connect attempts when nothing
+/// new is available to dial. `signature` hashes the candidate set we
+/// last attempted; if the current set differs we skip the gate and
+/// retry immediately. Otherwise `next_attempt_at` enforces exponential
+/// backoff capped at [`MAX_RETRY_BACKOFF`].
+struct RetryState {
+    next_attempt_at: Instant,
+    backoff: Duration,
+    signature: u64,
+}
+
+fn signature_of(ips: &HashSet<IpAddr>, primary: Option<IpAddr>) -> u64 {
+    let mut sorted: Vec<IpAddr> = ips.iter().copied().collect();
+    sorted.sort();
+    let mut hasher = DefaultHasher::new();
+    sorted.hash(&mut hasher);
+    primary.hash(&mut hasher);
+    hasher.finish()
+}
+
+/// Update `retry_state[handle]` after a failed connect attempt: doubles
+/// the backoff (capped at [`MAX_RETRY_BACKOFF`]) and stamps the
+/// candidate-set signature so a later signature change can short-
+/// circuit the gate.
+fn record_retry_failure(
+    retry_state: &Rc<RefCell<HashMap<ClientHandle, RetryState>>>,
+    handle: ClientHandle,
+    ips: &HashSet<IpAddr>,
+    primary: Option<IpAddr>,
+) {
+    let sig = signature_of(ips, primary);
+    let mut map = retry_state.borrow_mut();
+    let entry = map.entry(handle).or_insert(RetryState {
+        next_attempt_at: Instant::now(),
+        backoff: INITIAL_RETRY_BACKOFF,
+        signature: sig,
+    });
+    entry.signature = sig;
+    let next = entry.backoff;
+    entry.next_attempt_at = Instant::now() + next;
+    entry.backoff = (next * 2).min(MAX_RETRY_BACKOFF);
+}
+
 async fn connect(
     addr: SocketAddr,
     cert: Certificate,
@@ -70,12 +127,43 @@ async fn connect(
     }
 }
 
+/// Time the preferred address gets to handshake alone before the
+/// rest of the candidate list joins the race. Modeled on RFC 8305
+/// "happy eyeballs" v6→v4 fallback delay; long enough that a healthy
+/// preferred address virtually always wins, short enough that a
+/// broken preferred path only slightly delays connect.
+const PREFERRED_ADDR_HEAD_START: Duration = Duration::from_millis(200);
+
 async fn connect_any(
     addrs: &[SocketAddr],
+    preferred: Option<SocketAddr>,
     cert: Certificate,
 ) -> Result<(Arc<dyn Conn + Send + Sync>, SocketAddr), LanMouseConnectionError> {
     let mut joinset = JoinSet::new();
+    if let Some(p) = preferred {
+        // Dial the peer's mDNS-advertised primary first. If it
+        // handshakes within `PREFERRED_ADDR_HEAD_START` we're done
+        // before the others even start — the dialer biases toward
+        // the OS-preferred interface (Mac service order, Linux
+        // default route) without relying on RTT racing alone.
+        joinset.spawn_local(connect(p, cert.clone()));
+        let head_start = tokio::time::sleep(PREFERRED_ADDR_HEAD_START);
+        tokio::pin!(head_start);
+        loop {
+            tokio::select! {
+                _ = &mut head_start => break,
+                Some(r) = joinset.join_next() => match r.expect("join error") {
+                    Ok(conn) => return Ok(conn),
+                    Err((a, e)) => log::warn!("failed to connect to {a}: `{e}`"),
+                },
+            }
+        }
+    }
     for &addr in addrs {
+        if Some(addr) == preferred {
+            // already racing; don't dial the same socket twice
+            continue;
+        }
         joinset.spawn_local(connect(addr, cert.clone()));
     }
     loop {
@@ -99,10 +187,26 @@ pub(crate) struct LanMouseConnection {
     recv_rx: Receiver<(ClientHandle, ProtoEvent)>,
     recv_tx: Sender<(ClientHandle, ProtoEvent)>,
     ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
+    /// Map of `peer_hostname -> primary_ipv4` populated by the
+    /// `Discovery` mDNS browse task. Read on every `connect_to_handle`
+    /// to bias which address gets the handshake head-start. Empty
+    /// when discovery is disabled or no peer hint has arrived yet.
+    primary_hints: PrimaryCache,
+    /// Per-handle retry gate. Suppresses connect spawns when the
+    /// previous attempt failed and nothing new is available to dial,
+    /// so an offline peer doesn't trigger a fresh `connect_to_handle`
+    /// (and the associated DNS / mDNS lookup churn) on every mouse
+    /// event. Cleared on successful connect; bypassed automatically
+    /// when the candidate-set signature changes.
+    retry_state: Rc<RefCell<HashMap<ClientHandle, RetryState>>>,
 }
 
 impl LanMouseConnection {
-    pub(crate) fn new(cert: Certificate, client_manager: ClientManager) -> Self {
+    pub(crate) fn new(
+        cert: Certificate,
+        client_manager: ClientManager,
+        primary_hints: PrimaryCache,
+    ) -> Self {
         let (recv_tx, recv_rx) = channel();
         Self {
             cert,
@@ -112,6 +216,8 @@ impl LanMouseConnection {
             recv_rx,
             recv_tx,
             ping_response: Default::default(),
+            primary_hints,
+            retry_state: Default::default(),
         }
     }
 
@@ -119,13 +225,55 @@ impl LanMouseConnection {
         self.recv_rx.recv().await.expect("channel closed")
     }
 
+    /// Cheap send-only handle that shares all the dialer state with
+    /// `self`. The clone's `recv_rx` is a dead stub — only the
+    /// original [`LanMouseConnection`] (held by Capture) drains the
+    /// live receiver. Used by Service to fan clipboard frames out
+    /// without routing through the capture session loop.
+    pub(crate) fn sender_clone(&self) -> Self {
+        let (_, dead_rx) = channel();
+        Self {
+            cert: self.cert.clone(),
+            client_manager: self.client_manager.clone(),
+            conns: self.conns.clone(),
+            connecting: self.connecting.clone(),
+            recv_rx: dead_rx,
+            recv_tx: self.recv_tx.clone(),
+            ping_response: self.ping_response.clone(),
+            primary_hints: self.primary_hints.clone(),
+            retry_state: self.retry_state.clone(),
+        }
+    }
+
     pub(crate) async fn send(
         &self,
         event: ProtoEvent,
         handle: ClientHandle,
     ) -> Result<(), LanMouseConnectionError> {
-        let (buf, len): ([u8; MAX_EVENT_SIZE], usize) = event.into();
-        let buf = &buf[..len];
+        let event_display = format!("{event}");
+        // Clipboard frames are variable-length and can't ride the
+        // fixed-size codec; route them through the dedicated helper.
+        // For all other events the existing 21-byte path is faster.
+        let bytes_owned: Option<Vec<u8>> = match &event {
+            ProtoEvent::Clipboard { .. } => match encode_clipboard_event(&event) {
+                Ok(v) => Some(v),
+                Err(e) => {
+                    log::warn!("dropping oversize clipboard event for client {handle}: {e}");
+                    return Ok(());
+                }
+            },
+            _ => None,
+        };
+        let bytes_fixed: ([u8; MAX_EVENT_SIZE], usize) = if bytes_owned.is_some() {
+            ([0u8; MAX_EVENT_SIZE], 0)
+        } else {
+            event.into()
+        };
+        let buf: &[u8] = if let Some(v) = bytes_owned.as_deref() {
+            v
+        } else {
+            &bytes_fixed.0[..bytes_fixed.1]
+        };
         if let Some(addr) = self.client_manager.active_addr(handle) {
             let conn = {
                 let conns = self.conns.lock().await;
@@ -142,14 +290,14 @@ impl LanMouseConnection {
                         disconnect(&self.client_manager, handle, addr, &self.conns).await;
                     }
                 }
-                log::trace!("{event} >->->->->- {addr}");
+                log::trace!("{event_display} >->->->->- {addr}");
                 return Ok(());
             }
         }
 
         // check if we are already trying to connect
         let mut connecting = self.connecting.lock().await;
-        if !connecting.contains(&handle) {
+        if !connecting.contains(&handle) && self.should_attempt(handle) {
             connecting.insert(handle);
             // connect in the background
             spawn_local(connect_to_handle(
@@ -160,12 +308,44 @@ impl LanMouseConnection {
                 self.connecting.clone(),
                 self.recv_tx.clone(),
                 self.ping_response.clone(),
+                self.primary_hints.clone(),
+                self.retry_state.clone(),
             ));
         }
         Err(LanMouseConnectionError::NotConnected)
     }
+
+    /// Decide whether to spawn another `connect_to_handle` for `handle`.
+    /// Returns true (and refreshes the recorded signature) when:
+    ///   - we have no prior attempt for this handle, or
+    ///   - the candidate-set signature has changed since the last
+    ///     attempt (new IP from DNS, or new mDNS primary), or
+    ///   - the recorded backoff has elapsed.
+    ///
+    /// Otherwise returns false; the caller treats this as "still in
+    /// cooldown, keep returning NotConnected silently."
+    fn should_attempt(&self, handle: ClientHandle) -> bool {
+        let ips = self.client_manager.get_ips(handle).unwrap_or_default();
+        let primary = self.client_manager.get_hostname(handle).and_then(|h| {
+            let key = normalize_mdns_name(&h);
+            self.primary_hints.borrow().get(&key).copied()
+        });
+        let sig = signature_of(&ips, primary);
+        let mut state = self.retry_state.borrow_mut();
+        match state.get_mut(&handle) {
+            None => true,
+            Some(s) if s.signature != sig => {
+                s.signature = sig;
+                s.next_attempt_at = Instant::now();
+                s.backoff = INITIAL_RETRY_BACKOFF;
+                true
+            }
+            Some(s) => Instant::now() >= s.next_attempt_at,
+        }
+    }
 }
 
+#[allow(clippy::too_many_arguments)]
 async fn connect_to_handle(
     client_manager: ClientManager,
     cert: Certificate,
@@ -174,20 +354,43 @@ async fn connect_to_handle(
     connecting: Rc<Mutex<HashSet<ClientHandle>>>,
     tx: Sender<(ClientHandle, ProtoEvent)>,
     ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
+    primary_hints: PrimaryCache,
+    retry_state: Rc<RefCell<HashMap<ClientHandle, RetryState>>>,
 ) -> Result<(), LanMouseConnectionError> {
     log::info!("client {handle} connecting ...");
     // sending did not work, figure out active conn.
-    if let Some(addrs) = client_manager.get_ips(handle) {
+    if let Some(ips_set) = client_manager.get_ips(handle) {
         let port = client_manager.get_port(handle).unwrap_or(DEFAULT_PORT);
-        let addrs = addrs
-            .into_iter()
+        let addrs = ips_set
+            .iter()
+            .copied()
             .map(|a| SocketAddr::new(a, port))
             .collect::<Vec<_>>();
-        log::info!("client ({handle}) connecting ... (ips: {addrs:?})");
-        let res = connect_any(&addrs, cert).await;
+        // mDNS-advertised primary IP for this peer, if known. Used
+        // by `connect_any` as a head-start address: the dialer races
+        // it alone for ~200ms before joining the rest of the list,
+        // so a healthy primary almost always wins regardless of
+        // raw RTT ordering.
+        let primary_ip = client_manager.get_hostname(handle).and_then(|h| {
+            let key = normalize_mdns_name(&h);
+            primary_hints.borrow().get(&key).copied()
+        });
+        let preferred = primary_ip.map(|ip| SocketAddr::new(ip, port));
+        log::info!("client ({handle}) connecting ... (ips: {addrs:?}, preferred: {preferred:?})");
+        if addrs.is_empty() && preferred.is_none() {
+            // Nothing to dial. Bump backoff and bail without spawning
+            // DTLS work or spamming logs on every subsequent mouse
+            // event — `should_attempt` will keep gating until either
+            // the backoff elapses or new info arrives.
+            record_retry_failure(&retry_state, handle, &ips_set, primary_ip);
+            connecting.lock().await.remove(&handle);
+            return Err(LanMouseConnectionError::NotConnected);
+        }
+        let res = connect_any(&addrs, preferred, cert).await;
         let (conn, addr) = match res {
             Ok(c) => c,
             Err(e) => {
+                record_retry_failure(&retry_state, handle, &ips_set, primary_ip);
                 connecting.lock().await.remove(&handle);
                 return Err(e);
             }
@@ -196,6 +399,20 @@ async fn connect_to_handle(
         client_manager.set_active_addr(handle, Some(addr));
         conns.lock().await.insert(addr, conn.clone());
         connecting.lock().await.remove(&handle);
+        retry_state.borrow_mut().remove(&handle);
+
+        // Best-effort version handshake. Send our commit hash once
+        // immediately after the DTLS handshake; the listen side
+        // mirrors a Hello back so the receive loop can populate
+        // `peer_commit`. Old peers will silently skip this event
+        // per the forward-compat handler in [`receive_loop`].
+        let (buf, len) = ProtoEvent::Hello {
+            commit: local_commit(),
+        }
+        .into();
+        if let Err(e) = conn.send(&buf[..len]).await {
+            log::debug!("hello send to {addr} failed: {e}");
+        }
 
         // poll connection for active
         spawn_local(ping_pong(addr, conn.clone(), ping_response.clone()));
@@ -253,24 +470,69 @@ async fn receive_loop(
     tx: Sender<(ClientHandle, ProtoEvent)>,
     ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
 ) {
-    let mut buf = [0u8; MAX_EVENT_SIZE];
-    while conn.recv(&mut buf).await.is_ok() {
-        if let Ok(event) = buf.try_into() {
-            log::trace!("{addr} <==<==<== {event}");
-            match event {
-                ProtoEvent::Pong(b) => {
-                    client_manager.set_active_addr(handle, Some(addr));
-                    client_manager.set_alive(handle, b);
-                    ping_response.borrow_mut().insert(addr);
-                }
-                event => tx.send((handle, event)).expect("channel closed"),
+    // Buffer sized for the largest legal clipboard frame so a single
+    // DTLS recv never gets truncated. Non-clipboard events use only
+    // the first MAX_EVENT_SIZE bytes; the rest of the buffer is
+    // unused for those datagrams.
+    let mut buf = [0u8; MAX_CLIPBOARD_SIZE];
+    while let Ok(n) = conn.recv(&mut buf).await {
+        if n == 0 {
+            continue;
+        }
+        let datagram = &buf[..n];
+        let event = match decode_proto_datagram(datagram) {
+            Some(event) => event,
+            // Skip undecodable datagrams without dropping the
+            // connection. Each DTLS recv is one framed message, so
+            // skipping is safe and keeps us forward-compatible with
+            // peers that send event types we don't yet know about.
+            None => {
+                log::debug!("ignoring undecodable {n}-byte event from {addr}");
+                continue;
+            }
+        };
+        log::trace!("{addr} <==<==<== {event}");
+        match event {
+            ProtoEvent::Pong(b) => {
+                client_manager.set_active_addr(handle, Some(addr));
+                client_manager.set_alive(handle, b);
+                ping_response.borrow_mut().insert(addr);
+            }
+            ProtoEvent::Hello { commit } => {
+                client_manager.set_peer_commit(handle, Some(commit));
+                // Forward to capture.rs so Service can
+                // broadcast — without this the GUI's
+                // version-status indicator only updates when
+                // the listen-side `PeerHello` happens to
+                // match `get_client(addr)`, which fails when
+                // Mac dials in before Linux's outbound dial
+                // has populated `active_addr`.
+                tx.send((handle, ProtoEvent::Hello { commit }))
+                    .expect("channel closed");
             }
+            event => tx.send((handle, event)).expect("channel closed"),
         }
     }
     log::warn!("recv error");
     disconnect(&client_manager, handle, addr, &conns).await;
 }
 
+/// Classify the first byte of a DTLS datagram and dispatch through
+/// either the variable-length clipboard codec or the fixed-buffer
+/// `try_into` path. Returns `None` on any decode failure (bad tag,
+/// truncated payload, oversize frame).
+fn decode_proto_datagram(bytes: &[u8]) -> Option<ProtoEvent> {
+    use lan_mouse_proto::EventType;
+    let tag = *bytes.first()?;
+    if tag == EventType::Clipboard as u8 {
+        return decode_clipboard_event(bytes).ok();
+    }
+    let mut fixed = [0u8; MAX_EVENT_SIZE];
+    let copy_len = bytes.len().min(MAX_EVENT_SIZE);
+    fixed[..copy_len].copy_from_slice(&bytes[..copy_len]);
+    fixed.try_into().ok()
+}
+
 async fn disconnect(
     client_manager: &ClientManager,
     handle: ClientHandle,
@@ -280,6 +542,7 @@ async fn disconnect(
     log::warn!("client ({handle}) @ {addr} connection closed");
     conns.lock().await.remove(&addr);
     client_manager.set_active_addr(handle, None);
+    client_manager.set_peer_commit(handle, None);
     let active: Vec<SocketAddr> = conns.lock().await.keys().copied().collect();
     log::info!("active connections: {active:?}");
 }
diff --git a/src/discovery.rs b/src/discovery.rs
new file mode 100644
index 00000000..26e2a259
--- /dev/null
+++ b/src/discovery.rs
@@ -0,0 +1,328 @@
+//! Bonjour / mDNS-SD service registration + discovery.
+//!
+//! Why this exists: when a peer machine has multiple interfaces on
+//! the same subnet (Mac with Wi-Fi + Ethernet, Linux laptop with
+//! Wi-Fi + USB-C dock, etc.), plain hostname resolution returns
+//! every interface's IP and the dialer has no way to tell which one
+//! the OS would *prefer* for outbound traffic. The current connect
+//! path races them and uses whichever DTLS handshake completes first,
+//! which is RTT-roughly-correct but not always what the user wanted
+//! — Wi-Fi can win the race even when the user has Ethernet ranked
+//! higher in macOS's service order.
+//!
+//! Each lan-mouse instance registers a `_lan-mouse._udp.local.`
+//! Bonjour service whose TXT record advertises `primary=<ip>`, where
+//! `<ip>` is the IPv4 of the interface that owns the default route
+//! (which on macOS reflects service order). The dialer browses the
+//! same service type, looks up the peer instance by hostname, and
+//! prepends the primary IP to its connection-attempt list. If the
+//! peer is on an old version with no advertised service (or mDNS
+//! is firewalled), nothing breaks — we silently fall through to the
+//! existing `connect_any` race.
+//!
+//! The whole subsystem is gated by the `mdns_discovery` config flag
+//! (default true). Toggling it off shuts down the mDNS daemon and
+//! all browse/registration state — useful on networks where mDNS
+//! multicast (224.0.0.251) is firewalled.
+
+use std::{
+    cell::RefCell,
+    collections::HashMap,
+    net::{IpAddr, Ipv4Addr},
+    rc::Rc,
+};
+
+use mdns_sd::{ServiceDaemon, ServiceEvent, ServiceInfo};
+use tokio::task::{JoinHandle, spawn_local};
+
+const SERVICE_TYPE: &str = "_lan-mouse._udp.local.";
+const TXT_PRIMARY_KEY: &str = "primary";
+
+/// Cross-platform: IP of the interface that owns the default route.
+///
+/// On macOS the default route reflects the user's service-order
+/// ranking — that's exactly the "primary" the user expects when they
+/// say "use Ethernet, not Wi-Fi". On Linux it reflects the lowest-
+/// metric default route. On Windows it's whatever
+/// `GetBestRoute2` selects.
+fn primary_ipv4() -> Option<Ipv4Addr> {
+    let iface = netdev::get_default_interface().ok()?;
+    iface.ipv4.first().map(|net| net.addr())
+}
+
+fn local_hostname() -> String {
+    hostname::get()
+        .ok()
+        .and_then(|s| s.into_string().ok())
+        .unwrap_or_else(|| "lan-mouse".to_string())
+}
+
+/// Strip a single trailing dot if present. Bonjour hostnames are
+/// stored as fully-qualified ("foo.local."); user config typically
+/// writes them without the trailing dot ("foo.local"). Normalize
+/// to compare.
+fn strip_trailing_dot(s: &str) -> &str {
+    s.strip_suffix('.').unwrap_or(s)
+}
+
+/// Pull the service-instance label off a Bonjour fullname.
+///
+/// `mdns-sd` returns fullnames as `"<instance>.<service-type>"` where
+/// `<service-type>` is e.g. `"_lan-mouse._udp.local."`. The instance
+/// label is the user-visible identifier the announcer chose for itself
+/// — typically the system hostname, and the same string the user puts
+/// in their lan-mouse config's `hostname = "..."`. We key
+/// [`PrimaryCache`] on this instead of the SRV target so the dialer
+/// matches the config hostname even when the announcer's SRV target
+/// has macOS-style suffixes (`Foo.local` vs `Foo-2.local`) or other
+/// drift.
+fn instance_from_fullname<'a>(fullname: &'a str, service_type: &str) -> &'a str {
+    let suffix = format!(".{service_type}");
+    fullname.strip_suffix(&suffix).unwrap_or(fullname)
+}
+
+/// Canonicalize a Bonjour/mDNS-SD name for cache lookup. Lower-cases,
+/// drops a trailing FQDN dot, and drops the `.local` link-local
+/// suffix. The `.local` domain is implied for everything mDNS-SD
+/// touches, so callers shouldn't have to remember whether to include
+/// it — config that says `Foo.local`, an announcer's instance label
+/// `Foo`, and an SRV target `foo.local.` all collapse to `foo`.
+pub(crate) fn normalize_mdns_name(s: &str) -> String {
+    let s = strip_trailing_dot(s);
+    let s = s.strip_suffix(".local").unwrap_or(s);
+    s.to_ascii_lowercase()
+}
+
+/// Shared `peer_hostname -> primary_ipv4` map, populated by Discovery
+/// and read by the dialer (`connect_to_handle`). Owned by the dialer
+/// path so its references survive across discovery enable/disable
+/// cycles — when the user toggles discovery off, the daemon stops
+/// publishing/browsing but cached hints stay queryable. A subsequent
+/// re-enable populates fresh entries into the same map.
+pub(crate) type PrimaryCache = Rc<RefCell<HashMap<String, IpAddr>>>;
+
+pub(crate) struct Discovery {
+    /// The mDNS daemon. `None` when the subsystem is disabled (config
+    /// toggle off, or daemon failed to start). All public methods are
+    /// no-ops when this is None.
+    daemon: Option<ServiceDaemon>,
+    /// Fullname of our registered service, kept so we can unregister
+    /// on shutdown / before re-registering.
+    registered_fullname: Option<String>,
+    /// Shared cache (see [`PrimaryCache`]).
+    primary_cache: PrimaryCache,
+    /// Background task that consumes browse events and updates
+    /// `primary_cache`. Aborted when discovery is disabled or torn
+    /// down.
+    browse_task: Option<JoinHandle<()>>,
+    /// Port the dialer should connect to (advertised in the SRV
+    /// record's port field). Tracked so we can re-register when the
+    /// listen port changes.
+    port: u16,
+}
+
+impl Discovery {
+    /// Construct a Discovery sharing `primary_cache` with the dialer.
+    /// If `enabled` is false, returns an inert instance — calling any
+    /// method on it is a no-op. Same outcome when the mDNS daemon
+    /// fails to start (e.g. multicast group already joined by some
+    /// other process, or the OS lacks the permissions). In both
+    /// cases we log a warning and continue without discovery; the
+    /// dialer falls back to plain hostname resolution.
+    pub(crate) fn new(port: u16, enabled: bool, primary_cache: PrimaryCache) -> Self {
+        if !enabled {
+            log::info!("mdns discovery disabled by config");
+            return Self::inert(port, primary_cache);
+        }
+        match ServiceDaemon::new() {
+            Ok(daemon) => {
+                let browse_task = start_browse(&daemon, primary_cache.clone());
+                let mut this = Self {
+                    daemon: Some(daemon),
+                    registered_fullname: None,
+                    primary_cache,
+                    browse_task,
+                    port,
+                };
+                this.register();
+                this
+            }
+            Err(e) => {
+                log::warn!("mdns ServiceDaemon::new failed: {e}; discovery disabled");
+                Self::inert(port, primary_cache)
+            }
+        }
+    }
+
+    fn inert(port: u16, primary_cache: PrimaryCache) -> Self {
+        Self {
+            daemon: None,
+            registered_fullname: None,
+            primary_cache,
+            browse_task: None,
+            port,
+        }
+    }
+
+    /// Register `_lan-mouse._udp.local.` with our hostname + primary
+    /// IP. Called on construction and again whenever the primary IP
+    /// or port may have changed.
+    fn register(&mut self) {
+        let Some(daemon) = self.daemon.as_ref() else {
+            return;
+        };
+        // Drop the old registration first so we don't leave stale
+        // TXT records floating on the network.
+        if let Some(old) = self.registered_fullname.take() {
+            let _ = daemon.unregister(&old);
+        }
+        let host = local_hostname();
+        let host_record = format!("{host}.local.");
+        let primary = match primary_ipv4() {
+            Some(ip) => ip,
+            None => {
+                log::warn!(
+                    "mdns: no default-route interface; skipping registration (will retry on \
+                     interface change)"
+                );
+                return;
+            }
+        };
+        let mut props = HashMap::new();
+        props.insert(TXT_PRIMARY_KEY.to_string(), primary.to_string());
+        let info = match ServiceInfo::new(
+            SERVICE_TYPE,
+            &host,
+            &host_record,
+            IpAddr::V4(primary),
+            self.port,
+            Some(props),
+        ) {
+            Ok(i) => i,
+            Err(e) => {
+                log::warn!("mdns ServiceInfo::new failed: {e}; skipping registration");
+                return;
+            }
+        };
+        let fullname = info.get_fullname().to_string();
+        match daemon.register(info) {
+            Ok(()) => {
+                log::info!(
+                    "mdns: registered {fullname} on {primary}:{port} (primary interface)",
+                    port = self.port,
+                );
+                self.registered_fullname = Some(fullname);
+            }
+            Err(e) => log::warn!("mdns register failed: {e}"),
+        }
+    }
+
+    /// Re-register with the current primary IP. Called periodically
+    /// by the service's main loop so the TXT record reflects the
+    /// active default-route interface even when interface changes
+    /// don't arrive through if-watch.
+    pub(crate) fn refresh(&mut self) {
+        if self.daemon.is_some() {
+            self.register();
+        }
+    }
+
+    /// Re-register with a new port (config changed).
+    pub(crate) fn set_port(&mut self, port: u16) {
+        if self.port == port {
+            return;
+        }
+        self.port = port;
+        self.refresh();
+    }
+
+    /// Toggle the subsystem on/off. Off → unregister, abort browse,
+    /// drop daemon. On → spin up afresh, reusing the same shared
+    /// cache so any prior hints stay queryable until overwritten.
+    pub(crate) fn set_enabled(&mut self, enabled: bool) {
+        let currently = self.daemon.is_some();
+        if currently == enabled {
+            return;
+        }
+        if enabled {
+            *self = Self::new(self.port, true, self.primary_cache.clone());
+        } else {
+            self.shutdown();
+        }
+    }
+
+    fn shutdown(&mut self) {
+        if let Some(daemon) = self.daemon.take() {
+            if let Some(name) = self.registered_fullname.take() {
+                let _ = daemon.unregister(&name);
+            }
+            let _ = daemon.shutdown();
+        }
+        if let Some(task) = self.browse_task.take() {
+            task.abort();
+        }
+        // Don't clear primary_cache: the dialer may still benefit
+        // from the last-known hints, and a re-enable would otherwise
+        // lose them until each peer's next announcement.
+    }
+}
+
+impl Drop for Discovery {
+    fn drop(&mut self) {
+        self.shutdown();
+    }
+}
+
+/// Spawn a background task that browses `_lan-mouse._udp.local.` and
+/// keeps `primary_cache` updated as ServiceResolved / ServiceRemoved
+/// events arrive.
+fn start_browse(
+    daemon: &ServiceDaemon,
+    primary_cache: Rc<RefCell<HashMap<String, IpAddr>>>,
+) -> Option<JoinHandle<()>> {
+    let receiver = match daemon.browse(SERVICE_TYPE) {
+        Ok(rx) => rx,
+        Err(e) => {
+            log::warn!("mdns browse failed: {e}");
+            return None;
+        }
+    };
+    Some(spawn_local(async move {
+        while let Ok(event) = receiver.recv_async().await {
+            match event {
+                ServiceEvent::ServiceResolved(resolved) => {
+                    let Some(primary_str) = resolved.get_property_val_str(TXT_PRIMARY_KEY) else {
+                        continue;
+                    };
+                    let Ok(ip) = primary_str.parse::<IpAddr>() else {
+                        log::debug!(
+                            "mdns: peer {} advertised malformed primary={primary_str:?}",
+                            resolved.get_fullname()
+                        );
+                        continue;
+                    };
+                    let instance = instance_from_fullname(resolved.get_fullname(), SERVICE_TYPE);
+                    let key = normalize_mdns_name(instance);
+                    let target = strip_trailing_dot(resolved.get_hostname());
+                    log::info!(
+                        "mdns: peer instance={key} (target={target}) announces primary={ip} \
+                         (port={port})",
+                        port = resolved.get_port(),
+                    );
+                    primary_cache.borrow_mut().insert(key, ip);
+                }
+                ServiceEvent::ServiceRemoved(_, fullname) => {
+                    // Best-effort: the fullname is "<instance>._lan-
+                    // mouse._udp.local." — we don't have the host
+                    // record handy here, so drop on next browse-
+                    // resolved instead of trying to map back. Keeps
+                    // the cache slightly stale on goodbye but never
+                    // wrong: if the peer comes back with a different
+                    // primary, the next ServiceResolved overwrites.
+                    log::debug!("mdns: service removed {fullname}");
+                }
+                _ => {}
+            }
+        }
+    }))
+}
diff --git a/src/dns.rs b/src/dns.rs
index 60bc100a..b1d6d42b 100644
--- a/src/dns.rs
+++ b/src/dns.rs
@@ -1,9 +1,9 @@
-use std::{collections::HashMap, net::IpAddr};
+use std::{collections::HashMap, io, net::IpAddr};
 
 use local_channel::mpsc::{Receiver, Sender, channel};
+use tokio::net::lookup_host;
 use tokio::task::{JoinHandle, spawn_local};
 
-use hickory_resolver::{ResolveError, TokioResolver};
 use tokio_util::sync::CancellationToken;
 
 use lan_mouse_ipc::ClientHandle;
@@ -22,11 +22,10 @@ struct DnsRequest {
 
 pub(crate) enum DnsEvent {
     Resolving(ClientHandle),
-    Resolved(ClientHandle, String, Result<Vec<IpAddr>, ResolveError>),
+    Resolved(ClientHandle, String, io::Result<Vec<IpAddr>>),
 }
 
 struct DnsTask {
-    resolver: TokioResolver,
     request_rx: Receiver<DnsRequest>,
     event_tx: Sender<DnsEvent>,
     cancellation_token: CancellationToken,
@@ -34,14 +33,12 @@ struct DnsTask {
 }
 
 impl DnsResolver {
-    pub(crate) fn new() -> Result<Self, ResolveError> {
-        let resolver = TokioResolver::builder_tokio()?.build();
+    pub(crate) fn new() -> io::Result<Self> {
         let (request_tx, request_rx) = channel();
         let (event_tx, event_rx) = channel();
         let cancellation_token = CancellationToken::new();
         let dns_task = DnsTask {
             active_tasks: Default::default(),
-            resolver,
             request_rx,
             event_tx,
             cancellation_token: cancellation_token.clone(),
@@ -97,15 +94,13 @@ impl DnsTask {
 
             /* spawn task for dns request */
             let event_tx = self.event_tx.clone();
-            let resolver = self.resolver.clone();
             let cancellation_token = self.cancellation_token.clone();
 
             let task = tokio::task::spawn_local(async move {
                 tokio::select! {
-                    ips = resolver.lookup_ip(&hostname) => {
-                       let ips = ips.map(|ips| ips.iter().collect::<Vec<_>>());
+                    result = resolve_hostname(&hostname) => {
                        event_tx
-                           .send(DnsEvent::Resolved(handle, hostname, ips))
+                           .send(DnsEvent::Resolved(handle, hostname, result))
                            .expect("channel closed");
                     }
                     _ = cancellation_token.cancelled() => {},
@@ -115,3 +110,18 @@ impl DnsTask {
         }
     }
 }
+
+/// Resolve `hostname` via the operating system's full name-resolution
+/// stack (`getaddrinfo` on Unix, GetAddrInfoEx on Windows). This walks
+/// `/etc/nsswitch.conf` on Linux — picking up mDNS via Avahi, /etc/hosts,
+/// and DNS — and uses Bonjour for `.local` names on macOS. Pure-DNS
+/// resolvers like hickory miss all of those, which is why a Bonjour
+/// hostname (e.g. `JKMBP-M4-Max.local`) wouldn't resolve before.
+///
+/// Port `0` is a placeholder — `lookup_host` requires `host:port` but we
+/// only care about the IPs at this stage; the actual port is appended at
+/// connection time.
+async fn resolve_hostname(hostname: &str) -> io::Result<Vec<IpAddr>> {
+    let addrs = lookup_host((hostname, 0)).await?;
+    Ok(addrs.map(|sa| sa.ip()).collect())
+}
diff --git a/src/emulation.rs b/src/emulation.rs
index 853267ca..9e927747 100644
--- a/src/emulation.rs
+++ b/src/emulation.rs
@@ -1,7 +1,11 @@
+use crate::config::local_commit;
 use crate::listen::{LanMouseListener, ListenEvent, ListenerCreationError};
 use futures::StreamExt;
-use input_emulation::{EmulationHandle, InputEmulation, InputEmulationError};
-use input_event::Event;
+use input_emulation::{
+    EmulationHandle, InputEmulation, InputEmulationError, ReceivePostProcessing,
+};
+use input_event::{ClipboardEvent, Event};
+use lan_mouse_ipc::IncomingPeerConfig;
 use lan_mouse_proto::{Position, ProtoEvent};
 use local_channel::mpsc::{Receiver, Sender, channel};
 use std::{
@@ -16,6 +20,13 @@ use tokio::{
     task::{JoinHandle, spawn_local},
 };
 
+fn to_pp(peer: &IncomingPeerConfig) -> ReceivePostProcessing {
+    ReceivePostProcessing {
+        natural_scroll: peer.natural_scroll,
+        mouse_sensitivity: peer.mouse_sensitivity,
+    }
+}
+
 /// emulation handling events received from a listener
 pub(crate) struct Emulation {
     task: JoinHandle<()>,
@@ -52,12 +63,44 @@ pub(crate) enum EmulationEvent {
     EmulationEnabled,
     /// capture should be released
     ReleaseNotify,
+    /// peer sent us a Hello with its build commit hash. Used to
+    /// populate `client_manager.peer_commit` from the listen side
+    /// too — without this, peer-version visibility silently fails
+    /// whenever the outgoing connection in the *other* direction is
+    /// broken (one-way setups, asymmetric NAT, peer's TCP listener
+    /// down). The connect-side path stays as the primary source;
+    /// this is the defensive fallback.
+    PeerHello {
+        addr: SocketAddr,
+        commit: [u8; 8],
+    },
+    /// Authorized peer at `addr` delivered a clipboard frame whose
+    /// receive-side gate evaluated true. The local clipboard has
+    /// already been updated by [`ListenTask`]; Service consumes
+    /// this event to refresh the `ClipboardMonitor`'s
+    /// last-known-content (so the next poll doesn't re-emit it as a
+    /// fresh local change) and to fan the payload out to other
+    /// authorized peers whose `clipboard_send` is true.
+    /// `from_fingerprint` is the *originator*'s certificate
+    /// fingerprint stamped on the wire — distinct from the
+    /// fingerprint of the peer at `addr` when the message has
+    /// been forwarded through an intermediate hop.
+    ClipboardReceived {
+        addr: SocketAddr,
+        from_fingerprint: String,
+        content: String,
+    },
 }
 
 enum EmulationRequest {
     Reenable,
     Release(SocketAddr),
     ChangePort(u16),
+    /// Replace the per-fingerprint receive-side post-processing
+    /// table. Service pushes this on startup, on every authorization
+    /// change, and whenever the user adjusts a peer's natural-scroll
+    /// or sensitivity from the GUI.
+    SetIncomingPeers(HashMap<String, IncomingPeerConfig>),
     Terminate,
 }
 
@@ -74,6 +117,8 @@ impl Emulation {
             emulation_proxy,
             request_rx,
             event_tx,
+            addr_to_fingerprint: HashMap::new(),
+            incoming_peers: HashMap::new(),
         };
         let task = spawn_local(emulation_task.run());
         Self {
@@ -101,6 +146,16 @@ impl Emulation {
             .expect("channel closed")
     }
 
+    /// Push the latest authorized-peers table to the receive
+    /// pipeline. Calls fire-and-forget; ListenTask resolves
+    /// per-fingerprint settings against its addr→fingerprint cache
+    /// and pushes per-handle post-processing into InputEmulation.
+    pub(crate) fn set_incoming_peers(&self, peers: HashMap<String, IncomingPeerConfig>) {
+        self.request_tx
+            .send(EmulationRequest::SetIncomingPeers(peers))
+            .expect("channel closed")
+    }
+
     pub(crate) async fn event(&mut self) -> EmulationEvent {
         self.event_rx.recv().await.expect("channel closed")
     }
@@ -122,9 +177,25 @@ struct ListenTask {
     emulation_proxy: EmulationProxy,
     request_rx: Receiver<EmulationRequest>,
     event_tx: Sender<EmulationEvent>,
+    /// addr→fingerprint cache populated from `ListenEvent::Accept`.
+    /// Lets ListenTask resolve `IncomingPeerConfig` for an incoming
+    /// peer without a per-packet round-trip into the listener.
+    addr_to_fingerprint: HashMap<SocketAddr, String>,
+    /// Latest authorized-peers map pushed by Service. Read on Accept
+    /// and on `SetIncomingPeers` to build the per-handle
+    /// `ReceivePostProcessing` snapshots that go into InputEmulation.
+    incoming_peers: HashMap<String, IncomingPeerConfig>,
 }
 
 impl ListenTask {
+    fn post_processing_for_addr(&self, addr: SocketAddr) -> ReceivePostProcessing {
+        self.addr_to_fingerprint
+            .get(&addr)
+            .and_then(|fp| self.incoming_peers.get(fp))
+            .map(to_pp)
+            .unwrap_or_default()
+    }
+
     async fn run(mut self) {
         let mut interval = tokio::time::interval(Duration::from_secs(5));
         let mut last_response = HashMap::new();
@@ -141,6 +212,44 @@ impl ListenTask {
                                     log::info!("releasing capture: {addr} entered this device");
                                     self.event_tx.send(EmulationEvent::ReleaseNotify).expect("channel closed");
                                     self.listener.reply(addr, ProtoEvent::Ack(0)).await;
+                                    // Send the receiving device's display
+                                    // geometry so the capturing peer can
+                                    // model the guest cursor's position
+                                    // accurately. Old peers that don't
+                                    // recognize this event will skip it
+                                    // per the forward-compat fix.
+                                    if let Some((width, height)) = self.emulation_proxy.display_bounds() {
+                                        self.listener.reply(addr, ProtoEvent::Bounds { width, height }).await;
+                                    }
+                                    // Tell the capturing peer what
+                                    // sensitivity multiplier we'll
+                                    // apply to their motion deltas so
+                                    // their wall-press auto-release
+                                    // model can scale to match.
+                                    let pp = self.post_processing_for_addr(addr);
+                                    self.listener.reply(addr, ProtoEvent::ReceiverSensitivity {
+                                        mouse_sensitivity: pp.mouse_sensitivity,
+                                    }).await;
+                                    // No entry-edge midpoint warp here:
+                                    // the host's CursorPos (sent right
+                                    // after Enter) carries the
+                                    // proportional landing point and
+                                    // pins the on-axis dimension to the
+                                    // matching edge. Warping to the
+                                    // midpoint first would briefly
+                                    // place the cursor at center-edge
+                                    // — and a quick re-cross by the
+                                    // user would have the local
+                                    // CGEventTap (or equivalent) snap
+                                    // its `cursor=` field from the
+                                    // midpoint, masquerading as a
+                                    // mid-screen crossing on the next
+                                    // CursorPos sent back the other
+                                    // way. Trusts the host: if it
+                                    // can't compute a proportional
+                                    // point the cursor stays where it
+                                    // was, which is preferable to a
+                                    // forced midpoint.
                                     self.event_tx.send(EmulationEvent::Entered{addr, pos: to_ipc_pos(pos), fingerprint}).expect("channel closed");
                                 }
                             }
@@ -149,11 +258,103 @@ impl ListenTask {
                                 self.listener.reply(addr, ProtoEvent::Ack(0)).await;
                             }
                             ProtoEvent::Input(event) => self.emulation_proxy.consume(event, addr),
+                            ProtoEvent::Clipboard { from_fingerprint, content } => {
+                                let receive_ok = self.addr_to_fingerprint
+                                    .get(&addr)
+                                    .and_then(|fp| self.incoming_peers.get(fp))
+                                    .map(|peer| peer.clipboard_receive)
+                                    .unwrap_or(false);
+                                if !receive_ok {
+                                    log::debug!(
+                                        "dropping clipboard frame from {addr}: clipboard_receive disabled or unauthorized peer"
+                                    );
+                                } else {
+                                    // Inject locally via the same
+                                    // pipeline that handles input
+                                    // events. InputEmulation::consume
+                                    // short-circuits Clipboard events
+                                    // to its ClipboardEmulation sink.
+                                    self.emulation_proxy.consume(
+                                        Event::Clipboard(ClipboardEvent::Text(content.clone())),
+                                        addr,
+                                    );
+                                    // Hand off to Service so it can
+                                    // (a) suppress an immediate self-
+                                    // emit from the local
+                                    // ClipboardMonitor poll, and (b)
+                                    // forward to other peers honoring
+                                    // the (originator, content)
+                                    // recent-forwarded gate.
+                                    self.event_tx.send(EmulationEvent::ClipboardReceived {
+                                        addr,
+                                        from_fingerprint,
+                                        content,
+                                    }).expect("channel closed");
+                                }
+                            }
                             ProtoEvent::Ping => self.listener.reply(addr, ProtoEvent::Pong(self.emulation_proxy.emulation_active.get())).await,
+                            // Peer's version handshake. Echo our own
+                            // commit back so the peer's connect-side
+                            // receive_loop populates its `peer_commit`,
+                            // AND publish a PeerHello upward so our
+                            // service can populate ours from the listen
+                            // side too — the connect side is the primary
+                            // path, but if the outbound direction is
+                            // broken (one-way setup, NAT, peer's TCP
+                            // listener down) the version display would
+                            // otherwise silently say "unknown" while
+                            // the peer is in fact happily talking to us.
+                            ProtoEvent::Hello { commit } => {
+                                self.listener.reply(addr, ProtoEvent::Hello { commit: local_commit() }).await;
+                                self.event_tx.send(EmulationEvent::PeerHello { addr, commit }).expect("channel closed");
+                            }
+                            // Capturing peer told us where on its own
+                            // screen the user's cursor was, as a
+                            // normalized fraction (nx, ny) ∈ [0, 1]
+                            // plus the entry side (from our frame).
+                            // Scale against our live display bounds
+                            // and pin the on-axis dimension to the
+                            // matching edge so the cursor lands at
+                            // the visually-corresponding point.
+                            // Works without a prior Bounds round-trip,
+                            // so the very first crossing of a session
+                            // also lands at the visually-corresponding
+                            // point. The cross-axis multiply is
+                            // clamped to dim - 1 so a host edge
+                            // (nx == 1.0 or ny == 1.0) doesn't compute
+                            // one pixel past the addressable column.
+                            ProtoEvent::CursorPos { pos, nx, ny } => {
+                                if let Some((w, h)) = self.emulation_proxy.display_bounds() {
+                                    let pwi = w as i32;
+                                    let phi = h as i32;
+                                    let cx = ((nx * w as f32) as i32).clamp(0, pwi.saturating_sub(1));
+                                    let cy = ((ny * h as f32) as i32).clamp(0, phi.saturating_sub(1));
+                                    let (tx, ty) = match pos {
+                                        Position::Left => (0, cy),
+                                        Position::Right => (pwi.saturating_sub(1), cy),
+                                        Position::Top => (cx, 0),
+                                        Position::Bottom => (cx, phi.saturating_sub(1)),
+                                    };
+                                    log::info!(
+                                        "[cursor-pos] recv pos={pos:?} nx={nx:.3} ny={ny:.3} display_bounds=({w},{h}) → warp=({tx},{ty})"
+                                    );
+                                    self.emulation_proxy.warp_cursor(tx, ty);
+                                } else {
+                                    log::info!(
+                                        "[cursor-pos] recv pos={pos:?} nx={nx:.3} ny={ny:.3} but display_bounds=None — skipping warp"
+                                    );
+                                }
+                            }
                             _ => {}
                         }
                     }
                     Some(ListenEvent::Accept { addr, fingerprint }) => {
+                        self.addr_to_fingerprint.insert(addr, fingerprint.clone());
+                        // Pre-cache the per-handle post-processing so
+                        // EmulationTask can pick it up the moment the
+                        // first Input from this addr arrives.
+                        let pp = self.post_processing_for_addr(addr);
+                        self.emulation_proxy.set_post_processing(addr, pp);
                         self.event_tx.send(EmulationEvent::Connected { addr, fingerprint }).expect("channel closed");
                     }
                     Some(ListenEvent::Rejected { fingerprint }) => {
@@ -177,6 +378,25 @@ impl ListenTask {
                         let result = self.listener.port_changed().await;
                         self.event_tx.send(EmulationEvent::PortChanged(result)).expect("channel closed");
                     }
+                    EmulationRequest::SetIncomingPeers(peers) => {
+                        self.incoming_peers = peers;
+                        // Re-resolve every known address so the live
+                        // backend picks up changes for currently-
+                        // active peers, not just future ones.
+                        let known_addrs: Vec<SocketAddr> = self.addr_to_fingerprint.keys().copied().collect();
+                        for addr in known_addrs {
+                            let pp = self.post_processing_for_addr(addr);
+                            self.emulation_proxy.set_post_processing(addr, pp);
+                            // Push the updated sensitivity to the
+                            // capturing peer over the wire so their
+                            // wall-press auto-release model matches
+                            // immediately, without waiting for the
+                            // next cross-back-then-cross-forward.
+                            self.listener.reply(addr, ProtoEvent::ReceiverSensitivity {
+                                mouse_sensitivity: pp.mouse_sensitivity,
+                            }).await;
+                        }
+                    }
                     EmulationRequest::Terminate => break,
                 },
                 _ = interval.tick() => {
@@ -206,6 +426,11 @@ pub(crate) struct EmulationProxy {
     request_tx: Sender<ProxyRequest>,
     event_rx: Receiver<EmulationEvent>,
     task: JoinHandle<()>,
+    /// Cached display bounds. Refreshed each time the underlying
+    /// InputEmulation is (re)created. `None` until the first
+    /// successful query, or if the active backend doesn't report
+    /// geometry.
+    display_bounds: Rc<Cell<Option<(u32, u32)>>>,
 }
 
 enum ProxyRequest {
@@ -213,6 +438,16 @@ enum ProxyRequest {
     Remove(SocketAddr),
     Terminate,
     Reenable,
+    /// Warp the local cursor to an absolute position. Used on
+    /// `Enter` to seat the cursor at the entry edge so the
+    /// capturing peer's wall-press model is synchronized.
+    Warp(i32, i32),
+    /// Set the receive-side post-processing for events arriving
+    /// from `addr`. Resolved by ListenTask from the persistent
+    /// authorized-peers table; cached on the EmulationTask side
+    /// keyed by addr until a handle exists, then pushed into
+    /// InputEmulation by handle.
+    SetPostProcessing(SocketAddr, ReceivePostProcessing),
 }
 
 impl EmulationProxy {
@@ -221,9 +456,12 @@ impl EmulationProxy {
         let (event_tx, event_rx) = channel();
         let emulation_active = Rc::new(Cell::new(false));
         let exit_requested = Rc::new(Cell::new(false));
+        let display_bounds = Rc::new(Cell::new(None));
         let emulation_task = EmulationTask {
             backend,
             exit_requested: exit_requested.clone(),
+            display_bounds: display_bounds.clone(),
+            post_processing: HashMap::new(),
             request_rx,
             event_tx,
             handles: Default::default(),
@@ -236,7 +474,38 @@ impl EmulationProxy {
             request_tx,
             task,
             event_rx,
+            display_bounds,
+        }
+    }
+
+    /// Display geometry of this device (cached). Refreshed each
+    /// time the input emulation backend is (re)created.
+    pub(crate) fn display_bounds(&self) -> Option<(u32, u32)> {
+        self.display_bounds.get()
+    }
+
+    /// Fire-and-forget cursor warp. Drops silently if emulation
+    /// isn't currently active (no live backend to receive the
+    /// request).
+    pub(crate) fn warp_cursor(&self, x: i32, y: i32) {
+        if !self.emulation_active.get() {
+            return;
         }
+        let _ = self.request_tx.send(ProxyRequest::Warp(x, y));
+    }
+
+    /// Fire-and-forget per-addr post-processing update. Persists in
+    /// the EmulationTask cache so settings survive backend respawns
+    /// (CGEventTap timeout, portal session restart, etc.) and so a
+    /// handle created later for this addr inherits the right values.
+    pub(crate) fn set_post_processing(
+        &self,
+        addr: SocketAddr,
+        post_processing: ReceivePostProcessing,
+    ) {
+        let _ = self
+            .request_tx
+            .send(ProxyRequest::SetPostProcessing(addr, post_processing));
     }
 
     async fn event(&mut self) -> EmulationEvent {
@@ -283,6 +552,15 @@ impl EmulationProxy {
 struct EmulationTask {
     backend: Option<input_emulation::Backend>,
     exit_requested: Rc<Cell<bool>>,
+    /// Shared cache; refreshed each time we (re)create the inner
+    /// InputEmulation. Read by `EmulationProxy::display_bounds`.
+    display_bounds: Rc<Cell<Option<(u32, u32)>>>,
+    /// Per-addr receive-side post-processing snapshots. Pushed by
+    /// ListenTask via `ProxyRequest::SetPostProcessing` whenever
+    /// the underlying authorized-peers table changes. Re-applied to
+    /// every newly created InputEmulation (handle by handle) so a
+    /// backend respawn doesn't drop the user's settings.
+    post_processing: HashMap<SocketAddr, ReceivePostProcessing>,
     request_rx: Receiver<ProxyRequest>,
     event_tx: Sender<EmulationEvent>,
     handles: HashMap<SocketAddr, EmulationHandle>,
@@ -305,6 +583,13 @@ impl EmulationTask {
                     ProxyRequest::Terminate => return,
                     ProxyRequest::Input(..) => { /* emulation inactive => ignore */ }
                     ProxyRequest::Remove(..) => { /* emulation inactive => ignore */ }
+                    ProxyRequest::Warp(..) => { /* emulation inactive => ignore */ }
+                    ProxyRequest::SetPostProcessing(addr, pp) => {
+                        // No live backend yet, but cache the values so
+                        // the next created backend picks them up the
+                        // moment a handle is assigned for this addr.
+                        self.post_processing.insert(addr, pp);
+                    }
                 }
             }
         }
@@ -318,6 +603,21 @@ impl EmulationTask {
             _ = wait_for_termination(&mut self.request_rx) => return Ok(()),
         };
 
+        // Refresh the shared display-bounds cache. Goes through
+        // EmulationProxy::display_bounds() so the daemon can include
+        // it in the ProtoEvent::Bounds reply on Enter.
+        self.display_bounds.set(emulation.display_bounds());
+
+        // Re-apply per-handle post-processing for any handles we
+        // already had before the backend was (re)created. New
+        // handles created from `Input` will pick up their values
+        // from the same cache.
+        for (addr, &handle) in &self.handles {
+            if let Some(&pp) = self.post_processing.get(addr) {
+                emulation.set_post_processing(handle, pp);
+            }
+        }
+
         // used to send enabled and disabled events
         let _emulation_guard = DropGuard::new(
             self.event_tx.clone(),
@@ -365,6 +665,12 @@ impl EmulationTask {
                                 self.next_id += 1;
                                 emulation.create(handle).await;
                                 self.handles.insert(addr, handle);
+                                // Apply any cached post-processing
+                                // (set when the DTLS Accept arrived,
+                                // before the first Input).
+                                if let Some(&pp) = self.post_processing.get(&addr) {
+                                    emulation.set_post_processing(handle, pp);
+                                }
                                 handle
                             }
                         };
@@ -374,6 +680,31 @@ impl EmulationTask {
                         if let Some(handle) = self.handles.remove(&addr) {
                             emulation.destroy(handle).await;
                         }
+                        // Intentionally keep `post_processing[addr]`
+                        // alive across handle removal. `Remove` fires
+                        // on every `ProtoEvent::Leave` (cross-back to
+                        // the peer's screen) and on the 1-second
+                        // heartbeat timeout, neither of which means
+                        // the DTLS session is gone for good. The same
+                        // SocketAddr keeps delivering Input events on
+                        // the next cross; we want the user's per-pair
+                        // settings to follow the addr, not the
+                        // ephemeral handle that gets minted fresh on
+                        // each cross. A real DTLS disconnect followed
+                        // by a reconnect arrives with a new
+                        // SocketAddr (new ephemeral port), so a stale
+                        // entry doesn't shadow a fresh one.
+                    }
+                    ProxyRequest::Warp(x, y) => {
+                        if let Err(e) = emulation.warp_cursor(x, y).await {
+                            log::warn!("warp_cursor failed: {e}");
+                        }
+                    }
+                    ProxyRequest::SetPostProcessing(addr, pp) => {
+                        self.post_processing.insert(addr, pp);
+                        if let Some(&handle) = self.handles.get(&addr) {
+                            emulation.set_post_processing(handle, pp);
+                        }
                     }
                     ProxyRequest::Terminate => break Ok(()),
                     ProxyRequest::Reenable => continue,
@@ -392,12 +723,21 @@ fn to_ipc_pos(pos: Position) -> lan_mouse_ipc::Position {
     }
 }
 
+/// Where to seat the local cursor when this device is entered.
+/// `pos` is the protocol-level position in *this device's* frame
+/// (already inverted from the host's perspective by the capture
+/// side). For example, `Position::Left` means "the host is to my
+/// left, the cursor entered from my left edge", so the cursor
+/// should land at x=0. Y is centered along the entry edge for
+/// Left/Right; X is centered for Top/Bottom.
 async fn wait_for_termination(rx: &mut Receiver<ProxyRequest>) {
     loop {
         match rx.recv().await.expect("channel closed") {
             ProxyRequest::Terminate => return,
             ProxyRequest::Input(_, _) => continue,
             ProxyRequest::Remove(_) => continue,
+            ProxyRequest::Warp(_, _) => continue,
+            ProxyRequest::SetPostProcessing(_, _) => continue,
             ProxyRequest::Reenable => continue,
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
index ae9c66e5..ac7dee84 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,8 +4,13 @@ pub mod client;
 pub mod config;
 mod connect;
 mod crypto;
+mod discovery;
 mod dns;
 mod emulation;
 pub mod emulation_test;
 mod listen;
+#[cfg(target_os = "macos")]
+pub mod macos_tcc_probe;
+#[cfg(target_os = "macos")]
+pub mod macos_tcc_watch;
 pub mod service;
diff --git a/src/listen.rs b/src/listen.rs
index bd508584..6b35d202 100644
--- a/src/listen.rs
+++ b/src/listen.rs
@@ -1,15 +1,17 @@
 use futures::{Stream, StreamExt};
-use lan_mouse_proto::{MAX_EVENT_SIZE, ProtoEvent};
+use lan_mouse_ipc::IncomingPeerConfig;
+use lan_mouse_proto::{MAX_CLIPBOARD_SIZE, MAX_EVENT_SIZE, ProtoEvent, decode_clipboard_event};
 use local_channel::mpsc::{Receiver, Sender, channel};
 use rustls::pki_types::CertificateDer;
 use std::{
-    collections::{HashMap, VecDeque},
-    net::SocketAddr,
+    collections::{HashMap, HashSet, VecDeque},
+    net::{IpAddr, SocketAddr},
     rc::Rc,
     sync::{Arc, Mutex, RwLock},
     time::Duration,
 };
 use thiserror::Error;
+use tokio::time::MissedTickBehavior;
 use tokio::{
     sync::Mutex as AsyncMutex,
     task::{JoinHandle, spawn_local},
@@ -30,9 +32,12 @@ pub enum ListenerCreationError {
     WebrtcUtil(#[from] webrtc_util::Error),
     #[error(transparent)]
     WebrtcDtls(#[from] webrtc_dtls::Error),
+    #[error("no listener could be bound on any local address")]
+    NoBoundListener,
 }
 
 type ArcConn = Arc<dyn Conn + Send + Sync>;
+type DynListener = Box<dyn Listener + Send + Sync>;
 
 pub(crate) enum ListenEvent {
     Msg {
@@ -63,14 +68,31 @@ type VerifyPeerCertificateFn = Arc<
         + Sync,
 >;
 
+/// One bound DTLS listener and the task that accepts on it. Stored
+/// in a `HashMap<IpAddr, ListenerSlot>` keyed by the local IPv4
+/// address it's bound to so the supervisor can plug/unplug
+/// listeners as interfaces appear/disappear.
+struct ListenerSlot {
+    /// Background task that calls `listener.accept()` in a loop and
+    /// forwards events into the shared `listen_tx` / `conns`.
+    /// Aborted on `Drop` so dropping the supervisor cleans up.
+    accept_task: JoinHandle<()>,
+}
+
+impl Drop for ListenerSlot {
+    fn drop(&mut self) {
+        self.accept_task.abort();
+    }
+}
+
 impl LanMouseListener {
     pub(crate) async fn new(
         port: u16,
         cert: Certificate,
-        authorized_keys: Arc<RwLock<HashMap<String, String>>>,
+        authorized_keys: Arc<RwLock<HashMap<String, IncomingPeerConfig>>>,
     ) -> Result<Self, ListenerCreationError> {
         let (listen_tx, listen_rx) = channel();
-        let (request_port_change, mut request_port_change_rx) = channel();
+        let (request_port_change, request_port_change_rx) = channel();
         let (port_changed_tx, port_changed) = channel();
         let connection_attempts: Arc<Mutex<VecDeque<String>>> = Default::default();
 
@@ -109,72 +131,72 @@ impl LanMouseListener {
             ..Default::default()
         };
 
-        let listen_addr = SocketAddr::new("0.0.0.0".parse().expect("invalid ip"), port);
-        let mut listener = listen(listen_addr, cfg.clone()).await?;
-
         let conns: Rc<AsyncMutex<Vec<(SocketAddr, ArcConn)>>> =
             Rc::new(AsyncMutex::new(Vec::new()));
 
-        let conns_clone = conns.clone();
-        let listen_task: JoinHandle<()> = {
-            let listen_tx = listen_tx.clone();
-            let connection_attempts = connection_attempts.clone();
-            spawn_local(async move {
-                loop {
-                    let sleep = tokio::time::sleep(Duration::from_secs(2));
-                    tokio::select! {
-                        /* workaround for https://github.com/webrtc-rs/webrtc/issues/614 */
-                        _ = sleep => continue,
-                        c = listener.accept() => match c {
-                            Ok((conn, addr)) => {
-                                log::info!("dtls client connected, ip: {addr}");
-                                let mut conns = conns_clone.lock().await;
-                                conns.push((addr, conn.clone()));
-                                let dtls_conn: &DTLSConn = conn.as_any().downcast_ref().expect("dtls conn");
-                                let certs = dtls_conn.connection_state().await.peer_certificates;
-                                let cert = certs.first().expect("cert");
-                                let fingerprint = crypto::generate_fingerprint(cert);
-                                listen_tx.send(ListenEvent::Accept { addr, fingerprint }).expect("channel closed");
-                                spawn_local(read_loop(conns_clone.clone(), addr, conn, listen_tx.clone()));
-                            },
-                            Err(e) => {
-                                if let Error::Std(ref e) = e {
-                                    if let Some(e) = e.0.downcast_ref::<webrtc_dtls::Error>() {
-                                        match e {
-                                            webrtc_dtls::Error::ErrVerifyDataMismatch => {
-                                                if let Some(fingerprint) = connection_attempts.lock().expect("lock").pop_front() {
-                                                    listen_tx.send(ListenEvent::Rejected { fingerprint }).expect("channel closed");
-                                                }
-                                            }
-                                            _ => log::warn!("accept: {e}"),
-                                        }
-                                    } else {
-                                        log::warn!("accept: {e:?}");
-                                    }
-                                } else {
-                                    log::warn!("accept: {e:?}");
-                                }
-                            }
-                        },
-                        port = request_port_change_rx.recv() => {
-                            let port = port.expect("channel closed");
-                            let listen_addr = SocketAddr::new("0.0.0.0".parse().expect("invalid ip"), port);
-                            match listen(listen_addr, cfg.clone()).await {
-                                Ok(new_listener) => {
-                                    let _ = listener.close().await;
-                                    listener = new_listener;
-                                    port_changed_tx.send(Ok(port)).expect("channel closed");
-                                }
-                                Err(e) => {
-                                    log::warn!("unable to change port: {e}");
-                                    port_changed_tx.send(Err(e.into())).expect("channel closed");
-                                }
-                            };
-                        },
-                    };
+        // Bind one listener per local IPv4 address (skip loopback +
+        // link-local) instead of a single 0.0.0.0:port listener. With
+        // a single 0.0.0.0 bind on a multi-homed host, replies use
+        // the kernel's preferred outbound interface as source IP —
+        // which may not match the IP the peer dialed, breaking QUIC
+        // 4-tuple matching. Per-IP binds make replies symmetric
+        // automatically: each listener's reply socket is bound to a
+        // specific IP, so the kernel uses *that* IP as source.
+        let initial_addrs = enumerate_listenable_ipv4();
+        if initial_addrs.is_empty() {
+            // Fall back to 0.0.0.0 so we at least listen somewhere if
+            // interface enumeration fails (very unusual).
+            log::warn!("no listenable IPv4 addresses found; falling back to 0.0.0.0");
+        }
+        let mut listeners: HashMap<IpAddr, ListenerSlot> = HashMap::new();
+        let mut bound_count = 0usize;
+        for ip in &initial_addrs {
+            match try_bind_listener(*ip, port, &cfg).await {
+                Ok(listener) => {
+                    let task = spawn_accept_task(
+                        listener,
+                        listen_tx.clone(),
+                        conns.clone(),
+                        connection_attempts.clone(),
+                    );
+                    listeners.insert(*ip, ListenerSlot { accept_task: task });
+                    bound_count += 1;
+                    log::info!("listening for DTLS on {ip}:{port}");
                 }
-            })
-        };
+                Err(e) => log::warn!("failed to bind listener on {ip}:{port}: {e}"),
+            }
+        }
+        if bound_count == 0 {
+            // Either enumeration returned no addrs, or every bind
+            // failed. Try `0.0.0.0:port` as a last resort.
+            let fallback = IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED);
+            match try_bind_listener(fallback, port, &cfg).await {
+                Ok(listener) => {
+                    let task = spawn_accept_task(
+                        listener,
+                        listen_tx.clone(),
+                        conns.clone(),
+                        connection_attempts.clone(),
+                    );
+                    listeners.insert(fallback, ListenerSlot { accept_task: task });
+                    log::info!(
+                        "listening for DTLS on {fallback}:{port} (fallback — symmetric replies not guaranteed)"
+                    );
+                }
+                Err(e) => return Err(e),
+            }
+        }
+
+        let listen_task = spawn_supervisor_task(
+            port,
+            cfg,
+            listeners,
+            listen_tx.clone(),
+            conns.clone(),
+            connection_attempts,
+            request_port_change_rx,
+            port_changed_tx,
+        );
 
         Ok(Self {
             conns,
@@ -245,22 +267,299 @@ impl Stream for LanMouseListener {
     }
 }
 
+/// Enumerate local IPv4 addresses suitable for binding a public
+/// listener: skip loopback (127.0.0.0/8) and link-local
+/// (169.254.0.0/16) since neither is reachable from a peer. IPv6
+/// is intentionally omitted — lan-mouse is IPv4-only on the wire
+/// today.
+fn enumerate_listenable_ipv4() -> Vec<IpAddr> {
+    let ifaces = match if_addrs::get_if_addrs() {
+        Ok(v) => v,
+        Err(e) => {
+            log::warn!("get_if_addrs failed: {e}");
+            return Vec::new();
+        }
+    };
+    ifaces
+        .into_iter()
+        .filter_map(|iface| match iface.addr {
+            if_addrs::IfAddr::V4(v4) => Some(v4.ip),
+            if_addrs::IfAddr::V6(_) => None,
+        })
+        .filter(|ip| !ip.is_loopback() && !ip.is_link_local())
+        .map(IpAddr::V4)
+        .collect()
+}
+
+async fn try_bind_listener(
+    ip: IpAddr,
+    port: u16,
+    cfg: &Config,
+) -> Result<DynListener, ListenerCreationError> {
+    let addr = SocketAddr::new(ip, port);
+    let listener = listen(addr, cfg.clone()).await?;
+    Ok(Box::new(listener))
+}
+
+/// Spawn an accept loop for one bound listener. Each accepted
+/// `(conn, addr)` is registered in the shared `conns` vec and an
+/// `Accept` event is published. Verify-peer-certificate failures are
+/// re-published as `Rejected` so the UI can surface unauthorized
+/// fingerprints. The accept loop exits when the listener errors
+/// out or its task is aborted (interface went down, port changed).
+fn spawn_accept_task(
+    listener: DynListener,
+    listen_tx: Sender<ListenEvent>,
+    conns: Rc<AsyncMutex<Vec<(SocketAddr, ArcConn)>>>,
+    connection_attempts: Arc<Mutex<VecDeque<String>>>,
+) -> JoinHandle<()> {
+    spawn_local(async move {
+        loop {
+            // workaround for https://github.com/webrtc-rs/webrtc/issues/614
+            let sleep = tokio::time::sleep(Duration::from_secs(2));
+            tokio::select! {
+                _ = sleep => continue,
+                c = listener.accept() => match c {
+                    Ok((conn, addr)) => {
+                        log::info!("dtls client connected, ip: {addr}");
+                        {
+                            let mut conns_guard = conns.lock().await;
+                            conns_guard.push((addr, conn.clone()));
+                        }
+                        let dtls_conn: &DTLSConn = conn.as_any().downcast_ref().expect("dtls conn");
+                        let certs = dtls_conn.connection_state().await.peer_certificates;
+                        let cert = certs.first().expect("cert");
+                        let fingerprint = crypto::generate_fingerprint(cert);
+                        listen_tx
+                            .send(ListenEvent::Accept { addr, fingerprint })
+                            .expect("channel closed");
+                        spawn_local(read_loop(conns.clone(), addr, conn, listen_tx.clone()));
+                    }
+                    Err(e) => {
+                        if let Error::Std(ref se) = e {
+                            if let Some(de) = se.0.downcast_ref::<webrtc_dtls::Error>() {
+                                match de {
+                                    webrtc_dtls::Error::ErrVerifyDataMismatch => {
+                                        if let Some(fingerprint) =
+                                            connection_attempts.lock().expect("lock").pop_front()
+                                        {
+                                            listen_tx
+                                                .send(ListenEvent::Rejected { fingerprint })
+                                                .expect("channel closed");
+                                        }
+                                    }
+                                    _ => log::warn!("accept: {de}"),
+                                }
+                            } else {
+                                log::warn!("accept: {se:?}");
+                            }
+                        } else {
+                            log::warn!("accept: {e:?}");
+                        }
+                    }
+                },
+            };
+        }
+    })
+}
+
+/// Supervisor task: owns the set of active listeners, watches for
+/// interface up/down events via `if_watch`, and rebuilds listeners
+/// on port change. Each listener slot is keyed by its local IPv4
+/// address; on `IfEvent::Up` we add a slot, on `IfEvent::Down` we
+/// drop one (which aborts its accept task).
+#[allow(clippy::too_many_arguments)]
+fn spawn_supervisor_task(
+    initial_port: u16,
+    cfg: Config,
+    initial_listeners: HashMap<IpAddr, ListenerSlot>,
+    listen_tx: Sender<ListenEvent>,
+    conns: Rc<AsyncMutex<Vec<(SocketAddr, ArcConn)>>>,
+    connection_attempts: Arc<Mutex<VecDeque<String>>>,
+    mut request_port_change_rx: Receiver<u16>,
+    port_changed_tx: Sender<Result<u16, ListenerCreationError>>,
+) -> JoinHandle<()> {
+    spawn_local(async move {
+        let mut port = initial_port;
+        let mut listeners = initial_listeners;
+        let mut watcher = match if_watch::tokio::IfWatcher::new() {
+            Ok(w) => Some(w),
+            Err(e) => {
+                log::warn!(
+                    "if_watch::IfWatcher::new failed: {e}; interface plug/unplug \
+                     will not be detected (restart lan-mouse to pick up new addrs)"
+                );
+                None
+            }
+        };
+        // Periodic reconciliation: enumerate live IPs and diff against
+        // `listeners`. Network.framework on macOS doesn't reliably fire
+        // `IfEvent::Down` when an interface is administratively
+        // disabled (e.g. user toggles Wi-Fi off in System Settings),
+        // leaving stale slots bound to vanished IPs that no traffic
+        // can reach. Polling every 30s catches whatever if-watch
+        // misses — both adds (covers missed Up events too) and drops.
+        // `Skip` so a long suspend (laptop closed for hours) doesn't
+        // burst-fire backlog ticks at resume.
+        let mut reconcile_tick = tokio::time::interval(Duration::from_secs(30));
+        reconcile_tick.set_missed_tick_behavior(MissedTickBehavior::Skip);
+        // Skip the immediate-first tick — we just enumerated at startup
+        // and don't want to thrash listeners on the first iteration.
+        reconcile_tick.tick().await;
+        loop {
+            tokio::select! {
+                _ = reconcile_tick.tick() => {
+                    let current_ips: HashSet<IpAddr> =
+                        enumerate_listenable_ipv4().into_iter().collect();
+                    let to_drop: Vec<IpAddr> = listeners
+                        .keys()
+                        .filter(|ip| !current_ips.contains(*ip))
+                        .copied()
+                        .collect();
+                    for ip in to_drop {
+                        // `to_drop` was just collected from
+                        // `listeners.keys()` and we run single-
+                        // threaded, so the remove always returns Some.
+                        listeners.remove(&ip);
+                        log::info!(
+                            "reconcile: dropping stale listener on {ip}:{port} \
+                             (IP no longer present on any interface)"
+                        );
+                    }
+                    // `try_bind_listener` is async and may fail, so
+                    // `entry().or_insert_with(...)` doesn't fit — we
+                    // only want to insert on bind success. Match the
+                    // `Entry::Vacant` slot up front so the same hash
+                    // lookup covers both the existence check and the
+                    // later insert, satisfying clippy::map_entry.
+                    for ip in current_ips {
+                        if let std::collections::hash_map::Entry::Vacant(slot) =
+                            listeners.entry(ip)
+                        {
+                            match try_bind_listener(ip, port, &cfg).await {
+                                Ok(l) => {
+                                    let task = spawn_accept_task(
+                                        l,
+                                        listen_tx.clone(),
+                                        conns.clone(),
+                                        connection_attempts.clone(),
+                                    );
+                                    slot.insert(ListenerSlot { accept_task: task });
+                                    log::info!(
+                                        "reconcile: now listening on {ip}:{port} \
+                                         (IP appeared without an Up event)"
+                                    );
+                                }
+                                Err(e) => log::warn!(
+                                    "reconcile: failed to bind on {ip}:{port}: {e}"
+                                ),
+                            }
+                        }
+                    }
+                }
+                ev = async {
+                    match watcher.as_mut() {
+                        Some(w) => w.select_next_some().await,
+                        None => std::future::pending().await,
+                    }
+                } => match ev {
+                    Ok(if_watch::IfEvent::Up(net)) => {
+                        let ip = net.addr();
+                        let usable = if let IpAddr::V4(v4) = ip {
+                            !v4.is_loopback() && !v4.is_link_local()
+                        } else {
+                            false
+                        };
+                        if usable && !listeners.contains_key(&ip) {
+                            match try_bind_listener(ip, port, &cfg).await {
+                                Ok(l) => {
+                                    let task = spawn_accept_task(
+                                        l,
+                                        listen_tx.clone(),
+                                        conns.clone(),
+                                        connection_attempts.clone(),
+                                    );
+                                    listeners.insert(ip, ListenerSlot { accept_task: task });
+                                    log::info!("interface up: now listening on {ip}:{port}");
+                                }
+                                Err(e) => log::warn!("failed to bind on {ip}:{port}: {e}"),
+                            }
+                        }
+                    }
+                    Ok(if_watch::IfEvent::Down(net)) => {
+                        let ip = net.addr();
+                        if listeners.remove(&ip).is_some() {
+                            log::info!("interface down: stopped listening on {ip}:{port}");
+                        }
+                    }
+                    Err(e) => log::debug!("if_watch error: {e}"),
+                },
+                p = request_port_change_rx.recv() => {
+                    let new_port = p.expect("channel closed");
+                    listeners.clear(); // Drop aborts each accept task
+                    let mut bound = 0usize;
+                    let addrs = enumerate_listenable_ipv4();
+                    for ip in &addrs {
+                        match try_bind_listener(*ip, new_port, &cfg).await {
+                            Ok(l) => {
+                                let task = spawn_accept_task(
+                                    l,
+                                    listen_tx.clone(),
+                                    conns.clone(),
+                                    connection_attempts.clone(),
+                                );
+                                listeners.insert(*ip, ListenerSlot { accept_task: task });
+                                bound += 1;
+                            }
+                            Err(e) => log::warn!("port change: failed to bind {ip}:{new_port}: {e}"),
+                        }
+                    }
+                    if bound == 0 {
+                        port_changed_tx
+                            .send(Err(ListenerCreationError::NoBoundListener))
+                            .expect("channel closed");
+                    } else {
+                        port = new_port;
+                        port_changed_tx
+                            .send(Ok(port))
+                            .expect("channel closed");
+                    }
+                }
+            }
+        }
+    })
+}
+
 async fn read_loop(
     conns: Rc<AsyncMutex<Vec<(SocketAddr, ArcConn)>>>,
     addr: SocketAddr,
     conn: ArcConn,
     dtls_tx: Sender<ListenEvent>,
 ) -> Result<(), Error> {
-    let mut b = [0u8; MAX_EVENT_SIZE];
+    // Buffer sized for the largest legal clipboard frame; mouse /
+    // keyboard datagrams use only the first MAX_EVENT_SIZE bytes.
+    let mut b = [0u8; MAX_CLIPBOARD_SIZE];
 
-    while conn.recv(&mut b).await.is_ok() {
-        match b.try_into() {
-            Ok(event) => dtls_tx
+    while let Ok(n) = conn.recv(&mut b).await {
+        if n == 0 {
+            continue;
+        }
+        let datagram = &b[..n];
+        match decode_listen_datagram(datagram) {
+            Some(event) => dtls_tx
                 .send(ListenEvent::Msg { event, addr })
                 .expect("channel closed"),
-            Err(e) => {
-                log::warn!("error receiving event: {e}");
-                break;
+            None => {
+                // Skip the malformed/unknown datagram and keep
+                // listening. Each DTLS recv returns one full
+                // datagram, so a parse error here can't desync a
+                // stream; the next call gets a fresh, framed
+                // message. This makes the protocol forward-
+                // compatible: a peer running a newer Lan Mouse
+                // version can introduce additional event types
+                // and old peers will simply ignore them rather
+                // than dropping the connection.
+                log::debug!("ignoring undecodable {n}-byte event from {addr}");
             }
         }
     }
@@ -273,3 +572,19 @@ async fn read_loop(
     conns.remove(index);
     Ok(())
 }
+
+/// Classify a DTLS datagram by its first-byte event-type tag and
+/// route through the variable-length clipboard codec or the fixed-
+/// buffer `try_into` path. Mirrors `decode_proto_datagram` on the
+/// connect side so both directions accept the same wire formats.
+fn decode_listen_datagram(bytes: &[u8]) -> Option<ProtoEvent> {
+    use lan_mouse_proto::EventType;
+    let tag = *bytes.first()?;
+    if tag == EventType::Clipboard as u8 {
+        return decode_clipboard_event(bytes).ok();
+    }
+    let mut fixed = [0u8; MAX_EVENT_SIZE];
+    let copy_len = bytes.len().min(MAX_EVENT_SIZE);
+    fixed[..copy_len].copy_from_slice(&bytes[..copy_len]);
+    fixed.try_into().ok()
+}
diff --git a/src/macos_tcc_probe.rs b/src/macos_tcc_probe.rs
new file mode 100644
index 00000000..744f8ab8
--- /dev/null
+++ b/src/macos_tcc_probe.rs
@@ -0,0 +1,19 @@
+//! Fresh-process probe of TCC Accessibility permission.
+//!
+//! `AXIsProcessTrusted()` in already-running processes can return
+//! cached-true for an unbounded window after the user *removes* the
+//! app's entry from System Settings → Privacy & Security →
+//! Accessibility (vs *toggling* it off, which flips the cache
+//! promptly). To detect the "remove" case, the daemon spawns a fresh
+//! subprocess of the same binary that runs this probe — a fresh
+//! process consults the current TCC state without inheriting the
+//! parent's cached trust. See `macos_tcc_watch` for the watcher loop.
+
+#[link(name = "ApplicationServices", kind = "framework")]
+unsafe extern "C" {
+    fn AXIsProcessTrusted() -> bool;
+}
+
+pub fn is_accessibility_granted() -> bool {
+    unsafe { AXIsProcessTrusted() }
+}
diff --git a/src/macos_tcc_watch.rs b/src/macos_tcc_watch.rs
new file mode 100644
index 00000000..42dde1b0
--- /dev/null
+++ b/src/macos_tcc_watch.rs
@@ -0,0 +1,90 @@
+//! TCC.db mtime watcher → fresh-subprocess probe → daemon exit.
+//!
+//! Detects "user removed the app from System Settings → Privacy &
+//! Security → Accessibility" — the case where `AXIsProcessTrusted()`
+//! in already-running processes keeps reporting cached-true for an
+//! unbounded window, even though the OS has effectively revoked
+//! permission and a fresh process would see false.
+//!
+//! Strategy: poll the TCC database file's mtime every 2 seconds. The
+//! stat is essentially free (kernel-cached inode metadata, ~µs per
+//! call). When the mtime ticks, spawn a fresh subprocess of our own
+//! binary that runs `lan-mouse ax-probe` — a fresh process bypasses
+//! the parent's cached trust and consults the current TCC state. If
+//! the probe exits non-zero (AX revoked), we exit the daemon with
+//! `process::exit(0)`. The GUI's IPC-drop watcher then propagates
+//! the exit (see `lan_mouse_gtk::lib::receiver.recv` Err branch).
+//!
+//! Cost is negligible: one stat per 2s, plus one subprocess spawn
+//! per actual TCC change (rare — only fires when the user opens
+//! System Settings and modifies the list).
+
+use std::env;
+use std::path::{Path, PathBuf};
+use std::process::{self, Command};
+use std::time::{Duration, SystemTime};
+
+const POLL_INTERVAL: Duration = Duration::from_secs(2);
+
+/// System-level TCC database — holds Accessibility, Input Monitoring,
+/// Screen Recording, etc. for application bundles. This is the file
+/// that ticks when the user adds/removes/toggles entries in System
+/// Settings → Privacy & Security → Accessibility. The per-user
+/// `~/Library/Application Support/com.apple.TCC/TCC.db` does NOT
+/// track Accessibility — confirmed empirically; an earlier version
+/// of this watcher polled both and only the system path moved on
+/// the AX revoke path that this module exists to fix.
+const TCC_DB_PATH: &str = "/Library/Application Support/com.apple.TCC/TCC.db";
+
+fn read_mtime(path: &Path) -> Option<SystemTime> {
+    std::fs::metadata(path).ok()?.modified().ok()
+}
+
+fn probe_ax_in_fresh_subprocess() -> Option<bool> {
+    // Spawn a fresh copy of our binary with `ax-probe`. A fresh
+    // process consults the current TCC state without inheriting the
+    // parent's cached trust. Exit 0 = granted, 1 = revoked.
+    let exe = env::current_exe().ok()?;
+    let status = Command::new(exe).arg("ax-probe").status().ok()?;
+    Some(status.success())
+}
+
+/// Spawn the watcher on the current tokio runtime. Must be called
+/// from inside a tokio runtime; runs forever until the daemon exits.
+pub fn spawn() {
+    tokio::spawn(async move {
+        let path = PathBuf::from(TCC_DB_PATH);
+        let mut last_mtime = read_mtime(&path);
+        log::info!(
+            "tcc_watch: watching {} (initial mtime: {:?})",
+            path.display(),
+            last_mtime
+        );
+
+        loop {
+            tokio::time::sleep(POLL_INTERVAL).await;
+            let current_mtime = read_mtime(&path);
+            if current_mtime == last_mtime {
+                continue;
+            }
+            log::info!(
+                "tcc_watch: TCC.db mtime changed ({last_mtime:?} -> {current_mtime:?}) — confirming AX via fresh subprocess"
+            );
+            last_mtime = current_mtime;
+            match probe_ax_in_fresh_subprocess() {
+                Some(true) => {
+                    log::debug!("tcc_watch: probe confirms AX still granted");
+                }
+                Some(false) => {
+                    log::error!(
+                        "tcc_watch: AX revoked (TCC.db changed and fresh probe returned false) — daemon exiting"
+                    );
+                    process::exit(0);
+                }
+                None => {
+                    log::warn!("tcc_watch: probe subprocess failed to spawn or run");
+                }
+            }
+        }
+    });
+}
diff --git a/src/main.rs b/src/main.rs
index 0ca54c93..b61ccbb1 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -67,6 +67,17 @@ fn run() -> Result<(), LanMouseError> {
                     r => r?,
                 }
             }
+            #[cfg(target_os = "macos")]
+            Command::AxProbe => {
+                // Fresh-process probe of TCC Accessibility state. Spawned
+                // by the daemon's TCC.db watcher (see lan_mouse::tcc_watch
+                // on macOS) to bypass cached-trust state in already-running
+                // processes — particularly important for the "remove from
+                // list" case where AXIsProcessTrusted in the parent keeps
+                // reporting cached-true. Exit 0 = granted, 1 = revoked.
+                let granted = lan_mouse::macos_tcc_probe::is_accessibility_granted();
+                process::exit(if granted { 0 } else { 1 });
+            }
         },
         None => {
             //  otherwise start the service as a child process and
@@ -74,17 +85,43 @@ fn run() -> Result<(), LanMouseError> {
             #[cfg(feature = "gtk")]
             {
                 let mut service = start_service()?;
-                let res = lan_mouse_gtk::run();
+                let res = lan_mouse_gtk::run(config::local_commit());
+
+                // Bound the daemon-child cleanup so a wedged daemon
+                // (CGEventTap stuck on macOS, hung syscall, etc.)
+                // can't freeze the GUI on quit. SIGINT first, give it
+                // a few seconds to exit cleanly, then SIGKILL.
                 #[cfg(unix)]
                 {
-                    // on unix we give the service a chance to terminate gracefully
                     let pid = service.id() as libc::pid_t;
                     unsafe {
                         libc::kill(pid, libc::SIGINT);
                     }
-                    service.wait()?;
+                    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(3);
+                    loop {
+                        match service.try_wait() {
+                            Ok(Some(_)) => break,
+                            Ok(None) if std::time::Instant::now() >= deadline => {
+                                log::warn!(
+                                    "daemon child did not exit on SIGINT in 3s — sending SIGKILL"
+                                );
+                                let _ = service.kill();
+                                let _ = service.wait();
+                                break;
+                            }
+                            Ok(None) => std::thread::sleep(std::time::Duration::from_millis(50)),
+                            Err(e) => {
+                                log::error!("waiting for daemon child: {e}");
+                                break;
+                            }
+                        }
+                    }
+                }
+                #[cfg(not(unix))]
+                {
+                    let _ = service.kill();
+                    let _ = service.wait();
                 }
-                service.kill()?;
                 res?;
             }
             #[cfg(not(feature = "gtk"))]
@@ -132,6 +169,15 @@ async fn run_service(config: Config) -> Result<(), ServiceError> {
     let mut service = Service::new(config).await?;
     log::info!("using config: {config_path:?}");
     log::info!("Press {release_bind:?} to release the mouse");
+
+    // macOS-only: detect AX-permission "remove from list" by polling
+    // TCC.db's mtime and confirming via a fresh subprocess. The
+    // existing in-process AXIsProcessTrusted polling in the GUI only
+    // catches the toggle-off case; the remove case leaves the cached
+    // trust state stuck at true forever. See `macos_tcc_watch`.
+    #[cfg(target_os = "macos")]
+    lan_mouse::macos_tcc_watch::spawn();
+
     service.run().await?;
     log::info!("service exited!");
     Ok(())
diff --git a/src/service.rs b/src/service.rs
index d0772f66..9e7ee4ec 100644
--- a/src/service.rs
+++ b/src/service.rs
@@ -4,30 +4,34 @@ use crate::{
     config::{Config, ConfigClient},
     connect::LanMouseConnection,
     crypto,
+    discovery::{Discovery, PrimaryCache},
     dns::{DnsEvent, DnsResolver},
     emulation::{Emulation, EmulationEvent},
     listen::{LanMouseListener, ListenerCreationError},
 };
 use futures::StreamExt;
-use hickory_resolver::ResolveError;
+use input_capture::clipboard::{ClipboardMonitor, SuppressionList};
+use input_capture::frontmost_app;
+use input_event::{ClipboardEvent, Event as InputEvent};
 use lan_mouse_ipc::{
-    AsyncFrontendListener, ClientHandle, FrontendEvent, FrontendRequest, IpcError,
-    IpcListenerCreationError, Position, Status,
+    AppIdent, AsyncFrontendListener, ClientHandle, FrontendEvent, FrontendRequest, HostKind,
+    IncomingPeerConfig, IpcError, IpcListenerCreationError, Position, Status,
 };
+use lan_mouse_proto::ProtoEvent;
 use log;
 use std::{
     collections::{HashMap, HashSet, VecDeque},
+    hash::{DefaultHasher, Hash, Hasher},
     io,
     net::{IpAddr, SocketAddr},
     sync::{Arc, RwLock},
+    time::{Duration, Instant},
 };
 use thiserror::Error;
 use tokio::{process::Command, signal, sync::Notify};
 
 #[derive(Debug, Error)]
 pub enum ServiceError {
-    #[error(transparent)]
-    Dns(#[from] ResolveError),
     #[error(transparent)]
     IpcListen(#[from] IpcListenerCreationError),
     #[error(transparent)]
@@ -50,7 +54,12 @@ pub struct Service {
     /// frontend listener
     frontend_listener: AsyncFrontendListener,
     /// authorized public key sha256 fingerprints
-    authorized_keys: Arc<RwLock<HashMap<String, String>>>,
+    authorized_keys: Arc<RwLock<HashMap<String, IncomingPeerConfig>>>,
+    /// Shared mDNS browse cache. Used at DTLS-accept time to
+    /// reverse-lookup the connecting peer's IP back to the system
+    /// hostname they advertise via Bonjour, so the GUI can show a
+    /// human-readable identity in the Incoming Connections list.
+    primary_cache: PrimaryCache,
     /// (outgoing) client information
     client_manager: ClientManager,
     /// current port
@@ -70,6 +79,41 @@ pub struct Service {
     /// map from capture handle to connection info
     incoming_conn_info: HashMap<ClientHandle, Incoming>,
     next_trigger_handle: u64,
+    /// mDNS-SD service registration + browse. Advertises our primary
+    /// interface IP for peer dialers to bias toward; populates
+    /// shared `PrimaryCache` (read by `LanMouseConnection`) from
+    /// peer announcements.
+    discovery: Discovery,
+    /// Outgoing connection handle to fan clipboard frames out from
+    /// the capture / forwarding paths. Same handle Capture owns;
+    /// cloned in `Service::new` so Service can call `send` directly
+    /// without routing through the capture session loop.
+    conn: LanMouseConnection,
+    /// Cross-platform clipboard poller. `None` when the platform
+    /// clipboard couldn't be opened (headless CI, Wayland session
+    /// without compositor support). Service drains it in the main
+    /// loop and fans the resulting events out to peers whose
+    /// `clipboard_send` is true.
+    clipboard_monitor: Option<ClipboardMonitor>,
+    /// Recent forwards keyed on `(originator_fingerprint, hash)`.
+    /// Used to break N-peer rebroadcast cycles: when this device
+    /// receives a forwarded clipboard frame and would re-fan to
+    /// other peers, the entry under (origin, content_hash) blocks
+    /// the duplicate. Pruned lazily — entries older than
+    /// `RECENT_FORWARD_TTL` are dropped on each clipboard event.
+    recent_forwarded: HashMap<(String, u64), Instant>,
+    /// Shared with [`ClipboardMonitor`]; mutations to the inner
+    /// `HashSet` take effect on the next clipboard poll without
+    /// rebuilding the monitor.
+    clipboard_suppression: SuppressionList,
+}
+
+const RECENT_FORWARD_TTL: Duration = Duration::from_secs(1);
+
+fn clipboard_hash(content: &str) -> u64 {
+    let mut hasher = DefaultHasher::new();
+    content.hash(&mut hasher);
+    hasher.finish()
 }
 
 #[derive(Debug)]
@@ -94,21 +138,61 @@ impl Service {
         let frontend_listener = AsyncFrontendListener::new().await?;
 
         let authorized_keys = Arc::new(RwLock::new(config.authorized_fingerprints()));
-        // listener + connection
+        // listener + connection. The primary-IP cache is owned by
+        // the dialer side so its references survive Discovery
+        // toggles; Discovery writes peer hints into it as browse
+        // events arrive.
         let listener =
             LanMouseListener::new(config.port(), cert.clone(), authorized_keys.clone()).await?;
-        let conn = LanMouseConnection::new(cert.clone(), client_manager.clone());
+        let primary_cache: PrimaryCache = Default::default();
+        let conn =
+            LanMouseConnection::new(cert.clone(), client_manager.clone(), primary_cache.clone());
 
         // input capture + emulation
         let capture_backend = config.capture_backend().map(|b| b.into());
-        let capture = Capture::new(capture_backend, conn, config.release_bind());
+        let conn_for_service = conn.sender_clone();
+        let capture = Capture::new(
+            capture_backend,
+            conn,
+            config.release_bind(),
+            config.release_threshold_px(),
+        );
         let emulation_backend = config.emulation_backend().map(|b| b.into());
         let emulation = Emulation::new(emulation_backend, listener);
+        // Push the persisted authorized-peers table into the receive
+        // pipeline so per-peer post-processing is applied from the
+        // first incoming packet.
+        emulation.set_incoming_peers(authorized_keys.read().expect("lock").clone());
 
         // create dns resolver
         let resolver = DnsResolver::new()?;
 
         let port = config.port();
+        let discovery = Discovery::new(port, config.mdns_discovery(), primary_cache.clone());
+        // ClipboardMonitor is best-effort: a headless CI environment
+        // or a Wayland session without compositor support yields a
+        // permanent error here. We log and proceed without clipboard
+        // sync rather than tying daemon startup to clipboard
+        // availability.
+        let clipboard_suppression: SuppressionList = {
+            let host = HostKind::current();
+            let initial: HashSet<AppIdent> = config
+                .clipboard_suppression()
+                .host()
+                .iter()
+                .cloned()
+                .map(|s| host.make_ident(s))
+                .collect();
+            Arc::new(std::sync::Mutex::new(initial))
+        };
+        let clipboard_monitor =
+            match ClipboardMonitor::with_suppression(clipboard_suppression.clone()) {
+                Ok(m) => Some(m),
+                Err(e) => {
+                    log::warn!("clipboard monitor unavailable: {e}; clipboard sync disabled");
+                    None
+                }
+            };
         let service = Self {
             config,
             capture,
@@ -116,6 +200,7 @@ impl Service {
             frontend_listener,
             resolver,
             authorized_keys,
+            primary_cache,
             public_key_fingerprint,
             client_manager,
             frontend_event_pending: Default::default(),
@@ -126,6 +211,11 @@ impl Service {
             incoming_conn_info: Default::default(),
             incoming_conns: Default::default(),
             next_trigger_handle: 0,
+            discovery,
+            conn: conn_for_service,
+            clipboard_monitor,
+            recent_forwarded: HashMap::new(),
+            clipboard_suppression,
         };
         Ok(service)
     }
@@ -143,14 +233,31 @@ impl Service {
             self.activate_client(handle);
         }
 
+        // Periodic refresh of the Discovery service registration so
+        // its TXT record stays accurate when the OS-preferred
+        // interface (default route) changes — e.g. user switches
+        // off Wi-Fi and Mac falls back to Ethernet. Cheap: at most
+        // one re-publish every 30s, and a no-op when the primary
+        // hasn't moved. `Skip` so a long suspend doesn't backlog-
+        // burst on resume.
+        let mut discovery_refresh_tick = tokio::time::interval(Duration::from_secs(30));
+        discovery_refresh_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+        // skip the immediate-fire of the first tick — Discovery
+        // already published once at startup
+        discovery_refresh_tick.tick().await;
+
         loop {
             tokio::select! {
                 request = self.frontend_listener.next() => self.handle_frontend_request(request),
                 _ = self.frontend_event_pending.notified() => self.handle_frontend_pending().await,
-                event = self.emulation.event() => self.handle_emulation_event(event),
+                event = self.emulation.event() => self.handle_emulation_event(event).await,
                 event = self.capture.event() => self.handle_capture_event(event),
                 event = self.resolver.event() => self.handle_resolver_event(event),
                 _ = self.config.changed() => self.handle_config_change(),
+                _ = discovery_refresh_tick.tick() => self.discovery.refresh(),
+                event = recv_clipboard(&mut self.clipboard_monitor) => {
+                    self.handle_local_clipboard_event(event).await;
+                }
                 r = signal::ctrl_c() => break r.expect("failed to wait for CTRL+C"),
             }
         }
@@ -218,7 +325,178 @@ impl Service {
                 self.update_enter_hook(handle, enter_hook)
             }
             FrontendRequest::SaveConfiguration => self.save_config(),
+            FrontendRequest::SetReleaseThreshold(threshold) => {
+                self.config.set_release_threshold_px(threshold);
+                self.capture.set_release_threshold(threshold);
+                self.notify_frontend(FrontendEvent::ReleaseThreshold(threshold));
+                self.save_config();
+            }
+            FrontendRequest::SetIncomingPeerNaturalScroll(fp, natural_scroll) => {
+                self.set_incoming_peer_natural_scroll(fp, natural_scroll);
+                self.save_config();
+            }
+            FrontendRequest::SetIncomingPeerSensitivity(fp, sensitivity) => {
+                self.set_incoming_peer_sensitivity(fp, sensitivity);
+                self.save_config();
+            }
+            FrontendRequest::SetMdnsDiscovery(enabled) => {
+                self.config.set_mdns_discovery(enabled);
+                self.discovery.set_enabled(enabled);
+                self.notify_frontend(FrontendEvent::MdnsDiscovery(enabled));
+                self.save_config();
+            }
+            FrontendRequest::SetClientClipboardSend(handle, enabled) => {
+                if self.client_manager.set_clipboard_send(handle, enabled) {
+                    self.broadcast_client(handle);
+                    self.save_config();
+                }
+            }
+            FrontendRequest::SetIncomingPeerClipboardReceive(fp, enabled) => {
+                self.set_incoming_peer_clipboard_receive(fp, enabled);
+                self.save_config();
+            }
+            FrontendRequest::AddSuppressedApp(value) => {
+                self.add_suppressed_app(value);
+                self.save_config();
+            }
+            FrontendRequest::RemoveSuppressedApp(value) => {
+                self.remove_suppressed_app(value);
+                self.save_config();
+            }
+            FrontendRequest::ListRunningApps => {
+                let apps = frontmost_app::list_running_apps();
+                self.notify_frontend(FrontendEvent::RunningApps(apps));
+            }
+        }
+    }
+
+    fn add_suppressed_app(&mut self, value: String) {
+        let value = value.trim().to_owned();
+        if value.is_empty() {
+            return;
+        }
+        let mut suppression = self.config.clipboard_suppression();
+        let host = suppression.host_mut();
+        if !host.iter().any(|v| v.eq_ignore_ascii_case(&value)) {
+            host.push(value);
+        }
+        self.commit_suppression(suppression);
+    }
+
+    fn remove_suppressed_app(&mut self, value: String) {
+        let mut suppression = self.config.clipboard_suppression();
+        suppression
+            .host_mut()
+            .retain(|v| !v.eq_ignore_ascii_case(&value));
+        self.commit_suppression(suppression);
+    }
+
+    /// Persist the per-OS struct, refresh the runtime `HashSet`
+    /// shared with [`ClipboardMonitor`], and push the host slot to
+    /// the GUI. Centralized so add/remove can't drift apart.
+    fn commit_suppression(&mut self, suppression: lan_mouse_ipc::ClipboardSuppression) {
+        let host = HostKind::current();
+        let host_list = suppression.host().clone();
+        {
+            let mut guard = self.clipboard_suppression.lock().expect("lock");
+            guard.clear();
+            for s in &host_list {
+                guard.insert(host.make_ident(s.clone()));
+            }
+        }
+        self.config.set_clipboard_suppression(suppression);
+        self.notify_frontend(FrontendEvent::SuppressedAppsUpdated(host_list));
+    }
+
+    /// Refresh `last_addr` / `last_hostname` for the authorized-peer
+    /// entry matching `fingerprint` whenever a DTLS connect lands.
+    /// Hostname comes from a reverse-lookup against the mDNS
+    /// `hostname → primary_ip` cache; falls through to addr-only
+    /// if discovery isn't running on either end or the peer's
+    /// announced primary differs from the IP it actually connected
+    /// from. Persists the update so the GUI keeps a useful
+    /// identification across restarts.
+    fn update_incoming_peer_address(&mut self, addr: SocketAddr, fingerprint: &str) {
+        let ip = addr.ip().to_string();
+        let hostname = self.lookup_hostname_for_ip(addr.ip());
+        let mut keys = self.authorized_keys.write().expect("lock");
+        let Some(peer) = keys.get_mut(fingerprint) else {
+            return; // unauthorized peer; nothing to update
+        };
+        let mut changed = peer.last_addr.as_deref() != Some(&ip);
+        if changed {
+            peer.last_addr = Some(ip);
+        }
+        if let Some(h) = hostname {
+            if peer.last_hostname.as_deref() != Some(h.as_str()) {
+                peer.last_hostname = Some(h);
+                changed = true;
+            }
+        }
+        if !changed {
+            return;
+        }
+        let snapshot = keys.clone();
+        drop(keys);
+        // No need to push to InputEmulation — last_addr/last_hostname
+        // are display-only; per-pair scroll/sensitivity is unaffected.
+        self.notify_frontend(FrontendEvent::AuthorizedUpdated(snapshot));
+        self.save_config();
+    }
+
+    fn lookup_hostname_for_ip(&self, target: std::net::IpAddr) -> Option<String> {
+        self.primary_cache
+            .borrow()
+            .iter()
+            .find_map(|(host, ip)| (*ip == target).then(|| host.clone()))
+    }
+
+    fn set_incoming_peer_natural_scroll(&mut self, fingerprint: String, natural_scroll: bool) {
+        if let Some(peer) = self
+            .authorized_keys
+            .write()
+            .expect("lock")
+            .get_mut(&fingerprint)
+        {
+            peer.natural_scroll = natural_scroll;
+        }
+        let keys = self.authorized_keys.read().expect("lock").clone();
+        self.emulation.set_incoming_peers(keys.clone());
+        self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
+    }
+
+    fn set_incoming_peer_sensitivity(&mut self, fingerprint: String, sensitivity: f64) {
+        if let Some(peer) = self
+            .authorized_keys
+            .write()
+            .expect("lock")
+            .get_mut(&fingerprint)
+        {
+            peer.mouse_sensitivity = sensitivity;
+        }
+        let keys = self.authorized_keys.read().expect("lock").clone();
+        self.emulation.set_incoming_peers(keys.clone());
+        self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
+    }
+
+    fn set_incoming_peer_clipboard_receive(
+        &mut self,
+        fingerprint: String,
+        clipboard_receive: bool,
+    ) {
+        if let Some(peer) = self
+            .authorized_keys
+            .write()
+            .expect("lock")
+            .get_mut(&fingerprint)
+        {
+            peer.clipboard_receive = clipboard_receive;
         }
+        let keys = self.authorized_keys.read().expect("lock").clone();
+        // Emulation needs to know so the receive-side gate matches
+        // the new value immediately, not after a config-change cycle.
+        self.emulation.set_incoming_peers(keys.clone());
+        self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
     }
 
     fn save_config(&mut self) {
@@ -232,6 +510,7 @@ impl Service {
                 pos: c.pos,
                 active: s.active,
                 enter_hook: c.cmd,
+                clipboard_send: c.clipboard_send,
             })
             .collect();
         self.config.set_clients(clients);
@@ -258,11 +537,15 @@ impl Service {
         }
         let release_bind = self.config.release_bind();
         self.capture.set_release_bind(release_bind);
+        let release_threshold = self.config.release_threshold_px();
+        self.capture.set_release_threshold(release_threshold);
+        self.notify_frontend(FrontendEvent::ReleaseThreshold(release_threshold));
         let authorized_keys = self.config.authorized_fingerprints();
         self.authorized_keys
             .write()
             .unwrap()
             .clone_from(&authorized_keys);
+        self.emulation.set_incoming_peers(authorized_keys);
         self.sync_frontend();
     }
 
@@ -272,7 +555,7 @@ impl Service {
         }
     }
 
-    fn handle_emulation_event(&mut self, event: EmulationEvent) {
+    async fn handle_emulation_event(&mut self, event: EmulationEvent) {
         match event {
             EmulationEvent::ConnectionAttempt { fingerprint } => {
                 self.notify_frontend(FrontendEvent::ConnectionAttempt { fingerprint });
@@ -302,6 +585,7 @@ impl Service {
             EmulationEvent::PortChanged(port) => match port {
                 Ok(port) => {
                     self.port = port;
+                    self.discovery.set_port(port);
                     self.notify_frontend(FrontendEvent::PortChanged(port, None));
                 }
                 Err(e) => self
@@ -315,13 +599,148 @@ impl Service {
                 self.emulation_status = Status::Enabled;
                 self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status));
             }
-            EmulationEvent::ReleaseNotify => self.capture.release(),
+            EmulationEvent::ReleaseNotify => self.capture.release_for_handover(),
             EmulationEvent::Connected { addr, fingerprint } => {
+                self.update_incoming_peer_address(addr, &fingerprint);
                 self.notify_frontend(FrontendEvent::DeviceConnected { addr, fingerprint });
             }
+            EmulationEvent::PeerHello { addr, commit } => {
+                // Map the peer's source addr back to its client handle
+                // and stamp the commit. Skip if we don't have an
+                // outgoing client configured for this peer (incoming-
+                // only setup) — there's nowhere to display the version
+                // in that case anyway.
+                if let Some(handle) = self.client_manager.get_client(addr) {
+                    self.client_manager.set_peer_commit(handle, Some(commit));
+                    self.broadcast_client(handle);
+                }
+            }
+            EmulationEvent::ClipboardReceived {
+                addr,
+                from_fingerprint,
+                content,
+            } => {
+                self.handle_clipboard_received(addr, from_fingerprint, content)
+                    .await;
+            }
         }
     }
 
+    /// Local clipboard change picked up by the polling
+    /// [`ClipboardMonitor`]. Stamp the originator fingerprint on the
+    /// wire frame and fan out to every active outgoing client whose
+    /// `clipboard_send` is true. Records `(self_fp, hash)` in
+    /// `recent_forwarded` so a later forwarded copy of the same
+    /// content (re-arriving via another peer in an N-peer ring)
+    /// won't be redundantly re-broadcast.
+    async fn handle_local_clipboard_event(&mut self, event: Option<input_capture::CaptureEvent>) {
+        let Some(event) = event else {
+            return;
+        };
+        let input_capture::CaptureEvent::Input(InputEvent::Clipboard(ClipboardEvent::Text(
+            content,
+        ))) = event
+        else {
+            return;
+        };
+        let targets = self.client_manager.clipboard_send_targets();
+        if targets.is_empty() {
+            log::trace!(
+                "clipboard captured locally ({} bytes) but no peer has clipboard_send=true; skipping fan-out",
+                content.len()
+            );
+            return;
+        }
+        let from_fingerprint = self.public_key_fingerprint.clone();
+        let hash = clipboard_hash(&content);
+        self.prune_recent_forwarded();
+        self.recent_forwarded
+            .insert((from_fingerprint.clone(), hash), Instant::now());
+        log::info!(
+            "broadcasting local clipboard ({} bytes) to {} peer(s)",
+            content.len(),
+            targets.len()
+        );
+        for handle in targets {
+            let event = ProtoEvent::Clipboard {
+                from_fingerprint: from_fingerprint.clone(),
+                content: content.clone(),
+            };
+            if let Err(e) = self.conn.send(event, handle).await {
+                log::debug!("clipboard send to client {handle} failed: {e}");
+            }
+        }
+    }
+
+    /// Forwarded clipboard frame just landed via the listen side
+    /// (the local clipboard has already been updated by
+    /// `emulation::ListenTask`). Refresh the
+    /// [`ClipboardMonitor`]'s last-known content so the next 500ms
+    /// poll doesn't see this as a fresh local change and bounce it
+    /// back, then forward to other peers honoring the recent-
+    /// forwarded gate.
+    async fn handle_clipboard_received(
+        &mut self,
+        from_addr: SocketAddr,
+        from_fingerprint: String,
+        content: String,
+    ) {
+        if let Some(monitor) = self.clipboard_monitor.as_ref() {
+            monitor.update_last_content(content.clone());
+        }
+        let hash = clipboard_hash(&content);
+        self.prune_recent_forwarded();
+        let key = (from_fingerprint.clone(), hash);
+        if self.recent_forwarded.contains_key(&key) {
+            log::debug!(
+                "skipping clipboard re-fan-out: already forwarded ({}, {} bytes) within {}ms",
+                &from_fingerprint[..from_fingerprint.len().min(8)],
+                content.len(),
+                RECENT_FORWARD_TTL.as_millis()
+            );
+            return;
+        }
+        let targets = self.client_manager.clipboard_send_targets();
+        let forward_targets: Vec<ClientHandle> = targets
+            .into_iter()
+            .filter(|h| {
+                // Skip the client we just received from. Identified
+                // by IP rather than full SocketAddr so a peer's
+                // ephemeral source port (which differs between its
+                // outgoing and our cached active_addr) doesn't
+                // accidentally include them.
+                self.client_manager
+                    .active_addr(*h)
+                    .map(|a| a.ip() != from_addr.ip())
+                    .unwrap_or(true)
+            })
+            .collect();
+        if forward_targets.is_empty() {
+            return;
+        }
+        self.recent_forwarded.insert(key, Instant::now());
+        log::info!(
+            "forwarding clipboard ({} bytes, originator {}) to {} peer(s)",
+            content.len(),
+            &from_fingerprint[..from_fingerprint.len().min(8)],
+            forward_targets.len()
+        );
+        for handle in forward_targets {
+            let event = ProtoEvent::Clipboard {
+                from_fingerprint: from_fingerprint.clone(),
+                content: content.clone(),
+            };
+            if let Err(e) = self.conn.send(event, handle).await {
+                log::debug!("clipboard forward to client {handle} failed: {e}");
+            }
+        }
+    }
+
+    fn prune_recent_forwarded(&mut self) {
+        self.recent_forwarded
+            .retain(|_, ts| ts.elapsed() < RECENT_FORWARD_TTL);
+    }
+
     fn handle_capture_event(&mut self, event: ICaptureEvent) {
         match event {
             ICaptureEvent::CaptureBegin(handle) => {
@@ -343,6 +762,9 @@ impl Service {
                 log::info!("entering client {handle} ...");
                 self.spawn_hook_command(handle);
             }
+            ICaptureEvent::PeerCommitUpdated(handle) => {
+                self.broadcast_client(handle);
+            }
         }
     }
 
@@ -379,8 +801,14 @@ impl Service {
         self.notify_frontend(FrontendEvent::PublicKeyFingerprint(
             self.public_key_fingerprint.clone(),
         ));
+        self.notify_frontend(FrontendEvent::ReleaseThreshold(
+            self.config.release_threshold_px(),
+        ));
+        self.notify_frontend(FrontendEvent::MdnsDiscovery(self.config.mdns_discovery()));
         let keys = self.authorized_keys.read().expect("lock").clone();
         self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
+        let host_list = self.config.clipboard_suppression().host().clone();
+        self.notify_frontend(FrontendEvent::SuppressedAppsUpdated(host_list));
     }
 
     const ENTER_HANDLE_BEGIN: u64 = u64::MAX / 2 + 1;
@@ -447,14 +875,26 @@ impl Service {
     }
 
     fn add_authorized_key(&mut self, desc: String, fp: String) {
-        self.authorized_keys.write().expect("lock").insert(fp, desc);
+        // New authorizations land with default post-processing; the
+        // user can tune natural-scroll / sensitivity from the
+        // expanded row in the Incoming Connections list.
+        let entry = IncomingPeerConfig {
+            description: desc,
+            ..IncomingPeerConfig::default()
+        };
+        self.authorized_keys
+            .write()
+            .expect("lock")
+            .insert(fp, entry);
         let keys = self.authorized_keys.read().expect("lock").clone();
+        self.emulation.set_incoming_peers(keys.clone());
         self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
     }
 
     fn remove_authorized_key(&mut self, fp: String) {
         self.authorized_keys.write().expect("lock").remove(&fp);
         let keys = self.authorized_keys.read().expect("lock").clone();
+        self.emulation.set_incoming_peers(keys.clone());
         self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
     }
 
@@ -600,3 +1040,52 @@ impl Service {
         });
     }
 }
+
+/// `tokio::select!` arm helper for the optional [`ClipboardMonitor`].
+/// Resolves to `Some(event)` when the monitor surfaces a change and
+/// to a never-completing future when no monitor is alive — keeping
+/// the surrounding `select!` from busy-spinning when clipboard sync
+/// is unavailable on the host.
+async fn recv_clipboard(
+    monitor: &mut Option<ClipboardMonitor>,
+) -> Option<input_capture::CaptureEvent> {
+    match monitor.as_mut() {
+        Some(m) => m.recv().await,
+        None => std::future::pending().await,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn clipboard_hash_is_deterministic_within_run() {
+        let h1 = clipboard_hash("hello, world");
+        let h2 = clipboard_hash("hello, world");
+        assert_eq!(h1, h2);
+    }
+
+    #[test]
+    fn clipboard_hash_distinguishes_different_inputs() {
+        assert_ne!(clipboard_hash("foo"), clipboard_hash("bar"));
+        assert_ne!(clipboard_hash(""), clipboard_hash("\0"));
+    }
+
+    #[test]
+    fn recent_forwarded_prune_evicts_expired_entries() {
+        // Mirrors `Service::prune_recent_forwarded` so the eviction
+        // contract is documented as code rather than implicit in
+        // `HashMap::retain`.
+        let mut map: HashMap<(String, u64), Instant> = HashMap::new();
+        let now = Instant::now();
+        let stale = now
+            .checked_sub(Duration::from_secs(2))
+            .expect("clock far enough from epoch for the test to subtract 2s");
+        map.insert(("fp_a".into(), 1), stale);
+        map.insert(("fp_b".into(), 2), now);
+        map.retain(|_, ts| ts.elapsed() < RECENT_FORWARD_TTL);
+        assert!(!map.contains_key(&("fp_a".to_string(), 1)));
+        assert!(map.contains_key(&("fp_b".to_string(), 2)));
+    }
+}