docs: condense implementation comments

Adds vcpkg as a submodule at vcpkg/, pinned to the exact commit vcpkg.json
already declares as builtin-baseline, so the bundled checkout and the
manifest's resolved port versions can never drift apart.

cmake/voicecat-toolchain.cmake, scripts/common.sh, and
clients/apple/scripts/build-xcframework.sh now resolve vcpkg as:
VCPKG_ROOT env var (external checkout) > bundled submodule. Docs updated
to describe the new one-time setup.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.gitignore

@@ -14,9 +14,8 @@
 *.exe
 *.pdb
 
-# vcpkg
+# vcpkg (bundled as a submodule at /vcpkg — see docs/building.md §2)
 /vcpkg_installed/
-/vcpkg/
 
 # Generated protobuf
 *.pb.cc
@@ -36,7 +35,7 @@
 .DS_Store
 Thumbs.db
 
-# Apple / Windows client build artifacts (added in M4)
+# Apple / Windows client build artifacts
 clients/apple/**/build/
 clients/apple/**/*.xcodeproj/xcuserdata/
 clients/apple/**/*.xcodeproj/project.xcworkspace/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vcpkg"]
+	path = vcpkg
+	url = https://github.com/microsoft/vcpkg.git

AGENTS.md

@@ -38,15 +38,20 @@ making progress.
 
 ## Build
 
-Default development preset (real deps via vcpkg — works on Windows/Linux/macOS):
+Default development preset (real deps via vcpkg — works on Windows/Linux/macOS). vcpkg is
+bundled as a git submodule at `vcpkg/`, pinned to `vcpkg.json`'s `builtin-baseline`:
 
 ```bash
-export VCPKG_ROOT=/path/to/vcpkg     # bootstrap vcpkg first; cross-platform
+git submodule update --init vcpkg   # one-time, after cloning
+./vcpkg/bootstrap-vcpkg.sh          # .bat on Windows
 cmake --preset dev
 cmake --build --preset dev
 ctest --preset dev
 ```
 
+To use an external vcpkg checkout instead, `export VCPKG_ROOT=/path/to/vcpkg` — it always
+takes priority over the bundled submodule.
+
 Skeleton (no third-party deps — works immediately, no vcpkg needed):
 
 ```bash
@@ -68,7 +73,8 @@ for the full matrix.
 
 `vcpkg.json` pins all deps to a fixed vcpkg baseline — `cmake --preset dev` resolves them
 automatically on first configure. The vcpkg triplet is auto-resolved from the host platform
-by [`cmake/voicecat-toolchain.cmake`](cmake/voicecat-toolchain.cmake).
+by [`cmake/voicecat-toolchain.cmake`](cmake/voicecat-toolchain.cmake), which also resolves
+`VCPKG_ROOT` (env var override, else the bundled `vcpkg/` submodule).
 
 ## Where each subsystem lives (and its doc)
 

CLAUDE.md

@@ -8,10 +8,14 @@ and what's next* read [`PROGRESS.md`](PROGRESS.md); for *design* read [`docs/`](
 > server-mute, channel CRUD, in-app account management, disconnect/keepalive/reaper. Windows
 > WinForms C# client shipped (M4). **macOS AppKit client shipped** — `VoiceCatMac.xcodeproj`
 > at `clients/apple/macOS/`. **iOS SwiftUI client shipped** — `VoiceCatiOS.xcodeproj` at
-> `clients/apple/iOS/`. `ctest --preset dev` green — 24/24 tests.
+> `clients/apple/iOS/`. `ctest --preset dev` green — 29/29 tests.
 > External PCM feed/tap API (`vc_stream_feed_pcm` + `vc_set_pcm_sink`) shipped.
 > **Screen-audio sharing shipped on macOS (ScreenCaptureKit) and iOS (ReplayKit Broadcast
-> Upload Extension → host App Group ring → `vc_stream_feed_pcm`).** See [`PROGRESS.md`](PROGRESS.md).
+> Upload Extension → host App Group ring → `vc_stream_feed_pcm`).**
+> **Noise suppression shipped (RNNoise, vendored at `third_party/rnnoise/`)** — both send-side
+> mic NR (`vc_set_input_noise_reduction`) and per-listener receive NR; client on/off toggles ship
+on all three clients (receive NR now denoises stereo mic streams too — fixed 2026-06-23).
+> See [`PROGRESS.md`](PROGRESS.md).
 
 VoiceCat = self-hosted native voice & text chat (TeamSpeak/Mumble-style). Plain TCP (control)
 + UDP (media), no WebRTC, encrypted by default. A shared C++ core (`libvoicecat`) drives
@@ -64,10 +68,18 @@ Vcpkg triplet is auto-resolved from the host platform by
 Windows, `x64-linux` on Linux, `arm64-osx` on Apple Silicon. See docs/building.md §1
 "Platform matrix" for details.
 
-One-time vcpkg setup:
+vcpkg is bundled as a git submodule at `vcpkg/`, pinned to the commit in `vcpkg.json`'s
+`builtin-baseline`. One-time setup after cloning:
+
+```bash
+git submodule update --init vcpkg
+./vcpkg/bootstrap-vcpkg.sh               # .bat on Windows
+```
+
+To use an external vcpkg checkout instead (e.g. one shared across projects), set
+`VCPKG_ROOT` — it always takes priority over the bundled submodule:
 
 ```bash
-# one-time: git clone https://github.com/microsoft/vcpkg && ./vcpkg/bootstrap-vcpkg.sh  (.bat on Windows)
 export VCPKG_ROOT=/path/to/vcpkg         # works on Linux / macOS / Windows
 ```
 

CMakeLists.txt

@@ -3,7 +3,8 @@ cmake_minimum_required(VERSION 3.25)
 project(voicecat
     VERSION 0.0.1
     DESCRIPTION "Self-hosted native voice & text chat (see docs/)"
-    LANGUAGES CXX)
+    # C is needed for the vendored RNNoise noise-suppression lib (third_party/rnnoise).
+    LANGUAGES CXX C)
 
 # On iOS, audio_engine.cpp includes miniaudio.h which pulls in AVFoundation Objective-C
 # headers. Those cannot be compiled as C++; we set audio_engine.cpp's LANGUAGE to OBJCXX
@@ -13,11 +14,6 @@ if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
 endif()
 
 # ── Options ───────────────────────────────────────────────────────────────────
-# The M0 skeleton compiles with NO third-party dependencies: every subsystem is a
-# stub that returns VC_ERR_NOT_IMPLEMENTED. As each subsystem is built out, flip
-# VOICECAT_USE_VCPKG_DEPS=ON so CMake pulls the real libraries (mbedTLS, libsodium,
-# opus, protobuf, ...) via the vcpkg toolchain (see vcpkg.json / docs/tech-stack.md).
-option(VOICECAT_USE_VCPKG_DEPS "Link real third-party deps via vcpkg" OFF)
 option(VOICECAT_BUILD_SERVER   "Build voicecat-server"                ON)
 option(VOICECAT_BUILD_TOOLS    "Build the vccli headless test client" ON)
 option(VOICECAT_BUILD_TESTS    "Build tests"                          ON)
@@ -36,6 +32,20 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 
+# ── Static MinGW runtime (Windows) ────────────────────────────────────────────
+# x64-mingw-static only statically links vcpkg's OWN deps (protobuf, sodium, ...);
+# the GCC/MinGW runtime stays dynamic by default, so every produced .exe/.dll
+# otherwise depends on libgcc_s_seh-1.dll / libwinpthread-1.dll / libstdc++-6.dll
+# at runtime — DLLs that exist on a dev box (MSYS2/UCRT64) but not on a clean
+# Windows machine, where the server then fails to start with "… was not found".
+# Apply the fully-static-MinGW recipe to ALL targets so binaries are portable.
+# (The SHARED voicecat.dll already sets these in core/CMakeLists.txt; the duplicate
+# is harmless. Verify with: objdump -p build/<preset>/bin/voicecat-server.exe |
+# grep "DLL Name" — only Windows system DLLs should remain.)
+if(WIN32 AND MINGW)
+    add_link_options(-static-libgcc -static-libstdc++ -static -lwinpthread)
+endif()
+
 # ── Targets ───────────────────────────────────────────────────────────────────
 add_subdirectory(core)
 
@@ -45,9 +55,7 @@ endif()
 
 if(VOICECAT_BUILD_TOOLS)
     add_subdirectory(tools/vccli)
-    if(VOICECAT_USE_VCPKG_DEPS)
     add_subdirectory(tools/voicecat-admin)
-    endif()
 endif()
 
 if(VOICECAT_BUILD_TESTS)
@@ -56,5 +64,4 @@ if(VOICECAT_BUILD_TESTS)
 endif()
 
 message(STATUS "VoiceCat ${PROJECT_VERSION} configured "
-        "(vcpkg deps: ${VOICECAT_USE_VCPKG_DEPS}, "
+        "(server: ${VOICECAT_BUILD_SERVER}, tools: ${VOICECAT_BUILD_TOOLS})")
-        "server: ${VOICECAT_BUILD_SERVER}, tools: ${VOICECAT_BUILD_TOOLS})")

CMakePresets.json

@@ -5,28 +5,17 @@
     {
       "name": "vcpkg-common",
       "hidden": true,
-      "description": "Shared base for all presets that link real deps via vcpkg. Uses cmake/voicecat-toolchain.cmake, which auto-resolves VCPKG_TARGET_TRIPLET / VCPKG_HOST_TRIPLET from the host platform (x64-mingw-static on Windows, x64-linux on Linux, arm64-osx on Apple Silicon). Cross-compile presets override VCPKG_TARGET_TRIPLET in their cacheVariables. Requires VCPKG_ROOT in the environment.",
+      "description": "Shared base for all presets that link real deps via vcpkg. Uses cmake/voicecat-toolchain.cmake, which auto-resolves VCPKG_TARGET_TRIPLET / VCPKG_HOST_TRIPLET from the host platform (x64-mingw-static on Windows, x64-linux on Linux, arm64-osx on Apple Silicon). Cross-compile presets override VCPKG_TARGET_TRIPLET in their cacheVariables. Resolves vcpkg from the bundled git submodule (vcpkg/) unless VCPKG_ROOT points at an external checkout.",
       "generator": "Ninja",
       "toolchainFile": "${sourceDir}/cmake/voicecat-toolchain.cmake",
       "cacheVariables": {
         "VOICECAT_USE_VCPKG_DEPS": "ON"
       }
     },
-    {
-      "name": "skeleton",
-      "displayName": "Skeleton (no third-party deps)",
-      "description": "Builds the stub skeleton with just a C++20 compiler — no vcpkg needed. Subsystems return VC_ERR_NOT_IMPLEMENTED. Good for 'does the repo even build' smoke checks. Runs 2 tests (smoke + frame_codec).",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build/skeleton",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug",
-        "VOICECAT_USE_VCPKG_DEPS": "OFF"
-      }
-    },
     {
       "name": "dev",
       "displayName": "Dev (full real-deps build, vcpkg)",
-      "description": "Day-to-day development preset. Real protocol, crypto, voice, server — everything from M1 onward. Builds server + tools + tests (21 tests). Auto-triplet: x64-mingw-static on Windows, x64-linux on Linux, arm64-osx on Apple Silicon. Requires VCPKG_ROOT.",
+      "description": "Day-to-day development preset. Real protocol, crypto, voice, server. Builds server + tools + tests. Auto-triplet: x64-mingw-static on Windows, x64-linux on Linux, arm64-osx on Apple Silicon. Requires vcpkg bootstrapped (bundled submodule or VCPKG_ROOT).",
       "inherits": "vcpkg-common",
       "binaryDir": "${sourceDir}/build/dev",
       "cacheVariables": {
@@ -38,7 +27,7 @@
     {
       "name": "release",
       "displayName": "Release (optimized, tests on, symbols kept)",
-      "description": "Optimized build with the full test suite enabled. Use to run tests against optimized code, profile, or catch optimizer-sensitive bugs. Symbols are kept (not stripped) so stack traces and profiling remain useful. Auto-triplet. Requires VCPKG_ROOT.",
+      "description": "Optimized build with the full test suite enabled. Use to run tests against optimized code, profile, or catch optimizer-sensitive bugs. Symbols are kept (not stripped) so stack traces and profiling remain useful. Auto-triplet. Requires vcpkg bootstrapped (bundled submodule or VCPKG_ROOT).",
       "inherits": "vcpkg-common",
       "binaryDir": "${sourceDir}/build/release",
       "cacheVariables": {
@@ -50,7 +39,7 @@
     {
       "name": "server-release",
       "displayName": "Server Release (optimized, stripped, no tests)",
-      "description": "Production-shaped build for deployment. Optimized (Release) with stripped binaries (-s linker flag), no tests. This is what you'd ship/run — see docs/deployment.md. Auto-triplet. Requires VCPKG_ROOT.",
+      "description": "Production-shaped build for deployment. Optimized (Release) with stripped binaries (-s linker flag), no tests. This is what you'd ship/run — see docs/deployment.md. Auto-triplet. Requires vcpkg bootstrapped (bundled submodule or VCPKG_ROOT).",
       "inherits": "vcpkg-common",
       "binaryDir": "${sourceDir}/build/server-release",
       "cacheVariables": {
@@ -63,7 +52,7 @@
     },
     {
       "name": "windows-client",
-      "displayName": "Windows client (voicecat.dll for C# WinForms, M4)",
+      "displayName": "Windows client (voicecat.dll for C# WinForms)",
       "description": "Produces a redistributable Release voicecat.dll with no MinGW runtime DLL dependencies (see core/CMakeLists.txt's static-runtime link flags and clients/windows/README.md). Server/tools/tests are off — this preset exists only to build the DLL. Windows only.",
       "inherits": "vcpkg-common",
       "binaryDir": "${sourceDir}/build/windows-client",
@@ -78,7 +67,7 @@
     {
       "name": "apple-dev",
       "displayName": "Apple macOS (libvoicecat.a for Swift Package, scaffolding)",
-      "description": "SCAFFOLDING — not yet CI-validated; build on macOS to verify. Produces a static libvoicecat.a for macOS (arm64-osx on Apple Silicon, x64-osx on Intel) for consumption by the Swift Package / XCFramework. Server/tools/tests off. Requires VCPKG_ROOT.",
+      "description": "SCAFFOLDING — not yet CI-validated; build on macOS to verify. Produces a static libvoicecat.a for macOS (arm64-osx on Apple Silicon, x64-osx on Intel) for consumption by the Swift Package / XCFramework. Server/tools/tests off. Requires vcpkg bootstrapped (bundled submodule or VCPKG_ROOT).",
       "inherits": "vcpkg-common",
       "binaryDir": "${sourceDir}/build/apple-dev",
       "cacheVariables": {
@@ -91,7 +80,7 @@
     {
       "name": "apple-ios",
       "displayName": "Apple iOS device (XCFramework slice)",
-      "description": "Cross-compiles a static libvoicecat.a for iOS device (arm64). One slice of the XCFramework. Server/tools/tests off. Requires VCPKG_ROOT and a macOS host with iOS SDK. Uses cmake/vcpkg-overlays/triplets/arm64-ios.cmake (release-only, correct autoconf host triple).",
+      "description": "Cross-compiles a static libvoicecat.a for iOS device (arm64). One slice of the XCFramework. Server/tools/tests off. Requires vcpkg bootstrapped (bundled submodule or VCPKG_ROOT) and a macOS host with iOS SDK. Uses cmake/vcpkg-overlays/triplets/arm64-ios.cmake (release-only, correct autoconf host triple).",
       "inherits": "vcpkg-common",
       "binaryDir": "${sourceDir}/build/apple-ios",
       "cacheVariables": {
@@ -111,7 +100,7 @@
     {
       "name": "apple-ios-sim",
       "displayName": "Apple iOS simulator (XCFramework slice)",
-      "description": "Cross-compiles a static libvoicecat.a for iOS simulator (arm64-ios-simulator). One slice of the XCFramework. Server/tools/tests off. Requires VCPKG_ROOT and a macOS host with iOS simulator SDK. Uses cmake/vcpkg-overlays/triplets/arm64-ios-simulator.cmake (release-only, correct autoconf host triple).",
+      "description": "Cross-compiles a static libvoicecat.a for iOS simulator (arm64-ios-simulator). One slice of the XCFramework. Server/tools/tests off. Requires vcpkg bootstrapped (bundled submodule or VCPKG_ROOT) and a macOS host with iOS simulator SDK. Uses cmake/vcpkg-overlays/triplets/arm64-ios-simulator.cmake (release-only, correct autoconf host triple).",
       "inherits": "vcpkg-common",
       "binaryDir": "${sourceDir}/build/apple-ios-sim",
       "cacheVariables": {
@@ -130,7 +119,6 @@
     }
   ],
   "buildPresets": [
-    { "name": "skeleton",       "configurePreset": "skeleton" },
     { "name": "dev",            "configurePreset": "dev" },
     { "name": "release",        "configurePreset": "release" },
     { "name": "server-release", "configurePreset": "server-release" },
@@ -140,7 +128,6 @@
     { "name": "apple-ios-sim",  "configurePreset": "apple-ios-sim" }
   ],
   "testPresets": [
-    { "name": "skeleton", "configurePreset": "skeleton", "output": { "outputOnFailure": true } },
     { "name": "dev",      "configurePreset": "dev",      "output": { "outputOnFailure": true } },
     { "name": "release",  "configurePreset": "release",  "output": { "outputOnFailure": true } }
   ]

PROGRESS.md

@@ -10,8 +10,490 @@ up instantly. Newest status at the top.
 
 ## ▶ Where we left off / next action
 
-- **Awaiting on-device verification (2026-06-22):** **iOS real echo cancellation / noise suppression
+- **Done (2026-07-23):** **First comment-density cleanup across core, server, and native
-  via native VPIO.** Root cause of "voice chat doesn't sound like a call" (echo + no NR): real iOS
+  clients.** Condensed comments in the highest-noise audio, reconnect, registry, and binding
+  files; removed implementation history and narration; retained ABI ownership, threading,
+  real-time, ordering, and OS-API invariants. Moved the durable iOS audio-routing/pacing rules
+  to `docs/voice.md` and client reconnection policy to `docs/protocol.md`. No behavior, wire
+  format, or C ABI changes. **Verification:** `cmake --build --preset dev` green;
+  `ctest --preset dev` 29/29 green. `dotnet build VoiceCat.slnx` restores dependencies and
+  builds `VoiceCat.Interop` + `VoiceCat.App`, then fails in the unchanged test project because
+  `ExternalPcmTests.cs:49` references internal `NativeMethods` (`CS0122`).
+
+- **Done (2026-06-25):** **Fixed iOS AirPods-disconnect reinitialize loop on A2DP presets
+  (Stereo Mic / Mono Mic).** Regression from the 2026-06-25 audio-device-change recovery
+  commit below, which broadened the route-change recovery set from
+  `{oldDeviceUnavailable, newDeviceAvailable}` to "everything except
+  categoryChange/routeConfigurationChange". That added `.override` to the recovery set, and
+  `.override` is fired by our own `applyA2dpSpeakerFallback()` →
+  `overrideOutputAudioPort(.speaker)` — which `recoverAudio()` calls on every recovery. On an
+  A2DP preset with AirPods connected, disconnecting them ran:
+    `oldDeviceUnavailable` → `recoverAudio()` → `applyA2dpSpeakerFallback()` (no external
+    output now) → `overrideOutputAudioPort(.speaker)` → `.override` routeChange →
+    `recoverAudio()` → `applyConfiguration()` (setCategory resets the override) →
+    `applyA2dpSpeakerFallback()` → `overrideOutputAudioPort(.speaker)` → `.override` → …
+  Each iteration also called `IOSAudioEngine.reconfigure()` → `rebuild()` (a full
+  stop/restart of `AVAudioEngine`), which is the audible reinitialize loop + CPU spin the
+  user reported. Voice Chat (`.btHfpVoice`) and Built-in Mic + Speaker were unaffected
+  because `applyA2dpSpeakerFallback` early-returns for non-A2DP modes (no
+  `overrideOutputAudioPort` call, no `.override` notification).
+
+  Two-part fix (no C ABI / proto / docs changes — pure Swift iOS-app target):
+  1. **`AudioSessionManager.handleRouteChange`** (`AudioSessionManager.swift:182`): added
+     `.override` to the skip list alongside `.categoryChange`/`.routeConfigurationChange`.
+     `.override` is only ever fired by our own `overrideOutputAudioPort` call, so treating
+     it as a recovery reason is the loop by definition. The
+     `AVAudioEngineConfigurationChange` observer in `IOSVoiceProcessingEngine` remains as
+     the backstop for the case where an override actually stops the engine.
+  2. **`IOSAudioRouter.applyA2dpSpeakerFallback`** (`IOSAudioRouter.swift`): made idempotent
+     via a `lastAppliedOutputOverride` tracker. Skips the `overrideOutputAudioPort` call
+     when the desired override (`.none` for external output present, `.speaker` otherwise)
+     already matches the last successfully applied value — so even if some other path
+     re-enters, the redundant override (and its `.override` notification) isn't fired. The
+     tracker is reset to `nil` at the top of `applyConfiguration()` (setCategory can reset
+     the override) and on a failed call. Defense-in-depth on top of fix 1.
+
+  **Build:** `xcodebuild -project clients/apple/iOS/VoiceCatiOS.xcodeproj -scheme VoiceCatiOS
+  -destination 'generic/platform=iOS' build` green (Xcode 26.5 / iOS 18.0). The standalone
+  `swift test` in `clients/apple/` fails with `no such module 'VoiceCatC'` — pre-existing
+  (confirmed by stashing the changes: fails identically without them); the `VoiceCatC` C ABI
+  XCFramework isn't on SwiftPM's resolver path in this workspace. Not caused by this change
+  (the edit is in the iOS app target, not the `VoiceCatCore` SwiftPM package).
+  **Next (manual, on-device):** connect on the Stereo Mic preset, join voice, disconnect
+  AirPods — expect ONE `oldDeviceUnavailable` → one `recoverAudio` → one `engine started` →
+  one `override` routeChange (skipped, no further `recoverAudio`) and steady audio through
+  the loudspeaker. Also sanity-check AirPods reconnect and wired headphone plug/unplug
+  recover exactly once.
+
+- **Done (2026-06-25):** **iOS robustness — auto-reconnect after a network change + audio
+  recovery when audio devices plug/unplug.** Two layers of bugs the iOS client had:
+  (a) a `VC_EVENT_DISCONNECTED` from the C core on a Wi-Fi→cellular flip / DNS outage /
+  server restart used to leave the session dead with no retry; (b) unplugging wired
+  headphones or AirPods left the engine stopped forever — mic stopped transmitting and
+  remote audio stayed silent (the server connection itself survived, but the audio graph
+  did not recover).
+
+  The first attempt wired reconnect into `AppState.handleConnectEvent`, but that handler
+  never runs for a live-session disconnect: once `SessionState.init` overwrites
+  `client.onEvent` (`SessionState.swift:87`), the `.disconnected` event is delivered to
+  `SessionState.handleEvent`, which used to play a cue and do nothing else. So the live
+  session would sit as a zombie for ~30-60 s (the C core's TCP keepalive/reaper timeout)
+  and then play the "connection lost" sound with no reconnect armed — exactly what the
+  user saw. The fix below has two parts addressing both the missing reconnect AND the
+  long wait.
+
+  1. **Event-driven reconnect** (`AppState.swift`, `SessionState.swift`): added a
+     `weak var appState: AppState?` to `SessionState`, set by AppState on auth success.
+     `SessionState.handleEvent` `.disconnected` now plays the cue and calls
+     `appState?.onLiveSessionDisconnected()` — the SINGLE path by which AppState learns a
+     live session dropped (since its own `handleConnectEvent` is bypassed for live-session
+     events). `onLiveSessionDisconnected` calls a shared `teardownLiveSessionAndReconnect`
+     that snapshots the live session into `LastSession`, stops the audio engine,
+     deactivates the AVAudioSession, nil's `session` (which releases `VoiceCatClient` →
+     `vc_client_destroy` joins the io thread), resets the backoff counter, and arms
+     `scheduleReconnect`.
+  2. **Path-driven proactive reconnect** (`AppState.swift`): an `NWPathMonitor`
+     (`Network.framework`) now runs the whole time we're CONNECTED (started on auth
+     success, not only when armed for reconnect) and stays armed across reconnects. Its
+     `pathUpdateHandler` (dispatched to @MainActor) does two things:
+       - While connected: a primary-interface change (Wi-Fi↔cellular) OR the path becoming
+         `.unsatisfied` triggers `proactiveReconnect()` — tearing the live session down
+         BEFORE the C core notices the dead TCP read. This is what collapses the 30-60 s
+         reaper wait into ~1 s + the first backoff tick. Same-interface refreshes (Wi-Fi
+         BSSID roams, signal-strength changes) are intentionally ignored (signature
+         comparison via `pathSignature`); those usually don't break the TCP connection.
+       - While mid-reconnect (no session): a path becoming `.satisfied` resets the backoff
+         counter and arms `scheduleReconnect` for a fast-fresh retry.
+     `userInitiatedDisconnect` distinguishes manual `disconnect()`/`cancelConnect()` (which
+     set it true → cancel all reconnect state) from a network drop (which leaves it false).
+     On a successful reconnect, `reconnectAttempt` resets and `lastSession` clears; the
+     path monitor keeps watching for the next change. On user-initiated disconnect, all
+     reconnect state (task + path monitor + `lastSession` + `connectedServer`) is cancelled.
+  3. **Backoff + restore**: exponential backoff 1s → 2s → 4s → 8s → 16s → 30s cap,
+     indefinite. TOFU pins match on the second connect (`VC_TOFU_MATCHED`) so the identity
+     gate auto-confirms; on auth success `SessionState.requestRestore` issues a
+     `joinChannel` and re-arms voice + restores the local mute/deafen state on the
+     resulting `.joinResult`.
+  4. **Audio recovery** (`AudioSessionManager.swift`, `IOSVoiceProcessingEngine.swift`):
+     replaced the route-change handler's narrow `.oldDeviceUnavailable`/
+     `.newDeviceAvailable` guard with a single intent-gated `recoverAudio()` path that
+     re-activates the AVAudioSession, re-applies the route config, and rebuilds the
+     engine; it runs on every externally-initiated route change reason except
+     `.categoryChange`/`.routeConfigurationChange` (those we cause ourselves and would
+     loop). Interruption-end now always calls `recoverAudio()` instead of only when
+     `.shouldResume` is set (which left the session permanently dead after Siri). Added
+     an `AVAudioEngineConfigurationChange` observer on the engine in `IOSAudioEngine`
+     that catches the case where iOS stops the engine itself AFTER our route-change
+     handler already rebuilt it (the previous rebuilds raced the engine's own self-stop
+     and lost). And `IOSAudioEngine.rebuild()` now does a one-shot reactivation-retry on
+     `engine.start()` failure — iOS sometimes refuses to start until the AVAudioSession is
+     re-activated, which is the silent-death case.
+  **Build:** `scripts/build-ios-client.sh --no-configure` green (Xcode 26.5 / iOS 18.0 sim
+  SDK, Swift 5 mode). No C ABI / `voicecat.h` / `voicecat.proto` / C core changes; the
+  existing TOFU auto-confirm (`VC_TOFU_MATCHED`) and idempotent `vc_join_channel` make
+  reconnect+restore possible without new C ABI. macOS and Windows clients unchanged.
+  **Next (manual, on-device):** verify unplugging AirPods/wired headphones mid-call keeps
+  audio going through the loudspeaker; verify Wi-Fi→cellular flip mid-call now triggers a
+  FAST reconnect (within a couple seconds, not 30-60 s) and lands in the same channel with
+  voice re-armed; verify tapping Disconnect mid-reconnect-abort cancels cleanly.
+
+- **Done (2026-06-24):** **Three bug fixes — voice join/leave, channel edit defaults, channel-update stream restart.**
+  1. **Join/Leave Voice now truly subscribes/unsubscribes from the voice plane.** Previously
+     "Join Voice" only started the local mic — receiving was always on (gated by channel
+     membership alone). Added a protocol-level voice subscription concept: new
+     `SubscribeVoiceRequest`/`UnsubscribeVoiceRequest`/`VoiceSubscriptionResult` proto messages
+     (`core/proto/voicecat.proto`), `User.voice_subscribed` field, `vc_join_voice`/`vc_leave_voice`
+     C ABI functions (`core/include/voicecat.h`), `VC_EVENT_VOICE_STATE` event, server-side
+     `voice_subscribed_` flag on `ConnSession` checked by the SFU relay's recipient filter
+     (`SessionRegistry::find_channel_sessions` excludes non-subscribers; `MediaRelay::on_udp_frame`
+     also skips non-subscribed senders). The core client gates `sync_remote_streams` on
+     `voice_subscribed_`, tears down all remote decoders + stops local streams on leave, and
+     re-syncs from the session model on join. All three clients (Windows/macOS/iOS) rewired
+     their Join/Leave Voice button to call `joinVoice`+start mic / `leaveVoice`+core stops mic.
+     The configured input mode (PTT/VAD/AlwaysOn) takes effect on join — no extra mic button.
+     Text chat works regardless of voice subscription. **Apple clients not yet compile-verified
+     (Windows environment).**
+  2. **Channel edit dialog now shows the channel's actual current settings.** The read struct
+     `vc_channel` (`voicecat.h`) was missing `sort_order` and `audio` fields — only the write
+     struct `vc_channel_info` had them. Extended `vc_channel` with both (additive, no ABI break),
+     updated the session model (`session::Channel`) and `apply_snapshot`/`apply_channel_event`
+     to populate them, and updated `vc_list_channels` marshaling. All three clients now build
+     the edit descriptor from the actual channel info instead of hardcoded defaults.
+  3. **Channel parameter updates now automatically restart everyone's streams.** Previously
+     editing a channel's audio config (codec/bitrate/sample-rate/FEC/DTX/etc.) persisted and
+     broadcast a `ChannelEvent::UPDATED`, but no layer restarted streams — encoders/decoders
+     are frozen at announce time. `handle_channel_event` (`core/src/core/client.cpp`) now
+     detects audio-config changes on the user's current channel and calls
+     `restart_active_streams_for_channel`, which stop→starts each active local stream. The
+     server reads the updated channel config on re-announce, and peers' `sync_remote_streams`
+     wire up fresh decoders at the new ssrc. The `LocalStream` struct now retains the stream
+     label across restarts. No server or protocol change needed.
+
+- **[ ] Soon — jitter buffer should measure REAL arrival jitter (RFC 3550), not sender
+  timestamps.** `JitterBuffer::push` (`core/src/audio/audio_engine.cpp:84-108`) estimates
+  jitter from `gap = ts - last_push_ts_`, where `ts` is the **sender's timestamp** — which is
+  perfectly regular (`ls.timestamp += samples` every frame, independent of when the packet is
+  actually sent). So `diff` is always ~0, `jitter_est_` stays 0, and `target_depth_ms_` is
+  pinned at its ~20 ms floor. The buffer is therefore **blind to real network/arrival jitter
+  and to bursty senders** — it never deepens. Combined with the playout deliberately seeding
+  to near-zero depth (`on_playback`, ~line 715), the receiver tolerates only a *steady*
+  sender. This is exactly why the iOS mic needed a send-side pacing cushion (below) and why
+  genuine network jitter would also cause underruns. **Fix:** measure inter-arrival jitter
+  the RFC 3550 way — `D = (arrival_j - arrival_i) - (ts_j - ts_i)` using a wall-clock arrival
+  stamp captured in `push()` — and drive `target_depth_ms_` off that EWMA (keep the existing
+  marker/silence-gap outlier rejection). Then the receiver absorbs bursts itself and the iOS
+  send cushion could be reduced or removed. Shared-core change → add a test and re-verify
+  desktop↔desktop stays low-latency (steady sender ⇒ ~0 arrival jitter ⇒ no regression).
+
+- **Done (2026-06-24):** **Windows PTT can now work system-wide (in the background).** Previously
+  the PTT key was focus-scoped (WinForms `KeyDown`/`KeyUp`, dead the moment the window lost
+  focus). Added an AV-safe global path using the **Raw Input API** (`RegisterRawInputDevices` +
+  `WM_INPUT` with `RIDEV_INPUTSINK`) — *not* a `WH_KEYBOARD_LL` low-level hook, which is the
+  keylogger pattern AV heuristics flag (worse for our unsigned MinGW binary). New
+  `clients/windows/VoiceCat.App/Native/RawInput.cs` (P/Invoke + structs); `MainForm` overrides
+  `OnHandleCreated`/`OnHandleDestroyed`/`WndProc` to register the keyboard sink and handle
+  `WM_INPUT`, gates the focus-scoped `KeyDown`/`KeyUp` handlers off when system-wide is on, makes
+  the `Deactivate` force-release conditional, and adds a `GetAsyncKeyState` watchdog on the pump
+  timer so a missed key-up (RDP/lock-screen focus switch) can't leave PTT stuck. New
+  `VoiceSettings.SystemWidePtt` (default ON) with a "Works in the background (system-wide)"
+  checkbox in the Audio settings PTT section. Build green (`dotnet build`, 0 warnings). **Next
+  (manual):** verify background PTT against a live server, and confirm the binary trips no AV
+  keyboard-hook detection.
+
+- **Done (2026-06-23):** **Fixed: receive-side noise reduction silently skipped on stereo mic
+  streams (regression from stereo-mic capture below).** The per-listener NR toggle
+  (`vc_set_remote_stream(... noise_reduction)`) did nothing on Windows/macOS/iOS — the UI and
+  the whole C-ABI→core path were correctly wired, but the decode loop gated the RNNoise pass on
+  `dec_channels == 1` (`core/src/audio/audio_engine.cpp`), an old proxy for "this stream is
+  voice" that assumed *stereo ⇒ screen-share*. The stereo-mic commit broke it: a stereo mic with
+  **send-side NR off** transmits stereo Opus, so the receiver decoded `dec_channels == 2` and
+  skipped NR entirely (gain/mute have no channel guard, which is why only NR looked broken).
+  **Fix:** thread the stream *kind* through `init_recv_stream` into `RemoteStream::is_voice`
+  (set from `si.kind() == STREAM_MIC` in `client.cpp`), gate receive NR on `is_voice` instead of
+  channel count, and fold a stereo voice frame to mono → denoise → duplicate back across both
+  channels in place (symmetric with the send-side downmix; RNNoise is mono-only). A stereo voice
+  stream now plays mono while NR is on; a screen-audio share is never touched. New test
+  `tests/test_recv_noise_reduction.cpp` drives `AudioEngine` and asserts a stereo voice stream's
+  noise floor collapses with NR on (RMS 1046 → 0.1) while a screen-audio share stays unchanged
+  (RMS ≈ 1015). Full `ctest --preset dev` green — **29/29**. Docs: voice.md §10. Clients need no
+  change (shared-core fix). Not yet re-verified two-client E2E on real hardware.
+
+- **Done (2026-06-23):** **Stereo mic capture on Windows & macOS desktop clients.** Both
+  desktop mics were hard-mono: `ensure_audio_running()` defaults `capture_channels = 1` and
+  neither client ever called `vc_set_capture_channels` (only iOS did). Added a **"Stereo
+  microphone" toggle** to each client's Audio settings (off by default, persisted —
+  `VoiceSettings.StereoMic` on Windows, `MainWindowController.stereoMic` /
+  `voice.stereoMic` UserDefaults on macOS). It's applied to the core when the mic stream
+  starts (stored on the stream before the announce round-trip, so the first device open picks
+  it up) and live in settings via `vc_set_capture_channels` + `vc_audio_restart`. Exposed both
+  ABI calls in the Windows interop (`NativeMethods`/`VoiceCatClient`); the macOS wrapper already
+  had them. **Core fix:** `encode_and_send_frame` (`core/src/core/client.cpp`) now folds a
+  stereo mic frame to mono when the channel is mono — previously the `channels == 2` branch
+  encoded interleaved L/R directly even on a mono channel, feeding a mono `opus_encode` 2× its
+  samples (wrong pitch / garbage). Real stereo still only reaches the wire on a **stereo
+  channel** (encoder channel count = channel's Opus mode); on a mono channel the mic is cleanly
+  downmixed. Test: `test_stereo_mic_mono_channel` in `tests/test_vad_ptt_devices.cpp`. Full
+  `ctest --preset dev` green — 28/28. macOS Xcode build not compiled here (Windows host); the
+  Swift changes follow existing `nrChanged`/`setInputDevice` patterns. Docs: voice.md §8.
+
+- **Done (2026-06-23):** **Fixed iOS dual-stream / crackly mic — core opened a second
+  (miniaudio) capture device alongside the AVAudioEngine tap.** Symptom: with two clients in
+  a channel, the remote end heard the iOS mic **twice** and crackly. With Voice Chat + a BT
+  headset, both the BT mic and the internal mic were captured; with Stereo Mic, both a mono
+  and a stereo copy of the internal mic were sent simultaneously. Root cause is a timing gap
+  in `vc_client::ensure_audio_running()` (`core/src/core/client.cpp`): `external_capture` was
+  only set when a MIC stream already existed, but `ensure_audio_running` is also called from
+  `sync_remote_streams` (triggered by the post-auth `ServerStateSnapshot`) **before** the user
+  joins voice — so with no MIC stream, `external_capture` stayed `false` and
+  `AudioEngine::start()` opened a real miniaudio capture device. Later the user joined voice →
+  `IOSAudioEngine.startMic` installed the AVAudioEngine input tap → `feedPcm` →
+  `inject_capture` → `on_capture_frame`. The miniaudio device was still open (the engine was
+  already `running()`, so the later `ensure_audio_running` early-returned and never applied
+  `external_feed`), and `on_capture_frame` encodes+sends every frame with **no deduplication**
+  → the mic was sent twice. The two unsynchronized capture clocks interleaving in the encoder
+  is the crackle; the mono miniaudio device + stereo AVAudioEngine tap is the "mono and stereo
+  at the same time" on Stereo Mic.
+  - **Fix 1 (core, `core/src/core/client.cpp:ensure_audio_running`):** force
+    `p.external_capture = true` whenever `external_playback_` is set. In iOS unified mode the
+    core must never open a hardware capture device — the AVAudioEngine owns the only mic path.
+    No-op on desktop (`external_playback_` is never set there).
+  - **Fix 2 (iOS, `clients/apple/iOS/VoiceCatiOS/AppState.swift`):** move
+    `client.setExternalPlayback(true)` from the `authResult` handler to **before**
+    `client.connect(...)`. The server sends `AuthResult` immediately followed by
+    `ServerStateSnapshot`; `handle_server_state` runs `ensure_audio_running` on the io thread
+    before the main thread drains `authResult`, so setting the flag post-auth raced. Setting it
+    pre-connect guarantees `external_playback_` is true before any message is processed —
+    eliminating the playback-device race too (the mixer timer + AVAudioEngine playback path +
+    VPIO AEC reference are correct from the first frame).
+  - **Verify:** `cmake --build --preset dev` clean; `ctest --preset dev` = 24/28 — the 4
+    failures (`vad_ptt_devices`, `external_pcm`, `frame_ms_reframe`, `channel_samplerate`) are
+    a **pre-existing** teardown `mutex lock failed` race, reproduced identically with the
+    changes stashed. `external_playback` (the one test exercising this code path) **passes**.
+    No xcframework rebuild needed (no new symbols). **Next (manual, on device):** two clients
+    in a channel — Voice Chat + BT, and Stereo Mic — confirm the remote end hears the iOS mic
+    once, clean (no duplicate, no crackle); confirm the iOS user hears the remote user cleanly
+    with AEC working in Voice Chat.
+
+- **Done (2026-06-23):** **Fixed iOS mic flutter / crackle / octave-up.** The iOS mic was
+  unusable: a consistent ~40–60 ms flutter with volume fade ("talking through a slow fan") on
+  every preset. Root cause: the core sends each captured frame **synchronously**
+  (`on_capture_frame` → `encode_and_send_frame`, no send pacer), so packet cadence == capture
+  cadence; and the receiver's playout keeps **near-zero buffering** by design and its jitter
+  estimate is blind to arrival timing (see RFC-3550 item above). That's smooth only for a
+  *steady* sender (desktop miniaudio = steady 20 ms), but the iOS `AVAudioEngine` input tap
+  delivers ~2 frames per ~40 ms callback (more under VPIO) → bursty → receiver underruns → PLC
+  fade.
+  - **Fix (iOS-only, `clients/apple/iOS/VoiceCatiOS/IOSVoiceProcessingEngine.swift`):** the
+    mic tap converts to 48 kHz int16 and writes a lock-free SPSC ring; a 20 ms feed pump
+    drains it and calls `feedPcm` at a **steady** cadence so packets leave the core every
+    20 ms (what the receiver expects). The pump **primes a small prebuffer cushion**
+    (`PumpState.targetFrames`, 3 frames ≈ 60 ms, self-healing up to ~120 ms on underrun)
+    before releasing, so the tap's bursts can't drain it to empty. Two correctness rules
+    (each had bit us): never read a partial frame (`read` consumes what it returns →
+    discarding partials caused crackle), and rebuild the pump with the current channel count
+    every `rebuild()` (a frozen channel count fed mono-as-stereo = octave-up on a Stereo→Voice
+    Chat switch). Trade-off: ~60–120 ms added mic-send latency — unavoidable when de-bursting
+    for a near-zero-buffer receiver; the RFC-3550 fix above would let us shrink it.
+  - **Verify:** `xcodebuild` Debug **BUILD SUCCEEDED** (iOS Simulator, arm64). Audible test
+    requires a real device (simulator has no real mic route): mic should be smooth on Voice
+    Chat / Mono Mic / Stereo Mic, including switching presets while live (no octave).
+
+- **Done (2026-06-23):** **Fixed Apple client link failure (stale xcframework missing
+  RNNoise).** Both `VoiceCatMac` and `VoiceCatiOS` failed to link with `Undefined symbols for
+  architecture arm64: _rnnoise_create / _rnnoise_destroy / _rnnoise_process_frame`. Root
+  cause: `clients/apple/scripts/build-xcframework.sh` merged vcpkg deps into the fat static
+  lib but NOT the locally-built vendored `librnnoise.a` (a CMake target from
+  `third_party/rnnoise/`, linked privately into `voicecat` via `VOICECAT_HAS_NS` — not a
+  vcpkg dep). The xcframework had been rebuilt at 14:17 after the RNNoise commit but still
+  omitted the symbols, so every slice's `libvoicecat-fat.a` referenced `_rnnoise_*` with no
+  defining object. The iOS slices were also stale (pre-rnnoise) and absent from the
+  xcframework entirely.
+  - **Fix:** `build-xcframework.sh` now collects `.a` files from `build/<preset>/lib/`
+    (excluding `libvoicecat*`) in addition to `vcpkg_installed/<triplet>/lib/`, so vendored
+    CMake-target static libs like `librnnoise.a` are merged into the fat lib. Future-proof:
+    any new vendored static-lib target landing in `build/<preset>/lib/` is picked up
+    automatically. README "Fat static library" section updated.
+  - **Verify:** rebuilt `VoiceCatCore.xcframework --all` → all 3 slices (macos-arm64,
+    ios-arm64, ios-arm64-simulator) now carry 10 `_rnnoise_*` symbols each; fat lib
+    ~30 MB → ~33 MB. `xcodebuild` Debug **BUILD SUCCEEDED** for `VoiceCatMac`,
+    `VoiceCatiOS` (iphonesimulator arm64), and `VoiceCatiOS` (iphoneos arm64,
+    `CODE_SIGNING_ALLOWED=NO`). No core/ABI/proto changes — xcframework artifact only.
+
+- **Done (2026-06-23):** **Remote-stream noise suppression — real backend (RNNoise).** The
+  two-sided NR plumbing (`RemoteStream::recv_ns` + `vc_set_remote_stream(... noise_reduction)`)
+  was wired but **inert** — `ApmProcessor::create()` returned a no-op passthrough, because the
+  originally-planned `webrtc-audio-processing` won't build on Windows/macOS. Replaced with
+  **RNNoise** (BSD-3 + CC0), vendored at `third_party/rnnoise/` (the vcpkg port is `!windows
+  !arm`), built as a standalone C static lib + `VOICECAT_HAS_NS`. One `RnnoiseProcessor`
+  (`core/src/audio/apm_processor.cpp`) now backs **both** NR paths:
+  - **Receive-side** (per-listener, per-`ssrc`): lit up automatically via the factory; gated to
+    mono streams (`audio_engine.cpp` ~L791).
+  - **Send-side** (mic, new): `vc_set_input_noise_reduction(client, enable)` ABI +
+    `vc_client::mic_ns_`, run before input gain/VAD in `on_capture_frame`. A stereo mic is
+    downmixed to mono **only when NR is on**; with NR off a stereo mic keeps full stereo.
+  - RNNoise is mono/48 kHz/480-sample; our clock is fixed 48 kHz and Opus frame sizes are all
+    multiples of 480, so no resampling. RT-safe: alloc at construction, lock-free in the callback.
+  - **Verify status:** `ctest --preset dev` green — **28/28** (new `noise_suppression` test:
+    feeds white noise through `ApmProcessor::create()`, measures **99.9%** RMS reduction). Build
+    clean on the `dev` MinGW preset. **Next (manual):** add the on/off toggles to the client UIs
+    (Windows Audio Settings dialog, macOS/iOS settings) calling the two ABIs; build `windows-client`
+    + `apple-dev` presets to confirm RNNoise compiles under MinGW-DLL and arm64; two-client E2E.
+
+- **Done (2026-06-23):** **Aux outgoing stream (mic + a second input device) — Windows + macOS.**
+  Users can now transmit a second hardware input device (e.g. line-in / aux) alongside the mic, with
+  its own device picker and volume, from Audio Settings. **No core/ABI/proto changes** — the aux is
+  a `VC_STREAM_AUX_DEVICE` stream started with `external_feed=1`, captured client-side, and fed via
+  `vc_stream_feed_pcm` (the same external-feed pipeline screen-audio uses). Per-kind `local_streams_`
+  already allows mic + screen + one aux to coexist; volume is a client-side gain multiply (the core's
+  `vc_set_input_gain` is mic-only/global). The aux is always-on (the core never gates `AUX_DEVICE` on
+  VAD/PTT) and is tied to the voice session (started on Join Voice when enabled, stopped on Leave).
+  - **Windows:** new `Audio/InputDeviceCapture.cs` (WASAPI shared-mode capture from a real input
+    endpoint via `IMMDevice.Activate(IAudioClient)`, 48 kHz/s16, 20 ms frames) + `InputDeviceEnumerator`
+    (WASAPI capture-endpoint list — separate from the core's miniaudio ids). Aux section in
+    `AudioSettingsForm.cs` (enable checkbox, device combo, refresh, volume slider, accessible names,
+    live-apply + Cancel revert via callbacks). Lifecycle in `MainForm.cs` (`_auxStreamId` +
+    `InputDeviceCapture`). Persisted in `VoiceSettings.cs` (`AuxEnabled/AuxDeviceId/AuxGain`).
+  - **macOS:** new `Audio/InputDeviceCapture.swift` (AVAudioEngine input-node tap pinned to the chosen
+    Core Audio device via `kAudioOutputUnitProperty_CurrentDevice`; AVAudioConverter → 48 kHz int16;
+    20 ms framing modelled on `ScreenAudioCapture`) + `InputDeviceEnumerator` (Core Audio device list
+    by stable UID). Aux section in `SettingsWindowController.swift`; lifecycle + UserDefaults
+    persistence (`voice.aux*`) in `MainWindowController.swift`. New file added to `project.pbxproj`.
+  - **Verify status:** Windows C# solution builds clean (0 warn/0 err); `ctest` core suite unchanged
+    (no core edits). **Next (manual):** on a Mac, build `VoiceCatMac.xcodeproj`; then two-client E2E —
+    enable aux on a second input device, confirm two distinct streams for the sender and that the aux
+    volume slider moves the aux level independently of the mic; confirm persistence across relaunch.
+
+- **Done (2026-06-23):** **Input-settings persistence, mic input gain, + two iOS bugs (all 3
+  clients).** Four fixes:
+  1. **Input settings now persist.** Transmission mode (VAD/PTT/Always-On), VAD threshold, and the
+     new mic gain were applied to the core + UI but never saved, so every relaunch reset to VAD
+     defaults. Each client now persists them and re-applies on connect: iOS via `UserDefaults`
+     (`SessionState.loadAndApplyVoiceSettings` + setter writes, keys `voice.*`); macOS via
+     `UserDefaults` (`MainWindowController` `didSet` + `loadPersistedAudioSettings`, also restores
+     the VAD slider from the stored threshold); Windows via new
+     `VoiceCat.App/Models/VoiceSettings.cs` (JSON at `%AppData%\VoiceCat\voice.json`, mirrors
+     `FeedbackSettings`) loaded/applied in `MainForm`.
+  2. **Microphone input gain.** New global send-side API `vc_set_input_gain` (voicecat.h →
+     `client.cpp::on_capture_frame`, applied to MIC PCM before the VAD gate, clamped to int16) plus
+     Swift (`setInputGain`) and C# (`SetInputGain`) bindings. Mic-volume slider (0–300 %, default
+     100 %) added to all three clients' input settings, persisted with the rest.
+  3. **iOS chat send fixed.** `ChatView` called `sendText(scope:.channel)` with no `targetId` (→ 0),
+     so channel messages went nowhere; now passes `session.currentChannelId`.
+  4. **iOS per-user tuning reachable via VoiceOver.** The tuning sheet was long-press
+     `.contextMenu` only (invisible to VoiceOver); `UserRow` now also exposes the same buttons as
+     `.accessibilityActions` (no visual change), so the actions rotor reaches tuning + admin actions.
+  - **Verified:** core `cmake --build --preset dev` clean; `ctest --preset dev` = 24/27 (the 3
+    failures — `external_pcm`, `frame_ms_reframe`, `channel_samplerate` — are a pre-existing
+    teardown crash on this machine, reproduced identically with the changes stashed). xcframework
+    rebuilt (`--all`); **VoiceCatMac** and **VoiceCatiOS** (arm64 sim) → BUILD SUCCEEDED;
+    `VoiceCat.Interop` (`dotnet build`) succeeded. **Windows App not built** (WinForms
+    net10.0-windows can't build on macOS) — changes follow existing patterns; needs a Windows
+    build + manual check.
+  - **Next (manual):** on each client, set PTT + non-default VAD/mic-gain, relaunch → settings
+    restored; boost a quiet mic and confirm others hear it louder; iOS send a channel message;
+    iOS VoiceOver → focus a user → actions rotor opens tuning.
+
+- **Done (2026-06-22):** **Fixed growing voice latency (jitter-buffer depth ratchet).** Symptom:
+  end-to-end latency grew to multiple seconds and "drifted backward," reset only by leaving/
+  rejoining voice (DTX/FEC/DRED on, 10% loss). Root cause was **not** the codec settings (10% loss
+  is just an `OPUS_SET_PACKET_LOSS_PERC` encoder hint; FEC/DRED add no standing latency) but the
+  receiver playout logic in `core/src/audio/audio_engine.cpp`: the playout clock free-ran in real
+  time while the sender omitted silence from its timestamps and set **no header flags at all**, and
+  the only correction snapped the clock to the *oldest* buffered frame (could only *add* latency) —
+  with `target_depth_ms_` computed but never enforced, so latency could only grow or be reset.
+  **Fix:** bounded-depth playout — (re)seed to the *leading edge* (newest frame) on start/marker/
+  starve, and **frame-skip catch-up** that trims a backlog beyond `target + hysteresis` (the missing
+  downward force). Plus hardening: adaptive late-drop window, talkspurt `kFlagMarker`/`kFlagDtx`
+  now actually stamped by the sender (`client.cpp` send path) and consumed on recv, EWMA outlier
+  rejection (silence gaps/stragglers no longer poison the estimate), duplicate counting, ring-
+  underrun diagnostics (`stream_underruns`/`stream_duplicates`). New regression test
+  `tests/test_jitter_depth.cpp` asserts depth stays bounded (<200 ms) while arrivals outrun playout
+  for ~4 s. `ctest --preset dev` green — **27/27**. Docs: `docs/voice.md` §5 rewritten.
+  - **Next (manual E2E):** two clients in a channel, DTX/FEC/DRED on — talk in alternating bursts
+    for several minutes and confirm latency stays low/stable (no backward drift, no rejoin needed).
+
+- **Windows done / Apple awaiting Mac build (2026-06-22):** **Event sound effects + optional
+  text-to-speech for all clients.** Clients now play a cue per session event and can optionally
+  speak it (TTS off by default; when on it announces joins/leaves and reads message/PM bodies).
+  One canonical event→sound mapping (defined off the shared C ABI `vc_event` stream) is mirrored
+  across all three clients; `self` vs others is `user_id == self_user_id`, and outgoing messages
+  echo back as events so sent/recv cues need no separate send-path hook. Conservative defaults
+  (join/leave, channel/PM sent+recv, login, logout, connection-lost, mic on/off ON; per-utterance
+  self voice-activity `va_start/va_stop` and the PTT cue OFF). WAVs ship from `assets/sounds/`.
+  - **Windows (built + verified):** new `VoiceCat.App/Notifications/` (`FeedbackSettings` →
+    `%AppData%\VoiceCat\feedback.json`, `SoundPlayerPool` via `System.Media.SoundPlayer`,
+    `SpeechAnnouncer` via the **Prismatoid** NuGet 0.3.0, `EventFeedback` dispatcher); hooks in
+    `Forms/MainForm.cs`; `Forms/NotificationSettingsForm.cs` under a new **Settings ▸ Notifications**
+    menu. `.csproj` adds the Prismatoid PackageRef and copies the WAVs into `sounds\`. `dotnet build`
+    clean; WAVs + `Prismatoid.dll` confirmed in output. Note: `SoundPlayer` has no gain control, so
+    volume is honoured as a mute gate (0 = silent) — swap to NAudio if finer/overlap control is needed.
+  - **macOS + iOS (written, NOT yet built — needs a Mac):** shared `Sources/VoiceCatCore/Feedback/`
+    (`SoundEvent`, `EventFeedback` = `AVAudioPlayer` pool + native `AVSpeechSynthesizer`,
+    `FeedbackSettings` over `UserDefaults`); WAVs copied into `Sources/VoiceCatCore/Sounds/` and
+    bundled via `Package.swift` `resources: [.process("Sounds")]` (`Bundle.module`). Hooks: iOS
+    `SessionState.handleEvent` (+ split `userJoined`/`userLeft`, added a `.disconnected` cue case),
+    `AppState` auth-success login cue, PTT cue in `setPushToTalk`; macOS `MainWindowController`
+    handlers + NSEvent PTT monitor. Settings UI: iOS `SettingsView` Notifications section
+    (`@AppStorage`), macOS `SettingsWindowController` checkboxes + volume slider. No `.pbxproj`
+    edits needed (shared files are SPM-managed; app files already in the projects).
+  - **Next:** on a Mac, `clients/apple/scripts/build-xcframework.sh --all` then build
+    VoiceCatMac/VoiceCatiOS; fix compile fallout. **Watch the iOS audio session:** cues/TTS play over
+    the live VPIO `playAndRecord` session — verify they mix and don't duck/interrupt the call or get
+    silenced by the mute switch (most likely bug site). Then run `ctest --preset dev` (unchanged —
+    no core/server code touched).
+
+- **Done (2026-06-22):** **UDP media now shares the TCP port (self-host port-forward fix).** Symptom: a
+  remote self-hosted server (`iamtalon.me:8384`, TCP+UDP 8384 forwarded) accepted TCP connections but
+  passed no voice. Root cause: `Config::media_port` defaulted to `0` = OS-assigned, and `main.cpp`'s
+  `--port` only set `bind_port` (TCP) — so the UDP relay bound a *random high port*, advertised it to
+  clients in HELLO (`udp_port`), and clients sent voice there. With only `8384/udp` forwarded those
+  packets were dropped → connect OK, no audio. This contradicted `docs/deployment.md` ("Control and media
+  share one port number on TCP+UDP"). **Fix (`server/src/server.cpp`):** media follows bind_port when
+  `media_port == 0` — `media_want = cfg_.media_port != 0 ? cfg_.media_port : cfg_.bind_port`. The
+  `0 = OS-assigned` escape hatch survives when `bind_port` is also 0, so tests that bind ephemeral ports
+  are unaffected (kept the logic in server.cpp rather than hardcoding 8384 as the default, which would
+  collide parallel tests on UDP 8384). Banner now reads `TCP :8384  UDP :8384`. Build + `ctest --preset
+  dev` green (24/24); live-verified banner with `--port 8390` → `UDP :8390`. **Action for self-hosters:**
+  redeploy and confirm the startup banner shows matching TCP/UDP ports; the existing single forward rule
+  is now correct. If voice still fails, watch the server's rate-limited `[media] dropped frames —
+  unmapped-endpoint=…` line (NAT source-port rewrite would be the next suspect).
+
+- **Done (2026-06-23, Swift-only — no core/ABI change; awaiting on-device verification):** **iOS audio
+  stack unified — one always-external `AVAudioEngine`, miniaudio dropped on iOS.** The iOS audio path was
+  a fragile hybrid: Voice-Chat-class presets ran a native VPIO `AVAudioEngine` (core external) while
+  Stereo/Studio/A2DP presets ran the core's miniaudio devices. Nearly every bug lived in the seam
+  (lingering miniaudio capture unit fighting VPIO, the `audioRestart` ordering dance, the route-change
+  "glitching" loop, stereo↔mono stickiness, "can't hear anyone"), and switching presets/routes mid-call
+  routinely dropped input, output, or both. **Fix: drive *all* iOS audio through one `AVAudioEngine` with
+  the core fully external at all times** — `vc_set_external_playback(1)` once at connect, every MIC stream
+  `external_feed=1`, mic via `vc_stream_feed_pcm`, playback via `vc_set_mixed_output_sink`.
+  - `IOSVoiceProcessingEngine.swift` → **`IOSAudioEngine`** (same file): always-on `AVAudioSourceNode`
+    playback (runs whenever connected, so remote audio plays before you join voice); conditional mic tap;
+    VPIO + AGC toggled per config. One private `rebuild()` (stop → set VPIO → install tap → start) backs
+    `startListening`/`stop`/`startMic`/`stopMic`/`reconfigure`/`setCaptureChannels`. Kept the `PCMRing`
+    and ring-stats diagnostics.
+  - `IOSAudioRouter`: presets cut from seven to **four** — Voice Chat (VPIO mono, system output),
+    Stereo Mic / Mono Mic (internal built-in mic regardless of output, A2DP-capable, no VPIO), Advanced
+    (manual). New persisted `voiceProcessingEnabled` (master AEC+NS) + `agcEnabled`; setters now call
+    `IOSAudioEngine.reconfigure()` instead of `client.audioRestart()` + `reconcileVoicePath`. Kept the
+    proven AVAudioSession recipes (category/mode/options, stereo capsule, `applyA2dpSpeakerFallback`).
+  - `AudioSessionManager` slimmed (drops `client`/`activeMicStreamId`/`reconcileVoicePath`; adds
+    `isActive`); interruption-end & device-change now `reconfigure()` the engine. `SessionState`
+    `doStartMicStream`/`stopMicStream` collapsed to start-stream + `startMic`/`stopMic` (no
+    `setExternalPlayback`/`audioRestart` toggling); `reconcileVoicePath` deleted. `AppState` sets external
+    playback + `startListening` at connect, `stop()` at disconnect. `SettingsView` → four presets +
+    Advanced VPIO/AGC toggles.
+  - **No core/ABI/test change** — relies on the already-shipped `vc_set_external_playback` /
+    `external_feed` / `vc_set_mixed_output_sink` / `vc_stream_feed_pcm` path (`test_external_pcm`,
+    `test_external_playback`). `xcodebuild` iOS device Debug **BUILD SUCCEEDED**. **Rebuild the
+    xcframework is NOT required** (no new symbols).
+  - **Next (user, on device):** two iPhones in a channel — verify BOTH directions survive every
+    transition and are never silent unless intended: Voice Chat (no echo, NR), listen-only before joining,
+    join↔leave repeatedly, switch Voice Chat↔Stereo↔Mono↔Advanced *while in voice*, A2DP connect/unplug,
+    wired connect/unplug, phone-call interruption + resume, screen-audio share.
+
+- **Superseded by the 2026-06-23 unification above (2026-06-22):** **iOS real echo cancellation / noise
+  suppression via native VPIO.** Root cause of "voice chat doesn't sound like a call" (echo + no NR): real iOS
   AEC/NS/AGC come only from Apple's Voice-Processing I/O unit (VPIO), but the core uses miniaudio's
   plain RemoteIO units — so `.voiceChat` mode alone never engaged AEC. Fix moves both mic capture and
   playback to a native Swift `AVAudioEngine` (`setVoiceProcessingEnabled`) on the AEC presets, with the
@@ -148,6 +630,21 @@ up instantly. Newest status at the top.
   SUCCEEDED (sim slice still arm64-only → simulator run N/A). Next: on-device check of the
   drill-down + compose box + unified timeline.
 
+- **Done (2026-06-22):** **Windows exclude mode is now a real native exclude + self-echo
+  removal.** The "All apps except selected" mode previously captured the *complement of a frozen
+  app snapshot* in INCLUDE mode (missed late-launched apps, system sounds; wasted captures on
+  silent windows). It now opens a **single `ProcessLoopbackCapture` in EXCLUDE mode**
+  (`AUDIOCLIENT_PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE`) of the one chosen app — true
+  system-mix-minus-one, dynamic. `AppAudioPickerDialog` enforces single-selection in exclude
+  mode (the API takes one target PID). Added an **"Exclude VoiceCat's own audio (prevents echo)"**
+  checkbox (default on, entire-desktop only) that routes the desktop capture through the same
+  EXCLUDE path targeting `Environment.ProcessId`, killing the whole-device self-echo loop.
+  Touched `ProcessAudioMixer.cs` (`ResolveCaptures`), `AppAudioPickerDialog.cs`, `MainForm.cs`,
+  `AudioSessionEnumerator.cs` (`EntireDesktop(bool ExcludeSelf)`); docs in voice.md §9. No C++ /
+  ABI changes. `dotnet build` clean. **Still to verify on-device:** exclude actually silences
+  the chosen app while the rest plays, late-launched apps appear without restart, and the
+  self-exclude checkbox removes the echo.
+
 - **Done (2026-06-21):** **Screen-audio sharing on macOS + iOS.** macOS uses ScreenCaptureKit
   (`ScreenAudioCapture.swift`) → `vc_stream_feed_pcm`; iOS uses a ReplayKit Broadcast Upload
   Extension (`VoiceCatBroadcast`) that forwards captured `.audioApp` PCM through a shared App
@@ -381,7 +878,33 @@ up instantly. Newest status at the top.
 
 ## Recent completed work
 
-All items below are `[x]` done; `ctest --preset dev` 23/23 on Windows after all.
+All items below are `[x]` done; `ctest --preset dev` 26/26 on Windows after all.
+
+- **Per-channel sample_rate as a bandwidth cap** (2026-06-22): the channel `sample_rate` field
+  was inert (the codec is pinned to 48 kHz). Made it meaningful without changing the 48 kHz
+  clock: it's carried as `OpusParams::max_bandwidth_hz` and applied via `OPUS_SET_MAX_BANDWIDTH`
+  in `OpusEncoder::init` (8000→narrowband … 48000→full). Made it **channel-authoritative** on
+  the server (`conn_session.cpp` no longer overrides effective `sample_rate` with the client's
+  always-48000 request — like `frame_ms`/`mode`). `vc_get_stream_audio_config` now reports the
+  channel's configured rate for own streams too. New ctest `channel_samplerate`: a 7 kHz tone is
+  attenuated ~1000× on an 8 kHz channel vs a 48 kHz channel. Files: `opus_codec.{h,cpp}`,
+  `client.cpp`, `server/src/conn_session.cpp`, `docs/voice.md`, `tests/test_channel_samplerate.cpp`,
+  `tests/CMakeLists.txt`. (Future: a true non-48k stack is possible but unnecessary — 48 kHz is
+  what nearly all hard/software runs at; the bandwidth cap covers the narrowband use case.)
+
+- **Non-20ms channel frame_ms fix** (2026-06-22): the AudioEngine capture clock is fixed at
+  48 kHz / 20 ms (960-sample frames), but a channel may set any Opus `frame_ms` (2.5…60 ms,
+  docs/voice.md §3) and the server enforces it unclamped. The send path handed the engine's
+  960-sample frame straight to an encoder configured for the channel's window — silently
+  ignoring `frame_ms > 20` and **breaking `frame_ms < 20` entirely** (receiver sized its decode
+  buffer too small → `OPUS_BUFFER_TOO_SMALL` → dead audio). Affected the hardware mic AND
+  `vc_stream_feed_pcm`. Fix: `vc_client::on_capture_frame` now reframes each captured/fed block
+  to `ls.frame_samples` via a per-`LocalStream` accumulator (pre-sized at announce, no RT-thread
+  alloc) before `encode_and_send_frame`; the 20 ms case stays a zero-copy fast path. Also pinned
+  the codec to 48 kHz internally in `opus_params_from_audio_config` (was honoring a non-48k
+  effective sample_rate against a 48k PCM clock). New ctest `frame_ms_reframe` (40 ms accumulate
+  + 10 ms split round trips). Files: `client.{h,cpp}`, `voicecat.h` (feed doc), `docs/voice.md`,
+  `tests/test_frame_ms_reframe.cpp`, `tests/CMakeLists.txt`.
 
 - **External PCM feed/tap API** (2026-06-20): `vc_stream_feed_pcm` + `vc_set_pcm_sink` shipped.
   Promotes `vc_test_inject_capture` (mono-only, TEST-ONLY) to a public, stereo-capable API.
@@ -547,7 +1070,8 @@ text, device pickers, level meter on each platform.
 
 **Windows** (`clients/windows/`): `VoiceCat.Interop` (P/Invoke, `[UnmanagedCallersOnly]`),
 `VoiceCat.App` (ConnectDialog, ServerIdentityDialog, MainForm with full M5 moderation UI,
-PerUserTuningDialog, PttKeyCaptureDialog), `VoiceCat.Interop.Tests`. PTT is focus-scoped.
+PerUserTuningDialog, PttKeyCaptureDialog), `VoiceCat.Interop.Tests`. PTT can be system-wide
+(Raw Input / WM_INPUT) or focus-scoped, toggled in Audio settings (default system-wide).
 
 **macOS** (`clients/apple/macOS/VoiceCatMac.xcodeproj`): NSOutlineView channel tree,
 NSTableView user list, NSTextView chat, voice controls, full VoiceOver accessibility, admin
@@ -585,6 +1109,14 @@ iOS 18.0 deployment target. App Group `group.cat.voice.VoiceCat` for Keychain sh
   reconstructs the lost frame — otherwise falls back to standard PLC. New test:
   `test_dred_toggle` (ctest 22/22). Files: `voicecat.proto`, `voicecat.h`,
   `opus_codec.{h,cpp}`, `audio_engine.{h,cpp}`, `client.cpp`, `session.{h,cpp}`.
+- [x] **In-band FEC decoder wiring** — done (2026-06-22). The encoder set `OPUS_SET_INBAND_FEC`
+  all along, but the decoder never invoked it — the loss path went DRED → PLC, so FEC redundancy
+  was emitted (and paid for in bitrate) but never consumed. Wired the FEC recovery into
+  `AudioEngine::on_playback`'s loss branch between DRED and PLC: copy the next buffered packet
+  once, try DRED, else (if the stream negotiated FEC) `decode(next_pkt, …, fec=true)`, else PLC.
+  Added per-stream `RemoteStream::fec_enabled_`, captured from `OpusParams` in
+  `init_recv_stream`. Recovery priority is now **DRED → FEC → PLC**. ctest 27/27 green. Files:
+  `audio_engine.{h,cpp}`, `docs/voice.md`.
 - [ ] **DRED toggle in client UIs** — expose the `dred` flag in all three channel-config UIs
   so admins can enable it per channel. Windows: `ChannelEditForm` / `vc_channel_info.audio.dred`
   checkbox. macOS AppKit: channel-edit sheet. iOS SwiftUI: channel-edit form. All three UIs

README.md

@@ -23,9 +23,9 @@ The default development preset is **`dev`** — it builds everything (server + t
 with real vcpkg deps. It works on Windows, Linux, and macOS (vcpkg triplet auto-resolved).
 
 ```bash
-# one-time vcpkg setup:
+# one-time vcpkg setup (bundled as a submodule, pinned to vcpkg.json's builtin-baseline):
-git clone https://github.com/microsoft/vcpkg && ./vcpkg/bootstrap-vcpkg.sh  # .bat on Windows
+git submodule update --init vcpkg
-export VCPKG_ROOT=/path/to/vcpkg            # Linux/macOS; or $env:VCPKG_ROOT on PowerShell
+./vcpkg/bootstrap-vcpkg.sh                  # .bat on Windows
 
 # configure + build + test:
 cmake --preset dev
@@ -33,6 +33,9 @@ cmake --build --preset dev
 ctest --preset dev                          # 21 behavior tests
 ```
 
+To use an external vcpkg checkout instead, set `VCPKG_ROOT=/path/to/vcpkg` (or
+`$env:VCPKG_ROOT` on PowerShell) — it always takes priority over the bundled submodule.
+
 Artifacts land in `build/dev/bin/` (`voicecat-server`, `vccli`, `voicecat-admin`).
 
 The `skeleton` preset (no vcpkg deps, stubs only) is a fast smoke check that needs no

clients/apple/Package.swift

@@ -40,7 +40,11 @@ let package = Package(
         .target(
             name: "VoiceCatCore",
             dependencies: ["VoiceCatCoreXCF"],
-            path: "Sources/VoiceCatCore"
+            path: "Sources/VoiceCatCore",
+            // Event-cue WAVs (shared with the Windows client) bundled into the package's
+            // resource bundle; EventFeedback loads them via Bundle.module. Copied from
+            // assets/sounds/ into Sources/VoiceCatCore/Sounds/.
+            resources: [.process("Sounds")]
         ),
         // Smoke tests against a real voicecat-server — mirrors clients/windows/
         // VoiceCat.Interop.Tests/VoiceCatClientSmokeTests.cs. Requires the `dev` CMake preset

clients/apple/README.md

@@ -106,12 +106,16 @@ scripts/build-xcframework.sh --all
 
 The `apple-dev` CMake preset produces a 1.9 MB `libvoicecat.a` containing only voicecat's
 own object files — vcpkg's static dependencies (protobuf, mbedtls, libsodium, opus, sqlite3,
-spdlog, asio, abseil, …) are 107 separate `.a` files under `vcpkg_installed/arm64-osx/lib/`.
+spdlog, asio, abseil, …) are 107 separate `.a` files under `vcpkg_installed/arm64-osx/lib/`,
-A Swift Package binary target can only link ONE `.a` per XCFramework slice, so
+and the vendored RNNoise noise-suppression lib (`third_party/rnnoise/`, built as a CMake
-`build-xcframework.sh` merges them all into a single self-contained `libvoicecat-fat.a`
+target → `build/<preset>/lib/librnnoise.a`) is another. A Swift Package binary target can
-(~30 MB) using `libtool -static`. This is the Apple equivalent of how the Windows client
+only link ONE `.a` per XCFramework slice, so `build-xcframework.sh` merges them all — vcpkg
+deps plus the locally-built vendored libs — into a single self-contained `libvoicecat-fat.a`
+(~33 MB) using `libtool -static`. This is the Apple equivalent of how the Windows client
 ships a single `voicecat.dll` with all deps statically linked (via MinGW's `-static` flags
-in [`core/CMakeLists.txt`](../../core/CMakeLists.txt)).
+in [`core/CMakeLists.txt`](../../core/CMakeLists.txt)). If you add another vendored (non-vcpkg)
+static-lib target to the core, it's picked up automatically as long as it lands in
+`build/<preset>/lib/` and isn't named `libvoicecat*`.
 
 ### Swift Package
 

clients/apple/Sources/VoiceCatCore/Callbacks.swift

@@ -1,19 +1,5 @@
-// Callbacks — the C function pointers passed to `vc_callbacks`. These are the Swift
+// C callbacks use an unretained `user` context. Client destruction joins callback threads,
-// equivalent of the C# client's `[UnmanagedCallersOnly]` static methods (NativeCallbacks.cs).
+// and transient event pointers are copied before the callback returns.
-//
-// The critical patterns (carried over from the proven C# implementation):
-//   1. `@convention(c)` closures — plain C function pointers, NOT GC/ARC-managed closures.
-//      A @convention(c) closure cannot capture context, which is why the `user` pointer is
-//      used to resolve back to the VoiceCatClient instance (the C# version uses GCHandle for
-//      the same thing; Swift uses Unmanaged).
-//   2. `Unmanaged.passUnretained(self).toOpaque()` as the `user` context — a stable raw
-//      pointer to the Swift object WITHOUT incrementing the retain count. This is safe
-//      because `deinit` calls `vc_client_destroy` (which synchronously joins every internal
-//      thread) BEFORE the object's memory is freed — so no callback can fire after the object
-//      is gone. (The C# equivalent: GCHandle.Alloc + GCHandle.Free in Dispose.)
-//   3. Copy `ev.text` to a Swift `String` INSIDE `onEvent` (via `VoiceCatEvent.from(_:)`)
-//      before returning — the raw pointer is dangling after the callback returns. This is
-//      the #1 lifetime rule from voicecat.h's vc_event doc comment.
 
 import VoiceCatC
 import Foundation

clients/apple/Sources/VoiceCatCore/Enums.swift

@@ -61,7 +61,7 @@ public enum VoiceCatConnectionState: UInt32, Sendable, Equatable {
     case tlsHandshake = 2
     case authenticating = 3
     case connected = 4
-    /// M4: handshake succeeded, waiting on `confirmServerIdentity()`.
+    /// Handshake succeeded, waiting on `confirmServerIdentity()`.
     case verifyingIdentity = 5
 
     public init(_ cValue: vc_connection_state) {
@@ -125,14 +125,16 @@ public enum VoiceCatEventType: UInt32, Sendable, Equatable {
     case talkState = 9
     case error = 10
     case disconnected = 11
-    /// M4: reply to `joinChannel()` — see `VoiceCatEvent.result` / `.channelId`.
+    /// Reply to `joinChannel()` — see `VoiceCatEvent.result` / `.channelId`.
     case joinResult = 12
-    /// M4: the TOFU server-identity gate — see `VoiceCatEvent.tofuStatus` / `.text`.
+    /// The TOFU server-identity gate — see `VoiceCatEvent.tofuStatus` / `.text`.
     case serverIdentity = 13
-    /// M5: async result for moderation/admin/channel operations.
+    /// Async result for moderation/admin/channel operations.
     case genericResult = 14
-    /// M5: reply to `requestAccountList()` — call `listAccounts()` to read.
+    /// Reply to `requestAccountList()` — call `listAccounts()` to read.
     case accountList = 15
+    /// Voice-plane subscription state. `u32a` = 1 (subscribed) or 0 (unsubscribed).
+    case voiceState = 16
 
     public init(_ cValue: vc_event_type) {
         self = VoiceCatEventType(rawValue: cValue.rawValue) ?? .error

clients/apple/Sources/VoiceCatCore/Feedback/EventFeedback.swift

@@ -0,0 +1,105 @@
+// EventFeedback — shared audible + spoken feedback for session events, used by both the macOS
+// (AppKit) and iOS (SwiftUI) clients. Mirrors the Windows client's EventFeedback policy
+// (clients/windows/.../Notifications/EventFeedback.cs): the platform event handlers decide WHAT
+// to play (they own the model/nickname/channel context); this type owns the "should I, and how"
+// policy plus the AVFoundation playback/synthesis.
+//
+// Sound effects use AVAudioPlayer; spoken announcements use the OS-native AVSpeechSynthesizer.
+//
+// NOTE (iOS): on the voice path the app runs a play-and-record AVAudioSession (VPIO). Playing
+// these cues / speech over that session can interact with the live call (ducking, route, or the
+// mute switch). The session category should allow mixing — verify on device. This is the most
+// likely place for platform bugs to surface.
+
+import Foundation
+import AVFoundation
+
+/// User preferences for event sounds and spoken feedback, backed by UserDefaults so the macOS
+/// and iOS settings screens and this player share one source of truth.
+public struct FeedbackSettings: Sendable {
+    public var sounds: Bool
+    public var speech: Bool
+    public var volume: Float
+    public var selfTalkSounds: Bool
+    public var pttSound: Bool
+
+    static let keySounds = "feedback.sounds"
+    static let keySpeech = "feedback.speech"
+    static let keyVolume = "feedback.volume"
+    static let keySelfTalk = "feedback.selfTalk"
+    static let keyPtt = "feedback.ptt"
+
+    /// Default values registered with UserDefaults (so "unset" reads as the intended default
+    /// rather than false/0).
+    static let defaults: [String: Any] = [
+        keySounds: true,
+        keySpeech: false,
+        keyVolume: 1.0,
+        keySelfTalk: false,
+        keyPtt: false,
+    ]
+
+    /// The current settings, read live from UserDefaults.
+    public static var current: FeedbackSettings {
+        let d = UserDefaults.standard
+        d.register(defaults: defaults)  // idempotent — ensures "unset" reads as the intended default
+        return FeedbackSettings(
+            sounds: d.bool(forKey: keySounds),
+            speech: d.bool(forKey: keySpeech),
+            volume: d.float(forKey: keyVolume),
+            selfTalkSounds: d.bool(forKey: keySelfTalk),
+            pttSound: d.bool(forKey: keyPtt))
+    }
+}
+
+@MainActor
+public final class EventFeedback {
+    public static let shared = EventFeedback()
+
+    private var players: [SoundEvent: AVAudioPlayer] = [:]
+    private let synthesizer = AVSpeechSynthesizer()
+
+    private init() {
+        UserDefaults.standard.register(defaults: FeedbackSettings.defaults)
+    }
+
+    // MARK: - Sounds
+
+    /// Play an event cue, honouring the user's settings. The two opt-in categories (your own
+    /// voice-activity, and the PTT cue) are gated by their own flags.
+    public func play(_ event: SoundEvent) {
+        let s = FeedbackSettings.current
+        guard s.sounds, s.volume > 0 else { return }
+        if (event == .vaStart || event == .vaStop), !s.selfTalkSounds { return }
+        if event == .ptt, !s.pttSound { return }
+
+        guard let player = player(for: event) else { return }
+        player.volume = s.volume
+        player.currentTime = 0
+        player.play()
+    }
+
+    /// Lazily load and cache an AVAudioPlayer for the event's bundled WAV. Returns nil (silent)
+    /// if the resource is missing or fails to load.
+    private func player(for event: SoundEvent) -> AVAudioPlayer? {
+        if let cached = players[event] { return cached }
+        guard let url = Bundle.module.url(forResource: event.resourceName, withExtension: "wav"),
+              let player = try? AVAudioPlayer(contentsOf: url) else {
+            return nil
+        }
+        player.prepareToPlay()
+        players[event] = player
+        return player
+    }
+
+    // MARK: - Speech
+
+    /// Speak `text` when spoken feedback is enabled. Utterances queue (do not interrupt prior
+    /// speech) so a burst of events is read in order.
+    public func speak(_ text: String) {
+        guard FeedbackSettings.current.speech else { return }
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return }
+        synthesizer.speak(AVSpeechUtterance(string: trimmed))
+    }
+}

clients/apple/Sources/VoiceCatCore/Feedback/SoundEvent.swift

@@ -0,0 +1,43 @@
+// SoundEvent — the cross-platform set of audible event cues. Each maps to a WAV bundled as an
+// SPM resource (Sources/VoiceCatCore/Sounds/, copied from assets/sounds/). The same logical set
+// is mirrored in the Windows client (clients/windows/.../Notifications/SoundEvent.cs) so feedback
+// stays consistent across platforms.
+
+import Foundation
+
+public enum SoundEvent: CaseIterable, Sendable {
+    case channelJoin    // another user joined my channel
+    case channelLeave   // another user left my channel
+    case channelRecv    // channel text message from someone else
+    case channelSent    // channel text message I sent
+    case pmRecv         // private message received
+    case pmSent         // private message I sent
+    case login          // connected / authenticated
+    case logout         // clean disconnect
+    case connectionLost // unexpected disconnect
+    case voiceOn        // my microphone stream started
+    case voiceOff       // my microphone stream stopped
+    case vaStart        // my voice-activity began (off by default)
+    case vaStop         // my voice-activity ended (off by default)
+    case ptt            // push-to-talk engaged (off by default)
+
+    /// Resource name (without extension) as bundled in Sources/VoiceCatCore/Sounds/.
+    var resourceName: String {
+        switch self {
+        case .channelJoin:    return "channel_join"
+        case .channelLeave:   return "channel_leave"
+        case .channelRecv:    return "channel_recv"
+        case .channelSent:    return "channel_sent"
+        case .pmRecv:         return "pm_recv"
+        case .pmSent:         return "pm_sent"
+        case .login:          return "login"
+        case .logout:         return "logout"
+        case .connectionLost: return "connection_lost"
+        case .voiceOn:        return "voice_on"
+        case .voiceOff:       return "voice_off"
+        case .vaStart:        return "va_start"
+        case .vaStop:         return "va_stop"
+        case .ptt:            return "ptt"
+        }
+    }
+}

clients/apple/Sources/VoiceCatCore/Marshaling.swift

@@ -38,7 +38,8 @@ internal enum Marshaling {
             let c = items.advanced(by: i).pointee
             result.append(Channel(id: c.id, parentId: c.parent_id, name: string(c.name),
                                   topic: string(c.topic), passwordProtected: c.password_protected != 0,
-                                  maxUsers: c.max_users))
+                                  maxUsers: c.max_users, sortOrder: c.sort_order,
+                                  audio: audioConfig(c.audio)))
         }
         vc_free_channel_list(&list)
         return result
@@ -53,7 +54,8 @@ internal enum Marshaling {
             result.append(User(id: u.id, nickname: string(u.nickname), isGuest: u.is_guest != 0,
                                channelId: u.channel_id, selfMicMuted: u.self_mic_muted != 0,
                                selfDeafened: u.self_deafened != 0, serverMuted: u.server_muted != 0,
-                               serverDeafened: u.server_deafened != 0))
+                               serverDeafened: u.server_deafened != 0,
+                               voiceSubscribed: u.voice_subscribed != 0))
         }
         vc_free_user_list(&list)
         return result

clients/apple/Sources/VoiceCatCore/Models.swift

@@ -16,11 +16,17 @@ public struct Channel: Sendable, Equatable, Identifiable {
     public let passwordProtected: Bool
     /// 0 = unlimited.
     public let maxUsers: UInt32
+    public let sortOrder: UInt32
+    /// Authoritative channel Opus params (docs/voice.md §3). Populated from the Channel proto
+    /// so the edit dialog can read back the current config.
+    public let audio: AudioConfig
 
     public init(id: UInt32, parentId: UInt32, name: String, topic: String,
-                passwordProtected: Bool, maxUsers: UInt32) {
+                passwordProtected: Bool, maxUsers: UInt32, sortOrder: UInt32,
+                audio: AudioConfig) {
         self.id = id; self.parentId = parentId; self.name = name; self.topic = topic
         self.passwordProtected = passwordProtected; self.maxUsers = maxUsers
+        self.sortOrder = sortOrder; self.audio = audio
     }
 }
 
@@ -57,17 +63,19 @@ public struct User: Sendable, Equatable, Identifiable {
     public let selfDeafened: Bool
     public let serverMuted: Bool
     public let serverDeafened: Bool
+    public let voiceSubscribed: Bool
 
     public init(id: UInt32, nickname: String, isGuest: Bool, channelId: UInt32,
                 selfMicMuted: Bool, selfDeafened: Bool, serverMuted: Bool,
-                serverDeafened: Bool) {
+                serverDeafened: Bool, voiceSubscribed: Bool) {
         self.id = id; self.nickname = nickname; self.isGuest = isGuest; self.channelId = channelId
         self.selfMicMuted = selfMicMuted; self.selfDeafened = selfDeafened
         self.serverMuted = serverMuted; self.serverDeafened = serverDeafened
+        self.voiceSubscribed = voiceSubscribed
     }
 }
 
-/// Permission bitset — mirrors `vc_permissions` (M5).
+/// Permission bitset — mirrors `vc_permissions`.
 public struct Permissions: Sendable, Equatable {
     public let canCreateTempChannel: Bool
     public let canKick: Bool
@@ -83,7 +91,7 @@ public struct Permissions: Sendable, Equatable {
     }
 }
 
-/// Account entry — mirrors `vc_account` (M5, reply to `listAccounts()`).
+/// Account entry — mirrors `vc_account` (reply to `listAccounts()`).
 public struct Account: Sendable, Equatable {
     public let username: String
     public let isAdmin: Bool

clients/apple/Sources/VoiceCatCore/VoiceCatClient.swift

@@ -1,36 +1,6 @@
-// VoiceCatClient — the public, Swift-idiomatic surface over libvoicecat. This is the Swift
+// Swift binding invariants: native config strings outlive the handle, destroy joins callback
-// analog of the C# client's `VoiceCatClient.cs` (clients/windows/VoiceCat.Interop).
+// threads before deallocation, and callback payloads are copied before main-queue delivery.
-//
+// See docs/architecture.md §4 for the complete binding contract.
-// Key patterns carried over from the proven C# implementation (see docs/architecture.md §4
-// per-platform binding notes):
-//
-//   1. HANDLE OWNERSHIP: the class owns `vc_client*`; `deinit` calls `vc_client_destroy`
-//      (which synchronously joins every internal thread, so nothing can still be reading the
-//      config-string pointers or firing callbacks by the time it returns).
-//
-//   2. CONFIG STRING LIFETIMES: the core stores raw pointers from `vc_config` by value — it
-//      does NOT copy the string data. `client_name`/`client_version`/`tofu_store_path` are
-//      read later, whenever `connect()` actually runs on the io_thread_. So the native CString
-//      storage (`_clientNamePtr` etc.) must outlive the WHOLE client, not just `init`. It's
-//      freed in `deinit`, AFTER `vc_client_destroy` has returned. (C#: Marshal.StringToCoTask
-//      MemUTF8 in ctor, FreeCoTaskMem in Dispose after destroy.)
-//
-//   3. EVENT DELIVERY THREAD HANDOFF: `on_event` fires on the core's event thread. Events are
-//      buffered in a lock-protected array and drained on `DispatchQueue.main` — this is the
-//      boundary where the core's thread hands off to the UI thread. The C# analog is
-//      `Channel<VoiceCatEvent>` drained by a 30ms WinForms Timer; the Swift analog is a
-//      coalesced main-queue drain (only one async block scheduled at a time). `on_event`'s
-//      `text` is copied to a Swift `String` inside the callback (Callbacks.swift) before
-//      enqueueing — the raw pointer is dangling by the time the main thread drains.
-//
-//   4. LEVEL METER COALESCING: `on_level` fires far more often than `on_event` and
-//      intermediate values are visually irrelevant — coalesced to "latest sample per
-//      stream_id" in a lock-protected dictionary, drained on main alongside events.
-//      (C#: ConcurrentDictionary<uint,float> cleared in PumpEvents.)
-//
-//   5. IMMEDIATE vc_free_* ON LIST READS: `listChannels()`/`listUsers()`/etc. walk the native
-//      array, convert to Swift value types, and call `vc_free_*_list` INSIDE the function —
-//      callers never manage native list lifetime. (C#: Marshaling.ToManaged does the same.)
 
 import VoiceCatC
 import Foundation
@@ -56,26 +26,14 @@ public final class VoiceCatClient {
 
     // MARK: - Stored properties
 
-    /// The opaque C handle (`vc_client*` — Swift imports the incomplete C struct as
-    /// `OpaquePointer`). Set in `init`, passed to every C function, destroyed in `deinit`.
     private var handle: OpaquePointer?
 
-    /// Unmanaged pointer to `self` — passed as `vc_callbacks.user` so the C function-pointer
+    /// Unretained callback context; destroying the handle joins callback threads first.
-    /// callbacks can resolve back to this instance. `passUnretained` (not `passRetained`)
-    /// because we want normal ARC to control the object's lifetime — `deinit` calls
-    /// `vc_client_destroy` (joins all threads) before the object's memory is freed, so no
-    /// callback can fire with a dangling `user` pointer. See Callbacks.swift.
-    ///
-    /// Computed (not stored) to break a circular init dependency: it needs `self`, but
-    /// stored properties must be initialized before `self` is available. `Unmanaged.passUn
-    /// retained(self).toOpaque()` always returns the same address for a given instance, so
-    /// computing it on demand is safe and consistent.
     private var selfPointer: UnsafeMutableRawPointer {
         Unmanaged.passUnretained(self).toOpaque()
     }
 
-    /// Native CString storage backing `vc_config` — must outlive the whole client (the core
+    /// The core retains these pointers for the handle's lifetime.
-    /// stores raw pointers, doesn't copy). Freed in `deinit` after `vc_client_destroy`.
     private var clientNamePtr: UnsafeMutablePointer<CChar>?
     private var clientVersionPtr: UnsafeMutablePointer<CChar>?
     private var tofuStorePathPtr: UnsafeMutablePointer<CChar>?
@@ -90,7 +48,6 @@ public final class VoiceCatClient {
     /// Intermediate values are coalesced (only the latest per stream_id is delivered).
     public var onLevel: ((UInt32, Float) -> Void)?
 
-    /// Lock-protected buffers, written from the core's event thread, drained on main.
     private let bufferLock = NSLock()
     private var eventBuffer: [VoiceCatEvent] = []
     private var levelSamples: [UInt32: Float] = [:]
@@ -98,19 +55,12 @@ public final class VoiceCatClient {
 
     // MARK: - Init / deinit
 
-    /// Create a client. `config.clientName`/`clientVersion`/`tofuStorePath` are copied to
-    /// native CString storage held for the client's entire lifetime (the core reads them
-    /// later, e.g. when `connect()` runs on the io thread).
     public init(config: VoiceCatConfig) {
-        // Allocate native C strings — must persist until after vc_client_destroy in deinit.
-        // These don't need `self`, so they're safe to set first.
         self.clientNamePtr = strdup(config.clientName)
         self.clientVersionPtr = strdup(config.clientVersion)
         self.tofuStorePathPtr = config.tofuStorePath.flatMap { strdup($0) }
         self.handle = nil  // placeholder — set below after callbacks are wired
 
-        // All stored properties are now initialized → `self` is fully available, so we can
-        // call `selfPointer` (the computed property) to build the callbacks struct.
         var nativeConfig = vc_config()
         nativeConfig.client_name = UnsafePointer(clientNamePtr)
         nativeConfig.client_version = UnsafePointer(clientVersionPtr)
@@ -219,7 +169,7 @@ public final class VoiceCatClient {
         VoiceCatResult(vc_authenticate_user(handle, username, password))
     }
 
-    // MARK: - TOFU server-identity gate (M4)
+    // MARK: - TOFU server-identity gate
 
     /// Accept or reject the pending server-identity check. Call after a `.serverIdentity`
     /// event. `accept=true` on firstConnect/mismatch updates the pin file and proceeds;
@@ -256,6 +206,16 @@ public final class VoiceCatClient {
         VoiceCatResult(vc_leave_channel(handle))
     }
 
+    @discardableResult
+    public func joinVoice() -> VoiceCatResult {
+        VoiceCatResult(vc_join_voice(handle))
+    }
+
+    @discardableResult
+    public func leaveVoice() -> VoiceCatResult {
+        VoiceCatResult(vc_leave_voice(handle))
+    }
+
     /// Pull the current channel tree. Re-call after `.channelList`/`.userJoined`/`.userLeft`/
     /// `.userUpdated` events. The native list is freed inside this call — callers never
     /// manage native lifetime.
@@ -403,12 +363,29 @@ public final class VoiceCatClient {
 
     /// Global playback volume applied after mixing all remote streams. gain 0.0 = silent,
     /// 1.0 = unity (default), >1.0 amplifies. Always LOCAL — no protocol traffic. Mirrors the
-    /// Windows client's `SetOutputVolume` and the C ABI `vc_set_output_volume` added in M5.
+    /// Windows client's `SetOutputVolume` and the C ABI `vc_set_output_volume`.
     @discardableResult
     public func setOutputVolume(_ gain: Float) -> VoiceCatResult {
         VoiceCatResult(vc_set_output_volume(handle, gain < 0 ? 0 : gain))
     }
 
+    /// Send-side microphone input gain. Applied to captured MIC PCM before the VAD/PTT gate and
+    /// Opus encode (so boosting a quiet mic also helps it cross the VAD threshold). gain 0.0 =
+    /// silent, 1.0 = unity (default), >1.0 amplifies (clamped to int16). Always LOCAL.
+    @discardableResult
+    public func setInputGain(_ gain: Float) -> VoiceCatResult {
+        VoiceCatResult(vc_set_input_gain(handle, gain < 0 ? 0 : gain))
+    }
+
+    /// Send-side microphone noise suppression (RNNoise). Denoises captured MIC PCM before the
+    /// input gain and VAD/PTT gate, so everyone hears the cleaned signal (one pass for all
+    /// listeners). MIC stream only, mono only; always LOCAL — no protocol traffic. Independent
+    /// of the per-listener receive-side NR in `setRemoteStream` (docs/voice.md §10).
+    @discardableResult
+    public func setInputNoiseReduction(_ enable: Bool) -> VoiceCatResult {
+        VoiceCatResult(vc_set_input_noise_reduction(handle, enable ? 1 : 0))
+    }
+
     // MARK: - AVAudioSession interruption hooks (iOS)
 
     /// Pause miniaudio device I/O. Call when AVAudioSession interruption begins.
@@ -473,7 +450,7 @@ public final class VoiceCatClient {
         return Marshaling.devices(&native)
     }
 
-    // MARK: - M5: Moderation
+    // MARK: - Moderation
 
     @discardableResult
     public func kickUser(_ userId: UInt32, reason: String? = nil) -> VoiceCatResult {
@@ -508,7 +485,7 @@ public final class VoiceCatClient {
         VoiceCatResult(vc_move_user(handle, userId, channelId))
     }
 
-    // MARK: - M5: Channel admin
+    // MARK: - Channel admin
 
     @discardableResult
     public func createChannel(_ info: ChannelEdit) -> VoiceCatResult {
@@ -531,7 +508,7 @@ public final class VoiceCatClient {
         VoiceCatResult(vc_delete_channel(handle, channelId))
     }
 
-    // MARK: - M5: Account admin
+    // MARK: - Account admin
 
     @discardableResult
     public func createAccount(_ username: String, password: String) -> VoiceCatResult {

clients/apple/Tests/VoiceCatCoreTests/VoiceCatClientSmokeTests.swift

@@ -64,7 +64,7 @@ private final class ServerHarness {
         }
         self.port = port
 
-        // Provision a known admin account for moderation/admin tests (M5).
+        // Provision a known admin account for moderation/admin tests.
         let adminURL = URL(fileURLWithPath: repoRoot)
             .appendingPathComponent("build/dev/bin/voicecat-admin")
         guard FileManager.default.isExecutableFile(atPath: adminURL.path) else {
@@ -252,12 +252,12 @@ final class VoiceCatClientSmokeTests: XCTestCase {
         XCTAssertTrue(channels.contains { $0.id == 1 && $0.name == "Lobby" },
                       "expected Lobby (channel 1) in \(channels.map { $0.name })")
 
-        // M5: permissions getter round-trip.
+        // Permissions getter round-trip.
         let perms = client.getPermissions()
         XCTAssertFalse(perms.isAdmin)
         XCTAssertFalse(perms.canKick)
 
-        // M5: guest ListAccounts is rejected by the server with a GenericResult — proves the
+        // Guest ListAccounts is rejected by the server with a GenericResult — proves the
         // moderation wrapper path works end-to-end through the Swift interop layer.
         events.removeAll()
         XCTAssertEqual(client.requestAccountList(), .ok)

clients/apple/iOS/VoiceCatBroadcast/VoiceCatBroadcast.entitlements

@@ -4,7 +4,7 @@
 <dict>
 	<key>com.apple.security.application-groups</key>
 	<array>
-		<string>group.cat.voice.VoiceCat</string>
+		<string>group.me.iamtalon.voicecat</string>
 	</array>
 </dict>
 </plist>

clients/apple/iOS/VoiceCatiOS.xcodeproj/project.pbxproj

@@ -7,6 +7,7 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		AAAA00000000000000000002 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = AAAA00000000000000000001 /* Assets.xcassets */; };
 		BBBB00000000000000000030 /* VoiceCatiOSApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = BBBB00000000000000000017 /* VoiceCatiOSApp.swift */; };
 		BBBB00000000000000000031 /* AppState.swift in Sources */ = {isa = PBXBuildFile; fileRef = BBBB00000000000000000018 /* AppState.swift */; };
 		BBBB00000000000000000032 /* SessionState.swift in Sources */ = {isa = PBXBuildFile; fileRef = BBBB00000000000000000019 /* SessionState.swift */; };
@@ -61,6 +62,7 @@
 /* End PBXTargetDependency section */
 
 /* Begin PBXFileReference section */
+		AAAA00000000000000000001 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
 		BBBB00000000000000000012 /* VoiceCatiOS.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = VoiceCatiOS.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		BBBB00000000000000000015 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		BBBB00000000000000000016 /* VoiceCatiOS.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = VoiceCatiOS.entitlements; sourceTree = "<group>"; };
@@ -138,6 +140,7 @@
 		BBBB00000000000000000003 /* VoiceCatiOS */ = {
 			isa = PBXGroup;
 			children = (
+				AAAA00000000000000000001 /* Assets.xcassets */,
 				BBBB00000000000000000015 /* Info.plist */,
 				BBBB00000000000000000016 /* VoiceCatiOS.entitlements */,
 				BBBB00000000000000000017 /* VoiceCatiOSApp.swift */,
@@ -284,6 +287,7 @@
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				AAAA00000000000000000002 /* Assets.xcassets in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -473,7 +477,7 @@
 					"$(inherited)",
 					"-lc++",
 				);
-				PRODUCT_BUNDLE_IDENTIFIER = cat.voice.VoiceCatiOS;
+				PRODUCT_BUNDLE_IDENTIFIER = me.iamtalon.voicecat;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
 				SWIFT_VERSION = 5.9;
@@ -502,7 +506,7 @@
 					"$(inherited)",
 					"-lc++",
 				);
-				PRODUCT_BUNDLE_IDENTIFIER = cat.voice.VoiceCatiOS;
+				PRODUCT_BUNDLE_IDENTIFIER = me.iamtalon.voicecat;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
 				SWIFT_VERSION = 5.9;
@@ -526,7 +530,7 @@
 					"@executable_path/../../Frameworks",
 				);
 				MARKETING_VERSION = 0.0.1;
-				PRODUCT_BUNDLE_IDENTIFIER = cat.voice.VoiceCatiOS.broadcast;
+				PRODUCT_BUNDLE_IDENTIFIER = me.iamtalon.voicecat.broadcast;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
@@ -551,7 +555,7 @@
 					"@executable_path/../../Frameworks",
 				);
 				MARKETING_VERSION = 0.0.1;
-				PRODUCT_BUNDLE_IDENTIFIER = cat.voice.VoiceCatiOS.broadcast;
+				PRODUCT_BUNDLE_IDENTIFIER = me.iamtalon.voicecat.broadcast;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
 				SWIFT_COMPILATION_MODE = wholemodule;

clients/apple/iOS/VoiceCatiOS/AppState.swift

@@ -1,4 +1,5 @@
 import Foundation
+import Network
 import VoiceCatCore
 
 struct PendingIdentity: Identifiable {
@@ -25,6 +26,33 @@ final class AppState {
     private(set) var connectingServer: SavedServer?
     private var identityHandled = false
 
+    /// Retained after authentication so an interrupted session can be restored.
+    private var connectedServer: SavedServer?
+
+    // MARK: - Reconnect state
+
+    /// Distinguishes an explicit disconnect from a transport failure.
+    private var userInitiatedDisconnect = false
+
+    private struct LastSession {
+        let server: SavedServer
+        let channelId: UInt32
+        let voiceSubscribed: Bool
+        let micMuted: Bool
+        let deafened: Bool
+    }
+    private var lastSession: LastSession?
+
+    private var reconnectAttempt = 0
+
+    private var reconnectTask: Task<Void, Never>?
+
+    /// Detects interface changes before TCP keepalive notices a dead path.
+    private var pathMonitor: NWPathMonitor?
+    private let pathQueue = DispatchQueue(label: "cat.voice.network.path")
+
+    private var lastPathSignature: String?
+
     // MARK: - Server list management
 
     func addServer(_ server: SavedServer, password: String?) {
@@ -54,11 +82,19 @@ final class AppState {
     // MARK: - Connect flow
 
     func connectTo(_ server: SavedServer) {
+        connectTo(server, restoring: nil)
+    }
+
+    private func connectTo(_ server: SavedServer, restoring: LastSession?) {
         guard !isConnecting else { return }
         isConnecting = true
-        connectStatus = "Connecting…"
+        connectStatus = (restoring != nil) ? "Reconnecting…" : "Connecting…"
         connectingServer = server
         identityHandled = false
+        userInitiatedDisconnect = false
+
+        // Releasing the wrapper joins the core's I/O thread before freeing native strings.
+        connectingClient = nil
 
         let config = VoiceCatConfig(
             clientName: "VoiceCat-iOS",
@@ -69,11 +105,14 @@ final class AppState {
         connectingClient = client
 
         client.onEvent = { [weak self] ev in
-            Task { @MainActor [weak self] in self?.handleConnectEvent(ev, server: server) }
+            Task { @MainActor [weak self] in
+                self?.handleConnectEvent(ev, server: server, restoring: restoring)
             }
+        }
+        // Authentication can start audio, so select the external path before connecting.
+        client.setExternalPlayback(true)
         client.connect(host: server.host, port: server.port)
 
-        // Auth is queued immediately — the core serialises it behind TLS + TOFU.
         switch server.authMode {
         case .guest:
             let nick = (server.nickname?.isEmpty == false) ? server.nickname! : "iOS User"
@@ -89,13 +128,19 @@ final class AppState {
     }
 
     func disconnect() {
-        session?.stopMicStream()
+        // Set before disconnect so its event cannot arm reconnect.
+        userInitiatedDisconnect = true
+        cancelReconnect()
+        lastSession = nil
+        session?.leaveVoice()
         session?.client.disconnect()
+        IOSAudioEngine.shared.stop()
         AudioSessionManager.shared.deactivateSession()
         session = nil
         connectingClient?.disconnect()
         connectingClient = nil
         connectingServer = nil
+        connectedServer = nil
         isConnecting = false
         connectStatus = ""
         showPasswordPrompt = false
@@ -116,22 +161,139 @@ final class AppState {
     }
 
     func cancelConnect() {
+        // User explicitly cancelled — no reconnect for the resulting .disconnected event.
+        userInitiatedDisconnect = true
+        cancelReconnect()
+        lastSession = nil
         connectingClient?.disconnect()
         connectingClient = nil
         connectingServer = nil
+        connectedServer = nil
         isConnecting = false
         connectStatus = ""
         showPasswordPrompt = false
         pendingIdentity = nil
     }
 
+    // MARK: - Reconnect orchestration
+
+    private func cancelReconnect() {
+        reconnectTask?.cancel()
+        reconnectTask = nil
+        stopPathMonitor()
+    }
+
+    /// Schedules the next reconnect with exponential backoff capped at 30 seconds.
+    private func scheduleReconnect() {
+        guard !userInitiatedDisconnect, let last = lastSession else { return }
+        reconnectTask?.cancel()
+        reconnectAttempt = max(1, reconnectAttempt + 1)
+        let delaySec = min(pow(2.0, Double(reconnectAttempt - 1)), 30.0)
+        connectStatus = "Reconnecting (attempt \(reconnectAttempt))…"
+
+        startPathMonitor()
+
+        let task = Task { [weak self, last] in
+            guard let self else { return }
+            try? await Task.sleep(nanoseconds: UInt64(delaySec * 1_000_000_000))
+            if Task.isCancelled { return }
+            guard !self.userInitiatedDisconnect else { return }
+            guard self.lastSession != nil else { return }
+            guard self.session == nil else { return }
+            self.connectTo(last.server, restoring: last)
+        }
+        reconnectTask = task
+    }
+
+    private func startPathMonitor() {
+        guard pathMonitor == nil else { return }
+        let monitor = NWPathMonitor()
+        monitor.pathUpdateHandler = { [weak self] path in
+            Task { @MainActor [weak self] in
+                guard let self else { return }
+                guard !self.userInitiatedDisconnect else { return }
+                let sig = Self.pathSignature(path)
+                let prevSig = self.lastPathSignature
+                self.lastPathSignature = sig
+                if prevSig == nil { return }
+
+                if self.session != nil {
+                    if path.status != .satisfied || sig != prevSig {
+                        self.proactiveReconnect()
+                    }
+                } else if self.lastSession != nil {
+                    if path.status == .satisfied {
+                        self.reconnectAttempt = 0
+                        self.scheduleReconnect()
+                    }
+                }
+            }
+        }
+        monitor.start(queue: pathQueue)
+        pathMonitor = monitor
+    }
+
+    private func stopPathMonitor() {
+        pathMonitor?.cancel()
+        pathMonitor = nil
+        lastPathSignature = nil
+    }
+
+    private static func pathSignature(_ path: NWPath) -> String {
+        guard path.status == .satisfied else { return "unsatisfied" }
+        var parts: [String] = []
+        if path.usesInterfaceType(.wifi)           { parts.append("wifi") }
+        if path.usesInterfaceType(.cellular)       { parts.append("cellular") }
+        if path.usesInterfaceType(.wiredEthernet)  { parts.append("wired") }
+        if path.usesInterfaceType(.other)          { parts.append("other") }
+        return parts.isEmpty ? "none" : parts.sorted().joined(separator: "+")
+    }
+
+    // MARK: - Live-session disconnect (called by SessionState)
+
+    /// Receives disconnects after `SessionState` takes ownership of authenticated events.
+    func onLiveSessionDisconnected() {
+        guard !userInitiatedDisconnect else { return }
+        teardownLiveSessionAndReconnect(sound: false)
+    }
+
+    private func proactiveReconnect() {
+        guard !userInitiatedDisconnect else { return }
+        guard session != nil else { return }
+        teardownLiveSessionAndReconnect(sound: true)
+    }
+
+    private func teardownLiveSessionAndReconnect(sound: Bool) {
+        if let s = session, let srv = connectedServer {
+            lastSession = LastSession(
+                server: srv,
+                channelId: s.currentChannelId,
+                voiceSubscribed: s.voiceState.voiceSubscribed,
+                micMuted: s.voiceState.selfMuted,
+                deafened: s.voiceState.selfDeafened)
+        }
+        IOSAudioEngine.shared.stop()
+        AudioSessionManager.shared.deactivateSession()
+        session = nil
+        isConnecting = false
+        connectingClient = nil
+        connectedServer = nil
+        if sound {
+            EventFeedback.shared.play(.connectionLost)
+            EventFeedback.shared.speak("Network changed — reconnecting")
+        }
+        reconnectAttempt = 0
+        scheduleReconnect()
+    }
+
     // MARK: - Connect event handler
 
-    private func handleConnectEvent(_ ev: VoiceCatEvent, server: SavedServer) {
+    private func handleConnectEvent(_ ev: VoiceCatEvent, server: SavedServer,
+                                    restoring: LastSession?) {
         switch ev.type {
         case .connectionState:
             switch ev.connectionState {
-            case .connecting:        connectStatus = "Connecting…"
+            case .connecting:        connectStatus = (restoring != nil) ? "Reconnecting…" : "Connecting…"
             case .tlsHandshake:      connectStatus = "TLS handshake…"
             case .authenticating:    connectStatus = "Authenticating…"
             case .verifyingIdentity: connectStatus = "Verifying server identity…"
@@ -153,35 +315,86 @@ final class AppState {
                 guard let client = connectingClient else { break }
                 let perms = client.getPermissions()
                 let newSession = SessionState(client: client, selfUserId: ev.userId, permissions: perms)
+                newSession.appState = self
                 connectingClient = nil
                 isConnecting = false
                 connectStatus = ""
                 showPasswordPrompt = false
+                connectedServer = server
                 self.session = newSession
-                // Activate the audio session now, while connected — NOT lazily when the first
+                EventFeedback.shared.play(.login)
-                // remote stream arrives. The core opens its miniaudio playback device the moment
+                EventFeedback.shared.speak(restoring != nil ? "Reconnected" : "Connected")
-                // a remote stream starts and only THEN emits .streamStarted; if we waited for
+                // External-playback mode was enabled before connect() so the core never opens a
-                // that event to activate, the playback device would open against an inactive
+                // miniaudio device on iOS (the single ordering rule of the unified audio path).
-                // AVAudioSession and produce no sound (the "can't hear anyone" bug). Activating
+                // Now activate the session and start the engine in listening mode so remote audio
-                // here guarantees the session is live before any device opens.
+                // plays the moment someone talks, even before we join voice (no "can't hear anyone").
                 do {
                     try AudioSessionManager.shared.ensureSessionActive()
                 } catch {
                     print("Audio session activate on connect failed: \(error)")
                 }
+                IOSAudioEngine.shared.startListening(client: client)
+                // The path monitor runs the whole time we're connected so a network change fires
+                // proactiveReconnect immediately instead of waiting for the C core's TCP keepalive
+                // timeout (~30-60 s on a hard Wi-Fi drop). It stays armed across reconnects and is
+                // stopped only on user-initiated disconnect.
+                startPathMonitor()
+
+                // Reconnect restore: rejoin the prior channel and re-enable voice/mic if they
+                // were on. The session is fresh (server auto-places us in Lobby), so the restore
+                // is driven through SessionState.requestRestore, which issues a JoinChannel then
+                // (on the resulting .joinResult) re-arms voice + mute/deafen. A successful auth
+                // means the server is reachable, so the backoff counter resets and `lastSession`
+                // clears; the path monitor keeps watching for the next change.
+                if let restoring {
+                    newSession.requestRestore(channelId: restoring.channelId,
+                                              voiceSubscribed: restoring.voiceSubscribed,
+                                              micMuted: restoring.micMuted,
+                                              deafened: restoring.deafened)
+                    reconnectAttempt = 0
+                    lastSession = nil
+                }
             } else {
                 connectStatus = "Auth failed: \(ev.result.description)"
                 showPasswordPrompt = true
             }
         case .disconnected:
-            if session == nil { cancelConnect() }
+            // This handler runs ONLY during the connecting phase — after auth success
-            else {
+            // `SessionState.init` overwrites `client.onEvent`, so a live-session disconnect
+            // reaches `SessionState.handleEvent` and comes back via
+            // `onLiveSessionDisconnected`, not here. Two outcomes for this branch:
+            //   - A reconnect's connecting phase failed (`lastSession != nil`, set by a prior
+            //     teardown) → re-arm `scheduleReconnect` so the backoff loop continues.
+            //   - A fresh connect failed before auth (`lastSession == nil`) → show the error, do
+            //     not auto-reconnect (the user should retry manually once the server is reachable).
+            connectingClient = nil
+            isConnecting = false
+            IOSAudioEngine.shared.stop()
             AudioSessionManager.shared.deactivateSession()
-                session = nil; isConnecting = false
+
+            if userInitiatedDisconnect {
+                connectStatus = ""
+                showPasswordPrompt = false
+                pendingIdentity = nil
+                lastSession = nil
+                connectedServer = nil
+                cancelReconnect()
+            } else if lastSession != nil {
+                // Mid-reconnect drop — keep the backoff loop going.
+                EventFeedback.shared.play(.connectionLost)
+                EventFeedback.shared.speak("Connection lost — reconnecting")
+                scheduleReconnect()
+            } else {
+                // Fresh connect failed before auth. Surface the reason; no auto-reconnect.
+                connectStatus = ev.text ?? "Disconnected"
+                showPasswordPrompt = false
+                pendingIdentity = nil
+                connectedServer = nil
+                cancelReconnect()
             }
         case .error:
             connectStatus = ev.text ?? "Unknown error"
-            if session == nil { isConnecting = false }
+            // Errors don't disconnect us; the .disconnected event handles teardown/reconnect.
         default:
             break
         }

clients/apple/iOS/VoiceCatiOS/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,14 @@
+{
+  "images" : [
+    {
+      "filename" : "AppIcon-1024.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

clients/apple/iOS/VoiceCatiOS/Assets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

clients/apple/iOS/VoiceCatiOS/AudioSessionManager.swift

@@ -8,19 +8,6 @@ private let logger = Logger(subsystem: "cat.voice.VoiceCatiOS", category: "Audio
 final class AudioSessionManager {
     static let shared = AudioSessionManager()
 
-    weak var client: VoiceCatClient?
-
-    /// The stream ID of the currently active local MIC stream, if any. Set by `SessionState`
-    /// when the user joins/leaves voice so `IOSAudioRouter` can reset the core's capture
-    /// channel count (e.g. when switching stereo → mono) without going through `SessionState`.
-    var activeMicStreamId: UInt32?
-
-    /// Set by `SessionState`. Invoked by `IOSAudioRouter` after an audio-config change so the
-    /// voice path (native VPIO vs the core's miniaudio path) can be restarted to match the new
-    /// preset/route when the mic is active. No-op when not in voice. See
-    /// `SessionState.reconcileVoicePath()` and `IOSVoiceProcessingEngine`.
-    var reconcileVoicePath: (() -> Void)?
-
     /// Tracks whether WE activated the session. The session must be active whenever the
     /// AudioEngine is running (for capture OR playback), so it is activated when any audio
     /// needs to play (a remote stream started OR the user joins voice) and only deactivated
@@ -28,6 +15,10 @@ final class AudioSessionManager {
     /// want to hear remote audio.
     private var isSessionActive = false
 
+    /// Whether the AVAudioSession is currently active (we activated it). Read by `IOSAudioRouter`
+    /// to decide whether the post-activation A2DP speaker fallback can be applied.
+    var isActive: Bool { isSessionActive }
+
     func configure() {
         // Load stored audio routing preferences and apply them before any audio session
         // activation. IOSAudioRouter drives all iOS audio route selection via AVAudioSession;
@@ -44,6 +35,20 @@ final class AudioSessionManager {
             name: AVAudioSession.routeChangeNotification, object: nil)
     }
 
+    /// Idempotently restores audio after an interruption or external route change.
+    func recoverAudio() {
+        guard IOSAudioEngine.shared.isConnected else { return }
+        do {
+            try ensureSessionActive()
+        } catch {
+            logger.error("recoverAudio — session activate failed: \(error.localizedDescription)")
+        }
+        IOSAudioRouter.shared.applyConfiguration()
+        if isSessionActive { IOSAudioRouter.shared.applyA2dpSpeakerFallback() }
+        IOSAudioEngine.shared.reconfigure()
+        logSessionState("after recoverAudio")
+    }
+
     /// Activate the AVAudioSession if not already active. Call before any audio I/O:
     /// when the user joins voice, or when a remote stream starts (so playback works even
     /// before the user has joined voice). Idempotent — safe to call multiple times.
@@ -114,22 +119,18 @@ final class AudioSessionManager {
 
         switch type {
         case .began:
+            // The system stops our AVAudioEngine and deactivates the session. Nothing to tear
+            // down — `IOSAudioEngine` rebuilds on resume.
             logger.info("interruption began — session suspended by system")
-            isSessionActive = false  // system deactivated us
+            isSessionActive = false
-            client?.audioSuspend()
         case .ended:
-            let optionsValue = info[AVAudioSessionInterruptionOptionKey] as? UInt ?? 0
+            // Always attempt recovery when we have a live session. iOS sometimes ends an
-            let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
+            // interruption without the `.shouldResume` hint (e.g. Siri), and the previous
-            if options.contains(.shouldResume) {
+            // behavior of only reactivating when `.shouldResume` was set left the session
-                do {
+            // permanently dead — audio never came back. `recoverAudio()` is intent-gated on
-                    try AVAudioSession.sharedInstance().setActive(true)
+            // `IOSAudioEngine.isConnected` and idempotent, so speculatively calling it is safe.
-                    isSessionActive = true
+            logger.info("interruption ended — recovery requested")
-                    logger.info("interruption ended — session reactivated")
+            recoverAudio()
-                    client?.audioResume()
-                } catch {
-                    logger.error("interruption ended — reactivation failed: \(error.localizedDescription)")
-                }
-            }
         @unknown default: break
         }
     }
@@ -139,34 +140,23 @@ final class AudioSessionManager {
               let reasonValue = info[AVAudioSessionRouteChangeReasonKey] as? UInt,
               let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue)
         else {
-            logger.warning("routeChange — unknown reason, refreshing only")
+            logger.warning("routeChange — unknown reason, refreshing + recovery")
             IOSAudioRouter.shared.refreshRoutes()
             NotificationCenter.default.post(name: .voiceCatDeviceListChanged, object: nil)
+            recoverAudio()
             return
         }
 
         logger.info("routeChange reason=\(self.reasonLabel(reason))")
-
-        // Re-apply preferences ONLY on external device plug/unplug. Do NOT re-apply on
-        // .categoryChange / .routeConfigurationChange — those are triggered by our own
-        // applyConfiguration() calls (setCategory, setPreferredInput, etc.), and re-applying
-        // would create an infinite notification loop:
-        //   handleRouteChange → applyConfiguration → setCategory → routeChange → ...
-        // That loop burns CPU and cycles the audio session on/off — the "glitching" bug.
-        // IOSAudioRouter.applyConfiguration() also has a re-entrancy guard for synchronous
-        // notifications, but the reason check here is the primary defense.
-        if reason == .oldDeviceUnavailable || reason == .newDeviceAvailable {
-            logger.info("routeChange — external device change, re-applying config")
-            IOSAudioRouter.shared.applyConfiguration()
-            // Re-evaluate the A2DP-mode speaker fallback: a Bluetooth unplug should drop us onto
-            // the loud speaker (not the earpiece), and a replug should hand output back to A2DP.
-            if isSessionActive {
-                IOSAudioRouter.shared.applyA2dpSpeakerFallback()
-            }
-        }
-
         IOSAudioRouter.shared.refreshRoutes()
         NotificationCenter.default.post(name: .voiceCatDeviceListChanged, object: nil)
+
+        // Ignore notifications caused by our own configuration calls; rebuilding for them
+        // recursively emits more route changes. Engine-configuration notifications remain
+        // the recovery path if a self-initiated change actually stops AVAudioEngine.
+        if reason != .categoryChange && reason != .routeConfigurationChange && reason != .override {
+            recoverAudio()
+        }
         logSessionState("route change (\(reasonLabel(reason)))")
     }
 
@@ -179,6 +169,7 @@ final class AudioSessionManager {
         case .wakeFromSleep: return "wakeFromSleep"
         case .noSuitableRouteForCategory: return "noSuitableRouteForCategory"
         case .routeConfigurationChange: return "routeConfigurationChange"
+        case .unknown: return "unknown"
         @unknown default: return "unknown"
         }
     }

clients/apple/iOS/VoiceCatiOS/IOSAudioRouter.swift

@@ -4,47 +4,8 @@ import VoiceCatCore
 
 private let logger = Logger(subsystem: "cat.voice.VoiceCatiOS", category: "IOSAudioRouter")
 
-/// iOS audio routing layer — drives all iOS audio route selection via `AVAudioSession`
+/// Owns `AVAudioSession` routing for the iOS external-audio path.
-/// *before* the core (miniaudio) opens its device. This class is the sole owner of the
+/// Route configuration and ordering constraints are documented in `docs/voice.md`.
-/// session: miniaudio does NOT touch `AVAudioSession` on iOS, because the core opens its
-/// devices through a `ma_context` configured with `sessionCategory = none` +
-/// `noAudioSessionActivate/Deactivate` (see `AudioEngine::make_context_config` in
-/// `core/src/audio/audio_engine.cpp`). Without that, miniaudio's default path resets the
-/// category to `Record`/`Playback` with no options on every device open, wiping
-/// `.allowBluetoothA2DP`/`.playAndRecord` and killing headphone/A2DP output — so that
-/// config must stay in place. All iOS audio routing (input port selection, mic
-/// orientation/polar patterns, HFP vs A2DP, measurement/raw mode, stereo capture) must be
-/// driven from here.
-///
-/// The three user-facing choices:
-///   1. **Input port** — which physical input (built-in mic, Bluetooth HFP, headset,
-///      USB, AirPlay). For the built-in mic, a sub-selection of **data source**
-///      (orientation: front/back/top/bottom) and **polar pattern**
-///      (omni/cardioid/subcardioid/bidirectional).
-///   2. **Bluetooth mode** — how Bluetooth headsets are handled:
-///      - "BT HFP voice" (`.allowBluetoothHFP` + `.allowBluetoothA2DP`): both profiles
-///        allowed, iOS picks HFP for two-way mic or A2DP for output-only. Mono, AEC on.
-///      - "Built-in Mic + BT A2DP stereo" (`.allowBluetoothA2DP` only): stereo output,
-///        built-in mic, no HFP processing.
-///      - "Built-in Mic + Speaker" (neither): no Bluetooth at all.
-///   3. **Mic processing mode** — Standard (`.voiceChat`: AEC/AGC/HPF on) or
-///      Raw/Studio (`.measurement`: all processing off). Raw mode is allowed always
-///      but shows a warning when the output route is the speaker (echo risk, no AEC).
-///
-/// Additionally, **stereo capture** (2-channel built-in mic) is enabled by switching the
-/// built-in mic's data source to the `.stereo` polar pattern. The recipe is:
-/// `setPreferredDataSource(.stereo source)` + `setPreferredPolarPattern(.stereo)` +
-/// `setPreferredInput(built-in mic)` + `setInputDataSource(stereo source)`. The channel
-/// count itself must NOT be requested via `setPreferredInputNumberOfChannels(2)` — that
-/// session-level call collapses the A2DP output route. Instead the core is told to open the
-/// device with 2 channels via `vc_set_capture_channels(streamId, 2)`, and the AVAudioSession
-/// input anchor (`setPreferredInput` + `setInputDataSource`) keeps the route stable during
-/// the HFP→A2DP and mono→stereo reconfigurations.
-///
-/// Voice Isolation / Wide Spectrum (iOS 17+/18+) are user-toggleable in Control Center
-/// for `.voiceChat` apps — surfaced as a hint, not a programmatic toggle.
-///
-/// All choices are persisted in `UserDefaults` and re-applied on route changes.
 @MainActor
 final class IOSAudioRouter: ObservableObject {
 
@@ -64,77 +25,59 @@ final class IOSAudioRouter: ObservableObject {
     @Published var selectedInputPortId: String?
     @Published var selectedDataSourceId: String?
     @Published var selectedPolarPattern: String?
+    /// Master voice-processing switch (Apple VPIO: AEC + noise suppression bundled together).
+    /// iOS exposes no per-stage toggle, so this is the finest "echo cancellation / noise
+    /// reduction" control available. Only takes effect on a VPIO-capable config (mono + standard
+    /// + not A2DP); stereo / A2DP configs can't use VPIO regardless. Default on.
+    @Published var voiceProcessingEnabled: Bool = true
+    /// VPIO automatic gain control — the one VPIO sub-stage iOS lets us toggle independently.
+    /// Only meaningful when voice processing is active. Default on.
+    @Published var agcEnabled: Bool = true
     @Published var showsRawModeSpeakerWarning: Bool = false
     @Published var showsA2dpNoAecWarning: Bool = false
     @Published var hasBluetoothDevice: Bool = false
     @Published var hasWiredHeadset: Bool = false
 
-    /// Audio presets — sensible combinations of settings for common scenarios.
+    /// Audio presets — the four scenarios from the product spec. Pick a preset for a quick start,
-    /// The app is about choice: users can pick a preset for a quick start, then
+    /// then fine-tune individual settings under "Advanced". HFP / wired headsets are not separate
-    /// fine-tune individual settings under "Advanced Audio".
+    /// presets: Voice Chat lets the system route to them, and Advanced exposes manual selection.
     enum AudioPreset: String, CaseIterable, Identifiable {
-        /// Standard iOS VoIP experience: AEC/AGC/HPF on, mono, system picks best route
+        /// Voice chat: Apple VPIO does real AEC + noise suppression + AGC. Mono. The system picks
-        /// (BT HFP if connected, wired if connected, speaker if nothing). Always available.
+        /// the best route (Bluetooth HFP / wired / speaker / earpiece). Always available.
         case voiceChat = "Voice Chat"
-        /// Stereo built-in mic capture (front+back capsules). A2DP output if BT is connected,
+        /// Internal **stereo** built-in mic regardless of the output route. A2DP output when a
-        /// else built-in speaker / wired. Standard processing (no AEC — stereo needs a non-VPIO
+        /// Bluetooth headset is connected, else built-in speaker / wired. No VPIO (stereo can't
-        /// mode). Always available.
+        /// use it). Always available.
         case stereoMic = "Stereo Mic"
-        /// Maximum fidelity: stereo mic, no AEC/AGC/HPF (raw mode). A2DP output if BT connected,
+        /// Internal **mono** built-in mic regardless of the output route. A2DP output when a
-        /// else speaker/wired. Always available. Echo risk on speaker.
+        /// Bluetooth headset is connected, else built-in speaker / wired. No VPIO. Always available.
-        case studio = "Studio (No Processing)"
+        case monoMic = "Mono Mic"
-        /// Bluetooth HFP: BT mic + BT output, AEC on, mono. Only when BT is connected.
+        /// Everything manual — input port, mic orientation / polar pattern, mono/stereo, Bluetooth
-        case bluetoothHeadset = "Bluetooth Headset (HFP)"
+        /// mode, raw vs standard, and the VPIO / AGC toggles. Also the display state when the
-        /// A2DP stereo output + built-in mono mic, AEC off. Only when BT is connected. (For
+        /// individual settings don't match a named preset.
-        /// A2DP output + stereo mic, use the Stereo Mic preset while BT is connected.)
+        case advanced = "Advanced"
-        case btHeadphonesMonoMic = "BT Headphones + Mono Mic"
-        /// Wired headset/earpods: wired output + wired mic (or built-in), AEC on, mono.
-        /// Only when a wired audio device is connected.
-        case wiredHeadset = "Wired Headset"
-        /// Settings don't match any preset — user has tweaked advanced controls.
-        case custom = "Custom"
 
         var id: String { rawValue }
 
-        var requiresBluetooth: Bool {
-            switch self {
-            case .bluetoothHeadset, .btHeadphonesMonoMic: return true
-            default: return false
-            }
-        }
-
-        var requiresWired: Bool {
-            self == .wiredHeadset
-        }
-
         var bluetoothMode: BluetoothMode {
             switch self {
-            case .voiceChat, .bluetoothHeadset: return .btHfpVoice
+            case .voiceChat: return .btHfpVoice
-            // A2DP output when BT is connected; falls back to speaker/wired when it isn't.
+            // Internal-mic presets: A2DP output when BT is connected; speaker/wired when not.
-            case .stereoMic, .studio, .btHeadphonesMonoMic: return .builtInMicBtA2dp
+            case .stereoMic, .monoMic: return .builtInMicBtA2dp
-            case .wiredHeadset: return .builtInMicSpeaker
+            case .advanced: return .builtInMicSpeaker  // placeholder; Advanced sets it manually
-            case .custom: return .builtInMicSpeaker  // placeholder
             }
         }
 
         var captureChannels: CaptureChannels {
-            switch self {
+            self == .stereoMic ? .stereo : .mono
-            case .stereoMic, .studio: return .stereo
-            default: return .mono
-            }
         }
 
-        var micMode: MicMode {
+        var micMode: MicMode { .standard }
-            switch self {
-            case .studio: return .raw
-            default: return .standard
-            }
-        }
 
-        /// Whether this preset explicitly selects the built-in mic port.
+        /// Whether this preset explicitly pins the built-in mic port (the internal-mic presets).
         var usesBuiltInMic: Bool {
             switch self {
-            case .stereoMic, .studio, .btHeadphonesMonoMic: return true
+            case .stereoMic, .monoMic: return true
             default: return false
             }
         }
@@ -170,14 +113,15 @@ final class IOSAudioRouter: ObservableObject {
     private let kPolarPattern = "cat.voice.audio.polarPattern"
     private let kPreset = "cat.voice.audio.preset"
     private let kForceSpeaker = "cat.voice.audio.forceSpeaker"
+    private let kVoiceProcessing = "cat.voice.audio.voiceProcessing"
+    private let kAgc = "cat.voice.audio.agc"
 
-    /// Re-entrancy guard: setCategory/setPreferredInput/etc. trigger route-change
+    /// AVAudioSession setters can synchronously emit route-change notifications.
-    /// notifications synchronously on the same thread. Without this guard,
-    /// handleRouteChange → applyConfiguration → setCategory → route-change notification
-    /// → handleRouteChange → applyConfiguration → ... creates an infinite loop that
-    /// burns CPU and cycles the audio session on/off (the "glitching" bug).
     private var isApplyingConfiguration = false
 
+    /// Prevents redundant overrides; `setCategory` invalidates the cached value.
+    private var lastAppliedOutputOverride: AVAudioSession.PortOverride?
+
     private init() {}
 
     // MARK: - Load / refresh from AVAudioSession
@@ -271,55 +215,41 @@ final class IOSAudioRouter: ObservableObject {
         }
     }
 
-    /// The presets available given the current device connection state.
+    /// The presets the user can pick. All four are always available — the named presets simply
-    /// Always includes Voice Chat, Stereo Mic, Studio, and Custom. BT presets only when
+    /// describe what to do "regardless of the output route", and Advanced is always offered.
-    /// a Bluetooth device is connected. Wired preset only when a wired device is connected.
+    var availablePresets: [AudioPreset] { AudioPreset.allCases }
-    var availablePresets: [AudioPreset] {
-        AudioPreset.allCases.filter { preset in
-            if preset == .custom { return true }
-            if preset.requiresBluetooth && !hasBluetoothDevice { return false }
-            if preset.requiresWired && !hasWiredHeadset { return false }
-            return true
-        }
-    }
 
-    /// Which preset matches the current settings, or .custom if nothing matches.
+    /// Which named preset matches the current settings, or `.advanced` if nothing matches.
-    /// Checks device-specific presets first (BT, wired) so that e.g. when BT is connected
-    /// and settings match "Bluetooth Headset", it returns that instead of the equivalent
-    /// "Voice Chat" (which has the same bluetoothMode/micMode/channels but is more general).
     var activePreset: AudioPreset {
-        // Check device-specific presets first (most specific → least specific)
+        for preset in [AudioPreset.voiceChat, .stereoMic, .monoMic] {
-        let order: [AudioPreset] = [
-            .bluetoothHeadset, .btHeadphonesMonoMic,
-            .wiredHeadset,
-            .voiceChat, .stereoMic, .studio,
-        ]
-        for preset in order {
             if bluetoothMode == preset.bluetoothMode
                && captureChannels == preset.captureChannels
                && micMode == preset.micMode {
-                // Don't match a BT preset if no BT is connected — fall through to Voice Chat
-                if preset.requiresBluetooth && !hasBluetoothDevice { continue }
-                if preset.requiresWired && !hasWiredHeadset { continue }
                 return preset
             }
         }
-        return .custom
+        return .advanced
     }
 
-    /// Whether the current configuration should use the native iOS Voice-Processing path (VPIO:
+    /// Whether the current configuration should engage Apple's Voice-Processing I/O unit (VPIO:
-    /// real AEC/NS/AGC via `IOSVoiceProcessingEngine`). True exactly when `applyConfiguration`
+    /// real AEC + noise suppression + AGC, driven by `IOSAudioEngine`). VPIO forces mono and
-    /// selects the `.voiceChat` AVAudioSession mode — mono + standard processing + not A2DP
+    /// can't run on an A2DP route, so it is available only for a mono + standard + non-A2DP
-    /// (A2DP / stereo / raw modes can't use VPIO, so they keep the core's miniaudio path).
+    /// config, and then only when the user hasn't disabled it via the Advanced master toggle.
     var currentConfigUsesVoiceProcessing: Bool {
+        voiceProcessingEnabled && voiceProcessingAvailable
+    }
+
+    /// Whether the current config *could* use VPIO (mono + standard + non-A2DP), independent of
+    /// the user's master toggle. Drives whether the Advanced "Voice Processing" switch is shown.
+    var voiceProcessingAvailable: Bool {
         captureChannels == .mono && micMode == .standard && bluetoothMode != .builtInMicBtA2dp
     }
 
     // MARK: - Apply configuration
 
-    /// Apply the full audio configuration to AVAudioSession. Call this before the core
+    /// Apply the full audio configuration to AVAudioSession. Call this before (re)building the
-    /// opens its capture device (i.e. before `startMicStream` → `activateForStreaming`).
+    /// `IOSAudioEngine` graph so the engine binds to the intended route (`applyAndReconfigure`
-    /// Re-entrant-safe: if a route-change notification fires synchronously during a
+    /// does both). Re-entrant-safe: if a route-change notification fires synchronously during a
     /// `setCategory`/`setPreferredInput` call, the guard prevents re-entry.
     func applyConfiguration() {
         guard !isApplyingConfiguration else {
@@ -327,6 +257,9 @@ final class IOSAudioRouter: ObservableObject {
             return
         }
         isApplyingConfiguration = true
+        // setCategory below can reset the override out from under us, so drop our cached
+        // value — applyA2dpSpeakerFallback will re-derive and re-apply it from scratch.
+        lastAppliedOutputOverride = nil
         defer { isApplyingConfiguration = false }
 
         let session = AVAudioSession.sharedInstance()
@@ -397,13 +330,8 @@ final class IOSAudioRouter: ObservableObject {
 
         // 3. Input & mic-capsule configuration.
         if captureChannels == .stereo {
-            // Stereo: enable the built-in mic's .stereo polar pattern AND anchor the input
+            // See configureStereoCapture's doc comment for the full stereo-capture recipe
-            // route explicitly via setPreferredInput + setInputDataSource. With HFP disabled
+            // and why each step is necessary.
-            // the system routes input to the built-in mic, but without the explicit
-            // preferred-input anchor the route can collapse during the mode switch
-            // (.voiceChat → .default) and the output dies. The channel count is requested by
-            // miniaudio at the audio-unit level (vc_set_capture_channels), NOT via
-            // setPreferredInputNumberOfChannels(2) — that call collapses the A2DP output route.
             configureStereoCapture(session: session)
         } else if let portId = selectedInputPortId, !portId.isEmpty,
                   let port = session.availableInputs?.first(where: { $0.uid == portId }) {
@@ -424,16 +352,8 @@ final class IOSAudioRouter: ObservableObject {
         updateWarnings()
     }
 
-    /// Enable 2-channel capture on the built-in mic. The recipe that achieves stereo mic +
+    /// Anchors the built-in stereo data source without using
-    /// A2DP Bluetooth output simultaneously:
+    /// `setPreferredInputNumberOfChannels`, which disrupts A2DP routing.
-    ///   1. `setPreferredDataSource(stereoSource)` on the built-in mic port
-    ///   2. `setPreferredPolarPattern(.stereo)` on that data source
-    ///   3. `setPreferredInput(builtIn)` — anchor the input route explicitly. Without this
-    ///      anchor the route can collapse during the mode switch (.voiceChat → .default).
-    ///   4. `setInputDataSource(stereoSource)` — commit the data source at the session level
-    /// The channel count itself is requested by miniaudio at the audio-unit level via
-    /// `vc_set_capture_channels(2)`. We must NOT call `setPreferredInputNumberOfChannels(2)`
-    /// — that session-level call collapses the A2DP output route.
     private func configureStereoCapture(session: AVAudioSession) {
         guard let builtIn = session.availableInputs?.first(where: { $0.portType == .builtInMic })
         else {
@@ -449,8 +369,6 @@ final class IOSAudioRouter: ObservableObject {
         do {
             try builtIn.setPreferredDataSource(stereoSource)
             try stereoSource.setPreferredPolarPattern(.stereo)
-            // Anchor the input route explicitly; without it the route can collapse during
-            // the mode switch (.voiceChat → .default) and the A2DP output dies.
             try session.setPreferredInput(builtIn)
             // Commit the data source at the session level. setPreferredDataSource alone only
             // sets the port-level preference; setInputDataSource makes it the active source.
@@ -538,6 +456,9 @@ final class IOSAudioRouter: ObservableObject {
         selectedDataSourceId = UserDefaults.standard.string(forKey: kDataSourceId)
         selectedPolarPattern = UserDefaults.standard.string(forKey: kPolarPattern)
         forceSpeaker = UserDefaults.standard.bool(forKey: kForceSpeaker)
+        // VPIO toggles default ON when never set (object(forKey:) is nil → use true).
+        voiceProcessingEnabled = (UserDefaults.standard.object(forKey: kVoiceProcessing) as? Bool) ?? true
+        agcEnabled = (UserDefaults.standard.object(forKey: kAgc) as? Bool) ?? true
     }
     /// Persist current selections to UserDefaults.
     func savePreferences() {
@@ -548,86 +469,84 @@ final class IOSAudioRouter: ObservableObject {
         UserDefaults.standard.set(selectedDataSourceId, forKey: kDataSourceId)
         UserDefaults.standard.set(selectedPolarPattern, forKey: kPolarPattern)
         UserDefaults.standard.set(forceSpeaker, forKey: kForceSpeaker)
+        UserDefaults.standard.set(voiceProcessingEnabled, forKey: kVoiceProcessing)
+        UserDefaults.standard.set(agcEnabled, forKey: kAgc)
     }
 
     // MARK: - Selection setters (called from SettingsView pickers)
 
+    /// Persists the selection and rebuilds the engine against the resulting route.
+    private func applyAndReconfigure() {
+        savePreferences()
+        applyConfiguration()
+        if AudioSessionManager.shared.isActive { applyA2dpSpeakerFallback() }
+        refreshRoutes()
+        IOSAudioEngine.shared.reconfigure()
+    }
+
     func selectInputPort(_ portId: String) {
         selectedInputPortId = portId
         selectedDataSourceId = nil
         selectedPolarPattern = nil
-        savePreferences()
+        applyAndReconfigure()
-        applyConfiguration()
-        refreshRoutes()
     }
 
     func selectDataSource(_ dataSourceId: String) {
         selectedDataSourceId = dataSourceId
         selectedPolarPattern = nil
-        savePreferences()
+        applyAndReconfigure()
-        applyConfiguration()
-        refreshRoutes()
     }
 
     func selectPolarPattern(_ pattern: String) {
         selectedPolarPattern = pattern
-        savePreferences()
+        applyAndReconfigure()
-        applyConfiguration()
-        refreshRoutes()
     }
 
     func selectBluetoothMode(_ mode: BluetoothMode) {
         bluetoothMode = mode
-        savePreferences()
+        applyAndReconfigure()
-        applyConfiguration()
-        refreshRoutes()
-        // VPIO class or route may have changed — restart the voice path if mic is active.
-        AudioSessionManager.shared.reconcileVoicePath?()
     }
 
     func setForceSpeaker(_ on: Bool) {
         forceSpeaker = on
-        savePreferences()
+        applyAndReconfigure()
-        applyConfiguration()
-        refreshRoutes()
-        // Route changed under a possibly-running VPIO engine — reconcile if mic is active.
-        AudioSessionManager.shared.reconcileVoicePath?()
     }
 
     func selectMicMode(_ mode: MicMode) {
         micMode = mode
+        applyAndReconfigure()
+    }
+
+    func setVoiceProcessingEnabled(_ on: Bool) {
+        voiceProcessingEnabled = on
+        applyAndReconfigure()
+    }
+
+    func setAgcEnabled(_ on: Bool) {
+        agcEnabled = on
+        // No session reconfigure needed — just rebuild the engine so VPIO picks up the AGC flag.
         savePreferences()
-        applyConfiguration()
+        IOSAudioEngine.shared.reconfigure()
-        updateWarnings()
-        // Standard↔Raw flips the VPIO class — reconcile if mic is active.
-        AudioSessionManager.shared.reconcileVoicePath?()
     }
 
     func selectCaptureChannels(_ channels: CaptureChannels) {
         captureChannels = channels
         savePreferences()
         applyConfiguration()
-        // Update the core's stored capture channel count (does not restart the engine).
+        if AudioSessionManager.shared.isActive { applyA2dpSpeakerFallback() }
-        if let streamId = AudioSessionManager.shared.activeMicStreamId {
+        refreshRoutes()
-            _ = AudioSessionManager.shared.client?.setCaptureChannels(
+        // Push the channel count into the core's MIC stream, then rebuild the engine graph so the
-                streamId: streamId, channels: channels.channelCount)
+        // mic tap captures the right number of channels. The engine owns the route now, so there's
-        }
+        // no stereo-vs-A2DP race to sequence around.
-        // Restart the engine AFTER AVAudioSession routing has settled and the channel
+        IOSAudioEngine.shared.setCaptureChannels(channels.channelCount)
-        // count is stored. The engine reopens playback first (committing the A2DP/output
-        // route), then capture — avoiding the race where stereo capture activation drops
-        // A2DP before the playback device has a chance to claim the route.
-        _ = AudioSessionManager.shared.client?.audioRestart()
-        // Mono↔stereo flips the VPIO class (stereo can't use VPIO) — reconcile if mic is active.
-        AudioSessionManager.shared.reconcileVoicePath?()
     }
 
     // MARK: - Presets
 
-    /// Apply a preset — sets all individual audio settings to the preset's values, then
+    /// Apply a named preset — set all individual settings to the preset's values, then re-apply
-    /// applies the configuration. For presets that use the built-in mic (A2DP presets),
+    /// the configuration and rebind the engine. The internal-mic presets pin the built-in mic.
-    /// finds the built-in mic port UID from availableInputs.
     func applyPreset(_ preset: AudioPreset) {
-        guard preset != .custom else { return }  // can't "apply" custom — it's a display state
+        guard preset != .advanced else { return }  // Advanced is a display state, not "applied"
 
         bluetoothMode = preset.bluetoothMode
         micMode = preset.micMode
@@ -638,19 +557,17 @@ final class IOSAudioRouter: ObservableObject {
         if preset == .voiceChat { forceSpeaker = true }
 
         if preset.usesBuiltInMic {
-            // Find the built-in mic port from available inputs and select it.
+            // Pin the built-in mic. In stereo, iOS uses multiple capsules automatically; in mono
-            let session = AVAudioSession.sharedInstance()
+            // the default orientation is fine — so don't force a specific data source / pattern.
-            if let builtInMic = (session.availableInputs ?? []).first(where: {
+            if let builtInMic = (AVAudioSession.sharedInstance().availableInputs ?? []).first(where: {
                 $0.portType == .builtInMic
             }) {
                 selectedInputPortId = builtInMic.uid
             }
-            // Don't set a specific data source — in stereo mode, iOS uses multiple mic
-            // capsules automatically. In mono, the default orientation is fine.
             selectedDataSourceId = nil
             selectedPolarPattern = nil
         } else {
-            // For Default and Bluetooth Headset presets, let the system pick the input.
+            // Voice Chat: let the system pick the input (Bluetooth HFP / wired / built-in).
             selectedInputPortId = nil
             selectedDataSourceId = nil
             selectedPolarPattern = nil
@@ -659,18 +576,11 @@ final class IOSAudioRouter: ObservableObject {
         UserDefaults.standard.set(preset.rawValue, forKey: kPreset)
         savePreferences()
         applyConfiguration()
-        // Update the core's stored capture channel count (does not restart the engine).
+        if AudioSessionManager.shared.isActive { applyA2dpSpeakerFallback() }
-        if let streamId = AudioSessionManager.shared.activeMicStreamId {
-            _ = AudioSessionManager.shared.client?.setCaptureChannels(
-                streamId: streamId, channels: preset.captureChannels.channelCount)
-        }
-        // Restart the engine AFTER AVAudioSession routing has settled and the channel
-        // count is stored. Playback opens first (commits A2DP route), then capture.
-        _ = AudioSessionManager.shared.client?.audioRestart()
         refreshRoutes()
-        // The preset may have flipped the VPIO class (and/or the route) — restart the voice path
+        // Push the channel count to the core, then rebuild the engine graph (VPIO on/off + tap).
-        // if the mic is active so AEC/NS engage (or disengage) to match the new preset.
+        IOSAudioEngine.shared.setCaptureChannels(preset.captureChannels.channelCount)
-        AudioSessionManager.shared.reconcileVoicePath?()
+        IOSAudioEngine.shared.reconfigure()
         logger.info("applyPreset — \(preset.rawValue)")
     }
 
@@ -689,15 +599,8 @@ final class IOSAudioRouter: ObservableObject {
         showsA2dpNoAecWarning = (bluetoothMode == .builtInMicBtA2dp)
     }
 
-    /// Route fallback for the A2DP-output presets (Stereo Mic / Studio / BT Headphones + Mono
+    /// Uses the speaker only when an A2DP-capable preset has no external output.
-    /// Mic, all `.builtInMicBtA2dp`). These presets deliberately omit `.defaultToSpeaker` (it
+    /// The cached override avoids recursively generated route-change notifications.
-    /// breaks A2DP routing) and skip the `forceSpeaker` override, so when NO external output
-    /// (Bluetooth A2DP / wired / AirPlay) is connected `.playAndRecord` pins output to the quiet
-    /// built-in receiver (earpiece). This routes to the loud built-in speaker instead via a
-    /// post-activation `overrideOutputAudioPort(.speaker)` — the documented "A2DP if connected,
-    /// else speaker" behavior. When an external output IS present we clear the override so A2DP /
-    /// headphones / AirPlay are honored. No-op outside `.builtInMicBtA2dp` mode (other modes pick
-    /// their route via category options). Must be called AFTER the session is active.
     func applyA2dpSpeakerFallback() {
         guard bluetoothMode == .builtInMicBtA2dp else { return }
         let session = AVAudioSession.sharedInstance()
@@ -706,19 +609,30 @@ final class IOSAudioRouter: ObservableObject {
         let hasExternalOutput = session.currentRoute.outputs.contains {
             $0.portType != .builtInReceiver && $0.portType != .builtInSpeaker
         }
-        do {
+        let desired: AVAudioSession.PortOverride = hasExternalOutput ? .none : .speaker
-            if hasExternalOutput {
+        if desired == lastAppliedOutputOverride {
-                try session.overrideOutputAudioPort(.none)
+            logger.debug("A2DP fallback — desired=\(self.overrideLabel(desired)) already applied, skipping")
-                logger.info("A2DP mode — external output present, clearing speaker override")
+            return
-            } else {
-                try session.overrideOutputAudioPort(.speaker)
-                logger.info("A2DP mode — no external output, routing to built-in speaker")
         }
+        do {
+            try session.overrideOutputAudioPort(desired)
+            lastAppliedOutputOverride = desired
+            logger.info("A2DP mode — override applied: \(self.overrideLabel(desired))")
         } catch {
+            // Drop the cache so the next call re-derives from the live session state.
+            lastAppliedOutputOverride = nil
             logger.error("A2DP speaker fallback failed: \(error.localizedDescription)")
         }
     }
 
+    private func overrideLabel(_ o: AVAudioSession.PortOverride) -> String {
+        switch o {
+        case .none: return "none"
+        case .speaker: return "speaker"
+        @unknown default: return "unknown"
+        }
+    }
+
     /// The selected input port object, if any.
     var selectedPort: IOSAudioInputPort? {
         inputPorts.first(where: { $0.id == selectedInputPortId })

clients/apple/iOS/VoiceCatiOS/IOSVoiceProcessingEngine.swift

@@ -3,9 +3,9 @@ import Darwin
 import os
 import VoiceCatCore
 
-private let logger = Logger(subsystem: "cat.voice.VoiceCatiOS", category: "IOSVoiceProcessingEngine")
+private let logger = Logger(subsystem: "cat.voice.VoiceCatiOS", category: "IOSAudioEngine")
 
-/// In-process single-producer/single-consumer int16 PCM ring for the VPIO playback path.
+/// In-process single-producer/single-consumer int16 PCM ring for the playback path.
 ///
 ///   producer = the core's mixer-timer thread (the `vc_set_mixed_output_sink` callback)
 ///   consumer = the `AVAudioSourceNode` render thread
@@ -73,44 +73,88 @@ final class PCMRing {
         return n
     }
 
+    /// Consumer-side snapshot of how many interleaved int16 samples are currently buffered. Lets a
+    /// paced consumer check for a full frame *before* calling `read`, so it never reads (and thus
+    /// discards) a partial frame. Single consumer only (same thread that calls `read`).
+    var availableSamples: Int {
+        let r = readIdx
+        OSMemoryBarrier()
+        let w = writeIdx
+        return Int(w &- r)
+    }
+
     /// Discard everything buffered — call before (re)starting so stale pre-roll isn't played.
     func reset() { OSMemoryBarrier(); readIdx = writeIdx }
 
     /// Diagnostics: monotonic total samples written / read since the ring was created. The
     /// indices are already cumulative, so these are free. Only read them when both threads are
     /// quiesced (e.g. at teardown after the engine + mixer sink are stopped) — they are not
-    /// synchronized for live cross-thread reads. Lets us tell "core never delivered PCM" (Bug 1
+    /// synchronized for live cross-thread reads. Lets us tell "core never delivered PCM" apart
-    /// core path) apart from "PCM arrived but produced no sound" (AVAudioEngine output graph).
+    /// from "PCM arrived but produced no sound" (the AVAudioEngine output graph).
     var debugTotalWritten: UInt64 { writeIdx }
     var debugTotalRead: UInt64 { readIdx }
 }
 
-/// Native iOS voice-processing audio path (docs/voice.md §8 "iOS voice processing").
+/// The single iOS audio engine (docs/voice.md §8 "iOS audio engine").
 ///
-/// Real iOS echo cancellation / noise suppression / AGC come ONLY from Apple's Voice-Processing
+/// **One path, always external.** On iOS the core never opens a miniaudio device: a MIC stream is
-/// I/O unit (VPIO), which `AVAudioEngine.setVoiceProcessingEnabled(true)` enables. For VPIO to
+/// always started with `external_feed=1`, `vc_set_external_playback(1)` is set once at connect, and
-/// cancel echo it must own BOTH the mic capture and the remote-audio playback (it subtracts the
+/// this engine drives *both* directions through one `AVAudioEngine`:
-/// played-back signal from the mic), so on the AEC presets this engine drives both directions and
-/// the core runs in external mode (no hardware devices):
-///   - **Mic → core:** a tap on the VPIO input node → 48 kHz int16 → `client.feedPcm(micStreamId)`.
 ///   - **core → speaker:** the core's mixed-output sink fills `ring`; an `AVAudioSourceNode` pulls
-///     from it and renders through the VPIO output, giving AEC its reference signal.
+///     from it and renders through the engine output. This runs the whole time we're connected,
+///     so remote audio plays even before the user joins voice (no "can't hear anyone").
+///   - **mic → core:** when the mic is active a tap on the input node converts to 48 kHz int16 and
+///     writes to a pacing ring; a 20 ms timer releases steady 960-sample frames to
+///     `client.feedPcm(micStreamId)`. The core sends each captured frame synchronously, so this
+///     steady cadence is what keeps packets from bursting and fluttering the receiver's playout.
 ///
-/// Lifecycle is driven by `SessionState` join/leave. The Stereo Mic / Studio / A2DP presets keep
+/// Echo cancellation / noise suppression / AGC come from Apple's Voice-Processing I/O unit (VPIO),
-/// the core's miniaudio path instead (they want raw / stereo / no-AEC routing VPIO can't provide).
+/// which `inputNode.setVoiceProcessingEnabled(true)` enables. VPIO forces mono, so it is engaged
+/// only when the active preset wants it (`IOSAudioRouter.currentConfigUsesVoiceProcessing`) — the
+/// Stereo Mic / A2DP configs run the same engine with VPIO off.
+///
+/// Every preset / route / interruption change funnels through `reconfigure()`: a single
+/// deterministic stop → AVAudioSession reconfigure → rebuild graph → start. There is no second
+/// (miniaudio) audio path to hand off to, so a switch cannot leave one direction dropped.
 @MainActor
-final class IOSVoiceProcessingEngine {
+final class IOSAudioEngine {
-    static let shared = IOSVoiceProcessingEngine()
+    static let shared = IOSAudioEngine()
 
-    private(set) var isRunning = false
+    /// True while connected (between `startListening` and `stop`) — the playback graph should run.
+    private(set) var isConnected = false
+    /// True while a local mic stream is active — the input tap should be installed.
+    private(set) var micActive = false
 
     private let engine = AVAudioEngine()
     private var sourceNode: AVAudioSourceNode?
     private weak var client: VoiceCatClient?
     private var micStreamId: UInt32 = 0
+    private var captureChannels: UInt32 = 1
 
-    // 48 kHz stereo Float32 (deinterleaved) — the format the source node renders and the engine
+    // AVAudioEngine may deliver several codec frames per callback. Pace complete 20 ms frames
-    // processes in. The core delivers 48 kHz stereo int16 via the mixed-output sink.
+    // through an SPSC ring; never consume partial frames, and recreate the timer when the channel
+    // count changes.
+    private let micRing = PCMRing(capacitySamples: 48000 * 2)  // ~1 s stereo — ample elastic slack
+    private var micTimer: DispatchSourceTimer?
+    private let micQueue = DispatchQueue(label: "cat.voice.mic.feedPump")
+    private let micDrainScratch: UnsafeMutablePointer<Int16>
+    private static let micFrameSamplesPerChannel = 960  // 20 ms @ 48 kHz — core's frame size
+
+    /// Feed-pump state, touched only on `micQueue` (the pump's serial queue). A reference type so
+    /// the timer closure mutates it without capturing `self` (which is @MainActor). `targetFrames`
+    /// is the prebuffer depth: the pump fills this many frames before it starts releasing, so the
+    /// tap's bursty delivery (~2 frames at once) can't drain it to empty between bursts. It persists
+    /// across rebuilds and self-heals upward (capped) on an underrun, so it tunes to whatever IO
+    /// buffer size the active route/VPIO actually uses without a hard-coded guess.
+    private final class PumpState {
+        var primed = false
+        var targetFrames = 3  // ~60 ms initial cushion; grows on underrun up to maxTargetFrames
+        static let maxTargetFrames = 6  // ~120 ms cap — bounds added latency
+    }
+    private let pumpState = PumpState()
+
+    // 48 kHz stereo Float32 (deinterleaved) — the format the source node renders. The core
+    // delivers 48 kHz stereo int16 via the mixed-output sink; mainMixerNode adapts to the route.
     private let outFormat = AVAudioFormat(
         commonFormat: .pcmFormatFloat32, sampleRate: 48000, channels: 2, interleaved: false)!
 
@@ -121,33 +165,189 @@ final class IOSVoiceProcessingEngine {
     private let renderScratchFrames = 8192
     private let renderScratch: UnsafeMutablePointer<Int16>
 
-    // Mic-feed converter (input-node format → 48 kHz int16) and its target buffer. Owned here so
-    // the (background) tap block reuses them instead of allocating per callback.
-    private var micConverter: AVAudioConverter?
-    private var micTargetFormat: AVAudioFormat?
-
     private init() {
         renderScratch = UnsafeMutablePointer<Int16>.allocate(capacity: renderScratchFrames * 2)
         renderScratch.initialize(repeating: 0, count: renderScratchFrames * 2)
+        micDrainScratch = UnsafeMutablePointer<Int16>.allocate(capacity: 960 * 2)
+        micDrainScratch.initialize(repeating: 0, count: 960 * 2)
+
+        // AVAudioEngine stops itself on a mid-session route/configuration change (it stops
+        // if its I/O graph no longer matches the active route). Our route-change handler in
+        // AudioSessionManager normally rebuilds us before the user notices, but if the engine
+        // stops itself AFTER our recovery (because the route-change notification raced ahead
+        // of the engine's own self-stop), nothing restarts it. Catch that case here.
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(handleEngineConfigurationChange),
+            name: .AVAudioEngineConfigurationChange, object: engine)
     }
 
-    /// Start the VPIO engine for an active mic stream. The caller must have already enabled
+    /// The engine stopped itself because its configuration no longer matches the active AVAudio
-    /// external playback on the core (`client.setExternalPlayback(true)` + `audioRestart()`) and
+    /// route (this fires after a route change that the route-change handler can't always outrun).
-    /// started the MIC stream with `externalFeed: true`.
+    /// Dispatch to main and call the unified `recoverAudio()` — it's intent-gated on
-    func start(client: VoiceCatClient, micStreamId: UInt32, captureChannels: UInt32) {
+    /// `isConnected`, idempotent, and no-ops if the engine is already running (the common case
-        guard !isRunning else { return }
+    /// where our route-change handler got there first).
+    @objc private func handleEngineConfigurationChange(_ notification: Notification) {
+        Task { @MainActor [weak self] in
+            guard let self else { return }
+            guard self.isConnected, !self.engine.isRunning else { return }
+            logger.info("engine configuration-change — engine stopped itself, recovering")
+            AudioSessionManager.shared.recoverAudio()
+        }
+    }
+
+    // MARK: - Lifecycle
+
+    /// Begin playback-only (listening) operation. Called once at connect, after
+    /// `client.setExternalPlayback(true)` and `AudioSessionManager.ensureSessionActive()`. Attaches
+    /// the source node, wires the core's mixed-output sink into the ring, and starts the engine so
+    /// remote audio plays immediately.
+    func startListening(client: VoiceCatClient) {
         self.client = client
-        self.micStreamId = micStreamId
+        guard !isConnected else { return }
+        isConnected = true
         ring.reset()
 
-        // Enable the voice-processing I/O unit (AEC/NS/AGC) on the shared input+output unit.
+        // Wire the core's mixed-output sink into the ring (C function pointer, no captures). Stays
-        do {
+        // registered for the whole connection; the ring is drained by the source-node render block.
-            try engine.inputNode.setVoiceProcessingEnabled(true)
+        let ringPtr = Unmanaged.passUnretained(self.ring).toOpaque()
-        } catch {
+        client.setMixedOutputSink({ user, pcm, spc, ch, _ in
-            logger.error("setVoiceProcessingEnabled failed: \(error.localizedDescription) — AEC unavailable")
+            guard let user, let pcm else { return }
+            let ring = Unmanaged<PCMRing>.fromOpaque(user).takeUnretainedValue()
+            ring.write(pcm, count: spc * Int(ch))
+        }, user: ringPtr)
+
+        rebuild()
     }
 
-        // ── Playback: source node pulls mixed PCM from the ring through the VPIO output. ──
+    /// Tear down the engine and unhook the core sink. Called on disconnect.
+    func stop() {
+        guard isConnected else { return }
+        micActive = false
+        stopMicTimer()
+        isConnected = false
+        client?.setMixedOutputSink(nil, user: nil)
+        engine.inputNode.removeTap(onBus: 0)
+        if engine.isRunning { engine.stop() }
+        logger.info("audio engine stopped — ring written=\(self.ring.debugTotalWritten) read=\(self.ring.debugTotalRead) samples")
+        try? engine.inputNode.setVoiceProcessingEnabled(false)
+        if let src = sourceNode {
+            engine.detach(src)
+            sourceNode = nil
+        }
+        ring.reset()
+        micRing.reset()
+        client = nil
+    }
+
+    // MARK: - Mic transitions
+
+    /// Engage the mic: install the input tap and (if the preset wants it) VPIO. Called when the
+    /// user joins voice, after the MIC stream (external_feed) is started.
+    func startMic(streamId: UInt32, channels: UInt32) {
+        micStreamId = streamId
+        captureChannels = channels
+        micActive = true
+        rebuild()
+    }
+
+    /// Disengage the mic: remove the tap and VPIO, keep playback running for remaining remote audio.
+    func stopMic() {
+        guard micActive else { return }
+        micActive = false
+        rebuild()
+    }
+
+    /// Update the capture channel count (mono↔stereo) for the active mic and rebuild.
+    func setCaptureChannels(_ channels: UInt32) {
+        captureChannels = channels
+        if let client, micStreamId != 0 {
+            client.setCaptureChannels(streamId: micStreamId, channels: channels)
+        }
+        if micActive { rebuild() }
+    }
+
+    /// Re-apply the engine graph against the current AVAudioSession config (preset / route change).
+    /// Safe to call when only listening — it just rebuilds the playback graph against the new route.
+    func reconfigure() {
+        guard isConnected else { return }
+        rebuild()
+    }
+
+    // MARK: - Graph (re)build
+
+    /// The single place that (re)builds and starts the engine graph. Deterministic: stop → set
+    /// VPIO → (re)install the mic tap → start. The caller is responsible for having applied the
+    /// AVAudioSession config (category/mode/route) first (`IOSAudioRouter.applyConfiguration`).
+    private func rebuild() {
+        guard isConnected else { return }
+        // Stop the feed pump before touching the tap / ring so the timer (on micQueue) can't race
+        // the ring reset in installMicTap. It is restarted at the end with the current channel count.
+        stopMicTimer()
+        if engine.isRunning { engine.stop() }
+        engine.inputNode.removeTap(onBus: 0)
+
+        let useVPIO = micActive && IOSAudioRouter.shared.currentConfigUsesVoiceProcessing
+        do {
+            try engine.inputNode.setVoiceProcessingEnabled(useVPIO)
+        } catch {
+            logger.error("setVoiceProcessingEnabled(\(useVPIO)) failed: \(error.localizedDescription)")
+        }
+        if useVPIO {
+            // AGC is the one VPIO sub-stage iOS exposes; AEC+NS are bundled into the master switch.
+            engine.inputNode.isVoiceProcessingAGCEnabled = IOSAudioRouter.shared.agcEnabled
+        }
+
+        // The source node must bind to the selected voice-processing output unit.
+        rebuildSourceNode()
+        if micActive { installMicTap() }
+
+        engine.prepare()
+        do {
+            try engine.start()
+            let inFmt = engine.inputNode.outputFormat(forBus: 0)
+            let outFmt = engine.outputNode.outputFormat(forBus: 0)
+            let route = AVAudioSession.sharedInstance().currentRoute.outputs
+                .map { "\($0.portName)[\($0.portType.rawValue)]" }.joined(separator: ", ")
+            logger.info("""
+                engine started — mic=\(self.micActive) vpio=\(useVPIO) captureCh=\(self.captureChannels) \
+                inFormat=\(inFmt) outputNode=\(outFmt) outputRoute=[\(route)]
+                """)
+        } catch {
+            // Route changes can leave AVAudioSession inactive; retry once after reactivation.
+            logger.error("engine start failed: \(error.localizedDescription) — attempting one-shot recovery")
+            do {
+                try AudioSessionManager.shared.ensureSessionActive()
+            } catch {
+                logger.error("recovery — session re-activate failed: \(error.localizedDescription)")
+            }
+            IOSAudioRouter.shared.applyConfiguration()
+            if AudioSessionManager.shared.isActive {
+                IOSAudioRouter.shared.applyA2dpSpeakerFallback()
+            }
+            do {
+                try engine.start()
+                logger.info("engine start succeeded after one-shot recovery")
+            } catch {
+                logger.error("engine start failed after recovery: \(error.localizedDescription)")
+                // Not fatal — a subsequent route-change or AVAudioEngine configuration-change
+                // notification will trigger recoverAudio() and re-attempt the rebuild.
+            }
+        }
+
+        // Start the feed pump last, with the current channel count, so it never carries a stale
+        // (frozen) channel count across a mono↔stereo switch.
+        if micActive { startMicTimer() }
+    }
+
+    /// Detach any previous source node and attach a fresh one pulling mixed PCM from the ring.
+    /// Rebuilt on every graph rebuild so it always connects against the current output unit (the
+    /// VPIO state can change the output between rebuilds). Its format is route-independent —
+    /// `mainMixerNode` adapts 48 kHz stereo to whatever the output route is.
+    private func rebuildSourceNode() {
+        if let old = sourceNode {
+            engine.detach(old)
+            sourceNode = nil
+        }
         let ring = self.ring
         let scratch = self.renderScratch
         let scratchFrames = self.renderScratchFrames
@@ -156,17 +356,11 @@ final class IOSVoiceProcessingEngine {
             let abl = UnsafeMutableAudioBufferListPointer(ablPtr)
             let n = min(frames, scratchFrames)
             let got = ring.read(into: scratch, count: n * 2) / 2  // interleaved stereo → frames
-            // Deinterleave int16 → Float32 per channel; silence-fill any underrun tail.
             let scale: Float = 1.0 / 32768.0
             for ch in 0..<abl.count {
                 guard let base = abl[ch].mData?.assumingMemoryBound(to: Float.self) else { continue }
                 for i in 0..<frames {
-                    if i < got {
+                    base[i] = i < got ? Float(scratch[i * 2 + min(ch, 1)]) * scale : 0
-                        let s = scratch[i * 2 + min(ch, 1)]
-                        base[i] = Float(s) * scale
-                    } else {
-                        base[i] = 0
-                    }
                 }
             }
             return noErr
@@ -174,29 +368,39 @@ final class IOSVoiceProcessingEngine {
         sourceNode = src
         engine.attach(src)
         engine.connect(src, to: engine.mainMixerNode, format: outFormat)
-
-        // ── Mic: tap the VPIO input node, convert to 48 kHz int16, feed the core. ──
-        let inFormat = engine.inputNode.outputFormat(forBus: 0)
-        let targetCh = max(1, min(2, captureChannels))
-        let target = AVAudioFormat(commonFormat: .pcmFormatInt16, sampleRate: 48000,
-                                   channels: AVAudioChannelCount(targetCh), interleaved: true)
-        micTargetFormat = target
-        micConverter = (target != nil && inFormat.sampleRate > 0)
-            ? AVAudioConverter(from: inFormat, to: target!) : nil
-        if micConverter == nil {
-            logger.error("mic converter unavailable (in=\(inFormat)) — mic will not transmit")
     }
 
-        let c = client
+    /// Install the mic tap: convert the input node's native format to 48 kHz int16 (mono or
-        let sid = micStreamId
+    /// stereo per `captureChannels`) and write it to the pacing ring. The 20 ms feed pump
-        let converter = micConverter
+    /// (`startMicTimer`) releases steady 960-sample frames to `feedPcm` — see the mic-feed comment
-        let tgt = micTargetFormat
+    /// above for why the tap must NOT call feedPcm directly (it bursts packets → receiver flutter).
+    /// Rebuilds the converter each time because the input format depends on the VPIO state and the
+    /// active route.
+    private func installMicTap() {
+        guard client != nil else { return }
+        // Fresh ring on every (re)install — a rebuild must not feed stale pre-roll into the new tap.
+        // Safe here: the feed pump was stopped at the top of rebuild(), so no consumer is running.
+        micRing.reset()
+        let ring = micRing  // captured by the closure as a `let` — no self capture (see mic-feed comment)
+        let inFormat = engine.inputNode.outputFormat(forBus: 0)
+        guard inFormat.sampleRate > 0 else {
+            logger.error("input format unavailable (\(inFormat)) — mic will not transmit")
+            return
+        }
+        let targetCh = max(1, min(2, captureChannels))
+        guard let target = AVAudioFormat(commonFormat: .pcmFormatInt16, sampleRate: 48000,
+                                         channels: AVAudioChannelCount(targetCh), interleaved: true),
+              let converter = AVAudioConverter(from: inFormat, to: target) else {
+            logger.error("mic converter unavailable (in=\(inFormat), ch=\(targetCh)) — mic will not transmit")
+            return
+        }
+
+        let chInt = Int(targetCh)
         engine.inputNode.installTap(onBus: 0, bufferSize: 960, format: inFormat) { buffer, _ in
-            guard let converter, let tgt else { return }
             // Convert this tap buffer to 48 kHz int16. Output capacity scaled for any upsample.
-            let ratio = tgt.sampleRate / buffer.format.sampleRate
+            let ratio = target.sampleRate / buffer.format.sampleRate
             let outCap = AVAudioFrameCount(Double(buffer.frameLength) * ratio + 16)
-            guard let outBuf = AVAudioPCMBuffer(pcmFormat: tgt, frameCapacity: outCap) else { return }
+            guard let outBuf = AVAudioPCMBuffer(pcmFormat: target, frameCapacity: outCap) else { return }
             var fed = false
             let status = converter.convert(to: outBuf, error: nil) { _, outStatus in
                 if fed { outStatus.pointee = .noDataNow; return nil }
@@ -206,64 +410,66 @@ final class IOSVoiceProcessingEngine {
             }
             guard status != .error, outBuf.frameLength > 0,
                   let chData = outBuf.int16ChannelData else { return }
-            let spc = Int(outBuf.frameLength)
+            // int16 interleaved → channelData[0] is the interleaved buffer. Write the converter's
-            // int16 interleaved → channelData[0] is the interleaved buffer for interleaved formats.
+            // variable-length output to the pacing ring; the 20 ms feed pump releases steady
-            c.feedPcm(streamId: sid, pcm: chData[0], samplesPerChannel: spc, channels: targetCh)
+            // 960-sample frames to feedPcm so packets leave the core at a steady 20 ms cadence.
-        }
+            ring.write(chData[0], count: Int(outBuf.frameLength) * chInt)
-
-        // ── Wire the core's mixed-output sink into the ring (C function pointer, no captures). ──
-        let ringPtr = Unmanaged.passUnretained(self.ring).toOpaque()
-        client.setMixedOutputSink({ user, pcm, spc, ch, _ in
-            guard let user, let pcm else { return }
-            let ring = Unmanaged<PCMRing>.fromOpaque(user).takeUnretainedValue()
-            ring.write(pcm, count: spc * Int(ch))
-        }, user: ringPtr)
-
-        engine.prepare()
-        do {
-            try engine.start()
-            isRunning = true
-            // Diagnostics: capture the negotiated graph formats and the live output route so a
-            // silent-playback report can be triaged (format/rate mismatch vs. routing vs. the
-            // core not delivering PCM — see the ring stats logged in teardown()).
-            let outFmt = engine.outputNode.outputFormat(forBus: 0)
-            let mixFmt = engine.mainMixerNode.outputFormat(forBus: 0)
-            let route = AVAudioSession.sharedInstance().currentRoute.outputs
-                .map { "\($0.portName)[\($0.portType.rawValue)]" }.joined(separator: ", ")
-            logger.info("""
-                VPIO engine started — inFormat=\(inFormat), captureCh=\(targetCh), \
-                outputNode=\(outFmt), mainMixer=\(mixFmt), outputRoute=[\(route)]
-                """)
-        } catch {
-            logger.error("VPIO engine start failed: \(error.localizedDescription)")
-            teardown()
         }
     }
 
-    /// Stop the VPIO engine. The caller is responsible for restoring the core's hardware playback
+    // MARK: - Mic feed pump (paces feedPcm at a steady 20 ms cadence)
-    /// afterwards (`client.setExternalPlayback(false)` + `audioRestart()`).
+
-    func stop() {
+    /// Start the 20 ms feed pump. After priming a small cushion (`pumpState.targetFrames`), it
-        guard isRunning else { return }
+    /// releases ONE 960-sample frame per tick from `micRing` to `feedPcm`, so the core (which sends
-        teardown()
+    /// synchronously per captured frame) emits packets at a steady 20 ms — the cadence its receivers
-        logger.info("VPIO engine stopped")
+    /// expect. The cushion is essential: the receiver's playout deliberately keeps near-zero
+    /// buffering (low latency), so it tolerates a steady stream but not bursts; the iOS tap delivers
+    /// ~2 frames at once, and without the cushion the pump runs at ~0 depth and underruns on every
+    /// tap/timer phase beat (crackle). Recreated on every `rebuild()` so `ch` always reflects the
+    /// current `captureChannels` (mono↔stereo switches). Captures only locals + the reference-type
+    /// ring/client/state (no `self`, which is @MainActor).
+    private func startMicTimer() {
+        stopMicTimer()
+        guard let client else { return }
+        let ring = micRing
+        let scratch = micDrainScratch
+        let state = pumpState
+        let sid = micStreamId
+        let ch = max(1, min(2, Int(captureChannels)))
+        let frameSamples = Self.micFrameSamplesPerChannel
+        let full = frameSamples * ch
+        let chU32 = UInt32(ch)
+        // The ring was just reset in installMicTap, so the cushion must be refilled before sending.
+        state.primed = false
+        let feed: () -> Void = {
+            _ = ring.read(into: scratch, count: full)  // caller guarantees a full frame is present
+            _ = client.feedPcm(streamId: sid, pcm: scratch,
+                               samplesPerChannel: frameSamples, channels: chU32)
+        }
+        let t = DispatchSource.makeTimerSource(queue: micQueue)
+        t.schedule(deadline: .now(), repeating: .milliseconds(20), leeway: .milliseconds(2))
+        t.setEventHandler {
+            let frames = ring.availableSamples / full  // whole frames currently buffered
+            if !state.primed {
+                if frames < state.targetFrames { return }  // still filling the cushion (into silence)
+                state.primed = true
+            } else if frames == 0 {
+                // Re-prime with a larger cushion; consuming a partial frame would lose samples.
+                if state.targetFrames < PumpState.maxTargetFrames { state.targetFrames += 1 }
+                state.primed = false
+                return
+            }
+            feed()  // one steady frame per tick (frames >= 1 here)
+            // Catch-up: if the backlog grew past the cushion (pump descheduled, or producer ran
+            // ahead via a burst), release one extra frame to drain it and keep latency bounded.
+            if frames - 1 > state.targetFrames + 1 { feed() }
+        }
+        t.resume()
+        micTimer = t
     }
 
-    private func teardown() {
+    private func stopMicTimer() {
-        client?.setMixedOutputSink(nil, user: nil)
+        micTimer?.cancel()
-        engine.inputNode.removeTap(onBus: 0)
+        micTimer = nil
-        if engine.isRunning { engine.stop() }
-        // Diagnostics (threads now quiesced): how much mixed PCM the core delivered into the ring
-        // vs. how much the render thread consumed. written==0 ⇒ the core never delivered (Bug 1
-        // core/lifecycle path); written>0 with no audible output ⇒ the AVAudioEngine output graph.
-        logger.info("VPIO ring stats — written=\(self.ring.debugTotalWritten) read=\(self.ring.debugTotalRead) samples")
-        try? engine.inputNode.setVoiceProcessingEnabled(false)
-        if let src = sourceNode {
-            engine.detach(src)
-            sourceNode = nil
-        }
-        micConverter = nil
-        micTargetFormat = nil
-        ring.reset()
-        isRunning = false
     }
 }

clients/apple/iOS/VoiceCatiOS/Info.plist

@@ -26,8 +26,8 @@
 	<array>
 		<string>audio</string>
 	</array>
-	<key>UILaunchStoryboardName</key>
+	<key>UILaunchScreen</key>
-	<string>LaunchScreen</string>
+	<dict/>
 	<key>UIRequiresFullScreen</key>
 	<false/>
 	<key>UISupportedInterfaceOrientations</key>

clients/apple/iOS/VoiceCatiOS/SessionState.swift

@@ -20,12 +20,15 @@ struct ActivityEntry: Identifiable {
 
 struct VoiceState {
     var micActive = false
+    var voiceSubscribed = false
     var selfMuted = false
     var selfDeafened = false
     var serverMuted = false
     var serverDeafened = false
     var inputMode: VoiceCatInputMode = .voiceActivation
     var vadThreshold: Float = 0.025
+    var inputGain: Float = 1.0
+    var inputNoiseReduction: Bool = false
     var level: Float = 0.0
     var currentDeviceId: String?
     var localStreamId: UInt32 = 0
@@ -51,6 +54,30 @@ final class SessionState {
     var accounts: [Account] = []
     var devices: [Device] = []
 
+    /// Back-reference to the app state. Once `SessionState.init` overwrites `client.onEvent`,
+    /// `AppState.handleConnectEvent` no longer receives per-session events — so the
+    /// `.disconnected` event for a LIVE session arrives here in `handleEvent`, not in AppState.
+    /// This weak ref lets us hand the disconnect back to AppState (which owns the reconnect
+    /// state machine) so the auto-reconnect fires. Set by AppState on auth success.
+    weak var appState: AppState?
+
+    // MARK: - Reconnect restore state
+    //
+    // When the iOS client auto-reconnects after a network drop, AppState captures the prior
+    // session's channel + voice/mic state and asks the new SessionState (created on auth success)
+    // to restore it. We rejoin the channel explicitly (the server auto-placed us in Lobby on
+    // auth), and on the resulting `.joinResult` we re-arm voice subscription + mute/deafen. The
+    // drive is here, not in AppState, because once SessionState is created it owns
+    // `client.onEvent` and AppState no longer sees per-session events.
+    private struct RestoreRequest {
+        let channelId: UInt32
+        let voiceSubscribed: Bool
+        let micMuted: Bool
+        let deafened: Bool
+    }
+    private var pendingRestore: RestoreRequest?
+    private var didIssueRestoreJoin = false
+
     /// Host side of iOS screen-audio sharing — drains the broadcast extension's App Group ring
     /// and feeds the SCREEN_AUDIO stream this session owns. See BroadcastAudioPump.
     private let broadcastPump = BroadcastAudioPump()
@@ -59,7 +86,7 @@ final class SessionState {
         self.client = client
         self.selfUserId = selfUserId
         self.permissions = permissions
-        AudioSessionManager.shared.client = client
+        loadAndApplyVoiceSettings()
         refreshChannels()
         refreshUsers()
         syncSelfChannel()
@@ -73,16 +100,10 @@ final class SessionState {
         broadcastPump.onBroadcastStarted = { [weak self] in self?.startScreenShare() }
         broadcastPump.onBroadcastFinished = { [weak self] in self?.stopScreenShare() }
         broadcastPump.start()
-        // When IOSAudioRouter changes the audio config, restart the voice path if needed so the
-        // native VPIO engine (AEC/NS/AGC) engages or disengages to match the new preset/route.
-        AudioSessionManager.shared.reconcileVoicePath = { [weak self] in self?.reconcileVoicePath() }
     }
 
     deinit {
         broadcastPump.stop()
-        MainActor.assumeIsolated {
-            AudioSessionManager.shared.client = nil
-        }
     }
 
     // MARK: - Event dispatch
@@ -92,7 +113,22 @@ final class SessionState {
         case .channelList:
             refreshChannels()
             syncSelfChannel()
-        case .userJoined, .userLeft:
+        case .userJoined:
+            // ev.text = nickname, ev.channelId = the channel they joined (per voicecat.h).
+            if ev.userId != selfUserId && ev.channelId == currentChannelId {
+                EventFeedback.shared.play(.channelJoin)
+                EventFeedback.shared.speak("\(ev.text ?? "Someone") joined")
+            }
+            refreshUsers()
+            syncSelfChannel()
+        case .userLeft:
+            // Capture the leaving user's prior nickname/channel before refreshUsers() drops them.
+            if ev.userId != selfUserId,
+               let gone = users.first(where: { $0.id == ev.userId }),
+               gone.channelId == currentChannelId {
+                EventFeedback.shared.play(.channelLeave)
+                EventFeedback.shared.speak("\(gone.nickname) left")
+            }
             refreshUsers()
             syncSelfChannel()
         case .userUpdated:
@@ -103,13 +139,27 @@ final class SessionState {
             }
         case .textMessage:
             let sender = users.first(where: { $0.id == ev.userId })?.nickname ?? "Unknown"
+            let body = ev.text ?? ""
+            let isSelf = ev.userId == selfUserId
+            let isPrivate = ev.textScope == .private
             messages.append(ChatMessage(
                 timestamp: Date(timeIntervalSince1970: Double(ev.timestampUnixMs) / 1000),
                 senderName: sender,
-                text: ev.text ?? "",
+                text: body,
                 scope: ev.textScope))
+            EventFeedback.shared.play(isPrivate
+                ? (isSelf ? .pmSent : .pmRecv)
+                : (isSelf ? .channelSent : .channelRecv))
+            if !isSelf {
+                EventFeedback.shared.speak(isPrivate
+                    ? "Private message from \(sender): \(body)"
+                    : "\(sender): \(body)")
+            }
         case .talkState:
             let talking = ev.u32a != 0
+            if ev.userId == selfUserId {
+                EventFeedback.shared.play(talking ? .vaStart : .vaStop)
+            }
             let who = users.first(where: { $0.id == ev.userId })?.nickname ?? "user \(ev.userId)"
             addActivity(talking ? "\(who) started talking" : "\(who) stopped talking")
         case .streamStarted:
@@ -126,8 +176,6 @@ final class SessionState {
                 addActivity("Sharing screen audio (\(channels == 2 ? "stereo" : "mono"))")
                 break
             }
-            // A remote user started a stream — ensure the audio session is active so we can
-            // hear them even if we haven't joined voice ourselves.
             if ev.userId != selfUserId {
                 do {
                     try AudioSessionManager.shared.ensureSessionActive()
@@ -138,14 +186,48 @@ final class SessionState {
             AudioSessionManager.shared.logSessionState("stream started (user \(ev.userId))")
             addActivity("Stream started (user \(ev.userId))")
         case .streamStopped:
+            if ev.userId == selfUserId {
+                if ev.streamId == voiceState.localStreamId {
+                    voiceState.localStreamId = 0
+                    voiceState.micActive = false
+                    voiceState.level = 0
+                }
+            } else {
                 addActivity("Stream stopped (user \(ev.userId))")
+            }
+        case .voiceState:
+            let subscribed = ev.u32a != 0
+            voiceState.voiceSubscribed = subscribed
+            if subscribed {
+                doStartMicStream()
+            } else {
+                voiceState.micActive = false
+                voiceState.level = 0
+                EventFeedback.shared.play(.voiceOff)
+            }
         case .joinResult:
             if ev.result == .ok {
                 currentChannelId = ev.channelId
                 addActivity("Joined channel")
                 refreshUsers()
+                // Reconnect restore: this was our restore-join. Now that the server has
+                // processed the channel move, re-arm voice subscription (if the user was
+                // transmitting before the drop) and re-apply the local mute/deafen state.
+                // The server returns ok even when joining the channel we're already in, so
+                // this fires reliably for the Lobby-too case.
+                if didIssueRestoreJoin, let r = pendingRestore, r.channelId == ev.channelId {
+                    didIssueRestoreJoin = false
+                    completeRestore()
+                }
             } else {
                 addActivity("Join failed: \(ev.result.description)")
+                // Restore-join failed (channel was deleted, became password-protected or
+                // full while we were away). Give up on the voice/mute restore cleanly so we
+                // don't leave dangling state or attempt voice without being in a channel.
+                if didIssueRestoreJoin {
+                    didIssueRestoreJoin = false
+                    pendingRestore = nil
+                }
             }
         case .error:
             addActivity("Error: \(ev.text ?? ev.result.description)")
@@ -155,6 +237,16 @@ final class SessionState {
             }
         case .accountList:
             accounts = client.listAccounts()
+        case .disconnected:
+            // Audible cue, then hand the disconnect back to AppState so its reconnect state
+            // machine fires. This is the ONLY way AppState learns a live session dropped —
+            // after auth success, `SessionState.init` overwrites `client.onEvent`, so
+            // `AppState.handleConnectEvent` never sees this event. (Without this callback, a
+            // network drop on a live session would just play the cue and leave the session as a
+            // zombie — the user would have to tap Disconnect manually.)
+            EventFeedback.shared.play(ev.result == .ok ? .logout : .connectionLost)
+            EventFeedback.shared.speak(ev.result == .ok ? "Disconnected" : "Connection lost")
+            appState?.onLiveSessionDisconnected()
         default:
             break
         }
@@ -168,17 +260,18 @@ final class SessionState {
     // MARK: - Self-channel / server-mute sync
 
     /// Sync currentChannelId from the self user's channelId in the user list. Mirrors macOS
-    /// MainWindowController.swift:461,491,522. The server auto-places every authed user into
+    /// MainWindowController's bootstrap/event-handling sync. The server auto-places every
-    /// the Lobby (channel 1) on connect, but without this sync currentChannelId stays 0 and
+    /// authed user into the Lobby (channel 1) on connect, but without this sync
-    /// the mic button (gated on currentChannelId == 0) stays permanently dimmed.
+    /// currentChannelId stays 0 and the mic button (gated on currentChannelId == 0) stays
+    /// permanently dimmed.
     private func syncSelfChannel() {
         if let me = users.first(where: { $0.id == selfUserId }) {
             currentChannelId = me.channelId
         }
     }
 
-    /// Apply server-side mute/deafen state — mirrors macOS MainWindowController.swift:693-700.
+    /// Apply server-side mute/deafen state — mirrors macOS MainWindowController's handling
-    /// iOS was previously ignoring server mute/deafen entirely.
+    /// of UserEvent.UPDATED for the self user.
     private func applyServerMuteState(muted: Bool, deafened: Bool) {
         if muted && !voiceState.serverMuted { addActivity("You have been server-muted") }
         if deafened && !voiceState.serverDeafened { addActivity("You have been server-deafened") }
@@ -205,12 +298,15 @@ final class SessionState {
         currentChannelId = 0
     }
 
-    func startMicStream() {
+    func joinVoice() {
         AVAudioApplication.requestRecordPermission { [weak self] granted in
             DispatchQueue.main.async {
                 guard let self else { return }
                 if granted {
-                    self.doStartMicStream()
+                    let result = self.client.joinVoice()
+                    if result != .ok {
+                        self.addActivity("Failed to join voice: \(result.description)")
+                    }
                 } else {
                     self.addActivity("Microphone permission denied — grant in Settings > Privacy > Microphone")
                 }
@@ -226,94 +322,72 @@ final class SessionState {
             return
         }
 
-        // VPIO path: on the AEC presets, the native AVAudioEngine does AEC/NS/AGC and the core
-        // runs in external mode (no hardware mic/playback). The mic stream is started with
-        // externalFeed so the core skips the hardware capture device; setExternalPlayback makes
-        // it skip the hardware playback device and deliver the mix to IOSVoiceProcessingEngine.
-        //
-        // ORDER MATTERS: set the external-playback flag now, but defer audioRestart() until
-        // AFTER startStream (below) so the MIC LocalStream — which carries external_feed=true —
-        // already exists when ensure_audio_running() derives external_capture. Restarting before
-        // the stream exists makes the core reopen a hardware capture device that is never dropped
-        // (the announce-result restart early-returns because the engine is already running); that
-        // lingering miniaudio capture unit then fights the AVAudioEngine VPIO unit on the same
-        // .voiceChat session and silences VPIO playback.
-        let useVPIO = IOSAudioRouter.shared.currentConfigUsesVoiceProcessing
-        client.setExternalPlayback(useVPIO)
-
         let desc = StreamDescriptor(kind: .mic, deviceId: voiceState.currentDeviceId, label: "Mic",
-                                    externalFeed: useVPIO)
+                                    externalFeed: true)
         let (result, streamId) = client.startStream(desc)
-        if result == .ok {
+        guard result == .ok else {
+            addActivity("Failed to start mic: \(result.description)")
+            return
+        }
         voiceState.micActive = true
         voiceState.localStreamId = streamId
-            // Publish the active mic stream ID so IOSAudioRouter can reset the core's capture
+        EventFeedback.shared.play(.voiceOn)
-            // channel count when the user switches mono↔stereo (selectCaptureChannels /
+
-            // applyPreset). Without this, switching stereo→mono leaves the LocalStream's
-            // capture_channels field at 2 and the next engine start still opens stereo.
-            AudioSessionManager.shared.activeMicStreamId = streamId
-            // Store the user's capture channel selection before the server acknowledges
-            // the stream. The engine hasn't started yet at this point (it starts when
-            // handle_stream_announce_result fires), so vc_set_capture_channels just
-            // stores the value — no restart. ensure_audio_running() picks it up when
-            // the stream is confirmed and opens the device with the right channel count.
         let channels = IOSAudioRouter.shared.captureChannels.channelCount
         if channels != 1 {
             client.setCaptureChannels(streamId: streamId, channels: channels)
         }
-            if useVPIO {
+        IOSAudioEngine.shared.startMic(streamId: streamId, channels: channels)
-                // The external-feed MIC stream now exists, so restart the core into full
-                // external mode (no hardware capture/playback, mixer-timer only) — mic and
-                // speaker are owned entirely by the VPIO engine, which we start right after.
-                client.audioRestart()
-                IOSVoiceProcessingEngine.shared.start(
-                    client: client, micStreamId: streamId, captureChannels: channels)
     }
+
+    func leaveVoice() {
+        if voiceState.screenStreamId != 0 { stopScreenShare() }
+        client.setPushToTalk(false)
+        IOSAudioEngine.shared.stopMic()
+        client.leaveVoice()
+    }
+
+    // MARK: - Reconnect restore
+
+    /// Called by `AppState` after a reconnect's auth success to rejoin the prior channel and
+    /// re-enable the prior voice/mic state. Drives the restore through the `.joinResult` event
+    /// so we re-arm voice only AFTER the server processed the join — joining voice before the
+    /// channel move would be rejected server-side. `micMuted`/`deafened` are the user's LOCAL
+    /// mute/deafen state at the moment of the drop; the server resets those on a fresh auth, so
+    /// we re-push them via `setMute` after the channel is restored.
+    func requestRestore(channelId: UInt32, voiceSubscribed: Bool,
+                        micMuted: Bool, deafened: Bool) {
+        pendingRestore = RestoreRequest(channelId: channelId,
+                                        voiceSubscribed: voiceSubscribed,
+                                        micMuted: micMuted,
+                                        deafened: deafened)
+        didIssueRestoreJoin = false
+        if channelId != 0 {
+            // The server auto-placed us in the Lobby on auth; join our prior channel explicitly.
+            // `vc_join_channel` is idempotent server-side (joining the channel you're already in
+            // returns ok), so this is safe even if the prior channel was the Lobby.
+            client.joinChannel(channelId)
+            didIssueRestoreJoin = true
         } else {
-            addActivity("Failed to start mic: \(result.description)")
+            // No prior channel — go straight to the voice/mute restore. (voiceSubscribed with
-            if useVPIO {  // revert external-playback mode so remote audio still plays
+            // channelId == 0 is contradictory; `completeRestore` further guards on
-                client.setExternalPlayback(false)
+            // currentChannelId != 0 before subscribing to voice.)
-                client.audioRestart()
+            completeRestore()
-            }
         }
     }
 
-    func stopMicStream() {
+    /// Finish the restore after the channel is in place (or there was no channel to restore):
-        // Tear down the VPIO engine first (removes the mic tap + unregisters the mixed sink),
+    /// re-subscribe to voice if the user was transmitting, and re-apply the local mute/deafen
-        // then stop the mic stream, then restore the core's hardware playback for any remaining
+    /// state. Safe to call once per `pendingRestore`; clears it.
-        // remote audio. Order matters: the mic stream must be gone before audioRestart so the
+    private func completeRestore() {
-        // core opens a normal playback device (and no capture device — there's no mic stream).
+        guard let r = pendingRestore else { return }
-        let wasVPIO = IOSVoiceProcessingEngine.shared.isRunning
+        if r.voiceSubscribed && currentChannelId != 0 {
-        if wasVPIO {
+            joinVoice()
-            IOSVoiceProcessingEngine.shared.stop()
         }
-        if voiceState.localStreamId != 0 {
+        setMute(r.micMuted, deafened: r.deafened)
-            client.stopStream(voiceState.localStreamId)
+        addActivity("Restored to channel \(currentChannelId)"
-            voiceState.localStreamId = 0
+                    + (r.voiceSubscribed ? " with voice" : ""))
-            AudioSessionManager.shared.activeMicStreamId = nil
+        pendingRestore = nil
-        }
-        if wasVPIO {
-            client.setExternalPlayback(false)
-            client.audioRestart()  // reopen hardware playback (no mic stream → no hw capture)
-        }
-        voiceState.micActive = false
-        voiceState.level = 0
-        // Do NOT deactivate the AVAudioSession here — the user may still want to hear
-        // remote audio (other people talking). The session is deactivated only when
-        // disconnecting from the server (see AppState.disconnect / .disconnected event).
-    }
-
-    /// Restart the voice path when the audio config changes mid-call (driven by IOSAudioRouter).
-    /// If VPIO is involved on either the current or desired side, restart the mic so the native
-    /// voice-processing engine engages/disengages and re-binds to the new route. Pure miniaudio
-    /// config tweaks need no restart — the core's own audioRestart (already issued) handles them.
-    private func reconcileVoicePath() {
-        guard voiceState.micActive else { return }
-        let want = IOSAudioRouter.shared.currentConfigUsesVoiceProcessing
-        let have = IOSVoiceProcessingEngine.shared.isRunning
-        guard want || have else { return }
-        stopMicStream()
-        doStartMicStream()
     }
 
     // MARK: - Screen audio share
@@ -360,15 +434,65 @@ final class SessionState {
     func setInputMode(_ mode: VoiceCatInputMode) {
         client.setInputMode(mode)
         voiceState.inputMode = mode
+        UserDefaults.standard.set(Int(mode.rawValue), forKey: DefaultsKey.inputMode)
     }
 
     func setVadThreshold(_ threshold: Float) {
         client.setVadThreshold(threshold)
         voiceState.vadThreshold = threshold
+        UserDefaults.standard.set(threshold, forKey: DefaultsKey.vadThreshold)
     }
 
+    func setInputGain(_ gain: Float) {
+        client.setInputGain(gain)
+        voiceState.inputGain = gain
+        UserDefaults.standard.set(gain, forKey: DefaultsKey.inputGain)
+    }
+
+    func setInputNoiseReduction(_ on: Bool) {
+        client.setInputNoiseReduction(on)
+        voiceState.inputNoiseReduction = on
+        UserDefaults.standard.set(on, forKey: DefaultsKey.inputNoiseReduction)
+    }
+
+    // MARK: - Persisted input settings
+
+    private enum DefaultsKey {
+        static let inputMode    = "voice.inputMode"
+        static let vadThreshold = "voice.vadThreshold"
+        static let inputGain    = "voice.inputGain"
+        static let inputNoiseReduction = "voice.inputNoiseReduction"
+    }
+
+    /// Restore the saved input mode / VAD threshold / mic gain and push them into the core so a
+    /// relaunch keeps the user's transmission settings instead of resetting to VAD defaults.
+    private func loadAndApplyVoiceSettings() {
+        let d = UserDefaults.standard
+        if d.object(forKey: DefaultsKey.inputMode) != nil {
+            let raw = UInt32(d.integer(forKey: DefaultsKey.inputMode))
+            voiceState.inputMode = VoiceCatInputMode(rawValue: raw) ?? .voiceActivation
+        }
+        if d.object(forKey: DefaultsKey.vadThreshold) != nil {
+            voiceState.vadThreshold = d.float(forKey: DefaultsKey.vadThreshold)
+        }
+        if d.object(forKey: DefaultsKey.inputGain) != nil {
+            voiceState.inputGain = d.float(forKey: DefaultsKey.inputGain)
+        }
+        if d.object(forKey: DefaultsKey.inputNoiseReduction) != nil {
+            voiceState.inputNoiseReduction = d.bool(forKey: DefaultsKey.inputNoiseReduction)
+        }
+        client.setInputMode(voiceState.inputMode)
+        client.setVadThreshold(voiceState.vadThreshold)
+        client.setInputGain(voiceState.inputGain)
+        client.setInputNoiseReduction(voiceState.inputNoiseReduction)
+    }
+
+    private var pttEngaged = false
     func setPushToTalk(_ active: Bool) {
         client.setPushToTalk(active)
+        // Play the PTT cue only on the press transition (the gesture fires repeatedly while held).
+        if active && !pttEngaged { EventFeedback.shared.play(.ptt) }
+        pttEngaged = active
     }
 
     // MARK: - Text

clients/apple/iOS/VoiceCatiOS/Views/ChannelEditView.swift

@@ -15,8 +15,7 @@ struct ChannelEditView: View {
     @State private var maxUsers = "0"
     @State private var sortOrder = "0"
 
-    // Audio (Opus). Note: the channel list does not carry the current audio config, so when
+    // Audio (Opus) — populated from the channel's current config when editing.
-    // editing an existing channel these start from the codec defaults (same as macOS/Windows).
     @State private var stereo = false
     @State private var bitrate = "64000"
     @State private var sampleRate = "48000"
@@ -122,6 +121,17 @@ struct ChannelEditView: View {
         parentId = ch.parentId
         passwordProtected = ch.passwordProtected
         maxUsers = "\(ch.maxUsers)"
+        sortOrder = "\(ch.sortOrder)"
+        stereo = ch.audio.stereo
+        bitrate = "\(ch.audio.bitrateBps)"
+        sampleRate = "\(ch.audio.sampleRate)"
+        frameMs = ch.audio.frameMs
+        application = ch.audio.application
+        packetLoss = "\(ch.audio.expectedPacketLoss)"
+        complexity = Int(ch.audio.complexity)
+        fec = ch.audio.fec
+        dtx = ch.audio.dtx
+        dred = ch.audio.dred
     }
 
     private func save() {

clients/apple/iOS/VoiceCatiOS/Views/ChatView.swift

@@ -91,7 +91,7 @@ struct ChatView: View {
     private func sendMessage() {
         let text = composeText.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !text.isEmpty else { return }
-        session.sendText(text, scope: .channel)
+        session.sendText(text, scope: .channel, targetId: session.currentChannelId)
         composeText = ""
     }
 }

clients/apple/iOS/VoiceCatiOS/Views/PerUserTuningView.swift

@@ -20,7 +20,7 @@ struct PerUserTuningView: View {
                 Section("Volume") {
                     HStack {
                         Text("Gain")
-                        Slider(value: $gain, in: 0...2, step: 0.05) { _ in
+                        Slider(value: $gain, in: 0...4, step: 0.05) { _ in
                             applyToAllStreams()
                         }
                         .accessibilityLabel("Volume gain for \(user.nickname)")
@@ -48,7 +48,6 @@ struct PerUserTuningView: View {
             }
         }
         .onAppear {
-            // Load from first stream if available
             let streams = streamsForUser
             if let first = streams.first {
                 let (_, state) = session.client.getRemoteStream(userId: user.id, streamId: first.id)

clients/apple/iOS/VoiceCatiOS/Views/SettingsView.swift

@@ -8,6 +8,14 @@ struct SettingsView: View {
     @StateObject private var router = IOSAudioRouter.shared
     @State private var showAdvanced = false
 
+    // Notification feedback prefs — keys shared with VoiceCatCore's FeedbackSettings, so the
+    // EventFeedback player reads the same values these toggles write.
+    @AppStorage("feedback.sounds")   private var soundsEnabled = true
+    @AppStorage("feedback.speech")   private var speechEnabled = false
+    @AppStorage("feedback.volume")   private var soundsVolume = 1.0
+    @AppStorage("feedback.selfTalk") private var selfTalkEnabled = false
+    @AppStorage("feedback.ptt")      private var pttSoundEnabled = false
+
     var body: some View {
         NavigationStack {
             Form {
@@ -30,9 +38,9 @@ struct SettingsView: View {
                     .accessibilityLabel("Speaker output")
                     .accessibilityHint("Routes audio to the speaker instead of the earpiece when no headphones are connected.")
 
-                    // Surface the voice-processing state. On the AEC presets the native iOS
+                    // Surface the voice-processing state. On Voice Chat the native iOS
                     // Voice-Processing unit (VPIO) does echo cancellation, noise suppression and
-                    // automatic gain control; the other presets (stereo/studio/A2DP) can't use it.
+                    // automatic gain control; the stereo / mono-mic / A2DP configs can't use it.
                     if router.currentConfigUsesVoiceProcessing {
                         Label("Echo cancellation & noise suppression on (iOS voice processing)",
                               systemImage: "waveform.badge.mic")
@@ -40,18 +48,11 @@ struct SettingsView: View {
                             .foregroundStyle(.secondary)
                             .accessibilityLabel("Echo cancellation and noise suppression are on")
                     } else {
-                        Label("No echo cancellation in this preset (stereo / studio / A2DP)",
+                        Label("No echo cancellation in this configuration (stereo / A2DP / off)",
                               systemImage: "waveform.slash")
                             .font(.caption)
                             .foregroundStyle(.secondary)
-                            .accessibilityLabel("Echo cancellation is off in this preset")
+                            .accessibilityLabel("Echo cancellation is off in this configuration")
-                    }
-
-                    if !router.hasBluetoothDevice && !router.hasWiredHeadset {
-                        Text("Connect Bluetooth headphones or a wired headset for more presets.")
-                            .font(.caption)
-                            .foregroundStyle(.secondary)
-                            .accessibilityLabel("No external audio device connected")
                     }
                 }
 
@@ -119,6 +120,27 @@ struct SettingsView: View {
                         }
                         .accessibilityLabel("Microphone processing mode")
 
+                        // Voice-processing (VPIO) controls — only meaningful on a VPIO-capable
+                        // config (mono + standard + non-A2DP). iOS bundles echo cancellation and
+                        // noise suppression into one master switch (no per-stage toggle); AGC is
+                        // the one sub-stage it lets us control independently.
+                        if router.voiceProcessingAvailable {
+                            Toggle("Voice Processing (AEC + noise suppression)", isOn: Binding(
+                                get: { router.voiceProcessingEnabled },
+                                set: { router.setVoiceProcessingEnabled($0) }
+                            ))
+                            .accessibilityLabel("Voice processing")
+                            .accessibilityHint("Echo cancellation and noise suppression, bundled together by iOS.")
+
+                            if router.voiceProcessingEnabled {
+                                Toggle("Automatic Gain Control", isOn: Binding(
+                                    get: { router.agcEnabled },
+                                    set: { router.setAgcEnabled($0) }
+                                ))
+                                .accessibilityLabel("Automatic gain control")
+                            }
+                        }
+
                         if router.showsRawModeSpeakerWarning {
                             Label(
                                 "Raw mode on speaker — echo risk (no AEC)",
@@ -215,6 +237,48 @@ struct SettingsView: View {
                             .accessibilityLabel("Voice activation threshold")
                         }
                     }
+
+                    VStack(alignment: .leading, spacing: 4) {
+                        Text("Mic Volume: \(Int((session.voiceState.inputGain * 100).rounded()))%")
+                            .font(.caption)
+                        Slider(
+                            value: Binding(
+                                get: { Double(session.voiceState.inputGain) },
+                                set: { session.setInputGain(Float($0)) }
+                            ),
+                            in: 0...4, step: 0.05
+                        )
+                        .accessibilityLabel("Microphone volume")
+                        .accessibilityValue("\(Int((session.voiceState.inputGain * 100).rounded())) percent")
+                    }
+
+                    Toggle("Noise Reduction (RNNoise)", isOn: Binding(
+                        get: { session.voiceState.inputNoiseReduction },
+                        set: { session.setInputNoiseReduction($0) }
+                    ))
+                    .accessibilityLabel("Microphone noise reduction")
+                    .accessibilityHint("Denoises your microphone signal for everyone listening.")
+                }
+
+                // MARK: - Notifications
+                Section("Notifications") {
+                    Toggle("Event sounds", isOn: $soundsEnabled)
+                        .accessibilityLabel("Play event sounds")
+                    if soundsEnabled {
+                        VStack(alignment: .leading, spacing: 4) {
+                            Text("Sound volume")
+                                .font(.caption)
+                            Slider(value: $soundsVolume, in: 0...1)
+                                .accessibilityLabel("Sound volume")
+                        }
+                    }
+                    Toggle("Speak events (text-to-speech)", isOn: $speechEnabled)
+                        .accessibilityLabel("Speak events")
+                        .accessibilityHint("Announces joins and leaves and reads message text aloud.")
+                    Toggle("Your own voice-activity sounds", isOn: $selfTalkEnabled)
+                        .accessibilityLabel("Voice activity sounds")
+                    Toggle("Push-to-talk cue", isOn: $pttSoundEnabled)
+                        .accessibilityLabel("Push to talk cue")
                 }
 
                 // MARK: - Admin
@@ -230,7 +294,7 @@ struct SettingsView: View {
                 // MARK: - Server
                 Section("Server") {
                     Button(role: .destructive) {
-                        session.stopMicStream()
+                        session.leaveVoice()
                         appState.disconnect()
                     } label: {
                         Label("Disconnect", systemImage: "phone.down")

clients/apple/iOS/VoiceCatiOS/Views/UserRow.swift

@@ -18,6 +18,10 @@ struct UserRow: View {
     var body: some View {
         UserRowView(user: user, isSelf: user.id == session.selfUserId)
             .contextMenu { contextMenu }
+            // The context menu is long-press only, which VoiceOver doesn't surface — mirror the
+            // same buttons as accessibility actions so VoiceOver users can reach per-user tuning
+            // (and the admin actions) via the actions rotor on the focused row.
+            .accessibilityActions { contextMenu }
             .sheet(item: $activeSheet) { sheet in
                 switch sheet {
                 case .tuning:      PerUserTuningView(user: user, session: session)

clients/apple/iOS/VoiceCatiOS/Views/VoiceControlsView.swift

@@ -14,9 +14,9 @@ struct VoiceControlsView: View {
             } else {
                 Button {
                     if session.voiceState.micActive {
-                        session.stopMicStream()
+                        session.leaveVoice()
                     } else {
-                        session.startMicStream()
+                        session.joinVoice()
                     }
                 } label: {
                     Text(session.voiceState.micActive ? "Leave Voice" : "Join Voice")
@@ -28,7 +28,7 @@ struct VoiceControlsView: View {
                         .foregroundStyle(session.voiceState.micActive ? .green : .accentColor)
                 }
                 .disabled(session.currentChannelId == 0)
-                .accessibilityLabel(session.voiceState.micActive ? "Leave Voice — stop sending microphone audio" : "Join Voice — start sending microphone audio")
+                .accessibilityLabel(session.voiceState.micActive ? "Leave Voice" : "Join Voice")
             }
 
             // Level meter
@@ -81,7 +81,7 @@ struct VoiceControlsView: View {
 
             // Disconnect
             Button(role: .destructive) {
-                session.stopMicStream()
+                session.leaveVoice()
                 session.client.disconnect()
             } label: {
                 Image(systemName: "phone.down.fill")
@@ -115,13 +115,13 @@ private struct PTTButton: View {
                     .updating($isPressing) { _, state, _ in state = true }
                     .onChanged { _ in
                         if !isPressing { return }
-                        if !session.voiceState.micActive { session.startMicStream() }
+                        if !session.voiceState.micActive { session.joinVoice() }
                         session.setPushToTalk(true)
                         UIImpactFeedbackGenerator(style: .medium).impactOccurred()
                     }
                     .onEnded { _ in
                         session.setPushToTalk(false)
-                        session.stopMicStream()
+                        session.leaveVoice()
                     }
             )
             .accessibilityLabel("Push to talk, hold to transmit")

clients/apple/iOS/VoiceCatiOS/VoiceCatiOS.entitlements

@@ -4,7 +4,7 @@
 <dict>
 	<key>com.apple.security.application-groups</key>
 	<array>
-		<string>group.cat.voice.VoiceCat</string>
+		<string>group.me.iamtalon.voicecat</string>
 	</array>
 </dict>
 </plist>

clients/apple/macOS/VoiceCatMac.xcodeproj/project.pbxproj

@@ -31,6 +31,7 @@
 		AAAA00000000000000000048 /* UserPickerSheet.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAAA00000000000000000047 /* UserPickerSheet.swift */; };
 		AAAA0000000000000000004A /* SettingsWindowController.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAAA00000000000000000049 /* SettingsWindowController.swift */; };
 		AAAA0000000000000000004C /* ScreenAudioCapture.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAAA0000000000000000004B /* ScreenAudioCapture.swift */; };
+		AAAA00000000000000000051 /* InputDeviceCapture.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAAA00000000000000000050 /* InputDeviceCapture.swift */; };
 		AAAA0000000000000000004E /* ScreenSharePickerSheet.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAAA0000000000000000004F /* ScreenSharePickerSheet.swift */; };
 /* End PBXBuildFile section */
 
@@ -45,6 +46,7 @@
 		AAAA00000000000000000019 /* ConnectWindowController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ConnectWindowController.swift; sourceTree = "<group>"; };
 		AAAA0000000000000000001A /* MainWindowController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MainWindowController.swift; sourceTree = "<group>"; };
 		AAAA0000000000000000004B /* ScreenAudioCapture.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ScreenAudioCapture.swift; sourceTree = "<group>"; };
+		AAAA00000000000000000050 /* InputDeviceCapture.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = InputDeviceCapture.swift; sourceTree = "<group>"; };
 		AAAA0000000000000000001B /* AddServerSheet.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AddServerSheet.swift; sourceTree = "<group>"; };
 		AAAA0000000000000000001C /* ServerIdentitySheet.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ServerIdentitySheet.swift; sourceTree = "<group>"; };
 		AAAA0000000000000000001D /* PasswordPromptSheet.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PasswordPromptSheet.swift; sourceTree = "<group>"; };
@@ -104,6 +106,7 @@
 			isa = PBXGroup;
 			children = (
 				AAAA0000000000000000004B /* ScreenAudioCapture.swift */,
+				AAAA00000000000000000050 /* InputDeviceCapture.swift */,
 			);
 			path = Audio;
 			sourceTree = "<group>";
@@ -247,6 +250,7 @@
 				AAAA0000000000000000004E /* ScreenSharePickerSheet.swift in Sources */,
 				AAAA0000000000000000004A /* SettingsWindowController.swift in Sources */,
 				AAAA0000000000000000004C /* ScreenAudioCapture.swift in Sources */,
+				AAAA00000000000000000051 /* InputDeviceCapture.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

clients/apple/macOS/VoiceCatMac/Audio/InputDeviceCapture.swift

@@ -0,0 +1,229 @@
+import AVFoundation
+import CoreAudio
+
+// InputDeviceCapture — captures a single hardware INPUT device (mic / line-in / aux) on macOS and
+// emits 20 ms (960 samples/channel @ 48 kHz, interleaved int16) frames for the aux outgoing stream.
+//
+// The input-device analogue of ScreenAudioCapture (which captures system audio via
+// ScreenCaptureKit). The core already owns ONE capture device (the mic) and can't open a second
+// arbitrary input, so for the aux stream the client captures the chosen device here and feeds PCM
+// into the core via `vc_stream_feed_pcm` — the same external-feed pipeline screen audio uses.
+//
+// Device selection: an AVAudioEngine's input node wraps an AUHAL audio unit; setting
+// kAudioOutputUnitProperty_CurrentDevice on it pins capture to a specific Core Audio device. We
+// pass the device's *UID* (stable across reboots/replugs, unlike AudioDeviceID) and resolve it at
+// start. The tap delivers Float32; AVAudioConverter resamples/quantises to 48 kHz int16.
+final class InputDeviceCapture {
+
+    /// Receives a full 20 ms frame: (interleaved int16 PCM, samplesPerChannel = 960, channels).
+    typealias PcmHandler = (UnsafePointer<Int16>, Int, UInt32) -> Void
+
+    enum CaptureError: Error { case deviceNotFound, engineStartFailed(OSStatus) }
+
+    private static let frameSamplesPerChannel = 960  // 20 ms @ 48 kHz
+
+    private let deviceUID: String?  // nil = system default input device
+    private let onPcm: PcmHandler
+    private let engine = AVAudioEngine()
+    private var converter: AVAudioConverter?
+    private var outFormat: AVAudioFormat?
+    private var channels = 1
+
+    /// Interleaved int16 carry-over between tap callbacks (the tap buffer doesn't align to 20 ms),
+    /// drained in whole `frameSamplesPerChannel * channels` chunks. Only touched on the tap queue.
+    private var pending: [Int16] = []
+
+    init(deviceUID: String?, onPcm: @escaping PcmHandler) {
+        self.deviceUID = deviceUID
+        self.onPcm = onPcm
+    }
+
+    /// Begin capture. Throws if the device can't be resolved or the engine fails to start.
+    func start() throws {
+        let input = engine.inputNode
+
+        // Pin the engine's AUHAL to the chosen device (skip for default — the engine already uses
+        // the system default input). Must happen before reading inputFormat, which changes with
+        // the selected device.
+        if let deviceUID, let devId = Self.deviceID(forUID: deviceUID) {
+            var dev = devId
+            let status = AudioUnitSetProperty(input.audioUnit!,
+                                              kAudioOutputUnitProperty_CurrentDevice,
+                                              kAudioUnitScope_Global, 0,
+                                              &dev, UInt32(MemoryLayout<AudioDeviceID>.size))
+            if status != noErr { throw CaptureError.engineStartFailed(status) }
+        } else if deviceUID != nil {
+            throw CaptureError.deviceNotFound
+        }
+
+        let inFormat = input.inputFormat(forBus: 0)
+        channels = max(1, min(2, Int(inFormat.channelCount)))
+        guard let out = AVAudioFormat(commonFormat: .pcmFormatInt16, sampleRate: 48000,
+                                      channels: AVAudioChannelCount(channels), interleaved: true)
+        else { throw CaptureError.deviceNotFound }
+        outFormat = out
+        converter = AVAudioConverter(from: inFormat, to: out)
+
+        input.installTap(onBus: 0, bufferSize: 960, format: inFormat) { [weak self] buf, _ in
+            self?.process(buf)
+        }
+        engine.prepare()
+        do { try engine.start() }
+        catch { throw CaptureError.engineStartFailed(-1) }
+    }
+
+    /// Stop capture and tear down the engine. Safe to call multiple times.
+    func stop() {
+        engine.inputNode.removeTap(onBus: 0)
+        if engine.isRunning { engine.stop() }
+        converter = nil
+        pending.removeAll(keepingCapacity: false)
+    }
+
+    // MARK: - Conversion (called on the tap's realtime thread)
+
+    private func process(_ inBuf: AVAudioPCMBuffer) {
+        guard let converter, let outFormat else { return }
+
+        // Output capacity must cover up-sampling (e.g. 44.1 → 48 kHz) plus slack.
+        let ratio = outFormat.sampleRate / inBuf.format.sampleRate
+        let cap = AVAudioFrameCount(Double(inBuf.frameLength) * ratio + 32)
+        guard cap > 0, let outBuf = AVAudioPCMBuffer(pcmFormat: outFormat, frameCapacity: cap)
+        else { return }
+
+        var fed = false
+        var err: NSError?
+        let status = converter.convert(to: outBuf, error: &err) { _, outStatus in
+            if fed { outStatus.pointee = .noDataNow; return nil }
+            fed = true
+            outStatus.pointee = .haveData
+            return inBuf
+        }
+        guard status != .error, outBuf.frameLength > 0,
+              let ch = outBuf.int16ChannelData else { return }
+
+        // Interleaved int16: all channels live in the first buffer (ch[0]).
+        let n = Int(outBuf.frameLength) * channels
+        pending.append(contentsOf: UnsafeBufferPointer(start: ch[0], count: n))
+        emit()
+    }
+
+    /// Fire `onPcm` for every whole 20 ms frame accumulated.
+    private func emit() {
+        let full = Self.frameSamplesPerChannel * channels
+        while pending.count >= full {
+            pending.withUnsafeBufferPointer { buf in
+                onPcm(buf.baseAddress!, Self.frameSamplesPerChannel, UInt32(channels))
+            }
+            pending.removeFirst(full)
+        }
+    }
+
+    // MARK: - UID → AudioDeviceID resolution
+
+    private static func deviceID(forUID uid: String) -> AudioDeviceID? {
+        var addr = AudioObjectPropertyAddress(
+            mSelector: kAudioHardwarePropertyTranslateUIDToDevice,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain)
+        var deviceID = AudioDeviceID(0)
+        var cfUID = uid as CFString
+        var size = UInt32(MemoryLayout<AudioDeviceID>.size)
+        let status = withUnsafeMutablePointer(to: &cfUID) { uidPtr -> OSStatus in
+            AudioObjectGetPropertyData(AudioObjectID(kAudioObjectSystemObject), &addr,
+                                       UInt32(MemoryLayout<CFString>.size), uidPtr,
+                                       &size, &deviceID)
+        }
+        return (status == noErr && deviceID != 0) ? deviceID : nil
+    }
+}
+
+// InputDeviceInfo / InputDeviceEnumerator — Core Audio input-device enumeration for the aux-stream
+// picker. Separate from the core's vc_list_devices (whose ids are miniaudio-opaque and can't be
+// passed to Core Audio); the aux device is client-captured, so the picker uses device UIDs.
+struct InputDeviceInfo: Equatable {
+    let uid: String       // stable across reboots/replugs — what we persist
+    let name: String
+    let isDefault: Bool
+}
+
+enum InputDeviceEnumerator {
+
+    /// All Core Audio devices that expose at least one input channel.
+    static func list() -> [InputDeviceInfo] {
+        let defaultUID = defaultInputUID()
+        var result: [InputDeviceInfo] = []
+
+        for devID in allDeviceIDs() {
+            guard inputChannelCount(devID) > 0 else { continue }
+            guard let uid = stringProperty(devID, kAudioDevicePropertyDeviceUID) else { continue }
+            let name = stringProperty(devID, kAudioObjectPropertyName)
+                ?? stringProperty(devID, kAudioDevicePropertyDeviceNameCFString)
+                ?? "Unknown input device"
+            result.append(InputDeviceInfo(uid: uid, name: name, isDefault: uid == defaultUID))
+        }
+        return result.sorted { $0.name.localizedCaseInsensitiveCompare($1.name) == .orderedAscending }
+    }
+
+    // MARK: - Core Audio helpers
+
+    private static func allDeviceIDs() -> [AudioDeviceID] {
+        var addr = AudioObjectPropertyAddress(
+            mSelector: kAudioHardwarePropertyDevices,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain)
+        var size = UInt32(0)
+        guard AudioObjectGetPropertyDataSize(AudioObjectID(kAudioObjectSystemObject), &addr, 0, nil,
+                                             &size) == noErr, size > 0 else { return [] }
+        let count = Int(size) / MemoryLayout<AudioDeviceID>.size
+        var ids = [AudioDeviceID](repeating: 0, count: count)
+        let status = AudioObjectGetPropertyData(AudioObjectID(kAudioObjectSystemObject), &addr, 0,
+                                                nil, &size, &ids)
+        return status == noErr ? ids : []
+    }
+
+    private static func inputChannelCount(_ devID: AudioDeviceID) -> Int {
+        var addr = AudioObjectPropertyAddress(
+            mSelector: kAudioDevicePropertyStreamConfiguration,
+            mScope: kAudioObjectPropertyScopeInput,
+            mElement: kAudioObjectPropertyElementMain)
+        var size = UInt32(0)
+        guard AudioObjectGetPropertyDataSize(devID, &addr, 0, nil, &size) == noErr, size > 0
+        else { return 0 }
+        let bufList = UnsafeMutableRawPointer.allocate(byteCount: Int(size),
+                                                       alignment: MemoryLayout<AudioBufferList>.alignment)
+        defer { bufList.deallocate() }
+        guard AudioObjectGetPropertyData(devID, &addr, 0, nil, &size, bufList) == noErr
+        else { return 0 }
+        let abl = UnsafeMutableAudioBufferListPointer(
+            bufList.assumingMemoryBound(to: AudioBufferList.self))
+        return abl.reduce(0) { $0 + Int($1.mNumberChannels) }
+    }
+
+    private static func defaultInputUID() -> String? {
+        var addr = AudioObjectPropertyAddress(
+            mSelector: kAudioHardwarePropertyDefaultInputDevice,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain)
+        var devID = AudioDeviceID(0)
+        var size = UInt32(MemoryLayout<AudioDeviceID>.size)
+        guard AudioObjectGetPropertyData(AudioObjectID(kAudioObjectSystemObject), &addr, 0, nil,
+                                         &size, &devID) == noErr, devID != 0 else { return nil }
+        return stringProperty(devID, kAudioDevicePropertyDeviceUID)
+    }
+
+    private static func stringProperty(_ devID: AudioDeviceID,
+                                       _ selector: AudioObjectPropertySelector) -> String? {
+        var addr = AudioObjectPropertyAddress(
+            mSelector: selector,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain)
+        var cf: CFString? = nil
+        var size = UInt32(MemoryLayout<CFString?>.size)
+        let status = withUnsafeMutablePointer(to: &cf) { ptr in
+            AudioObjectGetPropertyData(devID, &addr, 0, nil, &size, ptr)
+        }
+        guard status == noErr else { return nil }
+        return cf as String?
+    }
+}

clients/apple/macOS/VoiceCatMac/Audio/ScreenAudioCapture.swift

@@ -1,14 +1,11 @@
 import AVFoundation
 import ScreenCaptureKit
 
-// Which apps' audio the SCREEN_AUDIO stream captures. ScreenCaptureKit filters audio at the
+// ScreenCaptureKit filters audio by application bundle identifier.
-// *application* level (not per-window), so the selection is expressed as bundle IDs. The
-// picker UI (ScreenSharePickerSheet) produces a `ScreenAudioSelection`; `start()` turns it
-// into the matching `SCContentFilter`.
 enum ScreenAudioScope: Equatable {
-    case entireDesktop          // whole display — the original behaviour
+    case entireDesktop
-    case onlyApps([String])     // capture only these bundle IDs
+    case onlyApps([String])
-    case allExcept([String])    // capture everything except these bundle IDs
+    case allExcept([String])
 }
 
 struct ScreenAudioSelection: Equatable {
@@ -20,20 +17,8 @@ struct ScreenAudioSelection: Equatable {
     static let `default` = ScreenAudioSelection()
 }
 
-// ScreenAudioCapture — macOS system/desktop audio capture for the SCREEN_AUDIO stream.
+// SCStream requires a minimal video configuration even for audio-only capture. Only its audio
-//
+// output is registered, and current-process audio is excluded to prevent feedback.
-// The macOS analog of the Windows WASAPI loopback path (docs/voice.md §9). ScreenCaptureKit
-// (macOS 13+) captures whatever the system is playing; we convert each audio CMSampleBuffer
-// (Float32) → int16 interleaved and push 20 ms frames (960 samples/channel @ 48 kHz) into the
-// core via `vc_stream_feed_pcm` (exposed as `VoiceCatClient.feedPcm`). The core then runs the
-// same Opus-encode → media-AEAD → UDP path as any other stream — only the *source* is
-// platform-specific (architecture.md §4).
-//
-// Audio-only: we request a 2×2 video plane at 1 fps purely because SCStream needs a video
-// configuration, and we never add a `.screen` output — only `.audio`. `excludesCurrentProcess
-// Audio` prevents the self-echo loop of re-capturing our own incoming voice mix.
-//
-// `feedPcm` is thread-safe (any thread), so we forward straight from the sample-handler queue.
 final class ScreenAudioCapture: NSObject, SCStreamOutput, SCStreamDelegate {
 
     /// Receives a full 20 ms frame: (interleaved int16 PCM, samplesPerChannel = 960, channels).

clients/apple/macOS/VoiceCatMac/Sheets/PerUserTuningSheet.swift

@@ -49,7 +49,7 @@ final class PerUserTuningSheet: NSViewController {
             let muted = state?.muted ?? false
             let nr = state?.noiseReduction ?? false
 
-            let gainSlider = NSSlider(value: Double(gain * 100), minValue: 0, maxValue: 200, target: self, action: #selector(sliderChanged))
+            let gainSlider = NSSlider(value: Double(gain * 100), minValue: 0, maxValue: 400, target: self, action: #selector(sliderChanged))
             gainSlider.tag = Int(stream.id)
             gainSlider.numberOfTickMarks = 0
             gainSlider.setAccessibilityLabel("Volume for \(stream.label): \(Int(gain * 100)) percent")

clients/apple/macOS/VoiceCatMac/Windows/ConnectWindowController.swift

@@ -44,7 +44,6 @@ final class ConnectWindowController: NSWindowController, NSWindowDelegate {
     private func buildUI() {
         guard let contentView = window?.contentView else { return }
 
-        // Server list
         let col = NSTableColumn(identifier: NSUserInterfaceItemIdentifier("server"))
         col.title = "Saved Servers"
         serverTableView.addTableColumn(col)
@@ -61,7 +60,6 @@ final class ConnectWindowController: NSWindowController, NSWindowDelegate {
         serverScrollView.translatesAutoresizingMaskIntoConstraints = false
         contentView.addSubview(serverScrollView)
 
-        // Buttons row
         configureButton(addButton, title: "Add…", action: #selector(addClicked))
         configureButton(editButton, title: "Edit…", action: #selector(editClicked))
         configureButton(removeButton, title: "Remove", action: #selector(removeClicked))
@@ -72,13 +70,11 @@ final class ConnectWindowController: NSWindowController, NSWindowDelegate {
         buttonStack.translatesAutoresizingMaskIntoConstraints = false
         contentView.addSubview(buttonStack)
 
-        // Status
         statusLabel.translatesAutoresizingMaskIntoConstraints = false
         statusLabel.textColor = .secondaryLabelColor
         statusLabel.setAccessibilityLabel("Connection status")
         contentView.addSubview(statusLabel)
 
-        // Connect button
         connectButton.title = "Connect"
         connectButton.bezelStyle = .rounded
         connectButton.keyEquivalent = "\r"
@@ -376,7 +372,3 @@ extension ConnectWindowController: NSTableViewDataSource, NSTableViewDelegate {
         return cell
     }
 }
-
-// MARK: - Helper
-
-

clients/apple/macOS/VoiceCatMac/Windows/MainWindowController.swift

@@ -31,10 +31,15 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
     internal var micStreamId: UInt32 = 0
     private var screenStreamId: UInt32 = 0
     private var screenCapture: ScreenAudioCapture?
+    private var auxStreamId: UInt32 = 0          // 0 = aux (second input device) stream not active
+    private var auxCapture: InputDeviceCapture?  // client-side capture feeding the aux stream
     // Last app/exclusion choice from the share picker; reused as the default next time.
     private var screenAudioSelection: ScreenAudioSelection = .default
-    internal var pttKeyCode: UInt16 = 0x60  // F8
+    internal var pttKeyCode: UInt16 = 0x60 {  // F8
+        didSet { UserDefaults.standard.set(Int(pttKeyCode), forKey: AudioDefaults.pttKeyCode) }
+    }
     private var pttMonitor: Any?
+    private var pttEngaged = false  // guards the PTT cue against key-repeat
     private var serverMuted = false
     private var serverDeafened = false
     private var channelTree: [ChannelNode] = []
@@ -48,11 +53,56 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
     private var settingsWindowController: SettingsWindowController?
 
     // MARK: - Audio settings state (source of truth — read/written by SettingsWindowController)
+    // The input mode / VAD threshold / mic gain / PTT key persist via UserDefaults (didSet below)
+    // so they survive relaunch; loadPersistedAudioSettings() restores them at startup and they are
+    // pushed into the core when the mic stream starts (micToggleClicked).
 
-    internal var selectedInputMode: VoiceCatInputMode = .voiceActivation
+    enum AudioDefaults {
-    internal var vadThresholdValue: Float = 0.05
+        static let inputMode    = "voice.inputMode"
+        static let vadThreshold = "voice.vadThreshold"
+        static let inputGain    = "voice.inputGain"
+        static let inputNoiseReduction = "voice.inputNoiseReduction"
+        static let stereoMic    = "voice.stereoMic"
+        static let pttKeyCode   = "voice.pttKeyCode"
+        static let auxEnabled   = "voice.auxEnabled"
+        static let auxDeviceUID = "voice.auxDeviceUID"
+        static let auxGain      = "voice.auxGain"
+    }
+
+    internal var selectedInputMode: VoiceCatInputMode = .voiceActivation {
+        didSet { UserDefaults.standard.set(Int(selectedInputMode.rawValue), forKey: AudioDefaults.inputMode) }
+    }
+    internal var vadThresholdValue: Float = 0.05 {
+        didSet { UserDefaults.standard.set(vadThresholdValue, forKey: AudioDefaults.vadThreshold) }
+    }
+    internal var inputGain: Float = 1.0 {
+        didSet { UserDefaults.standard.set(inputGain, forKey: AudioDefaults.inputGain) }
+    }
+    internal var inputNoiseReduction: Bool = false {
+        didSet { UserDefaults.standard.set(inputNoiseReduction, forKey: AudioDefaults.inputNoiseReduction) }
+    }
+    // Capture the mic in stereo (interleaved L/R) instead of mono. Real stereo only reaches the
+    // wire on a stereo channel; the core folds a stereo mic to mono on a mono channel. Applied to
+    // the core when the mic stream starts (micToggleClicked) and live via SettingsWindowController.
+    internal var stereoMic: Bool = false {
+        didSet { UserDefaults.standard.set(stereoMic, forKey: AudioDefaults.stereoMic) }
+    }
     internal var selectedInputDeviceId: String?
 
+    // Aux outgoing stream: a second hardware input device the client captures itself and feeds to
+    // the core (kind = AUX_DEVICE, external_feed). Device + volume only — aux is always-on (the
+    // core never gates AUX_DEVICE on VAD/PTT). auxDeviceUID is a Core Audio device UID (stable),
+    // NOT a core/miniaudio id. auxGain is read live by the capture feed, so the slider is instant.
+    internal var auxEnabled: Bool = false {
+        didSet { UserDefaults.standard.set(auxEnabled, forKey: AudioDefaults.auxEnabled) }
+    }
+    internal var auxDeviceUID: String? {
+        didSet { UserDefaults.standard.set(auxDeviceUID, forKey: AudioDefaults.auxDeviceUID) }
+    }
+    internal var auxGain: Float = 1.0 {
+        didSet { UserDefaults.standard.set(auxGain, forKey: AudioDefaults.auxGain) }
+    }
+
     // MARK: - UI components
     private let channelOutlineView = NSOutlineView()
     private let userTableView = NSTableView()
@@ -96,17 +146,46 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
         super.init(window: window)
         window.delegate = self
 
+        loadPersistedAudioSettings()
         buildUI()
         buildToolbar()
         wireEvents()
         bootstrap()
     }
 
+    /// Restore the saved input mode / VAD threshold / mic gain / PTT key from UserDefaults so a
+    /// relaunch keeps the user's transmission settings instead of resetting to VAD defaults.
+    private func loadPersistedAudioSettings() {
+        let d = UserDefaults.standard
+        if d.object(forKey: AudioDefaults.inputMode) != nil {
+            let raw = UInt32(d.integer(forKey: AudioDefaults.inputMode))
+            selectedInputMode = VoiceCatInputMode(rawValue: raw) ?? .voiceActivation
+        }
+        if d.object(forKey: AudioDefaults.vadThreshold) != nil {
+            vadThresholdValue = d.float(forKey: AudioDefaults.vadThreshold)
+        }
+        if d.object(forKey: AudioDefaults.inputGain) != nil {
+            inputGain = d.float(forKey: AudioDefaults.inputGain)
+        }
+        if d.object(forKey: AudioDefaults.inputNoiseReduction) != nil {
+            inputNoiseReduction = d.bool(forKey: AudioDefaults.inputNoiseReduction)
+        }
+        stereoMic = d.bool(forKey: AudioDefaults.stereoMic)
+        if d.object(forKey: AudioDefaults.pttKeyCode) != nil {
+            pttKeyCode = UInt16(d.integer(forKey: AudioDefaults.pttKeyCode))
+        }
+        auxEnabled = d.bool(forKey: AudioDefaults.auxEnabled)
+        if d.object(forKey: AudioDefaults.auxDeviceUID) != nil {
+            auxDeviceUID = d.string(forKey: AudioDefaults.auxDeviceUID)
+        }
+        if d.object(forKey: AudioDefaults.auxGain) != nil {
+            auxGain = d.float(forKey: AudioDefaults.auxGain)
+        }
+    }
+
     required init?(coder: NSCoder) { fatalError() }
 
-    deinit {
+    deinit {}
-        NSLog("[VoiceCatMac] MainWindowController deinit — client and event handlers are gone")
-    }
 
     // MARK: - UI construction
 
@@ -343,7 +422,11 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
         pttMonitor = NSEvent.addLocalMonitorForEvents(matching: [.keyDown, .keyUp]) { [weak self] event in
             guard let self, self.selectedInputMode == .pushToTalk,
                   self.micStreamId != 0, event.keyCode == self.pttKeyCode else { return event }
-            self.client.setPushToTalk(event.type == .keyDown)
+            let down = event.type == .keyDown
+            self.client.setPushToTalk(down)
+            // Cue only on the press transition — key-down auto-repeats while held.
+            if down && !self.pttEngaged { EventFeedback.shared.play(.ptt) }
+            self.pttEngaged = down
             return nil
         }
 
@@ -370,10 +453,6 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
         }
         ownPermissions = client.getPermissions()
 
-        NSLog("[VoiceCatMac] bootstrap: channels=%d users=%d perms{admin=%d kick=%d} currentChannelId=%u",
-              channels.count, allUsers.count,
-              ownPermissions.isAdmin, ownPermissions.canKick, currentChannelId)
-
         // Apply initial output volume (default 80% — matches Windows client)
         client.setOutputVolume(0.8)
 
@@ -385,14 +464,13 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
         buildMessagesMenu()
         buildAdminMenu()
         addActivity("Connected to server as \(nickname)")
+        EventFeedback.shared.play(.login)
+        EventFeedback.shared.speak("Connected")
     }
 
     // MARK: - Event handling
 
     private func handleEvent(_ event: VoiceCatEvent) {
-        NSLog("[VoiceCatMac] event type=%d result=%d userId=%u channelId=%u streamId=%u text=%@",
-              event.type.rawValue, event.result.rawValue, event.userId, event.channelId,
-              event.streamId, event.text ?? "(nil)")
         switch event.type {
         case .channelList:
             channels = client.listChannels()
@@ -410,11 +488,14 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
                          isGuest: true,
                          channelId: event.channelId,
                          selfMicMuted: false, selfDeafened: false,
-                         serverMuted: false, serverDeafened: false)
+                         serverMuted: false, serverDeafened: false,
+                         voiceSubscribed: false)
             users[event.userId] = u
             refreshChannelTree(); refreshUserList()
             if event.channelId == currentChannelId && event.userId != selfUserId {
                 addActivity("\(u.nickname) joined the channel")
+                EventFeedback.shared.play(.channelJoin)
+                EventFeedback.shared.speak("\(u.nickname) joined")
             }
 
         case .userLeft:
@@ -423,7 +504,11 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
             users.removeValue(forKey: event.userId)
             talkingUsers.remove(event.userId)
             refreshChannelTree(); refreshUserList()
-            if wasHere { addActivity("\(nick) left the channel") }
+            if wasHere {
+                addActivity("\(nick) left the channel")
+                EventFeedback.shared.play(.channelLeave)
+                EventFeedback.shared.speak("\(nick) left")
+            }
             if let pmWin = pmWindows[event.userId] {
                 pmWin.appendActivity("\(nick) disconnected from server")
             }
@@ -447,7 +532,8 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
                     users[selfUserId] = User(id: self_.id, nickname: self_.nickname, isGuest: self_.isGuest,
                                             channelId: event.channelId,
                                             selfMicMuted: self_.selfMicMuted, selfDeafened: self_.selfDeafened,
-                                            serverMuted: self_.serverMuted, serverDeafened: self_.serverDeafened)
+                                            serverMuted: self_.serverMuted, serverDeafened: self_.serverDeafened,
+                                            voiceSubscribed: self_.voiceSubscribed)
                 }
                 refreshChannelTree(); refreshUserList(); updateStatusLabel()
                 let name = channels.first(where: { $0.id == event.channelId })?.name ?? "Channel #\(event.channelId)"
@@ -473,6 +559,9 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
             let talking = event.u32a == 1
             if talking { talkingUsers.insert(event.userId) } else { talkingUsers.remove(event.userId) }
             refreshUserList()
+            if event.userId == selfUserId {
+                EventFeedback.shared.play(talking ? .vaStart : .vaStop)
+            }
             if talking && event.userId != selfUserId,
                let u = users[event.userId], u.channelId == currentChannelId {
                 addActivity("\(u.nickname) started talking")
@@ -493,10 +582,18 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
             addActivity("\(u.nickname) started \(kindStr) stream")
 
         case .streamStopped:
-            if let u = users[event.userId], u.channelId == currentChannelId {
+            if event.userId == selfUserId {
+                if event.streamId == micStreamId {
+                    micStreamId = 0
+                    settingsWindowController?.resetLevel()
+                }
+            } else if let u = users[event.userId], u.channelId == currentChannelId {
                 addActivity("\(u.nickname) stopped a stream")
             }
 
+        case .voiceState:
+            handleVoiceState(event)
+
         case .disconnected:
             handleDisconnected(event)
 
@@ -521,21 +618,28 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
             time = DateFormatter.localizedString(from: Date(), dateStyle: .none, timeStyle: .short)
         }
         let sender = nickname(for: event.userId)
+        let isSelf = event.userId == selfUserId
+        let body = event.text ?? ""
 
         if event.textScope == .private {
             // Route PMs to per-conversation windows. For our own outgoing PM, ev.channelId
             // carries the recipient user ID; for incoming, ev.userId is the sender.
-            let otherId = event.userId == selfUserId ? event.channelId : event.userId
+            let otherId = isSelf ? event.channelId : event.userId
             let win = getOrOpenPmWindow(otherId)
-            win.appendMessage(time: time, isSelf: event.userId == selfUserId, sender: sender,
+            win.appendMessage(time: time, isSelf: isSelf, sender: sender, text: body)
-                              text: event.text ?? "")
+            EventFeedback.shared.play(isSelf ? .pmSent : .pmRecv)
-            if event.userId != selfUserId {
+            if !isSelf {
                 addActivity("Private message from \(sender)")
+                EventFeedback.shared.speak("Private message from \(sender): \(body)")
             }
         } else {
-            let line = "[\(time)] \(sender): \(event.text ?? "")\n"
+            let line = "[\(time)] \(sender): \(body)\n"
             logTextView.textStorage?.append(NSAttributedString(string: line))
             logTextView.scrollToEndOfDocument(nil)
+            EventFeedback.shared.play(isSelf ? .channelSent : .channelRecv)
+            if !isSelf {
+                EventFeedback.shared.speak("\(sender): \(body)")
+            }
         }
     }
 
@@ -607,11 +711,14 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
         let msg = event.text.map { "Disconnected: \($0)" } ?? "Disconnected from server."
         statusLabel.stringValue = msg
         addActivity(msg)
+        EventFeedback.shared.play(event.result == .ok ? .logout : .connectionLost)
+        EventFeedback.shared.speak(event.result == .ok ? "Disconnected" : "Connection lost")
         channelTree = []; channelOutlineView.reloadData()
         displayedUsers = []; userTableView.reloadData()
         users.removeAll(); talkingUsers.removeAll()
         stopScreenCapture()
-        currentChannelId = 0; micStreamId = 0; screenStreamId = 0
+        auxCapture?.stop(); auxCapture = nil  // connection gone — drop capture, no stopStream
+        currentChannelId = 0; micStreamId = 0; screenStreamId = 0; auxStreamId = 0
         composeField.isEnabled = false; sendButton.isEnabled = false
         joinVoiceButton?.isEnabled = false
         shareScreenButton?.isEnabled = false
@@ -677,30 +784,127 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
 
     @objc private func micToggleClicked() {
         if micStreamId == 0 {
+            let result = client.joinVoice()
+            if result != .ok {
+                addActivity("Failed to join voice: \(result)")
+            }
+        } else {
+            stopAuxStream()
+            if screenStreamId != 0 { stopScreenAudio() }
+            client.setPushToTalk(false)
+            client.leaveVoice()
+        }
+    }
+
+    private func handleVoiceState(_ event: VoiceCatEvent) {
+        let subscribed = event.u32a != 0
+        if subscribed {
             let (result, streamId) = client.startStream(StreamDescriptor(kind: .mic, deviceId: nil, label: "Microphone"))
             if result == .ok {
                 micStreamId = streamId
                 if let devId = selectedInputDeviceId {
                     client.setInputDevice(streamId: streamId, deviceId: devId)
                 }
+                client.setCaptureChannels(streamId: streamId, channels: stereoMic ? 2 : 1)
                 client.setInputMode(selectedInputMode)
                 if selectedInputMode == .voiceActivation {
                     client.setVadThreshold(vadThresholdValue)
                 }
+                client.setInputGain(inputGain)
+                client.setInputNoiseReduction(inputNoiseReduction)
                 setVoiceJoinedState(true)
                 addActivity("Joined voice — microphone active")
+                EventFeedback.shared.play(.voiceOn)
                 NSAccessibility.post(element: logTextView, notification: .announcementRequested,
                                      userInfo: [.announcement: "Joined voice", .priority: NSAccessibilityPriorityLevel.medium])
+                startAuxStream()
             } else {
                 addActivity("Failed to start microphone: \(result)")
             }
         } else {
-            client.setPushToTalk(false)
-            client.stopStream(micStreamId)
             micStreamId = 0
             settingsWindowController?.resetLevel()
             setVoiceJoinedState(false)
             addActivity("Left voice")
+            EventFeedback.shared.play(.voiceOff)
+        }
+    }
+
+    // MARK: - Aux input stream (second hardware input device)
+
+    /// Called by SettingsWindowController when the user toggles the aux checkbox.
+    func applyAuxEnabled(_ on: Bool) {
+        auxEnabled = on
+        guard micStreamId != 0 else { return } // not in voice — applied on next Join Voice
+        if on { startAuxStream() } else { stopAuxStream() }
+    }
+
+    /// Called by SettingsWindowController when the user picks a different aux device.
+    func applyAuxDevice(_ uid: String?) {
+        auxDeviceUID = uid
+        if auxStreamId != 0 { restartAuxCapture() }
+    }
+
+    private func startAuxStream() {
+        guard auxStreamId == 0, auxEnabled else { return }
+        let (result, streamId) = client.startStream(
+            StreamDescriptor(kind: .auxDevice, deviceId: nil, label: "Aux device", externalFeed: true))
+        guard result == .ok else {
+            addActivity("Failed to start aux stream: \(result)")
+            return
+        }
+        auxStreamId = streamId
+        startAuxCapture()
+        addActivity("Aux input stream active")
+    }
+
+    private func startAuxCapture() {
+        let capture = InputDeviceCapture(deviceUID: auxDeviceUID) { [weak self] ptr, spc, ch in
+            self?.feedAux(ptr, samplesPerChannel: spc, channels: ch)
+        }
+        auxCapture = capture
+        do { try capture.start() }
+        catch {
+            addActivity("Failed to open aux input device")
+            stopAuxStream()
+        }
+    }
+
+    // Re-open the capture on a different device while the aux stream stays up (the core stream id
+    // is unchanged — only the client-side capture source changes).
+    private func restartAuxCapture() {
+        guard auxStreamId != 0 else { return }
+        auxCapture?.stop()
+        auxCapture = nil
+        startAuxCapture()
+    }
+
+    private func stopAuxStream() {
+        auxCapture?.stop()
+        auxCapture = nil
+        if auxStreamId != 0 {
+            client.stopStream(auxStreamId)
+            auxStreamId = 0
+        }
+    }
+
+    // Fired on the capture's realtime thread. feedPcm is thread-safe. Gain is read live from
+    // auxGain each frame so the volume slider takes effect immediately.
+    private func feedAux(_ pcm: UnsafePointer<Int16>, samplesPerChannel: Int, channels: UInt32) {
+        guard auxStreamId != 0 else { return }
+        let gain = auxGain
+        if gain != 1.0 {
+            let n = samplesPerChannel * Int(channels)
+            var scaled = [Int16](repeating: 0, count: n)
+            for i in 0..<n {
+                let v = (Float(pcm[i]) * gain).rounded()
+                scaled[i] = Int16(max(-32768, min(32767, v)))
+            }
+            client.feedPcm(streamId: auxStreamId, pcm: scaled,
+                           samplesPerChannel: samplesPerChannel, channels: channels)
+        } else {
+            client.feedPcm(streamId: auxStreamId, pcm: pcm,
+                           samplesPerChannel: samplesPerChannel, channels: channels)
         }
     }
 
@@ -740,6 +944,15 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
         }
     }
 
+    private func stopScreenAudio() {
+        guard screenStreamId != 0 else { return }
+        stopScreenCapture()
+        client.stopStream(screenStreamId)
+        screenStreamId = 0
+        setShareScreenButton(active: false)
+        addActivity("Stopped sharing screen audio")
+    }
+
     /// Announce the SCREEN_AUDIO stream with the chosen selection in hand. ScreenCaptureKit
     /// capture starts once the server's StreamAnnounceResult lands (the .streamStarted event),
     /// when the effective audio config — and thus the channel count — is known. See
@@ -845,7 +1058,7 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
         composeField.stringValue = ""
     }
 
-    // MARK: - M5: Moderation helpers
+    // MARK: - Moderation helpers
 
     private func moveUser(_ user: User) {
         let sheet = MoveUserSheet(channels: channels, currentChannelId: user.channelId)
@@ -1019,7 +1232,6 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
         presentSheet(sheet)
     }
 
-    /// Open a PM window from the user context menu.
     private func openPmWindow(_ user: User) {
         getOrOpenPmWindow(user.id)
     }
@@ -1066,17 +1278,13 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
     func windowWillClose(_ notification: Notification) {
         if let mon = pttMonitor { NSEvent.removeMonitor(mon) }
         NotificationCenter.default.removeObserver(self)
-        // Close all PM windows
         for (_, pmWin) in pmWindows { pmWin.close() }
         pmWindows.removeAll()
-        // Close settings window
         settingsWindowController?.close()
         settingsWindowController = nil
-        // Remove app menus we added
         if let item = voiceMenuItem { NSApp.mainMenu?.removeItem(item) }
         if let item = messagesMenuItem { NSApp.mainMenu?.removeItem(item) }
         if let item = adminMenuItem { NSApp.mainMenu?.removeItem(item) }
-        // Remove Settings menu item + separator from app menu
         if let appMenu = NSApp.mainMenu?.item(at: 0)?.submenu {
             if let item = settingsMenuItem { appMenu.removeItem(item) }
             // Remove the separator we inserted before Quit
@@ -1091,6 +1299,7 @@ final class MainWindowController: NSWindowController, NSWindowDelegate {
         }
         client.setPushToTalk(false)
         stopScreenCapture()
+        if auxStreamId != 0 { stopAuxStream() }
         if screenStreamId != 0 { client.stopStream(screenStreamId) }
         if micStreamId != 0 { client.stopStream(micStreamId) }
         client.onLevel = nil
@@ -1255,7 +1464,7 @@ extension MainWindowController: NSMenuDelegate {
         let info = ChannelEdit(id: ch.id, parentId: ch.parentId, name: ch.name,
                                topic: ch.topic, passwordProtected: ch.passwordProtected,
                                password: nil, maxUsers: ch.maxUsers,
-                               sortOrder: 0, audio: AudioConfig())
+                               sortOrder: ch.sortOrder, audio: ch.audio)
         let sheet = ChannelEditSheet(channels: channels, editing: info)
         sheet.onComplete = { [weak self] edited in
             guard let edited else { return }

clients/apple/macOS/VoiceCatMac/Windows/SettingsWindowController.swift

@@ -50,6 +50,56 @@ final class SettingsWindowController: NSWindowController, NSWindowDelegate {
     // Cached VAD slider position so we can restore it when the window reopens.
     private var vadSliderValue: Double = 50
 
+    // Mic input gain: 0–400 % (100 = unity). Persisted via MainWindowController.inputGain.
+    private let inputGainSlider: NSSlider = {
+        let s = NSSlider(value: 100, minValue: 0, maxValue: 400, target: nil, action: nil)
+        s.numberOfTickMarks = 0
+        return s
+    }()
+    private let inputGainValueLabel = NSTextField(labelWithString: "100%")
+
+    // Send-side mic noise reduction (RNNoise). MIC-only. Persisted via
+    // MainWindowController.inputNoiseReduction.
+    private let nrCheckbox = NSButton(checkboxWithTitle: "Noise reduction (RNNoise)",
+                                       target: nil, action: nil)
+
+    // Capture the mic in stereo (interleaved L/R) instead of mono. Real stereo only reaches the
+    // wire on a stereo channel; the core folds a stereo mic to mono on a mono channel. Persisted
+    // via MainWindowController.stereoMic.
+    private let stereoMicCheckbox = NSButton(checkboxWithTitle: "Stereo microphone",
+                                             target: nil, action: nil)
+
+    // Aux input stream: a second outgoing stream from another hardware input device (e.g. line-in
+    // / aux), captured client-side. Device + volume only — aux is always-on. Persisted via
+    // MainWindowController.auxEnabled / auxDeviceUID / auxGain.
+    private let auxCheckbox = NSButton(checkboxWithTitle: "Aux input stream (second device)",
+                                       target: nil, action: nil)
+    private let auxDevicePicker = NSPopUpButton()
+    private let auxRefreshButton = NSButton()
+    private let auxGainSlider: NSSlider = {
+        let s = NSSlider(value: 100, minValue: 0, maxValue: 400, target: nil, action: nil)
+        s.numberOfTickMarks = 0
+        return s
+    }()
+    private let auxGainValueLabel = NSTextField(labelWithString: "100%")
+    private let auxDeviceLabel = NSTextField(labelWithString: "Aux device:")
+    private let auxGainLabel = NSTextField(labelWithString: "Aux volume:")
+
+    // Notification feedback controls. Read/write UserDefaults with the same keys VoiceCatCore's
+    // FeedbackSettings reads, so EventFeedback honours these immediately.
+    private let soundsCheckbox = NSButton(checkboxWithTitle: "Event sounds", target: nil, action: nil)
+    private let soundsVolumeSlider: NSSlider = {
+        let s = NSSlider(value: 1, minValue: 0, maxValue: 1, target: nil, action: nil)
+        s.numberOfTickMarks = 0
+        return s
+    }()
+    private let speechCheckbox = NSButton(checkboxWithTitle: "Speak events (text-to-speech)",
+                                          target: nil, action: nil)
+    private let selfTalkCheckbox = NSButton(checkboxWithTitle: "Your own voice-activity sounds",
+                                            target: nil, action: nil)
+    private let pttSoundCheckbox = NSButton(checkboxWithTitle: "Push-to-talk cue",
+                                            target: nil, action: nil)
+
     // MARK: - Init
 
     init(client: VoiceCatClient, mainController: MainWindowController) {
@@ -57,13 +107,13 @@ final class SettingsWindowController: NSWindowController, NSWindowDelegate {
         self.mainController = mainController
 
         let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 380, height: 260),
+            contentRect: NSRect(x: 0, y: 0, width: 380, height: 420),
             styleMask: [.titled, .closable, .miniaturizable],
             backing: .buffered,
             defer: false
         )
-        window.title = "Audio Settings"
+        window.title = "Settings"
-        window.minSize = NSSize(width: 340, height: 220)
+        window.minSize = NSSize(width: 340, height: 380)
         window.center()
         super.init(window: window)
         window.delegate = self
@@ -71,6 +121,7 @@ final class SettingsWindowController: NSWindowController, NSWindowDelegate {
         buildUI()
         syncFromMainController()
         loadInputDevices()
+        loadAuxDevices()
     }
 
     required init?(coder: NSCoder) { fatalError() }
@@ -120,6 +171,24 @@ final class SettingsWindowController: NSWindowController, NSWindowDelegate {
         levelMeter.setAccessibilityLabel("Microphone input level")
         levelMeter.setAccessibilityHelp("Shows current microphone volume level")
 
+        let inputGainLabel = NSTextField(labelWithString: "Mic volume:")
+        inputGainLabel.setAccessibilityLabel("Microphone volume")
+        inputGainSlider.target = self
+        inputGainSlider.action = #selector(inputGainChanged)
+        inputGainSlider.setAccessibilityLabel("Microphone volume")
+        inputGainSlider.setAccessibilityHelp("Boost a quiet microphone. 100% is unity.")
+        inputGainValueLabel.setAccessibilityLabel("Microphone volume value")
+
+        nrCheckbox.target = self
+        nrCheckbox.action = #selector(nrChanged)
+        nrCheckbox.setAccessibilityLabel("Microphone noise reduction")
+        nrCheckbox.setAccessibilityHelp("RNNoise denoising of your microphone. Cleans your signal for everyone.")
+
+        stereoMicCheckbox.target = self
+        stereoMicCheckbox.action = #selector(stereoMicChanged)
+        stereoMicCheckbox.setAccessibilityLabel("Stereo microphone")
+        stereoMicCheckbox.setAccessibilityHelp("Capture your microphone in stereo. Only transmitted in stereo on a stereo channel.")
+
         let inputModeRow = NSStackView(views: [inputModeLabel, inputModeControl])
         inputModeRow.orientation = .horizontal
         inputModeRow.spacing = 8
@@ -140,7 +209,71 @@ final class SettingsWindowController: NSWindowController, NSWindowDelegate {
         levelRow.orientation = .horizontal
         levelRow.spacing = 8
 
-        let stack = NSStackView(views: [inputModeRow, vadRow, pttRow, deviceRow, levelRow])
+        let inputGainRow = NSStackView(views: [inputGainLabel, inputGainSlider, inputGainValueLabel])
+        inputGainRow.orientation = .horizontal
+        inputGainRow.spacing = 8
+
+        // ── Aux input stream ──────────────────────────────────────────────────
+        let auxHeader = NSTextField(labelWithString: "Aux input stream")
+        auxHeader.font = .boldSystemFont(ofSize: NSFont.systemFontSize)
+
+        auxCheckbox.target = self
+        auxCheckbox.action = #selector(auxEnabledChanged)
+        auxCheckbox.setAccessibilityLabel("Enable aux input stream")
+        auxCheckbox.setAccessibilityHelp("Transmit a second hardware input device alongside your microphone.")
+
+        auxDeviceLabel.setAccessibilityLabel("Aux input device")
+        auxDevicePicker.setAccessibilityLabel("Aux input device")
+        auxDevicePicker.target = self
+        auxDevicePicker.action = #selector(auxDeviceChanged)
+        auxRefreshButton.title = "↺"
+        auxRefreshButton.bezelStyle = .rounded
+        auxRefreshButton.target = self
+        auxRefreshButton.action = #selector(refreshAuxDevicesClicked)
+        auxRefreshButton.setAccessibilityLabel("Refresh aux device list")
+        auxRefreshButton.toolTip = "Refresh"
+
+        auxGainLabel.setAccessibilityLabel("Aux volume")
+        auxGainSlider.target = self
+        auxGainSlider.action = #selector(auxGainChanged)
+        auxGainSlider.setAccessibilityLabel("Aux volume")
+        auxGainSlider.setAccessibilityHelp("Volume of the aux input stream. 100% is unity.")
+        auxGainValueLabel.setAccessibilityLabel("Aux volume value")
+
+        let auxDeviceRow = NSStackView(views: [auxDeviceLabel, auxDevicePicker, auxRefreshButton])
+        auxDeviceRow.orientation = .horizontal
+        auxDeviceRow.spacing = 8
+
+        let auxGainRow = NSStackView(views: [auxGainLabel, auxGainSlider, auxGainValueLabel])
+        auxGainRow.orientation = .horizontal
+        auxGainRow.spacing = 8
+
+        // Notifications
+        let notificationsHeader = NSTextField(labelWithString: "Notifications")
+        notificationsHeader.font = .boldSystemFont(ofSize: NSFont.systemFontSize)
+
+        for box in [soundsCheckbox, speechCheckbox, selfTalkCheckbox, pttSoundCheckbox] {
+            box.target = self
+            box.action = #selector(notificationSettingChanged)
+        }
+        soundsCheckbox.setAccessibilityLabel("Play event sounds")
+        speechCheckbox.setAccessibilityLabel("Speak events")
+        selfTalkCheckbox.setAccessibilityLabel("Your own voice-activity sounds")
+        pttSoundCheckbox.setAccessibilityLabel("Push-to-talk cue")
+
+        let volumeLabel = NSTextField(labelWithString: "Sound volume:")
+        volumeLabel.setAccessibilityLabel("Sound volume")
+        soundsVolumeSlider.target = self
+        soundsVolumeSlider.action = #selector(notificationSettingChanged)
+        soundsVolumeSlider.setAccessibilityLabel("Sound volume")
+        let volumeRow = NSStackView(views: [volumeLabel, soundsVolumeSlider])
+        volumeRow.orientation = .horizontal
+        volumeRow.spacing = 8
+
+        let stack = NSStackView(views: [inputModeRow, vadRow, inputGainRow, nrCheckbox, stereoMicCheckbox, pttRow, deviceRow,
+                                        levelRow, auxHeader, auxCheckbox, auxDeviceRow, auxGainRow,
+                                        notificationsHeader, soundsCheckbox, volumeRow,
+                                        speechCheckbox, selfTalkCheckbox, pttSoundCheckbox])
         stack.orientation = .vertical
         stack.spacing = 12
         stack.alignment = .leading
@@ -155,9 +288,35 @@ final class SettingsWindowController: NSWindowController, NSWindowDelegate {
             stack.bottomAnchor.constraint(equalTo: contentView.bottomAnchor),
 
             vadSlider.widthAnchor.constraint(greaterThanOrEqualToConstant: 200),
+            inputGainSlider.widthAnchor.constraint(greaterThanOrEqualToConstant: 180),
             levelMeter.widthAnchor.constraint(equalToConstant: 200),
             devicePicker.widthAnchor.constraint(greaterThanOrEqualToConstant: 180),
+            soundsVolumeSlider.widthAnchor.constraint(greaterThanOrEqualToConstant: 200),
+            auxDevicePicker.widthAnchor.constraint(greaterThanOrEqualToConstant: 180),
+            auxGainSlider.widthAnchor.constraint(greaterThanOrEqualToConstant: 180),
         ])
+
+        syncNotificationControls()
+    }
+
+    /// Load the notification checkbox/slider states from UserDefaults. Touches EventFeedback.shared
+    /// first so its default values are registered before we read them.
+    private func syncNotificationControls() {
+        let s = FeedbackSettings.current
+        soundsCheckbox.state = s.sounds ? .on : .off
+        speechCheckbox.state = s.speech ? .on : .off
+        selfTalkCheckbox.state = s.selfTalkSounds ? .on : .off
+        pttSoundCheckbox.state = s.pttSound ? .on : .off
+        soundsVolumeSlider.doubleValue = Double(s.volume)
+    }
+
+    @objc private func notificationSettingChanged() {
+        let d = UserDefaults.standard
+        d.set(soundsCheckbox.state == .on, forKey: "feedback.sounds")
+        d.set(speechCheckbox.state == .on, forKey: "feedback.speech")
+        d.set(selfTalkCheckbox.state == .on, forKey: "feedback.selfTalk")
+        d.set(pttSoundCheckbox.state == .on, forKey: "feedback.ptt")
+        d.set(soundsVolumeSlider.doubleValue, forKey: "feedback.volume")
     }
 
     // MARK: - Sync from MainWindowController
@@ -173,9 +332,22 @@ final class SettingsWindowController: NSWindowController, NSWindowDelegate {
         case .alwaysOn:        inputModeControl.selectedSegment = 2
         }
 
+        // Restore the slider from the persisted threshold (invert vadThresholdFromSlider) so a
+        // relaunch shows the saved sensitivity, not the default mid-point.
+        vadSliderValue = vadSliderFromThreshold(mc.vadThresholdValue)
         vadSlider.doubleValue = vadSliderValue
         pttKeyLabel.stringValue = "(\(keyCodeName(mc.pttKeyCode)))"
 
+        inputGainSlider.doubleValue = Double(mc.inputGain * 100)
+        updateInputGainLabel()
+        nrCheckbox.state = mc.inputNoiseReduction ? .on : .off
+        stereoMicCheckbox.state = mc.stereoMic ? .on : .off
+
+        auxCheckbox.state = mc.auxEnabled ? .on : .off
+        auxGainSlider.doubleValue = Double(mc.auxGain * 100)
+        updateAuxGainLabel()
+        updateAuxControlsEnabled()
+
         updateConditionalControls()
     }
 
@@ -213,6 +385,39 @@ final class SettingsWindowController: NSWindowController, NSWindowDelegate {
         }
     }
 
+    @objc private func inputGainChanged() {
+        let gain = Float(inputGainSlider.doubleValue) / 100.0
+        mainController?.inputGain = gain
+        updateInputGainLabel()
+        if let mc = mainController, mc.micStreamId != 0 {
+            client.setInputGain(gain)
+        }
+    }
+
+    @objc private func nrChanged() {
+        let on = nrCheckbox.state == .on
+        mainController?.inputNoiseReduction = on
+        if let mc = mainController, mc.micStreamId != 0 {
+            client.setInputNoiseReduction(on)
+        }
+    }
+
+    @objc private func stereoMicChanged() {
+        let on = stereoMicCheckbox.state == .on
+        mainController?.stereoMic = on
+        // Channel count only takes effect when the capture device (re)starts, so restart it live.
+        if let mc = mainController, mc.micStreamId != 0 {
+            client.setCaptureChannels(streamId: mc.micStreamId, channels: on ? 2 : 1)
+            client.audioRestart()
+        }
+    }
+
+    private func updateInputGainLabel() {
+        let pct = Int(inputGainSlider.doubleValue.rounded())
+        inputGainValueLabel.stringValue = "\(pct)%"
+        inputGainSlider.setAccessibilityValue("\(pct) percent")
+    }
+
     @objc private func changePttClicked() {
         guard let mc = mainController else { return }
         let sheet = PttKeyCaptureSheet(currentKeyCode: mc.pttKeyCode)
@@ -234,6 +439,65 @@ final class SettingsWindowController: NSWindowController, NSWindowDelegate {
         }
     }
 
+    // MARK: - Aux input stream actions
+
+    @objc private func auxEnabledChanged() {
+        let on = auxCheckbox.state == .on
+        updateAuxControlsEnabled()
+        mainController?.applyAuxEnabled(on)
+    }
+
+    @objc private func refreshAuxDevicesClicked() { loadAuxDevices() }
+
+    @objc private func auxDeviceChanged() {
+        let uid = auxDevicePicker.selectedItem?.representedObject as? String
+        mainController?.applyAuxDevice(uid)
+    }
+
+    @objc private func auxGainChanged() {
+        mainController?.auxGain = Float(auxGainSlider.doubleValue) / 100.0
+        updateAuxGainLabel()
+    }
+
+    private func updateAuxGainLabel() {
+        let pct = Int(auxGainSlider.doubleValue.rounded())
+        auxGainValueLabel.stringValue = "\(pct)%"
+        auxGainSlider.setAccessibilityValue("\(pct) percent")
+    }
+
+    private func updateAuxControlsEnabled() {
+        let on = auxCheckbox.state == .on
+        auxDeviceLabel.isEnabled = on
+        auxDevicePicker.isEnabled = on
+        auxRefreshButton.isEnabled = on
+        auxGainLabel.isEnabled = on
+        auxGainSlider.isEnabled = on
+        auxGainValueLabel.isEnabled = on
+    }
+
+    private func loadAuxDevices() {
+        let devices = InputDeviceEnumerator.list()
+        let prevSelected = (auxDevicePicker.selectedItem?.representedObject as? String)
+            ?? mainController?.auxDeviceUID
+        auxDevicePicker.removeAllItems()
+        for d in devices {
+            let item = NSMenuItem(title: d.name, action: nil, keyEquivalent: "")
+            item.representedObject = d.uid
+            auxDevicePicker.menu?.addItem(item)
+        }
+        if let prev = prevSelected,
+           let item = auxDevicePicker.itemArray.first(where: { ($0.representedObject as? String) == prev }) {
+            auxDevicePicker.select(item)
+        } else if let def = devices.first(where: { $0.isDefault }),
+                  let item = auxDevicePicker.itemArray.first(where: { ($0.representedObject as? String) == def.uid }) {
+            auxDevicePicker.select(item)
+        } else if auxDevicePicker.numberOfItems > 0 {
+            auxDevicePicker.selectItem(at: 0)
+        }
+        // Persist the resolved selection so a relaunch (or Join Voice) opens the same device.
+        mainController?.auxDeviceUID = auxDevicePicker.selectedItem?.representedObject as? String
+    }
+
     // MARK: - Level meter (called by MainWindowController)
 
     func updateLevel(rms: Float) {
@@ -284,6 +548,12 @@ final class SettingsWindowController: NSWindowController, NSWindowDelegate {
         0.1 * (1.0 - Float(vadSlider.doubleValue - 1.0) / 99.0)
     }
 
+    /// Inverse of vadThresholdFromSlider: map a stored threshold back to a 1…100 slider position.
+    private func vadSliderFromThreshold(_ threshold: Float) -> Double {
+        let clamped = min(max(threshold, 0.0), 0.1)
+        return Double(1.0 + (1.0 - clamped / 0.1) * 99.0)
+    }
+
     private func presentSheet(_ vc: NSViewController) {
         if let cvc = window?.contentViewController {
             cvc.presentAsSheet(vc)

clients/apple/scripts/build-xcframework.sh

@@ -54,7 +54,8 @@ done
 # ── Resolve VCPKG_ROOT ───────────────────────────────────────────────────────────
 # The apple-dev CMake cache records the vcpkg root it was configured with (Z_VCPKG_ROOT_DIR);
 # reuse that so a developer who already configured `cmake --preset dev` doesn't need VCPKG_ROOT
-# in their shell env to run this script.
+# in their shell env to run this script. Falls back to the bundled submodule at
+# <repo-root>/vcpkg if neither the env var nor the cache resolve it.
 if [[ -z "${VCPKG_ROOT:-}" ]]; then
     cache="$REPO_ROOT/build/apple-dev/CMakeCache.txt"
     if [[ -f "$cache" ]]; then
@@ -64,9 +65,16 @@ if [[ -z "${VCPKG_ROOT:-}" ]]; then
         fi
     fi
 fi
+if [[ -z "${VCPKG_ROOT:-}" ]]; then
+    bundled="$REPO_ROOT/vcpkg"
+    if [[ -f "$bundled/scripts/buildsystems/vcpkg.cmake" ]]; then
+        export VCPKG_ROOT="$bundled"
+    fi
+fi
 if [[ -z "${VCPKG_ROOT:-}" || ! -d "$VCPKG_ROOT" ]]; then
     echo "error: VCPKG_ROOT is not set or does not exist." >&2
-    echo "       bootstrap vcpkg (https://vcpkg.io) then:  export VCPKG_ROOT=/path/to/vcpkg" >&2
+    echo "       either init the bundled submodule:  git submodule update --init vcpkg" >&2
+    echo "       or point at an external checkout:   export VCPKG_ROOT=/path/to/vcpkg" >&2
     exit 1
 fi
 echo "[build-xcframework] VCPKG_ROOT=$VCPKG_ROOT"
@@ -104,14 +112,24 @@ build_slice() {
     # to build protoc/etc at configure time. Merging those macOS .a files into the iOS
     # fat library triggers xcodebuild's "binaries with multiple platforms" rejection.
     local vcpkg_target_lib_dir="$REPO_ROOT/build/$preset/vcpkg_installed/$vcpkg_triplet/lib"
+    local local_lib_dir="$REPO_ROOT/build/$preset/lib"
     local fat_lib="$REPO_ROOT/build/$preset/lib/libvoicecat-fat.a"
-    echo "[build-xcframework] $slice_name: merging vcpkg deps into fat static lib (triplet: $vcpkg_triplet)"
+    echo "[build-xcframework] $slice_name: merging vcpkg + vendored deps into fat static lib (triplet: $vcpkg_triplet)"
-    # Collect all .a files (libvoicecat.a + every vcpkg target .a). libtool -static concatenates
+    # Collect all .a files (libvoicecat.a + every vcpkg target .a + locally-built vendored static
-    # object files from all input archives; duplicate-object warnings are benign (the linker
+    # libs). libtool -static concatenates object files from all input archives; duplicate-object
-    # resolves duplicates at final link time). "no symbols" warnings are for empty AVX2/AVX512
+    # warnings are benign (the linker resolves duplicates at final link time). "no symbols"
-    # objects on arm64 — also benign.
+    # warnings are for empty AVX2/AVX512 objects on arm64 — also benign.
+    #
+    # Two source dirs:
+    #  - vcpkg_target_lib_dir: vcpkg-installed deps (protobuf, mbedtls, sodium, opus, …).
+    #  - local_lib_dir: CMake static-lib targets built in this tree that are NOT vcpkg deps —
+    #    e.g. the vendored RNNoise lib (third_party/rnnoise, VOICECAT_HAS_NS). Without it the
+    #    fat lib references _rnnoise_* symbols that nothing defines → undefined-symbol link
+    #    errors in Xcode. Exclude libvoicecat* (the main lib is $lib; libvoicecat-fat.a is the
+    #    output we're building here).
     local all_libs=( "$lib" )
     while IFS= read -r f; do all_libs+=( "$f" ); done < <(find "$vcpkg_target_lib_dir" -name '*.a' -not -name 'libvoicecat*' | sort)
+    while IFS= read -r f; do all_libs+=( "$f" ); done < <(find "$local_lib_dir" -maxdepth 1 -name '*.a' -not -name 'libvoicecat*' | sort)
     libtool -static -o "$fat_lib" "${all_libs[@]}" 2>&1 | grep -v 'has no symbols' || true
     echo "[build-xcframework] $slice_name -> $fat_lib ($(stat -f%z "$fat_lib") bytes, fat)"
 }

clients/windows/VoiceCat.App/Audio/AudioSessionEnumerator.cs

@@ -6,91 +6,161 @@ namespace VoiceCat.App.Audio;
 // ── Scope types (mirror macOS ScreenAudioScope / ScreenAudioSelection) ────────
 
 public abstract record AppAudioScope;
-public sealed record EntireDesktop : AppAudioScope;
+// ExcludeSelf=true captures the whole system render mix minus VoiceCat's own process tree
+// (kills the self-echo loop). Routed through the external-feed mixer as a single EXCLUDE
+// capture; ExcludeSelf=false keeps the core's whole-device loopback path.
+public sealed record EntireDesktop(bool ExcludeSelf = false) : AppAudioScope;
 public sealed record OnlyApps(IReadOnlyList<int> Pids, IReadOnlyList<string> Names) : AppAudioScope;
 public sealed record AllExceptApps(IReadOnlyList<int> Pids, IReadOnlyList<string> Names) : AppAudioScope;
 
-public sealed record AudioAppInfo(int Pid, string DisplayName);
+// IsPlaying = a process in this app's executable group currently has an *active* audio
+// session on some render endpoint. Purely informational for the picker — capture works
+// on any PID regardless (process-loopback yields silence until the app plays).
+public sealed record AudioAppInfo(int Pid, string DisplayName, bool IsPlaying);
 
 // ── Enumerator ─────────────────────────────────────────────────────────────────
 
 public static class AudioSessionEnumerator
 {
-    // Returns all user-facing apps: visible-window processes (primary, like macOS
+    // Returns every app in the user's interactive session — windowed or not — so any of
-    // SCShareableContent.current) plus any background audio-session-only processes
+    // them can be picked for capture even before it starts producing audio. Process
-    // (e.g. Spotify in mini-player). Excludes VoiceCat itself and system processes.
+    // loopback (see ProcessLoopbackCapture) targets a PID and its child tree, so a silent
+    // selection simply starts working the moment that app plays.
+    //
+    // Apps are deduped by executable (multiple PIDs of the same program collapse to one
+    // row whose PID is the process-tree root). Session-0 services and VoiceCat itself are
+    // excluded. Apps currently producing audio are flagged IsPlaying and sorted first.
     public static IReadOnlyList<AudioAppInfo> GetAudioApps()
     {
-        var seen   = new HashSet<int>();
-        var result = new List<AudioAppInfo>();
         int selfPid    = Environment.ProcessId;
+        int sessionId  = SafeCurrentSessionId();
+        var playingPids = GetActiveAudioPids();
 
-        // ── 1. Visible-window processes (EnumWindows) ─────────────────────────
+        // Group by executable name; keep the best representative PID per group.
-        // Same set macOS ScreenCaptureKit exposes: all apps with at least one
+        var groups = new Dictionary<string, AppGroup>(StringComparer.OrdinalIgnoreCase);
-        // visible top-level window. Shows apps even when not currently producing audio.
+
-        EnumWindows((hWnd, _) =>
+        foreach (var proc in Process.GetProcesses())
         {
-            if (!IsWindowVisible(hWnd)) return true;
-            GetWindowThreadProcessId(hWnd, out uint pid);
-            if (pid == 0 || pid == (uint)selfPid || !seen.Add((int)pid)) return true;
-
             try
             {
-                var proc = Process.GetProcessById((int)pid);
+                if (proc.Id == selfPid) continue;
-                string name = proc.MainWindowTitle.Length > 0
+                if (proc.SessionId != sessionId) continue;   // drop session-0 services
-                    ? $"{proc.ProcessName} — {proc.MainWindowTitle}"
+                string name = proc.ProcessName;
-                    : proc.ProcessName;
+                if (string.IsNullOrEmpty(name)) continue;
-                if (!string.IsNullOrEmpty(proc.ProcessName))
-                    result.Add(new AudioAppInfo((int)pid, name));
-            }
-            catch { /* process exited between EnumWindows and GetProcessById */ }
 
-            return true; // continue enumeration
+                bool hasWindow = proc.MainWindowHandle != IntPtr.Zero;
-        }, IntPtr.Zero);
+                bool playing   = playingPids.Contains(proc.Id);
+                string title   = hasWindow ? SafeWindowTitle(proc) : "";
+                string display = title.Length > 0 ? $"{name} — {title}" : name;
 
-        // ── 2. Background audio-session processes (WASAPI, supplement) ────────
+                if (groups.TryGetValue(name, out var g))
-        // Catches apps that produce audio but have no visible window (screen reader,
-        // background music player, etc.). Silently skipped if WASAPI is unavailable.
-        AppendAudioSessionApps(seen, selfPid, result);
-
-        return result.OrderBy(a => a.DisplayName, StringComparer.OrdinalIgnoreCase).ToList();
-    }
-
-    // ── EnumWindows P/Invoke ──────────────────────────────────────────────────
-
-    private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
-
-    [DllImport("user32.dll")]
-    private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
-
-    [DllImport("user32.dll")]
-    private static extern bool IsWindowVisible(IntPtr hWnd);
-
-    [DllImport("user32.dll")]
-    private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
-
-    // ── WASAPI audio session supplement ──────────────────────────────────────
-
-    private static void AppendAudioSessionApps(HashSet<int> seen, int selfPid,
-                                               List<AudioAppInfo> result)
                 {
+                    g.AnyPlaying |= playing;
+                    // Prefer a windowed PID (the process-tree root) as the capture target;
+                    // among non-windowed, prefer a currently-playing PID.
+                    bool better = (hasWindow && !g.HasWindow)
+                               || (!g.HasWindow && !hasWindow && playing && !g.RepPlaying);
+                    if (better)
+                    {
+                        g.Pid        = proc.Id;
+                        g.Display    = display;
+                        g.HasWindow  = hasWindow;
+                        g.RepPlaying = playing;
+                    }
+                }
+                else
+                {
+                    groups[name] = new AppGroup
+                    {
+                        Pid        = proc.Id,
+                        Display    = display,
+                        HasWindow  = hasWindow,
+                        RepPlaying = playing,
+                        AnyPlaying = playing,
+                    };
+                }
+            }
+            catch { /* protected/exited process — skip */ }
+            finally { proc.Dispose(); }
+        }
+
+        return groups.Values
+            .Select(g => new AudioAppInfo(g.Pid, g.Display, g.AnyPlaying))
+            .OrderByDescending(a => a.IsPlaying)
+            .ThenBy(a => a.DisplayName, StringComparer.OrdinalIgnoreCase)
+            .ToList();
+    }
+
+    private sealed class AppGroup
+    {
+        public int    Pid;
+        public string Display    = "";
+        public bool   HasWindow;
+        public bool   RepPlaying; // representative PID is playing
+        public bool   AnyPlaying; // any PID in the group is playing
+    }
+
+    private static int SafeCurrentSessionId()
+    {
+        try { using var me = Process.GetCurrentProcess(); return me.SessionId; }
+        catch { return 1; } // typical interactive session fallback
+    }
+
+    private static string SafeWindowTitle(Process proc)
+    {
+        try { return proc.MainWindowTitle; }
+        catch { return ""; }
+    }
+
+    // ── WASAPI: PIDs with an active render session (any endpoint) ─────────────
+    // Scans ALL active render endpoints, not just the default — an app routed to a
+    // secondary device still counts as "playing now".
+
+    private static HashSet<int> GetActiveAudioPids()
+    {
+        var pids = new HashSet<int>();
         IMMDeviceEnumerator? enumerator = null;
-        IMMDevice? device    = null;
+        IMMDeviceCollection? devices    = null;
-        IAudioSessionManager2? manager  = null;
-        IAudioSessionEnumerator? sessions = null;
 
         try
         {
             enumerator = (IMMDeviceEnumerator)Activator.CreateInstance(
                 Type.GetTypeFromCLSID(new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E"))!)!;
 
-            enumerator.GetDefaultAudioEndpoint(0 /*eRender*/, 1 /*eMultimedia*/, out device);
+            if (enumerator.EnumAudioEndpoints(0 /*eRender*/, 0x1 /*DEVICE_STATE_ACTIVE*/,
+                    out devices) < 0 || devices == null)
+                return pids;
+
+            devices.GetCount(out int devCount);
+            for (int d = 0; d < devCount; d++)
+                CollectActivePids(devices, d, pids);
+        }
+        catch { /* no audio device or WASAPI unavailable — ignore */ }
+        finally
+        {
+            if (devices    != null) Marshal.ReleaseComObject(devices);
+            if (enumerator != null) Marshal.ReleaseComObject(enumerator);
+        }
+
+        return pids;
+    }
+
+    private static void CollectActivePids(IMMDeviceCollection devices, int index, HashSet<int> pids)
+    {
+        IMMDevice? device                = null;
+        IAudioSessionManager2? manager    = null;
+        IAudioSessionEnumerator? sessions = null;
+
+        try
+        {
+            if (devices.Item(index, out device) < 0 || device == null) return;
 
             var mgr2Iid = new Guid("77AA99A0-1BD6-484F-8BC7-2C654C9A9B6F");
-            device.Activate(ref mgr2Iid, 0x17 /*CLSCTX_ALL*/, IntPtr.Zero, out object mgr);
+            if (device.Activate(ref mgr2Iid, 0x17 /*CLSCTX_ALL*/, IntPtr.Zero, out object mgr) < 0)
+                return;
             manager = (IAudioSessionManager2)mgr;
 
-            manager.GetSessionEnumerator(out sessions);
+            if (manager.GetSessionEnumerator(out sessions) < 0 || sessions == null) return;
             sessions.GetCount(out int count);
 
             for (int i = 0; i < count; i++)
@@ -98,32 +168,24 @@ public static class AudioSessionEnumerator
                 IAudioSessionControl? ctrl = null;
                 try
                 {
-                    sessions.GetSession(i, out ctrl);
+                    if (sessions.GetSession(i, out ctrl) < 0 || ctrl == null) continue;
+                    ctrl.GetState(out int state);
+                    if (state != 1 /*AudioSessionStateActive*/) continue;
+
                     var ctrl2 = (IAudioSessionControl2)ctrl;
                     ctrl2.GetProcessId(out uint pid);
-
+                    if (pid != 0) pids.Add((int)pid);
-                    int ipid = (int)pid;
-                    if (pid == 0 || ipid == selfPid || !seen.Add(ipid)) continue;
-
-                    try
-                    {
-                        var proc = Process.GetProcessById(ipid);
-                        if (!string.IsNullOrEmpty(proc.ProcessName))
-                            result.Add(new AudioAppInfo(ipid, proc.ProcessName));
-                    }
-                    catch { /* exited */ }
                 }
                 catch { /* stale session */ }
                 finally { if (ctrl != null) Marshal.ReleaseComObject(ctrl); }
             }
         }
-        catch { /* no audio device or WASAPI unavailable — ignore */ }
+        catch { /* device went away */ }
         finally
         {
             if (sessions != null) Marshal.ReleaseComObject(sessions);
             if (manager  != null) Marshal.ReleaseComObject(manager);
             if (device   != null) Marshal.ReleaseComObject(device);
-            if (enumerator != null) Marshal.ReleaseComObject(enumerator);
         }
     }
 
@@ -133,13 +195,21 @@ public static class AudioSessionEnumerator
      InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
     internal interface IMMDeviceEnumerator
     {
-        [PreserveSig] int EnumAudioEndpoints(int dataFlow, int stateMask, out IntPtr devices);
+        [PreserveSig] int EnumAudioEndpoints(int dataFlow, int stateMask, out IMMDeviceCollection devices);
         [PreserveSig] int GetDefaultAudioEndpoint(int dataFlow, int role, out IMMDevice endpoint);
         [PreserveSig] int GetDevice([MarshalAs(UnmanagedType.LPWStr)] string id, out IMMDevice device);
         [PreserveSig] int RegisterEndpointNotificationCallback(IntPtr client);
         [PreserveSig] int UnregisterEndpointNotificationCallback(IntPtr client);
     }
 
+    [ComImport, Guid("0BD7A1BE-7A1A-44DB-8397-CC5392387B5E"),
+     InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IMMDeviceCollection
+    {
+        [PreserveSig] int GetCount(out int count);
+        [PreserveSig] int Item(int index, out IMMDevice device);
+    }
+
     [ComImport, Guid("D666063F-1587-4E43-81F1-B948E807363F"),
      InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
     internal interface IMMDevice

clients/windows/VoiceCat.App/Audio/InputDeviceCapture.cs

@@ -0,0 +1,443 @@
+using System.Runtime.InteropServices;
+
+// Captures a second hardware input for AUX_DEVICE and feeds it through vc_stream_feed_pcm.
+// Endpoint identifiers are WASAPI-specific and cannot be exchanged with the core's miniaudio ids.
+namespace VoiceCat.App.Audio;
+
+/// <summary>An audio input (capture) endpoint for the aux-stream device picker. <see cref="Id"/>
+/// is a WASAPI endpoint id (round-trip only; never construct by hand) — pass null to capture the
+/// system default. <see cref="ToString"/> returns the friendly name for ComboBox display.</summary>
+public sealed record InputDeviceInfo(string Id, string Name, bool IsDefault)
+{
+    public override string ToString() => Name;
+}
+
+/// <summary>Enumerates WASAPI capture endpoints. Separate from the core's vc_list_devices because
+/// the aux device is opened client-side and needs a WASAPI id, not a miniaudio one.</summary>
+public static class InputDeviceEnumerator
+{
+    public static IReadOnlyList<InputDeviceInfo> List()
+    {
+        var result = new List<InputDeviceInfo>();
+        InputDeviceCapture.IMMDeviceEnumerator? enumerator = null;
+        IntPtr collectionPtr = IntPtr.Zero;
+        string? defaultId = null;
+
+        try
+        {
+            enumerator = (InputDeviceCapture.IMMDeviceEnumerator)Activator.CreateInstance(
+                Type.GetTypeFromCLSID(new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E"))!)!;
+
+            // Resolve the default capture endpoint id so the picker can flag it.
+            if (enumerator.GetDefaultAudioEndpoint(1 /*eCapture*/, 0 /*eConsole*/,
+                    out var defDev) == 0 && defDev != null)
+            {
+                try { if (defDev.GetId(out string id) == 0) defaultId = id; }
+                finally { Marshal.ReleaseComObject(defDev); }
+            }
+
+            // DEVICE_STATE_ACTIVE = 0x1 — only currently-usable endpoints.
+            if (enumerator.EnumAudioEndpoints(1 /*eCapture*/, 0x1, out collectionPtr) != 0
+                || collectionPtr == IntPtr.Zero)
+                return result;
+
+            var collection = (InputDeviceCapture.IMMDeviceCollection)
+                Marshal.GetObjectForIUnknown(collectionPtr);
+            collection.GetCount(out int count);
+
+            for (int i = 0; i < count; i++)
+            {
+                if (collection.Item(i, out var dev) != 0 || dev == null) continue;
+                try
+                {
+                    if (dev.GetId(out string id) != 0) continue;
+                    string name = ReadFriendlyName(dev) ?? "Unknown input device";
+                    result.Add(new InputDeviceInfo(id, name, id == defaultId));
+                }
+                finally { Marshal.ReleaseComObject(dev); }
+            }
+        }
+        catch { /* no audio subsystem / WASAPI unavailable — return what we have */ }
+        finally
+        {
+            if (collectionPtr != IntPtr.Zero) Marshal.Release(collectionPtr);
+            if (enumerator != null) Marshal.ReleaseComObject(enumerator);
+        }
+
+        return result.OrderBy(d => d.Name, StringComparer.OrdinalIgnoreCase).ToList();
+    }
+
+    private static string? ReadFriendlyName(InputDeviceCapture.IMMDevice dev)
+    {
+        if (dev.OpenPropertyStore(0 /*STGM_READ*/, out IntPtr storePtr) != 0
+            || storePtr == IntPtr.Zero)
+            return null;
+        try
+        {
+            var store = (InputDeviceCapture.IPropertyStore)Marshal.GetObjectForIUnknown(storePtr);
+            // PKEY_Device_FriendlyName = {a45c254e-df1c-4efd-8020-67d146a850e0}, pid 14.
+            var key = new InputDeviceCapture.PropertyKey
+            {
+                fmtid = new Guid("a45c254e-df1c-4efd-8020-67d146a850e0"),
+                pid = 14,
+            };
+            if (store.GetValue(ref key, out var pv) != 0) return null;
+            try
+            {
+                // VT_LPWSTR = 31.
+                return pv.vt == 31 ? Marshal.PtrToStringUni(pv.pointerValue) : null;
+            }
+            finally { InputDeviceCapture.PropVariantClear(ref pv); }
+        }
+        finally { Marshal.Release(storePtr); }
+    }
+}
+
+/// <summary>Captures a single hardware input device in WASAPI shared mode and raises a 20 ms
+/// (960 samples/channel @ 48 kHz, interleaved s16) frame event. The caller feeds these to the
+/// core's external-feed stream. Threading mirrors ProcessLoopbackCapture: all WASAPI work runs on
+/// a dedicated background (MTA) thread; the event fires on that thread.</summary>
+public sealed class InputDeviceCapture : IDisposable
+{
+    /// <summary>Fired on the capture thread every 20 ms: (interleaved s16 PCM, samplesPerChannel
+    /// = 960, channels).</summary>
+    public event Action<short[], int /*samplesPerChannel*/, int /*channels*/>? PcmFrameReady;
+
+    private const int SampleRate   = 48000;
+    private const int FrameSamples = 960;  // 20 ms
+
+    private readonly string? _deviceId;  // null = system default capture endpoint
+
+    private IAudioClient?        _audioClient;
+    private IAudioCaptureClient? _captureClient;
+
+    private AutoResetEvent? _bufferEvent;
+    private Thread?         _captureThread;
+    private volatile bool   _running;
+    private int             _channels;
+
+    // Accumulator: assembles driver-callback-sized fragments into FrameSamples chunks.
+    private short[] _accumBuf = [];
+    private int     _accumCount;
+
+    // Init-done signal: Set() by the capture thread after activation completes.
+    private readonly ManualResetEventSlim _initDone = new(false);
+    private bool _initOk;
+
+    public InputDeviceCapture(string? deviceId) => _deviceId = deviceId;
+
+    /// <summary>Starts capture. Blocks until WASAPI activation completes (typically &lt;100 ms).
+    /// Returns false if the device cannot be opened.</summary>
+    public bool Start()
+    {
+        if (_running) return false;
+        _running       = true;
+        _captureThread = new Thread(CaptureThreadProc)
+        {
+            IsBackground = true,
+            Name         = "AuxInputCapture",
+        };
+        _captureThread.Start();
+
+        bool ok = _initDone.Wait(5000) && _initOk;
+        if (!ok) _running = false;
+        return ok;
+    }
+
+    public void Stop()
+    {
+        _running = false;
+        _bufferEvent?.Set();
+        _captureThread?.Join(500);
+        try { _audioClient?.Stop(); } catch { /* device already gone */ }
+    }
+
+    public void Dispose()
+    {
+        Stop();
+        if (_captureClient != null) { Marshal.ReleaseComObject(_captureClient); _captureClient = null; }
+        if (_audioClient   != null) { Marshal.ReleaseComObject(_audioClient);   _audioClient   = null; }
+        _bufferEvent?.Dispose();
+        _initDone.Dispose();
+    }
+
+    // ── Capture thread (MTA) ──────────────────────────────────────────────────
+
+    private void CaptureThreadProc()
+    {
+        _initOk = ActivateAndStart();
+        _initDone.Set();
+        if (!_initOk) return;
+        CaptureLoop();
+    }
+
+    private bool ActivateAndStart()
+    {
+        if (!ActivateClient()) return false;
+
+        _bufferEvent = new AutoResetEvent(false);
+        if (_audioClient!.SetEventHandle(_bufferEvent.SafeWaitHandle.DangerousGetHandle()) < 0)
+            return false;
+
+        return _audioClient.Start() >= 0;
+    }
+
+    private bool ActivateClient()
+    {
+        IMMDeviceEnumerator? enumerator = null;
+        IMMDevice? device = null;
+        try
+        {
+            enumerator = (IMMDeviceEnumerator)Activator.CreateInstance(
+                Type.GetTypeFromCLSID(new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E"))!)!;
+
+            int hr = _deviceId is null
+                ? enumerator.GetDefaultAudioEndpoint(1 /*eCapture*/, 0 /*eConsole*/, out device)
+                : enumerator.GetDevice(_deviceId, out device);
+            if (hr != 0 || device == null) return false;
+
+            var iidAudioClient = new Guid("1CB9AD4C-DBFA-4c32-B178-C2F568A703B2");
+            if (device.Activate(ref iidAudioClient, 0x17 /*CLSCTX_ALL*/, IntPtr.Zero,
+                    out object acObj) != 0 || acObj is not IAudioClient ac)
+                return false;
+            _audioClient = ac;
+
+            return InitializeStream();
+        }
+        catch { return false; }
+        finally
+        {
+            if (device     != null) Marshal.ReleaseComObject(device);
+            if (enumerator != null) Marshal.ReleaseComObject(enumerator);
+        }
+    }
+
+    private bool InitializeStream()
+    {
+        // Try s16 stereo first; fall back to s16 mono. AUTOCONVERTPCM lets the audio engine
+        // resample/convert the device's native format to our requested 48 kHz s16; EVENTCALLBACK
+        // drives the buffer-ready event. Shared mode (0), no LOOPBACK (this is a capture device).
+        //   AUDCLNT_STREAMFLAGS_EVENTCALLBACK    = 0x00040000
+        //   AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM   = 0x80000000
+        //   AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY = 0x08000000
+        const uint streamFlags = 0x00040000u | 0x80000000u | 0x08000000u;
+
+        foreach (int ch in new[] { 2, 1 })
+        {
+            var fmt = new WaveFormatEx
+            {
+                wFormatTag      = 1,           // WAVE_FORMAT_PCM
+                nChannels       = (ushort)ch,
+                nSamplesPerSec  = SampleRate,
+                wBitsPerSample  = 16,
+                nBlockAlign     = (ushort)(ch * 2),
+                nAvgBytesPerSec = (uint)(SampleRate * ch * 2),
+                cbSize          = 0,
+            };
+
+            IntPtr pFmt = Marshal.AllocHGlobal(Marshal.SizeOf<WaveFormatEx>());
+            try
+            {
+                Marshal.StructureToPtr(fmt, pFmt, false);
+                int hr = _audioClient!.Initialize(0 /*AUDCLNT_SHAREMODE_SHARED*/, streamFlags,
+                    2_000_000 /*200 ms hns*/, 0, pFmt, IntPtr.Zero);
+                if (hr >= 0)
+                {
+                    _channels   = ch;
+                    _accumBuf   = new short[FrameSamples * ch];
+                    _accumCount = 0;
+
+                    var iidCapture = new Guid("C8ADBD64-E71E-48a0-A4DE-185C395CD317");
+                    if (_audioClient.GetService(ref iidCapture, out object ccObj) != 0
+                        || ccObj is not IAudioCaptureClient cc)
+                        return false;
+                    _captureClient = cc;
+                    return true;
+                }
+                if (ch == 1) return false;
+            }
+            finally { Marshal.FreeHGlobal(pFmt); }
+        }
+        return false;
+    }
+
+    // ── Capture loop ─────────────────────────────────────────────────────────
+
+    private void CaptureLoop()
+    {
+        while (_running)
+        {
+            _bufferEvent!.WaitOne(100);
+            if (!_running) break;
+
+            while (_running)
+            {
+                if (_captureClient!.GetNextPacketSize(out uint packetSize) < 0 || packetSize == 0)
+                    break;
+
+                if (_captureClient.GetBuffer(out IntPtr dataPtr, out uint framesAvailable,
+                        out uint flags, out _, out _) < 0)
+                    break;
+
+                bool silent = (flags & 2) != 0; // AUDCLNT_BUFFERFLAGS_SILENT
+                if (framesAvailable > 0)
+                {
+                    if (silent) AccumulateSilence((int)framesAvailable);
+                    else        AccumulatePcm(dataPtr, (int)framesAvailable);
+                }
+
+                _captureClient.ReleaseBuffer(framesAvailable);
+            }
+        }
+    }
+
+    private unsafe void AccumulatePcm(IntPtr data, int frames)
+    {
+        var src   = (short*)data.ToPointer();
+        int total = frames * _channels;
+        int idx   = 0;
+        while (idx < total)
+        {
+            int space = _accumBuf.Length - _accumCount;
+            int copy  = Math.Min(total - idx, space);
+            fixed (short* dst = _accumBuf)
+                Buffer.MemoryCopy(src + idx, dst + _accumCount, copy * 2L, copy * 2L);
+            _accumCount += copy;
+            idx         += copy;
+            if (_accumCount == _accumBuf.Length)
+                FlushFrame();
+        }
+    }
+
+    private void AccumulateSilence(int frames)
+    {
+        int total = frames * _channels;
+        int idx   = 0;
+        while (idx < total)
+        {
+            int space = _accumBuf.Length - _accumCount;
+            int fill  = Math.Min(total - idx, space);
+            Array.Clear(_accumBuf, _accumCount, fill);
+            _accumCount += fill;
+            idx         += fill;
+            if (_accumCount == _accumBuf.Length)
+                FlushFrame();
+        }
+    }
+
+    private void FlushFrame()
+    {
+        var copy = new short[_accumBuf.Length];
+        _accumBuf.AsSpan().CopyTo(copy);
+        PcmFrameReady?.Invoke(copy, FrameSamples, _channels);
+        _accumCount = 0;
+    }
+
+    // ── COM declarations ───────────────────────────────────────────────────────
+    //
+    // Declared internal here so InputDeviceEnumerator can share them. These are standard MMDevice
+    // / WASAPI interfaces; a normal capture endpoint honours QueryInterface, so RCW marshalling is
+    // safe (unlike ProcessLoopbackCapture's process-loopback objects, which need raw vtable calls).
+
+    [ComImport, Guid("A95664D2-9614-4F35-A746-DE8DB63617E6"),
+     InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IMMDeviceEnumerator
+    {
+        [PreserveSig] int EnumAudioEndpoints(int dataFlow, int stateMask, out IntPtr devices);
+        [PreserveSig] int GetDefaultAudioEndpoint(int dataFlow, int role, out IMMDevice endpoint);
+        [PreserveSig] int GetDevice([MarshalAs(UnmanagedType.LPWStr)] string id, out IMMDevice device);
+        [PreserveSig] int RegisterEndpointNotificationCallback(IntPtr client);
+        [PreserveSig] int UnregisterEndpointNotificationCallback(IntPtr client);
+    }
+
+    [ComImport, Guid("0BD7A1BE-7A1A-44DB-8397-CC5392387B5E"),
+     InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IMMDeviceCollection
+    {
+        [PreserveSig] int GetCount(out int count);
+        [PreserveSig] int Item(int index, out IMMDevice device);
+    }
+
+    [ComImport, Guid("D666063F-1587-4E43-81F1-B948E807363F"),
+     InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IMMDevice
+    {
+        [PreserveSig] int Activate(ref Guid iid, int clsCtx, IntPtr activationParams,
+            [MarshalAs(UnmanagedType.IUnknown)] out object ppInterface);
+        [PreserveSig] int OpenPropertyStore(int stgmAccess, out IntPtr propStore);
+        [PreserveSig] int GetId([MarshalAs(UnmanagedType.LPWStr)] out string id);
+        [PreserveSig] int GetState(out int state);
+    }
+
+    [ComImport, Guid("886D8EEB-8CF2-4446-8D02-CDBA1DBDCF99"),
+     InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IPropertyStore
+    {
+        [PreserveSig] int GetCount(out int count);
+        [PreserveSig] int GetAt(int index, out PropertyKey key);
+        [PreserveSig] int GetValue(ref PropertyKey key, out PropVariant value);
+        [PreserveSig] int SetValue(ref PropertyKey key, ref PropVariant value);
+        [PreserveSig] int Commit();
+    }
+
+    [ComImport, Guid("1CB9AD4C-DBFA-4C32-B178-C2F568A703B2"),
+     InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IAudioClient
+    {
+        [PreserveSig] int Initialize(int shareMode, uint streamFlags, long hnsBufferDuration,
+            long hnsPeriodicity, IntPtr pFormat, IntPtr audioSessionGuid);
+        [PreserveSig] int GetBufferSize(out uint numBufferFrames);
+        [PreserveSig] int GetStreamLatency(out long latency);
+        [PreserveSig] int GetCurrentPadding(out uint numPaddingFrames);
+        [PreserveSig] int IsFormatSupported(int shareMode, IntPtr pFormat, out IntPtr closestMatch);
+        [PreserveSig] int GetMixFormat(out IntPtr deviceFormat);
+        [PreserveSig] int GetDevicePeriod(out long defaultDevicePeriod, out long minimumDevicePeriod);
+        [PreserveSig] int Start();
+        [PreserveSig] int Stop();
+        [PreserveSig] int Reset();
+        [PreserveSig] int SetEventHandle(IntPtr eventHandle);
+        [PreserveSig] int GetService(ref Guid riid,
+            [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
+    }
+
+    [ComImport, Guid("C8ADBD64-E71E-48A0-A4DE-185C395CD317"),
+     InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IAudioCaptureClient
+    {
+        [PreserveSig] int GetBuffer(out IntPtr data, out uint numFramesToRead, out uint flags,
+            out ulong devicePosition, out ulong qpcPosition);
+        [PreserveSig] int ReleaseBuffer(uint numFramesRead);
+        [PreserveSig] int GetNextPacketSize(out uint numFramesInNextPacket);
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 2)]
+    private struct WaveFormatEx
+    {
+        public ushort wFormatTag;
+        public ushort nChannels;
+        public uint   nSamplesPerSec;
+        public uint   nAvgBytesPerSec;
+        public ushort nBlockAlign;
+        public ushort wBitsPerSample;
+        public ushort cbSize;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct PropertyKey
+    {
+        public Guid fmtid;
+        public int  pid;
+    }
+
+    // Minimal PROPVARIANT: we only ever read VT_LPWSTR (friendly name). x64 layout — the value
+    // union starts at offset 8 after vt(2)+reserved(6).
+    [StructLayout(LayoutKind.Explicit)]
+    internal struct PropVariant
+    {
+        [FieldOffset(0)] public ushort vt;
+        [FieldOffset(8)] public IntPtr pointerValue;
+    }
+
+    [DllImport("ole32.dll")]
+    internal static extern int PropVariantClear(ref PropVariant pvar);
+}

clients/windows/VoiceCat.App/Audio/ProcessAudioMixer.cs

@@ -22,15 +22,14 @@ public sealed class ProcessAudioMixer : IDisposable
     private VoiceCatClient?  _client;
     private uint             _streamId;
 
-    public void Start(AppAudioScope scope, VoiceCatClient client, uint streamId,
+    public void Start(AppAudioScope scope, VoiceCatClient client, uint streamId)
-                      IReadOnlyList<AudioAppInfo> allApps)
     {
         if (_running) return;
         _client   = client;
         _streamId = streamId;
 
-        var pids = ResolvePids(scope, allApps);
+        var specs = ResolveCaptures(scope);
-        if (pids.Count == 0)
+        if (specs.Count == 0)
         {
             // nothing to capture — scope resolved to empty set
             return;
@@ -38,14 +37,15 @@ public sealed class ProcessAudioMixer : IDisposable
 
         lock (_frameLock)
         {
-            _latestFrames   = new List<short[]>(new short[pids.Count][]);
+            _latestFrames   = new List<short[]>(new short[specs.Count][]);
             _activeChannels = Channels;
         }
 
-        for (int i = 0; i < pids.Count; i++)
+        for (int i = 0; i < specs.Count; i++)
         {
             int captureIndex = i;
-            var cap = new ProcessLoopbackCapture(pids[i], ProcessLoopbackCapture.Mode.Include);
+            var (pid, mode) = specs[i];
+            var cap = new ProcessLoopbackCapture(pid, mode);
             cap.PcmFrameReady += (pcm, spc, ch) => OnCaptureFrame(captureIndex, pcm, ch);
             _captures.Add(cap);
         }
@@ -105,7 +105,6 @@ public sealed class ProcessAudioMixer : IDisposable
                     for (int i = 0; i < frameLen; i++)
                     {
                         int sum = mix[i] + frame[i];
-                        // Saturating clamp
                         mix[i] = (short)Math.Clamp(sum, short.MinValue, short.MaxValue);
                     }
                 }
@@ -117,18 +116,21 @@ public sealed class ProcessAudioMixer : IDisposable
 
     // ── Helpers ───────────────────────────────────────────────────────────────
 
-    // For "AllExcept": enumerate all running audio apps and exclude the specified ones.
+    // Resolve the scope to the WASAPI captures to open:
-    // For "OnlyApps": use their PIDs directly.
+    //  OnlyApps      → one INCLUDE capture per selected process tree.
-    private static List<int> ResolvePids(AppAudioScope scope, IReadOnlyList<AudioAppInfo> allApps)
+    //  AllExceptApps → one EXCLUDE capture of the single selected process tree, which
+    //                  natively captures the whole system render mix minus that tree
+    //                  (dynamic — apps launched later are included automatically).
+    private static List<(int pid, ProcessLoopbackCapture.Mode mode)> ResolveCaptures(AppAudioScope scope)
     {
         return scope switch
         {
-            OnlyApps    o => [.. o.Pids],
+            OnlyApps      o => o.Pids.Select(p => (p, ProcessLoopbackCapture.Mode.Include)).ToList(),
-            AllExceptApps a =>
+            AllExceptApps a when a.Pids.Count > 0 =>
-                allApps
+                [(a.Pids[0], ProcessLoopbackCapture.Mode.Exclude)],
-                    .Where(app => !a.Pids.Contains(app.Pid))
+            // Entire desktop minus VoiceCat itself: EXCLUDE our own process tree.
-                    .Select(app => app.Pid)
+            EntireDesktop { ExcludeSelf: true } =>
-                    .ToList(),
+                [(Environment.ProcessId, ProcessLoopbackCapture.Mode.Exclude)],
             _ => [],
         };
     }

clients/windows/VoiceCat.App/Audio/ProcessLoopbackCapture.cs

@@ -1,17 +1,8 @@
 using System.Runtime.InteropServices;
 
-// Single-process WASAPI loopback capture via AUDIOCLIENT_ACTIVATION_PARAMS
+// Process loopback requires MTA activation; blocking activation from the WinForms STA
-// (Windows 10 2004+ / Build 19041+).
+// deadlocks COM completion. The returned interfaces also reject RCW QueryInterface, so audio
-//
+// calls use explicitly owned raw pointers and vtable dispatch.
-// Threading: ALL WASAPI init runs on the capture thread (MTA). If called from the
-// WinForms UI thread (STA), ActivateAudioInterfaceAsync fires ActivateCompleted on
-// an MTA pool thread; COM marshals that back to the STA pump — but the STA thread is
-// blocked on CompletionEvent.Wait → deadlock. MTA capture thread avoids this.
-//
-// COM QI policy: the COM objects returned by the process-loopback activation path
-// reject QueryInterface for their own IIDs under .NET's RCW mechanism. Every call
-// to IAudioClient and IAudioCaptureClient is therefore dispatched via raw vtable
-// pointer arithmetic, bypassing .NET COM interop entirely.
 namespace VoiceCat.App.Audio;
 
 public sealed class ProcessLoopbackCapture : IDisposable

clients/windows/VoiceCat.App/Forms/AppAudioPickerDialog.cs

@@ -12,12 +12,18 @@ public sealed class AppAudioPickerDialog : Form
     private readonly RadioButton  _rdoAll;
     private readonly RadioButton  _rdoOnly;
     private readonly RadioButton  _rdoExcept;
+    private readonly CheckBox     _chkExcludeSelf;
+    private readonly TextBox      _txtFilter;
     private readonly ListView     _appList;
     private readonly Label        _lblApps;
 
     // Snapshot taken when the dialog opens (refresh on open, not on every check change).
     private IReadOnlyList<AudioAppInfo> _apps = [];
 
+    // Checked apps survive filtering (a filtered-out row keeps its check here).
+    // pid → clean display name (used for the shared scope's Names).
+    private readonly Dictionary<int, string> _checked = new();
+
     public AppAudioScope? ChosenScope { get; private set; }
 
     public AppAudioPickerDialog()
@@ -50,51 +56,78 @@ public sealed class AppAudioPickerDialog : Form
         _rdoOnly.CheckedChanged   += OnModeChanged;
         _rdoExcept.CheckedChanged += OnModeChanged;
 
-        // ── App list ────────────────────────────────────────────────────────
+        // ── Self-exclude (echo prevention) ───────────────────────────────────
-        _lblApps = new Label
+        // Captures the whole desktop minus VoiceCat's own playback, so the channel
+        // doesn't echo back the voices you're already hearing. Only applies to the
+        // entire-desktop mode (the per-app modes already exclude this app's tree).
+        _chkExcludeSelf = new CheckBox
         {
-            Text     = "Apps with active audio sessions:",
+            Text     = "E&xclude VoiceCat's own audio (prevents echo)",
-            AutoSize = true,
+            Checked  = true,
-            Location = new Point(12, 90),
+            Location = new Point(28, 84),
-            Visible  = false,
+            Size     = new Size(344, 20),
             TabIndex = 3,
         };
 
+        // ── App list ────────────────────────────────────────────────────────
+        _lblApps = new Label
+        {
+            Text     = "Apps (▶ = currently playing):",
+            AutoSize = true,
+            Location = new Point(12, 112),
+            Visible  = false,
+            TabIndex = 4,
+        };
+
+        _txtFilter = new TextBox
+        {
+            Location        = new Point(12, 132),
+            Size            = new Size(360, 23),
+            PlaceholderText = "Filter apps…",
+            Visible         = false,
+            TabIndex        = 5,
+        };
+        _txtFilter.TextChanged += (_, _) => PopulateList();
+
         _appList = new ListView
         {
-            Location      = new Point(12, 112),
+            Location      = new Point(12, 160),
-            Size          = new Size(360, 180),
+            Size          = new Size(360, 150),
             CheckBoxes    = true,
             View          = View.List,
             Visible       = false,
-            TabIndex      = 4,
+            TabIndex      = 6,
             FullRowSelect = true,
         };
+        // Exclude mode supports only one target process tree (WASAPI EXCLUDE takes a single
+        // PID), so enforce a single check while "All apps except selected" is active.
+        _appList.ItemCheck += OnAppItemCheck;
 
         // ── Buttons ─────────────────────────────────────────────────────────
         var btnShare = new Button
         {
             Text         = "&Share",
             DialogResult = DialogResult.OK,
-            Location     = new Point(216, 308),
+            Location     = new Point(216, 320),
             Size         = new Size(75, 27),
-            TabIndex     = 5,
+            TabIndex     = 7,
         };
         var btnCancel = new Button
         {
             Text         = "&Cancel",
             DialogResult = DialogResult.Cancel,
-            Location     = new Point(297, 308),
+            Location     = new Point(297, 320),
             Size         = new Size(75, 27),
-            TabIndex     = 6,
+            TabIndex     = 8,
         };
         btnShare.Click += OnShareClick;
 
         AcceptButton  = btnShare;
         CancelButton  = btnCancel;
         AutoScaleMode = AutoScaleMode.Font;
-        ClientSize    = new Size(384, 348);
+        ClientSize    = new Size(384, 360);
-        Controls.AddRange([_rdoAll, _rdoOnly, _rdoExcept, _lblApps, _appList, btnShare, btnCancel]);
+        Controls.AddRange([_rdoAll, _rdoOnly, _rdoExcept, _chkExcludeSelf, _lblApps, _txtFilter,
+                           _appList, btnShare, btnCancel]);
         FormBorderStyle = FormBorderStyle.FixedDialog;
         MaximizeBox     = false;
         MinimizeBox     = false;
@@ -111,41 +144,105 @@ public sealed class AppAudioPickerDialog : Form
     private void RefreshAppList()
     {
         _apps = AudioSessionEnumerator.GetAudioApps();
+        PopulateList();
+    }
+
+    // Rebuild the visible rows from _apps + the current filter text, restoring check
+    // state from _checked so a selection persists while the user filters.
+    private void PopulateList()
+    {
+        string filter = _txtFilter.Text.Trim();
+
+        _suppressItemCheck = true;
+        _appList.BeginUpdate();
         _appList.Items.Clear();
         foreach (var app in _apps)
-            _appList.Items.Add(new ListViewItem($"{app.DisplayName}  (PID {app.Pid})") { Tag = app.Pid });
+        {
+            if (filter.Length > 0 &&
+                app.DisplayName.IndexOf(filter, StringComparison.OrdinalIgnoreCase) < 0)
+                continue;
+
+            string marker = app.IsPlaying ? "▶ " : "";
+            _appList.Items.Add(new ListViewItem($"{marker}{app.DisplayName}  (PID {app.Pid})")
+            {
+                Tag     = app,
+                Checked = _checked.ContainsKey(app.Pid),
+            });
+        }
+        _appList.EndUpdate();
+        _suppressItemCheck = false;
     }
 
     private void OnModeChanged(object? sender, EventArgs e)
     {
         bool showList = _rdoOnly.Checked || _rdoExcept.Checked;
         _lblApps.Visible   = showList;
+        _txtFilter.Visible = showList;
         _appList.Visible   = showList;
+        _lblApps.Text = _rdoExcept.Checked
+            ? "App to exclude (everything else is shared):"
+            : "Apps (▶ = currently playing):";
+
+        // Self-exclude only applies to entire-desktop; the per-app modes already exclude
+        // this app's own tree (Include) or spend the single EXCLUDE slot on the chosen app.
+        _chkExcludeSelf.Enabled = _rdoAll.Checked;
+
+        // Switching into exclude mode: collapse any multi-selection down to a single item.
+        if (_rdoExcept.Checked)
+            TrimCheckedToOne();
 
         if (showList && _appList.Items.Count == 0)
             RefreshAppList();
+        else
+            PopulateList(); // re-render markers/labels and restore check state
+    }
+
+    // In exclude mode the list behaves like radio buttons: checking one item clears the rest.
+    private bool _suppressItemCheck;
+
+    private void OnAppItemCheck(object? sender, ItemCheckEventArgs e)
+    {
+        if (_suppressItemCheck) return;
+        if (_appList.Items[e.Index].Tag is not AudioAppInfo app) return;
+
+        if (e.NewValue == CheckState.Checked)
+        {
+            if (_rdoExcept.Checked)
+            {
+                // Radio behavior: clear every other visible check and the persisted set.
+                _suppressItemCheck = true;
+                foreach (ListViewItem item in _appList.Items)
+                    if (item.Index != e.Index && item.Checked) item.Checked = false;
+                _suppressItemCheck = false;
+                _checked.Clear();
+            }
+            _checked[app.Pid] = app.DisplayName;
+        }
+        else
+        {
+            _checked.Remove(app.Pid);
+        }
+    }
+
+    // Reduce the persisted selection to a single (first) entry — used when entering
+    // exclude mode, whose single EXCLUDE slot can only target one process tree.
+    private void TrimCheckedToOne()
+    {
+        if (_checked.Count <= 1) return;
+        var first = _checked.First();
+        _checked.Clear();
+        _checked[first.Key] = first.Value;
     }
 
     private void OnShareClick(object? sender, EventArgs e)
     {
         if (_rdoAll.Checked)
         {
-            ChosenScope = new EntireDesktop();
+            ChosenScope = new EntireDesktop(_chkExcludeSelf.Checked);
             return;
         }
 
-        var checkedPids   = new List<int>();
+        if (_checked.Count == 0)
-        var checkedNames  = new List<string>();
-        foreach (ListViewItem item in _appList.CheckedItems)
-        {
-            if (item.Tag is int pid)
-            {
-                checkedPids.Add(pid);
-                checkedNames.Add(item.Text);
-            }
-        }
-
-        if (checkedPids.Count == 0)
         {
             MessageBox.Show(
                 "Select at least one app, or choose 'Entire desktop'.",
@@ -156,11 +253,11 @@ public sealed class AppAudioPickerDialog : Form
             return;
         }
 
-        ChosenScope = _rdoOnly.Checked
+        var pids  = _checked.Keys.ToList();
-            ? new OnlyApps(checkedPids, checkedNames)
+        var names = _checked.Values.ToList();
-            : new AllExceptApps(checkedPids, checkedNames);
-    }
 
-    /// <summary>All apps that were visible in the list when the user clicked Share.</summary>
+        ChosenScope = _rdoOnly.Checked
-    public IReadOnlyList<AudioAppInfo> VisibleApps => _apps;
+            ? new OnlyApps(pids, names)
+            : new AllExceptApps(pids, names);
+    }
 }

clients/windows/VoiceCat.App/Forms/AudioSettingsForm.cs

@@ -0,0 +1,574 @@
+using System.ComponentModel;
+using VoiceCat.App.Audio;
+using VoiceCat.App.Models;
+using VoiceCat.Interop;
+
+namespace VoiceCat.App.Forms;
+
+/// <summary>
+/// Edits audio input settings: device selection, transmission mode (VAD/PTT/always-on),
+/// VAD sensitivity, mic gain, and PTT key. Changes are applied live to the client for
+/// immediate feedback; Cancel reverts them.
+/// </summary>
+public sealed class AudioSettingsForm : Form
+{
+    private readonly VoiceCatClient _client;
+    private readonly VoiceSettings _settings;
+    private readonly uint _micStreamId;
+
+    // Aux-stream live-apply callbacks, supplied by MainForm (which owns the aux capture). Null
+    // when not connected — the controls still edit settings, just without live effect.
+    private readonly Action<bool>?    _applyAuxEnabled;
+    private readonly Action<string?>? _applyAuxDevice;
+    private readonly Action<float>?   _applyAuxGain;
+
+    // Snapshot of original values so Cancel can restore them
+    private readonly string? _origDeviceId;
+    private readonly VcInputMode _origMode;
+    private readonly int _origVadSlider;
+    private readonly int _origMicGain;
+    private readonly bool _origMicNoiseReduction;
+    private readonly bool _origStereoMic;
+    private readonly Keys _origPttKey;
+    private readonly bool _origSystemWidePtt;
+    private readonly bool _origAuxEnabled;
+    private readonly string? _origAuxDeviceId;
+    private readonly int _origAuxGain;
+
+    private readonly ComboBox _cboDevice;
+    private readonly Button _btnRefresh;
+    private readonly RadioButton _radioVad;
+    private readonly RadioButton _radioPtt;
+    private readonly RadioButton _radioAlwaysOn;
+    private readonly Label _lblPttKey;
+    private readonly Button _btnChangePtt;
+    private readonly CheckBox _chkSystemWidePtt;
+    private readonly Label _lblSensitivity;
+    private readonly TrackBar _trkVad;
+    private readonly TrackBar _trkGain;
+    private readonly CheckBox _chkNoiseReduction;
+    private readonly CheckBox _chkStereoMic;
+    private readonly CheckBox _chkAux;
+    private readonly Label _lblAuxDevice;
+    private readonly ComboBox _cboAuxDevice;
+    private readonly Button _btnAuxRefresh;
+    private readonly Label _lblAuxGain;
+    private readonly TrackBar _trkAuxGain;
+
+    private Keys _pttKey;
+
+    public AudioSettingsForm(VoiceCatClient client, VoiceSettings settings, uint micStreamId,
+        Action<bool>? applyAuxEnabled = null, Action<string?>? applyAuxDevice = null,
+        Action<float>? applyAuxGain = null)
+    {
+        _client = client;
+        _settings = settings;
+        _micStreamId = micStreamId;
+        _applyAuxEnabled = applyAuxEnabled;
+        _applyAuxDevice = applyAuxDevice;
+        _applyAuxGain = applyAuxGain;
+        _pttKey = (Keys)settings.PttKey;
+
+        _origDeviceId = settings.InputDeviceId;
+        _origMode = (VcInputMode)settings.InputMode;
+        _origVadSlider = settings.VadThresholdSlider;
+        _origMicGain = settings.MicGain;
+        _origMicNoiseReduction = settings.MicNoiseReduction;
+        _origStereoMic = settings.StereoMic;
+        _origPttKey = _pttKey;
+        _origSystemWidePtt = settings.SystemWidePtt;
+        _origAuxEnabled = settings.AuxEnabled;
+        _origAuxDeviceId = settings.AuxDeviceId;
+        _origAuxGain = settings.AuxGain;
+
+        Text = "Audio settings";
+        FormBorderStyle = FormBorderStyle.FixedDialog;
+        MaximizeBox = false;
+        MinimizeBox = false;
+        StartPosition = FormStartPosition.CenterParent;
+        AutoScaleMode = AutoScaleMode.Font;
+        ClientSize = new Size(420, 639);
+
+        // ── Device row ────────────────────────────────────────────────────────
+        var lblDevice = new Label
+        {
+            Text = "Input &device:",
+            Location = new Point(12, 16),
+            AutoSize = true,
+        };
+
+        _cboDevice = new ComboBox
+        {
+            Location = new Point(12, 36),
+            Width = 300,
+            DropDownStyle = ComboBoxStyle.DropDownList,
+            DisplayMember = "Name",
+            ValueMember = "Id",
+            AccessibleName = "Input device",
+            AccessibleDescription = "Select which microphone or audio input device to use.",
+        };
+        _cboDevice.SelectedIndexChanged += CboDevice_SelectedIndexChanged;
+
+        _btnRefresh = new Button
+        {
+            Text = "&Refresh",
+            Location = new Point(320, 34),
+            Size = new Size(80, 26),
+        };
+        _btnRefresh.Click += (_, _) => LoadDevices();
+
+        // ── Transmission mode ─────────────────────────────────────────────────
+        var lblMode = new Label
+        {
+            Text = "Transmission mode:",
+            Location = new Point(12, 76),
+            AutoSize = true,
+        };
+
+        _radioVad = new RadioButton
+        {
+            Text = "&Voice activation",
+            Location = new Point(20, 96),
+            AutoSize = true,
+        };
+        _radioVad.CheckedChanged += RadioMode_CheckedChanged;
+
+        _lblSensitivity = new Label
+        {
+            Text = "Sensitivity:",
+            Location = new Point(36, 122),
+            AutoSize = true,
+        };
+        _trkVad = new TrackBar
+        {
+            Location = new Point(36, 140),
+            Size = new Size(200, 45),
+            Minimum = 1,
+            Maximum = 100,
+            TickFrequency = 10,
+            SmallChange = 1,
+            LargeChange = 10,
+            Value = Math.Clamp(settings.VadThresholdSlider, 1, 100),
+        };
+        _trkVad.AccessibleName = "VAD sensitivity";
+        _trkVad.AccessibleDescription =
+            "Voice detection sensitivity. Higher = more sensitive. Range 1–100.";
+        _trkVad.Scroll += TrkVad_Scroll;
+
+        _radioPtt = new RadioButton
+        {
+            Text = "&Push to talk",
+            Location = new Point(20, 192),
+            AutoSize = true,
+        };
+        _radioPtt.CheckedChanged += RadioMode_CheckedChanged;
+
+        _lblPttKey = new Label
+        {
+            Location = new Point(140, 194),
+            AutoSize = true,
+        };
+
+        _btnChangePtt = new Button
+        {
+            Text = "Change key...",
+            Location = new Point(200, 189),
+            Size = new Size(105, 26),
+        };
+        _btnChangePtt.Click += BtnChangePtt_Click;
+
+        // Indented PTT sub-option: observe the key system-wide (Raw Input) so it works while
+        // another app is focused. Visible only in PTT mode (RadioMode_CheckedChanged).
+        _chkSystemWidePtt = new CheckBox
+        {
+            Text = "Wor&ks in the background (system-wide)",
+            Location = new Point(36, 218),
+            AutoSize = true,
+            Checked = settings.SystemWidePtt,
+            AccessibleName = "System-wide push-to-talk",
+            AccessibleDescription =
+                "Let push-to-talk work while another application is focused. Uses the Windows Raw " +
+                "Input API, not a keyboard hook.",
+        };
+        _chkSystemWidePtt.CheckedChanged += ChkSystemWidePtt_CheckedChanged;
+
+        _radioAlwaysOn = new RadioButton
+        {
+            Text = "A&lways on",
+            Location = new Point(20, 252),
+            AutoSize = true,
+        };
+        _radioAlwaysOn.CheckedChanged += RadioMode_CheckedChanged;
+
+        // ── Mic gain ──────────────────────────────────────────────────────────
+        var lblGain = new Label
+        {
+            Text = "Microphone &volume:",
+            Location = new Point(12, 296),
+            AutoSize = true,
+        };
+        _trkGain = new TrackBar
+        {
+            Location = new Point(12, 316),
+            Size = new Size(200, 45),
+            Minimum = 0,
+            Maximum = 400,
+            TickFrequency = 25,
+            SmallChange = 5,
+            LargeChange = 25,
+            Value = Math.Clamp(settings.MicGain, 0, 400),
+        };
+        _trkGain.AccessibleName = "Microphone volume";
+        _trkGain.AccessibleDescription =
+            "Boost a quiet microphone. 100 is unity gain; range 0–400 percent.";
+        _trkGain.Scroll += TrkGain_Scroll;
+
+        // ── Mic noise reduction ───────────────────────────────────────────────
+        // Send-side RNNoise denoise of the mic stream. MIC-only (the core's NR runs before
+        // the input gain and VAD/PTT gate; aux/screen are excluded). One pass for all listeners.
+        _chkNoiseReduction = new CheckBox
+        {
+            Text = "Noise &reduction (RNNoise)",
+            Location = new Point(12, 368),
+            AutoSize = true,
+            Checked = settings.MicNoiseReduction,
+            AccessibleName = "Microphone noise reduction",
+            AccessibleDescription =
+                "RNNoise denoising of your microphone. Cleans your signal for everyone listening.",
+        };
+        _chkNoiseReduction.CheckedChanged += ChkNoiseReduction_CheckedChanged;
+
+        // ── Stereo microphone ─────────────────────────────────────────────────
+        // Opens the mic capture device in stereo (interleaved L/R) instead of mono. Real stereo
+        // only reaches the wire on a stereo channel; the core folds a stereo mic to mono on a mono
+        // channel. Toggling while connected restarts the capture device (vc_audio_restart) so the
+        // new channel count takes effect immediately.
+        _chkStereoMic = new CheckBox
+        {
+            Text = "&Stereo microphone",
+            Location = new Point(12, 392),
+            AutoSize = true,
+            Checked = settings.StereoMic,
+            AccessibleName = "Stereo microphone",
+            AccessibleDescription =
+                "Capture your microphone in stereo. Only transmitted in stereo on a stereo channel.",
+        };
+        _chkStereoMic.CheckedChanged += ChkStereoMic_CheckedChanged;
+
+        // ── Aux input stream ──────────────────────────────────────────────────
+        // A second outgoing stream from another hardware input device (e.g. line-in / aux),
+        // captured client-side and fed to the core. Device + volume only — aux is always-on
+        // (the core never gates AUX_DEVICE on VAD/PTT).
+        _chkAux = new CheckBox
+        {
+            Text = "&Aux stream (second input device)",
+            Location = new Point(12, 432),
+            AutoSize = true,
+            Checked = settings.AuxEnabled,
+            AccessibleName = "Enable aux input stream",
+            AccessibleDescription =
+                "Transmit a second hardware input device alongside your microphone.",
+        };
+        _chkAux.CheckedChanged += ChkAux_CheckedChanged;
+
+        _lblAuxDevice = new Label
+        {
+            Text = "Aux d&evice:",
+            Location = new Point(12, 462),
+            AutoSize = true,
+        };
+        _cboAuxDevice = new ComboBox
+        {
+            Location = new Point(12, 482),
+            Width = 300,
+            DropDownStyle = ComboBoxStyle.DropDownList,
+            DisplayMember = "Name",
+            ValueMember = "Id",
+            AccessibleName = "Aux input device",
+            AccessibleDescription = "Select the second audio input device to transmit.",
+        };
+        _cboAuxDevice.SelectedIndexChanged += CboAuxDevice_SelectedIndexChanged;
+
+        _btnAuxRefresh = new Button
+        {
+            Text = "Re&fresh",
+            Location = new Point(320, 480),
+            Size = new Size(80, 26),
+        };
+        _btnAuxRefresh.Click += (_, _) => LoadAuxDevices();
+
+        _lblAuxGain = new Label
+        {
+            Text = "Aux vo&lume:",
+            Location = new Point(12, 518),
+            AutoSize = true,
+        };
+        _trkAuxGain = new TrackBar
+        {
+            Location = new Point(12, 538),
+            Size = new Size(200, 45),
+            Minimum = 0,
+            Maximum = 400,
+            TickFrequency = 25,
+            SmallChange = 5,
+            LargeChange = 25,
+            Value = Math.Clamp(settings.AuxGain, 0, 400),
+        };
+        _trkAuxGain.AccessibleName = "Aux volume";
+        _trkAuxGain.AccessibleDescription =
+            "Volume of the aux input stream. 100 is unity gain; range 0–400 percent.";
+        _trkAuxGain.Scroll += TrkAuxGain_Scroll;
+
+        // ── OK / Cancel ───────────────────────────────────────────────────────
+        var btnOk = new Button
+        {
+            Text = "&OK",
+            DialogResult = DialogResult.OK,
+            Location = new Point(228, 600),
+            Size = new Size(80, 27),
+        };
+        var btnCancel = new Button
+        {
+            Text = "&Cancel",
+            DialogResult = DialogResult.Cancel,
+            Location = new Point(316, 600),
+            Size = new Size(80, 27),
+        };
+
+        AcceptButton = btnOk;
+        CancelButton = btnCancel;
+
+        btnOk.Click += (_, _) =>
+        {
+            _settings.Save();
+        };
+        FormClosing += AudioSettingsForm_FormClosing;
+
+        Controls.AddRange([
+            lblDevice, _cboDevice, _btnRefresh,
+            lblMode, _radioVad, _lblSensitivity, _trkVad,
+            _radioPtt, _lblPttKey, _btnChangePtt, _chkSystemWidePtt, _radioAlwaysOn,
+            lblGain, _trkGain, _chkNoiseReduction, _chkStereoMic,
+            _chkAux, _lblAuxDevice, _cboAuxDevice, _btnAuxRefresh, _lblAuxGain, _trkAuxGain,
+            btnOk, btnCancel,
+        ]);
+
+        // Apply saved mode (fires RadioMode_CheckedChanged which sets visibility)
+        switch ((VcInputMode)settings.InputMode)
+        {
+            case VcInputMode.PushToTalk: _radioPtt.Checked = true; break;
+            case VcInputMode.AlwaysOn:   _radioAlwaysOn.Checked = true; break;
+            default:                     _radioVad.Checked = true; break;
+        }
+
+        LoadDevices();
+        LoadAuxDevices();
+        UpdateAuxControlsEnabled();
+    }
+
+    private void LoadDevices()
+    {
+        string? currentId = (_cboDevice.SelectedItem as DeviceInfo)?.Id ?? _settings.InputDeviceId;
+
+        var devices = _client.ListDevices(VcDeviceKind.Input);
+        _cboDevice.SelectedIndexChanged -= CboDevice_SelectedIndexChanged;
+        _cboDevice.DataSource = new BindingList<DeviceInfo>(devices);
+        _cboDevice.SelectedIndexChanged += CboDevice_SelectedIndexChanged;
+
+        // Try to restore previous selection
+        int idx = -1;
+        if (currentId is not null)
+            idx = devices.FindIndex(d => d.Id == currentId);
+        if (idx < 0)
+            idx = devices.FindIndex(d => d.IsDefault);
+        _cboDevice.SelectedIndex = idx >= 0 ? idx : (devices.Count > 0 ? 0 : -1);
+    }
+
+    private void CboDevice_SelectedIndexChanged(object? sender, EventArgs e)
+    {
+        if (_cboDevice.SelectedItem is not DeviceInfo dev) return;
+        _settings.InputDeviceId = dev.IsDefault ? null : dev.Id;
+        if (_micStreamId != 0)
+            _client.SetInputDevice(_micStreamId, dev.IsDefault ? null : dev.Id);
+    }
+
+    // ── Aux input stream ──────────────────────────────────────────────────────
+
+    private void LoadAuxDevices()
+    {
+        string? currentId = (_cboAuxDevice.SelectedItem as InputDeviceInfo)?.Id
+                            ?? _settings.AuxDeviceId;
+
+        var devices = InputDeviceEnumerator.List().ToList();
+
+        // Set the data source AND restore the selection while unsubscribed so neither the initial
+        // populate nor a Refresh fires a spurious device-change (which would restart the capture).
+        _cboAuxDevice.SelectedIndexChanged -= CboAuxDevice_SelectedIndexChanged;
+        _cboAuxDevice.DataSource = new BindingList<InputDeviceInfo>(devices);
+
+        int idx = -1;
+        if (currentId is not null)
+            idx = devices.FindIndex(d => d.Id == currentId);
+        if (idx < 0)
+            idx = devices.FindIndex(d => d.IsDefault);
+        _cboAuxDevice.SelectedIndex = idx >= 0 ? idx : (devices.Count > 0 ? 0 : -1);
+        _cboAuxDevice.SelectedIndexChanged += CboAuxDevice_SelectedIndexChanged;
+
+        // Persist the resolved selection (null = default) so Join Voice opens the same device.
+        if (_cboAuxDevice.SelectedItem is InputDeviceInfo dev)
+            _settings.AuxDeviceId = dev.IsDefault ? null : dev.Id;
+    }
+
+    private void ChkAux_CheckedChanged(object? sender, EventArgs e)
+    {
+        _settings.AuxEnabled = _chkAux.Checked;
+        UpdateAuxControlsEnabled();
+        _applyAuxEnabled?.Invoke(_chkAux.Checked);
+    }
+
+    private void CboAuxDevice_SelectedIndexChanged(object? sender, EventArgs e)
+    {
+        if (_cboAuxDevice.SelectedItem is not InputDeviceInfo dev) return;
+        _settings.AuxDeviceId = dev.IsDefault ? null : dev.Id;
+        if (_chkAux.Checked)
+            _applyAuxDevice?.Invoke(dev.IsDefault ? null : dev.Id);
+    }
+
+    private void TrkAuxGain_Scroll(object? sender, EventArgs e)
+    {
+        _settings.AuxGain = _trkAuxGain.Value;
+        if (_chkAux.Checked)
+            _applyAuxGain?.Invoke(_trkAuxGain.Value / 100f);
+    }
+
+    private void UpdateAuxControlsEnabled()
+    {
+        bool on = _chkAux.Checked;
+        _lblAuxDevice.Enabled  = on;
+        _cboAuxDevice.Enabled  = on;
+        _btnAuxRefresh.Enabled = on;
+        _lblAuxGain.Enabled    = on;
+        _trkAuxGain.Enabled    = on;
+    }
+
+    private void RadioMode_CheckedChanged(object? sender, EventArgs e)
+    {
+        var mode = CurrentMode();
+        bool isVad = mode == VcInputMode.VoiceActivation;
+        bool isPtt = mode == VcInputMode.PushToTalk;
+
+        _lblSensitivity.Visible = isVad;
+        _trkVad.Visible = isVad;
+        _lblPttKey.Visible = isPtt;
+        _btnChangePtt.Visible = isPtt;
+        _chkSystemWidePtt.Visible = isPtt;
+        UpdatePttKeyLabel();
+
+        _settings.InputMode = (int)mode;
+        if (_micStreamId != 0)
+        {
+            _client.SetInputMode(mode);
+            if (isVad) _client.SetVadThreshold(VadThresholdFromSlider());
+            if (isPtt) _client.SetPushToTalk(false);
+        }
+    }
+
+    private void TrkVad_Scroll(object? sender, EventArgs e)
+    {
+        _settings.VadThresholdSlider = _trkVad.Value;
+        if (_micStreamId != 0 && CurrentMode() == VcInputMode.VoiceActivation)
+            _client.SetVadThreshold(VadThresholdFromSlider());
+    }
+
+    private void TrkGain_Scroll(object? sender, EventArgs e)
+    {
+        _settings.MicGain = _trkGain.Value;
+        if (_micStreamId != 0)
+            _client.SetInputGain(_trkGain.Value / 100f);
+    }
+
+    private void ChkNoiseReduction_CheckedChanged(object? sender, EventArgs e)
+    {
+        _settings.MicNoiseReduction = _chkNoiseReduction.Checked;
+        if (_micStreamId != 0)
+            _client.SetInputNoiseReduction(_chkNoiseReduction.Checked);
+    }
+
+    private void ChkStereoMic_CheckedChanged(object? sender, EventArgs e)
+    {
+        _settings.StereoMic = _chkStereoMic.Checked;
+        // Channel count only takes effect when the capture device (re)starts, so restart it live.
+        if (_micStreamId != 0)
+        {
+            _client.SetCaptureChannels(_micStreamId, _chkStereoMic.Checked ? 2u : 1u);
+            _client.AudioRestart();
+        }
+    }
+
+    private void ChkSystemWidePtt_CheckedChanged(object? sender, EventArgs e) =>
+        // No live effect here — MainForm reads SystemWidePtt after the dialog closes and
+        // registers/unregisters the Raw Input keyboard sink accordingly.
+        _settings.SystemWidePtt = _chkSystemWidePtt.Checked;
+
+    private void BtnChangePtt_Click(object? sender, EventArgs e)
+    {
+        using var dlg = new PttKeyCaptureDialog(_pttKey);
+        if (dlg.ShowDialog(this) == DialogResult.OK)
+        {
+            _pttKey = dlg.CapturedKey;
+            _settings.PttKey = (int)_pttKey;
+            UpdatePttKeyLabel();
+        }
+    }
+
+    private void AudioSettingsForm_FormClosing(object? sender, FormClosingEventArgs e)
+    {
+        if (DialogResult == DialogResult.OK) return;
+
+        // Cancel: restore originals to settings and live client
+        _settings.InputDeviceId = _origDeviceId;
+        _settings.InputMode = (int)_origMode;
+        _settings.VadThresholdSlider = _origVadSlider;
+        _settings.MicGain = _origMicGain;
+        _settings.MicNoiseReduction = _origMicNoiseReduction;
+        _settings.StereoMic = _origStereoMic;
+        _settings.PttKey = (int)_origPttKey;
+        _settings.SystemWidePtt = _origSystemWidePtt;
+
+        if (_micStreamId != 0)
+        {
+            _client.SetInputDevice(_micStreamId, _origDeviceId);
+            _client.SetInputMode(_origMode);
+            if (_origMode == VcInputMode.VoiceActivation)
+                _client.SetVadThreshold(0.1f * (1f - (_origVadSlider - 1f) / 99f));
+            _client.SetInputGain(_origMicGain / 100f);
+            _client.SetInputNoiseReduction(_origMicNoiseReduction);
+            // Restore capture channel count; restart the device only if it actually changed.
+            if (_origStereoMic != _chkStereoMic.Checked)
+            {
+                _client.SetCaptureChannels(_micStreamId, _origStereoMic ? 2u : 1u);
+                _client.AudioRestart();
+            }
+        }
+
+        // Aux: restore originals to settings and re-apply live (order: device + gain first so a
+        // re-enable starts with the right configuration).
+        _settings.AuxEnabled  = _origAuxEnabled;
+        _settings.AuxDeviceId = _origAuxDeviceId;
+        _settings.AuxGain     = _origAuxGain;
+        _applyAuxDevice?.Invoke(_origAuxDeviceId);
+        _applyAuxGain?.Invoke(_origAuxGain / 100f);
+        _applyAuxEnabled?.Invoke(_origAuxEnabled);
+    }
+
+    private void UpdatePttKeyLabel() =>
+        _lblPttKey.Text = $"({_pttKey})";
+
+    private VcInputMode CurrentMode() =>
+        _radioPtt.Checked ? VcInputMode.PushToTalk :
+        _radioAlwaysOn.Checked ? VcInputMode.AlwaysOn :
+        VcInputMode.VoiceActivation;
+
+    private float VadThresholdFromSlider() =>
+        0.1f * (1f - (_trkVad.Value - 1f) / 99f);
+}

clients/windows/VoiceCat.App/Forms/ConnectDialog.cs

@@ -19,6 +19,7 @@ public partial class ConnectDialog : Form
     public VoiceCatClient? ConnectedClient { get; private set; }
     public uint SelfUserId { get; private set; }
     public string Nickname { get; private set; } = "";
+    public string ServerName { get; private set; } = "";
 
     public ConnectDialog()
     {
@@ -91,13 +92,8 @@ public partial class ConnectDialog : Form
 
     private void BtnConnect_Click(object? sender, EventArgs e)
     {
-        Console.WriteLine("[ConnectDialog] BtnConnect_Click fired");
         if (lstServers.SelectedItem is not SavedServer server)
-        {
-            Console.WriteLine("[ConnectDialog] no SavedServer selected — ignoring click");
             return;
-        }
-        Console.WriteLine($"[ConnectDialog] selected server: Host={server.Host} Port={server.Port} AuthMode={server.AuthMode}");
         try
         {
             StartConnect(server);
@@ -115,22 +111,20 @@ public partial class ConnectDialog : Form
         SetBusy(true);
         lblStatus.Text = "Connecting...";
 
+        ServerName = string.IsNullOrWhiteSpace(server.DisplayName)
+            ? $"{server.Host}:{server.Port}"
+            : server.DisplayName;
+
         string tofuDir = Path.GetDirectoryName(ServerListStore.TofuStorePath)!;
-        Console.WriteLine($"[ConnectDialog] tofu store dir: {tofuDir}");
         Directory.CreateDirectory(tofuDir);
 
-        Console.WriteLine("[ConnectDialog] creating VoiceCatClient...");
         _client = new VoiceCatClient("VoiceCat-Windows", VoiceCatClient.VersionString,
             VcLogLevel.Info, ServerListStore.TofuStorePath);
-        Console.WriteLine("[ConnectDialog] VoiceCatClient created OK");
         _client.EventReceived += OnEvent;
         _identityDialogShown = false;
         _pumpTimer.Start();
-        Console.WriteLine($"[ConnectDialog] pump timer started, Enabled={_pumpTimer.Enabled}, Interval={_pumpTimer.Interval}");
 
-        Console.WriteLine($"[ConnectDialog] calling Connect({server.Host}, {server.Port})...");
         var connectResult = _client.Connect(server.Host, server.Port);
-        Console.WriteLine($"[ConnectDialog] Connect() returned {connectResult}");
         if (connectResult != VcResult.Ok)
         {
             lblStatus.Text = $"Connect failed: {connectResult}";
@@ -141,9 +135,7 @@ public partial class ConnectDialog : Form
         if (server.AuthMode == AuthMode.Guest)
         {
             Nickname = string.IsNullOrWhiteSpace(server.LastNickname) ? Environment.UserName : server.LastNickname;
-            Console.WriteLine($"[ConnectDialog] calling AuthenticateGuest({Nickname})...");
+            _client.AuthenticateGuest(Nickname);
-            var authResult = _client.AuthenticateGuest(Nickname);
-            Console.WriteLine($"[ConnectDialog] AuthenticateGuest() returned {authResult}");
         }
         else
         {
@@ -164,15 +156,12 @@ public partial class ConnectDialog : Form
                 password = pwDlg.Password;
             }
             Nickname = server.SavedUsername ?? "";
-            Console.WriteLine($"[ConnectDialog] calling AuthenticateUser({Nickname})...");
+            _client.AuthenticateUser(server.SavedUsername ?? "", password);
-            var authResult = _client.AuthenticateUser(server.SavedUsername ?? "", password);
-            Console.WriteLine($"[ConnectDialog] AuthenticateUser() returned {authResult}");
         }
     }
 
     private void OnEvent(VoiceCatEvent ev)
     {
-        Console.WriteLine($"[ConnectDialog] event: {ev}");
         switch (ev.Type)
         {
             case VcEventType.ConnectionState:
@@ -220,24 +209,18 @@ public partial class ConnectDialog : Form
 
     private void HandleServerIdentity(VcTofuStatus status, string certFingerprintHex)
     {
-        Console.WriteLine($"[ConnectDialog] HandleServerIdentity status={status} fp={certFingerprintHex} alreadyShown={_identityDialogShown}");
         if (_identityDialogShown) return; // one decision per connect attempt
         if (status == VcTofuStatus.Matched)
         {
             // Silent success path — no dialog. See ServerIdentityDialog's doc comment.
-            Console.WriteLine("[ConnectDialog] status=Matched -> auto-confirming, no dialog");
             _client!.ConfirmServerIdentity(true);
             return;
         }
 
         _identityDialogShown = true;
-        Console.WriteLine("[ConnectDialog] showing ServerIdentityDialog...");
         using var dlg = new ServerIdentityDialog(status, certFingerprintHex, _client!.GetServerIdentityDisplay());
-        var dlgResult = dlg.ShowDialog(this);
+        bool accept = dlg.ShowDialog(this) == DialogResult.OK;
-        Console.WriteLine($"[ConnectDialog] ServerIdentityDialog closed with {dlgResult}");
+        _client.ConfirmServerIdentity(accept);
-        bool accept = dlgResult == DialogResult.OK;
-        var confirmResult = _client.ConfirmServerIdentity(accept);
-        Console.WriteLine($"[ConnectDialog] ConfirmServerIdentity({accept}) returned {confirmResult}");
         if (!accept) lblStatus.Text = "Server identity rejected.";
     }
 

clients/windows/VoiceCat.App/Forms/MainForm.Designer.cs

@@ -36,21 +36,10 @@ partial class MainForm
     // Voice control panel (docked Bottom)
     private Panel pnlVoice = null!;
     private FlowLayoutPanel flpVoiceTop = null!;
-    private FlowLayoutPanel flpVoiceBottom = null!;
     private CheckBox chkMute = null!;
     private CheckBox chkDeafen = null!;
-    private RadioButton radioVad = null!;
-    private RadioButton radioPtt = null!;
-    private RadioButton radioAlwaysOn = null!;
-    private Label lblPttKey = null!;
-    private Button btnChangePtt = null!;
-    private Label lblInputDevice = null!;
-    private ComboBox cboInputDevice = null!;
-    private Button btnRefreshDevices = null!;
     private Label lblLevel = null!;
     private ProgressBar pbLevel = null!;
-    private Label lblVadThreshold = null!;
-    private TrackBar trkVadThreshold = null!;
 
     protected override void Dispose(bool disposing)
     {
@@ -79,21 +68,10 @@ partial class MainForm
         trkOutputVolume = new TrackBar();
         pnlVoice = new Panel();
         flpVoiceTop = new FlowLayoutPanel();
-        flpVoiceBottom = new FlowLayoutPanel();
         chkMute = new CheckBox();
         chkDeafen = new CheckBox();
-        radioVad = new RadioButton();
-        radioPtt = new RadioButton();
-        radioAlwaysOn = new RadioButton();
-        lblPttKey = new Label();
-        btnChangePtt = new Button();
-        lblInputDevice = new Label();
-        cboInputDevice = new ComboBox();
-        btnRefreshDevices = new Button();
         lblLevel = new Label();
         pbLevel = new ProgressBar();
-        lblVadThreshold = new Label();
-        trkVadThreshold = new TrackBar();
         menuStrip = new MenuStrip();
         toolStrip = new ToolStrip();
         tsbJoinVoice = new ToolStripButton();
@@ -140,6 +118,13 @@ partial class MainForm
         splitLeft.Panel1MinSize = 100;
         splitLeft.Panel2MinSize = 80;
         splitLeft.TabIndex = 0;
+        // Keep the resize splitter out of the Tab cycle so focus moves control-to-control.
+        splitLeft.TabStop = false;
+        // Name the otherwise-anonymous "pane" containers so screen readers announce
+        // orientation instead of a stack of unnamed panes.
+        splitLeft.AccessibleName = "Channels and users";
+        splitLeft.Panel1.AccessibleName = "Channels";
+        splitLeft.Panel2.AccessibleName = "Users";
         splitLeft.Panel1.Controls.Add(tvChannels);
         splitLeft.Panel1.Controls.Add(lblChannels);
         splitLeft.Panel2.Controls.Add(lstUsers);
@@ -214,6 +199,10 @@ partial class MainForm
         splitMain.Dock = DockStyle.Fill;
         splitMain.Panel1MinSize = 150;
         splitMain.TabIndex = 1;
+        splitMain.TabStop = false;
+        splitMain.AccessibleName = "Main";
+        splitMain.Panel1.AccessibleName = "Channels and users";
+        splitMain.Panel2.AccessibleName = "Chat and activity";
         splitMain.Panel1.Controls.Add(splitLeft);
         splitMain.Panel2.Controls.Add(tblRight);
 
@@ -230,71 +219,15 @@ partial class MainForm
         chkDeafen.Margin = new Padding(0, 4, 12, 0);
         chkDeafen.TabIndex = 2;
 
-        var lblMode = new Label { Text = "Mode:", AutoSize = true, Margin = new Padding(0, 5, 4, 0) };
+        flpVoiceTop.Dock = DockStyle.Fill;
-
-        radioVad.Text = "&Voice activation";
-        radioVad.AutoSize = true;
-        radioVad.Checked = true;
-        radioVad.Enabled = false;
-        radioVad.Margin = new Padding(0, 4, 6, 0);
-        radioVad.TabIndex = 3;
-
-        radioPtt.Text = "&Push to talk";
-        radioPtt.AutoSize = true;
-        radioPtt.Enabled = false;
-        radioPtt.Margin = new Padding(0, 4, 4, 0);
-        radioPtt.TabIndex = 4;
-
-        radioAlwaysOn.Text = "A&lways on";
-        radioAlwaysOn.AutoSize = true;
-        radioAlwaysOn.Enabled = false;
-        radioAlwaysOn.Margin = new Padding(0, 4, 12, 0);
-        radioAlwaysOn.TabIndex = 5;
-
-        lblPttKey.Text = "(F8)";
-        lblPttKey.AutoSize = true;
-        lblPttKey.Margin = new Padding(2, 5, 4, 0);
-        lblPttKey.Visible = false;
-
-        btnChangePtt.Text = "Change key...";
-        btnChangePtt.AutoSize = true;
-        btnChangePtt.Margin = new Padding(0, 2, 0, 0);
-        btnChangePtt.Visible = false;
-        btnChangePtt.TabIndex = 6;
-
-        flpVoiceTop.Dock = DockStyle.Top;
-        flpVoiceTop.Height = 34;
         flpVoiceTop.AutoSize = false;
         flpVoiceTop.Padding = new Padding(4, 2, 4, 0);
         flpVoiceTop.Controls.Add(chkMute);
         flpVoiceTop.Controls.Add(chkDeafen);
-        flpVoiceTop.Controls.Add(lblMode);
-        flpVoiceTop.Controls.Add(radioVad);
-        flpVoiceTop.Controls.Add(radioPtt);
-        flpVoiceTop.Controls.Add(radioAlwaysOn);
-        flpVoiceTop.Controls.Add(lblPttKey);
-        flpVoiceTop.Controls.Add(btnChangePtt);
-
-        // Bottom row: device picker + level meter
-        lblInputDevice.Text = "Input:";
-        lblInputDevice.AutoSize = true;
-        lblInputDevice.Margin = new Padding(0, 5, 4, 0);
-
-        cboInputDevice.AccessibleName = "Input device";
-        cboInputDevice.AccessibleDescription = "Select which microphone or audio device to use.";
-        cboInputDevice.DropDownStyle = ComboBoxStyle.DropDownList;
-        cboInputDevice.Width = 200;
-        cboInputDevice.Margin = new Padding(0, 2, 4, 0);
-        cboInputDevice.TabIndex = 7;
-
-        btnRefreshDevices.Text = "Re&fresh";
-        btnRefreshDevices.AutoSize = true;
-        btnRefreshDevices.Margin = new Padding(0, 2, 12, 0);
-        btnRefreshDevices.TabIndex = 8;
 
         lblLevel.Text = "Level:";
         lblLevel.AutoSize = true;
-        lblLevel.Margin = new Padding(0, 5, 4, 0);
+        lblLevel.Margin = new Padding(12, 5, 4, 0);
 
         pbLevel.AccessibleName = "Microphone level";
         pbLevel.AccessibleDescription = "Current input level from the microphone.";
@@ -305,42 +238,14 @@ partial class MainForm
         pbLevel.Style = ProgressBarStyle.Continuous;
         pbLevel.TabStop = false;
 
-        lblVadThreshold.Text = "Sensitivity:";
+        flpVoiceTop.Controls.Add(lblLevel);
-        lblVadThreshold.AutoSize = true;
+        flpVoiceTop.Controls.Add(pbLevel);
-        lblVadThreshold.Margin = new Padding(12, 5, 4, 0);
-        lblVadThreshold.Visible = true;
-
-        trkVadThreshold.AccessibleName = "VAD sensitivity";
-        trkVadThreshold.AccessibleDescription =
-            "Voice detection sensitivity. Higher = more sensitive (triggers on quieter sounds). " +
-            "Range 1–100; default 25.";
-        trkVadThreshold.Minimum = 1;
-        trkVadThreshold.Maximum = 100;
-        trkVadThreshold.Value = 76;
-        trkVadThreshold.TickFrequency = 10;
-        trkVadThreshold.SmallChange = 1;
-        trkVadThreshold.LargeChange = 10;
-        trkVadThreshold.Width = 120;
-        trkVadThreshold.Margin = new Padding(0, 2, 0, 0);
-        trkVadThreshold.TabIndex = 9;
-        trkVadThreshold.Visible = true;
-
-        flpVoiceBottom.Dock = DockStyle.Fill;
-        flpVoiceBottom.Padding = new Padding(4, 0, 4, 2);
-        flpVoiceBottom.Controls.Add(lblInputDevice);
-        flpVoiceBottom.Controls.Add(cboInputDevice);
-        flpVoiceBottom.Controls.Add(btnRefreshDevices);
-        flpVoiceBottom.Controls.Add(lblLevel);
-        flpVoiceBottom.Controls.Add(pbLevel);
-        flpVoiceBottom.Controls.Add(lblVadThreshold);
-        flpVoiceBottom.Controls.Add(trkVadThreshold);
 
         pnlVoice.Dock = DockStyle.Bottom;
-        pnlVoice.Height = 68;
+        pnlVoice.Height = 38;
         pnlVoice.BorderStyle = BorderStyle.FixedSingle;
         pnlVoice.Padding = new Padding(0);
-        pnlVoice.Controls.Add(flpVoiceBottom);  // Fill — added first
+        pnlVoice.Controls.Add(flpVoiceTop);
-        pnlVoice.Controls.Add(flpVoiceTop);     // Top — added last
 
         // ── Toolbar ───────────────────────────────────────────────────────────
         tsbJoinVoice.Text = "Join Voice";

clients/windows/VoiceCat.App/Forms/MainForm.cs

@@ -1,4 +1,7 @@
 using VoiceCat.App.Audio;
+using VoiceCat.App.Models;
+using VoiceCat.App.Native;
+using VoiceCat.App.Notifications;
 using VoiceCat.Interop;
 
 namespace VoiceCat.App.Forms;
@@ -12,6 +15,8 @@ public partial class MainForm : Form
     private readonly uint _selfUserId;
     private readonly string _nickname;
     private readonly System.Windows.Forms.Timer _pumpTimer = new() { Interval = 30 };
+    private readonly EventFeedback _feedback = new(FeedbackSettings.Load());
+    private readonly VoiceSettings _voiceSettings = VoiceSettings.Load();
 
     // Channel / user state
     private uint _currentChannelId;
@@ -24,7 +29,11 @@ public partial class MainForm : Form
     private uint _micStreamId; // 0 = not started
     private uint _screenStreamId; // 0 = not sharing screen audio
     private ProcessAudioMixer? _screenMixer; // non-null only in per-app capture mode
+    private uint _auxStreamId; // 0 = aux (second input device) stream not active
+    private InputDeviceCapture? _auxCapture; // client-side capture feeding the aux stream
     private Keys _pttKey = Keys.F8;
+    private bool _pttEngaged; // guards the PTT cue against key-repeat
+    private bool _rawInputRegistered; // true while the system-wide PTT keyboard sink is active
     private bool _serverMuted;
     private bool _serverDeafened;
 
@@ -35,18 +44,21 @@ public partial class MainForm : Form
     private ToolStripMenuItem _miJoinVoice = null!;
     private ToolStripMenuItem _miScreenShare = null!;
 
-    public MainForm(VoiceCatClient client, uint selfUserId, string nickname)
+    public MainForm(VoiceCatClient client, uint selfUserId, string nickname, string serverName)
     {
         InitializeComponent();
         _client = client;
         _selfUserId = selfUserId;
         _nickname = nickname;
 
-        Text = $"VoiceCat — {nickname}";
+        Text = string.IsNullOrWhiteSpace(serverName)
+            ? $"VoiceCat — {nickname}"
+            : $"VoiceCat — {nickname} @ {serverName}";
 
         _client.EventReceived += OnEvent;
         _client.LevelChanged += OnLevelChanged;
         _pumpTimer.Tick += (_, _) => _client.PumpEvents();
+        _pumpTimer.Tick += (_, _) => PttWatchdog();
 
         _ownPermissions = SafeGetPermissions();
         BuildMenus();
@@ -62,7 +74,7 @@ public partial class MainForm : Form
         tvChannels.DoubleClick += TvChannels_DoubleClick;
         tvChannels.KeyDown += TvChannels_KeyDown;
         lstUsers.DoubleClick += (_, _) => OpenUserTuning();
-        lstUsers.KeyDown += (_, e) => { if (e.KeyCode == Keys.Enter) OpenUserTuning(); };
+        lstUsers.KeyDown += (_, e) => { if (e.KeyCode == Keys.Enter) { OpenUserTuning(); e.Handled = e.SuppressKeyPress = true; } };
 
         // Compose
         txtCompose.KeyDown += TxtCompose_KeyDown;
@@ -78,26 +90,28 @@ public partial class MainForm : Form
         // Voice controls
         chkMute.CheckedChanged += (_, _) => ApplySelfMute();
         chkDeafen.CheckedChanged += (_, _) => ApplySelfMute();
-        radioVad.CheckedChanged += RadioVad_CheckedChanged;
-        radioPtt.CheckedChanged += RadioPtt_CheckedChanged;
-        radioAlwaysOn.CheckedChanged += RadioAlwaysOn_CheckedChanged;
-        trkVadThreshold.Scroll += TrkVadThreshold_Scroll;
-        btnChangePtt.Click += BtnChangePtt_Click;
-        btnRefreshDevices.Click += (_, _) => LoadInputDevices();
-        cboInputDevice.SelectedIndexChanged += CboInputDevice_SelectedIndexChanged;
 
-        // PTT and global hotkeys (focus-scoped — work only while this form has focus)
+        // PTT and global hotkeys. The mute/deafen/screen-share toggles (MainForm_HotkeyDown) are
+        // always focus-scoped. PTT is focus-scoped via KeyDown/KeyUp when system-wide PTT is OFF;
+        // when ON, the WM_INPUT path (WndProc + Raw Input) owns PTT for both focused and unfocused
+        // cases and the KeyDown/KeyUp handlers early-return.
         KeyDown += MainForm_KeyDown;
         KeyDown += MainForm_HotkeyDown;
         KeyUp += MainForm_KeyUp;
         Deactivate += (_, _) =>
         {
-            if (_micStreamId != 0) _client.SetPushToTalk(false);
+            // With system-wide PTT we WANT transmission to continue while unfocused, so don't
+            // release on deactivate — the Raw Input key-up (and PttWatchdog) handle release.
+            if (!_voiceSettings.SystemWidePtt && _micStreamId != 0) _client.SetPushToTalk(false);
         };
 
+        ApplyPersistedVoiceSettings();
         BootstrapFromServer();
     }
 
+    private void ApplyPersistedVoiceSettings() =>
+        _pttKey = (Keys)_voiceSettings.PttKey;
+
     // ── Startup ──────────────────────────────────────────────────────────────
 
     private void BootstrapFromServer()
@@ -118,6 +132,8 @@ public partial class MainForm : Form
         RefreshUserList();
         UpdateStatusLabel();
         AddActivity($"Connected to server as {_nickname}");
+        _feedback.PlaySound(SoundEvent.Login);
+        _feedback.Speak("Connected");
     }
 
     protected override void OnLoad(EventArgs e)
@@ -125,7 +141,6 @@ public partial class MainForm : Form
         base.OnLoad(e);
         splitMain.SplitterDistance = Math.Min(220, splitMain.Width - 304);
         splitLeft.SplitterDistance = Math.Min(260, splitLeft.Height - 84);
-        LoadInputDevices();
     }
 
     // ── Menu / context menu builders ─────────────────────────────────────────
@@ -161,6 +176,35 @@ public partial class MainForm : Form
         messagesMenu.DropDownItems.Add(miNewPm);
         menuStrip.Items.Add(messagesMenu);
 
+        // Settings menu — always visible
+        var settingsMenu = new ToolStripMenuItem("&Settings");
+        var miAudio = new ToolStripMenuItem("&Audio...");
+        miAudio.Click += (_, _) =>
+        {
+            using var dlg = new AudioSettingsForm(_client, _voiceSettings, _micStreamId,
+                applyAuxEnabled: on =>
+                {
+                    if (_micStreamId == 0) return; // not in voice — applied on next Join Voice
+                    if (on) StartAuxStream(); else StopAuxStream();
+                },
+                applyAuxDevice: _ =>
+                {
+                    if (_auxStreamId != 0) RestartAuxCapture(); // settings.AuxDeviceId already updated
+                });
+            dlg.ShowDialog(this);
+            _pttKey = (Keys)_voiceSettings.PttKey;
+            ApplySystemWidePtt(); // the system-wide toggle may have changed
+        };
+        settingsMenu.DropDownItems.Add(miAudio);
+        var miNotifications = new ToolStripMenuItem("&Notifications...");
+        miNotifications.Click += (_, _) =>
+        {
+            using var dlg = new NotificationSettingsForm(_feedback);
+            dlg.ShowDialog(this);
+        };
+        settingsMenu.DropDownItems.Add(miNotifications);
+        menuStrip.Items.Add(settingsMenu);
+
         // Admin menu — only if permitted
         if (_ownPermissions.CanAdminAccounts)
         {
@@ -201,6 +245,7 @@ public partial class MainForm : Form
                 ctx.Items.Add("&Delete channel...", null, (_, _) => DeleteSelectedChannel());
             }
         };
+        ctx.Opened += (_, _) => SelectFirstMenuItem(ctx);
         tvChannels.ContextMenuStrip = ctx;
     }
 
@@ -247,9 +292,26 @@ public partial class MainForm : Form
                 }
             }
         };
+        ctx.Opened += (_, _) => SelectFirstMenuItem(ctx);
         lstUsers.ContextMenuStrip = ctx;
     }
 
+    // Work around the WinForms ContextMenuStrip accessibility bug: when opened by
+    // keyboard (Shift+F10 / Apps key) the focused item is not set, so screen readers
+    // stay silent until the first arrow key. Selecting the first item ourselves on
+    // Opened raises the UIA focus event immediately.
+    private static void SelectFirstMenuItem(ContextMenuStrip ctx)
+    {
+        foreach (ToolStripItem item in ctx.Items)
+        {
+            if (item is ToolStripMenuItem && item.Enabled)
+            {
+                item.Select();
+                break;
+            }
+        }
+    }
+
     // ── Event dispatch ────────────────────────────────────────────────────────
 
     private void OnEvent(VoiceCatEvent ev)
@@ -287,10 +349,21 @@ public partial class MainForm : Form
                 HandleStreamStarted(ev);
                 break;
             case VcEventType.StreamStopped:
-                if (_users.TryGetValue(ev.UserId, out var stUser) &&
+                if (ev.UserId == _selfUserId)
+                {
+                    if (ev.StreamId == _micStreamId)
+                    {
+                        _micStreamId = 0;
+                        pbLevel.Value = 0;
+                    }
+                }
+                else if (_users.TryGetValue(ev.UserId, out var stUser) &&
                     stUser.ChannelId == _currentChannelId)
                     AddActivity($"{stUser.Nickname} stopped a stream");
                 break;
+            case VcEventType.VoiceState:
+                HandleVoiceState(ev);
+                break;
             case VcEventType.Disconnected:
                 HandleDisconnected(ev);
                 break;
@@ -316,12 +389,16 @@ public partial class MainForm : Form
     private void HandleUserJoined(VoiceCatEvent ev)
     {
         var user = new UserInfo(ev.UserId, ev.Text ?? $"User#{ev.UserId}", false, ev.ChannelId,
-            false, false, false, false);
+            false, false, false, false, false);
         _users[ev.UserId] = user;
         RefreshChannelTree();
         RefreshUserList();
         if (ev.ChannelId == _currentChannelId && ev.UserId != _selfUserId)
+        {
             AddActivity($"{user.Nickname} joined the channel");
+            _feedback.PlaySound(SoundEvent.ChannelJoin);
+            _feedback.Speak($"{user.Nickname} joined");
+        }
     }
 
     private void HandleUserLeft(VoiceCatEvent ev)
@@ -332,7 +409,12 @@ public partial class MainForm : Form
         _talkingUsers.Remove(ev.UserId);
         RefreshChannelTree();
         RefreshUserList();
-        if (wasHere) AddActivity($"{user.Nickname} left the channel");
+        if (wasHere)
+        {
+            AddActivity($"{user.Nickname} left the channel");
+            _feedback.PlaySound(SoundEvent.ChannelLeave);
+            _feedback.Speak($"{user.Nickname} left");
+        }
         if (_pmWindows.TryGetValue(ev.UserId, out var pmWin))
             pmWin.AppendActivity($"{user.Nickname} disconnected from server");
     }
@@ -388,18 +470,23 @@ public partial class MainForm : Form
                            .LocalDateTime.ToString("HH:mm")
             : DateTime.Now.ToString("HH:mm");
         string sender = GetNickname(ev.UserId);
+        bool isSelf = ev.UserId == _selfUserId;
+        string body = ev.Text ?? "";
 
         if (ev.TextScope == VcTextScope.Private)
         {
             // For our own outgoing PM, ev.ChannelId carries the recipient user ID.
-            uint otherUserId = ev.UserId == _selfUserId ? ev.ChannelId : ev.UserId;
+            uint otherUserId = isSelf ? ev.ChannelId : ev.UserId;
             var win = GetOrOpenPmWindow(otherUserId);
-            bool isSelf = ev.UserId == _selfUserId;
+            win.AppendMessage(time, isSelf, sender, body);
-            win.AppendMessage(time, isSelf, sender, ev.Text ?? "");
+            _feedback.PlaySound(isSelf ? SoundEvent.PmSent : SoundEvent.PmRecv);
+            if (!isSelf) _feedback.Speak($"Private message from {sender}: {body}");
         }
         else
         {
-            AppendChat(time, sender, ev.Text ?? "");
+            AppendChat(time, sender, body);
+            _feedback.PlaySound(isSelf ? SoundEvent.ChannelSent : SoundEvent.ChannelRecv);
+            if (!isSelf) _feedback.Speak($"{sender}: {body}");
         }
     }
 
@@ -409,6 +496,8 @@ public partial class MainForm : Form
         if (talking) _talkingUsers.Add(ev.UserId);
         else _talkingUsers.Remove(ev.UserId);
         RefreshUserList();
+        if (ev.UserId == _selfUserId)
+            _feedback.PlaySound(talking ? SoundEvent.VaStart : SoundEvent.VaStop);
         if (talking && ev.UserId != _selfUserId &&
             _users.TryGetValue(ev.UserId, out var tUser) &&
             tUser.ChannelId == _currentChannelId)
@@ -437,6 +526,16 @@ public partial class MainForm : Form
             : $"Disconnected: {ev.Text}";
         lblStatus.Text = msg;
         AddActivity(msg);
+        if (ev.Result == VcResult.Ok)
+        {
+            _feedback.PlaySound(SoundEvent.Logout);
+            _feedback.Speak("Disconnected");
+        }
+        else
+        {
+            _feedback.PlaySound(SoundEvent.ConnectionLost);
+            _feedback.Speak("Connection lost");
+        }
         tvChannels.Nodes.Clear();
         lstUsers.Items.Clear();
         _users.Clear();
@@ -445,6 +544,7 @@ public partial class MainForm : Form
         _micStreamId = 0;
         _screenStreamId = 0;
         _screenMixer?.Stop(); _screenMixer?.Dispose(); _screenMixer = null;
+        DisposeAuxCapture(); _auxStreamId = 0; // connection gone — drop capture, no StopStream
         txtCompose.Enabled = false;
         btnSend.Enabled = false;
         tsbJoinVoice.Enabled = false;
@@ -468,6 +568,7 @@ public partial class MainForm : Form
     private void RefreshChannelTree()
     {
         uint toSelect = tvChannels.SelectedNode?.Tag is uint s ? s : _currentChannelId;
+        bool hadFocus = tvChannels.Focused;
         tvChannels.BeginUpdate();
         tvChannels.Nodes.Clear();
 
@@ -493,6 +594,18 @@ public partial class MainForm : Form
         tvChannels.ExpandAll();
         SeekAndSelect(tvChannels.Nodes, toSelect);
         tvChannels.EndUpdate();
+
+        // A Nodes.Clear()/rebuild can drop keyboard focus and leave the screen reader
+        // without a current node. If the tree was focused before the refresh, restore
+        // focus and re-announce the now-current node (null-then-reselect forces UIA to
+        // fire a fresh focus event).
+        if (hadFocus && tvChannels.SelectedNode != null)
+        {
+            var node = tvChannels.SelectedNode;
+            tvChannels.Focus();
+            tvChannels.SelectedNode = null;
+            tvChannels.SelectedNode = node;
+        }
     }
 
     private bool SeekAndSelect(TreeNodeCollection nodes, uint channelId)
@@ -508,6 +621,11 @@ public partial class MainForm : Form
 
     private void RefreshUserList()
     {
+        // Preserve the keyboard selection across the rebuild: clearing the list resets
+        // SelectedIndex to -1, which would throw focus around every time a talking/mute
+        // indicator toggles. Capture the selected user id and reselect it afterwards.
+        uint? prevSel = (lstUsers.SelectedItem as UserListItem)?.UserId;
+
         lstUsers.BeginUpdate();
         lstUsers.Items.Clear();
         foreach (var user in _users.Values
@@ -521,6 +639,15 @@ public partial class MainForm : Form
             if (user.SelfDeafened || user.ServerDeafened) label += " (deafened)";
             lstUsers.Items.Add(new UserListItem(user.Id, label));
         }
+        if (prevSel is uint sel)
+        {
+            for (int i = 0; i < lstUsers.Items.Count; i++)
+                if (lstUsers.Items[i] is UserListItem item && item.UserId == sel)
+                {
+                    lstUsers.SelectedIndex = i;
+                    break;
+                }
+        }
         lstUsers.EndUpdate();
         UpdateStatusLabel();
     }
@@ -542,68 +669,22 @@ public partial class MainForm : Form
         lblStatus.Text = $"Connected as {_nickname}{suffix} — {chanName} ({count} user{(count == 1 ? "" : "s")})";
     }
 
-    // ── Device management ─────────────────────────────────────────────────────
-
-    private void LoadInputDevices()
-    {
-        var devices = _client.ListDevices(VcDeviceKind.Input);
-        DeviceInfo? prevDevice = cboInputDevice.SelectedItem as DeviceInfo;
-
-        cboInputDevice.Items.Clear();
-        foreach (var d in devices) cboInputDevice.Items.Add(d);
-
-        if (prevDevice is not null)
-        {
-            for (int i = 0; i < cboInputDevice.Items.Count; i++)
-            {
-                if (cboInputDevice.Items[i] is DeviceInfo d && d.Id == prevDevice.Id)
-                {
-                    cboInputDevice.SelectedIndex = i;
-                    return;
-                }
-            }
-        }
-        for (int i = 0; i < cboInputDevice.Items.Count; i++)
-        {
-            if (cboInputDevice.Items[i] is DeviceInfo d && d.IsDefault)
-            {
-                cboInputDevice.SelectedIndex = i;
-                return;
-            }
-        }
-        if (cboInputDevice.Items.Count > 0) cboInputDevice.SelectedIndex = 0;
-    }
-
     // ── Voice controls ────────────────────────────────────────────────────────
 
     private void BtnMicToggle_Click(object? sender, EventArgs e)
     {
         if (_micStreamId == 0)
         {
-            var (result, streamId) = _client.StartStream(VcStreamKind.Mic, "Microphone");
+            var result = _client.JoinVoice();
-            if (result == VcResult.Ok)
+            if (result != VcResult.Ok)
-            {
+                AddActivity($"Failed to join voice: {result}");
-                _micStreamId = streamId;
-                if (cboInputDevice.SelectedItem is DeviceInfo { IsDefault: false } dev)
-                    _client.SetInputDevice(streamId, dev.Id);
-                _client.SetInputMode(CurrentInputMode());
-                if (radioVad.Checked) _client.SetVadThreshold(VadThresholdFromSlider());
-                SetVoiceJoinedState(true);
-                AddActivity("Joined voice — microphone active");
-            }
-            else
-            {
-                AddActivity($"Failed to start microphone: {result}");
-            }
         }
         else
         {
+            StopAuxStream();
+            if (_screenStreamId != 0) StopScreenAudio();
             _client.SetPushToTalk(false);
-            _client.StopStream(_micStreamId);
+            _client.LeaveVoice();
-            _micStreamId = 0;
-            pbLevel.Value = 0;
-            SetVoiceJoinedState(false);
-            AddActivity("Left voice");
         }
     }
 
@@ -613,9 +694,42 @@ public partial class MainForm : Form
         _miJoinVoice.Text = joined ? "Leave &Voice" : "&Join Voice";
         chkMute.Enabled = joined;
         chkDeafen.Enabled = joined;
-        radioVad.Enabled = joined;
+    }
-        radioPtt.Enabled = joined;
+
-        radioAlwaysOn.Enabled = joined;
+    private void HandleVoiceState(VoiceCatEvent ev)
+    {
+        bool subscribed = ev.U32a != 0;
+        if (subscribed)
+        {
+            var (result, streamId) = _client.StartStream(VcStreamKind.Mic, "Microphone");
+            if (result == VcResult.Ok)
+            {
+                _micStreamId = streamId;
+                var mode = (VcInputMode)_voiceSettings.InputMode;
+                if (_voiceSettings.InputDeviceId is string devId)
+                    _client.SetInputDevice(streamId, devId);
+                _client.SetCaptureChannels(streamId, _voiceSettings.StereoMic ? 2u : 1u);
+                _client.SetInputMode(mode);
+                if (mode == VcInputMode.VoiceActivation)
+                    _client.SetVadThreshold(VadThresholdFromSettings());
+                _client.SetInputGain(_voiceSettings.MicGain / 100f);
+                _client.SetInputNoiseReduction(_voiceSettings.MicNoiseReduction);
+                SetVoiceJoinedState(true);
+                AddActivity("Joined voice — microphone active");
+                _feedback.PlaySound(SoundEvent.VoiceOn);
+                StartAuxStream();
+            }
+            else
+            {
+                AddActivity($"Failed to start microphone: {result}");
+            }
+        }
+        else
+        {
+            SetVoiceJoinedState(false);
+            AddActivity("Left voice");
+            _feedback.PlaySound(SoundEvent.VoiceOff);
+        }
     }
 
     private void ApplySelfMute() =>
@@ -640,7 +754,7 @@ public partial class MainForm : Form
 
         var scope = picker.ChosenScope;
 
-        if (scope is EntireDesktop)
+        if (scope is EntireDesktop { ExcludeSelf: false })
         {
             // Existing whole-device WASAPI loopback path — core handles it.
             var (result, streamId) = _client.StartStream(VcStreamKind.ScreenAudio, "Desktop audio");
@@ -654,7 +768,8 @@ public partial class MainForm : Form
         }
         else
         {
-            // Per-app path: suppress core loopback, C# mixer feeds PCM.
+            // External-feed path: suppress core loopback, C# mixer feeds PCM. Covers the
+            // per-app modes and "entire desktop except VoiceCat" (single EXCLUDE of self).
             var (result, streamId) = _client.StartStreamExternalFeed(VcStreamKind.ScreenAudio, "App audio");
             if (result != VcResult.Ok)
             {
@@ -664,12 +779,13 @@ public partial class MainForm : Form
             _screenStreamId = streamId;
 
             _screenMixer = new ProcessAudioMixer();
-            _screenMixer.Start(scope, _client, streamId, picker.VisibleApps);
+            _screenMixer.Start(scope, _client, streamId);
 
             string desc = scope switch
             {
+                EntireDesktop => "entire desktop (excluding VoiceCat)",
                 OnlyApps    o => $"only {o.Pids.Count} app(s)",
-                AllExceptApps a => $"all except {a.Pids.Count} app(s)",
+                AllExceptApps a => $"all except {a.Names[0]}",
                 _ => "apps",
             };
             AddActivity($"Sharing screen audio: {desc}");
@@ -692,88 +808,103 @@ public partial class MainForm : Form
         AddActivity("Stopped sharing screen audio");
     }
 
+    // ── Aux input stream (second hardware input device) ─────────────────────────
+    // A second outgoing stream (kind = AUX_DEVICE, external_feed). The core can't open a second
+    // capture device, so we capture the chosen device here and feed PCM in — the same external-
+    // feed pipeline as per-app screen audio. Tied to the voice session: started on Join Voice
+    // (when enabled) and stopped on Leave Voice. The aux is always-on (the core never gates
+    // AUX_DEVICE on VAD/PTT); volume is applied client-side before feeding.
+
+    private void StartAuxStream()
+    {
+        if (_auxStreamId != 0 || !_voiceSettings.AuxEnabled) return;
+
+        var (result, streamId) = _client.StartStreamExternalFeed(VcStreamKind.AuxDevice, "Aux device");
+        if (result != VcResult.Ok)
+        {
+            AddActivity($"Failed to start aux stream: {result}");
+            return;
+        }
+        _auxStreamId = streamId;
+
+        _auxCapture = new InputDeviceCapture(_voiceSettings.AuxDeviceId);
+        _auxCapture.PcmFrameReady += OnAuxPcmFrame;
+        if (!_auxCapture.Start())
+        {
+            AddActivity("Failed to open aux input device");
+            StopAuxStream();
+            return;
+        }
+        AddActivity("Aux input stream active");
+    }
+
+    private void StopAuxStream()
+    {
+        DisposeAuxCapture();
+        if (_auxStreamId != 0)
+        {
+            _client.StopStream(_auxStreamId);
+            _auxStreamId = 0;
+        }
+    }
+
+    // Re-open the capture on a different device while the aux stream stays up (the core stream id
+    // is unchanged — only the client-side capture source changes).
+    private void RestartAuxCapture()
+    {
+        if (_auxStreamId == 0) return;
+        DisposeAuxCapture();
+        _auxCapture = new InputDeviceCapture(_voiceSettings.AuxDeviceId);
+        _auxCapture.PcmFrameReady += OnAuxPcmFrame;
+        if (!_auxCapture.Start())
+            AddActivity("Failed to open aux input device");
+    }
+
+    private void DisposeAuxCapture()
+    {
+        if (_auxCapture == null) return;
+        _auxCapture.PcmFrameReady -= OnAuxPcmFrame;
+        _auxCapture.Stop();
+        _auxCapture.Dispose();
+        _auxCapture = null;
+    }
+
+    // Fired on the capture thread. vc_stream_feed_pcm is thread-safe, so feed directly. Gain is
+    // read live from settings each frame (so the volume slider takes effect immediately).
+    private void OnAuxPcmFrame(short[] pcm, int samplesPerChannel, int channels)
+    {
+        if (_auxStreamId == 0) return;
+        float gain = _voiceSettings.AuxGain / 100f;
+        if (gain != 1f)
+        {
+            for (int i = 0; i < pcm.Length; i++)
+                pcm[i] = (short)Math.Clamp((int)MathF.Round(pcm[i] * gain),
+                    short.MinValue, short.MaxValue);
+        }
+        _client.StreamFeedPcm(_auxStreamId, pcm, samplesPerChannel, (uint)channels);
+    }
+
     private void TrkOutputVolume_Scroll(object? sender, EventArgs e) =>
         _client.SetOutputVolume(trkOutputVolume.Value / 100f);
 
-    private void RadioVad_CheckedChanged(object? sender, EventArgs e)
+    private float VadThresholdFromSettings() =>
-    {
+        0.1f * (1f - (_voiceSettings.VadThresholdSlider - 1f) / 99f);
-        if (!radioVad.Checked) return;
-        lblPttKey.Visible = false;
-        btnChangePtt.Visible = false;
-        lblVadThreshold.Visible = true;
-        trkVadThreshold.Visible = true;
-        if (_micStreamId != 0)
-        {
-            _client.SetInputMode(VcInputMode.VoiceActivation);
-            _client.SetVadThreshold(VadThresholdFromSlider());
-        }
-    }
-
-    private void RadioPtt_CheckedChanged(object? sender, EventArgs e)
-    {
-        if (!radioPtt.Checked) return;
-        lblPttKey.Text = $"({_pttKey})";
-        lblPttKey.Visible = true;
-        btnChangePtt.Visible = true;
-        lblVadThreshold.Visible = false;
-        trkVadThreshold.Visible = false;
-        if (_micStreamId != 0)
-        {
-            _client.SetInputMode(VcInputMode.PushToTalk);
-            _client.SetPushToTalk(false);
-        }
-    }
-
-    private void RadioAlwaysOn_CheckedChanged(object? sender, EventArgs e)
-    {
-        if (!radioAlwaysOn.Checked) return;
-        lblPttKey.Visible = false;
-        btnChangePtt.Visible = false;
-        lblVadThreshold.Visible = false;
-        trkVadThreshold.Visible = false;
-        if (_micStreamId != 0) _client.SetInputMode(VcInputMode.AlwaysOn);
-    }
-
-    private void TrkVadThreshold_Scroll(object? sender, EventArgs e)
-    {
-        if (_micStreamId != 0 && radioVad.Checked)
-            _client.SetVadThreshold(VadThresholdFromSlider());
-    }
-
-    private float VadThresholdFromSlider() =>
-        0.1f * (1f - (trkVadThreshold.Value - 1f) / 99f);
-
-    private VcInputMode CurrentInputMode() =>
-        radioPtt.Checked ? VcInputMode.PushToTalk :
-        radioAlwaysOn.Checked ? VcInputMode.AlwaysOn :
-        VcInputMode.VoiceActivation;
-
-    private void BtnChangePtt_Click(object? sender, EventArgs e)
-    {
-        using var dlg = new PttKeyCaptureDialog(_pttKey);
-        if (dlg.ShowDialog(this) == DialogResult.OK)
-        {
-            _pttKey = dlg.CapturedKey;
-            lblPttKey.Text = $"({_pttKey})";
-        }
-    }
-
-    private void CboInputDevice_SelectedIndexChanged(object? sender, EventArgs e)
-    {
-        if (_micStreamId == 0) return;
-        string? deviceId = (cboInputDevice.SelectedItem as DeviceInfo)?.Id;
-        _client.SetInputDevice(_micStreamId, deviceId);
-    }
 
     // ── PTT key handling (focus-scoped) ───────────────────────────────────────
 
     private void MainForm_KeyDown(object? sender, KeyEventArgs e)
     {
-        if (!radioPtt.Checked || e.KeyCode != _pttKey || _micStreamId == 0) return;
+        if (_voiceSettings.SystemWidePtt) return; // handled by the WM_INPUT / Raw Input path
+        if ((VcInputMode)_voiceSettings.InputMode != VcInputMode.PushToTalk) return;
+        if (e.KeyCode != _pttKey || _micStreamId == 0) return;
         if (ActiveControl is TextBox or RichTextBox) return;
         _client.SetPushToTalk(true);
-        lblPttKey.Text = $"({_pttKey} ▶)";
+        if (!_pttEngaged) // first key-down only, not auto-repeat
-        e.Handled = true;
+        {
+            _pttEngaged = true;
+            _feedback.PlaySound(SoundEvent.Ptt);
+        }
+        e.Handled = e.SuppressKeyPress = true;
     }
 
     private void MainForm_HotkeyDown(object? sender, KeyEventArgs e)
@@ -784,31 +915,120 @@ public partial class MainForm : Form
         {
             case Keys.V:
                 BtnMicToggle_Click(null, EventArgs.Empty);
-                e.Handled = true;
                 break;
             case Keys.S:
                 BtnScreenShareToggle_Click(null, EventArgs.Empty);
-                e.Handled = true;
                 break;
             case Keys.M:
                 chkMute.Checked = !chkMute.Checked;
                 ApplySelfMute();
-                e.Handled = true;
                 break;
             case Keys.D:
                 chkDeafen.Checked = !chkDeafen.Checked;
                 ApplySelfMute();
-                e.Handled = true;
                 break;
+            default:
+                return;
         }
+        // A handled hotkey: suppress the follow-on WM_CHAR so the focused control
+        // (channel tree / user list) doesn't emit the system "ding".
+        e.Handled = e.SuppressKeyPress = true;
     }
 
     private void MainForm_KeyUp(object? sender, KeyEventArgs e)
     {
-        if (!radioPtt.Checked || e.KeyCode != _pttKey || _micStreamId == 0) return;
+        if (_voiceSettings.SystemWidePtt) return; // handled by the WM_INPUT / Raw Input path
+        if ((VcInputMode)_voiceSettings.InputMode != VcInputMode.PushToTalk) return;
+        if (e.KeyCode != _pttKey || _micStreamId == 0) return;
         _client.SetPushToTalk(false);
-        lblPttKey.Text = $"({_pttKey})";
+        _pttEngaged = false;
-        e.Handled = true;
+        e.Handled = e.SuppressKeyPress = true;
+    }
+
+    // ── System-wide PTT (Raw Input / WM_INPUT) ────────────────────────────────
+    // When the user enables "system-wide" PTT we observe the PTT key via the Raw Input API so it
+    // works while another app is focused. See VoiceCat.App.Native.RawInput for why this is used in
+    // preference to a low-level keyboard hook (antivirus keylogger heuristics).
+
+    protected override void OnHandleCreated(EventArgs e)
+    {
+        base.OnHandleCreated(e);
+        ApplySystemWidePtt();
+    }
+
+    protected override void OnHandleDestroyed(EventArgs e)
+    {
+        if (_rawInputRegistered)
+        {
+            RawInput.UnregisterKeyboardSink();
+            _rawInputRegistered = false;
+        }
+        base.OnHandleDestroyed(e);
+    }
+
+    protected override void WndProc(ref Message m)
+    {
+        if (m.Msg == RawInput.WM_INPUT && _voiceSettings.SystemWidePtt)
+            HandleRawInput(m.LParam);
+        base.WndProc(ref m);
+    }
+
+    /// <summary>Register or tear down the background keyboard sink to match the current
+    /// <see cref="VoiceSettings.SystemWidePtt"/> setting. Safe to call repeatedly.</summary>
+    private void ApplySystemWidePtt()
+    {
+        if (!IsHandleCreated) return; // OnHandleCreated will (re)apply once the handle exists
+        bool want = _voiceSettings.SystemWidePtt;
+        if (want && !_rawInputRegistered)
+        {
+            _rawInputRegistered = RawInput.RegisterKeyboardSink(Handle);
+        }
+        else if (!want && _rawInputRegistered)
+        {
+            RawInput.UnregisterKeyboardSink();
+            _rawInputRegistered = false;
+            // Release any PTT that was held via Raw Input so it can't stick after switching modes.
+            if (_micStreamId != 0) _client.SetPushToTalk(false);
+            _pttEngaged = false;
+        }
+    }
+
+    private void HandleRawInput(IntPtr lParam)
+    {
+        if ((VcInputMode)_voiceSettings.InputMode != VcInputMode.PushToTalk || _micStreamId == 0)
+            return;
+        if (!RawInput.TryParseKey(lParam, out ushort vkey, out bool keyUp)) return;
+        if (vkey != (ushort)_pttKey) return;
+
+        if (keyUp)
+        {
+            _client.SetPushToTalk(false);
+            _pttEngaged = false;
+            return;
+        }
+
+        // Key-down. Don't transmit while typing into our OWN text fields — matches the
+        // focus-scoped guard. When VoiceCat is in the background ContainsFocus is false, so the
+        // key still transmits (the whole point of system-wide PTT).
+        if (ContainsFocus && ActiveControl is TextBox or RichTextBox) return;
+        _client.SetPushToTalk(true);
+        if (!_pttEngaged) // first key-down only, not auto-repeat
+        {
+            _pttEngaged = true;
+            _feedback.PlaySound(SoundEvent.Ptt);
+        }
+    }
+
+    /// <summary>Watchdog (driven by the pump timer) that releases system-wide PTT if the key-up
+    /// was never observed — e.g. across an RDP or lock-screen focus switch — so PTT can't stick.</summary>
+    private void PttWatchdog()
+    {
+        if (!_pttEngaged || !_voiceSettings.SystemWidePtt || _micStreamId == 0) return;
+        if (!RawInput.IsKeyDown((int)_pttKey))
+        {
+            _client.SetPushToTalk(false);
+            _pttEngaged = false;
+        }
     }
 
     // ── Channel navigation ────────────────────────────────────────────────────
@@ -858,13 +1078,17 @@ public partial class MainForm : Form
             win = new PrivateMessageForm(_client, userId, nick, _selfUserId);
             win.FormClosed += (_, _) => _pmWindows.Remove(userId);
             _pmWindows[userId] = win;
-            win.Show(this);
+            // Show without an owner: an owned form is forced to stay above MainForm and pulls
+            // focus back to itself, so the main window can't be worked in while a PM is open.
+            // OnFormClosed already closes any open PM windows, so this doesn't leak.
+            win.Show();
         }
         else
         {
             if (win.WindowState == FormWindowState.Minimized)
                 win.WindowState = FormWindowState.Normal;
-            win.BringToFront();
+            // Raise it for this explicit user-initiated open without the owner-style focus trap.
+            win.Activate();
         }
         return win;
     }
@@ -890,7 +1114,7 @@ public partial class MainForm : Form
             OpenPmWindow(dlg.SelectedUserId);
     }
 
-    // ── M5: Moderation helpers ────────────────────────────────────────────────
+    // ── Moderation helpers ─────────────────────────────────────────────────────
 
     private void UpdateSelfServerMuteState(bool muted, bool deafened)
     {
@@ -922,8 +1146,8 @@ public partial class MainForm : Form
 
         var editInfo = new ChannelEditInfo(
             channel.Id, channel.ParentId, channel.Name, channel.Topic,
-            channel.PasswordProtected, null, channel.MaxUsers, 0,
+            channel.PasswordProtected, null, channel.MaxUsers, channel.SortOrder,
-            new AudioConfigInfo(0, false, 48000, 0, 20, 0, true, 0, false, 10, false));
+            channel.Audio);
 
         using var dlg = new ChannelEditDialog(_channels, editInfo);
         if (dlg.ShowDialog(this) != DialogResult.OK || dlg.Result is null) return;
@@ -1067,9 +1291,11 @@ public partial class MainForm : Form
         foreach (var win in _pmWindows.Values.ToList()) win.Close();
         _pmWindows.Clear();
         if (_screenStreamId != 0) { _screenMixer?.Stop(); _screenMixer?.Dispose(); _screenMixer = null; _client.StopStream(_screenStreamId); }
+        if (_auxStreamId != 0) StopAuxStream();
         if (_micStreamId != 0) _client.StopStream(_micStreamId);
         _client.Disconnect();
         _client.Dispose();
+        _feedback.Dispose();
         base.OnFormClosed(e);
     }
 

clients/windows/VoiceCat.App/Forms/NotificationSettingsForm.cs

@@ -0,0 +1,128 @@
+using VoiceCat.App.Notifications;
+
+namespace VoiceCat.App.Forms;
+
+/// <summary>
+/// Edits and persists <see cref="FeedbackSettings"/> (event sounds + spoken announcements).
+/// On OK the supplied <see cref="EventFeedback"/> is updated live and the settings saved.
+/// </summary>
+public sealed class NotificationSettingsForm : Form
+{
+    private readonly EventFeedback _feedback;
+
+    private readonly CheckBox _chkSounds;
+    private readonly CheckBox _chkSpeech;
+    private readonly TrackBar _trkVolume;
+    private readonly CheckBox _chkSelfTalk;
+    private readonly CheckBox _chkPtt;
+
+    public NotificationSettingsForm(EventFeedback feedback)
+    {
+        _feedback = feedback;
+        var s = feedback.Settings;
+
+        Text = "Notification settings";
+        FormBorderStyle = FormBorderStyle.FixedDialog;
+        MaximizeBox = false;
+        MinimizeBox = false;
+        StartPosition = FormStartPosition.CenterParent;
+        AutoScaleMode = AutoScaleMode.Font;
+        ClientSize = new Size(360, 300);
+
+        _chkSounds = new CheckBox
+        {
+            Text = "Play event &sounds",
+            Location = new Point(12, 12),
+            AutoSize = true,
+            Checked = s.Sounds,
+        };
+
+        var lblVolume = new Label
+        {
+            Text = "Sound &volume:",
+            Location = new Point(12, 42),
+            AutoSize = true,
+        };
+        _trkVolume = new TrackBar
+        {
+            Location = new Point(12, 64),
+            Size = new Size(330, 45),
+            Minimum = 0,
+            Maximum = 100,
+            TickFrequency = 10,
+            Value = (int)Math.Round(Math.Clamp(s.Volume, 0f, 1f) * 100),
+        };
+        _trkVolume.AccessibleName = "Sound volume";
+
+        _chkSpeech = new CheckBox
+        {
+            Text = "&Speak events (text-to-speech)",
+            Location = new Point(12, 118),
+            AutoSize = true,
+            Checked = s.Speech,
+        };
+        var lblSpeechHint = new Label
+        {
+            Text = feedback.SpeechAvailable
+                ? "Announces joins/leaves and reads message text aloud."
+                : "No speech engine available on this machine.",
+            Location = new Point(30, 142),
+            AutoSize = true,
+            ForeColor = SystemColors.GrayText,
+        };
+
+        var lblOptional = new Label
+        {
+            Text = "Optional sounds:",
+            Location = new Point(12, 174),
+            AutoSize = true,
+        };
+        _chkSelfTalk = new CheckBox
+        {
+            Text = "Your own voice-&activity start/stop",
+            Location = new Point(12, 198),
+            AutoSize = true,
+            Checked = s.SelfTalkSounds,
+        };
+        _chkPtt = new CheckBox
+        {
+            Text = "&Push-to-talk cue",
+            Location = new Point(12, 224),
+            AutoSize = true,
+            Checked = s.PttSound,
+        };
+
+        var btnOk = new Button
+        {
+            Text = "&OK",
+            DialogResult = DialogResult.OK,
+            Location = new Point(192, 262),
+            Size = new Size(75, 27),
+        };
+        var btnCancel = new Button
+        {
+            Text = "&Cancel",
+            DialogResult = DialogResult.Cancel,
+            Location = new Point(273, 262),
+            Size = new Size(75, 27),
+        };
+
+        AcceptButton = btnOk;
+        CancelButton = btnCancel;
+        Controls.AddRange([_chkSounds, lblVolume, _trkVolume, _chkSpeech, lblSpeechHint,
+                           lblOptional, _chkSelfTalk, _chkPtt, btnOk, btnCancel]);
+
+        btnOk.Click += (_, _) => Apply();
+    }
+
+    private void Apply()
+    {
+        var s = _feedback.Settings;
+        s.Sounds = _chkSounds.Checked;
+        s.Speech = _chkSpeech.Checked;
+        s.Volume = _trkVolume.Value / 100f;
+        s.SelfTalkSounds = _chkSelfTalk.Checked;
+        s.PttSound = _chkPtt.Checked;
+        s.Save();
+    }
+}

clients/windows/VoiceCat.App/Forms/PasswordPromptDialog.cs

@@ -1,7 +1,7 @@
 namespace VoiceCat.App.Forms;
 
 /// <summary>Small modal for "type a password right now" — used when a saved server's
-/// password wasn't remembered, and (Phase E) for password-protected channel joins.</summary>
+/// password wasn't remembered, and for password-protected channel joins.</summary>
 public partial class PasswordPromptDialog : Form
 {
     public string Password => txtPassword.Text;

clients/windows/VoiceCat.App/Forms/PerUserTuningDialog.cs

@@ -117,11 +117,11 @@ public sealed class PerUserTuningDialog : Form
         var trkGain = new TrackBar
         {
             AccessibleName = $"Gain for {s.Label}",
-            AccessibleDescription = "Volume level for this stream. 100 is normal (1.0×), 200 is double.",
+            AccessibleDescription = "Volume level for this stream. 100 is normal (1.0×); range 0–400 percent.",
             Location = new Point(12, y + 20),
             Size = new Size(260, 45),
             Minimum = 0,
-            Maximum = 200,
+            Maximum = 400,
             Value = ClampToTrack(gain0),
             TickFrequency = 25,
             SmallChange = 5,
@@ -150,7 +150,7 @@ public sealed class PerUserTuningDialog : Form
 
         var chkNr = new CheckBox
         {
-            Text = "&Noise reduction (planned — currently passthrough)",
+            Text = "&Noise reduction",
             AutoSize = true,
             Location = new Point(96, y + 48),
             Checked = nr0,
@@ -186,7 +186,7 @@ public sealed class PerUserTuningDialog : Form
     private static int ClampToTrack(float gain)
     {
         int v = (int)Math.Round(gain * 100f);
-        return Math.Max(0, Math.Min(200, v));
+        return Math.Max(0, Math.Min(400, v));
     }
 
     private sealed class StreamRow

clients/windows/VoiceCat.App/Forms/PrivateMessageForm.cs

@@ -26,6 +26,11 @@ public sealed class PrivateMessageForm : Form
         ClientSize = new Size(480, 360);
         MinimumSize = new Size(320, 240);
         StartPosition = FormStartPosition.Manual;
+        KeyPreview = true;
+        KeyDown += (_, e) =>
+        {
+            if (e.KeyCode == Keys.Escape) { e.Handled = e.SuppressKeyPress = true; Close(); }
+        };
 
         _rtbHistory = new RichTextBox
         {

clients/windows/VoiceCat.App/Forms/ServerIdentityDialog.cs

@@ -3,7 +3,7 @@ using VoiceCat.Interop;
 namespace VoiceCat.App.Forms;
 
 /// <summary>
-/// TOFU server-identity confirmation (M4). Shown only for VcTofuStatus.FirstConnect/Mismatch
+/// TOFU server-identity confirmation. Shown only for VcTofuStatus.FirstConnect/Mismatch
 /// — never Matched (that's the silent-success "subsequent connects verify the pin" path
 /// docs/security.md describes; showing a dialog on every routine reconnect would be exactly
 /// the "overly chatty" experience this project avoids elsewhere too).

clients/windows/VoiceCat.App/Models/VoiceSettings.cs

@@ -0,0 +1,88 @@
+using System.Text.Json;
+
+namespace VoiceCat.App.Models;
+
+/// <summary>
+/// User's send-side voice input preferences — transmission mode, VAD sensitivity, mic input
+/// gain, and the push-to-talk key. Persisted to %AppData%\VoiceCat\voice.json, same pattern as
+/// <see cref="ServerListStore"/> and FeedbackSettings: a missing or corrupt file yields defaults
+/// rather than throwing. Slider-position values are stored as-is so MainForm can restore the
+/// TrackBars directly.
+/// </summary>
+public sealed class VoiceSettings
+{
+    /// <summary>Transmission mode: 0 = voice activation, 1 = push-to-talk, 2 = always on
+    /// (matches Interop's VcInputMode).</summary>
+    public int InputMode { get; set; } = 0;
+
+    /// <summary>VAD sensitivity slider position, 1–100 (default mirrors the designer's 76).</summary>
+    public int VadThresholdSlider { get; set; } = 76;
+
+    /// <summary>Microphone input gain slider position, 0–400 percent (100 = unity).</summary>
+    public int MicGain { get; set; } = 100;
+
+    /// <summary>Send-side mic noise reduction (RNNoise) toggle. MIC stream only, mono only;
+    /// denoises captured mic PCM before input gain and VAD/PTT gate so everyone hears the
+    /// cleaned signal. Independent of the per-listener receive-side NR.</summary>
+    public bool MicNoiseReduction { get; set; } = false;
+
+    /// <summary>Capture the mic in stereo (interleaved L/R) instead of mono. Off by default. Real
+    /// stereo only reaches the wire on a stereo channel; on a mono channel the core folds the mic
+    /// to mono. Applied when the capture device next starts (Join Voice or an audio restart).</summary>
+    public bool StereoMic { get; set; } = false;
+
+    /// <summary>Push-to-talk key, stored as the integer value of System.Windows.Forms.Keys.</summary>
+    public int PttKey { get; set; } = (int)Keys.F8;
+
+    /// <summary>Make push-to-talk work system-wide — i.e. while another app is focused. When on,
+    /// MainForm registers a background Raw Input keyboard device (WM_INPUT + RIDEV_INPUTSINK) so the
+    /// PTT key is observed even when VoiceCat is not in the foreground; when off, PTT is focus-scoped
+    /// (only fires while the VoiceCat window has focus). Raw Input is used instead of a low-level
+    /// keyboard hook to avoid antivirus keylogger heuristics.</summary>
+    public bool SystemWidePtt { get; set; } = true;
+
+    /// <summary>Saved device ID from the last session; null means use the system default.</summary>
+    public string? InputDeviceId { get; set; } = null;
+
+    /// <summary>Whether the secondary "aux" outgoing stream is enabled. The aux stream is a
+    /// second hardware input device the client captures itself and feeds to the core via
+    /// vc_stream_feed_pcm (kind = AUX_DEVICE, external_feed). Lets a user transmit e.g. mic +
+    /// a line-in at once.</summary>
+    public bool AuxEnabled { get; set; } = false;
+
+    /// <summary>WASAPI endpoint id of the aux capture device; null = system default capture
+    /// device. NOTE: this is a WASAPI device id (from <see cref="Audio.InputDeviceEnumerator"/>),
+    /// NOT a core/miniaudio id — the aux device is opened client-side, so the two id spaces differ.</summary>
+    public string? AuxDeviceId { get; set; } = null;
+
+    /// <summary>Aux input volume slider position, 0–400 percent (100 = unity). Applied client-side
+    /// to the captured PCM before feeding (the core's input gain is mic-only and global).</summary>
+    public int AuxGain { get; set; } = 100;
+
+    private static readonly JsonSerializerOptions JsonOptions = new() { WriteIndented = true };
+
+    private static string AppDataDir => Path.Combine(
+        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "VoiceCat");
+
+    private static string FilePath => Path.Combine(AppDataDir, "voice.json");
+
+    public static VoiceSettings Load()
+    {
+        try
+        {
+            if (!File.Exists(FilePath)) return new VoiceSettings();
+            string json = File.ReadAllText(FilePath);
+            return JsonSerializer.Deserialize<VoiceSettings>(json) ?? new VoiceSettings();
+        }
+        catch
+        {
+            return new VoiceSettings();
+        }
+    }
+
+    public void Save()
+    {
+        Directory.CreateDirectory(AppDataDir);
+        File.WriteAllText(FilePath, JsonSerializer.Serialize(this, JsonOptions));
+    }
+}

clients/windows/VoiceCat.App/Native/RawInput.cs

@@ -0,0 +1,147 @@
+using System.Runtime.InteropServices;
+
+namespace VoiceCat.App.Native;
+
+/// <summary>
+/// Thin wrapper over the Win32 Raw Input API (user32) used to observe the push-to-talk key
+/// system-wide — i.e. while another application is focused.
+///
+/// We deliberately use Raw Input (<c>RegisterRawInputDevices</c> + <c>WM_INPUT</c> with
+/// <c>RIDEV_INPUTSINK</c>) rather than a low-level keyboard hook (<c>SetWindowsHookEx</c> /
+/// <c>WH_KEYBOARD_LL</c>). A low-level hook is the textbook keylogger pattern and is exactly
+/// what antivirus heuristics flag — especially for an unsigned, statically linked MinGW binary
+/// like ours. Raw Input involves no DLL injection and no global hook: the OS simply posts
+/// <c>WM_INPUT</c> messages to our own window's message queue (it is the same input path games
+/// use), so it does not trip those heuristics. It also passes keystrokes through to the focused
+/// app rather than swallowing them.
+///
+/// Only the keyboard device is registered; <see cref="TryParseKey"/> filters to the single PTT
+/// virtual-key code one level up (MainForm).
+/// </summary>
+internal static partial class RawInput
+{
+    // ── Constants ──────────────────────────────────────────────────────────────────────────
+    public const int WM_INPUT = 0x00FF;
+
+    private const uint RID_INPUT = 0x10000003;     // GetRawInputData: get the raw data
+    private const uint RIM_TYPEKEYBOARD = 1;       // RAWINPUTHEADER.dwType for a keyboard
+    private const uint RIDEV_INPUTSINK = 0x00000100; // receive input even when not in foreground
+    private const uint RIDEV_REMOVE = 0x00000001;  // stop receiving input from the device
+    private const ushort RI_KEY_BREAK = 0x01;      // RAWKEYBOARD.Flags bit set on key-up
+
+    private const ushort HID_USAGE_PAGE_GENERIC = 0x01;
+    private const ushort HID_USAGE_GENERIC_KEYBOARD = 0x06;
+
+    // ── Structs (must match the Win32 layout exactly) ──────────────────────────────────────
+    [StructLayout(LayoutKind.Sequential)]
+    private struct RAWINPUTDEVICE
+    {
+        public ushort usUsagePage;
+        public ushort usUsage;
+        public uint dwFlags;
+        public IntPtr hwndTarget;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct RAWINPUTHEADER
+    {
+        public uint dwType;
+        public uint dwSize;
+        public IntPtr hDevice;
+        public IntPtr wParam;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct RAWKEYBOARD
+    {
+        public ushort MakeCode;
+        public ushort Flags;
+        public ushort Reserved;
+        public ushort VKey;
+        public uint Message;
+        public uint ExtraInformation;
+    }
+
+    // ── P/Invoke (source-generated via LibraryImport, matching VoiceCat.Interop) ────────────
+    [LibraryImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static partial bool RegisterRawInputDevices(
+        ref RAWINPUTDEVICE pRawInputDevices, uint uiNumDevices, uint cbSize);
+
+    [LibraryImport("user32.dll")]
+    private static partial uint GetRawInputData(
+        IntPtr hRawInput, uint uiCommand, IntPtr pData, ref uint pcbSize, uint cbSizeHeader);
+
+    [LibraryImport("user32.dll")]
+    private static partial short GetAsyncKeyState(int vKey);
+
+    // ── Public helpers ─────────────────────────────────────────────────────────────────────
+
+    /// <summary>Register a background keyboard sink targeting <paramref name="hwnd"/>. With
+    /// RIDEV_INPUTSINK the window receives WM_INPUT even when it is not in the foreground.</summary>
+    public static bool RegisterKeyboardSink(IntPtr hwnd)
+    {
+        var rid = new RAWINPUTDEVICE
+        {
+            usUsagePage = HID_USAGE_PAGE_GENERIC,
+            usUsage = HID_USAGE_GENERIC_KEYBOARD,
+            dwFlags = RIDEV_INPUTSINK,
+            hwndTarget = hwnd,
+        };
+        return RegisterRawInputDevices(ref rid, 1, (uint)Marshal.SizeOf<RAWINPUTDEVICE>());
+    }
+
+    /// <summary>Tear down the keyboard sink. For RIDEV_REMOVE the target handle must be NULL.</summary>
+    public static bool UnregisterKeyboardSink()
+    {
+        var rid = new RAWINPUTDEVICE
+        {
+            usUsagePage = HID_USAGE_PAGE_GENERIC,
+            usUsage = HID_USAGE_GENERIC_KEYBOARD,
+            dwFlags = RIDEV_REMOVE,
+            hwndTarget = IntPtr.Zero,
+        };
+        return RegisterRawInputDevices(ref rid, 1, (uint)Marshal.SizeOf<RAWINPUTDEVICE>());
+    }
+
+    /// <summary>Decode a WM_INPUT message's <paramref name="hRawInput"/> (the message's LParam).
+    /// Returns false for anything that isn't a keyboard event. On success, <paramref name="vkey"/>
+    /// is the virtual-key code and <paramref name="keyUp"/> distinguishes a release from a press
+    /// (auto-repeat arrives as repeated presses).</summary>
+    public static bool TryParseKey(IntPtr hRawInput, out ushort vkey, out bool keyUp)
+    {
+        vkey = 0;
+        keyUp = false;
+
+        uint headerSize = (uint)Marshal.SizeOf<RAWINPUTHEADER>();
+        uint size = 0;
+        // First call (pData == NULL) returns 0 on success and fills `size` with the buffer length.
+        if (GetRawInputData(hRawInput, RID_INPUT, IntPtr.Zero, ref size, headerSize) != 0 || size == 0)
+            return false;
+
+        IntPtr buf = Marshal.AllocHGlobal((int)size);
+        try
+        {
+            if (GetRawInputData(hRawInput, RID_INPUT, buf, ref size, headerSize) != size)
+                return false;
+
+            var header = Marshal.PtrToStructure<RAWINPUTHEADER>(buf);
+            if (header.dwType != RIM_TYPEKEYBOARD)
+                return false;
+
+            // The keyboard payload immediately follows the (8-byte-aligned) header.
+            var kb = Marshal.PtrToStructure<RAWKEYBOARD>(buf + (int)headerSize);
+            vkey = kb.VKey;
+            keyUp = (kb.Flags & RI_KEY_BREAK) != 0;
+            return true;
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(buf);
+        }
+    }
+
+    /// <summary>True if the given virtual-key code is currently held down. Used as a watchdog to
+    /// catch a missed key-up (e.g. across an RDP / lock-screen focus switch) so PTT can't stick.</summary>
+    public static bool IsKeyDown(int vKey) => (GetAsyncKeyState(vKey) & 0x8000) != 0;
+}

clients/windows/VoiceCat.App/Notifications/EventFeedback.cs

@@ -0,0 +1,42 @@
+namespace VoiceCat.App.Notifications;
+
+/// <summary>
+/// Combines the sound pool and the speech announcer behind the user's <see cref="FeedbackSettings"/>.
+/// MainForm calls <see cref="PlaySound"/> / <see cref="Speak"/> from inside its existing event
+/// handlers (which already resolve nicknames and channel membership), so this type only owns the
+/// "should I, and how" policy — not the event routing.
+/// </summary>
+public sealed class EventFeedback : IDisposable
+{
+    private readonly SoundPlayerPool _sounds = new();
+    private readonly SpeechAnnouncer _speech = new();
+
+    public FeedbackSettings Settings { get; set; }
+
+    public EventFeedback(FeedbackSettings settings) => Settings = settings;
+
+    /// <summary>True when speech is both enabled and actually available on this machine.</summary>
+    public bool SpeechAvailable => _speech.Available;
+
+    public void PlaySound(SoundEvent ev)
+    {
+        if (!Settings.Sounds || Settings.Volume <= 0f) return;
+        // The two opt-in categories are gated by their own flags.
+        if ((ev is SoundEvent.VaStart or SoundEvent.VaStop) && !Settings.SelfTalkSounds) return;
+        if (ev is SoundEvent.Ptt && !Settings.PttSound) return;
+        _sounds.Play(ev);
+    }
+
+    /// <summary>Announce <paramref name="text"/> when spoken feedback is enabled.</summary>
+    public void Speak(string text)
+    {
+        if (!Settings.Speech) return;
+        _speech.Speak(text);
+    }
+
+    public void Dispose()
+    {
+        _sounds.Dispose();
+        _speech.Dispose();
+    }
+}

clients/windows/VoiceCat.App/Notifications/FeedbackSettings.cs

@@ -0,0 +1,55 @@
+using System.Text.Json;
+
+namespace VoiceCat.App.Notifications;
+
+/// <summary>
+/// User preferences for event sounds and spoken (text-to-speech) feedback. Persisted to
+/// %AppData%\VoiceCat\feedback.json — same pattern as <see cref="Models.ServerListStore"/>:
+/// a missing or corrupt file yields defaults rather than throwing.
+/// </summary>
+public sealed class FeedbackSettings
+{
+    /// <summary>Master switch for event sound effects.</summary>
+    public bool Sounds { get; set; } = true;
+
+    /// <summary>Master switch for spoken announcements (Prismatoid TTS). Off by default.</summary>
+    public bool Speech { get; set; } = false;
+
+    /// <summary>Sound-effects volume, 0..1. 0 mutes effects (SoundPlayer has no gain control,
+    /// so this is honoured as a mute gate — see <see cref="SoundPlayerPool"/>).</summary>
+    public float Volume { get; set; } = 1.0f;
+
+    /// <summary>Play va_start/va_stop for your own voice-activity transitions. Off by default
+    /// (fires on every utterance — noisy).</summary>
+    public bool SelfTalkSounds { get; set; } = false;
+
+    /// <summary>Play the ptt cue when push-to-talk is engaged. Off by default.</summary>
+    public bool PttSound { get; set; } = false;
+
+    private static readonly JsonSerializerOptions JsonOptions = new() { WriteIndented = true };
+
+    private static string AppDataDir => Path.Combine(
+        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "VoiceCat");
+
+    private static string FilePath => Path.Combine(AppDataDir, "feedback.json");
+
+    public static FeedbackSettings Load()
+    {
+        try
+        {
+            if (!File.Exists(FilePath)) return new FeedbackSettings();
+            string json = File.ReadAllText(FilePath);
+            return JsonSerializer.Deserialize<FeedbackSettings>(json) ?? new FeedbackSettings();
+        }
+        catch
+        {
+            return new FeedbackSettings();
+        }
+    }
+
+    public void Save()
+    {
+        Directory.CreateDirectory(AppDataDir);
+        File.WriteAllText(FilePath, JsonSerializer.Serialize(this, JsonOptions));
+    }
+}

clients/windows/VoiceCat.App/Notifications/SoundEvent.cs

@@ -0,0 +1,47 @@
+namespace VoiceCat.App.Notifications;
+
+/// <summary>
+/// The set of audible event cues. Each maps to a WAV in the app's <c>sounds\</c> folder
+/// (copied from <c>assets/sounds/</c> at build time). The same logical set is mirrored in the
+/// macOS/iOS clients so feedback stays consistent across platforms.
+/// </summary>
+public enum SoundEvent
+{
+    ChannelJoin,
+    ChannelLeave,
+    ChannelRecv,    // channel text message from someone else
+    ChannelSent,    // channel text message I sent
+    PmRecv,
+    PmSent,
+    Login,
+    Logout,
+    ConnectionLost,
+    VoiceOn,
+    VoiceOff,
+    VaStart,        // my voice-activity began (off by default)
+    VaStop,         // my voice-activity ended (off by default)
+    Ptt,            // push-to-talk engaged (off by default)
+}
+
+internal static class SoundEventExtensions
+{
+    /// <summary>WAV file name (without directory) for each event, matching assets/sounds/.</summary>
+    public static string FileName(this SoundEvent ev) => ev switch
+    {
+        SoundEvent.ChannelJoin => "channel_join.wav",
+        SoundEvent.ChannelLeave => "channel_leave.wav",
+        SoundEvent.ChannelRecv => "channel_recv.wav",
+        SoundEvent.ChannelSent => "channel_sent.wav",
+        SoundEvent.PmRecv => "pm_recv.wav",
+        SoundEvent.PmSent => "pm_sent.wav",
+        SoundEvent.Login => "login.wav",
+        SoundEvent.Logout => "logout.wav",
+        SoundEvent.ConnectionLost => "connection_lost.wav",
+        SoundEvent.VoiceOn => "voice_on.wav",
+        SoundEvent.VoiceOff => "voice_off.wav",
+        SoundEvent.VaStart => "va_start.wav",
+        SoundEvent.VaStop => "va_stop.wav",
+        SoundEvent.Ptt => "ptt.wav",
+        _ => throw new ArgumentOutOfRangeException(nameof(ev), ev, null),
+    };
+}

clients/windows/VoiceCat.App/Notifications/SoundPlayerPool.cs

@@ -0,0 +1,58 @@
+using System.Media;
+
+namespace VoiceCat.App.Notifications;
+
+/// <summary>
+/// Plays short event cues from the app's <c>sounds\</c> folder. Each WAV is loaded once into a
+/// cached <see cref="SoundPlayer"/> (built into the Windows Desktop framework — no extra
+/// dependency). <see cref="Play"/> is non-blocking (<see cref="SoundPlayer.Play"/> renders on a
+/// background thread).
+///
+/// Note: <see cref="SoundPlayer"/> exposes no gain control, so volume is honoured only as a mute
+/// gate (volume == 0 → silent). If finer control or reliable overlapping playback is needed
+/// later, swap this for NAudio.
+/// </summary>
+public sealed class SoundPlayerPool : IDisposable
+{
+    private static readonly string SoundsDir =
+        Path.Combine(AppContext.BaseDirectory, "sounds");
+
+    private readonly Dictionary<SoundEvent, SoundPlayer?> _players = [];
+
+    /// <summary>Resolve, load and cache the player for an event. Returns null if the file is
+    /// missing or fails to load — playback then silently no-ops.</summary>
+    private SoundPlayer? Get(SoundEvent ev)
+    {
+        if (_players.TryGetValue(ev, out var cached)) return cached;
+
+        SoundPlayer? player = null;
+        try
+        {
+            string path = Path.Combine(SoundsDir, ev.FileName());
+            if (File.Exists(path))
+            {
+                player = new SoundPlayer(path);
+                player.Load();
+            }
+        }
+        catch
+        {
+            player = null; // unreadable/invalid WAV — degrade to silence
+        }
+
+        _players[ev] = player;
+        return player;
+    }
+
+    public void Play(SoundEvent ev)
+    {
+        try { Get(ev)?.Play(); }
+        catch { /* never let a notification sound surface as an error */ }
+    }
+
+    public void Dispose()
+    {
+        foreach (var p in _players.Values) p?.Dispose();
+        _players.Clear();
+    }
+}

clients/windows/VoiceCat.App/Notifications/SpeechAnnouncer.cs

@@ -0,0 +1,56 @@
+using Prismatoid;
+
+namespace VoiceCat.App.Notifications;
+
+/// <summary>
+/// Spoken event announcements via Prismatoid (bindings for the Prism speech library —
+/// integrates with the active screen reader / system speech, no extra runtime deps).
+///
+/// All construction and calls are wrapped so a machine with no available speech backend simply
+/// degrades to silence rather than crashing the app.
+/// </summary>
+public sealed class SpeechAnnouncer : IDisposable
+{
+    private readonly PrismContext? _context;
+    private readonly object? _backend; // SpeechBackend; held as object to keep this resilient
+
+    public SpeechAnnouncer()
+    {
+        try
+        {
+            _context = new PrismContext();
+            _backend = _context.AcquireBestBackend();
+        }
+        catch
+        {
+            _context?.Dispose();
+            _context = null;
+            _backend = null;
+        }
+    }
+
+    /// <summary>True when a speech backend is available on this machine.</summary>
+    public bool Available => _backend is not null;
+
+    /// <summary>Speak <paramref name="text"/>. Queued (does not interrupt prior speech) so a
+    /// burst of events is read in order.</summary>
+    public void Speak(string text)
+    {
+        if (string.IsNullOrWhiteSpace(text)) return;
+        try
+        {
+            if (_backend is { } b)
+                ((dynamic)b).Speak(text, interrupt: false);
+        }
+        catch
+        {
+            /* never surface a speech failure */
+        }
+    }
+
+    public void Dispose()
+    {
+        try { (_backend as IDisposable)?.Dispose(); } catch { /* ignore */ }
+        _context?.Dispose();
+    }
+}

clients/windows/VoiceCat.App/Program.cs

@@ -7,30 +7,21 @@ internal static class Program
     [STAThread]
     private static void Main()
     {
-        // Diagnostic-logging-only for now (manual debugging session) — every exception that
+        // Surface exceptions that WinForms' default message-loop handling would otherwise
-        // would otherwise be silently caught by WinForms' default message-loop handling (or
+        // swallow silently (or crash with no visible cause).
-        // crash with no visible cause) gets printed to stdout/stderr first.
         Application.ThreadException += (_, e) =>
             Console.Error.WriteLine($"[UNHANDLED ThreadException] {e.Exception}");
         AppDomain.CurrentDomain.UnhandledException += (_, e) =>
             Console.Error.WriteLine($"[UNHANDLED AppDomain exception] {e.ExceptionObject}");
 
-        Console.WriteLine("VoiceCat.App starting...");
         ApplicationConfiguration.Initialize();
 
         using var connectDialog = new ConnectDialog();
-        Console.WriteLine("Showing ConnectDialog...");
         var result = connectDialog.ShowDialog();
-        Console.WriteLine($"ConnectDialog closed with DialogResult={result}, ConnectedClient={(connectDialog.ConnectedClient is null ? "null" : "set")}");
         if (result != DialogResult.OK || connectDialog.ConnectedClient is null)
-        {
-            Console.WriteLine("Exiting (cancelled or no connected client).");
             return;
-        }
 
-        Console.WriteLine("Launching MainForm...");
         Application.Run(new MainForm(connectDialog.ConnectedClient, connectDialog.SelfUserId,
-            connectDialog.Nickname));
+            connectDialog.Nickname, connectDialog.ServerName));
-        Console.WriteLine("MainForm closed. Exiting.");
     }
 }

clients/windows/VoiceCat.App/VoiceCat.App.csproj

@@ -4,6 +4,21 @@
     <ProjectReference Include="..\VoiceCat.Interop\VoiceCat.Interop.csproj" />
   </ItemGroup>
 
+  <!-- Prismatoid — .NET bindings for the Prism speech library, used for spoken event
+       announcements (text-to-speech). net10.0, no transitive dependencies. -->
+  <ItemGroup>
+    <PackageReference Include="Prismatoid" Version="0.3.0" />
+  </ItemGroup>
+
+  <!-- Event-cue WAVs (shared with the macOS/iOS clients) copied into sounds\ next to the exe;
+       SoundPlayerPool loads them from AppContext.BaseDirectory\sounds. -->
+  <ItemGroup>
+    <Content Include="..\..\..\assets\sounds\*.wav">
+      <Link>sounds\%(Filename)%(Extension)</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
     <TargetFramework>net10.0-windows</TargetFramework>

clients/windows/VoiceCat.Interop.Tests/VoiceCatClientSmokeTests.cs

@@ -23,10 +23,10 @@ public sealed class VoiceCatClientSmokeTests : IDisposable
         _tempDir = Path.Combine(Path.GetTempPath(), "vc_csharp_smoke_" + Guid.NewGuid().ToString("N"));
         Directory.CreateDirectory(_tempDir);
 
-        string serverExe = Path.Combine(FindRepoRoot(), "build", "m1-dev", "bin", "voicecat-server.exe");
+        string serverExe = Path.Combine(FindRepoRoot(), "build", "dev", "bin", "voicecat-server.exe");
         Assert.True(File.Exists(serverExe),
-            $"voicecat-server.exe not found at '{serverExe}' — build the m1-dev preset first " +
+            $"voicecat-server.exe not found at '{serverExe}' — build the dev preset first " +
-            "(cmake --preset m1-dev && cmake --build --preset m1-dev).");
+            "(cmake --preset dev && cmake --build --preset dev).");
 
         var psi = new ProcessStartInfo(serverExe)
         {
@@ -56,9 +56,9 @@ public sealed class VoiceCatClientSmokeTests : IDisposable
         Assert.True(port is not null, "voicecat-server.exe did not report a bound TCP port within 10s.");
         _port = port!.Value;
 
-        // M5: provision a known admin account so we can exercise moderation wrappers end-to-end.
+        // Provision a known admin account so we can exercise moderation wrappers end-to-end.
-        string adminExe = Path.Combine(FindRepoRoot(), "build", "m1-dev", "bin", "voicecat-admin.exe");
+        string adminExe = Path.Combine(FindRepoRoot(), "build", "dev", "bin", "voicecat-admin.exe");
-        Assert.True(File.Exists(adminExe), "voicecat-admin.exe not found — build the m1-dev preset.");
+        Assert.True(File.Exists(adminExe), "voicecat-admin.exe not found — build the dev preset.");
         var adminPsi = new ProcessStartInfo(adminExe)
         {
             Arguments = $"--data-dir \"{_tempDir}\" account add admin2 --admin --password testpassword123",
@@ -140,14 +140,14 @@ public sealed class VoiceCatClientSmokeTests : IDisposable
         var channels = client.ListChannels();
         Assert.Contains(channels, c => c.Id == 1 && c.Name == "Lobby");
 
-        // M5: permissions getter round-trip.
+        // Permissions getter round-trip.
         var perms = client.GetPermissions();
         Assert.False(perms.IsAdmin);
         Assert.False(perms.CanKick);
 
-        // M5: moderation request wrappers queue without error. As a guest, account listing
+        // Moderation request wrappers queue without error. As a guest, account listing
         // is rejected by the server with a GenericResult, which proves the wrapper path works
-        // end-to-end and that the new event type is delivered through P/Invoke.
+        // end-to-end and that the event type is delivered through P/Invoke.
         Assert.Equal(VcResult.Ok, client.RequestAccountList());
         Assert.True(PumpUntil(client,
             () => events.Any(e => e.Type == VcEventType.GenericResult), 3000),

clients/windows/VoiceCat.Interop/Enums.cs

@@ -37,7 +37,7 @@ public enum VcConnectionState
     TlsHandshake = 2,
     Authenticating = 3,
     Connected = 4,
-    /// <summary>M4: handshake succeeded, waiting on vc_confirm_server_identity().</summary>
+    /// <summary>Handshake succeeded, waiting on vc_confirm_server_identity().</summary>
     VerifyingIdentity = 5,
 }
 
@@ -84,14 +84,16 @@ public enum VcEventType
     TalkState = 9,
     Error = 10,
     Disconnected = 11,
-    /// <summary>M4: reply to VoiceCatClient.JoinChannelAsync's underlying vc_join_channel.</summary>
+    /// <summary>Reply to VoiceCatClient.JoinChannelAsync's underlying vc_join_channel.</summary>
     JoinResult = 12,
-    /// <summary>M4: the TOFU server-identity gate — see VcTofuStatus.</summary>
+    /// <summary>The TOFU server-identity gate — see VcTofuStatus.</summary>
     ServerIdentity = 13,
-    /// <summary>M5: async result for moderation/admin/channel operations.</summary>
+    /// <summary>Async result for moderation/admin/channel operations.</summary>
     GenericResult = 14,
-    /// <summary>M5: reply to VoiceCatClient.RequestAccountList — call ListAccounts() to read.</summary>
+    /// <summary>Reply to VoiceCatClient.RequestAccountList — call ListAccounts() to read.</summary>
     AccountList = 15,
+    /// <summary>Voice-plane subscription state. u32a = 1 (subscribed) or 0 (unsubscribed).</summary>
+    VoiceState = 16,
 }
 
 /// <summary>

clients/windows/VoiceCat.Interop/Marshaling.cs

@@ -38,7 +38,9 @@ internal static class Marshaling
                 Marshal.PtrToStringUTF8(raw.Name) ?? string.Empty,
                 Marshal.PtrToStringUTF8(raw.Topic) ?? string.Empty,
                 raw.PasswordProtected != 0,
-                raw.MaxUsers));
+                raw.MaxUsers,
+                raw.SortOrder,
+                ToManaged(in raw.Audio)));
         }
         NativeMethods.vc_free_channel_list(ref native);
         return result;
@@ -59,7 +61,8 @@ internal static class Marshaling
                 raw.SelfMicMuted != 0,
                 raw.SelfDeafened != 0,
                 raw.ServerMuted != 0,
-                raw.ServerDeafened != 0));
+                raw.ServerDeafened != 0,
+                raw.VoiceSubscribed != 0));
         }
         NativeMethods.vc_free_user_list(ref native);
         return result;

clients/windows/VoiceCat.Interop/Models.cs

@@ -9,7 +9,9 @@ public sealed record ChannelInfo(
     string Name,
     string Topic,
     bool PasswordProtected,
-    uint MaxUsers);
+    uint MaxUsers,
+    uint SortOrder,
+    AudioConfigInfo Audio);
 
 public sealed record ChannelEditInfo(
     uint Id,
@@ -30,7 +32,8 @@ public sealed record UserInfo(
     bool SelfMicMuted,
     bool SelfDeafened,
     bool ServerMuted,
-    bool ServerDeafened);
+    bool ServerDeafened,
+    bool VoiceSubscribed);
 
 public sealed record PermissionsInfo(
     bool CanCreateTempChannel,

clients/windows/VoiceCat.Interop/NativeMethods.cs

@@ -54,6 +54,12 @@ internal static partial class NativeMethods
     [LibraryImport(LibName)]
     internal static partial VcResult vc_leave_channel(nint c);
 
+    [LibraryImport(LibName)]
+    internal static partial VcResult vc_join_voice(nint c);
+
+    [LibraryImport(LibName)]
+    internal static partial VcResult vc_leave_voice(nint c);
+
     // ── Local media streams ─────────────────────────────────────────────────────────────────
     [LibraryImport(LibName)]
     internal static partial VcResult vc_stream_start(nint c, in VcStreamDescNative desc,
@@ -65,6 +71,12 @@ internal static partial class NativeMethods
     [LibraryImport(LibName, StringMarshalling = StringMarshalling.Utf8)]
     internal static partial VcResult vc_set_input_device(nint c, uint streamId, string? deviceId);
 
+    [LibraryImport(LibName)]
+    internal static partial VcResult vc_set_capture_channels(nint c, uint streamId, uint channels);
+
+    [LibraryImport(LibName)]
+    internal static partial VcResult vc_audio_restart(nint c);
+
     [LibraryImport(LibName)]
     internal static partial VcResult vc_set_input_mode(nint c, VcInputMode mode);
 
@@ -80,6 +92,12 @@ internal static partial class NativeMethods
     [LibraryImport(LibName)]
     internal static partial VcResult vc_set_output_volume(nint c, float gain);
 
+    [LibraryImport(LibName)]
+    internal static partial VcResult vc_set_input_gain(nint c, float gain);
+
+    [LibraryImport(LibName)]
+    internal static partial VcResult vc_set_input_noise_reduction(nint c, int enable);
+
     [LibraryImport(LibName)]
     internal static partial VcResult vc_set_remote_stream(nint c, uint userId, uint streamId,
         float gain, int muted, int noiseReduction);
@@ -130,7 +148,7 @@ internal static partial class NativeMethods
     [LibraryImport(LibName)]
     internal static partial void vc_free_device_list(ref VcDeviceListNative list);
 
-    // ── M4: channel / user / stream snapshot getters ────────────────────────────────────────
+    // ── Channel / user / stream snapshot getters ────────────────────────────────────────────
     [LibraryImport(LibName)]
     internal static partial VcResult vc_list_channels(nint c, out VcChannelListNative outList);
 
@@ -150,7 +168,7 @@ internal static partial class NativeMethods
     [LibraryImport(LibName)]
     internal static partial void vc_free_stream_summary_list(ref VcStreamSummaryListNative list);
 
-    // ── M4: TOFU server-identity gate ───────────────────────────────────────────────────────
+    // ── TOFU server-identity gate ───────────────────────────────────────────────────────────
     [LibraryImport(LibName)]
     internal static partial VcResult vc_confirm_server_identity(nint c, int accept);
 
@@ -158,7 +176,7 @@ internal static partial class NativeMethods
     internal static partial VcResult vc_get_server_identity_display(nint c, nint outBuf,
         nuint bufCap, out nuint outLen);
 
-    // ── M5: Moderation & admin ─────────────────────────────────────────────────────────────
+    // ── Moderation & admin ───────────────────────────────────────────────────────────────────
     [LibraryImport(LibName, StringMarshalling = StringMarshalling.Utf8)]
     internal static partial VcResult vc_kick_user(nint c, uint userId, string? reason);