diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 00000000..ae55ad7c
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,25 @@
+# Shared formatting rules, used by ktlint (through Spotless) and by editors.
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+
+[*.{kt,kts}]
+ktlint_code_style = android_studio
+# Existing Sidekit code does not enforce a wrap column; keep it that way.
+max_line_length = off
+# Sidekit imports MMS and WorkManager types wholesale in a few adapters.
+ktlint_standard_no-wildcard-imports = disabled
+# Screens are composables with PascalCase names, which is the Compose convention.
+ktlint_function_naming_ignore_when_annotated_with = Composable
+
+[*.{yml,yaml}]
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
diff --git a/.github/actions/android-setup/action.yml b/.github/actions/android-setup/action.yml
new file mode 100644
index 00000000..2e7bbf1b
--- /dev/null
+++ b/.github/actions/android-setup/action.yml
@@ -0,0 +1,21 @@
+name: Android build setup
+description: Install the JDK, Android SDK platform and Gradle caching used by every CI job.
+
+runs:
+  using: composite
+  steps:
+    - name: Set up JDK 21
+      uses: actions/setup-java@v4
+      with:
+        distribution: temurin
+        java-version: "21"
+
+    - name: Set up Android SDK
+      uses: android-actions/setup-android@v3
+      with:
+        # setup-android splits this on spaces, so a YAML block scalar arrives as one package name
+        # containing newlines and sdkmanager fails with "Failed to find package".
+        packages: platform-tools platforms;android-37.0 build-tools;37.0.0
+
+    - name: Set up Gradle
+      uses: gradle/actions/setup-gradle@v4
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000..bf667254
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,140 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  # Only supersede PR runs; every push to main keeps its own status.
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  wrapper-validation:
+    name: Gradle wrapper validation
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v4
+      - uses: gradle/actions/wrapper-validation@v4
+
+  build:
+    name: Build (debug + R8 release)
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      # versionName/versionCode come from `git describe` and the commit count, so a shallow
+      # clone would build a release that claims versionCode 1.
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/android-setup
+      - name: Assemble debug and release
+        run: >
+          ./gradlew :app:assembleDebug :app:assembleRelease :sidekit:assembleDebug
+          --stacktrace
+
+  unit-tests:
+    name: Unit tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/android-setup
+      # Robolectric downloads its Android runtime jars outside Gradle's cache.
+      - uses: actions/cache@v4
+        with:
+          path: ~/.m2/repository
+          key: robolectric-${{ runner.os }}-${{ hashFiles('gradle/libs.versions.toml') }}
+          restore-keys: robolectric-${{ runner.os }}-
+      - name: Run JVM and Robolectric tests
+        run: ./gradlew testDebugUnitTest --stacktrace
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports
+          path: |
+            **/build/reports/tests/testDebugUnitTest
+            **/build/test-results/testDebugUnitTest
+          retention-days: 7
+          if-no-files-found: ignore
+
+  android-lint:
+    name: Android Lint
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      contents: read
+      security-events: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/android-setup
+      - name: Run lint
+        run: ./gradlew lintDebug --stacktrace
+      - name: Upload lint reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: android-lint-reports
+          path: |
+            **/build/reports/lint-results-debug.html
+            **/build/reports/lint-results-debug.txt
+            **/build/reports/lint-results-debug.xml
+          retention-days: 7
+          if-no-files-found: ignore
+      - name: Upload lint results to code scanning
+        if: always()
+        continue-on-error: true
+        uses: github/codeql-action/upload-sarif@v4
+        with:
+          sarif_file: app/build/reports/lint-results-debug.sarif
+          category: android-lint
+
+  kotlin-format:
+    name: Kotlin formatting
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      # Spotless ratchets against origin/main, so it needs the base ref.
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/android-setup
+      - name: Check ktlint formatting of changed files
+        run: ./gradlew spotlessCheck --stacktrace
+
+  secrets:
+    name: Secret scan
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: gitleaks/gitleaks-action@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  dependency-review:
+    name: Dependency review
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/dependency-review-action@v4
+        with:
+          fail-on-severity: high
+          comment-summary-in-pr: on-failure
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 00000000..d923d133
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,40 @@
+name: CodeQL
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: "23 4 * * 1"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  security-events: write
+  packages: read
+  actions: read
+
+concurrency:
+  group: codeql-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  analyze:
+    name: Analyze Kotlin and Java
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/android-setup
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v4
+        with:
+          languages: java-kotlin
+          build-mode: manual
+      - name: Build for analysis
+        run: ./gradlew :app:assembleDebug :sidekit:assembleDebug --stacktrace
+      - name: Analyze
+        uses: github/codeql-action/analyze@v4
+        with:
+          category: "/language:java-kotlin"
diff --git a/.github/workflows/dependency-graph.yml b/.github/workflows/dependency-graph.yml
new file mode 100644
index 00000000..4064e3e7
--- /dev/null
+++ b/.github/workflows/dependency-graph.yml
@@ -0,0 +1,24 @@
+name: Dependency graph
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+concurrency:
+  group: dependency-graph-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  submit:
+    name: Submit Gradle dependencies
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/android-setup
+      # Populates GitHub's dependency graph, which the PR dependency-review job reads.
+      - uses: gradle/actions/dependency-submission@v4
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 08d6133f..0ddff4aa 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -3,6 +3,39 @@ plugins {
     alias(libs.plugins.kotlin.compose)
 }
 
+// Version metadata is read from git instead of being hand-edited here, so a build always reports
+// the code it was made from: a tagged commit is exactly "1.2.3", anything after it is
+// "1.2.3-3-g<sha>", and uncommitted changes add "-dirty". `versionCode` counts commits, so it only
+// ever grows and a newer build always installs over an older one — including over the 1.2.3 stable
+// build, which was bumped by hand to 6. A checkout without git (exported source, a CI tarball)
+// falls back to the last release; pass -PsidekitVersionName=… / -PsidekitVersionCode=… to override.
+val fallbackVersionName = "1.2.3"
+val fallbackVersionCode = 6
+
+fun git(vararg args: String) = providers.exec {
+    commandLine("git", *args)
+    workingDir = rootDir
+    isIgnoreExitValue = true
+}.standardOutput.asText.map(String::trim)
+
+// `--always` prints the bare sha when no release tag is reachable (a shallow clone, say), so such a
+// build reads "0.0.0-g<sha>" rather than passing itself off as the last release.
+val gitVersionName = git("describe", "--tags", "--match", "v[0-9]*", "--dirty", "--always")
+    .map { described ->
+        val name = described.removePrefix("v")
+        when {
+            name.isEmpty() -> fallbackVersionName
+            name.first().isDigit() -> name
+            else -> "0.0.0-g$name"
+        }
+    }
+val gitVersionCode = git("rev-list", "--count", "HEAD")
+    .map { it.toIntOrNull() ?: fallbackVersionCode }
+
+// A machine without a `git` binary makes the exec itself throw, rather than exit non-zero.
+fun versionCodeFromGit() = runCatching { gitVersionCode.get() }.getOrDefault(fallbackVersionCode)
+fun versionNameFromGit() = runCatching { gitVersionName.get() }.getOrDefault(fallbackVersionName)
+
 android {
     namespace = "hrln.interactive.sidekit"
     compileSdk {
@@ -13,8 +46,11 @@ android {
         applicationId = "hrln.interactive.sidekit"
         minSdk = 31
         targetSdk = 36
-        versionCode = 2
-        versionName = "1.1"
+        versionCode = providers.gradleProperty("sidekitVersionCode")
+            .map(String::toInt)
+            .getOrElse(versionCodeFromGit())
+        versionName = providers.gradleProperty("sidekitVersionName")
+            .getOrElse(versionNameFromGit())
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -40,9 +76,11 @@ android {
         // Development build that installs alongside the stable SideKit as a separate app
         // (`hrln.interactive.sidekit.dev`), so the stable one can remain the daily driver while
         // this tracks the current branch/tip for testing. See app/src/dev/res for its distinct
-        // name. It derives from `profile` (R8 + debug signing, no debug Compose checks, baseline
+        // name, and for the DEV pill and About row that mark its UI (values/build.xml). It derives from `profile` (R8 + debug signing, no debug Compose checks, baseline
         // profile) so the on-device testing build doesn't stutter like a raw debug build — it
         // also falls back to `.sidekit` release. Use `debug` for breakpoint debugging instead.
+        // The version comes from git describe, so a dev build names the branch tip it was built
+        // from (e.g. 1.2.3-1-g91da863-dev) rather than a stale hand-written number.
         create("dev") {
             initWith(getByName("profile"))
             applicationIdSuffix = ".dev"
diff --git a/app/screenshots/case_colour_sage_after.png b/app/screenshots/case_colour_sage_after.png
index 9febd267..496d9b15 100644
Binary files a/app/screenshots/case_colour_sage_after.png and b/app/screenshots/case_colour_sage_after.png differ
diff --git a/app/screenshots/case_colour_sage_before.png b/app/screenshots/case_colour_sage_before.png
index 378a04f1..791f3aee 100644
Binary files a/app/screenshots/case_colour_sage_before.png and b/app/screenshots/case_colour_sage_before.png differ
diff --git a/app/screenshots/keypad_mapping_automatic.png b/app/screenshots/keypad_mapping_automatic.png
index bf1db407..071b5e30 100644
Binary files a/app/screenshots/keypad_mapping_automatic.png and b/app/screenshots/keypad_mapping_automatic.png differ
diff --git a/app/screenshots/keypad_mapping_editor.png b/app/screenshots/keypad_mapping_editor.png
index 97921079..24590ed3 100644
Binary files a/app/screenshots/keypad_mapping_editor.png and b/app/screenshots/keypad_mapping_editor.png differ
diff --git a/app/screenshots/keypad_mapping_editor_keys.png b/app/screenshots/keypad_mapping_editor_keys.png
index f625d2bc..4c745b13 100644
Binary files a/app/screenshots/keypad_mapping_editor_keys.png and b/app/screenshots/keypad_mapping_editor_keys.png differ
diff --git a/app/screenshots/keypad_mapping_settings.png b/app/screenshots/keypad_mapping_settings.png
index a98d9b71..03ad65b7 100644
Binary files a/app/screenshots/keypad_mapping_settings.png and b/app/screenshots/keypad_mapping_settings.png differ
diff --git a/app/screenshots/keypad_mapping_tester.png b/app/screenshots/keypad_mapping_tester.png
index a8ba2796..0b10a7d8 100644
Binary files a/app/screenshots/keypad_mapping_tester.png and b/app/screenshots/keypad_mapping_tester.png differ
diff --git a/app/screenshots/launcher_grid_compact.png b/app/screenshots/launcher_grid_compact.png
new file mode 100644
index 00000000..e97ee720
Binary files /dev/null and b/app/screenshots/launcher_grid_compact.png differ
diff --git a/app/screenshots/launcher_list_36-2.png b/app/screenshots/launcher_list_36-2.png
index 53e69f1a..92445565 100644
Binary files a/app/screenshots/launcher_list_36-2.png and b/app/screenshots/launcher_list_36-2.png differ
diff --git a/app/screenshots/onboarding/01-home.png b/app/screenshots/onboarding/01-home.png
index 95a041fb..7d972e11 100644
Binary files a/app/screenshots/onboarding/01-home.png and b/app/screenshots/onboarding/01-home.png differ
diff --git a/app/screenshots/onboarding/02-colour.png b/app/screenshots/onboarding/02-colour.png
index 16c9e682..e7f1c9d6 100644
Binary files a/app/screenshots/onboarding/02-colour.png and b/app/screenshots/onboarding/02-colour.png differ
diff --git a/app/screenshots/onboarding/03-layout.png b/app/screenshots/onboarding/03-layout.png
index c1c41909..b1a35e33 100644
Binary files a/app/screenshots/onboarding/03-layout.png and b/app/screenshots/onboarding/03-layout.png differ
diff --git a/app/screenshots/onboarding/03b-hide-apps.png b/app/screenshots/onboarding/03b-hide-apps.png
index 9dbb3c8b..14ef6047 100644
Binary files a/app/screenshots/onboarding/03b-hide-apps.png and b/app/screenshots/onboarding/03b-hide-apps.png differ
diff --git a/app/screenshots/onboarding/04-permissions.png b/app/screenshots/onboarding/04-permissions.png
index 69f021cb..6b289a8a 100644
Binary files a/app/screenshots/onboarding/04-permissions.png and b/app/screenshots/onboarding/04-permissions.png differ
diff --git a/app/screenshots/onboarding/05-typing.png b/app/screenshots/onboarding/05-typing.png
index f68610cb..afdf7a0b 100644
Binary files a/app/screenshots/onboarding/05-typing.png and b/app/screenshots/onboarding/05-typing.png differ
diff --git a/app/screenshots/onboarding/06-t9.png b/app/screenshots/onboarding/06-t9.png
index 666ef884..5c3b6907 100644
Binary files a/app/screenshots/onboarding/06-t9.png and b/app/screenshots/onboarding/06-t9.png differ
diff --git a/app/screenshots/onboarding/07-qwerty.png b/app/screenshots/onboarding/07-qwerty.png
index 32c67be7..114847f2 100644
Binary files a/app/screenshots/onboarding/07-qwerty.png and b/app/screenshots/onboarding/07-qwerty.png differ
diff --git a/app/screenshots/onboarding/08-sundial.png b/app/screenshots/onboarding/08-sundial.png
index 344c35b1..ff7e7eeb 100644
Binary files a/app/screenshots/onboarding/08-sundial.png and b/app/screenshots/onboarding/08-sundial.png differ
diff --git a/app/screenshots/onboarding/09-controller.png b/app/screenshots/onboarding/09-controller.png
index 2781e0c1..5475fe98 100644
Binary files a/app/screenshots/onboarding/09-controller.png and b/app/screenshots/onboarding/09-controller.png differ
diff --git a/app/screenshots/onboarding/10-search-t9.png b/app/screenshots/onboarding/10-search-t9.png
index 6647e03f..dd2800e3 100644
Binary files a/app/screenshots/onboarding/10-search-t9.png and b/app/screenshots/onboarding/10-search-t9.png differ
diff --git a/app/screenshots/onboarding/11-search-qwerty.png b/app/screenshots/onboarding/11-search-qwerty.png
index 6647e03f..dd2800e3 100644
Binary files a/app/screenshots/onboarding/11-search-qwerty.png and b/app/screenshots/onboarding/11-search-qwerty.png differ
diff --git a/app/screenshots/onboarding/13-hide-apps-settings.png b/app/screenshots/onboarding/13-hide-apps-settings.png
index 75b3a9a0..933a1b4c 100644
Binary files a/app/screenshots/onboarding/13-hide-apps-settings.png and b/app/screenshots/onboarding/13-hide-apps-settings.png differ
diff --git a/app/screenshots/settings_96-891.png b/app/screenshots/settings_96-891.png
index ca3c13ae..fe8ab61b 100644
Binary files a/app/screenshots/settings_96-891.png and b/app/screenshots/settings_96-891.png differ
diff --git a/app/screenshots/settings_compact.png b/app/screenshots/settings_compact.png
new file mode 100644
index 00000000..8e162b6b
Binary files /dev/null and b/app/screenshots/settings_compact.png differ
diff --git a/app/screenshots/settings_system_home.png b/app/screenshots/settings_system_home.png
index c237814e..3bf4cb96 100644
Binary files a/app/screenshots/settings_system_home.png and b/app/screenshots/settings_system_home.png differ
diff --git a/app/src/dev/res/values/build.xml b/app/src/dev/res/values/build.xml
new file mode 100644
index 00000000..b1573714
--- /dev/null
+++ b/app/src/dev/res/values/build.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Dev build only. `hrln.interactive.sidekit.dev` installs alongside the stable Sidekit, and
+    these overrides are what stops the two being confused on the device: the launcher header
+    carries a DEV pill and Settings → About names the build.
+-->
+<resources>
+    <string name="build_label" translatable="false">DEV</string>
+    <bool name="is_dev_build">true</bool>
+</resources>
diff --git a/app/src/dev/res/values/strings.xml b/app/src/dev/res/values/strings.xml
index 5a5a0cfe..745ea27d 100644
--- a/app/src/dev/res/values/strings.xml
+++ b/app/src/dev/res/values/strings.xml
@@ -2,7 +2,9 @@
 <!--
     Overrides applied only to the `dev` build type (installs as a separate app,
     hrln.interactive.sidekit.dev, so it can run alongside the stable SideKit).
-    Only app_name is overridden; every other string is inherited from src/main.
+    Only app_name is overridden here; every other string is inherited from src/main. The rest of
+    what marks the UI as dev (the header pill, the About row) lives in
+    app/src/dev/res/values/build.xml.
 -->
 <resources>
     <string name="app_name">SideKit Dev</string>
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 278e3369..53fd9dfb 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -80,7 +80,7 @@
         android:theme="@style/Theme.Sidekit">
 
         <!--
-            configChanges: SideKit draws a fixed 480 x 640 canvas, so no configuration change
+            configChanges: SideKit draws its own 480-wide canvas, so no configuration change
             needs new resources. Handling them in place avoids tearing down and rebuilding the
             whole Compose tree (hundreds of ms on the MT8766) when e.g. a keyboard is attached,
             the font scale or dark mode changes.
diff --git a/app/src/main/java/hrln/interactive/sidekit/MainActivity.kt b/app/src/main/java/hrln/interactive/sidekit/MainActivity.kt
index 9fd4603c..b4bda5c8 100644
--- a/app/src/main/java/hrln/interactive/sidekit/MainActivity.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/MainActivity.kt
@@ -1,29 +1,32 @@
 package hrln.interactive.sidekit
 
+import android.annotation.SuppressLint
 import android.content.Intent
-import android.view.KeyEvent
-import androidx.lifecycle.lifecycleScope
-import hrln.interactive.sidekit.design.action.ChromeState
-import hrln.interactive.sidekit.design.input.Keypad
-import hrln.interactive.sidekit.design.input.SystemKeys
 import android.os.Bundle
+import android.view.KeyEvent
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.compose.runtime.*
-import hrln.interactive.sidekit.onboarding.OnboardingScreen
-import hrln.interactive.sidekit.apps.settings.SidekitPreferences
-import hrln.interactive.sidekit.apps.settings.rememberCaseColour
-import hrln.interactive.sidekit.design.theme.SidekitColors
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import androidx.lifecycle.lifecycleScope
+import hrln.interactive.sidekit.apps.settings.SidekitPreferences
+import hrln.interactive.sidekit.apps.settings.rememberCaseColour
+import hrln.interactive.sidekit.apps.settings.rememberCompactLayout
+import hrln.interactive.sidekit.apps.sidemessage.IncomingLinks
+import hrln.interactive.sidekit.apps.sideport.SideportLinks
+import hrln.interactive.sidekit.design.action.ChromeState
 import hrln.interactive.sidekit.design.canvas.SidekitCanvas
+import hrln.interactive.sidekit.design.input.Keypad
+import hrln.interactive.sidekit.design.input.SystemKeys
+import hrln.interactive.sidekit.design.theme.SidekitColors
+import hrln.interactive.sidekit.design.theme.SidekitSpacing
 import hrln.interactive.sidekit.design.theme.SidekitTheme
 import hrln.interactive.sidekit.navigation.SidekitNavHost
-import hrln.interactive.sidekit.apps.sidemessage.IncomingLinks
-import hrln.interactive.sidekit.apps.sideport.SideportLinks
+import hrln.interactive.sidekit.onboarding.OnboardingScreen
 
 class MainActivity : ComponentActivity() {
     /** Bumped when Home is pressed while SideKit is already in front; the nav host returns to the launcher. */
@@ -40,7 +43,7 @@ class MainActivity : ComponentActivity() {
         // Opened from an sms: link or a message notification: go to that conversation.
         if (savedInstanceState == null && !SideportLinks.handle(intent)) IncomingLinks.handle(intent)
         enableEdgeToEdge()
-        // The mocks use the whole 480 x 640 display; the launcher header carries the clock.
+        // SideKit uses the whole display; the launcher header carries the clock.
         WindowCompat.getInsetsController(window, window.decorView).apply {
             systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
             hide(WindowInsetsCompat.Type.systemBars())
@@ -49,10 +52,16 @@ class MainActivity : ComponentActivity() {
             val prefs = remember { SidekitPreferences(this) }
             var setupComplete by remember { mutableStateOf(prefs.setupComplete) }
             val caseColour = rememberCaseColour(prefs)
-            SidekitTheme(colors = caseColour?.palette() ?: SidekitColors()) {
+            // Compact layout (Settings) trims the header and the action bar on every screen.
+            val compact = rememberCompactLayout(prefs)
+            val spacing = remember(compact) { if (compact) SidekitSpacing.Compact else SidekitSpacing() }
+            SidekitTheme(colors = caseColour?.palette() ?: SidekitColors(), spacing = spacing) {
                 SidekitCanvas(chrome = chrome, keypad = keypad) {
-                    if (setupComplete) SidekitNavHost(homeRequests = homeRequests.intValue)
-                    else OnboardingScreen(onFinish = { setupComplete = true })
+                    if (setupComplete) {
+                        SidekitNavHost(homeRequests = homeRequests.intValue)
+                    } else {
+                        OnboardingScreen(onFinish = { setupComplete = true })
+                    }
                 }
             }
         }
@@ -67,6 +76,9 @@ class MainActivity : ComponentActivity() {
         hrln.interactive.sidekit.apps.settings.SidekitPreferences(this).applyInputDefault(keypad)
     }
 
+    // Overriding dispatchKeyEvent is the only way to see a keypad event before Compose or the
+    // system consumes it; lint flags the override because ComponentActivity marks it @RestrictTo.
+    @SuppressLint("RestrictedApi")
     override fun dispatchKeyEvent(raw: KeyEvent): Boolean {
         // Detect the module from the raw key before navigation rewrites it, so a first QWERTY press
         // on a letter that is also a navigator (T/D/B/J) still reveals the module.
@@ -84,6 +96,7 @@ class MainActivity : ComponentActivity() {
                 }
                 return true
             }
+
             // Keypad top-left (CALL) is turned into Back by KeypadAccessibilityService before the
             // system can open the dialer. Without the service only its release reaches us, after
             // the dialer has launched: swallow it so nothing happens twice.
@@ -95,7 +108,10 @@ class MainActivity : ComponentActivity() {
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         // singleTask: pressing Home while an app is open delivers the HOME intent here.
-        if (intent.hasCategory(Intent.CATEGORY_HOME)) homeRequests.intValue++
-        else if (!SideportLinks.handle(intent)) IncomingLinks.handle(intent)
+        if (intent.hasCategory(Intent.CATEGORY_HOME)) {
+            homeRequests.intValue++
+        } else if (!SideportLinks.handle(intent)) {
+            IncomingLinks.handle(intent)
+        }
     }
 }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppRow.kt b/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppRow.kt
new file mode 100644
index 00000000..d61fe1e0
--- /dev/null
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppRow.kt
@@ -0,0 +1,71 @@
+package hrln.interactive.sidekit.apps.apps
+
+import android.graphics.Bitmap
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.produceState
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.semantics.Role
+import hrln.interactive.sidekit.design.components.SidekitItem
+import hrln.interactive.sidekit.design.components.SidekitTextField
+import hrln.interactive.sidekit.design.theme.SidekitTheme
+
+/**
+ * The installed apps Sidekit may launch: all of them, except Sidekit itself. A sibling build
+ * (`.dev`) stays, since launching that is an ordinary app launch, not recursion.
+ */
+internal fun launchableApps(apps: List<LaunchableApp>, selfPackage: String): List<LaunchableApp> = apps.filterNot { it.component.packageName == selfPackage }
+
+/** An installed app's own icon, rasterised off the main thread and kept while it stays in the row. */
+@Composable
+internal fun rememberAppIcon(source: AppsSource, app: LaunchableApp): Bitmap? {
+    val icon by produceState<Bitmap?>(null, source, app.key) { value = source.icon(app) }
+    return icon
+}
+
+/** The search field both app lists start with, so the two match down to the placeholder. */
+@Composable
+internal fun AppSearchField(query: String, onQuery: (String) -> Unit) {
+    SidekitTextField(query, onQuery, placeholder = "Search apps", singleLine = true, onDone = {}, focusOnKeypad = true)
+}
+
+/**
+ * One installed app as a list row: its own icon, its label, an optional [secondary] note, and the
+ * link arrow that says a tap leads somewhere. Shared by the Apps screen and Sideport's Add app
+ * picker so an app list looks the same everywhere Sidekit shows phone apps.
+ */
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+internal fun AppRow(
+    app: LaunchableApp,
+    source: AppsSource,
+    modifier: Modifier = Modifier,
+    secondary: String? = null,
+    onClick: () -> Unit,
+    onLongClick: (() -> Unit)? = null,
+    onLongClickLabel: String? = null
+) {
+    val icon = rememberAppIcon(source, app)
+    SidekitItem(
+        title = app.label,
+        // Clip before the clickable, as SidekitItem does for its own onClick, so the press
+        // highlight keeps the row's rounded corners.
+        modifier = modifier.clip(SidekitTheme.shapes.item).combinedClickable(
+            role = Role.Button,
+            onClick = onClick,
+            onLongClick = onLongClick,
+            onLongClickLabel = onLongClickLabel
+        ),
+        secondary = secondary,
+        showLinkArrow = true,
+        leading = {
+            icon?.let { Image(it.asImageBitmap(), contentDescription = null, modifier = Modifier.size(SidekitTheme.spacing.iconSize)) }
+        }
+    )
+}
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppsGraph.kt b/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppsGraph.kt
index a8aac35f..d2ae0a35 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppsGraph.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppsGraph.kt
@@ -3,18 +3,11 @@ package hrln.interactive.sidekit.apps.apps
 import android.content.Intent
 import android.net.Uri
 import android.os.Process
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.graphics.asImageBitmap
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import androidx.lifecycle.viewmodel.initializer
@@ -24,8 +17,8 @@ import androidx.navigation.NavHostController
 import androidx.navigation.compose.composable
 import hrln.interactive.sidekit.design.action.SideAction
 import hrln.interactive.sidekit.design.components.*
-import hrln.interactive.sidekit.navigation.SubApp
 import hrln.interactive.sidekit.design.theme.SidekitTheme
+import hrln.interactive.sidekit.navigation.SubApp
 
 fun NavGraphBuilder.appsGraph(nav: NavHostController) {
     composable(SubApp.Apps.route) {
@@ -35,7 +28,6 @@ fun NavGraphBuilder.appsGraph(nav: NavHostController) {
     }
 }
 
-@OptIn(ExperimentalFoundationApi::class)
 @Composable
 internal fun AppsScreen(vm: AppsViewModel, back: () -> Unit) {
     val context = LocalContext.current
@@ -43,28 +35,45 @@ internal fun AppsScreen(vm: AppsViewModel, back: () -> Unit) {
     val query by vm.query.collectAsStateWithLifecycle()
     var selected by remember { mutableStateOf<LaunchableApp?>(null) }
     var message by remember { mutableStateOf<String?>(null) }
-    fun perform(action: () -> Unit) { try { action() } catch (e: Exception) { message = "Couldn't open app: ${e.localizedMessage}" } }
+    fun perform(action: () -> Unit) {
+        try {
+            action()
+        } catch (e: Exception) {
+            message = "Couldn't open app: ${e.localizedMessage}"
+        }
+    }
     val app = selected
-    val options = if (app == null) emptyList() else listOf(
-        SideAction("info", "App info") { perform { vm.repository.info(app) } },
-        SideAction("uninstall", "Uninstall") {
-            perform { context.startActivity(Intent(Intent.ACTION_DELETE, Uri.parse("package:${app.component.packageName}")).putExtra(Intent.EXTRA_USER, app.user)) }
-        },
-    )
+    val options = if (app == null) {
+        emptyList()
+    } else {
+        listOf(
+            SideAction("info", "App info") { perform { vm.repository.info(app) } },
+            SideAction("uninstall", "Uninstall") {
+                perform { context.startActivity(Intent(Intent.ACTION_DELETE, Uri.parse("package:${app.component.packageName}")).putExtra(Intent.EXTRA_USER, app.user)) }
+            }
+        )
+    }
     val list = rememberLazyListState()
     SidekitScaffold("Apps", actions = listOf(SideAction.back("back", "Home", back)), options = options) { padding ->
         SidekitList(padding, state = list) {
-            item { SidekitTextField(query, { vm.query.value = it }, placeholder = "Search apps", singleLine = true, onDone = {}, focusOnKeypad = true) }
+            item { AppSearchField(query) { vm.query.value = it } }
             item { SidekitCard { SidekitText(selected?.let { "${it.label} selected. Press Options for app info or uninstall." } ?: "Tap to open · hold an app for Options", style = SidekitTheme.typography.label, maxLines = Int.MAX_VALUE) } }
             (message ?: state.error)?.let { item { SidekitCard(onClick = { message = null }) { SidekitText(it, style = SidekitTheme.typography.label, maxLines = Int.MAX_VALUE) } } }
             if (!state.loaded && state.error == null) item { SidekitItem("Loading apps…") }
             if (state.loaded && state.apps.isEmpty()) item { SidekitItem("No matching apps") }
             itemsIndexed(state.apps, key = { _, it -> it.key }) { index, target ->
-                val icon by produceState<android.graphics.Bitmap?>(null, target, state.apps) { value = vm.repository.icon(target) }
-                SidekitItem(target.label, Modifier.listFade(list, index + 2).then(
-                    Modifier.combinedClickable(onClick = { selected = target; perform { vm.repository.launch(target) } }, onLongClick = { selected = target }, onLongClickLabel = "App options")
-                ), secondary = if (target.user != Process.myUserHandle()) "Work profile" else null,
-                    leading = { icon?.let { Image(it.asImageBitmap(), null, Modifier.size(SidekitTheme.spacing.iconSize)) } })
+                AppRow(
+                    target,
+                    vm.repository,
+                    Modifier.listFade(list, index + 2),
+                    secondary = if (target.user != Process.myUserHandle()) "Work profile" else null,
+                    onClick = {
+                        selected = target
+                        perform { vm.repository.launch(target) }
+                    },
+                    onLongClick = { selected = target },
+                    onLongClickLabel = "App options"
+                )
             }
         }
     }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppsRepository.kt b/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppsRepository.kt
index 83265fee..87c2d04e 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppsRepository.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/apps/AppsRepository.kt
@@ -34,22 +34,39 @@ class AppsRepository(private val context: Context) : AppsSource {
     }
     override val apps: Flow<List<LaunchableApp>> = callbackFlow {
         val callback = object : LauncherApps.Callback() {
-            override fun onPackageRemoved(packageName: String, user: UserHandle) { changed() }
-            override fun onPackageAdded(packageName: String, user: UserHandle) { changed() }
-            override fun onPackageChanged(packageName: String, user: UserHandle) { changed() }
-            override fun onPackagesAvailable(packageNames: Array<out String>, user: UserHandle, replacing: Boolean) { changed() }
-            override fun onPackagesUnavailable(packageNames: Array<out String>, user: UserHandle, replacing: Boolean) { changed() }
-            private fun changed() { icons.evictAll(); trySend(Unit) }
+            override fun onPackageRemoved(packageName: String, user: UserHandle) {
+                changed()
+            }
+            override fun onPackageAdded(packageName: String, user: UserHandle) {
+                changed()
+            }
+            override fun onPackageChanged(packageName: String, user: UserHandle) {
+                changed()
+            }
+            override fun onPackagesAvailable(packageNames: Array<out String>, user: UserHandle, replacing: Boolean) {
+                changed()
+            }
+            override fun onPackagesUnavailable(packageNames: Array<out String>, user: UserHandle, replacing: Boolean) {
+                changed()
+            }
+            private fun changed() {
+                icons.evictAll()
+                trySend(Unit)
+            }
         }
         launcher.registerCallback(callback, android.os.Handler(android.os.Looper.getMainLooper()))
         trySend(Unit)
-        awaitClose { launcher.unregisterCallback(callback); icons.evictAll() }
+        awaitClose {
+            launcher.unregisterCallback(callback)
+            icons.evictAll()
+        }
     }.conflate().mapLatest { load() }
 
     private suspend fun load(): List<LaunchableApp> = withContext(Dispatchers.IO) {
-        launcher.profiles.flatMap { user ->
+        val all = launcher.profiles.flatMap { user ->
             launcher.getActivityList(null, user).map { LaunchableApp(it.componentName, user, it.label.toString()) }
-        }.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.label })
+        }
+        launchableApps(all, context.packageName).sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.label })
     }
 
     override suspend fun icon(app: LaunchableApp): Bitmap? = withContext(Dispatchers.IO) {
@@ -74,7 +91,17 @@ fun matchesApp(label: String, query: String): Boolean {
     if (label.contains(text, ignoreCase = true)) return true
     if (!text.all(Char::isDigit)) return false
     val digits = label.lowercase().map { c ->
-        when (c) { in 'a'..'c' -> '2'; in 'd'..'f' -> '3'; in 'g'..'i' -> '4'; in 'j'..'l' -> '5'; in 'm'..'o' -> '6'; in 'p'..'s' -> '7'; in 't'..'v' -> '8'; in 'w'..'z' -> '9'; else -> c }
+        when (c) {
+            in 'a'..'c' -> '2'
+            in 'd'..'f' -> '3'
+            in 'g'..'i' -> '4'
+            in 'j'..'l' -> '5'
+            in 'm'..'o' -> '6'
+            in 'p'..'s' -> '7'
+            in 't'..'v' -> '8'
+            in 'w'..'z' -> '9'
+            else -> c
+        }
     }.joinToString("")
     return digits.contains(text)
 }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/calendar/CalendarEditor.kt b/app/src/main/java/hrln/interactive/sidekit/apps/calendar/CalendarEditor.kt
index 1e7fd005..af5c4952 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/calendar/CalendarEditor.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/calendar/CalendarEditor.kt
@@ -3,9 +3,7 @@ package hrln.interactive.sidekit.apps.calendar
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.focusable
 import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
 import hrln.interactive.sidekit.design.theme.SidekitTheme
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.runtime.*
@@ -77,7 +75,7 @@ fun CalendarEditor(id: Long?, date: LocalDate, onClose: () -> Unit) {
         }
     }
     BackHandler(choosingCalendar || deleting || busy) { if (!busy) { choosingCalendar = false; deleting = false } }
-    SidekitScaffold(modifier = Modifier.focusRequester(focus).focusable(), title = if (choosingCalendar) "Choose calendar" else if (id == null) "New event" else "Edit event",
+    SidekitScaffold(focusParking = focus, title = if (choosingCalendar) "Choose calendar" else if (id == null) "New event" else "Edit event",
         actions = when {
             busy -> listOf(SideAction("main", "Saving…") {})
             choosingCalendar -> listOf(SideAction("main", "Back") { choosingCalendar = false })
@@ -102,11 +100,11 @@ fun CalendarEditor(id: Long?, date: LocalDate, onClose: () -> Unit) {
                     item { SidekitCard(Modifier.listFade(list, 1).fillMaxWidth()) { SidekitTextField(title.orEmpty(), { title = it }, placeholder = "Title", focusOnKeypad = true, autoFocus = id == null, singleLine = true, onDone = { focus.requestFocus() }) } }
                     item { SidekitCard(Modifier.listFade(list, 2).fillMaxWidth()) { Column {
                         SidekitText("Start · YYYY-MM-DD HH:mm", style = SidekitTheme.typography.caption)
-                        SidekitTextField(start.orEmpty(), { start = it }, singleLine = true, onDone = { focus.requestFocus() })
+                        SidekitTextField(start.orEmpty(), { start = it }, singleLine = true, dictation = false, onDone = { focus.requestFocus() })
                     } } }
                     item { SidekitCard(Modifier.listFade(list, 3).fillMaxWidth()) { Column {
                         SidekitText("End · YYYY-MM-DD HH:mm", style = SidekitTheme.typography.caption)
-                        SidekitTextField(end.orEmpty(), { end = it }, singleLine = true, onDone = { focus.requestFocus() })
+                        SidekitTextField(end.orEmpty(), { end = it }, singleLine = true, dictation = false, onDone = { focus.requestFocus() })
                     } } }
                     item { SidekitItem(if (allDay) "All day · End date is exclusive" else "Timed event", Modifier.listFade(list, 4), onClick = { allDay = !allDay }) }
                     item { SidekitItem(calendars.find { it.id == calendarId }?.name ?: "No writable calendar", Modifier.listFade(list, 5), onClick = { choosingCalendar = true }) }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/clock/ClockGraph.kt b/app/src/main/java/hrln/interactive/sidekit/apps/clock/ClockGraph.kt
index 028b393c..72c6684a 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/clock/ClockGraph.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/clock/ClockGraph.kt
@@ -18,9 +18,7 @@ import androidx.compose.runtime.*
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.foundation.focusable
 import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -129,7 +127,7 @@ internal fun ClockScreen(onEdit: (String) -> Unit, repository: ClockRepository?
         // As in Sideticks, Undo takes a place in the bar while a delete can be undone.
         if (deletedPending != null) add(SideAction("undo", "Undo", SidekitIcon.Undo, tone = ActionTone.Muted, onClick = repo::undoDelete))
     }
-    SidekitScaffold(modifier = Modifier.focusRequester(focus).focusable(), title = if (permissionPage) "Clock access" else tab, actions = actions,
+    SidekitScaffold(focusParking = focus, title = if (permissionPage) "Clock access" else tab, actions = actions,
         options = if (permissionPage) emptyList() else listOf(SideAction("access", "Alarm access") { permissionPage = true })) { padding ->
         val list = rememberLazyListState()
         val swipes = rememberSwipeRevealGroup()
@@ -158,7 +156,7 @@ internal fun ClockScreen(onEdit: (String) -> Unit, repository: ClockRepository?
                     "Timer" -> {
                         item { SidekitItem(durationText(current.timer.remainingAt(now, elapsed)), Modifier.listFade(list, 3)) }
                         if (current.timer.endAt == null && current.timer.remaining == 0L) item { SidekitCard(Modifier.listFade(list, 4).fillMaxWidth()) {
-                            SidekitTextField(minutes, { minutes = it }, placeholder = "Minutes", singleLine = true, focusOnKeypad = true, onDone = { focus.requestFocus() })
+                            SidekitTextField(minutes, { minutes = it }, placeholder = "Minutes", singleLine = true, dictation = false, focusOnKeypad = true, onDone = { focus.requestFocus() })
                         } }
                     }
                     else -> {
@@ -191,13 +189,13 @@ private fun ClockEditor(id: String, onClose: () -> Unit) {
         repo.save((original ?: ClockAlarm()).copy(hour = parsed.hour, minute = parsed.minute, days = selected, enabled = enabled))
         onClose()
     }
-    SidekitScaffold(modifier = Modifier.focusRequester(focus).focusable(), title = if (id == "new") "New alarm" else "Edit alarm",
+    SidekitScaffold(focusParking = focus, title = if (id == "new") "New alarm" else "Edit alarm",
         actions = if (deleting) listOf(SideAction("cancel", "Cancel", SidekitIcon.ArrowLeftAlt, motion = ActionMotion.Back) { deleting = false }, SideAction("main", "Delete", SidekitIcon.DeleteForever, tone = ActionTone.Destructive) { repo.deleteWithUndo(id); onClose() })
         else listOf(SideAction("cancel", "Cancel", SidekitIcon.ArrowLeftAlt, motion = ActionMotion.Back, onClick = onClose), SideAction("main", "Save", SidekitIcon.Check, iconAtEnd = true, tone = ActionTone.Secondary, motion = ActionMotion.Up, onClick = ::save)),
         options = if (id == "new") emptyList() else listOf(SideAction("delete", "Delete", SidekitIcon.DeleteForever) { deleting = true })) { padding ->
         val list = rememberLazyListState()
         SidekitList(padding, state = list) {
-            item { SidekitCard(Modifier.listFade(list, 0).fillMaxWidth()) { SidekitTextField(time, { time = it }, placeholder = "HH:mm", singleLine = true, focusOnKeypad = true, autoFocus = id == "new", onDone = { focus.requestFocus() }) } }
+            item { SidekitCard(Modifier.listFade(list, 0).fillMaxWidth()) { SidekitTextField(time, { time = it }, placeholder = "HH:mm", singleLine = true, dictation = false, focusOnKeypad = true, autoFocus = id == "new", onDone = { focus.requestFocus() }) } }
             item { SidekitItem(if (enabled) "Alarm on" else "Alarm off", Modifier.listFade(list, 1), onClick = { enabled = !enabled }) }
             error?.let { item { SidekitItem(it, Modifier.listFade(list, 2)) } }
             (1..7).forEach { day -> item { SidekitItem(java.time.DayOfWeek.of(day).name.lowercase().replaceFirstChar { it.uppercase() }, Modifier.listFade(list, day + 2), secondary = if (day in selected) "Repeat" else "", onClick = { days = (if (day in selected) selected - day else selected + day).sorted().joinToString(",") }) } }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/health/HealthLive.kt b/app/src/main/java/hrln/interactive/sidekit/apps/health/HealthLive.kt
index 13b5bff2..c97521b9 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/health/HealthLive.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/health/HealthLive.kt
@@ -63,7 +63,7 @@ fun LiveHealth(page: String, onHistory: () -> Unit, onGoals: () -> Unit, onBack:
         SidekitList(padding, state = list) {
             when (page) {
                 "goals" -> {
-                    item { SidekitTile(Modifier.listFade(list, 0)) { SidekitTextField(goal, { goal = it }, Modifier.fillMaxWidth().padding(SidekitTheme.spacing.itemPadding), placeholder = "Steps per day", singleLine = true, focusOnKeypad = true, autoFocus = true, onDone = { if (vm.saveGoal(goal)) onBack() else message = "Enter a goal from 1 to 100000" }) } }
+                    item { SidekitTile(Modifier.listFade(list, 0)) { SidekitTextField(goal, { goal = it }, Modifier.fillMaxWidth().padding(SidekitTheme.spacing.itemPadding), placeholder = "Steps per day", singleLine = true, dictation = false, focusOnKeypad = true, autoFocus = true, onDone = { if (vm.saveGoal(goal)) onBack() else message = "Enter a goal from 1 to 100000" }) } }
                     item { OutdoorInfo(message, modifier = Modifier.listFade(list, 1)) }
                 }
                 "history" -> {
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/mail/MailAccountScreen.kt b/app/src/main/java/hrln/interactive/sidekit/apps/mail/MailAccountScreen.kt
index 6a78e8a1..f6f8a526 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/mail/MailAccountScreen.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/mail/MailAccountScreen.kt
@@ -37,9 +37,9 @@ fun MailAccountScreen(account: ImapSmtpAccount, onBack: () -> Unit, onConnected:
             item { SidekitTextField(username, { username = it }, Modifier.fillMaxWidth(), placeholder = "Username (or email)", singleLine = true) }
             item { hrln.interactive.sidekit.apps.integrations.SecretField(password, { password = it }, if (config == null) "App password" else "App password (blank keeps saved)") }
             item { SidekitTextField(imap, { imap = it }, Modifier.fillMaxWidth(), placeholder = "IMAP host", singleLine = true) }
-            item { SidekitTextField(imapPort, { imapPort = it }, Modifier.fillMaxWidth(), placeholder = "IMAP TLS port (993)", singleLine = true) }
+            item { SidekitTextField(imapPort, { imapPort = it }, Modifier.fillMaxWidth(), placeholder = "IMAP TLS port (993)", singleLine = true, dictation = false) }
             item { SidekitTextField(smtp, { smtp = it }, Modifier.fillMaxWidth(), placeholder = "SMTP host", singleLine = true) }
-            item { SidekitTextField(port, { port = it }, Modifier.fillMaxWidth(), placeholder = "SMTP port (465 or 587)", singleLine = true) }
+            item { SidekitTextField(port, { port = it }, Modifier.fillMaxWidth(), placeholder = "SMTP port (465 or 587)", singleLine = true, dictation = false) }
         }
     }
 }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/maps/OutdoorData.kt b/app/src/main/java/hrln/interactive/sidekit/apps/maps/OutdoorData.kt
index 2a0a9520..9d8f36e8 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/maps/OutdoorData.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/maps/OutdoorData.kt
@@ -4,8 +4,11 @@ import android.Manifest
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
+import android.location.Address
+import android.location.Geocoder
 import android.location.LocationManager
 import android.net.Uri
+import android.os.Build
 import android.os.CancellationSignal
 import android.util.AtomicFile
 import androidx.core.content.ContextCompat
@@ -128,7 +131,43 @@ suspend fun locate(context: Context): Place? = withTimeoutOrNull(15_000) {
             send(location)
         } }
     }.firstOrNull { it != null }
-    fix?.let { Place("Current location", it.latitude, it.longitude) }
+    fix?.let { Place(CURRENT_LOCATION, it.latitude, it.longitude) }
+}
+
+const val CURRENT_LOCATION = "Current location"
+
+/** "Current location · Madrid", or just "Current location" when the town is unknown. */
+fun currentLocationName(city: String?) = if (city.isNullOrBlank()) CURRENT_LOCATION else "$CURRENT_LOCATION · $city"
+
+/** A fix from [locate], whether or not its town has been looked up yet. */
+val Place.isCurrentLocation get() = name == CURRENT_LOCATION || name.startsWith("$CURRENT_LOCATION · ")
+
+/**
+ * The town or city at [place], from the platform geocoder. Null when the device has no geocoder,
+ * is offline, or nothing comes back within a few seconds.
+ */
+suspend fun cityName(context: Context, place: Place): String? = withTimeoutOrNull(5_000) {
+    if (!Geocoder.isPresent()) return@withTimeoutOrNull null
+    val geocoder = Geocoder(context)
+    val address: Address? = try {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) suspendCancellableCoroutine { continuation ->
+            geocoder.getFromLocation(place.latitude, place.longitude, 1, object : Geocoder.GeocodeListener {
+                override fun onGeocode(addresses: MutableList<Address>) { if (continuation.isActive) continuation.resume(addresses.firstOrNull()) }
+                override fun onError(errorMessage: String?) { if (continuation.isActive) continuation.resume(null) }
+            })
+        } else suspendCancellableCoroutine { continuation ->
+            // Not withContext(IO): that would wait out the blocking call even after the timeout,
+            // so the 5 s cap would never apply. A resume after cancellation is ignored.
+            Dispatchers.IO.asExecutor().execute {
+                val found = try {
+                    @Suppress("DEPRECATION")
+                    geocoder.getFromLocation(place.latitude, place.longitude, 1)?.firstOrNull()
+                } catch (_: java.io.IOException) { null } catch (_: IllegalArgumentException) { null }
+                continuation.resume(found)
+            }
+        }
+    } catch (_: java.io.IOException) { null } catch (_: IllegalArgumentException) { null }
+    address?.run { locality ?: subAdminArea ?: adminArea }?.takeIf(String::isNotBlank)
 }
 
 fun openDirections(context: Context, to: Place): Boolean {
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/maps/RasterMap.kt b/app/src/main/java/hrln/interactive/sidekit/apps/maps/RasterMap.kt
index 65f228b6..a7ab42e9 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/maps/RasterMap.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/maps/RasterMap.kt
@@ -1,11 +1,15 @@
 package hrln.interactive.sidekit.apps.maps
 
+import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.Canvas
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.input.InputMode
+import androidx.compose.ui.platform.LocalInputModeManager
 import androidx.compose.foundation.gestures.detectTransformGestures
 import androidx.compose.foundation.focusable
 import androidx.compose.foundation.layout.*
@@ -19,6 +23,7 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.unit.*
 import hrln.interactive.sidekit.design.components.*
 import hrln.interactive.sidekit.design.theme.SidekitTheme
+import hrln.interactive.sidekit.design.theme.drawFocusRing
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 import java.io.File
@@ -47,6 +52,22 @@ fun RasterMap(center: Place, current: Place?, destination: Place?, zoomChange: I
     LaunchedEffect(zoomChange) { if (zoomChange != 0) viewport = viewport.zoomBy(if (zoomChange > 0) 1 else -1) }
     val focus = remember { FocusRequester() }
     LaunchedEffect(Unit) { focus.requestFocus() }
+    // The D-pad moves focus past the map like any row; OK on the map hands it the arrows to pan
+    // with, and OK or Back hands them back.
+    var focused by remember { mutableStateOf(false) }
+    // The map takes focus as it opens, even by touch; the ring only means something on the D-pad.
+    val keyboardMode = LocalInputModeManager.current.inputMode == InputMode.Keyboard
+    var panning by remember { mutableStateOf(false) }
+    BackHandler(enabled = panning) { panning = false }
+    var tilesMissing by remember { mutableStateOf<Boolean?>(null) }
+    LaunchedEffect(tilesMissing, panning) {
+        onStatus(when {
+            tilesMissing == null -> return@LaunchedEffect
+            tilesMissing == true -> "Some tiles unavailable · location and search still work"
+            panning -> "Panning · d-pad moves the map; OK or Back to stop"
+            else -> "Map ready · drag, or OK to pan with the d-pad; Options to zoom"
+        })
+    }
     val colors = SidekitTheme.colors
     WhileVisible(repository) {
         try {
@@ -65,18 +86,20 @@ fun RasterMap(center: Place, current: Place?, destination: Place?, zoomChange: I
                     if (bitmap != null) tiles[key] = bitmap else missing = true
                 }
                 loaded = tiles
-                onStatus(if (missing) "Some tiles unavailable · location and search still work" else "Map ready · drag or use d-pad; Options to zoom")
+                tilesMissing = missing
             }
         } finally { repository.clearMemory(); loaded = emptyMap() }
     }
     SidekitTile(Modifier.fillMaxWidth().height(263.dp)) {
         Canvas(Modifier.fillMaxSize().onSizeChanged { canvasSize = it }.focusRequester(focus)
+            .onFocusChanged { focused = it.isFocused; if (!it.isFocused) panning = false }
             .onKeyEvent { e ->
                 if (e.type != KeyEventType.KeyDown) false else when (e.key) {
-                    Key.DirectionLeft -> { viewport = viewport.pan(-.5, 0.0); true }
-                    Key.DirectionRight -> { viewport = viewport.pan(.5, 0.0); true }
-                    Key.DirectionUp -> { viewport = viewport.pan(0.0, -.5); true }
-                    Key.DirectionDown -> { viewport = viewport.pan(0.0, .5); true }
+                    Key.DirectionCenter, Key.Enter, Key.NumPadEnter -> { if (e.nativeKeyEvent.repeatCount == 0) panning = !panning; true }
+                    Key.DirectionLeft -> panning.also { if (it) viewport = viewport.pan(-.5, 0.0) }
+                    Key.DirectionRight -> panning.also { if (it) viewport = viewport.pan(.5, 0.0) }
+                    Key.DirectionUp -> panning.also { if (it) viewport = viewport.pan(0.0, -.5) }
+                    Key.DirectionDown -> panning.also { if (it) viewport = viewport.pan(0.0, .5) }
                     Key.Plus, Key.Equals -> { viewport = viewport.zoomBy(1); true }
                     Key.Minus -> { viewport = viewport.zoomBy(-1); true }
                     else -> false
@@ -102,6 +125,7 @@ fun RasterMap(center: Place, current: Place?, destination: Place?, zoomChange: I
             }
             current?.let { marker(it, colors.primaryA1) }
             destination?.let { marker(it, colors.dangerA1) }
+            if (focused && keyboardMode) drawFocusRing(1f)
         }
         Box(Modifier.align(androidx.compose.ui.Alignment.BottomEnd).background(colors.surfaceA1).clickable {
             try { context.startActivity(android.content.Intent(android.content.Intent.ACTION_VIEW, android.net.Uri.parse("https://www.openstreetmap.org/copyright"))) } catch (_: android.content.ActivityNotFoundException) { }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/music/MusicScreens.kt b/app/src/main/java/hrln/interactive/sidekit/apps/music/MusicScreens.kt
index 520c71e7..0b4d34fe 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/music/MusicScreens.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/music/MusicScreens.kt
@@ -326,7 +326,7 @@ private fun backToMusic(onBack: () -> Unit) = listOf(SideAction.back("back", "Mu
 @Composable
 private fun SearchHeader(query: String, onQueryChange: (String) -> Unit, focusRequester: FocusRequester) {
     val spacing = SidekitTheme.spacing
-    Box(Modifier.fillMaxWidth().height(spacing.headerHeight).padding(horizontal = spacing.itemPadding).padding(top = spacing.itemPadding)) {
+    Box(Modifier.fillMaxWidth().height(spacing.headerHeight).padding(horizontal = spacing.itemPadding).padding(top = spacing.headerPaddingTop)) {
         SidekitTextField(query, onQueryChange, Modifier.fillMaxWidth().semantics { contentDescription = "Search music" }, textStyle = SidekitTheme.typography.title, placeholder = "Search here", focusRequester = focusRequester, focusOnKeypad = true, singleLine = true, autoFocus = true)
     }
 }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/phonebook/PhoneAccess.kt b/app/src/main/java/hrln/interactive/sidekit/apps/phonebook/PhoneAccess.kt
index 017178c3..95f38055 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/phonebook/PhoneAccess.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/phonebook/PhoneAccess.kt
@@ -31,6 +31,7 @@ import androidx.compose.ui.input.key.onPreviewKeyEvent
 import androidx.compose.ui.platform.LocalContext
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.compose.LifecycleResumeEffect
+import hrln.interactive.sidekit.design.action.KeysFromActionBar
 import java.util.Locale
 
 /**
@@ -122,8 +123,12 @@ object PhoneFormat {
 
 /**
  * Keypad digits for screens that take a number, not text (the contacts search and the dial pad).
- * The screen's body takes focus so presses reach it; `0`-`9`, `*`, `#` and Delete are delivered on
- * key down, and holding `0` asks for a "+".
+ * `0`-`9`, `*`, `#` and Delete are delivered on key down, and holding `0` asks for a "+".
+ *
+ * By default the element takes focus itself so presses reach it: right for a screen that is only
+ * a number. A screen with rows to move between passes its scaffold's [parking] spot instead and
+ * puts this on the scaffold: presses then reach it from the parking spot or from any row, and
+ * the D-pad still walks the rows (a focusable list would hold focus as one invisible block).
  */
 @Composable
 fun Modifier.keypadDigits(
@@ -131,32 +136,34 @@ fun Modifier.keypadDigits(
     onDelete: () -> Unit,
     onLongZero: (() -> Unit)? = null,
     enabled: Boolean = true,
+    parking: FocusRequester? = null,
 ): Modifier {
     if (!enabled) return this
-    val focus = remember { FocusRequester() }
+    val focus = parking ?: remember { FocusRequester() }
     val key by rememberUpdatedState(onKey)
     val delete by rememberUpdatedState(onDelete)
     val longZero by rememberUpdatedState(onLongZero)
     LaunchedEffect(focus) { runCatching { focus.requestFocus() } }
-    return this
-        .focusRequester(focus)
-        .onPreviewKeyEvent { e ->
-            val native = e.nativeKeyEvent
-            val c = when (native.keyCode) {
-                in KeyEvent.KEYCODE_0..KeyEvent.KEYCODE_9 -> '0' + (native.keyCode - KeyEvent.KEYCODE_0)
-                KeyEvent.KEYCODE_STAR -> '*'
-                KeyEvent.KEYCODE_POUND -> '#'
-                KeyEvent.KEYCODE_DEL -> '\b'
-                else -> return@onPreviewKeyEvent false
-            }
-            if (native.action == KeyEvent.ACTION_DOWN) {
-                when {
-                    native.repeatCount == 0 -> if (c == '\b') delete() else key(c)
-                    native.repeatCount == 1 && c == '0' -> longZero?.invoke()
-                    native.repeatCount > 0 && c == '\b' -> delete()
-                }
+    val handle: (androidx.compose.ui.input.key.KeyEvent) -> Boolean = handle@{ e ->
+        val native = e.nativeKeyEvent
+        val c = when (native.keyCode) {
+            in KeyEvent.KEYCODE_0..KeyEvent.KEYCODE_9 -> '0' + (native.keyCode - KeyEvent.KEYCODE_0)
+            KeyEvent.KEYCODE_STAR -> '*'
+            KeyEvent.KEYCODE_POUND -> '#'
+            KeyEvent.KEYCODE_DEL -> '\b'
+            else -> return@handle false
+        }
+        if (native.action == KeyEvent.ACTION_DOWN) {
+            when {
+                native.repeatCount == 0 -> if (c == '\b') delete() else key(c)
+                native.repeatCount == 1 && c == '0' -> longZero?.invoke()
+                native.repeatCount > 0 && c == '\b' -> delete()
             }
-            true
         }
-        .focusable()
+        true
+    }
+    // With rows to move between, focus can also reach the action bar, which is outside this element.
+    if (parking != null) KeysFromActionBar(handle)
+    val digits = Modifier.onPreviewKeyEvent(handle)
+    return if (parking != null) then(digits) else focusRequester(focus).then(digits).focusable()
 }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/phonebook/PhonebookScreens.kt b/app/src/main/java/hrln/interactive/sidekit/apps/phonebook/PhonebookScreens.kt
index c508f0e4..acefb060 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/phonebook/PhonebookScreens.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/phonebook/PhonebookScreens.kt
@@ -16,6 +16,7 @@ import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
+import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -91,13 +92,15 @@ fun PhonebookHomeScreen(
         if (searching) SideAction("dial", "Dial pad", onClick = onDialPad) else null,
     )
 
-    SidekitScaffold(title = "Phonebook", actions = actions, options = options) { padding ->
+    val parking = remember { FocusRequester() }
+    SidekitScaffold(
+        title = "Phonebook", actions = actions, options = options, focusParking = parking,
+        modifier = Modifier.keypadDigits(onKey = { if (it in '0'..'9') onDigit(it) }, onDelete = onDelete, parking = parking),
+    ) { padding ->
         val listState = rememberLazyListState()
         SidekitList(
             padding,
-            Modifier
-                .testTag(PhonebookTags.CONTACTS)
-                .keypadDigits(onKey = { if (it in '0'..'9') onDigit(it) }, onDelete = onDelete),
+            Modifier.testTag(PhonebookTags.CONTACTS),
             state = listState,
         ) {
             var index = 0
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/settings/CompactLayout.kt b/app/src/main/java/hrln/interactive/sidekit/apps/settings/CompactLayout.kt
new file mode 100644
index 00000000..b8acbba4
--- /dev/null
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/settings/CompactLayout.kt
@@ -0,0 +1,25 @@
+package hrln.interactive.sidekit.apps.settings
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+
+/**
+ * The compact-layout choice, read where the theme is built (MainActivity) so toggling it in
+ * Settings re-lays out the whole app on the next frame. The listener mirrors
+ * [rememberCaseColour]: the preference is written from another screen, so it has to be observed
+ * rather than read once.
+ */
+@Composable
+internal fun rememberCompactLayout(prefs: SidekitPreferences): Boolean {
+    var compact by remember(prefs) { mutableStateOf(prefs.compactLayout) }
+    DisposableEffect(prefs) {
+        val stop = prefs.observeCompactLayout { compact = prefs.compactLayout }
+        compact = prefs.compactLayout
+        onDispose { stop() }
+    }
+    return compact
+}
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/settings/SettingsScreen.kt b/app/src/main/java/hrln/interactive/sidekit/apps/settings/SettingsScreen.kt
index 49c55b0b..515f53e5 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/settings/SettingsScreen.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/settings/SettingsScreen.kt
@@ -1,6 +1,5 @@
 package hrln.interactive.sidekit.apps.settings
 
-import hrln.interactive.sidekit.onboarding.OnboardingScreen
 import android.app.ActivityManager
 import android.app.role.RoleManager
 import android.app.usage.StorageStatsManager
@@ -13,23 +12,26 @@ import android.provider.Settings
 import android.text.format.Formatter
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.height
-import hrln.interactive.sidekit.apps.everyday.CompactRowHeight
-import hrln.interactive.sidekit.design.theme.SidekitTheme
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.lifecycle.compose.LifecycleResumeEffect
 import androidx.navigation.NavGraphBuilder
 import androidx.navigation.NavHostController
 import androidx.navigation.compose.composable
+import hrln.interactive.sidekit.R
+import hrln.interactive.sidekit.apps.everyday.CompactRowHeight
 import hrln.interactive.sidekit.design.action.SideAction
 import hrln.interactive.sidekit.design.components.*
-import hrln.interactive.sidekit.design.input.LocalKeypad
 import hrln.interactive.sidekit.design.input.KeypadModule
+import hrln.interactive.sidekit.design.input.LocalKeypad
 import hrln.interactive.sidekit.design.input.T9Mode
+import hrln.interactive.sidekit.design.theme.SidekitTheme
 import hrln.interactive.sidekit.navigation.SubApp
+import hrln.interactive.sidekit.onboarding.OnboardingScreen
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
@@ -43,7 +45,7 @@ fun NavGraphBuilder.settingsGraph(nav: NavHostController) {
             onHiddenApps = { nav.navigate("${SubApp.Settings.route}/hidden-apps") },
             onSystem = { nav.navigate("${SubApp.Settings.route}/system") },
             onKeypadMapping = { nav.navigate(keypadMappingRoute()) },
-            onArrange = { nav.navigate("${SubApp.Settings.route}/arrange") },
+            onArrange = { nav.navigate("${SubApp.Settings.route}/arrange") }
         )
     }
     keypadMappingGraph(nav)
@@ -63,28 +65,56 @@ internal fun SettingsHome(onHome: () -> Unit, onAbout: () -> Unit, onCaseColour:
     val keypad = LocalKeypad.current
     var revision by remember { mutableIntStateOf(0) }
     var message by remember { mutableStateOf<String?>(null) }
-    LifecycleResumeEffect(Unit) { revision++; onPauseOrDispose {} }
+    LifecycleResumeEffect(Unit) {
+        revision++
+        onPauseOrDispose {}
+    }
     val accessibility = remember(revision) {
         val enabled = Settings.Secure.getString(context.contentResolver, Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES).orEmpty()
         enabled.split(':').mapNotNull(ComponentName::unflattenFromString).any { it.packageName == context.packageName && it.className.endsWith("KeypadAccessibilityService") }
     }
     val home = remember(revision) { context.getSystemService(RoleManager::class.java).isRoleHeld(RoleManager.ROLE_HOME) }
-    fun open(action: String) { try { context.startActivity(Intent(action)) } catch (_: Exception) { message = "This settings screen is unavailable on this device." } }
+    fun open(action: String) {
+        try {
+            context.startActivity(Intent(action))
+        } catch (_: Exception) {
+            message = "This settings screen is unavailable on this device."
+        }
+    }
     val listLayout = remember(revision) { prefs.listLayout }
+    val compactLayout = remember(revision) { prefs.compactLayout }
     val inputMode = remember(revision) { prefs.inputMode }
     val list = rememberLazyListState()
     SidekitScaffold("Settings", actions = listOf(SideAction.back("home", "Home", onHome), SideAction.forward("about", "About", onAbout))) { padding ->
         SidekitList(padding, state = list) {
-            item { SidekitItem("Launcher default", Modifier.height(CompactRowHeight).listFade(list, 0), secondary = if (listLayout) "List" else "Grid", onClick = { prefs.listLayout = !prefs.listLayout; revision++ }) }
+            item {
+                SidekitItem("Launcher default", Modifier.height(CompactRowHeight).listFade(list, 0), secondary = if (listLayout) "List" else "Grid", onClick = {
+                    prefs.listLayout = !prefs.listLayout
+                    revision++
+                })
+            }
             item { SidekitItem("Arrange apps", Modifier.height(CompactRowHeight).listFade(list, 1), secondary = "Home order & dock", onClick = onArrange) }
             item { SidekitItem("Case colour", Modifier.height(CompactRowHeight).listFade(list, 2), secondary = caseColour?.label ?: "Original blue", onClick = onCaseColour) }
+            // Shorter header and action bar on every screen: more room for the body.
+            item { SidekitItem("Compact layout", Modifier.height(CompactRowHeight).listFade(list, 3), secondary = if (compactLayout) "On" else "Off", onClick = { prefs.compactLayout = !prefs.compactLayout; revision++ }) }
             // Detected from the keys pressed; tapping overrides it until another module's key is seen.
             // A custom mapping fixes the module, so then the row opens the mapping instead.
             val custom = keypad?.mapper?.customModule
-            item { SidekitItem("Keypad", Modifier.height(CompactRowHeight).listFade(list, 3), secondary = custom?.let { "${it.label} · custom" } ?: keypad?.module?.label ?: "None", onClick = { if (custom != null) onKeypadMapping() else keypad?.let { it.useModule(KeypadModule.entries[(it.module.ordinal + 1) % KeypadModule.entries.size]) }; revision++ }) }
-            item { SidekitItem("Input mode", Modifier.height(CompactRowHeight).listFade(list, 4), secondary = if (inputMode == T9Mode.Numeric) "Numbers" else "Letters", onClick = { prefs.inputMode = T9Mode.entries[(prefs.inputMode.ordinal + 1) % T9Mode.entries.size]; keypad?.let { prefs.applyInputDefault(it) }; revision++ }) }
-            item { SidekitItem("Keypad Back key", Modifier.height(CompactRowHeight).listFade(list, 5), secondary = if (accessibility) "Enabled" else "Enable", onClick = { open(Settings.ACTION_ACCESSIBILITY_SETTINGS) }) }
-            item { SidekitItem("Home app", Modifier.height(CompactRowHeight).listFade(list, 6), secondary = if (home) "Sidekit" else "Choose", onClick = { open(Settings.ACTION_HOME_SETTINGS) }) }
+            item {
+                SidekitItem("Keypad", Modifier.height(CompactRowHeight).listFade(list, 4), secondary = custom?.let { "${it.label} · custom" } ?: keypad?.module?.label ?: "None", onClick = {
+                    if (custom != null) onKeypadMapping() else keypad?.let { it.useModule(KeypadModule.entries[(it.module.ordinal + 1) % KeypadModule.entries.size]) }
+                    revision++
+                })
+            }
+            item {
+                SidekitItem("Input mode", Modifier.height(CompactRowHeight).listFade(list, 5), secondary = if (inputMode == T9Mode.Numeric) "Numbers" else "Letters", onClick = {
+                    prefs.inputMode = T9Mode.entries[(prefs.inputMode.ordinal + 1) % T9Mode.entries.size]
+                    keypad?.let { prefs.applyInputDefault(it) }
+                    revision++
+                })
+            }
+            item { SidekitItem("Keypad Back key", Modifier.height(CompactRowHeight).listFade(list, 6), secondary = if (accessibility) "Enabled" else "Enable", onClick = { open(Settings.ACTION_ACCESSIBILITY_SETTINGS) }) }
+            item { SidekitItem("Home app", Modifier.height(CompactRowHeight).listFade(list, 7), secondary = if (home) "Sidekit" else "Choose", onClick = { open(Settings.ACTION_HOME_SETTINGS) }) }
             item { SidekitItem("Hide apps", showLinkArrow = true, onClick = onHiddenApps) }
             // Device settings live on their own page, so this screen stays Sidekit's own settings.
             item { SidekitItem("System settings", showLinkArrow = true, onClick = onSystem) }
@@ -101,7 +131,13 @@ internal fun SettingsHome(onHome: () -> Unit, onAbout: () -> Unit, onCaseColour:
 internal fun SystemSettingsScreen(back: () -> Unit) {
     val context = LocalContext.current
     var message by remember { mutableStateOf<String?>(null) }
-    fun open(action: String) { try { context.startActivity(Intent(action)) } catch (_: Exception) { message = "This settings screen is unavailable on this device." } }
+    fun open(action: String) {
+        try {
+            context.startActivity(Intent(action))
+        } catch (_: Exception) {
+            message = "This settings screen is unavailable on this device."
+        }
+    }
     val list = rememberLazyListState()
     SidekitScaffold("System settings", actions = listOf(SideAction.back("back", "Settings", back))) { padding ->
         SidekitList(padding, state = list) {
@@ -123,6 +159,10 @@ fun SettingsScreen(rows: List<SettingRow>, onRowClick: (SettingKey) -> Unit, onH
 @Composable
 private fun AboutScreen(back: () -> Unit) {
     val context = LocalContext.current
+    // The name comes from resources, so the dev build says "SideKit Dev" instead of the stable
+    // name, and names itself and its package on its own row.
+    val appName = stringResource(R.string.app_name)
+    val devBuild = context.resources.getBoolean(R.bool.is_dev_build)
     var rows by remember { mutableStateOf(listOf("Device" to "${Build.MANUFACTURER} ${Build.MODEL}", "Android" to "${Build.VERSION.RELEASE} (API ${Build.VERSION.SDK_INT})", "Build" to Build.DISPLAY)) }
     LaunchedEffect(Unit) {
         val summaries = withContext(Dispatchers.IO) {
@@ -131,17 +171,28 @@ private fun AboutScreen(back: () -> Unit) {
                 val stats = context.getSystemService(StorageStatsManager::class.java)
                 "${Formatter.formatFileSize(context, stats.getFreeBytes(StorageManager.UUID_DEFAULT))} free / ${Formatter.formatFileSize(context, stats.getTotalBytes(StorageManager.UUID_DEFAULT))}"
             }.getOrDefault("Unavailable")
-            listOf("Sidekit" to context.packageManager.getPackageInfo(context.packageName, 0).versionName.orEmpty(),
-                "Storage" to storage, "RAM" to "${Formatter.formatFileSize(context, memory.availMem)} available / ${Formatter.formatFileSize(context, memory.totalMem)}",
-                "Open-source notices" to "AndroidX / Jetpack Compose — Apache License 2.0. Kotlin — Apache License 2.0.",
-                "T9 word list" to context.assets.open("t9/NOTICE").bufferedReader().use { it.readText() })
+            buildList {
+                add(appName to context.packageManager.getPackageInfo(context.packageName, 0).versionName.orEmpty())
+                if (devBuild) add("Dev build" to "Installs alongside Sidekit as ${context.packageName}")
+                add("Storage" to storage)
+                add("RAM" to "${Formatter.formatFileSize(context, memory.availMem)} available / ${Formatter.formatFileSize(context, memory.totalMem)}")
+                add("Open-source notices" to "AndroidX / Jetpack Compose — Apache License 2.0. Kotlin — Apache License 2.0.")
+                add("T9 word list" to context.assets.open("t9/NOTICE").bufferedReader().use { it.readText() })
+            }
         }
         rows = rows + summaries
     }
     val list = rememberLazyListState()
     SidekitScaffold("About", actions = listOf(SideAction.back("back", "Settings", back))) { padding ->
-        SidekitList(padding, state = list) { itemsIndexed(rows) { index, row -> SidekitCard(Modifier.listFade(list, index)) {
-                Column { SidekitText(row.first, style = SidekitTheme.typography.headline); SidekitText(row.second, style = SidekitTheme.typography.label, maxLines = Int.MAX_VALUE) }
-            } } }
+        SidekitList(padding, state = list) {
+            itemsIndexed(rows) { index, row ->
+                SidekitCard(Modifier.listFade(list, index)) {
+                    Column {
+                        SidekitText(row.first, style = SidekitTheme.typography.headline)
+                        SidekitText(row.second, style = SidekitTheme.typography.label, maxLines = Int.MAX_VALUE)
+                    }
+                }
+            }
+        }
     }
 }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/settings/SettingsViewModel.kt b/app/src/main/java/hrln/interactive/sidekit/apps/settings/SettingsViewModel.kt
index 265c6436..281c9a05 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/settings/SettingsViewModel.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/settings/SettingsViewModel.kt
@@ -43,6 +43,18 @@ class SidekitPreferences(context: Context) {
     var listLayout: Boolean
         get() = prefs.getBoolean("list_layout", false)
         set(value) { prefs.edit().putBoolean("list_layout", value).apply() }
+    /** Shorter header and action bar; see `SidekitSpacing.Compact` in the design module. */
+    var compactLayout: Boolean
+        get() = prefs.getBoolean("compact_layout", false)
+        set(value) { prefs.edit().putBoolean("compact_layout", value).apply() }
+
+    fun observeCompactLayout(onChange: () -> Unit): () -> Unit {
+        val listener = SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
+            if (key == "compact_layout" || key == null) onChange()
+        }
+        prefs.registerOnSharedPreferenceChangeListener(listener)
+        return { prefs.unregisterOnSharedPreferenceChangeListener(listener) }
+    }
     var inputMode: T9Mode
         get() = T9Mode.entries.firstOrNull { it.name == prefs.getString("input_mode", null) } ?: T9Mode.MultiTap
         set(value) { prefs.edit().putString("input_mode", value.name).apply() }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/sideport/SideportGraph.kt b/app/src/main/java/hrln/interactive/sidekit/apps/sideport/SideportGraph.kt
index 5ab6d2e9..c28370f8 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/sideport/SideportGraph.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/sideport/SideportGraph.kt
@@ -36,7 +36,10 @@ import androidx.navigation.NavGraphBuilder
 import androidx.navigation.NavHostController
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.navigation
+import hrln.interactive.sidekit.apps.apps.AppRow
+import hrln.interactive.sidekit.apps.apps.AppSearchField
 import hrln.interactive.sidekit.apps.apps.AppsRepository
+import hrln.interactive.sidekit.apps.apps.LaunchableApp
 import hrln.interactive.sidekit.apps.apps.matchesApp
 import hrln.interactive.sidekit.apps.everyday.CompactRowHeight
 import hrln.interactive.sidekit.apps.sideport.bridge.Bridge
@@ -63,6 +66,7 @@ import hrln.interactive.sidekit.design.components.SidekitTextField
 import hrln.interactive.sidekit.design.components.listFade
 import hrln.interactive.sidekit.design.icons.SidekitIcon
 import hrln.interactive.sidekit.design.theme.SidekitTheme
+import hrln.interactive.sidekit.system.SidekitBuild
 import kotlinx.coroutines.launch
 
 /**
@@ -76,7 +80,7 @@ fun NavGraphBuilder.sideportGraph(nav: NavHostController) {
             SideportHomeScreen(
                 onHome = { nav.popBackStack() },
                 onAdd = { nav.navigate(SideportRoutes.ADD) { launchSingleTop = true } },
-                onHub = { nav.navigate(SideportRoutes.hub(it)) { launchSingleTop = true } },
+                onHub = { nav.navigate(SideportRoutes.hub(it)) { launchSingleTop = true } }
             )
         }
         composable(SideportRoutes.ADD) { SideportAddScreen(onDone = { nav.popBackStack() }) }
@@ -86,7 +90,7 @@ fun NavGraphBuilder.sideportGraph(nav: NavHostController) {
                 pkg,
                 onBack = { nav.popBackStack() },
                 onChat = { nav.navigate(SideportRoutes.chat(it)) },
-                onPlayer = { nav.navigate(SideportRoutes.player(pkg)) },
+                onPlayer = { nav.navigate(SideportRoutes.player(pkg)) }
             )
         }
         composable(SideportRoutes.CHAT) { entry ->
@@ -108,10 +112,12 @@ private fun Context.openSettings(action: String, data: Uri? = null): Boolean = t
 /** Opens a ported app, explaining what's missing if it can't. Returns a message to show, if any. */
 fun openPorted(context: Context, app: PortedApp): String? = when (Sideport.open(context, app)) {
     OpenResult.Opened -> null
+
     OpenResult.NeedsService -> {
         context.openSettings(Settings.ACTION_ACCESSIBILITY_SETTINGS)
         "Turn on \"Sideport projection\" in Accessibility, then open ${app.label} again."
     }
+
     OpenResult.NotInstalled -> "${app.label} isn't installed any more. Hold it in Sideport and choose Remove from Sideport."
 }
 
@@ -133,14 +139,17 @@ internal fun SideportHomeScreen(onHome: () -> Unit, onAdd: () -> Unit, onHub: (S
     val list = rememberLazyListState()
     SidekitScaffold(
         "Sideport",
-        actions = listOf(SideAction.back("home", "Home", onHome), SideAction.forward("add", "Add app", onAdd)),
+        actions = listOf(SideAction.back("home", "Home", onHome), SideAction.forward("add", "Add app", onAdd))
     ) { padding ->
         SidekitList(padding, state = list) {
             var index = 0
             (message ?: installMessage(install))?.let { text ->
                 val i = index++
                 item(key = "message") {
-                    SidekitCard(Modifier.fillMaxWidth().listFade(list, i), onClick = { message = null; ApkInstaller.clear() }) {
+                    SidekitCard(Modifier.fillMaxWidth().listFade(list, i), onClick = {
+                        message = null
+                        ApkInstaller.clear()
+                    }) {
                         SidekitText(text, style = SidekitTheme.typography.label, maxLines = Int.MAX_VALUE)
                     }
                 }
@@ -152,7 +161,7 @@ internal fun SideportHomeScreen(onHome: () -> Unit, onAdd: () -> Unit, onHub: (S
                         SidekitText(
                             "Add an Android app and it opens here as a Sidekit app: its screens redrawn with Sidekit's lists and action bar, its chats and music right in Sidekit.",
                             style = SidekitTheme.typography.label,
-                            maxLines = Int.MAX_VALUE,
+                            maxLines = Int.MAX_VALUE
                         )
                     }
                 }
@@ -164,26 +173,30 @@ internal fun SideportHomeScreen(onHome: () -> Unit, onAdd: () -> Unit, onHub: (S
                     Modifier.listFade(list, start + i).combinedClickable(
                         onClick = { message = openPorted(context, app) },
                         onLongClick = { onHub(app.packageName) },
-                        onLongClickLabel = "${app.label} messages, media and options",
+                        onLongClickLabel = "${app.label} messages, media and options"
                     ),
                     secondary = if (app.mode == PortMode.Original) "Original" else null,
-                    icon = SidekitIcon.DeployedCode,
+                    icon = SidekitIcon.DeployedCode
                 )
             }
             index += apps.size
             val setup = index
             item(key = "projection") {
                 SidekitItem(
-                    "Projection", Modifier.listFade(list, setup), colour = ItemColour.Muted,
+                    "Projection",
+                    Modifier.listFade(list, setup),
+                    colour = ItemColour.Muted,
                     secondary = if (projection) "On" else "Turn on",
-                    onClick = { context.openSettings(Settings.ACTION_ACCESSIBILITY_SETTINGS) },
+                    onClick = { context.openSettings(Settings.ACTION_ACCESSIBILITY_SETTINGS) }
                 )
             }
             item(key = "bridge") {
                 SidekitItem(
-                    "Chats & media", Modifier.listFade(list, setup + 1), colour = ItemColour.Muted,
+                    "Chats & media",
+                    Modifier.listFade(list, setup + 1),
+                    colour = ItemColour.Muted,
                     secondary = if (bridge) "On" else "Turn on",
-                    onClick = { context.openSettings(Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS) },
+                    onClick = { context.openSettings(Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS) }
                 )
             }
         }
@@ -198,6 +211,21 @@ private fun installMessage(status: InstallStatus): String? = when (status) {
     is InstallStatus.Failed -> "Install failed: ${status.message}"
 }
 
+/**
+ * Installed apps that can become Sideport apps: no Sidekit build (Sidekit never ports itself or a
+ * sibling), nothing already ported, one row per package, matching [query].
+ */
+internal fun sideportCandidates(
+    installed: List<LaunchableApp>,
+    ported: List<PortedApp>,
+    query: String
+): List<LaunchableApp> {
+    val have = ported.map { it.packageName }.toSet()
+    return installed
+        .filter { !SidekitBuild.isSidekit(it.component.packageName) && it.component.packageName !in have && matchesApp(it.label, query) }
+        .distinctBy { it.component.packageName }
+}
+
 /** Install an APK, or turn an app that's already installed into a Sideport app. */
 @Composable
 internal fun SideportAddScreen(onDone: () -> Unit) {
@@ -215,11 +243,7 @@ internal fun SideportAddScreen(onDone: () -> Unit) {
             onDone()
         }
     }
-    val candidates = remember(installed, portedApps, query) {
-        val have = portedApps.map { it.packageName }.toSet()
-        installed.filter { it.component.packageName != context.packageName && it.component.packageName !in have && matchesApp(it.label, query) }
-            .distinctBy { it.component.packageName }
-    }
+    val candidates = remember(installed, portedApps, query) { sideportCandidates(installed, portedApps, query) }
     val list = rememberLazyListState()
     SidekitScaffold("Add app", actions = listOf(SideAction.back("back", "Sideport", onDone))) { padding ->
         SidekitList(padding, state = list) {
@@ -240,9 +264,9 @@ internal fun SideportAddScreen(onDone: () -> Unit) {
                     }
                 }
             }
-            item(key = "search") { SidekitTextField(query, { query = it }, placeholder = "Search installed apps", singleLine = true, focusOnKeypad = true) }
+            item(key = "search") { AppSearchField(query) { query = it } }
             itemsIndexed(candidates, key = { _, a -> a.key }) { i, app ->
-                SidekitItem(app.label, Modifier.listFade(list, i + 2), showLinkArrow = true, onClick = {
+                AppRow(app, repository, Modifier.listFade(list, i + 2), onClick = {
                     ported.add(app.component.packageName, app.label)
                     onDone()
                 })
@@ -257,7 +281,7 @@ internal enum class HubRemoval(val verb: String) {
     Remove("Remove"),
 
     /** Hand the app to Android's uninstaller. */
-    Uninstall("Uninstall"),
+    Uninstall("Uninstall")
 }
 
 /** What a ported app's hub shows. [version] is null while the app isn't installed. */
@@ -268,7 +292,7 @@ internal data class SideportHubUiState(
     val mediaTitle: String? = null,
     val bridgeOn: Boolean = false,
     val message: String? = null,
-    val confirming: HubRemoval? = null,
+    val confirming: HubRemoval? = null
 )
 
 /**
@@ -296,7 +320,10 @@ internal fun SideportHubScreen(pkg: String, onBack: () -> Unit, onChat: (String)
     var message by remember { mutableStateOf<String?>(null) }
     var confirming by remember { mutableStateOf<HubRemoval?>(null) }
     // Coming back from the system uninstaller, the header says whether the app is still there.
-    LifecycleResumeEffect(pkg) { version = appVersion(context, pkg); onPauseOrDispose {} }
+    LifecycleResumeEffect(pkg) {
+        version = appVersion(context, pkg)
+        onPauseOrDispose {}
+    }
     val mediaTitle = media[pkg]?.let { it.metadata?.getString(MediaMetadata.METADATA_KEY_TITLE) ?: "Now playing" }
     SideportHubContent(
         SideportHubUiState(app, version, chats, mediaTitle, bridgeOn, message, confirming),
@@ -310,8 +337,11 @@ internal fun SideportHubScreen(pkg: String, onBack: () -> Unit, onChat: (String)
         onDismissMessage = { message = null },
         onAsk = { confirming = it },
         onCancel = { confirming = null },
-        onRemove = { ported.remove(pkg); onBack() },
-        onUninstall = { context.startActivity(Intent(Intent.ACTION_DELETE, Uri.parse("package:$pkg")).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)) },
+        onRemove = {
+            ported.remove(pkg)
+            onBack()
+        },
+        onUninstall = { context.startActivity(Intent(Intent.ACTION_DELETE, Uri.parse("package:$pkg")).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)) }
     )
 }
 
@@ -335,7 +365,7 @@ internal fun SideportHubContent(
     onAsk: (HubRemoval) -> Unit,
     onCancel: () -> Unit,
     onRemove: () -> Unit,
-    onUninstall: () -> Unit,
+    onUninstall: () -> Unit
 ) {
     val app = state.app
     val list = rememberLazyListState()
@@ -347,15 +377,19 @@ internal fun SideportHubContent(
             SideAction("forward", removal.verb, SidekitIcon.DeleteForever, tone = ActionTone.Destructive, weight = 1.2f, motion = ActionMotion.Up, contentDescription = "Confirm ${removal.verb.lowercase()} ${app.label}") {
                 when (removal) {
                     HubRemoval.Remove -> onRemove()
+
                     // The uninstaller is another activity: settle the bar first, so returning from it
                     // (uninstalled or cancelled) shows the hub again, not a stale confirmation.
-                    HubRemoval.Uninstall -> { onCancel(); onUninstall() }
+                    HubRemoval.Uninstall -> {
+                        onCancel()
+                        onUninstall()
+                    }
                 }
-            },
+            }
         )
     } ?: listOf(
         SideAction.square("back", SidekitIcon.ArrowLeftAlt, "Back", onBack, tone = ActionTone.Muted, motion = ActionMotion.Back),
-        SideAction.forward("open", "Open", onOpen),
+        SideAction.forward("open", "Open", onOpen)
     )
     // Everything frequent is in the body; Options keeps the one rare action, the system app page.
     val options = if (state.version != null) listOf(SideAction("info", "App info", SidekitIcon.Settings) { onInfo() }) else emptyList()
@@ -376,27 +410,30 @@ internal fun SideportHubContent(
                 val mode = index++
                 item(key = "mode") {
                     SidekitItem(
-                        "Open as", Modifier.height(CompactRowHeight).listFade(list, mode),
+                        "Open as",
+                        Modifier.height(CompactRowHeight).listFade(list, mode),
                         secondary = if (app.mode == PortMode.Projected) "Sideport" else "Original",
-                        onClick = onMode,
+                        onClick = onMode
                     )
                 }
             }
             val remove = index++
             item(key = "remove") {
                 SidekitLineButton(
-                    "Remove from Sideport", { onAsk(HubRemoval.Remove) },
+                    "Remove from Sideport",
+                    { onAsk(HubRemoval.Remove) },
                     Modifier.height(CompactRowHeight).listFade(list, remove),
-                    variant = LineButtonVariant.Secondary,
+                    variant = LineButtonVariant.Secondary
                 )
             }
             if (state.version != null) {
                 val uninstall = index++
                 item(key = "uninstall") {
                     SidekitLineButton(
-                        "Uninstall app", { onAsk(HubRemoval.Uninstall) },
+                        "Uninstall app",
+                        { onAsk(HubRemoval.Uninstall) },
                         Modifier.height(CompactRowHeight).listFade(list, uninstall),
-                        variant = LineButtonVariant.Destructive,
+                        variant = LineButtonVariant.Destructive
                     )
                 }
             }
@@ -434,8 +471,11 @@ private fun SideportHeader(app: PortedApp, version: String?, modifier: Modifier
         Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(SidekitTheme.spacing.itemContentGap)) {
             PortedAppIcon(app, size = 56.dp)
             Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
-                if (version != null) SidekitText("Version $version", style = SidekitTheme.typography.body)
-                else SidekitText("Not installed", style = SidekitTheme.typography.body, color = SidekitTheme.colors.dangerA2)
+                if (version != null) {
+                    SidekitText("Version $version", style = SidekitTheme.typography.body)
+                } else {
+                    SidekitText("Not installed", style = SidekitTheme.typography.body, color = SidekitTheme.colors.dangerA2)
+                }
                 SidekitText(app.packageName, style = SidekitTheme.typography.tiny, color = SidekitTheme.colors.surfaceA5)
             }
         }
@@ -454,11 +494,16 @@ internal fun SideportChatScreen(key: String, onBack: () -> Unit) {
     val canReply = chat?.reply != null
     val actions = buildList {
         add(SideAction.square("back", SidekitIcon.ArrowLeftAlt, "Back", onBack, tone = ActionTone.Muted, motion = ActionMotion.Back))
-        if (canReply) add(SideAction("send", "Send", SidekitIcon.ArrowUpward, iconAtEnd = true, tone = ActionTone.Secondary, motion = ActionMotion.Up) {
-            if (draft.isBlank()) return@SideAction
-            if (Bridge.reply(context, key, draft.trim())) draft = "" else message = "This chat can't be answered from Sidekit any more. Open the app to reply."
-        })
-        else chat?.open?.let { open -> add(SideAction.forward("open", "Open chat", { runCatching { open.send() } })) }
+        if (canReply) {
+            add(
+                SideAction("send", "Send", SidekitIcon.ArrowUpward, iconAtEnd = true, tone = ActionTone.Secondary, motion = ActionMotion.Up) {
+                    if (draft.isBlank()) return@SideAction
+                    if (Bridge.reply(context, key, draft.trim())) draft = "" else message = "This chat can't be answered from Sidekit any more. Open the app to reply."
+                }
+            )
+        } else {
+            chat?.open?.let { open -> add(SideAction.forward("open", "Open chat", { runCatching { open.send() } })) }
+        }
     }
     SidekitScaffold(chat?.title ?: "Chat", actions = actions) { padding ->
         SidekitList(padding, state = list) {
@@ -486,8 +531,12 @@ internal fun SideportPlayerScreen(pkg: String, onBack: () -> Unit) {
     var playback by remember(controller) { mutableStateOf(controller?.playbackState) }
     DisposableEffect(controller) {
         val callback = object : MediaController.Callback() {
-            override fun onMetadataChanged(m: MediaMetadata?) { metadata = m }
-            override fun onPlaybackStateChanged(s: PlaybackState?) { playback = s }
+            override fun onMetadataChanged(m: MediaMetadata?) {
+                metadata = m
+            }
+            override fun onPlaybackStateChanged(s: PlaybackState?) {
+                playback = s
+            }
         }
         controller?.registerCallback(callback)
         onDispose { controller?.unregisterCallback(callback) }
@@ -498,9 +547,11 @@ internal fun SideportPlayerScreen(pkg: String, onBack: () -> Unit) {
         add(SideAction.square("back", SidekitIcon.ArrowLeftAlt, "Back", onBack, tone = ActionTone.Muted, motion = ActionMotion.Back))
         if (transport != null) {
             add(SideAction.square("prev", SidekitIcon.SkipPrevious, "Previous", { transport.skipToPrevious() }, tone = ActionTone.Muted))
-            add(SideAction(if (playing) "pause" else "play", icon = if (playing) SidekitIcon.Pause else SidekitIcon.PlayArrow, contentDescription = if (playing) "Pause" else "Play") {
-                if (playing) transport.pause() else transport.play()
-            })
+            add(
+                SideAction(if (playing) "pause" else "play", icon = if (playing) SidekitIcon.Pause else SidekitIcon.PlayArrow, contentDescription = if (playing) "Pause" else "Play") {
+                    if (playing) transport.pause() else transport.play()
+                }
+            )
             add(SideAction.square("next", SidekitIcon.SkipNext, "Next", { transport.skipToNext() }, tone = ActionTone.Muted))
         }
     }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/sideport/install/ApkInstaller.kt b/app/src/main/java/hrln/interactive/sidekit/apps/sideport/install/ApkInstaller.kt
index e333c832..84c5c579 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/sideport/install/ApkInstaller.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/sideport/install/ApkInstaller.kt
@@ -7,18 +7,20 @@ import android.content.Intent
 import android.content.pm.PackageInstaller
 import android.content.pm.PackageManager
 import android.net.Uri
+import androidx.core.content.IntentCompat
 import hrln.interactive.sidekit.apps.sideport.registry.PortedApps
+import java.io.File
+import java.util.zip.ZipFile
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.withContext
-import java.io.File
-import java.util.zip.ZipFile
 
 sealed interface InstallStatus {
     data object Idle : InstallStatus
     data class Working(val step: String) : InstallStatus
+
     /** Android is showing its install confirmation. */
     data class Confirming(val label: String) : InstallStatus
     data class Installed(val packageName: String, val label: String) : InstallStatus
@@ -40,7 +42,9 @@ object ApkInstaller {
     private val _status = MutableStateFlow<InstallStatus>(InstallStatus.Idle)
     val status: StateFlow<InstallStatus> = _status.asStateFlow()
 
-    fun clear() { _status.value = InstallStatus.Idle }
+    fun clear() {
+        _status.value = InstallStatus.Idle
+    }
 
     fun canInstall(context: Context) = context.packageManager.canRequestPackageInstalls()
 
@@ -52,7 +56,10 @@ object ApkInstaller {
     }
 
     private fun stageAndCommit(context: Context, uri: Uri) {
-        val dir = File(context.cacheDir, "sideport-install").apply { deleteRecursively(); mkdirs() }
+        val dir = File(context.cacheDir, "sideport-install").apply {
+            deleteRecursively()
+            mkdirs()
+        }
         val download = File(dir, "download")
         context.contentResolver.openInputStream(uri).use { input ->
             requireNotNull(input) { "Couldn't open the file" }
@@ -114,7 +121,8 @@ object ApkInstaller {
             val pkg = intent.getStringExtra(EXTRA_PACKAGE).orEmpty()
             when (val status = intent.getIntExtra(PackageInstaller.EXTRA_STATUS, PackageInstaller.STATUS_FAILURE)) {
                 PackageInstaller.STATUS_PENDING_USER_ACTION -> {
-                    val confirm = intent.getParcelableExtra(Intent.EXTRA_INTENT, Intent::class.java)
+                    // The typed overload is API 33 (and buggy there); IntentCompat picks the safe call per version.
+                    val confirm = IntentCompat.getParcelableExtra(intent, Intent.EXTRA_INTENT, Intent::class.java)
                     if (confirm == null) {
                         _status.value = InstallStatus.Failed("Android didn't ask to confirm the install")
                         return
@@ -122,12 +130,14 @@ object ApkInstaller {
                     _status.value = InstallStatus.Confirming(label)
                     context.startActivity(confirm.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
                 }
+
                 PackageInstaller.STATUS_SUCCESS -> {
                     PortedApps.get(context).add(pkg, label)
                     _status.value = InstallStatus.Installed(pkg, label)
                 }
+
                 else -> _status.value = InstallStatus.Failed(
-                    intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE) ?: describe(status),
+                    intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE) ?: describe(status)
                 )
             }
         }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/sideport/registry/PortedApps.kt b/app/src/main/java/hrln/interactive/sidekit/apps/sideport/registry/PortedApps.kt
index ef2b7f16..397b0494 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/sideport/registry/PortedApps.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/sideport/registry/PortedApps.kt
@@ -2,6 +2,7 @@ package hrln.interactive.sidekit.apps.sideport.registry
 
 import android.content.Context
 import android.content.SharedPreferences
+import hrln.interactive.sidekit.system.SidekitBuild
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
@@ -14,7 +15,7 @@ enum class PortMode {
     Projected,
 
     /** Shown as the app draws itself, with a small button back to the projection (games, maps, cameras). */
-    Original,
+    Original
 }
 
 /** An Android app the user has turned into a Sidekit app. */
@@ -24,7 +25,7 @@ data class PortedApp(val packageName: String, val label: String, val mode: PortM
  * The apps added to Sideport, persisted in shared preferences. One process-wide instance so the
  * launcher, the Sideport screens and the projection service see the same list.
  */
-class PortedApps private constructor(private val prefs: SharedPreferences) {
+class PortedApps internal constructor(private val prefs: SharedPreferences) {
     private val _apps = MutableStateFlow(read())
     val apps: StateFlow<List<PortedApp>> = _apps.asStateFlow()
 
@@ -32,18 +33,20 @@ class PortedApps private constructor(private val prefs: SharedPreferences) {
 
     fun contains(packageName: String) = get(packageName) != null
 
+    /** Adds [packageName], unless it is already there or is a Sidekit build: Sidekit never ports itself. */
     fun add(packageName: String, label: String) {
-        if (contains(packageName)) return
+        if (SidekitBuild.isSidekit(packageName) || contains(packageName)) return
         write(_apps.value + PortedApp(packageName, label, addedAt = System.currentTimeMillis()))
     }
 
     fun remove(packageName: String) = write(_apps.value.filterNot { it.packageName == packageName })
 
-    fun setMode(packageName: String, mode: PortMode) =
-        write(_apps.value.map { if (it.packageName == packageName) it.copy(mode = mode) else it })
+    fun setMode(packageName: String, mode: PortMode) = write(_apps.value.map { if (it.packageName == packageName) it.copy(mode = mode) else it })
 
     private fun write(list: List<PortedApp>) {
-        val sorted = list.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.label })
+        // Sidekit builds are never Sideport apps, including entries saved by an earlier version.
+        val sorted = list.filterNot { SidekitBuild.isSidekit(it.packageName) }
+            .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.label })
         _apps.value = sorted
         val array = JSONArray()
         sorted.forEach {
@@ -60,9 +63,9 @@ class PortedApps private constructor(private val prefs: SharedPreferences) {
                 packageName = o.getString("package"),
                 label = o.getString("label"),
                 mode = runCatching { PortMode.valueOf(o.optString("mode")) }.getOrDefault(PortMode.Projected),
-                addedAt = o.optLong("added"),
+                addedAt = o.optLong("added")
             )
-        }
+        }.filterNot { SidekitBuild.isSidekit(it.packageName) }
     }.getOrDefault(emptyList())
 
     companion object {
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/sideticks/SideticksScreen.kt b/app/src/main/java/hrln/interactive/sidekit/apps/sideticks/SideticksScreen.kt
index 1539baab..bcc1aaf8 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/sideticks/SideticksScreen.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/sideticks/SideticksScreen.kt
@@ -1,6 +1,5 @@
 package hrln.interactive.sidekit.apps.sideticks
 
-import androidx.compose.foundation.focusable
 import androidx.compose.foundation.layout.Arrangement
 import hrln.interactive.sidekit.design.components.SidekitSwipeRow
 import hrln.interactive.sidekit.design.components.rememberSwipeRevealGroup
@@ -21,7 +20,6 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.text.style.TextDecoration
 import hrln.interactive.sidekit.design.components.ItemColour
 import hrln.interactive.sidekit.design.components.SidekitCard
@@ -59,7 +57,7 @@ fun SideticksScreen(
 ) {
     val screenFocus = remember { FocusRequester() }
     SidekitScaffold(
-        modifier = Modifier.focusRequester(screenFocus).focusable(),
+        focusParking = screenFocus,
         title = "My Sideticks",
         actions = buildList {
             add(
@@ -85,7 +83,7 @@ fun SideticksScreen(
             if (needsNotifications && state.dueText != null) row("permission") { SidekitItem("Allow notifications for due reminders", it) }
             if (state.dueText != null) row("due") { modifier ->
                 SidekitCard(modifier.fillMaxWidth()) {
-                    SidekitTextField(state.dueText, { onDue(it) }, placeholder = "YYYY-MM-DD HH:mm", singleLine = true, onDone = { screenFocus.requestFocus() })
+                    SidekitTextField(state.dueText, { onDue(it) }, placeholder = "YYYY-MM-DD HH:mm", singleLine = true, dictation = false, onDone = { screenFocus.requestFocus() })
                 }
             }
             if (state.draft != null) row("draft") { DraftRow(state.draft, onDraftChange, { screenFocus.requestFocus() }, it) }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/SideweatherGraph.kt b/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/SideweatherGraph.kt
index 6a1e080a..df7796f1 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/SideweatherGraph.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/SideweatherGraph.kt
@@ -5,6 +5,7 @@ import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import androidx.lifecycle.viewmodel.initializer
@@ -21,12 +22,23 @@ import hrln.interactive.sidekit.navigation.SubApp
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 
-class WeatherViewModel(val repository: WeatherRepository) : ViewModel() {
+/** [city] looks up the town for a current-location fix; the default (tests) knows none. */
+class WeatherViewModel(val repository: WeatherRepository, private val city: suspend (Place) -> String? = { null }) : ViewModel() {
     val forecast = MutableStateFlow<Forecast?>(null)
     val status = MutableStateFlow("Select a location")
+    /**
+     * Shows the fix straight away as "Current location", then adds its town once the geocoder
+     * answers ("Current location · Madrid"). Offline, the plain name stays until it is next shown.
+     */
+    fun selectCurrentLocation(fix: Place) { repository.select(fix); nameCurrentLocation(fix) }
+    private fun nameCurrentLocation(fix: Place) = viewModelScope.launch {
+        city(fix)?.let { repository.rename(fix, currentLocationName(it)) }
+    }
     suspend fun visible(place: Place?) {
         forecast.value = null
         if (place == null) return
+        // Saved before towns were looked up, or while offline.
+        if (place.name == CURRENT_LOCATION) nameCurrentLocation(place)
         forecast.value = repository.cached(place)
         while (currentCoroutineContext().isActive) {
             status.value = if (forecast.value == null) "Loading forecast…" else "Cached forecast"
@@ -45,14 +57,14 @@ fun NavGraphBuilder.sideweatherGraph(nav: NavHostController) {
             composable("$root/$page") { entry ->
                 val context = LocalContext.current
                 val parent = remember(entry) { nav.getBackStackEntry(root) }
-                val vm: WeatherViewModel = viewModel(parent, factory = viewModelFactory { initializer { WeatherViewModel(WeatherRepository.get(context)) } })
+                val vm: WeatherViewModel = viewModel(parent, factory = viewModelFactory { initializer { WeatherViewModel(WeatherRepository.get(context)) { cityName(context.applicationContext, it) } } })
                 val settings by vm.repository.settings.state.collectAsStateWithLifecycle()
                 val forecast by vm.forecast.collectAsStateWithLifecycle()
                 val status by vm.status.collectAsStateWithLifecycle()
                 val error by vm.repository.settings.error.collectAsStateWithLifecycle()
                 val place = settings?.places?.firstOrNull { it.key == settings?.selected }
                 val imperial = settings?.fahrenheit == true
-                if (page in listOf("home", "hourly", "five-day")) WhileVisible(place) { vm.visible(place) }
+                if (page in listOf("home", "hourly", "five-day")) WhileVisible(place?.key) { vm.visible(place) }
                 val back = { nav.popBackStack(); Unit }
                 val locations = { nav.navigate("$root/locations") { launchSingleTop = true }; Unit }
                 val options = listOf(SideAction("locations", "Locations", onClick = locations), SideAction("units", if (imperial) "Use °C" else "Use °F") { vm.repository.settings.edit { it.copy(fahrenheit = !it.fahrenheit) } })
@@ -62,7 +74,7 @@ fun NavGraphBuilder.sideweatherGraph(nav: NavHostController) {
                         var message by remember { mutableStateOf("Allow approximate location for nearby weather, or add a town.") }
                         var deleted by remember { mutableStateOf<Place?>(null) }
                         LaunchedEffect(deleted) { if (deleted != null) { delay(5_000); deleted = null } }
-                        val locate = locationAction(vm.repository::select) { message = it }
+                        val locate = locationAction(vm::selectCurrentLocation) { message = it }
                         val list = rememberLazyListState()
                         val group = rememberSwipeRevealGroup()
                         SidekitScaffold("Locations", actions = listOf(SideAction.back("back", "Back", back), deleted?.let { p -> SideAction("add", "Undo", tone = ActionTone.Muted) { vm.repository.select(p); deleted = null } } ?: SideAction("add", "Add") { nav.navigate("$root/search") }, locate)) { padding ->
@@ -79,7 +91,7 @@ fun NavGraphBuilder.sideweatherGraph(nav: NavHostController) {
                         }
                     }
                     "home" -> SideweatherHomeScreen(forecast?.let { f -> place?.let { f.current(it, imperial) } } ?: CurrentConditions(place?.name ?: "Choose a location", "—", "", ""), forecast?.summary(imperial).orEmpty() + WeatherRow(error ?: status, ""), { nav.navigate("$root/hourly") }, { nav.navigate("$root/five-day") }, options)
-                    else -> ForecastScreen(if (page == "hourly") "Hourly forecast" else "5-day forecast", (if (page == "hourly") forecast?.hourly(imperial) else forecast?.daily(imperial)).orEmpty() + WeatherRow(status, ""), back, locations)
+                    else -> ForecastScreen(if (page == "hourly") "Hourly forecast" else "5-day forecast", (if (page == "hourly") forecast?.hourly(imperial) else forecast?.daily(imperial)).orEmpty() + WeatherRow(status, ""), back, locations, place = place?.name)
                 }
             }
         }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/SideweatherScreens.kt b/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/SideweatherScreens.kt
index 2b4e75eb..bce2174d 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/SideweatherScreens.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/SideweatherScreens.kt
@@ -88,14 +88,21 @@ private fun ConditionsCard(current: CurrentConditions) {
 
 /** "Hourly forecast" (94:385) and "5-day forecast" (94:447). */
 @Composable
-fun ForecastScreen(title: String, rows: List<WeatherRow>, onBack: () -> Unit, onLocations: () -> Unit) {
+fun ForecastScreen(title: String, rows: List<WeatherRow>, onBack: () -> Unit, onLocations: () -> Unit, place: String? = null) {
     SidekitScaffold(
         title = title,
         actions = listOf(SideAction.back("back", "Back", onBack), SideAction.forward("forward", "Locations", onLocations)),
     ) { padding ->
         val list = rememberLazyListState()
+        val offset = if (place != null) 1 else 0
         SidekitList(padding, state = list) {
-            itemsIndexed(rows) { i, row -> SidekitItem(title = row.label, secondary = row.detail, modifier = Modifier.height(ForecastRowHeight).listFade(list, i)) }
+            // Which place this forecast is for, captioned like the home card.
+            if (place != null) item {
+                Box(Modifier.fillMaxWidth().padding(horizontal = SidekitTheme.spacing.itemPadding, vertical = 6.dp).listFade(list, 0)) {
+                    SidekitText(place, style = SidekitTheme.typography.caption, maxLines = 1)
+                }
+            }
+            itemsIndexed(rows) { i, row -> SidekitItem(title = row.label, secondary = row.detail, modifier = Modifier.height(ForecastRowHeight).listFade(list, i + offset)) }
         }
     }
 }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/WeatherRepository.kt b/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/WeatherRepository.kt
index 4bc8c754..3c157b28 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/WeatherRepository.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/sideweather/WeatherRepository.kt
@@ -73,7 +73,10 @@ class WeatherRepository(private val directory: File, scope: CoroutineScope,
         }
         return result
     }
-    fun select(place: Place) = settings.edit { it.copy(places = (it.places.filterNot { p -> p.key == place.key || (place.name == "Current location" && p.name == place.name) } + place).takeLast(30), selected = place.key) }
+    /** A new current-location fix replaces the previous one rather than piling up. */
+    fun select(place: Place) = settings.edit { it.copy(places = (it.places.filterNot { p -> p.key == place.key || (place.isCurrentLocation && p.isCurrentLocation) } + place).takeLast(30), selected = place.key) }
+    /** Renames a saved place in place, without changing which one is selected. */
+    fun rename(place: Place, name: String) = settings.edit { it.copy(places = it.places.map { p -> if (p.key == place.key) p.copy(name = name) else p }) }
     fun delete(place: Place) = settings.edit { val places = it.places.filterNot { p -> p.key == place.key }; it.copy(places = places, selected = if (it.selected == place.key) places.firstOrNull()?.key else it.selected) }
     companion object {
         @Volatile private var instance: WeatherRepository? = null
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/translate/TranslateScreen.kt b/app/src/main/java/hrln/interactive/sidekit/apps/translate/TranslateScreen.kt
index 9690a2df..ab146097 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/translate/TranslateScreen.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/translate/TranslateScreen.kt
@@ -140,6 +140,8 @@ private fun TranslateBody(
                         placeholder = "Type or speak",
                         focusOnKeypad = true,
                         autoFocus = true,
+                        // Translate has its own mic, which listens in the chosen source language.
+                        dictation = false,
                     )
                 }
             } else TextRow(if (state.translating) "Translating…" else pane.text.ifEmpty { "Translation" })
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/vault/VaultGraph.kt b/app/src/main/java/hrln/interactive/sidekit/apps/vault/VaultGraph.kt
index 9ff95c73..681b5865 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/vault/VaultGraph.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/vault/VaultGraph.kt
@@ -138,6 +138,6 @@ private fun VaultEditor(note: PrivateNote, onText: (String) -> Unit) {
     val latest by rememberUpdatedState(onText)
     LaunchedEffect(text) { snapshotFlow { text.text.toString() }.collect { latest(it) } }
     CompositionLocalProvider(hrln.interactive.sidekit.design.input.LocalKeypad provides privateKeypad) {
-        SidekitCard { SidekitTextField(text, placeholder = "Private note…", focusOnKeypad = true, autoFocus = true) }
+        SidekitCard { SidekitTextField(text, placeholder = "Private note…", focusOnKeypad = true, autoFocus = true, dictation = false) }
     }
 }
diff --git a/app/src/main/java/hrln/interactive/sidekit/apps/video/VideoScreens.kt b/app/src/main/java/hrln/interactive/sidekit/apps/video/VideoScreens.kt
index 9488a093..53eb9961 100644
--- a/app/src/main/java/hrln/interactive/sidekit/apps/video/VideoScreens.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/apps/video/VideoScreens.kt
@@ -141,7 +141,7 @@ private const val HIDE_AFTER_MS = 3_000L
 private const val TICK_MS = 500L
 
 /**
- * Full-screen player. The picture fills the whole 480 x 640 panel (letterboxed to its aspect).
+ * Full-screen player. The picture fills the whole canvas (letterboxed to its aspect).
  *
  * The bar is "← | ▶ Play / ❚❚ Pause | ⏭ +10 s" with a progress line and times just above it;
  * dragging or tapping the line seeks. While playing, bar and line slide away after 3 s without
diff --git a/app/src/main/java/hrln/interactive/sidekit/launcher/LauncherScreen.kt b/app/src/main/java/hrln/interactive/sidekit/launcher/LauncherScreen.kt
index 61bed155..c033c842 100644
--- a/app/src/main/java/hrln/interactive/sidekit/launcher/LauncherScreen.kt
+++ b/app/src/main/java/hrln/interactive/sidekit/launcher/LauncherScreen.kt
@@ -2,46 +2,51 @@ package hrln.interactive.sidekit.launcher
 
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.runtime.*
-import androidx.compose.foundation.text.input.rememberTextFieldState
 import androidx.compose.foundation.text.input.clearText
-import androidx.compose.foundation.layout.*
-import androidx.compose.ui.focus.focusProperties
+import androidx.compose.foundation.text.input.rememberTextFieldState
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
 import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.input.key.Key
 import androidx.compose.ui.input.key.KeyEventType
 import androidx.compose.ui.input.key.key
 import androidx.compose.ui.input.key.onPreviewKeyEvent
 import androidx.compose.ui.input.key.type
-import androidx.compose.ui.platform.LocalFocusManager
-import hrln.interactive.sidekit.apps.settings.*
-import hrln.interactive.sidekit.design.components.SidekitTextField
-import hrln.interactive.sidekit.design.components.SidekitText
-import hrln.interactive.sidekit.design.input.LocalKeypad
-import hrln.interactive.sidekit.design.icons.SidekitIcon
-import androidx.compose.ui.Modifier
 import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
+import hrln.interactive.sidekit.R
+import hrln.interactive.sidekit.apps.settings.*
 import hrln.interactive.sidekit.apps.sideport.registry.PortedApp
 import hrln.interactive.sidekit.apps.sideport.registry.PortedApps
 import hrln.interactive.sidekit.apps.sideport.ui.PortedAppIcon
 import hrln.interactive.sidekit.apps.sideport.ui.PortedTile
-import hrln.interactive.sidekit.design.action.SideAction
 import hrln.interactive.sidekit.design.action.LocalChrome
+import hrln.interactive.sidekit.design.action.SideAction
 import hrln.interactive.sidekit.design.components.SidekitIconItem
 import hrln.interactive.sidekit.design.components.SidekitItem
 import hrln.interactive.sidekit.design.components.SidekitItemRow
 import hrln.interactive.sidekit.design.components.SidekitList
 import hrln.interactive.sidekit.design.components.SidekitScaffold
+import hrln.interactive.sidekit.design.components.SidekitText
+import hrln.interactive.sidekit.design.components.SidekitTextField
 import hrln.interactive.sidekit.design.components.listFade
+import hrln.interactive.sidekit.design.icons.SidekitIcon
+import hrln.interactive.sidekit.design.input.LocalKeypad
 import hrln.interactive.sidekit.design.theme.SidekitTheme
 import hrln.interactive.sidekit.home.HomePreferences
 import hrln.interactive.sidekit.navigation.SubApp
+import hrln.interactive.sidekit.ui.DevBuildPill
 import hrln.interactive.sidekit.ui.SidekitPreviewFrame
 import hrln.interactive.sidekit.ui.SidephonePreview
 
@@ -76,7 +81,7 @@ class PortedEntry(val app: PortedApp) : LauncherEntry {
 internal fun toLauncherEntries(
     ids: List<String>,
     subsById: Map<String, SubApp>,
-    portedById: Map<String, PortedApp>,
+    portedById: Map<String, PortedApp>
 ): List<LauncherEntry> = ids.mapNotNull { id ->
     subsById[id]?.let { BuiltinEntry(it) } ?: portedById[id]?.let { PortedEntry(it) }
 }
@@ -85,7 +90,7 @@ internal fun toLauncherEntries(
 fun LauncherRoute(
     onOpenApp: (SubApp) -> Unit,
     onOpenPorted: (PortedApp) -> Unit = {},
-    viewModel: LauncherViewModel = viewModel(),
+    viewModel: LauncherViewModel = viewModel()
 ) {
     val context = androidx.compose.ui.platform.LocalContext.current
     val prefs = remember(context) { SidekitPreferences(context) }
@@ -121,7 +126,7 @@ fun LauncherRoute(
         onToggleLayout = viewModel::toggleLayout,
         home = homeEntries,
         dock = dockEntries,
-        onOpenPorted = onOpenPorted,
+        onOpenPorted = onOpenPorted
     )
 }
 
@@ -140,7 +145,7 @@ fun LauncherScreen(
     home: List<LauncherEntry> = emptyList(),
     onOpenPorted: (PortedApp) -> Unit = {},
     hiddenApps: Set<String> = emptySet(),
-    dock: List<LauncherEntry> = emptyList(),
+    dock: List<LauncherEntry> = emptyList()
 ) {
     val query = rememberTextFieldState()
     val searchFocus = remember { FocusRequester() }
@@ -181,46 +186,76 @@ fun LauncherScreen(
             ) {
                 startSearch()
                 true
-            } else false
+            } else {
+                false
+            }
         },
         header = {
-            Box(Modifier.fillMaxWidth().height(SidekitTheme.spacing.headerHeight).padding(horizontal = SidekitTheme.spacing.itemPadding).padding(top = SidekitTheme.spacing.itemPadding)) {
-                SidekitTextField(
-                    state = query,
-                    focusRequester = searchFocus,
-                    modifier = Modifier.fillMaxWidth().testTag(LauncherTags.SEARCH).focusProperties { canFocus = searching },
-                    textStyle = SidekitTheme.typography.title,
-                    placeholder = if (searching) "Search apps" else null,
-                    focusOnKeypad = true,
-                    onKeypadFocus = { searching = true },
-                    singleLine = true,
-                    trailingTypingAction = clear,
-                    onDone = { focusManager.clearFocus() },
-                )
-                if (!searching && text.isEmpty()) {
-                    Box(Modifier.fillMaxSize().then(clockGestures(onToggleLayout) { searching = true; searchFocus.requestFocus() })) {
-                        SidekitText(state.time, style = SidekitTheme.typography.title)
+            // The dev build type is the only one with a `build_label`, so the pill (and the width
+            // it costs the query field) appears there and nowhere else.
+            val buildLabel = stringResource(R.string.build_label)
+            val titleLine = with(LocalDensity.current) { SidekitTheme.typography.title.lineHeight.toDp() }
+            Row(
+                modifier = Modifier.fillMaxWidth().height(SidekitTheme.spacing.headerHeight).padding(horizontal = SidekitTheme.spacing.itemPadding).padding(top = SidekitTheme.spacing.headerPaddingTop),
+                horizontalArrangement = Arrangement.spacedBy(SidekitTheme.spacing.itemContentGap),
+                verticalAlignment = Alignment.Top
+            ) {
+                Box(Modifier.weight(1f)) {
+                    SidekitTextField(
+                        state = query,
+                        focusRequester = searchFocus,
+                        modifier = Modifier.fillMaxWidth().testTag(LauncherTags.SEARCH).focusProperties { canFocus = searching },
+                        textStyle = SidekitTheme.typography.title,
+                        placeholder = if (searching) "Search apps" else null,
+                        focusOnKeypad = true,
+                        onKeypadFocus = { searching = true },
+                        singleLine = true,
+                        trailingTypingAction = clear,
+                        onDone = { focusManager.clearFocus() }
+                    )
+                    if (!searching && text.isEmpty()) {
+                        Box(
+                            Modifier.fillMaxSize().then(
+                                clockGestures(onToggleLayout) {
+                                    searching = true
+                                    searchFocus.requestFocus()
+                                }
+                            )
+                        ) {
+                            SidekitText(state.time, style = SidekitTheme.typography.title)
+                        }
                     }
                 }
+                if (buildLabel.isNotEmpty()) {
+                    // Sits on the title's line box rather than the header's centre, so it stays on the
+                    // clock's baseline whatever the header height is.
+                    Box(Modifier.height(titleLine), contentAlignment = Alignment.Center) { DevBuildPill(buildLabel) }
+                }
             }
         },
         // The dock is the launcher's action bar, so opening an app morphs the tapped dock button
         // into the app's first action.
-        actions = if (searching || text.isNotEmpty()) listOf(
-            SideAction("search.query", text.ifEmpty { "Search apps" }, dense = true, onClick = { searchFocus.requestFocus() }),
-        ) else dockActions(dock.ifEmpty { defaultDock() }, hiddenApps, onOpenApp, onOpenPorted),
+        actions = if (searching || text.isNotEmpty()) {
+            listOf(
+                SideAction("search.query", text.ifEmpty { "Search apps" }, dense = true, onClick = { searchFocus.requestFocus() })
+            )
+        } else {
+            dockActions(dock.ifEmpty { defaultDock() }, hiddenApps, onOpenApp, onOpenPorted)
+        },
         trailingAction = if (searching || text.isNotEmpty()) clear else null,
         // Keypad Options key: the long-press gesture, as a button.
         options = listOf(
             SideAction("layout", if (state.layout == LauncherLayout.Grid) "List" else "Grid", contentDescription = "Switch grid or list", onClick = onToggleLayout),
-            SideAction("settings", icon = SubApp.Settings.icon, contentDescription = "Settings") { onOpenApp(SubApp.Settings) },
-        ),
+            SideAction("settings", icon = SubApp.Settings.icon, contentDescription = "Settings") { onOpenApp(SubApp.Settings) }
+        )
     ) { padding ->
         if (visible.isEmpty()) {
             SidekitText(if (text.isNotEmpty()) "No matching apps" else "No apps shown. Use Options → Settings to show apps.", maxLines = Int.MAX_VALUE)
-        } else when (state.layout) {
-            LauncherLayout.Grid -> AppGrid(visible, padding, onOpenApp, onOpenPorted) { focusedRow = it }
-            LauncherLayout.List -> AppList(visible, padding, onOpenApp, onOpenPorted) { focusedRow = it }
+        } else {
+            when (state.layout) {
+                LauncherLayout.Grid -> AppGrid(visible, padding, onOpenApp, onOpenPorted) { focusedRow = it }
+                LauncherLayout.List -> AppList(visible, padding, onOpenApp, onOpenPorted) { focusedRow = it }
+            }
         }
     }
 }
@@ -246,7 +281,7 @@ private fun AppGrid(
     padding: PaddingValues,
     onOpenApp: (SubApp) -> Unit,
     onOpenPorted: (PortedApp) -> Unit,
-    onFocusedRow: (Int) -> Unit,
+    onFocusedRow: (Int) -> Unit
 ) {
     val listState = rememberLazyListState()
     val rows = remember(entries) { entries.chunked(GRID_COLUMNS) }
@@ -272,7 +307,7 @@ private fun AppList(
     padding: PaddingValues,
     onOpenApp: (SubApp) -> Unit,
     onOpenPorted: (PortedApp) -> Unit,
-    onFocusedRow: (Int) -> Unit,
+    onFocusedRow: (Int) -> Unit
 ) {
     val listState = rememberLazyListState()
     SidekitList(padding, Modifier.testTag(LauncherTags.LIST), state = listState) {
@@ -285,7 +320,7 @@ private fun AppList(
                         is BuiltinEntry -> onOpenApp(entry.app)
                         is PortedEntry -> onOpenPorted(entry.app)
                     }
-                },
+                }
             )
         }
     }
@@ -298,7 +333,7 @@ private fun AppTile(app: SubApp, onOpenApp: (SubApp) -> Unit, modifier: Modifier
         contentDescription = app.label,
         modifier = modifier,
         iconSize = SidekitTheme.spacing.tileIconSize,
-        onClick = { onOpenApp(app) },
+        onClick = { onOpenApp(app) }
     )
 }
 
@@ -307,16 +342,17 @@ private fun dockActions(
     dock: List<LauncherEntry>,
     hidden: Set<String>,
     onOpenApp: (SubApp) -> Unit,
-    onOpenPorted: (PortedApp) -> Unit,
+    onOpenPorted: (PortedApp) -> Unit
 ): List<SideAction> = dock.filter { it.id !in hidden }.map { entry ->
     when (entry) {
         is BuiltinEntry -> SideAction("dock.${entry.app.name}", icon = entry.app.icon, contentDescription = entry.app.label) { onOpenApp(entry.app) }
+
         is PortedEntry -> SideAction(
             "dock.${entry.app.packageName}",
             label = entry.app.label,
             contentDescription = entry.app.label,
             artKey = entry.app.packageName,
-            art = { PortedAppIcon(entry.app) },
+            art = { PortedAppIcon(entry.app) }
         ) { onOpenPorted(entry.app) }
     }
 }
@@ -344,4 +380,4 @@ private fun LauncherGridPreview() = SidekitPreviewFrame {
 @Composable
 private fun LauncherListPreview() = SidekitPreviewFrame {
     LauncherScreen(LauncherUiState(layout = LauncherLayout.List), {}, {})
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/hrln/interactive/sidekit/system/SidekitBuild.kt b/app/src/main/java/hrln/interactive/sidekit/system/SidekitBuild.kt
new file mode 100644
index 00000000..6b19219b
--- /dev/null
+++ b/app/src/main/java/hrln/interactive/sidekit/system/SidekitBuild.kt
@@ -0,0 +1,17 @@
+package hrln.interactive.sidekit.system
+
+/**
+ * The package ids Sidekit ships under. The stable app is [ID]; every other build adds a suffix
+ * to it (`hrln.interactive.sidekit.dev`, see app/build.gradle.kts), so a checkout's dev build can
+ * be installed beside the daily driver.
+ *
+ * Sidekit can launch a sibling build as an ordinary app, but never itself, and no build can be
+ * turned into a Sideport app: projecting Sidekit with Sidekit is recursive.
+ */
+object SidekitBuild {
+    /** Application id of the stable build, shared by every variant. */
+    const val ID = "hrln.interactive.sidekit"
+
+    /** True for Sidekit itself and any build installed beside it. */
+    fun isSidekit(packageName: String): Boolean = packageName == ID || packageName.startsWith("$ID.")
+}
diff --git a/app/src/main/java/hrln/interactive/sidekit/ui/DevBuildPill.kt b/app/src/main/java/hrln/interactive/sidekit/ui/DevBuildPill.kt
new file mode 100644
index 00000000..1589d5fd
--- /dev/null
+++ b/app/src/main/java/hrln/interactive/sidekit/ui/DevBuildPill.kt
@@ -0,0 +1,46 @@
+package hrln.interactive.sidekit.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import hrln.interactive.sidekit.R
+import hrln.interactive.sidekit.design.components.SidekitText
+import hrln.interactive.sidekit.design.theme.SidekitTheme
+import hrln.interactive.sidekit.design.theme.contentColorFor
+
+/**
+ * The dev build's marker: a small "DEV" pill in the right-hand corner of the launcher header.
+ *
+ * Only the `dev` build type sets a non-empty `build_label`; stable builds pass an empty label and
+ * draw nothing, which also keeps every recorded screenshot unchanged. It is a marker, not a
+ * control: no click, no focus (so it stays out of the D-pad order and the focus tests), and a
+ * single spoken label - "Development build" - rather than spelling out the letters.
+ */
+@Composable
+fun DevBuildPill(label: String, modifier: Modifier = Modifier) {
+    val background = SidekitTheme.colors.surfaceA4
+    val description = stringResource(R.string.build_pill_description)
+    Box(
+        modifier
+            .clip(SidekitTheme.shapes.control)
+            .background(background)
+            .padding(horizontal = 12.dp, vertical = 4.dp)
+            .clearAndSetSemantics { contentDescription = description }
+    ) {
+        SidekitText(
+            text = label,
+            // `tiny` with a little tracking reads as a tag rather than as a word in the header.
+            style = SidekitTheme.typography.tiny.copy(fontWeight = FontWeight.Medium, letterSpacing = 2.sp),
+            color = SidekitTheme.colors.contentColorFor(background)
+        )
+    }
+}
diff --git a/app/src/main/res/values/build.xml b/app/src/main/res/values/build.xml
new file mode 100644
index 00000000..cbc79a78
--- /dev/null
+++ b/app/src/main/res/values/build.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Which build the UI is running in. The `dev` build type overrides these in
+    app/src/dev/res/values/build.xml; every other build keeps the quiet defaults below, so
+    stable installs never mark themselves.
+-->
+<resources>
+    <!-- Pill text in the launcher header. Empty means "draw no pill at all". -->
+    <string name="build_label" translatable="false"></string>
+    <!-- What a screen reader says for the pill instead of spelling out the letters. -->
+    <string name="build_pill_description" translatable="false">Development build</string>
+    <!-- True only in the dev build: Settings → About then names the build and its package. -->
+    <bool name="is_dev_build">false</bool>
+</resources>
diff --git a/app/src/test/java/hrln/interactive/sidekit/apps/apps/AppsViewModelTest.kt b/app/src/test/java/hrln/interactive/sidekit/apps/apps/AppsViewModelTest.kt
index 1ef32b14..76d42c84 100644
--- a/app/src/test/java/hrln/interactive/sidekit/apps/apps/AppsViewModelTest.kt
+++ b/app/src/test/java/hrln/interactive/sidekit/apps/apps/AppsViewModelTest.kt
@@ -16,11 +16,21 @@ import org.robolectric.annotation.Config
 @Config(sdk = [31])
 @OptIn(ExperimentalCoroutinesApi::class)
 class AppsViewModelTest {
+    @Test fun `Sidekit cannot launch itself, but can launch its dev build`() {
+        val app = { pkg: String -> LaunchableApp(ComponentName(pkg, "Main"), Process.myUserHandle(), pkg) }
+        val apps = listOf(app("hrln.interactive.sidekit"), app("hrln.interactive.sidekit.dev"), app("com.example.chat"))
+        assertEquals(
+            listOf("hrln.interactive.sidekit.dev", "com.example.chat"),
+            launchableApps(apps, selfPackage = "hrln.interactive.sidekit").map { it.component.packageName }
+        )
+    }
+
     @Test fun `search matches names and numeric keypad sequences`() {
         assertTrue(matchesApp("Firefox", "fire"))
         assertTrue(matchesApp("Firefox", "3473"))
         assertFalse(matchesApp("Firefox", "Maps"))
     }
+
     @Test fun `visible collection gets package changes and stops upstream on leaving`() = runTest {
         val dispatcher = StandardTestDispatcher(testScheduler)
         Dispatchers.setMain(dispatcher)
@@ -35,10 +45,19 @@ class AppsViewModelTest {
             }
             val vm = AppsViewModel(source)
             val collector = backgroundScope.launch { vm.state.collect {} }
-            runCurrent(); assertTrue(observing)
-            vm.query.value = "3473"; runCurrent(); assertEquals(1, vm.state.value.apps.size)
-            apps.value = emptyList(); runCurrent(); assertTrue(vm.state.value.apps.isEmpty())
-            collector.cancel(); runCurrent(); assertFalse(observing)
-        } finally { Dispatchers.resetMain() }
+            runCurrent()
+            assertTrue(observing)
+            vm.query.value = "3473"
+            runCurrent()
+            assertEquals(1, vm.state.value.apps.size)
+            apps.value = emptyList()
+            runCurrent()
+            assertTrue(vm.state.value.apps.isEmpty())
+            collector.cancel()
+            runCurrent()
+            assertFalse(observing)
+        } finally {
+            Dispatchers.resetMain()
+        }
     }
 }
diff --git a/app/src/test/java/hrln/interactive/sidekit/apps/everyday/EverydayScreenshotTest.kt b/app/src/test/java/hrln/interactive/sidekit/apps/everyday/EverydayScreenshotTest.kt
index 8fadd3e0..3e1a1eaf 100644
--- a/app/src/test/java/hrln/interactive/sidekit/apps/everyday/EverydayScreenshotTest.kt
+++ b/app/src/test/java/hrln/interactive/sidekit/apps/everyday/EverydayScreenshotTest.kt
@@ -26,6 +26,7 @@ import hrln.interactive.sidekit.apps.tripplanning.TripPlanningScreen
 import hrln.interactive.sidekit.apps.webbrowser.WebBrowserSampleData
 import hrln.interactive.sidekit.apps.webbrowser.WebBrowserScreen
 import hrln.interactive.sidekit.ui.SidekitPreviewFrame
+import java.time.LocalDate
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -42,7 +43,11 @@ class EverydayScreenshotTest {
         compose.onRoot().captureRoboImage("screenshots/$name.png")
     }
 
-    @Test fun calendar() = shoot("calendar_96-420") { CalendarScreen(CalendarUiState(), {}) }
+    // Pinned date: the month grid highlights "today", so a live clock would re-record this
+    // screenshot every midnight and keep the working tree permanently dirty.
+    @Test fun calendar() = shoot("calendar_96-420") {
+        CalendarScreen(CalendarUiState(date = LocalDate.of(2026, 11, 5)), {})
+    }
     @Test fun mail() = shoot("mail_96-499") { MailScreen(MailSampleData.summary, MailSampleData.inbox) }
     @Test fun maps() = shoot("maps_96-563") { MapsScreen(MapsSampleData.destination) }
     @Test fun compass() = shoot("compass_96-629") { CompassScreen(CompassSampleData.reading) }
diff --git a/app/src/test/java/hrln/interactive/sidekit/apps/settings/SettingsUiTest.kt b/app/src/test/java/hrln/interactive/sidekit/apps/settings/SettingsUiTest.kt
index 1a3a42bf..55cf1fc9 100644
--- a/app/src/test/java/hrln/interactive/sidekit/apps/settings/SettingsUiTest.kt
+++ b/app/src/test/java/hrln/interactive/sidekit/apps/settings/SettingsUiTest.kt
@@ -72,6 +72,34 @@ class SettingsUiTest {
         compose.onNodeWithText("List").assertIsDisplayed()
     }
 
+    @Test fun `compact layout row saves the choice and raises the body`() {
+        val prefs = SidekitPreferences(ApplicationProvider.getApplicationContext<Context>())
+        prefs.compactLayout = false
+        val compact = androidx.compose.runtime.mutableStateOf(false)
+        compose.setContent {
+            // SidekitTheme directly, not SidekitPreviewFrame: the frame installs its own (standard)
+            // spacing and would override the one under test.
+            hrln.interactive.sidekit.design.theme.SidekitTheme(
+                spacing = if (compact.value) hrln.interactive.sidekit.design.theme.SidekitSpacing.Compact
+                else hrln.interactive.sidekit.design.theme.SidekitSpacing(),
+            ) {
+                hrln.interactive.sidekit.design.canvas.SidekitCanvas { SettingsHome({}, {}) }
+            }
+        }
+        compose.mainClock.advanceTimeBy(1000)
+        val bodyTop = compose.onNodeWithText("Launcher default").getUnclippedBoundsInRoot().top
+        compose.onNodeWithText("Compact layout").performClick()
+        compose.runOnIdle { assertTrue(SidekitPreferences(ApplicationProvider.getApplicationContext()).compactLayout) }
+        compose.onNodeWithText("On").assertIsDisplayed()
+        // The preference listener is what MainActivity follows: flip the state as it would.
+        compose.runOnIdle { compact.value = true }
+        compose.mainClock.advanceTimeBy(1000)
+        compose.onRoot().captureRoboImage("screenshots/settings_compact.png")
+        val compactTop = compose.onNodeWithText("Launcher default").getUnclippedBoundsInRoot().top
+        // Header 103 -> 75, so the body starts 28 dp higher (1 dp == 1 px on this canvas).
+        assertEquals(28f, (bodyTop - compactTop).value, 1f)
+    }
+
     @Test fun `system settings live on their own page`() {
         var opened = 0
         compose.setContent { SidekitPreviewFrame { SettingsHome({}, {}, onSystem = { opened++ }) } }
diff --git a/app/src/test/java/hrln/interactive/sidekit/apps/sideport/SideportAddTest.kt b/app/src/test/java/hrln/interactive/sidekit/apps/sideport/SideportAddTest.kt
new file mode 100644
index 00000000..97cfedaa
--- /dev/null
+++ b/app/src/test/java/hrln/interactive/sidekit/apps/sideport/SideportAddTest.kt
@@ -0,0 +1,66 @@
+package hrln.interactive.sidekit.apps.sideport
+
+import android.content.ComponentName
+import android.content.Context
+import android.os.Process
+import androidx.test.core.app.ApplicationProvider
+import hrln.interactive.sidekit.apps.apps.LaunchableApp
+import hrln.interactive.sidekit.apps.sideport.registry.PortedApp
+import hrln.interactive.sidekit.apps.sideport.registry.PortedApps
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/** Sideport's Add app picker and registry: Sidekit builds are never ported, and rows are unified. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [31])
+class SideportAddTest {
+    private val context: Context = ApplicationProvider.getApplicationContext()
+    private val prefs get() = context.getSharedPreferences("sideport-test", Context.MODE_PRIVATE)
+
+    @Before fun cleanPrefs() {
+        prefs.edit().clear().commit()
+    }
+
+    private fun app(pkg: String, label: String, cls: String = "Main") = LaunchableApp(ComponentName(pkg, cls), Process.myUserHandle(), label)
+
+    @Test fun `candidates leave out every Sidekit build and apps already ported`() {
+        val installed = listOf(
+            app("hrln.interactive.sidekit", "Sidekit"),
+            app("hrln.interactive.sidekit.dev", "Sidekit dev"),
+            app("com.example.chat", "Example Chat"),
+            app("com.example.mail", "Example Mail")
+        )
+        val ported = listOf(PortedApp("com.example.mail", "Example Mail"))
+        assertEquals(listOf("com.example.chat"), sideportCandidates(installed, ported, "").map { it.component.packageName })
+    }
+
+    @Test fun `candidates keep one row per package and match the query`() {
+        val installed = listOf(
+            app("com.example.chat", "Example Chat", "Main"),
+            app("com.example.chat", "Example Chat", "Share"),
+            app("com.example.mail", "Example Mail")
+        )
+        val candidates = sideportCandidates(installed, emptyList(), "chat")
+        assertEquals(listOf("com.example.chat/Main"), candidates.map { "${it.component.packageName}/${it.component.className}" })
+    }
+
+    @Test fun `the registry refuses to port a Sidekit build`() {
+        val ported = PortedApps(prefs)
+        ported.add("hrln.interactive.sidekit", "Sidekit")
+        ported.add("hrln.interactive.sidekit.dev", "Sidekit dev")
+        ported.add("com.example.chat", "Example Chat")
+        assertEquals(listOf("com.example.chat"), ported.apps.value.map { it.packageName })
+    }
+
+    @Test fun `a Sidekit entry saved by an earlier version is dropped on read`() {
+        prefs.edit().putString(
+            "apps",
+            """[{"package":"hrln.interactive.sidekit.dev","label":"Sidekit dev","mode":"Projected","added":1}]"""
+        ).commit()
+        assertEquals(emptyList<PortedApp>(), PortedApps(prefs).apps.value)
+    }
+}
diff --git a/app/src/test/java/hrln/interactive/sidekit/apps/sideweather/WeatherRepositoryTest.kt b/app/src/test/java/hrln/interactive/sidekit/apps/sideweather/WeatherRepositoryTest.kt
index df82a946..7843176f 100644
--- a/app/src/test/java/hrln/interactive/sidekit/apps/sideweather/WeatherRepositoryTest.kt
+++ b/app/src/test/java/hrln/interactive/sidekit/apps/sideweather/WeatherRepositoryTest.kt
@@ -2,6 +2,7 @@ package hrln.interactive.sidekit.apps.sideweather
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import hrln.interactive.sidekit.apps.maps.Place
+import hrln.interactive.sidekit.apps.maps.currentLocationName
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 import org.json.JSONObject
@@ -54,4 +55,20 @@ class WeatherRepositoryTest {
             assertTrue(job.isCompleted)
         } finally { scope.cancel() }
     }
+    @Test fun `current location keeps one entry and takes its city name`() = runBlocking {
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+        try {
+            val repo = WeatherRepository(Files.createTempDirectory("weather-here").toFile(), scope, { payload() })
+            val sydney = Place("Sydney", -33.8, 151.2)
+            repo.select(sydney)
+            repo.select(Place("Current location · Madrid", 40.4, -3.7))
+            val fix = Place(currentLocationName(null), 41.4, 2.2)
+            repo.select(fix)
+            repo.select(sydney)
+            repo.rename(fix, currentLocationName("Barcelona"))
+            val settings = withTimeout(3_000) { repo.settings.state.first { s -> s?.places?.any { it.name.endsWith("Barcelona") } == true } }!!
+            assertEquals(listOf("Current location · Barcelona", "Sydney"), settings.places.map { it.name })
+            assertEquals(sydney.key, settings.selected)
+        } finally { scope.cancel() }
+    }
 }
diff --git a/app/src/test/java/hrln/interactive/sidekit/launcher/LauncherSearchTest.kt b/app/src/test/java/hrln/interactive/sidekit/launcher/LauncherSearchTest.kt
index 780ea37c..196b1a29 100644
--- a/app/src/test/java/hrln/interactive/sidekit/launcher/LauncherSearchTest.kt
+++ b/app/src/test/java/hrln/interactive/sidekit/launcher/LauncherSearchTest.kt
@@ -6,6 +6,7 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.input.InputMode
 import androidx.compose.ui.input.InputModeManager
 import androidx.compose.ui.platform.LocalInputModeManager
+import androidx.compose.ui.semantics.SemanticsProperties
 import androidx.compose.ui.test.*
 import androidx.compose.ui.test.junit4.v2.createComposeRule
 import androidx.test.core.app.ApplicationProvider
@@ -153,6 +154,35 @@ class LauncherSearchTest {
         compose.onNodeWithTag(LauncherTags.SEARCH).assertTextEquals("T")
     }
 
+    private fun dockButton(label: String) =
+        compose.onNode(hasContentDescription(label) and !hasAnyAncestor(hasTestTag(LauncherTags.GRID)))
+
+    @Test fun `keypad Up from the dock enters the grid`() {
+        launch(KeypadModule.Qwerty, LauncherLayout.Grid)
+        // Reached by touch, so there is no tile to go back to: Up still leaves the dock.
+        dockButton("Sidenotes").requestFocus()
+        compose.waitForIdle()
+        key(KeyEvent.KEYCODE_DPAD_UP)
+        dockButton("Sidenotes").assertIsNotFocused()
+        compose.onNode(isFocused() and hasAnyAncestor(hasTestTag(LauncherTags.GRID))).assertExists()
+    }
+
+    @Test fun `keypad Down into the dock and Up again returns to the same tile`() {
+        launch(KeypadModule.Qwerty, LauncherLayout.Grid)
+        focusFirstTile()
+        val inGrid = isFocused() and hasAnyAncestor(hasTestTag(LauncherTags.GRID))
+        // Down until focus leaves the grid for the dock, remembering the last tile it was on.
+        var last: String? = null
+        repeat(20) {
+            val focused = compose.onAllNodes(inGrid).fetchSemanticsNodes().singleOrNull() ?: return@repeat
+            last = focused.config[SemanticsProperties.ContentDescription].single()
+            key(KeyEvent.KEYCODE_DPAD_DOWN)
+        }
+        compose.onAllNodes(inGrid).assertCountEquals(0)
+        key(KeyEvent.KEYCODE_DPAD_UP)
+        tile(last!!).assertIsFocused()
+    }
+
     @Test fun `clear remains square and rightmost in typing options`() {
         launch(KeypadModule.T9)
         key(KeyEvent.KEYCODE_6)
diff --git a/app/src/test/java/hrln/interactive/sidekit/ui/DevBuildPillTest.kt b/app/src/test/java/hrln/interactive/sidekit/ui/DevBuildPillTest.kt
new file mode 100644
index 00000000..8615eec7
--- /dev/null
+++ b/app/src/test/java/hrln/interactive/sidekit/ui/DevBuildPillTest.kt
@@ -0,0 +1,51 @@
+package hrln.interactive.sidekit.ui
+
+import android.content.Context
+import androidx.compose.ui.test.assertCountEquals
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.v2.createComposeRule
+import androidx.compose.ui.test.onAllNodesWithContentDescription
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import hrln.interactive.sidekit.R
+import hrln.interactive.sidekit.design.theme.SidekitTheme
+import hrln.interactive.sidekit.launcher.LauncherScreen
+import hrln.interactive.sidekit.launcher.LauncherUiState
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
+
+/**
+ * The dev marker is driven entirely by resources. Unit tests compile against `src/main`, i.e.
+ * what a stable install shows, so these defaults are the guarantee that a release build can't
+ * advertise itself as a dev build - and that the recorded screenshots keep their current frames.
+ */
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [31])
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+class DevBuildPillTest {
+    @get:Rule val compose = createComposeRule()
+
+    private val description get() = "Development build"
+
+    @Test fun stableBuildsCarryNoMarker() {
+        val context = ApplicationProvider.getApplicationContext<Context>()
+        assertEquals("", context.getString(R.string.build_label))
+        assertFalse(context.resources.getBoolean(R.bool.is_dev_build))
+    }
+
+    @Test fun thePillIsSpokenAsOneLabel() {
+        compose.setContent { SidekitTheme { DevBuildPill("DEV") } }
+        compose.onNodeWithContentDescription(description).assertIsDisplayed()
+    }
+
+    @Test fun theLauncherHeaderShowsNoPillInAStableBuild() {
+        compose.setContent { SidekitPreviewFrame { LauncherScreen(LauncherUiState(), {}, {}) } }
+        compose.onAllNodesWithContentDescription(description).assertCountEquals(0)
+    }
+}
diff --git a/app/src/test/java/hrln/interactive/sidekit/ui/ScreenshotTest.kt b/app/src/test/java/hrln/interactive/sidekit/ui/ScreenshotTest.kt
index d7535a4f..7400b69f 100644
--- a/app/src/test/java/hrln/interactive/sidekit/ui/ScreenshotTest.kt
+++ b/app/src/test/java/hrln/interactive/sidekit/ui/ScreenshotTest.kt
@@ -14,6 +14,7 @@ import hrln.interactive.sidekit.apps.sidenotes.SidenotesSampleData
 import hrln.interactive.sidekit.apps.sidenotes.SidenotesUiState
 import hrln.interactive.sidekit.apps.sideticks.SideticksScreen
 import hrln.interactive.sidekit.apps.sideticks.SideticksUiState
+import hrln.interactive.sidekit.design.canvas.SidekitCanvas
 import hrln.interactive.sidekit.launcher.LauncherLayout
 import hrln.interactive.sidekit.launcher.LauncherScreen
 import hrln.interactive.sidekit.launcher.LauncherUiState
@@ -49,6 +50,15 @@ class ScreenshotTest {
     @Test fun launcherGridAtSidephoneAvdDensity() = shoot("launcher_grid_avd_320dpi", launcher(LauncherUiState()))
 
     @Test fun launcherList() = shoot("launcher_list_36-2", launcher(LauncherUiState(layout = LauncherLayout.List)))
+    /** The same frame with Settings → Compact layout on: header 75 instead of 103, bar 100 instead of 112. */
+    @Test fun launcherGridCompact() {
+        compose.setContent {
+            hrln.interactive.sidekit.design.theme.SidekitTheme(
+                spacing = hrln.interactive.sidekit.design.theme.SidekitSpacing.Compact,
+            ) { SidekitCanvas { LauncherScreen(LauncherUiState(), {}, {}) } }
+        }
+        compose.onRoot().captureRoboImage("screenshots/launcher_grid_compact.png")
+    }
     @Test fun sidenotes() = shoot("sidenotes_1-278") { SidenotesListScreen(SidenotesUiState(SidenotesSampleData.notes), {}, {}, {}, {}) }
     @Test fun sidenotesUndo() = shoot("sidenotes_undo") {
         SidenotesListScreen(SidenotesUiState(SidenotesSampleData.notes.drop(1), recentlyDeleted = SidenotesSampleData.notes.first()), {}, {}, {}, {})
diff --git a/build.gradle.kts b/build.gradle.kts
index 476e7406..c05a847f 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -3,4 +3,43 @@ plugins {
     alias(libs.plugins.android.application) apply false
     alias(libs.plugins.android.library) apply false
     alias(libs.plugins.kotlin.compose) apply false
+    alias(libs.plugins.spotless) apply false
+}
+
+// Formatting is checked with ktlint through Spotless. `ratchetFrom` limits the check to files
+// changed since main, so adopting it does not require reformatting the whole codebase at once.
+// Run `./gradlew spotlessApply` before pushing, or `spotlessCheck` to see the diff.
+//
+// Spotless does not pick up .editorconfig on its own, and without it ktlint falls back to its
+// defaults: 140-column wrapping and no Composable naming exemption, so every screen would fail.
+// The ktlint rules from .editorconfig are therefore read here and handed over explicitly; the
+// file stays the single source of truth for editors and for CI.
+val ktlintRulesFromEditorConfig: Map<String, String> =
+    providers.fileContents(rootProject.layout.projectDirectory.file(".editorconfig"))
+        .asText
+        .map { text ->
+            text.lines()
+                .map { it.substringBefore('#').trim() }
+                .filter { '=' in it }
+                .map { it.split('=', limit = 2).map(String::trim) }
+                .filter { (key, _) -> key == "max_line_length" || key.startsWith("ktlint_") }
+                .associate { (key, value) -> key to value }
+        }
+        .get()
+
+allprojects {
+    apply(plugin = "com.diffplug.spotless")
+
+    configure<com.diffplug.gradle.spotless.SpotlessExtension> {
+        // A fork clone or a checkout without that ref can point it elsewhere: -PspotlessRatchet=upstream/main
+        ratchetFrom(providers.gradleProperty("spotlessRatchet").getOrElse("origin/main"))
+        kotlin {
+            target("src/**/*.kt")
+            ktlint(libs.versions.ktlint.get()).editorConfigOverride(ktlintRulesFromEditorConfig)
+        }
+        kotlinGradle {
+            target("*.gradle.kts")
+            ktlint(libs.versions.ktlint.get()).editorConfigOverride(ktlintRulesFromEditorConfig)
+        }
+    }
 }
diff --git a/docs/ci.md b/docs/ci.md
new file mode 100644
index 00000000..81f5e7e7
--- /dev/null
+++ b/docs/ci.md
@@ -0,0 +1,87 @@
+# Continuous integration
+
+Sidekit runs its checks on GitHub Actions. All jobs are defined in
+[`.github/workflows`](../.github/workflows) and share the JDK 21, Android SDK 37 and
+Gradle cache setup in [`.github/actions/android-setup`](../.github/actions/android-setup).
+
+## What runs
+
+| Job | Command | Catches |
+| --- | --- | --- |
+| Gradle wrapper validation | `gradle/actions/wrapper-validation` | A modified or unverified `gradle-wrapper.jar` |
+| Build | `./gradlew :app:assembleDebug :app:assembleRelease :sidekit:assembleDebug` | Compile errors and R8/keep-rule breakage that only release builds show |
+| Unit tests | `./gradlew testDebugUnitTest` | JVM, Robolectric and Compose tests in both modules |
+| Android Lint | `./gradlew lintDebug` | API-level, manifest and resource problems; uploads SARIF to code scanning |
+| Kotlin formatting | `./gradlew spotlessCheck` | ktlint violations in files changed since `main` |
+| Secret scan | `gitleaks/gitleaks-action` | Committed credentials, private keys and tokens |
+| Dependency review | `actions/dependency-review-action` | High-severity vulnerable dependencies in a pull request |
+| CodeQL | manual Gradle build + `codeql-action` | Security data-flow issues in Kotlin and Java (`codeql.yml`) |
+| Dependency graph | `gradle/actions/dependency-submission` | Keeps the graph that dependency review reads up to date (`dependency-graph.yml`) |
+
+These checks gate pull requests. The repository does not run instrumented tests on
+an emulator: the only `androidTest` source today is the generated example, and the
+[PR template](../.github/pull_request_template.md) already requires physical-device
+testing for app changes. Add a `connectedDebugAndroidTest` job once real
+instrumentation tests exist.
+
+## Formatting
+
+Formatting is checked with ktlint through Spotless. It is *ratcheted* against
+`origin/main`, so only files changed on a branch must be clean. This lets the
+project adopt formatting without rewriting untouched code.
+
+```bash
+./gradlew spotlessCheck   # report violations
+./gradlew spotlessApply   # format the changed files
+```
+
+The rules live in [`.editorconfig`](../.editorconfig). `ktlint_code_style =
+android_studio` matches Android Studio's defaults, `max_line_length = off` keeps the
+existing long-line style, and `no-wildcard-imports` is disabled because a few MMS
+and WorkManager adapters intentionally import whole packages. `@Composable`
+functions are exempt from `function-naming`, because screens are PascalCase by
+convention.
+
+Spotless does not load `.editorconfig` on its own: `build.gradle.kts` reads the
+ktlint keys from it and passes them as `editorConfigOverride`. Keep editing the
+`.editorconfig` file; the build picks up new keys. ktlint caches the parsed rules
+inside the Gradle daemon, so after editing it run `./gradlew --stop` before the
+next `spotlessApply` or `spotlessCheck`.
+
+CI checks out the full history so the `origin/main` ref that Spotless ratchets
+against exists. Locally, fetch `main` first if the check complains about a missing
+ref.
+
+## Running the pipeline locally
+
+```bash
+./gradlew :app:assembleDebug :app:assembleRelease :sidekit:assembleDebug
+./gradlew testDebugUnitTest
+./gradlew lintDebug
+./gradlew spotlessCheck
+```
+
+Reports are written to `app/build/reports/` and `sidekit/build/reports/`.
+
+## Branch protection
+
+Recommended settings for `main`:
+
+- Require a pull request before merging.
+- Require the status checks `Gradle wrapper validation`, `Build (debug + R8 release)`,
+  `Unit tests`, `Android Lint`, `Kotlin formatting`, and `Secret scan`.
+- Require branches to be up to date before merging.
+- Do not allow bypassing the above settings.
+
+`Dependency review` only runs on pull requests, and `CodeQL` runs on pushes and
+pull requests to `main`; keep them optional if they are still being tuned.
+
+## Things that are intentionally not in PR CI
+
+- **Network integration probes** (`scripts/verify_nsw_transit.py`) depend on a
+  third-party service and should run on a schedule or manually, not block a pull
+  request.
+- **Emulator tests**: see above.
+- **Release signing and publishing**: wire this up when there is a distribution
+  channel. The `release` build type is currently unsigned, so CI only verifies
+  that R8 succeeds.
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c4fe9ebb..4ec1153c 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -12,6 +12,8 @@ lifecycle = "2.10.0"
 robolectric = "4.16.1"
 roborazzi = "1.77.0"
 coroutines = "1.9.0"
+ktlint = "1.8.0"
+spotless = "8.11.0"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
@@ -39,3 +41,4 @@ roborazzi-junit-rule = { group = "io.github.takahirom.roborazzi", name = "robora
 android-application = { id = "com.android.application", version.ref = "agp" }
 android-library = { id = "com.android.library", version.ref = "agp" }
 kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+spotless = { id = "com.diffplug.spotless", version.ref = "spotless" }
diff --git a/sidekit/src/main/AndroidManifest.xml b/sidekit/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..01d48922
--- /dev/null
+++ b/sidekit/src/main/AndroidManifest.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- SidekitTextField's dictation: the microphone, and visibility of the platform recogniser. -->
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+
+    <queries>
+        <intent>
+            <action android:name="android.speech.RecognitionService" />
+        </intent>
+    </queries>
+</manifest>
diff --git a/sidekit/src/main/java/hrln/interactive/sidekit/design/action/HeaderHost.kt b/sidekit/src/main/java/hrln/interactive/sidekit/design/action/HeaderHost.kt
index e5432baa..38b1e324 100644
--- a/sidekit/src/main/java/hrln/interactive/sidekit/design/action/HeaderHost.kt
+++ b/sidekit/src/main/java/hrln/interactive/sidekit/design/action/HeaderHost.kt
@@ -7,6 +7,7 @@ import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
@@ -41,6 +42,14 @@ private class HeaderModel {
         val newScreen = top !== owner
         owner = top
         current = spec
+        // A screen without the shared title draws its own header in that place (the launcher's
+        // clock): the old title goes at once, as fading it there would draw it over that header.
+        if (spec == null) {
+            job?.cancel()
+            previous = null
+            progress = 1f
+            return
+        }
         // A screen updating its own title (the clock ticking, a note saved) changes in place; only a
         // new screen plays the swap.
         if (newScreen && old?.title != spec?.title && (old != null || spec != null)) {
@@ -48,7 +57,7 @@ private class HeaderModel {
             progress = 0f
             job?.cancel()
             job = scope.launch {
-                animate(0f, 1f, animationSpec = SidekitMotion.content) { v, _ -> progress = v }
+                animate(0f, 1f, animationSpec = SidekitMotion.title) { v, _ -> progress = v }
                 previous = null
             }
         }
@@ -63,9 +72,16 @@ private class HeaderModel {
 internal fun HeaderHost(state: ChromeState, modifier: Modifier = Modifier) {
     val model = remember { HeaderModel() }
     val scope = rememberCoroutineScope()
-    val top = state.top
-    val spec = top?.header
-    SideEffect { if (top != null) model.sync(top, spec, scope) }
+    // Read here only to subscribe: HeaderHost recomposes whenever the top screen or its title changes.
+    state.top?.header
+    // Read at apply time, not from this composition: a screen attaching in the same frame has
+    // already synced through onHeaderChange, and syncing back to the stale `top` would undo it.
+    SideEffect { state.top?.let { model.sync(it, it.header, scope) } }
+    // Publishers notify in the frame a screen changes, so the title never trails the body by a frame.
+    DisposableEffect(state, model) {
+        state.onHeaderChange = { state.top?.let { model.sync(it, it.header, scope) } }
+        onDispose { state.onHeaderChange = null }
+    }
 
     val travel = with(LocalDensity.current) { TITLE_TRAVEL.toPx() }
     val current = model.current
@@ -98,7 +114,8 @@ internal fun HeaderHost(state: ChromeState, modifier: Modifier = Modifier) {
                 textAlign = current.align,
                 modifier = Modifier.graphicsLayer {
                     val p = progress()
-                    alpha = ((p - HANDOFF) / (1f - HANDOFF)).coerceIn(0f, 1f)
+                    // Composition hasn't caught up with a screen that has no shared title: hide it now.
+                    alpha = if (model.current == null) 0f else ((p - HANDOFF) / (1f - HANDOFF)).coerceIn(0f, 1f)
                     translationY = (1f - p) * travel
                     compositingStrategy = CompositingStrategy.ModulateAlpha
                 },
diff --git a/sidekit/src/main/java/hrln/interactive/sidekit/design/action/SideAction.kt b/sidekit/src/main/java/hrln/interactive/sidekit/design/action/SideAction.kt
index 0510245e..541cfa87 100644
--- a/sidekit/src/main/java/hrln/interactive/sidekit/design/action/SideAction.kt
+++ b/sidekit/src/main/java/hrln/interactive/sidekit/design/action/SideAction.kt
@@ -12,10 +12,12 @@ import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.referentialEqualityPolicy
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.key.KeyEvent
 import androidx.compose.ui.text.style.TextAlign
 import hrln.interactive.sidekit.design.icons.SidekitIcon
 import hrln.interactive.sidekit.design.theme.SidekitColors
@@ -154,6 +156,12 @@ class ChromeState {
     /** Temporary bars that take over from the screen's (T9 suggestions while typing). */
     internal val overrides = mutableStateListOf<ChromePublisher>()
 
+    /** Key handlers screens registered with [KeysFromActionBar]; the newest one is asked first. */
+    internal val barKeys = mutableStateListOf<(KeyEvent) -> Boolean>()
+
+    /** Offers a key pressed while focus is in the action bar to the screen that asked for it. */
+    internal fun barKey(event: KeyEvent): Boolean = barKeys.lastOrNull()?.invoke(event) ?: false
+
     internal val top: ChromePublisher? get() = publishers.lastOrNull()
 
     /** Whose options are showing in the bar, if any (see [toggleOptions]). */
@@ -213,6 +221,14 @@ class ChromeState {
      */
     internal var onChange: (() -> Unit)? = null
 
+    /** Set by the title host, for the same reason as [onChange]. */
+    internal var onHeaderChange: (() -> Unit)? = null
+
+    internal fun changed() {
+        onChange?.invoke()
+        onHeaderChange?.invoke()
+    }
+
     /**
      * False for the moment between one screen leaving and the next attaching. Hosts hold their
      * state through it rather than animating towards "nothing".
@@ -263,6 +279,22 @@ internal class ChromePublisher {
 
 val LocalChrome = staticCompositionLocalOf<ChromeState?> { null }
 
+/**
+ * Lets the current screen see key presses while focus is in the action bar. The bar is drawn by
+ * the canvas, outside the screen's body, so a key handler on the body never hears them: a screen
+ * that takes keypad digits anywhere (the contacts search) registers them here too.
+ */
+@Composable
+fun KeysFromActionBar(onKey: (KeyEvent) -> Boolean) {
+    val chrome = LocalChrome.current ?: return
+    val latest by rememberUpdatedState(onKey)
+    DisposableEffect(chrome) {
+        val handler: (KeyEvent) -> Boolean = { latest(it) }
+        chrome.barKeys += handler
+        onDispose { chrome.barKeys -= handler }
+    }
+}
+
 /**
  * Publishes this screen's title and actions while it is composed.
  *
@@ -303,15 +335,15 @@ private fun Publish(chrome: ChromeState, into: MutableList<ChromePublisher>, upd
         // briefly read as "this screen has an empty bar" and start the wrong animation.
         update(publisher)
         into.add(publisher)
-        chrome.onChange?.invoke()
+        chrome.changed()
         onDispose {
             into.remove(publisher)
             chrome.detached(publisher)
-            chrome.onChange?.invoke()
+            chrome.changed()
         }
     }
     SideEffect {
         update(publisher)
-        chrome.onChange?.invoke()
+        chrome.changed()
     }
 }
diff --git a/sidekit/src/main/java/hrln/interactive/sidekit/design/canvas/SidekitCanvas.kt b/sidekit/src/main/java/hrln/interactive/sidekit/design/canvas/SidekitCanvas.kt
index fac29327..ffad79b3 100644
--- a/sidekit/src/main/java/hrln/interactive/sidekit/design/canvas/SidekitCanvas.kt
+++ b/sidekit/src/main/java/hrln/interactive/sidekit/design/canvas/SidekitCanvas.kt
@@ -2,12 +2,14 @@ package hrln.interactive.sidekit.design.canvas
 
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.background
+import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.DisposableEffect
@@ -18,7 +20,12 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.focus.FocusDirection
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.focusRestorer
 import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.input.key.onPreviewKeyEvent
 import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.LocalView
 import android.view.ViewTreeObserver
@@ -39,17 +46,20 @@ object SidephoneCanvas {
     const val HEIGHT = 640
 
     /**
-     * Density that makes the 480 x 640 canvas fill [widthPx] x [heightPx] (letterboxed if the
-     * aspect ratio differs), so 1.dp in SideKit code is exactly 1 Figma px.
+     * Density that fits the 480 x 640 design inside [widthPx] x [heightPx], so 1.dp in SideKit code
+     * is exactly 1 Figma px. On a screen taller than 3:4 the canvas then grows down to fill it.
      */
     fun density(widthPx: Int, heightPx: Int): Float =
         minOf(widthPx / WIDTH.toFloat(), heightPx / HEIGHT.toFloat())
 }
 
 /**
- * Lays [content] out on a fixed 480 x 640 canvas scaled to the screen. On the Sidephone this is
- * a 1:1 mapping to physical pixels whatever density the system reports; on other screens the
- * canvas is scaled to fit and centred. Font scale is pinned to 1 because the canvas is fixed.
+ * Lays [content] out on a canvas that fills the whole screen, scaled so the 480 x 640 design fits.
+ * On the Sidephone this is exactly 480 x 640 and a 1:1 mapping to physical pixels whatever density
+ * the system reports. The canvas is always 480 wide: on a taller screen it grows in height to use
+ * the rest of the display, and on a wider one (landscape, a tablet) it stays 640 tall and is
+ * centred between dark side bars, since rows and the action bar would only stretch sideways.
+ * Font scale is pinned to 1 because sizes follow the design, not the system font setting.
  *
  * The canvas also owns the system chrome every screen shares: the title ([HeaderHost]) and the
  * action bar ([ActionBarHost]), drawn above the screens so they morph between them instead of
@@ -57,7 +67,7 @@ object SidephoneCanvas {
  * to text fields here.
  *
  * Overdraw: the activity drops its window background, so the canvas is the only full-screen
- * fill. The black letterbox is only painted when there is a letterbox.
+ * fill. The dark side bars are only painted when there are side bars.
  */
 @Composable
 fun SidekitCanvas(
@@ -71,24 +81,31 @@ fun SidekitCanvas(
         contentAlignment = Alignment.Center,
     ) {
         val scale = SidephoneCanvas.density(constraints.maxWidth, constraints.maxHeight)
-        val letterboxed = constraints.maxWidth - SidephoneCanvas.WIDTH * scale >= 1f ||
-            constraints.maxHeight - SidephoneCanvas.HEIGHT * scale >= 1f
-        if (letterboxed) Box(Modifier.fillMaxSize().background(SidekitTheme.colors.dark))
+        if (constraints.maxWidth - SidephoneCanvas.WIDTH * scale >= 1f) Box(Modifier.fillMaxSize().background(SidekitTheme.colors.dark))
         CompositionLocalProvider(
             LocalDensity provides Density(density = scale, fontScale = 1f),
             LocalChrome provides chrome,
             LocalKeypad provides keypad,
         ) {
             val hasFocus = revealFocusOnKeys()
+            val screenFocus = remember { FocusRequester() }
             Box(
                 modifier = Modifier
-                    .size(SidephoneCanvas.WIDTH.dp, SidephoneCanvas.HEIGHT.dp)
+                    // Design width, full height: with this density the width is exactly 480 on any
+                    // screen at least 3:4 tall, and the height is 640 or more.
+                    .width(SidephoneCanvas.WIDTH.dp)
+                    .fillMaxHeight()
                     .onFocusChanged { hasFocus.value = it.hasFocus }
                     // Screens slide during navigation; keep them inside the panel.
                     .clipToBounds()
                     .background(SidekitTheme.colors.surfaceA1),
             ) {
-                content()
+                // Screens run under the action bar, so D-pad search never finds them above it and
+                // Up from the bar went nowhere. The bar sends Up into this group instead: back to
+                // the item focus left from (lists restore their row too), or the bottom item.
+                Box(Modifier.fillMaxSize().focusRequester(screenFocus).focusRestorer().focusGroup()) {
+                    content()
+                }
                 // Back closes the options bar before it goes back a screen.
                 BackHandler(enabled = chrome.optionsOpen) { chrome.closeOptions() }
                 HeaderHost(
@@ -101,6 +118,8 @@ fun SidekitCanvas(
                     state = chrome,
                     modifier = Modifier
                         .align(Alignment.BottomCenter)
+                        .focusProperties { up = screenFocus }
+                        .onPreviewKeyEvent(chrome::barKey)
                         .imePadding()
                         .padding(SidekitTheme.spacing.pagePadding),
                 )
diff --git a/sidekit/src/main/java/hrln/interactive/sidekit/design/components/Scaffold.kt b/sidekit/src/main/java/hrln/interactive/sidekit/design/components/Scaffold.kt
index b50a04b9..c09ff7ba 100644
--- a/sidekit/src/main/java/hrln/interactive/sidekit/design/components/Scaffold.kt
+++ b/sidekit/src/main/java/hrln/interactive/sidekit/design/components/Scaffold.kt
@@ -1,5 +1,7 @@
 package hrln.interactive.sidekit.design.components
 
+import androidx.compose.foundation.focusGroup
+import androidx.compose.foundation.focusable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
@@ -14,9 +16,14 @@ import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusDirection
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
+import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.graphics.CompositingStrategy
 import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.platform.LocalInspectionMode
+import androidx.compose.ui.semantics.clearAndSetSemantics
 import androidx.compose.ui.semantics.heading
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.style.TextAlign
@@ -30,7 +37,8 @@ import hrln.interactive.sidekit.design.theme.SidekitTheme
 
 /**
  * Header frame (62:898): 460 x 103, title inset 30/30. Drawn by the shared title host; screens
- * use it directly only for a custom header.
+ * use it directly only for a custom header. The spacing token `headerPaddingTop` shortens it
+ * (with `headerHeight`) in compact mode.
  */
 @Composable
 fun SidekitHeader(
@@ -43,7 +51,7 @@ fun SidekitHeader(
             .fillMaxWidth()
             .height(SidekitTheme.spacing.headerHeight)
             .padding(horizontal = SidekitTheme.spacing.itemPadding)
-            .padding(top = SidekitTheme.spacing.itemPadding),
+            .padding(top = SidekitTheme.spacing.headerPaddingTop),
     ) {
         SidekitText(
             text = title,
@@ -66,6 +74,11 @@ fun SidekitHeader(
  * [header] replaces the shared title with custom content drawn in the body (e.g. a search field).
  *
  * [content] receives padding that keeps its last item clear of the action bar.
+ *
+ * [focusParking] is somewhere to put focus when a text field is done with it: clearing focus
+ * instead would hand it straight back to the first field. It is an empty point at the top of the
+ * body that the D-pad never moves onto and moves on from as from any row; a whole-screen
+ * focusable would trap it.
  */
 @Composable
 fun SidekitScaffold(
@@ -77,6 +90,7 @@ fun SidekitScaffold(
     titleModifier: Modifier = Modifier,
     header: (@Composable () -> Unit)? = null,
     trailingAction: SideAction? = null,
+    focusParking: FocusRequester? = null,
     content: @Composable (PaddingValues) -> Unit,
 ) {
     val spacing = SidekitTheme.spacing
@@ -114,6 +128,12 @@ fun SidekitScaffold(
                     },
             ) {
                 val bottom = if (actions.isNotEmpty()) spacing.actionBarHeight + spacing.pageGap + spacing.pagePadding else spacing.pagePadding
+                // Only parked on purpose (requestFocus), never landed on by the D-pad.
+                if (focusParking != null) Box(
+                    Modifier
+                        .focusProperties { onEnter = { if (requestedFocusDirection != FocusDirection.Enter) cancelFocusChange() } }
+                        .focusGroup(),
+                ) { Box(Modifier.focusRequester(focusParking).focusable().clearAndSetSemantics {}) }
                 CompositionLocalProvider(LocalBodyEntrance provides entrance) {
                     content(PaddingValues(bottom = bottom))
                 }
diff --git a/sidekit/src/main/java/hrln/interactive/sidekit/design/components/SidekitList.kt b/sidekit/src/main/java/hrln/interactive/sidekit/design/components/SidekitList.kt
index 5d2d2b9d..d79cc9e9 100644
--- a/sidekit/src/main/java/hrln/interactive/sidekit/design/components/SidekitList.kt
+++ b/sidekit/src/main/java/hrln/interactive/sidekit/design/components/SidekitList.kt
@@ -15,6 +15,7 @@ import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.focusRestorer
 import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.graphics.CompositingStrategy
@@ -103,7 +104,8 @@ fun SidekitList(
     }
     CompositionLocalProvider(LocalBringIntoViewSpec provides focusScroll) {
         LazyColumn(
-            modifier = modifier.fillMaxSize(),
+            // Coming back to the list (Up from the action bar) lands on the row focus left from.
+            modifier = modifier.fillMaxSize().focusRestorer(),
             state = state,
             contentPadding = contentPadding,
             verticalArrangement = Arrangement.spacedBy(spacing.itemOuterGap),
diff --git a/sidekit/src/main/java/hrln/interactive/sidekit/design/components/SidekitTextField.kt b/sidekit/src/main/java/hrln/interactive/sidekit/design/components/SidekitTextField.kt
index a4209b68..5f695774 100644
--- a/sidekit/src/main/java/hrln/interactive/sidekit/design/components/SidekitTextField.kt
+++ b/sidekit/src/main/java/hrln/interactive/sidekit/design/components/SidekitTextField.kt
@@ -1,5 +1,11 @@
 package hrln.interactive.sidekit.design.components
 
+import android.Manifest
+import android.content.pm.PackageManager
+import android.speech.SpeechRecognizer
+import android.widget.Toast
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.text.BasicTextField
 import androidx.compose.foundation.text.KeyboardOptions
@@ -26,6 +32,7 @@ import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.graphics.SolidColor
 import androidx.compose.ui.input.key.onInterceptKeyBeforeSoftKeyboard
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
 import androidx.compose.foundation.rememberScrollState
@@ -39,7 +46,10 @@ import hrln.interactive.sidekit.design.action.ActionTone
 import hrln.interactive.sidekit.design.action.PublishActionOverride
 import hrln.interactive.sidekit.design.action.SideAction
 import hrln.interactive.sidekit.design.icons.SidekitIcon
+import hrln.interactive.sidekit.design.input.Dictation
 import hrln.interactive.sidekit.design.input.LocalKeypad
+import hrln.interactive.sidekit.design.input.insertDictated
+import hrln.interactive.sidekit.design.input.rememberDictation
 import hrln.interactive.sidekit.design.input.T9Engine
 import hrln.interactive.sidekit.design.input.T9Mode
 import hrln.interactive.sidekit.design.input.T9Session
@@ -53,11 +63,14 @@ import hrln.interactive.sidekit.design.theme.SidekitTheme
  * inline) and the action bar turns into word completions for the letters so far (tap one, or
  * D-pad left / right and OK, to finish the word).
  *
- * When no word is being typed the bar shows the input mode (tap to switch letters / numbers) and
- * Done, which ends typing and gives the screen its own actions back.
+ * When no word is being typed the bar shows the input mode (tap to switch letters / numbers),
+ * dictation (speak a phrase; it goes in at the cursor) and Done, which ends typing and gives the
+ * screen its own actions back. With the virtual keyboard, dictation is the keyboard's own mic.
  *
  * @param focusOnKeypad make this the screen's main field: typing on the keypad while nothing is
  *   focused starts typing here.
+ * @param dictation offer the typing bar's mic. Off for fields that take numbers or a fixed format,
+ *   for private text that shouldn't go to a speech service, and for screens with their own mic.
  */
 @OptIn(ExperimentalComposeUiApi::class)
 @Composable
@@ -73,6 +86,7 @@ fun SidekitTextField(
     autoFocus: Boolean = false,
     trailingTypingAction: SideAction? = null,
     onKeypadFocus: (() -> Unit)? = null,
+    dictation: Boolean = true,
 ) {
     val keypad = LocalKeypad.current
     val scope = rememberCoroutineScope()
@@ -105,12 +119,38 @@ fun SidekitTextField(
         lastT9 = t9
     }
 
+    val context = LocalContext.current
+    val speech = rememberDictation()
+    // Checked up front so phones without a recogniser never show a mic that can only fail.
+    val canDictate = dictation && remember(context) { SpeechRecognizer.isRecognitionAvailable(context) }
+    // A word started on the keypad while listening is finished before the phrase goes in, so the
+    // phrase never lands inside it.
+    val dictate = { session?.finish(); speech.start { session?.finish(); state.insertDictated(it) } }
+    val microphone = rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
+        // Focus can move while the permission dialog is up; then the phrase has nowhere to go.
+        if (granted) { if (focused) dictate() }
+        else Toast.makeText(context, "Allow the microphone to dictate", Toast.LENGTH_SHORT).show()
+    }
+    // Leaving the field ends dictation; a phrase still in flight would land in the wrong place.
+    LaunchedEffect(focused) { if (!focused) speech.release() }
+
     if (focused && t9 && keypad != null && session != null) {
         PublishActionOverride(
             t9Actions(
                 maxSuggestions = if (trailingTypingAction == null) MAX_SHOWN else MAX_SHOWN - 1,
                 engine = keypad.engine,
                 session = session,
+                dictation = speech.takeIf { canDictate },
+                // With a screen's own (square) trailing button there's no room for Done's label:
+                // the other three share the rest of the bar equally, like the home dock.
+                compact = trailingTypingAction != null,
+                onDictate = {
+                    when {
+                        speech.listening -> speech.stop()
+                        context.checkSelfPermission(Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED -> dictate()
+                        else -> microphone.launch(Manifest.permission.RECORD_AUDIO)
+                    }
+                },
                 onDone = {
                     session.finish()
                     focusManager.clearFocus()
@@ -227,6 +267,7 @@ fun SidekitTextField(
     singleLine: Boolean = false,
     onDone: (() -> Unit)? = null,
     autoFocus: Boolean = false,
+    dictation: Boolean = true,
 ) {
     val state = rememberTextFieldState(value)
     val latest by rememberUpdatedState(onValueChange)
@@ -236,7 +277,7 @@ fun SidekitTextField(
     LaunchedEffect(value) {
         if (state.text.toString() != value) state.setTextAndPlaceCursorAtEnd(value)
     }
-    SidekitTextField(state, modifier, textStyle, placeholder, focusRequester, focusOnKeypad, singleLine, onDone, autoFocus)
+    SidekitTextField(state, modifier, textStyle, placeholder, focusRequester, focusOnKeypad, singleLine, onDone, autoFocus, dictation = dictation)
 }
 
 /**
@@ -244,7 +285,7 @@ fun SidekitTextField(
  * are reused as the completions change: each key press swaps labels in place and the strip grows
  * or shrinks between one and three buttons, instead of rebuilding.
  */
-private fun t9Actions(engine: T9Engine, session: T9Session, maxSuggestions: Int, onDone: () -> Unit): List<SideAction> {
+private fun t9Actions(engine: T9Engine, session: T9Session, dictation: Dictation?, compact: Boolean, maxSuggestions: Int, onDictate: () -> Unit, onDone: () -> Unit): List<SideAction> {
     if (engine.composing) {
         return engine.candidates.take(maxSuggestions).mapIndexed { i, word ->
             val chosen = i == engine.selected
@@ -259,11 +300,26 @@ private fun t9Actions(engine: T9Engine, session: T9Session, maxSuggestions: Int,
             ) { session.pick(i) }
         }
     }
-    return listOf(
-        SideAction("t9.0", engine.modeLabel, tone = ActionTone.Muted, weight = 0.8f, dense = true, motion = ActionMotion.Up, contentDescription = "Input mode ${engine.modeLabel}") {
+    return listOfNotNull(
+        SideAction("t9.0", engine.modeLabel, tone = ActionTone.Muted, weight = if (compact) 1f else 0.8f, dense = true, motion = ActionMotion.Up, contentDescription = "Input mode ${engine.modeLabel}") {
             session.setMode(if (engine.mode == T9Mode.MultiTap) T9Mode.Numeric else T9Mode.MultiTap)
         },
-        SideAction("t9.1", "Done", SidekitIcon.Check, iconAtEnd = true, tone = ActionTone.Secondary, motion = ActionMotion.Up, contentDescription = "Done typing", onClick = onDone),
+        // No mic for digits: a number is quicker to key than to say.
+        if (dictation != null && engine.mode != T9Mode.Numeric) {
+            SideAction(
+                "t9.1",
+                icon = if (dictation.listening) SidekitIcon.MicOff else SidekitIcon.Mic,
+                tone = if (dictation.listening) ActionTone.Primary else ActionTone.Muted,
+                // Crowded, the bar's buttons take equal shares, like the home dock.
+                square = !compact,
+                motion = ActionMotion.Up,
+                contentDescription = if (dictation.listening) "Stop dictating" else "Dictate",
+                onClick = onDictate,
+            )
+        } else {
+            null
+        },
+        SideAction("t9.2", if (compact) null else "Done", SidekitIcon.Check, iconAtEnd = !compact, tone = ActionTone.Secondary, motion = ActionMotion.Up, contentDescription = "Done typing", onClick = onDone),
     )
 }
 
diff --git a/sidekit/src/main/java/hrln/interactive/sidekit/design/input/Dictation.kt b/sidekit/src/main/java/hrln/interactive/sidekit/design/input/Dictation.kt
new file mode 100644
index 00000000..5b8fa99e
--- /dev/null
+++ b/sidekit/src/main/java/hrln/interactive/sidekit/design/input/Dictation.kt
@@ -0,0 +1,124 @@
+package hrln.interactive.sidekit.design.input
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.speech.RecognitionListener
+import android.speech.RecognizerIntent
+import android.speech.SpeechRecognizer
+import android.widget.Toast
+import androidx.compose.foundation.text.input.TextFieldState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.TextRange
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
+
+/**
+ * Speech to text for a text field, through the platform recognizer (absent on some AOSP builds).
+ * Each [start] listens for one phrase and hands back what was heard; the recognizer is only held
+ * while listening. Problems are shown as a toast: a text field has nowhere of its own to say so.
+ */
+@Stable
+class Dictation internal constructor(private val context: Context) {
+    /** True from [start] until a phrase or an error comes back. */
+    var listening by mutableStateOf(false)
+        private set
+    private var recognizer: SpeechRecognizer? = null
+    private var onHeard: ((String) -> Unit)? = null
+
+    fun start(onHeard: (String) -> Unit) {
+        release()
+        if (!SpeechRecognizer.isRecognitionAvailable(context)) {
+            tell("Speech recognition isn't installed on this phone")
+            return
+        }
+        this.onHeard = onHeard
+        try {
+            recognizer = SpeechRecognizer.createSpeechRecognizer(context).apply {
+                setRecognitionListener(Listener())
+                startListening(Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
+                    putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM)
+                    putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 1)
+                })
+            }
+            listening = true
+        } catch (_: Exception) {
+            release()
+            tell("Couldn't start dictation")
+        }
+    }
+
+    /** Stops listening; what was heard so far still arrives. */
+    fun stop() {
+        try { recognizer?.stopListening() } catch (_: Exception) {}
+    }
+
+    fun release() {
+        try { recognizer?.cancel() } catch (_: Exception) {}
+        recognizer?.destroy()
+        recognizer = null
+        onHeard = null
+        listening = false
+    }
+
+    private fun tell(message: String) = Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
+
+    private inner class Listener : RecognitionListener {
+        override fun onResults(results: Bundle) {
+            val text = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)?.firstOrNull().orEmpty()
+            val deliver = onHeard
+            release()
+            if (text.isNotBlank()) deliver?.invoke(text)
+        }
+        override fun onError(error: Int) {
+            release()
+            when (error) {
+                // Our own cancel() destroys the recogniser first, so this is a real start failure.
+                SpeechRecognizer.ERROR_CLIENT -> tell("Couldn't start dictation")
+                SpeechRecognizer.ERROR_RECOGNIZER_BUSY -> tell("Dictation is busy. Try again.")
+                SpeechRecognizer.ERROR_LANGUAGE_NOT_SUPPORTED, SpeechRecognizer.ERROR_LANGUAGE_UNAVAILABLE -> tell("Dictation isn't available in this language")
+                SpeechRecognizer.ERROR_SPEECH_TIMEOUT, SpeechRecognizer.ERROR_NO_MATCH -> tell("Didn't hear anything")
+                SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS -> tell("Allow the microphone to dictate")
+                SpeechRecognizer.ERROR_NETWORK, SpeechRecognizer.ERROR_NETWORK_TIMEOUT -> tell("Dictation needs a connection")
+                else -> tell("Didn't catch that. Try again.")
+            }
+        }
+        override fun onReadyForSpeech(params: Bundle?) = Unit
+        override fun onBeginningOfSpeech() = Unit
+        override fun onRmsChanged(rmsdB: Float) = Unit
+        override fun onBufferReceived(buffer: ByteArray?) = Unit
+        override fun onEndOfSpeech() = Unit
+        override fun onPartialResults(partialResults: Bundle?) = Unit
+        override fun onEvent(eventType: Int, params: Bundle?) = Unit
+    }
+}
+
+/** A [Dictation] that stops when the screen leaves or the app goes to the background. */
+@Composable
+fun rememberDictation(): Dictation {
+    val context = LocalContext.current
+    val dictation = remember(context) { Dictation(context) }
+    LifecycleEventEffect(Lifecycle.Event.ON_STOP) { dictation.release() }
+    DisposableEffect(dictation) { onDispose { dictation.release() } }
+    return dictation
+}
+
+/** Puts [heard] at the cursor (replacing any selection), spaced from the word before it. */
+internal fun TextFieldState.insertDictated(heard: String) {
+    val text = heard.trim()
+    if (text.isEmpty()) return
+    edit {
+        val start = selection.min
+        val end = selection.max
+        val spaced = if (start > 0 && !asCharSequence()[start - 1].isWhitespace()) " $text" else text
+        replace(start, end, spaced)
+        selection = TextRange(start + spaced.length)
+    }
+}
diff --git a/sidekit/src/main/java/hrln/interactive/sidekit/design/motion/SidekitMotion.kt b/sidekit/src/main/java/hrln/interactive/sidekit/design/motion/SidekitMotion.kt
index 44ba728e..5327645f 100644
--- a/sidekit/src/main/java/hrln/interactive/sidekit/design/motion/SidekitMotion.kt
+++ b/sidekit/src/main/java/hrln/interactive/sidekit/design/motion/SidekitMotion.kt
@@ -19,6 +19,9 @@ object SidekitMotion {
     /** Label and icon swap inside a button. Under-damped so arrows overshoot toward their direction. */
     val content = spring<Float>(dampingRatio = 0.68f, stiffness = 520f)
 
+    /** Screen title swap. Critically damped: the title rises into its fixed place and stops there. */
+    val title = spring<Float>(dampingRatio = 1f, stiffness = 520f)
+
     /** Bar sliding in from / out to the bottom edge when a screen gains or loses actions. */
     val enter = spring<Float>(dampingRatio = 0.86f, stiffness = Spring.StiffnessMediumLow)
 
diff --git a/sidekit/src/main/java/hrln/interactive/sidekit/design/theme/SidekitDimens.kt b/sidekit/src/main/java/hrln/interactive/sidekit/design/theme/SidekitDimens.kt
index 73c17f6a..c177e3a8 100644
--- a/sidekit/src/main/java/hrln/interactive/sidekit/design/theme/SidekitDimens.kt
+++ b/sidekit/src/main/java/hrln/interactive/sidekit/design/theme/SidekitDimens.kt
@@ -24,12 +24,28 @@ data class SidekitSpacing(
     // Measured from components
     val itemPadding: Dp = 30.dp,
     val itemContentGap: Dp = 14.dp,
+    /** Space above the header title. The Figma frame uses [itemPadding]; compact mode trims it. */
+    val headerPaddingTop: Dp = 30.dp,
     val headerHeight: Dp = 103.dp,
     val itemHeight: Dp = 104.dp,
     val actionBarHeight: Dp = 112.dp,
     val iconSize: Dp = 40.dp,
     val tileIconSize: Dp = 44.dp,
-)
+) {
+    companion object {
+        /**
+         * The measured Figma sizes, except the top and bottom chrome: the header title sits 14
+         * above its line box (a 75 tall header, 28 less than the mock) and the action bar is 12
+         * shorter. Slightly tighter insets buy body space on the 480 x 640 display without
+         * touching the type scale. Chosen from Settings → Compact layout.
+         */
+        val Compact: SidekitSpacing = SidekitSpacing(
+            headerPaddingTop = 14.dp,
+            headerHeight = 75.dp,
+            actionBarHeight = 100.dp,
+        )
+    }
+}
 
 @Immutable
 data class SidekitShapes(