diff --git a/docs/mobile-roadmap.md b/docs/mobile-roadmap.md
index 5c505e7..cb0abe5 100644
--- a/docs/mobile-roadmap.md
+++ b/docs/mobile-roadmap.md
@@ -31,10 +31,14 @@ wait for the editor, privacy and testing foundation.
 
 ## Now
 
-- **Checkout:** `android-keyboard-hardening`, branch `codex/android-alpha21-release-record`.
+- **Checkout:** `android-keyboard-hardening`, branch `codex/android-comfort-pass`.
 - **Released:** [signed alpha21](https://github.com/RioPlay/utterleaf/releases/tag/android-v0.1.0-alpha21), including the clean-room daily-surface reset and live selected-text completion safeguard (PRs #64–#66).
-- **Next:** complete the workflow-only Node.js/action and runner-image maintenance recorded in
-  [alpha20 release readiness](plans/completed/android-alpha20-release-readiness.md#post-release-ci-maintenance-memory).
+- **Current:** finish review and exact-main validation of the bounded
+  [daily-keyboard comfort pass](plans/active/android-comfort-pass.md). It quiets
+  suggestions, improves hint hierarchy, guarantees bottom-row touch widths and
+  unifies the action-key shape without changing typing, privacy or editor logic.
+- **Next:** complete the workflow-only Node.js/action and runner-image maintenance
+  recorded in [alpha20 release readiness](plans/completed/android-alpha20-release-readiness.md#post-release-ci-maintenance-memory).
   Editor-bound dictation recovery and the remaining Tools architecture work stay
   in the [capability and experience plan](plans/active/android-experience-refresh.md).
   Android remains the priority; desktop is parked.
@@ -50,6 +54,18 @@ wait for the editor, privacy and testing foundation.
 
 ## Current status
 
+- **Daily-keyboard comfort candidate verified locally — September 27, 2026:**
+  suggestions now use quiet, borderless fixed slots and clear stale hidden text;
+  empty states add no filler. Secondary hints use the palette's muted color at
+  9 sp, ordinary keys have explicit pressed fills, and the dynamic action uses
+  the standard key radius. Fixed mode/punctuation/action widths guarantee at
+  least 48 dp bottom-row targets while Space absorbs the remainder. Android
+  tooling passed **26/26**, JVM/lint passed, and the focused emulator bundle
+  passed **58/58** after exact reruns documented in the
+  [comfort plan](plans/active/android-comfort-pass.md#status--september-27-2026).
+  Final empty/one/three-candidate renders were inspected. No physical-device or
+  live assistive-technology claim is made.
+
 - **Alpha21 signed prerelease published — September 27, 2026:** PR #66 merged
   release metadata as exact main revision
   `394fdff11b8ed300d320d9e28c04876d00cc2c93`. Exact-main Android run
diff --git a/docs/plans/active/android-comfort-pass.md b/docs/plans/active/android-comfort-pass.md
new file mode 100644
index 0000000..43d4d78
--- /dev/null
+++ b/docs/plans/active/android-comfort-pass.md
@@ -0,0 +1,97 @@
+# Android daily-keyboard comfort pass
+
+## Goal
+
+Make ordinary Utterleaf typing feel calmer and more comfortable while retaining
+the independently implemented interaction model released in alpha21.
+
+## Area
+
+- `mobile/android/app/src/main/java/org/utterleaf/voice/TypingPanel.kt`
+- `mobile/android/app/src/main/java/org/utterleaf/voice/Ui.kt`
+- focused daily-strip and keyboard-geometry instrumentation tests
+- Android roadmap and this plan
+
+## Constraints
+
+- Preserve editor behavior, privacy policy, suggestion computation, gestures,
+  key ordering, preference identifiers and specialist Tools behavior.
+- Keep the suggestion region fixed at 48 dp and every actionable daily control
+  at least 48 dp in both orientations.
+- Do not copy FUTO code, assets, layouts, labels, constants or theme values.
+  FUTO is a behavioral comfort benchmark only; Utterleaf's implementation and
+  visual tokens remain independent.
+- Emulator rendering is not evidence of physical-phone comfort.
+
+## Acceptance
+
+- Suggestions read as quiet inline text choices rather than a second set of
+  raised keys, while retaining three predictable tap regions.
+- An empty suggestion state is visually calm and does not add instructional
+  filler or change keyboard geometry.
+- Secondary hints remain legible but are subordinate to primary key labels.
+- The dynamic action key uses the same rounded-key language as the keyboard;
+  the branded dictation control remains visually distinct.
+- Pressed, focused, selected and disabled controls retain visible state.
+- Portrait, landscape, one-handed, split and sensitive layouts retain their
+  existing geometry and behavior contracts.
+
+## Verification
+
+1. `python -m unittest discover -s mobile/android/tools -p test_*.py`
+2. `mobile/android/gradlew.bat testDebugUnitTest lintDebug --no-daemon`
+3. Focused emulator classes: `DailyToolbarContractTest`,
+   `KeyboardSpacingTest`, `KeyboardGeometryTest`, `KeyboardTuningTest`,
+   `SuggestionStripTest`, `SensitiveTypingPanelTest`, `OneHandLayoutTest`,
+   `SplitKeyboardTest`, `CompactLayerTest` and `KeyboardEditorContractTest`.
+4. Render ordinary empty, one-candidate and three-candidate states for visual
+   comparison. Record the emulator-only limitation.
+
+## Non-goals
+
+- No new prediction, autocorrection, gesture typing or language behavior.
+- No Tools architecture, settings, dictation-state or editor-lifecycle changes.
+- No release/version bump in this slice.
+- No claim of literal visual parity with another keyboard.
+
+## Stop
+
+Stop when the bounded daily-surface changes and focused checks pass. Move any
+interaction or architecture issue discovered during review to the owning plan
+instead of expanding this pass.
+
+## Status — September 27, 2026
+
+Implemented on `codex/android-comfort-pass`:
+
+- Added a dedicated flat suggestion role with stateful pressed/focus feedback,
+  three stable slots and no empty-state filler.
+- Hidden slots now clear candidate text and accessibility descriptions instead
+  of retaining stale words in invisible views.
+- Centralized the bounded key radii, hint size and bottom-row widths in
+  `Ui.KeyboardTokens`; hints use the opaque palette-muted color at 9 sp.
+- Mode, comma, Space, period and action now retain at least 48 dp touch width;
+  Space absorbs remaining width. The action keeps an explicit accent role and
+  uses the standard key radius. Dictation remains the branded pill.
+- Added explicit pressed fills without changing gesture routing or animation.
+- Added a contrast-safe inset focus/selected outline for primary controls; the
+  action remains visually distinct under external-keyboard focus.
+
+Verification:
+
+- Android tooling: **26/26 passed**.
+- JVM tests and `lintDebug`: **passed**; lint reported no build-stopping issue.
+- Focused emulator bundle: **58/58 passed** across daily toolbar, spacing,
+  geometry, tuning, suggestions, sensitive mode, one-hand, split and compact
+  layers, plus the real-editor action contract. Earlier runs exposed one newly
+  over-strict one-pixel width assertion, test assumptions that did not account
+  for split mode's two Space keys, and one default-IME readiness race. Review
+  also found that primary focus initially matched the default state. The test
+  assumptions were corrected, the readiness case passed on exact rerun, the
+  focus outline and rendering assertion were added, and the final combined run
+  was clean.
+- Final emulator renders for empty, no-match, one- and three-candidate states
+  were inspected locally under `.grok/validation/comfort-final-2/`.
+
+This is emulator evidence only. Physical-phone comfort and live assistive-
+technology review remain unverified.
diff --git a/mobile/android/app/src/androidTest/java/org/utterleaf/voice/KeyboardSpacingTest.kt b/mobile/android/app/src/androidTest/java/org/utterleaf/voice/KeyboardSpacingTest.kt
index 561fc4e..c4946f6 100644
--- a/mobile/android/app/src/androidTest/java/org/utterleaf/voice/KeyboardSpacingTest.kt
+++ b/mobile/android/app/src/androidTest/java/org/utterleaf/voice/KeyboardSpacingTest.kt
@@ -88,10 +88,19 @@ class KeyboardSpacingTest {
     @Test fun suggestionStripKeepsKeyGeometryAcrossCandidateStates() = main {
         var state = SuggestionEngine.SuggestionState.EMPTY
         val panel = panel(state = { state })
+        fun dailyControlBounds() = listOf("Keyboard tools", "Editing tools", "Dictate")
+            .associateWith { bounds(panel, it) }
         panel.reset(false, false, "Enter")
         val emptyHeight = measure(panel)
         val emptySpace = bounds(panel, "Space")
         val emptyQ = bounds(panel, "q")
+        val emptyControls = dailyControlBounds()
+        val emptySuggestionSlots = descendants(panel.view).filterIsInstance<HintedKey>()
+            .filter { it.visualRole == KeyVisualRole.SUGGESTION }
+        assertEquals("Daily strip must retain three predictable suggestion slots",
+            3, emptySuggestionSlots.size)
+        assertTrue("Empty suggestion slots must stay quiet without collapsing",
+            emptySuggestionSlots.all { it.visibility == View.INVISIBLE && it.measuredWidth > 0 })
         capture(panel, "empty")
 
         state = SuggestionEngine.SuggestionState("q", emptyList())
@@ -99,7 +108,8 @@ class KeyboardSpacingTest {
         val noMatchHeight = measure(panel)
         val noMatchSpace = bounds(panel, "Space")
         val noMatchQ = bounds(panel, "q")
-        assertTrue("No-match state must be represented accessibly",
+        val noMatchControls = dailyControlBounds()
+        assertFalse("No-match state must not add instructional filler",
             descendants(panel.view).filterIsInstance<TextView>().any { it.text == "No completions" })
         capture(panel, "no-match")
 
@@ -108,6 +118,7 @@ class KeyboardSpacingTest {
         val oneHeight = measure(panel)
         val oneSpace = bounds(panel, "Space")
         val oneQ = bounds(panel, "q")
+        val oneControls = dailyControlBounds()
         val oneChipCount = descendants(panel.view).filterIsInstance<Button>()
             .count { it.contentDescription == "Complete with quick" }
         capture(panel, "one")
@@ -117,6 +128,7 @@ class KeyboardSpacingTest {
         val threeHeight = measure(panel)
         val threeSpace = bounds(panel, "Space")
         val threeQ = bounds(panel, "q")
+        val threeControls = dailyControlBounds()
         val threeChipCount = descendants(panel.view).filterIsInstance<Button>()
             .count { it.contentDescription?.toString()?.startsWith("Complete with ") == true }
         capture(panel, "three")
@@ -129,14 +141,50 @@ class KeyboardSpacingTest {
         assertEquals("Three completions moved Space", oneSpace, threeSpace)
         assertEquals("Expected three completion chips", 3, threeChipCount)
         assertEquals("Expected the current candidate set to contain quick", 1, oneChipCount)
+        val visibleSuggestionSlots = descendants(panel.view).filterIsInstance<HintedKey>()
+            .filter { it.visualRole == KeyVisualRole.SUGGESTION && it.visibility == View.VISIBLE }
+        assertEquals("Expected three visible suggestion slots", 3, visibleSuggestionSlots.size)
+        val suggestionWidths = visibleSuggestionSlots.map { it.width }
+        assertTrue("Suggestion slots must divide their region evenly",
+            suggestionWidths.max() - suggestionWidths.min() <= 1)
+        assertTrue("Suggestion slots must retain 48dp touch widths",
+            visibleSuggestionSlots.all { it.width >= Ui.dp(app, 48) })
+        assertTrue("Completions must use the quiet suggestion visual role",
+            visibleSuggestionSlots.all { it.background.isStateful })
+        fun assertPressedDiffers(label: String, button: Button) {
+            val normal = android.graphics.Bitmap.createBitmap(button.width, button.height,
+                android.graphics.Bitmap.Config.ARGB_8888)
+            val pressed = android.graphics.Bitmap.createBitmap(button.width, button.height,
+                android.graphics.Bitmap.Config.ARGB_8888)
+            try {
+                button.isPressed = false; button.jumpDrawablesToCurrentState()
+                button.draw(android.graphics.Canvas(normal))
+                button.isPressed = true; button.jumpDrawablesToCurrentState()
+                button.draw(android.graphics.Canvas(pressed))
+                assertFalse("$label pressed state was visually indistinguishable", normal.sameAs(pressed))
+            } finally {
+                button.isPressed = false; button.jumpDrawablesToCurrentState()
+                normal.recycle(); pressed.recycle()
+            }
+        }
+        assertPressedDiffers("Suggestion", visibleSuggestionSlots.first())
+        assertPressedDiffers("Letter key", key(panel, "q"))
         assertEquals("No-match moved q", emptyQ, noMatchQ)
         assertEquals("One completion moved q", noMatchQ, oneQ)
         assertEquals("Three completions moved q", oneQ, threeQ)
+        assertEquals("No-match moved daily controls", emptyControls, noMatchControls)
+        assertEquals("One completion moved daily controls", noMatchControls, oneControls)
+        assertEquals("Three completions moved daily controls", oneControls, threeControls)
         state = SuggestionEngine.SuggestionState.EMPTY
         key(panel, "Space").performClick()
         val afterSpaceHeight = measure(panel)
         assertEquals("Space must not change the strip geometry", threeHeight, afterSpaceHeight)
-        assertTrue("Empty strip must be represented accessibly",
+        val clearedSlots = descendants(panel.view).filterIsInstance<HintedKey>()
+            .filter { it.visualRole == KeyVisualRole.SUGGESTION }
+        assertTrue("Hidden suggestions must not retain stale candidate text",
+            clearedSlots.all { it.visibility == View.INVISIBLE && !it.isEnabled &&
+                it.text.isEmpty() && it.contentDescription.isNullOrEmpty() })
+        assertFalse("Empty strip must not add instructional filler",
             descendants(panel.view).filterIsInstance<TextView>().any { it.text == "Type a word" })
         capture(panel, "after-space")
     }
@@ -169,36 +217,83 @@ class KeyboardSpacingTest {
 
     @Test fun bottomRowHasNoUnassignedTouchRegionOutsideExplicitSplitChannel() = main {
         val configurations = listOf(
-            Configuration.ORIENTATION_PORTRAIT to 360,
-            Configuration.ORIENTATION_LANDSCAPE to 700,
+            Triple(Configuration.ORIENTATION_PORTRAIT, 320, false),
+            Triple(Configuration.ORIENTATION_LANDSCAPE, 600, false),
+            Triple(Configuration.ORIENTATION_LANDSCAPE, 600, true),
         )
-        for ((orientation, widthDp) in configurations) {
+        for ((orientation, widthDp, split) in configurations) {
             val configured = Configuration(app.resources.configuration).apply {
                 this.orientation = orientation
             }
             val panelContext = app.createConfigurationContext(configured)
-            for (alignment in KeyboardAlignment.entries) {
+            val alignments = if (split) listOf(KeyboardAlignment.FULL) else KeyboardAlignment.entries
+            for (alignment in alignments) {
                 val panel = panel(panelContext,
-                    KeyboardOptions(numberRow = false, alignment = alignment), enabled = false)
+                    KeyboardOptions(numberRow = false, alignment = alignment,
+                        splitLandscape = split), enabled = false)
                 panel.reset(false, false, "Enter")
                 val width = Ui.dp(panelContext, widthDp)
                 panel.view.measure(View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
                     View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED))
                 panel.view.layout(0, 0, width, panel.view.measuredHeight)
 
-                val bottom = key(panel, "Space").parent as LinearLayout
+                val bottom = descendants(panel.view).filterIsInstance<Button>()
+                    .first { it.contentDescription == "Space" }.parent as LinearLayout
                 val children = (0 until bottom.childCount).map { bottom.getChildAt(it) }
-                assertTrue("$orientation/$alignment bottom row contains an inert slot",
-                    children.all { it is Button && it.isClickable && it.isFocusable })
+                if (split) {
+                    assertEquals("Split bottom row must contain exactly one intentional center channel",
+                        1, children.count { it !is Button })
+                    assertTrue("Split bottom row contains another inert slot",
+                        children.filterIsInstance<Button>().all { it.isClickable && it.isFocusable })
+                } else {
+                    assertTrue("$orientation/$alignment bottom row contains an inert slot",
+                        children.all { it is Button && it.isClickable && it.isFocusable })
+                }
                 assertEquals(0, children.first().left)
                 assertEquals(bottom.width, children.last().right)
                 children.zipWithNext().forEach { (left, right) ->
-                    assertEquals("$orientation/$alignment bottom row has a dead gap",
+                    assertEquals("$orientation/$alignment/split=$split bottom row has a dead gap",
                         left.right, right.left)
                 }
                 assertTrue(descendants(panel.view).filterIsInstance<Button>()
                     .mapNotNull { it.contentDescription?.toString() }
                     .containsAll(setOf(",", "Space", ".")))
+                listOf("Switch letters and symbols", ",", "Space", ".", "Enter").forEach { description ->
+                    val targets = descendants(panel.view).filterIsInstance<Button>()
+                        .filter { it.contentDescription == description }
+                    assertTrue("$orientation/$alignment/split=$split $description was absent",
+                        targets.isNotEmpty())
+                    assertTrue("$orientation/$alignment/split=$split $description was narrower than 48dp",
+                        targets.all { it.width >= Ui.dp(panelContext, 48) })
+                    assertTrue("$orientation/$alignment/split=$split $description was shorter than 48dp",
+                        targets.all { it.height >= Ui.dp(panelContext, 48) })
+                }
+                val action = key(panel, "Enter")
+                assertTrue("$orientation/$alignment/split=$split action key was disabled", action.isEnabled)
+                assertEquals(KeyVisualRole.ACTION, (action as HintedKey).visualRole)
+                val bitmap = android.graphics.Bitmap.createBitmap(action.width, action.height,
+                    android.graphics.Bitmap.Config.ARGB_8888)
+                val focused = android.graphics.Bitmap.createBitmap(action.width, action.height,
+                    android.graphics.Bitmap.Config.ARGB_8888)
+                try {
+                    action.background.draw(android.graphics.Canvas(bitmap))
+                    assertTrue("$orientation/$alignment/split=$split action key lost its primary fill",
+                        bitmap.getPixel(action.width / 2, action.height / 2) !=
+                            Ui.palette(panelContext, KeyboardOptions(numberRow = false,
+                                alignment = alignment, splitLandscape = split)).background)
+                    bitmap.eraseColor(android.graphics.Color.TRANSPARENT)
+                    action.draw(android.graphics.Canvas(bitmap))
+                    action.isFocusableInTouchMode = true
+                    assertTrue("$orientation/$alignment/split=$split action did not accept focus",
+                        action.requestFocus())
+                    action.jumpDrawablesToCurrentState()
+                    action.draw(android.graphics.Canvas(focused))
+                    assertFalse("$orientation/$alignment/split=$split action focus was visually indistinguishable",
+                        bitmap.sameAs(focused))
+                } finally {
+                    action.clearFocus(); action.jumpDrawablesToCurrentState()
+                    bitmap.recycle(); focused.recycle()
+                }
                 panel.dispose()
             }
         }
diff --git a/mobile/android/app/src/main/java/org/utterleaf/voice/TypingPanel.kt b/mobile/android/app/src/main/java/org/utterleaf/voice/TypingPanel.kt
index c03164b..e5e5b5a 100644
--- a/mobile/android/app/src/main/java/org/utterleaf/voice/TypingPanel.kt
+++ b/mobile/android/app/src/main/java/org/utterleaf/voice/TypingPanel.kt
@@ -26,14 +26,18 @@ import android.widget.LinearLayout
 import android.widget.TextView
 import android.widget.Toast
 
+internal enum class KeyVisualRole { STANDARD, SUGGESTION, ACTION }
+
 /** Secondary hints are visual; the button keeps its primary spoken key label. */
 internal class HintedKey(context: Context) : Button(context) {
+    var visualRole: KeyVisualRole = KeyVisualRole.STANDARD
     var primaryIcon: android.graphics.drawable.Drawable? = null
     var primaryIconSizeDp: Int = 24
     var tintPrimaryIcon: Boolean = true
     var bottomIcon: android.graphics.drawable.Drawable? = null
     var secondaryHint: String? = null
         set(value) { field = value; invalidate() }
+    var secondaryHintColor: Int? = null
     /** Mockup letter hints sit at the top-left; digit hints at the top-right. */
     var hintAlignRight: Boolean = true
         set(value) { field = value; invalidate() }
@@ -61,9 +65,9 @@ internal class HintedKey(context: Context) : Button(context) {
         }
         val hint = secondaryHint
         if (hint != null) {
-            hintPaint.color = currentTextColor
-            hintPaint.alpha = 170
-            hintPaint.textSize = 8 * resources.displayMetrics.scaledDensity
+            hintPaint.color = secondaryHintColor ?: currentTextColor
+            hintPaint.alpha = if (secondaryHintColor == null) 120 else 255
+            hintPaint.textSize = Ui.KeyboardTokens.secondaryHintSp * resources.displayMetrics.scaledDensity
             // At very large label sizes, preserve the primary key's legibility.
             val offset = Ui.dp(context, 3).toFloat()
             val primaryTop = (height - (paint.fontMetrics.descent - paint.fontMetrics.ascent)) / 2f + offset
@@ -74,12 +78,12 @@ internal class HintedKey(context: Context) : Button(context) {
                 canvas.restore()
                 if (hintAlignRight) {
                     hintPaint.textAlign = Paint.Align.RIGHT
-                    canvas.drawText(hint, width - Ui.dp(context, 8).toFloat(),
-                        Ui.dp(context, 6).toFloat() - hintPaint.ascent(), hintPaint)
+                    canvas.drawText(hint, width - Ui.dp(context, 7).toFloat(),
+                        Ui.dp(context, 5).toFloat() - hintPaint.ascent(), hintPaint)
                 } else {
                     hintPaint.textAlign = Paint.Align.LEFT
-                    canvas.drawText(hint, Ui.dp(context, 8).toFloat(),
-                        Ui.dp(context, 6).toFloat() - hintPaint.ascent(), hintPaint)
+                    canvas.drawText(hint, Ui.dp(context, 7).toFloat(),
+                        Ui.dp(context, 5).toFloat() - hintPaint.ascent(), hintPaint)
                 }
                 return
             }
@@ -118,6 +122,7 @@ class TypingPanel(private val context: Context, private var options: KeyboardOpt
     private val keyColor = palette.key
     private val utilityColor = palette.utility
     private val ink = palette.ink
+    private val muted = palette.muted
     private val accent = palette.accent
     private val accentInk = palette.accentInk
     private val keyHeight = if (options.keyHeightDp == 0) { if (options.large) 66 else 54 }
@@ -239,7 +244,6 @@ class TypingPanel(private val context: Context, private var options: KeyboardOpt
     private var layoutGeneration = 0
     private var suggestionRow: LinearLayout? = null
     private val suggestionChips = mutableListOf<Button>()
-    private var suggestionEmpty: TextView? = null
     private var renderedSuggestions = SuggestionEngine.SuggestionState.EMPTY
 
     /** Refreshes the cache-backed strip without reading the host editor. */
@@ -356,7 +360,7 @@ class TypingPanel(private val context: Context, private var options: KeyboardOpt
         caps = false; hubOpen = false; editOpen = false; extraKeysOpen = false
         alternateMode = false; alternateKey = null
         renderedSuggestions = SuggestionEngine.SuggestionState.EMPTY
-        suggestionRow = null; suggestionChips.clear(); suggestionEmpty = null
+        suggestionRow = null; suggestionChips.clear()
         arrowRepeaters.clear()
         toolbarStatus = null; capsKey = null
         ctrlKey = null; altKey = null
@@ -386,14 +390,18 @@ class TypingPanel(private val context: Context, private var options: KeyboardOpt
         content.addView(picker.view, LinearLayout.LayoutParams(-1, -2))
     }
     private val border = Color.parseColor(if (light) "#B9CCC1" else "#3D4845")
-    private fun shape(color: Int, pillShape: Boolean = false) = GradientDrawable().apply {
+    private fun shape(color: Int, pillShape: Boolean = false, outlined: Boolean = true,
+        emphasisStroke: Int? = null) = GradientDrawable().apply {
         setColor(color)
-        cornerRadius = if (pillShape) Ui.dp(context, 23).toFloat() else Ui.dp(context, 8).toFloat()
-        if (options.keyBorders) setStroke(Ui.dp(context, 1), border)
+        cornerRadius = Ui.dp(context, if (pillShape) Ui.KeyboardTokens.brandedPillRadiusDp
+            else Ui.KeyboardTokens.keyRadiusDp).toFloat()
+        if (emphasisStroke != null) setStroke(Ui.dp(context, 2), emphasisStroke)
+        else if (outlined && options.keyBorders) setStroke(Ui.dp(context, 1), border)
     }
     private fun key(row: LinearLayout, label: String, description: String = label, weight: Float = 1f,
         utility: Boolean = false, primary: Boolean = false, height: Int = keyHeight, chordable: Boolean = true,
         widthDp: Int? = null, compact: Boolean = false, labelSizeSp: Int? = null, pill: Boolean = false,
+        visualRole: KeyVisualRole = KeyVisualRole.STANDARD,
         action: () -> Unit): Button {
         val generation = layoutGeneration
         val button = HintedKey(context).apply {
@@ -406,21 +414,41 @@ class TypingPanel(private val context: Context, private var options: KeyboardOpt
             setAutoSizeTextTypeUniformWithConfiguration(minOf(if (compact) 10 else 12, maximumLabelSize),
                 maximumLabelSize,
                 1, TypedValue.COMPLEX_UNIT_SP)
-            typeface = Typeface.create("sans-serif", Typeface.NORMAL)
+            typeface = Typeface.create(if (visualRole == KeyVisualRole.SUGGESTION)
+                "sans-serif-medium" else "sans-serif", Typeface.NORMAL)
+            this.visualRole = visualRole
+            secondaryHintColor = muted
             minWidth = 0; minimumWidth = 0; minHeight = 0; minimumHeight = 0
             setPadding(0, 0, 0, 0); includeFontPadding = false
             gravity = Gravity.CENTER
             val selectedFill = if (compact && !primary) utilityColor else accent
-            val ordinaryFill = if (primary) accent else if (compact) surface else if (utility) utilityColor else keyColor
+            val ordinaryFill = if (visualRole == KeyVisualRole.SUGGESTION) surface else if (primary) accent
+                else if (compact) surface else if (utility) utilityColor else keyColor
+            val pressedFill = when {
+                primary -> accent
+                visualRole == KeyVisualRole.SUGGESTION || compact -> utilityColor
+                utility -> keyColor
+                else -> utilityColor
+            }
             val fill = StateListDrawable().apply {
-                if (primary) addState(intArrayOf(-android.R.attr.state_enabled), shape(surface, pill))
-                addState(intArrayOf(android.R.attr.state_selected), shape(selectedFill, pill))
-                addState(intArrayOf(android.R.attr.state_focused), shape(selectedFill, pill))
-                addState(intArrayOf(), shape(ordinaryFill, pill))
+                val outlined = visualRole != KeyVisualRole.SUGGESTION
+                if (primary && visualRole != KeyVisualRole.ACTION)
+                    addState(intArrayOf(-android.R.attr.state_enabled), shape(surface, pill, outlined))
+                addState(intArrayOf(android.R.attr.state_pressed), shape(pressedFill, pill, outlined))
+                addState(intArrayOf(android.R.attr.state_selected), shape(selectedFill, pill, outlined))
+                addState(intArrayOf(android.R.attr.state_focused), shape(selectedFill, pill, outlined))
+                addState(intArrayOf(), shape(ordinaryFill, pill, outlined))
             }
             val verticalInset = Ui.dp(context, if (compact) 5 else 4)
             background = InsetDrawable(RippleDrawable(ColorStateList.valueOf(0x40808080), fill, shape(Color.WHITE, pill)),
                 Ui.dp(context, 3), verticalInset, Ui.dp(context, 3), verticalInset)
+            if (primary) foreground = InsetDrawable(StateListDrawable().apply {
+                    addState(intArrayOf(android.R.attr.state_selected),
+                        shape(Color.TRANSPARENT, pill, outlined = false, emphasisStroke = accentInk))
+                    addState(intArrayOf(android.R.attr.state_focused),
+                        shape(Color.TRANSPARENT, pill, outlined = false, emphasisStroke = accentInk))
+                    addState(intArrayOf(), shape(Color.TRANSPARENT, pill, outlined = false))
+                }, Ui.dp(context, 3), verticalInset, Ui.dp(context, 3), verticalInset)
             backgroundTintList = null
             stateListAnimator = null
             setTextColor(ColorStateList(arrayOf(intArrayOf(-android.R.attr.state_enabled),
@@ -519,7 +547,7 @@ class TypingPanel(private val context: Context, private var options: KeyboardOpt
         if (suggestionChips.isEmpty()) {
             repeat(3) { index ->
                 suggestionChips += key(row, "", "", height = 48, compact = true,
-                    chordable = false, labelSizeSp = 16) {
+                    chordable = false, labelSizeSp = 15, visualRole = KeyVisualRole.SUGGESTION) {
                     renderedSuggestions.candidates.getOrNull(index)?.let { candidate ->
                         completeChip(renderedSuggestions.composing, candidate)
                     }
@@ -528,23 +556,12 @@ class TypingPanel(private val context: Context, private var options: KeyboardOpt
         }
         if (state.candidates.isEmpty()) {
             suggestionChips.forEach { chip ->
-                chip.visibility = View.GONE
+                chip.text = ""
+                chip.contentDescription = ""
+                chip.visibility = View.INVISIBLE
                 chip.isEnabled = false
             }
-            val empty = suggestionEmpty ?: TextView(context).also { created ->
-                created.textSize = 13f
-                created.setTextColor(ink)
-                created.gravity = Gravity.CENTER
-                created.includeFontPadding = false
-                suggestionEmpty = created
-                row.addView(created, row.indexOfChild(suggestionChips.first()),
-                    LinearLayout.LayoutParams(0, Ui.dp(context, 48), 3f))
-            }
-            empty.text = if (state.composing.isEmpty()) "Type a word" else "No completions"
-            empty.contentDescription = empty.text
-            empty.visibility = View.VISIBLE
         } else {
-            suggestionEmpty?.visibility = View.GONE
             suggestionChips.forEachIndexed { index, chip ->
                 val candidate = state.candidates.getOrNull(index)
                 chip.text = candidate ?: ""
@@ -1183,7 +1200,7 @@ class TypingPanel(private val context: Context, private var options: KeyboardOpt
         arrowRepeaters.forEach { it.cancel() }
         arrowRepeaters.clear()
         content.removeAllViews(); letters.clear(); actionKeys.clear()
-        suggestionRow = null; suggestionChips.clear(); suggestionEmpty = null
+        suggestionRow = null; suggestionChips.clear()
         shiftKeys.clear(); letterShiftKey = null; capsKey = null; ctrlKey = null; altKey = null
         applyContentAlignment()
         val landscapeExtra = extraKeysOpen && context.resources.configuration.orientation ==
@@ -1271,13 +1288,14 @@ class TypingPanel(private val context: Context, private var options: KeyboardOpt
     /** Continuous daily row: mode, punctuation, Space, punctuation and editor action. */
     private fun renderBottomRow() {
         val bottom = row()
-        key(bottom, if (symbols) "ABC" else "?123", "Switch letters and symbols", 1.5f, utility = true) {
+        key(bottom, if (symbols) "ABC" else "?123", "Switch letters and symbols", utility = true,
+            widthDp = Ui.KeyboardTokens.bottomModeWidthDp) {
             symbols = !symbols; moreSymbols = false
             extraKeysOpen = false; extraKeyGroup = ExtraKeyGroup.ACCESSORY
             cancelCompose(); alternateMode = false; alternateKey = null; render()
         }
         fun addPunctuation(label: String, description: String, value: Char) =
-            key(bottom, label, description) {
+            key(bottom, label, description, widthDp = Ui.KeyboardTokens.bottomPunctuationWidthDp) {
                 if (alternateMode) openAlternates(value) else if (type(value.toString())) afterCommit(value.toString())
             }.also { punctuation ->
                 view.registerOrdinaryKey(punctuation)
@@ -1308,7 +1326,8 @@ class TypingPanel(private val context: Context, private var options: KeyboardOpt
             addSpace(5f)
         }
         addPunctuation(".", ".", '.')
-        key(bottom, if (actionLabel == "Enter") "↵" else actionLabel, actionLabel, 1.5f, primary = true, pill = true) {
+        key(bottom, if (actionLabel == "Enter") "↵" else actionLabel, actionLabel, primary = true,
+            widthDp = Ui.KeyboardTokens.bottomActionWidthDp, visualRole = KeyVisualRole.ACTION) {
             if (!sensitiveField && (ctrl || alt)) special(KeyEvent.KEYCODE_ENTER)
             else {
                 if (!sensitiveField && options.autoCapitalize && actionLabel == "Enter" && !caps) {
diff --git a/mobile/android/app/src/main/java/org/utterleaf/voice/Ui.kt b/mobile/android/app/src/main/java/org/utterleaf/voice/Ui.kt
index b360161..f472616 100644
--- a/mobile/android/app/src/main/java/org/utterleaf/voice/Ui.kt
+++ b/mobile/android/app/src/main/java/org/utterleaf/voice/Ui.kt
@@ -12,6 +12,14 @@ import android.widget.*
 object Ui {
     data class Palette(val background: Int, val key: Int, val utility: Int, val ink: Int,
         val muted: Int, val accent: Int, val accentInk: Int)
+    object KeyboardTokens {
+        const val keyRadiusDp = 8
+        const val brandedPillRadiusDp = 23
+        const val secondaryHintSp = 9f
+        const val bottomModeWidthDp = 58
+        const val bottomPunctuationWidthDp = 48
+        const val bottomActionWidthDp = 64
+    }
     fun palette(context: Context, options: KeyboardOptions = KeyboardOptions.load(context)): Palette {
         val mode = when (options.theme) {
             ThemeMode.SYSTEM -> if (options.resolvedLight(context)) ThemeMode.LIGHT else ThemeMode.DARK