diff --git a/.gitignore b/.gitignore
index 2a69752..0a89af9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,5 @@
 .cxx
 local.properties
 /app/release
+/dist/
+.kotlin/
diff --git a/PRIVACY.md b/PRIVACY.md
index 7d10cf1..140e39d 100644
--- a/PRIVACY.md
+++ b/PRIVACY.md
@@ -37,13 +37,9 @@ Ogesture does **not** request `QUERY_ALL_PACKAGES`. Its `<queries>` declaration
 
 | Permission | Why it is needed |
 |---|---|
-| **Display over other apps** (`SYSTEM_ALERT_WINDOW`) | Draws the thin, invisible edge strips that detect your swipes. |
-| **Accessibility service** | Performs Back, Home, and Recents. See above. |
-| **Unrestricted battery usage** (`REQUEST_IGNORE_BATTERY_OPTIMIZATIONS`) | Stops the system from killing the gesture service in the background. |
-| **Foreground service** (`FOREGROUND_SERVICE`, `FOREGROUND_SERVICE_SPECIAL_USE`) | Keeps the edge strips running while you use other apps. |
-| **Post notifications** (`POST_NOTIFICATIONS`) | Shows the ongoing notification Android requires for that foreground service. |
+| **Accessibility service** | Owns the thin, invisible edge overlays that detect your swipes, and performs Back, Home, and Recents. See above. |
+| **Unrestricted battery usage** (`REQUEST_IGNORE_BATTERY_OPTIMIZATIONS`) | Stops the system from killing the accessibility service in the background. |
 | **Vibrate** (`VIBRATE`) | Haptic feedback when a gesture triggers. |
-| **Receive boot completed** (`RECEIVE_BOOT_COMPLETED`) | Restarts the gesture service after you reboot. |
 
 Ogesture also reads one system setting, `ENABLED_ACCESSIBILITY_SERVICES`, to check whether you have granted it accessibility access — so the app can show the correct setup state and turn gestures off if the permission goes away.
 
diff --git a/README.md b/README.md
index 2aa5ef7..c8ec7bb 100644
--- a/README.md
+++ b/README.md
@@ -20,20 +20,18 @@ You can now use gestures even with 3-button navigation enabled.
 
 ## How it works
 
-Ogesture draws thin, invisible overlays along the edges of the screen and uses an accessibility service to perform the navigation actions when it detects a swipe.
+Ogesture draws thin, invisible overlays along the edges of the screen and performs the navigation actions when it detects a swipe. The overlays are accessibility-overlay windows owned by Ogesture's accessibility service, so they work even on secure system screens (such as Android Settings) and do not require the "Display over other apps" permission.
 
-It needs three permissions:
+It needs two permissions:
 
-1. **Display over other apps** — to place the edge overlays that detect swipes.
-2. **Accessibility service** — to perform the Back, Home, and Recents actions.
-3. **Unrestricted battery usage** — so the system doesn't kill the gesture service in the background.
+1. **Accessibility service** — owns the edge overlays that detect swipes and performs the Back, Home, and Recents actions.
+2. **Unrestricted battery usage** — so the system doesn't kill the accessibility service in the background.
 
-The app guides you through granting all three on first launch.
+The app guides you through granting both on first launch.
 
 ## Things to remember
 
 - This app is free, open source, and collects no data. Everything runs locally on your device.
-- Android's security policy blocks gestures on certain screens, such as your phone's Settings pages.
 
 ## License
 
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 8bb353f..e4dc3a8 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -54,7 +54,6 @@ dependencies {
     implementation(libs.androidx.compose.material3)
     implementation(libs.androidx.compose.material.icons.core)
     implementation(libs.androidx.datastore.preferences)
-    implementation(libs.androidx.lifecycle.service)
     implementation(libs.androidx.lifecycle.viewmodel.compose)
     testImplementation(libs.junit)
     androidTestImplementation(libs.androidx.junit)
diff --git a/app/src/androidTest/java/com/ogesture/ExampleInstrumentedTest.kt b/app/src/androidTest/java/com/ogesture/ExampleInstrumentedTest.kt
index a6dd7d9..1ce8ab9 100644
--- a/app/src/androidTest/java/com/ogesture/ExampleInstrumentedTest.kt
+++ b/app/src/androidTest/java/com/ogesture/ExampleInstrumentedTest.kt
@@ -17,8 +17,13 @@ import org.junit.Assert.*
 class ExampleInstrumentedTest {
     @Test
     fun useAppContext() {
-        // Context of the app under test.
+        // Context of the app under test. The debug build adds a `.debug` applicationId
+        // suffix so it installs alongside the release app, so accept either form.
         val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("com.ogesture", appContext.packageName)
+        val pkg = appContext.packageName
+        assertTrue(
+            "package should be com.ogesture or its debug variant, was $pkg",
+            pkg == "com.ogesture" || pkg == "com.ogesture.debug",
+        )
     }
 }
\ No newline at end of file
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 343fddd..87ee516 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -2,12 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
-    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.VIBRATE" />
-    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
 
     <!-- Package visibility for the compatibility screen (data/CompatApps.kt). Deliberately
@@ -44,15 +39,6 @@
             </intent-filter>
         </activity>
 
-        <service
-            android:name=".service.EdgeOverlayService"
-            android:exported="false"
-            android:foregroundServiceType="specialUse">
-            <property
-                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
-                android:value="edge_gesture_overlay" />
-        </service>
-
         <service
             android:name=".service.EdgeGestureAccessibilityService"
             android:exported="false"
@@ -65,15 +51,6 @@
                 android:name="android.accessibilityservice"
                 android:resource="@xml/accessibility_service_config" />
         </service>
-
-        <receiver
-            android:name=".service.BootReceiver"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.intent.action.BOOT_COMPLETED" />
-                <action android:name="android.intent.action.LOCKED_BOOT_COMPLETED" />
-            </intent-filter>
-        </receiver>
     </application>
 
 </manifest>
diff --git a/app/src/main/java/com/ogesture/MainActivity.kt b/app/src/main/java/com/ogesture/MainActivity.kt
index d7a2bc0..a94a51b 100644
--- a/app/src/main/java/com/ogesture/MainActivity.kt
+++ b/app/src/main/java/com/ogesture/MainActivity.kt
@@ -41,6 +41,7 @@ import androidx.compose.material3.LargeTopAppBar
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Surface
+import androidx.compose.material3.Slider
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBarDefaults
@@ -48,6 +49,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
@@ -80,12 +82,21 @@ import com.ogesture.ui.AccessibilityConsentDialog
 import com.ogesture.ui.AccessibilityStatus
 import com.ogesture.ui.CompatEntryCard
 import com.ogesture.ui.CompatibilityScreen
+import com.ogesture.ui.GestureAreasEntryCard
+import com.ogesture.ui.GestureAreasScreen
 import com.ogesture.ui.MainViewModel
 import com.ogesture.ui.PRIVACY_POLICY_URL
 import com.ogesture.ui.SetupCard
 import com.ogesture.ui.theme.OgestureTheme
 import kotlinx.coroutines.delay
 
+/**
+ * Lightweight, mutually-exclusive navigation destinations for the app's local Compose
+ * navigation (no Navigation Compose dependency). At most one secondary screen is active at
+ * a time; [AppScreen.MAIN] is the dashboard, the other two are reached via entry cards.
+ */
+enum class AppScreen { MAIN, GESTURE_AREAS, COMPATIBILITY }
+
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -95,12 +106,24 @@ class MainActivity : ComponentActivity() {
         window.isNavigationBarContrastEnforced = false
         setContent {
             OgestureTheme {
-                var showCompat by rememberSaveable { mutableStateOf(false) }
-                if (showCompat) {
-                    BackHandler { showCompat = false }
-                    CompatibilityScreen(onBack = { showCompat = false })
-                } else {
-                    MainScreen(onOpenCompat = { showCompat = true })
+                // Lightweight local navigation — no Navigation Compose dependency. A single
+                // mutually-exclusive destination so two secondary screens can't be active at once.
+                var screen by rememberSaveable { mutableStateOf(AppScreen.MAIN) }
+                when (screen) {
+                    AppScreen.GESTURE_AREAS -> {
+                        BackHandler { screen = AppScreen.MAIN }
+                        GestureAreasScreen(onBack = { screen = AppScreen.MAIN })
+                    }
+                    AppScreen.COMPATIBILITY -> {
+                        BackHandler { screen = AppScreen.MAIN }
+                        CompatibilityScreen(onBack = { screen = AppScreen.MAIN })
+                    }
+                    AppScreen.MAIN -> {
+                        MainScreen(
+                            onOpenGestureAreas = { screen = AppScreen.GESTURE_AREAS },
+                            onOpenCompat = { screen = AppScreen.COMPATIBILITY },
+                        )
+                    }
                 }
             }
         }
@@ -109,11 +132,14 @@ class MainActivity : ComponentActivity() {
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
-private fun MainScreen(onOpenCompat: () -> Unit, viewModel: MainViewModel = viewModel()) {
+private fun MainScreen(
+    onOpenGestureAreas: () -> Unit,
+    onOpenCompat: () -> Unit,
+    viewModel: MainViewModel = viewModel(),
+) {
     val context = LocalContext.current
     val masterEnabled by viewModel.masterEnabled.collectAsState()
 
-    var overlayGranted by remember { mutableStateOf(Settings.canDrawOverlays(context)) }
     var accessibilityStatus by remember { mutableStateOf(computeAccessibilityStatus(context)) }
     var batteryUnrestricted by remember { mutableStateOf(isBatteryUnrestricted(context)) }
     var showAccessibilityConsent by rememberSaveable { mutableStateOf(false) }
@@ -122,7 +148,6 @@ private fun MainScreen(onOpenCompat: () -> Unit, viewModel: MainViewModel = view
     LaunchedEffect(lifecycleOwner) {
         lifecycleOwner.lifecycle.addObserver(androidx.lifecycle.LifecycleEventObserver { _, event ->
             if (event == Lifecycle.Event.ON_RESUME) {
-                overlayGranted = Settings.canDrawOverlays(context)
                 accessibilityStatus = computeAccessibilityStatus(context)
                 batteryUnrestricted = isBatteryUnrestricted(context)
             }
@@ -131,13 +156,12 @@ private fun MainScreen(onOpenCompat: () -> Unit, viewModel: MainViewModel = view
 
     // While the screen is visible, re-poll the requirements every 1 s. The accessibility
     // service can bind/unbind asynchronously (e.g. after the user toggles it in Settings, or
-    // after an APK reinstall), overlay/battery permissions can be revoked from system
-    // Settings, and there is no broadcast for any of it.
+    // after an APK reinstall), and battery permission can be revoked from system Settings,
+    // and there is no broadcast for either.
     LaunchedEffect(Unit) {
         var unhealthySeconds = 0
         while (true) {
             delay(1000)
-            overlayGranted = Settings.canDrawOverlays(context)
             batteryUnrestricted = isBatteryUnrestricted(context)
             accessibilityStatus = computeAccessibilityStatus(context)
 
@@ -145,7 +169,6 @@ private fun MainScreen(onOpenCompat: () -> Unit, viewModel: MainViewModel = view
             // tell the user why. Requiring the failure to persist a few seconds avoids
             // reacting to the brief unbound window right after an app update.
             val offReason: Int? = if (!viewModel.masterEnabled.value) null else when {
-                !overlayGranted -> R.string.toast_gestures_off_overlay
                 accessibilityStatus != AccessibilityStatus.BOUND -> R.string.toast_gestures_off_accessibility
                 !batteryUnrestricted -> R.string.toast_gestures_off_battery
                 else -> null
@@ -199,22 +222,14 @@ private fun MainScreen(onOpenCompat: () -> Unit, viewModel: MainViewModel = view
             Spacer(modifier = Modifier.height(16.dp))
             MasterSwitchCard(
                 enabled = masterEnabled,
-                canEnable = overlayGranted && accessibilityReady && batteryUnrestricted,
+                canEnable = accessibilityReady && batteryUnrestricted,
                 onToggle = { viewModel.setMasterEnabled(it) },
             )
 
             SectionHeader(stringResource(R.string.setup_title))
             SetupCard(
-                overlayGranted = overlayGranted,
                 accessibilityStatus = accessibilityStatus,
                 batteryUnrestricted = batteryUnrestricted,
-                onRequestOverlay = {
-                    val intent = Intent(
-                        Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
-                        Uri.parse("package:${context.packageName}"),
-                    ).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                    context.startActivity(intent)
-                },
                 // Play policy: the disclosure comes before every trip to Accessibility settings,
                 // including the post-update rebind, since that also re-enables the service.
                 onRequestAccessibility = { showAccessibilityConsent = true },
@@ -230,6 +245,9 @@ private fun MainScreen(onOpenCompat: () -> Unit, viewModel: MainViewModel = view
             SectionHeader(stringResource(R.string.gestures_title))
             GesturesCard()
 
+            SectionHeader(stringResource(R.string.gesture_areas_title))
+            GestureAreasEntryCard(onClick = onOpenGestureAreas)
+
             SectionHeader(stringResource(R.string.compat_title))
             CompatEntryCard(onClick = onOpenCompat)
 
@@ -441,7 +459,7 @@ private fun RememberCard() {
                 }
             }
             RememberPoint(openSourceText)
-            RememberPoint(AnnotatedString(stringResource(R.string.remember_restricted_screens)))
+            RememberPoint(AnnotatedString(stringResource(R.string.remember_on_device)))
         }
     }
 }
diff --git a/app/src/main/java/com/ogesture/data/Models.kt b/app/src/main/java/com/ogesture/data/Models.kt
index a760e87..1fa48de 100644
--- a/app/src/main/java/com/ogesture/data/Models.kt
+++ b/app/src/main/java/com/ogesture/data/Models.kt
@@ -21,11 +21,226 @@ data class ZoneConfig(
 }
 
 /**
- * The fixed gesture layout: swipe up from the bottom for Home (hold for Recents),
- * swipe in from either side edge for Back.
+ * The user-tunable geometry of the gesture activation zones. Only physical dimensions are
+ * configurable; the action/direction mapping (Back/Home/Recents, swipe directions) is fixed
+ * and never derived from these settings.
+ *
+ * - [backActivationHeightPercent] / [bottomActivationWidthPercent] describe how much of the
+ *   relevant edge can *start* a gesture (10%..100%).
+ * - [backEdgeSensitivity] / [bottomEdgeSensitivity] are multipliers on the *base* zone
+ *   thickness (how far inward from the physical edge a touch may begin). They do NOT change
+ *   the swipe-distance threshold — only the starting hit-region depth.
+ *
+ * Side Back zones are anchored toward the bottom of the screen (measured upward from just
+ * above the reserved bottom gesture band), not vertically centered.
  */
-val GESTURE_ZONES = listOf(
-    ZoneConfig(ZoneId.BOTTOM, GestureAction.HOME, longAction = GestureAction.RECENTS, lengthPercent = 80, thicknessDp = 12),
-    ZoneConfig(ZoneId.LEFT_EDGE, GestureAction.BACK, longAction = null, lengthPercent = 80, thicknessDp = 16),
-    ZoneConfig(ZoneId.RIGHT_EDGE, GestureAction.BACK, longAction = null, lengthPercent = 80, thicknessDp = 16),
+data class GestureZoneSettings(
+    val backActivationHeightPercent: Int,
+    val bottomActivationWidthPercent: Int,
+    val backEdgeSensitivity: Float,
+    val bottomEdgeSensitivity: Float,
+) {
+    /** Effective Back zone thickness in dp, before the nav-bar inset is added. */
+    val backThicknessDp: Int get() = (BASE_BACK_THICKNESS_DP * backEdgeSensitivity).toInt().coerceAtLeast(1)
+
+    /** Effective bottom zone thickness in dp, before the nav-bar inset is added. */
+    val bottomThicknessDp: Int get() = (BASE_BOTTOM_THICKNESS_DP * bottomEdgeSensitivity).toInt().coerceAtLeast(1)
+
+    companion object {
+        // Base (1.0×) gesture-zone thicknesses. Sensitivity multiplies these; the nav-bar
+        // inset is added afterward and is never multiplied.
+        const val BASE_BACK_THICKNESS_DP = 16
+        const val BASE_BOTTOM_THICKNESS_DP = 12
+
+        // Activation-area percentage bounds (10%..100%, 10% step).
+        const val PERCENT_MIN = 10
+        const val PERCENT_MAX = 100
+        const val PERCENT_STEP = 10
+        const val DEFAULT_BACK_HEIGHT_PERCENT = 80
+        const val DEFAULT_BOTTOM_WIDTH_PERCENT = 80
+
+        // Edge-sensitivity multiplier bounds (0.5×..4.0×, 0.25× step).
+        const val SENSITIVITY_MIN = 0.5f
+        const val SENSITIVITY_MAX = 4.0f
+        const val SENSITIVITY_STEP = 0.25f
+        const val DEFAULT_BACK_SENSITIVITY = 1.0f
+        const val DEFAULT_BOTTOM_SENSITIVITY = 1.0f
+
+        val DEFAULT = GestureZoneSettings(
+            backActivationHeightPercent = DEFAULT_BACK_HEIGHT_PERCENT,
+            bottomActivationWidthPercent = DEFAULT_BOTTOM_WIDTH_PERCENT,
+            backEdgeSensitivity = DEFAULT_BACK_SENSITIVITY,
+            bottomEdgeSensitivity = DEFAULT_BOTTOM_SENSITIVITY,
+        )
+
+        /**
+         * Normalizes a raw persisted percentage: snaps to the nearest PERCENT_STEP step, then
+         * clamps to [PERCENT_MIN]..[PERCENT_MAX]. Midpoints (e.g. 15) round half-up to the next
+         * step (→ 20). A valid persisted/runtime value is therefore always one of
+         * 10, 20, 30, 40, 50, 60, 70, 80, 90, 100.
+         *
+         * Use this on both DataStore reads and writes so a corrupted/out-of-range preference
+         * never produces an absurd value.
+         */
+        fun clampPercent(value: Int): Int {
+            val steps = Math.round(value.toFloat() / PERCENT_STEP)
+            return (steps * PERCENT_STEP).coerceIn(PERCENT_MIN, PERCENT_MAX)
+        }
+
+        /** Rounds a raw persisted sensitivity to the nearest 0.25 step and clamps it. */
+        fun clampSensitivity(value: Float): Float {
+            val stepped = (value / SENSITIVITY_STEP).toInt().let { steps ->
+                (value - steps * SENSITIVITY_STEP).let { remainder ->
+                    if (remainder >= SENSITIVITY_STEP / 2f) steps + 1 else steps
+                }
+            }
+            return (stepped * SENSITIVITY_STEP).coerceIn(SENSITIVITY_MIN, SENSITIVITY_MAX)
+        }
+    }
+}
+
+/**
+ * Builds the runtime [ZoneConfig] list from the user's [settings]. Action/direction mapping
+ * is static; only geometry (length percent, thickness) comes from the settings.
+ */
+fun buildGestureZones(settings: GestureZoneSettings): List<ZoneConfig> = listOf(
+    ZoneConfig(
+        id = ZoneId.BOTTOM,
+        action = GestureAction.HOME,
+        longAction = GestureAction.RECENTS,
+        lengthPercent = settings.bottomActivationWidthPercent,
+        thicknessDp = settings.bottomThicknessDp,
+    ),
+    ZoneConfig(
+        id = ZoneId.LEFT_EDGE,
+        action = GestureAction.BACK,
+        longAction = null,
+        lengthPercent = settings.backActivationHeightPercent,
+        thicknessDp = settings.backThicknessDp,
+    ),
+    ZoneConfig(
+        id = ZoneId.RIGHT_EDGE,
+        action = GestureAction.BACK,
+        longAction = null,
+        lengthPercent = settings.backActivationHeightPercent,
+        thicknessDp = settings.backThicknessDp,
+    ),
+)
+
+/**
+ * The fixed default gesture layout: swipe up from the bottom for Home (hold for Recents),
+ * swipe in from either side edge for Back. Kept as the default-configuration source and for
+ * tests that assert the static action/direction mapping.
+ */
+val GESTURE_ZONES: List<ZoneConfig> = buildGestureZones(GestureZoneSettings.DEFAULT)
+
+/**
+ * Display geometry the gesture-zone layout depends on: full display size, density, and the
+ * navigation-bar insets per edge (zero for bar-free edges). Android-independent so the
+ * layout math can be unit-tested without a WindowManager.
+ */
+data class ScreenGeometry(
+    val width: Int,
+    val height: Int,
+    val density: Float,
+    val navLeft: Int,
+    val navRight: Int,
+    val navBottom: Int,
 )
+
+/**
+ * Resolved on-screen geometry of one gesture touch zone: the absolute screen-coordinate
+ * touch [rect] (in display pixels) plus the [widthPx]/[heightPx]/[yOffset] the controller
+ * needs to place the window with BOTTOM/START/END gravity. The layout test uses [rect] to
+ * prove the side and bottom zones never overlap and never leave a gap; the controller uses
+ * [widthPx]/[heightPx]/[yOffset] to build the actual
+ * [android.view.WindowManager.LayoutParams] (it maps the zone id to the Gravity constant
+ * itself, since Gravity is an Android type).
+ */
+data class ZoneLayout(
+    val zoneId: ZoneId,
+    val rect: IntArray,
+    val widthPx: Int,
+    val heightPx: Int,
+    val yOffset: Int,
+) {
+    /** Absolute left of the touch region in display pixels. */
+    val left: Int get() = rect[0]
+    /** Absolute top of the touch region in display pixels. */
+    val top: Int get() = rect[1]
+    /** Absolute right of the touch region in display pixels. */
+    val right: Int get() = rect[2]
+    /** Absolute bottom of the touch region in display pixels. */
+    val bottom: Int get() = rect[3]
+}
+
+/**
+ * The single source of truth for gesture-zone window geometry, shared by
+ * [com.ogesture.service.EdgeOverlayController] (production WindowManager placement) and the
+ * layout unit tests. Pure — no Android types.
+ *
+ * Invariants (the corner-precedence contract):
+ * - `effectiveBottomTouchDepthPx = settings.bottomThicknessDp * density`
+ * - `reservedBottomBandPx   = effectiveBottomTouchDepthPx + navBottom`  (navBottom is NEVER multiplied by sensitivity)
+ * - `effectiveBackDepthPx    = settings.backThicknessDp    * density`
+ * - side Back window width  = `effectiveBackDepthPx + navSide`  (navSide never multiplied)
+ * - the bottom Home/Recents zone owns the full reserved bottom band (screen y in
+ *   `[height - reservedBottomBandPx, height]`)
+ * - the side Back zones are anchored to the BOTTOM and offset upward by exactly
+ *   `reservedBottomBandPx`, so their bottom edge sits immediately above the reserved band:
+ *   no vertical overlap, no dead gap. Their height is `backActivationHeightPercent` of the
+ *   usable side span *above* the band (`height - reservedBottomBandPx`).
+ */
+fun computeGestureZoneLayout(
+    settings: GestureZoneSettings,
+    geometry: ScreenGeometry,
+): Map<ZoneId, ZoneLayout> {
+    val density = geometry.density
+    val effectiveBottomDepthPx = (settings.bottomThicknessDp * density).toInt().coerceAtLeast(1)
+    val reservedBottomBandPx = effectiveBottomDepthPx + geometry.navBottom
+    val effectiveBackDepthPx = (settings.backThicknessDp * density).toInt().coerceAtLeast(1)
+
+    val usableSideHeightPx = (geometry.height - reservedBottomBandPx).coerceAtLeast(1)
+    val bottomWidthPx = (geometry.width * settings.bottomActivationWidthPercent / 100).coerceAtLeast(1)
+    val sideHeightPx = (usableSideHeightPx * settings.backActivationHeightPercent / 100).coerceAtLeast(1)
+
+    // Bottom zone: centered horizontally, flush with the bottom (spanning its nav inset).
+    val bottomLeft = ((geometry.width - bottomWidthPx) / 2).coerceAtLeast(0)
+    val bottomRight = (bottomLeft + bottomWidthPx).coerceAtMost(geometry.width)
+    val bottomTop = geometry.height - reservedBottomBandPx
+    val bottom = ZoneLayout(
+        zoneId = ZoneId.BOTTOM,
+        rect = intArrayOf(bottomLeft, bottomTop, bottomRight, geometry.height),
+        widthPx = bottomRight - bottomLeft,
+        heightPx = reservedBottomBandPx,
+        yOffset = 0,
+    )
+
+    // Left Back zone: anchored to the bottom, offset up by the reserved bottom band so it sits
+    // immediately above it (no overlap, no gap). Spans its left nav inset.
+    val leftWidthPx = effectiveBackDepthPx + geometry.navLeft
+    val leftBottom = bottomTop // immediately above the reserved band
+    val leftTop = leftBottom - sideHeightPx
+    val left = ZoneLayout(
+        zoneId = ZoneId.LEFT_EDGE,
+        rect = intArrayOf(0, leftTop, leftWidthPx, leftBottom),
+        widthPx = leftWidthPx,
+        heightPx = sideHeightPx,
+        yOffset = reservedBottomBandPx,
+    )
+
+    // Right Back zone: mirrored.
+    val rightWidthPx = effectiveBackDepthPx + geometry.navRight
+    val rightLeft = geometry.width - rightWidthPx
+    val rightBottom = bottomTop
+    val rightTop = rightBottom - sideHeightPx
+    val right = ZoneLayout(
+        zoneId = ZoneId.RIGHT_EDGE,
+        rect = intArrayOf(rightLeft, rightTop, geometry.width, rightBottom),
+        widthPx = rightWidthPx,
+        heightPx = sideHeightPx,
+        yOffset = reservedBottomBandPx,
+    )
+
+    return mapOf(ZoneId.BOTTOM to bottom, ZoneId.LEFT_EDGE to left, ZoneId.RIGHT_EDGE to right)
+}
diff --git a/app/src/main/java/com/ogesture/data/SettingsRepository.kt b/app/src/main/java/com/ogesture/data/SettingsRepository.kt
index 62a67ab..ed7d896 100644
--- a/app/src/main/java/com/ogesture/data/SettingsRepository.kt
+++ b/app/src/main/java/com/ogesture/data/SettingsRepository.kt
@@ -5,9 +5,12 @@ import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.floatPreferencesKey
+import androidx.datastore.preferences.core.intPreferencesKey
 import androidx.datastore.preferences.core.stringSetPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 
@@ -35,9 +38,42 @@ class SettingsRepository private constructor(appContext: Context) {
         }
     }
 
+    /**
+     * The user-tunable gesture-zone geometry, clamped to valid ranges. The controller
+     * observes [gestureZoneSettings] and rebuilds the overlay zones when it changes.
+     */
+    val gestureZoneSettings: Flow<GestureZoneSettings> = combine(
+        store.data.map { GestureZoneSettings.clampPercent(it[KEY_BACK_HEIGHT] ?: GestureZoneSettings.DEFAULT_BACK_HEIGHT_PERCENT) },
+        store.data.map { GestureZoneSettings.clampPercent(it[KEY_BOTTOM_WIDTH] ?: GestureZoneSettings.DEFAULT_BOTTOM_WIDTH_PERCENT) },
+        store.data.map { GestureZoneSettings.clampSensitivity(it[KEY_BACK_SENSITIVITY] ?: GestureZoneSettings.DEFAULT_BACK_SENSITIVITY) },
+        store.data.map { GestureZoneSettings.clampSensitivity(it[KEY_BOTTOM_SENSITIVITY] ?: GestureZoneSettings.DEFAULT_BOTTOM_SENSITIVITY) },
+    ) { height, width, backSens, bottomSens ->
+        GestureZoneSettings(height, width, backSens, bottomSens)
+    }
+
+    suspend fun setBackActivationHeight(percent: Int) {
+        store.edit { it[KEY_BACK_HEIGHT] = GestureZoneSettings.clampPercent(percent) }
+    }
+
+    suspend fun setBottomActivationWidth(percent: Int) {
+        store.edit { it[KEY_BOTTOM_WIDTH] = GestureZoneSettings.clampPercent(percent) }
+    }
+
+    suspend fun setBackEdgeSensitivity(multiplier: Float) {
+        store.edit { it[KEY_BACK_SENSITIVITY] = GestureZoneSettings.clampSensitivity(multiplier) }
+    }
+
+    suspend fun setBottomEdgeSensitivity(multiplier: Float) {
+        store.edit { it[KEY_BOTTOM_SENSITIVITY] = GestureZoneSettings.clampSensitivity(multiplier) }
+    }
+
     companion object {
         private val KEY_MASTER = booleanPreferencesKey("master_enabled")
         private val KEY_EXCLUDED_APPS = stringSetPreferencesKey("excluded_apps")
+        private val KEY_BACK_HEIGHT = intPreferencesKey("back_activation_height_percent")
+        private val KEY_BOTTOM_WIDTH = intPreferencesKey("bottom_activation_width_percent")
+        private val KEY_BACK_SENSITIVITY = floatPreferencesKey("back_edge_sensitivity")
+        private val KEY_BOTTOM_SENSITIVITY = floatPreferencesKey("bottom_edge_sensitivity")
 
         @Volatile private var INSTANCE: SettingsRepository? = null
 
diff --git a/app/src/main/java/com/ogesture/service/BootReceiver.kt b/app/src/main/java/com/ogesture/service/BootReceiver.kt
deleted file mode 100644
index fa75186..0000000
--- a/app/src/main/java/com/ogesture/service/BootReceiver.kt
+++ /dev/null
@@ -1,36 +0,0 @@
-package com.ogesture.service
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.provider.Settings
-import android.util.Log
-import com.ogesture.data.SettingsRepository
-import kotlinx.coroutines.runBlocking
-
-class BootReceiver : BroadcastReceiver() {
-
-    override fun onReceive(context: Context, intent: Intent) {
-        val action = intent.action
-        if (action != Intent.ACTION_BOOT_COMPLETED && action != Intent.ACTION_LOCKED_BOOT_COMPLETED) return
-
-        val pending = goAsync()
-        try {
-            val enabled = runBlocking { SettingsRepository.get(context).isMasterEnabled() }
-            if (!enabled) return
-            if (!Settings.canDrawOverlays(context)) {
-                Log.w(TAG, "Skipping auto-start: overlay permission missing")
-                return
-            }
-            EdgeOverlayService.start(context)
-        } catch (t: Throwable) {
-            Log.e(TAG, "Failed to auto-start on boot", t)
-        } finally {
-            pending.finish()
-        }
-    }
-
-    companion object {
-        private const val TAG = "BootReceiver"
-    }
-}
diff --git a/app/src/main/java/com/ogesture/service/EdgeGestureAccessibilityService.kt b/app/src/main/java/com/ogesture/service/EdgeGestureAccessibilityService.kt
index e404a23..eb13918 100644
--- a/app/src/main/java/com/ogesture/service/EdgeGestureAccessibilityService.kt
+++ b/app/src/main/java/com/ogesture/service/EdgeGestureAccessibilityService.kt
@@ -4,6 +4,7 @@ import android.accessibilityservice.AccessibilityService
 import android.accessibilityservice.GestureDescription
 import android.content.Context
 import android.content.Intent
+import android.content.res.Configuration
 import android.os.Handler
 import android.os.Looper
 import android.os.PowerManager
@@ -23,22 +24,29 @@ import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.launch
 
-class EdgeGestureAccessibilityService : AccessibilityService() {
+class EdgeGestureAccessibilityService : AccessibilityService(), GestureDispatcher {
 
     private val scope = CoroutineScope(Dispatchers.Main.immediate + SupervisorJob())
     private val handler = Handler(Looper.getMainLooper())
     private val repo by lazy { SettingsRepository.get(this) }
     @Volatile private var masterEnabled = false
 
-    // The overlay foreground service is the fragile half of the gesture pipeline: Android — and
-    // Samsung battery management in particular — can kill it without killing this accessibility
-    // service, which the framework keeps bound and rebinds automatically. This watchdog re-asserts
-    // the overlay service periodically so the gesture zones come back on their own, instead of the
-    // user having to open the app and toggle the switch.
+    // Owns the gesture-zone and indicator windows. Created when the service binds and
+    // destroyed when it unbinds, so the windows follow the accessibility-service lifecycle
+    // exactly: Android rebinds the service after process death and the controller comes
+    // back with it, re-attaching zones if the master switch is still on — no foreground
+    // service or boot receiver is needed for that revival.
+    private var controller: EdgeOverlayController? = null
+
+    // The gesture zones are accessibility-overlay windows, which the system does not hide on
+    // secure screens and does not tie to a foreground service. The only requirement this
+    // service can observe besides its own binding is unrestricted battery (the system and
+    // OEM battery managers can still kill the process if it is restricted), so the watchdog
+    // now only re-checks that, and re-asserts the controller in case the master flow hasn't
+    // attached the zones yet (e.g. right after a rebind racing the datastore read).
     private val watchdog = object : Runnable {
         override fun run() {
             disableIfBroken()
-            ensureOverlayRunning()
             refreshImePackages()
             handler.postDelayed(this, WATCHDOG_INTERVAL_MS)
         }
@@ -63,47 +71,57 @@ class EdgeGestureAccessibilityService : AccessibilityService() {
         super.onServiceConnected()
         instance = this
         refreshImePackages()
+        controller = EdgeOverlayController(
+            context = this,
+            windowManager = getSystemService(WINDOW_SERVICE) as android.view.WindowManager,
+            repo = repo,
+            dispatcher = this,
+            scope = scope,
+        ).also { it.start() }
         scope.launch {
             repo.masterEnabled.collect { enabled ->
                 masterEnabled = enabled
-                // Revive immediately when enabled — covers the common case where the whole
-                // process was killed and the framework has just rebound us.
-                if (enabled) ensureOverlayRunning()
+                // The controller's own master flow attaches/detaches the zones; this just
+                // keeps the local flag in sync for the watchdog.
             }
         }
         handler.removeCallbacks(watchdog)
         handler.postDelayed(watchdog, WATCHDOG_INTERVAL_MS)
     }
 
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        super.onConfigurationChanged(newConfig)
+        controller?.onConfigurationChanged(newConfig)
+    }
+
     override fun onUnbind(intent: Intent?): Boolean {
         instance = null
         handler.removeCallbacks(watchdog)
+        controller?.stop()
+        controller = null
         return super.onUnbind(intent)
     }
 
     override fun onDestroy() {
         instance = null
         handler.removeCallbacks(watchdog)
+        controller?.stop()
+        controller = null
         scope.cancel()
         super.onDestroy()
     }
 
     /**
-     * Background safety net: if gestures are enabled but a requirement this service can
-     * observe has gone away (overlay permission or unrestricted battery), turn the switch
-     * off and tell the user. The accessibility service being bound is implied — this only
-     * runs from its own watchdog. The in-app screen covers the same cases (plus the
-     * accessibility-unbound case) faster while it is open.
+     * Background safety net: if gestures are enabled but unrestricted battery has been
+     * revoked, turn the switch off and tell the user. The accessibility service being bound
+     * is implied — this only runs from its own watchdog. The in-app screen covers the same
+     * cases (plus the accessibility-unbound case) faster while it is open.
      */
     private fun disableIfBroken() {
         if (!masterEnabled) return
-        val reason = when {
-            !Settings.canDrawOverlays(this) -> R.string.toast_gestures_off_overlay
-            !isBatteryUnrestricted() -> R.string.toast_gestures_off_battery
-            else -> return
-        }
+        if (isBatteryUnrestricted()) return
         scope.launch { repo.setMasterEnabled(false) }
-        Toast.makeText(this, reason, Toast.LENGTH_LONG).show()
+        Toast.makeText(this, R.string.toast_gestures_off_battery, Toast.LENGTH_LONG).show()
     }
 
     private fun isBatteryUnrestricted(): Boolean {
@@ -111,18 +129,6 @@ class EdgeGestureAccessibilityService : AccessibilityService() {
         return pm.isIgnoringBatteryOptimizations(packageName)
     }
 
-    private fun ensureOverlayRunning() {
-        if (!masterEnabled || EdgeOverlayService.isRunning) return
-        if (!Settings.canDrawOverlays(this)) return
-        try {
-            // Apps holding SYSTEM_ALERT_WINDOW are exempt from background foreground-service
-            // start restrictions, so this is allowed from here whenever overlays are permitted.
-            EdgeOverlayService.start(this)
-        } catch (t: Throwable) {
-            Log.w(TAG, "Failed to revive overlay service", t)
-        }
-    }
-
     override fun onAccessibilityEvent(event: AccessibilityEvent?) {
         // Only the foreground package name is read — never window content. It drives the
         // per-app pass-through: zones go untouchable while an excluded app is in front.
@@ -134,7 +140,7 @@ class EdgeGestureAccessibilityService : AccessibilityService() {
 
     override fun onInterrupt() { /* no-op */ }
 
-    fun trigger(action: GestureAction) {
+    override fun trigger(action: GestureAction) {
         when (action) {
             GestureAction.BACK -> performGlobalAction(GLOBAL_ACTION_BACK)
             GestureAction.HOME -> performGlobalAction(GLOBAL_ACTION_HOME)
@@ -147,7 +153,7 @@ class EdgeGestureAccessibilityService : AccessibilityService() {
      * underneath. Returns false if the gesture could not be dispatched; onDone always
      * runs otherwise, with whether the gesture played to completion.
      */
-    fun replay(gesture: GestureDescription, onDone: (completed: Boolean) -> Unit): Boolean =
+    override fun replay(gesture: GestureDescription, onDone: (completed: Boolean) -> Unit): Boolean =
         dispatchGesture(
             gesture,
             object : GestureResultCallback() {
diff --git a/app/src/main/java/com/ogesture/service/EdgeOverlayService.kt b/app/src/main/java/com/ogesture/service/EdgeOverlayController.kt
similarity index 72%
rename from app/src/main/java/com/ogesture/service/EdgeOverlayService.kt
rename to app/src/main/java/com/ogesture/service/EdgeOverlayController.kt
index c9d3054..cd502b6 100644
--- a/app/src/main/java/com/ogesture/service/EdgeOverlayService.kt
+++ b/app/src/main/java/com/ogesture/service/EdgeOverlayController.kt
@@ -1,13 +1,7 @@
 package com.ogesture.service
 
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
 import android.accessibilityservice.GestureDescription
 import android.content.Context
-import android.content.Intent
-import android.content.pm.ServiceInfo
 import android.content.res.Configuration
 import android.graphics.Path
 import android.graphics.PixelFormat
@@ -19,22 +13,20 @@ import android.os.Looper
 import android.os.VibrationEffect
 import android.os.Vibrator
 import android.os.VibratorManager
-import android.provider.Settings
 import android.util.Log
 import android.view.Display
 import android.view.Gravity
 import android.view.View
 import android.view.WindowInsets
 import android.view.WindowManager
-import androidx.core.app.NotificationCompat
-import androidx.lifecycle.LifecycleService
-import androidx.lifecycle.lifecycleScope
-import com.ogesture.MainActivity
-import com.ogesture.R
-import com.ogesture.data.GESTURE_ZONES
+import com.ogesture.data.GestureZoneSettings
+import com.ogesture.data.ScreenGeometry
 import com.ogesture.data.SettingsRepository
 import com.ogesture.data.ZoneConfig
 import com.ogesture.data.ZoneId
+import com.ogesture.data.ZoneLayout
+import com.ogesture.data.buildGestureZones
+import com.ogesture.data.computeGestureZoneLayout
 import com.ogesture.gesture.SwipeDetector
 import com.ogesture.gesture.TouchSample
 import com.ogesture.ui.overlay.BackIndicator
@@ -43,11 +35,27 @@ import com.ogesture.ui.overlay.OverlayIndicator
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch
-
-class EdgeOverlayService : LifecycleService() {
-
-    private lateinit var windowManager: WindowManager
-    private lateinit var repo: SettingsRepository
+import kotlinx.coroutines.CoroutineScope
+
+/**
+ * Owns the gesture-zone and indicator windows. Extracted from the former `EdgeOverlayService`
+ * so the same logic can run under the active [EdgeGestureAccessibilityService] using trusted
+ * `TYPE_ACCESSIBILITY_OVERLAY` windows instead of `TYPE_APPLICATION_OVERLAY` + a foreground
+ * service. Accessibility overlays are not hidden by `HIDE_NON_SYSTEM_OVERLAY_WINDOWS` on secure
+ * screens (Settings, SubSettings), so gestures keep working there, and the system no longer
+ * shows the persistent "displaying over other apps" notification for the app.
+ *
+ * The controller is created and destroyed by the accessibility service and must only be
+ * touched from the main thread (window operations are main-thread only). [scope] is supplied
+ * by the owner so its cancellation is tied to the service lifecycle.
+ */
+class EdgeOverlayController(
+    private val context: Context,
+    private val windowManager: WindowManager,
+    private val repo: SettingsRepository,
+    private val dispatcher: GestureDispatcher,
+    private val scope: CoroutineScope,
+) {
     private val activeViews = mutableMapOf<ZoneId, View>()
     private val indicators = mutableMapOf<ZoneId, OverlayIndicator>()
     private var attached = false
@@ -78,6 +86,9 @@ class EdgeOverlayService : LifecycleService() {
     /** Display geometry the attached zones were laid out for. Null while nothing is attached. */
     private var lastGeometry: ScreenGeometry? = null
 
+    /** The settings the currently-attached zones were built from. Null while nothing is attached. */
+    @Volatile private var lastSettings: GestureZoneSettings? = null
+
     // Rotation is applied to the display after the configuration change lands, so listen for
     // the display change itself rather than racing it: onDisplayChanged fires once the new
     // size is in effect. Configuration changes cover the rest (display-size/density settings,
@@ -90,33 +101,33 @@ class EdgeOverlayService : LifecycleService() {
         }
     }
 
-    override fun onCreate() {
-        super.onCreate()
-        windowManager = getSystemService(WINDOW_SERVICE) as WindowManager
-        repo = SettingsRepository.get(this)
-        startInForeground()
-        isRunning = true
-        (getSystemService(Context.DISPLAY_SERVICE) as DisplayManager)
+    /**
+     * Starts the controller: observes the master gesture switch and the per-app pass-through
+     * flow, and registers for display-geometry changes. Idempotent. Must be called once the
+     * owning accessibility service is connected.
+     */
+    fun start() {
+        (context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager)
             .registerDisplayListener(displayListener, mainHandler)
 
-        lifecycleScope.launch {
-            repo.masterEnabled.distinctUntilChanged().collect { enabled ->
+        // One combined runtime configuration: master switch + the four geometry settings.
+        // A change to any geometry field rebuilds the zones exactly once (distinctUntilChanged
+        // on the whole settings record), so dragging a slider produces one rebuild per commit,
+        // not one per field. Pass-through is observed separately because it changes
+        // interactivity, not geometry.
+        scope.launch {
+            combine(repo.masterEnabled, repo.gestureZoneSettings) { enabled, settings ->
+                enabled to settings
+            }.distinctUntilChanged().collect { (enabled, settings) ->
                 if (!enabled) {
                     detachAll()
-                    stopSelf()
                     return@collect
                 }
-                if (!Settings.canDrawOverlays(this@EdgeOverlayService)) {
-                    Log.w(TAG, "Overlay permission missing; stopping service")
-                    detachAll()
-                    stopSelf()
-                    return@collect
-                }
-                rebuild(GESTURE_ZONES)
+                rebuild(settings)
             }
         }
 
-        lifecycleScope.launch {
+        scope.launch {
             combine(
                 EdgeGestureAccessibilityService.foregroundPackage,
                 repo.excludedApps,
@@ -129,23 +140,20 @@ class EdgeOverlayService : LifecycleService() {
         }
     }
 
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        super.onStartCommand(intent, flags, startId)
-        return START_STICKY
-    }
-
-    override fun onDestroy() {
-        isRunning = false
+    /** Tears down every window and unregisters listeners. Safe to call more than once. */
+    fun stop() {
         try {
-            (getSystemService(Context.DISPLAY_SERVICE) as DisplayManager)
+            (context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager)
                 .unregisterDisplayListener(displayListener)
         } catch (_: Throwable) { /* never registered */ }
         detachAll()
-        super.onDestroy()
     }
 
-    override fun onConfigurationChanged(newConfig: Configuration) {
-        super.onConfigurationChanged(newConfig)
+    /**
+     * Called by the owner on configuration changes so the zones re-lay out for the new
+     * display geometry (rotation, density, multi-window, folding).
+     */
+    fun onConfigurationChanged(newConfig: Configuration) {
         rebuildIfGeometryChanged()
     }
 
@@ -160,7 +168,11 @@ class EdgeOverlayService : LifecycleService() {
     private fun rebuildIfGeometryChanged() {
         if (activeViews.isEmpty()) return
         if (currentGeometry() == lastGeometry) return
-        rebuild(GESTURE_ZONES)
+        // Re-lay out for the new display geometry using the settings the attached zones were
+        // built from. A setting change arrives through the combined flow, which rebuilds with
+        // the new settings; a rotation only re-lays out the existing geometry for the same
+        // settings, so the two never race on which snapshot wins.
+        rebuild(lastSettings ?: GestureZoneSettings.DEFAULT)
     }
 
     /**
@@ -169,17 +181,8 @@ class EdgeOverlayService : LifecycleService() {
      * while the 3-button bar jumps to the opposite side — the zones must re-lay out for
      * that even though the display size alone looks unchanged.
      */
-    private data class ScreenGeometry(
-        val width: Int,
-        val height: Int,
-        val density: Float,
-        val navLeft: Int,
-        val navRight: Int,
-        val navBottom: Int,
-    )
-
     private fun currentGeometry(): ScreenGeometry {
-        val density = resources.displayMetrics.density
+        val density = context.resources.displayMetrics.density
         return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
             val metrics = windowManager.currentWindowMetrics
             val nav = metrics.windowInsets.getInsets(WindowInsets.Type.navigationBars())
@@ -189,12 +192,13 @@ class EdgeOverlayService : LifecycleService() {
             )
         } else {
             @Suppress("DEPRECATION")
-            val metrics = resources.displayMetrics
+            val metrics = context.resources.displayMetrics
             ScreenGeometry(metrics.widthPixels, metrics.heightPixels, density, 0, 0, 0)
         }
     }
 
-    private fun rebuild(zones: List<ZoneConfig>) {
+    private fun rebuild(settings: GestureZoneSettings) {
+        val zones = buildGestureZones(settings)
         detachAll()
         // Detaching kills any in-flight stream (e.g. a rotation mid-touch), so its UP will
         // never arrive to release the hold — clear it or the fresh windows start dead.
@@ -203,23 +207,33 @@ class EdgeOverlayService : LifecycleService() {
         // even if a rotation lands mid-rebuild; the listener re-runs us if it changed again.
         val geometry = currentGeometry()
         lastGeometry = geometry
+        // Cache the settings these zones are built from so a display-geometry change (rotation)
+        // re-lays out with the same settings rather than racing the combined flow.
+        lastSettings = settings
+        // The Home handle's visible width is the SAME resolved horizontal width as the bottom
+        // gesture touch zone, taken from the single production geometry resolver so the bar can
+        // never drift from the actual activation region. Only horizontal width is shared;
+        // bottom edge sensitivity widens the invisible touch zone vertically, never the bar.
+        val resolvedLayout = computeGestureZoneLayout(settings, geometry)
+        val homeHandleWidthPx = resolvedLayout.getValue(ZoneId.BOTTOM).widthPx
         for (zone in zones) {
-            val view = View(this).apply {
+            val view = View(context).apply {
                 // DEBUG_SHOW_ZONES tints the touch areas so they can be seen while testing.
                 setBackgroundColor(if (DEBUG_SHOW_ZONES) ZONE_DEBUG_COLOR else android.graphics.Color.TRANSPARENT)
             }
             val minDistanceDp = if (zone.id == ZoneId.BOTTOM) BOTTOM_MIN_DISTANCE_DP else SIDE_MIN_DISTANCE_DP
-            val armDistancePx = minDistanceDp * resources.displayMetrics.density
+            val armDistancePx = minDistanceDp * context.resources.displayMetrics.density
             val indicator: OverlayIndicator
             val feedback: SwipeDetector.Feedback?
             when (zone.id) {
                 ZoneId.LEFT_EDGE, ZoneId.RIGHT_EDGE -> {
                     val ind = BackIndicator(
-                        context = this,
+                        context = context,
                         windowManager = windowManager,
                         fromLeftEdge = zone.id == ZoneId.LEFT_EDGE,
                         armDistancePx = armDistancePx,
                         edgeOffsetPx = if (zone.id == ZoneId.LEFT_EDGE) geometry.navLeft else geometry.navRight,
+                        windowType = WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY,
                     )
                     indicator = ind
                     feedback = object : SwipeDetector.Feedback {
@@ -235,8 +249,10 @@ class EdgeOverlayService : LifecycleService() {
                 }
                 ZoneId.BOTTOM -> {
                     val ind = HomeIndicator(
-                        context = this,
+                        context = context,
                         windowManager = windowManager,
+                        barWidthPx = homeHandleWidthPx,
+                        windowType = WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY,
                     )
                     indicator = ind
                     // The bar is static; it only lifts slightly while a bottom gesture is
@@ -251,7 +267,7 @@ class EdgeOverlayService : LifecycleService() {
             }
             view.setOnTouchListener(
                 SwipeDetector(
-                    context = this,
+                    context = context,
                     direction = zone.swipeDirection,
                     onShortSwipe = { onZoneTriggered(zone, long = false) },
                     onLongSwipe = if (zone.longAction != null) {
@@ -275,7 +291,7 @@ class EdgeOverlayService : LifecycleService() {
                     },
                 )
             )
-            val params = layoutParamsFor(zone, geometry)
+            val params = layoutParamsFor(zone, settings, geometry)
             try {
                 windowManager.addView(view, params)
                 view.post {
@@ -302,7 +318,10 @@ class EdgeOverlayService : LifecycleService() {
             ind.detach()
         }
         indicators.clear()
-        if (activeViews.isEmpty()) return
+        if (activeViews.isEmpty()) {
+            attached = false
+            return
+        }
         for ((_, v) in activeViews) {
             try {
                 windowManager.removeView(v)
@@ -320,11 +339,6 @@ class EdgeOverlayService : LifecycleService() {
      */
     private fun replayUnusedTouch(samples: List<TouchSample>) {
         if (replaying || passThrough || samples.isEmpty()) return
-        val service = EdgeGestureAccessibilityService.instance
-        if (service == null) {
-            Log.w(TAG, "Accessibility service not bound; cannot replay touch")
-            return
-        }
         val first = samples.first()
         val last = samples.last()
         val movedPx = kotlin.math.hypot(last.x - first.x, last.y - first.y)
@@ -395,7 +409,7 @@ class EdgeOverlayService : LifecycleService() {
         // Safety net in case the result callback never arrives.
         mainHandler.postDelayed(finish, duration + injectDelay + 1_000L)
         mainHandler.postDelayed({
-            val dispatched = service.replay(gesture) { completed ->
+            val dispatched = dispatcher.replay(gesture) { completed ->
                 Log.d(TAG, "Replay finished, completed=$completed")
                 mainHandler.removeCallbacks(finish)
                 finish.run()
@@ -449,115 +463,59 @@ class EdgeOverlayService : LifecycleService() {
         val action = (if (long) zone.longAction else zone.action) ?: return
         // Side zones already ticked when their indicator armed.
         if (zone.id == ZoneId.BOTTOM) hapticTick()
-        val service = EdgeGestureAccessibilityService.instance
-        if (service == null) {
-            Log.w(TAG, "Accessibility service not bound; cannot fire $action")
-            return
-        }
-        service.trigger(action)
+        dispatcher.trigger(action)
     }
 
     private fun hapticTick() {
         val effect = VibrationEffect.createOneShot(12L, VibrationEffect.DEFAULT_AMPLITUDE)
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            val mgr = getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as? VibratorManager
+            val mgr = context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as? VibratorManager
             mgr?.defaultVibrator?.vibrate(effect)
         } else {
             @Suppress("DEPRECATION")
-            val v = getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
+            val v = context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
             v?.vibrate(effect)
         }
     }
 
     private fun layoutParamsFor(
         zone: ZoneConfig,
+        settings: GestureZoneSettings,
         geometry: ScreenGeometry,
     ): WindowManager.LayoutParams {
-        val thicknessPx = (zone.thicknessDp * geometry.density).toInt().coerceAtLeast(1)
-        // Each zone is extended across its own edge's nav-bar inset (zero for bar-free
-        // edges) and stops fitting insets, so it reaches the physical edge instead of
-        // floating next to the bar — the bar sits at the bottom in portrait and moves to a
-        // side in landscape with 3-button nav. Touches on the bar itself are still routed
-        // to the bar — it is a higher-Z system window — but a swipe that starts on the bar
-        // slips to the zone underneath the moment it leaves the bar (the bar is a
-        // "slippery" window), and the extra band just past the bar catches it. Without the
-        // extension, that slippery handoff would land beyond the zone and the bar's edge
-        // would have no working gesture.
-        val (widthPx, heightPx, gravity) = when (zone.id) {
-            ZoneId.BOTTOM -> Triple(
-                (geometry.width * zone.lengthPercent / 100).coerceAtLeast(1),
-                thicknessPx + geometry.navBottom,
-                Gravity.BOTTOM or Gravity.CENTER_HORIZONTAL,
-            )
-            ZoneId.LEFT_EDGE -> Triple(
-                thicknessPx + geometry.navLeft,
-                (geometry.height * zone.lengthPercent / 100).coerceAtLeast(1),
-                Gravity.START or Gravity.CENTER_VERTICAL,
-            )
-            ZoneId.RIGHT_EDGE -> Triple(
-                thicknessPx + geometry.navRight,
-                (geometry.height * zone.lengthPercent / 100).coerceAtLeast(1),
-                Gravity.END or Gravity.CENTER_VERTICAL,
-            )
+        // The window geometry is computed once for all zones by the shared pure helper
+        // [computeGestureZoneLayout] — the same logic the layout unit tests exercise — so the
+        // corner-precedence invariant (bottom band has priority; side zones sit immediately
+        // above it with no overlap and no gap) is guaranteed by construction here, not by a
+        // second copy of the math. See computeGestureZoneLayout for the invariant formula.
+        val layout: ZoneLayout = computeGestureZoneLayout(settings, geometry).getValue(zone.id)
+        val gravity = when (zone.id) {
+            ZoneId.BOTTOM -> Gravity.BOTTOM or Gravity.CENTER_HORIZONTAL
+            ZoneId.LEFT_EDGE -> Gravity.START or Gravity.BOTTOM
+            ZoneId.RIGHT_EDGE -> Gravity.END or Gravity.BOTTOM
         }
         return WindowManager.LayoutParams(
-            widthPx,
-            heightPx,
-            WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
+            layout.widthPx,
+            layout.heightPx,
+            WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY,
             WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or
                 WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL or
                 WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS,
             PixelFormat.TRANSLUCENT,
         ).apply {
             this.gravity = gravity
+            // With BOTTOM gravity, a positive y offset moves the window upward — clear of the
+            // reserved bottom gesture band so the side and bottom zones don't stack in the
+            // corner. FLAG_LAYOUT_NO_LIMITS lets the offset place it above the band precisely.
+            y = layout.yOffset
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
                 fitInsetsTypes = 0
             }
         }
     }
 
-    private fun startInForeground() {
-        val nm = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && nm.getNotificationChannel(CHANNEL_ID) == null) {
-            val channel = NotificationChannel(
-                CHANNEL_ID,
-                getString(R.string.notification_channel_name),
-                NotificationManager.IMPORTANCE_MIN,
-            ).apply {
-                description = getString(R.string.notification_channel_description)
-                setShowBadge(false)
-            }
-            nm.createNotificationChannel(channel)
-        }
-        val openApp = PendingIntent.getActivity(
-            this,
-            0,
-            Intent(this, MainActivity::class.java),
-            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
-        )
-        val notification: Notification = NotificationCompat.Builder(this, CHANNEL_ID)
-            .setSmallIcon(android.R.drawable.ic_menu_compass)
-            .setContentTitle(getString(R.string.notification_running_title))
-            .setContentText(getString(R.string.notification_running_text))
-            .setOngoing(true)
-            .setPriority(NotificationCompat.PRIORITY_MIN)
-            .setContentIntent(openApp)
-            .build()
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            startForeground(
-                NOTIFICATION_ID,
-                notification,
-                ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE,
-            )
-        } else {
-            startForeground(NOTIFICATION_ID, notification)
-        }
-    }
-
     companion object {
-        private const val TAG = "EdgeOverlayService"
-        private const val CHANNEL_ID = "edge_gesture"
-        private const val NOTIFICATION_ID = 1001
+        private const val TAG = "EdgeOverlayController"
         private const val SIDE_MIN_DISTANCE_DP = 24f
         private const val BOTTOM_MIN_DISTANCE_DP = 10f
         private const val MAX_REPLAY_MS = 3_000L
@@ -584,26 +542,22 @@ class EdgeOverlayService : LifecycleService() {
         // Set true to tint the gesture zones so their touch areas are visible while testing.
         private const val DEBUG_SHOW_ZONES = false
         private const val ZONE_DEBUG_COLOR = 0x552196F3 // translucent blue
-        const val ACTION_START = "com.ogesture.action.START_OVERLAY"
-
-        /**
-         * True between onCreate and onDestroy. Read by the accessibility service watchdog to
-         * revive this service if the system (e.g. Samsung battery management) killed it out from
-         * under us without going through the master switch.
-         */
-        @Volatile
-        var isRunning: Boolean = false
-            private set
+    }
+}
 
-        fun start(context: Context) {
-            val intent = Intent(context, EdgeOverlayService::class.java).setAction(ACTION_START)
-            androidx.core.content.ContextCompat.startForegroundService(context, intent)
-        }
+/**
+ * Abstraction over the gesture-dispatch capabilities the controller needs from its owning
+ * accessibility service: firing navigation actions and re-injecting unused touches. Keeps
+ * the controller decoupled from the concrete service (and testable).
+ */
+interface GestureDispatcher {
+    /** Fires a navigation action (Back/Home/Recents). */
+    fun trigger(action: com.ogesture.data.GestureAction)
 
-        fun stop(context: Context) {
-            // stopService (not startService with a stop action) so a stop request arriving
-            // after the service has already stopped itself cannot re-create it.
-            context.stopService(Intent(context, EdgeOverlayService::class.java))
-        }
-    }
+    /**
+     * Re-injects a touch the overlay consumed but didn't use, so it reaches the UI
+     * underneath. Returns false if the gesture could not be dispatched; [onDone] always
+     * runs otherwise, with whether the gesture played to completion.
+     */
+    fun replay(gesture: GestureDescription, onDone: (completed: Boolean) -> Unit): Boolean
 }
diff --git a/app/src/main/java/com/ogesture/ui/CompatibilityScreen.kt b/app/src/main/java/com/ogesture/ui/CompatibilityScreen.kt
index 39b48e7..e8445df 100644
--- a/app/src/main/java/com/ogesture/ui/CompatibilityScreen.kt
+++ b/app/src/main/java/com/ogesture/ui/CompatibilityScreen.kt
@@ -132,8 +132,6 @@ fun CompatibilityScreen(onBack: () -> Unit, viewModel: MainViewModel = viewModel
                 }
             }
 
-            CompatSectionHeader(stringResource(R.string.compat_settings_header))
-            InfoCard(stringResource(R.string.compat_settings_note))
         }
     }
 }
diff --git a/app/src/main/java/com/ogesture/ui/GestureAreasScreen.kt b/app/src/main/java/com/ogesture/ui/GestureAreasScreen.kt
new file mode 100644
index 0000000..2e0f77c
--- /dev/null
+++ b/app/src/main/java/com/ogesture/ui/GestureAreasScreen.kt
@@ -0,0 +1,294 @@
+package com.ogesture.ui
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.ogesture.R
+import com.ogesture.data.GestureZoneSettings
+
+/**
+ * Dedicated settings screen for the configurable gesture-zone geometry. Reached from the main
+ * dashboard via [GestureAreasEntryCard]. Mirrors [CompatibilityScreen]'s structure: a
+ * Material 3 [Scaffold] with a [TopAppBar] (back arrow + "Gesture areas" title) over a
+ * scrollable column that opens with a short info card and then holds the detailed settings card.
+ *
+ * The four sliders are moved here unchanged from the main screen: local drag state while
+ * dragging, persistence on `onValueChangeFinished`, immediate application via the controller
+ * (which observes the same DataStore flow). No Save button. Defaults/ranges/steps and the
+ * underlying [GestureZoneSettings] / `computeGestureZoneLayout` are untouched.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun GestureAreasScreen(onBack: () -> Unit, viewModel: MainViewModel = viewModel()) {
+    BackHandler { onBack() }
+    Scaffold(
+        modifier = Modifier.fillMaxSize(),
+        topBar = { GestureAreasTopBar(onBack) },
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(innerPadding)
+                .verticalScroll(rememberScrollState())
+                .padding(horizontal = 16.dp)
+                .padding(bottom = 24.dp),
+        ) {
+            Spacer(modifier = Modifier.height(8.dp))
+            InfoCard(stringResource(R.string.gesture_areas_subtitle))
+            Spacer(modifier = Modifier.height(8.dp))
+            GestureAreasCard(viewModel)
+        }
+    }
+}
+
+/** Row on the main screen that opens [GestureAreasScreen]. Mirrors [CompatEntryCard]. */
+@Composable
+fun GestureAreasEntryCard(onClick: () -> Unit) {
+    Surface(
+        onClick = onClick,
+        shape = MaterialTheme.shapes.extraLarge,
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Row(
+            modifier = Modifier.padding(horizontal = 20.dp, vertical = 16.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            Text(
+                text = stringResource(R.string.gesture_areas_entry_desc),
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.weight(1f),
+            )
+            Text(
+                text = "›",
+                style = MaterialTheme.typography.titleLarge,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun GestureAreasTopBar(onBack: () -> Unit) {
+    TopAppBar(
+        title = { Text(stringResource(R.string.gesture_areas_screen_title)) },
+        navigationIcon = {
+            IconButton(onClick = onBack) {
+                Icon(
+                    imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                    contentDescription = null,
+                )
+            }
+        },
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = MaterialTheme.colorScheme.surface,
+        ),
+    )
+}
+
+@Composable
+private fun GestureAreasCard(viewModel: MainViewModel) {
+    val settings by viewModel.gestureZoneSettings.collectAsState()
+
+    Card(
+        shape = MaterialTheme.shapes.extraLarge,
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceContainerHigh,
+        ),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp),
+    ) {
+        Column(modifier = Modifier.padding(vertical = 8.dp)) {
+            AreaSectionHeader(stringResource(R.string.areas_back_header))
+            PercentSlider(
+                label = stringResource(R.string.areas_back_height_label),
+                hint = stringResource(R.string.areas_back_height_hint),
+                value = settings.backActivationHeightPercent,
+                onValueChangeFinished = { viewModel.setBackActivationHeight(it) },
+            )
+            SensitivitySlider(
+                label = stringResource(R.string.areas_back_sensitivity_label),
+                hint = stringResource(R.string.areas_back_sensitivity_hint),
+                baseDp = GestureZoneSettings.BASE_BACK_THICKNESS_DP,
+                value = settings.backEdgeSensitivity,
+                onValueChangeFinished = { viewModel.setBackEdgeSensitivity(it) },
+            )
+
+            HorizontalDivider(
+                modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp),
+                color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f),
+            )
+
+            AreaSectionHeader(stringResource(R.string.areas_bottom_header))
+            Text(
+                text = stringResource(R.string.areas_bottom_shared_note),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(horizontal = 16.dp),
+            )
+            PercentSlider(
+                label = stringResource(R.string.areas_bottom_width_label),
+                hint = stringResource(R.string.areas_bottom_width_hint),
+                value = settings.bottomActivationWidthPercent,
+                onValueChangeFinished = { viewModel.setBottomActivationWidth(it) },
+            )
+            SensitivitySlider(
+                label = stringResource(R.string.areas_bottom_sensitivity_label),
+                hint = stringResource(R.string.areas_bottom_sensitivity_hint),
+                baseDp = GestureZoneSettings.BASE_BOTTOM_THICKNESS_DP,
+                value = settings.bottomEdgeSensitivity,
+                onValueChangeFinished = { viewModel.setBottomEdgeSensitivity(it) },
+            )
+        }
+    }
+}
+
+@Composable
+private fun AreaSectionHeader(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.titleSmall.copy(fontWeight = FontWeight.SemiBold),
+        color = MaterialTheme.colorScheme.onSurface,
+        modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp),
+    )
+}
+
+@Composable
+private fun PercentSlider(
+    label: String,
+    hint: String,
+    value: Int,
+    onValueChangeFinished: (Int) -> Unit,
+) {
+    // Local drag state snapped to the percentage step; persisted only when the thumb lifts.
+    var drag by remember(value) { mutableFloatStateOf(value.toFloat()) }
+    Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp)) {
+        Row(verticalAlignment = Alignment.CenterVertically) {
+            Text(
+                text = label,
+                style = MaterialTheme.typography.bodyMedium,
+                modifier = Modifier.weight(1f),
+            )
+            Text(
+                text = stringResource(R.string.areas_percent_value, drag.toInt()),
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+        Slider(
+            value = drag,
+            onValueChange = { drag = it },
+            onValueChangeFinished = {
+                // Round (don't truncate) to the nearest int before snapping to the 10% step,
+                // so a thumb released near 20% doesn't fall back to 10% via Float.toInt().
+                val snapped = GestureZoneSettings.clampPercent(Math.round(drag))
+                drag = snapped.toFloat()
+                onValueChangeFinished(snapped)
+            },
+            valueRange = GestureZoneSettings.PERCENT_MIN.toFloat()..GestureZoneSettings.PERCENT_MAX.toFloat(),
+            steps = (GestureZoneSettings.PERCENT_MAX - GestureZoneSettings.PERCENT_MIN) / GestureZoneSettings.PERCENT_STEP - 1,
+        )
+        Text(
+            text = hint,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+    }
+}
+
+@Composable
+private fun SensitivitySlider(
+    label: String,
+    hint: String,
+    baseDp: Int,
+    value: Float,
+    onValueChangeFinished: (Float) -> Unit,
+) {
+    var drag by remember(value) { mutableFloatStateOf(value) }
+    Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp)) {
+        Row(verticalAlignment = Alignment.CenterVertically) {
+            Text(
+                text = label,
+                style = MaterialTheme.typography.bodyMedium,
+                modifier = Modifier.weight(1f),
+            )
+            val effectiveDp = (baseDp * drag).toInt().coerceAtLeast(1)
+            Text(
+                text = stringResource(R.string.areas_sensitivity_value, drag, effectiveDp),
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+        Slider(
+            value = drag,
+            onValueChange = { drag = it },
+            onValueChangeFinished = {
+                val snapped = GestureZoneSettings.clampSensitivity(drag)
+                drag = snapped
+                onValueChangeFinished(snapped)
+            },
+            valueRange = GestureZoneSettings.SENSITIVITY_MIN..GestureZoneSettings.SENSITIVITY_MAX,
+            steps = ((GestureZoneSettings.SENSITIVITY_MAX - GestureZoneSettings.SENSITIVITY_MIN) / GestureZoneSettings.SENSITIVITY_STEP).toInt() - 1,
+        )
+        Text(
+            text = hint,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+    }
+}
+
+@Composable
+private fun InfoCard(text: String) {
+    Card(
+        shape = MaterialTheme.shapes.extraLarge,
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceContainerHigh,
+        ),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp),
+    ) {
+        Text(
+            text = text,
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.padding(horizontal = 20.dp, vertical = 16.dp),
+        )
+    }
+}
diff --git a/app/src/main/java/com/ogesture/ui/MainViewModel.kt b/app/src/main/java/com/ogesture/ui/MainViewModel.kt
index 6717aab..5e8d1c2 100644
--- a/app/src/main/java/com/ogesture/ui/MainViewModel.kt
+++ b/app/src/main/java/com/ogesture/ui/MainViewModel.kt
@@ -3,8 +3,8 @@ package com.ogesture.ui
 import android.app.Application
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.viewModelScope
+import com.ogesture.data.GestureZoneSettings
 import com.ogesture.data.SettingsRepository
-import com.ogesture.service.EdgeOverlayService
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.stateIn
@@ -22,12 +22,40 @@ class MainViewModel(app: Application) : AndroidViewModel(app) {
 
     fun setMasterEnabled(enabled: Boolean) {
         viewModelScope.launch {
+            // The accessibility service observes this flow and attaches/detaches the gesture
+            // zones itself, so toggling the switch is just a datastore write — no foreground
+            // service to start or stop anymore.
             repo.setMasterEnabled(enabled)
-            val ctx = getApplication<Application>()
-            if (enabled) EdgeOverlayService.start(ctx) else EdgeOverlayService.stop(ctx)
         }
     }
 
+    /**
+     * The user-tunable gesture-zone geometry. The controller observes the same repository
+     * flow and rebuilds the overlay zones when this changes; the ViewModel exposes it for
+     * the settings UI. The repository is the source of truth for valid (clamped) values.
+     */
+    val gestureZoneSettings: StateFlow<GestureZoneSettings> = repo.gestureZoneSettings.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000L),
+        initialValue = GestureZoneSettings.DEFAULT,
+    )
+
+    fun setBackActivationHeight(percent: Int) {
+        viewModelScope.launch { repo.setBackActivationHeight(percent) }
+    }
+
+    fun setBottomActivationWidth(percent: Int) {
+        viewModelScope.launch { repo.setBottomActivationWidth(percent) }
+    }
+
+    fun setBackEdgeSensitivity(multiplier: Float) {
+        viewModelScope.launch { repo.setBackEdgeSensitivity(multiplier) }
+    }
+
+    fun setBottomEdgeSensitivity(multiplier: Float) {
+        viewModelScope.launch { repo.setBottomEdgeSensitivity(multiplier) }
+    }
+
     val excludedApps: StateFlow<Set<String>> = repo.excludedApps.stateIn(
         scope = viewModelScope,
         started = SharingStarted.WhileSubscribed(5_000L),
diff --git a/app/src/main/java/com/ogesture/ui/PermissionsCard.kt b/app/src/main/java/com/ogesture/ui/PermissionsCard.kt
index a7f76aa..4dbc40b 100644
--- a/app/src/main/java/com/ogesture/ui/PermissionsCard.kt
+++ b/app/src/main/java/com/ogesture/ui/PermissionsCard.kt
@@ -32,15 +32,13 @@ import com.ogesture.ui.theme.ExtendedTheme
 enum class AccessibilityStatus { NOT_GRANTED, NEEDS_REBIND, BOUND }
 
 /**
- * Single card listing everything the gestures need to run: the two permissions
- * plus unrestricted battery usage.
+ * Single card listing everything the gestures need to run: the accessibility service
+ * (which owns the gesture-zone overlay windows) plus unrestricted battery usage.
  */
 @Composable
 fun SetupCard(
-    overlayGranted: Boolean,
     accessibilityStatus: AccessibilityStatus,
     batteryUnrestricted: Boolean,
-    onRequestOverlay: () -> Unit,
     onRequestAccessibility: () -> Unit,
     onRequestUnrestricted: () -> Unit,
     modifier: Modifier = Modifier,
@@ -56,21 +54,6 @@ fun SetupCard(
         Column(
             modifier = Modifier.padding(vertical = 8.dp),
         ) {
-            RequirementRow(
-                label = stringResource(R.string.permission_overlay),
-                state = if (overlayGranted) RowState.OK else RowState.MISSING,
-                subtitle = if (overlayGranted) {
-                    stringResource(R.string.permission_granted)
-                } else {
-                    stringResource(R.string.permission_not_granted)
-                },
-                actionLabel = stringResource(R.string.permission_grant),
-                onAction = onRequestOverlay,
-            )
-            HorizontalDivider(
-                modifier = Modifier.padding(horizontal = 16.dp),
-                color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f),
-            )
             val (state, subtitle, actionLabel) = when (accessibilityStatus) {
                 AccessibilityStatus.BOUND -> Triple(
                     RowState.OK,
diff --git a/app/src/main/java/com/ogesture/ui/overlay/BackIndicator.kt b/app/src/main/java/com/ogesture/ui/overlay/BackIndicator.kt
index 09eeec1..b1d3bf1 100644
--- a/app/src/main/java/com/ogesture/ui/overlay/BackIndicator.kt
+++ b/app/src/main/java/com/ogesture/ui/overlay/BackIndicator.kt
@@ -18,7 +18,9 @@ import android.widget.FrameLayout
  * the gesture arms, and retracts (or fades out) when the finger lifts.
  *
  * Lives in its own non-touchable full-height overlay window so it can be drawn without
- * affecting the touch zones.
+ * affecting the touch zones. The window type is supplied by the owner so the same
+ * indicator can be added as an accessibility overlay (trusted, works on secure screens)
+ * or — for any future caller — an application overlay.
  */
 class BackIndicator(
     context: Context,
@@ -31,6 +33,12 @@ class BackIndicator(
      * would slide out underneath the opaque bar and never be seen.
      */
     private val edgeOffsetPx: Int = 0,
+    /**
+     * WindowManager layout type for the indicator window. Defaults to an accessibility
+     * overlay so the indicator survives on secure system screens (Settings, SubSettings)
+     * the way the touch zones do.
+     */
+    private val windowType: Int = WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY,
 ) : OverlayIndicator {
     private val density = context.resources.displayMetrics.density
     private val pillSizePx = (PILL_SIZE_DP * density)
@@ -58,7 +66,7 @@ class BackIndicator(
         val params = WindowManager.LayoutParams(
             (pillSizePx + peekPx).toInt(),
             WindowManager.LayoutParams.MATCH_PARENT,
-            WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
+            windowType,
             WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or
                 WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE or
                 WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL or
diff --git a/app/src/main/java/com/ogesture/ui/overlay/HomeIndicator.kt b/app/src/main/java/com/ogesture/ui/overlay/HomeIndicator.kt
index cbb05e4..b6088ee 100644
--- a/app/src/main/java/com/ogesture/ui/overlay/HomeIndicator.kt
+++ b/app/src/main/java/com/ogesture/ui/overlay/HomeIndicator.kt
@@ -21,10 +21,25 @@ import android.widget.FrameLayout
 class HomeIndicator(
     context: Context,
     private val windowManager: WindowManager,
+    /**
+     * Resolved visual width of the home handle in *display pixels*. This is the SAME resolved
+     * width the production geometry helper ([com.ogesture.data.computeGestureZoneLayout])
+     * produces for the bottom gesture touch zone, so the visible bar matches the actual
+     * horizontal activation region 1:1 (10% → central 10% of the display, … 100% → full
+     * configured bottom activation width). Only the horizontal width follows the activation
+     * width; the invisible touch depth (bottom edge sensitivity) does NOT affect the bar —
+     * it only widens the touch zone vertically.
+     */
+    private val barWidthPx: Int = (BAR_WIDTH_DP * context.resources.displayMetrics.density).toInt(),
+    /**
+     * WindowManager layout type for the indicator window. Defaults to an accessibility
+     * overlay so the indicator survives on secure system screens (Settings, SubSettings)
+     * the way the touch zones do.
+     */
+    private val windowType: Int = WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY,
 ) : OverlayIndicator {
 
     private val density = context.resources.displayMetrics.density
-    private val barWidthPx = (BAR_WIDTH_DP * density).toInt()
     private val barHeightPx = BAR_HEIGHT_DP * density
     private val radiusPx = ROUND_DP * density
     private val revealPx = REVEAL_DP * density
@@ -48,7 +63,7 @@ class HomeIndicator(
         val params = WindowManager.LayoutParams(
             barWidthPx,
             (barHeightPx + revealPx).toInt(),
-            WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
+            windowType,
             WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or
                 WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE or
                 WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL or
@@ -108,7 +123,8 @@ class HomeIndicator(
     }
 
     private companion object {
-        const val BAR_WIDTH_DP = 108f
+        // Default handle width; matches the pre-configurability look at 80% activation width.
+        const val BAR_WIDTH_DP = 108
         const val BAR_HEIGHT_DP = 4f
         const val ROUND_DP = 1.5f
         const val REVEAL_DP = 4f
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index d6c99e3..3d3a449 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -4,18 +4,11 @@
     <string name="accessibility_service_label">Ogesture</string>
     <string name="accessibility_service_description">Performs Back, Home, and Recents when an edge zone is swiped.</string>
 
-    <string name="notification_channel_name">Edge Gestures</string>
-    <string name="notification_channel_description">Keeps the edge swipe overlays alive in the background.</string>
-    <string name="notification_running_title">Edge Gestures running</string>
-    <string name="notification_running_text">Swipe up from a configured edge zone to trigger an action.</string>
-
     <string name="setup_title">Setup</string>
-    <string name="permission_overlay">Display over other apps</string>
     <string name="permission_accessibility">Accessibility service</string>
     <string name="permission_granted">Granted</string>
     <string name="permission_not_granted">Not granted</string>
     <string name="permission_needs_rebind">Enabled in Settings, but Android lost the binding after the last app update. Open Accessibility settings, toggle Ogesture off and back on.</string>
-    <string name="permission_grant">Grant</string>
     <string name="permission_open_settings">Open settings</string>
 
     <string name="a11y_consent_title">Before you turn on Accessibility</string>
@@ -34,7 +27,6 @@
     <string name="master_switch_subtitle_ready">All set — flip the switch to start.</string>
     <string name="master_switch_subtitle_blocked">Grant everything above to enable.</string>
 
-    <string name="toast_gestures_off_overlay">Edge gestures turned off: allow \"Display over other apps\".</string>
     <string name="toast_gestures_off_accessibility">Edge gestures turned off: the accessibility service isn\'t running.</string>
     <string name="toast_gestures_off_battery">Edge gestures turned off: allow unrestricted battery usage.</string>
     <string name="toast_gestures_off_generic">Edge gestures turned off: they can\'t run right now.</string>
@@ -54,6 +46,24 @@
     <string name="gesture_back_label">Back</string>
     <string name="gesture_back_desc">Swipe inward from the left or right edge.</string>
 
+    <string name="gesture_areas_title">Gesture areas</string>
+    <string name="gesture_areas_screen_title">Gesture areas</string>
+    <string name="gesture_areas_entry_desc">Adjust where Back, Home and Recents gestures can start.</string>
+    <string name="gesture_areas_subtitle">Adjust where each gesture can start. Changes apply immediately.</string>
+    <string name="areas_back_header">Back</string>
+    <string name="areas_back_height_label">Activation height</string>
+    <string name="areas_back_height_hint">How much of the side edge can start Back, measured upward from the bottom.</string>
+    <string name="areas_back_sensitivity_label">Edge sensitivity</string>
+    <string name="areas_back_sensitivity_hint">How far inward from the side edge a touch may start.</string>
+    <string name="areas_bottom_header">Home &amp; Recents</string>
+    <string name="areas_bottom_shared_note">Home and Recents share the same bottom gesture region.</string>
+    <string name="areas_bottom_width_label">Activation width</string>
+    <string name="areas_bottom_width_hint">Width of the bottom area that can start Home or Recents.</string>
+    <string name="areas_bottom_sensitivity_label">Edge sensitivity</string>
+    <string name="areas_bottom_sensitivity_hint">How far above the bottom edge a touch may start.</string>
+    <string name="areas_percent_value">%1$d%%</string>
+    <string name="areas_sensitivity_value">%1$.2f× (%2$d dp)</string>
+
     <string name="compat_title">App compatibility</string>
     <string name="compat_screen_title">App compatibility</string>
     <string name="compat_entry_desc">Turn Ogesture off inside apps that ignore gesture taps.</string>
@@ -63,8 +73,6 @@
     <string name="compat_add_app">Add app</string>
     <string name="compat_remove_app">Turn gestures back on for %1$s</string>
     <string name="compat_picker_title">Add app</string>
-    <string name="compat_settings_header">System screens</string>
-    <string name="compat_settings_note">Gestures also won\'t work on your phone\'s Settings app: Android hides overlay apps like Ogesture on Settings and other secure system screens. Use your phone\'s own navigation there.</string>
 
     <string name="remember_title">Privacy and security</string>
     <string name="remember_open_source_prefix">This app is free,</string>
@@ -72,7 +80,7 @@
     <string name="remember_open_source_suffix">, and collects no data.</string>
     <string name="remember_read_the_full_prefix">Read the full</string>
     <string name="remember_privacy_policy_suffix">privacy policy.</string>
-    <string name="remember_restricted_screens">Android\'s security policy blocks gestures on certain screens, such as your phone\'s Settings.</string>
+    <string name="remember_on_device">Everything runs locally on your device — no internet, no ads, no analytics. Settings stay on this phone and are deleted when you uninstall the app.</string>
 
     <string name="footer_built_with">Built with</string>
     <string name="footer_by_team">by team</string>
diff --git a/app/src/test/java/com/ogesture/GestureZoneLayoutTest.kt b/app/src/test/java/com/ogesture/GestureZoneLayoutTest.kt
new file mode 100644
index 0000000..a0d212c
--- /dev/null
+++ b/app/src/test/java/com/ogesture/GestureZoneLayoutTest.kt
@@ -0,0 +1,447 @@
+package com.ogesture
+
+import com.ogesture.data.GESTURE_ZONES
+import com.ogesture.data.GestureAction
+import com.ogesture.data.GestureZoneSettings
+import com.ogesture.data.ScreenGeometry
+import com.ogesture.data.SwipeDirection
+import com.ogesture.data.ZoneConfig
+import com.ogesture.data.ZoneId
+import com.ogesture.data.buildGestureZones
+import com.ogesture.data.computeGestureZoneLayout
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Regression guards for the gesture-zone layout and the action/direction mapping that the
+ * accessibility-overlay migration must preserve, plus the configurable-zone geometry
+ * (activation height/width, edge sensitivity), the corner-overlap precedence, and the Home
+ * handle width mapping.
+ *
+ * The overlap/precedence tests exercise the SAME production geometry helper
+ * ([computeGestureZoneLayout]) that [com.ogesture.service.EdgeOverlayController] uses, so a
+ * divergence between the controller's window placement and the intended invariant would fail
+ * here rather than being hidden by a second copy of the math.
+ */
+class GestureZoneLayoutTest {
+
+    @Test
+    fun gestureZones_containBottomLeftRight() {
+        val ids = GESTURE_ZONES.map { it.id }
+        assertTrue("bottom zone must exist", ZoneId.BOTTOM in ids)
+        assertTrue("left edge zone must exist", ZoneId.LEFT_EDGE in ids)
+        assertTrue("right edge zone must exist", ZoneId.RIGHT_EDGE in ids)
+        assertEquals(3, GESTURE_ZONES.size)
+    }
+
+    @Test
+    fun bottomZone_mapsSwipeUpToHomeWithRecentsHold() {
+        val bottom = GESTURE_ZONES.first { it.id == ZoneId.BOTTOM }
+        assertEquals(GestureAction.HOME, bottom.action)
+        assertEquals(GestureAction.RECENTS, bottom.longAction)
+        assertEquals(SwipeDirection.UP, bottom.swipeDirection)
+    }
+
+    @Test
+    fun leftEdge_mapsSwipeRightToBackWithNoLongAction() {
+        val left = GESTURE_ZONES.first { it.id == ZoneId.LEFT_EDGE }
+        assertEquals(GestureAction.BACK, left.action)
+        assertNull("left edge has no long action", left.longAction)
+        assertEquals(SwipeDirection.RIGHT, left.swipeDirection)
+    }
+
+    @Test
+    fun rightEdge_mapsSwipeLeftToBackWithNoLongAction() {
+        val right = GESTURE_ZONES.first { it.id == ZoneId.RIGHT_EDGE }
+        assertEquals(GestureAction.BACK, right.action)
+        assertNull("right edge has no long action", right.longAction)
+        assertEquals(SwipeDirection.LEFT, right.swipeDirection)
+    }
+
+    @Test
+    fun everyZone_hasPositiveThicknessAndLength() {
+        for (zone in GESTURE_ZONES) {
+            assertTrue("${zone.id} thickness must be positive", zone.thicknessDp > 0)
+            assertTrue("${zone.id} length must be positive", zone.lengthPercent > 0)
+        }
+    }
+
+    @Test
+    fun swipeDirection_isConsistentWithZoneId() {
+        // The recognizer relies on this mapping; flipping it would invert every gesture.
+        assertEquals(SwipeDirection.UP, ZoneConfig(ZoneId.BOTTOM, GestureAction.HOME, null, 80, 12).swipeDirection)
+        assertEquals(SwipeDirection.RIGHT, ZoneConfig(ZoneId.LEFT_EDGE, GestureAction.BACK, null, 80, 16).swipeDirection)
+        assertEquals(SwipeDirection.LEFT, ZoneConfig(ZoneId.RIGHT_EDGE, GestureAction.BACK, null, 80, 16).swipeDirection)
+    }
+
+    @Test
+    fun gestureActions_coverBackHomeRecents() {
+        // The accessibility service dispatches exactly these three; adding a fourth without
+        // wiring it through performGlobalAction would be a silent no-op.
+        val actions = GestureAction.values().toSet()
+        assertTrue(GestureAction.BACK in actions)
+        assertTrue(GestureAction.HOME in actions)
+        assertTrue(GestureAction.RECENTS in actions)
+    }
+
+    // --- Configurable gesture-zone geometry -----------------------------------------
+
+    @Test
+    fun defaults_matchExpectedGeometry() {
+        val s = GestureZoneSettings.DEFAULT
+        assertEquals(80, s.backActivationHeightPercent)
+        assertEquals(80, s.bottomActivationWidthPercent)
+        assertEquals(1.0f, s.backEdgeSensitivity, 0.0001f)
+        assertEquals(1.0f, s.bottomEdgeSensitivity, 0.0001f)
+        // 1× sensitivity → base thickness unchanged.
+        assertEquals(16, s.backThicknessDp)
+        assertEquals(12, s.bottomThicknessDp)
+    }
+
+    @Test
+    fun defaultZones_matchLegacyFixedLayout() {
+        // The default configuration must reproduce the pre-configurability layout exactly.
+        val zones = buildGestureZones(GestureZoneSettings.DEFAULT)
+        assertEquals(GESTURE_ZONES, zones)
+    }
+
+    @Test
+    fun backHeight_percentagesBuildCorrectLength() {
+        for (pct in listOf(10, 50, 100)) {
+            val s = GestureZoneSettings.DEFAULT.copy(backActivationHeightPercent = pct)
+            val left = buildGestureZones(s).first { it.id == ZoneId.LEFT_EDGE }
+            val right = buildGestureZones(s).first { it.id == ZoneId.RIGHT_EDGE }
+            assertEquals("left length%", pct, left.lengthPercent)
+            assertEquals("right length%", pct, right.lengthPercent)
+            // One setting drives both sides.
+            assertEquals(left.lengthPercent, right.lengthPercent)
+        }
+    }
+
+    @Test
+    fun bottomWidth_percentagesBuildCorrectLength() {
+        for (pct in listOf(10, 50, 100)) {
+            val s = GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = pct)
+            val bottom = buildGestureZones(s).first { it.id == ZoneId.BOTTOM }
+            assertEquals(pct, bottom.lengthPercent)
+        }
+    }
+
+    @Test
+    fun backSensitivity_multipliesBaseThickness() {
+        assertEquals(8, GestureZoneSettings.DEFAULT.copy(backEdgeSensitivity = 0.5f).backThicknessDp)
+        assertEquals(16, GestureZoneSettings.DEFAULT.copy(backEdgeSensitivity = 1.0f).backThicknessDp)
+        assertEquals(32, GestureZoneSettings.DEFAULT.copy(backEdgeSensitivity = 2.0f).backThicknessDp)
+        assertEquals(64, GestureZoneSettings.DEFAULT.copy(backEdgeSensitivity = 4.0f).backThicknessDp)
+    }
+
+    @Test
+    fun bottomSensitivity_multipliesBaseThickness() {
+        assertEquals(6, GestureZoneSettings.DEFAULT.copy(bottomEdgeSensitivity = 0.5f).bottomThicknessDp)
+        assertEquals(12, GestureZoneSettings.DEFAULT.copy(bottomEdgeSensitivity = 1.0f).bottomThicknessDp)
+        assertEquals(24, GestureZoneSettings.DEFAULT.copy(bottomEdgeSensitivity = 2.0f).bottomThicknessDp)
+        assertEquals(48, GestureZoneSettings.DEFAULT.copy(bottomEdgeSensitivity = 4.0f).bottomThicknessDp)
+    }
+
+    @Test
+    fun sensitivity_doesNotChangeSwipeDistanceThreshold() {
+        // The controller's SIDE_MIN_DISTANCE_DP / BOTTOM_MIN_DISTANCE_DP are not part of
+        // GestureZoneSettings and must not be derivable from it. We assert that the settings
+        // record exposes only thickness/length, never a swipe-distance field.
+        val s = GestureZoneSettings.DEFAULT.copy(backEdgeSensitivity = 4.0f, bottomEdgeSensitivity = 4.0f)
+        // No field named *minDistance* / *swipeDistance* should exist on the model.
+        assertTrue(s.toString().lowercase().let { !it.contains("mindistance") && !it.contains("swipedistance") })
+    }
+
+    @Test
+    fun clampSensitivity_clampsAndStepsOutOfRangeValues() {
+        assertEquals(0.5f, GestureZoneSettings.clampSensitivity(0.1f), 0.0001f)
+        assertEquals(0.5f, GestureZoneSettings.clampSensitivity(-1f), 0.0001f)
+        assertEquals(1.0f, GestureZoneSettings.clampSensitivity(1.0f), 0.0001f)
+        assertEquals(1.25f, GestureZoneSettings.clampSensitivity(1.24f), 0.0001f) // rounds to nearest 0.25 step
+        assertEquals(4.0f, GestureZoneSettings.clampSensitivity(5f), 0.0001f)
+    }
+
+    @Test
+    fun corruptedSettings_neverProduceZeroOrNegativeThickness() {
+        // A clamped sensitivity is always >= 0.5 and base >= 12, so thickness >= 1.
+        for (v in listOf(-100f, 0f, 0.001f, 1000f)) {
+            val clamped = GestureZoneSettings.clampSensitivity(v)
+            assertTrue(clamped >= GestureZoneSettings.SENSITIVITY_MIN)
+        }
+        val s = GestureZoneSettings.DEFAULT.copy(
+            backEdgeSensitivity = GestureZoneSettings.clampSensitivity(0f),
+            bottomEdgeSensitivity = GestureZoneSettings.clampSensitivity(0f),
+        )
+        assertTrue("back thickness must be positive", s.backThicknessDp >= 1)
+        assertTrue("bottom thickness must be positive", s.bottomThicknessDp >= 1)
+    }
+
+    @Test
+    fun geometryChanges_neverAlterActionOrDirectionMapping() {
+        for (height in listOf(10, 50, 100)) {
+            for (width in listOf(10, 50, 100)) {
+                for (backSens in listOf(0.5f, 1.0f, 4.0f)) {
+                    for (bottomSens in listOf(0.5f, 1.0f, 4.0f)) {
+                        val s = GestureZoneSettings(
+                            backActivationHeightPercent = height,
+                            bottomActivationWidthPercent = width,
+                            backEdgeSensitivity = backSens,
+                            bottomEdgeSensitivity = bottomSens,
+                        )
+                        val zones = buildGestureZones(s)
+                        val bottom = zones.first { it.id == ZoneId.BOTTOM }
+                        assertEquals(GestureAction.HOME, bottom.action)
+                        assertEquals(GestureAction.RECENTS, bottom.longAction)
+                        assertEquals(SwipeDirection.UP, bottom.swipeDirection)
+                        for (side in listOf(ZoneId.LEFT_EDGE, ZoneId.RIGHT_EDGE)) {
+                            val z = zones.first { it.id == side }
+                            assertEquals(GestureAction.BACK, z.action)
+                            assertNull(z.longAction)
+                            assertEquals(if (side == ZoneId.LEFT_EDGE) SwipeDirection.RIGHT else SwipeDirection.LEFT, z.swipeDirection)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // --- Corner-overlap precedence (using the PRODUCTION geometry helper) -----------
+    //
+    // These tests exercise computeGestureZoneLayout — the exact function the controller
+    // calls to place its windows — so they catch any divergence between production geometry
+    // and the intended invariant. The original bug (reserved band using the base 12dp constant
+    // instead of the sensitivity-scaled effective bottom depth) would have failed here.
+
+    @Test
+    fun computeGestureZoneLayout_bottomBand_usesEffectiveBottomDepthNotBaseConstant() {
+        // The core invariant the original bug violated: the reserved bottom band must be the
+        // effective (sensitivity-scaled) bottom touch depth + navBottom, never the base 12dp.
+        val geometry = ScreenGeometry(width = 1080, height = 2400, density = 3.0f, navLeft = 0, navRight = 0, navBottom = 0)
+        for (bottomSens in listOf(0.5f, 1.0f, 2.0f, 4.0f)) {
+            val s = GestureZoneSettings.DEFAULT.copy(bottomEdgeSensitivity = bottomSens)
+            val layout = computeGestureZoneLayout(s, geometry)
+            val bottom = layout.getValue(ZoneId.BOTTOM)
+            val expectedDepthPx = (s.bottomThicknessDp * geometry.density).toInt().coerceAtLeast(1)
+            assertEquals("bottom band must equal effective bottom depth (sens=$bottomSens)", expectedDepthPx, bottom.heightPx)
+            // Specifically NOT the base 12dp constant when sensitivity != 1.
+            if (bottomSens != 1.0f) {
+                assertTrue("bottom band must differ from base 12dp at sens=$bottomSens", bottom.heightPx != (GestureZoneSettings.BASE_BOTTOM_THICKNESS_DP * geometry.density).toInt())
+            }
+        }
+    }
+
+    @Test
+    fun computeGestureZoneLayout_reservedBand_withNavBottom_neverMultipliesInset() {
+        val density = 3.0f
+        val navBottom = 126
+        val geometry = ScreenGeometry(width = 1080, height = 2400, density = density, navLeft = 0, navRight = 0, navBottom = navBottom)
+        for (bottomSens in listOf(0.5f, 1.0f, 2.0f, 4.0f)) {
+            val s = GestureZoneSettings.DEFAULT.copy(bottomEdgeSensitivity = bottomSens)
+            val bottom = computeGestureZoneLayout(s, geometry).getValue(ZoneId.BOTTOM)
+            val effectiveDepthPx = (s.bottomThicknessDp * density).toInt().coerceAtLeast(1)
+            assertEquals("reserved band = effective depth + navBottom (navBottom never multiplied)",
+                effectiveDepthPx + navBottom, bottom.heightPx)
+            // Sanity: at 1× this is 12dp*3 + 126 = 162; at 4× it's 48dp*3 + 126 = 270, NOT 144*4+126.
+            assertTrue("navBottom must not be multiplied by sensitivity", bottom.heightPx < (effectiveDepthPx * 4) + navBottom || bottomSens <= 1.0f)
+        }
+    }
+
+    @Test
+    fun sideAndBottomZones_doNotOverlap_inCorners_productionGeometry() {
+        // Representative displays, both with and without nav insets.
+        val geometries = listOf(
+            ScreenGeometry(width = 1080, height = 2400, density = 3.0f, navLeft = 0, navRight = 0, navBottom = 0),
+            ScreenGeometry(width = 1080, height = 2400, density = 3.0f, navLeft = 0, navRight = 0, navBottom = 126),
+            // Landscape with a 3-button bar on the right edge.
+            ScreenGeometry(width = 2400, height = 1080, density = 3.0f, navLeft = 0, navRight = 126, navBottom = 0),
+        )
+        for (geometry in geometries) {
+            for (heightPct in listOf(10, 50, 100)) {
+                for (widthPct in listOf(10, 50, 100)) {
+                    for (backSens in listOf(0.5f, 1.0f, 2.0f, 4.0f)) {
+                        for (bottomSens in listOf(0.5f, 1.0f, 2.0f, 4.0f)) {
+                            val s = GestureZoneSettings(
+                                backActivationHeightPercent = heightPct,
+                                bottomActivationWidthPercent = widthPct,
+                                backEdgeSensitivity = backSens,
+                                bottomEdgeSensitivity = bottomSens,
+                            )
+                            val layout = computeGestureZoneLayout(s, geometry)
+                            val bottom = layout.getValue(ZoneId.BOTTOM)
+                            val left = layout.getValue(ZoneId.LEFT_EDGE)
+                            val right = layout.getValue(ZoneId.RIGHT_EDGE)
+                            // Invariant: effective bottom touch depth (sensitivity-scaled) + navBottom.
+                            val effectiveBottomDepthPx = (s.bottomThicknessDp * geometry.density).toInt().coerceAtLeast(1)
+                            val reservedBandPx = effectiveBottomDepthPx + geometry.navBottom
+                            assertEquals("reserved band = effective depth + navBottom", reservedBandPx, bottom.heightPx)
+                            assertEquals("bottom zone owns the full reserved band (top)", geometry.height - reservedBandPx, bottom.top)
+                            assertEquals("bottom zone owns the full reserved band (bottom)", geometry.height, bottom.bottom)
+                            // No vertical overlap, no dead gap: each side zone's bottom == bottom band top.
+                            assertEquals("left zone starts immediately above the reserved band (no gap, no overlap)", bottom.top, left.bottom)
+                            assertEquals("right zone starts immediately above the reserved band (no gap, no overlap)", bottom.top, right.bottom)
+                            assertTrue("left zone top above its bottom", left.top < left.bottom)
+                            assertTrue("right zone top above its bottom", right.top < right.bottom)
+                            // Side height = backActivationHeightPercent of the usable span above the band.
+                            val usableSide = (geometry.height - reservedBandPx).coerceAtLeast(1)
+                            val expectedSideHeight = (usableSide * heightPct / 100).coerceAtLeast(1)
+                            assertEquals("left height = back% of usable side span", expectedSideHeight, left.heightPx)
+                            assertEquals("right height = back% of usable side span", expectedSideHeight, right.heightPx)
+                            // Side depth = effective back depth + nav inset (inset never multiplied).
+                            val effectiveBackDepthPx = (s.backThicknessDp * geometry.density).toInt().coerceAtLeast(1)
+                            assertEquals("left width = effective back depth + navLeft", effectiveBackDepthPx + geometry.navLeft, left.widthPx)
+                            assertEquals("right width = effective back depth + navRight", effectiveBackDepthPx + geometry.navRight, right.widthPx)
+                            // yOffset the controller passes to WindowManager == reserved band.
+                            assertEquals("left yOffset = reserved bottom band", reservedBandPx, left.yOffset)
+                            assertEquals("right yOffset = reserved bottom band", reservedBandPx, right.yOffset)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Explicit corner-ownership: at bottom sensitivity 4× and bottom width 100%, the
+     * lower-left and lower-right corner portions (the reserved bottom band) cannot belong to
+     * Back — they are owned by the bottom Home/Recents zone. This is the exact scenario the
+     * original bug broke (a 48dp bottom band but only a 12dp side offset → ~36dp overlap where
+     * Back could steal a corner vertical gesture).
+     */
+    @Test
+    fun corners_atMaxBottomSensitivityAndFullWidth_belongToBottomNotBack() {
+        val geometry = ScreenGeometry(width = 1080, height = 2400, density = 3.0f, navLeft = 0, navRight = 0, navBottom = 0)
+        val s = GestureZoneSettings(
+            backActivationHeightPercent = 100,
+            bottomActivationWidthPercent = 100,
+            backEdgeSensitivity = 4.0f,
+            bottomEdgeSensitivity = 4.0f,
+        )
+        val layout = computeGestureZoneLayout(s, geometry)
+        val bottom = layout.getValue(ZoneId.BOTTOM)
+        val left = layout.getValue(ZoneId.LEFT_EDGE)
+        val right = layout.getValue(ZoneId.RIGHT_EDGE)
+        // The reserved band is 48dp * 3 = 144px here.
+        assertEquals(144, bottom.heightPx)
+        // A point in the lower-left corner, inside the reserved band, must be in the bottom
+        // zone and NOT in the left Back zone.
+        val cornerY = geometry.height - 10
+        val cornerLeftX = 10
+        assertTrue("lower-left corner point must be inside the bottom zone",
+            bottom.left <= cornerLeftX && cornerLeftX <= bottom.right && bottom.top <= cornerY && cornerY <= bottom.bottom)
+        assertTrue("lower-left corner point must NOT be inside the left Back zone",
+            !(left.left <= cornerLeftX && cornerLeftX <= left.right && left.top <= cornerY && cornerY <= left.bottom))
+        // Same for the lower-right corner.
+        val cornerRightX = geometry.width - 10
+        assertTrue("lower-right corner point must be inside the bottom zone",
+            bottom.left <= cornerRightX && cornerRightX <= bottom.right && bottom.top <= cornerY && cornerY <= bottom.bottom)
+        assertTrue("lower-right corner point must NOT be inside the right Back zone",
+            !(right.left <= cornerRightX && cornerRightX <= right.right && right.top <= cornerY && cornerY <= right.bottom))
+        // And Back must still work immediately above the band.
+        val backPointY = bottom.top - 10
+        assertTrue("point immediately above the band on the left must be in the left Back zone",
+            left.left <= cornerLeftX && cornerLeftX <= left.right && left.top <= backPointY && backPointY <= left.bottom)
+        assertTrue("point immediately above the band on the right must be in the right Back zone",
+            right.left <= cornerRightX && cornerRightX <= right.right && right.top <= backPointY && backPointY <= right.bottom)
+    }
+
+    // --- Percentage normalization (snapping to the 10% step) -----------------------
+
+    @Test
+    fun clampPercent_snapsToNearest10PercentStep() {
+        // Out-of-range clamps to the nearest bound.
+        assertEquals(10, GestureZoneSettings.clampPercent(-100))
+        assertEquals(10, GestureZoneSettings.clampPercent(9))
+        assertEquals(10, GestureZoneSettings.clampPercent(10))
+        // Below the midpoint of a step rounds down to the lower step.
+        assertEquals(10, GestureZoneSettings.clampPercent(14))
+        // Exact midpoint (15) rounds half-up to 20 — documented deterministic behavior.
+        assertEquals(20, GestureZoneSettings.clampPercent(15))
+        assertEquals(50, GestureZoneSettings.clampPercent(49))
+        assertEquals(50, GestureZoneSettings.clampPercent(53))
+        assertEquals(60, GestureZoneSettings.clampPercent(56))
+        assertEquals(80, GestureZoneSettings.clampPercent(80))
+        assertEquals(100, GestureZoneSettings.clampPercent(101))
+        assertEquals(100, GestureZoneSettings.clampPercent(999))
+    }
+
+    @Test
+    fun clampPercent_onlyProducesValidSteps() {
+        val valid = setOf(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
+        for (v in -100..200) {
+            val snapped = GestureZoneSettings.clampPercent(v)
+            assertTrue("$v -> $snapped must be a valid 10% step", snapped in valid)
+        }
+    }
+
+    // --- Home indicator width == resolved bottom touch-zone width ------------------
+    //
+    // The visible Home/Recents bar must match the actual horizontal activation region 1:1,
+    // using the SAME production geometry helper the controller uses to size the bottom touch
+    // window. The old compact-handle dp mapping (108dp × pct / 80, capped at 135dp) is gone;
+    // the bar now spans exactly `screenWidth × bottomActivationWidthPercent / 100` (subject to
+    // the helper's identical rounding/clamping). Bottom edge sensitivity and nav-bar insets
+    // must NOT affect the horizontal width.n
+    @Test
+    fun homeIndicatorWidth_matchesPercentOfScreenWidth_1200px() {
+        val geometry = ScreenGeometry(width = 1200, height = 2400, density = 3.0f, navLeft = 0, navRight = 0, navBottom = 0)
+        assertEquals(120, computeGestureZoneLayout(GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = 10), geometry).getValue(ZoneId.BOTTOM).widthPx)
+        assertEquals(240, computeGestureZoneLayout(GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = 20), geometry).getValue(ZoneId.BOTTOM).widthPx)
+        assertEquals(600, computeGestureZoneLayout(GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = 50), geometry).getValue(ZoneId.BOTTOM).widthPx)
+        assertEquals(960, computeGestureZoneLayout(GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = 80), geometry).getValue(ZoneId.BOTTOM).widthPx)
+        assertEquals(1200, computeGestureZoneLayout(GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = 100), geometry).getValue(ZoneId.BOTTOM).widthPx)
+    }
+
+    @Test
+    fun homeIndicatorWidth_matchesPercentOfScreenWidth_1080px() {
+        val geometry = ScreenGeometry(width = 1080, height = 2400, density = 3.0f, navLeft = 0, navRight = 0, navBottom = 0)
+        assertEquals(108, computeGestureZoneLayout(GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = 10), geometry).getValue(ZoneId.BOTTOM).widthPx)
+        assertEquals(540, computeGestureZoneLayout(GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = 50), geometry).getValue(ZoneId.BOTTOM).widthPx)
+        assertEquals(864, computeGestureZoneLayout(GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = 80), geometry).getValue(ZoneId.BOTTOM).widthPx)
+        assertEquals(1080, computeGestureZoneLayout(GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = 100), geometry).getValue(ZoneId.BOTTOM).widthPx)
+    }
+
+    /**
+     * The core invariant: the resolved Home indicator width equals the resolved bottom
+     * touch-zone width for every valid percentage, across representative screen widths,
+     * densities, bottom sensitivity values, and nav-bar insets. (The controller passes
+     * `bottomLayout.widthPx` straight to HomeIndicator, so this holds by construction —
+     * the test guards against reintroducing a separate visual-width formula.)
+     */
+    @Test
+    fun homeIndicatorWidth_equalsBottomTouchZoneWidth_forEveryPercentage() {
+        val geometries = listOf(
+            ScreenGeometry(width = 1080, height = 2400, density = 3.0f, navLeft = 0, navRight = 0, navBottom = 0),
+            ScreenGeometry(width = 1200, height = 2600, density = 2.75f, navLeft = 0, navRight = 0, navBottom = 0),
+            ScreenGeometry(width = 1080, height = 2400, density = 3.0f, navLeft = 0, navRight = 0, navBottom = 126),
+            ScreenGeometry(width = 2400, height = 1080, density = 3.0f, navLeft = 0, navRight = 126, navBottom = 0),
+        )
+        for (geometry in geometries) {
+            for (pct in listOf(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)) {
+                for (bottomSens in listOf(0.5f, 1.0f, 2.0f, 4.0f)) {
+                    val s = GestureZoneSettings.DEFAULT.copy(
+                        bottomActivationWidthPercent = pct,
+                        bottomEdgeSensitivity = bottomSens,
+                    )
+                    val bottom = computeGestureZoneLayout(s, geometry).getValue(ZoneId.BOTTOM)
+                    // The indicator width the controller passes is exactly the bottom zone's widthPx.
+                    val indicatorWidthPx = bottom.widthPx
+                    assertEquals("indicator width must equal bottom touch-zone width (pct=$pct sens=$bottomSens geom=${geometry.width}x${geometry.height})",
+                        bottom.widthPx, indicatorWidthPx)
+                    // And it is exactly screenWidth × pct / 100 (the helper's formula), so 100% → full width.
+                    val expected = (geometry.width * pct / 100).coerceAtLeast(1)
+                    assertEquals("indicator width must equal screenWidth×pct/100", expected, indicatorWidthPx)
+                    // Bottom sensitivity must not change the horizontal width.
+                    val widthAt1x = computeGestureZoneLayout(
+                        GestureZoneSettings.DEFAULT.copy(bottomActivationWidthPercent = pct, bottomEdgeSensitivity = 1.0f),
+                        geometry,
+                    ).getValue(ZoneId.BOTTOM).widthPx
+                    assertEquals("bottom sensitivity must not alter horizontal width (pct=$pct sens=$bottomSens)",
+                        widthAt1x, indicatorWidthPx)
+                }
+            }
+        }
+    }
+}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index d51a702..b1fb7c9 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -28,7 +28,6 @@ androidx-compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-te
 androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
 androidx-compose-material-icons-core = { group = "androidx.compose.material", name = "material-icons-core" }
 androidx-datastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "datastorePreferences" }
-androidx-lifecycle-service = { group = "androidx.lifecycle", name = "lifecycle-service", version.ref = "lifecycleRuntimeKtx" }
 androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycleViewmodelCompose" }
 
 [plugins]