diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml
new file mode 100644
index 0000000000..46e315ed7e
--- /dev/null
+++ b/.github/workflows/ui-tests.yml
@@ -0,0 +1,431 @@
+name: ui-tests
+
+on:
+  workflow_dispatch:
+    inputs:
+      platform:
+        description: Which app's UI tests to run
+        type: choice
+        options:
+          - desktop
+          - android
+          - both
+        default: desktop
+      tests:
+        description: >-
+          Only these tests, comma- or space-separated: class names (chat.simplex.app.ui.main.ChatListRowsTest) or
+          Class#method; desktop also takes Gradle patterns with *. Empty runs all, in four shards per platform
+        type: string
+        default: ''
+
+permissions:
+  contents: read
+  actions: read
+
+concurrency:
+  group: ui-tests-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  GHC_VER: 9.6.3
+  CABAL_VER: 3.10.2.0
+  JAVA_VER: 17
+  DESKTOP_CORE_PKG: desktop-core-linux-x86_64.tar.gz
+  ANDROID_CORE_PKG: android-core-arm64-v8a.tar.gz
+  BIN_PKG: ui-tests-bin-linux-x86_64.tar.gz
+  APK: android-foss-arm64-v8a-debug.apk
+
+jobs:
+  plan:
+    name: choose jobs, find earlier builds
+    runs-on: ubuntu-24.04
+    timeout-minutes: 10
+    outputs:
+      run-desktop: ${{ steps.jobs.outputs.desktop }}
+      run-android: ${{ steps.jobs.outputs.android }}
+      desktop-shards: ${{ steps.jobs.outputs.desktop-shards }}
+      android-shards: ${{ steps.jobs.outputs.android-shards }}
+      desktop-core: ${{ steps.names.outputs.desktop-core }}
+      desktop-core-run: ${{ steps.desktop-core.outputs.run-id }}
+      android-core: ${{ steps.names.outputs.android-core }}
+      android-core-run: ${{ steps.android-core.outputs.run-id }}
+      bin: ${{ steps.names.outputs.bin }}
+      bin-run: ${{ steps.bin.outputs.run-id }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Choose jobs
+        id: jobs
+        env:
+          PLATFORM: ${{ inputs.platform }}
+          TESTS: ${{ inputs.tests }}
+        run: scripts/ci/ui-tests/plan.sh
+
+      # artifacts are named after the sources they are built from, so a run uses one that an earlier run uploaded;
+      # the core libraries have desktop-linux's and android-emu's names and sources, so these workflows reuse each other's
+      - name: Artifact names
+        id: names
+        run: |
+          echo "desktop-core=desktop-linux-core-${{ hashFiles('src/**', 'cabal.project', 'simplex-chat.cabal', 'PRIVACY.md', 'scripts/desktop/build-lib-linux.sh', 'scripts/ci/desktop-linux/build-core.sh') }}" >> "$GITHUB_OUTPUT"
+          echo "android-core=android-core-${{ hashFiles('src/**', 'cabal.project', 'simplex-chat.cabal', 'PRIVACY.md', 'flake.nix', 'flake.lock', 'scripts/nix/**', 'scripts/ci/android/build-core.sh') }}" >> "$GITHUB_OUTPUT"
+          echo "bin=ui-tests-bin-${{ hashFiles('src/**', 'apps/simplex-chat/**', 'tests/UITestServers.hs', 'tests/ChatClient.hs', 'tests/NameResolver.hs', 'tests/ChatTests/DBUtils.hs', 'tests/ChatTests/DBUtils/**', 'cabal.project', 'simplex-chat.cabal', 'PRIVACY.md', 'scripts/ci/ui-tests/build-bin.sh') }}" >> "$GITHUB_OUTPUT"
+
+      - name: Find desktop core library
+        id: desktop-core
+        if: steps.jobs.outputs.desktop == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: scripts/ci/desktop-linux/earlier-run.sh "${{ steps.names.outputs.desktop-core }}"
+
+      - name: Find Android core library
+        id: android-core
+        if: steps.jobs.outputs.android == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: scripts/ci/desktop-linux/earlier-run.sh "${{ steps.names.outputs.android-core }}"
+
+      - name: Find CLI and test servers
+        id: bin
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: scripts/ci/desktop-linux/earlier-run.sh "${{ steps.names.outputs.bin }}"
+
+  desktop-core:
+    name: core library for Linux
+    needs: plan
+    if: needs.plan.outputs.run-desktop == 'true' && needs.plan.outputs.desktop-core-run == ''
+    runs-on: ubuntu-24.04
+    timeout-minutes: 150
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Show runner
+        run: |
+          lsb_release -ds
+          nproc
+          free -h
+          df -h /
+
+      - name: Setup Haskell
+        uses: simplex-chat/setup-haskell-action@v2
+        with:
+          ghc-version: ${{ env.GHC_VER }}
+          cabal-version: ${{ env.CABAL_VER }}
+
+      - name: Install libraries
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libffi-dev libgmp-dev libnuma-dev libssl-dev zlib1g-dev patchelf
+
+      - name: Build core library
+        run: scripts/ci/desktop-linux/build-core.sh ~/core/${{ env.DESKTOP_CORE_PKG }}
+
+      - name: Upload core library
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ needs.plan.outputs.desktop-core }}
+          path: ~/core/${{ env.DESKTOP_CORE_PKG }}
+          compression-level: 0
+          retention-days: 30
+          if-no-files-found: error
+
+  android-core:
+    name: core library for Android arm64
+    needs: plan
+    if: needs.plan.outputs.run-android == 'true' && needs.plan.outputs.android-core-run == ''
+    runs-on: ubuntu-24.04
+    timeout-minutes: 150
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          filter: tree:0
+
+      - name: Show runner
+        run: |
+          lsb_release -ds
+          nproc
+          free -h
+          df -h /
+
+      - name: Build core library
+        run: scripts/ci/android/build-core.sh ~/core/${{ env.ANDROID_CORE_PKG }}
+
+      - name: Upload core library
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ needs.plan.outputs.android-core }}
+          path: ~/core/${{ env.ANDROID_CORE_PKG }}
+          compression-level: 0
+          retention-days: 30
+          if-no-files-found: error
+
+  bin:
+    name: CLI and test servers
+    needs: plan
+    if: needs.plan.outputs.bin-run == ''
+    runs-on: ubuntu-24.04
+    timeout-minutes: 150
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Show runner
+        run: |
+          lsb_release -ds
+          nproc
+          free -h
+          df -h /
+
+      - name: Setup Haskell
+        uses: simplex-chat/setup-haskell-action@v2
+        with:
+          ghc-version: ${{ env.GHC_VER }}
+          cabal-version: ${{ env.CABAL_VER }}
+
+      - name: Install libraries
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libffi-dev libgmp-dev libnuma-dev libssl-dev zlib1g-dev
+
+      - name: Build CLI and test servers
+        run: scripts/ci/ui-tests/build-bin.sh ~/bin/${{ env.BIN_PKG }}
+
+      - name: Upload CLI and test servers
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ needs.plan.outputs.bin }}
+          path: ~/bin/${{ env.BIN_PKG }}
+          compression-level: 0
+          retention-days: 30
+          if-no-files-found: error
+
+  desktop:
+    name: desktop UI tests (${{ matrix.shard }})
+    needs: [plan, desktop-core, bin]
+    # the builds are skipped when an earlier run built them
+    if: ${{ !cancelled() && !failure() && needs.plan.result == 'success' && needs.plan.outputs.run-desktop == 'true' }}
+    runs-on: ubuntu-24.04
+    timeout-minutes: 150
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJSON(needs.plan.outputs.desktop-shards) }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - name: Show runner
+        run: |
+          lsb_release -ds
+          nproc
+          free -h
+          df -h /
+          sysctl kernel.apparmor_restrict_unprivileged_userns || true
+
+      # the CLI's and test servers' libraries; the tests render headless, with these fonts
+      - name: Install libraries
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libffi-dev libgmp-dev libnuma-dev libssl-dev zlib1g-dev fonts-dejavu-core
+          dpkg-query -W libffi-dev libgmp-dev libnuma-dev libssl-dev zlib1g-dev fonts-dejavu-core
+
+      # uitest.sh runs the tests in their own user, PID and network namespaces, which Ubuntu 24.04 restricts
+      - name: Allow user namespaces
+        run: |
+          sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
+          unshare -rn --pid --fork --kill-child --mount-proc sh -c 'ip link set lo up && ip -brief addr'
+
+      - name: Download core library
+        uses: actions/download-artifact@v8
+        with:
+          name: ${{ needs.plan.outputs.desktop-core }}
+          path: ~/core
+          run-id: ${{ needs.plan.outputs.desktop-core-run || github.run_id }}
+          github-token: ${{ github.token }}
+
+      - name: Install core library
+        run: scripts/ci/desktop-linux/install-core.sh ~/core/${{ env.DESKTOP_CORE_PKG }}
+
+      - name: Download CLI and test servers
+        uses: actions/download-artifact@v8
+        with:
+          name: ${{ needs.plan.outputs.bin }}
+          path: ~/bin
+          run-id: ${{ needs.plan.outputs.bin-run || github.run_id }}
+          github-token: ${{ github.token }}
+
+      - name: Install CLI and test servers
+        run: scripts/ci/ui-tests/install-bin.sh ~/bin/${{ env.BIN_PKG }} "$RUNNER_TEMP/bin"
+
+      - name: Setup Java
+        uses: actions/setup-java@v5
+        with:
+          distribution: corretto
+          java-version: ${{ env.JAVA_VER }}
+
+      # uitest.sh builds the native library and the tests, then runs them with as many test JVMs as memory allows
+      - name: Run UI tests
+        id: run
+        working-directory: apps/multiplatform
+        env:
+          TESTS: ${{ matrix.tests }}
+        run: |
+          read -r -a patterns <<< "$TESTS"
+          args=()
+          for p in "${patterns[@]}"; do
+            args+=(--tests "$p")
+          done
+          scripts/uitest.sh "${args[@]}"
+
+      - name: Report UI tests
+        if: ${{ !cancelled() && steps.run.outcome != 'skipped' }}
+        env:
+          SHARD: ${{ matrix.shard }}
+        run: |
+          echo "## Desktop UI tests, shard $SHARD" >> "$GITHUB_STEP_SUMMARY"
+          scripts/ci/desktop-linux/test-summary.py apps/multiplatform/common/build/test-results/desktopUiTest/pass1
+
+      # a test's directory, with its peers' transcripts, is kept only when the test failed
+      - name: Upload UI test results
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v7
+        with:
+          name: ui-tests-desktop-${{ matrix.shard }}
+          path: |
+            apps/multiplatform/common/build/reports/tests/desktopUiTest
+            apps/multiplatform/common/build/test-results/desktopUiTest/*/*.xml
+            apps/multiplatform/build/uitest/run-*/failures
+            apps/multiplatform/build/uitest/run-*/jvm-*/t*/peers/*/transcript.log
+            apps/multiplatform/build/uitest/run-*/hs_err_pid*.log
+          retention-days: 7
+          if-no-files-found: warn
+
+  # an emulator runs one test at a time, so the tests are split over several. Each shard builds the APKs itself: it
+  # compiles the host-side bridge anyway, whose classpath names files in the job's own Gradle cache
+  android:
+    name: Android UI tests (${{ matrix.shard }})
+    needs: [plan, android-core, bin]
+    # the builds are skipped when an earlier run built them
+    if: ${{ !cancelled() && !failure() && needs.plan.result == 'success' && needs.plan.outputs.run-android == 'true' }}
+    runs-on: ubuntu-24.04
+    timeout-minutes: 240
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJSON(needs.plan.outputs.android-shards) }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - name: Show runner
+        run: |
+          lsb_release -ds
+          nproc
+          free -h
+          df -h /
+          echo "ANDROID_HOME=$ANDROID_HOME"
+          ls "$ANDROID_HOME/platforms" "$ANDROID_HOME/build-tools" "$ANDROID_HOME/ndk" || true
+
+      # the emulator's qemu needs libpulse0 and libegl1, the CLI and test servers the rest
+      - name: Install libraries
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libpulse0 libegl1 libffi-dev libgmp-dev libnuma-dev libssl-dev zlib1g-dev
+          dpkg-query -W libpulse0 libegl1 libffi-dev libgmp-dev libnuma-dev libssl-dev zlib1g-dev
+
+      - name: Download core library
+        uses: actions/download-artifact@v8
+        with:
+          name: ${{ needs.plan.outputs.android-core }}
+          path: ~/core
+          run-id: ${{ needs.plan.outputs.android-core-run || github.run_id }}
+          github-token: ${{ github.token }}
+
+      - name: Install core library
+        run: scripts/ci/android/install-core.sh ~/core/${{ env.ANDROID_CORE_PKG }}
+
+      - name: Download CLI and test servers
+        uses: actions/download-artifact@v8
+        with:
+          name: ${{ needs.plan.outputs.bin }}
+          path: ~/bin
+          run-id: ${{ needs.plan.outputs.bin-run || github.run_id }}
+          github-token: ${{ github.token }}
+
+      - name: Install CLI and test servers
+        run: scripts/ci/ui-tests/install-bin.sh ~/bin/${{ env.BIN_PKG }} "$RUNNER_TEMP/bin"
+
+      - name: Setup Java
+        uses: actions/setup-java@v5
+        with:
+          distribution: corretto
+          java-version: ${{ env.JAVA_VER }}
+
+      # as android-emu builds its APK, plus the test APK and the host-side bridge's classpath, which uitest-android.sh
+      # then finds up to date; all before install-sdk.sh points ANDROID_HOME at an SDK with only the emulator
+      - name: Build app, tests and bridge
+        working-directory: apps/multiplatform
+        run: |
+          ./gradlew --no-daemon --console=plain -Psimplex.assets.dir=../../assets -Pandroid.injected.build.abi=arm64-v8a \
+            :android:assembleFossDebug :android:assembleFossDebugAndroidTest :common:uitestBridgeClasspath
+          pkill -f KotlinCompileDaemon || true
+          mkdir -p "$RUNNER_TEMP/apk"
+          cp "android/build/intermediates/apk/foss/debug/$APK" "$RUNNER_TEMP/apk"
+          test_apk=$(find android/build -name 'android-foss-debug-androidTest.apk' | head -n 1)
+          [ -n "$test_apk" ] || { echo "error: no androidTest APK"; find android/build -name '*.apk'; exit 1; }
+          cp "$test_apk" "$RUNNER_TEMP/apk/androidTest.apk"
+          ls -la "$RUNNER_TEMP/apk"
+          unzip -l "$RUNNER_TEMP/apk/$APK" | grep -E ' lib/'
+
+      - name: Prepare test peers and servers
+        working-directory: apps/multiplatform
+        run: scripts/uitest.sh --prepare-only
+
+      - name: Install emulator and system image
+        run: scripts/ci/android/install-sdk.sh "$RUNNER_TEMP/android-sdk"
+
+      - name: Boot emulator
+        run: scripts/ci/android/emulator.sh start apps/multiplatform/build/uitest-android/emulator
+
+      # without local.properties' application_id.suffix the debug app's id is chat.simplex.app
+      - name: Run UI tests
+        id: run
+        working-directory: apps/multiplatform
+        env:
+          ARGS: ${{ matrix.args }}
+        run: |
+          read -r -a args <<< "$ARGS"
+          serial=$("$ANDROID_HOME/platform-tools/adb" devices | awk 'NR > 1 && $2 == "device" {print $1; exit}')
+          echo "device $serial"
+          free -m
+          export ADB="$ANDROID_HOME/platform-tools/adb" UITEST_SERIAL="$serial" UITEST_APP_ID=chat.simplex.app
+          scripts/uitest-android.sh "$RUNNER_TEMP/apk/$APK" "$RUNNER_TEMP/apk/androidTest.apk" "${args[@]}"
+
+      - name: Report UI tests
+        if: ${{ !cancelled() && steps.run.outcome != 'skipped' }}
+        env:
+          SHARD: ${{ matrix.shard }}
+        run: |
+          echo "## Android UI tests, shard $SHARD" >> "$GITHUB_STEP_SUMMARY"
+          run=$(ls -1dt apps/multiplatform/build/uitest-android/run-* | head -n 1)
+          scripts/ci/ui-tests/android-summary.py "$run"
+
+      # the bridge keeps its peers' transcripts for every test
+      - name: Upload UI test results
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v7
+        with:
+          name: ui-tests-android-${{ matrix.shard }}
+          path: |
+            apps/multiplatform/build/uitest-android
+            apps/multiplatform/build/uitest/run-*/jvm-*/bridge-peers/*/transcript.log
+          retention-days: 7
+          if-no-files-found: warn
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/AndroidHelpers.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/AndroidHelpers.kt
new file mode 100644
index 0000000000..b0021230a5
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/AndroidHelpers.kt
@@ -0,0 +1,125 @@
+package chat.simplex.app.ui.android
+
+import android.app.Notification
+import android.app.NotificationManager
+import android.content.ComponentName
+import android.os.ParcelFileDescriptor
+import android.os.PowerManager
+import android.view.KeyEvent
+import android.view.View
+import android.view.inputmethod.EditorInfo
+import android.widget.EditText
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.semantics.SemanticsProperties
+import androidx.compose.ui.state.ToggleableState
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.test.espresso.Espresso
+import androidx.test.espresso.UiController
+import androidx.test.espresso.ViewAction
+import androidx.test.espresso.ViewInteraction
+import androidx.test.espresso.matcher.ViewMatchers
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.runner.lifecycle.ActivityLifecycleMonitorRegistry
+import androidx.test.runner.lifecycle.Stage
+import androidx.work.WorkInfo
+import chat.simplex.app.SimplexService
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTestApp
+import chat.simplex.common.model.NotificationsMode
+import chat.simplex.common.platform.androidAppContext
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.platform.getWorkManagerInstance
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import chat.simplex.common.views.usersettings.changeNotificationsMode
+import org.hamcrest.CoreMatchers
+import org.hamcrest.Matcher
+
+internal fun shell(cmd: String): String =
+  ParcelFileDescriptor.AutoCloseInputStream(InstrumentationRegistry.getInstrumentation().uiAutomation.executeShellCommand(cmd)).bufferedReader().use { it.readText() }
+
+internal fun serviceNotification(): Notification? =
+  androidAppContext.getSystemService(NotificationManager::class.java).activeNotifications.firstOrNull { it.id == SimplexService.SIMPLEX_SERVICE_ID }?.notification
+
+internal fun receiverState(receiver: Class<*>): Int =
+  androidAppContext.packageManager.getComponentEnabledSetting(ComponentName(androidAppContext.packageName, receiver.name))
+
+internal fun uniqueWorkActive(name: String): Boolean =
+  androidAppContext.getWorkManagerInstance().getWorkInfosForUniqueWork(name).get().any { !it.state.isFinished }
+
+internal fun workStates(name: String): List<WorkInfo.State> =
+  androidAppContext.getWorkManagerInstance().getWorkInfosForUniqueWork(name).get().map { it.state }
+
+internal fun UiScope.withBackgroundServiceAllowed(body: () -> Unit) {
+  val pkg = androidAppContext.packageName
+  val allowListed = androidAppContext.getSystemService(PowerManager::class.java).isIgnoringBatteryOptimizations(pkg)
+  if (!allowListed) shell("dumpsys deviceidle whitelist +$pkg")
+  val result = runCatching {
+    poll(what = "the app allowed to run in background (battery allow-list, no background restriction)") { SimplexService.isBackgroundAllowed() }
+    body()
+  }
+  val stopped = runCatching {
+    UiTestApp.onMain { changeNotificationsMode(NotificationsMode.OFF, chatModel) }
+    poll(what = "the SimpleX Chat service to stop and its notification to go") { !SimplexService.isServiceStarted && !SimplexService.isServiceStarting && serviceNotification() == null }
+  }
+  if (!allowListed) shell("dumpsys deviceidle whitelist -$pkg")
+  result.getOrThrow()
+  stopped.getOrThrow()
+}
+
+internal class WindowFrame(val height: Int, val keyboardTop: Int)
+
+internal fun windowFrame(): WindowFrame {
+  var frame: WindowFrame? = null
+  UiTestApp.onMain {
+    val decor = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED).firstOrNull()?.window?.decorView
+    val insets = decor?.let { ViewCompat.getRootWindowInsets(it) }
+    if (decor != null && insets != null) frame = WindowFrame(decor.height, decor.height - insets.getInsets(WindowInsetsCompat.Type.ime()).bottom)
+  }
+  return frame ?: error("no resumed activity window to measure")
+}
+
+internal fun UiScope.settledKeyboardTop(): Int {
+  var last = -1
+  poll(what = "the soft keyboard to finish opening") {
+    val f = windowFrame()
+    (keyboardShown() && f.keyboardTop < f.height && f.keyboardTop == last).also { last = f.keyboardTop }
+  }
+  settle()
+  return windowFrame().keyboardTop
+}
+
+internal fun UiScope.boundsInWindow(key: UiKey): Rect {
+  waitFor(key)
+  return rule.onNode(matcher(key)).fetchSemanticsNode().boundsInWindow
+}
+
+internal fun UiScope.toggleState(key: UiKey): ToggleableState? {
+  waitFor(key)
+  return rule.onNode(matcher(key)).fetchSemanticsNode().config.getOrElseNullable(SemanticsProperties.ToggleableState) { null }
+}
+
+internal fun messageEditText(): ViewInteraction =
+  Espresso.onView(CoreMatchers.allOf(ViewMatchers.isAssignableFrom(EditText::class.java), ViewMatchers.withTagValue(CoreMatchers.equalTo<Any>(Ui.Chat.Message.tag))))
+
+internal fun messageLineCount(): Int {
+  var lines = -1
+  messageEditText().check { v, e -> lines = (v as? EditText)?.lineCount ?: throw (e ?: AssertionError("the message field is not an EditText")) }
+  return lines
+}
+
+internal fun pressImeEnter() {
+  messageEditText().perform(ImeEnterKey())
+}
+
+private class ImeEnterKey : ViewAction {
+  override fun getConstraints(): Matcher<View> = ViewMatchers.isAssignableFrom(EditText::class.java)
+  override fun getDescription() = "send the Enter key through the input connection, as the soft keyboard does"
+  override fun perform(uiController: UiController, view: View) {
+    val ic = (view as EditText).onCreateInputConnection(EditorInfo()) ?: error("the message field has no input connection")
+    ic.sendKeyEvent(KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENTER))
+    ic.sendKeyEvent(KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_ENTER))
+    uiController.loopMainThreadUntilIdle()
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/AppLinksAndroidTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/AppLinksAndroidTest.kt
new file mode 100644
index 0000000000..535339f642
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/AppLinksAndroidTest.kt
@@ -0,0 +1,110 @@
+package chat.simplex.app.ui.android
+
+import android.content.Intent
+import android.net.Uri
+import chat.simplex.app.MainActivity
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.CliPeer
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.createOneTimeLink
+import chat.simplex.app.ui.harness.planConfirm
+import chat.simplex.common.platform.androidAppContext
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class AppLinksAndroidTest : UiTest() {
+  @Test fun appLink_oneTimeLink_opensPlan() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val link = bobsOneTimeLink(bob)
+    alice.chatList.row(NOTES)
+    check(chatModel.chats.value.none { it.chatInfo.chatViewName == "bob" } && !exists(planConfirm)) { "bob's chat or a plan alert exists before the link is opened" }
+    deliverToApp(viewIntent(link))
+    awaitPlanForBob()
+    click(planConfirm)
+    poll(what = "bob's prepared chat open with Connect") { preparedBobOpen() && exists(Ui.Chat.Connect) }
+    click(Ui.Chat.Connect)
+    assertEquals("alice: contact is connected", bob.nextLine(CONNECT_TIMEOUT_MS))
+  }
+
+  @Test fun appLink_noData_showsInvalidLinkAlert() = uiTest {
+    app("alice").chatList.row(NOTES)
+    check(!AlertManager.shared.hasAlertsShown() && !seesText(INVALID_LINK)) { "an alert is shown before the link is opened" }
+    deliverToApp(viewIntent(null))
+    poll(what = "the `$INVALID_LINK` alert") { seesText(INVALID_LINK) && seesText("Please check that SimpleX link is correct.") }
+    check(!exists(planConfirm) && !AlertManager.privacySensitive.hasAlertsShown()) { "a link without data opened a connection plan" }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the alert closed over the chat list") { !AlertManager.shared.hasAlertsShown() && exists(Ui.ChatList.Search) }
+  }
+
+  @Test fun appLink_whileChatStopped_openedAfterStart() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val link = bobsOneTimeLink(bob)
+    stopChatFromChatData(alice)
+    deliverToApp(viewIntent(link))
+    poll(what = "the link queued by the app") { chatModel.appOpenUrl.value?.second == link }
+    settle()
+    check(chatModel.appOpenUrl.value?.second == link && !exists(planConfirm) && !AlertManager.privacySensitive.hasAlertsShown()) {
+      "the link was handled while the chat was stopped: queued ${chatModel.appOpenUrl.value}, texts ${texts().take(20)}"
+    }
+    click(Ui.Database.RunChat)
+    awaitPlanForBob()
+    check(chatModel.chatRunning.value == true && chatModel.appOpenUrl.value == null) { "the plan opened with the chat running ${chatModel.chatRunning.value}, queued ${chatModel.appOpenUrl.value}" }
+    click(planConfirm)
+    poll(what = "bob's prepared chat open in place of Chat data") { preparedBobOpen() && !exists(Ui.Database.RunChat) }
+  }
+
+  @Test fun appLink_intentFilter_matchesOnlyConnectionPaths() = uiTest {
+    val notOpening = OPENS.filterNot(::opensMainActivity)
+    val wronglyOpening = IGNORED.filter(::opensMainActivity)
+    check(notOpening.isEmpty() && wronglyOpening.isEmpty()) {
+      "links that must open the app but do not: $notOpening; links that open the app but must not: $wronglyOpening"
+    }
+  }
+
+  private fun bobsOneTimeLink(bob: CliPeer): String =
+    bob.createOneTimeLink().also { bob.eventually("and ask them to connect: /c <invitation_link_above>") }
+
+  private fun UiScope.awaitPlanForBob() =
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the plan alert for bob with `Open new chat`") { exists(planConfirm) && "Open new chat" in textsOf(planConfirm) && seesText("bob") }
+
+  private fun preparedBobOpen(): Boolean =
+    chatModel.chats.value.firstOrNull { it.chatInfo.chatViewName == "bob" && it.chatInfo.nextConnectPrepared }?.id?.let { it == chatModel.chatId.value } == true
+
+  private fun opensMainActivity(link: String): Boolean =
+    androidAppContext.packageManager.queryIntentActivities(Intent(Intent.ACTION_VIEW, Uri.parse(link)).setPackage(androidAppContext.packageName), 0)
+      .any { it.activityInfo.name == MainActivity::class.java.name }
+
+  private companion object {
+    const val NOTES = "Private notes"
+    const val INVALID_LINK = "Invalid link"
+    val OPENS = listOf(
+      "simplex:/contact#/?v=2-7&smp=x",
+      "simplexchat:/open",
+      "https://simplex.chat/contact#/?v=2-7&smp=x",
+      "https://simplex.chat/invitation#/?v=2-7&smp=x",
+      "https://simplex.chat/a#key",
+      "https://simplex.chat/c#key",
+      "https://simplex.chat/g#key",
+      "https://simplex.chat/i#key",
+      "https://simplex.chat/contact/#/?v=2-7&smp=x",
+      "https://simplex.chat/i/#key",
+      "https://smp4.simplex.im/a#key",
+      "https://smp19.simplex.im/i#key",
+      "https://smp1.simplexonflux.com/c#key",
+      "https://smp6.simplexonflux.com/g#key",
+    )
+    val IGNORED = listOf(
+      "https://simplex.chat/",
+      "https://simplex.chat/crowdfunding/",
+      "https://simplex.chat/blog/",
+      "https://simplex.chat/contacts",
+      "https://simplex.chat/about",
+      "https://localhost/a#key",
+      "https://example.com/i#key",
+    )
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/AppearanceAndroidTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/AppearanceAndroidTest.kt
new file mode 100644
index 0000000000..d1c6f5c8b3
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/AppearanceAndroidTest.kt
@@ -0,0 +1,58 @@
+package chat.simplex.app.ui.android
+
+import androidx.compose.ui.state.ToggleableState
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import chat.simplex.common.views.helpers.ModalManager
+import org.junit.Test
+
+class AppearanceAndroidTest : UiTest() {
+  @Test fun appearanceAndroid_interfaceSectionToolbars() = uiTest {
+    val alice = app("alice")
+    waitFor(Ui.ChatList.Search)
+    check(storedSetting(ONE_HAND) == null && storedSetting(CHAT_BOTTOM) == null) { "the toolbar prefs are not at their defaults: ${storedSetting(ONE_HAND)}, ${storedSetting(CHAT_BOTTOM)}" }
+    poll(what = "the chat list search field and toolbar at the bottom of the screen") { lowerHalf(Ui.ChatList.Search) == true && lowerHalf(Ui.ChatList.Bar) == true }
+    alice.chatList.open(NOTES)
+    poll(what = "the notes toolbar at the bottom of the screen") { lowerHalf(CHAT_TITLE) == true }
+    backToChatList()
+
+    alice.appearance()
+    check(toggleState(Ui.Appearance.OneHandUI) == ToggleableState.On && toggleState(Ui.Appearance.ChatBottomBar) == ToggleableState.On) {
+      "Reachable app toolbars ${toggleState(Ui.Appearance.OneHandUI)}, Reachable chat toolbar ${toggleState(Ui.Appearance.ChatBottomBar)}"
+    }
+    click(Ui.Appearance.ChatBottomBar)
+    poll(what = "Reachable chat toolbar off") { storedSetting(CHAT_BOTTOM) == "false" && toggleState(Ui.Appearance.ChatBottomBar) == ToggleableState.Off }
+    click(Ui.Appearance.OneHandUI)
+    poll(what = "Reachable app toolbars off, hiding Reachable chat toolbar") {
+      storedSetting(ONE_HAND) == "false" && toggleState(Ui.Appearance.OneHandUI) == ToggleableState.Off && !exists(Ui.Appearance.ChatBottomBar)
+    }
+    closeAppearance()
+    poll(what = "the chat list search field and toolbar at the top of the screen") { lowerHalf(Ui.ChatList.Search) == false && lowerHalf(Ui.ChatList.Bar) == false }
+
+    alice.appearance()
+    click(Ui.Appearance.OneHandUI)
+    poll(what = "Reachable app toolbars on, showing Reachable chat toolbar turned on again") {
+      storedSetting(ONE_HAND) == "true" && exists(Ui.Appearance.ChatBottomBar) && toggleState(Ui.Appearance.ChatBottomBar) == ToggleableState.On && storedSetting(CHAT_BOTTOM) == "true"
+    }
+  }
+
+  private fun UiScope.lowerHalf(key: UiKey): Boolean? =
+    rule.onAllNodes(matcher(key)).fetchSemanticsNodes().firstOrNull()?.boundsInWindow?.let { it.top >= windowFrame().height / 2f }
+
+  private fun UiScope.closeAppearance() {
+    escape()
+    poll(what = "Your settings again") { exists(Ui.Settings.Appearance) && !exists(Ui.Appearance.OneHandUI) }
+    escape()
+    poll(what = "the chat list with nothing open") { !ModalManager.start.hasModalsOpen() && !exists(Ui.Settings.Appearance) && !exists(Ui.UserPicker.Sheet) && exists(Ui.ChatList.Search) }
+  }
+
+  private companion object {
+    const val ONE_HAND = "OneHandUI"
+    const val CHAT_BOTTOM = "ChatBottomBar"
+    const val NOTES = "Private notes"
+    val CHAT_TITLE = Ui.Chat.Bar.part("title")
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/ComposeKeyboardAndroidTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/ComposeKeyboardAndroidTest.kt
new file mode 100644
index 0000000000..1d0159061e
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/ComposeKeyboardAndroidTest.kt
@@ -0,0 +1,87 @@
+package chat.simplex.app.ui.android
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class ComposeKeyboardAndroidTest : UiTest() {
+  @Test fun compose_enterKeyInsertsNewline_sendButtonSends() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, "hello")
+    pressImeEnter()
+    poll(what = "a line break after `hello` in the message field") { editableText(Ui.Chat.Message) == "hello\n" }
+    check(chat.itemTexts().none { "hello" in it }) { "Enter sent the message: ${chat.itemTexts()}" }
+    chat.send("there")
+    bob.expectsMessage("alice> hello", CONNECT_TIMEOUT_MS)
+    bob expects "there"
+  }
+
+  @Test fun compose_replyAndEdit_showKeyboard() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send(MINE)
+    bob.expectsMessage("alice> $MINE", CONNECT_TIMEOUT_MS)
+    bob sends "@alice $QUESTION"
+    val question = chat.itemId(QUESTION)
+    hideKeyboard()
+    rightClick(Ui.Chat.Item(question))
+    waitFor(Ui.Chat.ItemMenu(question, "reply"))
+    check(!keyboardShown() && !exists(CANCEL_CONTEXT)) { "the soft keyboard or a compose context is open before Reply" }
+    click(Ui.Chat.ItemMenu(question, "reply"))
+    poll(what = "the soft keyboard to open for the reply") { keyboardShown() && exists(CANCEL_CONTEXT) }
+    val keyboardTop = settledKeyboardTop()
+    val field = boundsInWindow(Ui.Chat.Message)
+    val quoted = boundsInWindow(Ui.Chat.Item(question))
+    check(field.bottom <= keyboardTop && quoted.bottom <= keyboardTop) {
+      "with the keyboard open (top at $keyboardTop px) the message field is at $field and bob's message at $quoted"
+    }
+
+    hideKeyboard()
+    chat.menu(MINE, "edit")
+    poll(what = "the soft keyboard to open for editing `$MINE`") { keyboardShown() && editableText(Ui.Chat.Message) == MINE }
+  }
+
+  @Test fun compose_editText_clearButtonForWrappedParagraph() = uiTest {
+    val alice = app("alice")
+    alice.chatList.open(NOTES)
+    typeInto(Ui.Chat.Message, "short")
+    poll(what = "`short` on one line of the message field") { messageLineCount() == 1 }
+    settle()
+    check(!exists(Ui.Chat.ClearText)) { "the clear-text button is shown for one line" }
+    replaceText(Ui.Chat.Message, PARAGRAPH)
+    poll(what = "the paragraph wrapped to four lines or more, with the clear-text button") { messageLineCount() >= 4 && exists(Ui.Chat.ClearText) }
+    check(editableText(Ui.Chat.Message)?.contains('\n') == false) { "the paragraph has a line break" }
+    hideKeyboard()
+    click(Ui.Chat.ClearText)
+    poll(what = "the message field cleared and the button gone") { editableText(Ui.Chat.Message).isNullOrEmpty() && !exists(Ui.Chat.ClearText) }
+  }
+
+  @Test fun attachSheet_keyboardOpen_fullyExpanded() = uiTest {
+    val alice = app("alice")
+    alice.chatList.open(NOTES)
+    click(Ui.Chat.Message)
+    poll(what = "the soft keyboard to open for the message field") { keyboardShown() }
+    check(!seesDescription("Close sheet")) { "the attachment sheet is open before Attach" }
+    click(described("Attach"))
+    poll(what = "the attachment sheet with Camera, Image, Video and File") { seesDescription("Close sheet") && SHEET_BUTTONS.all { exists(it) } }
+    SHEET_BUTTONS.forEach { waitStable(it) }
+    val keyboardTop = settledKeyboardTop()
+    val bottoms = SHEET_BUTTONS.associateWith { boundsInWindow(it).bottom }
+    check(bottoms.values.all { it <= keyboardTop }) { "attachment buttons end at $bottoms, below the keyboard top at $keyboardTop px" }
+  }
+
+  private companion object {
+    const val NOTES = "Private notes"
+    const val MINE = "my message to edit"
+    const val QUESTION = "question to reply to"
+    val PARAGRAPH = "word ".repeat(60).trim()
+    val SHEET_BUTTONS = listOf("camera", "image", "video", "file").map { Ui.Chat.Attach(it) }
+    val CANCEL_CONTEXT = described("Cancel")
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/KeystoreAndroidTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/KeystoreAndroidTest.kt
new file mode 100644
index 0000000000..34fcaa030c
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/KeystoreAndroidTest.kt
@@ -0,0 +1,142 @@
+package chat.simplex.app.ui.android
+
+import androidx.compose.ui.state.ToggleableState
+import chat.simplex.app.ui.harness.DB_WORK_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.chatData
+import chat.simplex.app.ui.harness.onboarding
+import chat.simplex.app.ui.harness.typeSecret
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.platform.chatCloseStore
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.platform.initChatController
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.database.deleteChatDatabaseFilesAndState
+import chat.simplex.common.views.helpers.AlertManager
+import chat.simplex.common.views.helpers.DBMigrationResult
+import chat.simplex.common.views.helpers.DatabaseUtils
+import chat.simplex.common.views.onboarding.OnboardingStage
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import java.security.KeyStore
+
+class KeystoreAndroidTest : UiTest() {
+  @Test fun keystore_freshDb_randomPassphraseFooter() = uiTest {
+    val alice = app(null)
+    freshInstallDatabaseViaApi()
+    val randomKey = DatabaseUtils.ksDatabasePassword.get()
+    check(!randomKey.isNullOrEmpty() && chatModel.chatDbEncrypted.value == true && storedSetting("InitialRandomDBPassphrase") == "true") {
+      "the fresh database: key in the Keystore ${!randomKey.isNullOrEmpty()}, encrypted ${chatModel.chatDbEncrypted.value}, random ${storedSetting("InitialRandomDBPassphrase")}"
+    }
+    val o = onboarding()
+    o.createProfile("alice")
+    check(o.stage == OnboardingStage.Step3_ChooseServerOperators) { "the step after Create profile is ${o.stage}, not Your network" }
+    click(Ui.Onboarding.Continue)
+    poll(what = "Network commitments") { o.stage == OnboardingStage.Step4_NetworkCommitments && exists(Ui.Onboarding.Accept) }
+    click(Ui.Onboarding.Accept)
+    o.waitForChatList()
+    check(DatabaseUtils.ksDatabasePassword.get() == randomKey && storedSetting("StoreDBPassphrase") == "true") { "onboarding changed the random key or stopped storing it" }
+
+    chatData(alice).management().passphrase()
+    val stored = storedFooter()
+    poll(what = "the random-passphrase footers") { seesText(stored) && seesText(RANDOM) }
+    check(toggleState(Ui.DbPassphrase.Save) == ToggleableState.On && !isEnabled(Ui.DbPassphrase.Save)) {
+      "Save passphrase in Keystore: ${toggleState(Ui.DbPassphrase.Save)}, enabled ${isEnabled(Ui.DbPassphrase.Save)}"
+    }
+    check(!exists(Ui.DbPassphrase.Current) && !seesText(NO_RECOVERY, substring = true)) { "the random passphrase screen asks for the current passphrase or shows the no-recovery note" }
+
+    typeSecret(Ui.DbPassphrase.New, NEW)
+    typeSecret(Ui.DbPassphrase.Confirm, NEW)
+    hideKeyboard()
+    click(Ui.DbPassphrase.Update)
+    poll(what = "the Change database passphrase? alert naming the Keystore") {
+      seesText("Change database passphrase?") && seesText(WILL_STORE, substring = true) && seesText(STORE_SECURELY, substring = true) &&
+        "Update" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the Database encrypted! alert") { seesText("Database encrypted!") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the chat running again and the Current passphrase field") {
+      !AlertManager.shared.hasAlertsShown() && chatModel.chatRunning.value == true && exists(Ui.DbPassphrase.Current)
+    }
+    poll(what = "the stored-passphrase footers without the random one") { seesText(stored) && seesText(NO_RECOVERY, substring = true) && !seesText(RANDOM) }
+    check(toggleState(Ui.DbPassphrase.Save) == ToggleableState.On && isEnabled(Ui.DbPassphrase.Save)) {
+      "Save passphrase in Keystore after the change: ${toggleState(Ui.DbPassphrase.Save)}, enabled ${isEnabled(Ui.DbPassphrase.Save)}"
+    }
+    check(DatabaseUtils.ksDatabasePassword.get() == NEW && storedSetting("InitialRandomDBPassphrase") == "false") {
+      "after the change: Keystore holds the new passphrase ${DatabaseUtils.ksDatabasePassword.get() == NEW}, random ${storedSetting("InitialRandomDBPassphrase")}"
+    }
+  }
+
+  @Test fun keystore_keyMissing_showsNotFoundAlert() = uiTest {
+    val alice = app("alice")
+    val notes = alice.chatList.open(NOTES)
+    notes.send(NOTE)
+    notes.itemId(NOTE)
+    backToChatList()
+    encryptDatabaseViaApi(NEW)
+    check(DatabaseUtils.ksDatabasePassword.get() == NEW && storedSetting("StoreDBPassphrase") == "true") { "the passphrase is not stored in the Keystore before the key is lost" }
+    deleteKeystoreKeyViaApi()
+    check(storedSetting("EncryptedDBPassphrase") != null && !seesText(NOT_FOUND)) { "the encrypted passphrase is gone from the prefs, or the alert shows before the restart" }
+    val after = restart(ready = { chatModel.chatDbStatus.value is DBMigrationResult.ErrorNotADatabase && !chatModel.ctrlInitInProgress.value }, what = "the database left locked without its key")
+    poll(what = "the Wrong database passphrase alert saying the passphrase is not in the Keystore") {
+      AlertManager.shared.hasAlertsShown() && seesText("Wrong database passphrase") && seesText(NOT_FOUND)
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the Encrypted database prompt with Save passphrase and open chat") {
+      !AlertManager.shared.hasAlertsShown() && seesText("Encrypted database") && "Save passphrase and open chat" in textsOf(Ui.DbError.Open)
+    }
+    typeSecret(Ui.DbError.Passphrase, NEW)
+    pressEnter(Ui.DbError.Passphrase)
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the chat list with alice's note after the keyboard's Done key") {
+      chatModel.chatDbStatus.value == DBMigrationResult.OK && chatModel.chatRunning.value == true && NOTE in after.chatList.rowTexts(NOTES)
+    }
+    check(DatabaseUtils.ksDatabasePassword.get() == NEW) { "Save passphrase and open chat did not store the passphrase in the Keystore again" }
+  }
+
+  private fun freshInstallDatabaseViaApi() {
+    val ctrl = chatController.getChatCtrl()
+    if (ctrl != null && ctrl != -1L) chatCloseStore(ctrl).let { check(it.isEmpty()) { "chatCloseStore failed: $it" } }
+    chatController.setChatCtrl(null)
+    deleteChatDatabaseFilesAndState()
+    appPrefs.initialRandomDBPassphrase.set(false)
+    runBlocking { initChatController() }
+    check(chatModel.chatDbStatus.value == DBMigrationResult.OK) { "fresh database: ${chatModel.chatDbStatus.value}" }
+  }
+
+  private fun encryptDatabaseViaApi(passphrase: String) {
+    val current = DatabaseUtils.ksDatabasePassword.get() ?: ""
+    val error = runBlocking {
+      chatController.apiStopChat()
+      chatModel.chatRunning.value = false
+      chatController.apiStorageEncryption(currentKey = current, newKey = passphrase)
+    }
+    check(error == null) { "encrypting the database failed: $error" }
+    DatabaseUtils.ksDatabasePassword.set(passphrase)
+    appPrefs.initialRandomDBPassphrase.set(false)
+    chatModel.chatDbEncrypted.value = true
+  }
+
+  private fun deleteKeystoreKeyViaApi() {
+    val ks = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
+    ks.deleteEntry(DB_KEY_ALIAS)
+    check(!ks.containsAlias(DB_KEY_ALIAS)) { "the Keystore still holds $DB_KEY_ALIAS" }
+  }
+
+  private fun storedFooter(): String =
+    "Android Keystore${DatabaseUtils.ksDatabasePassword.storage()?.let { " ($it)" } ?: ""} is used to securely store passphrase - it allows notification service to work."
+
+  private companion object {
+    const val NEW = "uitest-keystore-5Hq"
+    const val NOTES = "Private notes"
+    const val NOTE = "written before the key was lost"
+    const val DB_KEY_ALIAS = "databasePassword"
+    const val RANDOM = "Database is encrypted using a random passphrase, you can change it."
+    const val NO_RECOVERY = "you will NOT be able to recover or change passphrase if you lose it."
+    const val WILL_STORE = "Database encryption passphrase will be updated and stored in the Keystore."
+    const val STORE_SECURELY = "Please store passphrase securely, you will NOT be able to change it if you lose it."
+    const val NOT_FOUND = "Passphrase not found in Keystore, please enter it manually. This may have happened if you restored the app's data using a backup tool. If it's not the case, please contact developers."
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/NotificationModesAndroidTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/NotificationModesAndroidTest.kt
new file mode 100644
index 0000000000..36b5677a4e
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/NotificationModesAndroidTest.kt
@@ -0,0 +1,124 @@
+package chat.simplex.app.ui.android
+
+import android.Manifest
+import android.app.Notification
+import android.content.pm.PackageManager
+import chat.simplex.app.SimplexService
+import chat.simplex.app.ui.harness.App
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.described
+import chat.simplex.common.model.NotificationsMode
+import chat.simplex.common.platform.androidAppContext
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import org.junit.Test
+
+class NotificationModesAndroidTest : UiTest() {
+  @Test fun ntfMode_switchToService_startsForegroundService() = uiTest {
+    val alice = app("alice")
+    requireNotificationPermission()
+    withBackgroundServiceAllowed {
+      openNotificationSettings(alice)
+      check(OFF_TITLE in textsOf(Ui.Notifications.Mode)) { "Notification service row: ${textsOf(Ui.Notifications.Mode)}" }
+      openModePicker()
+      check(MODES.all { (mode, title) -> title in textsOf(option(mode)) }) { "mode options: ${MODES.map { textsOf(option(it.first)) }}" }
+      check(checkedTitles() == listOf(OFF_TITLE) && seesText(OFF_DESC)) { "picker before the change: checked ${checkedTitles()}" }
+      check(serviceNotification() == null && receiverState(START_RECEIVER) != PackageManager.COMPONENT_ENABLED_STATE_ENABLED && !uniqueWorkActive(RESTART_WORK)) {
+        "before Always on: service notification ${serviceNotification() != null}, StartReceiver ${receiverState(START_RECEIVER)}, restart work ${workStates(RESTART_WORK)}"
+      }
+
+      click(option(NotificationsMode.SERVICE))
+      poll(what = "Always on checked and stored, with its description") {
+        storedSetting(MODE_KEY) == NotificationsMode.SERVICE.name && checkedTitles() == listOf(SERVICE_TITLE) && seesText(SERVICE_DESC)
+      }
+      poll(what = "the SimpleX Chat service notification with Hide") {
+        serviceNotification()?.let { n ->
+          n.extras.getCharSequence(Notification.EXTRA_TITLE)?.toString() == "SimpleX Chat service" &&
+            n.extras.getCharSequence(Notification.EXTRA_TEXT)?.toString() == "Receiving messages…" &&
+            n.channelId == SimplexService.NOTIFICATION_CHANNEL_ID && n.actions.orEmpty().any { it.title?.toString() == "Hide" }
+        } == true && SimplexService.isServiceStarted
+      }
+      poll(what = "the boot and update receivers enabled and the restart worker scheduled") {
+        receiverState(START_RECEIVER) == PackageManager.COMPONENT_ENABLED_STATE_ENABLED &&
+          receiverState(UPDATE_RECEIVER) == PackageManager.COMPONENT_ENABLED_STATE_ENABLED && uniqueWorkActive(RESTART_WORK)
+      }
+      check(!AlertManager.shared.hasAlertsShown()) { "switching to Always on while allowed in background showed an alert: ${texts().take(20)}" }
+      escape()
+      poll(what = "Notifications showing Always on") { exists(Ui.Notifications.Mode) && SERVICE_TITLE in textsOf(Ui.Notifications.Mode) }
+
+      openModePicker()
+      click(option(NotificationsMode.OFF))
+      poll(what = "Runs when app is open checked and stored") { storedSetting(MODE_KEY) == NotificationsMode.OFF.name && checkedTitles() == listOf(OFF_TITLE) }
+      poll(what = "the service stopped, its notification gone, the receivers disabled and the restart worker cancelled") {
+        serviceNotification() == null && !SimplexService.isServiceStarted &&
+          receiverState(START_RECEIVER) == PackageManager.COMPONENT_ENABLED_STATE_DISABLED &&
+          receiverState(UPDATE_RECEIVER) == PackageManager.COMPONENT_ENABLED_STATE_DISABLED && !uniqueWorkActive(RESTART_WORK)
+      }
+      check(!AlertManager.shared.hasAlertsShown()) { "switching to Runs when app is open showed an alert: ${texts().take(20)}" }
+    }
+  }
+
+  @Test fun ntfMode_switchToPeriodic_schedulesFetcher() = uiTest {
+    val alice = app("alice")
+    requireNotificationPermission()
+    withBackgroundServiceAllowed {
+      val fetcher = "${androidAppContext.packageName}.UNIQUE_MESSAGES_FETCHER"
+      openNotificationSettings(alice)
+      openModePicker()
+      check(checkedTitles() == listOf(OFF_TITLE) && !uniqueWorkActive(fetcher)) { "before Starts periodically: checked ${checkedTitles()}, fetcher ${workStates(fetcher)}" }
+
+      click(option(NotificationsMode.PERIODIC))
+      poll(what = "Starts periodically checked and stored, with its description") {
+        storedSetting(MODE_KEY) == NotificationsMode.PERIODIC.name && checkedTitles() == listOf(PERIODIC_TITLE) && seesText(PERIODIC_DESC)
+      }
+      poll(what = "the periodic message fetcher scheduled") { uniqueWorkActive(fetcher) }
+      check(serviceNotification() == null && !SimplexService.isServiceStarted && receiverState(START_RECEIVER) == PackageManager.COMPONENT_ENABLED_STATE_DISABLED) {
+        "Starts periodically: service notification ${serviceNotification() != null}, service started ${SimplexService.isServiceStarted}, StartReceiver ${receiverState(START_RECEIVER)}"
+      }
+      check(!uniqueWorkActive(RESTART_WORK) && !AlertManager.shared.hasAlertsShown()) { "Starts periodically: restart work ${workStates(RESTART_WORK)}, alert ${AlertManager.shared.hasAlertsShown()}" }
+      escape()
+      poll(what = "Notifications showing Starts periodically") { exists(Ui.Notifications.Mode) && PERIODIC_TITLE in textsOf(Ui.Notifications.Mode) }
+
+      openModePicker()
+      click(option(NotificationsMode.OFF))
+      poll(what = "the periodic message fetcher cancelled with Runs when app is open stored") {
+        storedSetting(MODE_KEY) == NotificationsMode.OFF.name && !uniqueWorkActive(fetcher)
+      }
+    }
+  }
+
+  private fun requireNotificationPermission() =
+    check(androidAppContext.checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED) {
+      "the runner must grant POST_NOTIFICATIONS (setup item 2): without it the service does not start"
+    }
+
+  private fun UiScope.openNotificationSettings(app: App) {
+    app.settings()
+    click(described("Notifications"))
+    waitFor(Ui.Notifications.Mode)
+  }
+
+  private fun UiScope.openModePicker() {
+    click(Ui.Notifications.Mode)
+    waitFor(option(NotificationsMode.SERVICE))
+  }
+
+  private fun UiScope.checkedTitles(): List<String> = MODES.map { it.second }.filter { seesDescription(it) }
+
+  private fun option(mode: NotificationsMode) = Ui.Notifications.Mode.option(mode)
+
+  private companion object {
+    const val MODE_KEY = "NotificationsMode"
+    const val OFF_TITLE = "Runs when app is open"
+    const val PERIODIC_TITLE = "Starts periodically"
+    const val SERVICE_TITLE = "Always on"
+    const val OFF_DESC = "App can receive notifications only when it's running, no background service will be started"
+    const val PERIODIC_DESC = "Checks new messages every 10 minutes for up to 1 minute"
+    const val SERVICE_DESC = "Background service is always running – notifications will be shown as soon as the messages are available."
+    const val RESTART_WORK = SimplexService.SERVICE_START_WORKER_WORK_NAME_PERIODIC
+    val MODES = listOf(NotificationsMode.OFF to OFF_TITLE, NotificationsMode.PERIODIC to PERIODIC_TITLE, NotificationsMode.SERVICE to SERVICE_TITLE)
+    val START_RECEIVER = SimplexService.StartReceiver::class.java
+    val UPDATE_RECEIVER = SimplexService.AppUpdateReceiver::class.java
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/OnboardingProfileAndroidTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/OnboardingProfileAndroidTest.kt
new file mode 100644
index 0000000000..93ba92ccd3
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/OnboardingProfileAndroidTest.kt
@@ -0,0 +1,38 @@
+package chat.simplex.app.ui.android
+
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.onboarding
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.migration.MigrationToState
+import chat.simplex.common.views.onboarding.OnboardingStage
+import org.junit.Test
+
+class OnboardingProfileAndroidTest : UiTest() {
+  @Test fun androidOnboardingCreateProfileMobileLayout() = uiTest {
+    app(null)
+    waitFor(Ui.Onboarding.GetStarted)
+    check(!keyboardShown()) { "the soft keyboard is open on the welcome screen" }
+    click(Ui.Onboarding.GetStarted)
+    poll(what = "Your profile with the name field focused and the soft keyboard open") {
+      onboarding().stage == OnboardingStage.Step2_CreateProfile && exists(Ui.Onboarding.ProfileName) && keyboardShown()
+    }
+    check(seesText("Your profile") && seesText("On your phone, not on servers.") && seesText(NO_ACCOUNT, substring = true) && seesText("Enter profile name…")) {
+      "the mobile profile screen: ${texts().take(30)}"
+    }
+    check(textsOf(Ui.Onboarding.Migrate).toSet() == setOf("Migrate")) { "migrate button: ${textsOf(Ui.Onboarding.Migrate)}" }
+    check("Create profile" in textsOf(Ui.Onboarding.CreateProfile) && !isEnabled(Ui.Onboarding.CreateProfile)) { "Create profile is enabled with an empty name" }
+    typeInto(Ui.Onboarding.ProfileName, "alice")
+    poll(what = "Create profile enabled for `alice`") { isEnabled(Ui.Onboarding.CreateProfile) }
+
+    click(Ui.Onboarding.Migrate)
+    poll(what = "Migrate here leading with the camera section, then the archive link and file") {
+      chatModel.migrationState.value is MigrationToState.PasteOrScanLink && seesText("Scan QR code") && seesText("Or paste archive link") && seesText("Or import archive file")
+    }
+    check(!seesText("Paste archive link") && chatModel.currentUser.value == null) { "the desktop paste label is shown, or a profile was created: ${texts().take(30)}" }
+  }
+
+  private companion object {
+    const val NO_ACCOUNT = "No account. No phone. No email. No ID."
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/SettingsAndroidTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/SettingsAndroidTest.kt
new file mode 100644
index 0000000000..693f44599e
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/SettingsAndroidTest.kt
@@ -0,0 +1,92 @@
+package chat.simplex.app.ui.android
+
+import android.content.Intent
+import androidx.test.espresso.intent.Intents
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.chatRunningInCore
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.onboarding
+import chat.simplex.app.ui.harness.openProfileMenu
+import chat.simplex.app.ui.harness.userIdOf
+import chat.simplex.app.BuildConfig
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import chat.simplex.common.views.helpers.ModalManager
+import chat.simplex.common.views.onboarding.OnboardingStage
+import org.junit.Test
+
+class SettingsAndroidTest : UiTest() {
+  @Test fun settingsAndroid_rootListsAndroidItems() = uiTest {
+    val alice = app("alice")
+    alice.settings()
+    waitFor(Ui.Settings.Version)
+    val version = "${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})"
+    poll(what = "Your settings with the Android rows and the Android version") { ROOT_ITEMS.all { seesText(it) } && version in textsOf(Ui.Settings.Version) }
+    val texts = texts()
+    val advanced = ADVANCED_ORDER.map { texts.indexOf(it) }
+    check(advanced.zipWithNext().all { (a, b) -> a in 0 until b } && texts.indexOf(version) > advanced.last()) {
+      "Advanced settings order ${ADVANCED_ORDER.zip(advanced)}, version at ${texts.indexOf(version)}"
+    }
+
+    click(described("Shutdown"))
+    poll(what = "the Shutdown? alert with Cancel, Restart and Shutdown") {
+      AlertManager.shared.hasAlertsShown() && seesText("Shutdown?") && seesText(SHUTDOWN_DESC) && seesText("Restart") &&
+        "Cancel" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the alert closed over Your settings") { !AlertManager.shared.hasAlertsShown() && exists(Ui.Settings.Version) }
+    check(chatModel.chatRunning.value == true && chatRunningInCore()) { "Cancel on the Shutdown? alert stopped the chat" }
+
+    click(Ui.Settings.Version)
+    poll(what = "App version with the Android version, build and core version") {
+      seesText("App version: v${BuildConfig.VERSION_NAME}") && seesText("App build: ${BuildConfig.VERSION_CODE}") &&
+        seesText("Core version: v", substring = true) && seesText("Developer tools")
+    }
+  }
+
+  @Test fun helpAndroid_rateTheAppOpensMarket() = uiTest {
+    val alice = app("alice")
+    alice.settings()
+    click(Ui.Settings.Help)
+    waitFor(RATE)
+    check(seesText("Rate the app") && seesText("Contribute") && seesText("Star on GitHub")) { "Support the project rows: ${texts().take(40)}" }
+    check(viewIntents().isEmpty()) { "an ACTION_VIEW intent was fired before Rate the app: ${viewIntents()}" }
+    click(RATE)
+    poll(what = "an ACTION_VIEW intent for SimpleX Chat in the app store") { viewIntents().isNotEmpty() }
+    check(viewIntents() == listOf(MARKET_URI)) { "Rate the app opened ${viewIntents()}" }
+  }
+
+  @Test fun profilesAndroid_deleteLastVisibleReturnsToOnboarding() = uiTest {
+    val alice = app("alice")
+    val aliceId = userIdOf("alice")
+    alice.userPicker().profiles()
+    waitFor(Ui.Profiles.User(aliceId))
+    check(chatModel.users.size == 1 && chatRunningInCore()) { "users before the deletion: ${chatModel.users.map { it.user.displayName }}" }
+    openProfileMenu(aliceId, "delete")
+    click(Ui.Profiles.UserMenu(aliceId, "delete"))
+    val withConnections = Ui.Alert.Option(Ui.AlertSource.Shared, "deleteWithConnections")
+    poll(what = "the `Delete chat profile?` alert with `Profile and server connections`") { seesText("Delete chat profile?") && exists(withConnections) }
+    click(withConnections)
+    poll(what = "the welcome screen with Get started in place of the profiles list") {
+      exists(Ui.Onboarding.GetStarted) && onboarding().stage == OnboardingStage.Step1_SimpleXInfo && !ModalManager.start.hasModalsOpen() && !exists(Ui.Profiles.Add)
+    }
+    check(chatModel.currentUser.value == null && chatModel.users.isEmpty() && !chatRunningInCore()) {
+      "after deleting the last profile: current ${chatModel.currentUser.value?.displayName}, users ${chatModel.users.size}, chat running ${chatRunningInCore()}"
+    }
+  }
+
+  private fun viewIntents(): List<String> =
+    Intents.getIntents().filter { it.action == Intent.ACTION_VIEW }.map { it.data.toString() }
+
+  private companion object {
+    val RATE = described("Google Play")
+    const val MARKET_URI = "market://details?id=chat.simplex.app"
+    const val SHUTDOWN_DESC = "Notifications will stop working until you re-launch the app"
+    val ROOT_ITEMS = listOf(
+      "Your settings", "Appearance", "Your privacy", "Help & support", "Chat data", "Migrate to another device", "Supporter perks",
+      "Network & servers", "Notifications", "Audio & video calls", "Shutdown", "Crowdfunding on Wefunder"
+    )
+    val ADVANCED_ORDER = listOf("Network & servers", "Notifications", "Audio & video calls", "Shutdown")
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/ShareIntoAppAndroidTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/ShareIntoAppAndroidTest.kt
new file mode 100644
index 0000000000..63d98ce219
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/ShareIntoAppAndroidTest.kt
@@ -0,0 +1,226 @@
+package chat.simplex.app.ui.android
+
+import android.net.Uri
+import androidx.compose.ui.test.hasClickAction
+import androidx.compose.ui.test.hasContentDescription
+import androidx.compose.ui.test.hasTestTag
+import chat.simplex.app.ui.back.backFromRoot
+import chat.simplex.app.ui.back.relaunch
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.jpegFile
+import chat.simplex.app.ui.harness.receivesCompressedImage
+import chat.simplex.app.ui.harness.receivesFile
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.GroupFeatureEnabled
+import chat.simplex.common.model.GroupPreferences
+import chat.simplex.common.model.GroupProfile
+import chat.simplex.common.model.RoleGroupPreference
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import chat.simplex.common.views.helpers.ModalManager
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import java.io.File
+
+class ShareIntoAppAndroidTest : UiTest() {
+  @Test fun shareIn_text_toContact() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val bobId = alice.chatList.chatId("bob")
+    val chat = alice.chatList.open("bob")
+    chat.info()
+    waitFor(Ui.Info.Header)
+    check(ModalManager.end.hasModalsOpen() && shareListTitle() == null) { "bob's contact info is not open over his chat before the share" }
+    deliverToApp(shareTextIntent(TEXT))
+    poll(what = "the share list titled `$SHARE_MESSAGE` in place of bob's chat and contact info") {
+      shareListTitle() == SHARE_MESSAGE && chatModel.chatId.value == null && !ModalManager.end.hasModalsOpen() && !exists(Ui.Info.Header) && exists(Ui.Share.Row(bobId))
+    }
+    alice.chatList.shareTo("bob")
+    poll(what = "bob's chat with the shared text in the message field") { chatModel.chatId.value == bobId && editableText(Ui.Chat.Message) == TEXT }
+    chat.sendComposed()
+    bob.expectsMessage("alice> $TEXT", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun shareIn_file_toContact() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val bobId = alice.chatList.chatId("bob")
+    val pdf = File(exchangeDir(), PDF_NAME).apply { writeText(PDF_CONTENT) }
+    deliverToApp(shareStreamIntent("application/pdf", contentUri(pdf), CAPTION))
+    awaitShareList(SHARE_FILE)
+    alice.chatList.shareTo("bob")
+    poll(what = "bob's chat with the preview of $PDF_NAME and the shared caption") {
+      chatModel.chatId.value == bobId && seesDescription("Cancel file preview") && seesText(PDF_NAME) && editableText(Ui.Chat.Message) == CAPTION
+    }
+    ChatScreen(this).sendComposed()
+    poll(what = "the file preview cleared after Send") { !seesDescription("Cancel file preview") }
+    bob.expectsMessage("alice> $CAPTION", CONNECT_TIMEOUT_MS)
+    bob expectsMessage "alice> sends file $PDF_NAME (${PDF_CONTENT.length} bytes / ${PDF_CONTENT.length} bytes)"
+    bob expects "use /fr 1 [<dir>/ | <path>] to receive it"
+    bob.receivesFile(1, PDF_NAME, "alice")
+  }
+
+  @Test fun shareIn_image_toContact() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val bobId = alice.chatList.chatId("bob")
+    val (one, two, three) = listOf("share-1.jpg", "share-2.jpg", "share-3.jpg").map { contentUri(jpegFile(it)) }
+    deliverToApp(shareStreamIntent("image/jpeg", one))
+    awaitShareList(SHARE_MEDIA)
+    alice.chatList.shareTo("bob")
+    poll(what = "bob's chat with one image preview") { chatModel.chatId.value == bobId && seesDescription("Cancel image preview") && previewImages() == 1 }
+    sendImages()
+    bob.receivesCompressedImage("alice> ", 1)
+
+    deliverToApp(shareStreamsIntent("image/*", listOf(two, three)))
+    awaitShareList(SHARE_MEDIA)
+    alice.chatList.shareTo("bob")
+    poll(what = "bob's chat with two image previews") { chatModel.chatId.value == bobId && seesDescription("Cancel image preview") && previewImages() == 2 }
+    sendImages()
+    bob.receivesCompressedImage("alice> ", 2)
+    bob.receivesCompressedImage("alice> ", 3)
+  }
+
+  @Test fun shareIn_fileSchemeUri_invalidPathAlert() = uiTest {
+    app("alice").chatList.row(NOTES)
+    val fileUri = Uri.parse("file:///sdcard/Download/shared.jpg")
+    val intents = listOf(
+      shareStreamIntent("image/jpeg", fileUri),
+      shareStreamsIntent("image/*", listOf(contentUri(jpegFile("share-ok.jpg")), fileUri)),
+      shareStreamIntent("text/plain", fileUri, TEXT),
+      shareStreamIntent("application/pdf", fileUri),
+    )
+    for (intent in intents) {
+      val what = "${intent.action} ${intent.type}"
+      check(!AlertManager.shared.hasAlertsShown() && shareListTitle() == null) { "an alert or the share list is shown before $what" }
+      deliverToApp(intent)
+      poll(what = "the Invalid file path alert for $what") { seesText("Invalid file path") && seesText(INVALID_PATH) }
+      check(shareListTitle() == null && chatModel.sharedContent.value == null) { "$what with a file: URI was shared: ${chatModel.sharedContent.value}" }
+      click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+      poll(what = "the alert closed over the chat list after $what") { !AlertManager.shared.hasAlertsShown() && exists(Ui.ChatList.Search) }
+    }
+  }
+
+  @Test fun shareIn_sendMultipleNonMedia_onlyClosesChat() = uiTest {
+    val alice = app("alice")
+    val notesId = alice.chatList.chatId(NOTES)
+    alice.chatList.open(NOTES)
+    waitFor(Ui.Chat.Message)
+    check(chatModel.chatId.value == notesId) { "Private notes did not open" }
+    val pdf = contentUri(File(exchangeDir(), PDF_NAME).apply { writeText(PDF_CONTENT) })
+    deliverToApp(shareStreamsIntent("application/pdf", listOf(pdf, pdf)))
+    poll(what = "Private notes closed") { chatModel.chatId.value == null }
+    settle()
+    check(shareListTitle() == null && exists(Ui.ChatList.Search) && chatModel.sharedContent.value == null && !AlertManager.shared.hasAlertsShown()) {
+      "two shared PDFs: share list ${shareListTitle()}, shared content ${chatModel.sharedContent.value}, alert ${AlertManager.shared.hasAlertsShown()}"
+    }
+  }
+
+  @Test fun shareIn_fileToGroupWithFilesOff_alert() = uiTest {
+    app("alice").chatList.row(NOTES)
+    newGroupViaApi(NO_FILES, GroupPreferences(files = RoleGroupPreference(GroupFeatureEnabled.OFF)))
+    newGroupViaApi(NO_LINKS, GroupPreferences(simplexLinks = RoleGroupPreference(GroupFeatureEnabled.OFF)))
+    val alice = restart()
+    poll(what = "both groups loaded after the restart") { chatModel.chats.value.count { it.chatInfo is ChatInfo.Group } == 2 }
+    val noFilesId = alice.chatList.chatId(NO_FILES)
+    val noLinksId = alice.chatList.chatId(NO_LINKS)
+    val linkText = "join me: ${invitationLinkViaApi()}"
+    val pdf = File(exchangeDir(), PDF_NAME).apply { writeText(PDF_CONTENT) }
+
+    deliverToApp(shareStreamIntent("application/pdf", contentUri(pdf)))
+    awaitShareList(SHARE_FILE)
+    alice.chatList.shareTo(NO_FILES)
+    awaitProhibitedAlert()
+    alice.chatList.shareTo(NO_LINKS)
+    poll(what = "$NO_LINKS open with the preview of $PDF_NAME") { chatModel.chatId.value == noLinksId && seesDescription("Cancel file preview") && seesText(PDF_NAME) }
+
+    deliverToApp(shareTextIntent(linkText))
+    awaitShareList(SHARE_MESSAGE)
+    alice.chatList.shareTo(NO_LINKS)
+    awaitProhibitedAlert()
+    alice.chatList.shareTo(NO_FILES)
+    poll(what = "$NO_FILES open with the link in the message field") { chatModel.chatId.value == noFilesId && editableText(Ui.Chat.Message) == linkText }
+  }
+
+  @Test fun shareIn_systemBack_dropsContentAndFinishes() = uiTest {
+    app("alice").chatList.row(NOTES)
+    deliverToApp(shareTextIntent(TEXT))
+    awaitShareList(SHARE_MESSAGE)
+    backFromRoot()
+    check(chatModel.sharedContent.value == null) { "Back left the shared content: ${chatModel.sharedContent.value}" }
+    relaunch {
+      poll(what = "the chat list, not the share list, after relaunching") { exists(Ui.ChatList.Search) && shareListTitle() == null }
+    }
+  }
+
+  @Test fun shareIn_chatStopped_showsStoppedIcon() = uiTest {
+    val alice = app("alice")
+    val notesId = alice.chatList.chatId(NOTES)
+    deliverToApp(shareTextIntent(TEXT))
+    awaitShareList(SHARE_MESSAGE)
+    check(!seesDescription(STOPPED) && rowTappable(notesId)) { "the share list of a running chat: stopped icon ${seesDescription(STOPPED)}, notes tappable ${rowTappable(notesId)}" }
+    click(described("Back"))
+    poll(what = "the chat list after the toolbar Back, with the shared text dropped") {
+      shareListTitle() == null && exists(Ui.ChatList.Search) && chatModel.sharedContent.value == null
+    }
+
+    stopChatFromChatData(alice)
+    deliverToApp(shareTextIntent(TEXT))
+    awaitShareList(SHARE_MESSAGE)
+    check(seesDescription(STOPPED) && !rowTappable(notesId)) { "the share list of a stopped chat: stopped icon ${seesDescription(STOPPED)}, notes tappable ${rowTappable(notesId)}" }
+    click(described(STOPPED))
+    poll(what = "the `$STOPPED` alert with how to start the chat") { AlertManager.shared.hasAlertsShown() && seesText(STOPPED) && seesText(START_HINT) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the alert closed over the share list") { !AlertManager.shared.hasAlertsShown() && shareListTitle() == SHARE_MESSAGE }
+  }
+
+  private fun UiScope.previewImages(): Int =
+    rule.onAllNodes(hasContentDescription("preview image"), useUnmergedTree = true).fetchSemanticsNodes().size
+
+  private fun UiScope.sendImages() {
+    click(Ui.Chat.Send)
+    poll(what = "the image previews cleared after Send") { !seesDescription("Cancel image preview") }
+  }
+
+  private fun UiScope.awaitProhibitedAlert() {
+    poll(what = "the `Cannot send message` alert") { seesText("Cannot send message") && seesText("Selected chat preferences prohibit this message.") }
+    check(chatModel.chatId.value == null) { "a prohibited chat opened: ${chatModel.chatId.value}" }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the alert closed over the share list") { !AlertManager.shared.hasAlertsShown() && shareListTitle() != null }
+  }
+
+  private fun UiScope.rowTappable(chatId: String): Boolean {
+    waitFor(Ui.Share.Row(chatId))
+    return rule.onAllNodes(hasTestTag(Ui.Share.Row(chatId).tag) and hasClickAction()).fetchSemanticsNodes().isNotEmpty()
+  }
+
+  private fun newGroupViaApi(name: String, prefs: GroupPreferences) {
+    runBlocking { chatController.apiNewGroup(null, incognito = false, GroupProfile(name, "", null, groupPreferences = prefs)) } ?: error("apiNewGroup($name) failed")
+  }
+
+  private fun invitationLinkViaApi(): String =
+    runBlocking { chatController.apiAddContact(null, incognito = false) }.first?.first?.simplexChatUri(short = false) ?: error("apiAddContact failed")
+
+  private companion object {
+    const val NOTES = "Private notes"
+    const val TEXT = "hello from share"
+    const val CAPTION = "the notes, shared from another app"
+    const val PDF_NAME = "share-notes.pdf"
+    const val PDF_CONTENT = "Notes shared into SimpleX from another app"
+    const val NO_FILES = "nofiles"
+    const val NO_LINKS = "nolinks"
+    const val SHARE_MESSAGE = "Share message…"
+    const val SHARE_MEDIA = "Share media…"
+    const val SHARE_FILE = "Share file…"
+    const val STOPPED = "Chat is stopped"
+    const val START_HINT = "You can start chat via app Settings / Database or by restarting the app."
+    const val INVALID_PATH = "You shared an invalid file path. Report the issue to the app developers."
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/SystemIntegrationHelpers.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/SystemIntegrationHelpers.kt
new file mode 100644
index 0000000000..d06b2e09db
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/SystemIntegrationHelpers.kt
@@ -0,0 +1,95 @@
+package chat.simplex.app.ui.android
+
+import android.app.Notification
+import android.app.NotificationManager
+import android.content.Intent
+import android.net.Uri
+import androidx.core.content.FileProvider
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.runner.lifecycle.ActivityLifecycleMonitorRegistry
+import androidx.test.runner.lifecycle.Stage
+import chat.simplex.app.MainActivity
+import chat.simplex.app.model.NtfManager
+import chat.simplex.app.ui.harness.App
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTestApp
+import chat.simplex.app.ui.harness.chatData
+import chat.simplex.app.ui.harness.chatRunningInCore
+import chat.simplex.common.helpers.APPLICATION_ID
+import chat.simplex.common.platform.androidAppContext
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.platform.isAppOnForeground
+import chat.simplex.common.ui.Ui
+import java.io.File
+
+internal fun UiScope.deliverToApp(intent: Intent) {
+  InstrumentationRegistry.getInstrumentation().targetContext.startActivity(
+    Intent(intent).setClass(androidAppContext, MainActivity::class.java).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+  )
+  rule.waitForIdle()
+}
+
+internal fun contentUri(file: File): Uri = FileProvider.getUriForFile(androidAppContext, "$APPLICATION_ID.provider", file)
+
+internal fun shareTextIntent(text: String): Intent =
+  Intent(Intent.ACTION_SEND).setType("text/plain").putExtra(Intent.EXTRA_TEXT, text)
+
+internal fun shareStreamIntent(type: String, uri: Uri, text: String? = null): Intent =
+  Intent(Intent.ACTION_SEND).setType(type).putExtra(Intent.EXTRA_STREAM, uri).apply { if (text != null) putExtra(Intent.EXTRA_TEXT, text) }
+
+internal fun shareStreamsIntent(type: String, uris: List<Uri>): Intent =
+  Intent(Intent.ACTION_SEND_MULTIPLE).setType(type).putParcelableArrayListExtra(Intent.EXTRA_STREAM, ArrayList(uris))
+
+internal fun viewIntent(link: String?): Intent =
+  Intent(Intent.ACTION_VIEW).apply { if (link != null) data = Uri.parse(link) }
+
+internal fun UiScope.shareListTitle(): String? =
+  Ui.Share.Bar.part("title").let { if (exists(it)) textsOf(it).firstOrNull() else null }
+
+internal fun UiScope.awaitShareList(title: String) =
+  poll(what = "the share list titled `$title` in place of the chat list") { shareListTitle() == title && !exists(Ui.ChatList.Search) }
+
+internal fun UiScope.stopChatFromChatData(app: App) {
+  chatData(app).management()
+  click(Ui.Database.RunChat)
+  poll(what = "the Stop chat? alert with Stop") { seesText("Stop chat?") && "Stop" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+  click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  poll(what = "the chat stopped on screen and in the core") { seesText("Chat is stopped") && chatModel.chatRunning.value == false && !chatRunningInCore() }
+}
+
+internal class PostedNotification(val id: Int, val notification: Notification) {
+  val title: String? get() = notification.extras.getCharSequence(Notification.EXTRA_TITLE)?.toString()
+  val text: String? get() = notification.extras.getCharSequence(Notification.EXTRA_TEXT)?.toString()
+  override fun toString() = "#$id `$title`: `$text`"
+}
+
+private val notificationManager: NotificationManager get() = androidAppContext.getSystemService(NotificationManager::class.java)
+
+internal fun messageNotifications(): List<PostedNotification> =
+  notificationManager.activeNotifications
+    .filter { it.notification.channelId == NtfManager.MessageChannel && (it.notification.flags and Notification.FLAG_GROUP_SUMMARY) == 0 }
+    .map { PostedNotification(it.id, it.notification) }
+
+internal fun messageSummaryShown(): Boolean =
+  notificationManager.activeNotifications.any {
+    it.notification.channelId == NtfManager.MessageChannel && it.notification.group == NtfManager.MessageGroup && (it.notification.flags and Notification.FLAG_GROUP_SUMMARY) != 0
+  }
+
+internal fun clearNotificationsViaApi() = notificationManager.cancelAll()
+
+internal fun UiScope.awaitForeground() = poll(what = "the app in the foreground") { isAppOnForeground }
+
+internal fun runningMainActivities(): List<MainActivity> {
+  var live = emptyList<MainActivity>()
+  UiTestApp.onMain {
+    val monitor = ActivityLifecycleMonitorRegistry.getInstance()
+    live = Stage.values().filter { it != Stage.DESTROYED }.flatMap { monitor.getActivitiesInStage(it) }.filterIsInstance<MainActivity>()
+  }
+  return live
+}
+
+internal fun UiScope.finishMainActivities() {
+  val live = runningMainActivities()
+  UiTestApp.onMain { live.forEach { it.finish() } }
+  poll(what = "every MainActivity to be destroyed") { runningMainActivities().isEmpty() }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/SystemNotificationsAndroidTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/SystemNotificationsAndroidTest.kt
new file mode 100644
index 0000000000..5c3908fd09
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/SystemNotificationsAndroidTest.kt
@@ -0,0 +1,104 @@
+package chat.simplex.app.ui.android
+
+import android.app.Notification
+import chat.simplex.app.model.NtfManager
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitRowText
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.quiesce
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.MsgFilter
+import chat.simplex.common.platform.chatModel
+import org.junit.Test
+
+class SystemNotificationsAndroidTest : UiTest() {
+  @Test fun sysNtf_foreground_onlyForChatsNotOpen() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob)
+    connect(cath)
+    val bobId = alice.chatList.chatId("bob")
+    alice.chatList.row("cath")
+    quiesce()
+    awaitForeground()
+    clearNotificationsViaApi()
+    val chat = alice.chatList.open("bob")
+    bob sends "@alice $TO_OPEN_CHAT"
+    chat.itemId(TO_OPEN_CHAT)
+    cath sends "@alice $FROM_CATH"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "cath's message notification while bob's chat is open") { messageNotifications().any { it.title == "cath" } }
+    val fromCath = messageNotifications().single { it.title == "cath" }
+    check(fromCath.text == FROM_CATH && fromCath.notification.group == NtfManager.MessageGroup && (fromCath.notification.flags and Notification.FLAG_AUTO_CANCEL) != 0 && messageSummaryShown()) {
+      "cath's notification: $fromCath, group ${fromCath.notification.group}, flags ${fromCath.notification.flags}, summary ${messageSummaryShown()}"
+    }
+    check(chatModel.chatId.value == bobId && messageNotifications().none { it.title == "bob" }) { "bob's message to his open chat was notified: ${messageNotifications()}" }
+
+    backToChatList()
+    alice.chatList.rowMenu("cath", "ntfs.None", "Mute")
+    poll(what = "cath muted and her notification cancelled") {
+      alice.chatList.chat("cath").chatInfo.chatSettings?.enableNtfs == MsgFilter.None && messageNotifications().none { it.title == "cath" }
+    }
+    cath sends "@alice $MUTED"
+    awaitRowText(alice, "cath", MUTED)
+    bob sends "@alice $AFTER_CLOSE"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's notification now that his chat is closed") { messageNotifications().any { it.title == "bob" } }
+    check(messageNotifications().map { it.title to it.text } == listOf("bob" to AFTER_CLOSE)) { "notifications after muting cath: ${messageNotifications()}" }
+
+    alice.chatList.open("bob")
+    poll(what = "bob's notification cancelled once his chat is read") { messageNotifications().none { it.title == "bob" } }
+  }
+
+  @Test fun sysNtf_tapOpensChat() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val bobId = alice.chatList.chatId("bob")
+    quiesce()
+    awaitForeground()
+    clearNotificationsViaApi()
+    try {
+      bob sends "@alice $HELLO"
+      poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's message notification") { messageNotifications().any { it.title == "bob" && it.text == HELLO } }
+      check(chatModel.chatId.value == null && runningMainActivities().size == 1) { "before the tap: open chat ${chatModel.chatId.value}, activities ${runningMainActivities()}" }
+      messageNotifications().single { it.title == "bob" }.notification.contentIntent.send()
+      poll(what = "MainActivity recreated with bob's chat open") { runningMainActivities().size == 1 && chatModel.chatId.value == bobId }
+      ChatScreen(this).itemId(HELLO)
+      poll(what = "bob's notification cancelled once `$HELLO` is read") { messageNotifications().none { it.title == "bob" } }
+    } finally {
+      finishMainActivities()
+    }
+  }
+
+  @Test fun sysNtf_contactRequest_acceptAction() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val address = alice.userPicker().createAddress()
+    alice.chatList.row("Private notes")
+    awaitForeground()
+    clearNotificationsViaApi()
+    bob sends "/c $address"
+    bob expects "connection request sent!"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's contact request notification") { messageNotifications().any { it.title == "bob" && it.text == REQUEST } }
+    val request = messageNotifications().single { it.text == REQUEST }
+    val actions = request.notification.actions.orEmpty()
+    check(actions.map { it.title.toString() } == listOf("Accept") && request.notification.getLargeIcon() != null) {
+      "request notification actions ${actions.map { it.title }}, large icon ${request.notification.getLargeIcon() != null}"
+    }
+    check(chatModel.chats.value.none { (it.chatInfo as? ChatInfo.Direct)?.contact?.let { c -> c.displayName == "bob" && c.ready } == true }) { "bob is a connected contact before Accept" }
+    actions.single().actionIntent.send()
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the request notification replaced by bob's Connected notification") {
+      messageNotifications().let { ns -> ns.none { it.text == REQUEST } && ns.any { it.title == "bob" && it.text == "Connected" } }
+    }
+    check(chatModel.chatId.value == null) { "Accept in the notification opened a chat: ${chatModel.chatId.value}" }
+  }
+
+  private companion object {
+    const val TO_OPEN_CHAT = "sent to the open chat"
+    const val FROM_CATH = "hello from cath"
+    const val MUTED = "sent to a muted chat"
+    const val AFTER_CLOSE = "sent after the chat closed"
+    const val HELLO = "hello"
+    const val REQUEST = "New contact request"
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/UseFromDesktopAndroidTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/UseFromDesktopAndroidTest.kt
new file mode 100644
index 0000000000..c10c25e2a1
--- /dev/null
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/android/UseFromDesktopAndroidTest.kt
@@ -0,0 +1,73 @@
+package chat.simplex.app.ui.android
+
+import chat.simplex.app.ui.harness.Bridge
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitNewRemoteHost
+import chat.simplex.app.ui.harness.awaitRemoteHostCode
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.endDesktopSessionViaApi
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.linkToDesktop
+import chat.simplex.app.ui.harness.setDeviceName
+import chat.simplex.app.ui.harness.startRemoteHost
+import chat.simplex.app.ui.harness.useFromDesktop
+import chat.simplex.common.model.CIDirection
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.model.UIRemoteCtrlSessionState
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class UseFromDesktopAndroidTest : UiTest() {
+  @Test fun useFromDesktop_pasteVerifyConfirm_connected() = uiTest {
+    val alice = app("alice")
+    enableDeveloperToolsViaApi()
+    val desktop = cli("desktop")
+    desktop.setDeviceName(DESKTOP)
+    val invitation = desktop.startRemoteHost(Bridge.remoteCtrlPort())
+    setClipboardText(invitation)
+    val screen = useFromDesktop(alice)
+    val androidName = screen.deviceName()
+    check(!seesText(invitation)) { "the desktop address is shown before pasting it" }
+    screen.paste(invitation)
+    screen.connect()
+    val code = desktop.awaitRemoteHostCode()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Verify connection` with `$DESKTOP (new)` and the controller's session code `${code.take(23)}`") {
+      seesText("Verify connection") && seesText("$DESKTOP (new)") && seesText(code.take(23)) && exists(Ui.Remote.Confirm)
+    }
+    check(chatModel.remoteCtrlSession.value?.sessionState !is UIRemoteCtrlSessionState.Connected) { "the session is connected before Confirm" }
+    click(Ui.Remote.Confirm)
+    assertEquals("the host name the controller shows", androidName, desktop.awaitNewRemoteHost())
+    screen.awaitConnected(DESKTOP, code)
+    endDesktopSessionViaApi(desktop)
+  }
+
+  @Test fun useFromDesktop_controllerSendsAsAndroidUser() = uiTest {
+    val alice = app("alice")
+    enableDeveloperToolsViaApi()
+    val bob = cli("bob")
+    connect(bob)
+    val desktop = cli("desktop")
+    desktop.setDeviceName(DESKTOP)
+    linkToDesktop(alice, desktop, DESKTOP, Bridge.remoteCtrlPort())
+    desktop sends "/contacts"
+    desktop.eventually("bob")
+    desktop sends "@bob hi from desktop"
+    bob.eventuallyMessage("alice> hi from desktop", CONNECT_TIMEOUT_MS)
+    endDesktopSessionViaApi(desktop)
+    goBack()
+    poll(what = "`Connect to desktop` to close over alice's chat list") { !exists(Ui.Remote.DeviceName) && exists(Ui.ChatList.Search) }
+    alice.chatList.open("bob")
+    poll(what = "the message sent from the desktop as alice's sent item in the chat with bob") {
+      seesText("hi from desktop", substring = true) && chatModel.chatsContext.chatItems.value.any { it.content.text == "hi from desktop" && it.chatDir is CIDirection.DirectSnd }
+    }
+  }
+
+  private fun enableDeveloperToolsViaApi() = appPrefs.developerTools.set(true)
+
+  private companion object {
+    const val DESKTOP = "My desktop"
+  }
+}
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/CliPeer.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/CliPeer.kt
index 7236b92cd1..3f4ff3f6ee 100644
--- a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/CliPeer.kt
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/CliPeer.kt
@@ -35,12 +35,56 @@ object Bridge {
   }
 
   fun servers(): Pair<String, String> = call("servers").first().split(" ").let { it[1] to it[2] }
+
+  fun remoteCtrlPort(): Int = call("remotePort").first().removePrefix("ok ").toInt()
+}
+
+object TestServers {
+  fun start(name: String): String = Bridge.call("server start $name").first().removePrefix("ok ")
+
+  fun stop(name: String) { Bridge.call("server stop $name") }
+
+  fun reset(name: String): String = Bridge.call("server reset $name").first().removePrefix("ok ")
+
+  fun address(name: String): String = Bridge.call("server address $name").first().removePrefix("ok ")
+
+  fun restoreBaseline() { Bridge.call("server baseline") }
+}
+
+object SocksProxy {
+  private var started: Int? = null
+
+  val port: Int get() = started ?: error("the SOCKS proxy is not started; SocksProxy.start() starts it")
+
+  fun start() {
+    if (started == null) started = Bridge.call("socks start").first().removePrefix("ok ").toInt()
+  }
+
+  fun connections(): List<SocksConnection> =
+    Bridge.call("socks connections").map { line ->
+      val (host, port, username) = line.split(" ", limit = 3)
+      SocksConnection(host, port.toInt(), username.takeIf { it != "-" })
+    }
+
+  fun stop() {
+    if (started == null) return
+    started = null
+    Bridge.call("socks stop")
+  }
 }
 
 class CliPeer(name: String, private val flags: PeerFlags, waiter: Waiter) : PeerLines(name, waiter) {
+  private var relayLink: String? = null
+
+  val relayAddress: String
+    get() = relayLink ?: error("$name printed no chat relay address; start it with PeerFlags(relay = true) on a new database")
+
   fun start() {
-    val f = listOfNotNull("reactions".takeIf { flags.reactions }, "markRead".takeIf { flags.markRead }, "fullLinks".takeIf { flags.fullLinks })
-    Bridge.call("start $name ${f.joinToString(",")}")
+    val f = listOfNotNull(
+      "reactions".takeIf { flags.reactions }, "markRead".takeIf { flags.markRead }, "fullLinks".takeIf { flags.fullLinks }, "relay".takeIf { flags.relay },
+      "smp=${flags.smpServer}".takeIf { flags.smpServer != PeerFlags().smpServer }, "xftp=${flags.xftpServer}".takeIf { flags.xftpServer != PeerFlags().xftpServer }
+    )
+    Bridge.call("start $name ${f.joinToString(",")}").first().removePrefix("ok").trim().takeIf { it.isNotEmpty() }?.let { relayLink = it }
   }
 
   fun stop() { runCatching { Bridge.call("stop $name") } }
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/UiTest.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/UiTest.kt
index 16a3647a1c..baf41fbd9c 100644
--- a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/UiTest.kt
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/UiTest.kt
@@ -23,6 +23,9 @@ import android.app.Instrumentation
 import android.content.Intent
 import androidx.test.espresso.intent.Intents
 import androidx.test.espresso.intent.matcher.IntentMatchers
+import androidx.core.content.FileProvider
+import chat.simplex.common.helpers.APPLICATION_ID
+import java.io.File
 
 abstract class UiTest {
   @get:Rule val rule: ComposeTestRule = createEmptyComposeRule()
@@ -83,18 +86,36 @@ class UiScope(val rule: ComposeTestRule) {
     return App(this)
   }
 
-  fun restart(): App {
-    UiTestApp.restartCore()
-    UiTestApp.onMain { CommonPrefs.reload() }
-    poll(timeoutMs = 60_000, what = "the core to start again with chat running") {
+  fun restart(
+    ready: () -> Boolean = {
       val m = chat.simplex.common.platform.chatModel
       m.chatDbStatus.value != null && !m.ctrlInitInProgress.value && m.chatRunning.value == true && m.currentUser.value != null && m.users.isNotEmpty()
-    }
+    },
+    what: String = "the core to start again with chat running"
+  ): App {
+    UiTestApp.restartCore()
+    UiTestApp.onMain { CommonPrefs.reload() }
+    poll(timeoutMs = 60_000, what = what) { ready() }
     Timing.phase("close") { close() }
     Timing.phase("launch") { launch() }
     return App(this)
   }
 
+  fun exchangeDir(): File = File(androidAppContext.filesDir, "uitest-exchange").apply { mkdirs() }
+
+  fun saveFileAs(file: File, action: () -> Unit) = answerIntent(listOf(Intent.ACTION_CREATE_DOCUMENT), file, action)
+
+  fun openFile(file: File, action: () -> Unit) = answerIntent(listOf(Intent.ACTION_GET_CONTENT, Intent.ACTION_PICK), file, action)
+
+  private fun answerIntent(intentActions: List<String>, file: File, action: () -> Unit) {
+    val uri = FileProvider.getUriForFile(androidAppContext, "$APPLICATION_ID.provider", file)
+    val result = Instrumentation.ActivityResult(Activity.RESULT_OK, Intent().setData(uri))
+    intentActions.forEach { Intents.intending(IntentMatchers.hasAction(it)).respondWith(result) }
+    val before = Intents.getIntents().count { it.action in intentActions }
+    action()
+    poll(what = "the app to ask for a file with ${intentActions.joinToString(" or ")}") { Intents.getIntents().count { it.action in intentActions } > before }
+  }
+
   fun keyboardShown(): Boolean {
     var shown = false
     UiTestApp.onMain {
@@ -128,6 +149,7 @@ class UiScope(val rule: ComposeTestRule) {
 
   fun finish() {
     peers.forEach { it.dispose() }
+    runCatching { SocksProxy.stop() }
     Timing.phase("close") { close() }
     Timing.phase("drain") { UiTestApp.drain() }
   }
@@ -155,6 +177,7 @@ class UiScope(val rule: ComposeTestRule) {
     val deadline = start + timeoutMs
     var busyAtDeadline: Set<Long>? = null
     var lastError: Throwable? = null
+    var workEnded = false
     while (true) {
       rule.mainClock.advanceTimeBy(48, ignoreFrameDuration = true)
       rule.waitForIdle()
@@ -165,10 +188,12 @@ class UiScope(val rule: ComposeTestRule) {
       }
       val now = System.currentTimeMillis()
       val busy = if (now > deadline) busyAtDeadline ?: UiIdle.inFlight().map { it.id }.toSet().also { busyAtDeadline = it } else emptySet()
-      if (now > deadline && (UiIdle.inFlight().none { it.id in busy } || now > deadline + EXTENSION_MS)) {
+      val idle = now > deadline && UiIdle.inFlight().none { it.id in busy }
+      if (now > deadline && ((idle && workEnded) || now > deadline + EXTENSION_MS)) {
         val shot = if (screenshot) FailureShots.take(what) else null
         throw AssertionError("timed out after $timeoutMs ms waiting for $what; ${lastError?.let { "last condition error: $it; " } ?: ""}in flight: ${UiIdle.inFlight().joinToString { it.what }}; screenshot: $shot; visible texts: ${texts().take(60)}")
       }
+      workEnded = idle
       Thread.sleep(50)
     }
   }
@@ -197,6 +222,31 @@ class UiScope(val rule: ComposeTestRule) {
     }
   }
 
+  fun scrollChatTowardOlder(pages: Int = 1): Boolean = scrollChat(pages, towardOlder = true)
+
+  fun scrollChatTowardNewer(pages: Int = 1): Boolean = scrollChat(pages, towardOlder = false)
+
+  private fun scrollChat(pages: Int, towardOlder: Boolean): Boolean {
+    val list = rule.onNode(SemanticsMatcher.keyIsDefined(SemanticsActions.ScrollToIndex) and SemanticsMatcher.keyIsDefined(SemanticsActions.ScrollBy) and hasAnyDescendant(chatItemNode))
+    repeat(pages) {
+      val items = rule.onAllNodes(chatItemNode).fetchSemanticsNodes()
+      val tracked = (if (towardOlder) items.minByOrNull { it.boundsInRoot.top } else items.maxByOrNull { it.boundsInRoot.bottom })
+        ?: throw AssertionError("no chat items in view to scroll the chat")
+      val tag = tracked.config[SemanticsProperties.TestTag]
+      val before = tracked.boundsInRoot
+      val node = list.fetchSemanticsNode()
+      val dy = node.boundsInRoot.height * CHAT_SCROLL_PAGE
+      rule.runOnUiThread { node.config[SemanticsActions.ScrollBy].action?.invoke(0f, if (towardOlder) dy else -dy) }
+      settle()
+      val after = rule.onAllNodes(hasTestTag(tag)).fetchSemanticsNodes().firstOrNull()?.boundsInRoot
+      if (after == before) return false
+      if (after == null || (if (towardOlder) after.top <= before.top else after.bottom >= before.bottom)) {
+        throw AssertionError("scrolling the chat toward ${if (towardOlder) "older" else "newer"} messages moved $tag the other way: $before -> $after")
+      }
+    }
+    return true
+  }
+
   fun waitStable(key: UiKey) {
     var last: androidx.compose.ui.geometry.Rect? = null
     try {
@@ -246,13 +296,16 @@ class UiScope(val rule: ComposeTestRule) {
     rule.waitForIdle()
   }
 
-  private fun isMessageField(key: UiKey) = key.tag == Ui.Chat.Message.tag
+  private fun isMessageField(key: UiKey) = key.id == Ui.Chat.Message.id
+
+  private fun messageEditText(key: UiKey) =
+    Espresso.onView(org.hamcrest.CoreMatchers.allOf(ViewMatchers.isAssignableFrom(EditText::class.java), ViewMatchers.withTagValue(org.hamcrest.CoreMatchers.equalTo<Any>(key.tag))))
 
   private fun setMessageField(key: UiKey, value: String) {
     waitFor(key)
     waitStable(key)
     settle()
-    Espresso.onView(ViewMatchers.isAssignableFrom(EditText::class.java)).perform(CommitText(value))
+    messageEditText(key).perform(CommitText(value))
     poll(what = "the message field to hold `$value`") { editableText(key) == value }
   }
 
@@ -285,7 +338,7 @@ class UiScope(val rule: ComposeTestRule) {
   }
 
   fun pressEnter(key: UiKey) {
-    if (isMessageField(key)) click(Ui.Chat.Send) else rule.onNode(matcher(key)).performImeAction()
+    if (isMessageField(key)) click(key.part("send")) else rule.onNode(matcher(key)).performImeAction()
     rule.waitForIdle()
   }
 
@@ -295,13 +348,21 @@ class UiScope(val rule: ComposeTestRule) {
   fun editableText(key: UiKey): String? {
     if (isMessageField(key)) {
       var t: String? = null
-      Espresso.onView(ViewMatchers.isAssignableFrom(EditText::class.java)).check { v, _ -> t = (v as? EditText)?.text?.toString() }
+      messageEditText(key).check { v, _ -> t = (v as? EditText)?.text?.toString() }
       return t
     }
     return rule.onAllNodes((matcher(key) or hasAnyAncestor(matcher(key))) and SemanticsMatcher.keyIsDefined(SemanticsProperties.EditableText), useUnmergedTree = true)
       .fetchSemanticsNodes().firstOrNull()?.config?.get(SemanticsProperties.EditableText)?.text
   }
 
+  fun hintOf(key: UiKey): String? {
+    if (!isMessageField(key)) return if (editableText(key).isNullOrEmpty()) textsOf(key).firstOrNull() else null
+    waitFor(key)
+    var hint: String? = null
+    messageEditText(key).check { v, _ -> hint = (v as? EditText)?.takeIf { it.text.isNullOrEmpty() }?.hint?.toString() }
+    return hint
+  }
+
   fun textsOf(key: UiKey): List<String> {
     waitFor(key)
     val own = rule.onNode(matcher(key)).fetchSemanticsNode().config.getOrElseNullable(SemanticsProperties.Text) { null }.orEmpty().map { it.text }
@@ -350,6 +411,13 @@ class UiScope(val rule: ComposeTestRule) {
       val inner = if (i.action == Intent.ACTION_CHOOSER) i.getParcelableExtra(Intent.EXTRA_INTENT) as? Intent else i
       inner?.getStringExtra(Intent.EXTRA_TEXT)
     } ?: (androidAppContext.getSystemService(Context.CLIPBOARD_SERVICE) as android.content.ClipboardManager).primaryClip?.getItemAt(0)?.text?.toString()
+
+  fun setClipboardText(text: String?) = UiTestApp.onMain {
+    val cm = androidAppContext.getSystemService(Context.CLIPBOARD_SERVICE) as android.content.ClipboardManager
+    if (text != null) cm.setPrimaryClip(android.content.ClipData.newPlainText("uitest", text))
+    else if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.P) cm.clearPrimaryClip()
+    else error("clearing the clipboard needs Android 9")
+  }
 }
 
 object FailureShots {
@@ -379,6 +447,9 @@ object Timing {
 }
 
 private const val SETTLE_MS = 500L
+private const val CHAT_SCROLL_PAGE = 0.8f
+private val CHAT_ITEM_TAG = "${Ui.Chat.Item(0).id}["
+private val chatItemNode = SemanticsMatcher("a chat item") { it.config.getOrElseNullable(SemanticsProperties.TestTag) { null }?.startsWith(CHAT_ITEM_TAG) == true }
 private const val KEYBOARD_SHOW_MS = 1_500L
 private const val END_WORK_MS = 30_000L
 private const val EXTENSION_MS = 60_000L
diff --git a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/UiTestApp.kt b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/UiTestApp.kt
index d1da0df273..60a91e39cc 100644
--- a/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/UiTestApp.kt
+++ b/apps/multiplatform/android/src/androidTest/java/chat/simplex/app/ui/harness/UiTestApp.kt
@@ -75,6 +75,7 @@ object UiTestApp {
     Timing.phase("reset.stop running=${chatModel.chatRunning.value}") { stopCore() }
     Timing.phase("reset.delete") { deleteChatDatabaseFilesAndState() }
     Timing.phase("reset.prefs") { PrefStores.restore() }
+    Timing.phase("reset.serversBaseline") { TestServers.restoreBaseline() }
     androidx.test.platform.app.InstrumentationRegistry.getInstrumentation().uiAutomation.executeShellCommand("cmd statusbar collapse").close()
     if (chat.simplex.app.SimplexService.isServiceStarted) Timing.phase("reset.ntfs") {
       onMain { chat.simplex.common.views.usersettings.changeNotificationsMode(chat.simplex.common.model.NotificationsMode.OFF, chatModel) }
@@ -111,7 +112,12 @@ object UiTestApp {
   }
 
   private fun stopCore() {
-    waitUntil(10_000, "ctrlInitInProgress to clear") { !chatModel.ctrlInitInProgress.value }
+    val deadline = System.currentTimeMillis() + 10_000
+    while (chatModel.ctrlInitInProgress.value && System.currentTimeMillis() < deadline) Thread.sleep(50)
+    if (chatModel.ctrlInitInProgress.value) {
+      android.util.Log.w("UITEST", "ctrlInitInProgress still set after 10 s (left by a failed test); clearing it to reset")
+      chatModel.ctrlInitInProgress.value = false
+    }
     runBlocking {
       val ctrl = chatController.getChatCtrl()
       if (ctrl != null && ctrl != -1L && chatModel.chatRunning.value == true) chatController.apiStopChat()
diff --git a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/platform/PlatformTextField.android.kt b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/platform/PlatformTextField.android.kt
index 96a6a1e14d..dc492b8ef3 100644
--- a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/platform/PlatformTextField.android.kt
+++ b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/platform/PlatformTextField.android.kt
@@ -36,8 +36,9 @@ import chat.simplex.common.R
 import chat.simplex.common.helpers.toURI
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.model.ChatModel
-import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.ui
+import chat.simplex.common.ui.uiTestHooksEnabled
 import chat.simplex.common.ui.theme.CurrentColors
 import chat.simplex.common.views.chat.*
 import chat.simplex.common.views.helpers.*
@@ -62,6 +63,7 @@ actual fun PlatformTextField(
   onUpArrow: () -> Unit,
   onFilesPasted: (List<URI>) -> Unit,
   focusRequester: FocusRequester?,
+  uiKey: UiKey?,
   onDone: () -> Unit,
 ) {
   val cs = composeState.value
@@ -98,7 +100,7 @@ actual fun PlatformTextField(
   }
 
   val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
-  AndroidView(modifier = Modifier.ui(Ui.Chat.Message), factory = { context ->
+  AndroidView(modifier = Modifier.ui(uiKey), factory = { context ->
     val editText = @SuppressLint("AppCompatCustomView") object: EditText(context) {
       override fun setOnReceiveContentListener(
         mimeTypes: Array<out String>?,
@@ -137,6 +139,7 @@ actual fun PlatformTextField(
     editText.background = ColorDrawable(Color.Transparent.toArgb())
     editText.textDirection = if (isRtl) EditText.TEXT_DIRECTION_LOCALE else EditText.TEXT_DIRECTION_ANY_RTL
     editText.setPaddingRelative(paddingStart, paddingTop, paddingEnd, paddingBottom)
+    if (uiTestHooksEnabled) editText.tag = uiKey?.tag
     editText.setText(cs.message.text)
     editText.setSelection(cs.message.selection.start, cs.message.selection.end)
     editText.hint = placeholder
diff --git a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.android.kt b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.android.kt
index e16f99bf56..f0d0d711e7 100644
--- a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.android.kt
+++ b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.android.kt
@@ -13,6 +13,7 @@ import chat.simplex.common.model.ChatItem
 import chat.simplex.common.model.MsgContent
 import chat.simplex.common.platform.FileChooserLauncher
 import chat.simplex.common.platform.saveImage
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.res.*
 import com.google.accompanist.permissions.PermissionStatus
@@ -28,7 +29,7 @@ actual fun ReactionIcon(text: String, fontSize: TextUnit) {
 @Composable
 actual fun SaveContentItemAction(cItem: ChatItem, saveFileLauncher: FileChooserLauncher, showMenu: MutableState<Boolean>) {
   val writePermissionState = rememberPermissionState(permission = Manifest.permission.WRITE_EXTERNAL_STORAGE)
-  ItemAction(stringResource(MR.strings.save_verb), painterResource(MR.images.ic_download), onClick = {
+  ItemAction(stringResource(MR.strings.save_verb), painterResource(MR.images.ic_download), uiKey = Ui.Chat.ItemMenu(cItem.id, "save"), onClick = {
     when (cItem.content.msgContent) {
       is MsgContent.MCImage -> {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R || writePermissionState.status == PermissionStatus.Granted) {
diff --git a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.android.kt b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.android.kt
index a81d9cd1ee..0c5a8dceec 100644
--- a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.android.kt
+++ b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.android.kt
@@ -12,7 +12,9 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.theme.SimplexGreen
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.res.*
 import dev.icerock.moko.resources.compose.painterResource
@@ -26,6 +28,7 @@ actual fun SavePassphraseSetting(
   minHeight: Dp,
   enabled: Boolean,
   smallPadding: Boolean,
+  uiKey: UiKey?,
   onCheckedChange: (Boolean) -> Unit,
 ) {
   SectionItemView(minHeight = minHeight) {
@@ -48,6 +51,7 @@ actual fun SavePassphraseSetting(
       DefaultSwitch(
         checked = useKeychain,
         onCheckedChange = onCheckedChange,
+        modifier = Modifier.ui(uiKey),
         enabled = enabled
       )
     }
diff --git a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/helpers/ChooseAttachmentView.android.kt b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/helpers/ChooseAttachmentView.android.kt
index 4c980acf91..9a9b690bf9 100644
--- a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/helpers/ChooseAttachmentView.android.kt
+++ b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/helpers/ChooseAttachmentView.android.kt
@@ -4,6 +4,8 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.MutableState
 import androidx.compose.ui.Modifier
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.newchat.ActionButton
 import chat.simplex.res.*
 import dev.icerock.moko.resources.compose.painterResource
@@ -11,19 +13,19 @@ import dev.icerock.moko.resources.compose.stringResource
 
 @Composable
 actual fun ChooseAttachmentButtons(attachmentOption: MutableState<AttachmentOption?>, hide: () -> Unit) {
-  ActionButton(Modifier.fillMaxWidth(0.25f), null, stringResource(MR.strings.use_camera_button), icon = painterResource(MR.images.ic_camera_enhance)) {
+  ActionButton(Modifier.fillMaxWidth(0.25f).ui(Ui.Chat.Attach("camera")), null, stringResource(MR.strings.use_camera_button), icon = painterResource(MR.images.ic_camera_enhance)) {
     attachmentOption.value = AttachmentOption.CameraPhoto
     hide()
   }
-  ActionButton(Modifier.fillMaxWidth(0.33f), null, stringResource(MR.strings.gallery_image_button), icon = painterResource(MR.images.ic_add_photo)) {
+  ActionButton(Modifier.fillMaxWidth(0.33f).ui(Ui.Chat.Attach("image")), null, stringResource(MR.strings.gallery_image_button), icon = painterResource(MR.images.ic_add_photo)) {
     attachmentOption.value = AttachmentOption.GalleryImage
     hide()
   }
-  ActionButton(Modifier.fillMaxWidth(0.50f), null, stringResource(MR.strings.gallery_video_button), icon = painterResource(MR.images.ic_smart_display)) {
+  ActionButton(Modifier.fillMaxWidth(0.50f).ui(Ui.Chat.Attach("video")), null, stringResource(MR.strings.gallery_video_button), icon = painterResource(MR.images.ic_smart_display)) {
     attachmentOption.value = AttachmentOption.GalleryVideo
     hide()
   }
-  ActionButton(Modifier.fillMaxWidth(1f), null, stringResource(MR.strings.choose_file), icon = painterResource(MR.images.ic_note_add)) {
+  ActionButton(Modifier.fillMaxWidth(1f).ui(Ui.Chat.Attach("file")), null, stringResource(MR.strings.choose_file), icon = painterResource(MR.images.ic_note_add)) {
     attachmentOption.value = AttachmentOption.File
     hide()
   }
diff --git a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/usersettings/Appearance.android.kt b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/usersettings/Appearance.android.kt
index e5ae2b8a9b..b12c6d9c11 100644
--- a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/usersettings/Appearance.android.kt
+++ b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/usersettings/Appearance.android.kt
@@ -25,6 +25,7 @@ import androidx.compose.ui.platform.LocalContext
 import dev.icerock.moko.resources.compose.stringResource
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.model.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.model.ChatModel
@@ -105,11 +106,11 @@ fun AppearanceScope.AppearanceLayout(
       }
       //      }
 
-      SettingsPreferenceItem(icon = null, stringResource(MR.strings.one_hand_ui), ChatModel.controller.appPrefs.oneHandUI) { enabled ->
+      SettingsPreferenceItem(icon = null, stringResource(MR.strings.one_hand_ui), ChatModel.controller.appPrefs.oneHandUI, uiKey = Ui.Appearance.OneHandUI) { enabled ->
         if (enabled) appPrefs.chatBottomBar.set(true)
       }
       if (remember { appPrefs.oneHandUI.state }.value) {
-        SettingsPreferenceItem(icon = null, stringResource(MR.strings.chat_bottom_bar), ChatModel.controller.appPrefs.chatBottomBar)
+        SettingsPreferenceItem(icon = null, stringResource(MR.strings.chat_bottom_bar), ChatModel.controller.appPrefs.chatBottomBar, uiKey = Ui.Appearance.ChatBottomBar)
       }
     }
 
diff --git a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.android.kt b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.android.kt
index 4da9bf03b0..b77bc5bf52 100644
--- a/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.android.kt
+++ b/apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.android.kt
@@ -12,6 +12,7 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.style.TextAlign
 import chat.simplex.common.model.ChatModel
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.res.*
 import com.jakewharton.processphoenix.ProcessPhoenix
@@ -24,7 +25,7 @@ actual fun AdvancedSettingsAppSection(
   withAuth: (title: String, desc: String, block: () -> Unit) -> Unit,
 ) {
   SectionView {
-    SettingsActionItem(painterResource(MR.images.ic_code), stringResource(MR.strings.settings_developer_tools), showSettingsModal { DeveloperView(withAuth) })
+    SettingsActionItem(painterResource(MR.images.ic_code), stringResource(MR.strings.settings_developer_tools), showSettingsModal { DeveloperView(withAuth) }, uiKey = Ui.Settings.DeveloperTools)
   }
 }
 
@@ -50,7 +51,7 @@ private fun shutdownAppAlert() {
     text = generalGetString(MR.strings.shutdown_alert_desc),
     buttons = {
       Column {
-        SectionItemView({ AlertManager.shared.hideAlert() }) {
+        SectionItemView({ AlertManager.shared.hideAlert() }, uiKey = Ui.Alert.Dismiss(Ui.AlertSource.Shared)) {
           Text(stringResource(MR.strings.cancel_verb), Modifier.fillMaxWidth(), textAlign = TextAlign.Center)
         }
         SectionItemView({
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/App.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/App.kt
index ce1152de6a..e2a7eb7a24 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/App.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/App.kt
@@ -22,6 +22,7 @@ import chat.simplex.common.views.usersettings.SetDeliveryReceiptsView
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.CreateFirstProfile
 import chat.simplex.common.views.helpers.SimpleButton
@@ -125,6 +126,7 @@ fun MainScreen() {
         SimpleButton(
           stringResource(MR.strings.auth_unlock),
           icon = painterResource(MR.images.ic_lock),
+          uiKey = Ui.Lock.Unlock,
           click = {
             AppLock.laFailed.value = false
             AppLock.runAuthenticate()
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/platform/PlatformTextField.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/platform/PlatformTextField.kt
index 6b301b9df4..5c378c5e74 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/platform/PlatformTextField.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/platform/PlatformTextField.kt
@@ -4,6 +4,7 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.text.TextRange
 import androidx.compose.ui.text.TextStyle
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.views.chat.ComposeMessage
 import chat.simplex.common.views.chat.ComposeState
 import java.net.URI
@@ -22,5 +23,6 @@ expect fun PlatformTextField(
   onUpArrow: () -> Unit,
   onFilesPasted: (List<URI>) -> Unit,
   focusRequester: FocusRequester? = null,
+  uiKey: UiKey? = null,
   onDone: () -> Unit,
 )
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/ui/Ui.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/ui/Ui.kt
index 54209071e3..35864844ac 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/ui/Ui.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/ui/Ui.kt
@@ -3,6 +3,8 @@ package chat.simplex.common.ui
 import androidx.compose.runtime.Immutable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
+import chat.simplex.common.model.ChatFeature
+import chat.simplex.common.model.GroupFeature
 
 @Immutable
 data class UiKey(val id: String, val arg: Any? = null) {
@@ -53,25 +55,127 @@ object Ui {
   object NewChat {
     val CreateLink = UiKey("newChat.createLink")
     val CreateGroup = UiKey("newChat.createGroup")
+    val CreateChannel = UiKey("newChat.createChannel")
+    val PasteLink = UiKey("newChat.pasteLink")
+    val Search = UiKey("newChat.search")
+    fun Contact(chatId: String) = UiKey("newChat.contact", chatId)
+    fun ContactMenu(chatId: String, action: String) = UiKey("newChat.contact.menu.$action", chatId)
+    val Archived = UiKey("newChat.archived")
+    val Favorites = UiKey("newChat.favorites")
   }
   object UserPicker {
     fun User(userId: Long) = UiKey("userPicker.user", userId)
     val Address = UiKey("userPicker.address")
+    val ChatPreferences = UiKey("userPicker.chatPreferences")
+    val LinkMobile = UiKey("userPicker.linkMobile")
     val Settings = UiKey("userPicker.settings")
     val Profiles = UiKey("userPicker.profiles")
     val Sheet = UiKey("userPicker.sheet")
+    val ColorMode = UiKey("userPicker.colorMode")
+    val UseFromDesktop = UiKey("userPicker.useFromDesktop")
+    fun Device(remoteHostId: Long?) = UiKey("userPicker.device", remoteHostId ?: "local")
   }
   object Settings {
     val Appearance = UiKey("settings.appearance")
     val Help = UiKey("settings.help")
     val Privacy = UiKey("settings.privacy")
+    val Database = UiKey("settings.database")
+    val Network = UiKey("settings.network")
+    val Calls = UiKey("settings.calls")
+    val Version = UiKey("settings.version")
+    val DeveloperTools = UiKey("settings.developerTools")
+    val Migrate = UiKey("settings.migrate")
+  }
+  object Notifications {
+    val Mode = UiKey("notifications.mode")
+  }
+  object Network {
+    fun Operator(operatorId: Long) = UiKey("network.operator", operatorId)
+    val YourServers = UiKey("network.yourServers")
+    val UseSocks = UiKey("network.useSocks")
+    val SocksSettings = UiKey("network.socksSettings")
+    val Advanced = UiKey("network.advanced")
+    val SaveServers = UiKey("network.saveServers")
+  }
+  object Servers {
+    fun Server(server: String) = UiKey("servers.server", server)
+    val Add = UiKey("servers.add")
+    val TestAll = UiKey("servers.testAll")
+    val Address = UiKey("servers.address")
+    val Test = UiKey("servers.test")
+    val Use = UiKey("servers.use")
+    val Delete = UiKey("servers.delete")
+  }
+  object Operator {
+    val Info = UiKey("operator.info")
+    val Use = UiKey("operator.use")
+    val AcceptConditions = UiKey("operator.acceptConditions")
+  }
+  object AdvancedNetwork {
+    val ProxyMode = UiKey("advancedNetwork.proxyMode")
+    val ProxyFallback = UiKey("advancedNetwork.proxyFallback")
+    fun Setting(name: String) = UiKey("advancedNetwork.setting.$name")
+    val KeepAlive = UiKey("advancedNetwork.keepAlive")
+    val SessionMode = UiKey("advancedNetwork.sessionMode")
+    val Reset = UiKey("advancedNetwork.reset")
+    val Save = UiKey("advancedNetwork.save")
+  }
+  object Socks {
+    val Host = UiKey("socks.host")
+    val Port = UiKey("socks.port")
+    val OnionHosts = UiKey("socks.onionHosts")
+    val Save = UiKey("socks.save")
+    val Reset = UiKey("socks.reset")
   }
   object Privacy {
     val More = UiKey("privacy.more")
     val ShowLastMessages = UiKey("privacy.showLastMessages")
+    val Lock = UiKey("privacy.lock")
+    val LinkPreviews = UiKey("privacy.linkPreviews")
+    val AcceptImages = UiKey("privacy.acceptImages")
+    val BlurMedia = UiKey("privacy.blurMedia")
+    val ReceiptsContacts = UiKey("privacy.receiptsContacts")
+    val ReceiptsGroups = UiKey("privacy.receiptsGroups")
+    val SanitizeLinks = UiKey("privacy.sanitizeLinks")
+    val AutoAcceptMemberContacts = UiKey("privacy.autoAcceptMemberContacts")
+    val AutoAcceptGroupInvitations = UiKey("privacy.autoAcceptGroupInvitations")
+    val SaveDraft = UiKey("privacy.saveDraft")
+    val EncryptLocalFiles = UiKey("privacy.encryptLocalFiles")
+  }
+  object DeliveryReceipts {
+    val Enable = UiKey("deliveryReceipts.enable")
+    val Skip = UiKey("deliveryReceipts.skip")
+  }
+  object Lock {
+    val Enable = UiKey("lock.enable")
+    val Delay = UiKey("lock.delay")
+    val ChangePasscode = UiKey("lock.changePasscode")
+    val SelfDestruct = UiKey("lock.selfDestruct")
+    val SelfDestructName = UiKey("lock.selfDestructName")
+    val SelfDestructInfo = UiKey("lock.selfDestructInfo")
+    val ChangeSelfDestruct = UiKey("lock.changeSelfDestruct")
+    val Unlock = UiKey("lock.unlock")
+  }
+  object Passcode {
+    fun Digit(d: Int) = UiKey("passcode.digit", d)
+    val Backspace = UiKey("passcode.backspace")
+    val Clear = UiKey("passcode.clear")
+    val Submit = UiKey("passcode.submit")
+    val Cancel = UiKey("passcode.cancel")
+    val Entered = UiKey("passcode.entered")
   }
   object Help {
     val WhatsNew = UiKey("help.whatsNew")
+    val HowToUse = UiKey("help.howToUse")
+    val About = UiKey("help.about")
+    val Email = UiKey("help.email")
+    val Contribute = UiKey("help.contribute")
+    val Star = UiKey("help.star")
+  }
+  object DevTools {
+    val Console = UiKey("devTools.console")
+    val ResetHints = UiKey("devTools.resetHints")
+    val ShowOptions = UiKey("devTools.showOptions")
   }
   object WhatsNew {
     val Ok = UiKey("whatsNew.ok")
@@ -79,6 +183,11 @@ object Ui {
   }
   object ServersSummary {
     val ShowPercentage = UiKey("serversSummary.showPercentage")
+    val ResetStats = UiKey("serversSummary.resetStats")
+    val ReconnectAll = UiKey("serversSummary.reconnectAll")
+    val Details = UiKey("serversSummary.details")
+    fun SmpServer(host: String) = UiKey("serversSummary.smpServer", host)
+    val UserCategory = UiKey("serversSummary.userCategory")
   }
   object Onboarding {
     val GetStarted = UiKey("onboarding.getStarted")
@@ -106,22 +215,60 @@ object Ui {
   object Remote {
     val DeviceName = UiKey("remote.deviceName")
     val ShareLink = UiKey("remote.shareLink")
+    val AddMobile = UiKey("remote.addMobile")
+    val PasteAddress = UiKey("remote.pasteAddress")
+    val Connect = UiKey("remote.connect")
+    val Confirm = UiKey("remote.confirm")
+    val Disconnect = UiKey("remote.disconnect")
   }
   object Appearance {
     val ColorMode = UiKey("appearance.colorMode")
     val FontScale = UiKey("appearance.fontScale")
     val Zoom = UiKey("appearance.zoom")
+    val Language = UiKey("appearance.language")
+    val OneHandUI = UiKey("appearance.oneHandUI")
+    val DarkModeColors = UiKey("appearance.darkModeColors")
+    val ApplyTo = UiKey("appearance.applyTo")
+    fun Wallpaper(preset: String) = UiKey("appearance.wallpaper", preset)
+    val WallpaperImage = UiKey("appearance.wallpaperImage")
+    val RemoveImage = UiKey("appearance.removeImage")
+    val Customize = UiKey("appearance.customize")
+    val Accent = UiKey("appearance.accent")
+    val ColorHex = UiKey("appearance.colorHex")
+    val ResetColors = UiKey("appearance.resetColors")
+    val ExportTheme = UiKey("appearance.exportTheme")
+    val ImportTheme = UiKey("appearance.importTheme")
+    val ChatBottomBar = UiKey("appearance.chatBottomBar")
   }
   object Address {
     val Create = UiKey("address.create")
     val Share = UiKey("address.share")
+    val Delete = UiKey("address.delete")
+    val Business = UiKey("address.business")
+    val Settings = UiKey("address.settings")
+    val AutoAccept = UiKey("address.autoAccept")
+    val WelcomeMessage = UiKey("address.welcomeMessage")
+    val SaveSettings = UiKey("address.saveSettings")
+    val ShareWithContacts = UiKey("address.shareWithContacts")
+    val ShareViaChat = UiKey("address.shareViaChat")
+    val CreateLink = UiKey("address.createLink")
+    val LearnMore = UiKey("address.learnMore")
   }
   object NewGroup {
     val Name = UiKey("newGroup.name")
     val Create = UiKey("newGroup.create")
+    val Incognito = UiKey("newGroup.incognito")
+  }
+  object NewChannel {
+    val Name = UiKey("newChannel.name")
+    val Create = UiKey("newChannel.create")
   }
   object Profile {
     val Name = UiKey("profile.name")
+    val FullName = UiKey("profile.fullName")
+    val Bio = UiKey("profile.bio")
+    val Description = UiKey("profile.description")
+    val DescriptionText = UiKey("profile.descriptionText")
     val Save = UiKey("profile.save")
   }
   object Profiles {
@@ -135,6 +282,10 @@ object Ui {
     val Confirm = UiKey("hideProfile.confirm")
     val Save = UiKey("hideProfile.save")
   }
+  object ProfileAction {
+    val Password = UiKey("profileAction.password")
+    val Submit = UiKey("profileAction.submit")
+  }
   object NewProfile {
     val Name = UiKey("newProfile.name")
     val Create = UiKey("newProfile.create")
@@ -143,27 +294,66 @@ object Ui {
     val Text = UiKey("link.text")
     val ShareProfile = UiKey("link.shareProfile")
     val ProfileIncognito = UiKey("link.profile.incognito")
+    fun Profile(userId: Long) = UiKey("link.profile", userId)
+    val ProfileBar = UiKey("link.profileBar")
+    val Paste = UiKey("link.paste")
+    val ShortLinkToggle = UiKey("link.shortLinkToggle")
   }
   object Chat {
     val Bar = UiKey("chat.bar")
     val Message = UiKey("chat.compose")
-    val Send = UiKey("chat.send")
+    val Send = Message.part("send")
+    val SendLive = Message.part("sendLive")
+    val Live = Message.part("live")
+    val ClearText = Message.part("clearText")
+    val SendTimed = Message.part("timed")
+    val ScopeMessage = UiKey("chat.compose", "scope")
+    val ScopeSend = ScopeMessage.part("send")
     val Connect = UiKey("chat.connect")
     val BarMenu = UiKey("chat.bar.menu")
     fun BarMenuItem(action: String) = UiKey("chat.bar.menu.$action")
     val Selection = UiKey("chat.selection")
+    val TextSelectionCopy = UiKey("chat.textSelection.copy")
     val RequestAccept = UiKey("chat.request.accept")
     val RequestReject = UiKey("chat.request.reject")
+    val PendingAccept = UiKey("chat.pending.accept")
+    val PendingReject = UiKey("chat.pending.reject")
     fun Item(itemId: Long) = UiKey("chat.item", itemId)
     fun ItemMenu(itemId: Long, action: String) = UiKey("chat.item.menu.$action", itemId)
     fun ItemFile(itemId: Long) = UiKey("chat.item.file", itemId)
     val ScrollToBottom = UiKey("chat.scrollToBottom")
+    val UnreadAbove = UiKey("chat.unreadAbove")
+    val SearchButton = UiKey("chat.searchButton")
+    val ContentFilter = UiKey("chat.contentFilter")
     fun ItemReaction(itemId: Long, emoji: String) = UiKey("chat.item.menu.react", "$itemId:$emoji")
     fun ReactionChip(itemId: Long, emoji: String) = UiKey("chat.item.reaction", "$itemId:$emoji")
+    fun ReactionMember(itemId: Long, name: String) = UiKey("chat.item.reaction.member", "$itemId:$name")
+    val FullScreenMedia = UiKey("chat.fullScreenMedia")
     fun MentionMember(groupMemberId: Long) = UiKey("chat.mentionMember", groupMemberId)
+    fun PickerUser(userId: Long) = UiKey("chat.picker.user", userId)
+    val PickerIncognito = UiKey("chat.picker.incognito")
+    val Reports = UiKey("chat.reports")
+    val SupportChats = UiKey("chat.supportChats")
+    fun ReportReason(label: String) = UiKey("chat.reportReason", label)
+    fun Attach(option: String) = UiKey("chat.attach", option)
+    val CommandsButton = UiKey("chat.commands")
+    fun Command(keyword: String) = UiKey("chat.commands.command", keyword)
+    fun CommandMenu(label: String) = UiKey("chat.commands.menu", label)
+    val CommandsBack = UiKey("chat.commands.back")
+  }
+  object TimePicker {
+    val Value = UiKey("timePicker.value")
+    val Confirm = UiKey("timePicker.confirm")
+  }
+  object ItemInfo {
+    fun Member(groupMemberId: Long) = UiKey("itemInfo.member", groupMemberId)
+    val Quote = UiKey("itemInfo.quote")
+    val ForwardedFrom = UiKey("itemInfo.forwardedFrom")
+    val Share = UiKey("itemInfo.share")
   }
   object Share {
     fun Row(chatId: String) = UiKey("share.row", chatId)
+    val Bar = UiKey("share.bar")
   }
   object DbError {
     val Passphrase = UiKey("dbError.passphrase")
@@ -173,7 +363,32 @@ object Ui {
   object Info {
     val Alias = UiKey("info.alias")
     val DeleteContact = UiKey("info.deleteContact")
+    val ClearChat = UiKey("info.clearChat")
     val VerifyCode = UiKey("info.verifyCode")
+    val Preferences = UiKey("info.preferences")
+    val Name = UiKey("info.name")
+    val Header = UiKey("info.header")
+    val Mute = UiKey("info.mute")
+    val SwitchAddress = UiKey("info.switchAddress")
+    val AbortSwitchAddress = UiKey("info.abortSwitchAddress")
+    val ReceivingVia = UiKey("info.receivingVia")
+    val SendingVia = UiKey("info.sendingVia")
+    val Call = UiKey("info.call")
+    val SendReceipts = UiKey("info.sendReceipts")
+    val Ttl = UiKey("info.ttl")
+  }
+  object ContactPrefs {
+    fun Allow(feature: ChatFeature) = UiKey("contactPrefs.allow", feature.name)
+    val Timed = UiKey("contactPrefs.timed")
+    val Ttl = UiKey("contactPrefs.ttl")
+    val Reset = UiKey("contactPrefs.reset")
+    val Save = UiKey("contactPrefs.save")
+  }
+  object UserPrefs {
+    fun Allow(feature: ChatFeature) = UiKey("userPrefs.allow", feature.name)
+    val Timed = UiKey("userPrefs.timed")
+    val Reset = UiKey("userPrefs.reset")
+    val Save = UiKey("userPrefs.save")
   }
   object VerifyCode {
     val Code = UiKey("verifyCode.code")
@@ -182,18 +397,57 @@ object Ui {
   object InviteMembers {
     fun Contact(contactId: Long) = UiKey("inviteMembers.contact", contactId)
     val Invite = UiKey("inviteMembers.invite")
+    val Role = UiKey("inviteMembers.role")
+    val Skip = UiKey("inviteMembers.skip")
+    val Search = UiKey("inviteMembers.search")
+    val Clear = UiKey("inviteMembers.clear")
   }
   object GroupInfo {
     fun Member(groupMemberId: Long) = UiKey("groupInfo.member", groupMemberId)
     val CreateLink = UiKey("groupInfo.createLink")
+    val Preferences = UiKey("groupInfo.preferences")
+    val MemberSupport = UiKey("groupInfo.memberSupport")
+    val UserSupport = UiKey("groupInfo.userSupport")
+    val AddMembers = UiKey("groupInfo.addMembers")
+    val EditProfile = UiKey("groupInfo.editProfile")
+    val WelcomeMessage = UiKey("groupInfo.welcomeMessage")
+    val Leave = UiKey("groupInfo.leave")
+    val Delete = UiKey("groupInfo.delete")
+    val Reports = UiKey("groupInfo.reports")
+    val Content = UiKey("groupInfo.content")
+    val Mute = UiKey("groupInfo.mute")
+    val SendReceipts = UiKey("groupInfo.sendReceipts")
+    val GroupLink = UiKey("groupInfo.groupLink")
+    val MembersToolbar = UiKey("groupInfo.membersToolbar")
+    fun MemberMenu(groupMemberId: Long, action: String) = UiKey("groupInfo.member.menu.$action", groupMemberId)
+  }
+  object GroupProfile {
+    val Name = UiKey("groupProfile.name")
+    val ShortDescr = UiKey("groupProfile.shortDescr")
+    val Save = UiKey("groupProfile.save")
+  }
+  object Welcome {
+    val Text = UiKey("welcome.text")
+    val Preview = UiKey("welcome.preview")
+    val Save = UiKey("welcome.save")
   }
   object GroupLink {
     val Share = UiKey("groupLink.share")
+    val Continue = UiKey("groupLink.continue")
+    val Role = UiKey("groupLink.role")
   }
   object MemberInfo {
     val Role = UiKey("memberInfo.role")
     val Remove = UiKey("memberInfo.remove")
     val BlockForAll = UiKey("memberInfo.blockForAll")
+    val UnblockForAll = UiKey("memberInfo.unblockForAll")
+    val Block = UiKey("memberInfo.block")
+    val Unblock = UiKey("memberInfo.unblock")
+    val Message = UiKey("memberInfo.message")
+    val Call = UiKey("memberInfo.call")
+    val Video = UiKey("memberInfo.video")
+    val DeleteMessages = UiKey("memberInfo.deleteMessages")
+    val SupportChat = UiKey("memberInfo.supportChat")
   }
   enum class AlertSource { Shared, PrivacySensitive }
   object Alert {
@@ -201,4 +455,38 @@ object Ui {
     fun Dismiss(src: AlertSource) = UiKey("alert.dismiss", src)
     fun Option(src: AlertSource, name: String) = UiKey("alert.option.$name", src)
   }
+  object GroupPrefs {
+    val MemberAdmission = UiKey("groupPrefs.memberAdmission")
+    fun Toggle(feature: GroupFeature) = UiKey("groupPrefs.toggle", feature.name)
+    fun Role(feature: GroupFeature) = UiKey("groupPrefs.role", feature.name)
+    val Ttl = UiKey("groupPrefs.ttl")
+    val Reset = UiKey("groupPrefs.reset")
+    val Save = UiKey("groupPrefs.save")
+  }
+  object MemberAdmission {
+    val Review = UiKey("memberAdmission.review")
+    val Save = UiKey("memberAdmission.save")
+  }
+  object MemberSupport {
+    val Search = UiKey("memberSupport.search")
+    fun Row(groupMemberId: Long) = UiKey("memberSupport.row", groupMemberId)
+    fun RowMenu(groupMemberId: Long, action: String) = UiKey("memberSupport.row.menu.$action", groupMemberId)
+  }
+  object Database {
+    val Ttl = UiKey("database.ttl")
+    val Management = UiKey("database.management")
+    val DeleteFiles = UiKey("database.deleteFiles")
+    val Passphrase = UiKey("database.passphrase")
+    val Export = UiKey("database.export")
+    val Import = UiKey("database.import")
+    val Delete = UiKey("database.delete")
+    val RunChat = UiKey("database.runChat")
+  }
+  object DbPassphrase {
+    val Save = UiKey("dbPassphrase.save")
+    val Current = UiKey("dbPassphrase.current")
+    val New = UiKey("dbPassphrase.new")
+    val Confirm = UiKey("dbPassphrase.confirm")
+    val Update = UiKey("dbPassphrase.update")
+  }
 }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/TerminalView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/TerminalView.kt
index 1bfe88ecf7..5245dcbd77 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/TerminalView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/TerminalView.kt
@@ -20,6 +20,7 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.*
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.chat.*
 import chat.simplex.common.views.helpers.*
@@ -110,6 +111,7 @@ fun TerminalLayout(
             sendLiveMessage = null,
             updateLiveMessage = null,
             editPrevMessage = {},
+            uiKey = Ui.Chat.Message,
             onMessageChange = ::onMessageChange,
             onFilesPasted = {},
             textStyle = textStyle,
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/WelcomeView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/WelcomeView.kt
index b9cf956091..a8cf7e62ed 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/WelcomeView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/WelcomeView.kt
@@ -132,7 +132,7 @@ fun CreateProfile(chatModel: ChatModel, close: () -> Unit) {
             val validName = mkValidName(name)
             Spacer(Modifier.height(20.dp))
             if (name != validName) {
-              IconButton({ showInvalidNameAlert(mkValidName(displayName.value), displayName) }, Modifier.size(20.dp)) {
+              IconButton({ showInvalidNameAlert(mkValidName(displayName.value), displayName) }, Modifier.size(20.dp).ui(Ui.NewProfile.Name.part("invalid"))) {
                 Icon(painterResource(MR.images.ic_info), null, tint = MaterialTheme.colors.error)
               }
             }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatInfoView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatInfoView.kt
index cb7e1d63c1..cd52e49bd9 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatInfoView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatInfoView.kt
@@ -23,6 +23,7 @@ import androidx.compose.ui.graphics.painter.Painter
 import androidx.compose.ui.platform.*
 import chat.simplex.common.ui.ui
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.views.call.CallMediaType
 import chat.simplex.common.views.chatlist.*
 import androidx.compose.ui.text.*
@@ -261,7 +262,7 @@ private fun deleteContactOrConversationDialog(chat: Chat, contact: Contact, chat
           if (chatModel.controller.appPrefs.showDeleteConversationNotice.get()) {
             showDeleteConversationNotice(contact)
           }
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "onlyConversation")) {
           Text(generalGetString(MR.strings.only_delete_conversation), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.error)
         }
         // Delete contact
@@ -274,7 +275,7 @@ private fun deleteContactOrConversationDialog(chat: Chat, contact: Contact, chat
         // Cancel
         SectionItemView({
           AlertManager.shared.hideAlert()
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "cancel")) {
           Text(stringResource(MR.strings.cancel_verb), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
         }
       }
@@ -329,6 +330,7 @@ private fun deleteActiveContactDialog(chat: Chat, contact: Contact, chatModel: C
                 contactDeleteMode.value =
                   if (it) ContactDeleteMode.Entity() else ContactDeleteMode.Full()
               },
+              modifier = Modifier.ui(Ui.Alert.Option(Ui.AlertSource.Shared, "keepConversation")),
             )
           }
         }
@@ -339,7 +341,7 @@ private fun deleteActiveContactDialog(chat: Chat, contact: Contact, chatModel: C
           if (contactDeleteMode.value is ContactDeleteMode.Entity && chatModel.controller.appPrefs.showDeleteContactNotice.get()) {
             showDeleteContactNotice(contact)
           }
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "deleteWithoutNotification")) {
           Text(generalGetString(MR.strings.delete_without_notification), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.error)
         }
         // Delete contact and notify
@@ -379,7 +381,7 @@ private fun deleteContactWithoutConversation(chat: Chat, chatModel: ChatModel, c
             close,
             chatDeleteMode = ContactDeleteMode.Full().toChatDeleteMode(notify = true)
           )
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "deleteAndNotify")) {
           Text(
             generalGetString(MR.strings.delete_and_notify_contact),
             Modifier.fillMaxWidth(),
@@ -396,7 +398,7 @@ private fun deleteContactWithoutConversation(chat: Chat, chatModel: ChatModel, c
             close,
             chatDeleteMode = ContactDeleteMode.Full().toChatDeleteMode(notify = false)
           )
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "deleteWithoutNotification")) {
           Text(
             generalGetString(MR.strings.delete_without_notification),
             Modifier.fillMaxWidth(),
@@ -408,7 +410,7 @@ private fun deleteContactWithoutConversation(chat: Chat, chatModel: ChatModel, c
       // Cancel
       SectionItemView({
         AlertManager.shared.hideAlert()
-      }) {
+      }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "cancel")) {
         Text(
           stringResource(MR.strings.cancel_verb),
           Modifier.fillMaxWidth(),
@@ -435,7 +437,7 @@ private fun deleteNotReadyContact(chat: Chat, chatModel: ChatModel, close: (() -
           close,
           chatDeleteMode = ContactDeleteMode.Full().toChatDeleteMode(notify = false)
         )
-      }) {
+      }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "confirm")) {
         Text(
           generalGetString(MR.strings.confirm_verb),
           Modifier.fillMaxWidth(),
@@ -446,7 +448,7 @@ private fun deleteNotReadyContact(chat: Chat, chatModel: ChatModel, close: (() -
       // Cancel
       SectionItemView({
         AlertManager.shared.hideAlert()
-      }) {
+      }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "cancel")) {
         Text(
           stringResource(MR.strings.cancel_verb),
           Modifier.fillMaxWidth(),
@@ -574,7 +576,7 @@ fun ChatInfoLayout(
         verticalAlignment = Alignment.CenterVertically
       ) {
         SearchButton(modifier = Modifier.fillMaxWidth(0.25f), chat, contact, close, onSearchClicked)
-        AudioCallButton(modifier = Modifier.fillMaxWidth(0.33f), chat, contact, connStats)
+        AudioCallButton(modifier = Modifier.fillMaxWidth(0.33f), chat, contact, connStats, uiKey = Ui.Info.Call)
         VideoButton(modifier = Modifier.fillMaxWidth(0.5f), chat, contact, connStats)
         MuteButton(modifier = Modifier.fillMaxWidth(1f), chat, contact)
       }
@@ -620,7 +622,7 @@ fun ChatInfoLayout(
     SectionDividerSpaced()
 
     SectionView {
-      ChatTTLOption(chatItemTTL, setChatItemTTL, deletingItems)
+      ChatTTLOption(chatItemTTL, setChatItemTTL, deletingItems, uiKey = Ui.Info.Ttl)
     }
     SectionTextFooter(stringResource(MR.strings.chat_ttl_options_footer))
     SectionDividerSpaced()
@@ -659,21 +661,23 @@ fun ChatInfoLayout(
         if (cStats != null) {
           SwitchAddressButton(
             disabled = cStats.rcvQueuesInfo.any { it.rcvSwitchStatus != null } || cStats.ratchetSyncSendProhibited,
+            uiKey = Ui.Info.SwitchAddress,
             switchAddress = switchContactAddress
           )
           if (cStats.rcvQueuesInfo.any { it.rcvSwitchStatus != null }) {
             AbortSwitchAddressButton(
               disabled = cStats.rcvQueuesInfo.any { it.rcvSwitchStatus != null && !it.canAbortSwitch } || cStats.ratchetSyncSendProhibited,
+              uiKey = Ui.Info.AbortSwitchAddress,
               abortSwitchAddress = abortSwitchContactAddress
             )
           }
           val rcvServers = cStats.rcvQueuesInfo.map { it.rcvServer }
           if (rcvServers.isNotEmpty()) {
-            SimplexServers(stringResource(MR.strings.receiving_via), rcvServers)
+            SimplexServers(stringResource(MR.strings.receiving_via), rcvServers, Ui.Info.ReceivingVia)
           }
           val sndServers = cStats.sndQueuesInfo.map { it.sndServer }
           if (sndServers.isNotEmpty()) {
-            SimplexServers(stringResource(MR.strings.sending_via), sndServers)
+            SimplexServers(stringResource(MR.strings.sending_via), sndServers, Ui.Info.SendingVia)
           }
         }
       }
@@ -712,7 +716,7 @@ fun ChatInfoLayout(
 @Composable
 fun ChatInfoHeader(cInfo: ChatInfo, contact: Contact) {
   Column(
-    Modifier.padding(horizontal = DEFAULT_PADDING),
+    Modifier.ui(Ui.Info.Header).padding(horizontal = DEFAULT_PADDING),
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
     ChatInfoImage(cInfo, size = 192.dp, iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
@@ -756,7 +760,7 @@ fun ChatInfoHeader(cInfo: ChatInfo, contact: Contact) {
       textAlign = TextAlign.Center,
       maxLines = 3,
       overflow = TextOverflow.Ellipsis,
-      modifier = Modifier.combinedClickable(onClick = copyDisplayName, onLongClick = copyDisplayName).onRightClick(copyDisplayName)
+      modifier = Modifier.ui(Ui.Info.Name).combinedClickable(onClick = copyDisplayName, onLongClick = copyDisplayName).onRightClick(copyDisplayName)
     )
     ChatInfoDescription(cInfo, displayName, copyNameToClipboard)
     ContactSimplexNameView(contact)
@@ -920,6 +924,7 @@ fun MuteButton(
     title = stringResource(nextNtfMode.text(false)),
     disabled = disabled,
     disabledLook = disabled,
+    uiKey = Ui.Info.Mute,
     onClick = {
       toggleNotifications(chat.remoteHostId, chat.chatInfo, nextNtfMode, chatModel, enableNtfs)
     }
@@ -931,7 +936,8 @@ fun AudioCallButton(
   modifier: Modifier,
   chat: Chat,
   contact: Contact,
-  connectionStats: MutableState<ConnectionStats?>
+  connectionStats: MutableState<ConnectionStats?>,
+  uiKey: UiKey? = null
 ) {
   CallButton(
     modifier = modifier,
@@ -940,7 +946,8 @@ fun AudioCallButton(
     connectionStats,
     icon = painterResource(MR.images.ic_call),
     title = generalGetString(MR.strings.info_view_call_button),
-    mediaType = CallMediaType.Audio
+    mediaType = CallMediaType.Audio,
+    uiKey = uiKey
   )
 }
 
@@ -970,7 +977,8 @@ fun CallButton(
   connectionStats: MutableState<ConnectionStats?>,
   icon: Painter,
   title: String,
-  mediaType: CallMediaType
+  mediaType: CallMediaType,
+  uiKey: UiKey? = null
 ) {
   val canCall = contact.ready && contact.active && contact.mergedPreferences.calls.enabled.forUser && chatModel.activeCall.value == null
   val needToAllowCallsToContact = remember(chat.chatInfo) {
@@ -987,6 +995,7 @@ fun CallButton(
     title = title,
     disabled = chatModel.activeCall.value != null,
     disabledLook = !canCall,
+    uiKey = uiKey,
     onClick =
       when {
         canCall -> { {
@@ -1068,6 +1077,7 @@ fun InfoViewActionButton(
   title: String,
   disabled: Boolean,
   disabledLook: Boolean,
+  uiKey: UiKey? = null,
   onClick: () -> Unit
 ) {
   Box(modifier) {
@@ -1079,6 +1089,7 @@ fun InfoViewActionButton(
     ) {
       IconButton(
         onClick = onClick,
+        modifier = Modifier.ui(uiKey),
         enabled = !disabled
       ) {
         Box(
@@ -1157,18 +1168,18 @@ private fun ServerImage(subStatus: SubscriptionStatus) {
 }
 
 @Composable
-fun SimplexServers(text: String, servers: List<String>) {
+fun SimplexServers(text: String, servers: List<String>, uiKey: UiKey? = null) {
   val info = servers.joinToString(separator = ", ") { it.substringAfter("@") }
   val clipboardManager: ClipboardManager = LocalClipboardManager.current
-  InfoRowEllipsis(text, info) {
+  InfoRowEllipsis(text, info, uiKey) {
     clipboardManager.setText(AnnotatedString(servers.joinToString(separator = ",")))
     showToast(generalGetString(MR.strings.copied))
   }
 }
 
 @Composable
-fun SwitchAddressButton(disabled: Boolean, switchAddress: () -> Unit) {
-  SectionItemView(switchAddress, disabled = disabled) {
+fun SwitchAddressButton(disabled: Boolean, uiKey: UiKey? = null, switchAddress: () -> Unit) {
+  SectionItemView(switchAddress, disabled = disabled, uiKey = uiKey) {
     Text(
       stringResource(MR.strings.switch_receiving_address),
       color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary
@@ -1177,8 +1188,8 @@ fun SwitchAddressButton(disabled: Boolean, switchAddress: () -> Unit) {
 }
 
 @Composable
-fun AbortSwitchAddressButton(disabled: Boolean, abortSwitchAddress: () -> Unit) {
-  SectionItemView(abortSwitchAddress, disabled = disabled) {
+fun AbortSwitchAddressButton(disabled: Boolean, uiKey: UiKey? = null, abortSwitchAddress: () -> Unit) {
+  SectionItemView(abortSwitchAddress, disabled = disabled, uiKey = uiKey) {
     Text(
       stringResource(MR.strings.abort_switch_receiving_address),
       color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary
@@ -1225,7 +1236,8 @@ private fun ContactPreferencesButton(onClick: () -> Unit) {
   SettingsActionItem(
     painterResource(MR.images.ic_toggle_on),
     stringResource(MR.strings.contact_preferences),
-    click = onClick
+    click = onClick,
+    uiKey = Ui.Info.Preferences,
   )
 }
 
@@ -1240,6 +1252,8 @@ private fun SendReceiptsOption(currentUser: User, state: State<SendReceipts>, on
     state,
     icon = painterResource(MR.images.ic_double_check),
     enabled = remember { mutableStateOf(true) },
+    uiKey = Ui.Info.SendReceipts,
+    optionKey = { it.bool ?: "default" },
     onSelected = onSelected
   )
 }
@@ -1261,6 +1275,7 @@ fun ClearChatButton(onClick: () -> Unit) {
     click = onClick,
     textColor = WarningOrange,
     iconColor = WarningOrange,
+    uiKey = Ui.Info.ClearChat,
   )
 }
 
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatItemInfoView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatItemInfoView.kt
index 0c7f1937f7..11b4412a3f 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatItemInfoView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatItemInfoView.kt
@@ -26,6 +26,8 @@ import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.platform.*
 import chat.simplex.common.views.helpers.*
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.chat.group.MemberProfileImage
 import chat.simplex.common.views.chat.item.*
@@ -134,7 +136,7 @@ fun ChatItemInfoView(chatRh: Long?, ci: ChatItem, ciInfo: ChatItemInfo, devTools
 
     Column {
       Box(
-        Modifier.clipChatItem().background(quoteColor).padding(bottom = 3.dp)
+        Modifier.ui(Ui.ItemInfo.Quote).clipChatItem().background(quoteColor).padding(bottom = 3.dp)
           .combinedClickable(onLongClick = { showMenu.value = true }, onClick = {})
           .onRightClick { showMenu.value = true }
       ) {
@@ -219,7 +221,8 @@ fun ChatItemInfoView(chatRh: Long?, ci: ChatItem, ciInfo: ChatItemInfo, devTools
             ModalManager.end.closeModals()
           }
         },
-        padding = PaddingValues(start = 17.dp, end = DEFAULT_PADDING)
+        padding = PaddingValues(start = 17.dp, end = DEFAULT_PADDING),
+        uiKey = Ui.ItemInfo.ForwardedFrom
       ) {
         ForwardedFromSender(forwardedFromItem)
       }
@@ -375,7 +378,8 @@ fun ChatItemInfoView(chatRh: Long?, ci: ChatItem, ciInfo: ChatItemInfo, devTools
   @Composable
   fun MemberDeliveryStatusView(member: GroupMember, status: GroupSndStatus, sentViaProxy: Boolean?) {
     SectionItemView(
-      padding = PaddingValues(horizontal = 0.dp)
+      padding = PaddingValues(horizontal = 0.dp),
+      uiKey = Ui.ItemInfo.Member(member.groupMemberId)
     ) {
       MemberProfileImage(size = 36.dp, member)
       Spacer(Modifier.width(DEFAULT_SPACE_AFTER_ICON))
@@ -413,7 +417,7 @@ fun ChatItemInfoView(chatRh: Long?, ci: ChatItem, ciInfo: ChatItemInfo, devTools
       Box(modifier, contentAlignment = Alignment.Center) {
         Icon(
           painterResource(icon),
-          contentDescription = null,
+          contentDescription = status.statusDescription,
           tint = statusColor
         )
       }
@@ -559,6 +563,12 @@ fun ChatItemInfoView(chatRh: Long?, ci: ChatItem, ciInfo: ChatItemInfo, devTools
   }
 }
 
+private val GroupSndStatus.statusDescription: String? get() = when (this) {
+  is GroupSndStatus.Sent -> generalGetString(MR.strings.icon_descr_sent_msg_status_sent)
+  is GroupSndStatus.Rcvd -> generalGetString(MR.strings.icon_descr_sent_msg_status_rcvd)
+  else -> statusInto?.first
+}
+
 private fun membersStatuses(chatModel: ChatModel, memberDeliveryStatuses: List<MemberDeliveryStatus>): List<Triple<GroupMember, GroupSndStatus, Boolean?>> {
   return memberDeliveryStatuses.mapNotNull { mds ->
     chatModel.getGroupMember(mds.groupMemberId)?.let { mem ->
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatView.kt
index 7bcb80babe..9505bebd36 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatView.kt
@@ -731,7 +731,7 @@ fun ChatView(
                   ModalManager.end.closeModals()
                 }
                 ModalManager.end.showModalCloseable(endButtons = {
-                  ShareButton {
+                  ShareButton(uiKey = Ui.ItemInfo.Share) {
                     clipboard.shareText(itemInfoShareText(chatModel, initialCiInfo.first, initialCiInfo.second, chatModel.controller.appPrefs.developerTools.get()))
                   }
                 }) { close ->
@@ -1245,7 +1245,7 @@ fun BoxScope.ChatInfoToolbar(
           {
             showMenu.value = false
             showSearch.value = true
-          }, enabled = chatInfo.noteFolder.ready
+          }, Modifier.ui(Ui.Chat.SearchButton), enabled = chatInfo.noteFolder.ready
         ) {
           Icon(
             painterResource(MR.images.ic_search),
@@ -1307,7 +1307,7 @@ fun BoxScope.ChatInfoToolbar(
       if (chatInfo.groupInfo.canAddMembers) {
         if (!chatInfo.incognito && !chatInfo.groupInfo.useRelays) {
           menuItems.add {
-            ItemAction(stringResource(MR.strings.icon_descr_add_members), painterResource(MR.images.ic_person_add_500), onClick = {
+            ItemAction(stringResource(MR.strings.icon_descr_add_members), painterResource(MR.images.ic_person_add_500), uiKey = Ui.Chat.BarMenuItem("addMembers"), onClick = {
               showMenu.value = false
               addMembers(chatInfo.groupInfo)
             })
@@ -1344,6 +1344,7 @@ fun BoxScope.ChatInfoToolbar(
     barButtons.add {
       IconButton(
         { showContentFilterMenu.value = true },
+        Modifier.ui(Ui.Chat.ContentFilter),
         enabled = enabled
       ) {
         Icon(
@@ -1363,6 +1364,7 @@ fun BoxScope.ChatInfoToolbar(
       ItemAction(
         stringResource(nextNtfMode.text(chatInfo.hasMentions)),
         painterResource(nextNtfMode.icon),
+        uiKey = Ui.Chat.BarMenuItem("ntf"),
         onClick = {
           showMenu.value = false
           // Just to make a delay before changing state of ntfsEnabled, otherwise it will redraw menu item with new value before closing the menu
@@ -1432,7 +1434,7 @@ fun BoxScope.ChatInfoToolbar(
   val oneHandUI = remember { appPrefs.oneHandUI.state }
   val chatBottomBar = remember { appPrefs.chatBottomBar.state }
   val searchTrailingContent: @Composable (() -> Unit)? = if (showContentFilterButton) {{
-    IconButton({ showContentFilterMenu.value = true }) {
+    IconButton({ showContentFilterMenu.value = true }, Modifier.ui(Ui.Chat.ContentFilter)) {
       Icon(
         painterResource(if (contentFilter.value == null) MR.images.ic_photo_library else MR.images.ic_photo_library_filled),
         null,
@@ -1491,6 +1493,7 @@ fun BoxScope.ChatInfoToolbar(
               stringResource(filter.label),
               painterResource(if (isSelected) filter.iconFilled else filter.icon),
               color = if (isSelected) MaterialTheme.colors.primary else Color.Unspecified,
+              uiKey = Ui.Chat.ContentFilter.option(filter.name),
               onClick = {
                 showContentFilterMenu.value = false
                 if (contentFilter.value == filter) return@ItemAction
@@ -1511,6 +1514,7 @@ fun BoxScope.ChatInfoToolbar(
             ItemAction(
               stringResource(MR.strings.content_filter_all_messages),
               painterResource(MR.images.ic_forum),
+              uiKey = Ui.Chat.ContentFilter.option("all"),
               onClick = {
                 showContentFilterMenu.value = false
                 contentFilter.value = null
@@ -1685,6 +1689,7 @@ private fun SupportChatsCountToolbar(
       ) {
         Row(
           Modifier
+            .ui(Ui.Chat.Reports)
             .fillMaxWidth()
             .weight(1F)
             .height(AppBarHeight * fontSizeSqrtMultiplier + statusBarPadding)
@@ -1710,6 +1715,7 @@ private fun SupportChatsCountToolbar(
       if (supportUnreadCount > 0) {
         Row(
           Modifier
+            .ui(Ui.Chat.SupportChats)
             .fillMaxWidth()
             .weight(1F)
             .height(AppBarHeight * fontSizeSqrtMultiplier + statusBarPadding)
@@ -2704,7 +2710,7 @@ fun BoxScope.FloatingButtons(
   val showDropDown = remember { mutableStateOf(false) }
 
   TopEndFloatingButton(
-    Modifier.padding(end = DEFAULT_PADDING, top = 24.dp + topPaddingToContent).align(Alignment.TopEnd),
+    Modifier.ui(Ui.Chat.UnreadAbove).padding(end = DEFAULT_PADDING, top = 24.dp + topPaddingToContent).align(Alignment.TopEnd),
     topUnreadCount,
     requestedTopScroll,
     animatedScrollingInProgress,
@@ -2730,6 +2736,7 @@ fun BoxScope.FloatingButtons(
       ItemAction(
         generalGetString(MR.strings.mark_read),
         painterResource(MR.images.ic_check),
+        uiKey = Ui.Chat.UnreadAbove.part("markRead"),
         onClick = {
           markChatRead()
           showDropDown.value = false
@@ -3013,7 +3020,7 @@ private fun DownloadFilesButton(
   if (user != null) {
     TextButton(
       contentPadding = contentPadding,
-      modifier = modifier,
+      modifier = modifier.ui(Ui.Alert.Option(Ui.AlertSource.Shared, "download")),
       onClick = {
         AlertManager.shared.hideAlert()
 
@@ -3043,7 +3050,7 @@ private fun ForwardButton(
       forwardContent(forwardPlan.chatItemIds, chatInfo)
       AlertManager.shared.hideAlert()
     },
-    modifier = modifier,
+    modifier = modifier.ui(Ui.Alert.Option(Ui.AlertSource.Shared, "forward")),
     contentPadding = contentPadding
   ) {
     Text(stringResource(MR.strings.forward_chat_item), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/CommandsMenuView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/CommandsMenuView.kt
index 5f7aec3dd6..196adeb0fe 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/CommandsMenuView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/CommandsMenuView.kt
@@ -20,8 +20,10 @@ import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.DEFAULT_PADDING
 import chat.simplex.common.ui.theme.DEFAULT_PADDING_HALF
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.chat.group.*
 import chat.simplex.common.views.chat.item.sendCommandMsg
 import chat.simplex.common.views.helpers.commandMenuAnimSpec
@@ -112,6 +114,7 @@ fun CommandsMenuView(
   fun MenuLabelRow(prev: Pair<String, List<ChatBotCommand>>) {
     Box(
       modifier = Modifier
+        .ui(Ui.Chat.CommandsBack)
         .fillMaxWidth()
         .height(COMMAND_MENU_ROW_SIZE)
         .clickable {
@@ -148,6 +151,7 @@ fun CommandsMenuView(
       is ChatBotCommand.Command -> {
         Box(
           modifier = Modifier
+            .ui(Ui.Chat.Command(cmd.keyword))
             .fillMaxWidth()
             .height(COMMAND_MENU_ROW_SIZE)
             .clickable {
@@ -184,6 +188,7 @@ fun CommandsMenuView(
       is ChatBotCommand.Menu ->
         Box(
           modifier = Modifier
+            .ui(Ui.Chat.CommandMenu(cmd.label))
             .fillMaxWidth()
             .height(COMMAND_MENU_ROW_SIZE)
             .clickable {
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextGroupDirectInvitationActionsView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextGroupDirectInvitationActionsView.kt
index 015308fe22..c815148b6a 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextGroupDirectInvitationActionsView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextGroupDirectInvitationActionsView.kt
@@ -14,6 +14,8 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.ui.theme.DEFAULT_PADDING_HALF
 import chat.simplex.common.views.helpers.*
 import chat.simplex.res.*
@@ -74,7 +76,7 @@ fun ComposeContextMemberContactActionsView(
             .fillMaxWidth(),
           horizontalArrangement = Arrangement.SpaceEvenly,
         ) {
-          var rejectButtonModifier = Modifier.fillMaxWidth().fillMaxHeight().weight(1F)
+          var rejectButtonModifier = Modifier.ui(Ui.Chat.RequestReject).fillMaxWidth().fillMaxHeight().weight(1F)
           rejectButtonModifier =
             if (inProgress.value) rejectButtonModifier
             else rejectButtonModifier.clickable { showRejectMemberContactRequestAlert(rhId, contact) }
@@ -94,7 +96,7 @@ fun ComposeContextMemberContactActionsView(
               color = if (inProgress.value) MaterialTheme.colors.secondary else Color.Red
             )
           }
-          var acceptButtonModifier = Modifier.fillMaxWidth().fillMaxHeight().weight(1F)
+          var acceptButtonModifier = Modifier.ui(Ui.Chat.RequestAccept).fillMaxWidth().fillMaxHeight().weight(1F)
           acceptButtonModifier =
             if (inProgress.value) acceptButtonModifier
             else acceptButtonModifier.clickable { acceptMemberContact(rhId, contact.contactId, inProgress = inProgress) }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextPendingMemberActionsView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextPendingMemberActionsView.kt
index 8cda1226fd..c48dffb150 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextPendingMemberActionsView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextPendingMemberActionsView.kt
@@ -13,6 +13,8 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.chat.group.removeMember
 import chat.simplex.common.views.chat.group.removeMemberDialog
 import chat.simplex.common.views.helpers.*
@@ -41,6 +43,7 @@ fun ComposeContextPendingMemberActionsView(
     ) {
       Column(
         Modifier
+          .ui(Ui.Chat.PendingReject)
           .fillMaxWidth()
           .fillMaxHeight()
           .weight(1F)
@@ -55,6 +58,7 @@ fun ComposeContextPendingMemberActionsView(
 
       Column(
         Modifier
+          .ui(Ui.Chat.PendingAccept)
           .fillMaxWidth()
           .fillMaxHeight()
           .weight(1F)
@@ -91,14 +95,14 @@ fun acceptMemberDialog(rhId: Long?, groupInfo: GroupInfo, member: GroupMember, c
         SectionItemView({
           AlertManager.shared.hideAlert()
           acceptMember(rhId, groupInfo, member, GroupMemberRole.Member, close)
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "acceptAsMember")) {
           Text(generalGetString(MR.strings.accept_pending_member_alert_confirmation_as_member), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
         }
         // Accept as observer
         SectionItemView({
           AlertManager.shared.hideAlert()
           acceptMember(rhId, groupInfo, member, GroupMemberRole.Observer, close)
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "acceptAsObserver")) {
           Text(generalGetString(MR.strings.accept_pending_member_alert_confirmation_as_observer), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
         }
         // Cancel
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextProfilePickerView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextProfilePickerView.kt
index 80940bf631..56f466549b 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextProfilePickerView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeContextProfilePickerView.kt
@@ -17,7 +17,9 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.*
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.newchat.IncognitoOptionImage
 import chat.simplex.common.views.usersettings.IncognitoView
@@ -124,6 +126,7 @@ fun ComposeContextProfilePickerView(
       Modifier
         .fillMaxWidth()
         .sizeIn(minHeight = DEFAULT_MIN_SECTION_ITEM_HEIGHT + 8.dp)
+        .ui(Ui.Chat.PickerUser(user.userId))
         .clickable(onClick = {
           if (!chat.chatInfo.profileChangeProhibited) {
             if (selectedUser.value.userId == user.userId) {
@@ -167,6 +170,7 @@ fun ComposeContextProfilePickerView(
       Modifier
         .fillMaxWidth()
         .sizeIn(minHeight = DEFAULT_MIN_SECTION_ITEM_HEIGHT + 8.dp)
+        .ui(Ui.Chat.PickerIncognito)
         .clickable(onClick = {
           if (!chat.chatInfo.profileChangeProhibited) {
             if (incognitoDefault) {
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeView.kt
index b80fe11088..d97e8abc9d 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ComposeView.kt
@@ -33,6 +33,7 @@ import chat.simplex.common.model.ChatModel.controller
 import chat.simplex.common.model.ChatModel.filesToDelete
 import chat.simplex.common.platform.*
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.badges.openBadgesView
 import chat.simplex.common.views.chat.group.hostFromRelayLink
@@ -1297,6 +1298,7 @@ fun ComposeView(
     val commandsEnabled = chat.chatInfo.sendMsgEnabled && chat.chatInfo.menuCommands.isNotEmpty()
     IconButton(
       onClick = { showCommandsMenu.value = !showCommandsMenu.value },
+      modifier = Modifier.ui(Ui.Chat.CommandsButton),
       enabled = commandsEnabled
     ) {
       Box(
@@ -1528,6 +1530,7 @@ fun ComposeView(
       },
       editPrevMessage = ::editPrevMessage,
       onFilesPasted = { composeState.onFilesAttached(it) },
+      uiKey = if (chatsCtx.secondaryContextFilter == null) Ui.Chat.Message else Ui.Chat.ScopeMessage,
       onMessageChange = ::onMessageChange,
       textStyle = textStyle,
       focusRequester = focusRequester,
@@ -1573,7 +1576,7 @@ fun ComposeView(
     icon: ImageResource,
     connect: () -> Unit
   ) {
-    var modifier = Modifier.height(57.dp).fillMaxWidth()
+    var modifier = Modifier.height(57.dp).fillMaxWidth().ui(Ui.Chat.Connect)
     modifier = if (composeState.value.inProgress) modifier else modifier.clickable(onClick = { connect() })
     Box(
       modifier,
@@ -1881,13 +1884,13 @@ private fun showLinkPreviewsConfirmAlert(socksEnabled: Boolean, onChoice: (Boole
         SectionItemView({
           AlertManager.shared.hideAlert()
           onChoice(false)
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "disable")) {
           Text(stringResource(MR.strings.link_previews_alert_disable), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
         }
         SectionItemView({
           AlertManager.shared.hideAlert()
           onChoice(true)
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "enable")) {
           Text(stringResource(MR.strings.link_previews_alert_enable), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = if (socksEnabled) MaterialTheme.colors.primary else Color.Red)
         }
 //        SectionItemView({
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ContactPreferences.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ContactPreferences.kt
index b7adec1add..4f085d46be 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ContactPreferences.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ContactPreferences.kt
@@ -15,6 +15,7 @@ import androidx.compose.runtime.*
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.graphics.Color
 import dev.icerock.moko.resources.compose.stringResource
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.usersettings.PreferenceToggle
@@ -147,6 +148,8 @@ private fun FeatureSection(
       ContactFeatureAllowed.values(userDefault).map { it to it.text },
       allowFeature,
       icon = null,
+      uiKey = Ui.ContactPrefs.Allow(feature),
+      optionKey = { if (it is ContactFeatureAllowed.UserDefault) "default" else it.allowed.name },
       onSelected = onSelected
     )
     InfoRow(
@@ -180,6 +183,7 @@ private fun TimedMessagesFeatureSection(
     PreferenceToggle(
       generalGetString(MR.strings.chat_preferences_you_allow),
       checked = allowFeature.value,
+      uiKey = Ui.ContactPrefs.Timed,
     ) { allow ->
       onSelected(allow, if (allow) featuresAllowed.timedMessagesTTL ?: 86400 else null)
     }
@@ -196,6 +200,7 @@ private fun TimedMessagesFeatureSection(
         dropdownValues = TimedMessagesPreference.ttlValues,
         customPickerTitle = generalGetString(MR.strings.delete_after),
         customPickerConfirmButtonText = generalGetString(MR.strings.custom_time_picker_select),
+        uiKey = Ui.ContactPrefs.Ttl,
         onSelected = onTTLUpdated
       )
     } else if (pref.contactPreference.allow == FeatureAllowed.YES || pref.contactPreference.allow == FeatureAllowed.ALWAYS) {
@@ -208,10 +213,10 @@ private fun TimedMessagesFeatureSection(
 @Composable
 private fun ResetSaveButtons(reset: () -> Unit, save: () -> Unit, disabled: Boolean) {
   SectionView {
-    SectionItemView(reset, disabled = disabled) {
+    SectionItemView(reset, disabled = disabled, uiKey = Ui.ContactPrefs.Reset) {
       Text(stringResource(MR.strings.reset_verb), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
     }
-    SectionItemView(save, disabled = disabled) {
+    SectionItemView(save, disabled = disabled, uiKey = Ui.ContactPrefs.Save) {
       Text(stringResource(MR.strings.save_and_notify_contact), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
     }
   }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/SelectableChatItemToolbars.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/SelectableChatItemToolbars.kt
index 5e252dae3a..43aaaa21af 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/SelectableChatItemToolbars.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/SelectableChatItemToolbars.kt
@@ -16,6 +16,7 @@ import chat.simplex.common.model.*
 import chat.simplex.common.platform.BackHandler
 import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.helpers.*
 import dev.icerock.moko.resources.compose.stringResource
 import chat.simplex.res.*
@@ -52,7 +53,7 @@ fun BoxScope.SelectedItemsCounterToolbar(selectedItems: MutableState<Set<Long>?>
 
 @Composable
 private fun SelectAllButton(onClick: () -> Unit) {
-  IconButton(onClick) {
+  IconButton(onClick, Modifier.ui(Ui.Chat.Selection.part("selectAll"))) {
     Icon(
       painterResource(MR.images.ic_checklist), stringResource(MR.strings.back), Modifier.height(24.dp), tint = MaterialTheme.colors.primary
     )
@@ -94,7 +95,7 @@ fun SelectedItemsButtonsToolbar(
       horizontalArrangement = Arrangement.SpaceBetween,
       verticalAlignment = Alignment.CenterVertically
     ) {
-      IconButton({ if (canArchiveReports.value) archiveItems() else deleteItems(deleteForEveryoneEnabled.value) }, enabled = deleteEnabled.value && !deleteCountProhibited.value) {
+      IconButton({ if (canArchiveReports.value) archiveItems() else deleteItems(deleteForEveryoneEnabled.value) }, Modifier.ui(Ui.Chat.Selection.part("delete")), enabled = deleteEnabled.value && !deleteCountProhibited.value) {
         Icon(
           painterResource(MR.images.ic_delete),
           null,
@@ -103,7 +104,7 @@ fun SelectedItemsButtonsToolbar(
         )
       }
 
-      IconButton({ moderateItems() }, Modifier.alpha(if (canModerate.value) 1f else 0f), enabled = moderateEnabled.value && !deleteCountProhibited.value && chatsCtx.secondaryContextFilter == null) {
+      IconButton({ moderateItems() }, Modifier.ui(Ui.Chat.Selection.part("moderate")).alpha(if (canModerate.value) 1f else 0f), enabled = moderateEnabled.value && !deleteCountProhibited.value && chatsCtx.secondaryContextFilter == null) {
         Icon(
           painterResource(MR.images.ic_flag),
           null,
@@ -112,7 +113,7 @@ fun SelectedItemsButtonsToolbar(
         )
       }
 
-      IconButton({ forwardItems() }, enabled = forwardEnabled.value && !forwardCountProhibited.value && chatsCtx.secondaryContextFilter == null) {
+      IconButton({ forwardItems() }, Modifier.ui(Ui.Chat.Selection.part("forward")), enabled = forwardEnabled.value && !forwardCountProhibited.value && chatsCtx.secondaryContextFilter == null) {
         Icon(
           painterResource(MR.images.ic_forward),
           null,
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/SendMsgView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/SendMsgView.kt
index eddb5d727d..b4b8a1810d 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/SendMsgView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/SendMsgView.kt
@@ -20,7 +20,7 @@ import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.unit.*
 import chat.simplex.common.model.*
 import chat.simplex.common.ui.theme.*
-import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.ui
 import chat.simplex.common.views.chat.item.ItemAction
 import chat.simplex.common.views.helpers.*
@@ -62,6 +62,7 @@ fun SendMsgView(
   cancelLiveMessage: (() -> Unit)? = null,
   editPrevMessage: () -> Unit,
   onFilesPasted: (List<URI>) -> Unit,
+  uiKey: UiKey? = null,
   onMessageChange: (ComposeMessage) -> Unit,
   textStyle: MutableState<TextStyle>,
   focusRequester: FocusRequester? = null,
@@ -90,7 +91,8 @@ fun SendMsgView(
       onMessageChange,
       editPrevMessage,
       onFilesPasted,
-      focusRequester
+      focusRequester,
+      uiKey
     ) {
       if (!cs.inProgress) {
         if (sendToConnect != null) {
@@ -120,7 +122,7 @@ fun SendMsgView(
       }
     }
     if (showDeleteTextButton.value) {
-      DeleteTextButton(composeState)
+      DeleteTextButton(composeState, uiKey?.part("clearText"))
     }
     Box(Modifier.align(Alignment.BottomEnd).padding(bottom = if (appPlatform.isAndroid) 0.dp else 5.sp.toDp() * fontSizeSqrtMultiplier)) {
       val sendButtonSize = remember { Animatable(36f) }
@@ -135,7 +137,7 @@ fun SendMsgView(
       when {
         cs.progressByTimeout -> ComposeProgressIndicator()
         cs.contextItem is ComposeContextItem.ReportedItem -> {
-          SendMsgButton(painterResource(MR.images.ic_check_filled), sendButtonSize, sendButtonAlpha, sendButtonColor, !sendMsgButtonDisabled, sendToConnect, sendMessage)
+          SendMsgButton(painterResource(MR.images.ic_check_filled), sendButtonSize, sendButtonAlpha, sendButtonColor, !sendMsgButtonDisabled, sendToConnect, sendMessage, uiKey?.part("send"))
         }
         showVoiceButton && sendMsgEnabled -> {
           Row(verticalAlignment = Alignment.CenterVertically) {
@@ -161,7 +163,7 @@ fun SendMsgView(
               && cs.contextItem is ComposeContextItem.NoContextItem
             ) {
               Spacer(Modifier.width(12.dp))
-              StartLiveMessageButton {
+              StartLiveMessageButton(uiKey?.part("live")) {
                 if (composeState.value.preview is ComposePreview.NoPreview) {
                   startLiveMessage(scope, sendLiveMessage, updateLiveMessage, sendButtonSize, sendButtonAlpha, composeState, liveMessageAlertShown)
                 }
@@ -196,7 +198,8 @@ fun SendMsgView(
                     onClick = {
                       startLiveMessage(scope, sendLiveMessage, updateLiveMessage, sendButtonSize, sendButtonAlpha, composeState, liveMessageAlertShown)
                       showDropdown.value = false
-                    }
+                    },
+                    uiKey = uiKey?.part("sendLive")
                   )
                 }
               }
@@ -205,6 +208,7 @@ fun SendMsgView(
                   ItemAction(
                     generalGetString(MR.strings.disappearing_message),
                     painterResource(MR.images.ic_timer),
+                    uiKey = uiKey?.part("timed"),
                     onClick = {
                       showCustomDisappearingMessageDialog.value = true
                       showDropdown.value = false
@@ -245,17 +249,18 @@ fun SendMsgView(
           if (!hideSendButton) {
             val menuItems = MenuItems()
             if (menuItems.isNotEmpty()) {
-              SendMsgButton(icon, sendButtonSize, sendButtonAlpha, sendButtonColor, !sendMsgButtonDisabled, sendToConnect, sendMessage) { showDropdown.value = true }
+              SendMsgButton(icon, sendButtonSize, sendButtonAlpha, sendButtonColor, !sendMsgButtonDisabled, sendToConnect, sendMessage, uiKey?.part("send")) { showDropdown.value = true }
               DefaultDropdownMenu(showDropdown) {
                 menuItems.forEach { composable -> composable() }
               }
               CustomDisappearingMessageDialog(
                 showCustomDisappearingMessageDialog,
+                uiKey = uiKey?.part("timed"),
                 sendMessage = sendMessage,
                 customDisappearingMessageTimePref = customDisappearingMessageTimePref
               )
             } else {
-              SendMsgButton(icon, sendButtonSize, sendButtonAlpha, sendButtonColor, !sendMsgButtonDisabled, sendToConnect, sendMessage)
+              SendMsgButton(icon, sendButtonSize, sendButtonAlpha, sendButtonColor, !sendMsgButtonDisabled, sendToConnect, sendMessage, uiKey?.part("send"))
             }
           }
         }
@@ -273,6 +278,7 @@ expect fun VoiceButtonWithoutPermissionByPlatform()
 @Composable
 private fun CustomDisappearingMessageDialog(
   showMenu: MutableState<Boolean>,
+  uiKey: UiKey?,
   sendMessage: (Int?) -> Unit,
   customDisappearingMessageTimePref: SharedPreference<Int>?
 ) {
@@ -284,7 +290,7 @@ private fun CustomDisappearingMessageDialog(
       color = MaterialTheme.colors.secondary
     )
 
-    ItemAction(generalGetString(MR.strings.send_disappearing_message_30_seconds)) {
+    ItemAction(generalGetString(MR.strings.send_disappearing_message_30_seconds), uiKey = uiKey?.option(30)) {
       sendMessage(30)
       showMenu.value = false
     }
@@ -292,11 +298,11 @@ private fun CustomDisappearingMessageDialog(
       sendMessage(60)
       showMenu.value = false
     }
-    ItemAction(generalGetString(MR.strings.send_disappearing_message_5_minutes)) {
+    ItemAction(generalGetString(MR.strings.send_disappearing_message_5_minutes), uiKey = uiKey?.option(300)) {
       sendMessage(300)
       showMenu.value = false
     }
-    ItemAction(generalGetString(MR.strings.send_disappearing_message_custom_time)) {
+    ItemAction(generalGetString(MR.strings.send_disappearing_message_custom_time), uiKey = uiKey?.option("custom")) {
       showMenu.value = false
       val selectedDisappearingMessageTime = mutableStateOf(customDisappearingMessageTimePref?.get?.invoke() ?: 300)
       showCustomTimePickerDialog(
@@ -314,10 +320,10 @@ private fun CustomDisappearingMessageDialog(
 }
 
 @Composable
-private fun BoxScope.DeleteTextButton(composeState: MutableState<ComposeState>) {
+private fun BoxScope.DeleteTextButton(composeState: MutableState<ComposeState>, uiKey: UiKey?) {
   IconButton(
     { composeState.value = composeState.value.copy(message = ComposeMessage()) },
-    Modifier.align(Alignment.TopEnd).size(36.dp)
+    Modifier.ui(uiKey).align(Alignment.TopEnd).size(36.dp)
   ) {
     Icon(painterResource(MR.images.ic_close), null, Modifier.padding(7.dp).size(36.dp), tint = MaterialTheme.colors.secondary)
   }
@@ -459,12 +465,13 @@ private fun SendMsgButton(
   enabled: Boolean,
   sendToConnect: (() -> Unit)?,
   sendMessage: (Int?) -> Unit,
+  uiKey: UiKey?,
   onLongClick: (() -> Unit)? = null
 ) {
   val interactionSource = remember { MutableInteractionSource() }
   val ripple = remember { ripple(bounded = false, radius = 24.dp) }
   Box(
-    modifier = Modifier.ui(Ui.Chat.Send).requiredSize(36.dp)
+    modifier = Modifier.ui(uiKey).requiredSize(36.dp)
       .combinedClickable(
         onClick = {
           if (sendToConnect != null) {
@@ -498,11 +505,11 @@ private fun SendMsgButton(
 }
 
 @Composable
-private fun StartLiveMessageButton(onClick: () -> Unit) {
+private fun StartLiveMessageButton(uiKey: UiKey?, onClick: () -> Unit) {
   val interactionSource = remember { MutableInteractionSource() }
   val ripple = remember { ripple(bounded = false, radius = 24.dp) }
   Box(
-    modifier = Modifier.requiredSize(36.dp)
+    modifier = Modifier.ui(uiKey).requiredSize(36.dp)
       .clickable(
         onClick = onClick,
         role = Role.Button,
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/TextSelection.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/TextSelection.kt
index e04f75d799..dd0d7c7fed 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/TextSelection.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/TextSelection.kt
@@ -36,6 +36,8 @@ import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.chat.item.itemPrefixText
 import chat.simplex.common.views.chat.item.itemDisplay
 import chat.simplex.common.views.helpers.generalGetString
@@ -558,6 +560,7 @@ fun SelectionCopyButton() {
             .background(MaterialTheme.colors.surface, RoundedCornerShape(20.dp))
             .border(1.dp, MaterialTheme.colors.onSurface.copy(alpha = 0.12f), RoundedCornerShape(20.dp))
             .clip(RoundedCornerShape(20.dp))
+            .ui(Ui.Chat.TextSelectionCopy)
             .clickable {
                 manager.onCopySelection?.invoke()
                 manager.clearSelection()
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/AddGroupMembersView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/AddGroupMembersView.kt
index 86380f9580..fb6c602d66 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/AddGroupMembersView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/AddGroupMembersView.kt
@@ -31,6 +31,7 @@ import chat.simplex.common.views.usersettings.SettingsActionItem
 import chat.simplex.common.model.GroupInfo
 import chat.simplex.common.platform.*
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.res.*
 import dev.icerock.moko.resources.StringResource
 import kotlinx.coroutines.*
@@ -215,7 +216,7 @@ private fun SearchRowView(
     Icon(painterResource(MR.images.ic_search), stringResource(MR.strings.search_verb), tint = MaterialTheme.colors.secondary)
   }
   Spacer(Modifier.width(DEFAULT_SPACE_AFTER_ICON))
-  SearchTextField(Modifier.fillMaxWidth(), searchText = searchText, alwaysVisible = true) {
+  SearchTextField(Modifier.fillMaxWidth().ui(Ui.InviteMembers.Search), searchText = searchText, alwaysVisible = true) {
     searchText.value = searchText.value.copy(it)
   }
 }
@@ -235,7 +236,8 @@ private fun RoleSelectionRow(groupInfo: GroupInfo, selectedRole: MutableState<Gr
       values,
       selectedRole,
       icon = null,
-      enabled = rememberUpdatedState(enabled)
+      enabled = rememberUpdatedState(enabled),
+      uiKey = Ui.InviteMembers.Role
     ) { selectedRole.value = it }
   }
 }
@@ -261,6 +263,7 @@ fun SkipInvitingButton(onClick: () -> Unit) {
     click = onClick,
     textColor = MaterialTheme.colors.primary,
     iconColor = MaterialTheme.colors.primary,
+    uiKey = Ui.InviteMembers.Skip,
   )
 }
 
@@ -279,7 +282,7 @@ fun InviteSectionFooter(selectedContactsCount: Int, enabled: Boolean, clearSelec
         fontSize = 14.sp
       )
       Box(
-        Modifier.clickable { if (enabled) clearSelection() }
+        Modifier.ui(Ui.InviteMembers.Clear).clickable { if (enabled) clearSelection() }
       ) {
         Text(
           stringResource(MR.strings.clear_contacts_selection_button),
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupChatInfoView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupChatInfoView.kt
index 6270bd6d23..5711bdd599 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupChatInfoView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupChatInfoView.kt
@@ -40,6 +40,8 @@ import androidx.compose.ui.unit.*
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.usersettings.*
@@ -373,7 +375,7 @@ private fun removeMembersAlert(rhId: Long?, groupInfo: GroupInfo, memberIds: Lis
         SectionItemView({
           AlertManager.shared.hideAlert()
           removeMembers(rhId, groupInfo, memberIds, withMessages = false, onSuccess = onSuccess)
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "remove")) {
           Text(generalGetString(MR.strings.remove_member_confirmation), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = Color.Red)
         }
         SectionItemView({
@@ -431,6 +433,7 @@ fun MuteButton(
     title = generalGetString(nextNotificationMode.text(true)),
     disabled = !groupInfo.ready,
     disabledLook = !groupInfo.ready,
+    uiKey = Ui.GroupInfo.Mute,
     onClick = {
       toggleNotifications(chat.remoteHostId, chat.chatInfo, nextNotificationMode, chatModel, notificationMode)
     }
@@ -499,6 +502,7 @@ fun UserSupportChatButton(
       }
     },
     iconColor = (if (chat.supportUnreadCount > 0) MaterialTheme.colors.primary else MaterialTheme.colors.secondary),
+    uiKey = Ui.GroupInfo.UserSupport,
   ) {
     if (chat.supportUnreadCount > 0) {
       UnreadBadge(
@@ -559,6 +563,7 @@ fun ModalData.GroupChatInfoLayout(
     val navBarPadding = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding()
     val imePadding = WindowInsets.ime.asPaddingValues().calculateBottomPadding()
   LazyColumnWithScrollBar(
+    Modifier.ui(Ui.GroupInfo.Content),
     state = listState,
     contentPadding = if (oneHandUI.value) {
       PaddingValues(
@@ -945,11 +950,12 @@ private fun SelectedItemsCounterToolbarSetter(
 }
 
 @Composable
-fun ChatTTLOption(chatItemTTL: State<ChatItemTTL?>, setChatItemTTL: (ChatItemTTL?) -> Unit, deletingItems: State<Boolean>) {
+fun ChatTTLOption(chatItemTTL: State<ChatItemTTL?>, setChatItemTTL: (ChatItemTTL?) -> Unit, deletingItems: State<Boolean>, uiKey: UiKey? = null) {
   Box {
     TtlOptions(
       chatItemTTL,
       enabled = remember { derivedStateOf { !deletingItems.value } },
+      uiKey = uiKey,
       onSelected = setChatItemTTL,
       default = chatModel.chatItemTTL
     )
@@ -1018,7 +1024,8 @@ private fun MemberSupportButton(chat: Chat, onClick: () -> Unit) {
     painterResource(if (chat.supportUnreadCount > 0) MR.images.ic_flag_filled else MR.images.ic_flag),
     stringResource(MR.strings.member_support),
     click = onClick,
-    iconColor = (if (chat.supportUnreadCount > 0) MaterialTheme.colors.primary else MaterialTheme.colors.secondary)
+    iconColor = (if (chat.supportUnreadCount > 0) MaterialTheme.colors.primary else MaterialTheme.colors.secondary),
+    uiKey = Ui.GroupInfo.MemberSupport
   ) {
     if (chat.supportUnreadCount > 0) {
       UnreadBadge(
@@ -1034,7 +1041,8 @@ private fun GroupPreferencesButton(titleId: StringResource, onClick: () -> Unit)
   SettingsActionItem(
     painterResource(MR.images.ic_toggle_on),
     stringResource(titleId),
-    click = onClick
+    click = onClick,
+    uiKey = Ui.GroupInfo.Preferences
   )
 }
 
@@ -1044,7 +1052,8 @@ private fun GroupReportsButton(chat: Chat, onClick: () -> Unit) {
     painterResource(if (chat.chatStats.reportsCount > 0) MR.images.ic_flag_filled else MR.images.ic_flag),
     stringResource(MR.strings.group_reports_member_reports),
     click = onClick,
-    iconColor = (if (chat.chatStats.reportsCount > 0) Color.Red else MaterialTheme.colors.secondary)
+    iconColor = (if (chat.chatStats.reportsCount > 0) Color.Red else MaterialTheme.colors.secondary),
+    uiKey = Ui.GroupInfo.Reports
   ) {
     if (chat.chatStats.reportsCount > 0) {
       UnreadBadge(
@@ -1066,6 +1075,8 @@ private fun SendReceiptsOption(currentUser: User, state: State<SendReceipts>, on
     state,
     icon = painterResource(MR.images.ic_double_check),
     enabled = remember { mutableStateOf(true) },
+    uiKey = Ui.GroupInfo.SendReceipts,
+    optionKey = { it.bool },
     onSelected = onSelected
   )
 }
@@ -1093,7 +1104,8 @@ private fun AddMembersButton(titleId: StringResource, tint: Color = MaterialThem
     stringResource(titleId),
     onClick,
     iconColor = tint,
-    textColor = tint
+    textColor = tint,
+    uiKey = Ui.GroupInfo.AddMembers
   )
 }
 
@@ -1191,38 +1203,38 @@ private fun DropDownMenuForMember(rhId: Long?, member: GroupMember, groupInfo: G
       DefaultDropdownMenu(showMenu) {
         if (canBlockForAll) {
           if (member.blockedByAdmin) {
-            ItemAction(stringResource(MR.strings.unblock_for_all), painterResource(MR.images.ic_do_not_touch), onClick = {
+            ItemAction(stringResource(MR.strings.unblock_for_all), painterResource(MR.images.ic_do_not_touch), uiKey = Ui.GroupInfo.MemberMenu(member.groupMemberId, "unblockForAll"), onClick = {
               unblockForAllAlert(rhId, groupInfo, member)
               showMenu.value = false
             })
           } else {
-            ItemAction(stringResource(MR.strings.block_for_all), painterResource(MR.images.ic_back_hand), color = MaterialTheme.colors.error, onClick = {
+            ItemAction(stringResource(MR.strings.block_for_all), painterResource(MR.images.ic_back_hand), color = MaterialTheme.colors.error, uiKey = Ui.GroupInfo.MemberMenu(member.groupMemberId, "blockForAll"), onClick = {
               blockForAllAlert(rhId, groupInfo, member)
               showMenu.value = false
             })
           }
         }
         if (canRemove) {
-          ItemAction(stringResource(MR.strings.remove_member_button), painterResource(MR.images.ic_delete), color = MaterialTheme.colors.error, onClick = {
+          ItemAction(stringResource(MR.strings.remove_member_button), painterResource(MR.images.ic_delete), color = MaterialTheme.colors.error, uiKey = Ui.GroupInfo.MemberMenu(member.groupMemberId, "remove"), onClick = {
             removeMemberAlert(rhId, groupInfo, member)
             showMenu.value = false
           })
         }
         if (selectedItems.value == null && member.memberRole < GroupMemberRole.Moderator) {
           Divider()
-          SelectItemAction(showMenu) { toggleItemSelection(member.groupMemberId, selectedItems) }
+          SelectItemAction(showMenu, Ui.GroupInfo.MemberMenu(member.groupMemberId, "select")) { toggleItemSelection(member.groupMemberId, selectedItems) }
         }
       }
     }
   } else if (!member.blockedByAdmin) {
     DefaultDropdownMenu(showMenu) {
       if (member.memberSettings.showMessages) {
-        ItemAction(stringResource(MR.strings.block_member_button), painterResource(MR.images.ic_back_hand), color = MaterialTheme.colors.error, onClick = {
+        ItemAction(stringResource(MR.strings.block_member_button), painterResource(MR.images.ic_back_hand), color = MaterialTheme.colors.error, uiKey = Ui.GroupInfo.MemberMenu(member.groupMemberId, "block"), onClick = {
           blockMemberAlert(rhId, groupInfo, member)
           showMenu.value = false
         })
       } else {
-        ItemAction(stringResource(MR.strings.unblock_member_button), painterResource(MR.images.ic_do_not_touch), onClick = {
+        ItemAction(stringResource(MR.strings.unblock_member_button), painterResource(MR.images.ic_do_not_touch), uiKey = Ui.GroupInfo.MemberMenu(member.groupMemberId, "unblock"), onClick = {
           unblockMemberAlert(rhId, groupInfo, member)
           showMenu.value = false
         })
@@ -1237,7 +1249,8 @@ private fun GroupLinkButton(onClick: () -> Unit) {
     painterResource(MR.images.ic_link),
     stringResource(MR.strings.group_link),
     onClick,
-    iconColor = MaterialTheme.colors.secondary
+    iconColor = MaterialTheme.colors.secondary,
+    uiKey = Ui.GroupInfo.GroupLink
   )
 }
 
@@ -1341,7 +1354,8 @@ fun EditGroupProfileButton(titleId: StringResource = MR.strings.button_edit_grou
     painterResource(MR.images.ic_edit),
     stringResource(titleId),
     onClick,
-    iconColor = MaterialTheme.colors.secondary
+    iconColor = MaterialTheme.colors.secondary,
+    uiKey = Ui.GroupInfo.EditProfile
   )
 }
 
@@ -1356,7 +1370,8 @@ private fun AddOrEditWelcomeMessage(welcomeMessage: String?, onClick: () -> Unit
     painterResource(MR.images.ic_maps_ugc),
     text,
     onClick,
-    iconColor = MaterialTheme.colors.secondary
+    iconColor = MaterialTheme.colors.secondary,
+    uiKey = Ui.GroupInfo.WelcomeMessage
   )
 }
 
@@ -1367,7 +1382,8 @@ private fun LeaveGroupButton(titleId: StringResource, onClick: () -> Unit) {
     stringResource(titleId),
     onClick,
     iconColor = Color.Red,
-    textColor = Color.Red
+    textColor = Color.Red,
+    uiKey = Ui.GroupInfo.Leave
   )
 }
 
@@ -1378,19 +1394,21 @@ private fun DeleteGroupButton(titleId: StringResource, onClick: () -> Unit) {
     stringResource(titleId),
     onClick,
     iconColor = Color.Red,
-    textColor = Color.Red
+    textColor = Color.Red,
+    uiKey = Ui.GroupInfo.Delete
   )
 }
 
 @Composable
 fun MemberListSearchRowView(
-  searchText: MutableState<TextFieldValue> = rememberSaveable(stateSaver = TextFieldValue.Saver) { mutableStateOf(TextFieldValue()) }
+  searchText: MutableState<TextFieldValue> = rememberSaveable(stateSaver = TextFieldValue.Saver) { mutableStateOf(TextFieldValue()) },
+  uiKey: UiKey? = null
 ) {
   Box(Modifier.width(36.dp), contentAlignment = Alignment.Center) {
     Icon(painterResource(MR.images.ic_search), stringResource(MR.strings.search_verb), tint = MaterialTheme.colors.secondary)
   }
   Spacer(Modifier.width(14.dp))
-  SearchTextField(Modifier.fillMaxWidth(), searchText = searchText, alwaysVisible = true) {
+  SearchTextField(Modifier.fillMaxWidth().ui(uiKey), searchText = searchText, alwaysVisible = true) {
     searchText.value = searchText.value.copy(it)
   }
 }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupLinkView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupLinkView.kt
index 86d74900be..8fece09560 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupLinkView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupLinkView.kt
@@ -294,6 +294,7 @@ fun GroupLinkLayout(
               click = close,
               iconColor = MaterialTheme.colors.primary,
               textColor = MaterialTheme.colors.primary,
+              uiKey = Ui.GroupLink.Continue,
             )
           }
         }
@@ -316,7 +317,8 @@ private fun RoleSelectionRow(groupInfo: GroupInfo, selectedRole: MutableState<Gr
       values,
       selectedRole,
       icon = null,
-      enabled = rememberUpdatedState(enabled)
+      enabled = rememberUpdatedState(enabled),
+      uiKey = Ui.GroupLink.Role
     ) { selectedRole.value = it }
   }
 }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupMemberInfoView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupMemberInfoView.kt
index 00d580c5a8..e8deca9017 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupMemberInfoView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupMemberInfoView.kt
@@ -29,6 +29,7 @@ import androidx.compose.ui.unit.*
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatModel.controller
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.chat.*
 import chat.simplex.common.views.helpers.*
@@ -321,7 +322,7 @@ fun removeMemberDialog(rhId: Long?, groupInfo: GroupInfo, member: GroupMember, c
           SectionItemView({
             AlertManager.shared.hideAlert()
             removeMember(rhId, groupInfo, member, withMessages = true, chatModel, close)
-          }) {
+          }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "removeWithMessages")) {
             Text(generalGetString(MR.strings.remove_member_delete_messages_confirmation), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = Color.Red)
           }
           SectionItemView({
@@ -425,6 +426,7 @@ fun GroupMemberInfoLayout(
         }
       },
       iconColor = MaterialTheme.colors.secondary,
+      uiKey = Ui.MemberInfo.SupportChat,
     )
   }
 
@@ -509,7 +511,7 @@ fun GroupMemberInfoLayout(
               }
             }
 
-            OpenChatButton(modifier = Modifier.fillMaxWidth(0.33f), onClick = { openDirectChat(contact.contactId) })
+            OpenChatButton(modifier = Modifier.fillMaxWidth(0.33f), uiKey = Ui.MemberInfo.Message, onClick = { openDirectChat(contact.contactId) })
             AudioCallButton(modifier = Modifier.fillMaxWidth(0.5f), chat, contact, knownContactConnectionStats)
             VideoButton(modifier = Modifier.fillMaxWidth(1f), chat, contact, knownContactConnectionStats)
           } else if (groupInfo.fullGroupPreferences.directMessages.on(groupInfo.membership)) {
@@ -519,24 +521,25 @@ fun GroupMemberInfoLayout(
               OpenChatButton(
                 modifier = Modifier.fillMaxWidth(0.33f),
                 disabledLook = !(member.sendMsgEnabled || (member.activeConn?.connectionStats?.ratchetSyncAllowed ?: false)),
+                uiKey = Ui.MemberInfo.Message,
                 onClick = { createMemberContact() }
               )
             }
-            InfoViewActionButton(modifier = Modifier.fillMaxWidth(0.5f), painterResource(MR.images.ic_call), generalGetString(MR.strings.info_view_call_button), disabled = false, disabledLook = true, onClick = {
+            InfoViewActionButton(modifier = Modifier.fillMaxWidth(0.5f), painterResource(MR.images.ic_call), generalGetString(MR.strings.info_view_call_button), disabled = false, disabledLook = true, uiKey = Ui.MemberInfo.Call, onClick = {
               showSendMessageToEnableCallsAlert()
             })
-            InfoViewActionButton(modifier = Modifier.fillMaxWidth(1f), painterResource(MR.images.ic_videocam), generalGetString(MR.strings.info_view_video_button), disabled = false, disabledLook = true, onClick = {
+            InfoViewActionButton(modifier = Modifier.fillMaxWidth(1f), painterResource(MR.images.ic_videocam), generalGetString(MR.strings.info_view_video_button), disabled = false, disabledLook = true, uiKey = Ui.MemberInfo.Video, onClick = {
               showSendMessageToEnableCallsAlert()
             })
           } else { // no known contact chat && directMessages are off
             val messageId = if (groupInfo.businessChat == null) MR.strings.direct_messages_are_prohibited_in_group else MR.strings.direct_messages_are_prohibited_in_chat
-            InfoViewActionButton(modifier = Modifier.fillMaxWidth(0.33f), painterResource(MR.images.ic_chat_bubble), generalGetString(MR.strings.info_view_message_button), disabled = false, disabledLook = true, onClick = {
+            InfoViewActionButton(modifier = Modifier.fillMaxWidth(0.33f), painterResource(MR.images.ic_chat_bubble), generalGetString(MR.strings.info_view_message_button), disabled = false, disabledLook = true, uiKey = Ui.MemberInfo.Message, onClick = {
               showDirectMessagesProhibitedAlert(generalGetString(MR.strings.cant_send_message_to_member_alert_title), messageId)
             })
-            InfoViewActionButton(modifier = Modifier.fillMaxWidth(0.5f), painterResource(MR.images.ic_call), generalGetString(MR.strings.info_view_call_button), disabled = false, disabledLook = true, onClick = {
+            InfoViewActionButton(modifier = Modifier.fillMaxWidth(0.5f), painterResource(MR.images.ic_call), generalGetString(MR.strings.info_view_call_button), disabled = false, disabledLook = true, uiKey = Ui.MemberInfo.Call, onClick = {
               showDirectMessagesProhibitedAlert(generalGetString(MR.strings.cant_call_member_alert_title), messageId)
             })
-            InfoViewActionButton(modifier = Modifier.fillMaxWidth(1f), painterResource(MR.images.ic_videocam), generalGetString(MR.strings.info_view_video_button), disabled = false, disabledLook = true, onClick = {
+            InfoViewActionButton(modifier = Modifier.fillMaxWidth(1f), painterResource(MR.images.ic_videocam), generalGetString(MR.strings.info_view_video_button), disabled = false, disabledLook = true, uiKey = Ui.MemberInfo.Video, onClick = {
               showDirectMessagesProhibitedAlert(generalGetString(MR.strings.cant_call_member_alert_title), messageId)
             })
           }
@@ -647,6 +650,7 @@ fun GroupMemberInfoLayout(
         }
         SwitchAddressButton(
           disabled = cStats.rcvQueuesInfo.any { it.rcvSwitchStatus != null } || !member.sendMsgEnabled,
+          uiKey = Ui.Info.SwitchAddress,
           switchAddress = switchMemberAddress
         )
         if (cStats.rcvQueuesInfo.any { it.rcvSwitchStatus != null }) {
@@ -657,11 +661,11 @@ fun GroupMemberInfoLayout(
         }
         val rcvServers = cStats.rcvQueuesInfo.map { it.rcvServer }
         if (rcvServers.isNotEmpty()) {
-          SimplexServers(stringResource(MR.strings.receiving_via), rcvServers)
+          SimplexServers(stringResource(MR.strings.receiving_via), rcvServers, Ui.Info.ReceivingVia)
         }
         val sndServers = cStats.sndQueuesInfo.map { it.sndServer }
         if (sndServers.isNotEmpty()) {
-          SimplexServers(stringResource(MR.strings.sending_via), sndServers)
+          SimplexServers(stringResource(MR.strings.sending_via), sndServers, Ui.Info.SendingVia)
         }
       }
     } else if (!connectionLoaded && memberConnected) {
@@ -808,6 +812,7 @@ fun BlockMemberButton(onClick: () -> Unit) {
     click = onClick,
     textColor = Color.Red,
     iconColor = Color.Red,
+    uiKey = Ui.MemberInfo.Block,
   )
 }
 
@@ -816,7 +821,8 @@ fun UnblockMemberButton(onClick: () -> Unit) {
   SettingsActionItem(
     painterResource(MR.images.ic_do_not_touch),
     stringResource(MR.strings.unblock_member_button),
-    click = onClick
+    click = onClick,
+    uiKey = Ui.MemberInfo.Unblock,
   )
 }
 
@@ -837,7 +843,8 @@ fun UnblockForAllButton(onClick: () -> Unit) {
   SettingsActionItem(
     painterResource(MR.images.ic_do_not_touch),
     stringResource(MR.strings.unblock_for_all),
-    click = onClick
+    click = onClick,
+    uiKey = Ui.MemberInfo.UnblockForAll,
   )
 }
 
@@ -864,6 +871,7 @@ fun DeleteMemberMessagesButton(onClick: () -> Unit) {
     click = onClick,
     textColor = Color.Red,
     iconColor = Color.Red,
+    uiKey = Ui.MemberInfo.DeleteMessages,
   )
 }
 
@@ -882,6 +890,7 @@ fun ShareRelayAddressButton(onClick: () -> Unit) {
 fun OpenChatButton(
   modifier: Modifier,
   disabledLook: Boolean = false,
+  uiKey: UiKey? = null,
   onClick: () -> Unit
 ) {
   InfoViewActionButton(
@@ -890,6 +899,7 @@ fun OpenChatButton(
     title = generalGetString(MR.strings.info_view_message_button),
     disabled = false,
     disabledLook = disabledLook,
+    uiKey = uiKey,
     onClick = onClick
   )
 }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupMembersToolbar.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupMembersToolbar.kt
index 6dcc6e9a4f..1a16157da4 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupMembersToolbar.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupMembersToolbar.kt
@@ -14,6 +14,8 @@ import androidx.compose.ui.unit.max
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.theme.WarningOrange
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.chat.*
 import chat.simplex.common.views.helpers.*
 import chat.simplex.res.*
@@ -59,7 +61,7 @@ fun SelectedItemsMembersToolbar(
       horizontalArrangement = Arrangement.SpaceBetween,
       verticalAlignment = Alignment.CenterVertically
     ) {
-      IconButton(delete, enabled = deleteEnabled.value) {
+      IconButton(delete, Modifier.ui(Ui.GroupInfo.MembersToolbar.part("remove")), enabled = deleteEnabled.value) {
         Icon(
           painterResource(MR.images.ic_delete),
           null,
@@ -68,7 +70,7 @@ fun SelectedItemsMembersToolbar(
         )
       }
 
-      IconButton({ blockForAll(blockForAllEnabled.value) }, enabled = blockForAllButtonEnabled.value) {
+      IconButton({ blockForAll(blockForAllEnabled.value) }, Modifier.ui(Ui.GroupInfo.MembersToolbar.part("block")), enabled = blockForAllButtonEnabled.value) {
         Icon(
           painterResource(if (unblockForAllEnabled.value && blockForAllButtonEnabled.value) MR.images.ic_do_not_touch else MR.images.ic_back_hand),
           null,
@@ -77,7 +79,7 @@ fun SelectedItemsMembersToolbar(
         )
       }
 
-      IconButton({ changeRole(if (roleToMemberEnabled.value) GroupMemberRole.Member else GroupMemberRole.Observer) }, enabled = roleButtonEnabled.value) {
+      IconButton({ changeRole(if (roleToMemberEnabled.value) GroupMemberRole.Member else GroupMemberRole.Observer) }, Modifier.ui(Ui.GroupInfo.MembersToolbar.part("role")), enabled = roleButtonEnabled.value) {
         Icon(
           painterResource(if (roleToObserverEnabled.value || !roleButtonEnabled.value) MR.images.ic_person else MR.images.ic_person_edit),
           null,
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupPreferences.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupPreferences.kt
index bd3af10c37..ecc2807af8 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupPreferences.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupPreferences.kt
@@ -14,6 +14,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.runtime.saveable.rememberSaveable
 import dev.icerock.moko.resources.StringResource
 import dev.icerock.moko.resources.compose.stringResource
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.usersettings.PreferenceToggleWithIcon
@@ -258,7 +259,8 @@ private fun MemberAdmissionButton(onClick: () -> Unit) {
   SettingsActionItem(
     painterResource(MR.images.ic_toggle_on),
     stringResource(MR.strings.member_admission),
-    click = onClick
+    click = onClick,
+    uiKey = Ui.GroupPrefs.MemberAdmission
   )
 }
 
@@ -286,6 +288,7 @@ private fun FeatureSection(
         iconTint,
         disabled = disabled,
         checked = enableFeature.value == GroupFeatureEnabled.ON,
+        uiKey = Ui.GroupPrefs.Toggle(feature),
       ) { checked ->
         onSelected(if (checked) GroupFeatureEnabled.ON else GroupFeatureEnabled.OFF, enableForRole?.value)
       }
@@ -298,6 +301,7 @@ private fun FeatureSection(
           dropdownValues = TimedMessagesPreference.ttlValues,
           customPickerTitle = generalGetString(MR.strings.delete_after),
           customPickerConfirmButtonText = generalGetString(MR.strings.custom_time_picker_select),
+          uiKey = Ui.GroupPrefs.Ttl,
           onSelected = onTTLUpdated
         )
       }
@@ -306,6 +310,7 @@ private fun FeatureSection(
           generalGetString(MR.strings.feature_enabled_for),
           featureRoles,
           enableForRole,
+          uiKey = Ui.GroupPrefs.Role(feature),
           onSelected = { value ->
             onSelected(enableFeature.value, value)
           }
@@ -340,10 +345,10 @@ private fun FeatureSection(
 @Composable
 private fun ResetSaveButtons(reset: () -> Unit, save: () -> Unit, disabled: Boolean, saveTextId: StringResource) {
   SectionView {
-    SectionItemView(reset, disabled = disabled) {
+    SectionItemView(reset, disabled = disabled, uiKey = Ui.GroupPrefs.Reset) {
       Text(stringResource(MR.strings.reset_verb), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
     }
-    SectionItemView(save, disabled = disabled) {
+    SectionItemView(save, disabled = disabled, uiKey = Ui.GroupPrefs.Save) {
       Text(stringResource(saveTextId), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
     }
   }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupProfileView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupProfileView.kt
index c93179edd7..78d2e8908c 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupProfileView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupProfileView.kt
@@ -18,7 +18,9 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.*
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.onboarding.ReadableText
@@ -139,7 +141,7 @@ fun GroupProfileLayout(
                 }
               }
             }
-            ProfileNameField(displayName, "", { isValidNewProfileName(it, groupProfile) }, focusRequester)
+            ProfileNameField(displayName, "", { isValidNewProfileName(it, groupProfile) }, focusRequester, uiKey = Ui.GroupProfile.Name)
             if (groupProfile.fullName.trim().isNotEmpty() && groupProfile.fullName.trim() != groupProfile.displayName.trim()) {
               Spacer(Modifier.height(DEFAULT_PADDING))
               Text(
@@ -167,7 +169,7 @@ fun GroupProfileLayout(
                 }
               }
             }
-            ProfileNameField(shortDescr, "", isValid = { bioFitsLimit(it) })
+            ProfileNameField(shortDescr, "", isValid = { bioFitsLimit(it) }, uiKey = Ui.GroupProfile.ShortDescr)
 
             Spacer(Modifier.height(DEFAULT_PADDING))
             val enabled = !dataUnchanged && canUpdateProfile(displayName.value, shortDescr.value, groupProfile)
@@ -175,7 +177,7 @@ fun GroupProfileLayout(
             if (enabled) {
               Text(
                 stringResource(saveProfileLabel),
-                modifier = Modifier.clickable {
+                modifier = Modifier.ui(Ui.GroupProfile.Save).clickable {
                   saveProfile(
                     groupProfile.copy(
                       displayName = displayName.value.trim(),
@@ -190,6 +192,7 @@ fun GroupProfileLayout(
             } else {
               Text(
                 stringResource(saveProfileLabel),
+                Modifier.ui(Ui.GroupProfile.Save),
                 color = MaterialTheme.colors.secondary
               )
             }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/MemberAdmission.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/MemberAdmission.kt
index ef333a8826..303e8dcba4 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/MemberAdmission.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/MemberAdmission.kt
@@ -9,6 +9,7 @@ import SectionView
 import androidx.compose.foundation.background
 import androidx.compose.material.MaterialTheme
 import androidx.compose.ui.Modifier
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import androidx.compose.material.Text
 import androidx.compose.runtime.*
@@ -119,6 +120,7 @@ private fun AdmissionSection(
         generalGetString(admissionStageStrId),
         memberCriterias,
         memberCriteria,
+        uiKey = Ui.MemberAdmission.Review,
         onSelected = { value ->
           onSelected(value)
         }
@@ -139,7 +141,7 @@ private fun ResetSaveButtons(reset: () -> Unit, save: () -> Unit, disabled: Bool
     SectionItemView(reset, disabled = disabled) {
       Text(stringResource(MR.strings.reset_verb), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
     }
-    SectionItemView(save, disabled = disabled) {
+    SectionItemView(save, disabled = disabled, uiKey = Ui.MemberAdmission.Save) {
       Text(stringResource(MR.strings.save_and_notify_group_members), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
     }
   }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/MemberSupportView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/MemberSupportView.kt
index b05d425c46..9688f4a09a 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/MemberSupportView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/MemberSupportView.kt
@@ -22,6 +22,7 @@ import dev.icerock.moko.resources.compose.stringResource
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.chat.*
 import chat.simplex.common.views.chat.item.ItemAction
@@ -125,7 +126,7 @@ private fun ModalData.MemberSupportViewLayout(
     } else {
       item {
         SectionItemView(padding = PaddingValues(start = 14.dp, end = DEFAULT_PADDING_HALF)) {
-          MemberListSearchRowView(searchText)
+          MemberListSearchRowView(searchText, uiKey = Ui.MemberSupport.Search)
         }
       }
       items(filteredmembersWithChats.value, key = { it.groupMemberId }) { member ->
@@ -146,7 +147,8 @@ private fun ModalData.MemberSupportViewLayout(
           },
           longClick = { showMenu.value = true },
           minHeight = 54.dp,
-          padding = PaddingValues(horizontal = DEFAULT_PADDING)
+          padding = PaddingValues(horizontal = DEFAULT_PADDING),
+          uiKey = Ui.MemberSupport.Row(member.groupMemberId)
         ) {
           Box(contentAlignment = Alignment.CenterStart) {
             DropDownMenuForSupportChat(chat.remoteHostId, member, groupInfo, showMenu)
@@ -270,18 +272,18 @@ fun SupportChatRow(member: GroupMember, isChannel: Boolean) {
 private fun DropDownMenuForSupportChat(rhId: Long?, member: GroupMember, groupInfo: GroupInfo, showMenu: MutableState<Boolean>) {
   DefaultDropdownMenu(showMenu) {
     if (member.memberPending) {
-      ItemAction(stringResource(MR.strings.accept_pending_member_button), painterResource(MR.images.ic_check), color = MaterialTheme.colors.primary, onClick = {
+      ItemAction(stringResource(MR.strings.accept_pending_member_button), painterResource(MR.images.ic_check), color = MaterialTheme.colors.primary, uiKey = Ui.MemberSupport.RowMenu(member.groupMemberId, "accept"), onClick = {
         acceptMemberDialog(rhId, groupInfo, member)
         showMenu.value = false
       })
     } else {
       if (member.supportChatNotRead) {
-        ItemAction(stringResource(MR.strings.mark_read), painterResource(MR.images.ic_check), color = MaterialTheme.colors.primary, onClick = {
+        ItemAction(stringResource(MR.strings.mark_read), painterResource(MR.images.ic_check), color = MaterialTheme.colors.primary, uiKey = Ui.MemberSupport.RowMenu(member.groupMemberId, "markRead"), onClick = {
           markSupportChatRead(rhId, groupInfo, member)
           showMenu.value = false
         })
       }
-      ItemAction(stringResource(MR.strings.delete_member_support_chat_button), painterResource(MR.images.ic_delete), color = MaterialTheme.colors.error, onClick = {
+      ItemAction(stringResource(MR.strings.delete_member_support_chat_button), painterResource(MR.images.ic_delete), color = MaterialTheme.colors.error, uiKey = Ui.MemberSupport.RowMenu(member.groupMemberId, "delete"), onClick = {
         deleteMemberSupportChatDialog(rhId, groupInfo, member)
         showMenu.value = false
       })
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/WelcomeMessageView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/WelcomeMessageView.kt
index ef847c93cb..a81355b828 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/WelcomeMessageView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/WelcomeMessageView.kt
@@ -22,7 +22,9 @@ import dev.icerock.moko.resources.compose.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import chat.simplex.common.model.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.DEFAULT_PADDING
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.chat.item.MarkdownText
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.model.ChatModel
@@ -99,7 +101,7 @@ private fun GroupWelcomeLayout(
         val focusRequester = remember { FocusRequester() }
         TextEditor(
           wt,
-          Modifier.height(140.dp), stringResource(MR.strings.enter_welcome_message),
+          Modifier.height(140.dp).ui(Ui.Welcome.Text), stringResource(MR.strings.enter_welcome_message),
           focusRequester = focusRequester
         )
         LaunchedEffect(Unit) {
@@ -144,7 +146,7 @@ private fun GroupWelcomeLayout(
 @Composable
 private fun TextPreview(text: String, linkMode: SimplexLinkMode, markdown: Boolean = true) {
   val uriHandler = LocalUriHandler.current
-  Column {
+  Column(Modifier.ui(Ui.Welcome.Preview)) {
     SelectionContainer(Modifier.fillMaxWidth()) {
       val parsed = if (markdown) remember(text) { parseToMarkdownText(text) } else null
       MarkdownText(
@@ -164,7 +166,7 @@ private fun TextPreview(text: String, linkMode: SimplexLinkMode, markdown: Boole
 @Composable
 private fun SaveButton(save: () -> Unit, disabled: Boolean) {
   SectionView {
-    SectionItemView(save, disabled = disabled) {
+    SectionItemView(save, disabled = disabled, uiKey = Ui.Welcome.Save) {
       Text(stringResource(MR.strings.save_and_update_group_profile), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
     }
   }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/CIGroupInvitationView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/CIGroupInvitationView.kt
index 14ecd723b9..f5ca909a17 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/CIGroupInvitationView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/CIGroupInvitationView.kt
@@ -16,7 +16,9 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.model.*
 import chat.simplex.res.*
@@ -86,10 +88,10 @@ fun CIGroupInvitationView(
   val sentColor = MaterialTheme.appColors.sentMessage
   val receivedColor = MaterialTheme.appColors.receivedMessage
   Surface(
-    modifier = if (action && !inProgress.value) Modifier.clickable(onClick = {
+    modifier = (if (action && !inProgress.value) Modifier.clickable(onClick = {
       inProgress.value = true
       joinGroup(groupInvitation.groupId) { inProgress.value = false }
-    }) else Modifier,
+    }) else Modifier).ui(Ui.Chat.Item(ci.id).part("join")),
     shape = RoundedCornerShape(18.dp),
     color = if (sent) sentColor else receivedColor,
     contentColor = LocalContentColor.current
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/CIImageView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/CIImageView.kt
index a49884beeb..785d057d92 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/CIImageView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/CIImageView.kt
@@ -24,7 +24,9 @@ import chat.simplex.common.views.helpers.*
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.theme.DEFAULT_MAX_IMAGE_WIDTH
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.chat.chatViewScrollState
 import chat.simplex.res.*
 import dev.icerock.moko.resources.StringResource
@@ -38,6 +40,7 @@ fun CIImageView(
   imageProvider: () -> ImageGalleryProvider,
   showMenu: MutableState<Boolean>,
   smallView: Boolean,
+  uiKey: UiKey? = null,
   receiveFile: (Long) -> Unit
 ) {
   val blurred = remember { mutableStateOf(appPrefs.privacyMediaBlurRadius.get() > 0) }
@@ -101,13 +104,14 @@ fun CIImageView(
   }
 
   @Composable
-  fun imageView(imageBitmap: ImageBitmap, onClick: () -> Unit) {
+  fun imageView(imageBitmap: ImageBitmap, key: UiKey? = null, onClick: () -> Unit) {
     Image(
       imageBitmap,
       contentDescription = stringResource(MR.strings.image_descr),
       // .width(DEFAULT_MAX_IMAGE_WIDTH) is a hack for image to increase IntrinsicSize of FramedItemView
       // if text is short and take all available width if text is long
       modifier = Modifier
+        .ui(key)
         .width(if (imageBitmap.width * 0.97 <= imageBitmap.height) imageViewFullWidth() * 0.75f else DEFAULT_MAX_IMAGE_WIDTH)
         .combinedClickable(
           onLongClick = { showMenu.value = true },
@@ -132,6 +136,7 @@ fun CIImageView(
         // .width(DEFAULT_MAX_IMAGE_WIDTH) is a hack for image to increase IntrinsicSize of FramedItemView
         // if text is short and take all available width if text is long
         modifier = Modifier
+          .ui(uiKey)
           .width(if (painter.intrinsicSize.width * 0.97 <= painter.intrinsicSize.height) imageViewFullWidth() * 0.75f else DEFAULT_MAX_IMAGE_WIDTH)
           .combinedClickable(
             onLongClick = { showMenu.value = true },
@@ -224,7 +229,7 @@ fun CIImageView(
       val (imageBitmap, data, _) = loaded
       SimpleAndAnimatedImageView(data, imageBitmap, file, imageProvider, smallView, blurred, @Composable { painter, onClick -> ImageView(painter, image, onClick) })
     } else {
-      imageView(previewBitmap, onClick = {
+      imageView(previewBitmap, key = uiKey?.part("preview"), onClick = {
         if (file != null) {
           when {
             file.fileStatus is CIFileStatus.RcvInvitation || file.fileStatus is CIFileStatus.RcvAborted ->
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.kt
index 52f169e136..b106b640fc 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.kt
@@ -224,7 +224,8 @@ fun ChatItemView(
                     }
                   },
                   lineLimit = 1,
-                  color = if (m.onClick == null) MaterialTheme.colors.secondary else MenuTextColor
+                  color = if (m.onClick == null) MaterialTheme.colors.secondary else MenuTextColor,
+                  uiKey = Ui.Chat.ReactionMember(cItem.id, m.name)
                 )
               }
             }
@@ -273,6 +274,7 @@ fun ChatItemView(
       IconButton(
         onClick,
         Modifier
+          .ui(Ui.Chat.Item(cItem.id).part("goTo"))
           .padding(start = if (alignStart) 0.dp else DEFAULT_PADDING_HALF + 3.dp, end = if (alignStart) DEFAULT_PADDING_HALF + 3.dp else 0.dp)
           .then(if (fullyVisible) Modifier.background(mixedBackgroundColor, CircleShape) else Modifier)
           .size(22.dp),
@@ -427,7 +429,7 @@ fun ChatItemView(
                     }
 
                     if (copyAndShareAllowed) {
-                      ItemAction(stringResource(MR.strings.share_verb), painterResource(MR.images.ic_share), onClick = {
+                      ItemAction(stringResource(MR.strings.share_verb), painterResource(MR.images.ic_share), uiKey = Ui.Chat.ItemMenu(cItem.id, "share"), onClick = {
                         var fileSource = getLoadedFileSource(cItem.file)
                         val shareIfExists = {
                           when (val f = fileSource) {
@@ -446,7 +448,7 @@ fun ChatItemView(
                       })
                     }
                     if (copyAndShareAllowed) {
-                      ItemAction(stringResource(MR.strings.copy_verb), painterResource(MR.images.ic_content_copy), onClick = {
+                      ItemAction(stringResource(MR.strings.copy_verb), painterResource(MR.images.ic_content_copy), uiKey = Ui.Chat.ItemMenu(cItem.id, "copy"), onClick = {
                         copyItemToClipboard(cItem, clipboard)
                         showMenu.value = false
                       })
@@ -482,10 +484,10 @@ fun ChatItemView(
                     }
                     ItemInfoAction(cInfo, cItem, showItemDetails, showMenu)
                     if (revealed.value) {
-                      HideItemAction(revealed, showMenu, reveal)
+                      HideItemAction(revealed, showMenu, Ui.Chat.ItemMenu(cItem.id, "hide"), reveal)
                     }
                     if (cItem.meta.itemDeleted == null && cItem.file != null && cItem.file.cancelAction != null && !cItem.localNote) {
-                      CancelFileItemAction(cItem.file.fileId, showMenu, cancelFile = cancelFile, cancelAction = cItem.file.cancelAction)
+                      CancelFileItemAction(cItem.file.fileId, showMenu, Ui.Chat.ItemMenu(cItem.id, "cancelFile"), cancelFile = cancelFile, cancelAction = cItem.file.cancelAction)
                     }
                     if (!(live && cItem.meta.isLive) && !preview) {
                       DeleteItemAction(chatsCtx, cInfo, cItem, revealed, showMenu, questionText = deleteMessageQuestionText(), deleteMessage, deleteMessages)
@@ -507,11 +509,11 @@ fun ChatItemView(
                 cItem.meta.itemDeleted != null -> {
                   DefaultDropdownMenu(showMenu) {
                     if (revealed.value) {
-                      HideItemAction(revealed, showMenu, reveal)
+                      HideItemAction(revealed, showMenu, reveal = reveal)
                     } else if (!cItem.isDeletedContent) {
-                      RevealItemAction(revealed, showMenu, reveal)
+                      RevealItemAction(revealed, showMenu, reveal = reveal)
                     } else if (range.value != null) {
-                      ExpandItemAction(revealed, showMenu, reveal)
+                      ExpandItemAction(revealed, showMenu, Ui.Chat.ItemMenu(cItem.id, "expand"), reveal)
                     }
                     ItemInfoAction(cInfo, cItem, showItemDetails, showMenu)
                     DeleteItemAction(chatsCtx, cInfo, cItem, revealed, showMenu, questionText = deleteMessageQuestionText(), deleteMessage, deleteMessages)
@@ -534,9 +536,9 @@ fun ChatItemView(
                 cItem.mergeCategory != null && ((range.value?.count() ?: 0) > 1 || revealed.value) -> {
                   DefaultDropdownMenu(showMenu) {
                     if (revealed.value) {
-                      ShrinkItemAction(revealed, showMenu, reveal)
+                      ShrinkItemAction(revealed, showMenu, Ui.Chat.ItemMenu(cItem.id, "collapse"), reveal)
                     } else {
-                      ExpandItemAction(revealed, showMenu, reveal)
+                      ExpandItemAction(revealed, showMenu, Ui.Chat.ItemMenu(cItem.id, "expand"), reveal)
                     }
                     DeleteItemAction(chatsCtx, cInfo, cItem, revealed, showMenu, questionText = deleteMessageQuestionText(), deleteMessage, deleteMessages)
                     if (cItem.canBeDeletedForSelf) {
@@ -561,7 +563,7 @@ fun ChatItemView(
             fun MarkedDeletedItemDropdownMenu() {
               DefaultDropdownMenu(showMenu) {
                 if (!cItem.isDeletedContent) {
-                  RevealItemAction(revealed, showMenu, reveal)
+                  RevealItemAction(revealed, showMenu, Ui.Chat.ItemMenu(cItem.id, "reveal"), reveal)
                 }
                 ItemInfoAction(cInfo, cItem, showItemDetails, showMenu)
                 DeleteItemAction(chatsCtx, cInfo, cItem, revealed, showMenu, questionText = deleteMessageQuestionText(), deleteMessage, deleteMessages)
@@ -660,11 +662,11 @@ fun ChatItemView(
               MarkedDeletedItemView(chatsCtx, cItem, cInfo, cInfo.timedMessagesTTL, revealed, showViaProxy = showViaProxy, showTimestamp = showTimestamp)
               DefaultDropdownMenu(showMenu) {
                 if (revealed.value) {
-                  HideItemAction(revealed, showMenu, reveal)
+                  HideItemAction(revealed, showMenu, reveal = reveal)
                 } else if (!cItem.isDeletedContent) {
-                  RevealItemAction(revealed, showMenu, reveal)
+                  RevealItemAction(revealed, showMenu, reveal = reveal)
                 } else if (range.value != null) {
-                  ExpandItemAction(revealed, showMenu, reveal)
+                  ExpandItemAction(revealed, showMenu, Ui.Chat.ItemMenu(cItem.id, "expand"), reveal)
                 }
                 ItemInfoAction(cInfo, cItem, showItemDetails, showMenu)
                 DeleteItemAction(chatsCtx, cInfo, cItem, revealed, showMenu, questionText = generalGetString(MR.strings.delete_message_cannot_be_undone_warning), deleteMessage, deleteMessages)
@@ -837,12 +839,14 @@ expect fun SaveContentItemAction(cItem: ChatItem, saveFileLauncher: FileChooserL
 fun CancelFileItemAction(
   fileId: Long,
   showMenu: MutableState<Boolean>,
+  uiKey: UiKey? = null,
   cancelFile: (Long) -> Unit,
   cancelAction: CancelAction
 ) {
   ItemAction(
     stringResource(cancelAction.uiActionId),
     painterResource(MR.images.ic_close),
+    uiKey = uiKey,
     onClick = {
       showMenu.value = false
       cancelFileAlertDialog(fileId, cancelFile = cancelFile, cancelAction = cancelAction)
@@ -861,6 +865,7 @@ fun ItemInfoAction(
   ItemAction(
     stringResource(MR.strings.info_menu),
     painterResource(MR.images.ic_info),
+    uiKey = Ui.Chat.ItemMenu(cItem.id, "info"),
     onClick = {
       showItemDetails(cInfo, cItem)
       showMenu.value = false
@@ -956,10 +961,11 @@ fun SelectItemAction(
 }
 
 @Composable
-private fun RevealItemAction(revealed: State<Boolean>, showMenu: MutableState<Boolean>, reveal: (Boolean) -> Unit) {
+private fun RevealItemAction(revealed: State<Boolean>, showMenu: MutableState<Boolean>, uiKey: UiKey? = null, reveal: (Boolean) -> Unit) {
   ItemAction(
     stringResource(MR.strings.reveal_verb),
     painterResource(MR.images.ic_visibility),
+    uiKey = uiKey,
     onClick = {
       reveal(true)
       showMenu.value = false
@@ -968,10 +974,11 @@ private fun RevealItemAction(revealed: State<Boolean>, showMenu: MutableState<Bo
 }
 
 @Composable
-private fun HideItemAction(revealed: State<Boolean>, showMenu: MutableState<Boolean>, reveal: (Boolean) -> Unit) {
+private fun HideItemAction(revealed: State<Boolean>, showMenu: MutableState<Boolean>, uiKey: UiKey? = null, reveal: (Boolean) -> Unit) {
   ItemAction(
     stringResource(MR.strings.hide_verb),
     painterResource(MR.images.ic_visibility_off),
+    uiKey = uiKey,
     onClick = {
       reveal(false)
       showMenu.value = false
@@ -980,10 +987,11 @@ private fun HideItemAction(revealed: State<Boolean>, showMenu: MutableState<Bool
 }
 
 @Composable
-private fun ExpandItemAction(revealed: State<Boolean>, showMenu: MutableState<Boolean>, reveal: (Boolean) -> Unit) {
+private fun ExpandItemAction(revealed: State<Boolean>, showMenu: MutableState<Boolean>, uiKey: UiKey? = null, reveal: (Boolean) -> Unit) {
   ItemAction(
     stringResource(MR.strings.expand_verb),
     painterResource(MR.images.ic_expand_all),
+    uiKey = uiKey,
     onClick = {
       reveal(true)
       showMenu.value = false
@@ -992,10 +1000,11 @@ private fun ExpandItemAction(revealed: State<Boolean>, showMenu: MutableState<Bo
 }
 
 @Composable
-private fun ShrinkItemAction(revealed: State<Boolean>, showMenu: MutableState<Boolean>, reveal: (Boolean) -> Unit) {
+private fun ShrinkItemAction(revealed: State<Boolean>, showMenu: MutableState<Boolean>, uiKey: UiKey? = null, reveal: (Boolean) -> Unit) {
   ItemAction(
     stringResource(MR.strings.hide_verb),
     painterResource(MR.images.ic_collapse_all),
+    uiKey = uiKey,
     onClick = {
       reveal(false)
       showMenu.value = false
@@ -1012,6 +1021,7 @@ private fun ReportItemAction(
   ItemAction(
     stringResource(MR.strings.report_verb),
     painterResource(MR.images.ic_flag),
+    uiKey = Ui.Chat.ItemMenu(cItem.id, "report"),
     onClick = {
       AlertManager.shared.showAlertDialogButtons(
         title = generalGetString(MR.strings.report_reason_alert_title),
@@ -1032,13 +1042,13 @@ private fun ReportItemAction(
                 )
               }
               AlertManager.shared.hideAlert()
-            }) {
+            }, uiKey = Ui.Chat.ReportReason(reason.text)) {
               Text(reason.text, Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.error)
             }
           }
           SectionItemView({
             AlertManager.shared.hideAlert()
-          }) {
+          }, uiKey = Ui.Alert.Dismiss(Ui.AlertSource.Shared)) {
             Text(stringResource(MR.strings.cancel_verb), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
           }
         }
@@ -1054,6 +1064,7 @@ private fun ArchiveReportItemAction(id: Long, allowForAll: Boolean, showMenu: Mu
   ItemAction(
     stringResource(MR.strings.archive_report),
     painterResource(MR.images.ic_inventory_2),
+    uiKey = Ui.Chat.ItemMenu(id, "archive"),
     onClick = {
       showArchiveReportsAlert(listOf(id), allowForAll, archiveReports)
       showMenu.value = false
@@ -1074,7 +1085,7 @@ fun showArchiveReportsAlert(ids: List<Long>, allowForAll: Boolean, archiveReport
       SectionItemView({
         AlertManager.shared.hideAlert()
         archiveReports(ids, false)
-      }) {
+      }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "archiveForMe")) {
         Text(
           generalGetString(MR.strings.report_archive_for_me),
           Modifier.fillMaxWidth(),
@@ -1087,7 +1098,7 @@ fun showArchiveReportsAlert(ids: List<Long>, allowForAll: Boolean, archiveReport
         SectionItemView({
           AlertManager.shared.hideAlert()
           archiveReports(ids, true)
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "archiveForAll")) {
           Text(
             stringResource(MR.strings.report_archive_for_all_moderators),
             Modifier.fillMaxWidth(),
@@ -1446,13 +1457,13 @@ fun deleteMessagesAlertDialog(itemIds: List<Long>, questionText: String, forAll:
         TextButton(onClick = {
           deleteMessages(itemIds, false)
           AlertManager.shared.hideAlert()
-        }) { Text(stringResource(if (editorial) MR.strings.from_history else MR.strings.for_me_only), color = MaterialTheme.colors.error) }
+        }, Modifier.ui(Ui.Alert.Option(Ui.AlertSource.Shared, "forMe"))) { Text(stringResource(if (editorial) MR.strings.from_history else MR.strings.for_me_only), color = MaterialTheme.colors.error) }
 
         if (forAll) {
           TextButton(onClick = {
             deleteMessages(itemIds, true)
             AlertManager.shared.hideAlert()
-          }) { Text(stringResource(MR.strings.for_everybody), color = MaterialTheme.colors.error) }
+          }, Modifier.ui(Ui.Alert.Option(Ui.AlertSource.Shared, "forEveryone"))) { Text(stringResource(MR.strings.for_everybody), color = MaterialTheme.colors.error) }
         }
       }
     }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/FramedItemView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/FramedItemView.kt
index 8b9bd15cef..5647b8cf83 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/FramedItemView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/FramedItemView.kt
@@ -369,7 +369,7 @@ fun FramedItemView(
           } else {
             when (val mc = ci.content.msgContent) {
               is MsgContent.MCImage -> {
-                CIImageView(image = mc.image, file = ci.file, imageProvider ?: return@PriorityLayout, showMenu, false, receiveFile)
+                CIImageView(image = mc.image, file = ci.file, imageProvider ?: return@PriorityLayout, showMenu, false, Ui.Chat.ItemFile(ci.id), receiveFile)
                 if (mc.text == "" && !ci.meta.isLive) {
                   metaColor = Color.White
                 } else {
@@ -406,7 +406,7 @@ fun FramedItemView(
               is MsgContent.MCChat -> {
                 val hasText = mc.text != mc.chatLink.connLinkStr
                 Box(
-                  Modifier.combinedClickable(
+                  Modifier.ui(Ui.Chat.Item(ci.id).part("chatLink")).combinedClickable(
                     onClick = {
                       withBGApi { planAndConnect(chat.remoteHostId, mc.chatLink.connLinkStr, linkOwnerSig = mc.ownerSig, close = null) }
                     },
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/ImageFullScreenView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/ImageFullScreenView.kt
index b1604adc84..5c32b13313 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/ImageFullScreenView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/item/ImageFullScreenView.kt
@@ -14,7 +14,9 @@ import androidx.compose.ui.input.pointer.*
 import androidx.compose.ui.layout.onGloballyPositioned
 import chat.simplex.common.model.CryptoFile
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.CurrentColors
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.chat.ProviderMedia
 import chat.simplex.common.views.helpers.*
 import kotlinx.coroutines.flow.distinctUntilChanged
@@ -77,6 +79,7 @@ fun ImageFullScreenView(imageProvider: () -> ImageGalleryProvider, close: () ->
     val index = index - firstValidPageBeforeScrollingToStart.value
     Column(
       Modifier
+        .ui(Ui.Chat.FullScreenMedia)
         .fillMaxSize()
         .background(Color.Black)
         .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null, onClick = goBack)
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ChatListNavLinkView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ChatListNavLinkView.kt
index e917d75d99..689123ed22 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ChatListNavLinkView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ChatListNavLinkView.kt
@@ -344,7 +344,7 @@ fun GroupMenuItems(
       ToggleNotificationsChatAction(chat, chatModel, groupInfo.chatSettings.enableNtfs.nextMode(true), showMenu)
       TagListAction(chat, showMenu)
       if (chat.chatStats.reportsCount > 0 && groupInfo.membership.memberRole >= GroupMemberRole.Moderator) {
-        ArchiveAllReportsItemAction(showMenu) {
+        ArchiveAllReportsItemAction(showMenu, Ui.ChatList.RowMenu(chat.id, "archiveReports", chat.remoteHostId)) {
           archiveAllReportsForMe(chat.remoteHostId, chat.chatInfo.apiId)
         }
       }
@@ -496,7 +496,8 @@ fun DeleteGroupAction(chat: Chat, groupInfo: GroupInfo, chatModel: ChatModel, sh
       deleteGroupDialog(chat, groupInfo, chatModel)
       showMenu.value = false
     },
-    color = Color.Red
+    color = Color.Red,
+    uiKey = Ui.ChatList.RowMenu(chat.id, "delete", chat.remoteHostId)
   )
 }
 
@@ -519,6 +520,7 @@ fun JoinGroupAction(
     if (chat.chatInfo.incognito) stringResource(MR.strings.join_group_incognito_button) else stringResource(MR.strings.join_group_button),
     if (chat.chatInfo.incognito) painterResource(MR.images.ic_theater_comedy_filled) else painterResource(MR.images.ic_login),
     color = if (chat.chatInfo.incognito) Indigo else MaterialTheme.colors.onBackground,
+    uiKey = Ui.ChatList.RowMenu(chat.id, "join", chat.remoteHostId),
     onClick = {
       joinGroup()
       showMenu.value = false
@@ -651,10 +653,11 @@ private fun InvalidDataView() {
 }
 
 @Composable
-private fun ArchiveAllReportsItemAction(showMenu: MutableState<Boolean>, archiveReports: () -> Unit) {
+private fun ArchiveAllReportsItemAction(showMenu: MutableState<Boolean>, uiKey: UiKey? = null, archiveReports: () -> Unit) {
   ItemAction(
     stringResource(MR.strings.archive_reports),
     painterResource(MR.images.ic_inventory_2),
+    uiKey = uiKey,
     onClick = {
       showArchiveAllReportsForMeAlert(archiveReports)
       showMenu.value = false
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ChatPreviewView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ChatPreviewView.kt
index 6482e21148..d6b21da571 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ChatPreviewView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ChatPreviewView.kt
@@ -357,7 +357,7 @@ fun ChatPreviewView(
       }
       is MsgContent.MCChat -> SmallContentPreview(borderColor = if (mc.chatLink.image != null) MaterialTheme.colors.onSurface.copy(alpha = 0.12f) else Color.Transparent) {
         Box(
-          Modifier.fillMaxSize().clickable { withBGApi { planAndConnect(chat.remoteHostId, mc.chatLink.connLinkStr, linkOwnerSig = mc.ownerSig, close = null) } },
+          Modifier.fillMaxSize().ui(Ui.ChatList.Row(chat.id, chat.remoteHostId).part("link")).clickable { withBGApi { planAndConnect(chat.remoteHostId, mc.chatLink.connLinkStr, linkOwnerSig = mc.ownerSig, close = null) } },
           contentAlignment = Alignment.Center
         ) {
           val image = mc.chatLink.image
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ServersSummaryView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ServersSummaryView.kt
index e44293ad55..4e8c339818 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ServersSummaryView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ServersSummaryView.kt
@@ -187,7 +187,8 @@ private fun SMPServerView(srvSumm: SMPServerSummary, statsStartedAt: Instant, rh
           statsStartedAt = statsStartedAt
         )
       }
-    }
+    },
+    uiKey = Ui.ServersSummary.SmpServer(serverAddress(srvSumm.smpServer))
   ) {
     Text(
       serverAddress(srvSumm.smpServer),
@@ -312,7 +313,8 @@ private fun SMPStatsView(stats: AgentSMPServerStatsData, statsStartedAt: Instant
           stats = stats,
           statsStartedAt = statsStartedAt)
         }
-      }
+      },
+      uiKey = Ui.ServersSummary.Details
     ) {
       Text(text = generalGetString(MR.strings.servers_info_details), color = MaterialTheme.colors.onBackground)
     }
@@ -817,6 +819,7 @@ fun ModalData.ServersSummaryView(rh: RemoteHostInfo?, serversSummary: MutableSta
                 selectedUserCategory,
                 icon = null,
                 enabled = remember { mutableStateOf(true) },
+                uiKey = Ui.ServersSummary.UserCategory,
                 onSelected = {
                   selectedUserCategory.value = it
                 }
@@ -928,7 +931,7 @@ fun ModalData.ServersSummaryView(rh: RemoteHostInfo?, serversSummary: MutableSta
 
 @Composable
 private fun ReconnectAllServersButton(rh: RemoteHostInfo?) {
-  SectionItemView(click = { reconnectAllServersAlert(rh) }) {
+  SectionItemView(click = { reconnectAllServersAlert(rh) }, uiKey = Ui.ServersSummary.ReconnectAll) {
     Text(
       stringResource(MR.strings.servers_info_reconnect_all_servers_button),
       color = MaterialTheme.colors.primary
@@ -957,7 +960,7 @@ private fun reconnectAllServersAlert(rh: RemoteHostInfo?) {
 
 @Composable
 private fun ResetStatisticsButton(rh: RemoteHostInfo?, resetStats: () -> Unit) {
-  SectionItemView(click = { resetStatisticsAlert(rh, resetStats) }) {
+  SectionItemView(click = { resetStatisticsAlert(rh, resetStats) }, uiKey = Ui.ServersSummary.ResetStats) {
     Text(
       stringResource(MR.strings.servers_info_reset_stats),
       color = MaterialTheme.colors.primary
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ShareListView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ShareListView.kt
index 023aea530f..a1e887f874 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ShareListView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ShareListView.kt
@@ -16,6 +16,7 @@ import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.themedBackground
 import chat.simplex.common.views.chat.topPaddingToContent
 import chat.simplex.common.views.newchat.ActiveProfilePicker
@@ -182,7 +183,8 @@ private fun ShareListToolbar(chatModel: ChatModel, stopped: Boolean, onSearchVal
           )
         }
       }
-    }
+    },
+    uiKey = Ui.Share.Bar
   )
 }
 
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/UserPicker.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/UserPicker.kt
index 51714edaf6..68f54aa328 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/UserPicker.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/UserPicker.kt
@@ -253,7 +253,8 @@ fun UserPicker(
               }
             }()
           }),
-          disabled = stopped
+          disabled = stopped,
+          uiKey = Ui.UserPicker.ChatPreferences
         )
       }
       if (appPlatform.isDesktop) {
@@ -388,7 +389,8 @@ private fun GlobalSettingsSection(
           ConnectDesktopView(close)
         }
       },
-      disabled = stopped
+      disabled = stopped,
+      uiKey = Ui.UserPicker.UseFromDesktop
     )
   } else {
     UserPickerOptionRow(
@@ -400,7 +402,8 @@ private fun GlobalSettingsSection(
           ConnectMobileView()
         }
       },
-      disabled = stopped
+      disabled = stopped,
+      uiKey = Ui.UserPicker.LinkMobile
     )
   }
 
@@ -544,7 +547,8 @@ private fun DevicePickerRow(
         icon = painterResource(MR.images.ic_smartphone_300),
         text = activeHost.hostDeviceName,
         actionButtonVisible = activeHost.sessionState is RemoteHostSessionState.Connected,
-        onActionButtonClick = { onRemoteHostActionButtonClick(activeHost) }
+        onActionButtonClick = { onRemoteHostActionButtonClick(activeHost) },
+        uiKey = Ui.UserPicker.Device(activeHost.remoteHostId)
       ) {
         onRemoteHostClick(activeHost, connecting)
       }
@@ -554,7 +558,8 @@ private fun DevicePickerRow(
       active = localDeviceActive,
       icon = painterResource(MR.images.ic_desktop),
       text = stringResource(MR.strings.this_device),
-      actionButtonVisible = false
+      actionButtonVisible = false,
+      uiKey = Ui.UserPicker.Device(null)
     ) {
       onLocalDeviceClick()
     }
@@ -567,7 +572,8 @@ private fun DevicePickerRow(
         icon = painterResource(MR.images.ic_smartphone_300),
         text = h.hostDeviceName,
         actionButtonVisible = h.sessionState is RemoteHostSessionState.Connected,
-        onActionButtonClick = { onRemoteHostActionButtonClick(h) }
+        onActionButtonClick = { onRemoteHostActionButtonClick(h) },
+        uiKey = Ui.UserPicker.Device(h.remoteHostId)
       ) {
         onRemoteHostClick(h, connecting)
       }
@@ -597,9 +603,11 @@ fun DevicePill(
   text: String,
   actionButtonVisible: Boolean,
   onActionButtonClick: (() -> Unit)? = null,
+  uiKey: UiKey? = null,
   onClick: () -> Unit) {
   Row(
     Modifier
+      .ui(uiKey)
       .clip(RoundedCornerShape(8.dp))
       .border(
         BorderStroke(1.dp, MaterialTheme.colors.secondaryVariant),
@@ -637,7 +645,7 @@ fun DevicePill(
         val interactionSource = remember { MutableInteractionSource() }
         val hovered = interactionSource.collectIsHoveredAsState().value
         Spacer(Modifier.width(DEFAULT_SPACE_AFTER_ICON * fontSizeSqrtMultiplier))
-        IconButton(onActionButtonClick, Modifier.requiredSize(16.dp * fontSizeSqrtMultiplier)) {
+        IconButton(onActionButtonClick, Modifier.ui(uiKey?.part("disconnect")).requiredSize(16.dp * fontSizeSqrtMultiplier)) {
           Icon(
             painterResource(if (hovered) MR.images.ic_wifi_off else MR.images.ic_wifi),
             null,
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/contacts/ContactListNavView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/contacts/ContactListNavView.kt
index 8c77d7560f..f6b76f449a 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/contacts/ContactListNavView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/contacts/ContactListNavView.kt
@@ -6,6 +6,7 @@ import dev.icerock.moko.resources.compose.painterResource
 import dev.icerock.moko.resources.compose.stringResource
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.views.chat.*
 import chat.simplex.common.views.chat.item.ItemAction
 import chat.simplex.common.views.chatlist.*
@@ -101,6 +102,7 @@ fun ContactListNavLinkView(chat: Chat, nextChatSelected: State<Boolean>, showDel
                 disabled,
                 selectedChat,
                 nextChatSelected,
+                uiKey = Ui.NewChat.Contact(chat.id),
             )
         }
         is ChatInfo.ContactRequest -> {
@@ -144,6 +146,7 @@ fun DeleteContactAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState
     ItemAction(
         stringResource(MR.strings.delete_contact_menu_action),
         painterResource(MR.images.ic_delete),
+        uiKey = Ui.NewChat.ContactMenu(chat.id, "delete"),
         onClick = {
             deleteContactDialog(chat, chatModel)
             showMenu.value = false
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.kt
index 8f22515370..beeb087b02 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.kt
@@ -32,7 +32,10 @@ import androidx.compose.ui.unit.*
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.theme.*
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.usersettings.SettingsActionItem
 import chat.simplex.res.*
@@ -130,7 +133,8 @@ fun DatabaseEncryptionLayout(
           useKeychain.value,
           initialRandomDBPassphrase.value,
           storedKey.value,
-          enabled = (!initialRandomDBPassphrase.value && !progressIndicator.value) || migration
+          enabled = (!initialRandomDBPassphrase.value && !progressIndicator.value) || migration,
+          uiKey = Ui.DbPassphrase.Save
         ) { checked ->
           if (checked) {
             setUseKeychain(true, useKeychain, migration)
@@ -151,7 +155,7 @@ fun DatabaseEncryptionLayout(
           PassphraseField(
             currentKey,
             generalGetString(MR.strings.current_passphrase),
-            modifier = Modifier.padding(horizontal = DEFAULT_PADDING),
+            modifier = Modifier.ui(Ui.DbPassphrase.Current).padding(horizontal = DEFAULT_PADDING),
             isValid = ::validKey,
             keyboardActions = KeyboardActions(onNext = { defaultKeyboardAction(ImeAction.Next) }),
           )
@@ -160,7 +164,7 @@ fun DatabaseEncryptionLayout(
         PassphraseField(
           newKey,
           generalGetString(MR.strings.new_passphrase),
-          modifier = Modifier.padding(horizontal = DEFAULT_PADDING),
+          modifier = Modifier.ui(Ui.DbPassphrase.New).padding(horizontal = DEFAULT_PADDING),
           showStrength = true,
           isValid = ::validKey,
           keyboardActions = KeyboardActions(onNext = { defaultKeyboardAction(ImeAction.Next) }),
@@ -192,7 +196,7 @@ fun DatabaseEncryptionLayout(
         PassphraseField(
           confirmNewKey,
           generalGetString(MR.strings.confirm_new_passphrase),
-          modifier = Modifier.padding(horizontal = DEFAULT_PADDING),
+          modifier = Modifier.ui(Ui.DbPassphrase.Confirm).padding(horizontal = DEFAULT_PADDING),
           isValid = { confirmNewKey.value == "" || newKey.value == confirmNewKey.value },
           contentType = newKeyContentType,
           keyboardActions = KeyboardActions(onDone = {
@@ -201,7 +205,7 @@ fun DatabaseEncryptionLayout(
           }),
         )
 
-        SectionItemViewSpaceBetween(onClickUpdate, disabled = disabled, minHeight = TextFieldDefaults.MinHeight) {
+        SectionItemViewSpaceBetween(onClickUpdate, disabled = disabled, minHeight = TextFieldDefaults.MinHeight, uiKey = Ui.DbPassphrase.Update) {
           Text(generalGetString(if (migration) MR.strings.set_passphrase else MR.strings.update_database_passphrase), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
         }
       }
@@ -257,6 +261,7 @@ expect fun SavePassphraseSetting(
   minHeight: Dp = TextFieldDefaults.MinHeight,
   enabled: Boolean,
   smallPadding: Boolean = true,
+  uiKey: UiKey? = null,
   onCheckedChange: (Boolean) -> Unit,
 )
 
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseView.kt
index 6abbf83226..ae85ca848d 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseView.kt
@@ -22,7 +22,10 @@ import androidx.compose.ui.unit.dp
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.model.ChatModel.controller
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.theme.*
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.usersettings.*
 import chat.simplex.common.platform.*
@@ -125,7 +128,7 @@ fun DatabaseLayout(
 
     if (!chatModel.desktopNoUserNoRemote) {
       SectionView(stringResource(MR.strings.messages_section_title)) {
-        TtlOptions(chatItemTTL, enabled = rememberUpdatedState(!stopped && !progressIndicator), onChatItemTTLSelected)
+        TtlOptions(chatItemTTL, enabled = rememberUpdatedState(!stopped && !progressIndicator), uiKey = Ui.Database.Ttl, onSelected = onChatItemTTLSelected)
       }
       SectionTextFooter(
         remember(currentUser?.displayName) {
@@ -149,7 +152,8 @@ fun DatabaseLayout(
         stringResource(MR.strings.database_passphrase_and_export),
         click = showDatabaseManagement,
         iconColor = if (unencrypted || (appPlatform.isDesktop && passphraseSaved)) WarningOrange else MaterialTheme.colors.secondary,
-        disabled = operationsDisabled
+        disabled = operationsDisabled,
+        uiKey = Ui.Database.Management
       )
     }
     SectionDividerSpaced()
@@ -158,7 +162,8 @@ fun DatabaseLayout(
       val deleteFilesDisabled = operationsDisabled || appFilesCountAndSize.value.first == 0
       SectionItemView(
         deleteAppFilesAndMedia,
-        disabled = deleteFilesDisabled
+        disabled = deleteFilesDisabled,
+        uiKey = Ui.Database.DeleteFiles
       ) {
         Text(
           stringResource(if (users.size > 1) MR.strings.delete_files_and_media_for_all_users else MR.strings.delete_files_and_media_all),
@@ -234,7 +239,8 @@ fun DatabaseManagementView() {
           stringResource(MR.strings.database_passphrase),
           click = { ModalManager.start.showModal(cardScreen = true) { DatabaseEncryptionView(chatModel, false) } },
           iconColor = if (unencrypted || (appPlatform.isDesktop && prefs.storeDBPassphrase.state.value)) WarningOrange else MaterialTheme.colors.secondary,
-          disabled = operationsDisabled
+          disabled = operationsDisabled,
+          uiKey = Ui.Database.Passphrase
         )
         if (appPlatform.isDesktop) {
           SettingsActionItem(
@@ -261,7 +267,8 @@ fun DatabaseManagementView() {
           },
           textColor = MaterialTheme.colors.primary,
           iconColor = MaterialTheme.colors.primary,
-          disabled = operationsDisabled
+          disabled = operationsDisabled,
+          uiKey = Ui.Database.Export
         )
         SettingsActionItem(
           painterResource(MR.images.ic_download),
@@ -269,7 +276,8 @@ fun DatabaseManagementView() {
           { withLongRunningApi { importArchiveLauncher.launch("application/zip") } },
           textColor = Color.Red,
           iconColor = Color.Red,
-          disabled = operationsDisabled
+          disabled = operationsDisabled,
+          uiKey = Ui.Database.Import
         )
         SettingsActionItem(
           painterResource(MR.images.ic_delete_forever),
@@ -284,7 +292,8 @@ fun DatabaseManagementView() {
           },
           textColor = Color.Red,
           iconColor = Color.Red,
-          disabled = operationsDisabled
+          disabled = operationsDisabled,
+          uiKey = Ui.Database.Delete
         )
       }
 
@@ -347,6 +356,7 @@ private fun setChatItemTTLAlert(
 fun TtlOptions(
   current: State<ChatItemTTL?>,
   enabled: State<Boolean>,
+  uiKey: UiKey? = null,
   onSelected: (ChatItemTTL?) -> Unit,
   default: State<ChatItemTTL>? = null
 ) {
@@ -370,6 +380,7 @@ fun TtlOptions(
     current,
     icon = null,
     enabled = enabled,
+    uiKey = uiKey,
     onSelected = onSelected
   )
 }
@@ -389,6 +400,7 @@ fun RunChatSetting(
   ) {
     DefaultSwitch(
       checked = !stopped,
+      modifier = Modifier.ui(Ui.Database.RunChat),
       onCheckedChange = { runChatSwitch ->
         if (runChatSwitch) {
           startChat()
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/CustomTimePicker.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/CustomTimePicker.kt
index ed10c0f86f..2bf40fda08 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/CustomTimePicker.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/CustomTimePicker.kt
@@ -9,6 +9,8 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.style.TextAlign
 import chat.simplex.common.model.CustomTimeUnit
 import chat.simplex.common.model.timeText
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.res.*
 
 @Composable
@@ -66,7 +68,8 @@ fun showCustomTimePickerDialog(
       SectionItemView({
         AlertManager.shared.hideAlert()
         confirmButtonAction(selection.value)
-      }
+      },
+        uiKey = Ui.TimePicker.Confirm
       ) {
         Text(
           confirmButtonText,
@@ -88,6 +91,7 @@ fun DropdownCustomTimePickerSettingRow(
   customPickerTitle: String,
   customPickerConfirmButtonText: String,
   customPickerTimeUnitsLimits: List<TimeUnitLimits> = TimeUnitLimits.defaultUnitsLimits,
+  uiKey: UiKey? = null,
   onSelected: (Int?) -> Unit
 ) {
   fun getValues(selectedValue: Int?): List<DropdownSelection> =
@@ -120,6 +124,8 @@ fun DropdownCustomTimePickerSettingRow(
       }
     },
     dropdownSelection,
+    uiKey = uiKey,
+    optionKey = { sel -> if (sel is DropdownSelection.DropdownValue) sel.value else "custom" },
     onSelected = { sel: DropdownSelection ->
       when (sel) {
         is DropdownSelection.DropdownValue -> updateValue(sel.value)
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/DefaultTopAppBar.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/DefaultTopAppBar.kt
index a6ff2d233c..51ad9c2502 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/DefaultTopAppBar.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/DefaultTopAppBar.kt
@@ -146,8 +146,8 @@ fun NavigationButtonClose(onButtonClicked: (() -> Unit)?, tintColor: Color = if
 }
 
 @Composable
-fun ShareButton(onButtonClicked: () -> Unit) {
-  IconButton(onButtonClicked) {
+fun ShareButton(uiKey: UiKey? = null, onButtonClicked: () -> Unit) {
+  IconButton(onButtonClicked, Modifier.ui(uiKey)) {
     Icon(
       painterResource(MR.images.ic_share), stringResource(MR.strings.share_verb), tint = MaterialTheme.colors.primary
     )
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/ExposedDropDownSettingRow.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/ExposedDropDownSettingRow.kt
index b646fc31fa..4858a8f485 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/ExposedDropDownSettingRow.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/ExposedDropDownSettingRow.kt
@@ -34,6 +34,7 @@ fun <T> ExposedDropDownSetting(
   minWidth: Dp = 200.dp,
   maxWidth: Dp = with(LocalDensity.current) { 180.sp.toDp() },
   uiKey: UiKey? = null,
+  optionKey: (T) -> Any? = { it },
   onSelected: (T) -> Unit
 ) {
   val expanded = remember { mutableStateOf(false) }
@@ -74,7 +75,7 @@ fun <T> ExposedDropDownSetting(
             onSelected(selectionOption.first)
             expanded.value = false
           },
-          modifier = Modifier.ui(uiKey?.option(selectionOption.first ?: "null")),
+          modifier = Modifier.ui(uiKey?.option(optionKey(selectionOption.first) ?: "null")),
           contentPadding = PaddingValues(horizontal = DEFAULT_PADDING * 1.5f)
         ) {
           Text(
@@ -170,9 +171,10 @@ fun <T> ExposedDropDownSettingRow(
   minWidth: Dp = 200.dp,
   maxWidth: Dp = with(LocalDensity.current) { 180.sp.toDp() },
   uiKey: UiKey? = null,
+  optionKey: (T) -> Any? = { it },
   onSelected: (T) -> Unit
 ) {
   SettingsActionItemWithContent(icon, title, iconColor = iconTint, disabled = !enabled.value) {
-    ExposedDropDownSetting(values, selection ,textColor, label = label, enabled = enabled, minWidth = minWidth, maxWidth = maxWidth, uiKey = uiKey, onSelected = onSelected)
+    ExposedDropDownSetting(values, selection ,textColor, label = label, enabled = enabled, minWidth = minWidth, maxWidth = maxWidth, uiKey = uiKey, optionKey = optionKey, onSelected = onSelected)
   }
 }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/Section.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/Section.kt
index d04b21a61e..a50e7ada70 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/Section.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/Section.kt
@@ -158,12 +158,13 @@ fun <T> SectionViewSelectable(
   title: String?,
   currentValue: State<T>,
   values: List<ValueTitleDesc<T>>,
+  uiKey: UiKey? = null,
   onSelected: (T) -> Unit,
 ) {
   SectionView(title) {
     Column {
       values.forEach { item ->
-        SectionItemViewSpaceBetween({ onSelected(item.value) }) {
+        SectionItemViewSpaceBetween({ onSelected(item.value) }, uiKey = uiKey?.let { k -> item.value?.let { k.option(it) } }) {
           Text(item.title)
           if (currentValue.value == item.value) {
             Icon(painterResource(MR.images.ic_check), item.title, tint = MaterialTheme.colors.primary)
@@ -181,6 +182,7 @@ fun <T> SectionViewSelectableCards(
   title: String?,
   currentValue: State<T>,
   values: List<ValueTitleDesc<T>>,
+  uiKey: UiKey? = null,
   onSelected: (T) -> Unit,
 ) {
   SectionView(title) {
@@ -190,7 +192,7 @@ fun <T> SectionViewSelectableCards(
         Spacer(Modifier.height(DEFAULT_PADDING * 2f))
       }
       values.forEach { item ->
-        SelectableCard(currentValue, item.value, item.title, item.description, onSelected)
+        SelectableCard(currentValue, item.value, item.title, item.description, icon = null, uiKey = uiKey?.option(item.value ?: "null"), onSelected = onSelected)
       }
     }
   }
@@ -301,9 +303,10 @@ fun <T> SectionItemWithValue(
   icon: Painter? = null,
   iconTint: Color = MaterialTheme.colors.secondary,
   enabled: State<Boolean> = mutableStateOf(true),
+  uiKey: UiKey? = null,
   onSelected: () -> Unit
 ) {
-  SettingsActionItemWithContent(icon = icon, text = title, iconColor = iconTint, click = if (enabled.value) onSelected else null, disabled = !enabled.value) {
+  SettingsActionItemWithContent(icon = icon, text = title, iconColor = iconTint, click = if (enabled.value) onSelected else null, disabled = !enabled.value, uiKey = uiKey) {
     Row(
       Modifier.padding(start = 10.dp),
       verticalAlignment = Alignment.CenterVertically,
@@ -443,8 +446,8 @@ fun InfoRowTwoValues(
 
 
 @Composable
-fun InfoRowEllipsis(title: String, value: String, onClick: () -> Unit) {
-  SectionItemViewSpaceBetween(onClick) {
+fun InfoRowEllipsis(title: String, value: String, uiKey: UiKey? = null, onClick: () -> Unit) {
+  SectionItemViewSpaceBetween(onClick, uiKey = uiKey) {
     val screenWidthDp = windowWidth()
     Text(title)
     Text(
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/SimpleButton.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/SimpleButton.kt
index 99f94e941c..117cf1e11e 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/SimpleButton.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/SimpleButton.kt
@@ -58,9 +58,10 @@ fun SimpleButton(
   text: String, icon: Painter,
   color: Color = MaterialTheme.colors.primary,
   disabled: Boolean,
+  uiKey: UiKey? = null,
   click: () -> Unit
 ) {
-  SimpleButtonFrame(click, disabled = disabled) {
+  SimpleButtonFrame(click, Modifier.ui(uiKey), disabled = disabled) {
     Icon(
       icon, text, tint = if (disabled) MaterialTheme.colors.secondary else color,
       modifier = Modifier.padding(end = 8.dp)
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/localauth/PasscodeView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/localauth/PasscodeView.kt
index 957eb099d9..e07eee69a9 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/localauth/PasscodeView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/localauth/PasscodeView.kt
@@ -11,6 +11,7 @@ import androidx.compose.ui.input.key.*
 import dev.icerock.moko.resources.compose.painterResource
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.DEFAULT_PADDING
 import chat.simplex.common.views.chat.group.ProgressIndicator
 import chat.simplex.common.views.helpers.SimpleButton
@@ -76,9 +77,9 @@ fun PasscodeView(
       }
       PasscodeEntry(passcode, true, Modifier.weight(1f, fill = false))
       Row(Modifier.heightIn(min = 70.dp), verticalAlignment = Alignment.CenterVertically) {
-        SimpleButton(generalGetString(MR.strings.cancel_verb), icon = painterResource(MR.images.ic_close), disabled = !buttonsEnabled.value, click = cancel)
+        SimpleButton(generalGetString(MR.strings.cancel_verb), icon = painterResource(MR.images.ic_close), disabled = !buttonsEnabled.value, uiKey = Ui.Passcode.Cancel, click = cancel)
         Spacer(Modifier.size(20.dp))
-        SimpleButton(submitLabel, icon = painterResource(MR.images.ic_done_filled), disabled = submitEnabled?.invoke(passcode.value) == false || passcode.value.length < 4 || !buttonsEnabled.value, click = submit)
+        SimpleButton(submitLabel, icon = painterResource(MR.images.ic_done_filled), disabled = submitEnabled?.invoke(passcode.value) == false || passcode.value.length < 4 || !buttonsEnabled.value, uiKey = Ui.Passcode.Submit, click = submit)
       }
     }
   }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/localauth/PasswordEntry.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/localauth/PasswordEntry.kt
index 9305e21cc4..62134a403f 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/localauth/PasswordEntry.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/localauth/PasswordEntry.kt
@@ -16,6 +16,9 @@ import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.*
 import chat.simplex.common.platform.appPlatform
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import chat.simplex.common.ui.ui
 import chat.simplex.res.*
 
 @Composable
@@ -41,7 +44,7 @@ fun PasscodeView(password: MutableState<String>) {
   var showPasscode by rememberSaveable { mutableStateOf(false) }
   Text(
     if (password.value.isEmpty()) "" else remember(password.value, showPasscode) { splitPassword(showPasscode, password.value) },
-    Modifier.padding(vertical = 10.dp).clickable { showPasscode = !showPasscode },
+    Modifier.ui(Ui.Passcode.Entered).padding(vertical = 10.dp).clickable { showPasscode = !showPasscode },
     style = MaterialTheme.typography.body1
   )
 }
@@ -57,13 +60,13 @@ private fun BoxWithConstraintsScope.VerticalPasswordGrid(password: MutableState<
     DigitsRow(s, 7, 8, 9, password)
     Divider()
     Row(Modifier.requiredHeight(s)) {
-      PasswordEdit(s, painterResource(MR.images.ic_close)) {
+      PasswordEdit(s, painterResource(MR.images.ic_close), Ui.Passcode.Clear) {
         password.value = ""
       }
       VerticalDivider()
       PasswordDigit(s, 0, password)
       VerticalDivider()
-      PasswordEdit(s, painterResource(MR.images.ic_backspace)) {
+      PasswordEdit(s, painterResource(MR.images.ic_backspace), Ui.Passcode.Backspace) {
         password.value = password.value.dropLast(1)
       }
     }
@@ -121,7 +124,7 @@ private fun PasswordDigit(size: Dp, d: Int, password: MutableState<String>) {
     if (password.value.length < 16) {
       password.value += s
     }
-  }) {
+  }, uiKey = Ui.Passcode.Digit(d)) {
     Text(
       s,
       style = TextStyle(
@@ -135,16 +138,16 @@ private fun PasswordDigit(size: Dp, d: Int, password: MutableState<String>) {
 }
 
 @Composable
-private fun PasswordEdit(size: Dp, image: Painter, action: () -> Unit) {
-  PasswordButton(size, action) {
+private fun PasswordEdit(size: Dp, image: Painter, uiKey: UiKey? = null, action: () -> Unit) {
+  PasswordButton(size, action, uiKey) {
     Icon(image, null, tint = MaterialTheme.colors.secondary)
   }
 }
 
 @Composable
-private fun PasswordButton(size: Dp, action: () -> Unit, content: @Composable BoxScope.() -> Unit) {
+private fun PasswordButton(size: Dp, action: () -> Unit, uiKey: UiKey? = null, content: @Composable BoxScope.() -> Unit) {
   return Box(
-    Modifier.size(size)
+    Modifier.ui(uiKey).size(size)
       .background(MaterialTheme.colors.background, RoundedCornerShape(50))
       .clickable { action() },
     contentAlignment = Alignment.Center
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/AddChannelView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/AddChannelView.kt
index 7ad3076640..e23fc81d3b 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/AddChannelView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/AddChannelView.kt
@@ -22,6 +22,7 @@ import androidx.compose.ui.unit.sp
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.getUserServers
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import androidx.compose.ui.layout.ContentScale
 import chat.simplex.common.BuildConfigCommon
@@ -310,7 +311,7 @@ private fun ProfileStepView(
           }
         }
         Box(Modifier.padding(horizontal = DEFAULT_PADDING)) {
-          ProfileNameField(displayName, "", { isValidDisplayName(it.trim()) }, focusRequester)
+          ProfileNameField(displayName, "", { isValidDisplayName(it.trim()) }, focusRequester, uiKey = Ui.NewChannel.Name)
         }
         Spacer(Modifier.height(8.dp))
 
@@ -333,7 +334,8 @@ private fun ProfileStepView(
           click = createChannel,
           textColor = MaterialTheme.colors.primary,
           iconColor = MaterialTheme.colors.primary,
-          disabled = !canCreate
+          disabled = !canCreate,
+          uiKey = Ui.NewChannel.Create
         )
 
         SectionTextFooter(
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/AddGroupView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/AddGroupView.kt
index 72d5816d76..72e909de7a 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/AddGroupView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/AddGroupView.kt
@@ -19,6 +19,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import chat.simplex.common.model.*
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.chat.group.AddGroupMembersView
 import chat.simplex.common.views.chatlist.setGroupMembers
@@ -141,7 +142,7 @@ fun AddGroupLayout(
             )
             if (!isValidDisplayName(displayName.value.trim())) {
               Spacer(Modifier.size(DEFAULT_PADDING_HALF))
-              IconButton({ showInvalidNameAlert(mkValidName(displayName.value.trim()), displayName) }, Modifier.size(20.dp)) {
+              IconButton({ showInvalidNameAlert(mkValidName(displayName.value.trim()), displayName) }, Modifier.size(20.dp).ui(Ui.NewGroup.Name.part("invalid"))) {
                 Icon(painterResource(MR.images.ic_info), null, tint = MaterialTheme.colors.error)
               }
             }
@@ -169,7 +170,7 @@ fun AddGroupLayout(
             disabled = !canCreateProfile(displayName.value)
           )
 
-          IncognitoToggle(incognitoPref, incognito) { ModalManager.start.showModal { IncognitoView() } }
+          IncognitoToggle(incognitoPref, incognito, uiKey = Ui.NewGroup.Incognito) { ModalManager.start.showModal { IncognitoView() } }
 
           SectionTextFooter(
             buildAnnotatedString {
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/ConnectPlan.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/ConnectPlan.kt
index 8b145ef206..279fdf4bc3 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/ConnectPlan.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/ConnectPlan.kt
@@ -11,6 +11,7 @@ import androidx.compose.ui.unit.dp
 import dev.icerock.moko.resources.compose.stringResource
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.views.chat.subscriberCountStr
 import chat.simplex.common.views.chatlist.*
 import chat.simplex.common.views.helpers.*
@@ -471,7 +472,7 @@ fun askCurrentOrIncognitoProfileAlert(
           withBGApi {
             connectViaUri(chatModel, rhId, connectionLink, incognito = false, connectionPlan, close, cleanup)
           }
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.PrivacySensitive, "useCurrentProfile")) {
           Text(generalGetString(MR.strings.connect_use_current_profile), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = connectColor)
         }
         SectionItemView({
@@ -479,7 +480,7 @@ fun askCurrentOrIncognitoProfileAlert(
           withBGApi {
             connectViaUri(chatModel, rhId, connectionLink, incognito = true, connectionPlan, close, cleanup)
           }
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.PrivacySensitive, "useIncognito")) {
           Text(generalGetString(MR.strings.connect_use_new_incognito_profile), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = connectColor)
         }
         if (connectOtherButton != null && connectOtherLink != null) {
@@ -493,7 +494,7 @@ fun askCurrentOrIncognitoProfileAlert(
         SectionItemView({
           AlertManager.privacySensitive.hideAlert()
           cleanup?.invoke()
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.PrivacySensitive, "cancel")) {
           Text(stringResource(MR.strings.cancel_verb), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
         }
       }
@@ -606,7 +607,7 @@ fun ownGroupLinkConfirmConnect(
             AlertManager.privacySensitive.hideAlert()
             openKnownGroup(chatModel, rhId, close, groupInfo)
             cleanup?.invoke()
-          }) {
+          }, uiKey = Ui.Alert.Option(Ui.AlertSource.PrivacySensitive, "openGroup")) {
             Text(generalGetString(MR.strings.connect_plan_open_group), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
           }
           // Use current profile
@@ -615,7 +616,7 @@ fun ownGroupLinkConfirmConnect(
             withBGApi {
               connectViaUri(chatModel, rhId, connectionLink, incognito = false, connectionPlan, close, cleanup)
             }
-          }) {
+          }, uiKey = Ui.Alert.Option(Ui.AlertSource.PrivacySensitive, "useCurrentProfile")) {
             Text(generalGetString(MR.strings.connect_use_current_profile), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.error)
           }
           // Use new incognito profile
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/NewChatSheet.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/NewChatSheet.kt
index 00fbf2db3c..8acb8beb94 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/NewChatSheet.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/NewChatSheet.kt
@@ -30,6 +30,7 @@ import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.platform.*
 import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.UiKey
+import chat.simplex.common.ui.ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.chat.item.CIFileViewScope
 import chat.simplex.common.views.chat.topPaddingToContent
@@ -190,11 +191,11 @@ private fun ModalData.NewChatSheetLayout(
     NewChatAction(
       painterResource(MR.images.ic_qr_code),
       if (appPlatform.isAndroid) stringResource(MR.strings.scan_paste_link) else stringResource(MR.strings.paste_link),
-      null,
+      Ui.NewChat.PasteLink,
       scanPaste,
     ),
     NewChatAction(painterResource(MR.images.ic_group), stringResource(MR.strings.create_group_button), Ui.NewChat.CreateGroup, createGroup),
-    NewChatAction(painterResource(MR.images.ic_bigtop_updates), stringResource(MR.strings.create_channel_button), null, createChannel),
+    NewChatAction(painterResource(MR.images.ic_bigtop_updates), stringResource(MR.strings.create_channel_button), Ui.NewChat.CreateChannel, createChannel),
   )
 
   @Composable
@@ -234,7 +235,8 @@ private fun ModalData.NewChatSheetLayout(
                   })
                 }
               }
-            }
+            },
+            uiKey = Ui.NewChat.Archived
           ) {
             Icon(
               painterResource(MR.images.ic_inventory_2),
@@ -487,7 +489,7 @@ private fun ContactsSearchBar(
       tint = MaterialTheme.colors.secondary
     )
     SearchTextField(
-      Modifier.weight(1f).onFocusChanged { focused = it.hasFocus }.focusRequester(focusRequester),
+      Modifier.ui(Ui.NewChat.Search).weight(1f).onFocusChanged { focused = it.hasFocus }.focusRequester(focusRequester),
       placeholder = stringResource(MR.strings.search_or_paste_simplex_link),
       alwaysVisible = true,
       searchText = searchText,
@@ -572,7 +574,7 @@ private fun ContactsSearchBar(
 @Composable
 private fun ToggleFilterButton() {
   val pref = remember { appPrefs.showUnreadAndFavorites }
-  IconButton(onClick = { pref.set(!pref.get()) }) {
+  IconButton(onClick = { pref.set(!pref.get()) }, modifier = Modifier.ui(Ui.NewChat.Favorites)) {
     val sp16 = with(LocalDensity.current) { 16.sp.toDp() }
     Icon(
       painterResource(MR.images.ic_filter_list),
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/NewChatView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/NewChatView.kt
index e60059bc24..b8a4d6e673 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/NewChatView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/newchat/NewChatView.kt
@@ -372,7 +372,8 @@ fun ActiveProfilePicker(
         }
       },
         image = { ProfileImage(size = 42.dp, image = user.image) },
-        badge = user.profile.localBadge
+        badge = user.profile.localBadge,
+        uiKey = Ui.Link.Profile(user.userId)
     )
   }
 
@@ -544,6 +545,7 @@ private fun InviteView(rhId: Long?, connLinkInvitation: CreatedConnLink, contact
               showSearch = true,
               searchAlwaysVisible = true,
               onSearchValueChanged = { search.value = it },
+              uiKey = Ui.Link.ProfileBar,
               content = {
                 ActiveProfilePicker(
                   search = search,
@@ -593,7 +595,7 @@ fun ToggleShortLinkButton(short: MutableState<Boolean>) {
   if (appPrefs.developerTools.state.value) {
     Text(
       stringResource(if (short.value) MR.strings.full_link_button_text else MR.strings.short_link_button_text),
-      modifier = Modifier.clickable(
+      modifier = Modifier.ui(Ui.Link.ShortLinkToggle).clickable(
         interactionSource = remember { MutableInteractionSource() },
         indication = null
       ) { short.value = !short.value },
@@ -696,7 +698,7 @@ private fun PasteLinkView(rhId: Long?, pastedLink: MutableState<String>, showQRC
           text = generalGetString(MR.strings.the_text_you_pasted_is_not_a_link)
         )
       }
-    }) {
+    }, uiKey = Ui.Link.Paste) {
       Box(Modifier.weight(1f)) {
         Text(stringResource(MR.strings.tap_to_paste_link), color = MaterialTheme.colors.primary)
       }
@@ -858,6 +860,7 @@ fun strConnectTarget(str: String): ConnectTarget? {
 fun IncognitoToggle(
   incognitoPref: SharedPreference<Boolean>,
   incognito: MutableState<Boolean>,
+  uiKey: UiKey? = null,
   onClickInfo: () -> Unit
 ) {
   SettingsActionItemWithContent(
@@ -871,6 +874,7 @@ fun IncognitoToggle(
       stringResource(MR.strings.incognito),
       painterResource(MR.images.ic_info),
       stopped = false,
+      uiKey = uiKey,
       onClickInfo = onClickInfo,
       preference = incognitoPref,
       preferenceState = incognito
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/remote/ConnectDesktopView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/remote/ConnectDesktopView.kt
index 01b054fb28..c9389557ee 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/remote/ConnectDesktopView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/remote/ConnectDesktopView.kt
@@ -29,6 +29,8 @@ import chat.simplex.common.model.ChatController.switchToLocalSession
 import chat.simplex.common.model.ChatModel.connectedToRemote
 import chat.simplex.common.model.ChatModel.controller
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.chat.item.ItemAction
 import chat.simplex.common.views.helpers.*
@@ -202,7 +204,7 @@ private fun SearchingDesktop(deviceName: String, remoteCtrls: SnapshotStateList<
     Text(stringResource(MR.strings.waiting_for_desktop), fontStyle = FontStyle.Italic)
   }
   SectionDividerSpaced()
-  DisconnectButton(stringResource(MR.strings.scan_QR_code).replace('\n', ' '), MR.images.ic_qr_code, ::disconnectDesktop)
+  DisconnectButton(stringResource(MR.strings.scan_QR_code).replace('\n', ' '), MR.images.ic_qr_code, onClick = ::disconnectDesktop)
 }
 
 @Composable
@@ -271,7 +273,7 @@ private fun VerifySession(session: RemoteCtrlSession, rc: RemoteCtrlInfo?, sessC
 
   SectionView(stringResource(MR.strings.verify_code_with_desktop)) {
     SessionCodeText(sessCode)
-    SectionItemView({ verifyDesktopSessionCode(remoteCtrls, sessCode) }) {
+    SectionItemView({ verifyDesktopSessionCode(remoteCtrls, sessCode) }, uiKey = Ui.Remote.Confirm) {
       Icon(painterResource(MR.images.ic_check), generalGetString(MR.strings.confirm_verb), tint = MaterialTheme.colors.secondary)
       TextIconSpaced(false)
       Text(generalGetString(MR.strings.confirm_verb))
@@ -333,7 +335,7 @@ private fun ActiveSession(session: RemoteCtrlSession, rc: RemoteCtrlInfo, close:
   SectionDividerSpaced()
 
   SectionView {
-    DisconnectButton { disconnectDesktop(close) }
+    DisconnectButton(uiKey = Ui.Remote.Disconnect) { disconnectDesktop(close) }
   }
 }
 
@@ -381,6 +383,7 @@ private fun DesktopAddressView(sessionAddress: MutableState<String>) {
         click = {
           sessionAddress.value = clipboard.getText()?.text ?: ""
         },
+        uiKey = Ui.Remote.PasteAddress,
       )
     } else {
       Row(Modifier.padding(horizontal = DEFAULT_PADDING).fillMaxWidth()) {
@@ -408,6 +411,7 @@ private fun DesktopAddressView(sessionAddress: MutableState<String>) {
       click = {
         withBGApi { connectDesktopAddress(sessionAddress, sessionAddress.value) }
       },
+      uiKey = Ui.Remote.Connect,
     )
   }
 }
@@ -537,8 +541,8 @@ private fun verifyDesktopSessionCode(remoteCtrls: SnapshotStateList<RemoteCtrlIn
 }
 
 @Composable
-private fun DisconnectButton(label: String = generalGetString(MR.strings.disconnect_remote_host), icon: ImageResource = MR.images.ic_close, onClick: () -> Unit) {
-  SectionItemView(onClick) {
+private fun DisconnectButton(label: String = generalGetString(MR.strings.disconnect_remote_host), icon: ImageResource = MR.images.ic_close, uiKey: UiKey? = null, onClick: () -> Unit) {
+  SectionItemView(onClick, uiKey = uiKey) {
     Icon(painterResource(icon), label, tint = MaterialTheme.colors.secondary)
     TextIconSpaced(false)
     Text(label)
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/remote/ConnectMobileView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/remote/ConnectMobileView.kt
index 004611b842..d1ee6569a1 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/remote/ConnectMobileView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/remote/ConnectMobileView.kt
@@ -140,7 +140,7 @@ fun ConnectMobileLayout(
           }
         }
       }
-      SectionItemView(addMobileDevice) {
+      SectionItemView(addMobileDevice, uiKey = Ui.Remote.AddMobile) {
         Icon(painterResource(MR.images.ic_add), stringResource(MR.strings.link_a_mobile), tint = MaterialTheme.colors.primary)
         Spacer(Modifier.padding(horizontal = 10.dp))
         Text(stringResource(MR.strings.link_a_mobile), color = MaterialTheme.colors.primary)
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/Appearance.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/Appearance.kt
index b3ddb75d1c..a2b58de3e9 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/Appearance.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/Appearance.kt
@@ -337,6 +337,7 @@ object AppearanceScope {
         val checked = (background == null && (selectedWallpaper == null || selectedWallpaper == WallpaperType.Empty)) || selectedWallpaper?.samePreset(background) == true
         Box(
           Modifier
+            .ui(Ui.Appearance.Wallpaper(background?.filename ?: "none"))
             .size(width, height)
             .clip(RoundedCornerShape(percent = cornerRadius))
             .border(1.dp, if (checked) MaterialTheme.colors.primary.copy(0.8f) else MaterialTheme.colors.onBackground.copy(if (isInDarkTheme()) 0.2f else 0.1f), RoundedCornerShape(percent = cornerRadius))
@@ -375,6 +376,7 @@ object AppearanceScope {
             .size(width, height)
             .clip(RoundedCornerShape(percent = cornerRadius))
             .border(1.dp, if (type is WallpaperType.Image) MaterialTheme.colors.primary.copy(0.8f) else MaterialTheme.colors.onBackground.copy(0.1f), RoundedCornerShape(percent = cornerRadius))
+            .ui(Ui.Appearance.WallpaperImage)
             .clickable { onChooseType(WallpaperType.Image("", null, null)) },
           contentAlignment = Alignment.Center
         ) {
@@ -549,7 +551,7 @@ object AppearanceScope {
       )
       val type = MaterialTheme.wallpaper.type
       if (type is WallpaperType.Image && (themeUserDestination.value == null || perUserTheme.value.wallpaper?.imageFile != null)) {
-        SectionItemView(disabled = chatModel.remoteHostId != null && themeUserDestination.value != null, click = {
+        SectionItemView(disabled = chatModel.remoteHostId != null && themeUserDestination.value != null, uiKey = Ui.Appearance.RemoveImage, click = {
           if (themeUserDestination.value == null) {
             val defaultActiveTheme = ThemeManager.defaultActiveTheme(appPrefs.themeOverrides.get())
             ThemeManager.saveAndApplyWallpaper(baseTheme, null)
@@ -607,7 +609,7 @@ object AppearanceScope {
             UserWallpaperEditorModal(chatModel.remoteHostId(), user.first, close)
           }
         }
-      }) {
+      }, uiKey = Ui.Appearance.Customize) {
         Text(stringResource(MR.strings.customize_theme_title))
       }
     }
@@ -694,7 +696,7 @@ object AppearanceScope {
           SectionItemView({
             ThemeManager.resetAllThemeColors()
             saveThemeToDatabase(null)
-          }) {
+          }, uiKey = Ui.Appearance.ResetColors) {
             Text(generalGetString(MR.strings.reset_color), color = colors.primary)
           }
         }
@@ -717,7 +719,7 @@ object AppearanceScope {
           // Removing theme id without using custom serializer or data class
           theme.value = lines.subList(1, lines.size).joinToString("\n")
           withLongRunningApi { exportThemeLauncher.launch("simplex.theme") }
-        }) {
+        }, uiKey = Ui.Appearance.ExportTheme) {
           Text(generalGetString(MR.strings.export_theme), color = colors.primary)
         }
         val importThemeLauncher = rememberFileChooserLauncher(true) { to: URI? ->
@@ -730,7 +732,7 @@ object AppearanceScope {
           }
         }
         // Can not limit to YAML mime type since it's unsupported by Android
-        SectionItemView({ withLongRunningApi { importThemeLauncher.launch("*/*") } }) {
+        SectionItemView({ withLongRunningApi { importThemeLauncher.launch("*/*") } }, uiKey = Ui.Appearance.ImportTheme) {
           Text(generalGetString(MR.strings.import_theme), color = colors.primary)
         }
       }
@@ -755,6 +757,7 @@ object AppearanceScope {
     }
     Box(
       modifier = Modifier
+        .ui(Ui.UserPicker.ColorMode)
         .clip(CircleShape)
         .combinedClickable(
           onClick = {
@@ -931,6 +934,7 @@ object AppearanceScope {
         themeUserDest,
         icon = null,
         enabled = remember { mutableStateOf(true) },
+        uiKey = Ui.Appearance.ApplyTo,
         onSelected = { userId ->
           themeUserDest.value = userId
           if (userId != null) {
@@ -955,7 +959,7 @@ object AppearanceScope {
   @Composable
   fun CustomizeThemeColorsSection(currentTheme: ThemeManager.ActiveTheme, editColor: (ThemeColor) -> Unit) {
     SectionView(stringResource(MR.strings.theme_colors_section_title)) {
-      SectionItemViewSpaceBetween({ editColor(ThemeColor.PRIMARY) }) {
+      SectionItemViewSpaceBetween({ editColor(ThemeColor.PRIMARY) }, uiKey = Ui.Appearance.Accent) {
         val title = generalGetString(MR.strings.color_primary)
         Text(title)
         Icon(painterResource(MR.images.ic_circle_filled), title, tint = currentTheme.colors.primary)
@@ -1068,7 +1072,7 @@ object AppearanceScope {
             textFieldState.value = textFieldState.value.copy(hexTrimmed)
           }
           DefaultBasicTextField(
-            Modifier.fillMaxWidth(),
+            Modifier.fillMaxWidth().ui(Ui.Appearance.ColorHex),
             textFieldState,
             leadingIcon = {
               IconButton(onClick = { clipboard.shareText(hexTrimmed) }) {
@@ -1140,6 +1144,7 @@ object AppearanceScope {
       state,
       icon = null,
       enabled = remember { mutableStateOf(true) },
+      uiKey = Ui.Appearance.Language,
       onSelected = onSelected
     )
   }
@@ -1181,6 +1186,7 @@ object AppearanceScope {
       state,
       icon = null,
       enabled = remember { mutableStateOf(true) },
+      uiKey = Ui.Appearance.DarkModeColors,
       onSelected = { if (it != null) onSelected(it) }
     )
   }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/CallSettings.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/CallSettings.kt
index 1c55d1ebff..ff0fcac875 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/CallSettings.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/CallSettings.kt
@@ -106,6 +106,7 @@ fun SharedPreferenceToggleWithIcon(
   text: String,
   icon: Painter,
   stopped: Boolean = false,
+  uiKey: UiKey? = null,
   onClickInfo: () -> Unit,
   preference: SharedPreference<Boolean>,
   preferenceState: MutableState<Boolean>? = null
@@ -126,6 +127,7 @@ fun SharedPreferenceToggleWithIcon(
         preference.set(it)
         prefState.value = it
       },
+      modifier = Modifier.ui(uiKey),
       enabled = !stopped
     )
   }
@@ -137,6 +139,7 @@ fun SharedPreferenceToggleWithIcon(
   icon: Painter,
   onClickInfo: () -> Unit,
   checked: Boolean,
+  uiKey: UiKey? = null,
   onCheckedChange: (Boolean) -> Unit,
 ) {
   Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
@@ -151,6 +154,7 @@ fun SharedPreferenceToggleWithIcon(
     DefaultSwitch(
       checked = checked,
       onCheckedChange = onCheckedChange,
+      modifier = Modifier.ui(uiKey),
     )
   }
 }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/DeveloperView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/DeveloperView.kt
index fce6c69033..e962b5e06d 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/DeveloperView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/DeveloperView.kt
@@ -9,6 +9,7 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalUriHandler
 import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.platform.*
 import dev.icerock.moko.resources.compose.painterResource
@@ -31,7 +32,7 @@ fun DeveloperView(withAuth: (title: String, desc: String, block: () -> Unit) ->
       InstallTerminalAppItem(uriHandler)
       ChatConsoleItem { withAuth(generalGetString(MR.strings.auth_open_chat_console), generalGetString(MR.strings.auth_log_in_using_credential)) { ModalManager.start.showModalCloseable { TerminalView(false) } } }
       ResetHintsItem(unchangedHints)
-      SettingsPreferenceItem(painterResource(MR.images.ic_code), stringResource(MR.strings.show_developer_options), developerTools)
+      SettingsPreferenceItem(painterResource(MR.images.ic_code), stringResource(MR.strings.show_developer_options), developerTools, uiKey = Ui.DevTools.ShowOptions)
     }
     SectionTextFooter(
       generalGetString(if (devTools.value) MR.strings.show_dev_options else MR.strings.hide_dev_options) + " " +
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/NotificationsSettingsView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/NotificationsSettingsView.kt
index 083e5a07ae..0459b63f99 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/NotificationsSettingsView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/NotificationsSettingsView.kt
@@ -8,6 +8,7 @@ import androidx.compose.foundation.background
 import androidx.compose.material.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import androidx.compose.ui.text.AnnotatedString
 import dev.icerock.moko.resources.compose.stringResource
@@ -45,7 +46,7 @@ fun NotificationsSettingsLayout(
     AppBarTitle(stringResource(MR.strings.notifications))
     SectionView(null) {
       if (appPlatform == AppPlatform.ANDROID) {
-        SettingsActionItemWithContent(null, stringResource(MR.strings.settings_notifications_mode_title), showNotificationsMode) {
+        SettingsActionItemWithContent(null, stringResource(MR.strings.settings_notifications_mode_title), showNotificationsMode, uiKey = Ui.Notifications.Mode) {
           Text(
             modes.firstOrNull { it.value == notificationsMode.value }?.title ?: "",
             maxLines = 1,
@@ -70,7 +71,7 @@ fun NotificationsModeView(
   val modes = remember { notificationModes() }
   ColumnWithScrollBar {
     AppBarTitle(stringResource(MR.strings.settings_notifications_mode_title).lowercase().capitalize(Locale.current))
-    SectionViewSelectable(null, notificationsMode, modes, onNotificationsModeSelected)
+    SectionViewSelectable(null, notificationsMode, modes, Ui.Notifications.Mode, onNotificationsModeSelected)
     if (platform.androidIsXiaomiDevice() && (notificationsMode.value == NotificationsMode.PERIODIC || notificationsMode.value == NotificationsMode.SERVICE)) {
       SectionTextFooter(annotatedStringResource(MR.strings.xiaomi_ignore_battery_optimization))
     }
@@ -85,7 +86,7 @@ fun NotificationPreviewView(
   val previewModes = remember { notificationPreviewModes() }
   ColumnWithScrollBar {
     AppBarTitle(stringResource(MR.strings.settings_notification_preview_title))
-    SectionViewSelectable(null, notificationPreviewMode, previewModes, onNotificationPreviewModeSelected)
+    SectionViewSelectable(null, notificationPreviewMode, previewModes, onSelected = onNotificationPreviewModeSelected)
   }
 }
 
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/Preferences.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/Preferences.kt
index 6a06432c6d..1664030a17 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/Preferences.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/Preferences.kt
@@ -9,6 +9,7 @@ import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.MaterialTheme
 import androidx.compose.ui.Modifier
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import androidx.compose.material.Text
 import androidx.compose.runtime.*
@@ -122,6 +123,7 @@ private fun FeatureSection(feature: ChatFeature, allowFeature: State<FeatureAllo
       FeatureAllowed.values().map { it to it.text },
       allowFeature,
       icon = feature.icon,
+      uiKey = Ui.UserPrefs.Allow(feature),
       onSelected = onSelected,
     )
   }
@@ -143,6 +145,7 @@ private fun TimedMessagesFeatureSection(
       MaterialTheme.colors.secondary,
       checked = allowFeature.value == FeatureAllowed.ALWAYS || allowFeature.value == FeatureAllowed.YES,
       extraPadding = false,
+      uiKey = Ui.UserPrefs.Timed,
       onChange = onSelected
     )
     if (allowFeature.value == FeatureAllowed.ALWAYS || allowFeature.value == FeatureAllowed.YES) {
@@ -167,10 +170,10 @@ private fun TimedMessagesFeatureSection(
 @Composable
 private fun ResetSaveButtons(reset: () -> Unit, save: () -> Unit, disabled: Boolean) {
   SectionView {
-    SectionItemView(reset, disabled = disabled) {
+    SectionItemView(reset, disabled = disabled, uiKey = Ui.UserPrefs.Reset) {
       Text(stringResource(MR.strings.reset_verb), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
     }
-    SectionItemView(save, disabled = disabled) {
+    SectionItemView(save, disabled = disabled, uiKey = Ui.UserPrefs.Save) {
       Text(stringResource(MR.strings.save_and_notify_contacts), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
     }
   }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/PrivacySettings.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/PrivacySettings.kt
index 4abaa78370..b218f421b4 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/PrivacySettings.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/PrivacySettings.kt
@@ -1,6 +1,7 @@
 package chat.simplex.common.views.usersettings
 
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import SectionBottomSpacer
 import SectionItemView
 import SectionDividerSpaced
@@ -68,18 +69,20 @@ fun PrivacySettingsView(
         painterResource(MR.images.ic_travel_explore),
         stringResource(MR.strings.send_link_previews),
         chatModel.controller.appPrefs.privacyLinkPreviews,
+        uiKey = Ui.Privacy.LinkPreviews,
         onChange = { _ -> chatModel.controller.appPrefs.privacyLinkPreviewsShowAlert.set(false) } // to avoid showing alert to current users, show alert in v6.5
       )
       SettingsPreferenceItem(
         painterResource(MR.images.ic_link),
         stringResource(MR.strings.sanitize_links_toggle),
-        chatModel.controller.appPrefs.privacySanitizeLinks
+        chatModel.controller.appPrefs.privacySanitizeLinks,
+        uiKey = Ui.Privacy.SanitizeLinks
       )
     }
     SectionDividerSpaced()
 
     SectionView(stringResource(MR.strings.settings_section_title_files)) {
-      SettingsPreferenceItem(painterResource(MR.images.ic_image), stringResource(MR.strings.auto_accept_images), chatModel.controller.appPrefs.privacyAcceptImages)
+      SettingsPreferenceItem(painterResource(MR.images.ic_image), stringResource(MR.strings.auto_accept_images), chatModel.controller.appPrefs.privacyAcceptImages, uiKey = Ui.Privacy.AcceptImages)
       BlurRadiusOptions(remember { appPrefs.privacyMediaBlurRadius.state }) {
         appPrefs.privacyMediaBlurRadius.set(it)
       }
@@ -137,6 +140,7 @@ fun MorePrivacyView(chatModel: ChatModel) {
         painterResource(MR.images.ic_edit_note),
         stringResource(MR.strings.privacy_message_draft),
         chatModel.controller.appPrefs.privacySaveLastDraft,
+        uiKey = Ui.Privacy.SaveDraft,
         onChange = { saveDraft ->
           if (!saveDraft) {
             chatModel.draft.value = null
@@ -158,7 +162,7 @@ fun MorePrivacyView(chatModel: ChatModel) {
     SectionDividerSpaced()
 
     SectionView(stringResource(MR.strings.settings_section_title_files)) {
-      SettingsPreferenceItem(painterResource(MR.images.ic_lock), stringResource(MR.strings.encrypt_local_files), chatModel.controller.appPrefs.privacyEncryptLocalFiles, onChange = { enable ->
+      SettingsPreferenceItem(painterResource(MR.images.ic_lock), stringResource(MR.strings.encrypt_local_files), chatModel.controller.appPrefs.privacyEncryptLocalFiles, uiKey = Ui.Privacy.EncryptLocalFiles, onChange = { enable ->
         withBGApi { chatModel.controller.apiSetEncryptLocalFiles(enable) }
       })
       SettingsPreferenceItem(painterResource(MR.images.ic_security), stringResource(MR.strings.protect_ip_address), chatModel.controller.appPrefs.privacyAskToApproveRelays)
@@ -331,6 +335,7 @@ private fun BlurRadiusOptions(state: State<Int>, onSelected: (Int) -> Unit) {
     values,
     state,
     icon = painterResource(MR.images.ic_blur_on),
+    uiKey = Ui.Privacy.BlurMedia,
     onSelected = onSelected
   )
 }
@@ -354,7 +359,8 @@ private fun AutoAcceptSection(
         checked = currentUser.autoAcceptMemberContacts,
         onCheckedChange = { enable ->
           setAutoAcceptMemberContacts(enable)
-        }
+        },
+        modifier = Modifier.ui(Ui.Privacy.AutoAcceptMemberContacts)
       )
     }
     SettingsActionItemWithContent(painterResource(MR.images.ic_group), stringResource(MR.strings.group_invitations)) {
@@ -362,7 +368,8 @@ private fun AutoAcceptSection(
         checked = currentUser.autoAcceptGroupInvitations,
         onCheckedChange = { enable ->
           setAutoAcceptGroupInvitations(enable)
-        }
+        },
+        modifier = Modifier.ui(Ui.Privacy.AutoAcceptGroupInvitations)
       )
     }
   }
@@ -391,7 +398,8 @@ private fun DeliveryReceiptsSection(
         checked = currentUser.sendRcptsContacts,
         onCheckedChange = { enable ->
           setOrAskSendReceiptsContacts(enable)
-        }
+        },
+        modifier = Modifier.ui(Ui.Privacy.ReceiptsContacts)
       )
     }
     SettingsActionItemWithContent(painterResource(MR.images.ic_group), stringResource(MR.strings.receipts_section_groups)) {
@@ -399,7 +407,8 @@ private fun DeliveryReceiptsSection(
         checked = currentUser.sendRcptsSmallGroups,
         onCheckedChange = { enable ->
           setOrAskSendReceiptsGroups(enable)
-        }
+        },
+        modifier = Modifier.ui(Ui.Privacy.ReceiptsGroups)
       )
     }
   }
@@ -688,7 +697,7 @@ fun SimplexLockView(
       if (performLA.value) {
         LockDelaySelector(remember { laLockDelay.state }) { laLockDelay.set(it) }
         if (showChangePasscode.value && laMode.value == LAMode.PASSCODE) {
-          SectionItemView({ changeLAPassword() }) {
+          SectionItemView({ changeLAPassword() }, uiKey = Ui.Lock.ChangePasscode) {
             Text(
               generalGetString(MR.strings.la_change_app_passcode),
               color = MaterialTheme.colors.primary
@@ -705,12 +714,13 @@ fun SimplexLockView(
             SelfDestructInfoView()
           }
         }
-        SettingsActionItemWithContent(null, null, click = openInfo) {
+        SettingsActionItemWithContent(null, null, click = openInfo, uiKey = Ui.Lock.SelfDestructInfo) {
           SharedPreferenceToggleWithIcon(
             stringResource(MR.strings.enable_self_destruct),
             painterResource(MR.images.ic_info),
             openInfo,
-            remember { selfDestructPref.state }.value
+            remember { selfDestructPref.state }.value,
+            uiKey = Ui.Lock.SelfDestruct
           ) {
             toggleSelfDestruct(selfDestructPref)
           }
@@ -723,7 +733,7 @@ fun SimplexLockView(
               fontSize = 16.sp,
               modifier = Modifier.padding(bottom = DEFAULT_PADDING_HALF)
             )
-            ProfileNameField(selfDestructDisplayName, "", { isValidDisplayName(it.trim()) })
+            ProfileNameField(selfDestructDisplayName, "", { isValidDisplayName(it.trim()) }, uiKey = Ui.Lock.SelfDestructName)
             LaunchedEffect(selfDestructDisplayName.value) {
               val new = selfDestructDisplayName.value
               if (isValidDisplayName(new) && selfDestructDisplayNamePref.get() != new) {
@@ -731,7 +741,7 @@ fun SimplexLockView(
               }
             }
           }
-          SectionItemView({ changeSelfDestructPassword() }) {
+          SectionItemView({ changeSelfDestructPassword() }, uiKey = Ui.Lock.ChangeSelfDestruct) {
             Text(
               stringResource(MR.strings.change_self_destruct_passcode),
               color = MaterialTheme.colors.primary
@@ -791,6 +801,7 @@ private fun EnableLock(performLA: State<Boolean>, onCheckedChange: (Boolean) ->
       DefaultSwitch(
         checked = performLA.value,
         onCheckedChange = onCheckedChange,
+        modifier = Modifier.ui(Ui.Lock.Enable),
       )
     }
   }
@@ -819,6 +830,7 @@ private fun LockDelaySelector(state: State<Int>, onSelected: (Int) -> Unit) {
     state,
     icon = null,
     enabled = remember { mutableStateOf(true) },
+    uiKey = Ui.Lock.Delay,
     onSelected = onSelected
   )
 }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/SetDeliveryReceiptsView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/SetDeliveryReceiptsView.kt
index 003300a033..4b5e125ecc 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/SetDeliveryReceiptsView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/SetDeliveryReceiptsView.kt
@@ -14,6 +14,8 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.model.ChatModel
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.res.*
 import chat.simplex.common.ui.theme.DEFAULT_PADDING
 import chat.simplex.common.views.helpers.*
@@ -97,14 +99,14 @@ private fun SetDeliveryReceiptsLayout(
 
 @Composable
 private fun EnableReceiptsButton(onClick: () -> Unit) {
-  TextButton(onClick) {
+  TextButton(onClick, Modifier.ui(Ui.DeliveryReceipts.Enable)) {
     Text(stringResource(MR.strings.enable_receipts_all), style = MaterialTheme.typography.h2, color = MaterialTheme.colors.primary)
   }
 }
 
 @Composable
 private fun SkipButton(onClick: () -> Unit) {
-  SimpleButtonIconEnded(stringResource(MR.strings.dont_enable_receipts), painterResource(MR.images.ic_chevron_right), click = onClick)
+  SimpleButtonIconEnded(stringResource(MR.strings.dont_enable_receipts), painterResource(MR.images.ic_chevron_right), uiKey = Ui.DeliveryReceipts.Skip, click = onClick)
   TextBelowButton(stringResource(MR.strings.you_can_enable_delivery_receipts_later))
 }
 
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.kt
index 0bf1c8e9b6..088b8d54e6 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.kt
@@ -27,6 +27,7 @@ import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.platform.*
 import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.UiKey
+import chat.simplex.common.ui.ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.badges.BadgesView
 import chat.simplex.common.views.database.DatabaseView
@@ -105,7 +106,7 @@ fun SettingsLayout(
       SettingsActionItem(painterResource(MR.images.ic_lock), stringResource(MR.strings.your_privacy), showSettingsModal { PrivacySettingsView(it, showSettingsModal, setPerformLA) }, disabled = stopped, uiKey = Ui.Settings.Privacy)
       SettingsActionItem(painterResource(MR.images.ic_help), stringResource(MR.strings.help_and_support), showSettingsModal { HelpAndSupportView(it, showModal, showCustomModal) }, uiKey = Ui.Settings.Help)
       DatabaseItem(encrypted, passphraseSaved, showSettingsModal { DatabaseView() }, stopped)
-      SettingsActionItem(painterResource(MR.images.ic_ios_share), stringResource(MR.strings.migrate_from_device_to_another_device), { withAuth(generalGetString(MR.strings.auth_open_migration_to_another_device), generalGetString(MR.strings.auth_log_in_using_credential)) { ModalManager.fullscreen.showCustomModal { close -> MigrateFromDeviceView(close) } } }, disabled = stopped)
+      SettingsActionItem(painterResource(MR.images.ic_ios_share), stringResource(MR.strings.migrate_from_device_to_another_device), { withAuth(generalGetString(MR.strings.auth_open_migration_to_another_device), generalGetString(MR.strings.auth_log_in_using_credential)) { ModalManager.fullscreen.showCustomModal { close -> MigrateFromDeviceView(close) } } }, disabled = stopped, uiKey = Ui.Settings.Migrate)
     }
     SectionDividerSpaced()
 
@@ -122,11 +123,11 @@ fun SettingsLayout(
     SectionDividerSpaced()
 
     SectionView(stringResource(MR.strings.advanced_settings)) {
-      SettingsActionItem(painterResource(MR.images.ic_wifi_tethering), stringResource(MR.strings.network_and_servers), showCustomModal { _, close -> NetworkAndServersView(close) }, disabled = stopped)
+      SettingsActionItem(painterResource(MR.images.ic_wifi_tethering), stringResource(MR.strings.network_and_servers), showCustomModal { _, close -> NetworkAndServersView(close) }, disabled = stopped, uiKey = Ui.Settings.Network)
       if (appPlatform == AppPlatform.ANDROID) {
         SettingsActionItem(painterResource(if (notificationsMode.value == NotificationsMode.OFF) MR.images.ic_bolt_off else MR.images.ic_bolt), stringResource(MR.strings.notifications), showSettingsModal { NotificationsSettingsView(it) }, disabled = stopped)
       }
-      SettingsActionItem(painterResource(MR.images.ic_videocam), stringResource(MR.strings.settings_audio_video_calls), showSettingsModal { CallSettingsView(it, showModal) }, disabled = stopped)
+      SettingsActionItem(painterResource(MR.images.ic_videocam), stringResource(MR.strings.settings_audio_video_calls), showSettingsModal { CallSettingsView(it, showModal) }, disabled = stopped, uiKey = Ui.Settings.Calls)
       AppShutdownItem()
       AppVersionItem(showVersion)
     }
@@ -158,9 +159,9 @@ fun HelpAndSupportView(
     AppBarTitle(stringResource(MR.strings.help_and_support))
 
     SectionView(stringResource(MR.strings.settings_section_title_help)) {
-      SettingsActionItem(painterResource(MR.images.ic_help), stringResource(MR.strings.how_to_use_simplex_chat), showModal { HelpView(userDisplayName) }, disabled = stopped)
+      SettingsActionItem(painterResource(MR.images.ic_help), stringResource(MR.strings.how_to_use_simplex_chat), showModal { HelpView(userDisplayName) }, disabled = stopped, uiKey = Ui.Help.HowToUse)
       SettingsActionItem(painterResource(MR.images.ic_add), stringResource(MR.strings.whats_new), showCustomModal { _, close -> WhatsNewView(viaSettings = true, close = close) }, disabled = stopped, uiKey = Ui.Help.WhatsNew)
-      SettingsActionItem(painterResource(MR.images.ic_info), stringResource(MR.strings.about_simplex_chat), showModal { SimpleXInfo(it, onboarding = false) })
+      SettingsActionItem(painterResource(MR.images.ic_info), stringResource(MR.strings.about_simplex_chat), showModal { SimpleXInfo(it, onboarding = false) }, uiKey = Ui.Help.About)
     }
     SectionDividerSpaced()
 
@@ -169,7 +170,7 @@ fun HelpAndSupportView(
         SettingsActionItem(painterResource(MR.images.ic_bigtop_updates), stringResource(MR.strings.follow_simplex_network_news), { uriHandler.openVerifiedSimplexUri(simplexNewsUri) }, textColor = MaterialTheme.colors.primary, disabled = stopped)
         SettingsActionItem(painterResource(MR.images.ic_tag), stringResource(MR.strings.chat_with_the_founder), { uriHandler.openVerifiedSimplexUri(simplexTeamUri) }, textColor = MaterialTheme.colors.primary, disabled = stopped)
       }
-      SettingsActionItem(painterResource(MR.images.ic_mail), stringResource(MR.strings.send_us_an_email), { uriHandler.openUriCatching("mailto:chat@simplex.chat") }, textColor = MaterialTheme.colors.primary)
+      SettingsActionItem(painterResource(MR.images.ic_mail), stringResource(MR.strings.send_us_an_email), { uriHandler.openUriCatching("mailto:chat@simplex.chat") }, textColor = MaterialTheme.colors.primary, uiKey = Ui.Help.Email)
     }
     SectionDividerSpaced()
 
@@ -197,7 +198,7 @@ expect fun AdvancedSettingsAppSection(
 expect fun AppShutdownItem()
 
 @Composable private fun DatabaseItem(encrypted: Boolean, saved: Boolean, openDatabaseView: () -> Unit, stopped: Boolean) {
-  SectionItemView(openDatabaseView) {
+  SectionItemView(openDatabaseView, uiKey = Ui.Settings.Database) {
     Row(
       Modifier.fillMaxWidth(),
       verticalAlignment = Alignment.CenterVertically,
@@ -248,14 +249,15 @@ fun ChatLockItem(
     click = showSettingsModal { SimplexLockView(ChatModel, currentLAMode, setPerformLA) },
     icon = if (performLA.value) painterResource(MR.images.ic_lock_filled) else painterResource(MR.images.ic_lock),
     text = stringResource(MR.strings.chat_lock),
-    iconColor = if (performLA.value) SimplexGreen else MaterialTheme.colors.secondary
+    iconColor = if (performLA.value) SimplexGreen else MaterialTheme.colors.secondary,
+    uiKey = Ui.Privacy.Lock
   ) {
     Text(if (performLA.value) remember { currentLAMode.state }.value.text else generalGetString(MR.strings.la_mode_off), color = MaterialTheme.colors.secondary)
   }
 }
 
 @Composable fun ContributeItem(uriHandler: UriHandler) {
-  SectionItemView({ uriHandler.openExternalLink("https://github.com/simplex-chat/simplex-chat#contribute") }) {
+  SectionItemView({ uriHandler.openExternalLink("https://github.com/simplex-chat/simplex-chat#contribute") }, uiKey = Ui.Help.Contribute) {
     Icon(
       painterResource(MR.images.ic_keyboard),
       contentDescription = "GitHub",
@@ -283,7 +285,7 @@ fun ChatLockItem(
 }
 
 @Composable fun StarOnGithubItem(uriHandler: UriHandler) {
-  SectionItemView({ uriHandler.openExternalLink("https://github.com/simplex-chat/simplex-chat") }) {
+  SectionItemView({ uriHandler.openExternalLink("https://github.com/simplex-chat/simplex-chat") }, uiKey = Ui.Help.Star) {
     Icon(
       painter = painterResource(MR.images.ic_github),
       contentDescription = "GitHub",
@@ -295,7 +297,7 @@ fun ChatLockItem(
 }
 
 @Composable fun ChatConsoleItem(showTerminal: () -> Unit) {
-  SectionItemView(showTerminal) {
+  SectionItemView(showTerminal, uiKey = Ui.DevTools.Console) {
     Icon(
       painter = painterResource(MR.images.ic_outline_terminal),
       contentDescription = stringResource(MR.strings.chat_console),
@@ -331,7 +333,7 @@ fun ChatLockItem(
   SectionItemView({
     resetHintPreferences()
     unchangedHints.value = true
-  }, disabled = unchangedHints.value) {
+  }, disabled = unchangedHints.value, uiKey = Ui.DevTools.ResetHints) {
     Icon(
       painter = painterResource(MR.images.ic_lightbulb),
       contentDescription = "Lightbulb",
@@ -350,7 +352,7 @@ fun unchangedHintPreferences(): Boolean = appPreferences.hintPreferences.all { i
 
 @Composable
 fun AppVersionItem(showVersion: () -> Unit) {
-  SectionItemView(showVersion) { AppVersionText() }
+  SectionItemView(showVersion, uiKey = Ui.Settings.Version) { AppVersionText() }
 }
 
 @Composable fun AppVersionText() {
@@ -392,7 +394,7 @@ fun SettingsActionItem(icon: Painter, text: String, click: (() -> Unit)? = null,
 }
 
 @Composable
-fun SettingsActionItemWithContent(icon: Painter?, text: String? = null, click: (() -> Unit)? = null, iconColor: Color = MaterialTheme.colors.secondary, textColor: Color = MaterialTheme.colors.onBackground, disabled: Boolean = false, extraPadding: Boolean = false, content: @Composable RowScope.() -> Unit) {
+fun SettingsActionItemWithContent(icon: Painter?, text: String? = null, click: (() -> Unit)? = null, iconColor: Color = MaterialTheme.colors.secondary, textColor: Color = MaterialTheme.colors.onBackground, disabled: Boolean = false, extraPadding: Boolean = false, uiKey: UiKey? = null, content: @Composable RowScope.() -> Unit) {
   SectionItemView(
     click,
     extraPadding = extraPadding,
@@ -400,7 +402,8 @@ fun SettingsActionItemWithContent(icon: Painter?, text: String? = null, click: (
       PaddingValues(start = DEFAULT_PADDING * 1.7f, end = itemHPadding)
     else
       PaddingValues(horizontal = itemHPadding),
-    disabled = disabled
+    disabled = disabled,
+    uiKey = uiKey
   ) {
     if (icon != null) {
       Icon(icon, text, Modifier, tint = if (disabled) MaterialTheme.colors.secondary else iconColor)
@@ -441,12 +444,14 @@ fun PreferenceToggle(
   text: String,
   disabled: Boolean = false,
   checked: Boolean,
+  uiKey: UiKey? = null,
   onChange: (Boolean) -> Unit = {},
 ) {
   SettingsActionItemWithContent(null, text, disabled = disabled) {
     DefaultSwitch(
       checked = checked,
       onCheckedChange = onChange,
+      modifier = Modifier.ui(uiKey),
       enabled = !disabled
     )
   }
@@ -460,6 +465,7 @@ fun PreferenceToggleWithIcon(
   disabled: Boolean = false,
   checked: Boolean,
   extraPadding: Boolean = false,
+  uiKey: UiKey? = null,
   onChange: (Boolean) -> Unit = {},
 ) {
   SettingsActionItemWithContent(icon, text, iconColor = iconColor ?: MaterialTheme.colors.secondary, extraPadding = extraPadding) {
@@ -468,6 +474,7 @@ fun PreferenceToggleWithIcon(
       onCheckedChange = {
         onChange(it)
       },
+      modifier = Modifier.ui(uiKey),
       enabled = !disabled
     )
   }
@@ -501,6 +508,7 @@ fun doWithAuth(title: String, desc: String, block: () -> Unit) {
           SimpleButton(
             stringResource(MR.strings.auth_unlock),
             icon = painterResource(MR.images.ic_lock),
+            uiKey = Ui.Lock.Unlock,
             click = {
               runAuth(title, desc, onFinishAuth)
             }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserAddressView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserAddressView.kt
index b065f9c736..a55fa976bc 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserAddressView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserAddressView.kt
@@ -26,6 +26,7 @@ import dev.icerock.moko.resources.compose.stringResource
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.model.*
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.model.ChatModel
@@ -457,6 +458,7 @@ private fun ShareViaChatButton(onClick: () -> Unit) {
     onClick,
     iconColor = MaterialTheme.colors.primary,
     textColor = MaterialTheme.colors.primary,
+    uiKey = Ui.Address.ShareViaChat,
   )
 }
 
@@ -473,6 +475,7 @@ private fun CreateOneTimeLinkButton() {
     },
     iconColor = MaterialTheme.colors.primary,
     textColor = MaterialTheme.colors.primary,
+    uiKey = Ui.Address.CreateLink,
   )
 }
 
@@ -482,6 +485,7 @@ private fun LearnMoreButton(onClick: () -> Unit) {
     painterResource(MR.images.ic_info),
     stringResource(MR.strings.simplex_address_or_1_time_link),
     onClick,
+    uiKey = Ui.Address.LearnMore,
   )
 }
 
@@ -511,7 +515,8 @@ private fun AddressSettingsButton(
       ModalManager.start.showCustomModal { close ->
         UserAddressSettings(user, userAddress, shareViaProfile, setProfileAddress, saveAddressSettings, close = close)
       }
-    }
+    },
+    uiKey = Ui.Address.Settings,
   )
 }
 
@@ -589,6 +594,7 @@ fun ShareWithContactsButton(shareViaProfile: MutableState<Boolean>, setProfileAd
     stringResource(MR.strings.share_with_contacts),
     painterResource(MR.images.ic_person),
     checked = shareViaProfile.value,
+    uiKey = Ui.Address.ShareWithContacts,
   ) { on ->
     shareViaProfile.value = on
     if (on) {
@@ -629,6 +635,7 @@ private fun BusinessAddressToggle(addressSettingsState: MutableState<AddressSett
     stringResource(MR.strings.business_address),
     painterResource(MR.images.ic_work),
     checked = addressSettingsState.value.businessAddress,
+    uiKey = Ui.Address.Business,
   ) { businessToggle ->
     addressSettingsState.value = if (businessToggle)
       AddressSettingsState(
@@ -654,7 +661,8 @@ private fun AutoAcceptToggle(addressSettingsState: MutableState<AddressSettingsS
     stringResource(MR.strings.auto_accept_contact),
     painterResource(MR.images.ic_check),
     disabled = addressSettingsState.value.businessAddress,
-    checked = addressSettingsState.value.autoAccept
+    checked = addressSettingsState.value.autoAccept,
+    uiKey = Ui.Address.AutoAccept,
   ) { autoAcceptToggle ->
     addressSettingsState.value = if (autoAcceptToggle)
       AddressSettingsState(
@@ -682,6 +690,7 @@ private fun DeleteAddressButton(onClick: () -> Unit) {
     onClick,
     iconColor = MaterialTheme.colors.error,
     textColor = MaterialTheme.colors.error,
+    uiKey = Ui.Address.Delete,
   )
 }
 
@@ -759,7 +768,7 @@ private fun AutoReplyEditor(addressSettingsState: MutableState<AddressSettingsSt
   val autoReply = rememberSaveable { mutableStateOf(addressSettingsState.value.autoReply) }
   TextEditor(
     autoReply,
-    Modifier.height(100.dp),
+    Modifier.height(100.dp).ui(Ui.Address.WelcomeMessage),
     placeholder = stringResource(MR.strings.enter_welcome_message_optional),
     contentPadding = PaddingValues(),
     shape = SectionCardShape
@@ -778,7 +787,7 @@ private fun AutoReplyEditor(addressSettingsState: MutableState<AddressSettingsSt
 
 @Composable
 private fun saveAddressSettingsButton(disabled: Boolean, onClick: () -> Unit) {
-  SectionItemView(onClick, disabled = disabled) {
+  SectionItemView(onClick, disabled = disabled, uiKey = Ui.Address.SaveSettings) {
     Text(stringResource(MR.strings.save_verb), color = if (disabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
   }
 }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserProfileView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserProfileView.kt
index d7234ec04b..170f79eb88 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserProfileView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserProfileView.kt
@@ -146,7 +146,7 @@ fun UserProfileLayout(
             Box(Modifier.weight(1f, fill = false).padding(bottom = DEFAULT_PADDING)) {
               TextEditor(
                 description,
-                Modifier.heightIn(min = 140.dp),
+                Modifier.heightIn(min = 140.dp).ui(Ui.Profile.DescriptionText),
                 placeholder = stringResource(MR.strings.enter_description_optional),
                 contentPadding = PaddingValues(),
                 focusRequester = descrFocusRequester,
@@ -194,7 +194,7 @@ fun UserProfileLayout(
               )
               if (!isValidNewProfileName(displayName.value, profile)) {
                 Spacer(Modifier.width(DEFAULT_PADDING_HALF))
-                IconButton({ showInvalidNameAlert(mkValidName(displayName.value), displayName) }, Modifier.size(20.dp)) {
+                IconButton({ showInvalidNameAlert(mkValidName(displayName.value), displayName) }, Modifier.size(20.dp).ui(Ui.Profile.Name.part("invalid"))) {
                   Icon(painterResource(MR.images.ic_info), null, tint = MaterialTheme.colors.error)
                 }
               }
@@ -207,7 +207,7 @@ fun UserProfileLayout(
                 fontSize = 16.sp,
                 modifier = Modifier.padding(bottom = DEFAULT_PADDING_HALF)
               )
-              ProfileNameField(fullName)
+              ProfileNameField(fullName, uiKey = Ui.Profile.FullName)
             }
 
             Spacer(Modifier.height(DEFAULT_PADDING))
@@ -221,19 +221,19 @@ fun UserProfileLayout(
                 Spacer(Modifier.size(DEFAULT_PADDING_HALF))
                 IconButton(
                   onClick = { AlertManager.shared.showAlertMsg(title = generalGetString(MR.strings.bio_too_large)) },
-                  Modifier.size(20.dp)
+                  Modifier.size(20.dp).ui(Ui.Profile.Bio.part("invalid"))
                 ) {
                   Icon(painterResource(MR.images.ic_info), null, tint = MaterialTheme.colors.error)
                 }
               }
             }
-            ProfileNameField(shortDescr)
+            ProfileNameField(shortDescr, uiKey = Ui.Profile.Bio)
 
             Spacer(Modifier.height(DEFAULT_PADDING))
             Text(
               stringResource(if (description.value.isBlank()) MR.strings.add_description else MR.strings.edit_description),
               color = MaterialTheme.colors.primary,
-              modifier = Modifier.clickable { editingDescription = true }
+              modifier = Modifier.ui(Ui.Profile.Description).clickable { editingDescription = true }
             )
 
             Spacer(Modifier.height(DEFAULT_PADDING))
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserProfilesView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserProfilesView.kt
index 0d56ec7a96..c549e2cd04 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserProfilesView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/UserProfilesView.kt
@@ -23,6 +23,7 @@ import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatModel.controller
 import chat.simplex.common.platform.*
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.chat.item.ItemAction
 import chat.simplex.common.views.chatlist.UserProfilePickerItem
@@ -224,7 +225,7 @@ private fun UserView(
   Box(Modifier.padding(horizontal = DEFAULT_PADDING)) {
     DefaultDropdownMenu(showMenu) {
       if (user.hidden) {
-        ItemAction(stringResource(MR.strings.user_unhide), painterResource(MR.images.ic_lock_open_right), onClick = {
+        ItemAction(stringResource(MR.strings.user_unhide), painterResource(MR.images.ic_lock_open_right), uiKey = Ui.Profiles.UserMenu(user.userId, "unhide"), onClick = {
           showMenu.value = false
           unhideUser(user)
         })
@@ -236,12 +237,12 @@ private fun UserView(
           })
         }
         if (user.showNtfs) {
-          ItemAction(stringResource(MR.strings.user_mute), painterResource(MR.images.ic_notifications_off), onClick = {
+          ItemAction(stringResource(MR.strings.user_mute), painterResource(MR.images.ic_notifications_off), uiKey = Ui.Profiles.UserMenu(user.userId, "mute"), onClick = {
             showMenu.value = false
             muteUser(user)
           })
         } else {
-          ItemAction(stringResource(MR.strings.user_unmute), painterResource(MR.images.ic_notifications), onClick = {
+          ItemAction(stringResource(MR.strings.user_unmute), painterResource(MR.images.ic_notifications), uiKey = Ui.Profiles.UserMenu(user.userId, "unmute"), onClick = {
             showMenu.value = false
             unmuteUser(user)
           })
@@ -278,9 +279,9 @@ private fun ProfileActionView(action: UserProfileAction, user: User, doAction: (
     @Composable fun PasswordAndAction(label: StringResource, color: Color = MaterialTheme.colors.primary) {
       SectionView() {
         SectionItemViewWithoutMinPadding {
-          PassphraseField(actionPassword, generalGetString(MR.strings.profile_password), isValid = { passwordValid }, showStrength = true, contentType = null)
+          PassphraseField(actionPassword, generalGetString(MR.strings.profile_password), modifier = Modifier.ui(Ui.ProfileAction.Password), isValid = { passwordValid }, showStrength = true, contentType = null)
         }
-        SectionItemViewSpaceBetween({ doAction(actionPassword.value) }, disabled = !actionEnabled, minHeight = TextFieldDefaults.MinHeight) {
+        SectionItemViewSpaceBetween({ doAction(actionPassword.value) }, disabled = !actionEnabled, minHeight = TextFieldDefaults.MinHeight, uiKey = Ui.ProfileAction.Submit) {
           Text(generalGetString(label), color = if (actionEnabled) color else MaterialTheme.colors.secondary)
         }
       }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/AdvancedNetworkSettings.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/AdvancedNetworkSettings.kt
index 3a6fc0fb5c..bbab4b51b5 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/AdvancedNetworkSettings.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/AdvancedNetworkSettings.kt
@@ -23,7 +23,10 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.theme.*
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.model.ChatModel.controller
 import chat.simplex.common.platform.ColumnWithScrollBar
@@ -259,32 +262,32 @@ fun ModalData.AdvancedNetworkSettingsView(showModal: (@Composable ModalData.() -
         SectionItemView {
           TimeoutSettingRow(
             stringResource(MR.strings.network_option_tcp_connection_timeout), networkTCPConnectTimeoutInteractive,
-            listOf(10_000000, 15_000000, 20_000000, 30_000000), secondsLabel
+            listOf(10_000000, 15_000000, 20_000000, 30_000000), secondsLabel, Ui.AdvancedNetwork.Setting("tcpConnectTimeout")
           )
         }
         SectionItemView {
           TimeoutSettingRow(
             stringResource(MR.strings.network_option_tcp_connection_timeout_background), networkTCPConnectTimeoutBackground,
-            listOf(30_000000, 45_000000, 60_000000, 90_000000), secondsLabel
+            listOf(30_000000, 45_000000, 60_000000, 90_000000), secondsLabel, Ui.AdvancedNetwork.Setting("tcpConnectTimeoutBackground")
           )
         }
         SectionItemView {
           TimeoutSettingRow(
             stringResource(MR.strings.network_option_protocol_timeout), networkTCPTimeoutInteractive,
-            listOf(5_000000, 7_000000, 10_000000, 15_000000, 20_000_000), secondsLabel
+            listOf(5_000000, 7_000000, 10_000000, 15_000000, 20_000_000), secondsLabel, Ui.AdvancedNetwork.Setting("tcpTimeout")
           )
         }
         SectionItemView {
           TimeoutSettingRow(
             stringResource(MR.strings.network_option_protocol_timeout_background), networkTCPTimeoutBackground,
-            listOf(15_000000, 20_000000, 30_000000, 45_000000, 60_000_000), secondsLabel
+            listOf(15_000000, 20_000000, 30_000000, 45_000000, 60_000_000), secondsLabel, Ui.AdvancedNetwork.Setting("tcpTimeoutBackground")
           )
         }
         SectionItemView {
           // can't be higher than 130ms to avoid overflow on 32bit systems
           TimeoutSettingRow(
             stringResource(MR.strings.network_option_protocol_timeout_per_kb), networkTCPTimeoutPerKb,
-            listOf(2_500, 5_000, 10_000, 15_000, 20_000, 30_000), secondsLabel
+            listOf(2_500, 5_000, 10_000, 15_000, 20_000, 30_000), secondsLabel, Ui.AdvancedNetwork.Setting("tcpTimeoutPerKb")
           )
         }
         // SectionItemView {
@@ -296,13 +299,13 @@ fun ModalData.AdvancedNetworkSettingsView(showModal: (@Composable ModalData.() -
         SectionItemView {
           TimeoutSettingRow(
             stringResource(MR.strings.network_option_ping_interval), networkSMPPingInterval,
-            listOf(120_000000, 300_000000, 600_000000, 1200_000000, 2400_000000, 3600_000000), secondsLabel
+            listOf(120_000000, 300_000000, 600_000000, 1200_000000, 2400_000000, 3600_000000), secondsLabel, Ui.AdvancedNetwork.Setting("smpPingInterval")
           )
         }
         SectionItemView {
           IntSettingRow(
             stringResource(MR.strings.network_option_ping_count), networkSMPPingCount,
-            listOf(1, 2, 3, 5, 8), ""
+            listOf(1, 2, 3, 5, 8), "", Ui.AdvancedNetwork.Setting("smpPingCount")
           )
         }
         SectionItemView {
@@ -310,13 +313,13 @@ fun ModalData.AdvancedNetworkSettingsView(showModal: (@Composable ModalData.() -
         }
         if (networkEnableKeepAlive.value) {
           SectionItemView {
-            IntSettingRow("TCP_KEEPIDLE", networkTCPKeepIdle, listOf(15, 30, 60, 120, 180), secondsLabel)
+            IntSettingRow("TCP_KEEPIDLE", networkTCPKeepIdle, listOf(15, 30, 60, 120, 180), secondsLabel, Ui.AdvancedNetwork.Setting("tcpKeepIdle"))
           }
           SectionItemView {
             IntSettingRow("TCP_KEEPINTVL", networkTCPKeepIntvl, listOf(5, 10, 15, 30, 60), secondsLabel)
           }
           SectionItemView {
-            IntSettingRow("TCP_KEEPCNT", networkTCPKeepCnt, listOf(1, 2, 4, 6, 8), "")
+            IntSettingRow("TCP_KEEPCNT", networkTCPKeepCnt, listOf(1, 2, 4, 6, 8), "", Ui.AdvancedNetwork.Setting("tcpKeepCnt"))
           }
         } else {
           SectionItemView {
@@ -335,10 +338,10 @@ fun ModalData.AdvancedNetworkSettingsView(showModal: (@Composable ModalData.() -
     SectionDividerSpaced()
 
     SectionView {
-      SectionItemView(reset, disabled = resetDisabled) {
+      SectionItemView(reset, disabled = resetDisabled, uiKey = Ui.AdvancedNetwork.Reset) {
         Text(stringResource(MR.strings.network_options_reset_to_defaults), color = if (resetDisabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
       }
-      SectionItemView(save, disabled = saveDisabled) {
+      SectionItemView(save, disabled = saveDisabled, uiKey = Ui.AdvancedNetwork.Save) {
         Text(stringResource(MR.strings.network_options_save_and_reconnect), color = if (saveDisabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
       }
     }
@@ -369,11 +372,12 @@ private fun SMPProxyModePicker(
     smpProxyMode,
     values,
     icon = painterResource(MR.images.ic_settings_ethernet),
+    uiKey = Ui.AdvancedNetwork.ProxyMode,
     onSelected = {
       showModal {
         ColumnWithScrollBar {
           AppBarTitle(stringResource(MR.strings.network_smp_proxy_mode_private_routing))
-          SectionViewSelectableCards(null, smpProxyMode, values, updateSMPProxyMode)
+          SectionViewSelectableCards(null, smpProxyMode, values, Ui.AdvancedNetwork.ProxyMode, updateSMPProxyMode)
         }
       }
     }
@@ -404,11 +408,12 @@ private fun SMPProxyFallbackPicker(
     values,
     icon = painterResource(MR.images.ic_arrows_left_right),
     enabled = enabled,
+    uiKey = Ui.AdvancedNetwork.ProxyFallback,
     onSelected = {
       showModal {
         ColumnWithScrollBar {
           AppBarTitle(stringResource(MR.strings.network_smp_proxy_fallback_allow_downgrade))
-          SectionViewSelectableCards(null, smpProxyFallback, values, updateSMPProxyFallback)
+          SectionViewSelectableCards(null, smpProxyFallback, values, Ui.AdvancedNetwork.ProxyFallback, updateSMPProxyFallback)
         }
       }
     }
@@ -428,12 +433,13 @@ fun EnableKeepAliveSwitch(
     DefaultSwitch(
       checked = networkEnableKeepAlive.value,
       onCheckedChange = { networkEnableKeepAlive.value = it },
+      modifier = Modifier.ui(Ui.AdvancedNetwork.KeepAlive),
     )
   }
 }
 
 @Composable
-fun IntSettingRow(title: String, selection: MutableState<Int>, values: List<Int>, label: String) {
+fun IntSettingRow(title: String, selection: MutableState<Int>, values: List<Int>, label: String, uiKey: UiKey? = null) {
   Row(
     Modifier.fillMaxWidth(),
     verticalAlignment = Alignment.CenterVertically,
@@ -447,7 +453,8 @@ fun IntSettingRow(title: String, selection: MutableState<Int>, values: List<Int>
       expanded = expanded.value,
       onExpandedChange = {
         expanded.value = !expanded.value
-      }
+      },
+      modifier = Modifier.ui(uiKey)
     ) {
       Row(
         Modifier.width(140.dp),
@@ -477,6 +484,7 @@ fun IntSettingRow(title: String, selection: MutableState<Int>, values: List<Int>
               selection.value = selectionOption
               expanded.value = false
             },
+            modifier = Modifier.ui(uiKey?.option(selectionOption)),
             contentPadding = PaddingValues(horizontal = DEFAULT_PADDING * 1.5f)
           ) {
             Text(
@@ -492,7 +500,7 @@ fun IntSettingRow(title: String, selection: MutableState<Int>, values: List<Int>
 }
 
 @Composable
-fun TimeoutSettingRow(title: String, selection: MutableState<Long>, values: List<Long>, label: String) {
+fun TimeoutSettingRow(title: String, selection: MutableState<Long>, values: List<Long>, label: String, uiKey: UiKey? = null) {
   Row(
     Modifier.fillMaxWidth(),
     verticalAlignment = Alignment.CenterVertically,
@@ -506,7 +514,8 @@ fun TimeoutSettingRow(title: String, selection: MutableState<Long>, values: List
       expanded = expanded.value,
       onExpandedChange = {
         expanded.value = !expanded.value
-      }
+      },
+      modifier = Modifier.ui(uiKey)
     ) {
       val df = DecimalFormat("#.###")
       Row(
@@ -539,6 +548,7 @@ fun TimeoutSettingRow(title: String, selection: MutableState<Long>, values: List
               selection.value = selectionOption
               expanded.value = false
             },
+            modifier = Modifier.ui(uiKey?.option(selectionOption)),
             contentPadding = PaddingValues(horizontal = DEFAULT_PADDING * 1.5f)
           ) {
             Text(
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/NetworkAndServers.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/NetworkAndServers.kt
index 8c9baf3fec..96bbf418b1 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/NetworkAndServers.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/NetworkAndServers.kt
@@ -39,6 +39,7 @@ import chat.simplex.common.model.ChatController.setUserServers
 import chat.simplex.common.model.ChatModel.controller
 import chat.simplex.common.platform.*
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.ui
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.helpers.*
@@ -245,7 +246,7 @@ fun ModalData.NetworkAndServersView(closeNetworkAndServers: () -> Unit) {
               rhId = currentRemoteHost?.remoteHostId
             )
           }
-        }) {
+        }, uiKey = Ui.Network.YourServers) {
           Icon(
             painterResource(MR.images.ic_dns),
             stringResource(MR.strings.your_servers),
@@ -263,8 +264,8 @@ fun ModalData.NetworkAndServersView(closeNetworkAndServers: () -> Unit) {
 
       if (currentRemoteHost == null) {
         UseSocksProxySwitch(networkUseSocksProxy, toggleSocksProxy)
-        SettingsActionItem(painterResource(MR.images.ic_settings_ethernet), stringResource(MR.strings.network_socks_proxy_settings), { showCustomModal { SocksProxySettings(networkUseSocksProxy.value, appPrefs.networkProxy, onionHosts, sessionMode = appPrefs.networkSessionMode.get(), false, it) } })
-        SettingsActionItem(painterResource(MR.images.ic_cable), stringResource(MR.strings.network_settings), { ModalManager.start.showCustomModal { AdvancedNetworkSettingsView(showModal, it) } })
+        SettingsActionItem(painterResource(MR.images.ic_settings_ethernet), stringResource(MR.strings.network_socks_proxy_settings), { showCustomModal { SocksProxySettings(networkUseSocksProxy.value, appPrefs.networkProxy, onionHosts, sessionMode = appPrefs.networkSessionMode.get(), false, it) } }, uiKey = Ui.Network.SocksSettings)
+        SettingsActionItem(painterResource(MR.images.ic_cable), stringResource(MR.strings.network_settings), { ModalManager.start.showCustomModal { AdvancedNetworkSettingsView(showModal, it) } }, uiKey = Ui.Network.Advanced)
       }
     }
     if (currentRemoteHost == null && networkUseSocksProxy.value) {
@@ -277,6 +278,7 @@ fun ModalData.NetworkAndServersView(closeNetworkAndServers: () -> Unit) {
       SectionItemView(
         { scope.launch { saveServers(rhId = currentRemoteHost?.remoteHostId, currUserServers, userServers) } },
         disabled = saveDisabled,
+        uiKey = Ui.Network.SaveServers,
       ) {
         Text(stringResource(MR.strings.smp_servers_save), color = if (!saveDisabled) MaterialTheme.colors.onBackground else MaterialTheme.colors.secondary)
       }
@@ -359,6 +361,7 @@ fun UseSocksProxySwitch(
     DefaultSwitch(
       checked = networkUseSocksProxy.value,
       onCheckedChange = toggleSocksProxy,
+      modifier = Modifier.ui(Ui.Network.UseSocks),
     )
   }
 }
@@ -479,7 +482,7 @@ fun SocksProxySettings(
           DefaultConfigurableTextField(
             hostUnsaved,
             stringResource(MR.strings.host_verb),
-            modifier = Modifier.fillMaxWidth(),
+            modifier = Modifier.fillMaxWidth().ui(Ui.Socks.Host),
             isValid = ::validHost,
             keyboardActions = KeyboardActions(onNext = { defaultKeyboardAction(ImeAction.Next) }),
             keyboardType = KeyboardType.Text,
@@ -487,14 +490,14 @@ fun SocksProxySettings(
           DefaultConfigurableTextField(
             portUnsaved,
             stringResource(MR.strings.port_verb),
-            modifier = Modifier.fillMaxWidth(),
+            modifier = Modifier.fillMaxWidth().ui(Ui.Socks.Port),
             isValid = ::validPort,
             keyboardActions = KeyboardActions(onDone = { defaultKeyboardAction(ImeAction.Done); save(false) }),
             keyboardType = KeyboardType.Number,
           )
         }
 
-        UseOnionHosts(onionHosts, rememberUpdatedState(networkUseSocksProxy && proxyAuthRandomUnsaved.value)) {
+        UseOnionHosts(onionHosts, rememberUpdatedState(networkUseSocksProxy && proxyAuthRandomUnsaved.value), Ui.Socks.OnionHosts) {
           onionHosts.value = it
         }
       }
@@ -541,12 +544,13 @@ fun SocksProxySettings(
           passwordUnsaved.value = TextFieldValue()
           proxyAuthRandomUnsaved.value = true
           onionHosts.value = NetCfg.defaults.onionHosts
-        }, disabled = resetDisabled) {
+        }, disabled = resetDisabled, uiKey = Ui.Socks.Reset) {
           Text(stringResource(MR.strings.network_options_reset_to_defaults), color = if (resetDisabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
         }
         SectionItemView(
           click = { if (networkUseSocksProxy && !migration) showUpdateNetworkSettingsDialog { save(false) } else save(false) },
-          disabled = saveDisabled
+          disabled = saveDisabled,
+          uiKey = Ui.Socks.Save
         ) {
           Text(stringResource(if (networkUseSocksProxy && !migration) MR.strings.network_options_save_and_reconnect else MR.strings.network_options_save), color = if (saveDisabled) MaterialTheme.colors.secondary else MaterialTheme.colors.primary)
         }
@@ -576,6 +580,7 @@ private fun showUnsavedSocksHostPortAlert(confirmText: String, save: () -> Unit,
 fun UseOnionHosts(
   onionHosts: MutableState<OnionHosts>,
   enabled: State<Boolean>,
+  uiKey: UiKey? = null,
   useOnion: (OnionHosts) -> Unit,
 ) {
   val values = remember {
@@ -596,6 +601,7 @@ fun UseOnionHosts(
         onionHosts,
         icon = painterResource(MR.images.ic_security),
         enabled = enabled,
+        uiKey = uiKey,
         onSelected = useOnion
       )
     } else {
@@ -606,6 +612,7 @@ fun UseOnionHosts(
         remember { mutableStateOf(OnionHosts.NEVER) },
         icon = painterResource(MR.images.ic_security),
         enabled = enabled,
+        uiKey = uiKey,
         onSelected = {}
       )
     }
@@ -642,11 +649,12 @@ fun SessionModePicker(
     sessionMode,
     values,
     icon = painterResource(MR.images.ic_safety_divider),
+    uiKey = Ui.AdvancedNetwork.SessionMode,
     onSelected = {
       showModal {
         ColumnWithScrollBar {
           AppBarTitle(stringResource(MR.strings.network_session_mode_transport_isolation))
-          SectionViewSelectable(null, sessionMode, values, updateSessionMode)
+          SectionViewSelectable(null, sessionMode, values, Ui.AdvancedNetwork.SessionMode, onSelected = updateSessionMode)
         }
       }
     }
@@ -694,7 +702,8 @@ private fun ServerOperatorRow(
           rhId
         )
       }
-    }
+    },
+    uiKey = Ui.Network.Operator(operator.operatorId)
   ) {
     Image(
       painterResource(operator.logo),
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/OperatorView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/OperatorView.kt
index 20a182551c..601513fd7f 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/OperatorView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/OperatorView.kt
@@ -27,7 +27,9 @@ import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.model.ChatController.getUsageConditions
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.chat.item.ItemAction
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.onboarding.*
@@ -187,7 +189,7 @@ fun OperatorViewLayout(
 
   Column {
     SectionView(generalGetString(MR.strings.operator)) {
-      SectionItemView({ ModalManager.start.showModalCloseable { _ -> OperatorInfoView(operator) } }) {
+      SectionItemView({ ModalManager.start.showModalCloseable { _ -> OperatorInfoView(operator) } }, uiKey = Ui.Operator.Info) {
         Row(
           Modifier.fillMaxWidth(),
           verticalAlignment = Alignment.CenterVertically
@@ -597,6 +599,7 @@ private fun UseOperatorToggle(
           changeOperatorEnabled(userServers, operatorIndex, false)
         }
       },
+      modifier = Modifier.ui(Ui.Operator.Use),
     )
   }
 }
@@ -639,6 +642,7 @@ private fun SingleOperatorUsageConditionsView(
 
     Column(Modifier.fillMaxWidth().padding(bottom = DEFAULT_PADDING * 2), horizontalAlignment = Alignment.CenterHorizontally) {
       OnboardingActionButton(
+        modifier = Modifier.ui(Ui.Operator.AcceptConditions),
         labelId = MR.strings.accept_conditions,
         onboarding = null,
         enabled = operatorIds.isNotEmpty(),
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/ProtocolServerView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/ProtocolServerView.kt
index c1c423e981..f158824c2d 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/ProtocolServerView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/ProtocolServerView.kt
@@ -21,7 +21,9 @@ import androidx.compose.ui.unit.sp
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.model.ServerAddress.Companion.parseServerAddress
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.newchat.QRCode
 import chat.simplex.common.model.ChatModel
@@ -180,7 +182,7 @@ fun CustomServer(
     val testedPreviously = remember { mutableMapOf<String, Boolean?>() }
     TextEditor(
       serverAddress,
-      Modifier.height(144.dp)
+      Modifier.height(144.dp).ui(Ui.Servers.Address)
     )
     LaunchedEffect(Unit) {
       snapshotFlow { serverAddress.value }
@@ -250,7 +252,7 @@ private fun UseServerSection(
   onDelete: (() -> Unit)? = null,
 ) {
   SectionView(stringResource(MR.strings.smp_servers_use_server)) {
-    SectionItemViewSpaceBetween(testServer, disabled = !valid || testing) {
+    SectionItemViewSpaceBetween(testServer, disabled = !valid || testing, uiKey = Ui.Servers.Test) {
       Text(stringResource(MR.strings.smp_servers_test_server), color = if (valid && !testing) MaterialTheme.colors.onBackground else MaterialTheme.colors.secondary)
       ShowTestStatus(server.value)
     }
@@ -259,13 +261,14 @@ private fun UseServerSection(
     PreferenceToggle(
       stringResource(MR.strings.smp_servers_use_server_for_new_conn),
       disabled = testing,
-      checked = enabled.value
+      checked = enabled.value,
+      uiKey = Ui.Servers.Use
     ) {
       server.value = server.value.copy(enabled = it)
     }
 
     if (onDelete != null) {
-      SectionItemView(onDelete, disabled = testing) {
+      SectionItemView(onDelete, disabled = testing, uiKey = Ui.Servers.Delete) {
         Text(stringResource(MR.strings.smp_servers_delete_server), color = if (testing) MaterialTheme.colors.secondary else MaterialTheme.colors.error)
       }
     }
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/ProtocolServersView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/ProtocolServersView.kt
index 6e1fad133a..6e312f08e0 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/ProtocolServersView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/usersettings/networkAndServers/ProtocolServersView.kt
@@ -11,6 +11,7 @@ import androidx.compose.foundation.background
 import androidx.compose.material.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.*
 import androidx.compose.ui.platform.LocalUriHandler
 import dev.icerock.moko.resources.compose.painterResource
@@ -104,7 +105,7 @@ fun YourServersViewLayout(
       SectionView(generalGetString(MR.strings.message_servers)) {
         userServers.value[operatorIndex].smpServers.forEachIndexed { i, server  ->
           if (server.deleted) return@forEachIndexed
-          SectionItemView({ navigateToProtocolView(i, server, ServerProtocol.SMP) }) {
+          SectionItemView({ navigateToProtocolView(i, server, ServerProtocol.SMP) }, uiKey = Ui.Servers.Server(server.server)) {
             ProtocolServerViewLink(
               srv = server,
               serverProtocol = ServerProtocol.SMP,
@@ -138,7 +139,7 @@ fun YourServersViewLayout(
       SectionView(generalGetString(MR.strings.media_and_file_servers)) {
         userServers.value[operatorIndex].xftpServers.forEachIndexed { i, server ->
           if (server.deleted) return@forEachIndexed
-          SectionItemView({ navigateToProtocolView(i, server, ServerProtocol.XFTP) }) {
+          SectionItemView({ navigateToProtocolView(i, server, ServerProtocol.XFTP) }, uiKey = Ui.Servers.Server(server.server)) {
             ProtocolServerViewLink(
               srv = server,
               serverProtocol = ServerProtocol.XFTP,
@@ -182,7 +183,8 @@ fun YourServersViewLayout(
         click = { showAddServerDialog(scope, userServers, serverErrors, serverWarnings, rhId) },
         disabled = testing.value,
         textColor = if (testing.value) MaterialTheme.colors.secondary else MaterialTheme.colors.primary,
-        iconColor = if (testing.value) MaterialTheme.colors.secondary else MaterialTheme.colors.primary
+        iconColor = if (testing.value) MaterialTheme.colors.secondary else MaterialTheme.colors.primary,
+        uiKey = Ui.Servers.Add
       )
     }
     globalServersErrors(serverErrors.value).forEach { err ->
@@ -253,7 +255,8 @@ fun TestServersButton(
         testServers(testing, smpServers, xftpServers, chatRelays, chatModel, onUpdate, onUpdateRelays)
       }
     },
-    disabled = disabled.value
+    disabled = disabled.value,
+    uiKey = Ui.Servers.TestAll
   ) {
     Text(stringResource(MR.strings.smp_servers_test_servers), color = if (!disabled.value) MaterialTheme.colors.onBackground else MaterialTheme.colors.secondary)
   }
@@ -275,7 +278,7 @@ fun showAddServerDialog(
           ModalManager.start.showCustomModal { close ->
             NewServerView(userServers, serverErrors, serverWarnings, rhId, close)
           }
-        }) {
+        }, uiKey = Ui.Alert.Option(Ui.AlertSource.Shared, "enterManually")) {
           Text(stringResource(MR.strings.smp_servers_enter_manually), Modifier.fillMaxWidth(), textAlign = TextAlign.Center, color = MaterialTheme.colors.primary)
         }
         if (appPlatform.isAndroid) {
diff --git a/apps/multiplatform/common/src/commonMain/moko-resources/base/strings.xml b/apps/multiplatform/common/src/commonMain/moko-resources/base/strings.xml
index cd80492607..deb2ea2d5d 100644
--- a/apps/multiplatform/common/src/commonMain/moko-resources/base/strings.xml
+++ b/apps/multiplatform/common/src/commonMain/moko-resources/base/strings.xml
@@ -475,6 +475,7 @@
   <!-- CIMetaView.kt -->
   <string name="icon_descr_edited">edited</string>
   <string name="icon_descr_sent_msg_status_sent">sent</string>
+  <string name="icon_descr_sent_msg_status_rcvd">received</string>
   <string name="icon_descr_sent_msg_status_unauthorized_send">unauthorized send</string>
   <string name="icon_descr_sent_msg_status_send_failed">send failed</string>
   <string name="icon_descr_received_msg_status_unread">unread</string>
diff --git a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/platform/PlatformTextField.desktop.kt b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/platform/PlatformTextField.desktop.kt
index b2e6fc9b21..7d7de8b730 100644
--- a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/platform/PlatformTextField.desktop.kt
+++ b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/platform/PlatformTextField.desktop.kt
@@ -20,7 +20,7 @@ import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.input.*
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
-import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.ui
 import chat.simplex.common.views.chat.*
 import chat.simplex.common.views.helpers.*
@@ -56,6 +56,7 @@ actual fun PlatformTextField(
   onUpArrow: () -> Unit,
   onFilesPasted: (List<URI>) -> Unit,
   focusRequester: FocusRequester?,
+  uiKey: UiKey?,
   onDone: () -> Unit,
 ) {
 
@@ -118,7 +119,7 @@ actual fun PlatformTextField(
       autoCorrectEnabled = true
     ),
     modifier = Modifier
-      .ui(Ui.Chat.Message)
+      .ui(uiKey)
       .padding(start = startPadding, end = endPadding)
       .offset(y = (-5).dp)
       .fillMaxWidth()
diff --git a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.desktop.kt b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.desktop.kt
index 997100246c..cbc4b47851 100644
--- a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.desktop.kt
+++ b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.desktop.kt
@@ -13,6 +13,7 @@ import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.unit.*
 import chat.simplex.common.model.*
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.EmojiFont
 import chat.simplex.common.views.helpers.*
 import chat.simplex.res.*
@@ -32,7 +33,7 @@ actual fun ReactionIcon(text: String, fontSize: TextUnit) {
 
 @Composable
 actual fun SaveContentItemAction(cItem: ChatItem, saveFileLauncher: FileChooserLauncher, showMenu: MutableState<Boolean>) {
-  ItemAction(stringResource(MR.strings.save_verb), painterResource(MR.images.ic_download), onClick = {
+  ItemAction(stringResource(MR.strings.save_verb), painterResource(MR.images.ic_download), uiKey = Ui.Chat.ItemMenu(cItem.id, "save"), onClick = {
     val saveIfExists = {
       when (cItem.content.msgContent) {
         is MsgContent.MCImage, is MsgContent.MCFile, is MsgContent.MCVoice, is MsgContent.MCVideo -> withLongRunningApi { saveFileLauncher.launch(cItem.file?.fileName ?: "") }
diff --git a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.desktop.kt b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.desktop.kt
index 2d5f58a545..ffcbe356d9 100644
--- a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.desktop.kt
+++ b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/database/DatabaseEncryptionView.desktop.kt
@@ -12,7 +12,9 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
+import chat.simplex.common.ui.UiKey
 import chat.simplex.common.ui.theme.WarningOrange
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.res.*
 import dev.icerock.moko.resources.compose.painterResource
@@ -26,6 +28,7 @@ actual fun SavePassphraseSetting(
   minHeight: Dp,
   enabled: Boolean,
   smallPadding: Boolean,
+  uiKey: UiKey?,
   onCheckedChange: (Boolean) -> Unit,
 ) {
   SectionItemView(minHeight = minHeight) {
@@ -48,6 +51,7 @@ actual fun SavePassphraseSetting(
       DefaultSwitch(
         checked = useKeychain,
         onCheckedChange = onCheckedChange,
+        modifier = Modifier.ui(uiKey),
         enabled = enabled
       )
     }
diff --git a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/helpers/ChooseAttachmentView.desktop.kt b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/helpers/ChooseAttachmentView.desktop.kt
index 4ff8c552c4..2ecb06a68b 100644
--- a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/helpers/ChooseAttachmentView.desktop.kt
+++ b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/helpers/ChooseAttachmentView.desktop.kt
@@ -4,6 +4,8 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.MutableState
 import androidx.compose.ui.Modifier
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.ui
 import chat.simplex.common.views.newchat.ActionButton
 import chat.simplex.res.*
 import dev.icerock.moko.resources.compose.painterResource
@@ -11,15 +13,15 @@ import dev.icerock.moko.resources.compose.stringResource
 
 @Composable
 actual fun ChooseAttachmentButtons(attachmentOption: MutableState<AttachmentOption?>, hide: () -> Unit) {
-  ActionButton(Modifier.fillMaxWidth(0.33f), null, stringResource(MR.strings.gallery_image_button), icon = painterResource(MR.images.ic_add_photo)) {
+  ActionButton(Modifier.fillMaxWidth(0.33f).ui(Ui.Chat.Attach("image")), null, stringResource(MR.strings.gallery_image_button), icon = painterResource(MR.images.ic_add_photo)) {
     attachmentOption.value = AttachmentOption.GalleryImage
     hide()
   }
-  ActionButton(Modifier.fillMaxWidth(0.5f), null, stringResource(MR.strings.gallery_video_button), icon = painterResource(MR.images.ic_smart_display)) {
+  ActionButton(Modifier.fillMaxWidth(0.5f).ui(Ui.Chat.Attach("video")), null, stringResource(MR.strings.gallery_video_button), icon = painterResource(MR.images.ic_smart_display)) {
     attachmentOption.value = AttachmentOption.GalleryVideo
     hide()
   }
-  ActionButton(Modifier.fillMaxWidth(1f), null, stringResource(MR.strings.choose_file), icon = painterResource(MR.images.ic_note_add)) {
+  ActionButton(Modifier.fillMaxWidth(1f).ui(Ui.Chat.Attach("file")), null, stringResource(MR.strings.choose_file), icon = painterResource(MR.images.ic_note_add)) {
     attachmentOption.value = AttachmentOption.File
     hide()
   }
diff --git a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/helpers/CustomTimePicker.desktop.kt b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/helpers/CustomTimePicker.desktop.kt
index f1103bc516..05685ac8ab 100644
--- a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/helpers/CustomTimePicker.desktop.kt
+++ b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/helpers/CustomTimePicker.desktop.kt
@@ -6,6 +6,7 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import chat.simplex.common.model.CustomTimeUnit
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.ui.theme.DEFAULT_PADDING
 
 @Composable
@@ -64,6 +65,7 @@ actual fun CustomTimePicker(
       selection,
       textColor = MaterialTheme.colors.onBackground,
       enabled = remember { mutableStateOf(true) },
+      uiKey = Ui.TimePicker.Value,
       onSelected = { selection.value = it }
     )
     Spacer(Modifier.width(DEFAULT_PADDING))
diff --git a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/usersettings/Appearance.desktop.kt b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/usersettings/Appearance.desktop.kt
index aa70b3450f..c20f870a2d 100644
--- a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/usersettings/Appearance.desktop.kt
+++ b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/usersettings/Appearance.desktop.kt
@@ -63,7 +63,7 @@ fun AppearanceScope.AppearanceLayout(
           }
         }
       }
-      SettingsPreferenceItem(icon = null, stringResource(MR.strings.one_hand_ui), ChatModel.controller.appPrefs.oneHandUI)
+      SettingsPreferenceItem(icon = null, stringResource(MR.strings.one_hand_ui), ChatModel.controller.appPrefs.oneHandUI, uiKey = Ui.Appearance.OneHandUI)
       if (remember { appPrefs.oneHandUI.state }.value && !remember { appPrefs.chatBottomBar.state }.value) {
         SettingsPreferenceItem(icon = null, stringResource(MR.strings.chat_bottom_bar), ChatModel.controller.appPrefs.chatBottomBar)
       }
diff --git a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.desktop.kt b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.desktop.kt
index 8ea4a3c5e7..b27cb0af54 100644
--- a/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.desktop.kt
+++ b/apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/usersettings/SettingsView.desktop.kt
@@ -5,6 +5,7 @@ import androidx.compose.runtime.*
 import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.model.ChatModel
 import chat.simplex.common.platform.*
+import chat.simplex.common.ui.Ui
 import chat.simplex.common.views.helpers.*
 import chat.simplex.res.*
 import dev.icerock.moko.resources.compose.painterResource
@@ -16,7 +17,7 @@ actual fun AdvancedSettingsAppSection(
   withAuth: (title: String, desc: String, block: () -> Unit) -> Unit,
 ) {
   SectionView {
-    SettingsActionItem(painterResource(MR.images.ic_code), stringResource(MR.strings.settings_developer_tools), showSettingsModal { DeveloperView(withAuth) })
+    SettingsActionItem(painterResource(MR.images.ic_code), stringResource(MR.strings.settings_developer_tools), showSettingsModal { DeveloperView(withAuth) }, uiKey = Ui.Settings.DeveloperTools)
     val selectedChannel = remember { appPrefs.appUpdateChannel.state }
     val values = AppUpdatesChannel.entries.map { it to it.text }
     ExposedDropDownSettingRow(stringResource(MR.strings.app_check_for_updates), values, selectedChannel) {
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/AppearanceDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/AppearanceDesktopTest.kt
new file mode 100644
index 0000000000..b97823dc80
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/AppearanceDesktopTest.kt
@@ -0,0 +1,45 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.App
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.closeAppearance
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+import java.util.Locale
+
+private const val APP_LANGUAGE = "AppLanguage"
+
+class AppearanceDesktopTest : UiTest() {
+  @Test fun appearance_language_switch() = uiTest {
+    val alice = app("alice")
+    check(storedSetting(APP_LANGUAGE) == null && Locale.getDefault().language == "en") { "the app language before the change: ${storedSetting(APP_LANGUAGE)}, ${Locale.getDefault()}" }
+    selectLanguage(alice, "de")
+    poll(what = "German stored as the app language and applied") { storedSetting(APP_LANGUAGE) == "de" && Locale.getDefault().language == "de" }
+    closeAppearance()
+    assertSettingsStrings(alice, "Einstellungen", "Darstellung")
+    selectLanguageFromOpenSettings("system")
+    poll(what = "the app language cleared and the system language applied") { storedSetting(APP_LANGUAGE) == null && Locale.getDefault().language == "en" }
+    closeAppearance()
+    assertSettingsStrings(alice, "Settings", "Appearance")
+  }
+
+  private fun UiScope.selectLanguage(app: App, tag: String) {
+    app.appearance()
+    click(Ui.Appearance.Language)
+    click(Ui.Appearance.Language.option(tag))
+  }
+
+  private fun UiScope.selectLanguageFromOpenSettings(tag: String) {
+    click(Ui.Settings.Appearance)
+    click(Ui.Appearance.Language)
+    click(Ui.Appearance.Language.option(tag))
+  }
+
+  private fun UiScope.assertSettingsStrings(app: App, settings: String, appearance: String) {
+    app.userPicker()
+    poll(what = "the user picker's settings row reading `$settings`") { textOf(Ui.UserPicker.Settings) == settings }
+    click(Ui.UserPicker.Settings)
+    poll(what = "the Appearance row reading `$appearance`") { exists(Ui.Settings.Appearance) && textOf(Ui.Settings.Appearance) == appearance }
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ChatDataDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ChatDataDesktopTest.kt
new file mode 100644
index 0000000000..7a43cfa42f
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ChatDataDesktopTest.kt
@@ -0,0 +1,52 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.chatData
+import chat.simplex.app.ui.harness.chatRunningInCore
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import chat.simplex.common.views.helpers.DBMigrationResult
+import org.junit.Test
+
+class ChatDataDesktopTest : UiTest() {
+  @Test fun dbMgmt_stoppedStatePersistsRestart() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    chatData(alice).management()
+    click(Ui.Database.RunChat)
+    poll(what = "the Stop chat? alert with Stop") { seesText("Stop chat?") && "Stop" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the chat stopped on screen, on disk and in the core") { seesText("Chat is stopped") && storedSetting("ChatStopped") == "true" && !chatRunningInCore() }
+    bob sends "@alice $WHILE_STOPPED"
+    restart(ready = { startChatAsked() }, what = "the Start chat? alert")
+    poll(what = "the Start chat? alert") { seesText("Start chat?") && seesText(START_CHAT_TEXT) }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the start to finish with the chat stopped") {
+      !AlertManager.shared.hasAlertsShown() && !chatModel.ctrlInitInProgress.value && chatModel.chatRunning.value == false
+    }
+    check(!chatRunningInCore() && storedSetting("ChatStopped") == "true") { "Cancel started the chat: ChatStopped=${storedSetting("ChatStopped")}" }
+    click(described("Settings"))
+    poll(what = "Chat data marked as stopped in settings") { "Chat is stopped" in descriptionsOf(Ui.Settings.Database) }
+    val current = restart(ready = { startChatAsked() }, what = "the Start chat? alert after the second restart")
+    poll(what = "the Start chat? alert after the second restart") { seesText("Start chat?") && "OK" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the chat running with bob's message sent while it was stopped") {
+      chatRunningInCore() && WHILE_STOPPED in current.chatList.rowTexts("bob")
+    }
+    check(storedSetting("ChatStopped") == "false") { "ChatStopped is still stored after the start" }
+    current.chatList.open("bob").send(STARTED_AGAIN)
+    bob.expectsMessage("alice> $STARTED_AGAIN", CONNECT_TIMEOUT_MS)
+  }
+
+  private fun startChatAsked(): Boolean = chatModel.chatDbStatus.value == DBMigrationResult.OK && AlertManager.shared.hasAlertsShown()
+
+  private companion object {
+    const val WHILE_STOPPED = "sent before the restart"
+    const val STARTED_AGAIN = "started again"
+    const val START_CHAT_TEXT = "Chat is stopped. If you already used this database on another device, you should transfer it back before starting chat."
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ChatSearchDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ChatSearchDesktopTest.kt
new file mode 100644
index 0000000000..db6c1bf51e
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ChatSearchDesktopTest.kt
@@ -0,0 +1,32 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.contentFilter
+import chat.simplex.app.ui.harness.pickContentFilter
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+import java.io.File
+
+class ChatSearchDesktopTest : UiTest() {
+  @KnownAppIssue("15.5 item NEW", "waiting for `Files` in the content filter menu after a file note was added")
+  @Test fun contentFilter_fileAddedInOpenChat_listsFiles() = uiTest {
+    val alice = app("alice")
+    val source = File(exchangeDir(), "list.txt").apply { writeText("apples") }
+    val notes = alice.chatList.open("Private notes")
+    click(Ui.Chat.ContentFilter)
+    poll(what = "`Images` and `Links` without `Files` in the content filter menu of the empty notes") {
+      exists(contentFilter("Images")) && exists(contentFilter("Links")) && !exists(contentFilter("Files"))
+    }
+    click(contentFilter("Links"))
+    waitFor(Ui.Chat.Bar.part("search"))
+    pickContentFilter("all")
+    poll(what = "the content filter off") { !exists(Ui.Chat.Bar.part("search")) }
+    enterText(Ui.Chat.Message, source.absolutePath)
+    poll(what = "the preview of list.txt") { seesDescription("Cancel file preview") && seesText("list.txt") }
+    click(Ui.Chat.Send)
+    notes.itemId("the note with list.txt") { it.file?.fileName == "list.txt" }
+    click(Ui.Chat.ContentFilter)
+    poll(what = "`Files` in the content filter menu after a file note was added") { exists(contentFilter("Files")) }
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ComposeDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ComposeDesktopTest.kt
new file mode 100644
index 0000000000..3ee5a25dbb
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ComposeDesktopTest.kt
@@ -0,0 +1,142 @@
+package chat.simplex.app.ui.desktop
+
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.compose.ui.test.pressKey
+import androidx.compose.ui.test.withKeyDown
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.model.MsgContent
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import chat.simplex.common.ui.UiKey
+import com.sun.net.httpserver.HttpServer
+import org.junit.Test
+import java.awt.image.BufferedImage
+import java.io.ByteArrayOutputStream
+import java.io.Closeable
+import java.net.InetSocketAddress
+import java.util.concurrent.CopyOnWriteArrayList
+import javax.imageio.ImageIO
+
+class ComposeDesktopTest : UiTest() {
+  @Test fun multiline_shiftEnter_peerReceivesTwoLines() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, "   ")
+    pressEnter(Ui.Chat.Message)
+    check(editableText(Ui.Chat.Message) == "   " && !isEnabled(Ui.Chat.Send)) { "Enter on a blank message changed the field to `${editableText(Ui.Chat.Message)}`" }
+    replaceText(Ui.Chat.Message, "hello")
+    pressShiftEnter(Ui.Chat.Message)
+    poll(what = "a new line after `hello` in the message field") { editableText(Ui.Chat.Message) == "hello\n" }
+    chat.send("there")
+    bob expectsMessage "alice> hello"
+    bob expects "there"
+  }
+
+  @Test fun linkPreview_enable_peerReceivesLink_cancelSendsText() = uiTest {
+    PreviewServer().use { server ->
+      val alice = app("alice"); val bob = cli("bob")
+      connect(bob)
+      showLinkPreviewsAlertViaApi()
+      val chat = alice.chatList.open("bob")
+      val cat = server.url("cat.png")
+      typeInto(Ui.Chat.Message, cat)
+      poll(what = "the `Enable link previews?` alert with `Enable`") { seesText("Enable link previews?") && exists(ENABLE) }
+      check(server.requests().isEmpty()) { "the preview was fetched before it was enabled: ${server.requests()}" }
+      click(ENABLE)
+      poll(what = "the cat.png preview in the compose area") { seesText("cat.png") && exists(CANCEL_PREVIEW) && seesDescription("link preview image") }
+      check(server.requests() == listOf("/cat.png")) { "preview requests: ${server.requests()}" }
+      chat.sendComposed()
+      bob expectsMessage "alice> $cat"
+      val id = chat.itemId(cat)
+      poll(what = "alice's sent message showing the cat.png card") {
+        !exists(CANCEL_PREVIEW) && "cat.png" in textsOf(Ui.Chat.Item(id)) && "link preview image" in descriptionsOf(Ui.Chat.Item(id))
+      }
+      val aliceId = bob.contactId("alice")
+      bob sends "/_get content types @$aliceId"
+      bob expects "Chat content types: link"
+      val dog = server.url("dog.png")
+      typeInto(Ui.Chat.Message, "see $dog")
+      poll(what = "the dog.png preview fetched without asking again") { seesText("dog.png") && exists(CANCEL_PREVIEW) }
+      check(!seesText("Enable link previews?") && server.requests() == listOf("/cat.png", "/dog.png")) { "alert shown again or preview requests: ${server.requests()}" }
+      click(CANCEL_PREVIEW)
+      poll(what = "the dog.png preview removed") { !seesText("dog.png") && !exists(CANCEL_PREVIEW) }
+      chat.sendComposed()
+      bob expectsMessage "alice> see $dog"
+      bob sends "/_get content types @$aliceId"
+      bob expects "Chat content types: link, text"
+    }
+  }
+
+  @Test fun linkPreview_firstTimeAlert_disable_noPreview() = uiTest {
+    PreviewServer().use { server ->
+      val alice = app("alice")
+      showLinkPreviewsAlertViaApi()
+      val notes = alice.chatList.open("Private notes")
+      check(storedSetting(LINK_PREVIEWS) != "false") { "link previews are stored as off before the alert" }
+      val cat = server.url("cat.png")
+      typeInto(Ui.Chat.Message, cat)
+      poll(what = "the `Enable link previews?` alert with `Disable`") { seesText("Enable link previews?") && exists(DISABLE) }
+      click(DISABLE)
+      poll(what = "the alert closed and link previews stored as off") {
+        !seesText("Enable link previews?") && storedSetting(LINK_PREVIEWS) == "false" && storedSetting(LINK_PREVIEWS_ALERT) == "false"
+      }
+      awaitAppWork()
+      check(server.requests().isEmpty() && !exists(CANCEL_PREVIEW)) { "a preview after Disable; requests: ${server.requests()}" }
+      notes.sendComposed()
+      val id = notes.itemId(cat)
+      poll(what = "the note saved as text without a card") {
+        notes.item(id)?.content?.msgContent is MsgContent.MCText && "link preview image" !in descriptionsOf(Ui.Chat.Item(id))
+      }
+      typeInto(Ui.Chat.Message, server.url("dog.png"))
+      awaitAppWork()
+      check(!seesText("Enable link previews?") && !exists(CANCEL_PREVIEW) && server.requests().isEmpty()) { "alert or preview for a link typed after Disable; requests: ${server.requests()}" }
+    }
+  }
+
+  private fun showLinkPreviewsAlertViaApi() = appPrefs.privacyLinkPreviewsShowAlert.set(true)
+
+  private fun UiScope.awaitAppWork() = poll(what = "the app to finish handling the typed link") { UiIdle.inFlight().isEmpty() }
+
+  private fun UiScope.pressShiftEnter(key: UiKey) {
+    val node = ui.onNode(matcher(key))
+    ui.runOnUiThread { node.performSemanticsAction(SemanticsActions.RequestFocus) }
+    ui.runOnUiThread { node.performKeyInput { withKeyDown(Key.ShiftLeft) { pressKey(Key.Enter) } } }
+    ui.waitForIdle()
+  }
+
+  private class PreviewServer : Closeable {
+    private val paths = CopyOnWriteArrayList<String>()
+    private val server = HttpServer.create(InetSocketAddress("127.0.0.1", 0), 0).apply {
+      createContext("/") { exchange ->
+        paths += exchange.requestURI.path
+        exchange.responseHeaders.add("Content-Type", "image/png")
+        exchange.sendResponseHeaders(200, PNG.size.toLong())
+        exchange.responseBody.use { it.write(PNG) }
+      }
+      start()
+    }
+
+    fun url(name: String) = "http://127.0.0.1:${server.address.port}/$name"
+
+    fun requests(): List<String> = paths.toList()
+
+    override fun close() = server.stop(0)
+  }
+
+  private companion object {
+    val ENABLE = Ui.Alert.Option(Ui.AlertSource.Shared, "enable")
+    val DISABLE = Ui.Alert.Option(Ui.AlertSource.Shared, "disable")
+    val CANCEL_PREVIEW = described("cancel link preview")
+    const val LINK_PREVIEWS = "PrivacyLinkPreviews"
+    const val LINK_PREVIEWS_ALERT = "PrivacyLinkPreviewsShowAlert"
+    val PNG: ByteArray = ByteArrayOutputStream().also { ImageIO.write(BufferedImage(16, 16, BufferedImage.TYPE_INT_RGB), "png", it) }.toByteArray()
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/CopyShareDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/CopyShareDesktopTest.kt
new file mode 100644
index 0000000000..83672bc5e1
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/CopyShareDesktopTest.kt
@@ -0,0 +1,69 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.itemFileOf
+import chat.simplex.app.ui.harness.sendsFileTo
+import chat.simplex.common.model.CIFileStatus
+import chat.simplex.common.simplexWindowState
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.io.File
+
+class CopyShareDesktopTest : UiTest() {
+  @Test fun copy_text_toClipboardAndToast() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice hello there"
+    bob sends "@alice second line"
+    val chat = alice.chatList.open("bob")
+    chat.itemId("hello there")
+    chat.itemId("second line")
+    val before = copiedToasts()
+    setClipboardText("unrelated")
+    chat.menu("hello there", "copy")
+    poll(what = "`hello there` on the clipboard and the `Copied to clipboard` toast") { clipboardText() == "hello there" && copiedToasts() == before + 1 }
+    setClipboardText("unrelated")
+    chat.menu("second line", "share")
+    poll(what = "`second line` on the clipboard from Share and a second toast") { clipboardText() == "second line" && copiedToasts() == before + 2 }
+  }
+
+  @Test fun copy_fileItem_copiesPath() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob.sendsFileTo("alice", bob.createFile(NOTES_NAME, NOTES), 1, NOTES_NAME)
+    val chat = alice.chatList.open("bob")
+    val id = chat.itemId("the item of $NOTES_NAME") { it.file?.fileName == NOTES_NAME }
+    rightClick(Ui.Chat.Item(id))
+    click(Ui.Chat.ItemMenu(id, "download"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "$NOTES_NAME received") { itemFileOf(id)?.fileStatus is CIFileStatus.RcvComplete }
+    check(itemFileOf(id)?.fileSource?.cryptoArgs != null) { "$NOTES_NAME is stored unencrypted" }
+    val copied = copiedToasts()
+    setClipboardText(null)
+    rightClick(Ui.Chat.Item(id))
+    click(Ui.Chat.ItemMenu(id, "copy"))
+    poll(what = "the path of a readable copy of $NOTES_NAME on the clipboard and the `Copied to clipboard` toast") {
+      clipboardText()?.let { File(it).isFile && File(it).readText() == NOTES } == true && copiedToasts() == copied + 1
+    }
+    val target = File(exchangeDir(), "shared-$NOTES_NAME")
+    val saved = toasts().count { it == "File saved" }
+    check(!target.exists()) { "${target.name} exists before Share" }
+    rightClick(Ui.Chat.Item(id))
+    saveFileAs(target) { click(Ui.Chat.ItemMenu(id, "share")) }
+    poll(what = "the decrypted $NOTES_NAME written to ${target.name} and the `File saved` toast") {
+      target.length() == NOTES.length.toLong() && toasts().count { it == "File saved" } == saved + 1
+    }
+    assertEquals(NOTES, target.readText())
+  }
+
+  private fun toasts(): List<String> = simplexWindowState.toasts.toList().map { it.first }
+
+  private fun copiedToasts(): Int = toasts().count { it == "Copied to clipboard" }
+
+  private companion object {
+    const val NOTES_NAME = "copy-notes.md"
+    const val NOTES = "Shopping list from bob: apples and pears"
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/DraftDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/DraftDesktopTest.kt
new file mode 100644
index 0000000000..8ae393d27f
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/DraftDesktopTest.kt
@@ -0,0 +1,35 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+import java.io.File
+import kotlin.io.path.createTempDirectory
+
+class DraftDesktopTest : UiTest() {
+  @Test fun draft_withAttachment_restored() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val source = File(createTempDirectory("uitest-draft").toFile(), "report.txt").apply { writeText(REPORT) }
+    val bobId = alice.chatList.chatId("bob"); val notesId = alice.chatList.chatId("Private notes")
+    alice.chatList.open("bob")
+    waitFor(Ui.Chat.Message)
+    check(!seesDescription("Cancel file preview")) { "a file preview is shown before the paste" }
+    enterText(Ui.Chat.Message, source.absolutePath)
+    poll(what = "the preview of report.txt") { seesDescription("Cancel file preview") && seesText("report.txt") }
+    alice.chatList.open("Private notes")
+    poll(what = "notes without the preview") { chatModel.chatId.value == notesId && exists(Ui.Chat.Message) && !seesDescription("Cancel file preview") }
+    alice.chatList.open("bob")
+    poll(what = "the preview restored") { chatModel.chatId.value == bobId && seesDescription("Cancel file preview") && seesText("report.txt") }
+    click(Ui.Chat.Send)
+    bob.eventuallyMessage("alice> sends file report.txt (${REPORT.length} bytes / ${REPORT.length} bytes)", CONNECT_TIMEOUT_MS)
+    bob expects "use /fr 1 [<dir>/ | <path>] to receive it"
+  }
+
+  private companion object {
+    const val REPORT = "Quarterly report kept in a draft"
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/EditMessageDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/EditMessageDesktopTest.kt
new file mode 100644
index 0000000000..e79fa18602
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/EditMessageDesktopTest.kt
@@ -0,0 +1,98 @@
+package chat.simplex.app.ui.desktop
+
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.compose.ui.test.pressKey
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.common.model.MsgContent
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.File
+import kotlin.io.path.createTempDirectory
+
+class EditMessageDesktopTest : UiTest() {
+  @Test fun edit_upArrow_editsLastMessage() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("first")
+    bob expectsMessage "alice> first"
+    chat.send("second")
+    bob expectsMessage "alice> second"
+    bob sends "@alice from bob"
+    chat.itemId("from bob")
+    check(editableText(Ui.Chat.Message).isNullOrEmpty() && !exists(described("Cancel"))) { "the message field is not empty or already editing before Up" }
+    pressUp(Ui.Chat.Message)
+    poll(what = "the edit bar with alice's last message `second`") { editableText(Ui.Chat.Message) == "second" && exists(described("Cancel")) }
+    chat.replaceAndSend("second!")
+    bob expectsMessage "alice> [edited] second!"
+    typeInto(Ui.Chat.Message, "x")
+    pressUp(Ui.Chat.Message)
+    assertTrue("Up with text in the field started editing", editableText(Ui.Chat.Message) == "x" && !exists(described("Cancel")))
+  }
+
+  @Test fun edit_ownFile_keepsFileWithoutPreview() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val dir = createTempDirectory("uitest-edit-file").toFile()
+    val source = File(dir, "report.txt").apply { writeText(REPORT) }
+    val chat = alice.chatList.open("bob")
+    waitFor(Ui.Chat.Message)
+    enterText(Ui.Chat.Message, source.absolutePath)
+    poll(what = "the report.txt preview with `Cancel file preview`") {
+      seesDescription("Cancel file preview") && seesText("report.txt") && editableText(Ui.Chat.Message).isNullOrEmpty()
+    }
+    typeInto(Ui.Chat.Message, "doc")
+    click(Ui.Chat.Send)
+    bob.eventuallyMessage("alice> doc", CONNECT_TIMEOUT_MS)
+    bob expectsMessage "alice> sends file report.txt (${REPORT.length} bytes / ${REPORT.length} bytes)"
+    bob expects "use /fr 1 [<dir>/ | <path>] to receive it"
+    val id = fileItemId("report.txt")
+    poll(what = "the sent preview cleared and report.txt shown in the item") {
+      !seesDescription("Cancel file preview") && "report.txt" in textsOf(Ui.Chat.Item(id))
+    }
+    val shown = texts().count { it == "report.txt" }
+    rightClick(Ui.Chat.Item(id))
+    click(Ui.Chat.ItemMenu(id, "edit"))
+    poll(what = "the edit bar with `doc`, no compose file preview and no `Cancel file preview`") {
+      editableText(Ui.Chat.Message) == "doc" && exists(described("Cancel")) && texts().count { it == "report.txt" } == shown && !seesDescription("Cancel file preview")
+    }
+    chat.replaceAndSend("new doc")
+    bob expectsMessage "alice> [edited] new doc"
+    poll(what = "the edited item `new doc` still a file item showing report.txt") {
+      val item = chatModel.chatsContext.chatItems.value.firstOrNull { it.id == id }
+      item != null && item.content.msgContent is MsgContent.MCFile && item.content.text == "new doc" && "report.txt" in textsOf(Ui.Chat.Item(id))
+    }
+    chat.send("ping")
+    bob expectsMessage "alice> ping"
+  }
+
+  private fun UiScope.pressUp(key: UiKey) {
+    val node = ui.onNode(matcher(key))
+    ui.runOnUiThread { node.performSemanticsAction(SemanticsActions.RequestFocus) }
+    ui.runOnUiThread { node.performKeyInput { pressKey(Key.DirectionUp) } }
+    ui.waitForIdle()
+  }
+
+  private fun UiScope.fileItemId(name: String): Long {
+    var id: Long? = null
+    poll(what = "the item of file `$name`") {
+      id = chatModel.chatsContext.chatItems.value.lastOrNull { it.content.msgContent is MsgContent.MCFile && it.file?.fileName == name }?.id
+      id?.let { exists(Ui.Chat.Item(it)) } == true
+    }
+    return id!!
+  }
+
+  private companion object {
+    const val REPORT = "Quarterly report edited by Bob."
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/HelpDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/HelpDesktopTest.kt
new file mode 100644
index 0000000000..1c66340076
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/HelpDesktopTest.kt
@@ -0,0 +1,42 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.helpAndSupport
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import org.junit.Test
+
+private const val MAILTO = "mailto:chat@simplex.chat"
+private const val CONTRIBUTE = "https://github.com/simplex-chat/simplex-chat#contribute"
+private const val STAR = "https://github.com/simplex-chat/simplex-chat"
+
+class HelpDesktopTest : UiTest() {
+  @Test fun help_contributeAndStar() = uiTest {
+    val alice = app("alice")
+    helpAndSupport(alice)
+    check(opened().isEmpty()) { "links opened before any tap: ${opened()}" }
+    click(Ui.Help.Email)
+    poll(what = "the mailto link opened without a confirmation") { opened() == listOf(MAILTO) && !AlertManager.shared.hasAlertsShown() }
+    click(Ui.Help.Contribute)
+    awaitExternalLinkAlert(CONTRIBUTE)
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the alert closed by Cancel") { !AlertManager.shared.hasAlertsShown() }
+    check(opened() == listOf(MAILTO)) { "Cancel opened the link: ${opened()}" }
+    click(Ui.Help.Contribute)
+    awaitExternalLinkAlert(CONTRIBUTE)
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the Contribute link opened after Open") { opened() == listOf(MAILTO, CONTRIBUTE) && !AlertManager.shared.hasAlertsShown() }
+    click(Ui.Help.Star)
+    awaitExternalLinkAlert(STAR)
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the Star on GitHub link opened after Open") { opened() == listOf(MAILTO, CONTRIBUTE, STAR) }
+  }
+
+  private fun UiScope.opened(): List<String> = synchronized(uriHandler.opened) { uriHandler.opened.toList() }
+
+  private fun UiScope.awaitExternalLinkAlert(url: String) =
+    poll(what = "the Open external link? alert for $url with Open") {
+      seesText("Open external link?") && seesText(url) && "Open" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ItemInfoDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ItemInfoDesktopTest.kt
new file mode 100644
index 0000000000..91a32db3c0
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ItemInfoDesktopTest.kt
@@ -0,0 +1,36 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.common.model.localTimestamp
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class ItemInfoDesktopTest : UiTest() {
+  @Test fun info_share_copiesText() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice question"
+    val chat = alice.chatList.open("bob")
+    chat.itemId("question")
+    chat.menu("question", "reply")
+    chat.send("answer")
+    bob expectsMessage "alice> > question"
+    bob expects "      answer"
+    val id = chat.itemId("answer")
+    chat.itemInfo("answer")
+    setClipboardText("unrelated")
+    click(Ui.ItemInfo.Share)
+    var shared = ""
+    poll(what = "the item info text on the clipboard after Share") { shared = clipboardText().orEmpty(); shared.startsWith("# Sent message") }
+    val sentAt = localTimestamp(chat.item(id)!!.meta.itemTs)
+    check(shared.startsWith("# Sent message\n\nSent at: $sentAt\n")) { "the shared info does not start with the title and `Sent at: $sentAt`: `$shared`" }
+    val lines = shared.lines()
+    check("## In reply to" in lines && "question" in lines) { "the shared info has no `In reply to` section with bob's `question`: `$shared`" }
+    check("## History" in lines && shared.endsWith(" (current)\nanswer")) { "the shared info has no history ending with the current `answer`: `$shared`" }
+    val notesId = alice.chatList.chatId("Private notes")
+    click(Ui.ChatList.Row(notesId))
+    poll(what = "the notes open and the item info closed") { chatModel.chatId.value == notesId && !exists(Ui.ItemInfo.Share) && !seesText("Sent message") }
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/LockDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/LockDesktopTest.kt
new file mode 100644
index 0000000000..c62a2117d7
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/LockDesktopTest.kt
@@ -0,0 +1,525 @@
+package chat.simplex.app.ui.desktop
+
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.test.onRoot
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.pressKey
+import androidx.compose.ui.test.withKeyDown
+import chat.simplex.app.ui.harness.ChatDataScreen
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.LockScreen
+import chat.simplex.app.ui.harness.LockScreen.Companion.CONFIRM_PASSCODE
+import chat.simplex.app.ui.harness.LockScreen.Companion.ENTER_PASSCODE
+import chat.simplex.app.ui.harness.LockScreen.Companion.NEW_PASSCODE
+import chat.simplex.app.ui.harness.LockScreen.Companion.PASSCODE_SET
+import chat.simplex.app.ui.harness.PasscodeScreen
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.chatRunningInCore
+import chat.simplex.app.ui.harness.closeDeveloperTools
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.developerTools
+import chat.simplex.app.ui.harness.newGroupsViaApi
+import chat.simplex.app.ui.harness.openProfileMenu
+import chat.simplex.app.ui.harness.userIdOf
+import chat.simplex.app.ui.harness.userShowsNtfs
+import chat.simplex.app.ui.harness.yourPrivacy
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.AppLock
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.util.Base64
+
+class LockDesktopTest : UiTest() {
+  @Test fun lock_enable_setsPasscode() = uiTest {
+    val alice = app("alice")
+    val privacy = yourPrivacy(alice)
+    check("Off" in textsOf(Ui.Privacy.Lock)) { "SimpleX Lock before enabling: ${textsOf(Ui.Privacy.Lock)}" }
+    val lock = privacy.lock()
+    check(!exists(Ui.Lock.Delay) && !exists(Ui.Lock.ChangePasscode) && !exists(Ui.Lock.SelfDestruct)) { "lock options shown while the lock is off" }
+    check(storedSetting(PERFORM_LA) != "true" && storedSetting(APP_PASSCODE) == null) { "the lock is stored as on before enabling" }
+    click(Ui.Lock.Enable)
+    lock.passcode.await(NEW_PASSCODE)
+    lock.passcode.enter(CODE)
+    click(Ui.Passcode.Cancel)
+    poll(what = "the New Passcode screen to close") { lock.passcode.gone() && exists(Ui.Lock.Enable) }
+    check(storedSetting(PERFORM_LA) != "true" && storedSetting(APP_PASSCODE) == null && !exists(Ui.Lock.Delay)) { "Cancel turned the lock on" }
+    click(Ui.Lock.Enable)
+    lock.passcode.await(NEW_PASSCODE)
+    lock.passcode.enter(CODE)
+    lock.passcode.submit()
+    lock.passcode.await(CONFIRM_PASSCODE)
+    assertEquals("Confirm", lock.passcode.submitLabel())
+    lock.passcode.enter(MISMATCH)
+    lock.passcode.submit()
+    check(seesText(CONFIRM_PASSCODE) && !AlertManager.shared.hasAlertsShown() && storedSetting(APP_PASSCODE) == null) { "a mismatched confirmation was accepted" }
+    lock.passcode.backspace()
+    lock.passcode.backspace()
+    lock.passcode.enter(CODE.takeLast(2))
+    lock.passcode.submit()
+    lock.passcode.confirmAlert(PASSCODE_SET)
+    poll(what = "the lock stored as on with the passcode") { storedSetting(PERFORM_LA) == "true" && storedSetting(LOCK_DELAY) == "30" && decoded(APP_PASSCODE) == CODE }
+    check(textOf(Ui.Lock.Delay) == "30 seconds" && exists(Ui.Lock.ChangePasscode) && exists(Ui.Lock.SelfDestruct)) { "lock options after enabling: ${texts().take(30)}" }
+    escape()
+    poll(what = "Your privacy showing SimpleX Lock as Passcode") { !exists(Ui.Lock.Enable) && "Passcode" in textsOf(Ui.Privacy.Lock) }
+  }
+
+  @Test fun lock_screenOnStartup_wrongThenCorrect() = uiTest {
+    val alice = app("alice")
+    yourPrivacy(alice).lock().apply { enable(CODE); close() }
+    val current = restart()
+    val passcode = PasscodeScreen(this)
+    passcode.await(ENTER_PASSCODE)
+    check(seesText("Unlock") && passcode.submitLabel() == "Submit" && AppLock.userAuthorized.value == false) { "the startup passcode screen: ${texts().take(30)}" }
+    passcode.enter(WRONG)
+    passcode.submit()
+    passcode.authFailed()
+    poll(what = "the Unlock button instead of the app") { exists(Ui.Lock.Unlock) && passcode.gone() }
+    check(AppLock.userAuthorized.value == false) { "a wrong passcode unlocked the app" }
+    click(Ui.Lock.Unlock)
+    passcode.await(ENTER_PASSCODE)
+    passcode.enter(CODE)
+    passcode.submit()
+    awaitUnlocked(passcode)
+    val notes = current.chatList.open(NOTES)
+    notes.send(NOTE)
+    notes.itemId(NOTE)
+  }
+
+  @Test fun lock_changePasscode_newPasscodeUnlocks() = uiTest {
+    val alice = app("alice")
+    val lock = yourPrivacy(alice).lock()
+    lock.enable(CODE)
+    click(Ui.Lock.ChangePasscode)
+    lock.passcode.await(CURRENT_PASSCODE)
+    lock.passcode.enter(WRONG)
+    lock.passcode.submit()
+    lock.passcode.authFailed()
+    check(decoded(APP_PASSCODE) == CODE && !seesText(NEW_PASSCODE)) { "a wrong current passcode opened the change" }
+    click(Ui.Lock.ChangePasscode)
+    lock.passcode.await(CURRENT_PASSCODE)
+    lock.passcode.enter(CODE)
+    lock.passcode.submit()
+    lock.passcode.await(NEW_PASSCODE)
+    check(seesText("App passcode")) { "the New Passcode screen does not name the app passcode: ${texts().take(30)}" }
+    lock.passcode.enter(NEW_CODE)
+    lock.passcode.submit()
+    lock.passcode.await(CONFIRM_PASSCODE)
+    lock.passcode.enter(NEW_CODE)
+    lock.passcode.submit()
+    lock.passcode.confirmAlert("Passcode changed!")
+    poll(what = "the new passcode stored") { decoded(APP_PASSCODE) == NEW_CODE }
+    lock.close()
+    restart()
+    val passcode = PasscodeScreen(this)
+    passcode.await(ENTER_PASSCODE)
+    passcode.enter(NEW_CODE)
+    passcode.submit()
+    awaitUnlocked(passcode)
+  }
+
+  @Test fun lock_disable_requiresPasscode() = uiTest {
+    val alice = app("alice")
+    val lock = yourPrivacy(alice).lock()
+    lock.enable(CODE)
+    click(Ui.Lock.Enable)
+    lock.passcode.await(ENTER_PASSCODE)
+    check(seesText("Disable SimpleX Lock")) { "the passcode prompt does not say it disables the lock: ${texts().take(30)}" }
+    lock.passcode.enter(WRONG)
+    lock.passcode.submit()
+    lock.passcode.authFailed()
+    check(storedSetting(PERFORM_LA) == "true" && decoded(APP_PASSCODE) == CODE && exists(Ui.Lock.ChangePasscode)) { "a wrong passcode turned the lock off" }
+    click(Ui.Lock.Enable)
+    lock.passcode.await(ENTER_PASSCODE)
+    lock.passcode.enter(CODE)
+    lock.passcode.submit()
+    poll(what = "the lock stored as off and its options hidden") {
+      lock.passcode.gone() && storedSetting(PERFORM_LA) == "false" && storedSetting(APP_PASSCODE) == null && !exists(Ui.Lock.ChangePasscode) && !exists(Ui.Lock.Delay)
+    }
+    lock.close()
+    val after = restart()
+    poll(what = "the app open without a passcode screen") { AppLock.userAuthorized.value == true && after.chatList.shown(NOTES) }
+    check(!seesText(ENTER_PASSCODE) && !exists(Ui.Passcode.Submit)) { "a passcode screen after the lock was turned off" }
+  }
+
+  @Test fun lock_relocksAfterDelay() = uiTest {
+    val alice = app("alice")
+    val lock = yourPrivacy(alice).lock()
+    lock.enable(CODE)
+    lock.close()
+    hideAndReturn()
+    settle()
+    check(AppLock.userAuthorized.value == true && !exists(Ui.Passcode.Submit)) { "the app locked on return before 30 seconds passed" }
+    val again = yourPrivacy(alice).lock()
+    click(Ui.Lock.Delay)
+    for ((delay, name) in DELAYS) {
+      check(name in textsOf(Ui.Lock.Delay.option(delay))) { "Lock after option $delay is not `$name`: ${textsOf(Ui.Lock.Delay.option(delay))}" }
+    }
+    click(Ui.Lock.Delay.option(0))
+    poll(what = "Immediately shown and stored") { textOf(Ui.Lock.Delay) == "Immediately" && storedSetting(LOCK_DELAY) == "0" }
+    again.close()
+    hideAndReturn()
+    val passcode = PasscodeScreen(this)
+    passcode.await(ENTER_PASSCODE)
+    check(AppLock.userAuthorized.value == false) { "the passcode screen shows but the app is authorized" }
+    passcode.enter(CODE)
+    passcode.submit()
+    awaitUnlocked(passcode)
+  }
+
+  @Test fun selfDestruct_triggeredOnLockScreen() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice $BEFORE_WIPE"
+    poll(what = "bob's message on the row") { BEFORE_WIPE in alice.chatList.rowTexts("bob") }
+    val lock = yourPrivacy(alice).lock()
+    lock.enable(CODE)
+    check(storedSetting(SELF_DESTRUCT) != "true" && !exists(Ui.Lock.SelfDestructName)) { "self-destruct is on before enabling" }
+    click(Ui.Lock.SelfDestruct)
+    lock.passcode.await(CURRENT_PASSCODE)
+    lock.passcode.enter(CODE)
+    lock.passcode.submit()
+    lock.passcode.await(SET_PASSCODE)
+    check(seesText("Enable self-destruct passcode")) { "the Set passcode screen does not name self-destruct: ${texts().take(30)}" }
+    lock.passcode.enter(CODE)
+    lock.passcode.submit()
+    check(seesText(SET_PASSCODE) && !seesText(CONFIRM_PASSCODE) && lock.passcode.submitLabel() == "Save") { "the app passcode was accepted as the self-destruct passcode" }
+    lock.passcode.clear()
+    lock.passcode.enter(SD_CODE)
+    lock.passcode.submit()
+    lock.passcode.await(CONFIRM_PASSCODE)
+    lock.passcode.enter(SD_CODE)
+    lock.passcode.submit()
+    lock.passcode.confirmAlert("Self-destruct passcode enabled!")
+    poll(what = "self-destruct stored as on with its passcode") { storedSetting(SELF_DESTRUCT) == "true" && decoded(SD_PASSCODE) == SD_CODE && exists(Ui.Lock.SelfDestructName) }
+    typeInto(Ui.Lock.SelfDestructName, WIPED_NAME)
+    poll(what = "the new display name stored") { storedSetting(SD_NAME) == WIPED_NAME }
+    lock.close()
+    restart()
+    val passcode = PasscodeScreen(this)
+    passcode.await(ENTER_PASSCODE)
+    passcode.enter(SD_CODE)
+    passcode.submit()
+    poll(timeoutMs = 30_000, what = "the app opened as $WIPED_NAME without bob") {
+      AppLock.userAuthorized.value == true && chatModel.currentUser.value?.displayName == WIPED_NAME && chatModel.chats.value.none { it.chatInfo.chatViewName == "bob" }
+    }
+    assertEquals(listOf(WIPED_NAME), coreUserNames())
+    check(decoded(APP_PASSCODE) == SD_CODE && storedSetting(SD_PASSCODE) == null && storedSetting(SELF_DESTRUCT) == "false" && storedSetting(SD_NAME) == null) {
+      "after the wipe: app passcode ${decoded(APP_PASSCODE)}, self-destruct passcode stored ${storedSetting(SD_PASSCODE) != null}, self-destruct ${storedSetting(SELF_DESTRUCT)}, name ${storedSetting(SD_NAME)}"
+    }
+    restart()
+    passcode.await(ENTER_PASSCODE)
+    passcode.enter(SD_CODE)
+    passcode.submit()
+    awaitUnlocked(passcode)
+    check(chatModel.currentUser.value?.displayName == WIPED_NAME && coreUserNames() == listOf(WIPED_NAME)) { "the self-destruct code wiped the data again: ${coreUserNames()}" }
+  }
+
+  @Test fun lock_protectedActionsPrompt() = uiTest {
+    val alice = app("alice")
+    yourPrivacy(alice).lock().apply { enable(CODE); close() }
+    val passcode = PasscodeScreen(this)
+    developerTools(alice)
+    click(Ui.DevTools.Console)
+    passcode.await("Open chat console")
+    check(seesText(LOG_IN_REASON) && !exists(Ui.Chat.Message)) { "the console prompt: ${texts().take(30)}" }
+    passcode.enter(CODE)
+    passcode.submit()
+    poll(what = "the chat console after the passcode") { passcode.gone() && !exists(Ui.Lock.Unlock) && exists(Ui.Chat.Message) }
+    escape()
+    poll(what = "the chat console to close") { !exists(Ui.Chat.Message) && exists(Ui.DevTools.Console) }
+    closeDeveloperTools()
+    alice.settings()
+    click(Ui.Settings.Migrate)
+    passcode.await("Open migration screen")
+    passcode.enter(WRONG)
+    passcode.submit()
+    poll(what = "the passcode screen closed with only Unlock left") { passcode.gone() && exists(Ui.Lock.Unlock) }
+    check(!seesText(MIGRATE_TITLE)) { "a wrong passcode opened the migration screen" }
+    click(Ui.Lock.Unlock)
+    passcode.await("Open migration screen")
+    click(Ui.Passcode.Cancel)
+    poll(what = "the passcode screen cancelled with Unlock left") { passcode.gone() && exists(Ui.Lock.Unlock) }
+    check(!seesText(MIGRATE_TITLE)) { "cancelling the passcode opened the migration screen" }
+    escape()
+    poll(what = "Unlock closed back to Your settings") { !exists(Ui.Lock.Unlock) && exists(Ui.Settings.Database) }
+    check(!seesText(MIGRATE_TITLE)) { "closing Unlock opened the migration screen" }
+    click(Ui.Settings.Database)
+    ChatDataScreen(this).management()
+    stopChatAndConfirm()
+    passcode.await("Stop chat")
+    passcode.enter(WRONG)
+    passcode.submit()
+    passcode.authFailed()
+    check(chatRunningInCore() && chatModel.chatRunning.value == true && seesText("Chat is running")) { "a wrong passcode stopped the chat" }
+    stopChatAndConfirm()
+    passcode.await("Stop chat")
+    passcode.enter(CODE)
+    passcode.submit()
+    poll(what = "the chat stopped after the passcode") { passcode.gone() && seesText("Chat is stopped") && !chatRunningInCore() }
+  }
+
+  @Test fun profiles_actionsRequireAuthOnceWhenLocked() = uiTest {
+    val alice = app("alice")
+    yourPrivacy(alice).lock().apply { enable(CODE); close() }
+    val aliceId = userIdOf("alice")
+    val passcode = PasscodeScreen(this)
+    val profiles = alice.userPicker().profiles()
+    waitFor(Ui.Profiles.Add)
+    check(!exists(Ui.Passcode.Submit) && !exists(Ui.Lock.Unlock)) { "opening Your chat profiles asked for the passcode" }
+    click(Ui.Profiles.Add)
+    passcode.await(CHANGE_PROFILES)
+    check(!exists(Ui.NewProfile.Name)) { "the new profile screen opened before the passcode" }
+    passcode.enter(CODE)
+    passcode.submit()
+    poll(what = "the new profile screen after the passcode") { passcode.gone() && !exists(Ui.Lock.Unlock) && exists(Ui.NewProfile.Name) }
+    typeInto(Ui.NewProfile.Name, WORK)
+    click(Ui.NewProfile.Create)
+    poll(what = "`$WORK` active and the new profile screen closed") { chatModel.currentUser.value?.displayName == WORK && !exists(Ui.NewProfile.Create) }
+    waitFor(Ui.Profiles.User(aliceId))
+    openProfileMenu(aliceId, "mute")
+    click(Ui.Profiles.UserMenu(aliceId, "mute"))
+    poll(what = "alice muted") { userShowsNtfs(aliceId) == false }
+    check(!exists(Ui.Passcode.Submit) && !exists(Ui.Lock.Unlock)) { "the second profile action asked for the passcode again" }
+    profiles.close()
+    alice.userPicker().profiles()
+    waitFor(Ui.Profiles.User(aliceId))
+    openProfileMenu(aliceId, "unmute")
+    click(Ui.Profiles.UserMenu(aliceId, "unmute"))
+    passcode.await(CHANGE_PROFILES)
+    check(userShowsNtfs(aliceId) == false) { "alice was unmuted before the passcode" }
+    passcode.enter(CODE)
+    passcode.submit()
+    poll(what = "alice unmuted after the passcode in the reopened profiles screen") { passcode.gone() && userShowsNtfs(aliceId) == true }
+  }
+
+  @KnownAppIssue("15.5 item 23", "waiting for the SimpleX Lock notice with `Turn on`", intermittent = true)
+  @Test fun lock_noticeOfferedWithManyChats() = uiTest {
+    app("alice")
+    clearLockNoticeShownViaApi()
+    var current = restart()
+    poll(what = "the chat list after the restart") { current.chatList.shown(NOTES) }
+    settle()
+    check(chatModel.chats.value.size <= 3 && !AlertManager.shared.hasAlertsShown() && storedSetting(LA_NOTICE_SHOWN) == "false") {
+      "with ${chatModel.chats.value.size} chats: alert shown ${AlertManager.shared.hasAlertsShown()}, notice stored ${storedSetting(LA_NOTICE_SHOWN)}"
+    }
+    newGroupsViaApi("first", "second", "third")
+    current = restart()
+    poll(what = "the SimpleX Lock notice with `Turn on`") { seesText(LOCK_NOTICE_TEXT, substring = true) && "Turn on" in textsOf(CONFIRM) }
+    check(current.chatList.shown(NOTES) && chatModel.chats.value.size > 3 && storedSetting(LA_NOTICE_SHOWN) == "true" && storedSetting(PERFORM_LA) != "true") {
+      "the notice with ${chatModel.chats.value.size} chats: notice stored ${storedSetting(LA_NOTICE_SHOWN)}, lock ${storedSetting(PERFORM_LA)}"
+    }
+    click(CONFIRM)
+    val passcode = PasscodeScreen(this)
+    passcode.await(NEW_PASSCODE)
+    passcode.enter(CODE)
+    passcode.submit()
+    passcode.await(CONFIRM_PASSCODE)
+    passcode.enter(CODE)
+    passcode.submit()
+    passcode.confirmAlert("SimpleX Lock turned on")
+    poll(what = "the lock stored as on with the passcode") { storedSetting(PERFORM_LA) == "true" && decoded(APP_PASSCODE) == CODE && passcode.gone() }
+  }
+
+  @Test fun lock_passcodeKeypad_digitsBackspaceClearReveal() = uiTest {
+    val alice = app("alice")
+    val lock = yourPrivacy(alice).lock()
+    click(Ui.Lock.Enable)
+    lock.passcode.await(NEW_PASSCODE)
+    check(entered().isNullOrEmpty()) { "the passcode field is not empty: ${entered()}" }
+    lock.passcode.enter("12345")
+    poll(what = "five masked digits") { entered() == "●●●●●" }
+    lock.passcode.backspace()
+    poll(what = "four masked digits after backspace") { entered() == "●●●●" }
+    click(Ui.Passcode.Entered)
+    poll(what = "the digits shown after clicking them") { entered() == "1234" }
+    click(Ui.Passcode.Entered)
+    poll(what = "the digits masked again") { entered() == "●●●●" }
+    lock.passcode.clear()
+    poll(what = "the field cleared") { entered().isNullOrEmpty() }
+    lock.passcode.submit()
+    settle()
+    check(seesText(NEW_PASSCODE) && !seesText(CONFIRM_PASSCODE)) { "Save accepted an empty passcode" }
+    lock.passcode.enter("123")
+    lock.passcode.submit()
+    settle()
+    check(seesText(NEW_PASSCODE) && !seesText(CONFIRM_PASSCODE)) { "Save accepted three digits" }
+    lock.passcode.enter("4")
+    lock.passcode.submit()
+    lock.passcode.await(CONFIRM_PASSCODE)
+    lock.passcode.enter(CODE)
+    lock.passcode.submit()
+    lock.passcode.confirmAlert(PASSCODE_SET)
+    poll(what = "the lock stored as on with the passcode") { storedSetting(PERFORM_LA) == "true" && decoded(APP_PASSCODE) == CODE }
+  }
+
+  @Test fun lock_passcodeKeyboardKeys() = uiTest {
+    val alice = app("alice")
+    val lock = yourPrivacy(alice).lock()
+    click(Ui.Lock.Enable)
+    lock.passcode.await(NEW_PASSCODE)
+    for (k in listOf(Key.One, Key.Two, Key.Three)) press(k)
+    poll(what = "three masked digits typed with the keyboard") { entered() == "●●●" }
+    click(Ui.Passcode.Entered)
+    poll(what = "the typed digits shown") { entered() == "123" }
+    press(Key.Enter)
+    check(seesText(NEW_PASSCODE) && !seesText(CONFIRM_PASSCODE)) { "Enter submitted three digits" }
+    press(Key.NumPad4)
+    poll(what = "the NumPad digit added") { entered() == "1234" }
+    press(Key.Backspace)
+    poll(what = "the last digit removed by Backspace") { entered() == "123" }
+    val root = ui.onRoot()
+    ui.runOnUiThread { root.performKeyInput { withKeyDown(Key.CtrlLeft) { pressKey(Key.Backspace) } } }
+    poll(what = "the field cleared by Ctrl+Backspace") { entered().isNullOrEmpty() }
+    for (k in listOf(Key.NumPad5, Key.Six, Key.NumPad7, Key.Eight)) press(k)
+    poll(what = "the new digits typed") { entered() == NEW_CODE }
+    press(Key.Enter)
+    lock.passcode.await(CONFIRM_PASSCODE)
+    for (k in listOf(Key.Five, Key.Six, Key.Seven, Key.Eight)) press(k)
+    poll(what = "four masked digits on the confirm step") { entered() == "●●●●" }
+    press(Key.NumPadEnter)
+    lock.passcode.confirmAlert(PASSCODE_SET)
+    poll(what = "the passcode typed with the keyboard stored") { storedSetting(PERFORM_LA) == "true" && decoded(APP_PASSCODE) == NEW_CODE }
+  }
+
+  @Test fun selfDestruct_changePasscode() = uiTest {
+    val alice = app("alice")
+    val lock = yourPrivacy(alice).lock()
+    lock.enable(CODE)
+    click(Ui.Lock.SelfDestructInfo)
+    poll(what = "the Self-destruct page with its three items") { SD_INFO.all { seesText(it) } && !exists(Ui.Lock.Enable) }
+    check(storedSetting(SELF_DESTRUCT) != "true") { "the info row turned self-destruct on" }
+    escape()
+    poll(what = "back on SimpleX Lock") { exists(Ui.Lock.Enable) && !seesText(SD_INFO.first()) }
+    enableSelfDestruct(lock, SD_CODE)
+    click(Ui.Lock.ChangeSelfDestruct)
+    lock.passcode.await(CURRENT_PASSCODE)
+    lock.passcode.enter(CODE)
+    lock.passcode.submit()
+    lock.passcode.await(NEW_PASSCODE)
+    check(seesText("Self-destruct")) { "the New Passcode screen does not name self-destruct: ${texts().take(30)}" }
+    lock.passcode.enter(NEW_SD_CODE)
+    lock.passcode.submit()
+    lock.passcode.await(CONFIRM_PASSCODE)
+    lock.passcode.enter(NEW_SD_CODE)
+    lock.passcode.submit()
+    lock.passcode.confirmAlert("Self-destruct passcode changed!")
+    poll(what = "the new self-destruct passcode stored, the app passcode kept") { decoded(SD_PASSCODE) == NEW_SD_CODE && decoded(APP_PASSCODE) == CODE }
+    click(Ui.Lock.SelfDestruct)
+    lock.passcode.await(CURRENT_PASSCODE)
+    lock.passcode.enter(WRONG)
+    lock.passcode.submit()
+    lock.passcode.authFailed()
+    check(storedSetting(SELF_DESTRUCT) == "true" && decoded(SD_PASSCODE) == NEW_SD_CODE) { "a wrong passcode turned self-destruct off" }
+    click(Ui.Lock.SelfDestruct)
+    lock.passcode.await(CURRENT_PASSCODE)
+    lock.passcode.enter(CODE)
+    lock.passcode.submit()
+    poll(what = "self-destruct off, its passcode removed and its options hidden") {
+      lock.passcode.gone() && storedSetting(SELF_DESTRUCT) == "false" && storedSetting(SD_PASSCODE) == null && storedSetting(SD_IV) == null &&
+        !exists(Ui.Lock.SelfDestructName) && !exists(Ui.Lock.ChangeSelfDestruct)
+    }
+    lock.close()
+    restart()
+    val passcode = PasscodeScreen(this)
+    passcode.await(ENTER_PASSCODE)
+    passcode.enter(NEW_SD_CODE)
+    passcode.submit()
+    passcode.authFailed()
+    check(AppLock.userAuthorized.value == false && coreUserNames() == listOf("alice")) { "the old self-destruct passcode acted after self-destruct was turned off: ${coreUserNames()}" }
+    poll(what = "the Unlock button") { exists(Ui.Lock.Unlock) && passcode.gone() }
+    click(Ui.Lock.Unlock)
+    passcode.await(ENTER_PASSCODE)
+    passcode.enter(CODE)
+    passcode.submit()
+    awaitUnlocked(passcode)
+  }
+
+  private fun UiScope.awaitUnlocked(passcode: PasscodeScreen) =
+    poll(what = "the passcode screen to close and the app to unlock") { passcode.gone() && !exists(Ui.Lock.Unlock) && AppLock.userAuthorized.value == true }
+
+  private fun UiScope.hideAndReturn() {
+    ui.runOnUiThread {
+      AppLock.appWasHidden()
+      AppLock.recheckAuthState()
+    }
+    ui.waitForIdle()
+  }
+
+  private fun UiScope.stopChatAndConfirm() {
+    click(Ui.Database.RunChat)
+    poll(what = "the Stop chat? alert with Stop") { seesText("Stop chat?") && "Stop" in textsOf(CONFIRM) }
+    click(CONFIRM)
+    poll(what = "the Stop chat? alert to close") { !seesText("Stop chat?") }
+  }
+
+  private fun UiScope.enableSelfDestruct(lock: LockScreen, code: String) {
+    click(Ui.Lock.SelfDestruct)
+    lock.passcode.await(CURRENT_PASSCODE)
+    lock.passcode.enter(CODE)
+    lock.passcode.submit()
+    lock.passcode.await(SET_PASSCODE)
+    lock.passcode.enter(code)
+    lock.passcode.submit()
+    lock.passcode.await(CONFIRM_PASSCODE)
+    lock.passcode.enter(code)
+    lock.passcode.submit()
+    lock.passcode.confirmAlert("Self-destruct passcode enabled!")
+    poll(what = "self-destruct stored as on with its passcode") { storedSetting(SELF_DESTRUCT) == "true" && decoded(SD_PASSCODE) == code && exists(Ui.Lock.ChangeSelfDestruct) }
+  }
+
+  private fun UiScope.entered(): String? = textOf(Ui.Passcode.Entered)
+
+  private fun UiScope.press(key: Key) {
+    val root = ui.onRoot()
+    ui.runOnUiThread { root.performKeyInput { pressKey(key) } }
+    ui.waitForIdle()
+  }
+
+  private fun clearLockNoticeShownViaApi() = appPrefs.laNoticeShown.set(false)
+
+  private fun UiScope.decoded(key: String): String? = storedSetting(key)?.let { String(Base64.getDecoder().decode(it)) }
+
+  private fun coreUserNames(): List<String> = runBlocking { chatController.listUsers(null) }.map { it.user.displayName }
+
+  private companion object {
+    const val CODE = "1234"
+    const val MISMATCH = "1243"
+    const val WRONG = "9999"
+    const val NEW_CODE = "5678"
+    const val SD_CODE = "4321"
+    const val WIPED_NAME = "wiped"
+    const val BEFORE_WIPE = "before the wipe"
+    const val NOTES = "Private notes"
+    const val NOTE = "written after unlocking"
+    const val CURRENT_PASSCODE = "Current Passcode"
+    const val SET_PASSCODE = "Set passcode"
+    const val PERFORM_LA = "PerformLA"
+    const val LOCK_DELAY = "LocalAuthenticationLockDelay"
+    const val APP_PASSCODE = "EncryptedAppPassphrase"
+    const val SD_PASSCODE = "EncryptedSelfDestructPassphrase"
+    const val SELF_DESTRUCT = "LocalAuthenticationSelfDestruct"
+    const val SD_NAME = "LocalAuthenticationSelfDestructDisplayName"
+    const val SD_IV = "InitializationVectorSelfDestructPassphrase"
+    const val LA_NOTICE_SHOWN = "LANoticeShown"
+    const val NEW_SD_CODE = "8765"
+    const val WORK = "work"
+    const val LOG_IN_REASON = "Log in using your credential"
+    const val MIGRATE_TITLE = "Migrate device"
+    const val CHANGE_PROFILES = "Change chat profiles"
+    const val LOCK_NOTICE_TEXT = "To protect your information, turn on SimpleX Lock."
+    val CONFIRM = Ui.Alert.Confirm(Ui.AlertSource.Shared)
+    val SD_INFO = listOf(
+      "If you enter your self-destruct passcode while opening the app:",
+      "All app data is deleted.",
+      "App passcode is replaced with self-destruct passcode.",
+      "An empty chat profile with the provided name is created, and the app opens as usual.",
+    )
+    val DELAYS = listOf(10 to "10 seconds", 30 to "30 seconds", 60 to "1 minutes", 180 to "3 minutes", 600 to "10 minutes", 0 to "Immediately")
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/NotesDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/NotesDesktopTest.kt
new file mode 100644
index 0000000000..28f4d5511d
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/NotesDesktopTest.kt
@@ -0,0 +1,66 @@
+package chat.simplex.app.ui.desktop
+
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.compose.ui.test.pressKey
+import androidx.compose.ui.test.withKeyDown
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.common.model.CIFile
+import chat.simplex.common.model.readCryptoFile
+import chat.simplex.common.platform.getLoadedFilePath
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.io.File
+
+class NotesDesktopTest : UiTest() {
+  @Test fun notes_pasteFile_storedLocally_deleteRemovesFile() = uiTest {
+    val alice = app("alice")
+    val source = File(exchangeDir(), "plan.txt").apply { writeText(PLAN) }
+    val notes = alice.chatList.open("Private notes")
+    waitFor(Ui.Chat.Message)
+    check(!seesDescription("Cancel file preview") && !seesText("plan.txt")) { "a file preview is shown before the paste" }
+    setClipboardText(source.absolutePath)
+    pressCtrlV(Ui.Chat.Message)
+    poll(what = "the preview of plan.txt, with the path not typed into the message field") {
+      seesDescription("Cancel file preview") && seesText("plan.txt") && editableText(Ui.Chat.Message).isNullOrEmpty()
+    }
+    click(Ui.Chat.Send)
+    val id = notes.itemId("the note with plan.txt") { it.file?.fileName == "plan.txt" }
+    var stored: File? = null
+    poll(what = "plan.txt stored in the app's files") {
+      stored = getLoadedFilePath(notes.item(id)?.file)?.let { File(it) }
+      stored?.exists() == true
+    }
+    check(stored!!.canonicalPath != source.canonicalPath) { "the note points at the pasted file instead of a stored copy" }
+    assertEquals(PLAN, storedText(notes.item(id)!!.file!!, stored!!))
+    rightClick(Ui.Chat.Item(id))
+    click(Ui.Chat.ItemMenu(id, "delete"))
+    poll(what = "the `Delete message?` alert with `Delete for me` and without `Delete for everyone`") { exists(FOR_ME) && !exists(FOR_EVERYONE) }
+    click(FOR_ME)
+    poll(what = "the note and its stored copy of plan.txt deleted") { notes.item(id) == null && !exists(Ui.Chat.Item(id)) && !stored!!.exists() }
+    assertEquals("the pasted source file changed", PLAN, source.readText())
+  }
+
+  private fun UiScope.pressCtrlV(key: UiKey) {
+    val node = ui.onNode(matcher(key))
+    ui.runOnUiThread { node.performSemanticsAction(SemanticsActions.RequestFocus) }
+    ui.runOnUiThread { node.performKeyInput { withKeyDown(Key.CtrlLeft) { pressKey(Key.V) } } }
+    ui.waitForIdle()
+  }
+
+  private fun storedText(file: CIFile, stored: File): String {
+    val args = file.fileSource?.cryptoArgs
+    return (if (args != null) readCryptoFile(stored.absolutePath, args) else stored.readBytes()).toString(Charsets.UTF_8)
+  }
+
+  private companion object {
+    const val PLAN = "Plan kept in private notes"
+    val FOR_ME = Ui.Alert.Option(Ui.AlertSource.Shared, "forMe")
+    val FOR_EVERYONE = Ui.Alert.Option(Ui.AlertSource.Shared, "forEveryone")
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/PrivacyDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/PrivacyDesktopTest.kt
new file mode 100644
index 0000000000..f75cfce936
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/PrivacyDesktopTest.kt
@@ -0,0 +1,108 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiEnv
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.msgContent
+import chat.simplex.app.ui.harness.yourPrivacy
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import com.sun.net.httpserver.HttpServer
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.io.File
+import java.net.InetAddress
+import java.net.InetSocketAddress
+import java.util.concurrent.CopyOnWriteArrayList
+
+class PrivacyDesktopTest : UiTest() {
+  @Test fun privacy_linkPreviewsOff_noPreview() = uiTest {
+    PreviewSite().use { site ->
+      val alice = app("alice"); val bob = cli("bob")
+      connect(bob)
+      val aliceChat = "@${bob.contactId("alice")}"
+      check(storedSetting(LINK_PREVIEWS) != "false") { "Send link previews is stored as off before it is turned off" }
+      val privacy = yourPrivacy(alice)
+      click(Ui.Privacy.LinkPreviews)
+      poll(what = "Send link previews stored as off") { storedSetting(LINK_PREVIEWS) == "false" }
+      privacy.close()
+      val chat = alice.chatList.open("bob")
+      val off = site.url("off.jpg")
+      typeInto(Ui.Chat.Message, off)
+      poll(what = "the app to finish handling the typed link") { UiIdle.inFlight().isEmpty() }
+      check(!seesDescription(PREVIEW_IMAGE) && site.requests.isEmpty()) { "with previews off: preview shown ${seesDescription(PREVIEW_IMAGE)}, requests ${site.requests}" }
+      chat.sendComposed()
+      bob.expectsMessage("alice> $off", CONNECT_TIMEOUT_MS)
+      assertEquals("text", bob.msgContent(aliceChat, off)?.get("type")?.jsonPrimitive?.content)
+      val again = yourPrivacy(alice)
+      click(Ui.Privacy.LinkPreviews)
+      poll(what = "Send link previews stored as on") { storedSetting(LINK_PREVIEWS) == "true" }
+      again.close()
+      val on = site.url("on.jpg")
+      typeInto(Ui.Chat.Message, on)
+      poll(what = "the on.jpg link preview in the compose area") { seesDescription(PREVIEW_IMAGE) && seesText("on.jpg") }
+      chat.sendComposed()
+      bob.expectsMessage("alice> $on", CONNECT_TIMEOUT_MS)
+      val content = bob.msgContent(aliceChat, on)
+      assertEquals("link", content?.get("type")?.jsonPrimitive?.content)
+      assertEquals("on.jpg", content?.get("preview")?.jsonObject?.get("title")?.jsonPrimitive?.content)
+      assertEquals(listOf("/on.jpg"), site.requests.toList())
+    }
+  }
+
+  @Test fun privacy_removeLinkTracking() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    disableLinkPreviewsViaApi()
+    check(storedSetting(SANITIZE_LINKS) != "true") { "Remove link tracking is stored as on before it is turned on" }
+    val chat = alice.chatList.open("bob")
+    enterText(Ui.Chat.Message, TRACKED_LINK)
+    poll(what = "the typed link kept with Remove link tracking off") { editableText(Ui.Chat.Message) == TRACKED_LINK }
+    chat.sendComposed()
+    bob.expectsMessage("alice> $TRACKED_LINK", CONNECT_TIMEOUT_MS)
+    val privacy = yourPrivacy(alice)
+    click(Ui.Privacy.SanitizeLinks)
+    poll(what = "Remove link tracking stored as on") { storedSetting(SANITIZE_LINKS) == "true" }
+    privacy.close()
+    enterText(Ui.Chat.Message, TRACKED_LINK)
+    poll(what = "the tracking parameter removed from the typed link") { editableText(Ui.Chat.Message) == CLEAN_LINK }
+    chat.sendComposed()
+    bob.expectsMessage("alice> $CLEAN_LINK", CONNECT_TIMEOUT_MS)
+  }
+
+  private fun disableLinkPreviewsViaApi() = appPrefs.privacyLinkPreviews.set(false)
+
+  private class PreviewSite : AutoCloseable {
+    val requests = CopyOnWriteArrayList<String>()
+    private val image = File(UiEnv.repoRoot, "tests/fixtures/test.jpg").readBytes()
+    private val server = HttpServer.create(InetSocketAddress(InetAddress.getByName(HOST), 0), 0).apply {
+      createContext("/") { exchange ->
+        requests.add(exchange.requestURI.path)
+        exchange.responseHeaders.add("Content-Type", "image/jpeg")
+        exchange.sendResponseHeaders(200, image.size.toLong())
+        exchange.responseBody.use { it.write(image) }
+      }
+      start()
+    }
+
+    fun url(name: String) = "http://$HOST:${server.address.port}/$name"
+
+    override fun close() = server.stop(0)
+  }
+
+  private companion object {
+    const val LINK_PREVIEWS = "PrivacyLinkPreviews"
+    const val PREVIEW_IMAGE = "link preview image"
+    const val NOTES = "Private notes"
+    const val HOST = "127.0.0.1"
+    const val SANITIZE_LINKS = "PrivacySanitizeLinks"
+    const val TRACKED_LINK = "https://example.com/page?q=chat&utm_source=app"
+    const val CLEAN_LINK = "https://example.com/page?q=chat"
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ReceiveFileDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ReceiveFileDesktopTest.kt
new file mode 100644
index 0000000000..4e4afb1f62
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/ReceiveFileDesktopTest.kt
@@ -0,0 +1,43 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.itemFileOf
+import chat.simplex.app.ui.harness.onEdt
+import chat.simplex.app.ui.harness.sendsFileTo
+import chat.simplex.common.model.CIFileStatus
+import chat.simplex.common.simplexWindowState
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.io.File
+
+class ReceiveFileDesktopTest : UiTest() {
+  @Test fun rcvFile_clickCompleted_opensSaveDialog() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob.sendsFileTo("alice", bob.createFile(LIST_NAME, LIST), 1, LIST_NAME)
+    val chat = alice.chatList.open("bob")
+    val id = chat.itemId("the item of $LIST_NAME") { it.file?.fileName == LIST_NAME }
+    val dialog = simplexWindowState.saveDialog
+    check(itemFileOf(id)?.fileStatus is CIFileStatus.RcvInvitation && !dialog.isAwaiting) { "$LIST_NAME was received or a save dialog was open before the click" }
+    click(Ui.Chat.ItemFile(id))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "$LIST_NAME received and the save dialog opened for it") {
+      itemFileOf(id)?.fileStatus is CIFileStatus.RcvComplete && dialog.isAwaiting
+    }
+    val first = File(exchangeDir(), "first-$LIST_NAME").apply { delete() }
+    onEdt { dialog.onResult(first) }
+    poll(what = "the received $LIST_NAME saved to ${first.name}") { !dialog.isAwaiting && first.length() == LIST.length.toLong() }
+    assertEquals(LIST, first.readText())
+    val second = File(exchangeDir(), "second-$LIST_NAME").apply { delete() }
+    saveFileAs(second) { click(Ui.Chat.ItemFile(id)) }
+    poll(what = "the completed $LIST_NAME saved again to ${second.name} after a click") { second.length() == LIST.length.toLong() }
+    assertEquals(LIST, second.readText())
+  }
+
+  private companion object {
+    const val LIST_NAME = "list.txt"
+    const val LIST = "Shopping list from bob: apples and pears"
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/RemoteDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/RemoteDesktopTest.kt
new file mode 100644
index 0000000000..014da0c86e
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/RemoteDesktopTest.kt
@@ -0,0 +1,114 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.App
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitMobileSession
+import chat.simplex.app.ui.harness.connectPeers
+import chat.simplex.app.ui.harness.connectRemoteCtrl
+import chat.simplex.app.ui.harness.endMobileSessionViaApi
+import chat.simplex.app.ui.harness.linkMobile
+import chat.simplex.app.ui.harness.linkMobileHost
+import chat.simplex.app.ui.harness.setDeviceName
+import chat.simplex.app.ui.harness.stopRemoteCtrl
+import chat.simplex.app.ui.harness.verifyRemoteCtrl
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.simplexWindowState
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class RemoteDesktopTest : UiTest() {
+  @Test fun linkMobile_newPairing_verifyAndConnect() = uiTest {
+    val alice = app("alice")
+    enableDeveloperToolsViaApi()
+    val mobile = cli("mobile")
+    mobile.setDeviceName(MOBILE)
+    val link = linkMobile(alice)
+    val desktopName = link.deviceName()
+    val invitation = link.addMobile()
+    check(!seesText("Verify connection") && !seesText("New mobile device")) { "the pairing screen shows a mobile before one connected" }
+    val offer = mobile.connectRemoteCtrl(invitation)
+    assertEquals("the controller name the mobile sees", desktopName, offer.ctrlName)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Verify connection` with `New mobile device` and the mobile's session code `${offer.sessionCode.take(23)}`") {
+      seesText("Verify connection") && seesText("New mobile device") && seesText(offer.sessionCode.take(23)) && !seesDescription("QR Code")
+    }
+    check(chatModel.currentRemoteHost.value == null) { "the desktop switched to the mobile before the mobile verified the session code" }
+    assertEquals("the controller name in the mobile's session", desktopName, mobile.verifyRemoteCtrl(offer.sessionCode))
+    val rh = awaitMobileSession(MOBILE)
+    alice.userPicker()
+    poll(what = "the user picker with the `$MOBILE` and `This device` pills and the mobile's profile") {
+      MOBILE in textsOf(Ui.UserPicker.Device(rh)) && "This device" in textsOf(Ui.UserPicker.Device(null)) &&
+        "mobile" in textsOf(Ui.UserPicker.User(chatModel.currentUser.value!!.userId))
+    }
+    escape()
+    poll(what = "the user picker to close") { !exists(Ui.UserPicker.Sheet) }
+    endMobileSessionViaApi(mobile)
+  }
+
+  @Test fun linkMobile_remoteChatsVisible_sendMessage() = uiTest {
+    val alice = app("alice")
+    enableDeveloperToolsViaApi()
+    val mobile = cli("mobile")
+    mobile.setDeviceName(MOBILE)
+    val bob = cli("bob")
+    connectPeers(mobile, bob)
+    check(chatModel.chats.value.none { it.chatInfo.chatViewName == "bob" }) { "alice has a chat with bob on the desktop" }
+    val rh = linkMobileHost(alice, mobile, MOBILE)
+    val bobId = alice.chatList.chatId("bob")
+    val row = Ui.ChatList.Row(bobId, rh)
+    poll(what = "the mobile's chat with bob in the desktop's chat list") { exists(row) && "bob" in textsOf(row) }
+    click(row)
+    poll(what = "the mobile's chat with bob to open") { chatModel.chatId.value == bobId }
+    ChatScreen(this).send("hi from desktop")
+    bob.eventuallyMessage("mobile> hi from desktop", CONNECT_TIMEOUT_MS)
+    bob sends "@mobile hello desktop"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's reply on the desktop") { seesText("hello desktop", substring = true) }
+    endMobileSessionViaApi(mobile)
+  }
+
+  @Test fun linkMobile_disconnectFromDesktop() = uiTest {
+    val alice = app("alice")
+    enableDeveloperToolsViaApi()
+    val mobile = cli("mobile")
+    mobile.setDeviceName(MOBILE)
+    val rh = linkMobileHost(alice, mobile, MOBILE)
+    alice.userPicker()
+    click(Ui.UserPicker.Device(rh).part("disconnect"))
+    mobile.eventually("remote controller stopped", CONNECT_TIMEOUT_MS)
+    backOnThisDevice(alice, rh)
+  }
+
+  @Test fun linkMobile_mobileStopsSession() = uiTest {
+    val alice = app("alice")
+    enableDeveloperToolsViaApi()
+    val mobile = cli("mobile")
+    mobile.setDeviceName(MOBILE)
+    val rh = linkMobileHost(alice, mobile, MOBILE)
+    check(disconnectedToasts() == 0) { "a `was disconnected` toast before the mobile stopped" }
+    mobile.stopRemoteCtrl()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Mobile $MOBILE was disconnected` toast") { disconnectedToasts() == 1 }
+    backOnThisDevice(alice, rh)
+  }
+
+  private fun UiScope.backOnThisDevice(alice: App, rh: Long) {
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice's own profile back on the desktop") {
+      chatModel.currentRemoteHost.value == null && chatModel.currentUser.value?.displayName == "alice" && !chatModel.switchingUsersAndHosts.value
+    }
+    alice.userPicker()
+    poll(what = "the user picker with only the `This device` pill and alice's profile") {
+      exists(Ui.UserPicker.Device(null)) && !exists(Ui.UserPicker.Device(rh)) && "alice" in textsOf(Ui.UserPicker.User(chatModel.currentUser.value!!.userId))
+    }
+  }
+
+  private fun enableDeveloperToolsViaApi() = appPrefs.developerTools.set(true)
+
+  private fun disconnectedToasts(): Int = simplexWindowState.toasts.toList().count { (text, _) -> MOBILE in text && "was disconnected" in text }
+
+  private companion object {
+    const val MOBILE = "Pixel test"
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/SendAttachmentDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/SendAttachmentDesktopTest.kt
new file mode 100644
index 0000000000..50b5ecc2d7
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/SendAttachmentDesktopTest.kt
@@ -0,0 +1,66 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.CliPeer
+import chat.simplex.app.ui.harness.UiEnv
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.onEdt
+import chat.simplex.app.ui.harness.openAttachmentSheet
+import chat.simplex.app.ui.harness.receivesFile
+import chat.simplex.common.simplexWindowState
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+import java.io.File
+
+class SendAttachmentDesktopTest : UiTest() {
+  @Test fun attachImage_textOnLastImageOnly() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val fixture = File(UiEnv.repoRoot, "tests/fixtures/test.jpg")
+    val first = fixture.copyTo(File(exchangeDir(), "first.jpg"), overwrite = true)
+    val second = fixture.copyTo(File(exchangeDir(), "second.jpg"), overwrite = true)
+    alice.chatList.open("bob")
+    waitFor(Ui.Chat.Message)
+    check(!seesDescription("Cancel image preview")) { "an image preview is shown before an image is picked" }
+    openAttachmentSheet()
+    openFiles(listOf(first)) { click(Ui.Chat.Attach("image")) }
+    poll(what = "the preview of first.jpg") { seesDescription("Cancel image preview") && seesDescription("preview image") }
+    click(described("Cancel image preview"))
+    poll(what = "the image preview removed") { !seesDescription("Cancel image preview") && !seesDescription("preview image") }
+    openAttachmentSheet()
+    openFiles(listOf(first, second)) { click(Ui.Chat.Attach("image")) }
+    poll(what = "the previews of first.jpg and second.jpg") { seesDescription("Cancel image preview") && seesDescription("preview image") }
+    typeInto(Ui.Chat.Message, "caption")
+    click(Ui.Chat.Send)
+    poll(what = "the previews and the caption cleared after Send") { !seesDescription("Cancel image preview") && editableText(Ui.Chat.Message).isNullOrEmpty() }
+    val firstName = bob.receivesImageOffer(1)
+    bob expectsMessage "alice> caption"
+    val secondName = bob.receivesImageOffer(2)
+    bob.receivesFile(1, firstName, "alice")
+    bob.receivesFile(2, secondName, "alice")
+  }
+
+  private fun UiScope.openFiles(files: List<File>, action: () -> Unit) {
+    val dialog = simplexWindowState.openMultipleDialog
+    action()
+    poll(what = "the open files dialog") { dialog.isAwaiting }
+    onEdt { dialog.onResult(files) }
+    poll(what = "the open files dialog to close") { !dialog.isAwaiting }
+  }
+
+  private fun CliPeer.receivesImageOffer(fileId: Int): String {
+    val line = nextLine(CONNECT_TIMEOUT_MS)
+    val m = IMAGE_OFFER.matchEntire(line) ?: throw AssertionError("$name: expected a compressed image offer, got `$line`; next: ${pending()}")
+    check(m.groupValues[2].toLong() <= MAX_COMPRESSED_BYTES) { "${m.groupValues[1]} was sent uncompressed: ${m.groupValues[2]} bytes" }
+    this expects "use /fr $fileId [<dir>/ | <path>] to receive it"
+    return m.groupValues[1]
+  }
+
+  private companion object {
+    val IMAGE_OFFER = Regex("""(?:\d{2}:\d{2} )?alice> sends file (IMG_\S+\.jpg) \(.+ / (\d+) bytes\)""")
+    const val MAX_COMPRESSED_BYTES = 255L * 1024
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/TextSelectionDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/TextSelectionDesktopTest.kt
new file mode 100644
index 0000000000..a4c39622f8
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/TextSelectionDesktopTest.kt
@@ -0,0 +1,63 @@
+package chat.simplex.app.ui.desktop
+
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.test.onRoot
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.pressKey
+import androidx.compose.ui.test.withKeyDown
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class TextSelectionDesktopTest : UiTest() {
+  @Test fun textSelection_dragAcrossItems_copyButton() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    for (m in MESSAGES) bob sends "@alice $m"
+    val chat = alice.chatList.open("bob")
+    val ids = MESSAGES.map { chat.itemId(it) }
+    check(!exists(Ui.Chat.TextSelectionCopy)) { "the selection Copy button is shown before a selection" }
+    setClipboardText(UNRELATED)
+    drag(Ui.Chat.Item(ids[0]), Ui.Chat.Item(ids[2]))
+    poll(what = "the selection Copy button after the drag") { exists(Ui.Chat.TextSelectionCopy) }
+    check(clipboardText() == UNRELATED) { "the drag alone changed the clipboard to `${clipboardText()}`" }
+    click(Ui.Chat.TextSelectionCopy)
+    poll(what = "the first three messages on the clipboard, oldest first, and the Copy button gone") {
+      clipboardText() == MESSAGES.take(3).joinToString("\n") && !exists(Ui.Chat.TextSelectionCopy)
+    }
+  }
+
+  @Test fun textSelection_ctrlC_copies() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    for (m in MESSAGES) bob sends "@alice $m"
+    val chat = alice.chatList.open("bob")
+    val ids = MESSAGES.map { chat.itemId(it) }
+    setClipboardText(UNRELATED)
+    drag(Ui.Chat.Message, Ui.Chat.Item(ids[1]))
+    pressCtrlC()
+    check(!exists(Ui.Chat.TextSelectionCopy) && clipboardText() == UNRELATED) { "a drag that started outside the messages selected text: clipboard `${clipboardText()}`" }
+    drag(Ui.Chat.Item(ids[1]), Ui.Chat.Item(ids[1]))
+    poll(what = "the selection Copy button after selecting `${MESSAGES[1]}`") { exists(Ui.Chat.TextSelectionCopy) }
+    pressCtrlC()
+    poll(what = "`${MESSAGES[1]}` on the clipboard after Ctrl+C") { clipboardText() == MESSAGES[1] }
+    setClipboardText(UNRELATED)
+    click(Ui.Chat.Item(ids[0]))
+    poll(what = "the selection cleared by a click") { !exists(Ui.Chat.TextSelectionCopy) }
+    pressCtrlC()
+    check(clipboardText() == UNRELATED) { "Ctrl+C after the selection was cleared copied `${clipboardText()}`" }
+  }
+
+  private fun UiScope.pressCtrlC() {
+    val root = ui.onRoot()
+    ui.runOnUiThread { root.performKeyInput { withKeyDown(Key.CtrlLeft) { pressKey(Key.C) } } }
+    settle()
+  }
+
+  private companion object {
+    const val UNRELATED = "unrelated"
+    val MESSAGES = listOf("first message here", "the middle one", "third and selected", "fourth stays out", "fifth stays out")
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/TimedMessageDesktopTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/TimedMessageDesktopTest.kt
new file mode 100644
index 0000000000..64c918f723
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/TimedMessageDesktopTest.kt
@@ -0,0 +1,44 @@
+package chat.simplex.app.ui.desktop
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.PeerFlags
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.openTimedMenu
+import chat.simplex.app.ui.harness.receivedTtlSeconds
+import chat.simplex.common.model.shortTimeText
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class TimedMessageDesktopTest : UiTest() {
+  @Test fun timed_customTime_sendsWithChosenTtl() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(markRead = true))
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, "custom")
+    openTimedMenu()
+    click(Ui.Chat.SendTimed.option("custom"))
+    poll(what = "the `Delete after` picker at the default 5 minutes with `Send`") {
+      seesText("Delete after") && exists(Ui.TimePicker.Confirm) && "5" in textsOf(Ui.TimePicker.Value)
+    }
+    click(Ui.TimePicker.Value)
+    click(Ui.TimePicker.Value.option(CUSTOM_TTL))
+    poll(what = "2 (minutes) picked") { "2" in textsOf(Ui.TimePicker.Value) }
+    check(storedSetting(PREF) != "$CUSTOM_TTL") { "the custom time is stored as $CUSTOM_TTL before it is sent" }
+    click(Ui.TimePicker.Confirm)
+    bob.expectsMessage("alice> custom", CONNECT_TIMEOUT_MS)
+    val id = chat.itemId("custom")
+    poll(what = "alice's `custom` with a $CUSTOM_TTL s timer and `${shortTimeText(CUSTOM_TTL)}` in its meta") {
+      chat.item(id)?.meta?.itemTimed?.ttl == CUSTOM_TTL && shortTimeText(CUSTOM_TTL) in textsOf(Ui.Chat.Item(id))
+    }
+    val ttl = bob.receivedTtlSeconds("alice", "custom")
+    assertTrue("bob's `custom` is deleted $ttl s after it was sent, expected about $CUSTOM_TTL s", ttl in (CUSTOM_TTL - 2L)..(CUSTOM_TTL + 10L))
+    poll(what = "the custom time stored as $CUSTOM_TTL s") { storedSetting(PREF) == "$CUSTOM_TTL" }
+  }
+
+  private companion object {
+    const val CUSTOM_TTL = 120
+    const val PREF = "CustomDisappearingMessageTime"
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/CliPeer.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/CliPeer.kt
index 6482142023..a46c156b67 100644
--- a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/CliPeer.kt
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/CliPeer.kt
@@ -6,7 +6,7 @@ import java.io.File
 import java.io.InputStreamReader
 import java.util.concurrent.TimeUnit
 
-class CliPeer(name: String, private val dir: File, private val smpServer: String, private val flags: PeerFlags, waiter: Waiter) : PeerLines(name, waiter) {
+class CliPeer(name: String, private val dir: File, private val flags: PeerFlags, waiter: Waiter) : PeerLines(name, waiter) {
   private val transcript = File(dir, "transcript.log")
   private lateinit var screen: VtScreen
   private var proc: PtyProcess? = null
@@ -20,10 +20,11 @@ class CliPeer(name: String, private val dir: File, private val smpServer: String
     if (!File(dir, "simplex_v1_chat.db").exists()) {
       File(UiEnv.runDir, "peer-template").listFiles { f -> f.name.startsWith("simplex_v1_") }?.forEach { it.copyTo(File(dir, it.name)) }
     }
-    val args = mutableListOf(UiEnv.cli, "-d", File(dir, "simplex_v1").absolutePath, "--user-display-name", name, "-s", smpServer, "--xftp-server", TestServers.xftp1)
+    val args = mutableListOf(UiEnv.cli, "-d", File(dir, "simplex_v1").absolutePath, "--user-display-name", name, "-s", TestServers.address(flags.smpServer), "--xftp-server", TestServers.address(flags.xftpServer))
     if (flags.reactions) args += "--reactions"
     if (flags.markRead) args += "--mark-read"
     if (flags.fullLinks) args += "--show-full-links"
+    if (flags.relay) args += "--relay"
     val cmd = arrayOf("setpriv", "--pdeathsig", "KILL", "sh", "-c", "stty -echo -icanon; exec \"\$0\" \"\$@\"") + args
     val env = System.getenv().toMutableMap().apply {
       put("HOME", dir.absolutePath); put("TMPDIR", File(dir, "tmp").absolutePath)
@@ -45,11 +46,22 @@ class CliPeer(name: String, private val dir: File, private val smpServer: String
       } catch (_: Exception) {}
     }, "cli-$name").apply { isDaemon = true; start() }
     started = false
+    relayPromptAnswered = false
     startDeadline = System.currentTimeMillis() + START_TIMEOUT_MS
   }
 
   private var started = true
   private var startDeadline = 0L
+  private var relayPromptAnswered = false
+
+  var relayLink: String? = null
+    private set
+
+  val relayAddress: String
+    get() {
+      ensureStarted()
+      return relayLink ?: error("$name printed no chat relay address; start it with PeerFlags(relay = true) on a new database")
+    }
 
   fun awaitStart() = ensureStarted()
 
@@ -58,9 +70,14 @@ class CliPeer(name: String, private val dir: File, private val smpServer: String
   private fun ensureStarted() {
     if (started) return
     waiter.waitUntil((startDeadline - System.currentTimeMillis()).coerceAtLeast(0), "$name to start") {
+      answerRelayAddressPrompt()
       synchronized(lines) { lines.any { it.startsWith("Current user: ") } } && promptShown()
     }
-    synchronized(lines) { lines.clear() }
+    synchronized(lines) {
+      val i = lines.indexOfFirst { it.endsWith(RELAY_ADDRESS_CREATED) }
+      if (i >= 0) relayLink = lines.getOrNull(i + 1)
+      lines.clear()
+    }
     started = true
   }
 
@@ -85,6 +102,13 @@ class CliPeer(name: String, private val dir: File, private val smpServer: String
 
   private fun promptShown(): Boolean = screen.cursorRowText().startsWith(">")
 
+  private fun answerRelayAddressPrompt() {
+    if (flags.relay && !relayPromptAnswered && screen.cursorRowText().startsWith(RELAY_ADDRESS_PROMPT)) {
+      write("y\n")
+      relayPromptAnswered = true
+    }
+  }
+
   private fun write(s: String) {
     val out = proc!!.outputStream
     out.write(s.toByteArray(Charsets.UTF_8)); out.flush()
@@ -128,6 +152,8 @@ class CliPeer(name: String, private val dir: File, private val smpServer: String
     const val COLUMNS = 4000
     const val ROWS = 50
     private const val PROMPT = "> "
+    private const val RELAY_ADDRESS_PROMPT = "Create relay address (Yn):"
+    private const val RELAY_ADDRESS_CREATED = "Chat relay address is created:"
     private const val START_TIMEOUT_MS = 60_000L
     private const val TYPE_ATTEMPTS = 5
     private const val UNCHANGED_MS = 1_500L
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/Socks5Stub.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/Socks5Stub.kt
new file mode 100644
index 0000000000..8c8ea99a4e
--- /dev/null
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/Socks5Stub.kt
@@ -0,0 +1,134 @@
+package chat.simplex.app.ui.harness
+
+import java.io.DataInputStream
+import java.io.InputStream
+import java.io.OutputStream
+import java.net.InetAddress
+import java.net.InetSocketAddress
+import java.net.ServerSocket
+import java.net.Socket
+import java.util.concurrent.ConcurrentHashMap
+
+class Socks5Stub(val port: Int) : AutoCloseable {
+  private val server = ServerSocket().apply { reuseAddress = true; bind(InetSocketAddress(InetAddress.getLoopbackAddress(), port)) }
+  private val sockets: MutableSet<Socket> = ConcurrentHashMap.newKeySet()
+  private val recorded = ArrayList<SocksConnection>()
+
+  init {
+    Thread({
+      while (!server.isClosed) {
+        val client = runCatching { server.accept() }.getOrNull() ?: break
+        sockets += client
+        Thread({ serve(client) }, "socks-stub-client").apply { isDaemon = true; start() }
+      }
+    }, "socks-stub-$port").apply { isDaemon = true; start() }
+  }
+
+  fun connections(): List<SocksConnection> = synchronized(recorded) { recorded.toList() }
+
+  override fun close() {
+    runCatching { server.close() }
+    sockets.forEach { runCatching { it.close() } }
+    sockets.clear()
+  }
+
+  private fun serve(client: Socket) {
+    val target = runCatching { handshake(client) }.getOrNull()
+    if (target == null) {
+      runCatching { client.close() }
+      sockets.remove(client)
+      return
+    }
+    sockets += target
+    Thread({ pump(target.getInputStream(), client.getOutputStream(), client, target) }, "socks-stub-down").apply { isDaemon = true; start() }
+    pump(client.getInputStream(), target.getOutputStream(), client, target)
+  }
+
+  private fun handshake(client: Socket): Socket? {
+    val input = DataInputStream(client.getInputStream())
+    val out = client.getOutputStream()
+    if (input.readUnsignedByte() != VERSION) return null
+    val methods = ByteArray(input.readUnsignedByte()).also { input.readFully(it) }.map { it.toInt() and 0xFF }
+    val username = when {
+      AUTH_USERNAME in methods -> {
+        out.write(byteArrayOf(VERSION.toByte(), AUTH_USERNAME.toByte())); out.flush()
+        input.readUnsignedByte()
+        val user = String(ByteArray(input.readUnsignedByte()).also { input.readFully(it) }, Charsets.UTF_8)
+        input.readFully(ByteArray(input.readUnsignedByte()))
+        out.write(byteArrayOf(1, 0)); out.flush()
+        user
+      }
+      AUTH_NONE in methods -> { out.write(byteArrayOf(VERSION.toByte(), AUTH_NONE.toByte())); out.flush(); null }
+      else -> { out.write(byteArrayOf(VERSION.toByte(), 0xFF.toByte())); out.flush(); return null }
+    }
+    if (input.readUnsignedByte() != VERSION) return null
+    val command = input.readUnsignedByte()
+    input.readUnsignedByte()
+    val host = when (input.readUnsignedByte()) {
+      ATYP_IPV4 -> InetAddress.getByAddress(ByteArray(4).also { input.readFully(it) }).hostAddress
+      ATYP_DOMAIN -> String(ByteArray(input.readUnsignedByte()).also { input.readFully(it) }, Charsets.US_ASCII)
+      ATYP_IPV6 -> InetAddress.getByAddress(ByteArray(16).also { input.readFully(it) }).hostAddress
+      else -> return reply(out, REP_ADDRESS_TYPE)
+    }
+    val targetPort = input.readUnsignedShort()
+    if (command != CMD_CONNECT) return reply(out, REP_COMMAND)
+    synchronized(recorded) { recorded += SocksConnection(host, targetPort, username) }
+    val target = runCatching { Socket().apply { connect(InetSocketAddress(host, targetPort), CONNECT_TIMEOUT_MS) } }.getOrNull()
+      ?: return reply(out, REP_REFUSED)
+    reply(out, REP_OK)
+    return target
+  }
+
+  private fun pump(from: InputStream, to: OutputStream, a: Socket, b: Socket) {
+    val buf = ByteArray(16384)
+    try {
+      while (true) {
+        val n = from.read(buf)
+        if (n < 0) break
+        to.write(buf, 0, n)
+        to.flush()
+      }
+    } catch (_: Exception) {
+    } finally {
+      for (s in listOf(a, b)) { runCatching { s.close() }; sockets.remove(s) }
+    }
+  }
+
+  private fun reply(out: OutputStream, code: Int): Socket? {
+    out.write(byteArrayOf(VERSION.toByte(), code.toByte(), 0, ATYP_IPV4.toByte(), 0, 0, 0, 0, 0, 0))
+    out.flush()
+    return null
+  }
+
+  private companion object {
+    const val VERSION = 5
+    const val AUTH_NONE = 0
+    const val AUTH_USERNAME = 2
+    const val CMD_CONNECT = 1
+    const val ATYP_IPV4 = 1
+    const val ATYP_DOMAIN = 3
+    const val ATYP_IPV6 = 4
+    const val REP_OK = 0
+    const val REP_REFUSED = 5
+    const val REP_COMMAND = 7
+    const val REP_ADDRESS_TYPE = 8
+    const val CONNECT_TIMEOUT_MS = 10_000
+  }
+}
+
+object SocksProxy {
+  private var stub: Socks5Stub? = null
+
+  val port: Int get() = TestServers.socksPort
+
+  @Synchronized fun start() {
+    if (stub == null) stub = Socks5Stub(port)
+  }
+
+  @Synchronized fun connections(): List<SocksConnection> = stub?.connections() ?: error("the SOCKS proxy is not started; SocksProxy.start() starts it")
+
+  @Synchronized fun stop() {
+    stub?.close()
+    stub = null
+  }
+}
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/TestRoot.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/TestRoot.kt
index 581ff945de..598fa045e3 100644
--- a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/TestRoot.kt
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/TestRoot.kt
@@ -7,13 +7,32 @@ import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.platform.UriHandler
 import androidx.compose.ui.text.AnnotatedString
+import java.awt.datatransfer.Clipboard
+import java.awt.datatransfer.DataFlavor
+import java.awt.datatransfer.StringSelection
+import java.awt.datatransfer.Transferable
+import java.awt.datatransfer.UnsupportedFlavorException
 
 class TestClipboard : ClipboardManager {
-  @Volatile var content: AnnotatedString? = null
+  private val system = Clipboard("uitest").also(::installAsSkikoSystemClipboard)
+  var content: AnnotatedString?
+    get() = runCatching { system.getData(DataFlavor.stringFlavor) as String }.getOrNull()?.let(::AnnotatedString)
+    set(v) { system.setContents(v?.let { StringSelection(it.text) } ?: NO_TEXT, null) }
   override fun getText(): AnnotatedString? = content
   override fun setText(annotatedString: AnnotatedString) { content = annotatedString }
 }
 
+private val NO_TEXT = object : Transferable {
+  override fun getTransferDataFlavors() = emptyArray<DataFlavor>()
+  override fun isDataFlavorSupported(flavor: DataFlavor) = false
+  override fun getTransferData(flavor: DataFlavor): Any = throw UnsupportedFlavorException(flavor)
+}
+
+private fun installAsSkikoSystemClipboard(clipboard: Clipboard) {
+  val lazy = Class.forName("org.jetbrains.skiko.Actuals_awtKt").getDeclaredField("systemClipboard\$delegate").apply { isAccessible = true }.get(null)
+  lazy.javaClass.getDeclaredField("_value").apply { isAccessible = true }.set(lazy, clipboard)
+}
+
 class RecordingUriHandler : UriHandler {
   val opened = mutableListOf<String>()
   override fun openUri(uri: String) { synchronized(opened) { opened += uri } }
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/TestServers.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/TestServers.kt
index 44f8e84a5a..e5101c0333 100644
--- a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/TestServers.kt
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/TestServers.kt
@@ -2,6 +2,7 @@ package chat.simplex.app.ui.harness
 
 import java.io.File
 import java.io.RandomAccessFile
+import java.io.Writer
 import java.nio.channels.FileChannel
 import java.nio.channels.FileLock
 import java.util.concurrent.LinkedBlockingQueue
@@ -9,6 +10,9 @@ import java.util.concurrent.TimeUnit
 
 object TestServers {
   private const val SLOTS = 120
+  const val SOCKS_PORT_OFFSET = 20
+  private val BASELINE = setOf("smp1", "xftp1")
+  private const val REPLY_TIMEOUT_S = 30L
 
   private class SlotLock(val index: Int, val channel: FileChannel, val lock: FileLock)
 
@@ -22,43 +26,82 @@ object TestServers {
   }
   val slot: Int get() = slotLock.index
   val portBase: Int get() = 20000 + 100 * slot
+  val remoteCtrlPort: Int get() = portBase + 90
 
-  private var proc: Process? = null
+  @Volatile private var proc: Process? = null
+  private var commands: Writer? = null
+  private var log: File? = null
   private val responses = LinkedBlockingQueue<String>()
-  lateinit var smp1: String
-    private set
-  lateinit var xftp1: String
-    private set
+  private val addresses = HashMap<String, String>()
+  private val running = HashSet<String>()
 
-  fun start() {
+  val smp1: String get() = address("smp1")
+  val xftp1: String get() = address("xftp1")
+
+  @Synchronized fun launch() {
     if (proc != null) return
     val dir = File(UiEnv.jvmDir, "servers").apply { mkdirs() }
     val p = ProcessBuilder("setpriv", "--pdeathsig", "KILL", UiEnv.servers, dir.absolutePath, portBase.toString())
       .directory(UiEnv.repoRoot).redirectErrorStream(true).start()
     proc = p
-    val log = File(dir, "servers.log")
+    commands = p.outputStream.bufferedWriter(Charsets.UTF_8)
+    val logFile = File(dir, "servers.log").also { log = it }
     Thread({
       p.inputStream.bufferedReader().forEachLine { line ->
-        log.appendText("$line\n")
-        if (line.startsWith("ready ") || line.startsWith("error ")) responses.add(line)
+        logFile.appendText("$line\n")
+        if (line.startsWith("ready ") || line.startsWith("stopped ") || line.startsWith("error ")) responses.add(line)
       }
     }, "uitest-servers").apply { isDaemon = true; start() }
-    smp1 = ready("smp1", log)
-    xftp1 = ready("xftp1", log)
+    for (name in BASELINE) ready(name, reply(name))
   }
 
-  private fun ready(name: String, log: File): String {
-    val r = responses.poll(30, TimeUnit.SECONDS) ?: error("uitest-servers did not start $name; see $log")
-    check(r.startsWith("ready $name ")) { "uitest-servers: $r" }
-    return r.removePrefix("ready $name ")
+  @Synchronized fun start(name: String): String = ready(name, command("start", name))
+
+  @Synchronized fun stop(name: String) {
+    val r = command("stop", name)
+    check(r == "stopped $name") { "uitest-servers answered `$r` to `stop $name`; see $log" }
+    running -= name
   }
 
+  @Synchronized fun reset(name: String): String = ready(name, command("reset", name))
+
+  @Synchronized fun address(name: String): String =
+    addresses[name]?.takeIf { name in running } ?: error("server $name is not running; TestServers.start(\"$name\") starts it")
+
+  @Synchronized fun restoreBaseline() {
+    launch()
+    (running - BASELINE).forEach { stop(it) }
+    (BASELINE - running).forEach { start(it) }
+  }
+
+  val socksPort: Int get() = portBase + SOCKS_PORT_OFFSET
+
   fun configure() = configureServers(smp1, xftp1)
 
-  fun stop() {
+  fun shutdown() {
     val p = proc ?: return
     proc = null
     runCatching { p.outputStream.close() }
     if (!p.waitFor(10, TimeUnit.SECONDS)) p.destroyForcibly()
   }
+
+  private fun command(cmd: String, name: String): String {
+    launch()
+    val w = commands ?: error("uitest-servers is not running")
+    responses.clear()
+    w.write("$cmd $name\n")
+    w.flush()
+    return reply(name)
+  }
+
+  private fun reply(name: String): String {
+    val r = responses.poll(REPLY_TIMEOUT_S, TimeUnit.SECONDS) ?: error("uitest-servers did not answer for $name in $REPLY_TIMEOUT_S s; see $log")
+    check(!r.startsWith("error ")) { "uitest-servers: $r; see $log" }
+    return r
+  }
+
+  private fun ready(name: String, reply: String): String {
+    check(reply.startsWith("ready $name ")) { "uitest-servers answered `$reply` for $name; see $log" }
+    return reply.removePrefix("ready $name ").also { addresses[name] = it; running += name }
+  }
 }
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiBridge.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiBridge.kt
index f5e4efa00b..f837033242 100644
--- a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiBridge.kt
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiBridge.kt
@@ -18,7 +18,7 @@ object UiBridge {
   @JvmStatic fun main(args: Array<String>) {
     val port = args.getOrNull(0)?.toInt() ?: 7777
     UiJvm.setup()
-    TestServers.start()
+    TestServers.launch()
     val dir = File(UiEnv.jvmDir, "bridge-peers").apply { mkdirs() }
     println("uitest-bridge: smp ${TestServers.smp1}, port base ${TestServers.portBase}, listening on 127.0.0.1:$port, pid ${ProcessHandle.current().pid()}")
     ServerSocket(port, 1, InetAddress.getLoopbackAddress()).use { server ->
@@ -37,22 +37,31 @@ object UiBridge {
           Peers.stopAll()
           peers.clear()
           peerDirs.clear()
+          SocksProxy.stop()
+          runCatching { TestServers.restoreBaseline() }
         }
       }
     }
   }
 
+  private fun flag(flags: Set<String>, key: String): String? = flags.firstOrNull { it.startsWith("$key=") }?.removePrefix("$key=")
+
   private fun handle(line: String, dir: File): List<String> {
     val parts = line.split(" ", limit = 3)
     return when (parts[0]) {
       "servers" -> listOf("ok ${TestServers.smp1} ${TestServers.xftp1}")
+      "remotePort" -> listOf("ok ${TestServers.remoteCtrlPort}")
       "start" -> {
         val name = parts[1]
         val f = parts.getOrElse(2) { "" }.split(",").toSet()
-        val peer = CliPeer(name, peerDirs.getOrPut(name) { File(dir, "${System.nanoTime()}-$name") }, TestServers.smp1, PeerFlags("reactions" in f, "markRead" in f, "fullLinks" in f), sleepWaiter)
+        val flags = PeerFlags(
+          "reactions" in f, "markRead" in f, "fullLinks" in f, "relay" in f,
+          smpServer = flag(f, "smp") ?: PeerFlags().smpServer, xftpServer = flag(f, "xftp") ?: PeerFlags().xftpServer
+        )
+        val peer = CliPeer(name, peerDirs.getOrPut(name) { File(dir, "${System.nanoTime()}-$name") }, flags, sleepWaiter)
         Peers.add(peer); peers[name] = peer
         peer.start(); peer.awaitStart()
-        listOf("ok")
+        listOf(peer.relayLink?.let { "ok $it" } ?: "ok")
       }
       "type" -> { peers.getValue(parts[1]).types(parts.getOrElse(2) { "" }); listOf("ok") }
       "file" -> {
@@ -62,6 +71,23 @@ object UiBridge {
       "drain" -> { val ls = peers.getValue(parts[1]).drainLines(); listOf("lines ${ls.size}") + ls }
       "stop" -> { peers.remove(parts[1])?.stop(); listOf("ok") }
       "forget" -> { peers.remove(parts[1])?.stop(); peerDirs.remove(parts[1]); listOf("ok") }
+      "server" -> {
+        val name = parts.getOrElse(2) { "" }
+        when (parts[1]) {
+          "start" -> listOf("ok ${TestServers.start(name)}")
+          "stop" -> { TestServers.stop(name); listOf("ok") }
+          "reset" -> listOf("ok ${TestServers.reset(name)}")
+          "address" -> listOf("ok ${TestServers.address(name)}")
+          "baseline" -> { TestServers.restoreBaseline(); listOf("ok") }
+          else -> listOf("err unknown server command ${parts[1]}")
+        }
+      }
+      "socks" -> when (parts[1]) {
+        "start" -> { SocksProxy.start(); listOf("ok ${SocksProxy.port}") }
+        "connections" -> SocksProxy.connections().let { cs -> listOf("lines ${cs.size}") + cs.map { "${it.host} ${it.port} ${it.username ?: "-"}" } }
+        "stop" -> { SocksProxy.stop(); listOf("ok") }
+        else -> listOf("err unknown socks command ${parts[1]}")
+      }
       else -> listOf("err unknown command ${parts[0]}")
     }
   }
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiJvm.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiJvm.kt
index 668661ba2a..193d44d66e 100644
--- a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiJvm.kt
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiJvm.kt
@@ -11,7 +11,7 @@ object UiJvm {
     Runtime.getRuntime().addShutdownHook(Thread {
       runCatching { UiTestApp.stopCore() }
       Peers.stopAll()
-      TestServers.stop()
+      TestServers.shutdown()
       ProcessHandle.current().descendants().forEach { it.destroyForcibly() }
     })
   }
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiTest.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiTest.kt
index 8b90015573..3493ea3861 100644
--- a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiTest.kt
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiTest.kt
@@ -63,6 +63,7 @@ abstract class UiTest {
       }
       watchdog.cancel()
       Peers.stopAll()
+      SocksProxy.stop()
       if (passed) dir.deleteRecursively()
     }
   }
@@ -78,6 +79,13 @@ private const val LIST_PAGES = 20
 private const val REPLACE_CHECK_MS = 2_000L
 private const val SCROLL_PAGE = 0.6f
 private const val SCROLL_MARGIN_DP = 48f
+private const val CHAT_SCROLL_PAGE = 0.8f
+private const val DRAG_STEPS = 10
+private const val DRAG_INSET_PX = 4f
+private val CHAT_ITEM_TAG = "${chat.simplex.common.ui.Ui.Chat.Item(0).id}["
+private val chatItemNode = SemanticsMatcher("a chat item") {
+  it.config.getOrElseNullable(androidx.compose.ui.semantics.SemanticsProperties.TestTag) { null }?.startsWith(CHAT_ITEM_TAG) == true
+}
 
 class UiScope(val ui: SkikoComposeUiTest, private val dir: File) {
   val clipboard = TestClipboard()
@@ -90,17 +98,38 @@ class UiScope(val ui: SkikoComposeUiTest, private val dir: File) {
     return App(this)
   }
 
-  fun restart(): App {
+  fun restart(
+    ready: () -> Boolean = { chat.simplex.common.platform.chatModel.chatDbStatus.value != null && !chat.simplex.common.platform.chatModel.ctrlInitInProgress.value },
+    what: String = "the app to start again"
+  ): App {
     ui.setContent { }
     ui.waitForIdle()
     UiTestApp.restartCore(beforeInit = PrefStores::reloadFromDisk)
     ui.setContent { TestRoot(clipboard, uriHandler) { AppScreen() } }
-    poll(timeoutMs = 30_000, what = "the app to start again") {
-      chat.simplex.common.platform.chatModel.chatDbStatus.value != null && !chat.simplex.common.platform.chatModel.ctrlInitInProgress.value
-    }
+    poll(timeoutMs = 30_000, what = what) { ready() }
     return App(this)
   }
 
+  fun exchangeDir(): File = File(dir, "exchange").apply { mkdirs() }
+
+  fun saveFileAs(file: File, action: () -> Unit) = answerDialog(chat.simplex.common.simplexWindowState.saveDialog, "the save file dialog", file, action)
+
+  fun openFile(file: File, action: () -> Unit) {
+    val single = chat.simplex.common.simplexWindowState.openDialog
+    val multiple = chat.simplex.common.simplexWindowState.openMultipleDialog
+    action()
+    poll(what = "the open file dialog") { single.isAwaiting || multiple.isAwaiting }
+    onEdt { if (single.isAwaiting) single.onResult(file) else multiple.onResult(listOf(file)) }
+    poll(what = "the open file dialog to close") { !single.isAwaiting && !multiple.isAwaiting }
+  }
+
+  private fun answerDialog(dialog: chat.simplex.common.DialogState<File?>, what: String, file: File, action: () -> Unit) {
+    action()
+    poll(what = what) { dialog.isAwaiting }
+    onEdt { dialog.onResult(file) }
+    poll(what = "$what to close") { !dialog.isAwaiting }
+  }
+
   fun textOf(key: UiKey): String? {
     waitFor(key)
     val textKey = androidx.compose.ui.semantics.SemanticsProperties.Text
@@ -128,6 +157,8 @@ class UiScope(val ui: SkikoComposeUiTest, private val dir: File) {
 
   fun clipboardText(): String? = clipboard.content?.text
 
+  fun setClipboardText(text: String?) { clipboard.content = text?.let { androidx.compose.ui.text.AnnotatedString(it) } }
+
   fun matcher(key: UiKey): SemanticsMatcher =
     if (key.id == DESCRIBED) hasContentDescription(key.arg as String) and hasClickAction() else hasTestTag(key.tag)
 
@@ -162,6 +193,31 @@ class UiScope(val ui: SkikoComposeUiTest, private val dir: File) {
 
 
 
+  fun scrollChatTowardOlder(pages: Int = 1): Boolean = scrollChat(pages, towardOlder = true)
+
+  fun scrollChatTowardNewer(pages: Int = 1): Boolean = scrollChat(pages, towardOlder = false)
+
+  private fun scrollChat(pages: Int, towardOlder: Boolean): Boolean {
+    val list = ui.onNode(SemanticsMatcher.keyIsDefined(SemanticsActions.ScrollToIndex) and SemanticsMatcher.keyIsDefined(SemanticsActions.ScrollBy) and hasAnyDescendant(chatItemNode))
+    repeat(pages) {
+      val items = ui.onAllNodes(chatItemNode).fetchSemanticsNodes()
+      val tracked = (if (towardOlder) items.minByOrNull { it.boundsInRoot.top } else items.maxByOrNull { it.boundsInRoot.bottom })
+        ?: throw AssertionError("no chat items in view to scroll the chat")
+      val tag = tracked.config[androidx.compose.ui.semantics.SemanticsProperties.TestTag]
+      val before = tracked.boundsInRoot
+      val node = list.fetchSemanticsNode()
+      val dy = node.boundsInRoot.height * CHAT_SCROLL_PAGE
+      ui.runOnUiThread { node.config[SemanticsActions.ScrollBy].action?.invoke(0f, if (towardOlder) dy else -dy) }
+      repeat(SCROLL_ANIMATION_FRAMES) { ui.mainClock.advanceTimeBy(16, ignoreFrameDuration = true); ui.waitForIdle() }
+      val after = ui.onAllNodes(hasTestTag(tag)).fetchSemanticsNodes().firstOrNull()?.boundsInRoot
+      if (after == before) return false
+      if (after == null || (if (towardOlder) after.top <= before.top else after.bottom >= before.bottom)) {
+        throw AssertionError("scrolling the chat toward ${if (towardOlder) "older" else "newer"} messages moved $tag the other way: $before -> $after")
+      }
+    }
+    return true
+  }
+
   fun waitStable(key: UiKey) {
     var last: androidx.compose.ui.geometry.Rect? = null
     var count = 0
@@ -183,17 +239,19 @@ class UiScope(val ui: SkikoComposeUiTest, private val dir: File) {
       val rootBottom = generateSequence(node) { it.parent }.last().boundsInRoot.bottom
       val b = node.boundsInRoot
       val placed = b.width > 0f && b.height > 0f
-      if (placed && b.top >= 0f && b.bottom <= rootBottom) return
+      val margin = node.layoutInfo.density.density * SCROLL_MARGIN_DP
+      if (placed && b.top >= 0f && b.bottom <= rootBottom - margin) return
       val scroller = generateSequence(node.parent) { it.parent }
         .firstOrNull { it.config.contains(androidx.compose.ui.semantics.SemanticsActions.ScrollBy) } ?: return
-      val margin = node.layoutInfo.density.density * SCROLL_MARGIN_DP
       val dy = when {
+        !placed && node.positionInRoot.y < 0f -> node.positionInRoot.y - margin
         !placed -> rootBottom * SCROLL_PAGE
-        b.bottom > rootBottom -> b.bottom - rootBottom + margin
+        b.bottom > rootBottom - margin -> b.bottom - rootBottom + margin
         else -> b.top - margin
       }
       ui.runOnUiThread { scroller.config[androidx.compose.ui.semantics.SemanticsActions.ScrollBy].action?.invoke(0f, dy) }
       repeat(SCROLL_ANIMATION_FRAMES) { ui.mainClock.advanceTimeBy(16, ignoreFrameDuration = true); ui.waitForIdle() }
+      if (placed && ui.onAllNodes(matcher(key)).fetchSemanticsNodes().firstOrNull()?.boundsInRoot == b) return
     }
   }
 
@@ -270,6 +328,26 @@ class UiScope(val ui: SkikoComposeUiTest, private val dir: File) {
     ui.waitForIdle()
   }
 
+  fun drag(from: UiKey, to: UiKey) {
+    waitFor(from)
+    waitFor(to)
+    waitStable(from)
+    waitStable(to)
+    waitPopupsClosedUnlessInside(from)
+    val start = ui.onNode(matcher(from)).fetchSemanticsNode().boundsInRoot.let { androidx.compose.ui.geometry.Offset(it.left + DRAG_INSET_PX, it.top + DRAG_INSET_PX) }
+    val end = ui.onNode(matcher(to)).fetchSemanticsNode().boundsInRoot.let { androidx.compose.ui.geometry.Offset(it.right - DRAG_INSET_PX, it.bottom - DRAG_INSET_PX) }
+    val root = ui.onRoot()
+    ui.runOnUiThread { root.performMouseInput { moveTo(start); press() } }
+    repeat(FOCUS_SETTLE_FRAMES) { ui.mainClock.advanceTimeBy(16, ignoreFrameDuration = true); ui.waitForIdle() }
+    for (step in 1..DRAG_STEPS) {
+      val point = start + (end - start) * (step.toFloat() / DRAG_STEPS)
+      ui.runOnUiThread { root.performMouseInput { moveTo(point) } }
+      repeat(FOCUS_SETTLE_FRAMES) { ui.mainClock.advanceTimeBy(16, ignoreFrameDuration = true); ui.waitForIdle() }
+    }
+    ui.runOnUiThread { root.performMouseInput { release() } }
+    repeat(FOCUS_SETTLE_FRAMES) { ui.mainClock.advanceTimeBy(16, ignoreFrameDuration = true); ui.waitForIdle() }
+  }
+
   fun textsOf(key: UiKey): List<String> {
     waitFor(key)
     val textKey = androidx.compose.ui.semantics.SemanticsProperties.Text
@@ -301,14 +379,17 @@ class UiScope(val ui: SkikoComposeUiTest, private val dir: File) {
     ui.onAllNodes((matcher(key) or hasAnyAncestor(matcher(key))) and SemanticsMatcher.keyIsDefined(androidx.compose.ui.semantics.SemanticsProperties.EditableText), useUnmergedTree = true)
       .fetchSemanticsNodes().firstOrNull()?.config?.get(androidx.compose.ui.semantics.SemanticsProperties.EditableText)?.text
 
+  fun hintOf(key: UiKey): String? = if (editableText(key).isNullOrEmpty()) textsOf(key).firstOrNull() else null
+
   fun cli(name: String, flags: PeerFlags = PeerFlags()): CliPeer =
-    CliPeer(name, File(dir, "peers/$name"), TestServers.smp1, flags) { t, what, cond -> poll(t, what, cond = cond) }
+    CliPeer(name, File(dir, "peers/$name"), flags) { t, what, cond -> poll(t, what, cond = cond) }
       .also { Peers.add(it); it.start() }
 
   fun poll(timeoutMs: Long = 10_000, what: String, screenshot: Boolean = true, cond: () -> Boolean) {
     val deadline = System.currentTimeMillis() + timeoutMs
     var busyAtDeadline: Set<Long>? = null
     var lastError: Throwable? = null
+    var workEnded = false
     while (true) {
       ui.mainClock.advanceTimeBy(16, ignoreFrameDuration = true)
       ui.waitForIdle()
@@ -318,10 +399,11 @@ class UiScope(val ui: SkikoComposeUiTest, private val dir: File) {
       if (now > deadline) {
         val busy = busyAtDeadline ?: UiIdle.inFlight().map { it.id }.toSet().also { busyAtDeadline = it }
         val stillBusy = UiIdle.inFlight().any { it.id in busy }
-        if (!stillBusy || now > deadline + EXTENSION_MS) {
+        if ((!stillBusy && workEnded) || now > deadline + EXTENSION_MS) {
           val shot = if (screenshot) failureShot(what) else null
           throw AssertionError("timed out after $timeoutMs ms waiting for $what; ${lastError?.let { "last condition error: $it; " } ?: ""}in flight: ${UiIdle.inFlight().joinToString { it.what }}; screenshot: $shot; visible texts: ${texts().take(60)}")
         }
+        workEnded = !stillBusy
       }
       Thread.sleep(16)
     }
diff --git a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiTestApp.kt b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiTestApp.kt
index 4cebddc239..d9011fc734 100644
--- a/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiTestApp.kt
+++ b/apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiTestApp.kt
@@ -64,7 +64,7 @@ object UiTestApp {
     coreStarted = true
     PrefStores.restore()
     UiState.clearUiState()
-    TestServers.start()
+    TestServers.restoreBaseline()
     DbTemplate.installIfPresent()
     if (user != null) TestPrefs.preset()
     initCore()
diff --git a/apps/multiplatform/common/src/uiTestShared/README.md b/apps/multiplatform/common/src/uiTestShared/README.md
index b87bcb158c..40ce2fb21a 100644
--- a/apps/multiplatform/common/src/uiTestShared/README.md
+++ b/apps/multiplatform/common/src/uiTestShared/README.md
@@ -75,6 +75,19 @@ colour; `groupInvitation_tapRowShowsJoinAlert` never checked the alert.
 - Peer output that looks like an error and that the test did not consume explicitly fails the test (section 6).
 - The CLI inserts the open chat's name after a leading `> `, `! ` or `\ `. Write these commands without the space (`>@alice (quoted) reply`, `!@alice new text`), or the typed line will not match.
 
+### Servers and the SOCKS stub
+
+- `TestServers.stop(name)`, `start(name)` (returns the address) and `reset(name)` (restart without the store) control
+  `smp1`, `xftp1`, `smp2` and `xftp2` (plan §0.5.6). Each test JVM has its own servers, and every reset restores the
+  baseline (`smp1` and `xftp1` running, `smp2` and `xftp2` stopped), so start what the test needs and never rely on
+  what another test left.
+- A peer on the second server: `TestServers.start("smp2")`, then `cli("bob", PeerFlags(smpServer = "smp2"))`.
+- Keep outages to a few seconds and use `CONNECT_TIMEOUT_MS` for waits after a start: the agents back off.
+- Around an outage CLI peers print `disconnected N connections on server …` and `subscribed N connections on server …`,
+  so use `eventually*` for the next line after a stop or start, not `expects`.
+- `SocksProxy.start()`, `SocksProxy.port` (host `SOCKS_HOST`) and `SocksProxy.connections()` (each CONNECT the stub
+  received, with the target host, port and username); the harness stops it at the end of the test.
+
 ### Persistence
 
 "Persists across restart" means: change the setting through the UI, check `storedSetting(...)` (what is on disk),
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ChatSearchTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ChatSearchTest.kt
index 77cd9b83c8..39754c43a8 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ChatSearchTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ChatSearchTest.kt
@@ -1,10 +1,23 @@
 package chat.simplex.app.ui.chat
 
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiScope
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitRowText
+import chat.simplex.app.ui.harness.closeChatSearch
 import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.contentFilter
+import chat.simplex.app.ui.harness.loadedItemId
+import chat.simplex.app.ui.harness.loadedItemIds
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.app.ui.harness.pickContentFilter
+import chat.simplex.app.ui.harness.switchAwayFromChat
+import chat.simplex.common.model.MsgContent
 import chat.simplex.common.ui.Ui
 import org.junit.Test
 
+private const val FIXTURE_JPG = "tests/fixtures/test.jpg"
+
 class ChatSearchTest : UiTest() {
   @Test fun search_direct_filtersResults() = uiTest {
     val alice = app("alice"); val bob = cli("bob")
@@ -22,4 +35,117 @@ class ChatSearchTest : UiTest() {
         matches.all { exists(Ui.Chat.Item(it)) } && !exists(Ui.Chat.Item(other))
     }
   }
+
+  @Test fun search_group_filtersResults() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = ownGroup(alice, "team", bob)
+    bob sends "#team apples and pears"
+    val bobs = chat.itemId("bob's `apples and pears`") { it.content.text == "apples and pears" }
+    bob sends "#team plums"
+    val plums = chat.itemId("bob's `plums`") { it.content.text == "plums" }
+    chat.send("pears for bob")
+    val mine = chat.itemId("pears for bob")
+    bob.eventuallyMessage("#team alice> pears for bob", CONNECT_TIMEOUT_MS)
+    chat.search("pears")
+    poll(what = "bob's and alice's messages with `pears`, without bob's `plums`") {
+      chat.itemTexts().toSet() == setOf("apples and pears", "pears for bob") &&
+        exists(Ui.Chat.Item(bobs)) && exists(Ui.Chat.Item(mine)) && !exists(Ui.Chat.Item(plums))
+    }
+    replaceText(Ui.Chat.Bar.part("search"), "apples")
+    poll(what = "only bob's `apples and pears`") {
+      chat.itemTexts() == listOf("apples and pears") && exists(Ui.Chat.Item(bobs)) && !exists(Ui.Chat.Item(mine)) && !exists(Ui.Chat.Item(plums))
+    }
+  }
+
+  @Test fun search_goToResult_opensAroundItem() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice alpha"
+    bob sends "@alice the needle"
+    bob sends "@alice omega"
+    val chat = alice.chatList.open("bob")
+    val alpha = chat.itemId("alpha"); val needle = chat.itemId("the needle"); val omega = chat.itemId("omega")
+    val goTo = Ui.Chat.Item(needle).part("goTo")
+    check(!exists(goTo)) { "`the needle` has a go-to button outside search" }
+    chat.search("needle")
+    poll(what = "only `the needle`, with its go-to button") {
+      chat.itemTexts() == listOf("the needle") && exists(goTo) && !exists(Ui.Chat.Item(alpha)) && !exists(Ui.Chat.Item(omega))
+    }
+    hideKeyboard()
+    click(goTo)
+    poll(what = "the search closed and `the needle` shown with `alpha` and `omega` around it") {
+      !exists(Ui.Chat.Bar.part("search")) && !exists(goTo) &&
+        exists(Ui.Chat.Item(alpha)) && exists(Ui.Chat.Item(needle)) && exists(Ui.Chat.Item(omega))
+    }
+  }
+
+  @Test fun search_notes_filtersResults() = uiTest {
+    val alice = app("alice")
+    val notes = alice.chatList.open("Private notes")
+    notes.send("keep in mind")
+    notes.send("ahoy!")
+    val keep = notes.itemId("keep in mind"); val ahoy = notes.itemId("ahoy!")
+    check(!exists(Ui.Chat.Bar.part("search"))) { "the search field is open before the search button is clicked" }
+    hideKeyboard()
+    click(Ui.Chat.SearchButton)
+    typeInto(Ui.Chat.Bar.part("search"), "keep")
+    poll(what = "only `keep in mind`") {
+      notes.itemTexts() == listOf("keep in mind") && exists(Ui.Chat.Item(keep)) && !exists(Ui.Chat.Item(ahoy))
+    }
+    closeChatSearch()
+    poll(what = "both notes shown again after the search closed") {
+      notes.itemTexts().containsAll(listOf("keep in mind", "ahoy!")) && exists(Ui.Chat.Item(keep)) && exists(Ui.Chat.Item(ahoy))
+    }
+  }
+
+  @Test fun contentFilter_types_filterAndReset() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    ownGroup(alice, "team", bob)
+    switchAwayFromChat(alice)
+    bob sends "#team no links here"
+    bob sends "#team check out https://example.com"
+    bob sends "#team see https://simplex.chat"
+    bob sends "/f #team ${bob.createFile("list.txt", "apples")}"
+    bob expects "use /fc 1 to cancel sending"
+    bob.eventually("completed uploading file 1 (list.txt) for #team", CONNECT_TIMEOUT_MS)
+    bob sends "/img #team $FIXTURE_JPG"
+    bob expectsMessage "/f #team $FIXTURE_JPG"
+    bob expects "use /fc 2 to cancel sending"
+    bob.eventually("completed uploading file 2 (test.jpg) for #team", CONNECT_TIMEOUT_MS)
+    bob sends "#team last words"
+    awaitRowText(alice, "team", "bob: last words")
+    alice.chatList.open("team")
+    val plain = loadedItemId("`no links here`") { it.content.text == "no links here" }
+    val example = loadedItemId("`check out https://example.com`") { it.content.text == "check out https://example.com" }
+    val simplex = loadedItemId("`see https://simplex.chat`") { it.content.text == "see https://simplex.chat" }
+    val file = loadedItemId("the list.txt file") { it.file?.fileName == "list.txt" }
+    val image = loadedItemId("the image") { it.content.msgContent is MsgContent.MCImage }
+    val last = loadedItemId("`last words`") { it.content.text == "last words" }
+    val all = setOf(plain, example, simplex, file, image, last)
+    click(Ui.Chat.ContentFilter)
+    poll(what = "`Images`, `Files` and `Links` in the content filter menu, without `Videos`, `Voice messages` or `All messages`") {
+      listOf("Images", "Files", "Links").all { exists(contentFilter(it)) } && listOf("Videos", "Voice", "all").none { exists(contentFilter(it)) }
+    }
+    click(contentFilter("Files"))
+    showsOnly("only the list.txt file", setOf(file), all)
+    click(Ui.Chat.ContentFilter)
+    poll(what = "`All messages` in the menu while a filter is on") { exists(contentFilter("all")) }
+    click(contentFilter("Images"))
+    showsOnly("only the image", setOf(image), all)
+    pickContentFilter("Links")
+    showsOnly("only the two messages with links", setOf(example, simplex), all)
+    typeInto(Ui.Chat.Bar.part("search"), "example")
+    showsOnly("only the link message with `example`", setOf(example), all)
+    hideKeyboard()
+    pickContentFilter("all")
+    poll(what = "the filter off: no search field and every message loaded again, `last words` in view") {
+      !exists(Ui.Chat.Bar.part("search")) && loadedItemIds().containsAll(all) && exists(Ui.Chat.Item(last))
+    }
+  }
+
+  private fun UiScope.showsOnly(what: String, shown: Set<Long>, all: Set<Long>) = poll(what = what) {
+    loadedItemIds() == shown && shown.all { exists(Ui.Chat.Item(it)) } && (all - shown).none { exists(Ui.Chat.Item(it)) }
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ChatShellTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ChatShellTest.kt
new file mode 100644
index 0000000000..59b9f78a96
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ChatShellTest.kt
@@ -0,0 +1,146 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.becomeBot
+import chat.simplex.app.ui.harness.closeContactInfo
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.contactOf
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.infoNameText
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.common.model.CIContent
+import chat.simplex.common.model.MsgFilter
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.ModalManager
+import org.junit.Assert.assertFalse
+import org.junit.Test
+
+class ChatShellTest : UiTest() {
+  @Test fun directChat_opens_showsToolbarAndBanner() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    assertFalse("a chat toolbar is shown before a chat is opened", exists(TITLE))
+    val chat = alice.chatList.open("bob")
+    val e2ee = chat.itemId("bob's encryption info") { it.content is CIContent.RcvDirectE2EEInfo || it.content is CIContent.SndDirectE2EEInfo }
+    poll(what = "bob's name in the toolbar, `Your contact` in the banner and quantum resistant encryption info") {
+      textsOf(TITLE).let { t -> "bob" in t && FULL_NAME !in t } && seesText("Your contact") &&
+        textsOf(Ui.Chat.Item(e2ee)).let { t -> t.any { PQ_E2EE in it } && t.none { "end-to-end encryption" in it } }
+    }
+    bob sends """/_profile 1 {"displayName":"bob","fullName":"$FULL_NAME"}"""
+    bob.eventuallyMatching(Regex("user full name changed to $FULL_NAME \\(your 1 contacts are notified.*\\)"), CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's full name under his name in the toolbar") { textsOf(TITLE).let { "bob" in it && FULL_NAME in it } }
+    assertFalse("contact info is open before the title is clicked", exists(Ui.Info.Alias))
+    chat.info()
+    poll(what = "bob's contact info with the contact name field") { exists(Ui.Info.Alias) && infoNameText() == "bob" }
+    closeContactInfo()
+  }
+
+  @Test fun chatBanner_contextText_perChatType() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.chatList.open("bob")
+    poll(what = "`Your contact` in bob's banner") { seesText("Your contact") && !seesText("Bot") }
+    backToChatList()
+    val team = emptyGroup(alice, "team")
+    val e2ee = team.itemId("the encryption info of #team") { it.content is CIContent.SndGroupE2EEInfo }
+    poll(what = "`team` in the toolbar, `Your group` in the banner and the encryption info without quantum resistance") {
+      "team" in textsOf(TITLE) && seesText("Your group") && !seesText("Your contact") &&
+        textsOf(Ui.Chat.Item(e2ee)).let { t -> t.any { GROUP_E2EE in it } && t.none { "quantum resistant" in it } }
+    }
+    backToChatList()
+    hostGroup(bob, "club", "alice")
+    joinGroupFromList(alice, bob, "club")
+    alice.chatList.open("club")
+    poll(what = "`Group` in the banner of bob's #club") { "club" in textsOf(TITLE) && seesText("Group") && !seesText("Your group") }
+    backToChatList()
+    bob.becomeBot()
+    alice.chatList.open("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Bot` instead of `Your contact` in bob's banner once his profile says he is a bot") {
+      seesText("Bot") && !seesText("Your contact")
+    }
+  }
+
+  @Test fun toolbarMenu_direct_items() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.chatList.open("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice's contact with bob ready") { contactOf("bob").ready }
+    openBarMenu()
+    poll(what = "`Search` and `Mute` in bob's toolbar menu, without `Invite members`") {
+      exists(SEARCH) && ntfLabel() == "Mute" && !exists(ADD_MEMBERS)
+    }
+    click(NTF)
+    poll(what = "bob muted") { contactOf("bob").chatSettings.enableNtfs == MsgFilter.None }
+    openBarMenu()
+    poll(what = "`Unmute` in bob's toolbar menu") { ntfLabel() == "Unmute" }
+    click(NTF)
+    poll(what = "bob unmuted") { contactOf("bob").chatSettings.enableNtfs == MsgFilter.All }
+    openBarMenu()
+    poll(what = "`Mute` in bob's toolbar menu again") { ntfLabel() == "Mute" }
+    click(SEARCH)
+    waitFor(Ui.Chat.Bar.part("search"))
+  }
+
+  @Test fun toolbarMenu_group_items() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    emptyGroup(alice, "team")
+    openBarMenu()
+    poll(what = "`Invite members`, `Search` and `Mute` in the toolbar menu of alice's #team") {
+      exists(ADD_MEMBERS) && exists(SEARCH) && ntfLabel() == "Mute"
+    }
+    click(ADD_MEMBERS)
+    poll(what = "the invite members sheet listing bob") { ModalManager.end.hasModalsOpen() && exists(Ui.InviteMembers.Contact(contactOf("bob").contactId)) }
+    escape()
+    poll(what = "the invite members sheet to close") { !ModalManager.end.hasModalsOpen() }
+    cycleGroupNtfs("team")
+    backToChatList()
+    hostGroup(bob, "club", "alice")
+    joinGroupFromList(alice, bob, "club")
+    alice.chatList.open("club")
+    openBarMenu()
+    poll(what = "`Search` and `Mute` without `Invite members` or `Group link` in the toolbar menu of bob's #club") {
+      exists(SEARCH) && ntfLabel() == "Mute" && !exists(ADD_MEMBERS) && !seesText("Group link") && !seesText("Invite members")
+    }
+    click(SEARCH)
+    waitFor(Ui.Chat.Bar.part("search"))
+  }
+
+  private fun UiScope.cycleGroupNtfs(group: String) {
+    openBarMenu()
+    poll(what = "`Mute` in the toolbar menu of #$group") { ntfLabel() == "Mute" }
+    click(NTF)
+    poll(what = "#$group muted to mentions only") { groupInfoOf(group).chatSettings.enableNtfs == MsgFilter.Mentions }
+    openBarMenu()
+    poll(what = "`Mute all` in the toolbar menu of #$group") { ntfLabel() == "Mute all" }
+    click(NTF)
+    poll(what = "#$group muted") { groupInfoOf(group).chatSettings.enableNtfs == MsgFilter.None }
+    openBarMenu()
+    poll(what = "`Unmute` in the toolbar menu of #$group") { ntfLabel() == "Unmute" }
+    click(NTF)
+    poll(what = "#$group unmuted") { groupInfoOf(group).chatSettings.enableNtfs == MsgFilter.All }
+  }
+
+  private fun UiScope.openBarMenu() {
+    hideKeyboard()
+    click(Ui.Chat.BarMenu)
+    waitFor(NTF)
+  }
+
+  private fun UiScope.ntfLabel(): String? = if (exists(NTF)) textsOf(NTF).firstOrNull() else null
+
+  private companion object {
+    val TITLE = Ui.Chat.Bar.part("title")
+    val SEARCH = Ui.Chat.BarMenuItem("search")
+    val NTF = Ui.Chat.BarMenuItem("ntf")
+    val ADD_MEMBERS = Ui.Chat.BarMenuItem("addMembers")
+    const val FULL_NAME = "Robert Brown"
+    const val PQ_E2EE = "protected by quantum resistant e2e encryption"
+    const val GROUP_E2EE = "protected by end-to-end encryption with perfect forward secrecy"
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ComposeTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ComposeTest.kt
new file mode 100644
index 0000000000..b29c60b3ba
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ComposeTest.kt
@@ -0,0 +1,208 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.PREVIEW_IMAGE_DATA
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.becomeBotWithCommands
+import chat.simplex.app.ui.harness.commandShown
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.contactOf
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.groupMemberId
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.app.ui.harness.ownGroupOfThree
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertFalse
+import org.junit.Test
+
+class ComposeTest : UiTest() {
+  @Test fun sendText_sendButton_peerReceives() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    poll(what = "the empty message field with the voice and live buttons and no send button") {
+      exists(Ui.Chat.Message) && editableText(Ui.Chat.Message).isNullOrEmpty() &&
+        exists(Ui.Chat.Live) && seesDescription("Record voice message") && !exists(Ui.Chat.Send)
+    }
+    typeInto(Ui.Chat.Message, "   ")
+    poll(what = "a disabled send button for a blank message") { exists(Ui.Chat.Send) && !isEnabled(Ui.Chat.Send) && !exists(Ui.Chat.Live) }
+    replaceText(Ui.Chat.Message, TEXT)
+    click(Ui.Chat.Send)
+    bob expectsMessage "alice> $TEXT"
+    poll(what = "the message field cleared after Send") { editableText(Ui.Chat.Message).isNullOrEmpty() }
+    chat.itemId(TEXT)
+  }
+
+  @Test fun compose_clearTextButton_clears() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, "one\ntwo\nthree")
+    settle()
+    assertFalse("the clear button is shown for three lines", exists(Ui.Chat.ClearText))
+    typeInto(Ui.Chat.Message, "\nfour")
+    poll(what = "the clear button for four lines") { exists(Ui.Chat.ClearText) }
+    hideKeyboard()
+    click(Ui.Chat.ClearText)
+    poll(what = "the message field empty and the clear button gone") { editableText(Ui.Chat.Message).isNullOrEmpty() && !exists(Ui.Chat.ClearText) }
+    chat.send("hello\nthere")
+    bob expectsMessage "alice> hello"
+    bob expects "there"
+  }
+
+  @Test fun markdown_sent_rendersFormatted_peerGetsMarkers() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send(MARKDOWN)
+    bob expectsMessage "alice> $CLI_MARKDOWN"
+    val id = chat.itemId(MARKDOWN)
+    poll(what = "alice's bubble showing `bold italic strike code` without the markdown markers") {
+      textsOf(Ui.Chat.Item(id)).let { t -> t.any { "bold italic strike code" in it } && t.none { m -> MARKERS.any { it in m } } }
+    }
+    bob sends "/? @alice *bold*"
+    bob expectsMessage "alice> $CLI_MARKDOWN"
+  }
+
+  @Test fun linkPreview_received_rendersCard() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    val pageUrl = "http://127.0.0.1/page"
+    val title = "Loopback page"
+    val description = "A page served on the loopback address"
+    bob sends "@alice see http://127.0.0.1/other"
+    val plain = chat.itemId("see http://127.0.0.1/other")
+    val aliceId = bob.contactId("alice")
+    bob sends """/_send @$aliceId json [{"msgContent": {"type": "link", "text": "$pageUrl", "preview": {"uri": "$pageUrl", "title": "$title", "description": "$description", "image": "$PREVIEW_IMAGE_DATA"}}}]"""
+    val card = chat.itemId(pageUrl)
+    poll(what = "bob's link message with the preview card: image, title, description and URL") {
+      "link preview image" in descriptionsOf(Ui.Chat.Item(card)) && textsOf(Ui.Chat.Item(card)).let { t -> title in t && description in t && pageUrl in t }
+    }
+    check("link preview image" !in descriptionsOf(Ui.Chat.Item(plain)) && title !in textsOf(Ui.Chat.Item(plain))) { "bob's plain text message with a link shows a preview card" }
+  }
+
+  @Test fun mention_maxReached_showsLimit() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath"); val dan = cli("dan")
+    ownGroupOfThree(alice, bob, cath, dan)
+    typeInto(Ui.Chat.Message, "@b")
+    val bobRow = Ui.Chat.MentionMember(groupMemberId("bob"))
+    val cathRow = Ui.Chat.MentionMember(groupMemberId("cath"))
+    val danRow = Ui.Chat.MentionMember(groupMemberId("dan"))
+    val rows = listOf(bobRow, cathRow, danRow)
+    poll(what = "the mention picker listing bob and neither cath nor dan for `@b`") { exists(bobRow) && !exists(cathRow) && !exists(danRow) }
+    click(bobRow)
+    poll(what = "`@bob ` in the message field") { editableText(Ui.Chat.Message) == "@bob " }
+    typeInto(Ui.Chat.Message, "@")
+    poll(what = "bob, cath and dan offered and enabled for the second mention, without the limit message") { rows.all { exists(it) && isEnabled(it) } && !seesText(MENTION_LIMIT) }
+    click(cathRow)
+    poll(what = "`@bob @cath ` in the message field") { editableText(Ui.Chat.Message) == "@bob @cath " }
+    typeInto(Ui.Chat.Message, "@")
+    poll(what = "bob, cath and dan offered and enabled for the third mention, without the limit message") { rows.all { exists(it) && isEnabled(it) } && !seesText(MENTION_LIMIT) }
+    click(danRow)
+    poll(what = "`@bob @cath @dan ` in the message field") { editableText(Ui.Chat.Message) == "@bob @cath @dan " }
+    typeInto(Ui.Chat.Message, "@")
+    poll(what = "the limit message with every member disabled for a fourth mention") { seesText(MENTION_LIMIT) && rows.all { exists(it) && !isEnabled(it) } }
+  }
+
+  @Test fun mention_editAddsMention() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    val chat = ownGroup(alice, "team", bob, cath)
+    chat.send("hello")
+    bob.eventuallyMessage("#team alice> hello", CONNECT_TIMEOUT_MS)
+    cath.eventuallyMessage("#team alice> hello", CONNECT_TIMEOUT_MS)
+    val id = chat.itemId("hello")
+    check(chat.item(id)?.mentions.isNullOrEmpty()) { "`hello` mentions someone before the edit: ${chat.item(id)?.mentions}" }
+    hideKeyboard()
+    chat.menu("hello", "edit")
+    poll(what = "the edit bar with `hello` in the field") { editableText(Ui.Chat.Message) == "hello" && exists(described("Cancel")) }
+    replaceText(Ui.Chat.Message, "hello @b")
+    val bobId = groupMemberId("bob")
+    val cathId = groupMemberId("cath")
+    poll(what = "the mention picker listing bob and not cath for `@b` while editing") { exists(Ui.Chat.MentionMember(bobId)) && !exists(Ui.Chat.MentionMember(cathId)) }
+    click(Ui.Chat.MentionMember(bobId))
+    poll(what = "`hello @bob ` in the message field") { editableText(Ui.Chat.Message) == "hello @bob " }
+    typeInto(Ui.Chat.Message, "there")
+    chat.sendComposed()
+    bob.eventuallyMessage("#team alice> [edited] hello @bob there", CONNECT_TIMEOUT_MS)
+    cath.eventuallyMessage("#team alice> [edited] hello @bob there", CONNECT_TIMEOUT_MS)
+    poll(what = "alice's `hello` edited into `hello @bob there`, mentioning bob") {
+      chat.item(id)?.let { it.content.text == "hello @bob there" && it.mentions?.get("bob")?.memberRef?.groupMemberId == bobId } == true &&
+        textsOf(Ui.Chat.Item(id)).any { "hello @bob there" in it }
+    }
+  }
+
+  @Test fun commandsMenu_slash_showsBotCommands() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    bob.becomeBotWithCommands()
+    connect(bob)
+    alice.chatList.open("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's bot commands in alice's contact") { contactOf("bob").profile.preferences?.commands?.isNotEmpty() == true }
+    waitFor(Ui.Chat.CommandsButton)
+    check(!exists(Ui.Chat.Command("help")) && !exists(MORE)) { "the commands menu is open before `//` is clicked" }
+    hideKeyboard()
+    click(Ui.Chat.CommandsButton)
+    poll(what = "the commands menu with Help, Order and More, without the commands inside More") {
+      commandShown("help", "Help") && commandShown("order", "Order") && exists(MORE) && "More" in textsOf(MORE) &&
+        !exists(Ui.Chat.Command("status")) && !exists(Ui.Chat.CommandsBack)
+    }
+    click(MORE)
+    poll(what = "the More submenu with Status and Cost under a back row labelled More") {
+      commandShown("status", "Status") && commandShown("cost", "Cost") && exists(Ui.Chat.CommandsBack) && "More" in textsOf(Ui.Chat.CommandsBack) &&
+        !exists(Ui.Chat.Command("help")) && !exists(MORE)
+    }
+    click(Ui.Chat.CommandsBack)
+    poll(what = "the top commands back after the back row") {
+      exists(Ui.Chat.Command("help")) && exists(Ui.Chat.Command("order")) && exists(MORE) && !exists(Ui.Chat.Command("status")) && !exists(Ui.Chat.CommandsBack)
+    }
+    click(Ui.Chat.CommandsButton)
+    poll(what = "the commands menu closed by `//`") { !exists(Ui.Chat.Command("help")) && !exists(MORE) }
+    typeInto(Ui.Chat.Message, "/or")
+    poll(what = "only Order listed for `/or`") {
+      exists(Ui.Chat.Command("order")) && !exists(Ui.Chat.Command("help")) && !exists(MORE) && !exists(Ui.Chat.Command("status")) && !exists(Ui.Chat.Command("cost"))
+    }
+    replaceText(Ui.Chat.Message, "/st")
+    poll(what = "only Status from the More submenu listed for `/st`") {
+      exists(Ui.Chat.Command("status")) && !exists(Ui.Chat.Command("cost")) && !exists(Ui.Chat.Command("order")) && !exists(Ui.Chat.Command("help")) && !exists(Ui.Chat.CommandsBack)
+    }
+    replaceText(Ui.Chat.Message, "/")
+    poll(what = "the top commands listed for `/`") {
+      exists(Ui.Chat.Command("help")) && exists(Ui.Chat.Command("order")) && exists(MORE) && !exists(Ui.Chat.Command("status"))
+    }
+  }
+
+  @Test fun commandsMenu_selectCommand_sendsToBot() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    bob.becomeBotWithCommands()
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's bot commands in alice's contact") { contactOf("bob").profile.preferences?.commands?.isNotEmpty() == true }
+    hideKeyboard()
+    click(Ui.Chat.CommandsButton)
+    click(Ui.Chat.Command("order"))
+    poll(what = "`/order <number>` in the message field and the commands menu closed") {
+      editableText(Ui.Chat.Message) == "/order <number>" && !exists(Ui.Chat.Command("order")) && !exists(Ui.Chat.Command("help"))
+    }
+    replaceText(Ui.Chat.Message, "/order 7")
+    chat.sendComposed()
+    bob.expectsMessage("alice> /order 7", CONNECT_TIMEOUT_MS)
+    hideKeyboard()
+    click(Ui.Chat.CommandsButton)
+    click(Ui.Chat.Command("help"))
+    poll(what = "the message field empty and the commands menu closed after Help") {
+      editableText(Ui.Chat.Message).isNullOrEmpty() && !exists(Ui.Chat.Command("help"))
+    }
+    bob.expectsMessage("alice> /help", CONNECT_TIMEOUT_MS)
+    chat.itemId("/help")
+  }
+
+  private companion object {
+    const val TEXT = "hello there 🙂"
+    const val MARKDOWN = "*bold* _italic_ ~strike~ `code`"
+    const val CLI_MARKDOWN = "bold italic strike `code`"
+    val MARKERS = listOf("*bold*", "_italic_", "~strike~", "`code`")
+    const val MENTION_LIMIT = "You can mention up to 3 members per message!"
+    val MORE = Ui.Chat.CommandMenu("More")
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ContextMenuTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ContextMenuTest.kt
new file mode 100644
index 0000000000..8452ad5b9d
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ContextMenuTest.kt
@@ -0,0 +1,49 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.sendsFileTo
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+private val ACTIONS = listOf("reply", "copy", "download", "edit", "forward", "info", "delete", "reveal", "hide", "moderate", "report", "select")
+
+class ContextMenuTest : UiTest() {
+  @Test fun contextMenu_itemsMatrix_byItemType() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice copy me"
+    bob.sendsFileTo("alice", bob.createFile("offer.txt", "offered text"), 1, "offer.txt")
+    bob sends "@alice to be deleted"
+    bob sends "\\@alice to be deleted"
+    bob expects "message marked deleted"
+    val chat = alice.chatList.open("bob")
+    val text = chat.itemId("copy me")
+    val file = chat.itemId("bob's offer of offer.txt") { it.file?.fileName == "offer.txt" }
+    val deleted = chat.itemId("bob's `to be deleted` marked deleted") { it.content.text == "to be deleted" && it.meta.itemDeleted != null }
+    setClipboardText("nothing copied yet")
+    poll(what = "the clipboard holding the placeholder text") { clipboardText() == "nothing copied yet" }
+    assertEquals("menu of bob's text", setOf("reply", "share", "copy", "forward", "info", "delete", "select"), menuOf(text))
+    click(Ui.Chat.ItemMenu(text, "copy"))
+    poll(what = "`copy me` on the clipboard after Copy") { clipboardText() == "copy me" }
+    assertEquals("menu of bob's file offer", setOf("reply", "download", "info", "delete", "select"), menuOf(file))
+    closeBySelecting(file)
+    assertEquals("menu of bob's message marked deleted", setOf("reveal", "info", "delete", "select"), menuOf(deleted))
+    closeBySelecting(deleted)
+  }
+
+  private fun UiScope.menuOf(id: Long): Set<String> {
+    rightClick(Ui.Chat.Item(id))
+    waitFor(Ui.Chat.ItemMenu(id, "select"))
+    return ACTIONS.filter { exists(Ui.Chat.ItemMenu(id, it)) }.toSet() + listOfNotNull("share".takeIf { seesText("Share") })
+  }
+
+  private fun UiScope.closeBySelecting(id: Long) {
+    click(Ui.Chat.ItemMenu(id, "select"))
+    waitFor(Ui.Chat.Selection.part("title"))
+    escape()
+    poll(what = "selection mode to end") { !exists(Ui.Chat.Selection.part("title")) }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/CopyShareTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/CopyShareTest.kt
new file mode 100644
index 0000000000..af3576aeb0
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/CopyShareTest.kt
@@ -0,0 +1,47 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.itemFileOf
+import chat.simplex.app.ui.harness.sendsFileTo
+import chat.simplex.app.ui.harness.storedBytesOf
+import chat.simplex.common.model.CIFileStatus
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.io.File
+
+class CopyShareTest : UiTest() {
+  @Test fun save_encryptedFile_decrypts() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob.sendsFileTo("alice", bob.createFile(NOTES_NAME, NOTES), 1, NOTES_NAME)
+    val target = File(exchangeDir(), "saved-$NOTES_NAME").apply { delete() }
+    val chat = alice.chatList.open("bob")
+    val id = chat.itemId("the item of $NOTES_NAME") { it.file?.fileName == NOTES_NAME }
+    rightClick(Ui.Chat.Item(id))
+    waitFor(Ui.Chat.ItemMenu(id, "download"))
+    check(!exists(Ui.Chat.ItemMenu(id, "copy")) && !exists(Ui.Chat.ItemMenu(id, "share")) && !exists(Ui.Chat.ItemMenu(id, "save"))) {
+      "the menu of a file that is not downloaded offers Copy, Share or Save"
+    }
+    click(Ui.Chat.ItemMenu(id, "download"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "$NOTES_NAME received") { itemFileOf(id)?.fileStatus is CIFileStatus.RcvComplete }
+    val stored = itemFileOf(id)!!
+    check(stored.fileSource?.cryptoArgs != null && !storedBytesOf(stored).contentEquals(NOTES.toByteArray())) { "$NOTES_NAME is stored unencrypted" }
+    rightClick(Ui.Chat.Item(id))
+    waitFor(Ui.Chat.ItemMenu(id, "save"))
+    check(exists(Ui.Chat.ItemMenu(id, "copy")) && exists(Ui.Chat.ItemMenu(id, "share")) && !exists(Ui.Chat.ItemMenu(id, "download"))) {
+      "the menu of the downloaded file has no Copy or Share, or still offers Download"
+    }
+    check(!target.exists()) { "${target.name} exists before Save" }
+    saveFileAs(target) { click(Ui.Chat.ItemMenu(id, "save")) }
+    poll(what = "the decrypted $NOTES_NAME written to ${target.name}") { target.length() == NOTES.length.toLong() }
+    assertEquals(NOTES, target.readText())
+  }
+
+  private companion object {
+    const val NOTES_NAME = "save-notes.md"
+    const val NOTES = "Shopping list from bob: apples and pears"
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/DeleteMessageTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/DeleteMessageTest.kt
index e8eb361e8b..2799bc1aac 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/DeleteMessageTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/DeleteMessageTest.kt
@@ -1,8 +1,17 @@
 package chat.simplex.app.ui.chat
 
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
 import chat.simplex.app.ui.harness.UiTest
 import chat.simplex.app.ui.harness.connect
+import chat.simplex.common.model.ChatFeature
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.ContactFeatureAllowed
+import chat.simplex.common.model.contactFeaturesAllowedToPrefs
+import chat.simplex.common.model.contactUserPrefsToFeaturesAllowed
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
+import kotlinx.coroutines.runBlocking
 import org.junit.Assert.assertFalse
 import org.junit.Test
 
@@ -21,4 +30,101 @@ class DeleteMessageTest : UiTest() {
     chat.send("ping")
     bob expectsMessage "alice> ping"
   }
+
+  @Test fun delete_forEveryone_fullDeletion_peerSeesDeleted() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("one")
+    bob expectsMessage "alice> one"
+    val one = chat.itemId("one")
+    chat.menu("one", "delete")
+    poll(what = "`Delete message?` saying it will be marked for deletion, with both buttons") {
+      seesText("Delete message?") && seesText(MARK_ONE) && exists(FOR_ME) && exists(FOR_EVERYONE)
+    }
+    click(FOR_ME)
+    poll(what = "`one` removed from alice's chat") { chat.item(one) == null && !exists(Ui.Chat.Item(one)) }
+    bob sends "/set delete @alice always"
+    bob expects "you updated preferences for alice:"
+    bob expects "Full deletion: enabled for contact (you allow: always, contact allows: no)"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's full-deletion consent reaching alice") { alice.chatList.chat("bob").chatInfo.featureEnabled(ChatFeature.FullDelete) }
+    chat.send("two")
+    bob expectsMessage "alice> two"
+    val two = chat.itemId("two")
+    chat.menu("two", "delete")
+    poll(what = "`Delete message?` saying it cannot be undone") { seesText(FULL_ONE) && !seesText(MARK_ONE) && exists(FOR_EVERYONE) }
+    click(FOR_EVERYONE)
+    bob expectsMessage "alice> [deleted] two"
+    poll(what = "`two` removed, not marked deleted") { chat.item(two) == null && !exists(Ui.Chat.Item(two)) }
+    chat.send("three")
+    bob expectsMessage "alice> three"
+    chat.send("four")
+    bob expectsMessage "alice> four"
+    val three = chat.itemId("three"); val four = chat.itemId("four")
+    hideKeyboard()
+    chat.select("three")
+    chat.toggle(four)
+    poll(what = "Selected 2") { chat.selectionTitle() == "Selected 2" }
+    click(SEL_DELETE)
+    poll(what = "`Delete 2 messages?` saying they cannot be undone, with For everyone") { seesText("Delete 2 messages?") && seesText(FULL_MANY) && exists(FOR_EVERYONE) }
+    click(FOR_EVERYONE)
+    bob expectsMessage "alice> [deleted] three"
+    bob expectsMessage "alice> [deleted] four"
+    poll(what = "both removed and selection ended") { chat.item(three) == null && chat.item(four) == null && !exists(SEL_TITLE) }
+  }
+
+  @Test fun markedDeleted_received_revealHide() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice keep"
+    bob sends "@alice one"
+    bob sends "@alice two"
+    val chat = alice.chatList.open("bob")
+    val keep = chat.itemId("keep"); val one = chat.itemId("one"); val two = chat.itemId("two")
+    check(textsOf(Ui.Chat.Item(one)).let { t -> t.any { "one" in it } && "marked deleted" !in t }) { "`one` is not shown as sent before bob deletes it" }
+    bob sends "\\@alice one"
+    bob expects "message marked deleted"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`one` shown as `marked deleted` without its text") {
+      textsOf(Ui.Chat.Item(one)).let { t -> "marked deleted" in t && t.none { "one" in it } }
+    }
+    bob sends "\\@alice two"
+    bob expects "message marked deleted"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`2 messages marked deleted` on one row") {
+      "2 messages marked deleted" in textsOf(Ui.Chat.Item(two)) && !exists(Ui.Chat.Item(one))
+    }
+    check(textsOf(Ui.Chat.Item(keep)).any { "keep" in it }) { "`keep` changed after bob's deletions" }
+    chat.menu("two", "reveal")
+    poll(what = "both texts revealed") { textsOf(Ui.Chat.Item(one)).any { "one" in it } && textsOf(Ui.Chat.Item(two)).any { "two" in it } }
+    chat.menu("two", "hide")
+    poll(what = "collapsed again") { "2 messages marked deleted" in textsOf(Ui.Chat.Item(two)) && !exists(Ui.Chat.Item(one)) }
+    chat.menu("two", "select")
+    poll(what = "the collapsed range selected as 2") { chat.selectionTitle() == "Selected 2" }
+    escape()
+    poll(what = "selection mode to end") { !exists(SEL_TITLE) }
+    allowFullDeletionViaApi("bob")
+    bob expects "alice updated preferences for you:"
+    bob expects "Full deletion: enabled for you (you allow: default (no), contact allows: always)"
+    bob sends "@alice three"
+    val three = chat.itemId("three")
+    bob sends "\\@alice three"
+    bob expects "message deleted"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`three` removed from alice's chat") { chat.item(three) == null && !exists(Ui.Chat.Item(three)) }
+    check(exists(Ui.Chat.Item(keep)) && "2 messages marked deleted" in textsOf(Ui.Chat.Item(two))) { "`keep` or the collapsed row changed after the full deletion" }
+  }
+
+  private fun allowFullDeletionViaApi(contactName: String) {
+    val contact = (chatModel.chats.value.first { it.chatInfo.chatViewName == contactName }.chatInfo as ChatInfo.Direct).contact
+    val prefs = contactFeaturesAllowedToPrefs(contactUserPrefsToFeaturesAllowed(contact.mergedPreferences).copy(fullDelete = ContactFeatureAllowed.Always))
+    runBlocking { chatController.apiSetContactPrefs(null, contact.contactId, prefs) } ?: error("apiSetContactPrefs($contactName) failed")
+  }
+
+  private companion object {
+    val FOR_ME = Ui.Alert.Option(Ui.AlertSource.Shared, "forMe")
+    val FOR_EVERYONE = Ui.Alert.Option(Ui.AlertSource.Shared, "forEveryone")
+    val SEL_TITLE = Ui.Chat.Selection.part("title")
+    val SEL_DELETE = Ui.Chat.Selection.part("delete")
+    const val MARK_ONE = "Message will be marked for deletion. The recipient(s) will be able to reveal this message."
+    const val FULL_ONE = "Message will be deleted - this cannot be undone!"
+    const val FULL_MANY = "Messages will be deleted - this cannot be undone!"
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/DraftTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/DraftTest.kt
new file mode 100644
index 0000000000..3c13e51c20
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/DraftTest.kt
@@ -0,0 +1,88 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitRowText
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.switchAwayFromChat
+import chat.simplex.app.ui.harness.visitNotesAndBack
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class DraftTest : UiTest() {
+  @Test fun draft_onlyLastChatKept() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    val bobId = alice.chatList.chatId("bob"); val cathId = alice.chatList.chatId("cath")
+    alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, "for bob")
+    backToChatList()
+    alice.chatList.open("cath")
+    poll(what = "cath's field empty, bob's draft not carried over") { chatModel.chatId.value == cathId && editableText(Ui.Chat.Message).isNullOrEmpty() }
+    typeInto(Ui.Chat.Message, "for cath")
+    switchAwayFromChat(alice)
+    poll(what = "a draft on cath's row only") {
+      alice.chatList.rowTexts("cath").any { it.endsWith(" for cath") } && alice.chatList.rowTexts("bob").none { it.endsWith(" for bob") }
+    }
+    alice.chatList.open("bob")
+    poll(what = "bob's field empty, only the last draft kept") { chatModel.chatId.value == bobId && editableText(Ui.Chat.Message).isNullOrEmpty() }
+    backToChatList()
+    val chat = alice.chatList.open("cath")
+    poll(what = "cath's draft restored") { chatModel.chatId.value == cathId && editableText(Ui.Chat.Message) == "for cath" }
+    chat.sendComposed()
+    cath.eventuallyMessage("alice> for cath", CONNECT_TIMEOUT_MS)
+    poll(what = "cath's row with the sent text and no draft") {
+      alice.chatList.rowTexts("cath").let { "for cath" in it && it.none { t -> t != "for cath" && t.endsWith(" for cath") } }
+    }
+  }
+
+  @Test fun draft_withQuote_restored() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice question"
+    awaitRowText(alice, "bob", "question")
+    val chat = alice.chatList.open("bob")
+    chat.send("hello")
+    bob expectsMessage "alice> hello"
+    check(!seesDescription("Context icon")) { "a context bar is shown before Reply" }
+    chat.menu("question", "reply")
+    typeInto(Ui.Chat.Message, "answer")
+    visitNotesAndBack(alice, "bob")
+    poll(what = "the reply draft restored") { editableText(Ui.Chat.Message) == "answer" && seesDescription("Context icon") }
+    chat.sendComposed()
+    bob expectsMessage "alice> > question"
+    bob expects "      answer"
+    chat.menu("hello", "edit")
+    poll(what = "the edited text in the field") { editableText(Ui.Chat.Message) == "hello" }
+    replaceText(Ui.Chat.Message, "hello world")
+    visitNotesAndBack(alice, "bob")
+    poll(what = "the edit draft restored") { editableText(Ui.Chat.Message) == "hello world" && seesDescription("Context icon") }
+    chat.sendComposed()
+    bob expectsMessage "alice> [edited] hello world"
+  }
+
+  @Test fun draft_clearedWhenSendDisabled() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    val bobId = alice.chatList.chatId("bob"); val cathId = alice.chatList.chatId("cath")
+    alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, "for bob")
+    bob sends "/d alice"
+    bob expects "alice: contact is deleted"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the field cleared once sending is impossible") {
+      !alice.chatList.chat("bob").chatInfo.sendMsgEnabled && exists(Ui.Chat.Message) && editableText(Ui.Chat.Message).isNullOrEmpty()
+    }
+    backToChatList()
+    alice.chatList.open("cath")
+    poll(what = "no draft on bob's row") { chatModel.chatId.value == cathId && alice.chatList.rowTexts("bob").none { it.endsWith(" for bob") } }
+    typeInto(Ui.Chat.Message, "for cath")
+    backToChatList()
+    alice.chatList.open("bob")
+    poll(what = "bob's chat open") { chatModel.chatId.value == bobId }
+    backToChatList()
+    alice.chatList.open("cath")
+    poll(what = "cath's draft kept through the visit to bob's chat") { chatModel.chatId.value == cathId && editableText(Ui.Chat.Message) == "for cath" }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/EditMessageTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/EditMessageTest.kt
index 1f9ba1971d..7899fd527d 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/EditMessageTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/EditMessageTest.kt
@@ -1,20 +1,98 @@
 package chat.simplex.app.ui.chat
 
+import chat.simplex.app.ui.harness.UiScope
 import chat.simplex.app.ui.harness.UiTest
 import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class EditMessageTest : UiTest() {
+  @Test fun edit_menu_updatesPeer() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("hello")
+    bob expectsMessage "alice> hello"
+    val id = chat.itemId("hello")
+    chat.itemInfo("hello").run {
+      val h = history()
+      check(h.count { it == "(current)" } == 1 && h.indexOfFirst { it.startsWith("hello") } in 0 until h.indexOf("(current)") && h.none { "hey" in it }) { "unedited history: $h" }
+      close()
+    }
+    waitFor(Ui.Chat.Message)
+    assertFalse("edit bar before Edit", exists(described("Cancel")))
+    chat.menu("hello", "edit")
+    poll(what = "the edit bar with `hello` in the message field") { editableText(Ui.Chat.Message) == "hello" && exists(described("Cancel")) }
+    hideKeyboard()
+    click(described("Cancel"))
+    poll(what = "the edit bar gone and the field empty") { !exists(described("Cancel")) && editableText(Ui.Chat.Message).isNullOrEmpty() }
+    chat.menu("hello", "edit")
+    poll(what = "`hello` in the message field") { editableText(Ui.Chat.Message) == "hello" }
+    chat.replaceAndSend("hello")
+    chat.menu("hello", "edit")
+    chat.replaceAndSend("hey 👋")
+    bob expectsMessage "alice> [edited] hey 👋"
+    poll(what = "the same bubble showing `hey 👋`, not `hello`, edited in the model") {
+      chat.item(id)?.let { it.content.text == "hey 👋" && it.meta.itemEdited } == true &&
+        textsOf(Ui.Chat.Item(id)).let { t -> t.any { "hey 👋" in it } && t.none { "hello" in it } }
+    }
+    chat.itemInfo("hey 👋").run {
+      val h = history()
+      val newest = h.indexOfFirst { it.startsWith("hey 👋") }
+      val current = h.indexOf("(current)")
+      val old = h.indexOfFirst { it.startsWith("hello") }
+      check(newest in 0 until current && current < old && h.count { it == "(current)" } == 1) { "edited history: $h" }
+      close()
+    }
+  }
+
+  @Test fun edit_notOffered_forReceivedOrForwarded() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice theirs"
+    val chat = alice.chatList.open("bob")
+    val received = chat.itemId("theirs")
+    chat.send("mine")
+    bob expectsMessage "alice> mine"
+    val mine = chat.itemId("mine")
+    chat.forwardTo("theirs", "bob")
+    var forwarded = 0L
+    poll(what = "alice's forwarded copy of `theirs`") {
+      forwarded = chatModel.chatsContext.chatItems.value.lastOrNull { it.content.text == "theirs" && it.meta.itemForwarded != null }?.id ?: 0L
+      forwarded != 0L && exists(Ui.Chat.Item(forwarded))
+    }
+    hideKeyboard()
+    assertTrue("Edit not offered on alice's own message", editOffered(mine))
+    assertFalse("Edit offered on bob's message", editOffered(received))
+    assertFalse("Edit offered on the forwarded message", editOffered(forwarded))
+  }
+
   @Test fun edit_received_updatesBubble() = uiTest {
     val alice = app("alice"); val bob = cli("bob")
     connect(bob)
     bob sends "@alice hello"
     val chat = alice.chatList.open("bob")
     val id = chat.itemId("hello")
+    check(textsOf(Ui.Chat.Item(id)).any { "hello" in it }) { "bob's bubble does not show `hello` before the edit" }
     bob sends "!@alice hey"
-    poll(what = "the edited bubble") {
-      chat.item(id)?.let { it.content.text == "hey" && it.meta.itemEdited } == true && textsOf(Ui.Chat.Item(id)).any { "hey" in it }
+    poll(what = "the edited bubble showing `hey`, not `hello`") {
+      chat.item(id)?.let { it.content.text == "hey" && it.meta.itemEdited } == true &&
+        textsOf(Ui.Chat.Item(id)).let { t -> t.any { "hey" in it } && t.none { "hello" in it } }
     }
   }
+
+  private fun UiScope.editOffered(id: Long): Boolean {
+    rightClick(Ui.Chat.Item(id))
+    waitFor(Ui.Chat.ItemMenu(id, "select"))
+    val offered = exists(Ui.Chat.ItemMenu(id, "edit"))
+    click(Ui.Chat.ItemMenu(id, "select"))
+    waitFor(Ui.Chat.Selection.part("title"))
+    escape()
+    poll(what = "selection mode to end") { !exists(Ui.Chat.Selection.part("title")) }
+    return offered
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ForwardTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ForwardTest.kt
index 301b4dcf93..4015df3495 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ForwardTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ForwardTest.kt
@@ -1,11 +1,27 @@
 package chat.simplex.app.ui.chat
 
 import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
+import chat.simplex.app.ui.harness.UiScope
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitRowText
+import chat.simplex.app.ui.harness.backToChatList
 import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.connectPeers
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.app.ui.harness.newGroupsViaApi
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.app.ui.harness.receivesFile
+import chat.simplex.app.ui.harness.sendsFileTo
+import chat.simplex.common.model.CIFileStatus
 import chat.simplex.common.model.CIForwardedFrom
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.MsgContent
 import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertFalse
 import org.junit.Test
 
 class ForwardTest : UiTest() {
@@ -31,4 +47,257 @@ class ForwardTest : UiTest() {
     val id = chat.itemId("hey")
     poll(what = "the `saved from` / `bob` header") { textsOf(Ui.Chat.Item(id)).let { t -> t.any { "saved from" in it } && "bob" in t } }
   }
+
+  @Test fun forward_acrossChatTypes_peersReceiveAndSourceOpens() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    ownGroup(alice, "team", cath)
+    backToChatList()
+    bob sends "@alice hey"
+    awaitRowText(alice, "bob", "hey")
+    val chat = alice.chatList.open("bob")
+    chat.forwardTo("hey", "team")
+    cath.eventuallyMessage("#team alice> -> forwarded", CONNECT_TIMEOUT_MS)
+    cath expects "      hey"
+    cath sends "#team hello"
+    val teamId = alice.chatList.chatId("team"); val bobId = alice.chatList.chatId("bob")
+    poll(what = "team open after the forward") { chatModel.chatId.value == teamId }
+    val original = chat.itemId("hello")
+    chat.forwardTo("hello", "bob")
+    bob.eventuallyMessage("alice> -> forwarded", CONNECT_TIMEOUT_MS)
+    bob expects "      hello"
+    val fwd = chat.itemId("hello")
+    poll(what = "the `forwarded` header without the source name") {
+      chatModel.chatId.value == bobId && textsOf(Ui.Chat.Item(fwd)).let { t -> "forwarded" in t && t.none { "forwarded from" in it || it == "team" } }
+    }
+    click(Ui.Chat.Item(fwd).part("goTo"))
+    poll(what = "team's chat opened at cath's `hello`") { chatModel.chatId.value == teamId && exists(Ui.Chat.Item(original)) }
+    backToChatList()
+    val notesId = alice.chatList.chatId("Private notes")
+    val notes = alice.chatList.open("Private notes")
+    poll(what = "the notes folder open") { chatModel.chatId.value == notesId }
+    notes.send("memo")
+    notes.forwardTo("memo", "bob")
+    bob.expectsMessage("alice> memo", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun forward_withComment_sendsCommentQuoted() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    bob sends "@alice hey"
+    awaitRowText(alice, "bob", "hey")
+    val chat = alice.chatList.open("bob")
+    val cathId = alice.chatList.chatId("cath")
+    chat.menu("hey", "forward")
+    alice.chatList.shareTo("cath")
+    poll(what = "cath's chat with the forwarding bar") { chatModel.chatId.value == cathId && seesDescription("Context icon") && isEnabled(Ui.Chat.Send) }
+    click(described("Cancel"))
+    poll(what = "the forwarding bar gone and nothing forwarded") {
+      exists(Ui.Chat.Message) && !seesDescription("Context icon") && chatModel.chatsContext.chatItems.value.none { it.content.text == "hey" }
+    }
+    typeInto(Ui.Chat.Message, "unsent")
+    backToChatList()
+    alice.chatList.open("bob")
+    poll(what = "cath's row showing the draft") { alice.chatList.rowTexts("cath").any { it.endsWith(" unsent") } }
+    chat.menu("hey", "forward")
+    alice.chatList.shareTo("cath")
+    poll(what = "the forwarding bar with an empty field, the draft hidden") {
+      chatModel.chatId.value == cathId && seesDescription("Context icon") && editableText(Ui.Chat.Message).isNullOrEmpty()
+    }
+    typeInto(Ui.Chat.Message, "see this")
+    poll(what = "the send button to be enabled") { isEnabled(Ui.Chat.Send) }
+    pressEnter(Ui.Chat.Message)
+    cath.expectsMessage("alice> -> forwarded", CONNECT_TIMEOUT_MS)
+    cath expects "      hey"
+    cath expectsMessage "alice> >> hey"
+    cath expects "      see this"
+    poll(what = "the draft back after the forward") { editableText(Ui.Chat.Message) == "unsent" && !seesDescription("Context icon") }
+  }
+
+  @Test fun forwarded_received_showsHeader() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connectPeers(bob, cath)
+    bob sends "@alice plain"
+    cath sends "@bob secret"
+    bob.eventuallyMessage("cath> secret", CONNECT_TIMEOUT_MS)
+    bob types "@alice <- @cath secret"
+    bob expectsMessage "@alice <- @cath"
+    bob expects "      secret"
+    awaitRowText(alice, "bob", "secret")
+    val chat = alice.chatList.open("bob")
+    val plain = chat.itemId("plain")
+    val fwd = chat.itemId("secret")
+    check(textsOf(Ui.Chat.Item(plain)).let { t -> t.any { "plain" in it } && "forwarded" !in t }) { "an ordinary message shows a forwarded header" }
+    poll(what = "the `forwarded` header without the source name") {
+      textsOf(Ui.Chat.Item(fwd)).let { t -> "forwarded" in t && t.none { "forwarded from" in it || "cath" in it } }
+    }
+    assertFalse("a received forward offers a go-to-source arrow", exists(Ui.Chat.Item(fwd).part("goTo")))
+  }
+
+  @Test fun forwardPlan_filesNotAccepted_alertOptions() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    bob sends "@alice one"
+    bob.sendsFileTo("alice", bob.createFile("notes.md", NOTES), 1, "notes.md")
+    bob sends "@alice two"
+    bob sends "@alice three"
+    awaitRowText(alice, "bob", "three")
+    val chat = alice.chatList.open("bob")
+    val file = chat.itemId("the item of notes.md") { it.file?.fileName == "notes.md" }
+    val two = chat.itemId("two"); val three = chat.itemId("three")
+    check(chat.item(file)?.file?.fileStatus is CIFileStatus.RcvInvitation) { "notes.md was received before the forward: ${chat.item(file)?.file?.fileStatus}" }
+    chat.select("one")
+    chat.toggle(file); chat.toggle(two); chat.toggle(three)
+    poll(what = "`Selected 4`") { chat.selectionTitle() == "Selected 4" }
+    chat.forwardSelected()
+    poll(what = "the plan alert for 3 messages and 1 file with Forward, Download and Cancel") {
+      seesText("Forward 3 message(s)?") && seesText("1 file(s) were not downloaded.", substring = true) &&
+        seesText("Forward messages without files?", substring = true) && exists(FORWARD) && exists(DOWNLOAD) && seesText("Cancel")
+    }
+    click(FORWARD)
+    poll(what = "the destination list for several messages") { seesText("Forward messages…") }
+    alice.chatList.shareTo("cath")
+    val cathId = alice.chatList.chatId("cath")
+    poll(what = "cath's chat with `Forwarding 3 messages`") { chatModel.chatId.value == cathId && seesText("Forwarding 3 messages") && isEnabled(Ui.Chat.Send) }
+    bob sends "\\@alice three"
+    bob.eventually("message marked deleted")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's deletion processed by alice") { "marked deleted" in alice.chatList.rowTexts("bob") }
+    click(Ui.Chat.Send)
+    cath.expectsMessage("alice> -> forwarded", CONNECT_TIMEOUT_MS)
+    cath expects "      one"
+    cath expectsMessage "alice> -> forwarded"
+    cath expects "      two"
+    poll(what = "the deleted-after-selection alert") { seesText("1 messages not forwarded") && seesText("Messages were deleted after you selected them.") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    chat.send("end")
+    cath expectsMessage "alice> end"
+  }
+
+  @Test fun forwardPlan_downloadButton_receivesFiles() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    bob sends "@alice kept"
+    bob sends "@alice gone"
+    bob sends "\\@alice gone"
+    bob.eventually("message marked deleted")
+    bob.sendsFileTo("alice", bob.createFile("notes.md", NOTES), 1, "notes.md")
+    awaitRowText(alice, "bob", "notes.md")
+    val chat = alice.chatList.open("bob")
+    val bobId = alice.chatList.chatId("bob")
+    val kept = chat.itemId("kept"); val gone = chat.itemId("gone")
+    val file = chat.itemId("the item of notes.md") { it.file?.fileName == "notes.md" }
+    menuCheck(chat, kept, "the menu of a message has no Forward") { exists(Ui.Chat.ItemMenu(kept, "forward")) }
+    menuCheck(chat, gone, "the menu of a deleted message offers Forward") { !exists(Ui.Chat.ItemMenu(gone, "forward")) }
+    rightClick(Ui.Chat.Item(file))
+    waitFor(Ui.Chat.ItemMenu(file, "select"))
+    check(exists(Ui.Chat.ItemMenu(file, "download")) && !exists(Ui.Chat.ItemMenu(file, "forward"))) { "the menu of a file not downloaded has no Download or offers Forward" }
+    click(Ui.Chat.ItemMenu(file, "select"))
+    poll(what = "`Selected 1`") { chat.selectionTitle() == "Selected 1" }
+    chat.forwardSelected()
+    poll(what = "`Nothing to forward!` with Download and no Forward") {
+      seesText("Nothing to forward!") && seesText("1 file(s) were not downloaded.") && !seesText("Forward messages without files?", substring = true) &&
+        exists(DOWNLOAD) && !exists(FORWARD)
+    }
+    click(DOWNLOAD)
+    poll(what = "the alert closed and no destination list") { !seesText("Nothing to forward!") && !seesText("Forward message…") && chatModel.chatId.value == bobId }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "notes.md received") { chat.item(file)?.file?.fileStatus is CIFileStatus.RcvComplete }
+    escape()
+    poll(what = "selection mode to end") { chat.selectionTitle() == null }
+    chat.forwardItemTo(file, "cath")
+    cath.expectsMessage("alice> -> forwarded", CONNECT_TIMEOUT_MS)
+    cath expects "      notes_1.md"
+    cath expectsMessage "alice> sends file notes_1.md (${NOTES.length} bytes / ${NOTES.length} bytes)"
+    cath expects "use /fr 1 [<dir>/ | <path>] to receive it"
+    cath.receivesFile(1, "notes_1.md", "alice")
+  }
+
+  @Test fun forward_destinationProhibitsContent_alert() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    hostGroup(bob, "team", "alice")
+    joinGroupFromList(alice, bob, "team")
+    bob sends "/img @alice $FIXTURE_JPG"
+    bob expectsMessage "/f @alice $FIXTURE_JPG"
+    bob expects "use /fc 1 to cancel sending"
+    bob.eventually("completed uploading file 1 (test.jpg) for alice", CONNECT_TIMEOUT_MS)
+    backToChatList()
+    val chat = alice.chatList.open("bob")
+    val teamId = alice.chatList.chatId("team")
+    val img = chat.itemId("bob's image") { it.content.msgContent is MsgContent.MCImage }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the image received") { chat.item(img)?.file?.fileStatus is CIFileStatus.RcvComplete }
+    rightClick(Ui.Chat.Item(img))
+    click(Ui.Chat.ItemMenu(img, "forward"))
+    alice.chatList.shareTo("team")
+    poll(what = "team open with the forwarding bar while files are allowed") { chatModel.chatId.value == teamId && seesDescription("Context icon") && isEnabled(Ui.Chat.Send) }
+    click(described("Cancel"))
+    poll(what = "the forwarding bar gone") { exists(Ui.Chat.Message) && !seesDescription("Context icon") }
+    bob sends "/set files #team off"
+    bob expects "updated group preferences:"
+    bob expects "Files and media: off"
+    chat.itemId("`Files and media: off` in team") { it.content.text.startsWith("Files and media: off") }
+    backToChatList()
+    alice.chatList.open("bob")
+    rightClick(Ui.Chat.Item(img))
+    click(Ui.Chat.ItemMenu(img, "forward"))
+    alice.chatList.shareTo("team")
+    poll(what = "`Cannot send message` and no chat opened") {
+      seesText("Cannot send message") && seesText("Selected chat preferences prohibit this message.") && chatModel.chatId.value == null
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "still in the destination list") { !seesText("Cannot send message") && seesText("Forward message…") && chatModel.chatId.value == null }
+    alice.chatList.shareTo("Private notes")
+    val notesId = alice.chatList.chatId("Private notes")
+    poll(what = "notes with the forwarding bar") { chatModel.chatId.value == notesId && seesDescription("Context icon") && isEnabled(Ui.Chat.Send) }
+    click(Ui.Chat.Send)
+    val saved = chat.itemId("the image saved in notes") { it.content.msgContent is MsgContent.MCImage }
+    poll(what = "the `saved from` / `bob` header on the saved image") { textsOf(Ui.Chat.Item(saved)).let { t -> t.any { "saved from" in it } && "bob" in t } }
+    backToChatList()
+    val team = alice.chatList.open("team")
+    poll(what = "team open") { chatModel.chatId.value == teamId }
+    team.send("after")
+    bob expectsMessage "#team alice> after"
+  }
+
+  @Test fun forward_searchDestinations_filtersList() = uiTest {
+    app("alice").chatList.row("Private notes")
+    val groups = listOf("bobcats", "jobs", "team", "club", "news", "work").take(SEARCH_MIN_CHATS - 1 - chatModel.chats.value.size)
+    check(groups.size >= 3) { "too many chats before the test: ${chatModel.chats.value.map { it.id }}" }
+    newGroupsViaApi(*groups.toTypedArray())
+    val alice = restart()
+    poll(what = "the ${groups.size} groups loaded after the restart") { chatModel.chats.value.count { it.chatInfo is ChatInfo.Group } == groups.size }
+    val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice hey"
+    awaitRowText(alice, "bob", "hey")
+    check(chatModel.chats.value.size == SEARCH_MIN_CHATS) { "$SEARCH_MIN_CHATS chats are needed for the search button, found ${chatModel.chats.value.map { it.id }}" }
+    alice.chatList.open("bob").menu("hey", "forward")
+    poll(what = "the destination list") { seesText("Forward message…") }
+    for (name in listOf("bob", "bobcats", "jobs", "team", "Private notes")) scrollTo(Ui.Share.Row(alice.chatList.chatId(name)))
+    alice.chatList.shareSearch("bob")
+    poll(what = "only bob and bobcats listed for `bob`") {
+      alice.chatList.shareShown("bob") && alice.chatList.shareShown("bobcats") &&
+        !alice.chatList.shareShown("jobs") && !alice.chatList.shareShown("team") && !alice.chatList.shareShown("Private notes")
+    }
+    alice.chatList.shareTo("bobcats")
+    val bobcatsId = alice.chatList.chatId("bobcats")
+    poll(what = "bobcats opened with the forwarding bar") { chatModel.chatId.value == bobcatsId && seesDescription("Context icon") }
+  }
+
+  private fun UiScope.menuCheck(chat: ChatScreen, id: Long, failure: String, cond: () -> Boolean) {
+    rightClick(Ui.Chat.Item(id))
+    waitFor(Ui.Chat.ItemMenu(id, "select"))
+    check(cond()) { failure }
+    click(Ui.Chat.ItemMenu(id, "select"))
+    poll(what = "`Selected 1`") { chat.selectionTitle() == "Selected 1" }
+    escape()
+    poll(what = "selection mode to end") { chat.selectionTitle() == null }
+  }
+
+  private companion object {
+    const val NOTES = "Shopping list from bob: apples and pears"
+    const val SEARCH_MIN_CHATS = 8
+    const val FIXTURE_JPG = "tests/fixtures/test.jpg"
+    val FORWARD = Ui.Alert.Option(Ui.AlertSource.Shared, "forward")
+    val DOWNLOAD = Ui.Alert.Option(Ui.AlertSource.Shared, "download")
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ItemInfoTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ItemInfoTest.kt
new file mode 100644
index 0000000000..45ecc20184
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ItemInfoTest.kt
@@ -0,0 +1,246 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.confirmAlert
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.openItemInfo
+import chat.simplex.app.ui.harness.openTimedMenu
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.common.model.CIDeleted
+import chat.simplex.common.model.CIStatus
+import chat.simplex.common.model.SndCIStatusProgress
+import chat.simplex.common.model.localTimestamp
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertFalse
+import org.junit.Test
+
+class ItemInfoTest : UiTest() {
+  @Test fun info_sent_showsSentAt() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("mine")
+    bob expectsMessage "alice> mine"
+    bob sends "@alice theirs"
+    val mine = chat.itemId("mine"); val theirs = chat.itemId("theirs")
+    chat.itemInfo("mine").run {
+      val sentAt = localTimestamp(chat.item(mine)!!.meta.itemTs)
+      check(row("Sent at") == sentAt) { "`Sent at` of alice's message: `${row("Sent at")}`, expected `$sentAt`" }
+      check(!seesText("Received message") && !seesText("Received at") && !seesText("Deleted at")) { "received or deleted rows in the info of alice's message" }
+      close()
+    }
+    chat.receivedItemInfo("theirs").run {
+      val meta = chat.item(theirs)!!.meta
+      check(row("Sent at") == localTimestamp(meta.itemTs) && row("Received at") == localTimestamp(meta.createdAt)) {
+        "`Sent at` / `Received at` of bob's message: `${row("Sent at")}` / `${row("Received at")}`"
+      }
+      check(!seesText("Sent message") && !seesText("Deleted at")) { "sent or deleted rows in the info of bob's message" }
+      close()
+    }
+    bob sends "\\@alice theirs"
+    bob expects "message marked deleted"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's message marked deleted") {
+      chat.item(theirs)?.meta?.itemDeleted is CIDeleted.Deleted && "marked deleted" in textsOf(Ui.Chat.Item(theirs))
+    }
+    chat.receivedItemInfo("theirs").run {
+      val deletedAt = (chat.item(theirs)!!.meta.itemDeleted as CIDeleted.Deleted).deletedTs!!.let(::localTimestamp)
+      check(row("Deleted at") == deletedAt) { "`Deleted at` of bob's deleted message: `${row("Deleted at")}`, expected `$deletedAt`" }
+      close()
+    }
+  }
+
+  @Test fun info_delivery_listsGroupMembers() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    val direct = alice.chatList.open("bob")
+    direct.send("just you")
+    bob expectsMessage "alice> just you"
+    direct.itemInfo("just you").run {
+      assertFalse("the info of a direct message has a Delivery tab", seesText("Delivery"))
+      close()
+    }
+    backToChatList()
+    val chat = ownGroup(alice, "team", bob, cath)
+    chat.send("hello team")
+    bob.eventuallyMessage("#team alice> hello team", CONNECT_TIMEOUT_MS)
+    cath.eventuallyMessage("#team alice> hello team", CONNECT_TIMEOUT_MS)
+    chat.itemInfo("hello team").run {
+      val bobId = memberId("bob"); val cathId = memberId("cath")
+      poll(what = "the Delivery tab listing bob and cath") {
+        seesText("Delivery") && listed(bobId, "bob") && listed(cathId, "cath")
+      }
+      close()
+    }
+  }
+
+  @Test fun info_delivery_liveUpdatesOnReceipt() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    val chat = ownGroup(alice, "team", bob, cath)
+    cath.eventually("#team: member bob is connected", CONNECT_TIMEOUT_MS)
+    cath.stop()
+    chat.send("hi")
+    bob.eventuallyMessage("#team alice> hi", CONNECT_TIMEOUT_MS)
+    val hi = chat.itemId("hi")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`hi` received by bob only") {
+      (chat.item(hi)?.meta?.itemStatus as? CIStatus.SndRcvd)?.sndProgress == SndCIStatusProgress.Partial
+    }
+    chat.itemInfo("hi").run {
+      val bobRow = Ui.ItemInfo.Member(memberId("bob")); val cathRow = Ui.ItemInfo.Member(memberId("cath"))
+      poll(what = "the Delivery tab with bob `$RECEIVED` and cath `$SENT`") {
+        descriptionsOf(bobRow).let { RECEIVED in it && SENT !in it } && descriptionsOf(cathRow).let { SENT in it && RECEIVED !in it }
+      }
+      cath.start()
+      cath.eventuallyMessage("#team alice> hi", CONNECT_TIMEOUT_MS)
+      poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "cath `$RECEIVED` in the open Delivery tab") {
+        descriptionsOf(cathRow).let { RECEIVED in it && SENT !in it } && RECEIVED in descriptionsOf(bobRow)
+      }
+      close()
+    }
+  }
+
+  @Test fun info_quoteTab_showsQuoted() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice question"
+    val chat = alice.chatList.open("bob")
+    chat.itemId("question")
+    chat.send("plain")
+    bob expectsMessage "alice> plain"
+    chat.itemInfo("plain").run {
+      check(!exists(QUOTE_TAB) && !exists(Ui.ItemInfo.Quote)) { "the info of a message without a quote has an `In reply to` tab" }
+      close()
+    }
+    hideKeyboard()
+    chat.menu("question", "reply")
+    chat.send("answer")
+    bob expectsMessage "alice> > question"
+    bob expects "      answer"
+    chat.itemInfo("answer").run {
+      poll(what = "the `In reply to` tab, with the history shown first") { exists(QUOTE_TAB) && !exists(Ui.ItemInfo.Quote) }
+      click(QUOTE_TAB)
+      poll(what = "the `In reply to` tab showing bob's `question`") {
+        exists(Ui.ItemInfo.Quote) && textsOf(Ui.ItemInfo.Quote).any { "question" in it } && seesText("In reply to")
+      }
+      close()
+    }
+  }
+
+  @Test fun info_forwardedTab_showsSource() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    emptyGroup(alice, "team")
+    backToChatList()
+    bob sends "@alice hi"
+    val chat = alice.chatList.open("bob")
+    chat.itemId("hi")
+    hideKeyboard()
+    chat.forwardTo("hi", "team")
+    val teamId = alice.chatList.chatId("team")
+    poll(what = "team open with the forwarded `hi`") { chatModel.chatId.value == teamId && chat.itemTexts().contains("hi") }
+    hideKeyboard()
+    chat.itemInfo("hi").run {
+      poll(what = "the `Forwarded` tab, with the history shown first") { exists(FORWARDED_TAB) && !exists(Ui.ItemInfo.ForwardedFrom) }
+      click(FORWARDED_TAB)
+      poll(what = "`Forwarded from` bob, hidden from the recipients") {
+        exists(Ui.ItemInfo.ForwardedFrom) && "bob" in textsOf(Ui.ItemInfo.ForwardedFrom) && seesText("Forwarded from") && seesText(SOURCE_HIDDEN)
+      }
+    }
+    click(Ui.ItemInfo.ForwardedFrom)
+    val bobId = alice.chatList.chatId("bob")
+    poll(what = "bob's chat opened from the source row and the item info closed") { chatModel.chatId.value == bobId && !exists(Ui.ItemInfo.ForwardedFrom) }
+    hideKeyboard()
+    chat.forwardTo("hi", "Private notes")
+    val notesId = alice.chatList.chatId("Private notes")
+    poll(what = "the notes open with the saved `hi`") { chatModel.chatId.value == notesId && chat.itemTexts().contains("hi") }
+    hideKeyboard()
+    openItemInfo(chat.itemId("hi"), "Saved message").run {
+      poll(what = "the `Saved` tab, with the history shown first") { exists(SAVED_TAB) && !exists(Ui.ItemInfo.ForwardedFrom) }
+      click(SAVED_TAB)
+      poll(what = "`Saved from` bob, without the recipients line") {
+        exists(Ui.ItemInfo.ForwardedFrom) && "bob" in textsOf(Ui.ItemInfo.ForwardedFrom) && seesText("Saved from") &&
+          !seesText("Forwarded from") && !seesText(SOURCE_HIDDEN)
+      }
+      close()
+    }
+  }
+
+  @Test fun info_timed_showsDisappearsAt() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("plain")
+    bob expectsMessage "alice> plain"
+    chat.itemInfo("plain").run {
+      check(!seesText("Disappears at")) { "the info of a message without a timer shows `Disappears at`" }
+      close()
+    }
+    typeInto(Ui.Chat.Message, "timed")
+    openTimedMenu()
+    click(Ui.Chat.SendTimed.option(FIVE_MINUTES))
+    bob.expectsMessage("alice> timed", CONNECT_TIMEOUT_MS)
+    val id = chat.itemId("timed")
+    var disappearsAt: String? = null
+    poll(what = "alice's `timed` with a 5-minute timer") {
+      disappearsAt = chat.item(id)?.meta?.itemTimed?.takeIf { it.ttl == FIVE_MINUTES }?.deleteAt?.let(::localTimestamp)
+      disappearsAt != null
+    }
+    chat.itemInfo("timed").run {
+      check(row("Disappears at") == disappearsAt) { "`Disappears at` of the timed message: `${row("Disappears at")}`, expected `$disappearsAt`" }
+      close()
+    }
+  }
+
+  @Test fun info_moderated_showsModeratedAt() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = ownGroup(alice, "team", bob)
+    bob sends "#team spam"
+    val id = chat.itemId("spam")
+    chat.receivedItemInfo("spam").run {
+      check(!seesText("Moderated at") && !seesText("Deleted at")) { "the info of bob's message shows `Moderated at` or `Deleted at` before moderation" }
+      close()
+    }
+    hideKeyboard()
+    chat.menu("spam", "moderate")
+    confirmAlert("Delete member message?", "The message will be marked as moderated for all members.", "Delete")
+    bob.eventuallyMessage("#team bob> [marked deleted by alice] spam", CONNECT_TIMEOUT_MS)
+    var moderatedAt: String? = null
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `spam` moderated by alice") {
+      moderatedAt = (chat.item(id)?.meta?.itemDeleted as? CIDeleted.Moderated)?.deletedTs?.let(::localTimestamp)
+      moderatedAt != null && "moderated by alice" in textsOf(Ui.Chat.Item(id))
+    }
+    openItemInfo(id, "Received message").run {
+      check(row("Moderated at") == moderatedAt && !seesText("Deleted at")) { "`Moderated at` of the moderated message: `${row("Moderated at")}`, expected `$moderatedAt`" }
+      close()
+    }
+  }
+
+  private fun UiScope.listed(groupMemberId: Long, name: String): Boolean =
+    exists(Ui.ItemInfo.Member(groupMemberId)) && name in textsOf(Ui.ItemInfo.Member(groupMemberId))
+
+  private fun UiScope.memberId(name: String): Long {
+    var id: Long? = null
+    poll(what = "member `$name` in the model") {
+      id = chatModel.groupMembers.value.firstOrNull { it.memberProfile.displayName == name }?.groupMemberId
+      id != null
+    }
+    return id!!
+  }
+
+  private companion object {
+    const val SENT = "sent"
+    const val RECEIVED = "received"
+    const val FIVE_MINUTES = 300
+    const val SOURCE_HIDDEN = "Recipient(s) can't see who this message is from."
+    val QUOTE_TAB = described("In reply to")
+    val FORWARDED_TAB = described("Forwarded")
+    val SAVED_TAB = described("Saved")
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ItemStatusCompatTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ItemStatusCompatTest.kt
new file mode 100644
index 0000000000..43d2fe1872
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ItemStatusCompatTest.kt
@@ -0,0 +1,28 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.ownGroupWithTwo
+import chat.simplex.common.model.CIStatus
+import chat.simplex.common.model.MsgReceiptStatus
+import chat.simplex.common.model.SndCIStatusProgress
+import org.junit.Test
+
+class ItemStatusCompatTest : UiTest() {
+  @Test fun status_group_partialThenComplete() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = ownGroupWithTwo(alice, bob, cath)
+    cath.stop()
+    chat.send("hi")
+    bob.eventuallyMessage("#team alice> hi", CONNECT_TIMEOUT_MS)
+    val id = chat.itemId("hi")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`hi` delivered to bob only: delivered, partial") {
+      (chat.item(id)?.meta?.itemStatus as? CIStatus.SndRcvd)?.let { it.msgRcptStatus == MsgReceiptStatus.Ok && it.sndProgress == SndCIStatusProgress.Partial } == true
+    }
+    cath.start()
+    cath.eventuallyMessage("#team alice> hi", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`hi` delivered to bob and cath: delivered, complete") {
+      (chat.item(id)?.meta?.itemStatus as? CIStatus.SndRcvd)?.let { it.msgRcptStatus == MsgReceiptStatus.Ok && it.sndProgress == SndCIStatusProgress.Complete } == true
+    }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ItemStatusTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ItemStatusTest.kt
new file mode 100644
index 0000000000..f68247996d
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ItemStatusTest.kt
@@ -0,0 +1,96 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.TestServers
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitConnectionDeletedOnServer
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.contactOf
+import chat.simplex.common.model.CIStatus
+import chat.simplex.common.model.SndError
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ItemStatusTest : UiTest() {
+  @Test fun status_authError_clickShowsDeliveryError() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("before")
+    bob.expectsMessage("alice> before", CONNECT_TIMEOUT_MS)
+    val before = chat.itemId("before")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`before` delivered to bob") { chat.item(before)?.meta?.itemStatus is CIStatus.SndRcvd }
+    click(Ui.Chat.Item(before))
+    settle()
+    assertFalse("clicking a delivered message shows a delivery alert", seesText(DELIVERY_ERROR))
+    bob sends "/d alice notify=off"
+    bob expects "alice: contact is deleted"
+    awaitConnectionDeletedOnServer(bob)
+    chat.send("after")
+    val after = chat.itemId("after")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`after` failed with an authorization error") {
+      (chat.item(after)?.meta?.itemStatus as? CIStatus.CISSndError)?.agentError is SndError.Auth
+    }
+    assertFalse("the delivery alert is shown before the failed message is clicked", seesText(DELIVERY_ERROR))
+    click(Ui.Chat.Item(after))
+    poll(what = "the `$DELIVERY_ERROR` alert explaining the authorization error") { seesText(DELIVERY_ERROR) && seesText(AUTH_ERROR_INFO) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the delivery error alert to close") { !seesText(DELIVERY_ERROR) }
+  }
+
+  @Test fun status_quotaExceeded_warningAlert() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice's contact with bob ready") { contactOf("bob").ready }
+    chat.send("drained")
+    bob.expectsMessage("alice> drained", CONNECT_TIMEOUT_MS)
+    val drained = chat.itemId("drained")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`drained` delivered to bob, so bob's queue is empty") { chat.item(drained)?.meta?.itemStatus is CIStatus.SndRcvd }
+    bob.stop()
+    chat.send("m1")
+    val first = chat.itemId("m1")
+    for (i in 2..QUOTA + 1) chat.send("m$i")
+    val last = chat.itemId("m${QUOTA + 1}")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the message over the queue capacity marked with a delivery warning") {
+      (chat.item(last)?.meta?.itemStatus as? CIStatus.SndWarning)?.agentError is SndError.Quota
+    }
+    assertFalse("a message within the queue capacity has a delivery warning", chat.item(first)?.meta?.itemStatus is CIStatus.SndWarning)
+    click(Ui.Chat.Item(last))
+    poll(what = "the `$DELIVERY_WARNING` alert explaining the exceeded capacity") { seesText(DELIVERY_WARNING) && seesText(QUOTA_INFO) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the delivery warning alert to close") { !seesText(DELIVERY_WARNING) }
+  }
+
+  @Test fun status_pending_whileServerDown() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice's contact with bob ready") { contactOf("bob").ready }
+    chat.send("before")
+    bob.expectsMessage("alice> before", CONNECT_TIMEOUT_MS)
+    val before = chat.itemId("before")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`before` sent with smp1 up") { chat.item(before)?.meta?.itemStatus.isSentOrDelivered() }
+    TestServers.stop("smp1")
+    chat.send("while down")
+    val pending = chat.itemId("while down")
+    poll(what = "the send of `while down` to return with smp1 down") { UiIdle.inFlight().isEmpty() }
+    chat.item(pending)?.meta?.itemStatus.let { assertTrue("`while down` is not pending with smp1 down: $it", it is CIStatus.SndNew) }
+    TestServers.start("smp1")
+    bob.eventuallyMessage("alice> while down", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`while down` sent once smp1 is back") { chat.item(pending)?.meta?.itemStatus.isSentOrDelivered() }
+  }
+
+  private fun CIStatus?.isSentOrDelivered() = this is CIStatus.SndSent || this is CIStatus.SndRcvd
+
+  private companion object {
+    const val QUOTA = 16
+    const val DELIVERY_ERROR = "Message delivery error"
+    const val DELIVERY_WARNING = "Message delivery warning"
+    const val AUTH_ERROR_INFO = "Wrong key or unknown connection - most likely this connection is deleted."
+    const val QUOTA_INFO = "Capacity exceeded - recipient did not receive previously sent messages."
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/LiveMessageTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/LiveMessageTest.kt
new file mode 100644
index 0000000000..13de30fc94
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/LiveMessageTest.kt
@@ -0,0 +1,137 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.CliPeer
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertFalse
+import org.junit.Test
+
+class LiveMessageTest : UiTest() {
+  @Test fun liveMessage_menuStart_alertConfirm_peerSeesStarted() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "/show on"
+    bob expects "ok"
+    val chat = alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, "hello")
+    rightClick(Ui.Chat.Send)
+    click(Ui.Chat.SendLive)
+    confirmLiveMessageAlert()
+    bob.expectsLiveStarted("hello")
+    val id = chat.itemId("hello")
+    poll(what = "alice's `hello` marked LIVE") { "LIVE" in textsOf(Ui.Chat.Item(id)) }
+    typeInto(Ui.Chat.Message, " there,")
+    bob.expectsMessage("alice> [LIVE] hello there,", CONNECT_TIMEOUT_MS)
+    poll(what = "alice's bubble updated in place to `hello there,`, still LIVE") {
+      chat.item(id)?.content?.text == "hello there," && textsOf(Ui.Chat.Item(id)).let { t -> "LIVE" in t && t.any { "hello there," in it } }
+    }
+    typeInto(Ui.Chat.Message, " bob")
+    click(Ui.Chat.Send)
+    bob.eventuallyMessage("alice> [LIVE ended] hello there, bob", CONNECT_TIMEOUT_MS)
+    poll(what = "the field cleared and alice's bubble showing `hello there, bob` without LIVE") {
+      editableText(Ui.Chat.Message).isNullOrEmpty() &&
+        chat.item(id)?.let { it.content.text == "hello there, bob" && !it.meta.isLive } == true && "LIVE" !in textsOf(Ui.Chat.Item(id))
+    }
+    chat.send("bye")
+    bob expectsMessage "alice> bye"
+  }
+
+  @KnownAppIssue("15.5 item 13", "[LIVE started] use /show", intermittent = true)
+  @Test fun liveMessage_boltButton_emptyStart() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.chatList.open("bob")
+    click(Ui.Chat.Live)
+    confirmLiveMessageAlert()
+    poll(what = "an empty live message: `Cancel live message` in place of the live button and a placeholder item") {
+      exists(CANCEL) && !exists(Ui.Chat.Live) && chatModel.chatsContext.chatItems.value.any { it.isLiveDummy }
+    }
+    click(CANCEL)
+    poll(what = "the live button back and the placeholder item gone") {
+      exists(Ui.Chat.Live) && !exists(CANCEL) && chatModel.chatsContext.chatItems.value.none { it.isLiveDummy }
+    }
+    click(Ui.Chat.Live)
+    poll(what = "a second empty live message") { exists(CANCEL) }
+    assertFalse("the `Live message!` alert was shown again", seesText("Live message!"))
+    typeInto(Ui.Chat.Message, "hi!")
+    bob.expectsLiveStarted("hi!")
+    click(Ui.Chat.Send)
+    bob.expectsMessage("alice> [LIVE ended] hi!", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun liveMessage_received_showsLiveBadge() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    val aliceId = bob.contactId("alice")
+    bob sends "/_send @$aliceId live=on text hello"
+    val id = chat.itemId("hello")
+    poll(what = "bob's `hello` marked LIVE") { "LIVE" in textsOf(Ui.Chat.Item(id)) && chat.item(id)?.meta?.isLive == true }
+    bob sends "/last_item_id @alice"
+    val bobItemId = bob.eventuallyMatching(Regex("\\d+")).value
+    bob sends "/_update item @$aliceId $bobItemId live=on text hello there"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the same bubble showing `hello there`, still LIVE") {
+      chat.item(id)?.content?.text == "hello there" && textsOf(Ui.Chat.Item(id)).let { t -> "LIVE" in t && t.any { "hello there" in it } }
+    }
+    bob sends "/_update item @$aliceId $bobItemId text hello there"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the bubble without LIVE once bob ends the live message") {
+      chat.item(id)?.meta?.isLive == false && textsOf(Ui.Chat.Item(id)).let { t -> "LIVE" !in t && t.any { "hello there" in it } }
+    }
+    chat.receivedItemInfo("hello there").run {
+      val h = history()
+      val newest = h.indexOfFirst { it.startsWith("hello there") }
+      val current = h.indexOf("(current)")
+      val first = h.indexOfFirst { it.startsWith("hello") && !it.startsWith("hello there") }
+      check(newest in 0 until current && current < first && h.count { it == "(current)" } == 1) { "live message history: $h" }
+      close()
+    }
+  }
+
+  @Test fun liveMessage_chatSwitch_sendsToOriginalChat() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, "hello")
+    rightClick(Ui.Chat.Send)
+    click(Ui.Chat.SendLive)
+    confirmLiveMessageAlert()
+    bob.expectsLiveStarted("hello")
+    val id = chat.itemId("hello")
+    poll(what = "alice's `hello` marked LIVE") { "LIVE" in textsOf(Ui.Chat.Item(id)) }
+    backToChatList()
+    val notes = alice.chatList.open("Private notes")
+    bob.expectsMessage("alice> [LIVE ended] hello", CONNECT_TIMEOUT_MS)
+    poll(what = "the notes with an empty message field") { exists(Ui.Chat.Message) && editableText(Ui.Chat.Message).isNullOrEmpty() }
+    assertFalse("the live message was saved in the notes", "hello" in notes.itemTexts())
+    backToChatList()
+    alice.chatList.open("bob")
+    poll(what = "bob's chat with `hello` no longer live and an empty message field") {
+      chat.item(id)?.let { it.content.text == "hello" && !it.meta.isLive } == true && "LIVE" !in textsOf(Ui.Chat.Item(id)) &&
+        editableText(Ui.Chat.Message).isNullOrEmpty()
+    }
+    chat.send("bye")
+    bob expectsMessage "alice> bye"
+  }
+
+  private fun UiScope.confirmLiveMessageAlert() {
+    poll(what = "the `Live message!` alert with `Send`") { seesText("Live message!") && "Send" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  }
+
+  private fun CliPeer.expectsLiveStarted(text: String) {
+    val line = nextLine(CONNECT_TIMEOUT_MS)
+    val started = Regex("""^(\d{2}:\d{2} )?alice> \[LIVE started] use /show \[on/off/\d+] """ + Regex.escape(text) + "$")
+    check(started.matches(line)) { "$name: expected alice's live message `$text` to start, got `$line`; next: ${pending()}" }
+  }
+
+  private companion object {
+    val CANCEL = described("Cancel live message")
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/MemberReportTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/MemberReportTest.kt
new file mode 100644
index 0000000000..07471d2ee9
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/MemberReportTest.kt
@@ -0,0 +1,117 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.composeReport
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.app.ui.harness.memberOfHostedGroup
+import chat.simplex.app.ui.harness.menuOffers
+import chat.simplex.app.ui.harness.openReportReasons
+import chat.simplex.app.ui.harness.receivesReport
+import chat.simplex.app.ui.harness.reportSendFinished
+import chat.simplex.app.ui.harness.reportSentAlert
+import chat.simplex.app.ui.harness.sendReport
+import chat.simplex.common.model.GroupFeature
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class MemberReportTest : UiTest() {
+  @KnownAppIssue("15.5 item 12", "bob: expected `      report content`, got `      report illegal`")
+  @Test fun report_member_spam_moderatorsReceive() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = memberOfHostedGroup(alice, bob, cath)
+    cath sends "#team inappropriate joke"
+    bob.eventuallyMessage("#team cath> inappropriate joke", CONNECT_TIMEOUT_MS)
+    val joke = chat.itemId("cath's `inappropriate joke`") { it.content.text == "inappropriate joke" }
+    openReportReasons(joke)
+    for (reason in listOf("Spam", "Inappropriate content", "Community guidelines violation", "Inappropriate profile", "Another reason")) {
+      check(exists(Ui.Chat.ReportReason(reason)) && reason in textsOf(Ui.Chat.ReportReason(reason))) { "`Report reason?` does not offer `$reason`" }
+    }
+    check("Cancel" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))) { "`Report reason?` has no `Cancel`" }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "`Report reason?` closed by `Cancel` with no report in compose") {
+      !seesText("Report reason?") && exists(Ui.Chat.Message) && !seesText("only group moderators will see it.", substring = true)
+    }
+
+    val spam = "Report spam: only group moderators will see it."
+    composeReport(joke, "Spam", spam)
+    check(editableText(Ui.Chat.Message).isNullOrEmpty() && isEnabled(Ui.Chat.Send)) { "a `Spam` report cannot be sent without a comment" }
+    sendReport(spam)
+    reportSentAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    bob.receivesReport("team", "alice", "cath", "inappropriate joke", "report spam")
+
+    val violation = "Report violation: only group moderators will see it."
+    composeReport(joke, "Community guidelines violation", violation)
+    sendReport(violation)
+    reportSentAlert()
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    bob.receivesReport("team", "alice", "cath", "inappropriate joke", "report community")
+
+    val profile = "Report member profile: only group moderators will see it."
+    composeReport(joke, "Inappropriate profile", profile)
+    sendReport(profile)
+    bob.receivesReport("team", "alice", "cath", "inappropriate joke", "report profile")
+    reportSendFinished()
+    check(!seesText("Report sent to moderators")) { "`Report sent to moderators` shown again after `Don't show again`" }
+
+    val other = "Report other: only group moderators will see it."
+    composeReport(joke, "Another reason", other)
+    waitFor(Ui.Chat.Send)
+    check(!isEnabled(Ui.Chat.Send)) { "an `Another reason` report can be sent without a comment" }
+    typeInto(Ui.Chat.Message, "fake giveaway")
+    hideKeyboard()
+    poll(what = "the send button enabled once the comment is typed") { isEnabled(Ui.Chat.Send) }
+    sendReport(other)
+    bob.receivesReport("team", "alice", "cath", "inappropriate joke", "report other: fake giveaway")
+
+    chat.send("after reports")
+    bob.expectsMessage("#team alice> after reports", CONNECT_TIMEOUT_MS)
+    cath.expectsMessage("#team alice> after reports", CONNECT_TIMEOUT_MS)
+
+    val content = "Report content: only group moderators will see it."
+    composeReport(joke, "Inappropriate content", content)
+    sendReport(content)
+    bob.receivesReport("team", "alice", "cath", "inappropriate joke", "report content")
+  }
+
+  @Test fun report_notOffered_forOwnModeratorOrPrefOff() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    hostGroup(bob, "team", "alice")
+    joinGroupFromList(alice, bob, "team")
+    backToChatList()
+    val chat = alice.chatList.open("team")
+    bob sends "#team from the owner"
+    val owners = chat.itemId("bob's `from the owner`") { it.content.text == "from the owner" }
+    chat.send("mine")
+    bob.eventuallyMessage("#team alice> mine", CONNECT_TIMEOUT_MS)
+    val mine = chat.itemId("mine")
+    check(menuOffers(owners, "report")) { "`Report` not offered to a member on the owner's message" }
+    check(!menuOffers(mine, "report")) { "`Report` offered on alice's own message" }
+
+    bob sends "/set reports #team off"
+    bob expects "updated group preferences:"
+    bob expects "Member reports: off"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "member reports off in team's model") { !groupInfoOf("team").groupFeatureEnabled(GroupFeature.Reports) }
+    check(!menuOffers(owners, "report")) { "`Report` offered with member reports off" }
+
+    bob sends "/set reports #team on"
+    bob expects "updated group preferences:"
+    bob expects "Member reports: on"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "member reports on in team's model") { groupInfoOf("team").groupFeatureEnabled(GroupFeature.Reports) }
+    check(menuOffers(owners, "report")) { "`Report` not offered again with member reports back on" }
+
+    bob sends "/mr team alice moderator"
+    bob.eventuallyMatching(Regex("#team: you changed the role of alice to moderator( \\(signed\\))?"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice a moderator of team") { groupInfoOf("team").membership.memberRole == GroupMemberRole.Moderator }
+    check(!menuOffers(owners, "report")) { "`Report` offered to a moderator" }
+    check(!menuOffers(owners, "moderate")) { "`Moderate` offered to a moderator on the owner's message" }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/MessagingTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/MessagingTest.kt
index b9f459dcd5..7f7a81d097 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/MessagingTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/MessagingTest.kt
@@ -32,17 +32,6 @@ class MessagingTest : UiTest() {
     bob expects "      all good - you?"
   }
 
-  @Test fun edit_menu_updatesPeer() = uiTest {
-    val alice = app("alice"); val bob = cli("bob")
-    connect(bob)
-    val chat = alice.chatList.open("bob")
-    chat.send("hello")
-    bob expectsMessage "alice> hello"
-    chat.menu("hello", "edit")
-    chat.replaceAndSend("hey 👋")
-    bob expectsMessage "alice> [edited] hey 👋"
-  }
-
   @Test fun delete_ownForEveryone_peerSeesMarkedDeleted() = uiTest {
     val alice = app("alice"); val bob = cli("bob")
     connect(bob)
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/MultiSelectTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/MultiSelectTest.kt
new file mode 100644
index 0000000000..5bf8ec02ef
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/MultiSelectTest.kt
@@ -0,0 +1,112 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertFalse
+import org.junit.Test
+
+class MultiSelectTest : UiTest() {
+  @Test fun select_toggle_updatesCounter() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice one"
+    bob sends "@alice two"
+    val chat = alice.chatList.open("bob")
+    chat.send("mine")
+    bob expectsMessage "alice> mine"
+    val one = chat.itemId("one"); val two = chat.itemId("two"); val mine = chat.itemId("mine")
+    waitFor(Ui.Chat.Bar.part("title"))
+    assertFalse("selection title before Select", exists(SEL_TITLE))
+    assertFalse("selection Delete before Select", exists(SEL_DELETE))
+    hideKeyboard()
+    chat.menu("one", "select")
+    poll(what = "`Selected 1` instead of bob's chat bar, Delete enabled") { chat.selectionTitle() == "Selected 1" && !exists(Ui.Chat.Bar.part("title")) && isEnabled(SEL_DELETE) }
+    chat.toggle(two)
+    poll(what = "Selected 2") { chat.selectionTitle() == "Selected 2" }
+    chat.toggle(mine)
+    poll(what = "Selected 3") { chat.selectionTitle() == "Selected 3" }
+    chat.toggle(one)
+    poll(what = "Selected 2 after unselecting `one`") { chat.selectionTitle() == "Selected 2" }
+    chat.toggle(two)
+    poll(what = "Selected 1") { chat.selectionTitle() == "Selected 1" }
+    chat.toggle(mine)
+    poll(what = "`Nothing selected` with Delete disabled") { chat.selectionTitle() == "Nothing selected" && exists(SEL_DELETE) && !isEnabled(SEL_DELETE) }
+    click(described("Back"))
+    poll(what = "selection ended with bob's chat bar back and all three messages kept") {
+      !exists(SEL_TITLE) && !exists(SEL_DELETE) && exists(Ui.Chat.Bar.part("title")) && listOf(one, two, mine).all { chat.item(it) != null && exists(Ui.Chat.Item(it)) }
+    }
+  }
+
+  @Test fun selectDelete_forEveryone_peerSeesBoth() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("hello")
+    bob expectsMessage "alice> hello"
+    bob sends "@alice hey"
+    chat.send("hi")
+    bob expectsMessage "alice> hi"
+    chat.send("bye")
+    bob expectsMessage "alice> bye"
+    val hello = chat.itemId("hello"); val hey = chat.itemId("hey"); val hi = chat.itemId("hi"); val bye = chat.itemId("bye")
+    hideKeyboard()
+    chat.select("hello")
+    chat.toggle(hey)
+    poll(what = "Selected 2") { chat.selectionTitle() == "Selected 2" }
+    click(SEL_DELETE)
+    poll(what = "`Delete 2 messages?` saying they cannot be undone, with Delete for me") { seesText("Delete 2 messages?") && seesText(FULL_MANY) && exists(FOR_ME) }
+    assertFalse("For everyone offered for a selection with bob's message", exists(FOR_EVERYONE))
+    click(FOR_ME)
+    poll(what = "`hello` and `hey` removed, selection ended, `hi` kept") {
+      chat.item(hello) == null && chat.item(hey) == null && !exists(Ui.Chat.Item(hello)) && !exists(Ui.Chat.Item(hey)) && !exists(SEL_TITLE) && exists(Ui.Chat.Item(hi))
+    }
+    chat.select("hi")
+    chat.toggle(bye)
+    poll(what = "Selected 2") { chat.selectionTitle() == "Selected 2" }
+    click(SEL_DELETE)
+    poll(what = "`Delete 2 messages?` saying they will be marked for deletion, with For everyone") { seesText(MARK_MANY) && exists(FOR_EVERYONE) }
+    click(FOR_EVERYONE)
+    bob expectsMessage "alice> [marked deleted] hi"
+    bob expectsMessage "alice> [marked deleted] bye"
+    poll(what = "alice's two messages collapsed into `2 messages marked deleted`") { "2 messages marked deleted" in textsOf(Ui.Chat.Item(bye)) && !exists(Ui.Chat.Item(hi)) }
+  }
+
+  @KnownAppIssue("15.5 item 22", "Forward disabled and Delete enabled after bob deleted it")
+  @Test fun select_itemDeletedByPeer_recheck() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice one"
+    val chat = alice.chatList.open("bob")
+    chat.send("mine")
+    bob expectsMessage "alice> mine"
+    val one = chat.itemId("one"); val mine = chat.itemId("mine")
+    val forward = Ui.Chat.Selection.part("forward")
+    hideKeyboard()
+    chat.select("one")
+    chat.toggle(mine)
+    poll(what = "`Selected 2` with Forward and Delete enabled") { chat.selectionTitle() == "Selected 2" && isEnabled(forward) && isEnabled(SEL_DELETE) }
+    bob sends "\\@alice one"
+    bob.eventually("message marked deleted")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `one` marked deleted") { chat.item(one)?.meta?.itemDeleted != null }
+    poll(what = "`one` still selected, Forward disabled and Delete enabled after bob deleted it") {
+      chat.selectionTitle() == "Selected 2" && exists(forward) && !isEnabled(forward) && isEnabled(SEL_DELETE)
+    }
+    chat.toggle(one)
+    poll(what = "`Selected 1` with Forward enabled again once the deleted message is unselected") {
+      chat.selectionTitle() == "Selected 1" && isEnabled(forward) && isEnabled(SEL_DELETE)
+    }
+  }
+
+  private companion object {
+    val FOR_ME = Ui.Alert.Option(Ui.AlertSource.Shared, "forMe")
+    val FOR_EVERYONE = Ui.Alert.Option(Ui.AlertSource.Shared, "forEveryone")
+    val SEL_TITLE = Ui.Chat.Selection.part("title")
+    val SEL_DELETE = Ui.Chat.Selection.part("delete")
+    const val FULL_MANY = "Messages will be deleted - this cannot be undone!"
+    const val MARK_MANY = "Messages will be marked for deletion. The recipient(s) will be able to reveal these messages."
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/NotesTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/NotesTest.kt
index 998ede7130..53123e16f9 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/NotesTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/NotesTest.kt
@@ -1,7 +1,12 @@
 package chat.simplex.app.ui.chat
 
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
 import chat.simplex.common.model.CIDirection
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertFalse
 import org.junit.Test
 
 class NotesTest : UiTest() {
@@ -13,4 +18,43 @@ class NotesTest : UiTest() {
     poll(what = "a local note") { notes.item(id)?.chatDir is CIDirection.LocalSnd }
     restart().chatList.open("Private notes").itemId("keep in mind")
   }
+
+  @Test fun notes_editDelete_staysLocal() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val notes = alice.chatList.open("Private notes")
+    notes.send("keep in mind")
+    notes.send("ahoy!")
+    notes.send("scratch")
+    val ahoy = notes.itemId("ahoy!"); val scratch = notes.itemId("scratch")
+    hideKeyboard()
+    rightClick(Ui.Chat.Item(ahoy))
+    waitFor(Ui.Chat.ItemMenu(ahoy, "edit"))
+    assertFalse("a note offers Reply", exists(Ui.Chat.ItemMenu(ahoy, "reply")))
+    click(Ui.Chat.ItemMenu(ahoy, "edit"))
+    poll(what = "`ahoy!` in the message field") { editableText(Ui.Chat.Message) == "ahoy!" }
+    notes.replaceAndSend("Greetings.")
+    poll(what = "the same note showing `Greetings.` instead of `ahoy!`") {
+      notes.item(ahoy)?.content?.text == "Greetings." && textsOf(Ui.Chat.Item(ahoy)).let { t -> t.any { "Greetings." in it } && t.none { "ahoy!" in it } }
+    }
+    hideKeyboard()
+    notes.menu("scratch", "delete")
+    poll(what = "the `Delete message?` alert with `Delete for me` and without `Delete for everyone`") { exists(FOR_ME) && !exists(FOR_EVERYONE) }
+    click(FOR_ME)
+    poll(what = "`scratch` deleted") { notes.item(scratch) == null && !exists(Ui.Chat.Item(scratch)) }
+    val restarted = restart()
+    val again = restarted.chatList.open("Private notes")
+    again.itemId("Greetings.")
+    poll(what = "after a restart `keep in mind` and `Greetings.`, without `ahoy!` and `scratch`") {
+      again.itemTexts().let { it.containsAll(listOf("keep in mind", "Greetings.")) && "ahoy!" !in it && "scratch" !in it }
+    }
+    backToChatList()
+    restarted.chatList.open("bob").send("sentinel")
+    bob.expectsMessage("alice> sentinel", CONNECT_TIMEOUT_MS)
+  }
+
+  private companion object {
+    val FOR_ME = Ui.Alert.Option(Ui.AlertSource.Shared, "forMe")
+    val FOR_EVERYONE = Ui.Alert.Option(Ui.AlertSource.Shared, "forEveryone")
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ReactionTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ReactionTest.kt
new file mode 100644
index 0000000000..0c393a3187
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ReactionTest.kt
@@ -0,0 +1,89 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.PeerFlags
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.closeContactInfo
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.offeredReactions
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.common.model.ChatFeature
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ReactionTest : UiTest() {
+  @KnownAppIssue("15.5 item 17", "waiting for the chip menu listing `bob` and `you`", intermittent = true)
+  @Test fun reaction_chipClickOthers_adds() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(reactions = true))
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("hi")
+    bob expectsMessage "alice> hi"
+    bob sends "+1 @alice hi"
+    bob expects "added 👍"
+    val hi = chat.itemId("hi")
+    val chip = Ui.Chat.ReactionChip(hi, "👍")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's 👍 chip on `hi` without a count") { exists(chip) && chat.reactionCount("hi", "👍") == null }
+    assertTrue("the menu of `hi` does not offer 👍 before alice reacts", "👍" in offeredReactions(hi))
+    click(chip)
+    bob.expectsMessage("alice> > hi", CONNECT_TIMEOUT_MS)
+    bob expects "    + 👍"
+    poll(what = "the 👍 chip counting 2") { chat.reactionCount("hi", "👍") == "2" }
+    offeredReactions(hi).let { assertTrue("the menu still offers 👍 or no longer offers 👎 after alice reacted: $it", "👍" !in it && "👎" in it) }
+    rightClick(chip)
+    poll(what = "the chip menu listing `bob` and `you`") { exists(Ui.Chat.ReactionMember(hi, "bob")) && exists(Ui.Chat.ReactionMember(hi, "you")) }
+    click(Ui.Chat.ReactionMember(hi, "bob"))
+    poll(what = "bob's contact info opened from the chip menu") { exists(Ui.Info.Alias) && !exists(Ui.Chat.ReactionMember(hi, "bob")) }
+    closeContactInfo()
+    click(chip)
+    bob.expectsMessage("alice> > hi", CONNECT_TIMEOUT_MS)
+    bob expects "    - 👍"
+    poll(what = "bob's 👍 chip left without a count") { exists(chip) && chat.reactionCount("hi", "👍") == null }
+    assertTrue("the menu does not offer 👍 again after alice removed hers", "👍" in offeredReactions(hi))
+  }
+
+  @Test fun reaction_chipMenu_group_membersAndOpenInfo() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    val chat = ownGroup(alice, "team", bob, cath)
+    chat.send("hi")
+    bob.eventuallyMessage("#team alice> hi", CONNECT_TIMEOUT_MS)
+    cath.eventuallyMessage("#team alice> hi", CONNECT_TIMEOUT_MS)
+    bob sends "+1 #team hi"
+    bob.eventually("added 👍")
+    cath sends "+1 #team hi"
+    cath.eventually("added 👍")
+    val hi = chat.itemId("hi")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the 👍 chip on `hi` counting 2") { chat.reactionCount("hi", "👍") == "2" }
+    rightClick(Ui.Chat.ReactionChip(hi, "👍"))
+    poll(what = "the chip menu listing bob and cath but not alice") {
+      exists(Ui.Chat.ReactionMember(hi, "bob")) && exists(Ui.Chat.ReactionMember(hi, "cath")) && !exists(Ui.Chat.ReactionMember(hi, "alice"))
+    }
+    click(Ui.Chat.ReactionMember(hi, "cath"))
+    poll(what = "member info with `Change role` showing `member`") { exists(Ui.MemberInfo.Role) && "member" in textsOf(Ui.MemberInfo.Role) }
+    click(Ui.MemberInfo.BlockForAll)
+    poll(what = "the `Block member for all?` alert naming cath") { seesText("Block member for all?") && seesText("All new messages from cath will be hidden!") }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the alert closed on cath's member info") { !seesText("Block member for all?") && exists(Ui.MemberInfo.BlockForAll) }
+  }
+
+  @Test fun reaction_disabled_noMenuRow() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice hi"
+    val chat = alice.chatList.open("bob")
+    val hi = chat.itemId("hi")
+    assertTrue("the menu of `hi` does not offer 👍 while reactions are allowed", "👍" in offeredReactions(hi))
+    val aliceId = bob.contactId("alice")
+    bob sends """/_set prefs @$aliceId {"reactions": {"allow": "no"}}"""
+    bob expects "you updated preferences for alice:"
+    bob.eventuallyMatching(Regex("Message reactions: off .*"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `no` for reactions to reach alice") {
+      !alice.chatList.chat("bob").chatInfo.featureEnabled(ChatFeature.Reactions)
+    }
+    assertEquals("the menu of `hi` still offers reactions", emptyList<String>(), offeredReactions(hi))
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ReceiveFileTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ReceiveFileTest.kt
new file mode 100644
index 0000000000..b4ad5112f5
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ReceiveFileTest.kt
@@ -0,0 +1,175 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.TestServers
+import chat.simplex.app.ui.harness.PREVIEW_IMAGE_DATA
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.attachFile
+import chat.simplex.app.ui.harness.closeItemMenu
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.itemFileOf
+import chat.simplex.app.ui.harness.plainBytesOf
+import chat.simplex.common.model.CIFileStatus
+import chat.simplex.common.model.MsgContent
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.MAX_IMAGE_SIZE_AUTO_RCV
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Test
+import java.io.File
+
+class ReceiveFileTest : UiTest() {
+  @Test fun sndFile_revoke_peerSeesCancelled() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val source = File(exchangeDir(), REVOKED_NAME).apply { writeText(REVOKED) }
+    val chat = alice.chatList.open("bob")
+    waitFor(Ui.Chat.Message)
+    attachFile(source)
+    hideKeyboard()
+    click(Ui.Chat.Send)
+    bob.expectsMessage("alice> sends file $REVOKED_NAME (${REVOKED.length} bytes / ${REVOKED.length} bytes)", CONNECT_TIMEOUT_MS)
+    bob expects "use /fr 1 [<dir>/ | <path>] to receive it"
+    val id = chat.itemId("alice's $REVOKED_NAME") { it.chatDir.sent && it.file?.fileName == REVOKED_NAME }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "$REVOKED_NAME uploaded") { itemFileOf(id)?.fileStatus is CIFileStatus.SndComplete }
+    rightClick(Ui.Chat.Item(id))
+    poll(what = "`Revoke file` in the menu of the uploaded file") {
+      exists(Ui.Chat.ItemMenu(id, "cancelFile")) && "Revoke file" in textsOf(Ui.Chat.ItemMenu(id, "cancelFile"))
+    }
+    click(Ui.Chat.ItemMenu(id, "cancelFile"))
+    poll(what = "the `Revoke file?` alert with `Revoke`") {
+      seesText("Revoke file?") && seesText("File will be deleted from servers.") && "Revoke" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    assertEquals("alice cancelled sending file 1 ($REVOKED_NAME)", bob.nextLine(CONNECT_TIMEOUT_MS))
+    poll(what = "alice's $REVOKED_NAME cancelled") { itemFileOf(id)?.fileStatus is CIFileStatus.SndCancelled }
+    rightClick(Ui.Chat.Item(id))
+    waitFor(Ui.Chat.ItemMenu(id, "select"))
+    assertFalse("the menu of the revoked file still offers to cancel it", exists(Ui.Chat.ItemMenu(id, "cancelFile")))
+    closeItemMenu(id)
+    val dir = File(bob.createFile(".fr-probe", "probe")).parent
+    bob sends "/fr 1 $dir/"
+    bob expects "file cancelled: $REVOKED_NAME"
+  }
+
+  @Test fun rcvImage_click_opensFullScreen() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "/img @alice $FIXTURE_JPG"
+    bob expectsMessage "/f @alice $FIXTURE_JPG"
+    bob expects "use /fc 1 to cancel sending"
+    bob.eventually("completed uploading file 1 (test.jpg) for alice", CONNECT_TIMEOUT_MS)
+    val chat = alice.chatList.open("bob")
+    val id = chat.itemId("bob's image") { it.content.msgContent is MsgContent.MCImage }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the image received and shown in full") {
+      itemFileOf(id)?.fileStatus is CIFileStatus.RcvComplete && exists(Ui.Chat.ItemFile(id))
+    }
+    check(!exists(Ui.Chat.FullScreenMedia) && !chatModel.fullscreenGalleryVisible.value) { "the full-screen viewer is open before the image is clicked" }
+    hideKeyboard()
+    click(Ui.Chat.ItemFile(id))
+    poll(what = "the full-screen viewer showing the image") { exists(Ui.Chat.FullScreenMedia) && "Image" in descriptionsOf(Ui.Chat.FullScreenMedia) }
+    click(Ui.Chat.FullScreenMedia)
+    poll(what = "the full-screen viewer closed, back to the chat") { !exists(Ui.Chat.FullScreenMedia) && exists(Ui.Chat.ItemFile(id)) }
+  }
+
+  @Test fun rcvFile_acceptedBeforeUpload_showsWaitingAlert() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val path = bob.createFile(WAITING_NAME, WAITING)
+    TestServers.stop("xftp1")
+    bob sends "/f @alice $path"
+    bob expects "use /fc 1 to cancel sending"
+    val chat = alice.chatList.open("bob")
+    val id = chat.itemId("bob's $WAITING_NAME") { it.file?.fileName == WAITING_NAME }
+    check(itemFileOf(id)?.fileStatus is CIFileStatus.RcvInvitation) { "$WAITING_NAME before the click: ${itemFileOf(id)?.fileStatus}" }
+    hideKeyboard()
+    click(Ui.Chat.ItemFile(id))
+    poll(what = "$WAITING_NAME accepted and waiting for bob's upload") { itemFileOf(id)?.fileStatus is CIFileStatus.RcvAccepted }
+    check(!seesText(WAITING_TITLE)) { "the `$WAITING_TITLE` alert is shown before the accepted file is clicked again" }
+    click(Ui.Chat.ItemFile(id))
+    poll(what = "the `$WAITING_TITLE` alert") { seesText(WAITING_TITLE) && seesText(WAITING_INFO) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the `$WAITING_TITLE` alert to close") { !seesText(WAITING_TITLE) }
+    check(itemFileOf(id)?.fileStatus is CIFileStatus.RcvAccepted) { "$WAITING_NAME left the waiting state with xftp1 down: ${itemFileOf(id)?.fileStatus}" }
+    val saved = File(exchangeDir(), "saved-$WAITING_NAME").apply { delete() }
+    TestServers.start("xftp1")
+    bob.eventually("completed uploading file 1 ($WAITING_NAME) for alice", CONNECT_TIMEOUT_MS)
+    saveFileAs(saved) {
+      poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "$WAITING_NAME received once xftp1 is back") { itemFileOf(id)?.fileStatus is CIFileStatus.RcvComplete }
+    }
+    assertEquals(WAITING, plainBytesOf(itemFileOf(id)!!).toString(Charsets.UTF_8))
+    poll(what = "the received $WAITING_NAME written to ${saved.name}") { saved.length() == WAITING.length.toLong() }
+    assertEquals(WAITING, saved.readText())
+  }
+
+  @Test fun rcvImage_large_clickDownloads() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val aliceId = bob.contactId("alice")
+    bob sends """/_send @$aliceId json [{"filePath": "$LARGE_PNG", "msgContent": {"type": "image", "text": "", "image": "$PREVIEW_IMAGE_DATA"}}]"""
+    bob.eventually("completed uploading file 1 ($LARGE_PNG_NAME) for alice", CONNECT_TIMEOUT_MS)
+    bob sends "/img @alice $FIXTURE_JPG"
+    bob.eventually("completed uploading file 2 (test.jpg) for alice", CONNECT_TIMEOUT_MS)
+    val chat = alice.chatList.open("bob")
+    val large = chat.itemId("bob's large image") { it.content.msgContent is MsgContent.MCImage && it.file?.fileName == LARGE_PNG_NAME }
+    val small = chat.itemId("bob's small image") { it.content.msgContent is MsgContent.MCImage && it.file?.fileName == "test.jpg" }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the small image, sent after the large one, received without a click") { itemFileOf(small)?.fileStatus is CIFileStatus.RcvComplete }
+    val offered = itemFileOf(large)!!
+    check(offered.fileStatus is CIFileStatus.RcvInvitation && offered.fileSize > MAX_IMAGE_SIZE_AUTO_RCV) {
+      "$LARGE_PNG_NAME (${offered.fileSize} bytes) was received without a click: ${offered.fileStatus}"
+    }
+    poll(what = "the preview of $LARGE_PNG_NAME with `Asked to receive the image`") {
+      exists(Ui.Chat.ItemFile(large).part("preview")) && "Asked to receive the image" in descriptionsOf(Ui.Chat.Item(large))
+    }
+    hideKeyboard()
+    click(Ui.Chat.ItemFile(large).part("preview"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "$LARGE_PNG_NAME received and shown in full, without `Asked to receive the image`") {
+      itemFileOf(large)?.fileStatus is CIFileStatus.RcvComplete && exists(Ui.Chat.ItemFile(large)) &&
+        "Asked to receive the image" !in descriptionsOf(Ui.Chat.Item(large))
+    }
+    val received = plainBytesOf(itemFileOf(large)!!)
+    assertEquals(offered.fileSize, received.size.toLong())
+    check(received.take(PNG_MAGIC.size) == PNG_MAGIC) { "the received $LARGE_PNG_NAME is not the PNG bob sent: ${received.take(PNG_MAGIC.size)}" }
+  }
+
+  @Test fun rcvFile_senderDeletedItem_cannotReceive() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val path = bob.createFile(DELETED_NAME, DELETED)
+    val aliceId = bob.contactId("alice")
+    bob sends """/_send @$aliceId json [{"filePath": "$path", "msgContent": {"type": "text", "text": "$CAPTION"}}]"""
+    bob.eventually("completed uploading file 1 ($DELETED_NAME) for alice", CONNECT_TIMEOUT_MS)
+    val chat = alice.chatList.open("bob")
+    val id = chat.itemId("`$CAPTION` with $DELETED_NAME") { it.content.text == CAPTION && it.file?.fileName == DELETED_NAME }
+    rightClick(Ui.Chat.Item(id))
+    waitFor(Ui.Chat.ItemMenu(id, "select"))
+    check(exists(Ui.Chat.ItemMenu(id, "download"))) { "the menu of the offered file has no Download" }
+    closeItemMenu(id)
+    bob sends "\\@alice $CAPTION"
+    bob.eventually("message marked deleted")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the item showing `marked deleted` in place of `$CAPTION`") {
+      chat.item(id)?.meta?.itemDeleted != null && textsOf(Ui.Chat.Item(id)).let { t -> t.any { "marked deleted" in it } && t.none { CAPTION in it } }
+    }
+    rightClick(Ui.Chat.Item(id))
+    waitFor(Ui.Chat.ItemMenu(id, "reveal"))
+    assertFalse("the menu of the deleted item offers Download", exists(Ui.Chat.ItemMenu(id, "download")))
+    closeItemMenu(id)
+  }
+
+  private companion object {
+    const val REVOKED_NAME = "revoke-me.txt"
+    const val REVOKED = "This file will be revoked by alice"
+    const val DELETED_NAME = "deleted.txt"
+    const val DELETED = "This file goes with a deleted message"
+    const val CAPTION = "hi, sending a file"
+    const val WAITING_NAME = "waiting.txt"
+    const val WAITING = "Uploaded after the file server is back"
+    const val WAITING_TITLE = "Waiting for file"
+    const val WAITING_INFO = "File will be received when your contact completes uploading it."
+    const val FIXTURE_JPG = "tests/fixtures/test.jpg"
+    const val LARGE_PNG = "website/src/img/simplex_mobile.png"
+    const val LARGE_PNG_NAME = "simplex_mobile.png"
+    val PNG_MAGIC = listOf(0x89.toByte(), 'P'.code.toByte(), 'N'.code.toByte(), 'G'.code.toByte())
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ReplyTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ReplyTest.kt
new file mode 100644
index 0000000000..0ffb428dac
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/ReplyTest.kt
@@ -0,0 +1,110 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import org.junit.Assert.assertFalse
+import org.junit.Test
+
+class ReplyTest : UiTest() {
+  @Test fun reply_group_peerSeesMemberQuote() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    val chat = ownGroup(alice, "team", bob, cath)
+    cath.eventually("#team: member bob is connected", CONNECT_TIMEOUT_MS)
+    bob sends "#team $QUESTION"
+    chat.menu(QUESTION, "reply")
+    chat.send(ANSWER)
+    bob.eventuallyMessage("#team alice!> > bob $QUESTION", CONNECT_TIMEOUT_MS)
+    bob expects "      $ANSWER"
+    cath.eventuallyMessage("#team alice> > bob $QUESTION", CONNECT_TIMEOUT_MS)
+    cath expects "      $ANSWER"
+    val answer = chat.itemId(ANSWER)
+    poll(what = "alice's reply quoting `bob` / `$QUESTION`") {
+      textsOf(Ui.Chat.Item(answer)).let { t -> "bob" in t && t.any { QUESTION in it } && t.any { ANSWER in it } }
+    }
+    chat.menu(ANSWER, "reply")
+    chat.send(FOLLOW_UP)
+    bob.eventuallyMessage("#team alice> > alice $ANSWER", CONNECT_TIMEOUT_MS)
+    bob expects "      $FOLLOW_UP"
+    cath.eventuallyMessage("#team alice> > alice $ANSWER", CONNECT_TIMEOUT_MS)
+    cath expects "      $FOLLOW_UP"
+    val followUp = chat.itemId(FOLLOW_UP)
+    poll(what = "alice's follow-up quoting `alice` / `$ANSWER`") {
+      textsOf(Ui.Chat.Item(followUp)).let { t -> "alice" in t && "bob" !in t && t.any { ANSWER in it } && t.any { FOLLOW_UP in it } }
+    }
+  }
+
+  @Test fun reply_cancelContext() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice hello"
+    val chat = alice.chatList.open("bob")
+    chat.itemId("hello")
+    waitFor(Ui.Chat.Message)
+    check(!seesDescription("Context icon")) { "a context bar is shown before Reply" }
+    chat.menu("hello", "reply")
+    poll(what = "the reply bar with `Cancel`") { seesDescription("Context icon") && exists(described("Cancel")) }
+    typeInto(Ui.Chat.Message, "just text")
+    hideKeyboard()
+    click(described("Cancel"))
+    poll(what = "the reply bar gone with `just text` kept in the field") { !seesDescription("Context icon") && editableText(Ui.Chat.Message) == "just text" }
+    chat.sendComposed()
+    bob.expectsMessage("alice> just text", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun reply_whileEditing_replacesEdit() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice question"
+    val chat = alice.chatList.open("bob")
+    chat.itemId("question")
+    chat.send("draft answer")
+    bob expectsMessage "alice> draft answer"
+    val draft = chat.itemId("draft answer")
+    chat.menu("draft answer", "edit")
+    poll(what = "the edit bar with `draft answer` in the field") { editableText(Ui.Chat.Message) == "draft answer" && exists(described("Cancel")) }
+    hideKeyboard()
+    chat.menu("question", "reply")
+    poll(what = "an empty field under the reply bar") { editableText(Ui.Chat.Message).isNullOrEmpty() && seesDescription("Context icon") && exists(described("Cancel")) }
+    chat.send("final answer")
+    bob.expectsMessage("alice> > question", CONNECT_TIMEOUT_MS)
+    bob expects "      final answer"
+    poll(what = "`draft answer` unchanged and not edited") { chat.item(draft)?.let { it.content.text == "draft answer" && !it.meta.itemEdited } == true }
+  }
+
+  @Test fun quote_click_deleted_showsNoMessageAlert() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("the original")
+    bob expectsMessage "alice> the original"
+    bob types ">@alice (the original) the reply"
+    bob expectsMessage "@alice > the original"
+    bob expects "      the reply"
+    val original = chat.itemId("the original")
+    val reply = chat.itemId("the reply")
+    hideKeyboard()
+    click(Ui.Chat.Item(reply).part("quote"))
+    poll(what = "the quote of an existing message handled, `the original` in view") { UiIdle.inFlight().isEmpty() && exists(Ui.Chat.Item(original)) }
+    settle()
+    assertFalse("the `No message` alert for the quote of an existing message", seesText("No message"))
+    chat.menu("the original", "delete")
+    click(Ui.Alert.Option(Ui.AlertSource.Shared, "forMe"))
+    poll(what = "`the original` deleted for alice") { chat.item(original) == null && !exists(Ui.Chat.Item(original)) }
+    click(Ui.Chat.Item(reply).part("quote"))
+    poll(what = "the `No message` alert for the quote of the deleted message") { seesText("No message") && seesText("This message was deleted or not received yet.") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the `No message` alert closed") { !seesText("No message") }
+  }
+
+  private companion object {
+    const val QUESTION = "hello! how are you?"
+    const val ANSWER = "hello, all good, you?"
+    const val FOLLOW_UP = "will tell more"
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/SendAttachmentTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/SendAttachmentTest.kt
new file mode 100644
index 0000000000..78d49b9a0f
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/SendAttachmentTest.kt
@@ -0,0 +1,127 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.attachFile
+import chat.simplex.app.ui.harness.attachImage
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.jpegFile
+import chat.simplex.app.ui.harness.openAttachmentSheet
+import chat.simplex.app.ui.harness.receivesCompressedImage
+import chat.simplex.app.ui.harness.receivesFile
+import chat.simplex.common.model.GroupFeature
+import chat.simplex.common.model.GroupFeatureEnabled
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.MAX_FILE_SIZE_XFTP
+import org.junit.Test
+import java.io.File
+import java.io.RandomAccessFile
+
+class SendAttachmentTest : UiTest() {
+  @Test fun attachFile_withText_peerReceivesTextAndFile() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val source = File(exchangeDir(), NOTES_NAME).apply { writeText(NOTES) }
+    alice.chatList.open("bob")
+    waitFor(Ui.Chat.Message)
+    check(!seesDescription("Close sheet") && !seesDescription("Cancel file preview")) { "the attachment sheet or a file preview is shown before Attach" }
+    attachFile(source)
+    click(described("Cancel file preview"))
+    poll(what = "the preview of $NOTES_NAME removed") { !seesDescription("Cancel file preview") && !seesText(NOTES_NAME) }
+    attachFile(source)
+    typeInto(Ui.Chat.Message, CAPTION)
+    hideKeyboard()
+    click(Ui.Chat.Send)
+    poll(what = "the preview and the text cleared after Send") { !seesDescription("Cancel file preview") && editableText(Ui.Chat.Message).isNullOrEmpty() }
+    bob.expectsMessage("alice> $CAPTION", CONNECT_TIMEOUT_MS)
+    bob expectsMessage "alice> sends file $NOTES_NAME (${NOTES.length} bytes / ${NOTES.length} bytes)"
+    bob expects "use /fr 1 [<dir>/ | <path>] to receive it"
+    bob.receivesFile(1, NOTES_NAME, "alice")
+  }
+
+  @Test fun attachFile_tooLarge_showsLargeFileAlert() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val huge = File(exchangeDir(), HUGE_NAME)
+    RandomAccessFile(huge, "rw").use { it.setLength(MAX_FILE_SIZE_XFTP + 1) }
+    try {
+      val chat = alice.chatList.open("bob")
+      waitFor(Ui.Chat.Message)
+      check(!seesText("Large file!")) { "the `Large file!` alert is shown before the file is picked" }
+      openAttachmentSheet()
+      openFile(huge) { click(Ui.Chat.Attach("file")) }
+      poll(what = "the `Large file!` alert with OK and no preview of $HUGE_NAME") {
+        seesText("Large file!") && "OK" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && !seesDescription("Cancel file preview")
+      }
+      click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+      poll(what = "the alert closed and still no preview of $HUGE_NAME") {
+        !seesText("Large file!") && !seesDescription("Cancel file preview") && !seesText(HUGE_NAME)
+      }
+      chat.send("after")
+      bob.expectsMessage("alice> after", CONNECT_TIMEOUT_MS)
+    } finally {
+      huge.delete()
+    }
+  }
+
+  @Test fun attachImage_withQuote_peerSeesQuote() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val photo = jpegFile(PHOTO_NAME)
+    bob sends "@alice $QUESTION"
+    val chat = alice.chatList.open("bob")
+    chat.menu(QUESTION, "reply")
+    poll(what = "the reply bar and no image preview") { seesDescription("Context icon") && !seesDescription("Cancel image preview") }
+    attachImage(photo)
+    typeInto(Ui.Chat.Message, IMAGE_CAPTION)
+    hideKeyboard()
+    click(Ui.Chat.Send)
+    poll(what = "the image preview, the reply bar and the caption cleared after Send") {
+      !seesDescription("Cancel image preview") && !seesDescription("Context icon") && editableText(Ui.Chat.Message).isNullOrEmpty()
+    }
+    bob.expectsMessage("alice> > $QUESTION", CONNECT_TIMEOUT_MS)
+    bob expects "      $IMAGE_CAPTION"
+    val sent = bob.receivesCompressedImage("alice> ", 1)
+    bob.receivesFile(1, sent, "alice")
+  }
+
+  @Test fun attach_groupFilesProhibited_buttonDisabled() = uiTest {
+    val alice = app("alice")
+    val chat = emptyGroup(alice, "team")
+    val attach = described("Attach")
+    chat.send("draft")
+    poll(what = "the attach button enabled in team") { exists(attach) && isEnabled(attach) }
+    hideKeyboard()
+    chat.menu("draft", "edit")
+    poll(what = "the edit bar with `draft` in the field and the attach button disabled") {
+      editableText(Ui.Chat.Message) == "draft" && exists(described("Cancel")) && exists(attach) && !isEnabled(attach)
+    }
+    hideKeyboard()
+    click(described("Cancel"))
+    poll(what = "the edit bar closed and the attach button enabled again") {
+      !exists(described("Cancel")) && editableText(Ui.Chat.Message).isNullOrEmpty() && exists(attach) && isEnabled(attach)
+    }
+    val info = chat.groupInfo()
+    val prefs = info.preferences()
+    prefs.toggle(GroupFeature.Files)
+    prefs.save()
+    poll(what = "files and media prohibited in team") { groupInfoOf("team").fullGroupPreferences.files.enable == GroupFeatureEnabled.OFF }
+    prefs.backClosing()
+    info.close()
+    poll(what = "the attach button disabled in team with files prohibited") { exists(attach) && !isEnabled(attach) }
+    chat.send("text still goes")
+  }
+
+  private companion object {
+    const val NOTES_NAME = "attach-notes.txt"
+    const val NOTES = "Notes attached through the file chooser"
+    const val CAPTION = "hi, sending a file"
+    const val HUGE_NAME = "attach-huge.bin"
+    const val PHOTO_NAME = "attach-photo.jpg"
+    const val QUESTION = "hi alice"
+    const val IMAGE_CAPTION = "hey bob"
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/SpecialItemTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/SpecialItemTest.kt
new file mode 100644
index 0000000000..ab21ee5be0
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/SpecialItemTest.kt
@@ -0,0 +1,90 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.eventIds
+import chat.simplex.app.ui.harness.itemMenu
+import chat.simplex.app.ui.harness.loadedItemId
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.common.model.CIContent
+import chat.simplex.common.model.ChatFeature
+import chat.simplex.common.model.ChatItem
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class SpecialItemTest : UiTest() {
+  @Test fun featureItems_merged_iconRowExpandHide() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.chatList.open("bob")
+    val initial = featureItemIds("the five feature items created on connection", INITIAL.size)
+    poll(what = "the five feature items collapsed into one row of icons without text") { collapsedInto(initial.max(), initial) }
+    bob sends "/set voice @alice no"
+    bob expects "you updated preferences for alice:"
+    bob.eventuallyMatching(Regex("Voice messages: off \\(you allow: no.*"))
+    val all = featureItemIds("bob's `Voice messages: off` feature item", INITIAL.size + 1)
+    val voiceOff = all.max()
+    poll(what = "bob's change joining the collapsed row of feature icons without text") { collapsedInto(voiceOff, all) }
+    itemMenu(voiceOff, "expand")
+    poll(what = "every feature item shown with its text after Expand") {
+      shows(voiceOff, "Voice messages: off") && INITIAL.all { (feature, text) -> shows(initialItem(feature), text) }
+    }
+    itemMenu(voiceOff, "collapse")
+    poll(what = "the feature items collapsed into the icon row again after Hide") { collapsedInto(voiceOff, all) }
+  }
+
+  @Test fun events_merged_deleteRange() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    val chat = ownGroup(alice, "team", bob, cath)
+    val (older, newer) = eventIds("the `connected` events of bob and cath in team", 2) { it.memberConnected != null }
+    chat.send("keep")
+    bob.eventuallyMessage("#team alice> keep", CONNECT_TIMEOUT_MS)
+    val keep = chat.itemId("keep")
+    val e2ee = loadedItemId("the encryption info of team") { it.content is CIContent.SndGroupE2EEInfo }
+    poll(what = "the two `connected` events merged into one row") { exists(Ui.Chat.Item(newer)) && !exists(Ui.Chat.Item(older)) }
+    hideKeyboard()
+    itemMenu(newer, "delete")
+    poll(what = "the alert to delete the merged events for alice only") {
+      seesText("Messages will be deleted - this cannot be undone!") && exists(EVENTS_FOR_ME) && !exists(EVENTS_FOR_EVERYONE)
+    }
+    click(EVENTS_FOR_ME)
+    poll(what = "both `connected` events deleted, `keep` and the encryption info kept") {
+      chat.item(older) == null && chat.item(newer) == null && !exists(Ui.Chat.Item(newer)) && exists(Ui.Chat.Item(keep)) && chat.item(e2ee) != null
+    }
+  }
+
+  private fun UiScope.featureItemIds(what: String, count: Int): List<Long> {
+    var ids = emptyList<Long>()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = what) {
+      ids = chatModel.chatsContext.chatItems.value.filter { it.content is CIContent.RcvChatFeature }.map { it.id }
+      ids.size == count
+    }
+    return ids
+  }
+
+  private fun initialItem(feature: ChatFeature): Long =
+    chatModel.chatsContext.chatItems.value.first { it.isFeature(feature) }.id
+
+  private fun ChatItem.isFeature(feature: ChatFeature) = (content as? CIContent.RcvChatFeature)?.feature == feature
+
+  private fun UiScope.collapsedInto(row: Long, ids: List<Long>): Boolean =
+    exists(Ui.Chat.Item(row)) && (ids - row).none { exists(Ui.Chat.Item(it)) } && textsOf(Ui.Chat.Item(row)).none { t -> INITIAL.any { (_, text) -> text.substringBefore(":") in t } }
+
+  private fun UiScope.shows(id: Long, text: String): Boolean = exists(Ui.Chat.Item(id)) && textsOf(Ui.Chat.Item(id)).any { text in it }
+
+  private companion object {
+    val EVENTS_FOR_ME = Ui.Alert.Option(Ui.AlertSource.Shared, "forMe")
+    val EVENTS_FOR_EVERYONE = Ui.Alert.Option(Ui.AlertSource.Shared, "forEveryone")
+    val INITIAL = listOf(
+      ChatFeature.TimedMessages to "Disappearing messages: off",
+      ChatFeature.FullDelete to "Delete for everyone: off",
+      ChatFeature.Reactions to "Message reactions: enabled",
+      ChatFeature.Voice to "Voice messages: enabled",
+      ChatFeature.Calls to "Audio/video calls: enabled",
+    )
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/TimedMessageTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/TimedMessageTest.kt
new file mode 100644
index 0000000000..7f1192578d
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/TimedMessageTest.kt
@@ -0,0 +1,92 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.PeerFlags
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitGoneFromPeer
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.openTimedMenu
+import chat.simplex.app.ui.harness.receivedTtlSeconds
+import chat.simplex.common.model.ChatFeature
+import chat.simplex.common.model.shortTimeText
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class TimedMessageTest : UiTest() {
+  @Test fun timed_send30s_bothSidesDelete() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(markRead = true))
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, "hello!")
+    assertFalse("the disappearing message menu is open before the send button is right-clicked", exists(Ui.Chat.SendTimed))
+    openTimedMenu()
+    assertTrue("`1 minute` and `5 minutes` in the disappearing message menu", seesText("1 minute") && seesText("5 minutes"))
+    click(Ui.Chat.SendTimed.option(30))
+    bob.expectsMessage("alice> hello!", CONNECT_TIMEOUT_MS)
+    val id = chat.itemId("hello!")
+    poll(what = "alice's `hello!` with a 30 s timer and `${shortTimeText(30)}` in its meta") {
+      chat.item(id)?.meta?.itemTimed?.ttl == 30 && shortTimeText(30) in textsOf(Ui.Chat.Item(id))
+    }
+    val ttl = bob.receivedTtlSeconds("alice", "hello!")
+    assertTrue("bob's `hello!` is deleted $ttl s after it was sent, expected about 30 s", ttl in 28L..40L)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`hello!` to disappear from alice's chat 30 s after it was sent") {
+      chat.item(id) == null && !exists(Ui.Chat.Item(id))
+    }
+    awaitGoneFromPeer(bob, "alice", "alice> hello!")
+  }
+
+  @Test fun timed_menuHidden_whenFeatureOff() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(markRead = true))
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, "allowed")
+    openTimedMenu()
+    click(Ui.Chat.SendTimed.option(30))
+    bob.expectsMessage("alice> allowed", CONNECT_TIMEOUT_MS)
+    chat.itemId("allowed")
+    bob sends "/set disappear @alice no"
+    bob expects "you updated preferences for alice:"
+    bob.eventuallyMatching(Regex("Disappearing messages: off \\(you allow: no.*"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's preference change to turn disappearing messages off for alice") {
+      !alice.chatList.chat("bob").chatInfo.featureEnabled(ChatFeature.TimedMessages)
+    }
+    typeInto(Ui.Chat.Message, "not allowed")
+    rightClick(Ui.Chat.Send)
+    poll(what = "the send menu with `Send live message` and without `Disappearing message`") {
+      exists(Ui.Chat.SendLive) && !exists(Ui.Chat.SendTimed)
+    }
+  }
+
+  @Test fun timed_meta_showsTimerAndTtl() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(markRead = true))
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    bob sends "/set disappear @alice yes $CHAT_TTL"
+    bob expects "you updated preferences for alice:"
+    bob.eventuallyMatching(Regex("Disappearing messages: enabled .*"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's $CHAT_TTL s timer to reach alice") { alice.chatList.chat("bob").chatInfo.timedMessagesTTL == CHAT_TTL }
+    chat.send("chat timer")
+    bob.expectsMessage("alice> chat timer", CONNECT_TIMEOUT_MS)
+    typeInto(Ui.Chat.Message, "own timer")
+    openTimedMenu()
+    click(Ui.Chat.SendTimed.option(30))
+    bob.expectsMessage("alice> own timer", CONNECT_TIMEOUT_MS)
+    val chatTimer = chat.itemId("chat timer")
+    val ownTimer = chat.itemId("own timer")
+    poll(what = "the chat timer item without a TTL in its meta and the own timer item with `${shortTimeText(30)}`") {
+      chat.item(chatTimer)?.meta?.itemTimed?.ttl == CHAT_TTL && chat.item(ownTimer)?.meta?.itemTimed?.ttl == 30 &&
+        textsOf(Ui.Chat.Item(chatTimer)).none { it == shortTimeText(CHAT_TTL) || it == shortTimeText(30) } &&
+        shortTimeText(30) in textsOf(Ui.Chat.Item(ownTimer))
+    }
+    val chatTtl = bob.receivedTtlSeconds("alice", "chat timer")
+    assertTrue("bob's `chat timer` is deleted $chatTtl s after it was sent, expected about $CHAT_TTL s", chatTtl in (CHAT_TTL - 2L)..(CHAT_TTL + 10L))
+    val ownTtl = bob.receivedTtlSeconds("alice", "own timer")
+    assertTrue("bob's `own timer` is deleted $ownTtl s after it was sent, expected about 30 s", ownTtl in 28L..40L)
+  }
+
+  private companion object {
+    const val CHAT_TTL = 120
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/UnreadScrollTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/UnreadScrollTest.kt
new file mode 100644
index 0000000000..4a13900012
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/chat/UnreadScrollTest.kt
@@ -0,0 +1,199 @@
+package chat.simplex.app.ui.chat
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitRowText
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.contactOf
+import chat.simplex.app.ui.harness.loadedItemId
+import chat.simplex.app.ui.harness.loadedText
+import chat.simplex.app.ui.harness.loadedNumbered
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.app.ui.harness.replyViaApi
+import chat.simplex.app.ui.harness.sendTextsViaApi
+import chat.simplex.app.ui.harness.shownText
+import chat.simplex.app.ui.harness.switchAwayFromChat
+import chat.simplex.common.model.ChatPagination
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+private const val UNREAD = 60
+private const val FAR = 120
+private const val NOTES = "Private notes"
+private const val OLDER = 300
+private const val AROUND_AFTER = ChatPagination.PRELOAD_COUNT * 2
+private const val NEWER = 360
+private const val MAX_PAGES = 150
+private const val BANNER = "Your contact"
+
+class UnreadScrollTest : UiTest() {
+  @Test fun unread_openChat_scrollsToFirstUnread() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    for (i in 1..UNREAD) bob sends "@alice m$i"
+    awaitRowText(alice, "bob", "$UNREAD")
+    val chat = alice.chatList.open("bob")
+    val first = chat.itemId("m1")
+    var below = 0
+    poll(what = "`m1` read, and the row and the scroll-down button both counting the unread messages below the view") {
+      below = alice.chatList.chat("bob").chatStats.unreadCount
+      chat.item(first)?.isRcvNew == false && below in 1 until UNREAD &&
+        exists(Ui.Chat.ScrollToBottom) && "$below" in textsOf(Ui.Chat.ScrollToBottom) && "$below" in alice.chatList.rowTexts("bob")
+    }
+    val newest = chatModel.chatsContext.chatItems.value.lastOrNull { it.content.text == "m$UNREAD" }
+    check(newest == null || (newest.isRcvNew && !exists(Ui.Chat.Item(newest.id)))) { "`m$UNREAD` was shown or read before the chat was scrolled to it" }
+    click(Ui.Chat.ScrollToBottom)
+    val last = chat.itemId("`m$UNREAD` in view after the scroll-down button") { it.content.text == "m$UNREAD" }
+    var above = 0
+    poll(what = "`m$UNREAD` read, no scroll-down button, and the row and the scroll-up button both counting the skipped unread messages") {
+      above = alice.chatList.chat("bob").chatStats.unreadCount
+      chat.item(last)?.isRcvNew == false && !exists(Ui.Chat.ScrollToBottom) && above in 1 until below &&
+        exists(Ui.Chat.UnreadAbove) && "$above" in textsOf(Ui.Chat.UnreadAbove) && "$above" in alice.chatList.rowTexts("bob")
+    }
+    rightClick(Ui.Chat.UnreadAbove)
+    click(Ui.Chat.UnreadAbove.part("markRead"))
+    poll(what = "every message read: no scroll-up button and no unread count on the row") {
+      alice.chatList.chat("bob").chatStats.unreadCount == 0 && !exists(Ui.Chat.UnreadAbove) &&
+        alice.chatList.rowTexts("bob").none { it.isNotEmpty() && it.all(Char::isDigit) }
+    }
+  }
+
+  @Test fun unreadChatFlag_clearedOnOpen() = uiTest {
+    val alice = app("alice")
+    alice.chatList.row(NOTES)
+    val badges = alice.chatList.rowTexts(NOTES).count { it.isEmpty() }
+    alice.chatList.rowMenu(NOTES, "markUnread")
+    poll(what = "the unread mark on the notes row") {
+      alice.chatList.chat(NOTES).chatStats.unreadChat && alice.chatList.rowTexts(NOTES).count { it.isEmpty() } > badges
+    }
+    alice.chatList.open(NOTES)
+    poll(what = "the unread mark cleared by opening the notes") {
+      !alice.chatList.chat(NOTES).chatStats.unreadChat && alice.chatList.rowTexts(NOTES).count { it.isEmpty() } == badges
+    }
+    val restarted = restart()
+    restarted.chatList.row(NOTES)
+    check(!restarted.chatList.chat(NOTES).chatStats.unreadChat && restarted.chatList.rowTexts(NOTES).count { it.isEmpty() } == badges) {
+      "the unread mark is back after a restart"
+    }
+  }
+
+  @Test fun pagination_quoteOutsidePage_jumpLoadsOriginal() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("the original")
+    bob expectsMessage "alice> the original"
+    val original = chat.itemId("the original")
+    switchAwayFromChat(alice)
+    for (i in 1..FAR) bob sends "@alice f$i"
+    bob types ">@alice (the original) far reply"
+    bob expectsMessage "@alice > the original"
+    bob expects "      far reply"
+    awaitRowText(alice, "bob", "far reply")
+    alice.chatList.rowMenu("bob", "markRead")
+    poll(what = "bob's chat marked read") { alice.chatList.chat("bob").chatStats.unreadCount == 0 }
+    alice.chatList.open("bob")
+    val reply = chat.itemId("far reply")
+    check(chat.item(original) == null && !exists(Ui.Chat.Item(original))) { "`the original` was loaded with the newest page" }
+    click(Ui.Chat.Item(reply).part("quote"))
+    poll(what = "`the original` loaded and in view, with the scroll-down arrow and no count") {
+      exists(Ui.Chat.Item(original)) && exists(Ui.Chat.ScrollToBottom) && textsOf(Ui.Chat.ScrollToBottom).isEmpty()
+    }
+    bob sends "@alice new one"
+    val newOne = loadedItemId("`new one` received in alice's open chat") { it.content.text == "new one" }
+    poll(what = "`the original` still in view, `new one` below it and the scroll-down button counting 1") {
+      exists(Ui.Chat.Item(original)) && !exists(Ui.Chat.Item(newOne)) && exists(Ui.Chat.ScrollToBottom) && "1" in textsOf(Ui.Chat.ScrollToBottom)
+    }
+    click(Ui.Chat.ScrollToBottom)
+    poll(what = "`new one` in view and read, with no scroll-down button") {
+      exists(Ui.Chat.Item(newOne)) && chat.item(newOne)?.isRcvNew == false && !exists(Ui.Chat.ScrollToBottom)
+    }
+    bob sends "@alice latest"
+    val latest = loadedItemId("`latest` received in alice's open chat") { it.content.text == "latest" }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the chat scrolled down to `latest` by itself") { exists(Ui.Chat.Item(latest)) }
+  }
+
+  @Test fun pagination_scrollUp_loadsOlder() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's contact ready to send to") { alice.chatList.shown("bob") && contactOf("bob").sndReady }
+    val texts = (1..OLDER).map { "p$it" }
+    sendTextsViaApi("bob", texts)
+    val chat = alice.chatList.open("bob")
+    chat.itemId("p$OLDER")
+    val initial = loadedNumbered("p")
+    check(initial == texts.takeLast(ChatPagination.INITIAL_COUNT)) { "the chat opened with ${initial.size} messages ${initial.firstOrNull()}..${initial.lastOrNull()}, not the newest ${ChatPagination.INITIAL_COUNT}" }
+    check(!seesText(BANNER)) { "the chat banner is shown before the oldest message is loaded" }
+    var pages = 0
+    while (!seesText(BANNER)) {
+      if (++pages > MAX_PAGES) throw AssertionError("the chat banner not shown after $MAX_PAGES pages up; oldest loaded: ${loadedNumbered("p").firstOrNull()}")
+      val loaded = chatModel.chatsContext.chatItems.value.size
+      if (!scrollChatTowardOlder()) {
+        poll(what = "older messages loaded at the top of the chat, or the chat banner; oldest loaded: ${loadedNumbered("p").firstOrNull()}") {
+          chatModel.chatsContext.chatItems.value.size > loaded || seesText(BANNER)
+        }
+      }
+    }
+    check(loadedNumbered("p") == texts) { "the messages loaded by scrolling up are not `p1`..`p$OLDER` in order: ${loadedNumbered("p").size} loaded" }
+  }
+
+  @Test fun pagination_afterAround_scrollDownLoadsNewer() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("the original")
+    bob expectsMessage "alice> the original"
+    val original = chat.itemId("the original")
+    switchAwayFromChat(alice)
+    val texts = (1..NEWER).map { "n$it" }
+    sendTextsViaApi("bob", texts)
+    replyViaApi("bob", original, "far reply")
+    alice.chatList.open("bob")
+    val reply = chat.itemId("far reply")
+    check(chat.item(original) == null) { "`the original` was loaded with the newest page" }
+    click(Ui.Chat.Item(reply).part("quote"))
+    poll(what = "`the original` loaded around and in view") { exists(Ui.Chat.Item(original)) }
+    val aroundNewest = "n$AROUND_AFTER"
+    val firstGap = "n${AROUND_AFTER + 1}"
+    check(loadedText(aroundNewest) && !loadedText(firstGap) && loadedText("n$NEWER")) { "the jump did not leave a gap after `$aroundNewest`: ${loadedNumbered("n").size} loaded" }
+    var pages = 0
+    while (!loadedText(firstGap)) {
+      if (shownText(aroundNewest)) throw AssertionError("`$aroundNewest`, the newest message loaded around `the original`, scrolled into view before newer messages were loaded below it")
+      if (++pages > MAX_PAGES) throw AssertionError("`$firstGap` not loaded after $MAX_PAGES pages down")
+      if (!scrollChatTowardNewer()) throw AssertionError("the chat stopped scrolling down before `$firstGap` was loaded")
+    }
+    check(!shownText(aroundNewest)) { "`$firstGap` was loaded only after `$aroundNewest` scrolled into view" }
+    while (!exists(Ui.Chat.Item(reply))) {
+      if (++pages > MAX_PAGES) throw AssertionError("`far reply` not in view after $MAX_PAGES pages down; ${loadedNumbered("n").size} of $NEWER loaded")
+      if (!scrollChatTowardNewer()) throw AssertionError("the chat stopped scrolling down before `far reply`; ${loadedNumbered("n").size} of $NEWER loaded")
+    }
+    check(loadedNumbered("n") == texts) { "the messages loaded by scrolling down are not `n1`..`n$NEWER` in order: ${loadedNumbered("n").size} loaded" }
+  }
+
+  @Test fun groupRcv_avatarClick_opensMemberInfo() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    val chat = ownGroup(alice, "team", bob, cath)
+    chat.send("start")
+    bob.eventuallyMessage("#team alice> start", CONNECT_TIMEOUT_MS)
+    cath.eventuallyMessage("#team alice> start", CONNECT_TIMEOUT_MS)
+    bob sends "#team from bob"
+    val fromBob = chat.itemId("from bob")
+    cath sends "#team from cath"
+    val fromCath = chat.itemId("from cath")
+    poll(what = "the avatars of bob and cath on their messages") {
+      exists(Ui.Chat.Item(fromBob).part("avatar")) && exists(Ui.Chat.Item(fromCath).part("avatar"))
+    }
+    check(!exists(Ui.MemberInfo.BlockForAll)) { "member info is open before an avatar is clicked" }
+    hideKeyboard()
+    click(Ui.Chat.Item(fromCath).part("avatar"))
+    poll(what = "member info with `Change role` and `Block for all`") { exists(Ui.MemberInfo.Role) && exists(Ui.MemberInfo.BlockForAll) }
+    click(Ui.MemberInfo.BlockForAll)
+    poll(what = "the `Block member for all?` alert naming cath, not bob") {
+      seesText("Block member for all?") && seesText("All new messages from cath will be hidden!") && !seesText("All new messages from bob will be hidden!")
+    }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the alert closed on cath's member info") { !seesText("Block member for all?") && exists(Ui.MemberInfo.BlockForAll) }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/BusinessChatTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/BusinessChatTest.kt
new file mode 100644
index 0000000000..9c6d8b3b63
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/BusinessChatTest.kt
@@ -0,0 +1,167 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.businessChat
+import chat.simplex.app.ui.harness.businessTypeOf
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.connectPeers
+import chat.simplex.app.ui.harness.createAddress
+import chat.simplex.app.ui.harness.createBusinessAddress
+import chat.simplex.app.ui.harness.deleteBusinessChatFromInfo
+import chat.simplex.app.ui.harness.enterLinkInNewChatSearch
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.inviteMembers
+import chat.simplex.app.ui.harness.leaveBusinessChatFromInfo
+import chat.simplex.app.ui.harness.openNewChatFromSearch
+import chat.simplex.app.ui.harness.planConfirm
+import chat.simplex.app.ui.harness.quiesce
+import chat.simplex.app.ui.harness.switchAwayFromChat
+import chat.simplex.common.model.BusinessChatType
+import chat.simplex.common.model.CIContent
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.model.GroupMemberStatus
+import chat.simplex.common.model.RcvGroupEvent
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class BusinessChatTest : UiTest() {
+  @Test fun business_addTeamMember() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val address = createBusinessAddress(alice)
+    connect(cath)
+    bob sends "/c $address"
+    bob expects "connection request sent!"
+    bob.eventually("#alice: joining the group...", CONNECT_TIMEOUT_MS)
+    bob.eventually("#alice: you joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "a customer business chat named bob") { businessTypeOf("bob") == BusinessChatType.Customer }
+    quiesce()
+    val chat = alice.chatList.open("bob")
+    val info = chat.groupInfo()
+    poll(what = "`Chat preferences` with the chat owners footer in the business chat's info") {
+      seesText("Chat preferences") && seesText("Only chat owners can change preferences.") && !seesText("Group preferences")
+    }
+    check(!exists(Ui.GroupInfo.CreateLink) && !exists(Ui.GroupInfo.GroupLink) && !exists(Ui.GroupInfo.MemberSupport) &&
+      !exists(Ui.GroupInfo.EditProfile) && !exists(Ui.GroupInfo.WelcomeMessage)) { "the business chat's info offers a group link, `Chats with members`, profile or welcome editing" }
+    scrollTo(Ui.GroupInfo.AddMembers)
+    check("Add team members" in textsOf(Ui.GroupInfo.AddMembers)) { "the business owner's add button is not `Add team members`: ${textsOf(Ui.GroupInfo.AddMembers)}" }
+    val invite = inviteMembers()
+    invite.toggle("cath")
+    invite.invite()
+    cath.eventually("#bob: alice invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    cath expects "use /j bob to accept"
+    cath sends "/j bob"
+    cath.eventuallyAll(lines = listOf("#bob: you joined the group", "#bob: member bob_1 is connected"), timeoutMs = CONNECT_TIMEOUT_MS)
+    bob.eventuallyAll(lines = listOf("#alice: alice_1 added cath to the group (connecting...)", "#alice: new member cath is connected"), timeoutMs = CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "cath listed as connected in the business chat") { info.memberTexts("cath").let { "connected" in it || "complete" in it } }
+    info.close()
+    chat.send("welcome from the team")
+    bob.eventuallyMessage("#alice alice_1> welcome from the team", CONNECT_TIMEOUT_MS)
+    cath.eventuallyMessage("#bob alice> welcome from the team", CONNECT_TIMEOUT_MS)
+    bob sends "#alice thanks"
+    cath.eventuallyMessage("#bob bob_1> thanks", CONNECT_TIMEOUT_MS)
+    chat.itemId("bob's `thanks` in the business chat") { it.content.text == "thanks" }
+    chat.groupInfo()
+    deleteBusinessChatFromInfo("bob")
+    bob.eventuallyMatching(Regex("#alice: alice_1 deleted the group( \\(signed\\))?"), CONNECT_TIMEOUT_MS)
+    cath.eventuallyMatching(Regex("#bob: alice deleted the group( \\(signed\\))?"), CONNECT_TIMEOUT_MS)
+    alice.chatList.gone("bob")
+  }
+
+  @Test fun customer_connectToBusinessAddress() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val address = bob.createAddress(business = true)
+    alice.chatList.row("Private notes")
+    check(chatModel.chats.value.none { it.chatInfo.chatViewName == "bob" }) { "a chat named bob exists before the address is opened" }
+    val chat = openNewChatFromSearch(address, "bob")
+    val bizId = chatModel.chatId.value!!
+    poll(what = "a prepared business chat with `Tap Connect to chat`, a message field and `Connect`") {
+      businessTypeOf("bob") == BusinessChatType.Business && seesText("Tap Connect to chat") &&
+        exists(Ui.Chat.Message) && exists(Ui.Chat.Connect) && "Connect" in textsOf(Ui.Chat.Connect)
+    }
+    click(Ui.Chat.Connect)
+    bob.eventually("#alice: accepting business address request...", CONNECT_TIMEOUT_MS)
+    bob.eventually("#alice: alice_1 joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the banner `Business connection` with `Connect` gone and alice connected") {
+      seesText("Business connection") && !seesText("Tap Connect to chat") && !exists(Ui.Chat.Connect) && exists(Ui.Chat.Message) &&
+        groupInfoOf("bob").membership.memberStatus == GroupMemberStatus.MemConnected
+    }
+    chat.send("hello business")
+    bob.eventuallyMessage("#alice alice_1> hello business", CONNECT_TIMEOUT_MS)
+    bob sends "#alice hi alice"
+    chat.itemId("bob's `hi alice` in the business chat") { it.content.text == "hi alice" }
+    switchAwayFromChat(alice)
+    check(chatModel.chatId.value != bizId) { "the business chat is still open before the address is pasted again" }
+    enterLinkInNewChatSearch(alice, address)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the known business alert for bob with `Open chat` and no member role") {
+      exists(planConfirm) && "Open chat" in textsOf(planConfirm) && seesText("bob") && !seesText("You are a member")
+    }
+    click(planConfirm)
+    poll(what = "the New chat sheet closed with the business chat open and still one chat named bob") {
+      !exists(planConfirm) && !exists(Ui.NewChat.Search) && chatModel.chatId.value == bizId && chatModel.chats.value.count { it.chatInfo.chatViewName == "bob" } == 1
+    }
+  }
+
+  @Test fun customer_seesTeamMemberAdded() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    businessChat(bob)
+    connectPeers(bob, cath)
+    val chat = alice.chatList.open("bob")
+    bob sends "/a #alice cath"
+    bob.eventually("invitation to join the group #alice sent to cath")
+    cath.eventually("#alice: bob invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    cath expects "use /j alice to accept"
+    cath sends "/j alice"
+    cath.eventuallyAll(lines = listOf("#alice: you joined the group", "#alice: member alice_1 is connected"), timeoutMs = CONNECT_TIMEOUT_MS)
+    bob.eventually("#alice: cath joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `invited cath` event in the business chat") {
+      chatModel.chatsContext.chatItems.value.any { ((it.content as? CIContent.RcvGroupEventContent)?.rcvGroupEvent as? RcvGroupEvent.MemberAdded)?.profile?.displayName == "cath" }
+    }
+    cath sends "#alice hello from the team"
+    chat.itemId("cath's `hello from the team` in the business chat") { it.content.text == "hello from the team" }
+    val info = chat.groupInfo()
+    poll(what = "`Chat preferences` with the chat owners footer in the customer's chat info") {
+      seesText("Chat preferences") && seesText("Only chat owners can change preferences.") && !seesText("Group preferences")
+    }
+    check(!exists(Ui.GroupInfo.EditProfile) && !exists(Ui.GroupInfo.MemberSupport) && !exists(Ui.GroupInfo.CreateLink)) { "a customer's chat info offers profile editing, `Chats with members` or a group link" }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "cath listed as connected in the business chat") { info.memberTexts("cath").let { "connected" in it || "complete" in it } }
+    check(info.ownMemberTexts().isNotEmpty() && !exists(Ui.GroupInfo.AddMembers)) { "a customer's member list offers `Add friends`" }
+    leaveBusinessChatFromInfo("bob")
+    bob.eventuallyMatching(Regex("#alice: alice_1 left the group( \\(signed\\))?"), CONNECT_TIMEOUT_MS)
+    cath.eventuallyMatching(Regex("#alice: alice_1 left the group( \\(signed\\))?"), CONNECT_TIMEOUT_MS)
+    poll(what = "`you left` in the business chat's compose field") { seesText("you left") }
+  }
+
+  @Test fun business_promoteCustomerToAdmin() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val address = createBusinessAddress(alice)
+    bob sends "/c $address"
+    bob expects "connection request sent!"
+    bob.eventually("#alice: you joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "a customer business chat named bob") { businessTypeOf("bob") == BusinessChatType.Customer }
+    quiesce()
+    val info = alice.chatList.open("bob").groupInfo()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the customer bob listed as connected, without a role label") {
+      info.memberTexts("bob").let { ("connected" in it || "complete" in it) && "admin" !in it }
+    }
+    val member = info.member("bob")
+    member.pickRole(GroupMemberRole.Admin)
+    check(seesText("The role will be changed to \"admin\". Everyone in the chat will be notified.")) {
+      "the `Change role?` alert of a business chat does not use the chat wording"
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    bob.eventuallyMatching(Regex("#alice: \\S+ changed your role from member to admin \\(signed\\)"), CONNECT_TIMEOUT_MS)
+    poll(what = "bob's role picker at `admin`") { !seesText("Change role?") && "admin" in textsOf(Ui.MemberInfo.Role) }
+    click(Ui.MemberInfo.Remove)
+    poll(what = "the `Remove member?` alert saying bob will be removed from the chat") {
+      seesText("Remove member?") && seesText("Member will be removed from chat - this cannot be undone!") &&
+        exists(Ui.Alert.Option(Ui.AlertSource.Shared, "remove"))
+    }
+    click(Ui.Alert.Option(Ui.AlertSource.Shared, "remove"))
+    bob.eventuallyMatching(Regex("#alice: \\S+ removed you from the group( \\(signed\\))?"), CONNECT_TIMEOUT_MS)
+    poll(what = "bob no longer a current member of the business chat") {
+      chatModel.groupMembers.value.none { it.memberProfile.displayName == "bob" && it.memberCurrent }
+    }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ChannelOwnerBroadcastTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ChannelOwnerBroadcastTest.kt
new file mode 100644
index 0000000000..6e50ccf459
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ChannelOwnerBroadcastTest.kt
@@ -0,0 +1,26 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.PeerFlags
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.channelLinkViaApi
+import chat.simplex.app.ui.harness.createChannel
+import chat.simplex.app.ui.harness.joinChannel
+import chat.simplex.app.ui.harness.registerChatRelaysViaApi
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class ChannelOwnerBroadcastTest : UiTest() {
+  @Test fun channel_broadcastPlaceholderAndDelivery() = uiTest {
+    val alice = app("alice"); val relay = cli("relay1", PeerFlags(relay = true)); val bob = cli("bob"); val cath = cli("cath")
+    registerChatRelaysViaApi(relay)
+    val chat = createChannel(alice, "team").continueToChannel()
+    val link = channelLinkViaApi("team")
+    bob.joinChannel("team", link, relay)
+    cath.joinChannel("team", link, relay)
+    poll(what = "the empty message field of team showing the placeholder `Broadcast`") { hintOf(Ui.Chat.Message) == "Broadcast" }
+    chat.send("hi")
+    bob.eventuallyMessage("#team> hi [>>]", CONNECT_TIMEOUT_MS)
+    cath.eventuallyMessage("#team> hi [>>]", CONNECT_TIMEOUT_MS)
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ChannelOwnerCreateTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ChannelOwnerCreateTest.kt
new file mode 100644
index 0000000000..5a1f4466b3
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ChannelOwnerCreateTest.kt
@@ -0,0 +1,61 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChannelLinkScreen
+import chat.simplex.app.ui.harness.PeerFlags
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.channelChatId
+import chat.simplex.app.ui.harness.channelLinkViaApi
+import chat.simplex.app.ui.harness.createChannel
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.joinChannel
+import chat.simplex.app.ui.harness.registerChatRelaysViaApi
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class ChannelOwnerCreateTest : UiTest() {
+  @Test fun createChannel_singleRelayCompletesAndShowsLink() = uiTest {
+    val alice = app("alice"); val relay = cli("relay1", PeerFlags(relay = true))
+    registerChatRelaysViaApi(relay)
+    alice.newChat()
+    click(Ui.NewChat.CreateChannel)
+    typeInto(Ui.NewChannel.Name, "team")
+    check(channelChatId("team") == null) { "a channel named team exists before `Create public channel` is clicked" }
+    click(Ui.NewChannel.Create)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Creating channel` step with `0/1 relays active` and no channel link") {
+      seesText("Creating channel") && seesText("0/1 relays active") && !exists(Ui.GroupLink.Share)
+    }
+    relay.eventually("#team: you joined the group as relay", CONNECT_TIMEOUT_MS)
+    val linkScreen = ChannelLinkScreen(this, "team")
+    poll(what = "the channel link explanation in place of the `Creating channel` step") {
+      seesText("You can share a link or a QR code - anybody will be able to join the channel.") && !seesText("Creating channel")
+    }
+    groupInfoOf("team").let { check(it.useRelays && it.membership.memberRole == GroupMemberRole.Owner) { "team is not a channel owned by alice: useRelays ${it.useRelays}, role ${it.membership.memberRole}" } }
+    linkScreen.continueToChannel()
+  }
+
+  @Test fun channelLink_cliSubscriberJoins() = uiTest {
+    val alice = app("alice"); val relay = cli("relay1", PeerFlags(relay = true)); val bob = cli("bob")
+    registerChatRelaysViaApi(relay)
+    val linkScreen = createChannel(alice, "team")
+    val link = linkScreen.share()
+    linkScreen.continueToChannel()
+    bob.joinChannel("team", link, relay)
+  }
+
+  @Test fun channelInfo_subscriberCountUpdates() = uiTest {
+    val alice = app("alice"); val relay = cli("relay1", PeerFlags(relay = true)); val bob = cli("bob"); val cath = cli("cath")
+    registerChatRelaysViaApi(relay)
+    val chat = createChannel(alice, "team").continueToChannel()
+    val link = channelLinkViaApi("team")
+    chat.groupInfo().apply {
+      poll(what = "Group info of the new channel with `Subscribers` and `1 subscriber`") { seesText("Subscribers") && seesText("1 subscriber") }
+      close()
+    }
+    bob.joinChannel("team", link, relay)
+    cath.joinChannel("team", link, relay)
+    chat.groupInfo()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`3 subscribers` in Group info after bob and cath joined") { seesText("Subscribers") && seesText("3 subscribers") }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ChannelSubscriberTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ChannelSubscriberTest.kt
new file mode 100644
index 0000000000..a820ba2d96
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ChannelSubscriberTest.kt
@@ -0,0 +1,39 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.PeerFlags
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.createChannel
+import chat.simplex.app.ui.harness.joinPreparedChannel
+import chat.simplex.app.ui.harness.openPreparedChannelFromSearch
+import chat.simplex.common.model.CIDirection
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class ChannelSubscriberTest : UiTest() {
+  @Test fun subscriber_receivesBroadcast() = uiTest {
+    val alice = app("alice"); val relay = cli("relay1", PeerFlags(relay = true)); val bob = cli("bob")
+    val link = bob.createChannel("team", relay)
+    alice.chatList.row("Private notes")
+    val chat = openPreparedChannelFromSearch(link, "team")
+    joinPreparedChannel("team", bob, relay)
+    check(chatModel.chatsContext.chatItems.value.none { it.content.text == "hi" }) { "team shows `hi` before the owner posts it" }
+    bob sends "#team hi"
+    chat.itemId("`hi` received from the channel") { it.content.text == "hi" && it.chatDir is CIDirection.ChannelRcv }
+  }
+
+  @Test fun subscriber_composeDisabled() = uiTest {
+    val alice = app("alice"); val relay = cli("relay1", PeerFlags(relay = true)); val bob = cli("bob")
+    val link = bob.createChannel("team", relay)
+    alice.chatList.row("Private notes")
+    openPreparedChannelFromSearch(link, "team")
+    poll(what = "the banner `Tap Join channel` without `you are subscriber`") { seesText("Tap Join channel") && !seesText("you are subscriber") }
+    joinPreparedChannel("team", bob, relay)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`you are subscriber` in the message field of team") { seesText("you are subscriber") }
+    click(Ui.Chat.Message)
+    poll(what = "the `You can't send messages!` alert") { seesText("You can't send messages!") && "OK" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the alert to close with team still read-only") { !seesText("You can't send messages!") && seesText("you are subscriber") }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/CreateGroupTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/CreateGroupTest.kt
new file mode 100644
index 0000000000..6d759d751e
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/CreateGroupTest.kt
@@ -0,0 +1,112 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
+import chat.simplex.app.ui.harness.InviteMembersScreen
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.alertSaying
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.quiesce
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.ModalManager
+import org.junit.Assert.assertNotEquals
+import org.junit.Test
+
+class CreateGroupTest : UiTest() {
+  @Test fun createGroup_buttonDisabledForEmptyOrInvalidName() = uiTest {
+    val alice = app("alice")
+    alice.newChat()
+    click(Ui.NewChat.CreateGroup)
+    waitFor(Ui.NewGroup.Name)
+    check(editableText(Ui.NewGroup.Name).isNullOrEmpty() && !exists(Ui.NewGroup.Name.part("invalid"))) { "the new group name is not empty, or is flagged invalid while empty" }
+    click(Ui.NewGroup.Create)
+    typeInto(Ui.NewGroup.Name, "a_1")
+    waitFor(Ui.NewGroup.Name.part("invalid"))
+    click(Ui.NewGroup.Create)
+    click(Ui.NewGroup.Name.part("invalid"))
+    poll(what = "the `Invalid name!` alert offering `a-1`") { seesText("Invalid name!") && seesText("Correct name to a-1?") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the name corrected to `a-1` without the invalid-name icon") {
+      editableText(Ui.NewGroup.Name) == "a-1" && !exists(Ui.NewGroup.Name.part("invalid")) && !seesText("Invalid name!")
+    }
+    check(chatModel.chats.value.none { it.chatInfo is ChatInfo.Group }) { "`Create group` created a group from an empty or invalid name" }
+    click(Ui.NewGroup.Create)
+    val id = alice.chatList.chatId("a-1")
+    poll(what = "group `a-1` open with the invite members sheet") { chatModel.chatId.value == id && seesText("Invite members") }
+    val groups = chatModel.chats.value.filter { it.chatInfo is ChatInfo.Group }.map { it.chatInfo.chatViewName }
+    check(groups == listOf("a-1")) { "groups after creating `a-1` are $groups" }
+  }
+
+  @Test fun createGroup_skipInviting() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.newChat().createGroup("team")
+    val id = alice.chatList.chatId("team")
+    val inv = InviteMembersScreen(this)
+    poll(what = "bob offered, with `Skip inviting members` and no `Invite to group`") {
+      inv.listed("bob") && exists(Ui.InviteMembers.Skip) && !exists(Ui.InviteMembers.Invite) && seesText("No contacts selected")
+    }
+    inv.toggle("bob")
+    poll(what = "`Invite to group` in place of `Skip inviting members` with bob selected") {
+      exists(Ui.InviteMembers.Invite) && !exists(Ui.InviteMembers.Skip) && seesText("1 contact(s) selected")
+    }
+    inv.toggle("bob")
+    poll(what = "`Skip inviting members` back after unselecting bob") {
+      exists(Ui.InviteMembers.Skip) && !exists(Ui.InviteMembers.Invite) && seesText("No contacts selected")
+    }
+    click(Ui.InviteMembers.Skip)
+    poll(what = "the invite sheet closed with team's chat open") {
+      !exists(Ui.InviteMembers.Role) && !ModalManager.end.hasModalsOpen() && chatModel.chatId.value == id
+    }
+    backToChatList()
+    alice.chatList.open("bob").send("after skip")
+    bob.expectsMessage("alice> after skip", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun createGroupIncognito_cliJoinerSeesIncognitoHost() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    alice.newChat()
+    click(Ui.NewChat.CreateGroup)
+    typeInto(Ui.NewGroup.Name, "team")
+    hideKeyboard()
+    poll(what = "`Incognito` off with the main profile footer") { exists(Ui.NewGroup.Incognito) && !seesText(RANDOM_PROFILE, substring = true) }
+    click(Ui.NewGroup.Incognito)
+    poll(what = "the random profile footer after turning `Incognito` on") { seesText(RANDOM_PROFILE, substring = true) }
+    click(Ui.NewGroup.Create)
+    val id = alice.chatList.chatId("team")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "team open with the `Group link` step showing `Share link` and `Continue`, without `Delete link` or the invite sheet") {
+      chatModel.chatId.value == id && exists(Ui.GroupLink.Share) && exists(Ui.GroupLink.Continue) && !seesText("Delete link") && !exists(Ui.InviteMembers.Role)
+    }
+    val membership = groupInfoOf("team").membership
+    check(membership.memberIncognito) { "team was created with alice's main profile" }
+    val incognito = membership.memberProfile.displayName
+    assertNotEquals("alice", incognito)
+    setClipboardText(null)
+    click(Ui.GroupLink.Share)
+    var link: String? = null
+    poll(what = "team's link shared") { link = clipboardText()?.takeIf { it.isNotBlank() }; link != null }
+    click(Ui.GroupLink.Continue)
+    poll(what = "the link step closed with team's chat open") { !exists(Ui.GroupLink.Share) && !ModalManager.end.hasModalsOpen() && chatModel.chatId.value == id }
+    bob sends "/c ${link!!}"
+    bob expects "connection request sent!"
+    bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    quiesce()
+    val chat = ChatScreen(this)
+    chat.send("hello from the host")
+    bob.eventuallyMessage("#team $incognito> hello from the host", CONNECT_TIMEOUT_MS)
+    chat.groupInfo()
+    scrollTo(Ui.GroupInfo.AddMembers)
+    check("Invite members" in textsOf(Ui.GroupInfo.AddMembers)) { "the add button of an incognito group is not `Invite members`: ${textsOf(Ui.GroupInfo.AddMembers)}" }
+    click(Ui.GroupInfo.AddMembers)
+    alertSaying("Can't invite contacts!", "You're using an incognito profile for this group - to prevent sharing your main profile inviting contacts is not allowed")
+    check(!exists(Ui.InviteMembers.Role)) { "the invite sheet opened for an incognito group" }
+  }
+
+  private companion object {
+    const val RANDOM_PROFILE = "A new random profile will be shared."
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupEventsTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupEventsTest.kt
new file mode 100644
index 0000000000..24a89baed0
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupEventsTest.kt
@@ -0,0 +1,114 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.eventIds
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.inviteMembers
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.itemMenu
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.common.model.CIContent
+import chat.simplex.common.model.GroupFeature
+import chat.simplex.common.model.RcvGroupEvent
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+private val TWO_CONNECTED = Regex("(bob and cath|cath and bob) connected")
+
+class GroupEventsTest : UiTest() {
+  @Test fun groupEvents_memberConnectedMerged() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob)
+    connect(cath)
+    ownGroup(alice, "team", bob, cath)
+    val (older, newer) = eventIds("the `connected` events of bob and cath in team", 2) { it.memberConnected != null }
+    fun rowTexts(id: Long) = textsOf(Ui.Chat.Item(id))
+    poll(what = "one row `… and … connected` in place of the two events") {
+      exists(Ui.Chat.Item(newer)) && rowTexts(newer).any { TWO_CONNECTED.containsMatchIn(it) } && !exists(Ui.Chat.Item(older))
+    }
+    itemMenu(newer, "expand")
+    poll(what = "each `connected` event on a row of its own") {
+      exists(Ui.Chat.Item(older)) &&
+        listOf(older, newer).all { id -> rowTexts(id).let { t -> t.any { "connected" in it } && t.none { TWO_CONNECTED.containsMatchIn(it) } } }
+    }
+    itemMenu(newer, "collapse")
+    poll(what = "the two events merged into one row again") {
+      !exists(Ui.Chat.Item(older)) && rowTexts(newer).any { TWO_CONNECTED.containsMatchIn(it) }
+    }
+  }
+
+  @Test fun groupEvents_roleChangeItems() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    hostGroup(bob, "team", "alice")
+    joinGroupFromList(alice, bob, "team")
+    backToChatList()
+    val chat = alice.chatList.open("team")
+    bob sends "/mr team alice admin"
+    bob.eventuallyMatching(Regex("#team: you changed the role of alice to admin( \\(signed\\))?"))
+    val role = chat.itemId("bob's `changed your role to admin` in team") {
+      (it.content as? CIContent.RcvGroupEventContent)?.rcvGroupEvent is RcvGroupEvent.UserRole
+    }
+    poll(what = "`changed your role to admin` on its own row") { textsOf(Ui.Chat.Item(role)).any { "changed your role to admin" in it } }
+    for (welcome in listOf("Hello", "Hello again")) {
+      bob sends "/set welcome #team $welcome"
+      bob.eventually("welcome message changed to:")
+      bob expects welcome
+    }
+    val (older, newer) = eventIds("bob's two `updated group profile` events in team", 2) {
+      (it.content as? CIContent.RcvGroupEventContent)?.rcvGroupEvent is RcvGroupEvent.GroupUpdated
+    }
+    poll(what = "`2 group events` in place of the two profile updates, the role change still on its own row") {
+      textsOf(Ui.Chat.Item(newer)).any { "2 group events" in it } && !exists(Ui.Chat.Item(older)) &&
+        textsOf(Ui.Chat.Item(role)).any { "changed your role to admin" in it }
+    }
+    itemMenu(newer, "expand")
+    poll(what = "both `updated group profile` events on rows of their own") {
+      listOf(older, newer).all { id -> exists(Ui.Chat.Item(id)) && textsOf(Ui.Chat.Item(id)).let { t -> t.any { "updated group profile" in it } && t.none { "2 group events" in it } } }
+    }
+  }
+
+  @Test fun history_newCliMemberReceivesHistory() = uiTest {
+    val alice = app("alice"); val cath = cli("cath"); val dan = cli("dan")
+    connect(cath)
+    connect(dan)
+    val chat = emptyGroup(alice, "team")
+    chat.send("hello")
+    val info = chat.groupInfo()
+    inviteMembers().apply {
+      poll(what = "cath offered") { listed("cath") }
+      toggle("cath")
+      invite()
+    }
+    cath.expectsMessage("#team: alice invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    cath expects "use /j team to accept"
+    cath sends "/j team"
+    cath.eventuallyAll(lines = listOf("#team: you joined the group"), messages = listOf("#team alice> hello [>>]"), timeoutMs = CONNECT_TIMEOUT_MS)
+    val prefs = info.preferences()
+    prefs.toggle(GroupFeature.History)
+    prefs.save()
+    cath.eventually("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS)
+    cath expects "updated group preferences:"
+    cath expects "Recent history: off"
+    poll(what = "visible history off for team") { !groupInfoOf("team").fullGroupPreferences.history.on }
+    prefs.backClosing()
+    inviteMembers().apply {
+      poll(what = "dan offered") { listed("dan") }
+      toggle("dan")
+      invite()
+    }
+    dan.expectsMessage("#team: alice invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    dan expects "use /j team to accept"
+    dan sends "/j team"
+    dan.expectsMessage("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    dan.expectsMessage("#team: member cath is connected", CONNECT_TIMEOUT_MS)
+    info.close()
+    chat.send("after")
+    dan.expectsMessage("#team alice> after", CONNECT_TIMEOUT_MS)
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupInfoTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupInfoTest.kt
new file mode 100644
index 0000000000..e5babb2a2a
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupInfoTest.kt
@@ -0,0 +1,114 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.groupInfoRow
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.app.ui.harness.newGroupsViaApi
+import chat.simplex.common.model.MsgFilter
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class GroupInfoTest : UiTest() {
+  @Test fun groupInfo_setLocalAlias() = uiTest {
+    val alice = app("alice")
+    var info = emptyGroup(alice, "team").groupInfo()
+    poll(what = "group info of `team` with an empty `Set chat name…` field") {
+      exists(Ui.Info.Alias) && editableText(Ui.Info.Alias).isNullOrEmpty() && seesText("Set chat name…") && seesText("team")
+    }
+    typeInto(Ui.Info.Alias, "Work")
+    poll(what = "`Work` saved as team's local name") { groupInfoOf("Work").localAlias == "Work" }
+    hideKeyboard()
+    info.close()
+    backToChatList()
+    poll(what = "the row reading `Work` instead of `team`") { alice.chatList.rowTexts("Work").let { "Work" in it && "team" !in it } }
+    val after = restart()
+    poll(what = "the group listed as `Work` after the restart") {
+      chatModel.chatRunning.value == true && chatModel.chats.value.any { it.chatInfo.chatViewName == "Work" }
+    }
+    poll(what = "the row still reading `Work` after the restart") { after.chatList.rowTexts("Work").let { "Work" in it && "team" !in it } }
+    info = after.chatList.open("Work").groupInfo()
+    poll(what = "group info showing the profile name `team` with the local name `Work`") { editableText(Ui.Info.Alias) == "Work" && seesText("team") }
+    replaceText(Ui.Info.Alias, "")
+    poll(what = "team's local name cleared") { groupInfoOf("team").localAlias.isEmpty() }
+    hideKeyboard()
+    info.close()
+    backToChatList()
+    poll(what = "the row reading `team` again") { alice.chatList.rowTexts("team").let { "team" in it && "Work" !in it } }
+  }
+
+  @Test fun groupInfo_muteCycleWithMentions() = uiTest {
+    val alice = app("alice")
+    var info = emptyGroup(alice, "team").groupInfo()
+    fun mode() = groupInfoOf("team").chatSettings.enableNtfs
+    poll(what = "`Mute` on the group info button with all notifications on") { exists(Ui.GroupInfo.Mute) && seesText("Mute") && mode() == MsgFilter.All }
+    click(Ui.GroupInfo.Mute)
+    poll(what = "mentions-only notifications and `Mute all` on the button") { mode() == MsgFilter.Mentions && seesText("Mute all") && !seesText("Mute") }
+    click(Ui.GroupInfo.Mute)
+    poll(what = "notifications off and `Unmute` on the button") { mode() == MsgFilter.None && seesText("Unmute") && !seesText("Mute all") }
+    info.close()
+    backToChatList()
+    poll(what = "the mute icon on team's row") { "Notifications" in alice.chatList.rowDescriptions("team") }
+    info = alice.chatList.open("team").groupInfo()
+    poll(what = "`Unmute` on the button after reopening group info") { exists(Ui.GroupInfo.Mute) && seesText("Unmute") }
+    click(Ui.GroupInfo.Mute)
+    poll(what = "all notifications and `Mute` on the button") { mode() == MsgFilter.All && seesText("Mute") && !seesText("Unmute") }
+    info.close()
+    backToChatList()
+    poll(what = "no mute icon on team's row") { "Notifications" !in alice.chatList.rowDescriptions("team") }
+  }
+
+  @Test fun groupInfo_actionButtonsByRole() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    hostGroup(bob, "team", "alice")
+    joinGroupFromList(alice, bob, "team")
+    backToChatList()
+    val info = alice.chatList.open("team").groupInfo()
+    poll(what = "a member's group info with `Search` and `Mute`") { exists(Ui.GroupInfo.Mute) && exists(Ui.GroupInfo.Preferences) && seesText("Search") && seesText("Mute") }
+    check(!seesText("Invite")) { "a member's group info offers `Invite`" }
+    check(listOf(Ui.GroupInfo.CreateLink, Ui.GroupInfo.GroupLink, Ui.GroupInfo.AddMembers, Ui.GroupInfo.MemberSupport, Ui.GroupInfo.Reports).none { exists(it) }) {
+      "a member's group info shows a link, `Invite members`, `Chats with members` or `Member reports` row"
+    }
+    bob sends "/mr team alice admin"
+    bob.eventuallyMatching(Regex("#team: you changed the role of alice to admin( \\(signed\\))?"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "an admin's group info with `Invite`, `Create group link`, `Invite members`, `Chats with members` and `Member reports`") {
+      seesText("Invite") && listOf(Ui.GroupInfo.CreateLink, Ui.GroupInfo.AddMembers, Ui.GroupInfo.MemberSupport, Ui.GroupInfo.Reports).all { exists(it) }
+    }
+    check(!exists(Ui.GroupInfo.GroupLink)) { "`Group link` shown before a link was created" }
+    info.createLink()
+    poll(what = "`Group link` in place of `Create group link`") { exists(Ui.GroupInfo.GroupLink) && !exists(Ui.GroupInfo.CreateLink) }
+    groupInfoRow(Ui.GroupInfo.GroupLink)
+    waitFor(Ui.GroupLink.Share, CONNECT_TIMEOUT_MS)
+    escape()
+    poll(what = "the group link screen to close to group info") { !exists(Ui.GroupLink.Share) && exists(Ui.GroupInfo.GroupLink) }
+  }
+
+  @Test fun groupInfo_sendReceiptsOption() = uiTest {
+    val alice = app("alice")
+    newGroupsViaApi("club")
+    var info = emptyGroup(alice, "team").groupInfo()
+    fun receipts(): List<String> = textsOf(Ui.GroupInfo.SendReceipts)
+    poll(what = "team's `Send receipts` at `default (…)`") { receipts().any { it.startsWith("default (") } }
+    click(Ui.GroupInfo.SendReceipts)
+    click(Ui.GroupInfo.SendReceipts.option(false))
+    poll(what = "`no` selected and saved for team") { "no" in receipts() && groupInfoOf("team").chatSettings.sendRcpts == false }
+    info.close()
+    val after = restart()
+    poll(what = "team and club listed after the restart") {
+      chatModel.chatRunning.value == true && chatModel.chats.value.map { it.chatInfo.chatViewName }.containsAll(listOf("team", "club"))
+    }
+    info = after.chatList.open("team").groupInfo()
+    poll(what = "team's `Send receipts` still `no` after the restart") { "no" in receipts() }
+    info.close()
+    backToChatList()
+    info = after.chatList.open("club").groupInfo()
+    poll(what = "club's `Send receipts` still at `default (…)`") { receipts().any { it.startsWith("default (") } && groupInfoOf("club").chatSettings.sendRcpts == null }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupLinksTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupLinksTest.kt
index aee0ce25ed..2358904581 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupLinksTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupLinksTest.kt
@@ -1,14 +1,27 @@
 package chat.simplex.app.ui.groups
 
 import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.closeGroupLink
 import chat.simplex.app.ui.harness.connect
 import chat.simplex.app.ui.harness.connectIncognito
+import chat.simplex.app.ui.harness.contactOf
+import chat.simplex.app.ui.harness.coreGroupLinkRole
+import chat.simplex.app.ui.harness.coreMemberContactId
+import chat.simplex.app.ui.harness.described
 import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.groupInfoOf
 import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.openNewGroupLink
 import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.app.ui.harness.pickGroupLinkRole
+import chat.simplex.app.ui.harness.sharedGroupLink
+import chat.simplex.common.model.ChatController.appPrefs
 import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.GroupMemberRole
 import chat.simplex.common.model.GroupMemberStatus
+import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
 import chat.simplex.common.views.helpers.ModalManager
 import org.junit.Assert.assertNotEquals
@@ -88,8 +101,130 @@ class GroupLinksTest : UiTest() {
       textsOf(Ui.Chat.Item(after)).let { t -> "blocked by admin" in t && t.none { "after block" in it } } &&
         textsOf(Ui.Chat.Item(before)).any { "before block" in it }
     }
+    bob sends "#team still blocked"
+    val again = chat.itemId("still blocked")
+    poll(what = "bob's two blocked messages collapsed into `2 messages blocked by admin`") {
+      "2 messages blocked by admin" in textsOf(Ui.Chat.Item(again)) && !exists(Ui.Chat.Item(after))
+    }
     chat.send("after the block")
     bob.expectsMessage("#team alice> after the block", CONNECT_TIMEOUT_MS)
     cath.expectsMessage("#team alice> after the block", CONNECT_TIMEOUT_MS)
   }
+
+  @Test fun groupLink_cliJoinsViaFullLink() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val info = emptyGroup(alice, "team").groupInfo()
+    poll(what = "`Create group link` in team's info, without a `Group link` row") { exists(Ui.GroupInfo.CreateLink) && !exists(Ui.GroupInfo.GroupLink) }
+    openNewGroupLink()
+    poll(what = "the link created by itself, with the QR code, `Initial role`, `Share link` and `Delete link`, and no `Full link` toggle") {
+      seesDescription("QR Code") && seesText("Initial role") && exists(Ui.GroupLink.Role) && exists(described("Delete link")) && !exists(Ui.Link.ShortLinkToggle)
+    }
+    val short = sharedGroupLink()
+    check(FULL_CONTACT_LINK !in short) { "`Share link` shared the full link `$short` by default" }
+    enableDeveloperToolsViaApi()
+    poll(what = "the `Full link` toggle with developer tools on") { exists(Ui.Link.ShortLinkToggle) && "Full link" in textsOf(Ui.Link.ShortLinkToggle) }
+    click(Ui.Link.ShortLinkToggle)
+    poll(what = "the toggle reading `Short link`") { "Short link" in textsOf(Ui.Link.ShortLinkToggle) }
+    val full = sharedGroupLink(previous = short)
+    check(FULL_CONTACT_LINK in full) { "`Share link` with `Full link` shared `$full`, not the full link" }
+    bob sends "/c $full"
+    bob expects "connection request sent!"
+    bob.eventually("#team: joining the group...", CONNECT_TIMEOUT_MS)
+    bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    closeGroupLink()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob listed as connected in team's members") { "connected" in info.memberTexts("bob") }
+  }
+
+  @Test fun groupLink_initialRoleObserver() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = emptyGroup(alice, "team")
+    val info = chat.groupInfo()
+    val groupId = groupInfoOf("team").groupId
+    openNewGroupLink()
+    poll(what = "`Initial role` member") { "member" in textsOf(Ui.GroupLink.Role) && coreGroupLinkRole(groupId) == GroupMemberRole.Member }
+    pickGroupLinkRole(GroupMemberRole.Observer)
+    poll(what = "`observer` as the link's initial role in the core") { "observer" in textsOf(Ui.GroupLink.Role) && coreGroupLinkRole(groupId) == GroupMemberRole.Observer }
+    val link = sharedGroupLink()
+    bob sends "/c $link"
+    bob expects "connection request sent!"
+    bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    bob sends "#team hi there"
+    bob expects "#team: you don't have permission to send messages"
+    pickGroupLinkRole(GroupMemberRole.Member)
+    poll(what = "`member` as the link's initial role in the core again") { "member" in textsOf(Ui.GroupLink.Role) && coreGroupLinkRole(groupId) == GroupMemberRole.Member }
+    cath sends "/c $link"
+    cath expects "connection request sent!"
+    cath.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    cath sends "#team hello from cath"
+    closeGroupLink()
+    info.close()
+    chat.itemId("cath's `hello from cath`") { it.content.text == "hello from cath" }
+    check(chatModel.chatsContext.chatItems.value.none { it.content.text == "hi there" }) { "the observer bob's message reached the group" }
+  }
+
+  @Test fun groupLink_deleteKeepsMembers() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = emptyGroup(alice, "team")
+    val info = chat.groupInfo()
+    openNewGroupLink()
+    val link = sharedGroupLink()
+    bob sends "/c $link"
+    bob expects "connection request sent!"
+    bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    check(!seesText("Delete link?")) { "`Delete link?` is shown before `Delete link` is clicked" }
+    click(described("Delete link"))
+    poll(what = "the `Delete link?` alert saying members stay, with `Delete`") {
+      seesText("Delete link?") && seesText("All group members will remain connected.") && "Delete" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the group link screen offering `Create link` after the deletion") { !exists(Ui.GroupLink.Share) && seesText("Create link") }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the deleted group link to fail its plan on the server") {
+      cath sends "/_connect plan 1 $link"
+      cath.eventuallyMatching(GROUP_LINK_PLAN).value.startsWith("error")
+    }
+    cath sends "/c $link"
+    cath.eventuallyMatching(AUTH_FAILED)
+    closeGroupLink()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob still connected in team's members and cath not listed") {
+      "connected" in info.memberTexts("bob") && info.memberTexts("cath").isEmpty()
+    }
+    info.close()
+    chat.send("still here")
+    bob.expectsMessage("#team alice> still here", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun groupLink_existingContactMergedWithMember() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val bobChatId = alice.chatList.chatId("bob")
+    val chat = emptyGroup(alice, "team")
+    val link = chat.groupInfo().createLink()
+    bob sends "/c $link"
+    bob expects "connection request sent!"
+    bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    bob.eventually("contact and member are merged: alice, #team alice_1", CONNECT_TIMEOUT_MS)
+    bob expects "use @alice <message> to send messages"
+    val bobContactId = contactOf("bob").contactId
+    val groupId = groupInfoOf("team").groupId
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice's core to link bob's member to his existing contact") { coreMemberContactId(groupId, "bob") == bobContactId }
+    escape()
+    poll(what = "group info to close") { !ModalManager.end.hasModalsOpen() }
+    val info = chat.groupInfo()
+    poll(what = "bob's member in reopened group info linked to his existing contact, with no second chat for bob") {
+      chatModel.groupMembers.value.firstOrNull { it.memberProfile.displayName == "bob" }?.memberContactId == bobContactId &&
+        chatModel.chats.value.count { (it.chatInfo as? ChatInfo.Direct)?.contact?.profile?.displayName == "bob" } == 1
+    }
+    info.member("bob").message()
+    poll(what = "bob's existing chat open from his member info") { chatModel.chatId.value == bobChatId && !ModalManager.end.hasModalsOpen() }
+    ChatScreen(this).send("via member info")
+    bob.expectsMessage("alice> via member info", CONNECT_TIMEOUT_MS)
+  }
+
+  private fun enableDeveloperToolsViaApi() = appPrefs.developerTools.set(true)
+
+  private companion object {
+    const val FULL_CONTACT_LINK = "/contact#/?v="
+    val GROUP_LINK_PLAN = Regex("group link: ok to connect.*|error: connection authorization failed.*")
+    val AUTH_FAILED = Regex("error: connection authorization failed - .*")
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupPreferencesTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupPreferencesTest.kt
new file mode 100644
index 0000000000..ab5f4d1635
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupPreferencesTest.kt
@@ -0,0 +1,270 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.createOneTimeLink
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.app.ui.harness.quiesce
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.GroupFeature
+import chat.simplex.common.model.GroupFeatureEnabled
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Ignore
+import org.junit.Test
+
+class GroupPreferencesTest : UiTest() {
+  @Test fun groupPrefs_unsavedChangesAlert() = uiTest {
+    val alice = app("alice")
+    val info = emptyGroup(alice, "team").groupInfo()
+    var prefs = info.preferences()
+    waitFor(Ui.GroupPrefs.Toggle(GroupFeature.Reports))
+    waitFor(Ui.GroupPrefs.Toggle(GroupFeature.Support))
+    check(isEnabled(Ui.GroupPrefs.Toggle(GroupFeature.Reactions))) { "the `Message reactions` toggle is disabled" }
+    check(!isEnabled(Ui.GroupPrefs.Toggle(GroupFeature.Reports)) && !isEnabled(Ui.GroupPrefs.Toggle(GroupFeature.Support))) { "the `Member reports` or `Chat with admins` toggle is enabled" }
+    poll(what = "reactions allowed before the change") { seesText("Allow message reactions.") }
+    prefs.toggle(GroupFeature.Reactions)
+    poll(what = "reactions prohibited after the toggle") { seesText("Prohibit messages reactions.") && !seesText("Allow message reactions.") }
+    prefs.reset()
+    poll(what = "reactions allowed again after `Reset`") { seesText("Allow message reactions.") && !seesText("Prohibit messages reactions.") }
+    prefs.backClosing()
+    prefs = info.preferences()
+    poll(what = "reactions allowed when reopened after `Reset`") { seesText("Allow message reactions.") }
+    prefs.toggle(GroupFeature.Reactions)
+    poll(what = "reactions prohibited after the toggle") { seesText("Prohibit messages reactions.") && !seesText("Allow message reactions.") }
+    prefs.backExpectingAlert("Save preferences?")
+    check("Save and notify group members" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && "Exit without saving" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))) { "the `Save preferences?` alert has no `Save and notify group members` / `Exit without saving`" }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "group preferences to close after `Exit without saving`") { !exists(Ui.GroupPrefs.MemberAdmission) && !seesText("Save preferences?") }
+    check(groupInfoOf("team").fullGroupPreferences.reactions.enable == GroupFeatureEnabled.ON) { "`Exit without saving` saved the reactions change" }
+    prefs = info.preferences()
+    poll(what = "reactions still allowed after `Exit without saving`") { seesText("Allow message reactions.") }
+    prefs.toggle(GroupFeature.Reactions)
+    poll(what = "reactions prohibited after the toggle") { seesText("Prohibit messages reactions.") && !seesText("Allow message reactions.") }
+    prefs.backExpectingAlert("Save preferences?")
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "group preferences to close with reactions saved off") {
+      !exists(Ui.GroupPrefs.MemberAdmission) && groupInfoOf("team").fullGroupPreferences.reactions.enable == GroupFeatureEnabled.OFF
+    }
+    info.close()
+    restart().chatList.open("team").groupInfo().preferences()
+    poll(what = "reactions prohibited after restart") { seesText("Prohibit messages reactions.") && !seesText("Allow message reactions.") }
+  }
+
+  @Test fun groupPrefs_ownerChangesNotifyAndRestrictMembers() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val link = bob.createOneTimeLink()
+    bob.eventually("and ask them to connect: /c <invitation_link_above>")
+    val file = bob.createFile("p.txt", "x")
+    val chat = ownGroup(alice, "team", bob)
+    chat.send("hi")
+    bob.expectsMessage("#team alice> hi", CONNECT_TIMEOUT_MS)
+    bob sends "+1 #team hi"
+    bob expects "added 👍"
+    val hi = chat.itemId("hi")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's 👍 on `hi`") { exists(Ui.Chat.ReactionChip(hi, "👍")) }
+    check(menuOffersReaction(hi, "👎")) { "the menu of `hi` offers no 👎 while reactions are allowed" }
+    var info = chat.groupInfo()
+    val p = info.preferences()
+    check(!exists(Ui.GroupPrefs.Ttl) && !exists(Ui.GroupPrefs.Role(GroupFeature.DirectMessages)) && exists(Ui.GroupPrefs.Role(GroupFeature.Voice))) { "`Delete after` / `Enabled for` rows do not match the default preferences" }
+    p.toggle(GroupFeature.TimedMessages)
+    poll(what = "`Delete after` shown with `1 day`") { exists(Ui.GroupPrefs.Ttl) && "1 day" in textsOf(Ui.GroupPrefs.Ttl) }
+    p.ttl(7 * 86400)
+    p.toggle(GroupFeature.DirectMessages)
+    poll(what = "`Enabled for` `all members` under `Direct messages`") {
+      exists(Ui.GroupPrefs.Role(GroupFeature.DirectMessages)) && "all members" in textsOf(Ui.GroupPrefs.Role(GroupFeature.DirectMessages))
+    }
+    p.role(GroupFeature.DirectMessages, GroupMemberRole.Owner)
+    p.toggle(GroupFeature.FullDelete)
+    p.toggle(GroupFeature.Reactions)
+    p.toggle(GroupFeature.Voice)
+    poll(what = "`Enabled for` hidden under voice messages turned off") { !exists(Ui.GroupPrefs.Role(GroupFeature.Voice)) }
+    p.role(GroupFeature.Files, GroupMemberRole.Admin)
+    p.role(GroupFeature.SimplexLinks, GroupMemberRole.Owner)
+    p.toggle(GroupFeature.History)
+    p.save()
+    bob.expectsMessage("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "updated group preferences:"
+    bob expects "Disappearing messages: on (1 week)"
+    bob expects "Direct messages: on for owners"
+    bob expects "Full deletion: on"
+    bob expects "Message reactions: off"
+    bob expects "Voice messages: off"
+    bob expects "Files and media: on for admins"
+    bob expects "SimpleX links: on for owners"
+    bob expects "Recent history: off"
+    poll(what = "the saved preferences in team's model") { groupInfoOf("team").fullGroupPreferences.history.enable == GroupFeatureEnabled.OFF }
+    p.backClosing()
+    info.close()
+    check(!menuOffersReaction(hi, "👎")) { "the menu of `hi` still offers 👎 with reactions prohibited" }
+    click(described("Record voice message"))
+    poll(what = "the `Voice messages prohibited!` alert") { seesText("Voice messages prohibited!") && seesText("Only group owners can enable voice messages.") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    bob sends "+^ #team hi"
+    bob expects "bad chat command: feature not allowed Message reactions"
+    bob sends "#team $link"
+    bob expects "bad chat command: feature not allowed SimpleX links"
+    bob sends "/f #team $file"
+    bob expects "bad chat command: feature not allowed Files and media"
+    chat.send(link)
+    bob.expectsMessage("#team alice> $link", CONNECT_TIMEOUT_MS)
+    hideKeyboard()
+    info = chat.groupInfo()
+    val p2 = info.preferences()
+    p2.toggle(GroupFeature.TimedMessages)
+    poll(what = "`Delete after` hidden with disappearing messages off") { !exists(Ui.GroupPrefs.Ttl) }
+    p2.toggle(GroupFeature.Reactions)
+    p2.save()
+    bob.expectsMessage("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "updated group preferences:"
+    bob expects "Disappearing messages: off"
+    bob expects "Message reactions: on"
+    poll(what = "reactions allowed again in team's model") { groupInfoOf("team").fullGroupPreferences.reactions.enable == GroupFeatureEnabled.ON }
+    p2.backClosing()
+    info.close()
+    check(menuOffersReaction(hi, "👎")) { "the menu of `hi` offers no 👎 after reactions were allowed again" }
+    bob sends "+^ #team hi"
+    bob expects "added 🚀"
+  }
+
+  @Test fun groupPrefs_directMessagesForOwnersOnly() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val info = emptyGroup(alice, "team").groupInfo()
+    val link = info.createLink()
+    bob sends "/c $link"
+    bob expects "connection request sent!"
+    bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob listed as connected in team's members") { "connected" in info.memberTexts("bob") }
+    quiesce()
+    info.member("bob").message()
+    poll(what = "the `Can't message group member` alert") { seesText("Can't message group member") && seesText("Direct messages between members are prohibited in this group.") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    goBack()
+    poll(what = "member info to close to group info") { !exists(Ui.MemberInfo.Message) && exists(Ui.GroupInfo.Preferences) }
+    bob sends "@alice hi"
+    bob expects "bad chat command: direct messages not allowed"
+    val p = info.preferences()
+    check(!exists(Ui.GroupPrefs.Role(GroupFeature.DirectMessages))) { "`Enabled for` shown under `Direct messages` while they are off" }
+    p.toggle(GroupFeature.DirectMessages)
+    poll(what = "`Enabled for` `all members` under `Direct messages`") {
+      exists(Ui.GroupPrefs.Role(GroupFeature.DirectMessages)) && "all members" in textsOf(Ui.GroupPrefs.Role(GroupFeature.DirectMessages))
+    }
+    p.role(GroupFeature.DirectMessages, GroupMemberRole.Owner)
+    p.save()
+    bob.expectsMessage("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "updated group preferences:"
+    bob expects "Direct messages: on for owners"
+    poll(what = "direct messages for owners saved in team's model") { groupInfoOf("team").fullGroupPreferences.directMessages.role == GroupMemberRole.Owner }
+    p.backClosing()
+    bob sends "@alice hi"
+    bob expects "bad chat command: direct messages not allowed"
+    info.member("bob").message()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "a direct chat with bob opened instead of the alert") {
+      (chatModel.chats.value.firstOrNull { it.id == chatModel.chatId.value }?.chatInfo as? ChatInfo.Direct)?.contact?.displayName == "bob" && !seesText("Can't message group member")
+    }
+  }
+
+  @Test fun groupPrefs_readOnlyForMember() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val link = bob.createOneTimeLink()
+    bob.eventually("and ask them to connect: /c <invitation_link_above>")
+    hostGroup(bob, "team", "alice")
+    joinGroupFromList(alice, bob, "team")
+    val chat = alice.chatList.open("team")
+    var info = chat.groupInfo()
+    var p = info.preferences()
+    check(!exists(Ui.GroupPrefs.Toggle(GroupFeature.Voice)) && !seesText("Save and notify group members") && !seesText("Reset")) { "a member's group preferences offer toggles, `Reset` or `Save and notify group members`" }
+    check(seesText("Members can send voice messages.") && seesText("Members can send SimpleX links.") && !seesText("admins")) { "a member's group preferences do not show the host's defaults" }
+    p.admission()
+    check(!exists(Ui.MemberAdmission.Review) && seesText("off") && !seesText("all")) { "a member's `Review members` is editable or not `off`" }
+    bob sends "/set admission review #team all"
+    bob expects "changed member admission rules"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice's read-only `Review members` to show `all`") { seesText("all") && !seesText("off") }
+    goBack()
+    poll(what = "member admission to close to group preferences") { !seesText("Review members before admitting (\"knocking\").") && exists(Ui.GroupPrefs.MemberAdmission) }
+    p.backClosing()
+    info.close()
+    bob sends "#team before voice"
+    chat.itemId("before voice")
+    bob sends "/set voice #team on admin"
+    bob expects "updated group preferences:"
+    bob expects "Voice messages: on for admins"
+    val ev = chat.itemId("Voice messages: on (admins)")
+    check(textsOf(Ui.Chat.Item(ev)).any { "Voice messages: on (admins)" in it }) { "the `Voice messages: on (admins)` item is not shown" }
+    click(described("Record voice message"))
+    poll(what = "the `Voice messages prohibited!` alert") { seesText("Voice messages prohibited!") && seesText("Only group owners can enable voice messages.") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    info = chat.groupInfo()
+    p = info.preferences()
+    poll(what = "voice messages enabled for admins in alice's read-only preferences") { seesText("Members can send voice messages.") && seesText("Enabled for") && seesText("admins") }
+    p.backClosing()
+    info.close()
+    bob sends "/set links #team on owner"
+    bob expects "updated group preferences:"
+    bob expects "SimpleX links: on for owners"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "SimpleX links prohibited for alice in team's model") { !groupInfoOf("team").groupFeatureEnabled(GroupFeature.SimplexLinks) }
+    typeInto(Ui.Chat.Message, link)
+    poll(what = "`SimpleX links not allowed` with the send button disabled") { seesText("SimpleX links not allowed") && exists(Ui.Chat.Send) && !isEnabled(Ui.Chat.Send) }
+    bob sends "/set links #team on"
+    bob expects "updated group preferences:"
+    bob expects "SimpleX links: on"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`SimpleX links not allowed` gone with the send button enabled") { !seesText("SimpleX links not allowed") && isEnabled(Ui.Chat.Send) }
+    pressEnter(Ui.Chat.Message)
+    poll(what = "the message field to clear after one Enter") { editableText(Ui.Chat.Message).isNullOrEmpty() }
+    bob.expectsMessage("#team alice> $link", CONNECT_TIMEOUT_MS)
+    hideKeyboard()
+    info = chat.groupInfo()
+    poll(what = "`Chat with admins` shown and `Chats with members` hidden for a member") { seesText("Chat with admins") && !exists(Ui.GroupInfo.MemberSupport) }
+    info.close()
+    bob sends "/mr #team alice moderator"
+    bob.eventuallyMatching(Regex("#team: you changed the role of alice to moderator( \\(signed\\))?"))
+    info = chat.groupInfo()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Chats with members` shown and `Chat with admins` hidden for a moderator") { exists(Ui.GroupInfo.MemberSupport) && !seesText("Chat with admins") }
+    info.chatsWithMembers().empty()
+  }
+
+  @KnownAppIssue("15.5 item 8", "the unsaved `Message reactions` change was discarded when bob's message arrived")
+  @Test fun groupPrefs_unsavedEditsKeptWhenMessageArrives() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = ownGroup(alice, "team", bob)
+    val p = chat.groupInfo().preferences()
+    poll(what = "reactions allowed before the change") { seesText("Allow message reactions.") }
+    p.toggle(GroupFeature.Reactions)
+    poll(what = "reactions prohibited after the toggle") { seesText("Prohibit messages reactions.") }
+    bob sends "#team hello"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `hello` in team's chat") { chatModel.chatsContext.chatItems.value.any { it.content.text == "hello" } }
+    settle()
+    check(seesText("Prohibit messages reactions.")) { "the unsaved `Message reactions` change was discarded when bob's message arrived" }
+    p.save()
+    bob.expectsMessage("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "updated group preferences:"
+    bob expects "Message reactions: off"
+  }
+
+  @Ignore("commented-out code (\"Sign messages\", GroupPreferences.kt:219-221; plan §11.3)")
+  @Test fun groupPrefs_signMessages() {}
+
+  private fun UiScope.menuOffersReaction(id: Long, emoji: String): Boolean {
+    rightClick(Ui.Chat.Item(id))
+    waitFor(Ui.Chat.ItemMenu(id, "reply"))
+    val offered = exists(Ui.Chat.ItemReaction(id, emoji))
+    click(Ui.Chat.ItemMenu(id, "select"))
+    waitFor(Ui.Chat.Selection.part("title"))
+    escape()
+    poll(what = "selection mode to end") { !exists(Ui.Chat.Selection.part("title")) }
+    return offered
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupProfileTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupProfileTest.kt
new file mode 100644
index 0000000000..7cef575f59
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/GroupProfileTest.kt
@@ -0,0 +1,120 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.editGroupProfile
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.hostGroupWithWelcome
+import chat.simplex.app.ui.harness.inviteMembers
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.app.ui.harness.welcomeMessage
+import chat.simplex.app.ui.harness.welcomeRowText
+import chat.simplex.common.model.CIDirection
+import chat.simplex.common.model.ChatItem
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+private const val WELCOME = "Welcome to the team!"
+
+class GroupProfileTest : UiTest() {
+  @Test fun editGroupProfile_renameNotifiesMembers() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    ownGroup(alice, "team", bob).groupInfo()
+    var p = editGroupProfile()
+    poll(what = "the profile editor showing `team` with no short description") { p.name() == "team" && p.shortDescr().isNullOrEmpty() }
+    p.rename("my_team")
+    p.save()
+    bob.expectsMessage("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "changed to #my_team"
+    poll(what = "team renamed to `my_team` in group info") {
+      chatModel.chats.value.any { it.chatInfo.chatViewName == "my_team" } && seesText("my_team")
+    }
+    p = editGroupProfile()
+    poll(what = "the profile editor showing `my_team`") { p.name() == "my_team" && p.shortDescr().isNullOrEmpty() }
+    p.describe("Our team")
+    p.save()
+    bob.expectsMessage("alice updated group #my_team: (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "description changed to: Our team"
+    poll(what = "`Our team` shown in group info and saved") { seesText("Our team", substring = true) && groupInfoOf("my_team").groupProfile.shortDescr == "Our team" }
+  }
+
+  @Test fun welcomeMessage_addNotifiesMembers() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    ownGroup(alice, "team", bob).groupInfo()
+    poll(what = "`Add welcome message` in team's info") { "Add welcome message" in welcomeRowText() }
+    var w = welcomeMessage()
+    poll(what = "an empty welcome message editor") { w.text().isEmpty() }
+    w.type(WELCOME)
+    w.save()
+    bob.expectsMessage("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "welcome message changed to:"
+    bob expects WELCOME
+    poll(what = "the welcome message saved for team") { groupInfoOf("team").groupProfile.description == WELCOME }
+    w.close()
+    poll(what = "`Welcome message` in team's info after saving") { welcomeRowText().let { "Welcome message" in it && "Add welcome message" !in it } }
+    w = welcomeMessage()
+    poll(what = "the editor holding the saved welcome message") { w.text() == WELCOME }
+    w.replace("")
+    w.save()
+    bob.expectsMessage("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "welcome message removed"
+    poll(what = "the welcome message removed from team") { groupInfoOf("team").groupProfile.description == null }
+    w.close()
+    poll(what = "`Add welcome message` back in team's info") { "Add welcome message" in welcomeRowText() }
+  }
+
+  @Test fun welcomeMessage_newMemberReceivesItFirst() = uiTest {
+    val alice = app("alice"); val cath = cli("cath")
+    connect(cath)
+    emptyGroup(alice, "team").groupInfo()
+    val w = welcomeMessage()
+    w.type(WELCOME)
+    w.save()
+    poll(what = "the welcome message saved for team") { groupInfoOf("team").groupProfile.description == WELCOME }
+    w.close()
+    val inv = inviteMembers()
+    poll(what = "cath offered") { inv.listed("cath") }
+    inv.toggle("cath")
+    inv.invite()
+    cath.expectsMessage("#team: alice invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    cath expects "use /j team to accept"
+    cath sends "/j team"
+    cath.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    cath.expectsMessage("#team alice> $WELCOME", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun welcomeMessage_receivedAsFirstItem() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    hostGroupWithWelcome(bob, "team", WELCOME, "alice")
+    joinGroupFromList(alice, bob, "team")
+    backToChatList()
+    val chat = alice.chatList.open("team")
+    val welcome = chat.itemId("bob's welcome message in team") { it.content.text == WELCOME && it.isFrom("bob") }
+    bob sends "#team after welcome"
+    val after = chat.itemId("bob's `after welcome` in team") { it.content.text == "after welcome" && it.isFrom("bob") }
+    val items = chatModel.chatsContext.chatItems.value
+    val messages = items.filter { it.content.msgContent != null }.map { it.id }
+    check(messages.firstOrNull() == welcome && messages.indexOf(after) > messages.indexOf(welcome)) {
+      "bob's welcome message is not the first message in team, before `after welcome`: ${items.map { it.content.text }}"
+    }
+    chat.groupInfo()
+    poll(what = "`Welcome message` and no `Edit group profile` in a member's group info") {
+      welcomeRowText().let { "Welcome message" in it && "Add welcome message" !in it } && !exists(Ui.GroupInfo.EditProfile)
+    }
+    welcomeMessage()
+    poll(what = "bob's welcome message shown read-only with `Copy`, without the editor or `Save and update group profile`") {
+      textsOf(Ui.Welcome.Preview).any { WELCOME in it } && seesText("Copy") && !exists(Ui.Welcome.Text) && !exists(Ui.Welcome.Save)
+    }
+  }
+
+  private fun ChatItem.isFrom(name: String) =
+    (chatDir as? CIDirection.GroupRcv)?.groupMember?.memberProfile?.displayName == name
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/InviteMembersCompatTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/InviteMembersCompatTest.kt
new file mode 100644
index 0000000000..9ba6d55cdd
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/InviteMembersCompatTest.kt
@@ -0,0 +1,32 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.inviteMembers
+import chat.simplex.common.model.GroupMemberRole
+import org.junit.Test
+
+class InviteMembersCompatTest : UiTest() {
+  @Test fun inviteMembers_asObserver() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val info = emptyGroup(alice, "team").groupInfo()
+    val inv = inviteMembers()
+    poll(what = "bob offered with `New member role` set to `member`") { inv.listed("bob") && "member" in inv.roleTexts() }
+    inv.role(GroupMemberRole.Observer)
+    poll(what = "`New member role` set to `observer`") { "observer" in inv.roleTexts() && "member" !in inv.roleTexts() }
+    inv.toggle("bob")
+    inv.invite()
+    bob.expectsMessage("#team: alice invites you to join the group as observer", CONNECT_TIMEOUT_MS)
+    bob expects "use /j team to accept"
+    bob sends "/j team"
+    bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob listed in team's members as a connected observer") {
+      info.memberTexts("bob").let { "observer" in it && "connected" in it }
+    }
+    bob sends "#team hi"
+    bob expects "#team: you don't have permission to send messages"
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/InviteMembersTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/InviteMembersTest.kt
new file mode 100644
index 0000000000..23903812a1
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/InviteMembersTest.kt
@@ -0,0 +1,107 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.connectIncognito
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.inviteMembers
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.common.model.CIContent
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class InviteMembersTest : UiTest() {
+  @Test fun inviteMembers_listsOnlyEligibleContacts() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath"); val dan = cli("dan")
+    connect(bob)
+    connect(cath)
+    val incognito = connectIncognito(dan)
+    val info = ownGroup(alice, "team", bob).groupInfo()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob a connected member of team") { "connected" in info.memberTexts("bob") }
+    val inv = inviteMembers()
+    poll(what = "cath and the incognito contact dan offered, the member bob not offered, nothing selected") {
+      inv.listed("cath") && inv.listed("dan") && !inv.listed("bob") && seesText("No contacts selected")
+    }
+    inv.toggle("dan")
+    poll(what = "the `Can't invite contact!` alert") {
+      seesText("Can't invite contact!") &&
+        seesText("You're trying to invite contact with whom you've shared an incognito profile to the group in which you're using your main profile")
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the alert closed with dan not selected") { !seesText("Can't invite contact!") && seesText("No contacts selected") }
+    inv.toggle("cath")
+    poll(what = "cath selected") { seesText("1 contact(s) selected") }
+    inv.invite()
+    cath.expectsMessage("#team: alice invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    cath expects "use /j team to accept"
+    info.close()
+    backToChatList()
+    alice.chatList.open("dan").send("hi dan")
+    dan.expectsMessage("$incognito> hi dan", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun inviteMembers_reAddInvitedMember() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val info = emptyGroup(alice, "team").groupInfo()
+    val first = inviteMembers()
+    poll(what = "bob offered") { first.listed("bob") }
+    first.toggle("bob")
+    first.invite()
+    bob.expectsMessage("#team: alice invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    bob expects "use /j team to accept"
+    poll(what = "bob listed as invited in team's members") { "invited" in info.memberTexts("bob") }
+    val again = inviteMembers()
+    poll(what = "the invited bob still offered, nothing selected") { again.listed("bob") && seesText("No contacts selected") }
+    again.toggle("bob")
+    again.invite()
+    bob.expectsMessage("#team: alice invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    bob expects "use /j team to accept"
+  }
+
+  @Test fun inviteMembers_selectionCounterAndClear() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob)
+    connect(cath)
+    val info = emptyGroup(alice, "team").groupInfo()
+    val inv = inviteMembers()
+    poll(what = "bob and cath offered with nothing selected and no `Clear`") {
+      inv.listed("bob") && inv.listed("cath") && seesText("No contacts selected") && !exists(Ui.InviteMembers.Clear)
+    }
+    typeInto(Ui.InviteMembers.Search, "CA")
+    poll(what = "only cath offered for `CA`") { inv.listed("cath") && !inv.listed("bob") }
+    hideKeyboard()
+    inv.toggle("cath")
+    poll(what = "`1 contact(s) selected` with `Clear`") { seesText("1 contact(s) selected") && exists(Ui.InviteMembers.Clear) }
+    replaceText(Ui.InviteMembers.Search, "")
+    poll(what = "bob offered again with cath still selected") { inv.listed("bob") && inv.listed("cath") && seesText("1 contact(s) selected") }
+    hideKeyboard()
+    inv.toggle("bob")
+    poll(what = "`2 contact(s) selected` with `Clear`") { seesText("2 contact(s) selected") && "Clear" in textsOf(Ui.InviteMembers.Clear) }
+    click(Ui.InviteMembers.Clear)
+    poll(what = "`No contacts selected` without `Clear` after clearing") {
+      seesText("No contacts selected") && !seesText("2 contact(s) selected") && !exists(Ui.InviteMembers.Clear)
+    }
+    inv.toggle("cath")
+    poll(what = "only cath selected") { seesText("1 contact(s) selected") }
+    inv.invite()
+    cath.expectsMessage("#team: alice invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    cath expects "use /j team to accept"
+    info.close()
+    backToChatList()
+    val cathChat = alice.chatList.open("cath")
+    val sent = cathChat.itemId("the sent invitation to team in cath's chat") {
+      (it.content as? CIContent.SndGroupInvitation)?.groupInvitation?.groupProfile?.displayName == "team"
+    }
+    poll(what = "`You sent group invitation` in cath's chat") { textsOf(Ui.Chat.Item(sent)).any { "You sent group invitation" in it } }
+    backToChatList()
+    val bobChat = alice.chatList.open("bob")
+    bobChat.send("not invited")
+    bob.expectsMessage("alice> not invited", CONNECT_TIMEOUT_MS)
+    bobChat.itemId("not invited")
+    check(chatModel.chatsContext.chatItems.value.none { it.content is CIContent.SndGroupInvitation }) { "bob's chat shows a group invitation sent to him" }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/JoiningCompatTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/JoiningCompatTest.kt
index d531e34da6..3e7e2e15f3 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/JoiningCompatTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/JoiningCompatTest.kt
@@ -3,7 +3,9 @@ package chat.simplex.app.ui.groups
 import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
 import chat.simplex.app.ui.harness.UiTest
 import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.groupInfoOf
 import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.common.model.CIContent
 import chat.simplex.common.model.ChatInfo
 import chat.simplex.common.model.GroupMemberStatus
 import chat.simplex.common.ui.Ui
@@ -25,4 +27,25 @@ class JoiningCompatTest : UiTest() {
     bob.eventually("#team: alice joined the group", CONNECT_TIMEOUT_MS)
     poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "membership of #team to be connected") { membership() == GroupMemberStatus.MemConnected }
   }
+
+  @Test fun groupInvitation_tapToJoin() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    hostGroup(bob, "team", "alice")
+    alice.chatList.row("team")
+    poll(what = "alice invited to #team") { groupInfoOf("team").membership.memberStatus == GroupMemberStatus.MemInvited }
+    val chat = alice.chatList.open("bob")
+    val inv = chat.itemId("bob's invitation to team in his direct chat") {
+      (it.content as? CIContent.RcvGroupInvitation)?.groupInvitation?.groupProfile?.displayName == "team"
+    }
+    poll(what = "`You are invited to group` with `Tap to join` on the invitation") {
+      textsOf(Ui.Chat.Item(inv)).let { t -> "You are invited to group" in t && t.any { "Tap to join" in it } }
+    }
+    click(Ui.Chat.Item(inv).part("join"))
+    bob.eventually("#team: alice joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice connected to #team and the invitation reading `You joined this group`") {
+      groupInfoOf("team").membership.memberStatus == GroupMemberStatus.MemConnected &&
+        textsOf(Ui.Chat.Item(inv)).let { t -> t.any { "You joined this group" in it } && t.none { "Tap to join" in it } }
+    }
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/JoiningTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/JoiningTest.kt
new file mode 100644
index 0000000000..bbe9941a2d
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/JoiningTest.kt
@@ -0,0 +1,265 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.PeerFlags
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.connectionRequestSentToGroup
+import chat.simplex.app.ui.harness.createFullGroupLink
+import chat.simplex.app.ui.harness.createGroupLink
+import chat.simplex.app.ui.harness.createShortAndFullGroupLink
+import chat.simplex.app.ui.harness.createWelcomeGroupLink
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.enterLinkInNewChatSearch
+import chat.simplex.app.ui.harness.enterLinkInSearch
+import chat.simplex.app.ui.harness.groupChatIds
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.openChatById
+import chat.simplex.app.ui.harness.openPreparedGroupFromSearch
+import chat.simplex.app.ui.harness.pendingConnectionIds
+import chat.simplex.app.ui.harness.planConfirm
+import chat.simplex.app.ui.harness.planOption
+import chat.simplex.app.ui.harness.switchAwayFromChat
+import chat.simplex.common.model.CIDirection
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.GroupMemberStatus
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Test
+
+class JoiningTest : UiTest() {
+  @Test fun joinGroup_pasteShortLinkPrepareAndJoin() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val link = bob.createWelcomeGroupLink("team", "Welcome!")
+    bob.eventually("to delete it: /delete link #team (joined members will remain connected to you)")
+    alice.chatList.row("Private notes")
+    check(groupChatIds("team").isEmpty()) { "a group named team exists before the link is opened" }
+    val chat = openPreparedGroupFromSearch(link, "team")
+    val teamId = chatModel.chatId.value!!
+    chat.itemId("Welcome!")
+    poll(what = "the banner `Tap Join group` and a `Join group` button with no message field") {
+      seesText("Tap Join group") && exists(Ui.Chat.Connect) && "Join group" in textsOf(Ui.Chat.Connect) && !exists(Ui.Chat.Message)
+    }
+    click(Ui.Chat.Connect)
+    bob.eventually("alice: accepting request to join group #team...", CONNECT_TIMEOUT_MS)
+    bob.eventually("#team: alice joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the message field in place of `Join group` with alice connected") {
+      exists(Ui.Chat.Message) && !exists(Ui.Chat.Connect) && !seesText("Tap Join group") &&
+        groupInfoOf("team").membership.memberStatus == GroupMemberStatus.MemConnected
+    }
+    chat.send("hi team")
+    bob.eventuallyMessage("#team alice> hi team", CONNECT_TIMEOUT_MS)
+    switchAwayFromChat(alice)
+    check(chatModel.chatId.value != teamId) { "team is still the open chat before the link is pasted again" }
+    enterLinkInNewChatSearch(alice, link)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the known-group alert for team saying `You are a member` with `Open group`") {
+      exists(planConfirm) && "Open group" in textsOf(planConfirm) && seesText("team") && seesText("You are a member")
+    }
+    click(planConfirm)
+    poll(what = "the New chat sheet closed with team's chat open and still one group named team") {
+      !exists(planConfirm) && !exists(Ui.NewChat.Search) && chatModel.chatId.value == teamId && groupChatIds("team") == listOf(teamId)
+    }
+  }
+
+  @Test fun joinGroup_preparedJoinIncognito() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val link = bob.createGroupLink("team")
+    bob.eventually("to delete it: /delete link #team (joined members will remain connected to you)")
+    val aliceId = chatModel.currentUser.value!!.userId
+    alice.chatList.row("Private notes")
+    val chat = openPreparedGroupFromSearch(link, "team")
+    poll(what = "`Your profile` with alice selected and no `Incognito` option") {
+      seesText("Your profile") && exists(Ui.Chat.PickerUser(aliceId)) && !exists(Ui.Chat.PickerIncognito)
+    }
+    click(Ui.Chat.PickerUser(aliceId))
+    poll(what = "the profile list with `Incognito`") { exists(Ui.Chat.PickerIncognito) }
+    click(Ui.Chat.PickerIncognito)
+    poll(what = "the list collapsed to `Incognito`") { exists(Ui.Chat.PickerIncognito) && !exists(Ui.Chat.PickerUser(aliceId)) }
+    click(Ui.Chat.Connect)
+    val incognito = bob.eventuallyMatching(Regex("(\\S+): accepting request to join group #team\\.\\.\\."), CONNECT_TIMEOUT_MS).groupValues[1]
+    assertNotEquals("alice", incognito)
+    bob.eventually("#team: $incognito joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice connected to team with an incognito membership") {
+      groupInfoOf("team").membership.let { it.memberStatus == GroupMemberStatus.MemConnected && it.memberIncognito } && exists(Ui.Chat.Message)
+    }
+    val info = chat.groupInfo()
+    poll(what = "alice's own member row named `$incognito`, not `alice`") {
+      info.ownMemberTexts().let { incognito in it && "alice" !in it }
+    }
+  }
+
+  @Test fun joinGroup_fullLinkCurrentProfile() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(fullLinks = true))
+    val full = bob.createFullGroupLink("team")
+    alice.chatList.row("Private notes")
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Join group?` alert for the full group link") {
+      seesText("Join group?") && seesText("You will connect to all group members.", substring = true) &&
+        exists(planOption("useCurrentProfile")) && exists(planOption("useIncognito")) && exists(planOption("cancel"))
+    }
+    click(planOption("cancel"))
+    poll(what = "the alert to close and the search to clear") {
+      !seesText("Join group?") && editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search)
+    }
+    check(pendingConnectionIds().isEmpty() && chatModel.chats.value.none { it.chatInfo is ChatInfo.Group }) { "Cancel created a pending connection or a group" }
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Join group?` alert again") { seesText("Join group?") }
+    click(planOption("useCurrentProfile"))
+    connectionRequestSentToGroup()
+    assertEquals("alice: accepting request to join group #team...", bob.nextLine(CONNECT_TIMEOUT_MS))
+    bob.eventually("#team: alice joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice connected to team with no pending connection left") {
+      groupChatIds("team").size == 1 && groupInfoOf("team").membership.memberStatus == GroupMemberStatus.MemConnected && pendingConnectionIds().isEmpty()
+    }
+    backToChatList()
+    alice.chatList.open("team").send("joined via the full link")
+    bob.eventuallyMessage("#team alice> joined via the full link", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun connectPlan_ownGroupLinkJoinAsSecondMember() = uiTest {
+    val alice = app("alice")
+    val info = emptyGroup(alice, "team").groupInfo()
+    val link = info.createLink()
+    info.close()
+    val teamId = alice.chatList.chatId("team")
+    switchAwayFromChat(alice)
+    check(chatModel.chatId.value != teamId) { "team is still the open chat before its link is pasted" }
+    enterLinkInNewChatSearch(alice, link)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Join your group?` alert with `Open group` and `Use current profile`") {
+      seesText("Join your group?") && seesText("This is your link for group", substring = true) &&
+        exists(planOption("openGroup")) && exists(planOption("useCurrentProfile"))
+    }
+    click(planOption("openGroup"))
+    poll(what = "the alert and the New chat sheet to close with team's chat open") {
+      !seesText("Join your group?") && !exists(Ui.NewChat.Search) && chatModel.chatId.value == teamId
+    }
+    check(groupChatIds("team") == listOf(teamId)) { "`Open group` created another group named team" }
+    backToChatList()
+    enterLinkInNewChatSearch(alice, link)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Join your group?` alert again") { seesText("Join your group?") && exists(planOption("useCurrentProfile")) }
+    click(planOption("useCurrentProfile"))
+    connectionRequestSentToGroup()
+    var secondId: String? = null
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "a second group named team, listed, with alice connected as herself") {
+      secondId = groupChatIds("team").singleOrNull { it != teamId }
+      val second = chatModel.chats.value.firstOrNull { it.id == secondId }?.chatInfo as? ChatInfo.Group
+      second != null && second.groupInfo.membership.memberStatus == GroupMemberStatus.MemConnected && !second.groupInfo.membership.memberIncognito &&
+        exists(Ui.ChatList.Row(secondId!!))
+    }
+    backToChatList()
+    openChatById(teamId).send("to my other self")
+    backToChatList()
+    openChatById(secondId!!).itemId("`to my other self` received in the second team") { it.content.text == "to my other self" && it.chatDir is CIDirection.GroupRcv }
+  }
+
+  @Test fun connectPlan_connectingAllowsReconnect() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(fullLinks = true))
+    val full = bob.createFullGroupLink("team")
+    bob.stop()
+    alice.chatList.row("Private notes")
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Join group?` alert for the full group link") { seesText("Join group?") && exists(planOption("useCurrentProfile")) }
+    click(planOption("useCurrentProfile"))
+    connectionRequestSentToGroup()
+    poll(what = "one pending connection") { pendingConnectionIds().size == 1 }
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Repeat join request?` with both profile options while bob is offline") {
+      seesText("Repeat join request?") && seesText("You are already joining the group via this link.", substring = true) &&
+        exists(planOption("useCurrentProfile")) && exists(planOption("useIncognito")) && !seesText("Join group?")
+    }
+    click(planOption("cancel"))
+    poll(what = "the alert to close with still one pending connection") {
+      !seesText("Repeat join request?") && editableText(Ui.ChatList.Search).isNullOrEmpty() && pendingConnectionIds().size == 1
+    }
+    bob.start()
+    bob.eventually("alice: accepting request to join group #team...", CONNECT_TIMEOUT_MS)
+    bob.eventually("#team: alice joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "one group team with alice connected and no pending connection") {
+      groupChatIds("team").size == 1 && groupInfoOf("team").membership.memberStatus == GroupMemberStatus.MemConnected && pendingConnectionIds().isEmpty()
+    }
+  }
+
+  @Test fun groupInvitation_deleteInvitation() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    hostGroup(bob, "team", "alice")
+    hostGroup(bob, "club", "alice")
+    alice.chatList.row("team")
+    alice.chatList.row("club")
+    poll(what = "alice invited to team and club") {
+      listOf("team", "club").all { groupInfoOf(it).membership.memberStatus == GroupMemberStatus.MemInvited }
+    }
+    alice.chatList.rowMenu("team", "delete")
+    poll(what = "the `Delete group?` alert for team saying it is deleted only for alice, with `Delete`") {
+      seesText("Delete group?") && seesText("team\n\nGroup will be deleted for you - this cannot be undone!") &&
+        "Delete" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    alice.chatList.gone("team")
+    check(alice.chatList.shown("club") && groupInfoOf("club").membership.memberStatus == GroupMemberStatus.MemInvited) { "deleting team's invitation removed or changed club's" }
+    alice.chatList.rowMenu("club", "join", "Join")
+    assertEquals("#club: alice joined the group", bob.nextLine(CONNECT_TIMEOUT_MS))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice connected to club") { groupInfoOf("club").membership.memberStatus == GroupMemberStatus.MemConnected }
+  }
+
+  @Test fun joinGroup_fullLinkIncognito() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(fullLinks = true))
+    val full = bob.createFullGroupLink("team")
+    alice.chatList.row("Private notes")
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Join group?` alert with `Use new incognito profile`") {
+      seesText("Join group?") && exists(planOption("useIncognito")) && exists(planOption("useCurrentProfile"))
+    }
+    click(planOption("useIncognito"))
+    connectionRequestSentToGroup()
+    val incognito = bob.eventuallyMatching(Regex("(\\S+): accepting request to join group #team\\.\\.\\."), CONNECT_TIMEOUT_MS).groupValues[1]
+    assertNotEquals("alice", incognito)
+    bob.eventually("#team: $incognito joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice connected to team with the incognito profile `$incognito`") {
+      groupChatIds("team").size == 1 && groupInfoOf("team").membership.let {
+        it.memberStatus == GroupMemberStatus.MemConnected && it.memberIncognito && it.memberProfile.displayName == incognito
+      }
+    }
+    backToChatList()
+    alice.chatList.open("team").send("hi from incognito")
+    bob.eventuallyMessage("#team $incognito> hi from incognito", CONNECT_TIMEOUT_MS)
+  }
+
+  @KnownAppIssue("15.5 item 20", "the `Group already exists!` alert for the group being joined")
+  @Test fun connectPlan_connectingProhibit() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(fullLinks = true))
+    val (short, full) = bob.createShortAndFullGroupLink("team")
+    bob.stop()
+    alice.chatList.row("Private notes")
+    openPreparedGroupFromSearch(short, "team")
+    val teamId = chatModel.chatId.value!!
+    poll(what = "`Join group` in the prepared group") { exists(Ui.Chat.Connect) && "Join group" in textsOf(Ui.Chat.Connect) }
+    click(Ui.Chat.Connect)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the join request sent while bob is offline, with alice not yet connected") {
+      groupInfoOf("team").let { !it.nextConnectPrepared && it.membership.memberStatus != GroupMemberStatus.MemConnected }
+    }
+    switchAwayFromChat(alice)
+    check(chatModel.chatId.value != teamId) { "team is still the open chat before the full link is pasted" }
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Group already exists!` alert for the group being joined") {
+      seesText("Group already exists!") && seesText("You are already joining the group", substring = true) && exists(planConfirm) &&
+        !seesText("Join group?") && !seesText("Repeat join request?")
+    }
+    click(planConfirm)
+    poll(what = "the alert closed with still one team and no pending connection") {
+      !seesText("Group already exists!") && editableText(Ui.ChatList.Search).isNullOrEmpty() && groupChatIds("team") == listOf(teamId) &&
+        pendingConnectionIds().isEmpty()
+    }
+    bob.start()
+    bob.eventually("alice: accepting request to join group #team...", CONNECT_TIMEOUT_MS)
+    bob.eventually("#team: alice joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice connected to the one team") {
+      groupChatIds("team") == listOf(teamId) && groupInfoOf("team").membership.memberStatus == GroupMemberStatus.MemConnected
+    }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/LeaveDeleteClearTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/LeaveDeleteClearTest.kt
new file mode 100644
index 0000000000..701e6c3e4b
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/LeaveDeleteClearTest.kt
@@ -0,0 +1,110 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.App
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
+import chat.simplex.app.ui.harness.CliPeer
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.clearChatFromInfo
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.deleteGroupFromInfo
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.app.ui.harness.leaveGroupFromInfo
+import chat.simplex.app.ui.harness.offersOnlyDelete
+import chat.simplex.app.ui.harness.offersOnlyLeave
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.ModalManager
+import org.junit.Test
+
+class LeaveDeleteClearTest : UiTest() {
+  @KnownAppIssue("15.5 item 14", "a list to scroll to groupInfo.delete", intermittent = true)
+  @Test fun leaveGroup_thenDeleteLocalCopy() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val chat = memberOfBobsTeam(alice, bob)
+    chat.groupInfo()
+    check(offersOnlyLeave()) { "a current member's group info does not offer only `Leave group`" }
+    leaveGroupFromInfo("team")
+    bob.eventually("#team: alice left the group (signed)", CONNECT_TIMEOUT_MS)
+    poll(what = "`you left` in team's compose field") { seesText("you left") }
+    chat.groupInfo()
+    check(offersOnlyDelete()) { "group info after leaving does not offer only `Delete group`" }
+    deleteGroupFromInfo("team", "Group will be deleted for you - this cannot be undone!")
+    alice.chatList.gone("team")
+    alice.chatList.open("bob").send("after delete")
+    bob.expectsMessage("alice> after delete", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun deleteGroup_ownerDeletesForAll() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    ownGroup(alice, "team", bob).groupInfo()
+    deleteGroupFromInfo("team", "Group will be deleted for all members - this cannot be undone!")
+    bob.expectsMessage("#team: alice deleted the group (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "use /d #team to delete the local copy of the group"
+    alice.chatList.gone("team")
+  }
+
+  @Test fun deleteGroup_memberSeesGroupDeleted() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val chat = memberOfBobsTeam(alice, bob)
+    bob sends "/d #team"
+    bob.eventuallyMatching(Regex("#team: you deleted the group( \\(signed\\))?"))
+    chat.itemId("bob's `deleted group` event in team") { it.content.text == "deleted group" }
+    poll(what = "`group is deleted` in team's compose field") { seesText("group is deleted") }
+    chat.groupInfo()
+    check(offersOnlyDelete()) { "group info of a deleted group does not offer only `Delete group`" }
+  }
+
+  @Test fun clearChat_removesLocalItemsOnly() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = ownGroup(alice, "team", bob)
+    chat.send("hello")
+    bob.expectsMessage("#team alice> hello", CONNECT_TIMEOUT_MS)
+    bob sends "#team hi there"
+    val hello = chat.itemId("hello")
+    val hi = chat.itemId("bob's `hi there` in team") { it.content.text == "hi there" }
+    hideKeyboard()
+    chat.groupInfo()
+    clearChatFromInfo("team")
+    poll(what = "group info closed with `hello` and `hi there` gone from team's chat") {
+      !ModalManager.end.hasModalsOpen() && !exists(Ui.Chat.Item(hello)) && !exists(Ui.Chat.Item(hi)) &&
+        chatModel.chatsContext.chatItems.value.none { it.content.text == "hello" || it.content.text == "hi there" }
+    }
+    check((alice.chatList.chat("team").chatInfo as ChatInfo.Group).groupInfo.membership.memberCurrent) { "alice is no longer a current member of team after clearing its chat" }
+    bob sends "#team after clear"
+    chat.itemId("bob's `after clear` in team") { it.content.text == "after clear" }
+    chat.send("still here")
+    bob.expectsMessage("#team alice> still here", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun removedFromGroup_composeDisabled() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val chat = memberOfBobsTeam(alice, bob)
+    bob sends "/rm team alice"
+    bob.eventuallyMatching(Regex("#team: you removed alice from the group( \\(signed\\))?"))
+    chat.itemId("bob's `removed you` event in team") { it.content.text == "removed you" }
+    poll(what = "`removed from group` in team's compose field") { seesText("removed from group") }
+    chat.groupInfo()
+    check(offersOnlyDelete()) { "group info after removal does not offer only `Delete group`" }
+  }
+
+  private fun UiScope.memberOfBobsTeam(alice: App, bob: CliPeer): ChatScreen {
+    connect(bob)
+    hostGroup(bob, "team", "alice")
+    joinGroupFromList(alice, bob, "team")
+    backToChatList()
+    val chat = alice.chatList.open("team")
+    poll(what = "team's compose field with no reason it can't send") {
+      exists(Ui.Chat.Message) && !seesText("you left") && !seesText("group is deleted") && !seesText("removed from group")
+    }
+    return chat
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberAdmissionTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberAdmissionTest.kt
new file mode 100644
index 0000000000..881b26167b
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberAdmissionTest.kt
@@ -0,0 +1,170 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.SupportChatScreen
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.acceptAlert
+import chat.simplex.app.ui.harness.createGroupLink
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.joinLink
+import chat.simplex.app.ui.harness.pendingLinkJoin
+import chat.simplex.app.ui.harness.quiesce
+import chat.simplex.common.model.GroupMemberStatus
+import chat.simplex.common.model.MemberCriteria
+import chat.simplex.common.platform.appPlatform
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.ModalManager
+import org.junit.Ignore
+import org.junit.Test
+
+class MemberAdmissionTest : UiTest() {
+  @Test fun memberAdmission_unsavedChangesAlert() = uiTest {
+    val alice = app("alice")
+    val p = emptyGroup(alice, "team").groupInfo().preferences()
+    var a = p.admission()
+    poll(what = "`Review members` off") { "off" in a.review() }
+    a.select(MemberCriteria.All)
+    poll(what = "`Review members` all after selecting it") { "all" in a.review() }
+    goBack()
+    poll(what = "the `Save admission settings?` alert with `Save and notify group members` and `Exit without saving`") {
+      seesText("Save admission settings?") && exists(Ui.Alert.Confirm(Ui.AlertSource.Shared)) &&
+        "Save and notify group members" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && "Exit without saving" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "member admission to close to group preferences after `Exit without saving`") {
+      !seesText("Review members before admitting (\"knocking\").") && exists(Ui.GroupPrefs.MemberAdmission)
+    }
+    check(groupInfoOf("team").groupProfile.memberAdmission?.review == null) { "`Exit without saving` saved the admission setting" }
+    a = p.admission()
+    poll(what = "`Review members` still off after `Exit without saving`") { "off" in a.review() }
+    a.select(MemberCriteria.All)
+    goBack()
+    poll(what = "the `Save admission settings?` alert") { seesText("Save admission settings?") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "member admission to close with review of all members saved") {
+      groupInfoOf("team").groupProfile.memberAdmission?.review == MemberCriteria.All && !seesText("Save admission settings?") &&
+        !seesText("Review members before admitting (\"knocking\").") && exists(Ui.GroupPrefs.MemberAdmission)
+    }
+    a = p.admission()
+    poll(what = "`Review members` all when reopened") { "all" in a.review() }
+  }
+
+  @Test fun review_acceptAsMember() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val chat = pendingLinkJoin(alice, bob, "team")
+    chat.send("before review")
+    hideKeyboard()
+    val info = chat.groupInfo()
+    val cwm = info.chatsWithMembers()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob listed in `Chats with members` as `pending review`") { cwm.rowTexts("bob").let { "bob" in it && "pending review" in it } }
+    val sc = cwm.open("bob")
+    poll(what = "bob's join request with `Accept` and `Reject` in his support chat") {
+      sc.items().any { it.content.text == "New member wants to join the group." } &&
+        exists(Ui.Chat.PendingAccept) && "Accept" in textsOf(Ui.Chat.PendingAccept) && exists(Ui.Chat.PendingReject) && "Reject" in textsOf(Ui.Chat.PendingReject)
+    }
+    sc.send("hi")
+    bob.expectsMessage("#team (support) alice> hi", CONNECT_TIMEOUT_MS)
+    check("hi" !in chat.itemTexts()) { "alice's support message `hi` was added to team's main chat" }
+    bob sends "#team (support) hello"
+    sc.itemId("hello")
+    sc.acceptVia("acceptAsMember")
+    val joined = listOf(bob.nextLine(CONNECT_TIMEOUT_MS), bob.nextLine(CONNECT_TIMEOUT_MS))
+    check("#team: you joined the group" in joined && joined.any { it.endsWith("#team alice> before review [>>]") }) { "bob's lines after acceptance are not exactly the join and the `before review` history: $joined" }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the support chat to close and bob listed as `member`") {
+      chatModel.secondaryChatsContext.value == null && cwm.rowTexts("bob").let { "member" in it && "pending review" !in it }
+    }
+    val accepted = cwm.open("bob")
+    accepted.itemId("hello")
+    check(!exists(Ui.Chat.PendingAccept) && !exists(Ui.Chat.PendingReject)) { "`Accept` / `Reject` still shown for an accepted member" }
+    accepted.close()
+    cwm.close()
+    info.close()
+    chat.send("after accept")
+    bob.expectsMessage("#team alice> after accept", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun review_acceptAsObserver() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val chat = pendingLinkJoin(alice, bob, "team")
+    val info = chat.groupInfo()
+    val cwm = info.chatsWithMembers()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob listed in `Chats with members` as `pending review`") { "pending review" in cwm.rowTexts("bob") }
+    cwm.menuAccept("bob")
+    acceptAlert("acceptAsObserver")
+    bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob listed as `observer`") { cwm.rowTexts("bob").let { "observer" in it && "pending review" !in it } }
+    bob sends "#team hi"
+    bob expects "#team: you don't have permission to send messages"
+    cwm.close()
+    info.close()
+    chat.send("for observers")
+    bob.expectsMessage("#team alice> for observers", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun review_rejectPendingMember() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val chat = pendingLinkJoin(alice, bob, "team")
+    val cwm = chat.groupInfo().chatsWithMembers()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob listed in `Chats with members` as `pending review`") { "pending review" in cwm.rowTexts("bob") }
+    val sc = cwm.open("bob")
+    sc.reject()
+    poll(what = "the `Reject member?` alert with `Reject` and `Cancel`") {
+      seesText("Reject member?") && exists(Ui.Alert.Confirm(Ui.AlertSource.Shared)) &&
+        "Reject" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && "Cancel" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the alert to close with bob still pending") { !seesText("Reject member?") && exists(Ui.Chat.PendingReject) }
+    sc.send("still pending")
+    bob.expectsMessage("#team (support) alice> still pending", CONNECT_TIMEOUT_MS)
+    sc.reject()
+    poll(what = "the `Reject member?` alert") { seesText("Reject member?") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    bob.expectsMessage("#team: alice removed you from the group (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "use /d #team to delete the group"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the support chat to close after rejecting bob") { chatModel.secondaryChatsContext.value == null }
+    cwm.empty()
+  }
+
+  @Test fun joinerPendingReview_acceptedByAdmin() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val link = bob.createGroupLink("team")
+    bob.eventually("to delete it: /delete link #team (joined members will remain connected to you)")
+    bob sends "/set admission review #team all"
+    bob expects "changed member admission rules"
+    joinLink(link)
+    bob.eventuallyAll(lines = listOf("alice: accepting request to join group #team...", "#team: alice connected and pending review"), timeoutMs = CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice pending review in #team") { groupInfoOf("team").membership.memberStatus == GroupMemberStatus.MemPendingReview }
+    quiesce()
+    val chat = alice.chatList.open("team")
+    val sc = SupportChatScreen(this)
+    sc.waitOpen()
+    poll(what = "`Chat with admins` opened with the request to wait for review") {
+      seesText("Chat with admins") && sc.items().any { it.content.text == "Please wait for group moderators to review your request to join the group." }
+    }
+    if (appPlatform.isDesktop) poll(what = "`reviewed by admins` in the group's compose field") { seesText("reviewed by admins") }
+    sc.send("hello admins")
+    bob.expectsMessage("#team (support: alice) alice> hello admins", CONNECT_TIMEOUT_MS)
+    bob sends "#team while pending"
+    bob sends "#team (support: alice) hi alice"
+    sc.itemId("hi alice")
+    check(chatModel.chatsContext.chatItems.value.none { it.content.text == "while pending" }) { "bob's group message sent while alice was pending reached her" }
+    bob sends "/accept member #team alice"
+    bob expects "#team: alice accepted"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the support chat to close after acceptance") { chatModel.secondaryChatsContext.value == null && !ModalManager.end.hasModalsOpen() }
+    poll(what = "`reviewed by admins` gone from the group's compose field") { exists(Ui.Chat.Message) && !seesText("reviewed by admins") }
+    chat.send("hi all")
+    bob.expectsMessage("#team alice> hi all", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `while pending` delivered once as group history after acceptance") {
+      chatModel.chatsContext.chatItems.value.count { it.content.text == "while pending" } == 1
+    }
+  }
+
+  @Ignore("host \"pending approval\" needs Haskell `chatHooks` (plan §11.3)")
+  @Test fun admission_hostPendingApproval() {}
+
+  @Ignore("\"join rejected\" needs Haskell `chatHooks` (plan §11.3)")
+  @Test fun admission_joinRejectedByHook() {}
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberContactTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberContactTest.kt
new file mode 100644
index 0000000000..c1baa1e697
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberContactTest.kt
@@ -0,0 +1,78 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
+import chat.simplex.app.ui.harness.CliPeer
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.confirmAlert
+import chat.simplex.app.ui.harness.linkGroupWithDirectMessages
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class MemberContactTest : UiTest() {
+  @Test fun memberContact_createAndSendInvitation() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val info = linkGroupWithDirectMessages(alice, "team", bob)
+    bob sends "/set accept member contacts on"
+    bob expects "ok"
+    check(directChatWith("bob") == null) { "alice already has a direct chat with bob" }
+    info.member("bob").message()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "a new direct chat with bob open with `Send direct message to connect`") {
+      chatModel.chatId.value != null && chatModel.chatId.value == directChatWith("bob")?.id && seesText("Send direct message to connect")
+    }
+    val chat = ChatScreen(this)
+    chat.send("hi")
+    bob.eventuallyAll(lines = listOf("#team alice is creating direct contact alice with you"), messages = listOf("alice> hi"), timeoutMs = CONNECT_TIMEOUT_MS)
+    bob.eventually("alice: you can send messages to contact", CONNECT_TIMEOUT_MS)
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(what = "`Send direct message to connect` gone once bob is connected") { !seesText("Send direct message to connect") }
+    bob sends "@alice hey"
+    chat.itemId("bob's `hey` in the direct chat") { it.content.text == "hey" }
+  }
+
+  @Test fun memberContact_acceptAndRejectRequests() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    linkGroupWithDirectMessages(alice, "team", bob, cath).close()
+    bob.requestsContactWith("alice")
+    backToChatList()
+    var chat = alice.chatList.open("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's request with `Accept` and `Reject` in place of the message field") {
+      exists(Ui.Chat.RequestAccept) && exists(Ui.Chat.RequestReject) && !exists(Ui.Chat.Message) && chat.itemTexts().contains("hi")
+    }
+    click(Ui.Chat.RequestAccept)
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the message field in place of `Accept` and `Reject`") { exists(Ui.Chat.Message) && !exists(Ui.Chat.RequestAccept) }
+    chat.send("welcome")
+    bob.expectsMessage("alice> welcome", CONNECT_TIMEOUT_MS)
+    cath.requestsContactWith("alice")
+    backToChatList()
+    alice.chatList.open("cath")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "cath's request with `Reject`") { exists(Ui.Chat.RequestReject) }
+    click(Ui.Chat.RequestReject)
+    confirmAlert("Reject contact request", "The sender will NOT be notified.", "Reject")
+    alice.chatList.gone("cath")
+    backToChatList()
+    chat = alice.chatList.open("team")
+    chat.send("end")
+    cath.expectsMessage("#team alice> end", CONNECT_TIMEOUT_MS)
+  }
+
+  private fun directChatWith(name: String) =
+    chatModel.chats.value.firstOrNull { (it.chatInfo as? ChatInfo.Direct)?.contact?.displayName == name }
+
+  private fun CliPeer.requestsContactWith(member: String) {
+    this sends "@#team $member hi"
+    eventuallyAll(
+      lines = listOf(
+        "member #team $member does not have direct connection, creating",
+        "contact for member #team $member is created",
+        "sent invitation to connect directly to member #team $member",
+      ),
+      messages = listOf("@$member hi"),
+      timeoutMs = CONNECT_TIMEOUT_MS,
+    )
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberInfoTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberInfoTest.kt
index 2c7cf3c7ef..106c4db73f 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberInfoTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberInfoTest.kt
@@ -1,11 +1,47 @@
 package chat.simplex.app.ui.groups
 
 import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
+import chat.simplex.app.ui.harness.GroupPreferencesScreen
+import chat.simplex.app.ui.harness.KnownAppIssue
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.alertSaying
+import chat.simplex.app.ui.harness.awaitAppIdle
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.blockForAllViaApi
+import chat.simplex.app.ui.harness.closeMemberInfo
+import chat.simplex.app.ui.harness.confirmAlert
 import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.copiedServer
+import chat.simplex.app.ui.harness.createGroup
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.groupInfoRow
+import chat.simplex.app.ui.harness.groupMemberId
+import chat.simplex.app.ui.harness.inviteMembers
+import chat.simplex.app.ui.harness.isServer
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.app.ui.harness.joinsViaLink
+import chat.simplex.app.ui.harness.localSmpServer
+import chat.simplex.app.ui.harness.memberConnected
+import chat.simplex.app.ui.harness.memberConnectionLoaded
+import chat.simplex.app.ui.harness.memberOfHostedGroup
+import chat.simplex.app.ui.harness.openMemberMenu
 import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.app.ui.harness.ownGroupWithTwo
+import chat.simplex.app.ui.harness.shownSecurityCode
+import chat.simplex.common.model.CIContent
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.GroupFeature
+import chat.simplex.common.model.GroupFeatureEnabled
 import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.model.RcvGroupEvent
 import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.ModalManager
+import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class MemberInfoTest : UiTest() {
@@ -25,4 +61,358 @@ class MemberInfoTest : UiTest() {
     cath.eventually("#team: alice removed bob from the group (signed)", CONNECT_TIMEOUT_MS)
     poll(what = "bob no longer a current member") { chatModel.groupMembers.value.none { it.memberProfile.displayName == "bob" && it.memberCurrent } }
   }
+
+  @Test fun memberInfo_changeRoleToObserverCannotSend() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val info = ownGroup(alice, "team", bob).groupInfo()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob listed in team's members without a role label") { info.memberTexts("bob").let { "bob" in it && "observer" !in it } }
+    val member = info.member("bob")
+    member.pickRole(GroupMemberRole.Observer)
+    check(seesText("The role will be changed to \"observer\". Everyone in the group will be notified.")) { "the `Change role?` alert does not name `observer`" }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the role picker back at `member` after dismissing `Change role?`") {
+      !seesText("Change role?") && "member" in textsOf(Ui.MemberInfo.Role) && "observer" !in textsOf(Ui.MemberInfo.Role)
+    }
+    member.changeRole(GroupMemberRole.Observer)
+    bob.expectsMessage("#team: alice changed your role from member to observer (signed)", CONNECT_TIMEOUT_MS)
+    escape()
+    poll(what = "bob listed as `observer` in group info") { !exists(Ui.MemberInfo.Role) && "observer" in info.memberTexts("bob") }
+    bob sends "#team hi"
+    bob expects "#team: you don't have permission to send messages"
+  }
+
+  @Test fun memberInfo_blockForMeHidesMessages() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = memberOfHostedGroup(alice, bob, cath)
+    cath sends "#team before block"
+    bob.eventuallyMessage("#team cath> before block", CONNECT_TIMEOUT_MS)
+    val before = chat.itemId("cath's `before block`") { it.content.text == "before block" }
+    var info = chat.groupInfo()
+    poll(what = "cath listed in team's members, not blocked") { info.memberTexts("cath").let { "cath" in it && "blocked" !in it } }
+    info.member("cath").block("cath")
+    poll(what = "cath's member info offering `Unblock member`") { exists(Ui.MemberInfo.Unblock) && !exists(Ui.MemberInfo.Block) }
+    escape()
+    poll(what = "member info to close to group info with cath listed as `blocked`") { !exists(Ui.MemberInfo.Unblock) && "blocked" in info.memberTexts("cath") }
+    info.close()
+    chat.send("after block")
+    bob.expectsMessage("#team alice> after block", CONNECT_TIMEOUT_MS)
+    cath.expectsMessage("#team alice> after block", CONNECT_TIMEOUT_MS)
+    cath sends "#team while blocked"
+    bob.expectsMessage("#team cath> while blocked", CONNECT_TIMEOUT_MS)
+    val hidden = chat.itemId("cath's `while blocked`") { it.content.text == "while blocked" }
+    poll(what = "cath's `while blocked` shown as `blocked`, her `before block` unchanged") {
+      textsOf(Ui.Chat.Item(hidden)).let { t -> "blocked" in t && t.none { "while blocked" in it } } && textsOf(Ui.Chat.Item(before)).any { "before block" in it }
+    }
+    info = chat.groupInfo()
+    info.member("cath").unblock("cath")
+    poll(what = "cath's member info offering `Block member` again") { exists(Ui.MemberInfo.Block) && !exists(Ui.MemberInfo.Unblock) }
+    escape()
+    poll(what = "member info to close to group info with cath not blocked") { !exists(Ui.MemberInfo.Block) && "blocked" !in info.memberTexts("cath") }
+    info.close()
+    cath sends "#team after unblock"
+    bob.expectsMessage("#team cath> after unblock", CONNECT_TIMEOUT_MS)
+    val shown = chat.itemId("cath's `after unblock`") { it.content.text == "after unblock" }
+    poll(what = "cath's `after unblock` shown with its text") { textsOf(Ui.Chat.Item(shown)).let { t -> t.any { "after unblock" in it } && "blocked" !in t } }
+    chat.send("end")
+    cath.expectsMessage("#team alice> end", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun memberInfo_unblockForAll() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = ownGroupWithTwo(alice, bob, cath)
+    blockForAllViaApi("team", "bob")
+    cath.eventually("#team: alice blocked bob (signed)", CONNECT_TIMEOUT_MS)
+    bob sends "#team while blocked"
+    val blocked = chat.itemId("bob's `while blocked`") { it.content.text == "while blocked" }
+    poll(what = "bob's `while blocked` shown as `blocked by admin`") { textsOf(Ui.Chat.Item(blocked)).let { t -> "blocked by admin" in t && t.none { "while blocked" in it } } }
+    val info = chat.groupInfo()
+    val member = info.member("bob")
+    poll(what = "bob's member info offering `Unblock for all`, not `Block for all`") { exists(Ui.MemberInfo.UnblockForAll) && !exists(Ui.MemberInfo.BlockForAll) }
+    member.unblockForAll("bob")
+    cath.expectsMessage("#team: alice unblocked bob (signed)", CONNECT_TIMEOUT_MS)
+    poll(what = "bob's member info offering `Block for all` again") { exists(Ui.MemberInfo.BlockForAll) && !exists(Ui.MemberInfo.UnblockForAll) }
+    escape()
+    poll(what = "member info to close to group info") { !exists(Ui.MemberInfo.Remove) }
+    info.close()
+    bob sends "#team after unblock"
+    cath.expectsMessage("#team bob> after unblock", CONNECT_TIMEOUT_MS)
+    val after = chat.itemId("bob's `after unblock`") { it.content.text == "after unblock" }
+    poll(what = "bob's `after unblock` shown with its text") { textsOf(Ui.Chat.Item(after)).let { t -> t.any { "after unblock" in it } && "blocked by admin" !in t } }
+  }
+
+  @Test fun memberInfo_removeMemberWithMessages() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = ownGroupWithTwo(alice, bob, cath)
+    bob sends "#team bob was here"
+    cath.eventuallyMessage("#team bob> bob was here", CONNECT_TIMEOUT_MS)
+    val msg = chat.itemId("bob's `bob was here`") { it.content.text == "bob was here" }
+    val info = chat.groupInfo()
+    info.member("bob").removeWithMessages()
+    bob.expectsMessage("#team: alice removed you from the group with all messages (signed)", CONNECT_TIMEOUT_MS)
+    bob expects "use /d #team to delete the group"
+    cath.expectsMessage("#team: alice removed bob from the group with all messages (signed)", CONNECT_TIMEOUT_MS)
+    poll(what = "member info to close to group info after removing bob") { !exists(Ui.MemberInfo.Remove) && exists(Ui.GroupInfo.Preferences) }
+    info.close()
+    poll(what = "bob's `bob was here` shown as `moderated by alice`") { textsOf(Ui.Chat.Item(msg)).let { t -> "moderated by alice" in t && t.none { "bob was here" in it } } }
+  }
+
+  @Test fun memberInfo_messageOpensKnownContact() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val team = ownGroup(alice, "team", bob)
+    val teamId = alice.chatList.chatId("team")
+    val bobId = alice.chatList.chatId("bob")
+    poll(what = "team's chat open") { chatModel.chatId.value == teamId }
+    team.groupInfo().member("bob").message()
+    poll(what = "bob's direct chat open with group and member info closed") { chatModel.chatId.value == bobId && !ModalManager.end.hasModalsOpen() }
+    check(chatModel.chats.value.count { (it.chatInfo as? ChatInfo.Direct)?.contact?.displayName == "bob" } == 1) { "`message` created a second direct chat with bob" }
+    ChatScreen(this).send("hi from member info")
+    bob.eventuallyMessage("alice> hi from member info", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun memberInfo_verifyCodeMatchesCli() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val info = ownGroup(alice, "team", bob).groupInfo()
+    memberConnected(info, "bob")
+    fun verified() = chatModel.groupMembers.value.first { it.memberProfile.displayName == "bob" }.verified
+    info.member("bob")
+    memberConnectionLoaded()
+    poll(what = "`Verify security code` in bob's member info with bob not verified") {
+      textOf(Ui.Info.VerifyCode) == "Verify security code" && !verified()
+    }
+    val shown = shownSecurityCode()
+    poll(what = "`bob is not verified` with `Mark verified`") { seesText("bob is not verified") && exists(Ui.VerifyCode.Mark) }
+    bob sends "/code #team alice"
+    bob.eventually("#team alice security code:")
+    assertEquals(bob.nextLine().filterNot(Char::isWhitespace), shown)
+    click(Ui.VerifyCode.Mark)
+    poll(what = "the security code screen closed with bob verified and `View security code` in his member info") {
+      !exists(Ui.VerifyCode.Mark) && verified() && exists(Ui.Info.VerifyCode) && textOf(Ui.Info.VerifyCode) == "View security code"
+    }
+    click(Ui.Info.VerifyCode)
+    poll(what = "`bob is verified` with `Clear verification`") {
+      seesText("bob is verified") && exists(described("Clear verification")) && !exists(Ui.VerifyCode.Mark)
+    }
+    click(described("Clear verification"))
+    poll(what = "`bob is not verified` and `Mark verified` again, with bob not verified") {
+      seesText("bob is not verified") && exists(Ui.VerifyCode.Mark) && !exists(described("Clear verification")) && !verified()
+    }
+    goBack()
+    poll(what = "`Verify security code` back in bob's member info") {
+      !exists(Ui.VerifyCode.Mark) && exists(Ui.Info.VerifyCode) && textOf(Ui.Info.VerifyCode) == "Verify security code"
+    }
+  }
+
+  @Test fun memberInfo_changeRoleOfInvitedMember() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val info = emptyGroup(alice, "team").groupInfo()
+    val inv = inviteMembers()
+    poll(what = "bob offered") { inv.listed("bob") }
+    inv.role(GroupMemberRole.Admin)
+    poll(what = "`New member role` set to `admin`") { "admin" in inv.roleTexts() }
+    inv.toggle("bob")
+    inv.invite()
+    bob.expectsMessage("#team: alice invites you to join the group as admin", CONNECT_TIMEOUT_MS)
+    bob expects "use /j team to accept"
+    poll(what = "bob listed as an invited admin") { info.memberTexts("bob").let { "invited" in it && "admin" in it } }
+    val member = info.member("bob")
+    poll(what = "bob's role picker at `admin`") { exists(Ui.MemberInfo.Role) && "admin" in textsOf(Ui.MemberInfo.Role) }
+    member.pickRole(GroupMemberRole.Member)
+    check(seesText("The role will be changed to \"member\". The member will receive a new invitation.")) {
+      "the `Change role?` alert for an invited member does not say that a new invitation is sent"
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    bob.expectsMessage("#team: alice invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    bob expects "use /j team to accept"
+    closeMemberInfo("bob")
+    poll(what = "bob listed as an invited member without the `admin` label") { info.memberTexts("bob").let { "invited" in it && "admin" !in it } }
+  }
+
+  @Test fun memberInfo_roleReadOnlyForHigherRole() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob)
+    connect(cath)
+    bob.createGroup("team")
+    bob sends "/a team alice admin"
+    bob.eventually("invitation to join the group #team sent to alice")
+    joinGroupFromList(alice, bob, "team")
+    backToChatList()
+    val info = alice.chatList.open("team").groupInfo()
+    poll(what = "alice an admin of team") { groupInfoOf("team").membership.memberRole == GroupMemberRole.Admin }
+    info.member("bob")
+    poll(what = "the owner bob's role shown read-only, with no role picker and no `Remove member`") {
+      seesText("Role") && seesText("owner") && !exists(Ui.MemberInfo.Role) && !exists(Ui.MemberInfo.Remove)
+    }
+    closeMemberInfo("bob")
+    val inv = inviteMembers()
+    poll(what = "cath offered") { inv.listed("cath") }
+    click(Ui.InviteMembers.Role)
+    poll(what = "`New member role` offering roles up to `admin`, without `owner`") {
+      exists(Ui.InviteMembers.Role.option(GroupMemberRole.Admin)) && exists(Ui.InviteMembers.Role.option(GroupMemberRole.Observer)) &&
+        !exists(Ui.InviteMembers.Role.option(GroupMemberRole.Owner))
+    }
+    click(Ui.InviteMembers.Role.option(GroupMemberRole.Admin))
+    poll(what = "`New member role` set to `admin`") { "admin" in inv.roleTexts() }
+    inv.toggle("cath")
+    inv.invite()
+    cath.expectsMessage("#team: alice invites you to join the group as admin", CONNECT_TIMEOUT_MS)
+    cath expects "use /j team to accept"
+    info.member("cath")
+    poll(what = "a role picker at `admin` for the invited cath") { exists(Ui.MemberInfo.Role) && "admin" in textsOf(Ui.MemberInfo.Role) }
+    click(Ui.MemberInfo.Role)
+    poll(what = "cath's roles offered up to `admin`, without `owner`") {
+      exists(Ui.MemberInfo.Role.option(GroupMemberRole.Member)) && exists(Ui.MemberInfo.Role.option(GroupMemberRole.Admin)) &&
+        !exists(Ui.MemberInfo.Role.option(GroupMemberRole.Owner))
+    }
+    click(Ui.MemberInfo.Role.option(GroupMemberRole.Admin))
+    poll(what = "the role list closed without a `Change role?` alert") { !exists(Ui.MemberInfo.Role.option(GroupMemberRole.Member)) && !seesText("Change role?") }
+  }
+
+  @Test fun memberInfo_blockedByAdminShownToMember() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = memberOfHostedGroup(alice, bob, cath)
+    cath sends "#team spam from cath"
+    bob.eventuallyMessage("#team cath> spam from cath", CONNECT_TIMEOUT_MS)
+    val spam = chat.itemId("cath's `spam from cath`") { it.content.text == "spam from cath" }
+    poll(what = "cath's message shown with its text") { textsOf(Ui.Chat.Item(spam)).let { t -> t.any { "spam from cath" in it } && "moderated by bob" !in t } }
+    bob sends "\\\\ #team @cath spam from cath"
+    bob.eventually("message marked deleted by you")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "cath's message shown as `moderated by bob`") {
+      textsOf(Ui.Chat.Item(spam)).let { t -> "moderated by bob" in t && t.none { "spam from cath" in it } }
+    }
+    val info = chat.groupInfo()
+    poll(what = "cath listed in team's members, not blocked") { info.memberTexts("cath").let { "cath" in it && "blocked" !in it } }
+    val cathId = openMemberMenu("cath")
+    poll(what = "a member's menu for cath with `Block member` and without the moderator actions") {
+      exists(Ui.GroupInfo.MemberMenu(cathId, "block")) && "Block member" in textsOf(Ui.GroupInfo.MemberMenu(cathId, "block")) &&
+        !exists(Ui.GroupInfo.MemberMenu(cathId, "blockForAll")) && !exists(Ui.GroupInfo.MemberMenu(cathId, "remove"))
+    }
+    click(Ui.GroupInfo.MemberMenu(cathId, "block"))
+    confirmAlert("Block member?", "All new messages from cath will be hidden!", "Block")
+    poll(what = "cath listed as `blocked`") { "blocked" in info.memberTexts("cath") }
+    openMemberMenu("cath")
+    poll(what = "`Unblock member` in place of `Block member` in cath's menu") {
+      exists(Ui.GroupInfo.MemberMenu(cathId, "unblock")) && !exists(Ui.GroupInfo.MemberMenu(cathId, "block"))
+    }
+    click(Ui.GroupInfo.MemberMenu(cathId, "unblock"))
+    confirmAlert("Unblock member?", "Messages from cath will be shown!", "Unblock")
+    poll(what = "cath no longer listed as `blocked`") { "blocked" !in info.memberTexts("cath") }
+    info.member("cath")
+    poll(what = "`Block member` in cath's member info") { exists(Ui.MemberInfo.Block) && !seesText("Blocked by admin") }
+    bob sends "/block for all #team cath"
+    bob.eventually("#team: you blocked cath (signed)")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "cath's member info showing `Blocked by admin` in place of `Block member`") {
+      seesText("Blocked by admin") && !exists(Ui.MemberInfo.Block) && !exists(Ui.MemberInfo.Unblock)
+    }
+    closeMemberInfo("cath")
+    poll(what = "cath listed as `blocked`") { "blocked" in info.memberTexts("cath") }
+    openMemberMenu("cath")
+    check(!exists(Ui.GroupInfo.MemberMenu(cathId, "block")) && !exists(Ui.GroupInfo.MemberMenu(cathId, "unblock"))) {
+      "a member's menu offers blocking cath, who is blocked by admin"
+    }
+  }
+
+  @Test fun memberInfo_callButtonsDirectMessagesProhibitedAlert() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val info = emptyGroup(alice, "team").groupInfo()
+    check(groupInfoOf("team").fullGroupPreferences.directMessages.enable == GroupFeatureEnabled.OFF) { "direct messages are on in a new group" }
+    val link = info.createLink()
+    bob.joinsViaLink(link, "team")
+    memberConnected(info, "bob")
+    info.member("bob")
+    for (button in listOf(Ui.MemberInfo.Call, Ui.MemberInfo.Video)) {
+      click(button)
+      alertSaying("Can't call group member", "Direct messages between members are prohibited in this group.")
+    }
+    closeMemberInfo("bob")
+    groupInfoRow(Ui.GroupInfo.Preferences)
+    val prefs = GroupPreferencesScreen(this)
+    prefs.toggle(GroupFeature.DirectMessages)
+    prefs.save()
+    poll(what = "direct messages allowed in team") { groupInfoOf("team").fullGroupPreferences.directMessages.enable == GroupFeatureEnabled.ON }
+    prefs.backClosing()
+    info.member("bob")
+    for (button in listOf(Ui.MemberInfo.Call, Ui.MemberInfo.Video)) {
+      click(button)
+      alertSaying("Can't call group member", "Send message to enable calls.")
+    }
+  }
+
+  @Test fun memberInfo_switchAddress() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = ownGroup(alice, "team", bob)
+    val info = chat.groupInfo()
+    memberConnected(info, "bob")
+    val smp = localSmpServer()
+    info.member("bob")
+    memberConnectionLoaded()
+    poll(what = "`Receiving via` and `Sending via` the local server, `Network status` and `Change receiving address` in bob's member info") {
+      exists(Ui.Info.SendingVia) && exists(described("Network status")) && exists(Ui.Info.SwitchAddress) && !seesText(ABORT_SWITCH) &&
+        textsOf(Ui.Info.ReceivingVia).let { "Receiving via" in it && it.any { t -> smp.hostnames.first() in t } } &&
+        textsOf(Ui.Info.SendingVia).let { "Sending via" in it && it.any { t -> smp.hostnames.first() in t } }
+    }
+    val receiving = copiedServer(Ui.Info.ReceivingVia)
+    check(isServer(receiving, smp)) { "`Receiving via` copied `$receiving`, not the local server $smp" }
+    val sending = copiedServer(Ui.Info.SendingVia)
+    check(isServer(sending, smp)) { "`Sending via` copied `$sending`, not the local server $smp" }
+    check(!seesText(NETWORK_STATUS_TEXT)) { "the network status explanation is shown before `Network status` is clicked" }
+    click(described("Network status"))
+    alertSaying("Network status", NETWORK_STATUS_TEXT)
+    click(Ui.Info.SwitchAddress)
+    poll(what = "the `Change receiving address?` alert with `Change`") {
+      seesText("Change receiving address?") &&
+        seesText("Receiving address will be changed to a different server. Address change will complete after sender comes online.") &&
+        "Change" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    val bobRow = Ui.GroupInfo.Member(groupMemberId("bob"))
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "member info closed to group info after `Change`") { !exists(Ui.Info.SwitchAddress) && exists(bobRow) }
+    bob.eventually("#team: alice started changing address for you", CONNECT_TIMEOUT_MS)
+    bob.eventually("#team: alice changed address for you", CONNECT_TIMEOUT_MS)
+    info.close()
+    chat.itemId("`you changed address for bob` in team") { it.content is CIContent.SndConnEventContent && it.content.text == "you changed address for bob" }
+    bob sends "#team after switch"
+    chat.itemId("bob's `after switch` on the new address") { it.content.text == "after switch" }
+  }
+
+  @KnownAppIssue("15.5 item 21", "cath's loaded member info offering memberInfo.deleteMessages and not memberInfo.remove")
+  @Test fun memberInfo_deleteMessagesOfLeftMember() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = ownGroupWithTwo(alice, bob, cath)
+    bob sends "#team bob stays"
+    cath.eventuallyMessage("#team bob> bob stays", CONNECT_TIMEOUT_MS)
+    cath sends "#team cath was here"
+    bob.eventuallyMessage("#team cath> cath was here", CONNECT_TIMEOUT_MS)
+    val stays = chat.itemId("bob's `bob stays`") { it.content.text == "bob stays" }
+    val msg = chat.itemId("cath's `cath was here`") { it.content.text == "cath was here" }
+    cath sends "/leave #team"
+    cath.eventually("#team: you left the group")
+    bob.eventually("#team: cath left the group (signed)", CONNECT_TIMEOUT_MS)
+    val left = chat.itemId("cath's `left` event in team") { (it.content as? CIContent.RcvGroupEventContent)?.rcvGroupEvent is RcvGroupEvent.MemberLeft }
+    poll(what = "cath's `left` event shown, her message still shown with its text") {
+      textsOf(Ui.Chat.Item(left)).any { "left" in it } && textsOf(Ui.Chat.Item(msg)).any { "cath was here" in it }
+    }
+    click(Ui.Chat.Item(msg).part("avatar"))
+    awaitAppIdle("opening cath's member info")
+    poll(what = "cath's loaded member info offering ${Ui.MemberInfo.DeleteMessages.tag} and not ${Ui.MemberInfo.Remove.tag}") {
+      exists(Ui.MemberInfo.DeleteMessages) && !exists(Ui.MemberInfo.Remove)
+    }
+    click(Ui.MemberInfo.DeleteMessages)
+    confirmAlert("Delete member messages?", "Member messages will be deleted - this cannot be undone!", "Delete messages")
+    bob.eventually("#team: alice removed cath from the group with all messages (signed)", CONNECT_TIMEOUT_MS)
+    poll(what = "member info closed with cath's message shown as `moderated by alice` and bob's kept") {
+      !exists(Ui.MemberInfo.DeleteMessages) && !ModalManager.end.hasModalsOpen() &&
+        textsOf(Ui.Chat.Item(msg)).let { t -> "moderated by alice" in t && t.none { "cath was here" in it } } &&
+        textsOf(Ui.Chat.Item(stays)).any { "bob stays" in it }
+    }
+  }
+
+  private companion object {
+    const val NETWORK_STATUS_TEXT = "You are connected to the server used to receive messages from this connection."
+    const val ABORT_SWITCH = "Abort changing address"
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberListTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberListTest.kt
new file mode 100644
index 0000000000..6dbd5fc339
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MemberListTest.kt
@@ -0,0 +1,149 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.confirmAlert
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.emptyGroup
+import chat.simplex.app.ui.harness.groupMemberId
+import chat.simplex.app.ui.harness.inviteMembers
+import chat.simplex.app.ui.harness.membersTitleShown
+import chat.simplex.app.ui.harness.openMemberMenu
+import chat.simplex.app.ui.harness.ownGroupOfThree
+import chat.simplex.app.ui.harness.scrollToMembersEnd
+import chat.simplex.app.ui.harness.selectMembers
+import chat.simplex.app.ui.harness.selectionEnded
+import chat.simplex.app.ui.harness.setRoleViaApi
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+private val ROLE_LABELS = listOf("owner", "admin", "moderator", "observer", "member")
+
+class MemberListTest : UiTest() {
+  @Test fun memberList_rolesAndStatuses() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob)
+    connect(cath)
+    val info = emptyGroup(alice, "team").groupInfo()
+    poll(what = "`1 members` with alice's own row `you: creator`, `owner`") {
+      info.ownMemberTexts().let { "you: creator" in it && "owner" in it } && membersTitleShown(1)
+    }
+    val first = inviteMembers()
+    poll(what = "cath offered") { first.listed("cath") }
+    first.toggle("cath")
+    first.invite()
+    cath.expectsMessage("#team: alice invites you to join the group as member", CONNECT_TIMEOUT_MS)
+    cath expects "use /j team to accept"
+    val second = inviteMembers()
+    poll(what = "bob offered") { second.listed("bob") }
+    second.role(GroupMemberRole.Admin)
+    poll(what = "`New member role` set to `admin`") { "admin" in second.roleTexts() }
+    second.toggle("bob")
+    second.invite()
+    bob.expectsMessage("#team: alice invites you to join the group as admin", CONNECT_TIMEOUT_MS)
+    bob expects "use /j team to accept"
+    poll(what = "`3 members` once bob and cath are invited") { info.ownMemberTexts().isNotEmpty() && membersTitleShown(3) && !membersTitleShown(1) }
+    cath sends "/j team"
+    cath.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    bob sends "/j team"
+    bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob `connected` as `admin`, cath `connected` without a role label") {
+      info.memberTexts("bob").let { "connected" in it && "admin" in it } &&
+        info.memberTexts("cath").let { t -> "connected" in t && ROLE_LABELS.none { it in t } }
+    }
+    poll(what = "the admin bob listed above cath, who was invited first") {
+      textsOf(Ui.GroupInfo.Content).let { t -> t.indexOf("bob") >= 0 && t.indexOf("bob") < t.indexOf("cath") }
+    }
+  }
+
+  @KnownAppIssue("15.5 item 15", "FOREIGN KEY constraint failed")
+  @Test fun memberSelection_blockUnblockAndRemoveMultiple() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath"); val dan = cli("dan")
+    var info = ownGroupOfThree(alice, bob, cath, dan).groupInfo()
+    poll(what = "`4 members` in team's info") { info.ownMemberTexts().isNotEmpty() && membersTitleShown(4) }
+    val cathId = groupMemberId("cath")
+    scrollToMembersEnd()
+    val bobId = openMemberMenu("bob")
+    poll(what = "bob's menu with `Block for all`, `Remove member` and `Select`") {
+      listOf("blockForAll", "remove", "select").all { exists(Ui.GroupInfo.MemberMenu(bobId, it)) } && !exists(Ui.GroupInfo.MemberMenu(bobId, "unblockForAll")) &&
+        listOf("Block for all", "Remove member", "Select").all { seesText(it) }
+    }
+    click(Ui.GroupInfo.MemberMenu(bobId, "select"))
+    poll(what = "`Selected 1` after `Select` on bob") { ChatScreen(this).selectionTitle() == "Selected 1" }
+    click(Ui.GroupInfo.Member(cathId))
+    poll(what = "`Selected 2` after tapping cath") { ChatScreen(this).selectionTitle() == "Selected 2" }
+    click(Ui.GroupInfo.MembersToolbar.part("block"))
+    confirmAlert("Block members for all?", "All new messages from these members will be hidden!", "Block for all")
+    dan.eventuallyAll(lines = listOf("#team: alice blocked bob (signed)", "#team: alice blocked cath (signed)"), timeoutMs = CONNECT_TIMEOUT_MS)
+    selectionEnded()
+    poll(what = "bob and cath listed as `blocked`, dan not") {
+      "blocked" in info.memberTexts("bob") && "blocked" in info.memberTexts("cath") && "blocked" !in info.memberTexts("dan")
+    }
+    openMemberMenu("bob")
+    poll(what = "bob's menu offering `Unblock for all` instead of `Block for all`") {
+      exists(Ui.GroupInfo.MemberMenu(bobId, "unblockForAll")) && !exists(Ui.GroupInfo.MemberMenu(bobId, "blockForAll"))
+    }
+    click(Ui.GroupInfo.MemberMenu(bobId, "select"))
+    poll(what = "`Selected 1` after `Select` on the blocked bob") { ChatScreen(this).selectionTitle() == "Selected 1" }
+    click(Ui.GroupInfo.Member(cathId))
+    poll(what = "`Selected 2` after tapping the blocked cath") { ChatScreen(this).selectionTitle() == "Selected 2" }
+    click(Ui.GroupInfo.MembersToolbar.part("block"))
+    confirmAlert("Unblock members for all?", "Messages from these members will be shown!", "Unblock for all")
+    dan.eventuallyAll(lines = listOf("#team: alice unblocked bob (signed)", "#team: alice unblocked cath (signed)"), timeoutMs = CONNECT_TIMEOUT_MS)
+    selectionEnded()
+    poll(what = "bob and cath no longer `blocked`") { "blocked" !in info.memberTexts("bob") && "blocked" !in info.memberTexts("cath") }
+    selectMembers("bob", "cath")
+    click(Ui.GroupInfo.MembersToolbar.part("remove"))
+    val remove = Ui.Alert.Option(Ui.AlertSource.Shared, "remove")
+    poll(what = "the `Remove members?` alert with `Remove` and `Remove and delete messages`") {
+      seesText("Remove members?") && seesText("Members will be removed from group - this cannot be undone!") &&
+        exists(remove) && "Remove" in textsOf(remove) && seesText("Remove and delete messages")
+    }
+    click(remove)
+    bob.eventually("#team: alice removed you from the group (signed)", CONNECT_TIMEOUT_MS)
+    cath.eventually("#team: alice removed you from the group (signed)", CONNECT_TIMEOUT_MS)
+    dan.eventuallyAll(lines = listOf("#team: alice removed bob from the group (signed)", "#team: alice removed cath from the group (signed)"), timeoutMs = CONNECT_TIMEOUT_MS)
+    selectionEnded()
+    info.close()
+    info = ChatScreen(this).groupInfo()
+    poll(what = "`2 members` with dan listed and bob and cath gone") {
+      info.ownMemberTexts().isNotEmpty() && membersTitleShown(2) && "dan" in info.memberTexts("dan") &&
+        !exists(Ui.GroupInfo.Member(bobId)) && !exists(Ui.GroupInfo.Member(cathId))
+    }
+  }
+
+  @Test fun memberSelection_selectAllExcludesModerators() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath"); val dan = cli("dan")
+    val chat = ownGroupOfThree(alice, bob, cath, dan)
+    setRoleViaApi("team", "dan", GroupMemberRole.Moderator)
+    dan.eventually("#team: alice changed your role from member to moderator (signed)", CONNECT_TIMEOUT_MS)
+    val info = chat.groupInfo()
+    poll(what = "dan listed as `moderator`, bob and cath without a role label") {
+      "moderator" in info.memberTexts("dan") && "moderator" !in info.memberTexts("bob") && "moderator" !in info.memberTexts("cath")
+    }
+    scrollToMembersEnd()
+    selectMembers("bob")
+    click(Ui.GroupInfo.Member(groupMemberId("dan")))
+    check(ChatScreen(this).selectionTitle() == "Selected 1") { "tapping the moderator dan changed the selection to `${ChatScreen(this).selectionTitle()}`" }
+    click(Ui.Chat.Selection.part("selectAll"))
+    poll(what = "`Selected 2` (bob and cath) after select all, the moderator dan left out") { ChatScreen(this).selectionTitle() == "Selected 2" }
+    click(Ui.GroupInfo.MembersToolbar.part("role"))
+    confirmAlert("Change role?", "The role will be changed to \"observer\". Everyone in the group will be notified.", "Change")
+    bob.eventually("#team: alice changed your role from member to observer (signed)", CONNECT_TIMEOUT_MS)
+    cath.eventually("#team: alice changed your role from member to observer (signed)", CONNECT_TIMEOUT_MS)
+    dan.eventuallyAll(
+      lines = listOf("#team: alice changed the role of bob from member to observer (signed)", "#team: alice changed the role of cath from member to observer (signed)"),
+      timeoutMs = CONNECT_TIMEOUT_MS,
+    )
+    selectionEnded()
+    poll(what = "bob and cath listed as `observer`, dan still `moderator`") {
+      "observer" in info.memberTexts("bob") && "observer" in info.memberTexts("cath") && info.memberTexts("dan").let { "moderator" in it && "observer" !in it }
+    }
+    info.close()
+    chat.send("done")
+    dan.expectsMessage("#team alice> done", CONNECT_TIMEOUT_MS)
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MentionNotificationTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MentionNotificationTest.kt
new file mode 100644
index 0000000000..a7d91a505f
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/MentionNotificationTest.kt
@@ -0,0 +1,48 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.chatListToolbar
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.app.ui.harness.quiesce
+import chat.simplex.common.model.MsgFilter
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class MentionNotificationTest : UiTest() {
+  @Test fun mentions_mentionsOnlyMuteCountsOnlyMentionsForOtherProfile() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    hostGroup(bob, "team", "alice")
+    joinGroupFromList(alice, bob, "team")
+    backToChatList()
+    val info = alice.chatList.open("team").groupInfo()
+    waitFor(Ui.GroupInfo.Mute)
+    click(Ui.GroupInfo.Mute)
+    poll(what = "team muted to mentions only") { groupInfoOf("team").chatSettings.enableNtfs == MsgFilter.Mentions && seesText("Mute all") }
+    info.close()
+    backToChatList()
+    alice.userPicker().profiles().apply { add("work"); close() }
+    quiesce()
+    fun aliceUser() = chatModel.users.first { it.user.displayName == "alice" }
+    val before = aliceUser().unreadCount
+    bob sends "#team @alice one"
+    bob sends "#team plain"
+    bob sends "#team @alice two"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "both mentions counted for the inactive profile alice and the badge on the profile button") {
+      aliceUser().unreadCount >= before + 2 && chatListToolbar().profileBadge()
+    }
+    check(aliceUser().unreadCount == before + 2) { "alice's unread count is ${aliceUser().unreadCount}, expected ${before + 2}: the plain message in the mentions-only group was counted" }
+    val picker = alice.userPicker()
+    poll(what = "alice's row in the user picker showing ${before + 2}") { "${before + 2}" in textsOf(Ui.UserPicker.User(aliceUser().user.userId)) }
+    picker.switchTo("alice")
+    val chat = alice.chatList.open("team")
+    chat.itemId("bob's `plain` in team") { it.content.text == "plain" }
+    chat.itemId("bob's `@alice two` in team") { it.content.text == "@alice two" }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ModerationTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ModerationTest.kt
new file mode 100644
index 0000000000..919447e5dc
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ModerationTest.kt
@@ -0,0 +1,36 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.ownGroupWithTwo
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class ModerationTest : UiTest() {
+  @Test fun moderate_multipleSelected() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = ownGroupWithTwo(alice, bob, cath)
+    bob sends "#team spam one"
+    cath.eventuallyMessage("#team bob> spam one", CONNECT_TIMEOUT_MS)
+    cath sends "#team spam two"
+    bob.eventuallyMessage("#team cath> spam two", CONNECT_TIMEOUT_MS)
+    val one = chat.itemId("bob's `spam one`") { it.content.text == "spam one" }
+    val two = chat.itemId("cath's `spam two`") { it.content.text == "spam two" }
+    chat.select("spam one")
+    chat.toggle(two)
+    poll(what = "`Selected 2` in the selection toolbar") { chat.selectionTitle() == "Selected 2" }
+    click(Ui.Chat.Selection.part("moderate"))
+    poll(what = "the `Delete 2 messages of members?` alert saying they will be marked as moderated, with `Delete`") {
+      seesText("Delete 2 messages of members?") && seesText("The messages will be marked as moderated for all members.") &&
+        "Delete" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    bob.expectsMessage("#team bob> [marked deleted by alice] spam one", CONNECT_TIMEOUT_MS)
+    bob.expectsMessage("#team cath> [marked deleted by alice] spam two", CONNECT_TIMEOUT_MS)
+    cath.expectsMessage("#team bob> [marked deleted by alice] spam one", CONNECT_TIMEOUT_MS)
+    cath.expectsMessage("#team cath> [marked deleted by alice] spam two", CONNECT_TIMEOUT_MS)
+    poll(what = "both messages collapsed into `2 messages moderated by alice` and selection mode ended") {
+      "2 messages moderated by alice" in textsOf(Ui.Chat.Item(two)) && !exists(Ui.Chat.Item(one)) && !exists(Ui.Chat.Selection.part("title"))
+    }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ModeratorReportTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ModeratorReportTest.kt
new file mode 100644
index 0000000000..6905f17bc6
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/ModeratorReportTest.kt
@@ -0,0 +1,127 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.openReportsFromBanner
+import chat.simplex.app.ui.harness.ownGroupWithTwo
+import chat.simplex.app.ui.harness.receivesReport
+import chat.simplex.app.ui.harness.sendsReport
+import chat.simplex.app.ui.harness.reportsBanner
+import chat.simplex.app.ui.harness.setRoleViaApi
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class ModeratorReportTest : UiTest() {
+  @Test fun reports_moderatorBannerAndCounts() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = ownGroupWithTwo(alice, bob, cath)
+    cath sends "#team joke one"
+    cath sends "#team joke two"
+    bob.eventuallyMessage("#team cath> joke two", CONNECT_TIMEOUT_MS)
+    chat.itemId("cath's `joke two`") { it.content.text == "joke two" }
+    check(!exists(Ui.Chat.Reports)) { "a reports banner shown before any report" }
+    bob.sendsReport("team", "spam", "cath", "joke one")
+    reportsBanner("1 report")
+    bob.sendsReport("team", "community", "cath", "joke two")
+    reportsBanner("2 reports")
+    val info = chat.groupInfo()
+    poll(what = "`Member reports` with the count 2 in group info") { info.reportsTexts().let { "Member reports" in it && "2" in it } }
+    info.close()
+    val view = openReportsFromBanner()
+    val one = view.reportId("joke one")
+    val two = view.reportId("joke two")
+    check(view.texts(one).any { "Spam" in it } && view.texts(two).any { "Community guidelines violation" in it }) {
+      "the reports do not show their reasons: ${view.texts(one)}, ${view.texts(two)}"
+    }
+    view.menu(two, "delete")
+    val forMe = Ui.Alert.Option(Ui.AlertSource.Shared, "forMe")
+    poll(what = "the `Delete message?` alert for a report offering only `Delete for me`") {
+      seesText("Delete message?") && exists(forMe) && "Delete for me" in textsOf(forMe) && !exists(Ui.Alert.Option(Ui.AlertSource.Shared, "forEveryone"))
+    }
+    click(forMe)
+    poll(what = "the `joke two` report gone from `Member reports`, the `joke one` report kept") {
+      view.items().none { it.id == two } && !exists(Ui.Chat.Item(two)) && exists(Ui.Chat.Item(one))
+    }
+    view.close()
+    reportsBanner("1 report")
+    chat.send("after delete")
+    bob.expectsMessage("#team alice> after delete", CONNECT_TIMEOUT_MS)
+    cath.expectsMessage("#team alice> after delete", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun reports_archiveForMeForAllModeratorsAndAll() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = ownGroupWithTwo(alice, bob, cath)
+    setRoleViaApi("team", "cath", GroupMemberRole.Moderator)
+    cath.eventually("#team: alice changed your role from member to moderator (signed)", CONNECT_TIMEOUT_MS)
+    bob.eventually("#team: alice changed the role of cath from member to moderator (signed)", CONNECT_TIMEOUT_MS)
+    cath sends "#team joke one"
+    cath sends "#team joke two"
+    cath sends "#team joke three"
+    bob.eventuallyMessage("#team cath> joke three", CONNECT_TIMEOUT_MS)
+    chat.itemId("cath's `joke three`") { it.content.text == "joke three" }
+    bob.sendsReport("team", "spam", "cath", "joke one")
+    cath.receivesReport("team", "bob", "cath", "joke one", "report spam")
+    bob.sendsReport("team", "community", "cath", "joke two")
+    cath.receivesReport("team", "bob", "cath", "joke two", "report community")
+    bob.sendsReport("team", "profile", "cath", "joke three")
+    cath.receivesReport("team", "bob", "cath", "joke three", "report profile")
+    reportsBanner("3 reports")
+    val view = openReportsFromBanner()
+    val one = view.reportId("joke one")
+    val two = view.reportId("joke two")
+    val three = view.reportId("joke three")
+    check(listOf(one, two, three).none { id -> view.texts(id).any { "archived report" in it } }) { "a report shown as archived before archiving" }
+    view.archive(one, "archiveForMe")
+    poll(what = "the `joke one` report shown as `archived report`") { view.texts(one).any { "archived report" in it } }
+    view.archive(three, "archiveForAll")
+    cath.expectsMessage("#team (support: bob) bob> [marked deleted by alice] report profile", CONNECT_TIMEOUT_MS)
+    poll(what = "the `joke three` report shown as `archived report`") { view.texts(three).any { "archived report" in it } }
+    check(view.texts(two).none { "archived report" in it }) { "the `joke two` report was archived too" }
+    view.close()
+    reportsBanner("1 report")
+    backToChatList()
+    alice.chatList.rowMenu("team", "archiveReports")
+    poll(what = "the `Archive all reports?` alert with `Archive`") {
+      seesText("Archive all reports?") && seesText("All reports will be archived for you.") && "Archive" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "no active reports left in team") { alice.chatList.chat("team").chatStats.reportsCount == 0 }
+    alice.chatList.open("team")
+    chat.itemId("joke three")
+    check(!exists(Ui.Chat.Reports)) { "the reports banner still shown after `Archive all reports`" }
+    chat.send("after archive")
+    cath.expectsMessage("#team alice> after archive", CONNECT_TIMEOUT_MS)
+    bob.expectsMessage("#team alice> after archive", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun reports_moderateReportedMessageMarksReport() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = ownGroupWithTwo(alice, bob, cath)
+    cath sends "#team bad joke"
+    bob.eventuallyMessage("#team cath> bad joke", CONNECT_TIMEOUT_MS)
+    val joke = chat.itemId("cath's `bad joke`") { it.content.text == "bad joke" }
+    bob.sendsReport("team", "spam", "cath", "bad joke")
+    reportsBanner("1 report")
+    chat.menu("bad joke", "moderate")
+    poll(what = "the `Delete member message?` alert with `Delete`") {
+      seesText("Delete member message?") && "Delete" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    cath.expectsMessage("#team cath> [marked deleted by alice] bad joke", CONNECT_TIMEOUT_MS)
+    bob.expectsMessage("#team cath> [marked deleted by alice] bad joke", CONNECT_TIMEOUT_MS)
+    bob expects "#team: 1 messages deleted by member alice"
+    poll(what = "`moderated by alice` in place of `bad joke` and the reports banner gone") {
+      textsOf(Ui.Chat.Item(joke)).let { t -> "moderated by alice" in t && t.none { "bad joke" in it } } && !exists(Ui.Chat.Reports)
+    }
+    val info = chat.groupInfo()
+    poll(what = "`Member reports` in group info without a count") { info.reportsTexts().let { "Member reports" in it && "1" !in it } }
+    val view = info.reports()
+    val report = view.reportId("bad joke")
+    poll(what = "the `bad joke` report shown as `archived report`") { view.texts(report).any { "archived report" in it } }
+    view.close()
+    info.close()
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/SupportChatTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/SupportChatTest.kt
new file mode 100644
index 0000000000..588cf01e96
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/groups/SupportChatTest.kt
@@ -0,0 +1,203 @@
+package chat.simplex.app.ui.groups
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.CliPeer
+import chat.simplex.app.ui.harness.MemberSupportScreen
+import chat.simplex.app.ui.harness.SupportChatScreen
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.closeMemberInfo
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.expectsScopedMessage
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.groupInfoOf
+import chat.simplex.app.ui.harness.groupMemberId
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.joinGroupFromList
+import chat.simplex.app.ui.harness.memberConnected
+import chat.simplex.app.ui.harness.memberOfBobsTeamWithCath
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.app.ui.harness.openSupportRowMenu
+import chat.simplex.app.ui.harness.ownTeamWithSupportRequests
+import chat.simplex.app.ui.harness.supportBanner
+import chat.simplex.app.ui.harness.supportRowBadge
+import chat.simplex.app.ui.harness.unreadBadge
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.ModalManager
+import org.junit.Test
+
+class SupportChatTest : UiTest() {
+  @Test fun supportChat_memberSendsToAdmins() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = memberOfBobsTeamWithCath(alice, bob, cath)
+    poll(what = "team's chat open with no support banner") { exists(Ui.Chat.Message) && supportBanner().isEmpty() }
+    bob sends "#team (support: alice) first"
+    bob sends "#team (support: alice) second"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `2 messages` banner in team's chat") { "2 messages" in supportBanner() }
+    val info = chat.groupInfo()
+    poll(what = "`Chat with admins` with 2 unread in group info") {
+      exists(Ui.GroupInfo.UserSupport) && "Chat with admins" in textsOf(Ui.GroupInfo.UserSupport) && unreadBadge(Ui.GroupInfo.UserSupport) == "2"
+    }
+    waitStable(Ui.GroupInfo.UserSupport)
+    click(Ui.GroupInfo.UserSupport)
+    val sc = SupportChatScreen(this)
+    sc.waitOpen()
+    sc.itemId("first")
+    sc.itemId("second")
+    poll(what = "bob's two support messages marked read in alice's support chat") {
+      sc.items().filter { it.content.text == "first" || it.content.text == "second" }.let { it.size == 2 && it.none { i -> i.isRcvNew } }
+    }
+    sc.send("hello")
+    bob.expectsScopedMessage("#team (support: alice) alice", "hello")
+    check(chat.itemTexts().none { it == "hello" || it == "first" || it == "second" }) { "a support message was added to team's main chat" }
+    sc.close()
+    info.close()
+    poll(what = "the support banner gone after the messages were read") { exists(Ui.Chat.Message) && supportBanner().isEmpty() }
+    bob sends "#team (support: alice) third"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `1 messages` banner in team's chat") { "1 messages" in supportBanner() }
+    click(Ui.Chat.SupportChats)
+    val again = SupportChatScreen(this)
+    again.waitOpen()
+    again.itemId("third")
+    again.itemId("hello")
+    again.close()
+    chat.send("for everyone")
+    cath.expectsMessage("#team alice> for everyone", CONNECT_TIMEOUT_MS)
+    bob.expectsMessage("#team alice> for everyone", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun chatsWithMembers_markRead() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    ownTeamWithSupportRequests(alice, bob, cath)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `2 chats with members` banner in team's chat") { supportBanner().any { it.startsWith("2 chat") } }
+    click(Ui.Chat.SupportChats)
+    MemberSupportScreen(this)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's and cath's support chats each with 1 unread") { supportRowBadge("bob") == "1" && supportRowBadge("cath") == "1" }
+    val bobId = openSupportRowMenu("bob")
+    click(Ui.MemberSupport.RowMenu(bobId, "markRead"))
+    poll(what = "bob's unread badge gone and cath's kept") {
+      exists(Ui.MemberSupport.Row(bobId)) && supportRowBadge("bob") == null && supportRowBadge("cath") == "1"
+    }
+    openSupportRowMenu("bob")
+    check(!exists(Ui.MemberSupport.RowMenu(bobId, "markRead"))) { "`Mark read` offered for bob's chat with no unread messages" }
+    click(Ui.MemberSupport.RowMenu(bobId, "delete"))
+    poll(what = "the `Delete chat with member?` alert with `Delete chat`") {
+      seesText("Delete chat with member?") && "Delete chat" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    val cathId = groupMemberId("cath")
+    poll(what = "bob's support chat gone from `Chats with members` and cath's kept") {
+      !exists(Ui.MemberSupport.Row(bobId)) && exists(Ui.MemberSupport.Row(cathId)) && supportRowBadge("cath") == "1"
+    }
+    goBack()
+    poll(what = "`Chats with members` closed to team's chat showing `1 chat`") {
+      !ModalManager.end.hasModalsOpen() && supportBanner().any { it.startsWith("1 chat") }
+    }
+  }
+
+  @Test fun chatsWithMembers_listSearchAndOpen() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val chat = ownTeamWithSupportRequests(alice, bob, cath)
+    val info = chat.groupInfo()
+    val cwm = info.chatsWithMembers()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob and cath listed in `Chats with members`") { "bob" in cwm.rowTexts("bob") && "cath" in cwm.rowTexts("cath") }
+    typeInto(Ui.MemberSupport.Search, "bo")
+    poll(what = "only bob listed for `bo`") { "bob" in cwm.rowTexts("bob") && cwm.rowTexts("cath").isEmpty() }
+    replaceText(Ui.MemberSupport.Search, "cat")
+    poll(what = "only cath listed for `cat`") { "cath" in cwm.rowTexts("cath") && cwm.rowTexts("bob").isEmpty() }
+    hideKeyboard()
+    val sc = cwm.open("cath")
+    sc.itemId("cath needs help")
+    check(sc.items().none { it.content.text == "bob needs help" }) { "bob's support message is shown in cath's support chat" }
+    sc.send("hi cath")
+    cath.expectsMessage("#team (support) alice> hi cath", CONNECT_TIMEOUT_MS)
+    check(chat.itemTexts().none { it == "hi cath" }) { "alice's support reply was added to team's main chat" }
+    sc.close()
+    cwm.close()
+    info.close()
+    chat.send("for everyone")
+    bob.expectsMessage("#team alice> for everyone", CONNECT_TIMEOUT_MS)
+    cath.expectsMessage("#team alice> for everyone", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun chatsWithMembers_disabledState() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    hostGroup(bob, "team", "alice")
+    joinGroupFromList(alice, bob, "team")
+    backToChatList()
+    val info = alice.chatList.open("team").groupInfo()
+    fun supportOn() = groupInfoOf("team").fullGroupPreferences.support.on
+    poll(what = "`Chat with admins` and no `Chats with members` in a member's group info while support is on") {
+      supportOn() && exists(Ui.GroupInfo.Preferences) && exists(Ui.GroupInfo.UserSupport) && !exists(Ui.GroupInfo.MemberSupport)
+    }
+    bob.setsSupport("off")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Chat with admins` gone with support off, as alice has no support chat") {
+      !supportOn() && exists(Ui.GroupInfo.Preferences) && !exists(Ui.GroupInfo.UserSupport)
+    }
+    bob.setsSupport("on")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Chat with admins` back with support on") { supportOn() && exists(Ui.GroupInfo.UserSupport) }
+    waitStable(Ui.GroupInfo.UserSupport)
+    click(Ui.GroupInfo.UserSupport)
+    val sc = SupportChatScreen(this)
+    sc.waitOpen()
+    sc.send("help please")
+    bob.eventuallyMatching(Regex("(\\d{2}:\\d{2} )?#team \\(support: alice\\) alice!?> help please"), CONNECT_TIMEOUT_MS)
+    sc.close()
+    bob.setsSupport("off")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Chat with admins` kept with support off, as alice has a support chat") {
+      !supportOn() && exists(Ui.GroupInfo.Preferences) && exists(Ui.GroupInfo.UserSupport)
+    }
+    bob sends "/mr team alice moderator"
+    bob.eventuallyMatching(Regex("#team: you changed the role of alice to moderator( \\(signed\\))?"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Chats with members` in the group info of the moderator alice") {
+      groupInfoOf("team").membership.memberRole == GroupMemberRole.Moderator && exists(Ui.GroupInfo.MemberSupport)
+    }
+    info.chatsWithMembers()
+    poll(what = "`Chats with members are disabled`, not `No chats with members`") {
+      seesText("Chats with members are disabled") && !seesText("No chats with members")
+    }
+  }
+
+  @Test fun supportChat_adminOpensFromMemberInfo() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = ownGroup(alice, "team", bob)
+    val info = chat.groupInfo()
+    memberConnected(info, "bob")
+    val member = info.member("bob")
+    poll(what = "`Chat with member` in the member bob's member info") {
+      exists(Ui.MemberInfo.SupportChat) && "Chat with member" in textsOf(Ui.MemberInfo.SupportChat)
+    }
+    member.changeRole(GroupMemberRole.Moderator)
+    bob.eventually("#team: alice changed your role from member to moderator (signed)", CONNECT_TIMEOUT_MS)
+    poll(what = "no `Chat with member` for the moderator bob, who has no support chat") {
+      "moderator" in textsOf(Ui.MemberInfo.Role) && !exists(Ui.MemberInfo.SupportChat)
+    }
+    member.changeRole(GroupMemberRole.Member)
+    bob.eventually("#team: alice changed your role from moderator to member (signed)", CONNECT_TIMEOUT_MS)
+    poll(what = "`Chat with member` back for the member bob") { "member" in textsOf(Ui.MemberInfo.Role) && exists(Ui.MemberInfo.SupportChat) }
+    closeMemberInfo("bob")
+    info.close()
+    poll(what = "team's chat with no support banner before bob's support message") { exists(Ui.Chat.Message) && supportBanner().isEmpty() }
+    bob sends "#team (support) bob needs help"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `1 chat` banner for bob's support message in team's chat") {
+      supportBanner().any { it.startsWith("1 chat") }
+    }
+    chat.groupInfo().member("bob")
+    click(Ui.MemberInfo.SupportChat)
+    val sc = SupportChatScreen(this)
+    sc.waitOpen()
+    sc.itemId("bob needs help")
+    sc.send("on it")
+    bob.eventuallyMessage("#team (support) alice> on it", CONNECT_TIMEOUT_MS)
+    check(chat.itemTexts().none { it == "on it" || it == "bob needs help" }) { "a support message was added to team's main chat" }
+  }
+
+  private fun CliPeer.setsSupport(state: String) {
+    this sends "/set support #team $state"
+    eventually("updated group preferences:")
+    this expects "Chat with admins: $state"
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/BusinessChatScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/BusinessChatScreens.kt
new file mode 100644
index 0000000000..83318d8ee5
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/BusinessChatScreens.kt
@@ -0,0 +1,30 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.BusinessChatType
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.ModalManager
+
+fun businessTypeOf(name: String): BusinessChatType? =
+  chatModel.chats.value.firstNotNullOfOrNull { c -> (c.chatInfo as? ChatInfo.Group)?.groupInfo?.takeIf { c.chatInfo.chatViewName == name }?.businessChat?.chatType }
+
+fun UiScope.createBusinessAddress(app: App): String {
+  val address = app.userPicker().address().create()
+  waitFor(Ui.Address.Business)
+  click(Ui.Address.Business)
+  poll(what = "a business address with auto-accept saved") { savedAddressSettings()?.let { it.businessAddress && it.autoAccept != null } == true }
+  AddressScreen(this).close()
+  return address
+}
+
+fun UiScope.leaveBusinessChatFromInfo(name: String) {
+  groupInfoRow(Ui.GroupInfo.Leave)
+  confirmAlert("Leave chat?", "$name\n\nYou will stop receiving messages from this chat. Chat history will be preserved.", "Leave")
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "group info to close after leaving `$name`") { !ModalManager.end.hasModalsOpen() }
+}
+
+fun UiScope.deleteBusinessChatFromInfo(name: String) {
+  groupInfoRow(Ui.GroupInfo.Delete)
+  confirmAlert("Delete chat?", "$name\n\nChat will be deleted for all members - this cannot be undone!", "Delete")
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChannelScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChannelScreens.kt
new file mode 100644
index 0000000000..105f8a5507
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChannelScreens.kt
@@ -0,0 +1,97 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import kotlinx.coroutines.runBlocking
+
+class ChannelLinkScreen(private val s: UiScope, private val channel: String) {
+  init {
+    s.poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Channel link` screen of `$channel` with `Share link` and `Continue`") {
+      s.seesText("Channel link") && s.exists(Ui.GroupLink.Share) && s.exists(Ui.GroupLink.Continue)
+    }
+  }
+
+  fun share(): String {
+    s.click(Ui.GroupLink.Share)
+    var link: String? = null
+    s.poll(what = "the channel link of `$channel` shared") { link = s.clipboardText()?.takeIf { it.isNotBlank() }; link != null }
+    return link!!
+  }
+
+  fun continueToChannel(): ChatScreen {
+    s.click(Ui.GroupLink.Continue)
+    s.poll(what = "the `Channel link` screen to close with `$channel` open") {
+      !s.exists(Ui.GroupLink.Share) && chatModel.chatId.value != null && chatModel.chatId.value == channelChatId(channel)
+    }
+    return ChatScreen(s)
+  }
+}
+
+fun channelChatId(name: String): String? =
+  chatModel.chats.value.singleOrNull { (it.chatInfo as? ChatInfo.Group)?.groupInfo?.let { g -> g.useRelays && g.groupProfile.displayName == name } == true }?.id
+
+fun UiScope.createChannel(app: App, name: String): ChannelLinkScreen {
+  app.newChat()
+  click(Ui.NewChat.CreateChannel)
+  typeInto(Ui.NewChannel.Name, name)
+  click(Ui.NewChannel.Create)
+  return ChannelLinkScreen(this, name)
+}
+
+fun channelLinkViaApi(name: String): String {
+  val groupId = groupInfoOf(name).groupId
+  val link = runBlocking { chatController.apiGetGroupLink(null, groupId) } ?: error("apiGetGroupLink failed for $name")
+  return link.connLinkContact.simplexChatUri(short = true)
+}
+
+fun CliPeer.joinChannel(channel: String, link: String, vararg relays: CliPeer) {
+  this sends "/c $link"
+  this expects "#$channel: connection started"
+  eventuallyAll(
+    relays.flatMap { listOf("#$channel: joining the group (connecting to relay ${it.name})...", "#$channel: you joined the group (connected to relay ${it.name})") },
+    timeoutMs = CONNECT_TIMEOUT_MS
+  )
+  for (r in relays) {
+    r.eventually("$name: accepting request to join group #$channel...", CONNECT_TIMEOUT_MS)
+    r.eventually("#$channel: $name joined the group", CONNECT_TIMEOUT_MS)
+  }
+}
+
+fun CliPeer.createChannel(channel: String, relay: CliPeer): String {
+  this sends "/relays name=${relay.name} ${relay.relayAddress}"
+  this expects "ok"
+  this sends "/public group relays=1 #$channel"
+  this expects "group #$channel is created"
+  this expects "wait for selected relay(s) to join, then you can invite members via group link"
+  eventually("  - relay id 1: active", CONNECT_TIMEOUT_MS)
+  this expects "group link:"
+  val link = nextLine()
+  relay.eventually("#$channel: you joined the group as relay", CONNECT_TIMEOUT_MS)
+  return link
+}
+
+fun UiScope.openPreparedChannelFromSearch(link: String, name: String): ChatScreen {
+  enterLinkInSearch(link)
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the plan alert for channel `$name` with `Open channel`") {
+    exists(planConfirm) && "Open channel" in textsOf(planConfirm) && seesText(name)
+  }
+  click(planConfirm)
+  poll(what = "`$name`'s prepared channel open") {
+    val id = channelChatId(name)
+    id != null && id == chatModel.chatId.value && chatModel.chats.value.first { it.id == id }.chatInfo.nextConnectPrepared
+  }
+  return ChatScreen(this)
+}
+
+fun UiScope.joinPreparedChannel(name: String, owner: CliPeer, relay: CliPeer) {
+  poll(what = "`Join channel` in place of the message field") { exists(Ui.Chat.Connect) && "Join channel" in textsOf(Ui.Chat.Connect) }
+  click(Ui.Chat.Connect)
+  val me = chatModel.currentUser.value!!.displayName
+  owner.eventually("#$name: ${relay.name} introduced $me in the channel", CONNECT_TIMEOUT_MS)
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the message field in place of `Join channel` in `$name`") {
+    !exists(Ui.Chat.Connect) && exists(Ui.Chat.Message) && channelChatId(name)?.let { id -> chatModel.chats.value.first { it.id == id }.chatInfo.nextConnectPrepared } == false
+  }
+  quiesce()
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatItemActionsScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatItemActionsScreens.kt
new file mode 100644
index 0000000000..933bbfe988
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatItemActionsScreens.kt
@@ -0,0 +1,51 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.CIFile
+import chat.simplex.common.model.MsgReaction
+import chat.simplex.common.model.readCryptoFile
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.platform.getLoadedFilePath
+import chat.simplex.common.ui.Ui
+import java.io.File
+
+fun UiScope.openAttachmentSheet() {
+  hideKeyboard()
+  click(described("Attach"))
+  poll(what = "the attachment sheet over the chat with Image, Video and File") {
+    seesDescription("Close sheet") && exists(Ui.Chat.Attach("image")) && exists(Ui.Chat.Attach("video")) && exists(Ui.Chat.Attach("file"))
+  }
+}
+
+fun UiScope.attachFile(file: File) {
+  openAttachmentSheet()
+  openFile(file) { click(Ui.Chat.Attach("file")) }
+  poll(what = "the preview of ${file.name} with `Cancel file preview`") { seesDescription("Cancel file preview") && seesText(file.name) }
+}
+
+fun UiScope.closeItemMenu(id: Long) {
+  click(Ui.Chat.ItemMenu(id, "select"))
+  waitFor(Ui.Chat.Selection.part("title"))
+  escape()
+  poll(what = "selection mode to end") { !exists(Ui.Chat.Selection.part("title")) }
+}
+
+fun UiScope.offeredReactions(id: Long): List<String> {
+  rightClick(Ui.Chat.Item(id))
+  waitFor(Ui.Chat.ItemMenu(id, "reply"))
+  val offered = MsgReaction.supported.map { it.text }.filter { exists(Ui.Chat.ItemReaction(id, it)) }
+  closeItemMenu(id)
+  return offered
+}
+
+fun itemFileOf(id: Long): CIFile? = chatModel.chatsContext.chatItems.value.firstOrNull { it.id == id }?.file
+
+fun storedBytesOf(file: CIFile): ByteArray {
+  val path = getLoadedFilePath(file) ?: throw AssertionError("${file.fileName} is not on disk (status ${file.fileStatus})")
+  return File(path).readBytes()
+}
+
+fun plainBytesOf(file: CIFile): ByteArray {
+  val path = getLoadedFilePath(file) ?: throw AssertionError("${file.fileName} is not on disk (status ${file.fileStatus})")
+  val args = file.fileSource?.cryptoArgs
+  return if (args != null) readCryptoFile(path, args) else File(path).readBytes()
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatListFilterScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatListFilterScreens.kt
index 8f56a2445c..b2e0208da1 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatListFilterScreens.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatListFilterScreens.kt
@@ -77,11 +77,15 @@ fun UiScope.businessChat(biz: CliPeer) {
   quiesce()
 }
 
-fun CliPeer.createAddress(business: Boolean = false): String {
+fun CliPeer.createAddress(business: Boolean = false, autoAccept: Boolean = true): String {
   this sends "/ad"
   this expects "Your new chat address is created!"
   this expects ""
   val link = nextLine()
+  if (!autoAccept) {
+    eventually("to delete it: /da (accepted contacts will remain connected)")
+    return link
+  }
   this sends (if (business) "/auto_accept on business" else "/auto_accept on")
   eventually(if (business) "auto_accept on, business" else "auto_accept on")
   return link
@@ -95,8 +99,6 @@ fun CliPeer.createGroupLink(group: String): String {
   return nextLine()
 }
 
-val planConfirm = Ui.Alert.Confirm(Ui.AlertSource.PrivacySensitive)
-
 fun UiScope.enterLinkInSearch(link: String) = enterText(Ui.ChatList.Search, link)
 
 fun UiScope.searchShowsLink(description: String): Boolean =
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatMessagesScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatMessagesScreens.kt
new file mode 100644
index 0000000000..3f85f25212
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatMessagesScreens.kt
@@ -0,0 +1,29 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.ui.Ui
+
+private const val BOT_COMMANDS =
+  """[{"type":"command","keyword":"help","label":"Help"},{"type":"command","keyword":"order","label":"Order","params":"<number>"},""" +
+    """{"type":"menu","label":"More","commands":[{"type":"command","keyword":"status","label":"Status"},{"type":"command","keyword":"cost","label":"Cost"}]}]"""
+private val BOT_COMMANDS_FOOTER = Regex("use /set bot commands .* or /delete bot commands")
+
+const val PREVIEW_IMAGE_DATA =
+  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII="
+
+fun CliPeer.becomeBotWithCommands() {
+  this sends """/_profile 1 {"displayName":"$name","fullName":"","peerType":"bot","preferences":{"commands":$BOT_COMMANDS}}"""
+  this sends "/u"
+  eventually("user profile: $name (bot)")
+  this expects "use /p <name> [<bio>] to change it"
+  this expects "Bot commands:"
+  eventuallyMatching(BOT_COMMANDS_FOOTER)
+}
+
+fun UiScope.openItemInfo(id: Long, title: String): ItemInfoScreen {
+  itemMenu(id, "info")
+  poll(what = "the item info titled `$title`") { seesText(title) }
+  return ItemInfoScreen(this)
+}
+
+fun UiScope.commandShown(keyword: String, label: String): Boolean =
+  exists(Ui.Chat.Command(keyword)) && textsOf(Ui.Chat.Command(keyword)).let { label in it && "/$keyword" in it }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatViewScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatViewScreens.kt
new file mode 100644
index 0000000000..1b73c8f8f3
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ChatViewScreens.kt
@@ -0,0 +1,30 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatItem
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+
+fun contentFilter(name: String): UiKey = Ui.Chat.ContentFilter.option(name)
+
+fun UiScope.pickContentFilter(name: String) {
+  click(Ui.Chat.ContentFilter)
+  click(contentFilter(name))
+}
+
+fun loadedItemIds(): Set<Long> = chatModel.chatsContext.chatItems.value.map { it.id }.toSet()
+
+fun UiScope.loadedItemId(what: String, match: (ChatItem) -> Boolean): Long {
+  var id: Long? = null
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = what) {
+    id = chatModel.chatsContext.chatItems.value.lastOrNull(match)?.id
+    id != null
+  }
+  return id!!
+}
+
+fun UiScope.closeChatSearch() {
+  hideKeyboard()
+  goBack()
+  poll(what = "the chat search to close") { !exists(Ui.Chat.Bar.part("search")) }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ConnectScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ConnectScreens.kt
new file mode 100644
index 0000000000..12e541393a
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ConnectScreens.kt
@@ -0,0 +1,64 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.MsgContent
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+
+val planConfirm = Ui.Alert.Confirm(Ui.AlertSource.PrivacySensitive)
+
+val planDismiss = Ui.Alert.Dismiss(Ui.AlertSource.PrivacySensitive)
+
+fun planOption(name: String) = Ui.Alert.Option(Ui.AlertSource.PrivacySensitive, name)
+
+fun UiScope.openPasteLink(app: App) {
+  app.newChat()
+  click(Ui.NewChat.PasteLink)
+  poll(what = "the `Paste the link you received` section with `Tap to paste link`") {
+    seesText("Paste the link you received") && exists(Ui.Link.Paste) && "Tap to paste link" in textsOf(Ui.Link.Paste)
+  }
+}
+
+fun UiScope.enterLinkInNewChatSearch(app: App, link: String) {
+  app.newChat()
+  enterText(Ui.NewChat.Search, link)
+}
+
+fun UiScope.openNewChatFromSearch(link: String, name: String): ChatScreen {
+  enterLinkInSearch(link)
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the plan alert for `$name` with `Open new chat`") {
+    exists(planConfirm) && "Open new chat" in textsOf(planConfirm) && seesText(name)
+  }
+  click(planConfirm)
+  poll(what = "`$name`'s prepared chat open") {
+    chatModel.chats.value.firstOrNull { it.chatInfo.chatViewName == name && it.chatInfo.nextConnectPrepared }?.id?.let { it == chatModel.chatId.value } == true
+  }
+  return ChatScreen(this)
+}
+
+fun UiScope.chatLinkItemId(): Long {
+  var id: Long? = null
+  poll(what = "a chat link card in the open chat") {
+    id = chatModel.chatsContext.chatItems.value.lastOrNull { it.content.msgContent is MsgContent.MCChat }?.id
+    id != null && exists(Ui.Chat.Item(id!!))
+  }
+  return id!!
+}
+
+fun CliPeer.createFullOneTimeLink(): String {
+  this types "/c"
+  eventually("The invitation link for old clients:")
+  return nextLine()
+}
+
+fun CliPeer.createFullAddress(): String {
+  this sends "/ad"
+  this expects "Your new chat address is created!"
+  return eventuallyMatching(Regex("The contact link for old clients: (\\S+)")).groupValues[1]
+}
+
+fun CliPeer.becomeBot() {
+  this sends """/_profile 1 {"displayName":"$name","fullName":"","peerType":"bot"}"""
+  this sends "/u"
+  eventually("user profile: $name (bot)")
+  this expects "use /p <name> [<bio>] to change it"
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ContactDetailsScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ContactDetailsScreens.kt
new file mode 100644
index 0000000000..8653c30b5c
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ContactDetailsScreens.kt
@@ -0,0 +1,71 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatFeature
+import chat.simplex.common.model.FeatureAllowed
+import chat.simplex.common.model.FullChatPreferences
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+
+class UserPrefsScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the `Your preferences` screen") { s.exists(Ui.UserPrefs.Timed) && s.exists(Ui.UserPrefs.Allow(ChatFeature.Calls)) }
+    s.waitStable(Ui.UserPrefs.Allow(ChatFeature.FullDelete))
+  }
+
+  fun allow(f: ChatFeature, option: FeatureAllowed) {
+    s.click(Ui.UserPrefs.Allow(f))
+    s.click(Ui.UserPrefs.Allow(f).option(option))
+  }
+
+  fun allowTexts(f: ChatFeature): List<String> = s.textsOf(Ui.UserPrefs.Allow(f))
+
+  fun toggleTimed() = s.click(Ui.UserPrefs.Timed)
+
+  fun reset() = s.click(Ui.UserPrefs.Reset)
+
+  fun save() = s.click(Ui.UserPrefs.Save)
+
+  fun backExpectingAlert() {
+    s.goBack()
+    s.poll(what = "the `Save preferences?` alert") { s.seesText("Save preferences?") }
+  }
+
+  fun backClosing() {
+    s.goBack()
+    s.poll(what = "your preferences to close without an alert") { !s.exists(Ui.UserPrefs.Save) && !s.seesText("Save preferences?") }
+  }
+}
+
+fun UiScope.userPrefs(app: App): UserPrefsScreen {
+  app.userPicker()
+  click(described("Chat preferences"))
+  return UserPrefsScreen(this)
+}
+
+fun savedUserPrefs(): FullChatPreferences = chatModel.currentUser.value!!.fullPreferences
+
+fun UiScope.keepIncognitoOneTimeLink(app: App) {
+  val before = pendingConnectionIds()
+  app.newChat().createOneTimeLink()
+  click(Ui.Link.ShareProfile)
+  click(Ui.Link.ProfileIncognito)
+  poll(what = "the 1-time link switched to incognito") { seesText(NEW_RANDOM_PROFILE) && !exists(Ui.Link.ProfileIncognito) }
+  goBack()
+  closeNewChatSheet()
+  poll(what = "the incognito link's pending connection kept") { pendingConnectionIds().size == before.size + 1 }
+}
+
+fun UiScope.archiveContact(app: App, name: String) {
+  app.chatList.rowMenu(name, "delete")
+  click(Ui.Alert.Option(Ui.AlertSource.Shared, "onlyConversation"))
+  poll(what = "`$name` archived and hidden from the chat list") { contactOf(name).chatDeleted && !app.chatList.shown(name) }
+}
+
+fun UiScope.openArchivedContact(app: App, name: String): ChatScreen {
+  val id = app.chatList.chatId(name)
+  app.newChat()
+  click(described("Archived contacts"))
+  click(Ui.NewChat.Contact(id))
+  poll(what = "`$name`'s archived chat open") { chatModel.chatId.value == id }
+  return ChatScreen(this)
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ContactInfoScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ContactInfoScreens.kt
new file mode 100644
index 0000000000..b821a272ad
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ContactInfoScreens.kt
@@ -0,0 +1,54 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.ServerAddress
+import chat.simplex.common.model.ServerAddress.Companion.parseServerAddress
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import kotlinx.coroutines.runBlocking
+
+fun setContactAliasViaApi(name: String, alias: String) {
+  val contactId = contactOf(name).contactId
+  runBlocking { chatController.apiSetContactAlias(null, contactId, alias) } ?: error("apiSetContactAlias failed")
+}
+
+fun markContactVerifiedViaApi(name: String) {
+  val contactId = contactOf(name).contactId
+  val code = runBlocking { chatController.apiGetContactCode(null, contactId) }?.second ?: error("apiGetContactCode failed")
+  val (verified, _) = runBlocking { chatController.apiVerifyContact(null, contactId, code) } ?: error("apiVerifyContact failed")
+  check(verified) { "apiVerifyContact did not verify $name with its own code" }
+}
+
+fun localSmpServer(): ServerAddress {
+  val groups = runBlocking { chatController.getUserServers(null) } ?: error("getUserServers failed")
+  val server = groups.flatMap { it.smpServers }.first { it.enabled && !it.deleted && !it.preset }.server
+  return parseServerAddress(server) ?: error("cannot parse the local SMP server `$server`")
+}
+
+fun isServer(text: String?, expected: ServerAddress): Boolean =
+  text != null && parseServerAddress(text)?.let { it.hostnames == expected.hostnames && it.port == expected.port && it.keyHash == expected.keyHash } == true
+
+fun UiScope.copiedServer(row: UiKey): String? {
+  setClipboardText(null)
+  click(row)
+  var copied: String? = null
+  poll(what = "the server of ${row.tag} on the clipboard") { copied = clipboardText()?.takeIf { it.isNotBlank() }; copied != null }
+  return copied
+}
+
+fun UiScope.joinOneTimeLinkInSearch(link: String) {
+  enterLinkInSearch(link)
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Connect via one-time link?` alert with `Use current profile`") {
+    seesText("Connect via one-time link?") && exists(planOption("useCurrentProfile"))
+  }
+  click(planOption("useCurrentProfile"))
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Connection request sent!`") { seesText("Connection request sent!") && exists(planConfirm) }
+  click(planConfirm)
+  poll(what = "the alert closed with a pending connection in the list") {
+    !seesText("Connection request sent!") && chatModel.chats.value.any { it.chatInfo is ChatInfo.ContactConnection }
+  }
+}
+
+fun UiScope.infoNameText(): String? = if (exists(Ui.Info.Name)) textOf(Ui.Info.Name) else null
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ContactsScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ContactsScreens.kt
new file mode 100644
index 0000000000..9658a83527
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ContactsScreens.kt
@@ -0,0 +1,117 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.AddressSettings
+import chat.simplex.common.model.ChatFeature
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.Contact
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.ModalManager
+
+fun contactOf(name: String): Contact =
+  (chatModel.chats.value.first { it.chatInfo.chatViewName == name }.chatInfo as ChatInfo.Direct).contact
+
+fun savedAddressSettings(): AddressSettings? = chatModel.userAddress.value?.addressSettings
+
+fun UiScope.shareAddress(): String {
+  click(Ui.Address.Share)
+  var link: String? = null
+  poll(what = "the address on the clipboard") { link = clipboardText()?.takeIf { it.isNotBlank() }; link != null }
+  return link!!
+}
+
+class AddressSettingsScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the `Address settings` screen") { s.exists(Ui.Address.AutoAccept) && s.exists(Ui.Address.WelcomeMessage) }
+    s.waitStable(Ui.Address.AutoAccept)
+  }
+
+  fun toggleAutoAccept() = s.click(Ui.Address.AutoAccept)
+
+  fun autoAcceptEnabled(): Boolean = s.isEnabled(Ui.Address.AutoAccept)
+
+  fun welcome(text: String) {
+    s.typeInto(Ui.Address.WelcomeMessage, text)
+    s.hideKeyboard()
+  }
+
+  fun replaceWelcome(text: String) {
+    s.replaceText(Ui.Address.WelcomeMessage, text)
+    s.hideKeyboard()
+  }
+
+  fun save() = s.click(Ui.Address.SaveSettings)
+
+  fun close() {
+    s.escape()
+    s.poll(what = "address settings to close to the address screen") { !s.exists(Ui.Address.AutoAccept) && s.exists(Ui.Address.Business) }
+    s.waitStable(Ui.Address.Business)
+  }
+}
+
+fun UiScope.addressSettings(): AddressSettingsScreen {
+  click(Ui.Address.Settings)
+  return AddressSettingsScreen(this)
+}
+
+fun CliPeer.addressPlanOk(link: String): Boolean {
+  this sends "/_connect plan 1 $link"
+  val line = nextLine(CONNECT_TIMEOUT_MS)
+  if ("error: connection authorization failed" in line) return false
+  check(line == "contact address: ok to connect") { "$name: unexpected plan for the address: `$line`; next: ${pending()}" }
+  this sends "/u"
+  eventually("user profile: $name")
+  this expects "use /p <name> [<bio>] to change it"
+  return true
+}
+
+fun CliPeer.awaitAddressGone(link: String) {
+  val deadline = System.currentTimeMillis() + CONNECT_TIMEOUT_MS
+  while (addressPlanOk(link)) {
+    check(System.currentTimeMillis() < deadline) { "$name: the address still accepts connections ${CONNECT_TIMEOUT_MS / 1000} s after it was deleted" }
+  }
+}
+
+class ContactPrefsScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the `Contact preferences` screen") { s.exists(Ui.ContactPrefs.Timed) && s.exists(Ui.ContactPrefs.Allow(ChatFeature.FullDelete)) }
+    s.waitStable(Ui.ContactPrefs.Allow(ChatFeature.FullDelete))
+  }
+
+  fun allow(f: ChatFeature, option: String) {
+    s.click(Ui.ContactPrefs.Allow(f))
+    s.click(Ui.ContactPrefs.Allow(f).option(option))
+  }
+
+  fun allowTexts(f: ChatFeature): List<String> = s.textsOf(Ui.ContactPrefs.Allow(f))
+
+  fun toggleTimed() = s.click(Ui.ContactPrefs.Timed)
+
+  fun ttlShown(): Boolean = s.exists(Ui.ContactPrefs.Ttl)
+
+  fun ttlTexts(): List<String> = s.textsOf(Ui.ContactPrefs.Ttl)
+
+  fun reset() = s.click(Ui.ContactPrefs.Reset)
+
+  fun save() = s.click(Ui.ContactPrefs.Save)
+
+  fun backExpectingAlert() {
+    s.goBack()
+    s.poll(what = "the `Save preferences?` alert") { s.seesText("Save preferences?") }
+  }
+
+  fun backClosing() {
+    s.goBack()
+    s.poll(what = "contact preferences to close without an alert") { !s.exists(Ui.ContactPrefs.Save) && !s.seesText("Save preferences?") }
+  }
+}
+
+fun UiScope.contactPrefs(): ContactPrefsScreen {
+  click(Ui.Info.Preferences)
+  return ContactPrefsScreen(this)
+}
+
+fun UiScope.closeContactInfo() {
+  escape()
+  poll(what = "contact info to close") { !ModalManager.end.hasModalsOpen() }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/DatabaseScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/DatabaseScreens.kt
new file mode 100644
index 0000000000..3b4000e3ee
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/DatabaseScreens.kt
@@ -0,0 +1,107 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.CC
+import chat.simplex.common.model.CR
+import chat.simplex.common.model.ChatItemTTL
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import chat.simplex.common.ui.UiKey
+import chat.simplex.common.views.helpers.AlertManager
+import kotlinx.coroutines.runBlocking
+
+const val DB_WORK_TIMEOUT_MS = 120_000L
+
+fun UiScope.typeSecret(key: UiKey, text: String) {
+  val before = editableText(key).orEmpty().length
+  enterText(key, text)
+  poll(what = "field ${key.tag} to hold ${before + text.length} characters") { editableText(key)?.length == before + text.length }
+}
+
+fun chatRunningInCore(): Boolean = runBlocking { chatController.sendCmd(null, CC.CheckChatRunning()) }.result is CR.ChatRunning
+
+fun UiScope.chatData(app: App): ChatDataScreen {
+  app.settings()
+  click(Ui.Settings.Database)
+  waitFor(Ui.Database.Management)
+  return ChatDataScreen(this)
+}
+
+class ChatDataScreen(private val s: UiScope) {
+  fun ttlText(): String? = s.textOf(Ui.Database.Ttl)
+
+  fun selectTtl(ttl: ChatItemTTL) {
+    s.poll(what = "the previous message deletion change to finish before opening the picker") { UiIdle.inFlight().isEmpty() }
+    s.click(Ui.Database.Ttl)
+    s.click(Ui.Database.Ttl.option(ttl))
+  }
+
+  fun management(): DatabaseManagementScreen {
+    s.click(Ui.Database.Management)
+    s.waitFor(Ui.Database.Export)
+    return DatabaseManagementScreen(s)
+  }
+
+  fun close() {
+    s.escape()
+    s.poll(what = "Chat data to close") { !s.exists(Ui.Database.Management) && s.exists(Ui.Settings.Database) }
+    s.escape()
+    s.poll(what = "Your settings to close") { !s.exists(Ui.Settings.Database) && s.exists(Ui.ChatList.Search) }
+  }
+}
+
+class DatabaseManagementScreen(private val s: UiScope) {
+  fun passphrase(): PassphraseScreen {
+    s.click(Ui.Database.Passphrase)
+    s.waitFor(Ui.DbPassphrase.New)
+    return PassphraseScreen(s)
+  }
+
+  fun close() {
+    s.escape()
+    s.poll(what = "Database passphrase & export to close") { !s.exists(Ui.Database.Export) && s.exists(Ui.Database.Management) }
+    ChatDataScreen(s).close()
+  }
+}
+
+class PassphraseScreen(private val s: UiScope) {
+  fun setFirst(passphrase: String) {
+    s.typeSecret(Ui.DbPassphrase.New, passphrase)
+    s.typeSecret(Ui.DbPassphrase.Confirm, passphrase)
+    s.click(Ui.DbPassphrase.Update)
+    s.waitFor(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    s.click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    s.poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the Database encrypted! alert") { s.seesText("Database encrypted!") }
+    s.click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    s.poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the chat running again and the Current passphrase field") {
+      !AlertManager.shared.hasAlertsShown() && chatModel.chatRunning.value == true && s.exists(Ui.DbPassphrase.Current)
+    }
+  }
+
+  fun change(current: String, new: String) {
+    s.typeSecret(Ui.DbPassphrase.Current, current)
+    s.typeSecret(Ui.DbPassphrase.New, new)
+    s.typeSecret(Ui.DbPassphrase.Confirm, new)
+    s.click(Ui.DbPassphrase.Update)
+    s.poll(what = "the Change database passphrase? alert with Update") {
+      s.seesText("Change database passphrase?") && "Update" in s.textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    s.click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  }
+
+  fun reopen() {
+    close()
+    s.click(Ui.Database.Passphrase)
+    s.waitFor(Ui.DbPassphrase.New)
+    for (key in listOf(Ui.DbPassphrase.Current, Ui.DbPassphrase.New, Ui.DbPassphrase.Confirm)) {
+      check(s.editableText(key).isNullOrEmpty()) { "${key.tag} still holds ${s.editableText(key)?.length} characters after reopening" }
+    }
+  }
+
+  fun close() {
+    s.hideKeyboard()
+    s.escape()
+    s.poll(what = "Database passphrase to close") { !s.exists(Ui.DbPassphrase.New) && s.exists(Ui.Database.Export) }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/DraftScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/DraftScreens.kt
new file mode 100644
index 0000000000..9b04ebfa3a
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/DraftScreens.kt
@@ -0,0 +1,14 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+
+fun UiScope.visitNotesAndBack(app: App, name: String): ChatScreen {
+  backToChatList()
+  app.chatList.open("Private notes")
+  poll(what = "the notes folder with an empty field and no context bar") {
+    chatModel.chatId.value == app.chatList.chatId("Private notes") && editableText(Ui.Chat.Message).isNullOrEmpty() && !seesDescription("Context icon")
+  }
+  backToChatList()
+  return app.chatList.open(name)
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ForwardScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ForwardScreens.kt
new file mode 100644
index 0000000000..d50c2ff55f
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ForwardScreens.kt
@@ -0,0 +1,25 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.GroupProfile
+import chat.simplex.common.platform.chatController
+import kotlinx.coroutines.runBlocking
+import java.io.File
+
+fun CliPeer.sendsFileTo(contact: String, path: String, fileId: Int, name: String) {
+  this sends "/f @$contact $path"
+  this expects "use /fc $fileId to cancel sending"
+  eventually("completed uploading file $fileId ($name) for $contact", CONNECT_TIMEOUT_MS)
+}
+
+fun CliPeer.receivesFile(fileId: Int, name: String, from: String) {
+  val dir = File(createFile(".fr-probe", "probe")).parent
+  this sends "/fr $fileId $dir/"
+  eventually("completed receiving file $fileId ($name) from $from", CONNECT_TIMEOUT_MS)
+}
+
+fun newGroupsViaApi(vararg names: String) = names.forEach {
+  runBlocking { chatController.apiNewGroup(null, incognito = false, GroupProfile(it, "", null)) } ?: error("apiNewGroup($it) failed")
+}
+
+fun UiScope.awaitRowText(app: App, name: String, text: String) =
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`$text` on $name's row") { text in app.chatList.rowTexts(name) }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupExtraScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupExtraScreens.kt
new file mode 100644
index 0000000000..364b83715d
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupExtraScreens.kt
@@ -0,0 +1,47 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.ui.Ui
+
+fun UiScope.memberConnectionLoaded() {
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the member's servers loaded in member info") { exists(Ui.Info.ReceivingVia) }
+  waitStable(Ui.Info.ReceivingVia)
+}
+
+fun UiScope.shownSecurityCode(): String {
+  click(Ui.Info.VerifyCode)
+  waitFor(Ui.VerifyCode.Code)
+  return textOf(Ui.VerifyCode.Code)!!.filterNot(Char::isWhitespace)
+}
+
+fun UiScope.closeMemberInfo(name: String) {
+  val row = Ui.GroupInfo.Member(groupMemberId(name))
+  escape()
+  poll(what = "$name's member info to close to group info") { !exists(Ui.MemberInfo.Role) && !exists(Ui.Info.VerifyCode) && exists(row) }
+}
+
+fun UiScope.alertSaying(title: String, text: String) {
+  poll(what = "the `$title` alert saying `$text`") { seesText(title) && seesText(text) && exists(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+  click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  poll(what = "the `$title` alert to close") { !seesText(text) }
+}
+
+fun CliPeer.createShortAndFullGroupLink(group: String): Pair<String, String> {
+  createGroup(group)
+  this sends "/create link #$group"
+  this expects "Group link is created!"
+  this expects ""
+  val short = nextLine()
+  val full = eventuallyMatching(Regex("The group link for old clients: (\\S+)")).groupValues[1]
+  return short to full
+}
+
+fun CliPeer.joinsViaLink(link: String, group: String) {
+  this sends "/c $link"
+  this expects "connection request sent!"
+  eventually("#$group: you joined the group", CONNECT_TIMEOUT_MS)
+}
+
+fun UiScope.memberConnected(info: GroupInfoScreen, name: String) =
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "$name listed as connected in the group's members") {
+    info.memberTexts(name).let { "connected" in it || "complete" in it }
+  }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupLifecycleScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupLifecycleScreens.kt
new file mode 100644
index 0000000000..cc64057295
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupLifecycleScreens.kt
@@ -0,0 +1,146 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import chat.simplex.common.views.helpers.ModalManager
+
+class InviteMembersScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the `Invite members` sheet with `New member role`") { s.exists(Ui.InviteMembers.Role) }
+    s.waitStable(Ui.InviteMembers.Role)
+  }
+
+  fun listed(name: String): Boolean = s.exists(Ui.InviteMembers.Contact(contactId(name)))
+
+  fun toggle(name: String) = s.click(Ui.InviteMembers.Contact(contactId(name)))
+
+  fun roleTexts(): List<String> = s.textsOf(Ui.InviteMembers.Role)
+
+  fun role(r: GroupMemberRole) {
+    s.click(Ui.InviteMembers.Role)
+    s.click(Ui.InviteMembers.Role.option(r))
+  }
+
+  fun invite() {
+    s.click(Ui.InviteMembers.Invite)
+    s.poll(what = "the invite sheet to close") { !s.exists(Ui.InviteMembers.Role) }
+  }
+
+  private fun contactId(name: String): Long =
+    chatModel.chats.value.firstNotNullOf { (it.chatInfo as? ChatInfo.Direct)?.contact?.takeIf { c -> c.displayName == name }?.contactId }
+}
+
+class GroupProfileScreen(private val s: UiScope) {
+  init {
+    s.waitFor(Ui.GroupProfile.Name)
+    s.waitStable(Ui.GroupProfile.Name)
+  }
+
+  fun name(): String? = s.editableText(Ui.GroupProfile.Name)
+
+  fun shortDescr(): String? = s.editableText(Ui.GroupProfile.ShortDescr)
+
+  fun rename(name: String) = s.replaceText(Ui.GroupProfile.Name, name)
+
+  fun describe(text: String) = s.typeInto(Ui.GroupProfile.ShortDescr, text)
+
+  fun save() {
+    s.click(Ui.GroupProfile.Save)
+    s.poll(what = "the group profile editor to close after `Save group profile`") { !s.exists(Ui.GroupProfile.Name) }
+  }
+}
+
+class WelcomeMessageScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the `Welcome message` editor or read-only text") { s.exists(Ui.Welcome.Text) || s.exists(Ui.Welcome.Preview) }
+  }
+
+  fun text(): String = s.editableText(Ui.Welcome.Text).orEmpty()
+
+  fun type(text: String) = s.typeInto(Ui.Welcome.Text, text)
+
+  fun replace(text: String) = s.replaceText(Ui.Welcome.Text, text)
+
+  fun save() = s.click(Ui.Welcome.Save)
+
+  fun close() {
+    s.goBack()
+    s.poll(what = "the welcome message screen to close without an alert") {
+      !s.exists(Ui.Welcome.Text) && !s.exists(Ui.Welcome.Preview) && !s.seesText("Save welcome message?")
+    }
+  }
+}
+
+fun UiScope.groupInfoRow(key: UiKey) {
+  scrollTo(key)
+  click(key)
+}
+
+fun UiScope.inviteMembers(): InviteMembersScreen {
+  groupInfoRow(Ui.GroupInfo.AddMembers)
+  return InviteMembersScreen(this)
+}
+
+fun UiScope.editGroupProfile(): GroupProfileScreen {
+  groupInfoRow(Ui.GroupInfo.EditProfile)
+  return GroupProfileScreen(this)
+}
+
+fun UiScope.welcomeMessage(): WelcomeMessageScreen {
+  groupInfoRow(Ui.GroupInfo.WelcomeMessage)
+  return WelcomeMessageScreen(this)
+}
+
+fun UiScope.welcomeRowText(): List<String> {
+  scrollTo(Ui.GroupInfo.WelcomeMessage)
+  return textsOf(Ui.GroupInfo.WelcomeMessage)
+}
+
+fun UiScope.leaveGroupFromInfo(group: String) {
+  groupInfoRow(Ui.GroupInfo.Leave)
+  poll(what = "the `Leave group?` alert for `$group` with `Leave`") {
+    seesText("Leave group?") && seesText("$group\n\nYou will stop receiving messages from this group. Chat history will be preserved.") &&
+      "Leave" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  }
+  click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "group info to close after leaving `$group`") { !ModalManager.end.hasModalsOpen() }
+}
+
+fun UiScope.deleteGroupFromInfo(group: String, warning: String) {
+  groupInfoRow(Ui.GroupInfo.Delete)
+  poll(what = "the `Delete group?` alert for `$group` saying `$warning`, with `Delete`") {
+    seesText("Delete group?") && seesText("$group\n\n$warning") && "Delete" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  }
+  click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+}
+
+fun UiScope.clearChatFromInfo(group: String) {
+  groupInfoRow(Ui.Info.ClearChat)
+  poll(what = "the `Clear chat?` alert for `$group` with `Clear`") {
+    seesText("Clear chat?") && seesText("$group\n\nAll messages will be deleted - this cannot be undone! The messages will be deleted ONLY for you.") &&
+      "Clear" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  }
+  click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+}
+
+fun UiScope.offersOnlyDelete(): Boolean {
+  scrollTo(Ui.GroupInfo.Delete)
+  return exists(Ui.GroupInfo.Delete) && !exists(Ui.GroupInfo.Leave)
+}
+
+fun UiScope.offersOnlyLeave(): Boolean {
+  scrollTo(Ui.GroupInfo.Leave)
+  return exists(Ui.GroupInfo.Leave) && !exists(Ui.GroupInfo.Delete)
+}
+
+fun UiScope.hostGroupWithWelcome(host: CliPeer, group: String, welcome: String, member: String) {
+  host.createGroup(group)
+  host sends "/set welcome #$group $welcome"
+  host expects "welcome message changed to:"
+  host expects welcome
+  host sends "/a $group $member"
+  host.eventually("invitation to join the group #$group sent to $member")
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupLinkScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupLinkScreens.kt
new file mode 100644
index 0000000000..85e1a7bbf2
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupLinkScreens.kt
@@ -0,0 +1,38 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.ui.Ui
+import kotlinx.coroutines.runBlocking
+
+fun UiScope.openNewGroupLink() {
+  click(Ui.GroupInfo.CreateLink)
+  waitFor(Ui.GroupLink.Share, CONNECT_TIMEOUT_MS)
+  waitStable(Ui.GroupLink.Share)
+}
+
+fun UiScope.sharedGroupLink(previous: String? = null): String {
+  if (previous == null) setClipboardText(null)
+  click(Ui.GroupLink.Share)
+  var link: String? = null
+  poll(what = "the group link shared") { link = clipboardText()?.takeIf { it.isNotBlank() && it != previous }; link != null }
+  return link!!
+}
+
+fun UiScope.pickGroupLinkRole(role: GroupMemberRole) {
+  click(Ui.GroupLink.Role)
+  click(Ui.GroupLink.Role.option(role))
+}
+
+fun coreGroupLinkRole(groupId: Long): GroupMemberRole? =
+  runBlocking { chatController.apiGetGroupLink(null, groupId) }?.acceptMemberRole
+
+fun coreMemberContactId(groupId: Long, name: String): Long? =
+  runBlocking { chatController.apiListMembers(null, groupId) }.firstOrNull { it.memberProfile.displayName == name }?.memberContactId
+
+fun UiScope.closeGroupLink() {
+  escape()
+  poll(what = "the group link screen to close to group info") {
+    !exists(Ui.GroupLink.Share) && !seesText("Create link") && (exists(Ui.GroupInfo.CreateLink) || exists(Ui.GroupInfo.GroupLink))
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupMembersScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupMembersScreens.kt
new file mode 100644
index 0000000000..97f8c210df
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupMembersScreens.kt
@@ -0,0 +1,90 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatItem
+import chat.simplex.common.model.GroupFeature
+import chat.simplex.common.model.GroupFeatureEnabled
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+
+fun UiScope.groupMemberId(name: String): Long {
+  var id: Long? = null
+  poll(what = "member `$name` in the model") {
+    id = chatModel.groupMembers.value.firstOrNull { it.memberProfile.displayName == name }?.groupMemberId
+    id != null
+  }
+  return id!!
+}
+
+fun UiScope.membersTitleShown(count: Int): Boolean = seesText("$count members")
+
+fun UiScope.scrollToMembersEnd() = scrollTo(Ui.GroupInfo.Delete)
+
+fun UiScope.openMemberMenu(name: String): Long {
+  val id = groupMemberId(name)
+  scrollTo(Ui.GroupInfo.Member(id))
+  openContextMenu(Ui.GroupInfo.Member(id))
+  return id
+}
+
+fun UiScope.selectMembers(first: String, vararg more: String) {
+  val id = openMemberMenu(first)
+  click(Ui.GroupInfo.MemberMenu(id, "select"))
+  poll(what = "`Selected 1` after `Select` on $first") { ChatScreen(this).selectionTitle() == "Selected 1" }
+  more.forEachIndexed { i, name ->
+    click(Ui.GroupInfo.Member(groupMemberId(name)))
+    poll(what = "`Selected ${i + 2}` after tapping $name") { ChatScreen(this).selectionTitle() == "Selected ${i + 2}" }
+  }
+}
+
+fun UiScope.selectionEnded() = poll(what = "member selection to end") { ChatScreen(this).selectionTitle() == null }
+
+fun UiScope.confirmAlert(title: String, text: String, action: String) {
+  poll(what = "the `$title` alert saying `$text` with `$action`") {
+    seesText(title) && seesText(text) && action in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  }
+  click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+}
+
+fun UiScope.ownGroupOfThree(app: App, a: CliPeer, b: CliPeer, c: CliPeer, group: String = "team"): ChatScreen {
+  connect(a)
+  connect(b)
+  connect(c)
+  val chat = ownGroup(app, group, a, b, c)
+  c.eventuallyAll(lines = listOf("#$group: member ${a.name} is connected", "#$group: member ${b.name} is connected"), timeoutMs = CONNECT_TIMEOUT_MS)
+  quiesce()
+  return chat
+}
+
+fun UiScope.linkGroupWithDirectMessages(app: App, group: String, vararg joiners: CliPeer): GroupInfoScreen {
+  val info = emptyGroup(app, group).groupInfo()
+  val prefs = info.preferences()
+  prefs.toggle(GroupFeature.DirectMessages)
+  prefs.save()
+  poll(what = "direct messages allowed in #$group") { groupInfoOf(group).fullGroupPreferences.directMessages.enable == GroupFeatureEnabled.ON }
+  prefs.backClosing()
+  val link = info.createLink()
+  val joined = mutableListOf<CliPeer>()
+  for (j in joiners) {
+    j sends "/c $link"
+    j expects "connection request sent!"
+    j.eventuallyAll(lines = listOf("#$group: you joined the group") + joined.map { "#$group: member ${it.name} is connected" }, timeoutMs = CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "${j.name} listed as connected in #$group") { "connected" in info.memberTexts(j.name) }
+    joined += j
+  }
+  quiesce()
+  return info
+}
+
+fun UiScope.eventIds(what: String, count: Int, match: (ChatItem) -> Boolean): List<Long> {
+  var ids = emptyList<Long>()
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = what) {
+    ids = chatModel.chatsContext.chatItems.value.filter(match).map { it.id }
+    ids.size == count
+  }
+  return ids
+}
+
+fun UiScope.itemMenu(id: Long, action: String) {
+  openContextMenu(Ui.Chat.Item(id))
+  click(Ui.Chat.ItemMenu(id, action))
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupPrefsScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupPrefsScreens.kt
new file mode 100644
index 0000000000..b9eb63f410
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/GroupPrefsScreens.kt
@@ -0,0 +1,185 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.ChatItem
+import chat.simplex.common.model.GroupFeature
+import chat.simplex.common.model.GroupInfo
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.model.MemberCriteria
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.ModalManager
+import chat.simplex.common.views.helpers.ModalViewId
+
+fun groupInfoOf(name: String): GroupInfo =
+  (chatModel.chats.value.first { it.chatInfo.chatViewName == name }.chatInfo as ChatInfo.Group).groupInfo
+
+class GroupPreferencesScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the `Group preferences` screen") { s.seesText("Group preferences") && s.exists(Ui.GroupPrefs.MemberAdmission) }
+    s.waitStable(Ui.GroupPrefs.MemberAdmission)
+  }
+
+  fun toggle(f: GroupFeature) = s.click(Ui.GroupPrefs.Toggle(f))
+
+  fun role(f: GroupFeature, r: GroupMemberRole?) {
+    s.click(Ui.GroupPrefs.Role(f))
+    s.click(Ui.GroupPrefs.Role(f).option(r ?: "null"))
+  }
+
+  fun ttl(seconds: Int) {
+    s.click(Ui.GroupPrefs.Ttl)
+    s.click(Ui.GroupPrefs.Ttl.option(seconds))
+  }
+
+  fun reset() = s.click(Ui.GroupPrefs.Reset)
+
+  fun save() = s.click(Ui.GroupPrefs.Save)
+
+  fun admission(): MemberAdmissionScreen {
+    s.click(Ui.GroupPrefs.MemberAdmission)
+    return MemberAdmissionScreen(s)
+  }
+
+  fun backExpectingAlert(title: String) {
+    s.goBack()
+    s.poll(what = "the `$title` alert") { s.seesText(title) }
+  }
+
+  fun backClosing() {
+    s.goBack()
+    s.poll(what = "group preferences to close without an alert") { !s.exists(Ui.GroupPrefs.MemberAdmission) && !s.seesText("Save preferences?") }
+  }
+}
+
+class MemberAdmissionScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the `Member admission` screen") { s.seesText("Member admission") && s.seesText("Review members before admitting (\"knocking\").") }
+  }
+
+  fun review(): List<String> = s.textsOf(Ui.MemberAdmission.Review)
+
+  fun select(c: MemberCriteria?) {
+    s.waitStable(Ui.MemberAdmission.Review)
+    s.click(Ui.MemberAdmission.Review)
+    s.click(Ui.MemberAdmission.Review.option(c ?: "null"))
+  }
+
+  fun save() = s.click(Ui.MemberAdmission.Save)
+}
+
+fun UiScope.enableReviewAll(info: GroupInfoScreen, group: String) {
+  val adm = info.preferences().admission()
+  poll(what = "`Review members` off before enabling review") { "off" in adm.review() }
+  adm.select(MemberCriteria.All)
+  adm.save()
+  poll(what = "review of all members saved for #$group") { groupInfoOf(group).groupProfile.memberAdmission?.review == MemberCriteria.All }
+  goBack()
+  poll(what = "member admission to close to group preferences") { !seesText("Review members before admitting (\"knocking\").") && exists(Ui.GroupPrefs.MemberAdmission) }
+  GroupPreferencesScreen(this).backClosing()
+}
+
+class MemberSupportScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the `Chats with members` screen") { s.seesText("Chats with members") && !s.exists(Ui.GroupInfo.MemberSupport) }
+  }
+
+  fun empty() = s.poll(what = "`No chats with members`") { s.seesText("No chats with members") }
+
+  fun close() {
+    s.goBack()
+    s.poll(what = "`Chats with members` to close to group info") { s.exists(Ui.GroupInfo.MemberSupport) }
+    s.waitStable(Ui.GroupInfo.MemberSupport)
+  }
+
+  fun rowTexts(name: String): List<String> {
+    val id = chatModel.groupMembers.value.firstOrNull { it.memberProfile.displayName == name }?.groupMemberId ?: return emptyList()
+    return if (s.exists(Ui.MemberSupport.Row(id))) s.textsOf(Ui.MemberSupport.Row(id)) else emptyList()
+  }
+
+  fun open(name: String): SupportChatScreen {
+    s.click(Ui.MemberSupport.Row(memberId(name)))
+    return SupportChatScreen(s).also { it.waitOpen() }
+  }
+
+  fun menuAccept(name: String) {
+    val id = memberId(name)
+    s.openContextMenu(Ui.MemberSupport.Row(id))
+    s.click(Ui.MemberSupport.RowMenu(id, "accept"))
+  }
+
+  private fun memberId(name: String): Long {
+    var id: Long? = null
+    s.poll(what = "member `$name` in the model") {
+      id = chatModel.groupMembers.value.firstOrNull { it.memberProfile.displayName == name }?.groupMemberId
+      id != null
+    }
+    return id!!
+  }
+}
+
+class SupportChatScreen(private val s: UiScope) {
+  fun waitOpen() = s.poll(what = "the support chat") {
+    chatModel.secondaryChatsContext.value != null && ModalManager.end.hasModalOpen(ModalViewId.SECONDARY_CHAT)
+  }
+
+  fun items(): List<ChatItem> = chatModel.secondaryChatsContext.value?.chatItems?.value.orEmpty()
+
+  fun itemId(text: String): Long {
+    var id: Long? = null
+    s.poll(what = "support chat item `$text`") {
+      id = items().lastOrNull { it.content.text == text }?.id
+      id != null && s.exists(Ui.Chat.Item(id!!))
+    }
+    return id!!
+  }
+
+  fun send(text: String) {
+    s.typeInto(Ui.Chat.ScopeMessage, text)
+    s.poll(what = "the support chat send button to be enabled") { s.isEnabled(Ui.Chat.ScopeSend) }
+    s.pressEnter(Ui.Chat.ScopeMessage)
+    s.poll(what = "the support chat message field to clear after one Enter") { s.editableText(Ui.Chat.ScopeMessage).isNullOrEmpty() }
+    s.hideKeyboard()
+  }
+
+  fun acceptVia(option: String) {
+    s.click(Ui.Chat.PendingAccept)
+    s.acceptAlert(option)
+  }
+
+  fun reject() = s.click(Ui.Chat.PendingReject)
+
+  fun close() {
+    s.goBack()
+    s.poll(what = "the support chat to close") { chatModel.secondaryChatsContext.value == null && !ModalManager.end.hasModalOpen(ModalViewId.SECONDARY_CHAT) }
+  }
+}
+
+fun UiScope.acceptAlert(option: String) {
+  poll(what = "the `Accept member` alert with `Accept as member` and `Accept as observer`") {
+    seesText("Accept member") && seesText("Member will join the group, accept member?") && seesText("Accept as member") && seesText("Accept as observer")
+  }
+  click(Ui.Alert.Option(Ui.AlertSource.Shared, option))
+}
+
+fun UiScope.pendingLinkJoin(app: App, joiner: CliPeer, group: String): ChatScreen {
+  val me = chatModel.currentUser.value!!.displayName
+  val chat = emptyGroup(app, group)
+  val info = chat.groupInfo()
+  info.chatsWithMembers().apply { empty() }.close()
+  enableReviewAll(info, group)
+  val link = info.createLink()
+  info.close()
+  joiner sends "/c $link"
+  joiner expects "connection request sent!"
+  joiner.eventuallyAll(
+    lines = listOf(
+      "#$group: $me accepted you to the group, pending review",
+      "#$group: joining the group...",
+      "#$group: you joined the group, connecting to group moderators for admission to group",
+    ),
+    timeoutMs = CONNECT_TIMEOUT_MS,
+  )
+  quiesce()
+  return chat
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ItemInfoScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ItemInfoScreens.kt
new file mode 100644
index 0000000000..6a72e5277b
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ItemInfoScreens.kt
@@ -0,0 +1,15 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.views.helpers.ModalManager
+
+class ItemInfoScreen(private val s: UiScope) {
+  fun history(): List<String> = s.texts().dropWhile { it != "History" }.drop(1)
+
+  fun row(title: String): String? = s.texts().let { t -> t.indexOf(title).takeIf { it >= 0 }?.let { t.getOrNull(it + 1) } }
+
+  fun close() {
+    s.hideKeyboard()
+    s.escape()
+    s.poll(what = "the item info to close") { !ModalManager.end.hasModalsOpen() }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/JoiningScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/JoiningScreens.kt
new file mode 100644
index 0000000000..ce050b105b
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/JoiningScreens.kt
@@ -0,0 +1,55 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+
+fun CliPeer.createWelcomeGroupLink(group: String, welcome: String): String {
+  createGroup(group)
+  this sends "/set welcome #$group $welcome"
+  this expects "welcome message changed to:"
+  this expects welcome
+  this sends "/create link #$group"
+  this expects "Group link is created!"
+  this expects ""
+  return nextLine()
+}
+
+fun CliPeer.createFullGroupLink(group: String): String {
+  createGroup(group)
+  this sends "/create link #$group"
+  this expects "Group link is created!"
+  return eventuallyMatching(Regex("The group link for old clients: (\\S+)")).groupValues[1]
+}
+
+fun groupChatIds(name: String): List<String> =
+  chatModel.chats.value.filter { it.chatInfo is ChatInfo.Group && it.chatInfo.chatViewName == name }.map { it.id }
+
+fun UiScope.openPreparedGroupFromSearch(link: String, name: String): ChatScreen {
+  enterLinkInSearch(link)
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the plan alert for group `$name` with `Open group`") {
+    exists(planConfirm) && "Open group" in textsOf(planConfirm) && seesText(name)
+  }
+  click(planConfirm)
+  poll(what = "`$name`'s prepared group open") {
+    chatModel.chats.value.firstOrNull { it.chatInfo is ChatInfo.Group && it.chatInfo.chatViewName == name && it.chatInfo.nextConnectPrepared }
+      ?.id?.let { it == chatModel.chatId.value } == true
+  }
+  return ChatScreen(this)
+}
+
+fun UiScope.openChatById(id: String): ChatScreen {
+  click(Ui.ChatList.Row(id))
+  poll(what = "chat $id to open") { chatModel.chatId.value == id }
+  return ChatScreen(this)
+}
+
+fun UiScope.connectionRequestSentToGroup() {
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Connection request sent!` for a group link") {
+    seesText("Connection request sent!") && seesText("You will be connected to group when the group host's device is online, please wait or check later!")
+  }
+  click(planConfirm)
+  poll(what = "the alert to close and the search to clear") {
+    !seesText("Connection request sent!") && editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search)
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/MessageMetaScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/MessageMetaScreens.kt
new file mode 100644
index 0000000000..555c482df3
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/MessageMetaScreens.kt
@@ -0,0 +1,54 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.ui.Ui
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
+
+private const val PEER_RECHECK_MS = 1_000L
+private val SENT_AT = Regex("sent at: (\\S+ \\S+)")
+private val RECEIVED_AT = Regex("received at: .+")
+private val DELETE_AT = Regex("to be deleted at: (\\S+ \\S+)")
+private val SERVERS_SUMMARY = Regex("agent servers summary: .*")
+private val CONN_DELETED = Regex("\"_connDeleted\":[1-9]")
+
+fun UiScope.openTimedMenu() {
+  rightClick(Ui.Chat.Send)
+  click(Ui.Chat.SendTimed)
+  poll(what = "the `Send disappearing message` menu with `30 seconds` and `Custom time`") {
+    seesText("Send disappearing message") && exists(Ui.Chat.SendTimed.option(30)) && exists(Ui.Chat.SendTimed.option("custom"))
+  }
+}
+
+fun CliPeer.receivedTtlSeconds(contact: String, text: String): Long {
+  sends("/item info @$contact $text")
+  val sentAt = eventuallyMatching(SENT_AT).groupValues[1]
+  eventuallyMatching(RECEIVED_AT)
+  val deleteAt = eventuallyMatching(DELETE_AT).groupValues[1]
+  return (localTs(deleteAt) - localTs(sentAt)).inWholeSeconds
+}
+
+fun UiScope.awaitGoneFromPeer(peer: CliPeer, contact: String, line: String) {
+  var askedAt = 0L
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`$line` gone from the end of ${peer.name}'s chat with $contact") {
+    if (System.currentTimeMillis() - askedAt < PEER_RECHECK_MS) return@poll false
+    askedAt = System.currentTimeMillis()
+    peer sends "/tail @$contact 1"
+    !peer.nextLine().endsWith(line)
+  }
+}
+
+fun UiScope.awaitConnectionDeletedOnServer(peer: CliPeer) {
+  var askedAt = 0L
+  var deleted = false
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the server to confirm ${peer.name}'s deleted connection") {
+    if (System.currentTimeMillis() - askedAt >= PEER_RECHECK_MS) {
+      askedAt = System.currentTimeMillis()
+      peer sends "/get servers summary 1"
+      deleted = CONN_DELETED.containsMatchIn(peer.eventuallyMatching(SERVERS_SUMMARY).value)
+    }
+    deleted
+  }
+}
+
+private fun localTs(s: String) = LocalDateTime.parse(s.replace(' ', 'T')).toInstant(TimeZone.UTC)
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/NetworkScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/NetworkScreens.kt
new file mode 100644
index 0000000000..197426c311
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/NetworkScreens.kt
@@ -0,0 +1,263 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.CC
+import chat.simplex.common.model.CR
+import chat.simplex.common.model.NetCfg
+import chat.simplex.common.model.NetworkProxy
+import chat.simplex.common.model.ServerAddress.Companion.parseServerAddress
+import chat.simplex.common.model.ServerOperator
+import chat.simplex.common.model.UserOperatorServers
+import chat.simplex.common.model.UserServer
+import chat.simplex.common.model.json
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import chat.simplex.common.views.helpers.AlertManager
+import kotlinx.coroutines.runBlocking
+
+const val UNREACHABLE_HOST = "127.0.0.2"
+
+fun coreNetworkConfig(): NetCfg {
+  val r = runBlocking { chatController.sendCmd(null, CC.APIGetNetworkConfig()) }
+  return (r.result as? CR.NetworkConfig)?.networkConfig ?: error("/network failed: ${r.responseType} ${r.details}")
+}
+
+fun saveNetworkConfigViaApi(cfg: NetCfg) {
+  check(runBlocking { chatController.apiSetNetworkConfig(cfg) }) { "apiSetNetworkConfig failed" }
+  chatController.setNetCfg(cfg)
+}
+
+fun coreOperators(): List<ServerOperator> =
+  runBlocking { chatController.getServerOperators(null) }?.serverOperators ?: error("getServerOperators failed")
+
+fun customServers(): UserOperatorServers =
+  (runBlocking { chatController.getUserServers(null) } ?: error("getUserServers failed")).single { it.operator == null }
+
+fun hostOf(server: String): String? = parseServerAddress(server)?.hostnames?.firstOrNull()
+
+fun unreachableSmpServer(): String = "smp://${localSmpServer().keyHash}@$UNREACHABLE_HOST:1"
+
+fun customSmpServer(host: String): UserServer? = customServers().smpServers.firstOrNull { hostOf(it.server) == host }
+
+fun addCustomSmpServerViaApi(server: String): String {
+  val groups = runBlocking { chatController.getUserServers(null) } ?: error("getUserServers failed")
+  val added = UserServer(remoteHostId = null, serverId = null, server = server, preset = false, enabled = true, deleted = false)
+  val updated = groups.map { g -> if (g.operator == null) g.copy(smpServers = g.smpServers + added) else g }
+  check(runBlocking { chatController.setUserServers(null, updated) }) { "setUserServers failed" }
+  return customSmpServer(hostOf(server)!!)?.server ?: error("the added server `$server` is not in the core")
+}
+
+fun UiScope.networkAndServers(app: App): NetworkScreen {
+  app.settings()
+  return openNetworkFromSettings()
+}
+
+fun UiScope.openNetworkFromSettings(): NetworkScreen {
+  click(Ui.Settings.Network)
+  return NetworkScreen(this)
+}
+
+class NetworkScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "`Network & servers` with the servers loaded") { s.exists(Ui.Network.YourServers) && s.exists(Ui.Network.SaveServers) && !s.exists(Ui.Settings.Network) }
+  }
+
+  fun edited(key: UiKey): Boolean = EDITED in s.descriptionsOf(key)
+
+  fun yourServers(): YourServersScreen {
+    s.click(Ui.Network.YourServers)
+    return YourServersScreen(s)
+  }
+
+  fun operator(operatorId: Long): OperatorScreen {
+    s.click(Ui.Network.Operator(operatorId))
+    return OperatorScreen(s)
+  }
+
+  fun save(row: UiKey) {
+    s.click(Ui.Network.SaveServers)
+    s.poll(what = "`Save servers` to save and clear the `edited` mark of ${row.tag}") { !edited(row) && !AlertManager.shared.hasAlertsShown() }
+  }
+
+  fun advanced(): AdvancedNetworkScreen {
+    s.click(Ui.Network.Advanced)
+    return AdvancedNetworkScreen(s)
+  }
+
+  fun socks(): SocksScreen {
+    s.click(Ui.Network.SocksSettings)
+    return SocksScreen(s)
+  }
+
+  fun enableSocks() {
+    val confirm = Ui.Alert.Confirm(Ui.AlertSource.Shared)
+    s.click(Ui.Network.UseSocks)
+    s.poll(what = "the `Use SOCKS proxy?` alert with `Confirm`") { s.seesText("Use SOCKS proxy?") && s.exists(confirm) && "Confirm" in s.textsOf(confirm) }
+    s.click(confirm)
+    s.poll(what = "the `Use SOCKS proxy?` alert to close") { !s.seesText("Use SOCKS proxy?") }
+  }
+
+  fun close() {
+    s.goBack()
+    awaitClosed()
+  }
+
+  fun awaitClosed() = s.poll(what = "`Network & servers` to close to the settings") { !s.exists(Ui.Network.SaveServers) && s.exists(Ui.Settings.Network) }
+
+  private companion object {
+    const val EDITED = "edited"
+  }
+}
+
+class YourServersScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "`Your servers`") { s.exists(Ui.Servers.Add) && !s.exists(Ui.Network.SaveServers) }
+  }
+
+  fun open(server: String): ServerScreen {
+    s.click(Ui.Servers.Server(server))
+    return ServerScreen(s)
+  }
+
+  fun add(): ServerScreen {
+    s.click(Ui.Servers.Add)
+    val manually = Ui.Alert.Option(Ui.AlertSource.Shared, "enterManually")
+    s.poll(what = "the `Add server` alert with `Enter server manually`") { s.exists(manually) && "Enter server manually" in s.textsOf(manually) }
+    s.click(manually)
+    s.poll(what = "`New server`") { s.seesText("New server") && s.exists(Ui.Servers.Address) && !s.exists(Ui.Servers.Add) }
+    return ServerScreen(s)
+  }
+
+  fun testAll() {
+    s.click(Ui.Servers.TestAll)
+    s.poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the server tests to finish (`Add server` clickable again)") { s.exists(described(ADD_SERVER)) }
+  }
+
+  fun back() {
+    s.goBack()
+    s.poll(what = "back on `Network & servers`") { !s.exists(Ui.Servers.Add) && s.exists(Ui.Network.SaveServers) }
+  }
+
+  private companion object {
+    const val ADD_SERVER = "Add server"
+  }
+}
+
+class ServerScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the server screen with `Use for new connections`") { s.exists(Ui.Servers.Use) && !s.exists(Ui.Servers.Add) }
+  }
+
+  fun enterAddress(address: String) = s.typeInto(Ui.Servers.Address, address)
+
+  fun toggleUse() = s.click(Ui.Servers.Use)
+
+  fun test() = s.click(Ui.Servers.Test)
+
+  fun delete() {
+    s.click(Ui.Servers.Delete)
+    awaitClosed()
+  }
+
+  fun back() {
+    s.goBack()
+    awaitClosed()
+  }
+
+  private fun awaitClosed() = s.poll(what = "back on `Your servers`") { !s.exists(Ui.Servers.Use) && s.exists(Ui.Servers.Add) }
+}
+
+class OperatorScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the operator screen with `Use servers`") { s.exists(Ui.Operator.Use) && !s.exists(Ui.Network.SaveServers) }
+  }
+
+  fun info() {
+    s.click(Ui.Operator.Info)
+    s.poll(what = "`Network operator`") { s.seesText("Network operator") && !s.exists(Ui.Operator.Use) }
+  }
+
+  fun closeInfo() {
+    s.goBack()
+    s.poll(what = "back on the operator screen") { !s.seesText("Network operator") && s.exists(Ui.Operator.Use) }
+  }
+
+  fun toggleUse() = s.click(Ui.Operator.Use)
+
+  fun back() {
+    s.goBack()
+    s.poll(what = "back on `Network & servers`") { !s.exists(Ui.Operator.Use) && s.exists(Ui.Network.SaveServers) }
+  }
+}
+
+class AdvancedNetworkScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "`Advanced settings`") { s.exists(Ui.AdvancedNetwork.Save) && !s.exists(Ui.Network.SaveServers) }
+  }
+
+  fun value(name: String): String? = s.textsOf(Ui.AdvancedNetwork.Setting(name)).firstOrNull()?.trim()
+
+  fun select(name: String, value: Any) {
+    val row = Ui.AdvancedNetwork.Setting(name)
+    s.click(row)
+    s.click(row.option(value))
+    s.poll(what = "the `$name` menu to close") { !s.exists(row.option(value)) }
+  }
+
+  fun pick(row: UiKey, value: Any) {
+    s.click(row)
+    s.poll(what = "the ${row.tag} options") { s.exists(row.option(value)) && !s.exists(Ui.AdvancedNetwork.Save) }
+    s.click(row.option(value))
+    s.goBack()
+    s.poll(what = "back on `Advanced settings` from the ${row.tag} options") { !s.exists(row.option(value)) && s.exists(Ui.AdvancedNetwork.Save) }
+  }
+
+  fun saveAndReconnect() {
+    s.click(Ui.AdvancedNetwork.Save)
+    confirmUpdate(s)
+  }
+
+  fun back() {
+    s.goBack()
+    awaitClosed()
+  }
+
+  fun awaitClosed() = s.poll(what = "`Advanced settings` to close") { !s.exists(Ui.AdvancedNetwork.Save) && s.exists(Ui.Network.SaveServers) }
+}
+
+class SocksScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "`SOCKS proxy settings`") { s.exists(Ui.Socks.Save) && s.exists(Ui.Socks.OnionHosts) && !s.exists(Ui.Network.SaveServers) }
+  }
+
+  fun onionHosts(): List<String> = s.textsOf(Ui.Socks.OnionHosts)
+
+  fun saveProxy(host: String, port: Int) {
+    s.replaceText(Ui.Socks.Host, host)
+    s.replaceText(Ui.Socks.Port, port.toString())
+    s.hideKeyboard()
+    s.click(Ui.Socks.Save)
+    s.poll(what = "the proxy $host:$port stored") { s.storedSetting(PROXY_PREF)?.let { json.decodeFromString(NetworkProxy.serializer(), it) }?.let { it.host == host && it.port == port } == true }
+  }
+
+  fun saveAndReconnect() {
+    s.click(Ui.Socks.Save)
+    confirmUpdate(s)
+  }
+
+  fun back() {
+    s.goBack()
+    s.poll(what = "`SOCKS proxy settings` to close") { !s.exists(Ui.Socks.Save) && s.exists(Ui.Network.SaveServers) }
+  }
+
+  private companion object {
+    const val PROXY_PREF = "NetworkProxyHostPort"
+  }
+}
+
+private fun confirmUpdate(s: UiScope) {
+  val confirm = Ui.Alert.Confirm(Ui.AlertSource.Shared)
+  s.poll(what = "the `Update network settings?` alert with `Update`") { s.seesText("Update network settings?") && s.exists(confirm) && "Update" in s.textsOf(confirm) }
+  s.click(confirm)
+  s.poll(what = "the `Update network settings?` alert to close") { !s.seesText("Update network settings?") }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/OneTimeLinkScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/OneTimeLinkScreens.kt
new file mode 100644
index 0000000000..cfdbefaf27
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/OneTimeLinkScreens.kt
@@ -0,0 +1,49 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+
+const val NEW_RANDOM_PROFILE = "A new random profile will be shared."
+private val INVITATION_PLAN = Regex("invitation link: ok to connect|error: connection authorization failed.*")
+
+fun pendingConnectionIds(): List<String> =
+  chatModel.chats.value.filter { it.chatInfo is ChatInfo.ContactConnection }.map { it.id }
+
+fun UiScope.leaveInviteExpectingKeepAlert() {
+  goBack()
+  poll(what = "the `Keep unused invitation?` alert with `Delete` and `Keep`") {
+    seesText("Keep unused invitation?") && seesText("You can view invitation link again in connection details.") &&
+      "Delete" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && "Keep" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+  }
+}
+
+fun UiScope.awaitInviteClosed() =
+  poll(what = "the 1-time link screen to close, back on the New chat sheet or the chat list") {
+    !exists(Ui.Link.Text) && (exists(Ui.NewChat.CreateLink) || !chatModel.newChatSheetVisible.value)
+  }
+
+fun UiScope.closeNewChatSheet() {
+  awaitInviteClosed()
+  poll(what = "no alert over the New chat sheet") { !AlertManager.shared.hasAlertsShown() }
+  if (exists(Ui.NewChat.CreateLink)) goBack()
+  poll(what = "the New chat sheet to close") { !chatModel.newChatSheetVisible.value && !exists(Ui.NewChat.CreateLink) }
+}
+
+fun UiScope.chooseLinkProfile(userId: Long, oldLink: String): String {
+  scrollTo(Ui.Link.Profile(userId))
+  click(Ui.Link.Profile(userId))
+  var link: String? = null
+  poll(what = "user $userId active, the profile list closed and a new link shown") {
+    link = editableText(Ui.Link.Text)?.takeIf { it.isNotBlank() }
+    chatModel.currentUser.value?.userId == userId && !exists(Ui.Link.Profile(userId)) && link != null && link != oldLink
+  }
+  return link!!
+}
+
+fun UiScope.awaitInvitationGone(peer: CliPeer, link: String) =
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the deleted 1-time link to fail its plan on the server") {
+    peer sends "/_connect plan 1 $link"
+    peer.eventuallyMatching(INVITATION_PLAN).value.startsWith("error")
+  }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PaginationScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PaginationScreens.kt
new file mode 100644
index 0000000000..d5ae1ab5b6
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PaginationScreens.kt
@@ -0,0 +1,30 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatType
+import chat.simplex.common.model.ComposedMessage
+import chat.simplex.common.model.MsgContent
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import kotlinx.coroutines.runBlocking
+
+private const val API_BATCH = 100
+
+fun sendTextsViaApi(contact: String, texts: List<String>) =
+  texts.chunked(API_BATCH).forEach { batch -> sendViaApi(contact, batch.map { ComposedMessage(null, null, MsgContent.MCText(it), emptyMap()) }) }
+
+fun replyViaApi(contact: String, quotedItemId: Long, text: String) =
+  sendViaApi(contact, listOf(ComposedMessage(null, quotedItemId, MsgContent.MCText(text), emptyMap())))
+
+private fun sendViaApi(contact: String, messages: List<ComposedMessage>) {
+  val contactId = contactOf(contact).contactId
+  runBlocking { chatController.apiSendMessages(null, ChatType.Direct, contactId, null, composedMessages = messages) } ?: error("apiSendMessages failed")
+}
+
+fun loadedText(text: String): Boolean = chatModel.chatsContext.chatItems.value.any { it.content.text == text }
+
+fun UiScope.shownText(text: String): Boolean =
+  chatModel.chatsContext.chatItems.value.lastOrNull { it.content.text == text }?.let { exists(Ui.Chat.Item(it.id)) } == true
+
+fun loadedNumbered(prefix: String): List<String> =
+  Regex("${Regex.escape(prefix)}\\d+").let { r -> chatModel.chatsContext.chatItems.value.map { it.content.text }.filter { r.matches(it) } }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PeerLines.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PeerLines.kt
index 5ba2d88231..c2d41fa8b1 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PeerLines.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PeerLines.kt
@@ -4,7 +4,14 @@ fun interface Waiter {
   fun waitUntil(timeoutMs: Long, what: String, cond: () -> Boolean)
 }
 
-data class PeerFlags(val reactions: Boolean = false, val markRead: Boolean = false, val fullLinks: Boolean = false)
+data class PeerFlags(
+  val reactions: Boolean = false,
+  val markRead: Boolean = false,
+  val fullLinks: Boolean = false,
+  val relay: Boolean = false,
+  val smpServer: String = "smp1",
+  val xftpServer: String = "xftp1"
+)
 
 abstract class PeerLines(val name: String, protected val waiter: Waiter) {
   protected val lines = ArrayList<String>()
@@ -51,6 +58,12 @@ abstract class PeerLines(val name: String, protected val waiter: Waiter) {
     }
   }
 
+  fun eventuallyAll(lines: List<String>, messages: List<String> = emptyList(), timeoutMs: Long = LINE_TIMEOUT_MS) {
+    val wanted = lines.map { l -> { s: String -> s == l } } + messages.map { m -> { s: String -> stripTime(s) == m } }
+    await(timeoutMs, "$name: all of ${lines + messages}") { lastIndexOfAll(wanted) != null }
+    synchronized(this.lines) { lastIndexOfAll(wanted)?.takeIf { it >= 0 }?.let { dropThrough(it) } }
+  }
+
   fun nextLine(timeoutMs: Long = LINE_TIMEOUT_MS): String {
     await(timeoutMs, "$name: next output line") { synchronized(lines) { lines.isNotEmpty() } }
     return synchronized(lines) { lines.removeAt(0) }
@@ -94,6 +107,11 @@ abstract class PeerLines(val name: String, protected val waiter: Waiter) {
 
   protected fun stripTime(line: String): String = TIME_PREFIX.replaceFirst(line, "")
 
+  private fun lastIndexOfAll(wanted: List<(String) -> Boolean>): Int? = synchronized(lines) {
+    val used = HashSet<Int>()
+    wanted.maxOfOrNull { p -> lines.indices.firstOrNull { it !in used && p(lines[it]) }?.also { used += it } ?: return null } ?: -1
+  }
+
   private fun takeFirst(pred: (String) -> Boolean): String? = synchronized(lines) {
     val i = lines.indexOfFirst(pred)
     if (i >= 0) lines.removeAt(i) else null
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PrivacyScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PrivacyScreens.kt
new file mode 100644
index 0000000000..a645ea2f2a
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PrivacyScreens.kt
@@ -0,0 +1,131 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+
+fun UiScope.yourPrivacy(app: App): PrivacyScreen {
+  app.settings()
+  click(Ui.Settings.Privacy)
+  waitFor(Ui.Privacy.More)
+  return PrivacyScreen(this)
+}
+
+class PrivacyScreen(private val s: UiScope) {
+  fun more(): PrivacyScreen {
+    s.click(Ui.Privacy.More)
+    s.waitFor(Ui.Privacy.ShowLastMessages)
+    return this
+  }
+
+  fun lock(): LockScreen {
+    s.click(Ui.Privacy.Lock)
+    s.waitFor(Ui.Lock.Enable)
+    return LockScreen(s)
+  }
+
+  fun closeMore() {
+    s.escape()
+    s.poll(what = "More privacy to close") { !s.exists(Ui.Privacy.ShowLastMessages) && s.exists(Ui.Privacy.More) }
+  }
+
+  fun close() {
+    s.escape()
+    s.poll(what = "Your privacy to close") { !s.exists(Ui.Privacy.More) && s.exists(Ui.Settings.Privacy) }
+    s.escape()
+    s.poll(what = "Your settings to close") { !s.exists(Ui.Settings.Privacy) && s.exists(Ui.ChatList.Search) }
+  }
+}
+
+class LockScreen(private val s: UiScope) {
+  val passcode = PasscodeScreen(s)
+
+  fun enable(code: String) {
+    s.click(Ui.Lock.Enable)
+    passcode.await(NEW_PASSCODE)
+    passcode.enter(code)
+    passcode.submit()
+    passcode.await(CONFIRM_PASSCODE)
+    passcode.enter(code)
+    passcode.submit()
+    passcode.confirmAlert(PASSCODE_SET)
+    s.poll(what = "Lock after and Change passcode on the lock screen") { s.exists(Ui.Lock.Delay) && s.exists(Ui.Lock.ChangePasscode) }
+  }
+
+  fun close() {
+    s.escape()
+    s.poll(what = "SimpleX Lock to close") { !s.exists(Ui.Lock.Enable) && s.exists(Ui.Privacy.Lock) }
+    PrivacyScreen(s).close()
+  }
+
+  companion object {
+    const val NEW_PASSCODE = "New Passcode"
+    const val CONFIRM_PASSCODE = "Confirm passcode"
+    const val ENTER_PASSCODE = "Enter Passcode"
+    const val PASSCODE_SET = "Passcode set!"
+  }
+}
+
+class PasscodeScreen(private val s: UiScope) {
+  fun await(title: String) =
+    s.poll(what = "the `$title` passcode screen") { s.seesText(title) && s.exists(Ui.Passcode.Submit) }
+
+  fun enter(code: String) {
+    for (c in code) s.click(Ui.Passcode.Digit(c.digitToInt()))
+  }
+
+  fun submitLabel(): String? = s.textsOf(Ui.Passcode.Submit).firstOrNull()
+
+  fun submit() = s.click(Ui.Passcode.Submit)
+
+  fun clear() = s.click(Ui.Passcode.Clear)
+
+  fun backspace() = s.click(Ui.Passcode.Backspace)
+
+  fun gone(): Boolean = !s.exists(Ui.Passcode.Submit)
+
+  fun confirmAlert(title: String) {
+    s.poll(what = "the `$title` alert") { s.seesText(title) && AlertManager.shared.hasAlertsShown() }
+    s.click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    s.poll(what = "the `$title` alert to close") { !AlertManager.shared.hasAlertsShown() }
+  }
+
+  fun authFailed() {
+    s.poll(what = "the passcode screen to close") { gone() }
+    s.poll(what = "the Authentication failed alert") { s.seesText(AUTH_FAILED) && s.seesText(NOT_VERIFIED) }
+    confirmAlert(AUTH_FAILED)
+  }
+
+  private companion object {
+    const val AUTH_FAILED = "Authentication failed"
+    const val NOT_VERIFIED = "You could not be verified; please try again."
+  }
+}
+
+fun PeerLines.groupId(group: String): Long {
+  sends("/i #$group")
+  val id = eventuallyMatching(Regex("group ID: (\\d+)")).groupValues[1].toLong()
+  eventuallyMatching(Regex("current members: \\d+"))
+  return id
+}
+
+fun PeerLines.chatItems(chatRef: String, count: Int = 20): List<JsonObject> {
+  sends("/_get chat $chatRef count=$count")
+  val json = eventuallyMatching(CHAT_JSON).value
+  return Json.parseToJsonElement(json).jsonObject.getValue("chatItems").jsonArray.map { it.jsonObject }
+}
+
+fun PeerLines.item(chatRef: String, text: String): JsonObject? =
+  chatItems(chatRef).lastOrNull { it.getValue("meta").jsonObject["itemText"]?.jsonPrimitive?.content == text }
+
+fun PeerLines.itemStatus(chatRef: String, text: String): String? =
+  item(chatRef, text)?.let { it.getValue("meta").jsonObject["itemStatus"]?.jsonObject?.get("type")?.jsonPrimitive?.content }
+
+fun PeerLines.msgContent(chatRef: String, text: String): JsonObject? =
+  item(chatRef, text)?.get("content")?.jsonObject?.get("msgContent")?.jsonObject
+
+private val CHAT_JSON = Regex("\\{.*\"chatItems\":.*")
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ProfilesAddressScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ProfilesAddressScreens.kt
new file mode 100644
index 0000000000..31502c1c92
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ProfilesAddressScreens.kt
@@ -0,0 +1,74 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import chat.simplex.common.ui.UiKey
+
+val PROFILES_SEARCH = Ui.Profiles.Bar.part("search")
+
+fun userHidden(userId: Long): Boolean = chatModel.users.firstOrNull { it.user.userId == userId }?.user?.hidden == true
+
+fun addressShared(): Boolean = chatModel.currentUser.value?.addressShared == true
+
+fun UiScope.labelled(key: UiKey, text: String): Boolean = exists(key) && text in textsOf(key)
+
+fun UiScope.awaitAppIdle(what: String) = poll(what = "app work started by $what to finish") { UiIdle.inFlight().isEmpty() }
+
+fun UiScope.typePassword(key: UiKey, text: String) {
+  val before = editableText(key).orEmpty().length
+  enterText(key, text)
+  poll(what = "field ${key.tag} to hold ${before + text.length} characters") { editableText(key)?.length == before + text.length }
+}
+
+fun UiScope.closeTopScreen(what: String, closed: () -> Boolean) {
+  hideKeyboard()
+  escape()
+  poll(what = "$what to close", cond = closed)
+}
+
+fun UiScope.closeProfilesScreen() {
+  hideKeyboard()
+  click(described("Back"))
+  poll(what = "the profiles screen to close") { !exists(PROFILES_SEARCH) }
+}
+
+fun UiScope.dismissNewChatSheet() {
+  hideKeyboard()
+  goBack()
+  poll(what = "the New chat sheet to close") { !exists(Ui.NewChat.Search) }
+}
+
+fun UiScope.pickerRowOpens(app: App, row: UiKey, what: String, shown: () -> Boolean) {
+  app.userPicker()
+  click(row)
+  poll(what = "$what, with the user picker closed") { shown() && !exists(Ui.UserPicker.Sheet) }
+}
+
+fun UiScope.pickerRowInert(app: App, row: UiKey, what: String, opened: () -> Boolean) {
+  app.userPicker()
+  waitFor(row)
+  if (isEnabled(row)) click(row)
+  settle()
+  awaitAppIdle("tapping ${row.tag}")
+  check(exists(Ui.ChatList.Search) && !opened()) { "${row.tag} opened $what while chat is stopped" }
+  if (exists(Ui.UserPicker.Sheet)) {
+    escape()
+    poll(what = "the user picker to close") { !exists(Ui.UserPicker.Sheet) }
+  }
+}
+
+fun UiScope.leaveAddressSettingsExpectingSaveAlert() {
+  hideKeyboard()
+  escape()
+  poll(what = "the `Save settings?` alert with `Save SimpleX address settings` and `Exit without saving`") {
+    seesText("Save settings?") &&
+      labelled(Ui.Alert.Confirm(Ui.AlertSource.Shared), "Save SimpleX address settings") &&
+      labelled(Ui.Alert.Dismiss(Ui.AlertSource.Shared), "Exit without saving")
+  }
+}
+
+fun UiScope.awaitAddressScreenAfterSettings() {
+  poll(what = "address settings to close to the address screen") { !exists(Ui.Address.AutoAccept) && exists(Ui.Address.Business) }
+  waitStable(Ui.Address.Business)
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ProfilesScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ProfilesScreens.kt
new file mode 100644
index 0000000000..19529e7e28
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ProfilesScreens.kt
@@ -0,0 +1,63 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import kotlinx.coroutines.runBlocking
+
+private const val RESEND_MS = 2_000L
+
+fun userIdOf(name: String): Long = chatModel.users.first { it.user.displayName == name }.user.userId
+
+fun userShowsNtfs(userId: Long): Boolean? = chatModel.users.firstOrNull { it.user.userId == userId }?.user?.showNtfs
+
+fun hideUserViaApi(userId: Long, password: String) {
+  val user = chatModel.users.first { it.user.userId == userId }.user
+  chatModel.updateUser(runBlocking { chatController.apiHideUser(user, password) })
+}
+
+fun setFullNameViaApi(fullName: String) {
+  val profile = chatModel.currentUser.value!!.profile.toProfile().copy(fullName = fullName)
+  val (updated, _) = runBlocking { chatController.apiUpdateProfile(null, profile) } ?: error("apiUpdateProfile failed")
+  chatModel.updateCurrentUser(null, updated)
+}
+
+fun UiScope.unreadBadge(key: UiKey): String? =
+  textsOf(key).firstOrNull { it.isNotEmpty() && it.all(Char::isDigit) }
+
+fun UiScope.openProfileMenu(userId: Long, action: String) {
+  openContextMenu(Ui.Profiles.User(userId))
+  waitFor(Ui.Profiles.UserMenu(userId, "delete"))
+  check(exists(Ui.Profiles.UserMenu(userId, action))) { "the menu of user $userId has no `$action`" }
+}
+
+fun UiScope.profileEditorSave() {
+  hideKeyboard()
+  poll(what = "`Save and notify contacts` to be enabled") { isEnabled(Ui.Profile.Save) }
+  click(Ui.Profile.Save)
+}
+
+fun UiScope.leaveProfileEditorExpectingSaveAlert() {
+  hideKeyboard()
+  goBack()
+  poll(what = "the `Save preferences?` alert with `Save and notify contacts` and `Exit without saving`") {
+    seesText("Save preferences?") &&
+      "Save and notify contacts" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) &&
+      "Exit without saving" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+  }
+}
+
+fun UiScope.sendUntilAuthFailed(peer: CliPeer, contact: String) {
+  val failed = Regex("\\[$contact, contactId: \\d+, connId: \\d+] error: connection authorization failed.*")
+  var sentAt = 0L
+  var n = 0
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "${peer.name}'s messages to $contact to fail with `connection authorization failed`") {
+    if (System.currentTimeMillis() - sentAt >= RESEND_MS) {
+      peer sends "@$contact are you there ${++n}"
+      sentAt = System.currentTimeMillis()
+    }
+    peer.pending().any { failed.matches(it) }
+  }
+  peer.eventuallyMatching(failed)
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/RemoteScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/RemoteScreens.kt
new file mode 100644
index 0000000000..4a16ad69a5
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/RemoteScreens.kt
@@ -0,0 +1,164 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import kotlinx.coroutines.runBlocking
+
+class RemoteCtrlOffer(val ctrlName: String, val sessionCode: String)
+
+fun CliPeer.setDeviceName(name: String) {
+  this sends "/set device name $name"
+  eventually("ok")
+}
+
+fun CliPeer.connectRemoteCtrl(invitation: String): RemoteCtrlOffer {
+  this sends "/connect remote ctrl $invitation"
+  val ctrlName = eventuallyMatching(CONNECTING_NEW_CTRL, CONNECT_TIMEOUT_MS).groupValues[1]
+  eventually("new remote controller connected", CONNECT_TIMEOUT_MS)
+  this expects "Compare session code with controller and use:"
+  val verify = nextLine()
+  if (!verify.startsWith(VERIFY_CTRL)) throw AssertionError("$name: expected `$VERIFY_CTRL<session code>`, got `$verify`; next: ${pending()}")
+  return RemoteCtrlOffer(ctrlName, verify.removePrefix(VERIFY_CTRL))
+}
+
+fun CliPeer.verifyRemoteCtrl(sessionCode: String): String {
+  this sends "$VERIFY_CTRL$sessionCode"
+  return eventuallyMatching(CTRL_SESSION_STARTED, CONNECT_TIMEOUT_MS).groupValues[1]
+}
+
+fun CliPeer.stopRemoteCtrl() {
+  this sends "/stop remote ctrl"
+  eventually("ok")
+}
+
+fun CliPeer.startRemoteHost(port: Int): String {
+  this sends "/start remote host new addr=127.0.0.1 iface=\"lo\" port=$port"
+  eventually("new remote host started on 127.0.0.1:$port", CONNECT_TIMEOUT_MS)
+  eventually("Remote session invitation:")
+  return nextLine()
+}
+
+fun CliPeer.awaitRemoteHostCode(): String {
+  eventually("new remote host connecting", CONNECT_TIMEOUT_MS)
+  this expects "Compare session code with host:"
+  return nextLine()
+}
+
+fun CliPeer.awaitNewRemoteHost(): String {
+  val added = eventuallyMatching(NEW_HOST_ADDED, CONNECT_TIMEOUT_MS)
+  eventuallyMatching(Regex("remote host ${added.groupValues[1]} connected \\((with|no) compression\\)"), CONNECT_TIMEOUT_MS)
+  return added.groupValues[2]
+}
+
+fun UiScope.linkMobile(app: App): LinkMobileScreen {
+  app.userPicker()
+  click(Ui.UserPicker.LinkMobile)
+  waitFor(Ui.Remote.AddMobile)
+  return LinkMobileScreen(this)
+}
+
+class LinkMobileScreen(private val s: UiScope) {
+  fun deviceName(): String? {
+    s.waitFor(Ui.Remote.DeviceName)
+    return s.editableText(Ui.Remote.DeviceName)
+  }
+
+  fun addMobile(): String {
+    s.click(Ui.Remote.AddMobile)
+    s.poll(timeoutMs = 30_000, what = "the invitation QR code with `Waiting for mobile to connect:` and `Share link`") {
+      s.seesDescription("QR Code") && s.seesText("Waiting for mobile to connect:") && s.exists(Ui.Remote.ShareLink)
+    }
+    s.click(Ui.Remote.ShareLink)
+    var invitation: String? = null
+    s.poll(what = "the invitation on the clipboard") {
+      invitation = s.clipboardText()?.takeIf { it.startsWith("xrcp:/") }
+      invitation != null
+    }
+    return invitation!!
+  }
+}
+
+fun UiScope.awaitMobileSession(hostDeviceName: String): Long {
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the desktop to switch to the mobile `$hostDeviceName` and close the pairing screen") {
+    chatModel.currentRemoteHost.value?.hostDeviceName == hostDeviceName && !chatModel.switchingUsersAndHosts.value &&
+      !exists(Ui.Remote.AddMobile) && !exists(Ui.Remote.DeviceName)
+  }
+  quiesce()
+  return chatModel.currentRemoteHost.value!!.remoteHostId
+}
+
+fun UiScope.linkMobileHost(app: App, mobile: CliPeer, hostDeviceName: String): Long {
+  val offer = mobile.connectRemoteCtrl(linkMobile(app).addMobile())
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the session code `${offer.sessionCode.take(23)}` on the pairing screen") { seesText(offer.sessionCode.take(23)) }
+  mobile.verifyRemoteCtrl(offer.sessionCode)
+  return awaitMobileSession(hostDeviceName)
+}
+
+fun UiScope.endMobileSessionViaApi(mobile: CliPeer) {
+  val host = chatModel.currentRemoteHost.value ?: error("the desktop has no mobile session to end")
+  chatController.stopRemoteHostAndReloadHosts(host, switchToLocal = true)
+  mobile.eventually("remote controller stopped", CONNECT_TIMEOUT_MS)
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the desktop back on its own profile") {
+    chatModel.currentRemoteHost.value == null && !chatModel.switchingUsersAndHosts.value
+  }
+  quiesce()
+}
+
+fun UiScope.useFromDesktop(app: App): ConnectDesktopScreen {
+  app.userPicker()
+  click(Ui.UserPicker.UseFromDesktop)
+  waitFor(Ui.Remote.DeviceName)
+  return ConnectDesktopScreen(this)
+}
+
+class ConnectDesktopScreen(private val s: UiScope) {
+  fun deviceName(): String? {
+    s.waitFor(Ui.Remote.DeviceName)
+    return s.editableText(Ui.Remote.DeviceName)
+  }
+
+  fun paste(invitation: String) {
+    s.click(Ui.Remote.PasteAddress)
+    s.poll(what = "the pasted desktop address in the address field") { s.seesText(invitation) }
+  }
+
+  fun connect() = s.click(Ui.Remote.Connect)
+
+  fun confirm(sessionCode: String) {
+    s.poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Verify connection` with the session code `${sessionCode.take(23)}`") {
+      s.seesText("Verify connection") && s.seesText(sessionCode.take(23)) && s.exists(Ui.Remote.Confirm)
+    }
+    s.click(Ui.Remote.Confirm)
+  }
+
+  fun awaitConnected(desktopName: String, sessionCode: String) =
+    s.poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Connected to desktop` with `$desktopName` and the session code `${sessionCode.take(23)}`") {
+      s.seesText("Connected to desktop") && s.seesText("Connected desktop") && s.seesText(desktopName) && s.seesText(sessionCode.take(23)) && s.exists(Ui.Remote.Disconnect)
+    }
+}
+
+fun UiScope.linkToDesktop(app: App, controller: CliPeer, desktopName: String, port: Int): ConnectDesktopScreen {
+  val invitation = controller.startRemoteHost(port)
+  setClipboardText(invitation)
+  val screen = useFromDesktop(app)
+  screen.paste(invitation)
+  screen.connect()
+  val code = controller.awaitRemoteHostCode()
+  screen.confirm(code)
+  controller.awaitNewRemoteHost()
+  screen.awaitConnected(desktopName, code)
+  return screen
+}
+
+fun UiScope.endDesktopSessionViaApi(controller: CliPeer) {
+  check(runBlocking { chatController.stopRemoteCtrl() }) { "stopRemoteCtrl failed" }
+  runBlocking { chatController.switchToLocalSession() }
+  controller.eventuallyMatching(Regex("remote host \\d+ stopped"), CONNECT_TIMEOUT_MS)
+  quiesce()
+}
+
+private const val VERIFY_CTRL = "/verify remote ctrl "
+private val CONNECTING_NEW_CTRL = Regex("connecting new remote controller: (.+), v\\d\\S*.*")
+private val CTRL_SESSION_STARTED = Regex("remote controller \\d+ session started with (.+) \\((with|no) compression\\)")
+private val NEW_HOST_ADDED = Regex("new remote host (\\d+) added: (.+)")
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ReportScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ReportScreens.kt
new file mode 100644
index 0000000000..67d5548fab
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ReportScreens.kt
@@ -0,0 +1,148 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatItem
+import chat.simplex.common.model.GroupMemberRole
+import chat.simplex.common.model.MsgContentTag
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import chat.simplex.common.views.helpers.ModalManager
+import chat.simplex.common.views.helpers.ModalViewId
+import kotlinx.coroutines.runBlocking
+
+fun UiScope.memberOfHostedGroup(app: App, host: CliPeer, member: CliPeer, group: String = "team"): ChatScreen {
+  val me = chatModel.currentUser.value!!.displayName
+  connect(host)
+  connectPeers(host, member)
+  hostGroup(host, group, me, member.name)
+  joinGroupFromList(app, host, group)
+  member sends "/j $group"
+  member.eventually("#$group: you joined the group", CONNECT_TIMEOUT_MS)
+  host.eventually("#$group: ${member.name} joined the group", CONNECT_TIMEOUT_MS)
+  member.eventually("#$group: member $me is connected", CONNECT_TIMEOUT_MS)
+  quiesce()
+  backToChatList()
+  return app.chatList.open(group)
+}
+
+fun UiScope.ownGroupWithTwo(app: App, a: CliPeer, b: CliPeer, group: String = "team"): ChatScreen {
+  connect(a)
+  connect(b)
+  val chat = ownGroup(app, group, a, b)
+  a.eventuallyMatching(Regex("#$group: (new )?member ${b.name} is connected"), CONNECT_TIMEOUT_MS)
+  b.eventuallyMatching(Regex("#$group: (new )?member ${a.name} is connected"), CONNECT_TIMEOUT_MS)
+  quiesce()
+  return chat
+}
+
+fun CliPeer.sendsReport(group: String, reason: String, author: String, text: String) {
+  this sends "/report #$group $reason $text"
+  expectsMessage("#$group (support) > $author $text")
+  this expects "      report $reason"
+}
+
+fun CliPeer.receivesReport(group: String, reporter: String, author: String, text: String, report: String) {
+  val line = nextLine(CONNECT_TIMEOUT_MS)
+  val expected = Regex("""^(\d{2}:\d{2} )?""" + Regex.escape("#$group (support: $reporter) $reporter") + """!?""" + Regex.escape("> > $author $text") + "$")
+  check(expected.matches(line)) { "$name: expected the report of `$text` from $reporter, got `$line`; next: ${pending()}" }
+  this expects "      $report"
+}
+
+private fun memberIdViaApi(group: String, name: String): Long =
+  runBlocking { chatController.apiListMembers(null, groupInfoOf(group).groupId) }.first { it.memberProfile.displayName == name }.groupMemberId
+
+fun setRoleViaApi(group: String, name: String, role: GroupMemberRole) {
+  val changed = runBlocking { chatController.apiMembersRole(null, groupInfoOf(group).groupId, listOf(memberIdViaApi(group, name)), role) }
+  check(changed.any { it.memberRole == role }) { "apiMembersRole did not make $name $role" }
+}
+
+fun blockForAllViaApi(group: String, name: String) {
+  val blocked = runBlocking { chatController.apiBlockMembersForAll(null, groupInfoOf(group).groupId, listOf(memberIdViaApi(group, name)), true) }
+  check(blocked.any { it.blockedByAdmin }) { "apiBlockMembersForAll did not block $name" }
+}
+
+fun UiScope.menuOffers(id: Long, action: String): Boolean {
+  openContextMenu(Ui.Chat.Item(id))
+  waitFor(Ui.Chat.ItemMenu(id, "select"))
+  val offered = exists(Ui.Chat.ItemMenu(id, action))
+  click(Ui.Chat.ItemMenu(id, "select"))
+  waitFor(Ui.Chat.Selection.part("title"))
+  escape()
+  poll(what = "selection mode to end") { !exists(Ui.Chat.Selection.part("title")) }
+  return offered
+}
+
+fun UiScope.openReportReasons(id: Long) {
+  openContextMenu(Ui.Chat.Item(id))
+  click(Ui.Chat.ItemMenu(id, "report"))
+  poll(what = "the `Report reason?` alert") { seesText("Report reason?") && exists(Ui.Alert.Dismiss(Ui.AlertSource.Shared)) }
+}
+
+fun UiScope.composeReport(id: Long, reason: String, header: String) {
+  openReportReasons(id)
+  click(Ui.Chat.ReportReason(reason))
+  poll(what = "the `$reason` report in compose with `$header`") { !seesText("Report reason?") && seesText(header) }
+}
+
+fun UiScope.sendReport(header: String) {
+  click(Ui.Chat.Send)
+  poll(what = "the report with `$header` to leave compose after sending") { !seesText(header) && editableText(Ui.Chat.Message).isNullOrEmpty() }
+}
+
+fun UiScope.reportSentAlert() =
+  poll(what = "the `Report sent to moderators` alert with `OK` and `Don't show again`") {
+    seesText("Report sent to moderators") && seesText("You can view your reports in Chat with admins.") &&
+      "OK" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && "Don't show again" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+  }
+
+fun UiScope.reportSendFinished() = poll(what = "the report send to finish") { UiIdle.inFlight().isEmpty() }
+
+fun UiScope.reportsBanner(count: String) =
+  poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `$count` banner in the group chat") { exists(Ui.Chat.Reports) && count in textsOf(Ui.Chat.Reports) }
+
+fun UiScope.openReportsFromBanner(): MemberReportsScreen {
+  click(Ui.Chat.Reports)
+  return MemberReportsScreen(this)
+}
+
+class MemberReportsScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "the `Member reports` view") {
+      chatModel.secondaryChatsContext.value?.contentTag == MsgContentTag.Report && ModalManager.end.hasModalOpen(ModalViewId.SECONDARY_CHAT) && s.seesText("Member reports")
+    }
+  }
+
+  fun items(): List<ChatItem> = chatModel.secondaryChatsContext.value?.chatItems?.value.orEmpty()
+
+  fun reportId(quoted: String): Long {
+    var id: Long? = null
+    s.poll(what = "the report of `$quoted` in `Member reports`") {
+      id = items().lastOrNull { it.isReport && it.quotedItem?.text == quoted }?.id
+      id != null && s.exists(Ui.Chat.Item(id!!))
+    }
+    return id!!
+  }
+
+  fun texts(id: Long): List<String> = s.textsOf(Ui.Chat.Item(id))
+
+  fun menu(id: Long, action: String) {
+    s.openContextMenu(Ui.Chat.Item(id))
+    s.click(Ui.Chat.ItemMenu(id, action))
+  }
+
+  fun archive(id: Long, option: String) {
+    menu(id, "archive")
+    val forMe = Ui.Alert.Option(Ui.AlertSource.Shared, "archiveForMe")
+    val forAll = Ui.Alert.Option(Ui.AlertSource.Shared, "archiveForAll")
+    s.poll(what = "the `Archive report?` alert with `For me` and `For all moderators`") {
+      s.seesText("Archive report?") && s.exists(forMe) && "For me" in s.textsOf(forMe) && s.exists(forAll) && "For all moderators" in s.textsOf(forAll)
+    }
+    s.click(Ui.Alert.Option(Ui.AlertSource.Shared, option))
+  }
+
+  fun close() {
+    s.goBack()
+    s.poll(what = "`Member reports` to close") { chatModel.secondaryChatsContext.value == null && !ModalManager.end.hasModalOpen(ModalViewId.SECONDARY_CHAT) }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/Screens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/Screens.kt
index b0e942d6da..83d13ad4a9 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/Screens.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/Screens.kt
@@ -5,6 +5,8 @@ import chat.simplex.common.model.ChatItem
 import chat.simplex.common.model.GroupMemberRole
 import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import chat.simplex.common.views.helpers.AlertManager
 import chat.simplex.common.views.helpers.ModalManager
 
 class App(private val s: UiScope) {
@@ -79,7 +81,11 @@ class ChatListScreen(private val s: UiScope) {
   }
 
   fun open(name: String): ChatScreen {
-    s.click(Ui.ChatList.Row(chatId(name)))
+    val id = chatId(name)
+    s.click(Ui.ChatList.Row(id))
+    s.poll(what = "chat `$name` to open, or an alert instead") {
+      chatModel.chatId.value == id || AlertManager.shared.hasAlertsShown() || AlertManager.privacySensitive.hasAlertsShown()
+    }
     return ChatScreen(s)
   }
 
@@ -89,6 +95,13 @@ class ChatListScreen(private val s: UiScope) {
 
   fun shareTo(name: String) = s.click(Ui.Share.Row(chatId(name)))
 
+  fun shareSearch(text: String) {
+    s.click(described("Search"))
+    s.typeInto(Ui.Share.Bar.part("search"), text)
+  }
+
+  fun shareShown(name: String): Boolean = s.exists(Ui.Share.Row(chatId(name)))
+
   fun rowTexts(name: String): List<String> = s.textsOf(Ui.ChatList.Row(chatId(name)))
 
   fun rowDescriptions(name: String): List<String> = s.descriptionsOf(Ui.ChatList.Row(chatId(name)))
@@ -187,6 +200,13 @@ class AppearanceScreen(private val s: UiScope) {
 
   fun colorModeText(): String? = s.textOf(Ui.Appearance.ColorMode)
 
+  fun darkModeColors(theme: String) {
+    s.click(Ui.Appearance.DarkModeColors)
+    s.click(Ui.Appearance.DarkModeColors.option(theme))
+  }
+
+  fun darkModeColorsText(): String? = s.textOf(Ui.Appearance.DarkModeColors)
+
   var fontScale: Float
     get() = s.sliderValue(Ui.Appearance.FontScale)
     set(v) = s.setSlider(Ui.Appearance.FontScale, v)
@@ -245,6 +265,27 @@ class ChatScreen(private val s: UiScope) {
     s.click(Ui.Chat.ItemMenu(id, action))
   }
 
+  fun select(text: String) {
+    menu(text, "select")
+    s.waitFor(Ui.Chat.Selection.part("title"))
+  }
+
+  fun toggle(id: Long) = s.click(Ui.Chat.Item(id))
+
+  fun selectionTitle(): String? = Ui.Chat.Selection.part("title").let { k -> if (s.exists(k)) s.textsOf(k).firstOrNull() else null }
+
+  fun itemInfo(text: String): ItemInfoScreen {
+    menu(text, "info")
+    s.poll(what = "the item info with `Sent message` and `History`") { s.seesText("Sent message") && s.seesText("History") }
+    return ItemInfoScreen(s)
+  }
+
+  fun receivedItemInfo(text: String): ItemInfoScreen {
+    menu(text, "info")
+    s.poll(what = "the item info with `Received message`") { s.seesText("Received message") }
+    return ItemInfoScreen(s)
+  }
+
   fun react(text: String, emoji: String) {
     val id = itemId(text)
     s.rightClick(Ui.Chat.Item(id))
@@ -261,6 +302,31 @@ class ChatScreen(private val s: UiScope) {
     s.click(Ui.Chat.Send)
   }
 
+  fun itemId(what: String, match: (ChatItem) -> Boolean): Long {
+    var id: Long? = null
+    s.poll(timeoutMs = CONNECT_TIMEOUT_MS, what = what) {
+      val found = chatModel.chatsContext.chatItems.value.lastOrNull(match)?.id
+      id = found
+      found != null && s.exists(Ui.Chat.Item(found))
+    }
+    return id!!
+  }
+
+  fun forwardItemTo(id: Long, chatName: String) {
+    s.rightClick(Ui.Chat.Item(id))
+    s.click(Ui.Chat.ItemMenu(id, "forward"))
+    ChatListScreen(s).shareTo(chatName)
+    s.poll(what = "the send button to be enabled for forwarding") { s.isEnabled(Ui.Chat.Send) }
+    s.click(Ui.Chat.Send)
+  }
+
+  fun forwardSelected() = s.click(Ui.Chat.Selection.part("forward"))
+
+  fun sendComposed() {
+    s.click(Ui.Chat.Send)
+    s.poll(what = "the message field to clear after Send") { s.editableText(Ui.Chat.Message).isNullOrEmpty() }
+  }
+
   fun openSearch() {
     s.click(Ui.Chat.BarMenu)
     s.click(Ui.Chat.BarMenuItem("search"))
@@ -334,6 +400,28 @@ class GroupInfoScreen(private val s: UiScope) {
     return link!!
   }
 
+  fun preferences(): GroupPreferencesScreen {
+    s.click(Ui.GroupInfo.Preferences)
+    return GroupPreferencesScreen(s)
+  }
+
+  fun chatsWithMembers(): MemberSupportScreen {
+    s.click(Ui.GroupInfo.MemberSupport)
+    return MemberSupportScreen(s)
+  }
+
+  fun reportsTexts(): List<String> = s.textsOf(Ui.GroupInfo.Reports)
+
+  fun reports(): MemberReportsScreen {
+    s.click(Ui.GroupInfo.Reports)
+    return MemberReportsScreen(s)
+  }
+
+  fun close() {
+    s.escape()
+    s.poll(what = "group info to close") { !ModalManager.end.hasModalsOpen() }
+  }
+
   private fun memberId(name: String): Long {
     var id: Long? = null
     s.poll(what = "member `$name` in the model") {
@@ -362,6 +450,37 @@ class MemberInfoScreen(private val s: UiScope) {
     s.click(Ui.MemberInfo.Remove)
     s.click(Ui.Alert.Option(Ui.AlertSource.Shared, "remove"))
   }
+
+  fun removeWithMessages() {
+    s.click(Ui.MemberInfo.Remove)
+    val option = Ui.Alert.Option(Ui.AlertSource.Shared, "removeWithMessages")
+    s.poll(what = "the `Remove member?` alert with `Remove and delete messages`") {
+      s.seesText("Remove member?") && s.exists(option) && "Remove and delete messages" in s.textsOf(option)
+    }
+    s.click(option)
+  }
+
+  fun pickRole(role: GroupMemberRole) {
+    s.click(Ui.MemberInfo.Role)
+    s.click(Ui.MemberInfo.Role.option(role))
+    s.poll(what = "the `Change role?` alert with `Change`") { s.seesText("Change role?") && "Change" in s.textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+  }
+
+  fun block(name: String) = confirm(Ui.MemberInfo.Block, "Block member?", "All new messages from $name will be hidden!", "Block")
+
+  fun unblock(name: String) = confirm(Ui.MemberInfo.Unblock, "Unblock member?", "Messages from $name will be shown!", "Unblock")
+
+  fun unblockForAll(name: String) = confirm(Ui.MemberInfo.UnblockForAll, "Unblock member for all?", "Messages from $name will be shown!", "Unblock for all")
+
+  private fun confirm(button: UiKey, title: String, text: String, action: String) {
+    s.click(button)
+    s.poll(what = "the `$title` alert saying `$text` with `$action`") {
+      s.seesText(title) && s.seesText(text) && action in s.textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    s.click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  }
+
+  fun message() = s.click(Ui.MemberInfo.Message)
 }
 
 fun UiScope.emptyGroup(app: App, group: String): ChatScreen {
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/SendImageScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/SendImageScreens.kt
new file mode 100644
index 0000000000..46353ffcba
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/SendImageScreens.kt
@@ -0,0 +1,26 @@
+package chat.simplex.app.ui.harness
+
+import androidx.compose.ui.graphics.ImageBitmap
+import chat.simplex.common.platform.compressImageData
+import chat.simplex.common.ui.Ui
+import java.io.File
+
+private const val JPEG_SIZE = 64
+private val COMPRESSED_IMAGE_OFFER = Regex("""(?:\d{2}:\d{2} )?(.+)sends file (IMG_\S+\.jpg) \(.+ / \d+ bytes\)""")
+
+fun UiScope.jpegFile(name: String): File =
+  File(exchangeDir(), name).apply { writeBytes(compressImageData(ImageBitmap(JPEG_SIZE, JPEG_SIZE), usePng = false).toByteArray()) }
+
+fun UiScope.attachImage(file: File) {
+  openAttachmentSheet()
+  openFile(file) { click(Ui.Chat.Attach("image")) }
+  poll(what = "the preview of ${file.name} with `Cancel image preview`") { seesDescription("Cancel image preview") && seesDescription("preview image") }
+}
+
+fun CliPeer.receivesCompressedImage(sender: String, fileId: Int, timeoutMs: Long = CONNECT_TIMEOUT_MS): String {
+  val line = nextLine(timeoutMs)
+  val m = COMPRESSED_IMAGE_OFFER.matchEntire(line)?.takeIf { it.groupValues[1] == sender }
+    ?: throw AssertionError("$name: expected `${sender}sends file IMG_….jpg (…)`, got `$line`; next: ${pending()}")
+  this expects "use /fr $fileId [<dir>/ | <path>] to receive it"
+  return m.groupValues[2]
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ServersConfig.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ServersConfig.kt
index f8af563602..cbec933daf 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ServersConfig.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ServersConfig.kt
@@ -1,5 +1,7 @@
 package chat.simplex.app.ui.harness
 
+import chat.simplex.common.model.RelayProfile
+import chat.simplex.common.model.UserChatRelay
 import chat.simplex.common.model.UserServer
 import chat.simplex.common.platform.chatController
 import chat.simplex.common.platform.chatModel
@@ -16,3 +18,17 @@ fun configureServers(smp: String, xftp: String) {
   check(runBlocking { chatController.setUserServers(null, updated) }) { "setUserServers failed" }
   chatModel.conditions.value = runBlocking { chatController.getServerOperators(null) } ?: error("getServerOperators failed")
 }
+
+fun registerChatRelaysViaApi(vararg relays: CliPeer) {
+  val groups = runBlocking { chatController.getUserServers(null) } ?: error("getUserServers failed")
+  val added = relays.map {
+    UserChatRelay(chatRelayId = null, address = it.relayAddress, relayProfile = RelayProfile(displayName = it.name, fullName = ""), domains = emptyList(), preset = false, enabled = true, deleted = false)
+  }
+  val updated = groups.map { g -> if (g.operator == null) g.copy(chatRelays = g.chatRelays + added) else g }
+  check(updated.any { it.operator == null }) { "no custom server group to add chat relays to" }
+  check(runBlocking { chatController.setUserServers(null, updated) }) { "setUserServers failed" }
+}
+
+const val SOCKS_HOST = "127.0.0.1"
+
+data class SocksConnection(val host: String, val port: Int, val username: String?)
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ServersSummaryScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ServersSummaryScreens.kt
new file mode 100644
index 0000000000..27058b10f6
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ServersSummaryScreens.kt
@@ -0,0 +1,33 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.ui.Ui
+
+class ServersSummaryScreen(private val s: UiScope) {
+  init {
+    s.poll(what = "`Servers info` with the loaded summary") { s.seesText("Servers info") && s.exists(Ui.ServersSummary.ResetStats) }
+    s.waitStable(Ui.ServersSummary.Details)
+  }
+
+  fun value(title: String): String? = s.texts().let { t -> t.indexOf(title).takeIf { it >= 0 }?.let { t.getOrNull(it + 1) } }
+
+  fun subscribed(): String? = s.texts().let { t -> t.indexOf("Subscribed").takeIf { it >= 0 }?.let { t.getOrNull(it + 3) } }
+
+  fun details() {
+    s.click(Ui.ServersSummary.Details)
+    s.poll(what = "`Detailed statistics` with the `Subscribed` row") { s.seesText("Detailed statistics") && s.seesText("Subscribed") && !s.seesText("Connected servers") }
+  }
+
+  fun backToSummary() {
+    s.goBack()
+    s.poll(what = "back on `Servers info`") { !s.seesText("Detailed statistics") && s.exists(Ui.ServersSummary.ResetStats) }
+    s.waitStable(Ui.ServersSummary.Details)
+  }
+}
+
+fun UiScope.openServersSummary(): ServersSummaryScreen {
+  backToChatList()
+  click(Ui.ChatList.Subscriptions)
+  return ServersSummaryScreen(this)
+}
+
+fun String?.isCount(): Boolean = this != null && isNotEmpty() && all(Char::isDigit) && this != "0"
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/SettingsScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/SettingsScreens.kt
new file mode 100644
index 0000000000..bff740d737
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/SettingsScreens.kt
@@ -0,0 +1,65 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.platform.getPreferenceFilePath
+import chat.simplex.common.platform.readThemeOverrides
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.theme.CurrentColors
+import chat.simplex.common.ui.theme.DefaultTheme
+import chat.simplex.common.ui.theme.ThemeOverrides
+import chat.simplex.common.views.helpers.WallpaperType
+import java.io.File
+
+fun UiScope.developerTools(app: App) {
+  app.settings()
+  click(Ui.Settings.Version)
+  click(Ui.Settings.DeveloperTools)
+  waitFor(Ui.DevTools.Console)
+}
+
+fun UiScope.closeDeveloperTools(what: String = "the chat list", shown: UiScope.() -> Boolean = { exists(Ui.ChatList.Search) }) {
+  escape()
+  poll(what = "Developer tools to close") { !exists(Ui.DevTools.Console) && exists(Ui.Settings.DeveloperTools) }
+  escape()
+  poll(what = "App version to close") { !exists(Ui.Settings.DeveloperTools) && exists(Ui.Settings.Version) }
+  escape()
+  poll(what = "Your settings to close, showing $what") { !exists(Ui.Settings.Version) && shown() }
+}
+
+fun UiScope.chatConsole(app: App) {
+  developerTools(app)
+  click(Ui.DevTools.Console)
+  waitFor(Ui.Chat.Message)
+}
+
+fun UiScope.helpAndSupport(app: App) {
+  app.settings()
+  click(Ui.Settings.Help)
+  waitFor(Ui.Help.HowToUse)
+}
+
+fun UiScope.customizeTheme(app: App) {
+  app.appearance()
+  click(Ui.Appearance.Customize)
+  waitFor(Ui.Appearance.ExportTheme)
+}
+
+fun UiScope.closeAppearance() {
+  escape()
+  poll(what = "Appearance to close") { !exists(Ui.Appearance.ColorMode) && exists(Ui.Settings.Appearance) }
+  escape()
+  poll(what = "Your settings to close") { !exists(Ui.Settings.Appearance) && exists(Ui.ChatList.Search) }
+}
+
+fun UiScope.consoleShows(label: String): Boolean = texts().any { it.endsWith(" $label") }
+
+object StoredThemes {
+  fun yamlBytes(): ByteArray? = File(getPreferenceFilePath("themes.yaml")).takeIf { it.exists() }?.readBytes()
+
+  fun active(base: DefaultTheme): ThemeOverrides? {
+    val id = appPrefs.currentThemeIds.get()[base.themeName] ?: return null
+    return readThemeOverrides().firstOrNull { it.base == base && it.themeId == id }
+  }
+}
+
+fun currentWallpaperPreset(): String? = (CurrentColors.value.wallpaper.type as? WallpaperType.Preset)?.filename
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/SupportChatScreens.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/SupportChatScreens.kt
new file mode 100644
index 0000000000..8750cfe4a3
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/SupportChatScreens.kt
@@ -0,0 +1,49 @@
+package chat.simplex.app.ui.harness
+
+import chat.simplex.common.ui.Ui
+
+fun CliPeer.expectsScopedMessage(from: String, text: String, timeoutMs: Long = CONNECT_TIMEOUT_MS) {
+  val got = nextLine(timeoutMs)
+  val expected = Regex("(\\d{2}:\\d{2} )?" + Regex.escape(from) + "!?> " + Regex.escape(text))
+  check(expected.matches(got)) { "$name: expected message `$from> $text` (attention marker optional), got `$got`; next: ${pending()}" }
+}
+
+fun UiScope.memberOfBobsTeamWithCath(app: App, bob: CliPeer, cath: CliPeer): ChatScreen {
+  connect(bob)
+  connectPeers(bob, cath)
+  hostGroup(bob, "team", "alice", "cath")
+  joinGroupFromList(app, bob, "team")
+  cath sends "/j team"
+  cath.eventually("#team: you joined the group")
+  bob.eventually("#team: cath joined the group")
+  cath.eventually("#team: member alice is connected", CONNECT_TIMEOUT_MS)
+  quiesce()
+  backToChatList()
+  return app.chatList.open("team")
+}
+
+fun UiScope.ownTeamWithSupportRequests(app: App, bob: CliPeer, cath: CliPeer): ChatScreen {
+  connect(bob)
+  connect(cath)
+  val chat = ownGroup(app, "team", bob, cath)
+  bob.eventuallyMatching(Regex("#team: (new )?member cath is connected"), CONNECT_TIMEOUT_MS)
+  cath.eventuallyMatching(Regex("#team: (new )?member bob is connected"), CONNECT_TIMEOUT_MS)
+  poll(what = "team's chat open with no support banner") { exists(Ui.Chat.Message) && !exists(Ui.Chat.SupportChats) }
+  bob sends "#team (support) bob needs help"
+  cath sends "#team (support) cath needs help"
+  return chat
+}
+
+fun UiScope.supportBanner(): List<String> = if (exists(Ui.Chat.SupportChats)) textsOf(Ui.Chat.SupportChats) else emptyList()
+
+fun UiScope.supportRowBadge(name: String): String? {
+  val row = Ui.MemberSupport.Row(groupMemberId(name))
+  return if (exists(row)) unreadBadge(row) else null
+}
+
+fun UiScope.openSupportRowMenu(name: String): Long {
+  val id = groupMemberId(name)
+  openContextMenu(Ui.MemberSupport.Row(id))
+  waitFor(Ui.MemberSupport.RowMenu(id, "delete"))
+  return id
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/AddressTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/AddressTest.kt
new file mode 100644
index 0000000000..f522083d17
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/AddressTest.kt
@@ -0,0 +1,264 @@
+package chat.simplex.app.ui.main
+
+import chat.simplex.app.ui.harness.AddressScreen
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.addressPlanOk
+import chat.simplex.app.ui.harness.addressSettings
+import chat.simplex.app.ui.harness.addressShared
+import chat.simplex.app.ui.harness.awaitAddressGone
+import chat.simplex.app.ui.harness.awaitAddressScreenAfterSettings
+import chat.simplex.app.ui.harness.awaitAppIdle
+import chat.simplex.app.ui.harness.closeTopScreen
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.labelled
+import chat.simplex.app.ui.harness.leaveAddressSettingsExpectingSaveAlert
+import chat.simplex.app.ui.harness.pickerRowOpens
+import chat.simplex.app.ui.harness.savedAddressSettings
+import chat.simplex.app.ui.harness.shareAddress
+import chat.simplex.common.model.BusinessChatType
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import chat.simplex.common.views.helpers.AlertManager
+import org.junit.Test
+
+class AddressTest : UiTest() {
+  @Test fun addressDelete() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob)
+    alice.chatList.row("bob")
+    alice.userPicker().address()
+    click(Ui.Address.Create)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Share address with SimpleX contacts?` alert with `Share`") {
+      seesText("Share address with SimpleX contacts?") && "Share" in textsOf(CONFIRM)
+    }
+    click(CONFIRM)
+    bob.eventually("alice set new contact address, use /info alice to view", CONNECT_TIMEOUT_MS)
+    val address = shareAddress()
+    check(cath.addressPlanOk(address)) { "cath's plan rejects the address before it is deleted" }
+    click(Ui.Address.Delete)
+    poll(what = "the `Delete address?` alert saying contacts stay connected and get a profile update") {
+      seesText("Delete address?") && seesText("All your contacts will remain connected. Profile update will be sent to your contacts.") && "Delete" in textsOf(CONFIRM)
+    }
+    click(CONFIRM)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the address screen back to `Create SimpleX address`") {
+      chatModel.userAddress.value == null && exists(Ui.Address.Create) && !exists(Ui.Address.Delete)
+    }
+    bob.eventually("alice removed contact address", CONNECT_TIMEOUT_MS)
+    cath.awaitAddressGone(address)
+    cath sends "/c $address"
+    cath.nextLine(CONNECT_TIMEOUT_MS).let { check("error: connection authorization failed" in it) { "cath's `/c` via the deleted address printed `$it`" } }
+  }
+
+  @Test fun addressAutoAcceptWelcomeMessage() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath"); val dave = cli("dave")
+    val address = alice.userPicker().createAddress()
+    bob sends "/c $address"
+    bob expects "connection request sent!"
+    alice.chatList.request("bob")
+    alice.userPicker().address()
+    val settings = addressSettings()
+    settings.toggleAutoAccept()
+    poll(what = "auto-accept saved") { savedAddressSettings()?.autoAccept != null }
+    settings.welcome("hello!")
+    settings.save()
+    poll(what = "the welcome message saved") { savedAddressSettings()?.autoReply?.text == "hello!" }
+    cath sends "/c $address"
+    cath expects "connection request sent!"
+    cath.eventuallyAll(listOf("alice: contact is connected"), messages = listOf("alice> hello!"), timeoutMs = CONNECT_TIMEOUT_MS)
+    settings.toggleAutoAccept()
+    poll(what = "auto-accept off saved with no welcome message") { savedAddressSettings()?.let { it.autoAccept == null && it.autoReply == null } == true }
+    settings.close()
+    AddressScreen(this).close()
+    dave sends "/c $address"
+    dave expects "connection request sent!"
+    alice.chatList.request("dave")
+    alice.chatList.request("bob")
+    poll(what = "cath connected as a contact without a request") {
+      (alice.chatList.chat("cath").chatInfo as? ChatInfo.Direct)?.contact?.let { it.sndReady && !it.nextAcceptContactRequest } == true
+    }
+  }
+
+  @Test fun addressBusinessToggleAutoEnablesAutoAccept() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val address = alice.userPicker().address().create()
+    waitFor(Ui.Address.Business)
+    check(!seesText(TEAM_FOOTER) && savedAddressSettings()?.let { !it.businessAddress && it.autoAccept == null } == true) { "a new address is a business address or auto-accepts" }
+    click(Ui.Address.Business)
+    poll(what = "the business footer shown and business with auto-accept saved") {
+      seesText(TEAM_FOOTER) && savedAddressSettings()?.let { it.businessAddress && it.autoAccept != null } == true
+    }
+    val settings = addressSettings()
+    check(!settings.autoAcceptEnabled()) { "`Auto-accept` can be turned off for a business address" }
+    settings.close()
+    bob sends "/c $address"
+    bob expects "connection request sent!"
+    bob.eventually("#alice: joining the group...", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "a customer business chat with bob") {
+      chatModel.chats.value.any { (it.chatInfo as? ChatInfo.Group)?.groupInfo?.businessChat?.chatType == BusinessChatType.Customer && it.chatInfo.chatViewName == "bob" }
+    }
+    click(Ui.Address.Business)
+    poll(what = "the business footer gone and a plain auto-accepting address saved") {
+      !seesText(TEAM_FOOTER) && savedAddressSettings()?.let { !it.businessAddress && it.autoAccept != null } == true
+    }
+    cath sends "/c $address"
+    cath expects "connection request sent!"
+    cath.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "cath connected as a direct contact") {
+      chatModel.chats.value.any { (it.chatInfo as? ChatInfo.Direct)?.contact?.let { c -> c.displayName == "cath" && c.sndReady } == true }
+    }
+  }
+
+  @Test fun addressScreenNoAddressShowsCreate() = uiTest {
+    val alice = app("alice")
+    alice.userPicker().address()
+    poll(what = "`For social media` › `Create SimpleX address`, `Or to share privately` › `Create 1-time link`, and `SimpleX address or 1-time link?`") {
+      seesText("For social media") && labelled(Ui.Address.Create, "Create SimpleX address") &&
+        seesText("Or to share privately") && labelled(Ui.Address.CreateLink, "Create 1-time link") &&
+        labelled(Ui.Address.LearnMore, "SimpleX address or 1-time link?") && !exists(Ui.Address.Share) && !exists(Ui.Address.Delete)
+    }
+    click(Ui.Address.LearnMore)
+    poll(what = "`Address or 1-time link?` with its three sections") {
+      seesText("Address or 1-time link?") && seesText("Share address publicly") && seesText("Share 1-time link with a friend") &&
+        seesText("Connection security") && !exists(Ui.Address.Create)
+    }
+    closeTopScreen("`Address or 1-time link?`") { !seesText("Address or 1-time link?") && exists(Ui.Address.Create) }
+    click(Ui.Address.CreateLink)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "New chat on the 1-time link with the link created") {
+      seesText("Share this 1-time invite link") && !editableText(Ui.Link.Text).isNullOrBlank() && chatModel.showingInvitation.value != null &&
+        !exists(Ui.Address.CreateLink)
+    }
+    check(chatModel.userAddress.value == null) { "`Create 1-time link` created a SimpleX address" }
+  }
+
+  @Test fun createAddressNoContactsSharesAutomatically() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    alice.userPicker()
+    poll(what = "the user picker row `Create SimpleX address`") { labelled(Ui.UserPicker.Address, "Create SimpleX address") }
+    click(Ui.UserPicker.Address)
+    click(Ui.Address.Create)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the address created and shared with no alert") {
+      chatModel.userAddress.value != null && exists(Ui.Address.Share) && addressShared() && UiIdle.inFlight().isEmpty()
+    }
+    check(!AlertManager.shared.hasAlertsShown() && !seesText("Share address with SimpleX contacts?")) { "an alert asked to share the address with no contacts" }
+    AddressScreen(this).close()
+    alice.userPicker()
+    poll(what = "the user picker row `Your SimpleX address`") { labelled(Ui.UserPicker.Address, "Your SimpleX address") && !labelled(Ui.UserPicker.Address, "Create SimpleX address") }
+    click(Ui.UserPicker.Address)
+    poll(what = "the address screen for the existing address") { exists(Ui.Address.Share) && exists(Ui.Address.Delete) && !exists(Ui.Address.Create) }
+    connect(bob)
+    bob sends "/i @alice"
+    bob.eventuallyMatching(Regex("contact address: \\S+"))
+  }
+
+  @Test fun addressSettingsShareWithContactsOnOff() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.chatList.row("bob")
+    alice.userPicker().address()
+    click(Ui.Address.Create)
+    awaitShareAlert(CONNECT_TIMEOUT_MS)
+    click(DISMISS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the address created and not shared after `Cancel`") {
+      chatModel.userAddress.value != null && exists(Ui.Address.Settings) && !AlertManager.shared.hasAlertsShown() && UiIdle.inFlight().isEmpty()
+    }
+    check(!addressShared()) { "`Cancel` on `Share address with SimpleX contacts?` shared the address" }
+    addressSettings()
+
+    click(Ui.Address.ShareWithContacts)
+    awaitShareAlert()
+    click(DISMISS)
+    poll(what = "the share alert closed") { !AlertManager.shared.hasAlertsShown() }
+    awaitAppIdle("`Cancel` on the share alert")
+    check(!addressShared()) { "`Cancel` on the share alert shared the address" }
+    click(Ui.Address.ShareWithContacts)
+    awaitShareAlert()
+    click(CONFIRM)
+    bob.eventually("alice set new contact address, use /info alice to view", CONNECT_TIMEOUT_MS)
+    poll(what = "the address shared") { addressShared() }
+
+    click(Ui.Address.ShareWithContacts)
+    awaitStopSharingAlert()
+    click(DISMISS)
+    poll(what = "the stop-sharing alert closed") { !AlertManager.shared.hasAlertsShown() }
+    awaitAppIdle("`Cancel` on the stop-sharing alert")
+    check(addressShared()) { "`Cancel` on `Stop sharing address?` stopped sharing" }
+    click(Ui.Address.ShareWithContacts)
+    awaitStopSharingAlert()
+    click(CONFIRM)
+    bob.eventually("alice removed contact address", CONNECT_TIMEOUT_MS)
+    poll(what = "the address no longer shared") { !addressShared() }
+  }
+
+  @Test fun addressShareViaChat() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val address = alice.userPicker().createAddress()
+    connect(bob)
+    val bobId = alice.chatList.chatId("bob")
+    pickerRowOpens(alice, Ui.UserPicker.Address, "the address screen") { exists(Ui.Address.ShareViaChat) }
+    click(Ui.Address.ShareViaChat)
+    poll(what = "the share list with bob and without the notes folder") {
+      alice.chatList.shareShown("bob") && !alice.chatList.shareShown("Private notes") && !exists(Ui.Address.ShareViaChat)
+    }
+    alice.chatList.shareTo("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's chat with the address card ready to send and no typed text") {
+      chatModel.chatId.value == bobId && editableText(Ui.Chat.Message).isNullOrEmpty() && isEnabled(Ui.Chat.Send)
+    }
+    click(Ui.Chat.Send)
+    bob.eventuallyMessage("alice> contact address of @alice (signed):", CONNECT_TIMEOUT_MS)
+    val link = bob.nextLine().trim()
+    check(link == address) { "bob got the link `$link`, not alice's address `$address`" }
+  }
+
+  @Test fun addressSettingsUnsavedChangesAlertExitAndSave() = uiTest {
+    val alice = app("alice")
+    alice.userPicker().address().create()
+    val first = addressSettings()
+    poll(what = "an empty welcome message") { editableText(Ui.Address.WelcomeMessage).isNullOrEmpty() }
+    awaitAppIdle("creating and sharing the address")
+    val saved = chatModel.userAddress.value
+    click(Ui.Address.SaveSettings)
+    awaitAppIdle("`Save` with unchanged settings")
+    check(chatModel.userAddress.value === saved) { "`Save` saved unchanged address settings" }
+
+    first.welcome("first")
+    leaveAddressSettingsExpectingSaveAlert()
+    click(DISMISS)
+    awaitAddressScreenAfterSettings()
+    check(chatModel.userAddress.value === saved && savedAddressSettings()?.autoReply == null) { "`Exit without saving` saved the welcome message" }
+
+    val settings = addressSettings()
+    poll(what = "the welcome message still empty after `Exit without saving`") { editableText(Ui.Address.WelcomeMessage).isNullOrEmpty() }
+    settings.welcome("second")
+    leaveAddressSettingsExpectingSaveAlert()
+    click(CONFIRM)
+    awaitAddressScreenAfterSettings()
+    poll(what = "the welcome message `second` saved") { savedAddressSettings()?.autoReply?.text == "second" }
+
+    val again = addressSettings()
+    poll(what = "the saved welcome message shown") { editableText(Ui.Address.WelcomeMessage) == "second" }
+    again.replaceWelcome("second again")
+    again.save()
+    poll(what = "the welcome message `second again` saved") { savedAddressSettings()?.autoReply?.text == "second again" }
+    again.close()
+  }
+
+  private fun UiScope.awaitShareAlert(timeoutMs: Long = 10_000) =
+    poll(timeoutMs = timeoutMs, what = "the `Share address with SimpleX contacts?` alert with `Share` and `Cancel`") {
+      seesText("Share address with SimpleX contacts?") && labelled(CONFIRM, "Share") && labelled(DISMISS, "Cancel") && !seesText("Stop sharing address?")
+    }
+
+  private fun UiScope.awaitStopSharingAlert() =
+    poll(what = "the `Stop sharing address?` alert with `Stop sharing` and `Cancel`") {
+      seesText("Stop sharing address?") && labelled(CONFIRM, "Stop sharing") && labelled(DISMISS, "Cancel") && !seesText("Share address with SimpleX contacts?")
+    }
+
+  private companion object {
+    val CONFIRM = Ui.Alert.Confirm(Ui.AlertSource.Shared)
+    val DISMISS = Ui.Alert.Dismiss(Ui.AlertSource.Shared)
+    const val TEAM_FOOTER = "Add your team members to the conversations."
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatListMenusPendingTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatListMenusPendingTest.kt
index 8c62ffb0be..e0d4289595 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatListMenusPendingTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatListMenusPendingTest.kt
@@ -114,19 +114,6 @@ class ChatListMenusPendingTest : UiTest() {
     poll(what = "the row named `friend`") { "friend" in alice.chatList.rowTexts("friend") }
   }
 
-  @Test fun pendingConnectionClickOpensInfo() = uiTest {
-    val alice = app("alice")
-    keepOneTimeLink(alice)
-    poll(what = "the pending row `invited to connect` / `you shared one-time link` and no pending connection info") {
-      alice.chatList.rowTexts(PENDING).containsAll(listOf(PENDING, "you shared one-time link")) && !seesText("You invited a contact")
-    }
-    val id = alice.chatList.chatId(PENDING)
-    alice.chatList.open(PENDING)
-    poll(what = "`You invited a contact` with the one-time link and the name field") {
-      chatModel.chatId.value == id && seesText("You invited a contact") && seesText("One-time invitation link") && exists(Ui.Info.Alias)
-    }
-  }
-
   @Test fun pendingConnectionMenuDeleteInitiated() = uiTest {
     val alice = app("alice"); val bob = cli("bob")
     val link = keepOneTimeLink(alice)
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatListToolbarSearchTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatListToolbarSearchTest.kt
index 3a349a2950..51a9c05c6d 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatListToolbarSearchTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatListToolbarSearchTest.kt
@@ -194,6 +194,19 @@ class ChatListToolbarSearchTest : UiTest() {
     }
     click(Ui.Alert.Dismiss(Ui.AlertSource.PrivacySensitive))
     poll(what = "the search field cleared and editable") { editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search) }
+    bob sends "/da"
+    bob expects "Your chat address is deleted - accepted contacts will remain connected."
+    bob expects "To create a new chat address use /ad"
+    enterLinkInSearch(address)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Connection link removed` alert for the deleted address") {
+      seesText("Connection link removed") && seesText("Your contact removed this link", substring = true)
+    }
+    check(!exists(planConfirm)) { "the plan alert opened for a deleted address" }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the alert to close, the search cleared and editable, and no chat with bob") {
+      !seesText("Connection link removed") && editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search) &&
+        chatModel.chats.value.none { it.chatInfo.chatViewName == "bob" }
+    }
   }
 
   @Test fun searchPasteKnownContactLinkFiltersToContact() = uiTest {
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatProfilesTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatProfilesTest.kt
index accc74201a..6104018534 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatProfilesTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ChatProfilesTest.kt
@@ -1,9 +1,30 @@
 package chat.simplex.app.ui.main
 
+import chat.simplex.app.ui.harness.PROFILES_SEARCH
+import chat.simplex.app.ui.harness.UiScope
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitAppIdle
+import chat.simplex.app.ui.harness.closeProfilesScreen
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.hideUserViaApi
+import chat.simplex.app.ui.harness.labelled
+import chat.simplex.app.ui.harness.newGroupsViaApi
+import chat.simplex.app.ui.harness.openProfileMenu
+import chat.simplex.app.ui.harness.sendUntilAuthFailed
+import chat.simplex.app.ui.harness.typePassword
+import chat.simplex.app.ui.harness.userHidden
+import chat.simplex.app.ui.harness.userIdOf
+import chat.simplex.app.ui.harness.userShowsNtfs
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
 import org.junit.Test
 
+private const val MUTE_ALERT = "ShowMuteProfileAlert"
+private const val HIDDEN_NOTICE = "ShowHiddenProfilesNotice"
+private const val SECRET_PASSWORD = "secret-pass-7"
+
 class ChatProfilesTest : UiTest() {
   @Test fun profilesAddProfile() = uiTest {
     val alice = app("alice")
@@ -13,4 +34,217 @@ class ChatProfilesTest : UiTest() {
     profiles.add("work")
     poll(what = "the profiles list with `alice` and `work`") { exists(Ui.Profiles.Add) && seesText("alice") && seesText("work") }
   }
+
+  @Test fun profilesMuteUnmute() = uiTest {
+    val alice = app("alice")
+    appPrefs.showMuteProfileAlert.set(true)
+    alice.userPicker().profiles().apply { add("work"); close() }
+    val workId = userIdOf("work")
+    alice.userPicker().switchTo("alice")
+    alice.userPicker().profiles()
+    waitFor(Ui.Profiles.User(workId))
+    poll(what = "work not muted and the mute alert stored as on") { userShowsNtfs(workId) == true && storedSetting(MUTE_ALERT) == "true" }
+    openProfileMenu(workId, "mute")
+    check(!exists(Ui.Profiles.UserMenu(workId, "unmute"))) { "`Unmute` offered for a profile that is not muted" }
+    click(Ui.Profiles.UserMenu(workId, "mute"))
+    awaitMutedAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "work muted and the alert closed") { userShowsNtfs(workId) == false && !AlertManager.shared.hasAlertsShown() }
+    check(storedSetting(MUTE_ALERT) == "true") { "`OK` on the mute alert turned the alert off" }
+
+    openProfileMenu(workId, "unmute")
+    check(!exists(Ui.Profiles.UserMenu(workId, "mute"))) { "`Mute` offered for a muted profile" }
+    click(Ui.Profiles.UserMenu(workId, "unmute"))
+    poll(what = "work unmuted") { userShowsNtfs(workId) == true }
+
+    openProfileMenu(workId, "mute")
+    click(Ui.Profiles.UserMenu(workId, "mute"))
+    awaitMutedAlert()
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "work muted and the mute alert stored as off") {
+      userShowsNtfs(workId) == false && storedSetting(MUTE_ALERT) == "false" && !AlertManager.shared.hasAlertsShown()
+    }
+
+    openProfileMenu(workId, "unmute")
+    click(Ui.Profiles.UserMenu(workId, "unmute"))
+    poll(what = "work unmuted again") { userShowsNtfs(workId) == true }
+    openProfileMenu(workId, "mute")
+    click(Ui.Profiles.UserMenu(workId, "mute"))
+    poll(what = "work muted again") { userShowsNtfs(workId) == false }
+    openProfileMenu(workId, "unmute")
+    check(!AlertManager.shared.hasAlertsShown() && !seesText("Muted when inactive!")) { "the mute alert was shown after `Don't show again`" }
+
+    restart().userPicker().profiles()
+    waitFor(Ui.Profiles.User(workId))
+    openProfileMenu(workId, "unmute")
+    check(userShowsNtfs(workId) == false && !exists(Ui.Profiles.UserMenu(workId, "mute"))) { "work is not muted after restart" }
+  }
+
+  @Test fun profilesDeleteActiveSwitchesToNext() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val aliceId = userIdOf("alice")
+    alice.userPicker().profiles().apply { add("work"); close() }
+    newGroupsViaApi("team")
+    val workId = userIdOf("work")
+    alice.userPicker().switchTo("alice")
+    alice.chatList.row("bob")
+    val profiles = alice.userPicker().profiles()
+    poll(what = "alice and work in the profiles list") { exists(Ui.Profiles.User(aliceId)) && exists(Ui.Profiles.User(workId)) }
+    openProfileMenu(aliceId, "delete")
+    click(Ui.Profiles.UserMenu(aliceId, "delete"))
+    val withConnections = Ui.Alert.Option(Ui.AlertSource.Shared, "deleteWithConnections")
+    poll(what = "the `Delete chat profile?` alert with `Profile and server connections`") { seesText("Delete chat profile?") && exists(withConnections) }
+    click(withConnections)
+    poll(what = "work active, alice gone from the users and the profiles list") {
+      chatModel.currentUser.value?.userId == workId && chatModel.users.none { it.user.userId == aliceId } &&
+        !exists(Ui.Profiles.User(aliceId)) && exists(Ui.Profiles.User(workId))
+    }
+    profiles.close()
+    alice.chatList.row("team")
+    poll(what = "alice's contact bob gone from the chats") { chatModel.chats.value.none { it.chatInfo.chatViewName == "bob" } }
+    sendUntilAuthFailed(bob, "alice")
+  }
+
+  @Test fun profilesListShowsAllVisible() = uiTest {
+    val alice = app("alice")
+    newGroupsViaApi("team")
+    val aliceId = userIdOf("alice")
+    alice.userPicker().profiles().apply { add("work"); close() }
+    newGroupsViaApi("office")
+    val workId = userIdOf("work")
+    alice.userPicker().profiles().apply { add("secret"); close() }
+    val secretId = userIdOf("secret")
+    hideUserViaApi(secretId, SECRET_PASSWORD)
+    alice.userPicker().switchTo("alice")
+    alice.chatList.row("team")
+
+    alice.userPicker().profiles()
+    poll(what = "alice and work listed with `Add profile` and `Tap to activate profile.`, the hidden secret not") {
+      exists(Ui.Profiles.User(aliceId)) && exists(Ui.Profiles.User(workId)) && !exists(Ui.Profiles.User(secretId)) &&
+        exists(Ui.Profiles.Add) && seesText("Tap to activate profile.")
+    }
+    click(Ui.Profiles.User(workId))
+    poll(what = "work active with its chats loaded") {
+      chatModel.currentUser.value?.userId == workId && !chatModel.switchingUsersAndHosts.value &&
+        chatModel.chats.value.any { it.chatInfo.chatViewName == "office" } && chatModel.chats.value.none { it.chatInfo.chatViewName == "team" }
+    }
+    typeInto(PROFILES_SEARCH, "ALI")
+    poll(what = "only alice listed for `ALI`, without `Add profile`") {
+      exists(Ui.Profiles.User(aliceId)) && !exists(Ui.Profiles.User(workId)) && !exists(Ui.Profiles.User(secretId)) && !exists(Ui.Profiles.Add)
+    }
+    closeProfilesScreen()
+    alice.chatList.row("office")
+    check(!seesText("team")) { "alice's group is listed after activating work" }
+  }
+
+  @Test fun profilesAddProfileInvalidName() = uiTest {
+    val alice = app("alice")
+    alice.userPicker().profiles()
+    click(Ui.Profiles.Add)
+    typeInto(Ui.NewProfile.Name, "?bob")
+    waitFor(INVALID_NAME)
+    click(Ui.NewProfile.Create)
+    awaitAppIdle("`Create profile` with an invalid name")
+    check(chatModel.users.size == 1 && exists(Ui.NewProfile.Create) && !seesText("Duplicate display name!")) { "`Create profile` acted on the invalid name `?bob`" }
+    click(INVALID_NAME)
+    poll(what = "the `Invalid name!` alert offering `bob`") { seesText("Invalid name!") && seesText("Correct name to bob?") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the name corrected to `bob` without the invalid-name icon") { editableText(Ui.NewProfile.Name) == "bob" && !exists(INVALID_NAME) && !seesText("Invalid name!") }
+
+    replaceText(Ui.NewProfile.Name, "alice")
+    check(!exists(INVALID_NAME)) { "`alice` is flagged as an invalid name" }
+    click(Ui.NewProfile.Create)
+    poll(what = "the `Duplicate display name!` alert") {
+      seesText("Duplicate display name!") && seesText("You already have a chat profile with the same display name. Please choose another name.")
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the alert closed with the Create profile screen kept and no second profile") {
+      !seesText("Duplicate display name!") && exists(Ui.NewProfile.Create) && chatModel.users.size == 1 && chatModel.currentUser.value?.displayName == "alice"
+    }
+  }
+
+  @Test fun profilesHiddenNoticeFirstTime() = uiTest {
+    val alice = app("alice")
+    appPrefs.showHiddenProfilesNotice.set(true)
+    poll(what = "the hidden-profiles notice stored as on") { storedSetting(HIDDEN_NOTICE) == "true" }
+    val profiles = alice.userPicker().profiles()
+    waitFor(Ui.Profiles.Add)
+    settle()
+    check(!seesText("Make profile private!")) { "the hidden-profiles notice was shown with one profile" }
+    profiles.close()
+    awaitPickerClosed()
+    appPrefs.showHiddenProfilesNotice.set(false)
+    alice.userPicker().profiles().apply { add("work"); close() }
+    awaitPickerClosed()
+    appPrefs.showHiddenProfilesNotice.set(true)
+
+    alice.userPicker().profiles()
+    awaitHiddenNotice()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the notice closed and still on") { !seesText("Make profile private!") && storedSetting(HIDDEN_NOTICE) == "true" }
+    profiles.close()
+    awaitPickerClosed()
+
+    alice.userPicker().profiles()
+    awaitHiddenNotice()
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the notice closed and stored as off") { !seesText("Make profile private!") && storedSetting(HIDDEN_NOTICE) == "false" }
+    profiles.close()
+    awaitPickerClosed()
+
+    alice.userPicker().profiles()
+    waitFor(Ui.Profiles.Add)
+    settle()
+    check(!seesText("Make profile private!")) { "the hidden-profiles notice was shown after `Don't show again`" }
+  }
+
+  @Test fun profilesUnhideActiveRequiresPassword() = uiTest {
+    val alice = app("alice")
+    val aliceId = userIdOf("alice")
+    alice.userPicker().profiles().apply { add("work"); close() }
+    val workId = userIdOf("work")
+    hideUserViaApi(workId, SECRET_PASSWORD)
+    alice.userPicker().profiles()
+    poll(what = "the active hidden work and alice listed") { exists(Ui.Profiles.User(workId)) && exists(Ui.Profiles.User(aliceId)) && userHidden(workId) }
+
+    openProfileMenu(aliceId, "mute")
+    check(!exists(Ui.Profiles.UserMenu(aliceId, "hide"))) { "`Hide` offered for the only visible profile" }
+    click(Ui.Profiles.UserMenu(aliceId, "mute"))
+    poll(what = "alice muted and the menu closed") { userShowsNtfs(aliceId) == false && !exists(Ui.Profiles.UserMenu(aliceId, "delete")) }
+
+    openProfileMenu(workId, "unhide")
+    check(!exists(Ui.Profiles.UserMenu(workId, "hide")) && !exists(Ui.Profiles.UserMenu(workId, "mute"))) { "the hidden profile's menu offers `Hide` or `Mute`" }
+    click(Ui.Profiles.UserMenu(workId, "unhide"))
+    poll(what = "`Unhide profile` asking for `Profile password` with `Unhide chat profile`") {
+      seesText("Unhide profile") && seesText("Profile password") && exists(Ui.ProfileAction.Password) && labelled(Ui.ProfileAction.Submit, "Unhide chat profile")
+    }
+    typePassword(Ui.ProfileAction.Password, SECRET_PASSWORD.dropLast(1))
+    click(Ui.ProfileAction.Submit)
+    awaitAppIdle("`Unhide chat profile` with a wrong password")
+    check(userHidden(workId) && exists(Ui.ProfileAction.Submit)) { "`Unhide chat profile` acted on a wrong password" }
+    typePassword(Ui.ProfileAction.Password, SECRET_PASSWORD.takeLast(1))
+    click(Ui.ProfileAction.Submit)
+    poll(what = "work unhidden and the Unhide profile screen closed") { !userHidden(workId) && !exists(Ui.ProfileAction.Password) }
+    poll(what = "work listed as a visible profile") { exists(Ui.Profiles.User(workId)) && chatModel.currentUser.value?.userId == workId }
+  }
+
+  private fun UiScope.awaitPickerClosed() =
+    poll(what = "the user picker to close after `Your chat profiles` closed") { !exists(Ui.UserPicker.Sheet) && exists(Ui.ChatList.Search) }
+
+  private fun UiScope.awaitHiddenNotice() =
+    poll(what = "the `Make profile private!` notice with `OK` and `Don't show again`") {
+      seesText("Make profile private!") && seesText("You can hide or mute a user profile - hold it for the menu.") &&
+        labelled(Ui.Alert.Confirm(Ui.AlertSource.Shared), "OK") && labelled(Ui.Alert.Dismiss(Ui.AlertSource.Shared), "Don't show again")
+    }
+
+  private fun UiScope.awaitMutedAlert() =
+    poll(what = "the `Muted when inactive!` alert with `OK` and `Don't show again`") {
+      seesText("Muted when inactive!") && seesText("You will still receive calls and notifications from muted profiles when they are active.") &&
+        "Don't show again" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    }
+
+  private companion object {
+    val INVALID_NAME = Ui.NewProfile.Name.part("invalid")
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ConnectPlanTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ConnectPlanTest.kt
new file mode 100644
index 0000000000..c25a81c5f1
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ConnectPlanTest.kt
@@ -0,0 +1,237 @@
+package chat.simplex.app.ui.main
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.PeerFlags
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.chatLinkItemId
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.createAddress
+import chat.simplex.app.ui.harness.createFullAddress
+import chat.simplex.app.ui.harness.createFullOneTimeLink
+import chat.simplex.app.ui.harness.enterLinkInSearch
+import chat.simplex.app.ui.harness.joinLink
+import chat.simplex.app.ui.harness.keepOneTimeLink
+import chat.simplex.app.ui.harness.openPasteLink
+import chat.simplex.app.ui.harness.planConfirm
+import chat.simplex.app.ui.harness.planDismiss
+import chat.simplex.app.ui.harness.planOption
+import chat.simplex.app.ui.harness.quiesce
+import chat.simplex.app.ui.harness.searchShowsLink
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.MsgContent
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertNotEquals
+import org.junit.Test
+
+class ConnectPlanTest : UiTest() {
+  @Test fun pasteLinkInvalidTextAlert() = uiTest {
+    assumeCamera()
+    val alice = app("alice")
+    val address = alice.userPicker().createAddress()
+    openPasteLink(alice)
+    setClipboardText(null)
+    click(Ui.Link.Paste)
+    settle()
+    check(exists(Ui.Link.Paste) && "Tap to paste link" in textsOf(Ui.Link.Paste)) { "the paste row is gone after a tap with an empty clipboard" }
+    check(!seesText("Invalid link!") && !exists(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && !exists(planConfirm)) { "an alert opened for an empty clipboard" }
+    setClipboardText("https://example.com/invite")
+    click(Ui.Link.Paste)
+    poll(what = "the `Invalid link!` alert for a web link") { seesText("Invalid link!") && seesText("The text you pasted is not a SimpleX link.") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the alert to close with the paste row still offered") { !seesText("Invalid link!") && exists(Ui.Link.Paste) }
+    setClipboardText(address)
+    click(Ui.Link.Paste)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Connect to yourself?` alert with the pasted link in place of the row") {
+      seesText("Connect to yourself?") && !exists(Ui.Link.Paste)
+    }
+    click(planOption("cancel"))
+    poll(what = "the alert to close and the paste row to return") { !seesText("Connect to yourself?") && exists(Ui.Link.Paste) }
+  }
+
+  @Test fun planOwnInvitationConnectToYourself() = uiTest {
+    val alice = app("alice")
+    val address = alice.userPicker().createAddress()
+    alice.chatList.row("Private notes")
+    check(chatModel.chats.value.none { it.chatInfo.chatViewName == "alice" }) { "a chat named alice exists before alice connects to herself" }
+    enterLinkInSearch(address)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Connect to yourself?` alert for alice's own address with three buttons") {
+      seesText("Connect to yourself?") && seesText("This is your own SimpleX address!", substring = true) &&
+        exists(planOption("useCurrentProfile")) && exists(planOption("useIncognito")) && exists(planOption("cancel"))
+    }
+    click(planOption("useCurrentProfile"))
+    poll(what = "`Connection request sent!` for an address") {
+      seesText("Connection request sent!") && seesText("You will be connected when your connection request is accepted, please wait or check later!")
+    }
+    click(planConfirm)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice's own contact request in the model") { chatModel.chats.value.any { it.chatInfo.chatViewName == "alice" } }
+    alice.chatList.request("alice")
+    poll(what = "the search field cleared and editable") { editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search) }
+
+    val pendingIds = { chatModel.chats.value.filter { it.chatInfo is ChatInfo.ContactConnection }.map { it.id }.toSet() }
+    val contactsNamedAlice = {
+      chatModel.chats.value.filter { (it.chatInfo as? ChatInfo.Direct)?.contact?.let { c -> c.profile.displayName == "alice" && c.sndReady } == true }
+    }
+    val pendingBefore = pendingIds()
+    val link = keepOneTimeLink(alice)
+    check(contactsNamedAlice().isEmpty()) { "a connected contact named alice exists before alice uses her own 1-time link" }
+    enterLinkInSearch(link)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Connect to yourself?` alert for alice's own 1-time link") {
+      seesText("Connect to yourself?") && seesText("This is your own one-time link!", substring = true)
+    }
+    click(planOption("useCurrentProfile"))
+    poll(what = "`Connection request sent!` for a 1-time link") {
+      seesText("Connection request sent!") && seesText("You will be connected when your contact's device is online, please wait or check later!")
+    }
+    click(planConfirm)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "two contacts named alice connected to each other and the 1-time link no longer pending") {
+      contactsNamedAlice().let { c -> c.size == 2 && c.all { exists(Ui.ChatList.Row(it.id)) } } && pendingIds() == pendingBefore
+    }
+  }
+
+  @Test fun planInvitationAlreadyConnectingFullLink() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(fullLinks = true))
+    val full = bob.createFullOneTimeLink()
+    bob.stop()
+    alice.chatList.row("Private notes")
+    val pending = { chatModel.chats.value.count { it.chatInfo is ChatInfo.ContactConnection } }
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Connect via one-time link?` alert for the full link") {
+      searchShowsLink("SimpleX one-time invitation") && seesText("Connect via one-time link?") &&
+        seesText("Your profile will be sent to the contact that you received this link from.", substring = true)
+    }
+    click(planOption("cancel"))
+    poll(what = "the alert to close and the search to clear") {
+      !seesText("Connect via one-time link?") && editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search)
+    }
+    check(pending() == 0) { "Cancel created a pending connection" }
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Connect via one-time link?` alert again") { seesText("Connect via one-time link?") }
+    click(planOption("useCurrentProfile"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Connection request sent!` for a 1-time link") {
+      seesText("Connection request sent!") && seesText("You will be connected when your contact's device is online, please wait or check later!")
+    }
+    click(planConfirm)
+    poll(what = "one pending connection and the search cleared") {
+      pending() == 1 && editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search)
+    }
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Already connecting!` for the same link while bob is offline") {
+      seesText("Already connecting!") && seesText("You are already connecting via this one-time link!", substring = true) && !seesText("Connect via one-time link?")
+    }
+    click(planConfirm)
+    poll(what = "the alert to close with still one pending connection") { !seesText("Already connecting!") && pending() == 1 }
+    bob.start()
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob connected and no pending connection left") {
+      chatModel.chats.value.any { (it.chatInfo as? ChatInfo.Direct)?.contact?.let { c -> c.displayName == "bob" && c.sndReady } == true } && pending() == 0
+    }
+    alice.chatList.row("bob")
+  }
+
+  @Test fun planAddressRepeatConnectionRequest() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(fullLinks = true))
+    val full = bob.createFullAddress()
+    alice.chatList.row("Private notes")
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Connect via contact address?` alert for the full address") {
+      searchShowsLink("SimpleX contact address") && seesText("Connect via contact address?") &&
+        seesText("Your profile will be sent to the contact that you received this link from.", substring = true)
+    }
+    click(planOption("useIncognito"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Connection request sent!` for an address") {
+      seesText("Connection request sent!") && seesText("You will be connected when your connection request is accepted, please wait or check later!")
+    }
+    click(planConfirm)
+    val rand = bob.eventuallyMatching(Regex("(\\S+) wants to connect to you!"), CONNECT_TIMEOUT_MS).groupValues[1]
+    assertNotEquals("alice", rand)
+    bob expects "to accept: /ac $rand"
+    bob expects "to reject: /rc $rand (the sender will NOT be notified)"
+    poll(what = "the search field cleared and editable") { editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search) }
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`Repeat connection request?` for the pending request") {
+      seesText("Repeat connection request?") && seesText("You have already requested connection via this address!", substring = true) &&
+        !seesText("Connect via contact address?")
+    }
+    click(planOption("cancel"))
+    poll(what = "the alert to close and the search to clear") {
+      !seesText("Repeat connection request?") && editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search)
+    }
+    bob sends "/ac $rand"
+    bob.nextLine().let { check(it.startsWith("$rand: accepting contact request")) { "bob's next line after /ac is `$it`, not the acceptance" } }
+    bob.eventually("$rand: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "an incognito contact bob ready to send") {
+      chatModel.chats.value.any { (it.chatInfo as? ChatInfo.Direct)?.contact?.let { c -> c.displayName == "bob" && c.contactConnIncognito && c.sndReady } == true }
+    }
+  }
+
+  @Test fun planViaChatItemLinkCard() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(cath)
+    val bobAddress = bob.createAddress()
+    joinLink(bobAddress)
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    val cathAddress = cath.createAddress()
+    cath sends "/share address @alice"
+    cath.eventuallyMessage("@alice contact address of @cath (signed):")
+    cath expects cathAddress
+    bob sends "/share address @alice"
+    bob.eventuallyMessage("@alice contact address of @bob (signed):")
+    bob expects bobAddress
+    val bobId = alice.chatList.chatId("bob"); val cathId = alice.chatList.chatId("cath")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "both address cards received") {
+      listOf(bobId, cathId).all { id -> chatModel.chats.value.firstOrNull { it.id == id }?.chatItems?.lastOrNull()?.content?.msgContent is MsgContent.MCChat }
+    }
+    quiesce()
+
+    enterLinkInSearch(cathAddress)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the plan alert for cath's pasted address with `Open new chat`") {
+      exists(planConfirm) && "Open new chat" in textsOf(planConfirm) && seesText("cath")
+    }
+    check(!seesText("Link signature verified.")) { "a pasted address with no signature shows `Link signature verified.`" }
+    click(planDismiss)
+    poll(what = "the alert to close and the search to clear") { !exists(planConfirm) && editableText(Ui.ChatList.Search).isNullOrEmpty() }
+
+    backToChatList()
+    click(Ui.ChatList.Row(cathId).part("link"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the plan alert for cath's chat-list card with `Link signature verified.`") {
+      seesText("cath") && seesText("Link signature verified.") && exists(planConfirm) && "Open new chat" in textsOf(planConfirm)
+    }
+    click(planDismiss)
+    poll(what = "the alert to close") { !exists(planConfirm) }
+
+    val bobChat = alice.chatList.open("bob")
+    poll(what = "bob's chat open") { chatModel.chatId.value == bobId }
+    val bobCard = chatLinkItemId()
+    poll(what = "bob's card with his name, `Contact address (from owner)` and `Tap to open`") {
+      textsOf(Ui.Chat.Item(bobCard)).containsAll(listOf("bob", "Contact address (from owner)", "Tap to open"))
+    }
+    click(Ui.Chat.Item(bobCard).part("chatLink"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the known-contact alert for bob with `Open chat`") {
+      exists(planConfirm) && "Open chat" in textsOf(planConfirm) && seesText("bob") && !seesText("Link signature verified.")
+    }
+    click(planConfirm)
+    poll(what = "bob's chat still open and no second chat named bob") {
+      !exists(planConfirm) && chatModel.chatId.value == bobId && chatModel.chats.value.count { it.chatInfo.chatViewName == "bob" } == 1
+    }
+    bobChat.send("still here")
+    bob.expectsMessage("alice> still here", CONNECT_TIMEOUT_MS)
+
+    backToChatList()
+    alice.chatList.open("cath")
+    poll(what = "cath's chat open") { chatModel.chatId.value == cathId }
+    val cathCard = chatLinkItemId()
+    poll(what = "cath's card with her name, `Contact address (from owner)` and `Tap to open`, and no link text") {
+      textsOf(Ui.Chat.Item(cathCard)).let { t -> t.containsAll(listOf("cath", "Contact address (from owner)", "Tap to open")) && cathAddress !in t }
+    }
+    click(Ui.Chat.Item(cathCard).part("chatLink"))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the plan alert for cath's card with `Link signature verified.` and `Open new chat`") {
+      seesText("Link signature verified.") && exists(planConfirm) && "Open new chat" in textsOf(planConfirm)
+    }
+    click(planConfirm)
+    poll(what = "a new prepared chat with cath open") {
+      chatModel.chatId.value != cathId && seesText("Tap Connect to send request") && chatModel.chats.value.count { it.chatInfo.chatViewName == "cath" } == 2
+    }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactInfoTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactInfoTest.kt
index d8387b73a0..0718d5c165 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactInfoTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactInfoTest.kt
@@ -1,10 +1,43 @@
 package chat.simplex.app.ui.main
 
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.CliPeer
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.TestServers
+import chat.simplex.app.ui.harness.UiScope
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.clearChatFromInfo
+import chat.simplex.app.ui.harness.closeContactInfo
 import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.connectIncognito
+import chat.simplex.app.ui.harness.contactOf
+import chat.simplex.app.ui.harness.contactPrefs
+import chat.simplex.app.ui.harness.copiedServer
+import chat.simplex.app.ui.harness.createAddress
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.infoNameText
+import chat.simplex.app.ui.harness.isServer
+import chat.simplex.app.ui.harness.itemStatus
+import chat.simplex.app.ui.harness.loadedText
+import chat.simplex.app.ui.harness.localSmpServer
+import chat.simplex.app.ui.harness.markContactVerifiedViaApi
+import chat.simplex.app.ui.harness.openNewChatFromSearch
+import chat.simplex.app.ui.harness.setContactAliasViaApi
+import chat.simplex.app.ui.harness.switchAwayFromChat
+import chat.simplex.common.model.CIContent
+import chat.simplex.common.model.ChatFeature
 import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.ChatItemTTL
+import chat.simplex.common.model.FeatureAllowed
+import chat.simplex.common.model.MsgFilter
+import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import chat.simplex.common.views.helpers.ModalManager
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class ContactInfoTest : UiTest() {
@@ -28,4 +61,442 @@ class ContactInfoTest : UiTest() {
     click(Ui.Info.VerifyCode)
     poll(what = "`bob is verified`") { seesText("bob is verified") }
   }
+
+  @Test fun contactInfoSetLocalAlias() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.chatList.row("bob")
+    assertTrue("bob" in alice.chatList.rowTexts("bob"))
+    alice.chatList.open("bob").info()
+    typeInto(Ui.Info.Alias, "friend")
+    poll(what = "the row to read `friend`") { chatModel.chats.value.any { it.chatInfo.chatViewName == "friend" } }
+    poll(what = "the row text `friend` instead of `bob`") { alice.chatList.rowTexts("friend").let { "friend" in it && "bob" !in it } }
+  }
+
+  @Test fun contactInfoClearLocalAlias() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    setContactAliasViaApi("bob", "friend")
+    restart()
+    val id = alice.chatList.chatId("friend")
+    poll(what = "bob's row named `friend`") { alice.chatList.rowTexts("friend").let { "friend" in it && "bob" !in it } }
+    alice.chatList.open("friend").info()
+    poll(what = "the alias `friend` in the name field of contact info") { exists(Ui.Info.Alias) && editableText(Ui.Info.Alias) == "friend" }
+    replaceText(Ui.Info.Alias, "")
+    poll(what = "bob's alias cleared in the model") { (chatModel.chats.value.first { it.id == id }.chatInfo as ChatInfo.Direct).contact.localAlias.isEmpty() }
+    closeContactInfo()
+    backToChatList()
+    poll(what = "bob's row named `bob` again") { alice.chatList.rowTexts("bob").let { "bob" in it && "friend" !in it } }
+    switchAwayFromChat(alice)
+    check(chatModel.chatId.value != id) { "bob is the open chat, which is listed whatever the search text" }
+    alice.chatList.search("fri")
+    poll(what = "bob hidden for the cleared alias") { editableText(Ui.ChatList.Search) == "fri" && !alice.chatList.shown("bob") }
+    replaceText(Ui.ChatList.Search, "bo")
+    poll(what = "bob listed for his name") { editableText(Ui.ChatList.Search) == "bo" && alice.chatList.shown("bob") }
+  }
+
+  @Test fun contactInfoClearVerification() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    markContactVerifiedViaApi("bob")
+    restart()
+    alice.chatList.row("bob")
+    val info = alice.chatList.open("bob").contactInfo()
+    poll(what = "the row `View security code` and the shield before bob's name") {
+      info.verifyRowText() == "View security code" && infoNameText() == "${SHIELD}bob"
+    }
+    click(Ui.Info.VerifyCode)
+    poll(what = "`bob is verified` with `Clear verification`") {
+      seesText("bob is verified") && exists(described("Clear verification")) && !exists(Ui.VerifyCode.Mark)
+    }
+    click(described("Clear verification"))
+    poll(what = "the security code screen still open with `bob is not verified` and `Mark verified`") {
+      seesText("bob is not verified") && !seesText("bob is verified") && exists(Ui.VerifyCode.Mark) && !exists(described("Clear verification"))
+    }
+    poll(what = "bob not verified in the model") { !contactOf("bob").verified }
+    goBack()
+    poll(what = "the row `Verify security code` and no shield before bob's name") {
+      !exists(Ui.VerifyCode.Mark) && info.verifyRowText() == "Verify security code" && infoNameText() == "bob"
+    }
+  }
+
+  @Test fun contactInfoHeaderShowsNameBioCopy() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.info()
+    poll(what = "bob's name in the header with the name field, and no full name or bio") {
+      infoNameText() == "bob" && exists(Ui.Info.Alias) && textsOf(Ui.Info.Header).none { FULL_NAME in it || BIO in it }
+    }
+    closeContactInfo()
+    bob.updateProfile()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's full name and bio in the model") {
+      bobProfile()?.let { it.fullName == FULL_NAME && it.shortDescr == BIO } == true
+    }
+    chat.info()
+    poll(what = "bob's name, full name and bio in the header") {
+      infoNameText() == "bob" && textsOf(Ui.Info.Header).let { t -> t.any { FULL_NAME in it } && t.any { BIO in it } }
+    }
+    setClipboardText(null)
+    check(clipboardText() == null) { "the clipboard is not empty before copying the name" }
+    click(Ui.Info.Name)
+    poll(what = "bob's name on the clipboard") { clipboardText() == "bob" }
+  }
+
+  @KnownAppIssue("15.5 item 16", "waiting for the full name `Robert Brown` and the bio `Plays the cello` in the open contact info")
+  @Test fun contactInfoHeaderFollowsProfileUpdate() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.chatList.open("bob").info()
+    poll(what = "bob's name in the header, and no full name or bio") {
+      infoNameText() == "bob" && textsOf(Ui.Info.Header).none { FULL_NAME in it || BIO in it }
+    }
+    bob.updateProfile()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's full name and bio in the model") {
+      bobProfile()?.let { it.fullName == FULL_NAME && it.shortDescr == BIO } == true
+    }
+    poll(what = "the full name `$FULL_NAME` and the bio `$BIO` in the open contact info") {
+      textsOf(Ui.Info.Header).let { t -> FULL_NAME in t && t.any { BIO in it } }
+    }
+  }
+
+  @Test fun contactInfoMuteButtonToggles() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    fun muteIcon() = "Notifications" in alice.chatList.rowDescriptions("bob")
+    alice.chatList.row("bob")
+    poll(what = "bob's row without the mute icon") { !muteIcon() && contactOf("bob").chatSettings.enableNtfs == MsgFilter.All }
+    val chat = alice.chatList.open("bob")
+    chat.info()
+    poll(what = "`Mute` in contact info") { exists(Ui.Info.Mute) && seesText("Mute") && !seesText("Unmute") }
+    click(Ui.Info.Mute)
+    poll(what = "`Unmute` with bob's notifications off") { seesText("Unmute") && !seesText("Mute") && contactOf("bob").chatSettings.enableNtfs == MsgFilter.None }
+    closeContactInfo()
+    backToChatList()
+    poll(what = "the mute icon on bob's row") { muteIcon() }
+    alice.chatList.open("bob").info()
+    poll(what = "`Unmute` in reopened contact info") { exists(Ui.Info.Mute) && seesText("Unmute") }
+    click(Ui.Info.Mute)
+    poll(what = "`Mute` with bob's notifications on") { seesText("Mute") && !seesText("Unmute") && contactOf("bob").chatSettings.enableNtfs == MsgFilter.All }
+    closeContactInfo()
+    backToChatList()
+    poll(what = "the mute icon gone from bob's row") { !muteIcon() }
+  }
+
+  @Test fun contactInfoServersSection() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val smp = localSmpServer()
+    alice.chatList.open("bob").info()
+    poll(what = "`Receiving via` and `Sending via` the local server, and `Network status`") {
+      exists(Ui.Info.ReceivingVia) && exists(Ui.Info.SendingVia) && exists(described("Network status")) &&
+        textsOf(Ui.Info.ReceivingVia).let { "Receiving via" in it && it.any { t -> smp.hostnames.first() in t } } &&
+        textsOf(Ui.Info.SendingVia).let { "Sending via" in it && it.any { t -> smp.hostnames.first() in t } }
+    }
+    val receiving = copiedServer(Ui.Info.ReceivingVia)
+    check(isServer(receiving, smp)) { "`Receiving via` copied `$receiving`, not the local server $smp" }
+    val sending = copiedServer(Ui.Info.SendingVia)
+    check(isServer(sending, smp)) { "`Sending via` copied `$sending`, not the local server $smp" }
+    check(!seesText(NETWORK_STATUS_TEXT)) { "the network status explanation is shown before `Network status` is clicked" }
+    click(described("Network status"))
+    poll(what = "the `Network status` alert saying alice is connected to bob's receiving server") {
+      seesText(NETWORK_STATUS_TEXT) && exists(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the `Network status` alert to close") { !seesText(NETWORK_STATUS_TEXT) }
+  }
+
+  @Test fun contactInfoSwitchAddress() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.info()
+    poll(what = "`Change receiving address` without `Abort changing address`") { exists(Ui.Info.SwitchAddress) && !seesText(ABORT_SWITCH) }
+    bob.stop()
+    click(Ui.Info.SwitchAddress)
+    poll(what = "the `Change receiving address?` alert with `Change`") {
+      seesText("Change receiving address?") &&
+        seesText("Receiving address will be changed to a different server. Address change will complete after sender comes online.") &&
+        "Change" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "contact info closed after `Change`") { !ModalManager.end.hasModalsOpen() }
+    chat.itemId("`changing address…` in bob's chat") { it.content is CIContent.SndConnEventContent && it.content.text == "changing address…" }
+    chat.info()
+    poll(what = "`Abort changing address` while bob is offline") { exists(Ui.Info.SwitchAddress) && seesText(ABORT_SWITCH) }
+    closeContactInfo()
+    bob.start()
+    bob.eventually("alice started changing address for you", CONNECT_TIMEOUT_MS)
+    bob.eventually("alice changed address for you", CONNECT_TIMEOUT_MS)
+    chat.itemId("`you changed address` in bob's chat") { it.content is CIContent.SndConnEventContent && it.content.text == "you changed address" }
+    chat.info()
+    poll(what = "`Change receiving address` back without `Abort changing address`") { exists(Ui.Info.SwitchAddress) && !seesText(ABORT_SWITCH) }
+    closeContactInfo()
+    bob sends "@alice after switch"
+    chat.itemId("bob's `after switch` on the new address") { it.content.text == "after switch" }
+  }
+
+  @Test fun contactInfoAbortSwitchAddress() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's contact ready") { contactOf("bob").ready }
+    chat.info()
+    poll(what = "`Change receiving address` without `Abort changing address`") { exists(Ui.Info.SwitchAddress) && !exists(Ui.Info.AbortSwitchAddress) }
+    TestServers.stop("smp1")
+    click(Ui.Info.SwitchAddress)
+    poll(what = "the `Change receiving address?` alert with `Change`") {
+      seesText("Change receiving address?") && "Change" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "contact info closed after `Change`") { !ModalManager.end.hasModalsOpen() }
+    chat.info()
+    poll(what = "`Abort changing address` while smp1 is down") { exists(Ui.Info.AbortSwitchAddress) && ABORT_SWITCH in textsOf(Ui.Info.AbortSwitchAddress) }
+    click(Ui.Info.AbortSwitchAddress)
+    poll(what = "the `Abort changing address?` alert with `Abort`") {
+      seesText("Abort changing address?") && "Abort" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "`Abort changing address` gone and `Change receiving address` back after `Abort`") {
+      !seesText("Abort changing address?") && !exists(Ui.Info.AbortSwitchAddress) && exists(Ui.Info.SwitchAddress)
+    }
+    closeContactInfo()
+    TestServers.start("smp1")
+    chat.send("after abort")
+    bob.eventuallyMessage("alice> after abort", CONNECT_TIMEOUT_MS)
+    bob sends "@alice reply after abort"
+    chat.itemId("reply after abort")
+    assertTrue("alice's chat shows an address change after the abort: ${chat.itemTexts()}", chat.itemTexts().none { "changing address" in it || "changed address" in it })
+  }
+
+  @Test fun contactInfoClearChat() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.send("hello")
+    bob.expectsMessage("alice> hello", CONNECT_TIMEOUT_MS)
+    bob sends "@alice hi there"
+    val hello = chat.itemId("hello")
+    val hi = chat.itemId("bob's `hi there`") { it.content.text == "hi there" }
+    hideKeyboard()
+    chat.info()
+    clearChatFromInfo("bob")
+    poll(what = "contact info closed with `hello` and `hi there` gone from bob's chat") {
+      !ModalManager.end.hasModalsOpen() && !exists(Ui.Chat.Item(hello)) && !exists(Ui.Chat.Item(hi)) &&
+        chatModel.chatsContext.chatItems.value.none { it.content.text == "hello" || it.content.text == "hi there" }
+    }
+    check(contactOf("bob").let { it.active && it.ready }) { "bob's contact is not active and ready after clearing the chat" }
+    bob sends "/tail @alice 2"
+    bob.expectsMessage("alice> hello")
+    bob.expectsMessage("@alice hi there")
+    bob sends "@alice after clear"
+    chat.itemId("bob's `after clear`") { it.content.text == "after clear" }
+    chat.send("still here")
+    bob.expectsMessage("alice> still here", CONNECT_TIMEOUT_MS)
+    backToChatList()
+    alice.chatList.row("bob")
+  }
+
+  @Test fun contactInfoContactAddressSection() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob.createAddress(autoAccept = false)
+    alice.chatList.open("bob").info()
+    poll(what = "contact info without bob's address") { exists(Ui.Info.DeleteContact) && !exists(Ui.Address.Share) && !seesText(ADDRESS_FOOTER) }
+    bob sends "/pa on"
+    bob.eventually("new contact address set")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's address with `Share address…` in the open contact info") {
+      exists(Ui.Address.Share) && seesText(ADDRESS_FOOTER) && contactOf("bob").contactLink != null
+    }
+    setClipboardText(null)
+    click(Ui.Address.Share)
+    var shared: String? = null
+    poll(what = "bob's address shared") { shared = clipboardText()?.takeIf { it.isNotBlank() }; shared != null }
+    bob sends "/_connect plan 1 $shared"
+    bob.eventually("contact address: own address")
+  }
+
+  @Test fun contactInfoNotReadyContactHidesSections() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val address = bob.createAddress(autoAccept = false)
+    alice.chatList.row("Private notes")
+    val chat = openNewChatFromSearch(address, "bob")
+    click(Ui.Chat.Connect)
+    poll(what = "`Send contact request?` with `Send request without message`") {
+      seesText("Send contact request?") && "Send request without message" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    bob.eventuallyAll(
+      listOf("alice wants to connect to you!", "to accept: /ac alice", "to reject: /rc alice (the sender will NOT be notified)"),
+      timeoutMs = CONNECT_TIMEOUT_MS
+    )
+    poll(what = "bob's contact connecting and not ready") { contactOf("bob").let { it.activeConn != null && !it.ready } }
+    hideKeyboard()
+    chat.info()
+    poll(what = "contact info of the not-ready bob without verification, preferences, servers, and with `Mute` disabled") {
+      exists(Ui.Info.DeleteContact) && exists(Ui.Info.Mute) && !isEnabled(Ui.Info.Mute) &&
+        !exists(Ui.Info.VerifyCode) && !exists(Ui.Info.Preferences) && !exists(Ui.Info.ReceivingVia) && !exists(Ui.Info.SwitchAddress)
+    }
+    closeContactInfo()
+    bob sends "/ac alice"
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's contact ready") { contactOf("bob").ready }
+    chat.info()
+    poll(what = "verification, preferences, servers and an enabled `Mute` in the contact info of the ready bob") {
+      exists(Ui.Info.VerifyCode) && exists(Ui.Info.Preferences) && exists(Ui.Info.ReceivingVia) && exists(Ui.Info.SwitchAddress) && isEnabled(Ui.Info.Mute)
+    }
+  }
+
+  @Test fun contactInfoAllowCallsAlert() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.info()
+    val prefs = contactPrefs()
+    poll(what = "calls allowed by both") { seesText(CALLS_BOTH) && !seesText(CALLS_OFF) }
+    prefs.allow(ChatFeature.Calls, "NO")
+    poll(what = "calls prohibited after the change") { seesText(CALLS_OFF) }
+    prefs.save()
+    assertEquals("alice updated preferences for you:", bob.nextLine(CONNECT_TIMEOUT_MS))
+    bob expects "Audio/video calls: off (you allow: default (yes), contact allows: no)"
+    poll(what = "alice's `no` for calls saved in bob's contact") { contactOf("bob").mergedPreferences.calls.userPreference.pref.allow == FeatureAllowed.NO }
+    prefs.backClosing()
+    closeContactInfo()
+    chat.info()
+    waitFor(Ui.Info.Call)
+    check(!seesText(ALLOW_CALLS_TEXT)) { "`Allow calls?` is shown before `call` is clicked" }
+    click(Ui.Info.Call)
+    poll(what = "the `Allow calls?` alert with `Allow`") {
+      seesText("Allow calls?") && seesText(ALLOW_CALLS_TEXT) && "Allow" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    assertEquals("alice updated preferences for you:", bob.nextLine(CONNECT_TIMEOUT_MS))
+    bob expects "Audio/video calls: enabled (you allow: default (yes), contact allows: yes)"
+    poll(what = "calls enabled for alice after `Allow`") { contactOf("bob").mergedPreferences.calls.enabled.forUser }
+    bob sends "/set calls @alice no"
+    bob expects "you updated preferences for alice:"
+    bob expects "Audio/video calls: off (you allow: no, contact allows: yes)"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `no` for calls in alice's contact") {
+      contactOf("bob").mergedPreferences.calls.contactPreference.allow == FeatureAllowed.NO
+    }
+    closeContactInfo()
+    chat.info()
+    waitFor(Ui.Info.Call)
+    check(!seesText(CALLS_PROHIBITED_TEXT)) { "`Calls prohibited!` is shown before `call` is clicked" }
+    click(Ui.Info.Call)
+    poll(what = "the `Calls prohibited!` alert asking to have calls enabled, not `Allow calls?`") {
+      seesText("Calls prohibited!") && seesText(CALLS_PROHIBITED_TEXT) && !seesText("Allow calls?")
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the `Calls prohibited!` alert to close") { !seesText("Calls prohibited!") }
+  }
+
+  @Test fun contactInfoSendReceiptsNo() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val direct = "@${bob.contactId("alice")}"
+    bob sends "@alice r0"
+    val chat = alice.chatList.open("bob")
+    chat.itemId("r0")
+    awaitReceipt(bob, direct, "r0")
+    chat.info()
+    poll(what = "`Send receipts` reading `default (yes)`") { "default (yes)" in textsOf(Ui.Info.SendReceipts) && contactOf("bob").chatSettings.sendRcpts == null }
+    click(Ui.Info.SendReceipts)
+    click(Ui.Info.SendReceipts.option(false))
+    poll(what = "`Send receipts` reading `no`, saved for bob") { "no" in textsOf(Ui.Info.SendReceipts) && contactOf("bob").chatSettings.sendRcpts == false }
+    bob sends "@alice r1"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `r1` received while receipts are off") { loadedText("r1") }
+    click(Ui.Info.SendReceipts)
+    click(Ui.Info.SendReceipts.option("default"))
+    poll(what = "`Send receipts` back to `default (yes)`, saved for bob") {
+      "default (yes)" in textsOf(Ui.Info.SendReceipts) && contactOf("bob").chatSettings.sendRcpts == null
+    }
+    bob sends "@alice r2"
+    awaitReceipt(bob, direct, "r2")
+    assertEquals("r1 received while receipts were off", "sndSent", bob.itemStatus(direct, "r1"))
+  }
+
+  @Test fun contactInfoIncognitoSection() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val incognito = connectIncognito(bob)
+    connect(cath)
+    check(incognito != "alice") { "bob sees alice's own name for an incognito connection" }
+    alice.chatList.row("bob")
+    alice.chatList.open("cath").info()
+    poll(what = "cath's contact info without `Your random profile`") {
+      infoNameText() == "cath" && exists(Ui.Info.DeleteContact) && !seesText(RANDOM_PROFILE) && !seesText(incognito)
+    }
+    closeContactInfo()
+    backToChatList()
+    alice.chatList.open("bob").info()
+    poll(what = "bob's contact info with `Your random profile` named `$incognito`, the name bob sees") {
+      infoNameText() == "bob" && seesText(RANDOM_PROFILE) && seesText(incognito)
+    }
+  }
+
+  @Test fun contactInfoChatTtlEnable() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val chat = alice.chatList.open("bob")
+    chat.info()
+    poll(what = "`Delete messages after` reading `default (never)`") {
+      "default (never)" in textsOf(Ui.Info.Ttl) && contactOf("bob").chatItemTTL == null
+    }
+    pickTtl(ChatItemTTL.Day)
+    poll(what = "the `Enable automatic message deletion?` alert with `Delete messages`") {
+      seesText(ENABLE_TTL) && "Delete messages" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the picker back at `default (never)` after `Cancel`") { !seesText(ENABLE_TTL) && "default (never)" in textsOf(Ui.Info.Ttl) }
+    check(contactOf("bob").chatItemTTL == null) { "`Cancel` set a message TTL for bob" }
+    pickTtl(ChatItemTTL.Day)
+    poll(what = "the `Enable automatic message deletion?` alert again") { seesText(ENABLE_TTL) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "bob's chat TTL of 1 day read back from the core, and `1 day` in the picker") {
+      contactOf("bob").chatItemTTL == 86400L && "1 day" in textsOf(Ui.Info.Ttl)
+    }
+    closeContactInfo()
+    chat.info()
+    poll(what = "`1 day` in reopened contact info") { "1 day" in textsOf(Ui.Info.Ttl) }
+    pickTtl(ChatItemTTL.None)
+    poll(what = "the `Disable automatic message deletion?` alert with `Disable delete messages`") {
+      seesText("Disable automatic message deletion?") && "Disable delete messages" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "bob's chat TTL set to never in the core and `never` in the picker") {
+      contactOf("bob").chatItemTTL == 0L && "never" in textsOf(Ui.Info.Ttl)
+    }
+  }
+
+  private fun UiScope.pickTtl(ttl: ChatItemTTL) {
+    poll(what = "the previous message deletion change to finish before opening the picker") { UiIdle.inFlight().isEmpty() }
+    click(Ui.Info.Ttl)
+    click(Ui.Info.Ttl.option(ttl))
+  }
+
+  private fun UiScope.awaitReceipt(peer: CliPeer, chatRef: String, text: String) =
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "${peer.name} to get alice's receipt for `$text`") { peer.itemStatus(chatRef, text) == "sndRcvd" }
+
+  private fun bobProfile() =
+    chatModel.chats.value.firstNotNullOfOrNull { (it.chatInfo as? ChatInfo.Direct)?.contact?.profile?.takeIf { p -> p.displayName == "bob" } }
+
+  private fun CliPeer.updateProfile() {
+    this sends """/_profile 1 {"displayName":"bob","fullName":"$FULL_NAME","shortDescr":"$BIO"}"""
+    eventuallyMatching(Regex("user full name changed to $FULL_NAME \\(your 1 contacts are notified.*\\)"), CONNECT_TIMEOUT_MS)
+  }
+
+  private companion object {
+    const val SHIELD = "�"
+    const val FULL_NAME = "Robert Brown"
+    const val BIO = "Plays the cello"
+    const val NETWORK_STATUS_TEXT = "You are connected to the server used to receive messages from this connection."
+    const val ABORT_SWITCH = "Abort changing address"
+    const val ADDRESS_FOOTER = "You can share this address with your contacts to let them connect with bob."
+    const val CALLS_BOTH = "Both you and your contact can make calls."
+    const val CALLS_OFF = "Audio/video calls are prohibited."
+    const val ALLOW_CALLS_TEXT = "You need to allow your contact to call to be able to call them."
+    const val CALLS_PROHIBITED_TEXT = "Please ask your contact to enable calls."
+    const val RANDOM_PROFILE = "Your random profile"
+    const val ENABLE_TTL = "Enable automatic message deletion?"
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactPreferencesTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactPreferencesTest.kt
new file mode 100644
index 0000000000..d02c30fccc
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactPreferencesTest.kt
@@ -0,0 +1,217 @@
+package chat.simplex.app.ui.main
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.closeContactInfo
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.contactOf
+import chat.simplex.app.ui.harness.contactPrefs
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.savedUserPrefs
+import chat.simplex.app.ui.harness.userPrefs
+import chat.simplex.common.model.ChatFeature
+import chat.simplex.common.model.ContactUserPref
+import chat.simplex.common.model.FeatureAllowed
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class ContactPreferencesTest : UiTest() {
+  @Test fun contactPrefsSaveNotifiesContactAndEnforces() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice one"
+    val chat = alice.chatList.open("bob")
+    val one = chat.itemId("one")
+    bob sends "\\@alice one"
+    bob.eventually("message marked deleted")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`one` only marked deleted while full deletion is off") { chat.item(one)?.meta?.itemDeleted != null && exists(Ui.Chat.Item(one)) }
+    chat.send("hi")
+    bob.expectsMessage("alice> hi", CONNECT_TIMEOUT_MS)
+    bob sends "+1 @alice hi"
+    bob expects "added 👍"
+    hideKeyboard()
+    chat.info()
+    var prefs = contactPrefs()
+    poll(what = "the default preferences: everything allowed except full deletion, with `Delete after`") {
+      seesText(TIMED_BOTH) && seesText(DELETE_OFF) && seesText(REACTIONS_BOTH) && seesText(VOICE_BOTH) && seesText(CALLS_BOTH) &&
+        prefs.ttlShown() && "default (no)" in prefs.allowTexts(ChatFeature.FullDelete)
+    }
+    prefs.toggleTimed()
+    prefs.allow(ChatFeature.FullDelete, "ALWAYS")
+    prefs.allow(ChatFeature.Reactions, "NO")
+    prefs.allow(ChatFeature.Voice, "NO")
+    prefs.allow(ChatFeature.Calls, "NO")
+    poll(what = "every section showing the unsaved change") {
+      seesText(TIMED_OFF) && seesText(DELETE_BY_CONTACT) && seesText(REACTIONS_OFF) && seesText(VOICE_OFF) && seesText(CALLS_OFF) &&
+        !seesText(TIMED_BOTH) && !seesText(VOICE_BOTH) && !prefs.ttlShown() && "always" in prefs.allowTexts(ChatFeature.FullDelete)
+    }
+    prefs.save()
+    assertEquals("alice updated preferences for you:", bob.nextLine(CONNECT_TIMEOUT_MS))
+    bob expects "Disappearing messages: off (you allow: default (yes), contact allows: no)"
+    bob expects "Full deletion: enabled for you (you allow: default (no), contact allows: always)"
+    bob expects "Message reactions: off (you allow: default (yes), contact allows: no)"
+    bob expects "Voice messages: off (you allow: default (yes), contact allows: no)"
+    bob expects "Audio/video calls: off (you allow: default (yes), contact allows: no)"
+    poll(what = "the saved preferences in bob's contact") { contactOf("bob").mergedPreferences.calls.userPreference.pref.allow == FeatureAllowed.NO }
+    prefs.backClosing()
+    closeContactInfo()
+    bob sends "@alice two"
+    val two = chat.itemId("two")
+    bob sends "\\@alice two"
+    bob expects "message deleted"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`two` removed from alice's chat") { chat.item(two) == null && !exists(Ui.Chat.Item(two)) }
+    bob sends "+^ @alice hi"
+    bob expects "bad chat command: feature not allowed Message reactions"
+    click(described("Record voice message"))
+    poll(what = "the `Allow voice messages?` alert with `Allow`") {
+      seesText("Allow voice messages?") && seesText("You need to allow your contact to send voice messages to be able to send them.") &&
+        "Allow" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    assertEquals("alice updated preferences for you:", bob.nextLine(CONNECT_TIMEOUT_MS))
+    bob expects "Voice messages: enabled (you allow: default (yes), contact allows: yes)"
+    chat.info()
+    prefs = contactPrefs()
+    poll(what = "voice allowed and disappearing messages still off") { seesText(VOICE_BOTH) && seesText(TIMED_OFF) && !prefs.ttlShown() }
+    prefs.toggleTimed()
+    poll(what = "`Delete after` shown with `1 day`") { prefs.ttlShown() && "1 day" in prefs.ttlTexts() && seesText(TIMED_BOTH) }
+    prefs.save()
+    assertEquals("alice updated preferences for you:", bob.nextLine(CONNECT_TIMEOUT_MS))
+    bob expects "Disappearing messages: enabled (you allow: yes (1 day), contact allows: yes (1 day))"
+  }
+
+  @Test fun contactPrefsResetAndUnsavedAlert() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.chatList.open("bob").info()
+    var prefs = contactPrefs()
+    poll(what = "voice messages allowed by both") { seesText(VOICE_BOTH) && !seesText(VOICE_OFF) }
+    bob sends "/set voice @alice no"
+    bob expects "you updated preferences for alice:"
+    bob expects "Voice messages: off (you allow: no, contact allows: yes)"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `no` shown under `Voice messages`") {
+      seesText(VOICE_OFF) && !seesText(VOICE_BOTH) && contactOf("bob").mergedPreferences.voice.contactPreference.allow == FeatureAllowed.NO
+    }
+    prefs.allow(ChatFeature.Reactions, "NO")
+    poll(what = "reactions prohibited after the change") { seesText(REACTIONS_OFF) && !seesText(REACTIONS_BOTH) }
+    prefs.reset()
+    poll(what = "reactions back to `default (yes)` after `Reset`") {
+      seesText(REACTIONS_BOTH) && !seesText(REACTIONS_OFF) && "default (yes)" in prefs.allowTexts(ChatFeature.Reactions)
+    }
+    prefs.backClosing()
+    prefs = contactPrefs()
+    prefs.allow(ChatFeature.Reactions, "NO")
+    poll(what = "reactions prohibited after the change") { seesText(REACTIONS_OFF) }
+    prefs.backExpectingAlert()
+    check("Save and notify contact" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && "Exit without saving" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))) {
+      "the `Save preferences?` alert has no `Save and notify contact` / `Exit without saving`"
+    }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "contact preferences to close after `Exit without saving`") { !exists(Ui.ContactPrefs.Save) && !seesText("Save preferences?") }
+    check(contactOf("bob").mergedPreferences.reactions.userPreference is ContactUserPref.User) { "`Exit without saving` saved the reactions change" }
+    prefs = contactPrefs()
+    poll(what = "reactions still `default (yes)` after `Exit without saving`") {
+      seesText(REACTIONS_BOTH) && "default (yes)" in prefs.allowTexts(ChatFeature.Reactions)
+    }
+    prefs.allow(ChatFeature.Reactions, "NO")
+    poll(what = "reactions prohibited after the change") { seesText(REACTIONS_OFF) }
+    prefs.backExpectingAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "contact preferences to close with reactions saved off") {
+      !exists(Ui.ContactPrefs.Save) && contactOf("bob").mergedPreferences.reactions.userPreference.pref.allow == FeatureAllowed.NO
+    }
+    assertEquals("alice updated preferences for you:", bob.nextLine(CONNECT_TIMEOUT_MS))
+    bob expects "Message reactions: off (you allow: default (yes), contact allows: no)"
+  }
+
+  @Test fun userPrefsFullDeleteReactionsVoiceCalls() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob)
+    connect(cath)
+    alice.chatList.row("cath")
+    val prefs = userPrefs(alice)
+    poll(what = "the default preferences: full deletion only marked, the rest allowed if the contact allows") {
+      seesText(U_TIMED_YES, substring = true) && seesText(U_DELETE_NO) && seesText(U_REACTIONS_YES) && seesText(U_VOICE_YES) && seesText(U_CALLS_YES)
+    }
+    prefs.toggleTimed()
+    prefs.allow(ChatFeature.FullDelete, FeatureAllowed.ALWAYS)
+    prefs.allow(ChatFeature.Reactions, FeatureAllowed.NO)
+    prefs.allow(ChatFeature.Voice, FeatureAllowed.NO)
+    prefs.allow(ChatFeature.Calls, FeatureAllowed.NO)
+    poll(what = "every footer showing the unsaved change") {
+      seesText(U_TIMED_NO) && seesText(U_DELETE_ALWAYS) && seesText(U_REACTIONS_NO) && seesText(U_VOICE_NO) && seesText(U_CALLS_NO) &&
+        !seesText(U_TIMED_YES, substring = true) && !seesText(U_DELETE_NO) && !seesText(U_CALLS_YES)
+    }
+    check(savedUserPrefs().calls.allow == FeatureAllowed.YES) { "the calls change was saved before `Save and notify contacts`" }
+    prefs.save()
+    for (peer in listOf(bob, cath)) {
+      assertEquals("alice updated preferences for you:", peer.nextLine(CONNECT_TIMEOUT_MS))
+      peer expects "Disappearing messages: off (you allow: default (yes), contact allows: no)"
+      peer expects "Full deletion: enabled for you (you allow: default (no), contact allows: always)"
+      peer expects "Message reactions: off (you allow: default (yes), contact allows: no)"
+      peer expects "Voice messages: off (you allow: default (yes), contact allows: no)"
+      peer expects "Audio/video calls: off (you allow: default (yes), contact allows: no)"
+    }
+    poll(what = "the saved preferences in alice's profile") {
+      savedUserPrefs().let { it.calls.allow == FeatureAllowed.NO && it.fullDelete.allow == FeatureAllowed.ALWAYS && it.timedMessages.allow == FeatureAllowed.NO }
+    }
+    prefs.backClosing()
+  }
+
+  @Test fun userPrefsResetAndUnsavedAlert() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    var prefs = userPrefs(alice)
+    poll(what = "reactions allowed by default") { seesText(U_REACTIONS_YES) && "yes" in prefs.allowTexts(ChatFeature.Reactions) }
+    prefs.allow(ChatFeature.Reactions, FeatureAllowed.NO)
+    poll(what = "reactions prohibited after the change") { seesText(U_REACTIONS_NO) && "no" in prefs.allowTexts(ChatFeature.Reactions) }
+    prefs.reset()
+    poll(what = "reactions back to `yes` after `Reset`") { seesText(U_REACTIONS_YES) && "yes" in prefs.allowTexts(ChatFeature.Reactions) }
+    prefs.backClosing()
+    prefs = userPrefs(alice)
+    prefs.allow(ChatFeature.Reactions, FeatureAllowed.NO)
+    poll(what = "reactions prohibited after the change") { seesText(U_REACTIONS_NO) }
+    prefs.backExpectingAlert()
+    check("Save and notify contacts" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && "Exit without saving" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))) {
+      "the `Save preferences?` alert has no `Save and notify contacts` / `Exit without saving`"
+    }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "your preferences to close after `Exit without saving`") { !exists(Ui.UserPrefs.Save) && !seesText("Save preferences?") }
+    check(savedUserPrefs().reactions.allow == FeatureAllowed.YES) { "`Exit without saving` saved the reactions change" }
+    prefs = userPrefs(alice)
+    poll(what = "reactions still `yes` after `Exit without saving`") { seesText(U_REACTIONS_YES) && "yes" in prefs.allowTexts(ChatFeature.Reactions) }
+    prefs.allow(ChatFeature.Reactions, FeatureAllowed.NO)
+    poll(what = "reactions prohibited after the change") { seesText(U_REACTIONS_NO) }
+    prefs.backExpectingAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "your preferences to close with reactions saved off") {
+      !exists(Ui.UserPrefs.Save) && savedUserPrefs().reactions.allow == FeatureAllowed.NO
+    }
+    assertEquals("alice updated preferences for you:", bob.nextLine(CONNECT_TIMEOUT_MS))
+    bob expects "Message reactions: off (you allow: default (yes), contact allows: no)"
+  }
+
+  private companion object {
+    const val TIMED_BOTH = "Both you and your contact can send disappearing messages."
+    const val TIMED_OFF = "Disappearing messages are prohibited in this chat."
+    const val DELETE_OFF = "Irreversible message deletion is prohibited in this chat."
+    const val DELETE_BY_CONTACT = "Only your contact can irreversibly delete messages (you can mark them for deletion). (24 hours)"
+    const val REACTIONS_BOTH = "Both you and your contact can add message reactions."
+    const val REACTIONS_OFF = "Message reactions are prohibited in this chat."
+    const val VOICE_BOTH = "Both you and your contact can send voice messages."
+    const val VOICE_OFF = "Voice messages are prohibited in this chat."
+    const val CALLS_BOTH = "Both you and your contact can make calls."
+    const val CALLS_OFF = "Audio/video calls are prohibited."
+    const val U_TIMED_YES = "Allow disappearing messages only if your contact allows them."
+    const val U_TIMED_NO = "Prohibit sending disappearing messages."
+    const val U_DELETE_NO = "Contacts can mark messages for deletion; you will be able to view them."
+    const val U_DELETE_ALWAYS = "Allow your contacts to irreversibly delete sent messages. (24 hours)"
+    const val U_REACTIONS_YES = "Allow message reactions only if your contact allows them."
+    const val U_REACTIONS_NO = "Prohibit message reactions."
+    const val U_VOICE_YES = "Allow voice messages only if your contact allows them."
+    const val U_VOICE_NO = "Prohibit sending voice messages."
+    const val U_CALLS_YES = "Allow calls only if your contact allows them."
+    const val U_CALLS_NO = "Prohibit audio/video calls."
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactsTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactsTest.kt
index 4be3137261..7f512bab7b 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactsTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ContactsTest.kt
@@ -3,9 +3,7 @@ package chat.simplex.app.ui.main
 import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
 import chat.simplex.app.ui.harness.connect
 import chat.simplex.app.ui.harness.UiTest
-import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
-import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class ContactsTest : UiTest() {
@@ -40,17 +38,6 @@ class ContactsTest : UiTest() {
     alice.chatList.gone("bob")
   }
 
-  @Test fun contactInfoSetLocalAlias() = uiTest {
-    val alice = app("alice"); val bob = cli("bob")
-    connect(bob)
-    alice.chatList.row("bob")
-    assertTrue("bob" in alice.chatList.rowTexts("bob"))
-    alice.chatList.open("bob").info()
-    typeInto(Ui.Info.Alias, "friend")
-    poll(what = "the row to read `friend`") { chatModel.chats.value.any { it.chatInfo.chatViewName == "friend" } }
-    poll(what = "the row text `friend` instead of `bob`") { alice.chatList.rowTexts("friend").let { "friend" in it && "bob" !in it } }
-  }
-
   @Test fun editProfileDisplayName() = uiTest {
     val alice = app("alice"); val bob = cli("bob")
     connect(bob)
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/DeleteContactTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/DeleteContactTest.kt
new file mode 100644
index 0000000000..1a5bbb46e9
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/DeleteContactTest.kt
@@ -0,0 +1,224 @@
+package chat.simplex.app.ui.main
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.archiveContact
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.contactOf
+import chat.simplex.app.ui.harness.createAddress
+import chat.simplex.app.ui.harness.enterLinkInSearch
+import chat.simplex.app.ui.harness.openArchivedContact
+import chat.simplex.app.ui.harness.openNewChatFromSearch
+import chat.simplex.app.ui.harness.planConfirm
+import chat.simplex.app.ui.harness.planDismiss
+import chat.simplex.app.ui.harness.presetFilter
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.chatlist.PresetTagKind
+import chat.simplex.common.views.helpers.ModalManager
+import org.junit.Test
+
+class DeleteContactTest : UiTest() {
+  @Test fun deleteContactOnlyConversation() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    bob sends "@alice hello"
+    val bobId = alice.chatList.chatId("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `hello` on his row") { "hello" in alice.chatList.rowTexts("bob") }
+    alice.chatList.row("cath")
+    appPrefs.showDeleteConversationNotice.set(true)
+    poll(what = "the conversation notice stored as enabled") { storedSetting(CONVERSATION_NOTICE) == "true" }
+    alice.chatList.rowMenu("bob", "delete")
+    poll(what = "`Delete contact?` with `Only delete conversation`, `Delete contact` and `Cancel`") {
+      seesText("Delete contact?") && "Only delete conversation" in textsOf(ONLY_CONVERSATION) &&
+        "Delete contact" in textsOf(DELETE_CONTACT) && "Cancel" in textsOf(CANCEL)
+    }
+    click(CANCEL)
+    poll(what = "the alert closed with bob's row and `hello` kept") {
+      !exists(ONLY_CONVERSATION) && "hello" in alice.chatList.rowTexts("bob") && !contactOf("bob").chatDeleted
+    }
+    alice.chatList.rowMenu("bob", "delete")
+    click(ONLY_CONVERSATION)
+    poll(what = "the `Conversation deleted!` notice with `Don't show again`") {
+      seesText("Conversation deleted!") && seesText("You can send messages to bob from Archived contacts.") &&
+        "Don't show again" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the notice closed and turned off on disk") {
+      !seesText("Conversation deleted!") && !appPrefs.showDeleteConversationNotice.get() && storedSetting(CONVERSATION_NOTICE) == "false"
+    }
+    poll(what = "bob's row hidden with his contact archived, and cath still listed") {
+      contactOf("bob").chatDeleted && !exists(Ui.ChatList.Row(bobId)) && alice.chatList.shown("cath")
+    }
+    presetFilter(PresetTagKind.CONTACTS, "Contacts")
+    poll(what = "only cath under `Contacts`") {
+      alice.chatList.shown("cath") && !exists(Ui.ChatList.Row(bobId)) && !alice.chatList.shown("Private notes")
+    }
+    bob sends "@alice hi"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob back under `Contacts` with `hi` and without `hello`") {
+      !contactOf("bob").chatDeleted && exists(Ui.ChatList.Row(bobId)) && alice.chatList.rowTexts("bob").let { "hi" in it && "hello" !in it }
+    }
+    val chat = alice.chatList.open("bob")
+    chat.itemId("hi")
+    check("hello" !in chat.itemTexts()) { "the deleted conversation came back with bob's new message" }
+    chat.send("back")
+    bob.expectsMessage("alice> back", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun deleteContactWithoutNotification() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    alice.chatList.row("cath")
+    val bobId = alice.chatList.chatId("bob")
+    alice.chatList.open("bob").info()
+    click(Ui.Info.DeleteContact)
+    click(DELETE_CONTACT)
+    poll(what = "the second `Delete contact?` alert with `Keep conversation` and both delete options") {
+      seesText("bob\n\nContact will be deleted - this cannot be undone!") && exists(KEEP_CONVERSATION) &&
+        "Delete without notification" in textsOf(WITHOUT_NOTIFICATION) && "Delete and notify contact" in textsOf(AND_NOTIFY)
+    }
+    click(WITHOUT_NOTIFICATION)
+    poll(what = "contact info and bob's chat closed") { chatModel.chatId.value == null && !ModalManager.end.hasModalsOpen() && !exists(Ui.Info.DeleteContact) }
+    alice.chatList.gone("bob")
+    check(!exists(Ui.ChatList.Row(bobId)) && alice.chatList.shown("cath")) { "bob's row is listed or cath's row is gone after deleting bob" }
+    alice.chatList.rowMenu("cath", "delete")
+    click(DELETE_CONTACT)
+    click(AND_NOTIFY)
+    cath.eventually("alice deleted contact with you", CONNECT_TIMEOUT_MS)
+    alice.chatList.gone("cath")
+    bob sends "/u"
+    bob expects "user profile: bob"
+  }
+
+  @Test fun deleteContactKeepConversation() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice hello"
+    val bobId = alice.chatList.chatId("bob")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `hello` on his row") { "hello" in alice.chatList.rowTexts("bob") }
+    appPrefs.showDeleteContactNotice.set(true)
+    alice.chatList.rowMenu("bob", "delete")
+    click(DELETE_CONTACT)
+    click(KEEP_CONVERSATION)
+    click(AND_NOTIFY)
+    poll(what = "the `Contact deleted!` notice with `OK` and `Don't show again`") {
+      seesText("Contact deleted!") && seesText("You can still view conversation with bob in the list of chats.") &&
+        "OK" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && "Don't show again" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    }
+    bob.eventually("alice deleted contact with you", CONNECT_TIMEOUT_MS)
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the notice closed and still enabled on disk") {
+      !seesText("Contact deleted!") && appPrefs.showDeleteContactNotice.get() && storedSetting(CONTACT_NOTICE) == "true"
+    }
+    poll(what = "bob's row kept with `hello` and his contact deleted") {
+      !contactOf("bob").active && exists(Ui.ChatList.Row(bobId)) && "hello" in alice.chatList.rowTexts("bob")
+    }
+    val chat = alice.chatList.open("bob")
+    chat.itemId("hello")
+    poll(what = "`contact deleted` in place of the message field") { seesText("contact deleted") }
+  }
+
+  @Test fun contactDeletedByPeerShowsDeleted() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice hello"
+    val chat = alice.chatList.open("bob")
+    chat.itemId("hello")
+    check(contactOf("bob").active && !seesText("contact deleted")) { "bob's contact is inactive before he deletes it" }
+    bob sends "/d alice"
+    bob expects "alice: contact is deleted"
+    chat.itemId("bob's `deleted contact` event") { it.content.text == "deleted contact" }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's contact inactive and `contact deleted` in place of the message field") {
+      !contactOf("bob").active && seesText("contact deleted")
+    }
+  }
+
+  @Test fun deleteArchivedContactConfirm() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob); connect(cath)
+    archiveContact(alice, "bob")
+    archiveContact(alice, "cath")
+    openArchivedContact(alice, "cath").contactInfo()
+    click(Ui.Info.DeleteContact)
+    awaitConfirmArchivedDeletion("cath")
+    click(CANCEL)
+    poll(what = "the alert closed with cath still archived") { !seesText(CONFIRM_DELETION) && contactOf("cath").chatDeleted }
+    click(Ui.Info.DeleteContact)
+    awaitConfirmArchivedDeletion("cath")
+    click(WITHOUT_NOTIFICATION)
+    alice.chatList.gone("cath")
+    backToChatList()
+    openArchivedContact(alice, "bob").contactInfo()
+    click(Ui.Info.DeleteContact)
+    awaitConfirmArchivedDeletion("bob")
+    click(AND_NOTIFY)
+    bob.eventually("alice deleted contact with you", CONNECT_TIMEOUT_MS)
+    alice.chatList.gone("bob")
+    cath sends "/u"
+    cath expects "user profile: cath"
+  }
+
+  @Test fun deleteNotReadyContactConfirm() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val address = bob.createAddress(autoAccept = false)
+    alice.chatList.row("Private notes")
+    val chat = openNewChatFromSearch(address, "bob")
+    click(Ui.Chat.Connect)
+    poll(what = "`Send contact request?` with `Send request without message`") {
+      seesText("Send contact request?") && "Send request without message" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    bob.eventuallyAll(
+      listOf("alice wants to connect to you!", "to accept: /ac alice", "to reject: /rc alice (the sender will NOT be notified)"),
+      timeoutMs = CONNECT_TIMEOUT_MS
+    )
+    poll(what = "bob's contact connecting and not ready") { contactOf("bob").let { it.activeConn != null && !it.ready } }
+    val bobId = alice.chatList.chatId("bob")
+    hideKeyboard()
+    chat.info()
+    click(Ui.Info.DeleteContact)
+    awaitConfirmNotReadyDeletion()
+    click(CANCEL)
+    poll(what = "the alert closed with bob kept") { !seesText(CONFIRM_DELETION) && chatModel.chats.value.any { it.id == bobId } }
+    click(Ui.Info.DeleteContact)
+    awaitConfirmNotReadyDeletion()
+    click(CONFIRM)
+    alice.chatList.gone("bob")
+    poll(what = "contact info and bob's chat closed") { chatModel.chatId.value == null && !ModalManager.end.hasModalsOpen() }
+    backToChatList()
+    enterLinkInSearch(address)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the plan for bob's address offering `Open new chat` again, as the contact is gone from the core") {
+      exists(planConfirm) && "Open new chat" in textsOf(planConfirm) && seesText("bob")
+    }
+    click(planDismiss)
+  }
+
+  private fun UiScope.awaitConfirmArchivedDeletion(name: String) =
+    poll(what = "`Confirm contact deletion?` for the archived $name with both delete options and `Cancel`") {
+      seesText(CONFIRM_DELETION) && seesText("$name\n\n$CANNOT_UNDO") && "Delete and notify contact" in textsOf(AND_NOTIFY) &&
+        "Delete without notification" in textsOf(WITHOUT_NOTIFICATION) && "Cancel" in textsOf(CANCEL) && !seesText("Delete contact?")
+    }
+
+  private fun UiScope.awaitConfirmNotReadyDeletion() =
+    poll(what = "`Confirm contact deletion?` for the not-ready bob with only `Confirm` and `Cancel`") {
+      seesText(CONFIRM_DELETION) && seesText("bob\n\n$CANNOT_UNDO") && "Confirm" in textsOf(CONFIRM) && "Cancel" in textsOf(CANCEL) &&
+        !exists(AND_NOTIFY) && !exists(WITHOUT_NOTIFICATION)
+    }
+
+  private companion object {
+    val ONLY_CONVERSATION = Ui.Alert.Option(Ui.AlertSource.Shared, "onlyConversation")
+    val DELETE_CONTACT = Ui.Alert.Option(Ui.AlertSource.Shared, "deleteContact")
+    val CANCEL = Ui.Alert.Option(Ui.AlertSource.Shared, "cancel")
+    val KEEP_CONVERSATION = Ui.Alert.Option(Ui.AlertSource.Shared, "keepConversation")
+    val WITHOUT_NOTIFICATION = Ui.Alert.Option(Ui.AlertSource.Shared, "deleteWithoutNotification")
+    val AND_NOTIFY = Ui.Alert.Option(Ui.AlertSource.Shared, "deleteAndNotify")
+    val CONFIRM = Ui.Alert.Option(Ui.AlertSource.Shared, "confirm")
+    const val CONFIRM_DELETION = "Confirm contact deletion?"
+    const val CANNOT_UNDO = "Contact will be deleted - this cannot be undone!"
+    const val CONVERSATION_NOTICE = "showDeleteConversationNotice"
+    const val CONTACT_NOTICE = "showDeleteContactNotice"
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/NewChatSheetTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/NewChatSheetTest.kt
new file mode 100644
index 0000000000..f73da1a75f
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/NewChatSheetTest.kt
@@ -0,0 +1,190 @@
+package chat.simplex.app.ui.main
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.ChatScreen
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.contactOf
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.dismissNewChatSheet
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.labelled
+import chat.simplex.app.ui.harness.openContextMenu
+import chat.simplex.common.platform.appPlatform
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class NewChatSheetTest : UiTest() {
+  @Test fun newChatSheetShowsActions() = uiTest {
+    val alice = app("alice")
+    alice.newChat()
+    awaitSheet()
+    check(
+      "Create 1-time link" in textsOf(Ui.NewChat.CreateLink) &&
+        (if (appPlatform.isAndroid) "Paste link / Scan" else "Paste link") in textsOf(Ui.NewChat.PasteLink) &&
+        "Create group" in textsOf(Ui.NewChat.CreateGroup) &&
+        "Create public channel" in textsOf(Ui.NewChat.CreateChannel)
+    ) { "the New chat actions are not all shown with their labels" }
+    check(!exists(Ui.NewGroup.Name) && !seesText("Channel name")) { "a creation screen is shown before its action is clicked" }
+
+    click(Ui.NewChat.CreateGroup)
+    poll(what = "the `Create secret group` screen in place of the sheet") {
+      exists(Ui.NewGroup.Name) && seesText("Create secret group") && !exists(Ui.NewChat.CreateLink) && !seesText("Channel name")
+    }
+    leave(what = "the group screen") { !exists(Ui.NewGroup.Name) }
+    awaitSheet()
+
+    click(Ui.NewChat.CreateChannel)
+    poll(what = "the `Create public channel` screen in place of the sheet") {
+      seesText("Channel name") && seesText("Configure relays") && !exists(Ui.NewChat.CreateLink) && !exists(Ui.NewGroup.Name)
+    }
+    leave(what = "the channel screen") { !seesText("Channel name") }
+    awaitSheet()
+  }
+
+  @Test fun newChatSheetSearchFiltersContacts() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob)
+    connect(cath)
+    val bobId = alice.chatList.chatId("bob"); val cathId = alice.chatList.chatId("cath")
+    alice.newChat()
+    poll(what = "`Your contacts` listing bob and cath") {
+      seesText("Your contacts") && exists(Ui.NewChat.Contact(bobId)) && exists(Ui.NewChat.Contact(cathId))
+    }
+    typeInto(Ui.NewChat.Search, "CA")
+    poll(what = "only cath listed for `CA`") {
+      exists(Ui.NewChat.Contact(cathId)) && !exists(Ui.NewChat.Contact(bobId)) && !seesText("Your contacts") && !seesText("No filtered contacts")
+    }
+    replaceText(Ui.NewChat.Search, "zzz")
+    poll(what = "`No filtered contacts` and no contact listed for `zzz`") {
+      seesText("No filtered contacts") && !exists(Ui.NewChat.Contact(cathId)) && !exists(Ui.NewChat.Contact(bobId))
+    }
+    replaceText(Ui.NewChat.Search, "ca")
+    poll(what = "only cath listed for `ca`") { exists(Ui.NewChat.Contact(cathId)) && !exists(Ui.NewChat.Contact(bobId)) }
+    hideKeyboard()
+    click(Ui.NewChat.Contact(cathId))
+    poll(what = "cath's chat open and the New chat sheet closed") {
+      chatModel.chatId.value == cathId && !chatModel.newChatSheetVisible.value && !exists(Ui.NewChat.Search)
+    }
+    ChatScreen(this).send("found you")
+    cath.expectsMessage("alice> found you", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun archivedContactsSendMessageRestores() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob)
+    connect(cath)
+    val bobId = alice.chatList.chatId("bob"); val cathId = alice.chatList.chatId("cath")
+    alice.chatList.row("cath")
+    alice.newChat()
+    poll(what = "bob and cath under `Your contacts` and no `Archived contacts` row") {
+      exists(Ui.NewChat.Contact(bobId)) && exists(Ui.NewChat.Contact(cathId)) && exists(Ui.NewChat.CreateLink) && !exists(Ui.NewChat.Archived)
+    }
+    dismissNewChatSheet()
+    alice.chatList.rowMenu("bob", "delete")
+    click(ONLY_CONVERSATION)
+    poll(what = "bob archived and gone from the chat list") { contactOf("bob").chatDeleted && !exists(Ui.ChatList.Row(bobId)) }
+
+    alice.newChat()
+    poll(what = "the `Archived contacts` row, with cath but not bob under `Your contacts`") {
+      labelled(Ui.NewChat.Archived, "Archived contacts") && exists(Ui.NewChat.Contact(cathId)) && !exists(Ui.NewChat.Contact(bobId))
+    }
+    typeInto(Ui.NewChat.Search, "bo")
+    poll(what = "the archived bob found by `bo`, cath not") {
+      exists(Ui.NewChat.Contact(bobId)) && !exists(Ui.NewChat.Contact(cathId)) && !exists(Ui.NewChat.Archived)
+    }
+    hideKeyboard()
+    click(described("Close button"))
+    poll(what = "the search cleared, bob hidden again behind `Archived contacts`") {
+      editableText(Ui.NewChat.Search).isNullOrEmpty() && exists(Ui.NewChat.Archived) && exists(Ui.NewChat.Contact(cathId)) && !exists(Ui.NewChat.Contact(bobId))
+    }
+    click(Ui.NewChat.Archived)
+    poll(what = "the `Archived contacts` list with bob only, in place of the sheet") {
+      exists(Ui.NewChat.Contact(bobId)) && !exists(Ui.NewChat.Contact(cathId)) && !exists(Ui.NewChat.CreateLink)
+    }
+    click(Ui.NewChat.Contact(bobId))
+    poll(what = "bob's chat open with the archived list and the sheet closed") {
+      chatModel.chatId.value == bobId && !exists(Ui.NewChat.Contact(bobId)) && !exists(Ui.NewChat.Search)
+    }
+    ChatScreen(this).send("hi")
+    bob.expectsMessage("alice> hi", CONNECT_TIMEOUT_MS)
+    backToChatList()
+    poll(what = "bob back in the chat list with `hi`") {
+      !contactOf("bob").chatDeleted && exists(Ui.ChatList.Row(bobId)) && "hi" in alice.chatList.rowTexts("bob")
+    }
+    alice.newChat()
+    poll(what = "bob under `Your contacts` and no `Archived contacts` row") {
+      exists(Ui.NewChat.Contact(bobId)) && exists(Ui.NewChat.Contact(cathId)) && exists(Ui.NewChat.CreateLink) && !exists(Ui.NewChat.Archived)
+    }
+  }
+
+  @Test fun newChatSheetFavoritesFilterToggle() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    connect(bob)
+    connect(cath)
+    val bobId = alice.chatList.chatId("bob"); val cathId = alice.chatList.chatId("cath")
+    alice.chatList.row("cath")
+    alice.chatList.rowMenu("bob", "favorite", "Favorite")
+    poll(what = "bob favourite and cath not") {
+      alice.chatList.chat("bob").chatInfo.chatSettings?.favorite == true && alice.chatList.chat("cath").chatInfo.chatSettings?.favorite == false
+    }
+    alice.newChat()
+    poll(what = "bob and cath listed with the filter off") { exists(Ui.NewChat.Contact(bobId)) && exists(Ui.NewChat.Contact(cathId)) && exists(Ui.NewChat.Favorites) }
+    check(storedSetting(FAVORITES_FILTER) != "true") { "the favourites filter is stored as on before it is toggled" }
+    click(Ui.NewChat.Favorites)
+    poll(what = "only the favourite bob listed and the filter stored as on") {
+      exists(Ui.NewChat.Contact(bobId)) && !exists(Ui.NewChat.Contact(cathId)) && storedSetting(FAVORITES_FILTER) == "true"
+    }
+    click(Ui.NewChat.Favorites)
+    poll(what = "bob and cath listed again and the filter stored as off") {
+      exists(Ui.NewChat.Contact(bobId)) && exists(Ui.NewChat.Contact(cathId)) && storedSetting(FAVORITES_FILTER) == "false"
+    }
+  }
+
+  @Test fun newChatSheetContactWithRequestOpensChat() = uiTest {
+    val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+    val address = alice.userPicker().createAddress()
+    connect(bob)
+    cath sends "/c $address"
+    cath expects "connection request sent!"
+    alice.chatList.request("cath")
+    val bobId = alice.chatList.chatId("bob"); val cathId = alice.chatList.chatId("cath")
+    alice.newChat()
+    poll(what = "bob and cath's request under `Your contacts`") { exists(Ui.NewChat.Contact(bobId)) && exists(Ui.NewChat.Contact(cathId)) }
+
+    openContextMenu(Ui.NewChat.Contact(bobId))
+    click(Ui.NewChat.ContactMenu(bobId, "delete"))
+    click(DELETE_CONTACT)
+    click(AND_NOTIFY)
+    bob.eventually("alice deleted contact with you", CONNECT_TIMEOUT_MS)
+    poll(what = "bob gone from the sheet, cath still listed") {
+      chatModel.chats.value.none { it.id == bobId } && !exists(Ui.NewChat.Contact(bobId)) && exists(Ui.NewChat.Contact(cathId))
+    }
+
+    click(Ui.NewChat.Contact(cathId))
+    poll(what = "cath's chat open with the `Reject` / `Accept` bar and the sheet closed") {
+      chatModel.chatId.value == cathId && exists(Ui.Chat.RequestAccept) && exists(Ui.Chat.RequestReject) && !exists(Ui.Chat.Message) && !exists(Ui.NewChat.Search)
+    }
+  }
+
+  private fun UiScope.awaitSheet() =
+    poll(what = "the New chat sheet with its actions") {
+      exists(Ui.NewChat.CreateLink) && exists(Ui.NewChat.CreateGroup) && exists(Ui.NewChat.CreateChannel)
+    }
+
+  private fun UiScope.leave(what: String, closed: () -> Boolean) {
+    hideKeyboard()
+    goBack()
+    poll(what = "$what to close", cond = closed)
+  }
+
+  private companion object {
+    val ONLY_CONVERSATION = Ui.Alert.Option(Ui.AlertSource.Shared, "onlyConversation")
+    val DELETE_CONTACT = Ui.Alert.Option(Ui.AlertSource.Shared, "deleteContact")
+    val AND_NOTIFY = Ui.Alert.Option(Ui.AlertSource.Shared, "deleteAndNotify")
+    const val FAVORITES_FILTER = "ShowUnreadAndFavorites"
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/OneTimeLinkCompatTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/OneTimeLinkCompatTest.kt
index c53a1154ad..dde6a6b512 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/OneTimeLinkCompatTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/OneTimeLinkCompatTest.kt
@@ -2,6 +2,8 @@ package chat.simplex.app.ui.main
 
 import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.ui.Ui
 import org.junit.Test
 
 class OneTimeLinkCompatTest : UiTest() {
@@ -12,4 +14,30 @@ class OneTimeLinkCompatTest : UiTest() {
     bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
     alice.chatList.row("bob")
   }
+
+  @Test fun oneTimeLinkCliConnectsViaFullLink() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val short = alice.newChat().createOneTimeLink()
+    poll(what = "the 1-time link without the `Full link` toggle while developer tools are off") {
+      seesText("OR SHOW THIS CODE") && !exists(Ui.Link.ShortLinkToggle)
+    }
+    check(FULL_INVITATION !in short) { "the 1-time link shown by default is the full link `$short`" }
+    enableDeveloperToolsViaApi()
+    poll(what = "the `Full link` toggle with developer tools on") { exists(Ui.Link.ShortLinkToggle) && "Full link" in textsOf(Ui.Link.ShortLinkToggle) }
+    click(Ui.Link.ShortLinkToggle)
+    var full: String? = null
+    poll(what = "the full link in place of the short one, and the toggle reading `Short link`") {
+      full = editableText(Ui.Link.Text)?.takeIf { FULL_INVITATION in it }
+      full != null && "Short link" in textsOf(Ui.Link.ShortLinkToggle)
+    }
+    bob sends "/c $full"; bob expects "confirmation sent!"
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    alice.chatList.row("bob")
+  }
+
+  private fun enableDeveloperToolsViaApi() = appPrefs.developerTools.set(true)
+
+  private companion object {
+    const val FULL_INVITATION = "/invitation#/?v="
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/OneTimeLinkTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/OneTimeLinkTest.kt
index 6fe192aa80..e6b66a87c2 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/OneTimeLinkTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/OneTimeLinkTest.kt
@@ -1,14 +1,29 @@
 package chat.simplex.app.ui.main
 
 import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.NEW_RANDOM_PROFILE
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.awaitInvitationGone
+import chat.simplex.app.ui.harness.awaitInviteClosed
+import chat.simplex.app.ui.harness.chooseLinkProfile
+import chat.simplex.app.ui.harness.closeNewChatSheet
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.hideUserViaApi
+import chat.simplex.app.ui.harness.leaveInviteExpectingKeepAlert
+import chat.simplex.app.ui.harness.pendingConnectionIds
+import chat.simplex.app.ui.harness.userIdOf
 import chat.simplex.common.model.ChatInfo
 import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNotEquals
 import org.junit.Test
 
+private const val INCOGNITO_PREF = "Incognito"
+private const val HIDDEN_PASSWORD = "hide-me-42"
+private val PROFILE_SEARCH = Ui.Link.ProfileBar.part("search")
+
 class OneTimeLinkTest : UiTest() {
   @Test fun oneTimeLinkSwitchToIncognito() = uiTest {
     val alice = app("alice"); val bob = cli("bob")
@@ -24,4 +39,110 @@ class OneTimeLinkTest : UiTest() {
       chatModel.chats.value.any { (it.chatInfo as? ChatInfo.Direct)?.contact?.let { c -> c.displayName == "bob" && c.contactConnIncognito } == true }
     }
   }
+
+  @Test fun createOneTimeLinkShowsLinkAndQr() = uiTest {
+    val alice = app("alice")
+    val sheet = alice.newChat()
+    poll(what = "the New chat sheet without a link or a QR code") { exists(Ui.NewChat.CreateLink) && !exists(Ui.Link.Text) && !seesDescription("QR Code") }
+    sheet.createOneTimeLink()
+    poll(what = "the link section, the QR code and alice in `Share profile`") {
+      seesText("Share this 1-time invite link") && seesText("OR SHOW THIS CODE") && seesDescription("QR Code") && "alice" in textsOf(Ui.Link.ShareProfile)
+    }
+  }
+
+  @Test fun oneTimeLinkKeepUnusedAlert() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val deleted = alice.newChat().createOneTimeLink()
+    val deletedId = pendingConnectionIds().single()
+    leaveInviteExpectingKeepAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    closeNewChatSheet()
+    poll(what = "the deleted link's pending connection gone") { deletedId !in pendingConnectionIds() && !exists(Ui.ChatList.Row(deletedId)) }
+
+    val shared = alice.newChat().createOneTimeLink()
+    click(Ui.Link.Text)
+    poll(what = "the link shared") { clipboardText() == shared }
+    goBack()
+    awaitInviteClosed()
+    check(!AlertManager.shared.hasAlertsShown() && !seesText("Keep unused invitation?")) { "`Keep unused invitation?` shown for a shared link" }
+    closeNewChatSheet()
+    poll(what = "the shared link's pending connection listed") { pendingConnectionIds().size == 1 }
+
+    val kept = alice.newChat().createOneTimeLink()
+    leaveInviteExpectingKeepAlert()
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    closeNewChatSheet()
+    poll(what = "the kept link's pending connection listed next to the shared one") { pendingConnectionIds().size == 2 }
+
+    bob sends "/c $kept"; bob expects "confirmation sent!"
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    alice.chatList.row("bob")
+    awaitInvitationGone(bob, deleted)
+  }
+
+  @Test fun oneTimeLinkChangeToOtherProfile() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    alice.userPicker().profiles().apply { add("work"); close() }
+    val workId = userIdOf("work")
+    alice.userPicker().switchTo("alice")
+    val first = alice.newChat().createOneTimeLink()
+    poll(what = "alice in `Share profile`") { "alice" in textsOf(Ui.Link.ShareProfile) }
+    click(Ui.Link.ShareProfile)
+    val second = chooseLinkProfile(workId, first)
+    poll(what = "work in `Share profile`") { "work" in textsOf(Ui.Link.ShareProfile) && "alice" !in textsOf(Ui.Link.ShareProfile) }
+    bob sends "/c $second"; bob expects "confirmation sent!"
+    bob.eventually("work: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob in work's chats") {
+      chatModel.currentUser.value?.userId == workId && chatModel.chats.value.any { it.chatInfo is ChatInfo.Direct && it.chatInfo.chatViewName == "bob" }
+    }
+    awaitInvitationGone(bob, first)
+  }
+
+  @Test fun oneTimeLinkChangeToHiddenProfileViaPassword() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    alice.userPicker().profiles().apply { add("work"); close() }
+    val workId = userIdOf("work"); val aliceId = userIdOf("alice")
+    alice.userPicker().switchTo("alice")
+    hideUserViaApi(workId, HIDDEN_PASSWORD)
+    val first = alice.newChat().createOneTimeLink()
+    click(Ui.Link.ShareProfile)
+    poll(what = "alice listed in `Select chat profile` and the hidden work not") { exists(Ui.Link.Profile(aliceId)) && !exists(Ui.Link.Profile(workId)) }
+    typeInto(PROFILE_SEARCH, "work")
+    poll(what = "no profile listed for the hidden profile's name") {
+      editableText(PROFILE_SEARCH) == "work" && exists(Ui.Link.ProfileIncognito) && !exists(Ui.Link.Profile(workId)) && !exists(Ui.Link.Profile(aliceId))
+    }
+    replaceText(PROFILE_SEARCH, HIDDEN_PASSWORD)
+    poll(what = "work listed for its password") { exists(Ui.Link.Profile(workId)) }
+    hideKeyboard()
+    val link = chooseLinkProfile(workId, first)
+    poll(what = "work in `Share profile`") { "work" in textsOf(Ui.Link.ShareProfile) }
+    bob sends "/c $link"; bob expects "confirmation sent!"
+    bob.eventually("work: contact is connected", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun oneTimeLinkSwitchBackFromIncognito() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val aliceId = userIdOf("alice")
+    check(storedSetting(INCOGNITO_PREF) != "true") { "incognito is stored as the default before the test chooses it" }
+    val sheet = alice.newChat()
+    sheet.createOneTimeLink()
+    click(Ui.Link.ShareProfile)
+    click(Ui.Link.ProfileIncognito)
+    poll(what = "the incognito footer and incognito stored as the default") { seesText(NEW_RANDOM_PROFILE) && storedSetting(INCOGNITO_PREF) == "true" }
+    goBack()
+    awaitInviteClosed()
+
+    val incognitoLink = sheet.createOneTimeLink()
+    poll(what = "the new link incognito by default") { seesText(NEW_RANDOM_PROFILE) && "Incognito" in textsOf(Ui.Link.ShareProfile) }
+    click(Ui.Link.ShareProfile)
+    val link = chooseLinkProfile(aliceId, incognitoLink)
+    poll(what = "alice in `Share profile`, no footer and incognito no longer the default") {
+      "alice" in textsOf(Ui.Link.ShareProfile) && !seesText(NEW_RANDOM_PROFILE) && storedSetting(INCOGNITO_PREF) == "false"
+    }
+    bob sends "/c $link"; bob expects "confirmation sent!"
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "a contact bob that is not incognito") {
+      chatModel.chats.value.any { (it.chatInfo as? ChatInfo.Direct)?.contact?.let { c -> c.displayName == "bob" && !c.contactConnIncognito } == true }
+    }
+  }
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/PendingConnectionTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/PendingConnectionTest.kt
new file mode 100644
index 0000000000..d228a8942f
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/PendingConnectionTest.kt
@@ -0,0 +1,156 @@
+package chat.simplex.app.ui.main
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.NEW_RANDOM_PROFILE
+import chat.simplex.app.ui.harness.PeerFlags
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.closePendingConnectionInfo
+import chat.simplex.app.ui.harness.connectionRequestSentToGroup
+import chat.simplex.app.ui.harness.createFullGroupLink
+import chat.simplex.app.ui.harness.createFullOneTimeLink
+import chat.simplex.app.ui.harness.described
+import chat.simplex.app.ui.harness.enterLinkInSearch
+import chat.simplex.app.ui.harness.joinOneTimeLinkInSearch
+import chat.simplex.app.ui.harness.keepIncognitoOneTimeLink
+import chat.simplex.app.ui.harness.keepOneTimeLink
+import chat.simplex.app.ui.harness.openChatById
+import chat.simplex.app.ui.harness.pendingConnectionIds
+import chat.simplex.app.ui.harness.planOption
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class PendingConnectionTest : UiTest() {
+  @Test fun pendingInfoInvitedSharesWorkingLink() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    keepOneTimeLink(alice)
+    alice.chatList.open(INVITED)
+    poll(what = "`You invited a contact` with the one-time link section and `Share 1-time link`") {
+      seesText("You invited a contact") && seesText("One-time invitation link") && seesText(CONTACT_ONLINE) && exists(SHARE) &&
+        !seesText("You accepted connection")
+    }
+    setClipboardText(null)
+    check(clipboardText() == null) { "the clipboard is not empty before sharing the link" }
+    click(SHARE)
+    var link: String? = null
+    poll(what = "the one-time link shared") { link = clipboardText()?.takeIf { it.isNotBlank() }; link != null }
+    bob sends "/c $link"
+    bob expects "confirmation sent!"
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob connected in place of the pending connection") {
+      chatModel.chats.value.any { (it.chatInfo as? ChatInfo.Direct)?.contact?.let { c -> c.displayName == "bob" && c.sndReady } == true } &&
+        chatModel.chats.value.none { it.chatInfo is ChatInfo.ContactConnection }
+    }
+  }
+
+  @Test fun pendingInfoDelete() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val link = keepOneTimeLink(alice)
+    alice.chatList.open(INVITED)
+    poll(what = "`You invited a contact` with `Delete`") { seesText("You invited a contact") && exists(DELETE) }
+    click(DELETE)
+    poll(what = "the `Delete pending connection?` alert for the invitation with `Delete`") {
+      seesText("Delete pending connection?") && seesText("$INVITED\n\nThe contact you shared this link with will NOT be able to connect!") &&
+        "Delete" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    alice.chatList.gone(INVITED)
+    poll(what = "the pending connection info closed") { chatModel.chatId.value == null && !seesText("You invited a contact") }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the deleted link to fail its plan on the server") {
+      bob sends "/_connect plan 1 $link"
+      bob.eventuallyMatching(PLAN_RESULT).value.startsWith("error")
+    }
+    bob sends "/c $link"
+    bob.eventuallyMatching(AUTH_FAILED)
+  }
+
+  @KnownAppIssue("15.5 item 18", "waiting for the pending row named `accepted invitation` with `via one-time link`")
+  @Test fun pendingInfoAcceptedShowsNoLink() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(fullLinks = true))
+    val full = bob.createFullOneTimeLink()
+    bob.stop()
+    alice.chatList.row("Private notes")
+    joinOneTimeLinkInSearch(full)
+    val pending = chatModel.chats.value.first { it.chatInfo is ChatInfo.ContactConnection }.id
+    poll(what = "the pending row named `$ACCEPTED` with `via one-time link`") {
+      textsOf(Ui.ChatList.Row(pending)).let { ACCEPTED in it && "via one-time link" in it }
+    }
+    alice.chatList.open(ACCEPTED)
+    poll(what = "`You accepted connection` with the name field and `Learn more`, without the one-time link or `Share 1-time link`") {
+      seesText("You accepted connection") && seesText(CONTACT_ONLINE) && exists(Ui.Info.Alias) && exists(described("Learn more")) &&
+        !seesText("You invited a contact") && !seesText("One-time invitation link") && !exists(SHARE)
+    }
+    typeInto(Ui.Info.Alias, "dentist")
+    poll(what = "the alias `dentist` saved for the pending connection") {
+      chatModel.chats.value.any { (it.chatInfo as? ChatInfo.ContactConnection)?.contactConnection?.localAlias == "dentist" }
+    }
+    bob.start()
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob connected under the alias `dentist` and no pending connection left") {
+      chatModel.chats.value.any { (it.chatInfo as? ChatInfo.Direct)?.contact?.let { c -> c.profile.displayName == "bob" && c.localAlias == "dentist" && c.sndReady } == true } &&
+        chatModel.chats.value.none { it.chatInfo is ChatInfo.ContactConnection }
+    }
+    alice.chatList.row("dentist")
+  }
+
+  @Test fun pendingInfoIncognitoShown() = uiTest {
+    val alice = app("alice")
+    keepOneTimeLink(alice)
+    val plain = pendingConnectionIds().single()
+    keepIncognitoOneTimeLink(alice)
+    val incognito = pendingConnectionIds().single { it != plain }
+    openChatById(plain)
+    poll(what = "the plain invitation's info sharing alice's profile, without `Incognito`") {
+      seesText("You invited a contact") && seesText(OWN_PROFILE) && !seesText("Incognito") && !seesText(NEW_RANDOM_PROFILE)
+    }
+    closePendingConnectionInfo()
+    openChatById(incognito)
+    poll(what = "the incognito invitation's info with `Incognito` and the random profile footer") {
+      seesText("You invited a contact") && seesText("Incognito") && seesText(NEW_RANDOM_PROFILE) && !seesText(OWN_PROFILE)
+    }
+    check(!seesText(SCAN_TO_CONNECT, substring = true)) { "the `Learn more` text is shown before `Learn more` is clicked" }
+    click(described("Learn more"))
+    poll(what = "the `One-time invitation link` page explaining how to connect") { seesText(SCAN_TO_CONNECT, substring = true) }
+  }
+
+  @Test fun pendingInfoGroupLinkHidesAlias() = uiTest {
+    val alice = app("alice"); val bob = cli("bob", PeerFlags(fullLinks = true))
+    val full = bob.createFullGroupLink("team")
+    bob.stop()
+    keepOneTimeLink(alice)
+    val invitation = pendingConnectionIds().single()
+    enterLinkInSearch(full)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `Join group?` alert with `Use current profile`") {
+      seesText("Join group?") && exists(planOption("useCurrentProfile"))
+    }
+    click(planOption("useCurrentProfile"))
+    connectionRequestSentToGroup()
+    var joining: String? = null
+    poll(what = "a pending connection for the group link next to the invitation") {
+      joining = pendingConnectionIds().singleOrNull { it != invitation }
+      joining != null
+    }
+    openChatById(invitation)
+    poll(what = "the invitation's info with the name field") { seesText("You invited a contact") && exists(Ui.Info.Alias) }
+    closePendingConnectionInfo()
+    openChatById(joining!!)
+    poll(what = "the group link connection's info waiting for the host, without the name field") {
+      seesText(GROUP_HOST_ONLINE) && !seesText("You invited a contact") && !exists(Ui.Info.Alias)
+    }
+  }
+
+  private companion object {
+    const val INVITED = "invited to connect"
+    const val ACCEPTED = "accepted invitation"
+    const val CONTACT_ONLINE = "You will be connected when your contact's device is online, please wait or check later!"
+    const val GROUP_HOST_ONLINE = "You will be connected to group when the group host's device is online, please wait or check later!"
+    const val OWN_PROFILE = "Your profile alice will be shared."
+    const val SCAN_TO_CONNECT = "To connect, your contact can scan QR code or use the link in the app."
+    val SHARE = described("Share 1-time link")
+    val DELETE = described("Delete")
+    val PLAN_RESULT = Regex("invitation link: ok to connect|error: connection authorization failed.*")
+    val AUTH_FAILED = Regex("error: connection authorization failed - .*")
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/PreparedChatTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/PreparedChatTest.kt
new file mode 100644
index 0000000000..73dfbd8f4f
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/PreparedChatTest.kt
@@ -0,0 +1,149 @@
+package chat.simplex.app.ui.main
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.becomeBot
+import chat.simplex.app.ui.harness.createAddress
+import chat.simplex.app.ui.harness.createOneTimeLink
+import chat.simplex.app.ui.harness.openNewChatFromSearch
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Test
+
+class PreparedChatTest : UiTest() {
+  @Test fun preparedContactInvitationConnectButton() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val link = bob.createOneTimeLink()
+    bob.eventually("and ask them to connect: /c <invitation_link_above>")
+    alice.chatList.row("Private notes")
+    check(chatModel.chats.value.none { it.chatInfo.chatViewName == "bob" }) { "a chat named bob exists before the link is opened" }
+    val chat = openNewChatFromSearch(link, "bob")
+    poll(what = "the banner `Tap Connect to chat` and a `Connect` button with no message field") {
+      seesText("Tap Connect to chat") && exists(Ui.Chat.Connect) && "Connect" in textsOf(Ui.Chat.Connect) && !exists(Ui.Chat.Message)
+    }
+    backToChatList()
+    poll(what = "`Open to connect` on bob's row") { "Open to connect" in alice.chatList.rowTexts("bob") }
+    alice.chatList.open("bob")
+    click(Ui.Chat.Connect)
+    assertEquals("alice: contact is connected", bob.nextLine(CONNECT_TIMEOUT_MS))
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the message field in place of `Connect` with bob ready") {
+      exists(Ui.Chat.Message) && !exists(Ui.Chat.Connect) && !seesText("Tap Connect to chat") &&
+        (alice.chatList.chat("bob").chatInfo as? ChatInfo.Direct)?.contact?.sndReady == true
+    }
+    chat.send("hi")
+    bob.expectsMessage("alice> hi", CONNECT_TIMEOUT_MS)
+    backToChatList()
+    poll(what = "`Open to connect` gone from bob's row") { "Open to connect" !in alice.chatList.rowTexts("bob") }
+  }
+
+  @Test fun preparedContactAddressSendRequestWithMessage() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    val address = bob.createAddress(autoAccept = false)
+    alice.chatList.row("Private notes")
+    val chat = openNewChatFromSearch(address, "bob")
+    poll(what = "the banner `Tap Connect to send request`, a message field and `Connect`") {
+      seesText("Tap Connect to send request") && exists(Ui.Chat.Message) && exists(Ui.Chat.Connect) && "Connect" in textsOf(Ui.Chat.Connect)
+    }
+    click(Ui.Chat.Connect)
+    poll(what = "`Send contact request?` with `Send request without message` and `Add message`") {
+      seesText("Send contact request?") && exists(Ui.Alert.Confirm(Ui.AlertSource.Shared)) &&
+        "Send request without message" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && "Add message" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the alert to close with `Connect` still shown") { !seesText("Send contact request?") && exists(Ui.Chat.Connect) }
+    typeInto(Ui.Chat.Message, "hello")
+    poll(what = "`Connect` hidden and the send button enabled once there is text") { !exists(Ui.Chat.Connect) && isEnabled(Ui.Chat.Send) }
+    pressEnter(Ui.Chat.Message)
+    hideKeyboard()
+    poll(what = "`Send contact request?` with `Send request` and `Cancel`") {
+      seesText("Send contact request?") && exists(Ui.Alert.Confirm(Ui.AlertSource.Shared)) &&
+        "Send request" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && "Cancel" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    bob.eventuallyAll(
+      listOf("alice wants to connect to you!", "to accept: /ac alice", "to reject: /rc alice (the sender will NOT be notified)"),
+      messages = listOf("alice> hello"), timeoutMs = CONNECT_TIMEOUT_MS
+    )
+    poll(what = "the message field cleared and `contact should accept…` shown") {
+      editableText(Ui.Chat.Message).isNullOrEmpty() && seesText("contact should accept…")
+    }
+    chat.itemId("hello")
+    bob sends "/ac alice"
+    bob.nextLine().let { check(it.startsWith("alice: accepting contact request")) { "bob's next line after /ac is `$it`, not the acceptance" } }
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`contact should accept…` gone with bob ready") {
+      !seesText("contact should accept…") && (alice.chatList.chat("bob").chatInfo as? ChatInfo.Direct)?.contact?.sndReady == true
+    }
+    chat.send("hi")
+    bob.expectsMessage("alice> hi", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun preparedBotConnect() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    bob.becomeBot()
+    val address = bob.createAddress()
+    alice.chatList.row("Private notes")
+    openNewChatFromSearch(address, "bob")
+    poll(what = "the banner `Tap Connect to use bot` and `Connect` with no message field") {
+      seesText("Tap Connect to use bot") && exists(Ui.Chat.Connect) && "Connect" in textsOf(Ui.Chat.Connect) &&
+        !exists(Ui.Chat.Message) && !seesText("Tap Connect to send request")
+    }
+    backToChatList()
+    poll(what = "`Open to use bot` on bob's row") { alice.chatList.rowTexts("bob").let { "Open to use bot" in it && "Open to connect" !in it } }
+    val chat = alice.chatList.open("bob")
+    click(Ui.Chat.Connect)
+    bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the message field and the `Bot` banner after connecting") {
+      exists(Ui.Chat.Message) && !exists(Ui.Chat.Connect) && seesText("Bot") && !seesText("Tap Connect to use bot")
+    }
+    chat.send("hi")
+    bob.expectsMessage("alice> hi", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun preparedContactIncognitoBeforeConnect() = uiTest {
+    app("alice"); val bob = cli("bob")
+    val link = bob.createOneTimeLink()
+    bob.eventually("and ask them to connect: /c <invitation_link_above>")
+    val aliceId = chatModel.currentUser.value!!.userId
+    openNewChatFromSearch(link, "bob")
+    poll(what = "`Your profile` with alice selected and no `Incognito` option") {
+      seesText("Your profile") && exists(Ui.Chat.PickerUser(aliceId)) && !exists(Ui.Chat.PickerIncognito)
+    }
+    click(Ui.Chat.PickerUser(aliceId))
+    poll(what = "the profile list with `Incognito`") { exists(Ui.Chat.PickerIncognito) }
+    click(Ui.Chat.PickerIncognito)
+    poll(what = "the list collapsed to `Incognito`") { exists(Ui.Chat.PickerIncognito) && !exists(Ui.Chat.PickerUser(aliceId)) }
+    click(Ui.Chat.Connect)
+    val shared = bob.eventuallyMatching(Regex("(\\S+): contact is connected"), CONNECT_TIMEOUT_MS).groupValues[1]
+    assertNotEquals("alice", shared)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the profile picker gone and the message field shown") {
+      !seesText("Your profile") && !exists(Ui.Chat.PickerIncognito) && exists(Ui.Chat.Message)
+    }
+  }
+
+  @Test fun preparedContactChangeProfileBeforeConnect() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    alice.userPicker().profiles().apply { add("alice2"); close() }
+    alice.userPicker().switchTo("alice")
+    val link = bob.createOneTimeLink()
+    bob.eventually("and ask them to connect: /c <invitation_link_above>")
+    val aliceId = chatModel.users.first { it.user.displayName == "alice" }.user.userId
+    val alice2Id = chatModel.users.first { it.user.displayName == "alice2" }.user.userId
+    openNewChatFromSearch(link, "bob")
+    val bobChatId = chatModel.chatId.value
+    poll(what = "the picker with alice selected") { exists(Ui.Chat.PickerUser(aliceId)) && !exists(Ui.Chat.PickerUser(alice2Id)) }
+    click(Ui.Chat.PickerUser(aliceId))
+    poll(what = "alice2 in the profile list") { exists(Ui.Chat.PickerUser(alice2Id)) }
+    click(Ui.Chat.PickerUser(alice2Id))
+    poll(what = "alice2 active with bob's prepared chat still open and selected in the picker") {
+      chatModel.currentUser.value?.userId == alice2Id && chatModel.chatId.value == bobChatId &&
+        exists(Ui.Chat.PickerUser(alice2Id)) && !exists(Ui.Chat.PickerUser(aliceId))
+    }
+    click(Ui.Chat.Connect)
+    assertEquals("alice2: contact is connected", bob.nextLine(CONNECT_TIMEOUT_MS))
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ProfileEditTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ProfileEditTest.kt
new file mode 100644
index 0000000000..3ef91e3677
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ProfileEditTest.kt
@@ -0,0 +1,136 @@
+package chat.simplex.app.ui.main
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.labelled
+import chat.simplex.app.ui.harness.leaveProfileEditorExpectingSaveAlert
+import chat.simplex.app.ui.harness.profileEditorSave
+import chat.simplex.app.ui.harness.setFullNameViaApi
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+class ProfileEditTest : UiTest() {
+  @Test fun editProfileBioAndFullName() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.profile()
+    poll(what = "the profile editor with `Bio:` and without `Full name:`") {
+      exists(Ui.Profile.Bio) && exists(Ui.Profile.Save) && seesText("Bio:") && !exists(Ui.Profile.FullName) && !seesText("Full name:")
+    }
+    check(!isEnabled(Ui.Profile.Save)) { "`Save and notify contacts` is enabled before any change" }
+    typeInto(Ui.Profile.Bio, "loves cats")
+    profileEditorSave()
+    bob.eventually("contact alice updated bio: loves cats", CONNECT_TIMEOUT_MS)
+    poll(what = "the profile editor to close after saving") { !exists(Ui.Profile.Save) }
+
+    setFullNameViaApi("Alice Smith")
+    bob.eventually("contact alice updated full name: Alice Smith", CONNECT_TIMEOUT_MS)
+    alice.profile()
+    poll(what = "`Full name:` with `Alice Smith` and the saved bio") {
+      seesText("Full name:") && editableText(Ui.Profile.FullName) == "Alice Smith" && editableText(Ui.Profile.Bio) == "loves cats"
+    }
+    replaceText(Ui.Profile.FullName, "Alice Jones")
+    profileEditorSave()
+    bob.eventually("contact alice updated full name: Alice Jones", CONNECT_TIMEOUT_MS)
+    poll(what = "the profile editor to close and the full name saved") {
+      !exists(Ui.Profile.Save) && chatModel.currentUser.value?.profile?.fullName == "Alice Jones"
+    }
+  }
+
+  @Test fun editProfileUnsavedChangesAlertExitAndSave() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.profile()
+    replaceText(Ui.Profile.Name, "carol")
+    leaveProfileEditorExpectingSaveAlert()
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the profile editor closed with alice unchanged") { !exists(Ui.Profile.Name) && chatModel.currentUser.value?.displayName == "alice" }
+
+    alice.profile()
+    poll(what = "the profile editor showing `alice` again") { editableText(Ui.Profile.Name) == "alice" }
+    replaceText(Ui.Profile.Name, "alice2")
+    leaveProfileEditorExpectingSaveAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    bob.eventually("contact alice changed to alice2", CONNECT_TIMEOUT_MS)
+    poll(what = "the profile editor closed with alice2 as the current user") { !exists(Ui.Profile.Name) && chatModel.currentUser.value?.displayName == "alice2" }
+  }
+
+  @Test fun editProfileInvalidNameDisablesSave() = uiTest {
+    val alice = app("alice")
+    alice.userPicker().profiles().apply { add("work"); close() }
+    alice.userPicker().switchTo("alice")
+    alice.profile()
+    poll(what = "the profile editor with `alice`") { editableText(Ui.Profile.Name) == "alice" && exists(Ui.Profile.Save) }
+    check(!isEnabled(Ui.Profile.Save) && !exists(NAME_INVALID) && !exists(BIO_INVALID)) { "Save is enabled, or an error icon is shown, before any change" }
+
+    replaceText(Ui.Profile.Name, "alice2")
+    poll(what = "Save enabled for a new valid name") { isEnabled(Ui.Profile.Save) }
+    replaceText(Ui.Profile.Name, "alice")
+    poll(what = "Save disabled again with the name changed back") { !isEnabled(Ui.Profile.Save) }
+    replaceText(Ui.Profile.Name, "   ")
+    poll(what = "Save disabled for a blank name") { editableText(Ui.Profile.Name) == "   " && !isEnabled(Ui.Profile.Save) }
+    replaceText(Ui.Profile.Name, "?alice2")
+    poll(what = "the invalid-name icon and Save disabled for `?alice2`") { exists(NAME_INVALID) && !isEnabled(Ui.Profile.Save) }
+    click(NAME_INVALID)
+    poll(what = "the `Invalid name!` alert offering `alice2`") { seesText("Invalid name!") && seesText("Correct name to alice2?") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the name corrected to `alice2` with Save enabled") {
+      editableText(Ui.Profile.Name) == "alice2" && !exists(NAME_INVALID) && !seesText("Invalid name!") && isEnabled(Ui.Profile.Save)
+    }
+
+    typeInto(Ui.Profile.Bio, "x".repeat(MAX_BIO + 1))
+    poll(what = "the bio error icon and Save disabled for a ${MAX_BIO + 1}-character bio") { exists(BIO_INVALID) && !isEnabled(Ui.Profile.Save) }
+    click(BIO_INVALID)
+    poll(what = "the `Bio too large` alert") { seesText("Bio too large") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the alert closed") { !seesText("Bio too large") }
+    replaceText(Ui.Profile.Bio, "x".repeat(MAX_BIO))
+    poll(what = "no bio error icon and Save enabled for a $MAX_BIO-character bio") { !exists(BIO_INVALID) && isEnabled(Ui.Profile.Save) }
+
+    replaceText(Ui.Profile.Name, "work")
+    poll(what = "Save enabled for the other profile's name") { !exists(NAME_INVALID) && isEnabled(Ui.Profile.Save) }
+    profileEditorSave()
+    poll(what = "the `Duplicate display name!` alert") {
+      seesText("Duplicate display name!") && seesText("You already have a chat profile with the same display name. Please choose another name.")
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the editor kept open with alice unchanged") {
+      !seesText("Duplicate display name!") && exists(Ui.Profile.Save) &&
+        chatModel.currentUser.value?.let { it.displayName == "alice" && it.shortDescr == null } == true
+    }
+  }
+
+  @Test fun editProfileDescription() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.profile()
+    poll(what = "`Add description` in the profile editor") { labelled(Ui.Profile.Description, "Add description") && !exists(Ui.Profile.DescriptionText) }
+    click(Ui.Profile.Description)
+    poll(what = "the description editor in place of the profile fields") { exists(Ui.Profile.DescriptionText) && !exists(Ui.Profile.Save) }
+    typeInto(Ui.Profile.DescriptionText, DESCRIPTION)
+    hideKeyboard()
+    goBack()
+    poll(what = "the profile fields back with `Edit description`") {
+      labelled(Ui.Profile.Description, "Edit description") && exists(Ui.Profile.Save) && !exists(Ui.Profile.DescriptionText)
+    }
+    profileEditorSave()
+    bob.eventually("contact alice updated description: $DESCRIPTION", CONNECT_TIMEOUT_MS)
+    poll(what = "the profile editor closed with the description saved") {
+      !exists(Ui.Profile.Save) && chatModel.currentUser.value?.profileDescription == DESCRIPTION
+    }
+    alice.profile()
+    poll(what = "`Edit description` after reopening") { labelled(Ui.Profile.Description, "Edit description") }
+    click(Ui.Profile.Description)
+    poll(what = "the saved description in the editor") { editableText(Ui.Profile.DescriptionText) == DESCRIPTION }
+  }
+
+  private companion object {
+    val NAME_INVALID = Ui.Profile.Name.part("invalid")
+    val BIO_INVALID = Ui.Profile.Bio.part("invalid")
+    const val MAX_BIO = 160
+    const val DESCRIPTION = "I like long walks"
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ServersSummaryTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ServersSummaryTest.kt
new file mode 100644
index 0000000000..ece070896c
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/ServersSummaryTest.kt
@@ -0,0 +1,94 @@
+package chat.simplex.app.ui.main
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.isCount
+import chat.simplex.app.ui.harness.localSmpServer
+import chat.simplex.app.ui.harness.openServersSummary
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.chatlist.PresentedUserCategory
+import org.junit.Test
+
+class ServersSummaryTest : UiTest() {
+  @Test fun serversSummaryShowsLocalSmpConnected() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice hi"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `hi` on his row") { "hi" in alice.chatList.rowTexts("bob") }
+    val host = localSmpServer().hostnames.first()
+    check(!seesText("Servers info")) { "`Servers info` is shown before the indicator is clicked" }
+    val summary = openServersSummary()
+    poll(what = "the local SMP server under `Connected servers` with sent and received messages and an active connection") {
+      seesText("Connected servers") && exists(Ui.ServersSummary.SmpServer(host)) &&
+        summary.value("Messages sent").isCount() && summary.value("Messages received").isCount() && summary.value("Active connections").isCount()
+    }
+    click(Ui.ServersSummary.SmpServer(host))
+    poll(what = "`SMP server` with the local server's address, statistics and active connection") {
+      seesText("SMP server") && seesText("Server address") && !seesText("Connected servers") && seesText(host, substring = true) &&
+        summary.value("Messages received").isCount() && summary.value("Active connections").isCount()
+    }
+  }
+
+  @Test fun serversSummaryResetStatsAndReconnectAll() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice hi"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `hi` on his row") { "hi" in alice.chatList.rowTexts("bob") }
+    val summary = openServersSummary()
+    poll(what = "messages sent and received counted") { summary.value("Messages sent").isCount() && summary.value("Messages received").isCount() }
+    click(Ui.ServersSummary.ResetStats)
+    poll(what = "the `Reset all statistics?` alert with `Reset`") {
+      seesText("Reset all statistics?") && seesText("Servers statistics will be reset - this cannot be undone!") &&
+        "Reset" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "`-` for messages sent and received after the reset") { summary.value("Messages sent") == "-" && summary.value("Messages received") == "-" }
+    summary.details()
+    poll(what = "no subscriptions counted since the reset") { summary.subscribed() == "-" }
+    summary.backToSummary()
+    click(Ui.ServersSummary.ReconnectAll)
+    poll(what = "the `Reconnect servers?` alert") {
+      seesText("Reconnect servers?") && seesText("Reconnect all connected servers to force message delivery. It uses additional traffic.") &&
+        exists(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the `Reconnect servers?` alert to close") { !seesText("Reconnect servers?") }
+    bob sends "@alice after reconnect"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's message counted as received after the reconnect") { summary.value("Messages received").isCount() }
+    check(!seesText("Error reconnecting servers")) { "reconnecting all servers showed an error" }
+    summary.details()
+    poll(what = "the resubscription after the reconnect counted under `Subscribed`") { summary.subscribed().isCount() }
+  }
+
+  @Test fun serversSummaryAllVsCurrentProfile() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice hi"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's `hi` on his row") { "hi" in alice.chatList.rowTexts("bob") }
+    val host = localSmpServer().hostnames.first()
+    openServersSummary()
+    poll(what = "the local SMP server listed for the only profile, without `Showing info for`") {
+      exists(Ui.ServersSummary.SmpServer(host)) && !exists(Ui.ServersSummary.UserCategory) && !seesText(SHOWING_INFO_FOR)
+    }
+    goBack()
+    poll(what = "`Servers info` to close") { !seesText("Servers info") }
+    alice.userPicker().profiles().apply { add("work"); close() }
+    val summary = openServersSummary()
+    poll(what = "`Showing info for` `All profiles` listing the local server and alice's sent messages") {
+      seesText(SHOWING_INFO_FOR) && "All profiles" in textsOf(Ui.ServersSummary.UserCategory) &&
+        exists(Ui.ServersSummary.SmpServer(host)) && seesText("Connected servers") && summary.value("Messages sent").isCount()
+    }
+    click(Ui.ServersSummary.UserCategory)
+    click(Ui.ServersSummary.UserCategory.option(PresentedUserCategory.CURRENT_USER))
+    poll(what = "`Current profile` for the connection-less work profile: no servers and `-` for messages sent") {
+      "Current profile" in textsOf(Ui.ServersSummary.UserCategory) && !exists(Ui.ServersSummary.SmpServer(host)) &&
+        !seesText("Connected servers") && summary.value("Messages sent") == "-"
+    }
+  }
+
+  private companion object {
+    const val SHOWING_INFO_FOR = "Showing info for"
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/UserPickerTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/UserPickerTest.kt
index 4e951dfb5b..1cf4da6faf 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/UserPickerTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/main/UserPickerTest.kt
@@ -1,11 +1,22 @@
 package chat.simplex.app.ui.main
 
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.closeTopScreen
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.labelled
+import chat.simplex.app.ui.harness.pickerRowInert
+import chat.simplex.app.ui.harness.pickerRowOpens
+import chat.simplex.app.ui.harness.unreadBadge
+import chat.simplex.app.ui.harness.userIdOf
 import chat.simplex.common.model.GroupProfile
+import chat.simplex.common.platform.appPlatform
 import chat.simplex.common.platform.chatController
 import chat.simplex.common.platform.chatModel
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.database.stopChatAsync
 import kotlinx.coroutines.runBlocking
+import org.junit.Ignore
 import org.junit.Test
 
 class UserPickerTest : UiTest() {
@@ -21,4 +32,81 @@ class UserPickerTest : UiTest() {
     alice.userPicker().switchTo("alice")
     alice.chatList.row("team")
   }
+
+  @Test fun userPickerUnreadBadgePerUser() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    alice.userPicker().profiles().apply { add("work"); close() }
+    connect(bob)
+    val aliceId = userIdOf("alice"); val workId = userIdOf("work")
+    alice.userPicker().switchTo("alice")
+    alice.userPicker()
+    poll(what = "work's avatar in the user picker without a badge") { exists(Ui.UserPicker.User(workId)) && unreadBadge(Ui.UserPicker.User(workId)) == null }
+    bob sends "@work one"
+    bob sends "@work two"
+    bob sends "@alice three"
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "badge 2 on work's avatar") { unreadBadge(Ui.UserPicker.User(workId)) == "2" }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's message unread in alice's chat") { alice.chatList.chat("bob").chatStats.unreadCount == 1 }
+    check(unreadBadge(Ui.UserPicker.User(aliceId)) == null) { "the active user alice has an unread badge in the user picker" }
+    escape()
+    poll(what = "the user picker to close") { !exists(Ui.UserPicker.Sheet) }
+    alice.userPicker().switchTo("work")
+    alice.userPicker()
+    poll(what = "badge 1 on alice's avatar and none on the active work's") {
+      unreadBadge(Ui.UserPicker.User(aliceId)) == "1" && exists(Ui.UserPicker.User(workId)) && unreadBadge(Ui.UserPicker.User(workId)) == null
+    }
+    click(Ui.UserPicker.Profiles)
+    poll(what = "badge 1 on alice's row in the profiles list and none on work's") {
+      unreadBadge(Ui.Profiles.User(aliceId)) == "1" && exists(Ui.Profiles.User(workId)) && unreadBadge(Ui.Profiles.User(workId)) == null
+    }
+  }
+
+  @Test fun userPickerOpensAndShowsCurrentUser() = uiTest {
+    val alice = app("alice")
+    val aliceId = userIdOf("alice")
+    alice.userPicker()
+    poll(what = "the user picker with alice and the rows `Create SimpleX address`, `Chat preferences`, `Your chat profiles`, `$DEVICES` and `Settings`") {
+      labelled(Ui.UserPicker.User(aliceId), "alice") && labelled(Ui.UserPicker.Address, "Create SimpleX address") &&
+        labelled(Ui.UserPicker.ChatPreferences, "Chat preferences") && labelled(Ui.UserPicker.Profiles, "Your chat profiles") &&
+        labelled(devicesRow, DEVICES) && labelled(Ui.UserPicker.Settings, "Settings")
+    }
+    click(Ui.UserPicker.User(aliceId))
+    poll(what = "`Your current profile` with alice, and the user picker closed") {
+      seesText("Your current profile") && editableText(Ui.Profile.Name) == "alice" && !exists(Ui.UserPicker.Sheet)
+    }
+    closeTopScreen("the profile editor") { !exists(Ui.Profile.Name) }
+
+    pickerRowOpens(alice, Ui.UserPicker.ChatPreferences, "`Your preferences`") { seesText("Your preferences") }
+    closeTopScreen("`Your preferences`") { !seesText("Your preferences") }
+
+    pickerRowOpens(alice, Ui.UserPicker.Settings, "`Your settings`") { seesText("Your settings") && exists(Ui.Settings.Appearance) }
+    closeTopScreen("`Your settings`") { !exists(Ui.Settings.Appearance) }
+
+    if (appPlatform.isDesktop) {
+      pickerRowOpens(alice, devicesRow, "`Link a mobile` with `This device name`") { seesText("This device name") }
+    }
+  }
+
+  @Ignore("plan §15.4 item 55: disabled user picker rows are merged into the picker's clickable container, so the harness cannot find them")
+  @Test fun userPickerDisabledWhenChatStopped() = uiTest {
+    val alice = app("alice")
+    val aliceId = userIdOf("alice")
+    pickerRowOpens(alice, Ui.UserPicker.ChatPreferences, "`Your preferences` while chat runs") { seesText("Your preferences") }
+    closeTopScreen("`Your preferences`") { !seesText("Your preferences") }
+
+    runBlocking { stopChatAsync(chatModel) }
+    poll(what = "chat stopped") { chatModel.chatRunning.value == false && exists(Ui.ChatList.Stopped) }
+    pickerRowInert(alice, Ui.UserPicker.User(aliceId), "`Your current profile`") { exists(Ui.Profile.Name) }
+    pickerRowInert(alice, Ui.UserPicker.Address, "the address screen") { exists(Ui.Address.Create) || exists(Ui.Address.Share) }
+    pickerRowInert(alice, Ui.UserPicker.ChatPreferences, "`Your preferences`") { seesText("Your preferences") }
+    pickerRowInert(alice, Ui.UserPicker.Profiles, "`Your chat profiles`") { exists(Ui.Profiles.Add) }
+    pickerRowInert(alice, devicesRow, "`$DEVICES`") { seesText("This device name") || seesText("Connect to desktop") }
+    pickerRowOpens(alice, Ui.UserPicker.Settings, "`Your settings` with chat stopped") { seesText("Your settings") && exists(Ui.Settings.Appearance) }
+  }
+
+  private companion object {
+    val DEVICES: String get() = if (appPlatform.isDesktop) "Link a mobile" else "Use from desktop"
+  }
+
+  private val devicesRow get() = if (appPlatform.isAndroid) Ui.UserPicker.UseFromDesktop else Ui.UserPicker.LinkMobile
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/AppearanceTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/AppearanceTest.kt
index 114ceefc3f..32eac85221 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/AppearanceTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/AppearanceTest.kt
@@ -1,11 +1,41 @@
 package chat.simplex.app.ui.settings
 
+import androidx.compose.ui.graphics.Color
+import chat.simplex.app.ui.harness.StoredThemes
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.closeAppearance
+import chat.simplex.app.ui.harness.currentWallpaperPreset
+import chat.simplex.app.ui.harness.customizeTheme
+import chat.simplex.app.ui.harness.jpegFile
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.model.yaml
 import chat.simplex.common.platform.appPlatform
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.platform.getWallpaperFilePath
+import chat.simplex.common.platform.readThemeOverrides
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import chat.simplex.common.ui.theme.BlackColorPalette
 import chat.simplex.common.ui.theme.CurrentColors
 import chat.simplex.common.ui.theme.DefaultTheme
+import chat.simplex.common.ui.theme.ThemeColor
+import chat.simplex.common.ui.theme.ThemeManager
+import chat.simplex.common.ui.theme.ThemeOverrides
+import chat.simplex.common.views.helpers.AlertManager
+import chat.simplex.common.views.helpers.PresetWallpaper
+import chat.simplex.common.views.helpers.WallpaperType
+import kotlinx.coroutines.runBlocking
 import org.junit.Assert.assertEquals
 import org.junit.Test
+import java.io.File
+
+private const val CURRENT_THEME = "CurrentTheme"
+private const val SYSTEM_DARK_THEME = "SystemDarkTheme"
+private const val ONE_HAND_UI = "OneHandUI"
+private const val RED_HEX = "#ffff0000"
+private val FLOWERS = PresetWallpaper.FLOWERS.filename
+private val SCHOOL = PresetWallpaper.SCHOOL.filename
 
 class AppearanceTest : UiTest() {
   @Test fun appearance_settingsPersistAcrossRestart() = uiTest {
@@ -28,4 +58,164 @@ class AppearanceTest : UiTest() {
     assertEquals(1.2f, after.fontScale, 0.001f)
     if (appPlatform.isDesktop) assertEquals(1.5f, after.zoom, 0.001f)
   }
+
+  @Test fun appearance_colorMode_systemLightDark() = uiTest {
+    val appearance = app("alice").appearance()
+    check(CurrentColors.value.name == DefaultTheme.SYSTEM_THEME_NAME && storedSetting(CURRENT_THEME) != "LIGHT" && storedSetting(SYSTEM_DARK_THEME).let { it != "BLACK" && it != "SIMPLEX" }) {
+      "the color mode before the change: ${CurrentColors.value.name}, stored ${storedSetting(CURRENT_THEME)} / ${storedSetting(SYSTEM_DARK_THEME)}"
+    }
+    appearance.colorMode("LIGHT")
+    poll(what = "the light theme applied and stored") {
+      CurrentColors.value.base == DefaultTheme.LIGHT && storedSetting(CURRENT_THEME) == "LIGHT" && appearance.colorModeText() == "Light"
+    }
+    appearance.darkModeColors(DefaultTheme.BLACK.themeName)
+    poll(what = "Black stored as the dark mode colors") { storedSetting(SYSTEM_DARK_THEME) == "BLACK" }
+    check(CurrentColors.value.base == DefaultTheme.LIGHT && storedSetting(CURRENT_THEME) == "LIGHT") {
+      "choosing the dark mode colors in light mode changed the theme: ${CurrentColors.value.name}, stored ${storedSetting(CURRENT_THEME)}"
+    }
+    appearance.colorMode("DARK")
+    poll(what = "dark mode applied with the Black colors") {
+      CurrentColors.value.base == DefaultTheme.BLACK && CurrentColors.value.colors.background == BlackColorPalette.background &&
+        storedSetting(CURRENT_THEME) == "BLACK" && appearance.colorModeText() == "Dark" && appearance.darkModeColorsText() == "Black"
+    }
+    appearance.darkModeColors(DefaultTheme.SIMPLEX.themeName)
+    poll(what = "the SimpleX colors applied at once in dark mode") {
+      CurrentColors.value.base == DefaultTheme.SIMPLEX && storedSetting(CURRENT_THEME) == "SIMPLEX" && storedSetting(SYSTEM_DARK_THEME) == "SIMPLEX"
+    }
+    appearance.colorMode("null")
+    poll(what = "the System color mode applied and stored") {
+      CurrentColors.value.name == DefaultTheme.SYSTEM_THEME_NAME && storedSetting(CURRENT_THEME) == DefaultTheme.SYSTEM_THEME_NAME && appearance.colorModeText() == "System"
+    }
+  }
+
+  @Test fun appearance_wallpaperPreset_select() = uiTest {
+    val appearance = app("alice").appearance()
+    appearance.colorMode("LIGHT")
+    poll(what = "the light theme with the default wallpaper") { CurrentColors.value.base == DefaultTheme.LIGHT && currentWallpaperPreset() == SCHOOL }
+    check(StoredThemes.active(DefaultTheme.LIGHT)?.wallpaper?.preset != FLOWERS) { "the flowers wallpaper is stored before it was chosen" }
+    click(Ui.Appearance.Wallpaper(FLOWERS))
+    poll(what = "the flowers wallpaper applied and stored for the light theme") {
+      currentWallpaperPreset() == FLOWERS && StoredThemes.active(DefaultTheme.LIGHT)?.wallpaper?.preset == FLOWERS
+    }
+    appearance.colorMode("DARK")
+    poll(what = "the dark theme with its default wallpaper") { CurrentColors.value.base == DefaultTheme.DARK && currentWallpaperPreset() == SCHOOL }
+    check(readThemeOverrides().none { it.base == DefaultTheme.DARK && it.wallpaper?.preset == FLOWERS }) { "the light theme's wallpaper was stored for the dark theme" }
+    appearance.colorMode("LIGHT")
+    poll(what = "the flowers wallpaper in the light theme again") { CurrentColors.value.base == DefaultTheme.LIGHT && currentWallpaperPreset() == FLOWERS }
+    restart()
+    poll(what = "the flowers wallpaper in the light theme after a restart") { CurrentColors.value.base == DefaultTheme.LIGHT && currentWallpaperPreset() == FLOWERS }
+  }
+
+  @Test fun appearance_themeDestination_perUser() = uiTest {
+    val alice = app("alice")
+    val userId = chatModel.currentUser.value!!.userId
+    val dark = !CurrentColors.value.colors.isLight
+    val yamlBefore = StoredThemes.yamlBytes()
+    check(coreUiThemesPreset(userId, dark) == null) { "alice has a theme in the core before Apply to" }
+    alice.appearance()
+    click(Ui.Appearance.ApplyTo)
+    click(Ui.Appearance.ApplyTo.option(userId))
+    poll(what = "Apply to showing alice") { textOf(Ui.Appearance.ApplyTo) == "alice" }
+    click(Ui.Appearance.Wallpaper(FLOWERS))
+    poll(what = "the flowers wallpaper set as alice's theme and the save finished") {
+      chatModel.currentUser.value?.uiThemes?.preferredMode(dark)?.wallpaper?.preset == FLOWERS && UiIdle.inFlight().isEmpty()
+    }
+    assertEquals("alice's wallpaper in the core", FLOWERS, coreUiThemesPreset(userId, dark))
+    check(StoredThemes.yamlBytes().contentEquals(yamlBefore) && readThemeOverrides().none { it.wallpaper?.preset == FLOWERS }) {
+      "the per-user wallpaper changed the app theme: ${readThemeOverrides()}"
+    }
+  }
+
+  @Test fun appearance_reachableAppToolbars() = uiTest {
+    val alice = app("alice")
+    poll(what = "the new-chat button in the toolbar and no floating button") { exists(Ui.ChatList.NewChat) && !exists(Ui.ChatList.NewChatFab) }
+    check(storedSetting(ONE_HAND_UI) != "false") { "Reachable app toolbars is stored as off before the change" }
+    alice.appearance()
+    click(Ui.Appearance.OneHandUI)
+    poll(what = "Reachable app toolbars stored as off") { storedSetting(ONE_HAND_UI) == "false" }
+    closeAppearance()
+    poll(what = "the floating new-chat button instead of the toolbar button") { exists(Ui.ChatList.NewChatFab) && !exists(Ui.ChatList.NewChat) }
+    alice.appearance()
+    click(Ui.Appearance.OneHandUI)
+    poll(what = "Reachable app toolbars stored as on") { storedSetting(ONE_HAND_UI) == "true" }
+    closeAppearance()
+    poll(what = "the toolbar new-chat button again") { exists(Ui.ChatList.NewChat) && !exists(Ui.ChatList.NewChatFab) }
+  }
+
+  @Test fun customizeTheme_editInterfaceColor() = uiTest {
+    val alice = app("alice")
+    enableDeveloperToolsViaApi()
+    val base = CurrentColors.value.base
+    val defaultAccent = CurrentColors.value.colors.primary
+    check(defaultAccent != Color.Red && StoredThemes.active(base)?.colors?.primary == null) { "the accent is red or stored before the change" }
+    customizeTheme(alice)
+    check(!exists(Ui.Appearance.ResetColors)) { "Reset colors is offered before any color was changed" }
+    click(Ui.Appearance.Accent)
+    replaceText(Ui.Appearance.ColorHex, "#ff0000")
+    poll(what = "the red accent applied and stored in themes.yaml") { CurrentColors.value.colors.primary == Color.Red && StoredThemes.active(base)?.colors?.primary == RED_HEX }
+    escape()
+    poll(what = "Customize theme with Reset colors") { exists(Ui.Appearance.ResetColors) && !exists(Ui.Appearance.ColorHex) }
+    click(Ui.Appearance.ResetColors)
+    poll(what = "the default accent applied, removed from themes.yaml, and Reset colors gone") {
+      CurrentColors.value.colors.primary == defaultAccent && StoredThemes.active(base)?.colors?.primary == null && !exists(Ui.Appearance.ResetColors)
+    }
+  }
+
+  @Test fun customizeTheme_exportImportTheme() = uiTest {
+    val alice = app("alice")
+    val base = CurrentColors.value.base
+    setAccentViaApi(base, Color.Red)
+    customizeTheme(alice)
+    val exported = File(exchangeDir(), "exported.theme")
+    check(!exported.exists()) { "the export file exists before the export" }
+    saveFileAs(exported) { click(Ui.Appearance.ExportTheme) }
+    poll(what = "the exported theme file with the accent") { exported.exists() && "accent" in exported.readText() }
+    val text = exported.readText()
+    val theme = yaml.decodeFromString(ThemeOverrides.serializer(), text)
+    check("themeId" !in text && theme.base == base && theme.colors.primary == RED_HEX) { "exported theme:\n$text" }
+    click(Ui.Appearance.ResetColors)
+    poll(what = "the accent reset before the import") { CurrentColors.value.colors.primary != Color.Red && StoredThemes.active(base)?.colors?.primary == null }
+    openFile(exported) { click(Ui.Appearance.ImportTheme) }
+    poll(what = "the imported red accent applied and stored, with its base theme selected") {
+      CurrentColors.value.colors.primary == Color.Red && StoredThemes.active(base)?.colors?.primary == RED_HEX && storedSetting(CURRENT_THEME) == base.themeName
+    }
+    val yamlBefore = StoredThemes.yamlBytes()
+    val invalid = File(exchangeDir(), "invalid.theme").apply { writeText("colors: [accent") }
+    openFile(invalid) { click(Ui.Appearance.ImportTheme) }
+    poll(what = "the Import theme error alert") { seesText("Import theme error") && AlertManager.shared.hasAlertsShown() }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the Import theme error alert to close") { !AlertManager.shared.hasAlertsShown() }
+    check(StoredThemes.yamlBytes().contentEquals(yamlBefore) && CurrentColors.value.colors.primary == Color.Red) { "the invalid theme changed the stored themes" }
+  }
+
+  @Test fun appearance_wallpaperImage_import() = uiTest {
+    val alice = app("alice")
+    alice.appearance()
+    val base = CurrentColors.value.base
+    val image = jpegFile("wallpaper.jpg")
+    waitFor(Ui.Appearance.ColorMode)
+    check(CurrentColors.value.wallpaper.type !is WallpaperType.Image && StoredThemes.active(base)?.wallpaper?.imageFile == null && !exists(Ui.Appearance.RemoveImage)) {
+      "an image wallpaper or `Remove image` before the import: ${CurrentColors.value.wallpaper.type}"
+    }
+    scrollTo(Ui.Appearance.WallpaperImage)
+    openFile(image) { click(Ui.Appearance.WallpaperImage) }
+    var name: String? = null
+    poll(what = "the image applied as the wallpaper, copied to the wallpapers folder, stored for the theme, with `Remove image`") {
+      name = (CurrentColors.value.wallpaper.type as? WallpaperType.Image)?.filename
+      name?.let { n -> File(getWallpaperFilePath(n)).let { it.exists() && it.readBytes().contentEquals(image.readBytes()) } && StoredThemes.active(base)?.wallpaper?.imageFile == n } == true &&
+        exists(Ui.Appearance.RemoveImage)
+    }
+    val copy = File(getWallpaperFilePath(name!!))
+    click(Ui.Appearance.RemoveImage)
+    poll(what = "the image wallpaper gone, the copied image deleted and the theme without it") {
+      CurrentColors.value.wallpaper.type !is WallpaperType.Image && !copy.exists() && StoredThemes.active(base)?.wallpaper?.imageFile == null && !exists(Ui.Appearance.RemoveImage)
+    }
+  }
+
+  private fun enableDeveloperToolsViaApi() = appPrefs.developerTools.set(true)
+
+  private fun setAccentViaApi(base: DefaultTheme, color: Color) = ThemeManager.saveAndApplyThemeColor(base, ThemeColor.PRIMARY, color)
+
+  private fun coreUiThemesPreset(userId: Long, dark: Boolean): String? =
+    runBlocking { chatController.listUsers(null) }.first { it.user.userId == userId }.user.uiThemes?.preferredMode(dark)?.wallpaper?.preset
 }
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/ChatDataTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/ChatDataTest.kt
new file mode 100644
index 0000000000..13e3ce2685
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/ChatDataTest.kt
@@ -0,0 +1,315 @@
+package chat.simplex.app.ui.settings
+
+import chat.simplex.app.ui.harness.App
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.DB_WORK_TIMEOUT_MS
+import chat.simplex.app.ui.harness.KnownAppIssue
+import chat.simplex.app.ui.harness.PassphraseScreen
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.chatData
+import chat.simplex.app.ui.harness.chatRunningInCore
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.onboarding
+import chat.simplex.app.ui.harness.typeSecret
+import chat.simplex.app.ui.harness.userIdOf
+import chat.simplex.common.model.API
+import chat.simplex.common.model.CC
+import chat.simplex.common.model.CIFileStatus
+import chat.simplex.common.model.CR
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.model.ChatItemTTL
+import chat.simplex.common.platform.appFilesDir
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import chat.simplex.common.views.onboarding.OnboardingStage
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import java.io.File
+import java.util.zip.ZipFile
+
+class ChatDataTest : UiTest() {
+  @Test fun chatData_ttlDecrease_alertConfirm() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice $KEPT"
+    poll(what = "bob's first message on the row") { KEPT in alice.chatList.rowTexts("bob") }
+    bob sends "@alice $EXPIRED"
+    poll(what = "bob's second message on the row") { EXPIRED in alice.chatList.rowTexts("bob") }
+    backdateItemViaSql(alice.chatList.chat("bob").chatItems.last { it.content.text == EXPIRED }.id)
+    val data = chatData(alice)
+    check(seesText("This setting applies to messages in your current chat profile alice.")) { "the Messages footer does not name alice" }
+    check(data.ttlText() == "never" && coreTtl() == ChatItemTTL.None) { "TTL before the change: picker ${data.ttlText()}, core ${coreTtl()}" }
+    data.selectTtl(ChatItemTTL.Day)
+    awaitDeletionAlert()
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the picker back to never after Cancel") { !AlertManager.shared.hasAlertsShown() && data.ttlText() == "never" }
+    check(coreTtl() == ChatItemTTL.None) { "Cancel applied the TTL: ${coreTtl()}" }
+    data.selectTtl(ChatItemTTL.Day)
+    awaitDeletionAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "1 day in the picker and in the core") { data.ttlText() == "1 day" && coreTtl() == ChatItemTTL.Day }
+    data.selectTtl(ChatItemTTL.Week)
+    poll(what = "1 week in the picker and in the core") { data.ttlText() == "1 week" && coreTtl() == ChatItemTTL.Week }
+    check(!AlertManager.shared.hasAlertsShown()) { "a longer TTL asked for confirmation" }
+    data.close()
+    poll(what = "bob's row previewing the kept message") { alice.chatList.rowTexts("bob").let { KEPT in it && EXPIRED !in it } }
+    val chat = alice.chatList.open("bob")
+    poll(what = "bob's chat with the kept message and without the expired one") { chat.itemTexts().let { KEPT in it && EXPIRED !in it } }
+  }
+
+  @Test fun chatData_ttlPerProfile() = uiTest {
+    val alice = app("alice")
+    val aliceId = userIdOf("alice")
+    var data = chatData(alice)
+    check(footerNames("alice") && data.ttlText() == "never" && DELETE_ALL_FILES in textsOf(Ui.Database.DeleteFiles)) {
+      "Chat data with one profile: TTL ${data.ttlText()}, files item ${textsOf(Ui.Database.DeleteFiles)}"
+    }
+    data.selectTtl(ChatItemTTL.Week)
+    awaitDeletionAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "1 week for alice in the picker and in the core") { data.ttlText() == "1 week" && coreTtlOf(aliceId) == ChatItemTTL.Week }
+    data.close()
+    alice.userPicker().profiles().apply { add("work"); close() }
+    val workId = userIdOf("work")
+    data = chatData(alice)
+    poll(what = "Chat data for work with its own TTL and the files item for all profiles") {
+      footerNames("work") && data.ttlText() == "never" && DELETE_FILES_ALL_PROFILES in textsOf(Ui.Database.DeleteFiles)
+    }
+    check(coreTtlOf(workId) == ChatItemTTL.None) { "work's TTL in the core: ${coreTtlOf(workId)}" }
+    data.selectTtl(ChatItemTTL.Day)
+    awaitDeletionAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "1 day for work in the picker and in the core") { data.ttlText() == "1 day" && coreTtlOf(workId) == ChatItemTTL.Day }
+    data.close()
+    alice.userPicker().switchTo("alice")
+    data = chatData(alice)
+    poll(what = "Chat data for alice with her TTL, unchanged by work's") {
+      footerNames("alice") && data.ttlText() == "1 week" && DELETE_FILES_ALL_PROFILES in textsOf(Ui.Database.DeleteFiles) && coreTtlOf(aliceId) == ChatItemTTL.Week
+    }
+  }
+
+  @Test fun dbMgmt_stopAndStartChat() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val db = chatData(alice).management()
+    check(seesText("Chat is running") && chatRunningInCore() && storedSetting("ChatStopped") != "true") { "the chat is not running before the stop" }
+    click(Ui.Database.RunChat)
+    awaitStopAlert()
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the chat still running after Cancel") { !AlertManager.shared.hasAlertsShown() && seesText("Chat is running") }
+    check(chatRunningInCore() && storedSetting("ChatStopped") != "true") { "Cancel stopped the chat" }
+    click(Ui.Database.RunChat)
+    awaitStopAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the chat stopped on screen, on disk and in the core") {
+      seesText("Chat is stopped") && seesText(MOST_RECENT_DB, substring = true) && storedSetting("ChatStopped") == "true" && !chatRunningInCore()
+    }
+    bob sends "@alice $WHILE_STOPPED"
+    click(Ui.Database.RunChat)
+    poll(what = "the chat running again on screen, on disk and in the core") {
+      seesText("Chat is running") && !seesText(MOST_RECENT_DB, substring = true) && storedSetting("ChatStopped") == "false" && chatRunningInCore()
+    }
+    db.close()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the message bob sent while the chat was stopped") { WHILE_STOPPED in alice.chatList.rowTexts("bob") }
+    alice.chatList.open("bob").send(BACK_ONLINE)
+    bob.expectsMessage("alice> $BACK_ONLINE", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun dbMgmt_importArchive_restoresData() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice $BEFORE_EXPORT"
+    poll(what = "bob's message before the export") { BEFORE_EXPORT in alice.chatList.rowTexts("bob") }
+    writeNote(alice, NOTE_BEFORE_EXPORT)
+    setLinkPreviewsPrefDirectly(false)
+    check(storedSetting("PrivacyLinkPreviews") == "false") { "link previews are not stored as off before the export" }
+    val zip = File(exchangeDir(), "export.zip")
+    val db = chatData(alice).management()
+    click(Ui.Database.Export)
+    poll(what = "the Set passphrase to export alert") {
+      seesText("Set passphrase to export") && seesText("Database is encrypted using a random passphrase. Please change it before exporting.")
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    waitFor(Ui.DbPassphrase.New)
+    val pass = PassphraseScreen(this)
+    pass.setFirst(PASSPHRASE)
+    pass.close()
+    check(!zip.exists() && seesText("Chat is running")) { "before the export: archive exists ${zip.exists()}, texts ${texts().take(30)}" }
+    saveFileAs(zip) { click(Ui.Database.Export) }
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the archive with both databases at the chosen path") {
+      zip.length() > 0 && ZipFile(zip).use { z -> z.entries().toList().map { it.name }.containsAll(listOf("simplex_v1_chat.db", "simplex_v1_agent.db")) }
+    }
+    poll(what = "the chat left stopped after the export") { seesText("Chat is stopped") }
+    setLinkPreviewsPrefDirectly(true)
+    check(storedSetting("PrivacyLinkPreviews") == "true") { "link previews are not stored as on after the export" }
+    click(Ui.Database.RunChat)
+    poll(what = "the chat running again") { seesText("Chat is running") && chatModel.chatRunning.value == true }
+    db.close()
+    writeNote(alice, NOTE_AFTER_EXPORT)
+    chatData(alice).management()
+    openFile(zip) { click(Ui.Database.Import) }
+    poll(what = "the Import chat database? alert") { seesText("Import chat database?") && "Import" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the Chat database imported alert") { seesText("Chat database imported") && seesText("Restart the app to use imported chat database.") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the passphrase prompt with Save passphrase and open chat") {
+      seesText("Encrypted database") && seesText("Database passphrase is required to open chat.") && "Save passphrase and open chat" in textsOf(Ui.DbError.Open)
+    }
+    check(storedSetting("EncryptedDBPassphrase") == null) { "the import left the old passphrase stored" }
+    typeSecret(Ui.DbError.Passphrase, PASSPHRASE)
+    click(Ui.DbError.Open)
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the Start chat? alert") { seesText("Start chat?") && seesText(START_CHAT_TEXT) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the chat started in the core with bob from the archive listed") { chatRunningInCore() && alice.chatList.shown("bob") }
+    check(storedSetting("PrivacyLinkPreviews") == "false" && storedSetting("ShouldImportAppSettings") == "false" && storedSetting("EncryptedDBPassphrase") != null) {
+      "after the import: PrivacyLinkPreviews=${storedSetting("PrivacyLinkPreviews")}, ShouldImportAppSettings=${storedSetting("ShouldImportAppSettings")}, passphrase stored ${storedSetting("EncryptedDBPassphrase") != null}"
+    }
+    val notes = alice.chatList.open("Private notes")
+    poll(what = "the notes from the archive, without the note written after the export") {
+      notes.itemTexts().let { NOTE_BEFORE_EXPORT in it && NOTE_AFTER_EXPORT !in it }
+    }
+    backToChatList()
+    val chat = alice.chatList.open("bob")
+    chat.itemId(BEFORE_EXPORT)
+    chat.send(AFTER_IMPORT)
+    bob.expectsMessage("alice> $AFTER_IMPORT", CONNECT_TIMEOUT_MS)
+  }
+
+  @KnownAppIssue("15.5 item 7", "waiting for the Error importing chat database alert")
+  @Test fun dbMgmt_importInvalidArchive() = uiTest {
+    val alice = app("alice")
+    writeNote(alice, NOTE_BEFORE_IMPORT)
+    val bad = File(exchangeDir(), "not-an-archive.zip").apply { writeText("not a zip archive") }
+    val db = chatData(alice).management()
+    openFile(bad) { click(Ui.Database.Import) }
+    poll(what = "the Import chat database? alert") { seesText("Import chat database?") && "Import" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the Error importing chat database alert") { seesText("Error importing chat database") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "alice still the user, without the welcome screen") {
+      !AlertManager.shared.hasAlertsShown() && chatModel.currentUser.value?.displayName == "alice" && !exists(Ui.Onboarding.GetStarted)
+    }
+    check(coreUserNames() == listOf("alice")) { "users after the failed import: ${coreUserNames()}" }
+    db.close()
+    poll(what = "alice's note still listed") { NOTE_BEFORE_IMPORT in alice.chatList.rowTexts("Private notes") }
+  }
+
+  @Test fun dbMgmt_deleteDatabase() = uiTest {
+    val alice = app("alice")
+    chatData(alice).management()
+    click(Ui.Database.Delete)
+    awaitDeleteAlert()
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the database screen after Cancel") { !AlertManager.shared.hasAlertsShown() && exists(Ui.Database.Delete) }
+    check(coreUserNames() == listOf("alice")) { "users after Cancel: ${coreUserNames()}" }
+    click(Ui.Database.Delete)
+    awaitDeleteAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the Chat database deleted alert") { seesText("Chat database deleted") && seesText("Restart the app to create a new chat profile.") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the welcome screen without a restart") {
+      exists(Ui.Onboarding.GetStarted) && onboarding().stage == OnboardingStage.Step1_SimpleXInfo && chatModel.currentUser.value == null
+    }
+    check(coreUserNames().isEmpty()) { "users after the deletion: ${coreUserNames()}" }
+  }
+
+  @Test fun chatData_deleteFilesAndMedia() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "/img @alice $FIXTURE_JPG"
+    bob expectsMessage "/f @alice $FIXTURE_JPG"
+    bob expects "use /fc 1 to cancel sending"
+    bob.eventually("completed uploading file 1 (test.jpg) for alice", CONNECT_TIMEOUT_MS)
+    bob sends "@alice $KEPT"
+    val chat = alice.chatList.open("bob")
+    chat.itemId(KEPT)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's image to be received") { imageStatus() is CIFileStatus.RcvComplete }
+    backToChatList()
+    val data = chatData(alice)
+    check(seesText("1 file(s) with total size of", substring = true) && !seesText("No received or sent files")) { "the files footer before the deletion: ${texts().take(30)}" }
+    check(!appFilesDir.listFiles().isNullOrEmpty()) { "no received file on disk before the deletion" }
+    click(Ui.Database.DeleteFiles)
+    poll(what = "the Delete files and media? alert") {
+      seesText("Delete files and media?") && seesText(DELETE_FILES_TEXT) && "Delete" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "no files on screen or on disk and the chat running again") {
+      seesText("No received or sent files") && appFilesDir.listFiles().isNullOrEmpty() && chatModel.chatRunning.value == true && chatRunningInCore()
+    }
+    data.close()
+    val after = alice.chatList.open("bob")
+    after.itemId(KEPT)
+    check(chatModel.chatsContext.chatItems.value.any { it.file?.fileName == "test.jpg" }) { "the image message was deleted with its file" }
+    after.send(FILES_GONE)
+    bob.expectsMessage("alice> $FILES_GONE", CONNECT_TIMEOUT_MS)
+  }
+
+  private fun UiScope.writeNote(app: App, text: String) {
+    val notes = app.chatList.open("Private notes")
+    notes.send(text)
+    notes.itemId(text)
+    backToChatList()
+  }
+
+  private fun UiScope.awaitDeletionAlert() =
+    poll(what = "the Enable automatic message deletion? alert with Delete messages") {
+      seesText("Enable automatic message deletion?") && "Delete messages" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+
+  private fun UiScope.awaitStopAlert() =
+    poll(what = "the Stop chat? alert with Stop") {
+      seesText("Stop chat?") && seesText(STOP_CHAT_TEXT) && "Stop" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+
+  private fun UiScope.awaitDeleteAlert() =
+    poll(what = "the Delete chat profile? alert with Delete") {
+      seesText("Delete chat profile?") && seesText(DELETE_PROFILE_TEXT) && "Delete" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+
+  private fun backdateItemViaSql(itemId: Long) {
+    val r = runBlocking { chatController.sendCmd(null, CC.Console("/sql chat UPDATE chat_items SET created_at = '2020-01-01 00:00:00' WHERE chat_item_id = $itemId")) }
+    check(r !is API.Error) { "backdating chat item $itemId failed: ${r.responseType} ${r.details}" }
+  }
+
+  private fun setLinkPreviewsPrefDirectly(on: Boolean) = appPrefs.privacyLinkPreviews.set(on)
+
+  private fun coreTtl(): ChatItemTTL = runBlocking { chatController.getChatItemTTL(null) }
+
+  private fun coreTtlOf(userId: Long): ChatItemTTL {
+    val r = runBlocking { chatController.sendCmd(null, CC.APIGetChatItemTTL(userId)) }
+    val ttl = r.result as? CR.ChatItemTTL ?: error("/_ttl $userId failed: ${r.responseType} ${r.details}")
+    return ttl.chatItemTTL?.let { ChatItemTTL.fromSeconds(it) } ?: ChatItemTTL.None
+  }
+
+  private fun UiScope.footerNames(name: String) = seesText("This setting applies to messages in your current chat profile $name.")
+
+  private fun coreUserNames(): List<String> = runBlocking { chatController.listUsers(null) }.map { it.user.displayName }
+
+  private fun imageStatus(): CIFileStatus? = chatModel.chatsContext.chatItems.value.lastOrNull { it.file?.fileName == "test.jpg" }?.file?.fileStatus
+
+  private companion object {
+    const val KEPT = "kept message"
+    const val DELETE_ALL_FILES = "Delete all files"
+    const val DELETE_FILES_ALL_PROFILES = "Delete files for all chat profiles"
+    const val EXPIRED = "expired message"
+    const val WHILE_STOPPED = "sent while stopped"
+    const val BACK_ONLINE = "back online"
+    const val BEFORE_EXPORT = "before export"
+    const val AFTER_IMPORT = "after import"
+    const val NOTE_BEFORE_EXPORT = "note written before the export"
+    const val NOTE_AFTER_EXPORT = "note written after the export"
+    const val NOTE_BEFORE_IMPORT = "note written before the import"
+    const val FILES_GONE = "files gone"
+    const val PASSPHRASE = "uitest-export-8Wd"
+    const val FIXTURE_JPG = "tests/fixtures/test.jpg"
+    const val MOST_RECENT_DB = "You must use the most recent version of your chat database on one device ONLY"
+    const val STOP_CHAT_TEXT = "Stop chat to export, import or delete chat database. You will not be able to receive and send messages while the chat is stopped."
+    const val START_CHAT_TEXT = "Chat is stopped. If you already used this database on another device, you should transfer it back before starting chat."
+    const val DELETE_PROFILE_TEXT = "This action cannot be undone - your profile, contacts, messages and files will be irreversibly lost."
+    const val DELETE_FILES_TEXT = "This action cannot be undone - all received and sent files and media will be deleted. Low resolution pictures will remain."
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/DatabaseEncryptionTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/DatabaseEncryptionTest.kt
new file mode 100644
index 0000000000..d5ee94e9c8
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/DatabaseEncryptionTest.kt
@@ -0,0 +1,160 @@
+package chat.simplex.app.ui.settings
+
+import chat.simplex.app.ui.harness.App
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.DB_WORK_TIMEOUT_MS
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.chatData
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.typeSecret
+import chat.simplex.common.model.API
+import chat.simplex.common.model.CC
+import chat.simplex.common.platform.appPlatform
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatDatabaseFileName
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import chat.simplex.common.views.helpers.DBMigrationResult
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+
+class DatabaseEncryptionTest : UiTest() {
+  @Test fun dbEncrypt_changePassphrase() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    bob sends "@alice $BEFORE_CHANGE"
+    poll(what = "bob's message on the row") { BEFORE_CHANGE in alice.chatList.rowTexts("bob") }
+    val pass = chatData(alice).management().passphrase()
+    check(!exists(Ui.DbPassphrase.Current) && storedSetting("InitialRandomDBPassphrase") == "true") { "a passphrase is set before the first one" }
+    pass.setFirst(FIRST)
+    val storedFirst = storedSetting("EncryptedDBPassphrase")
+    check(storedFirst != null && storedSetting("InitialRandomDBPassphrase") == "false") { "after the first passphrase: stored ${storedFirst != null}, random ${storedSetting("InitialRandomDBPassphrase")}" }
+    pass.change(current = "wrong-$FIRST", new = SECOND)
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the Wrong passphrase! alert") { seesText("Wrong passphrase!") && seesText("Please enter correct current passphrase.") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    check(storedSetting("EncryptedDBPassphrase") == storedFirst) { "a wrong current passphrase changed the stored passphrase" }
+    pass.reopen()
+    pass.change(current = FIRST, new = SECOND)
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the Database encrypted! alert") { seesText("Database encrypted!") }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the chat running again with the new passphrase stored") {
+      chatModel.chatRunning.value == true && storedSetting("EncryptedDBPassphrase").let { it != null && it != storedFirst }
+    }
+    val after = restart()
+    poll(what = "the chat list without a passphrase prompt") { after.chatList.shown("bob") && !seesText("Encrypted database") && !seesText("Wrong database passphrase") }
+    val chat = after.chatList.open("bob")
+    chat.itemId(BEFORE_CHANGE)
+    chat.send(AFTER_CHANGE)
+    bob.expectsMessage("alice> $AFTER_CHANGE", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun dbEncrypt_removeFromSettings() = uiTest {
+    val alice = app("alice")
+    writeNote(alice)
+    chatData(alice).management().passphrase().setFirst(FIRST)
+    check(seesText(onPlatform(STORED_DESKTOP, STORED_ANDROID), substring = true) && seesText(NO_RECOVERY, substring = true)) { "the stored-passphrase footer: ${texts().take(30)}" }
+    val stored = storedSetting("EncryptedDBPassphrase")
+    check(stored != null && storedSetting("StoreDBPassphrase") == "true") { "no passphrase stored before Remove" }
+    click(Ui.DbPassphrase.Save)
+    awaitRemoveAlert()
+    click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+    poll(what = "the passphrase still stored after Cancel") { !AlertManager.shared.hasAlertsShown() && seesText(onPlatform(STORED_DESKTOP, STORED_ANDROID), substring = true) }
+    check(storedSetting("EncryptedDBPassphrase") == stored && storedSetting("StoreDBPassphrase") == "true") { "Cancel removed the stored passphrase" }
+    click(Ui.DbPassphrase.Save)
+    awaitRemoveAlert()
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the passphrase removed on screen and on disk") {
+      seesText(NOT_STORED) && seesText(NO_RECOVERY, substring = true) && storedSetting("EncryptedDBPassphrase") == null && storedSetting("StoreDBPassphrase") == "false"
+    }
+    var current = restart(ready = { passphrasePrompted() }, what = "the passphrase prompt")
+    poll(what = "the Encrypted database prompt with Open chat") {
+      seesText("Encrypted database") && seesText("Database passphrase is required to open chat.") && "Open chat" in textsOf(Ui.DbError.Open)
+    }
+    typeSecret(Ui.DbError.Passphrase, FIRST.dropLast(1))
+    click(Ui.DbError.Open)
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the Wrong passphrase! alert") {
+      seesText("Wrong passphrase!") && seesText("Enter correct passphrase.") && chatModel.chatDbStatus.value is DBMigrationResult.ErrorNotADatabase
+    }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    typeSecret(Ui.DbError.Passphrase, FIRST.takeLast(1))
+    click(Ui.DbError.Open)
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the chat list after the right passphrase") { chatModel.chatDbStatus.value == DBMigrationResult.OK && current.chatList.shown(NOTES) }
+    check(storedSetting("EncryptedDBPassphrase") == null) { "Open chat stored the passphrase" }
+    val notes = current.chatList.open(NOTES)
+    notes.itemId(NOTE)
+    backToChatList()
+    chatData(current).management().passphrase()
+    check(seesText(NOT_STORED)) { "the passphrase screen after Open chat: ${texts().take(30)}" }
+    click(Ui.DbPassphrase.Save)
+    poll(what = "storing turned on but nothing stored yet") {
+      seesText(onPlatform(WILL_STORE_DESKTOP, WILL_STORE_ANDROID)) && storedSetting("StoreDBPassphrase") == "true" && storedSetting("EncryptedDBPassphrase") == null
+    }
+    check(!AlertManager.shared.hasAlertsShown()) { "turning storing on asked for confirmation" }
+    current = restart(ready = { passphrasePrompted() }, what = "the passphrase prompt")
+    poll(what = "the Encrypted database prompt with Save passphrase and open chat") {
+      seesText("Encrypted database") && "Save passphrase and open chat" in textsOf(Ui.DbError.Open)
+    }
+    typeSecret(Ui.DbError.Passphrase, FIRST)
+    click(Ui.DbError.Open)
+    poll(timeoutMs = DB_WORK_TIMEOUT_MS, what = "the chat list with the passphrase stored") {
+      chatModel.chatDbStatus.value == DBMigrationResult.OK && current.chatList.shown(NOTES) && storedSetting("EncryptedDBPassphrase") != null
+    }
+    current = restart()
+    poll(what = "the chat list without a passphrase prompt") { current.chatList.shown(NOTES) && !seesText("Encrypted database") }
+  }
+
+  @Test fun dbError_incompatibleDowngrade() = uiTest {
+    app("alice")
+    waitFor(Ui.ChatList.Search)
+    check(chatModel.chatDbStatus.value == DBMigrationResult.OK && !seesText(INCOMPATIBLE)) { "database status before the fixture: ${chatModel.chatDbStatus.value}" }
+    addFutureMigrationViaSql()
+    restart(ready = { chatModel.chatDbStatus.value is DBMigrationResult.ErrorMigration && !chatModel.ctrlInitInProgress.value }, what = "the database migration error")
+    poll(what = "Incompatible database version naming the file and the migration") {
+      seesText(INCOMPATIBLE) && seesText("File: $chatDatabaseFileName") &&
+        seesText("Error: database version is newer than the app, but no down migration for: $FUTURE_MIGRATION")
+    }
+    check(!exists(Ui.DbError.Passphrase) && !exists(Ui.ChatList.Search)) { "the incompatible database screen offers a passphrase field or the chat list" }
+  }
+
+  private fun UiScope.writeNote(app: App) {
+    val notes = app.chatList.open(NOTES)
+    notes.send(NOTE)
+    notes.itemId(NOTE)
+    backToChatList()
+  }
+
+  private fun UiScope.awaitRemoveAlert() =
+    poll(what = "the Remove passphrase alert with Remove") {
+      seesText(onPlatform("Remove passphrase from settings?", "Remove passphrase from Keystore?")) && "Remove" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    }
+
+  private fun passphrasePrompted(): Boolean =
+    chatModel.chatDbStatus.value is DBMigrationResult.ErrorNotADatabase && !chatModel.ctrlInitInProgress.value
+
+  private fun onPlatform(desktop: String, android: String): String = if (appPlatform.isDesktop) desktop else android
+
+  private fun addFutureMigrationViaSql() {
+    val r = runBlocking { chatController.sendCmd(null, CC.Console("/sql chat INSERT INTO migrations (name, ts, down) VALUES ('$FUTURE_MIGRATION', '2999-12-31 00:00:00', NULL)")) }
+    check(r !is API.Error) { "adding the future migration failed: ${r.responseType} ${r.details}" }
+  }
+
+  private companion object {
+    const val FIRST = "uitest-first-7Kq"
+    const val SECOND = "uitest-second-3Zp"
+    const val BEFORE_CHANGE = "before passphrase change"
+    const val AFTER_CHANGE = "after passphrase change"
+    const val NOTES = "Private notes"
+    const val NOTE = "kept across restarts"
+    const val FUTURE_MIGRATION = "29991231_uitest_newer"
+    const val INCOMPATIBLE = "Incompatible database version"
+    const val STORED_DESKTOP = "The passphrase is stored in settings as plaintext."
+    const val STORED_ANDROID = "is used to securely store passphrase - it allows notification service to work."
+    const val NO_RECOVERY = "you will NOT be able to recover or change passphrase if you lose it."
+    const val NOT_STORED = "You have to enter passphrase every time the app starts - it is not stored on the device."
+    const val WILL_STORE_DESKTOP = "The passphrase will be stored in settings as plaintext after you change it or restart the app."
+    const val WILL_STORE_ANDROID = "Android Keystore will be used to securely store passphrase after you restart the app or change passphrase - it will allow receiving notifications."
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/HelpTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/HelpTest.kt
new file mode 100644
index 0000000000..9ba6b29fe9
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/HelpTest.kt
@@ -0,0 +1,38 @@
+package chat.simplex.app.ui.settings
+
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.helpAndSupport
+import chat.simplex.common.platform.appPlatform
+import chat.simplex.common.platform.platform
+import chat.simplex.common.ui.Ui
+import org.junit.Test
+
+private val HELP_ROWS = listOf(
+  "How to use it", "What's new", "About SimpleX Chat",
+  "Follow SimpleX Network News", "Send questions and ideas", "Send us email", "Star on GitHub",
+)
+private const val WELCOME = "Welcome alice!"
+private const val HELP_TEXT = "Thank you for installing SimpleX Chat!"
+private const val ABOUT_TEXT = "Private and secure messaging."
+private const val WHY_BUILT = "Why SimpleX is built."
+
+class HelpTest : UiTest() {
+  @Test fun help_layoutHowToUseAndAbout() = uiTest {
+    val alice = app("alice")
+    helpAndSupport(alice)
+    check(HELP_ROWS.all { seesText(it) }) { "Help & support rows missing: ${HELP_ROWS.filterNot { seesText(it) }}" }
+    check(seesText("Rate the app") == appPlatform.isAndroid) { "Rate the app shown: ${seesText("Rate the app")} on ${appPlatform.name}" }
+    check(seesText("Contribute") == !platform.androidIsPlayStoreBuild) { "Contribute shown: ${seesText("Contribute")}" }
+    check(!seesText(WELCOME) && !seesText(ABOUT_TEXT)) { "How to use it or About is shown before it was opened" }
+    click(Ui.Help.HowToUse)
+    poll(what = "How to use it with alice's welcome and the help text") { seesText(WELCOME) && seesText(HELP_TEXT) && !exists(Ui.Help.HowToUse) }
+    escape()
+    poll(what = "Help & support again") { exists(Ui.Help.About) && !seesText(WELCOME) }
+    click(Ui.Help.About)
+    poll(what = "About SimpleX Chat without the onboarding buttons") {
+      seesText(ABOUT_TEXT) && !exists(Ui.Help.About) && !exists(Ui.Onboarding.WhyBuilt) && !seesText(WHY_BUILT)
+    }
+    escape()
+    poll(what = "Help & support after About") { exists(Ui.Help.About) && !seesText(ABOUT_TEXT) }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/NetworkProxyTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/NetworkProxyTest.kt
new file mode 100644
index 0000000000..4fdec25ad9
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/NetworkProxyTest.kt
@@ -0,0 +1,390 @@
+package chat.simplex.app.ui.settings
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.SOCKS_HOST
+import chat.simplex.app.ui.harness.SocksProxy
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
+import chat.simplex.app.ui.harness.closeDeveloperTools
+import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.coreNetworkConfig
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.localSmpServer
+import chat.simplex.app.ui.harness.networkAndServers
+import chat.simplex.app.ui.harness.saveNetworkConfigViaApi
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.model.HostMode
+import chat.simplex.common.model.KeepAliveOpts
+import chat.simplex.common.model.NetCfg
+import chat.simplex.common.model.NetworkProxy
+import chat.simplex.common.model.OnionHosts
+import chat.simplex.common.model.SMPProxyFallback
+import chat.simplex.common.model.SMPProxyMode
+import chat.simplex.common.model.TransportSessionMode
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.views.helpers.AlertManager
+import org.junit.Test
+
+private class NetSetting(val name: String, val pref: String, val new: Long, val oldText: String, val newText: String, val core: (NetCfg) -> Long)
+
+private val TIMEOUTS = listOf(
+  NetSetting("tcpConnectTimeout", "NetworkTCPConnectTimeoutInteractive", 20_000_000, "15 sec", "20 sec") { it.tcpConnectTimeout.interactiveTimeout },
+  NetSetting("tcpConnectTimeoutBackground", "NetworkTCPConnectTimeoutBackground", 60_000_000, "45 sec", "60 sec") { it.tcpConnectTimeout.backgroundTimeout },
+  NetSetting("tcpTimeout", "NetworkTCPTimeoutInteractive", 15_000_000, "10 sec", "15 sec") { it.tcpTimeout.interactiveTimeout },
+  NetSetting("tcpTimeoutBackground", "NetworkTCPTimeoutBackground", 45_000_000, "30 sec", "45 sec") { it.tcpTimeout.backgroundTimeout },
+  NetSetting("tcpTimeoutPerKb", "networkTCPTimeoutPerKb", 20_000, "0.01 sec", "0.02 sec") { it.tcpTimeoutPerKb },
+  NetSetting("smpPingInterval", "NetworkSMPPingInterval", 600_000_000, "1200 sec", "600 sec") { it.smpPingInterval },
+  NetSetting("smpPingCount", "NetworkSMPPingCount", 5, "3", "5") { it.smpPingCount.toLong() },
+)
+
+private const val PER_KB = "networkTCPTimeoutPerKb"
+private const val PING_COUNT = "NetworkSMPPingCount"
+private const val KEEP_ALIVE = "NetworkEnableKeepAlive"
+private const val PROXY_MODE = "NetworkSMPProxyMode"
+private const val PROXY_FALLBACK = "NetworkSMPProxyFallback"
+private const val USE_SOCKS = "NetworkUseSocksProxy"
+private const val HOST_MODE = "NetworkHostMode"
+private const val REQUIRED_HOST_MODE = "NetworkRequiredHostMode"
+private const val UPDATE_TITLE = "Update network settings?"
+private const val ONION_REQUIRED_FOOTER = "Onion hosts will be required for connection."
+private const val PROXY = "NetworkProxyHostPort"
+private const val SESSION_MODE = "NetworkSessionMode"
+private const val CUSTOM_PER_KB = 20_000L
+private const val WRONG_PROXY_TITLE = "Error saving proxy"
+private const val WRONG_PROXY_TEXT = "Make sure proxy configuration is correct."
+private const val PROXY_HOST = "127.0.0.1"
+private const val PROXY_PORT = "9150"
+private val ALERT_CONFIRM = Ui.Alert.Confirm(Ui.AlertSource.Shared)
+private val ALERT_DISMISS = Ui.Alert.Dismiss(Ui.AlertSource.Shared)
+
+class NetworkProxyTest : UiTest() {
+  @Test fun socks_enable_confirm() = uiTest {
+    val alice = app("alice")
+    saveNetworkConfigViaApi(coreNetworkConfig().copy(tcpTimeoutPerKb = CUSTOM_PER_KB))
+    val def = NetCfg.defaults
+    val proxyDef = NetCfg.proxyDefaults
+    coreNetworkConfig().let {
+      check(it.socksProxy == null && it.tcpConnectTimeout == def.tcpConnectTimeout && it.tcpTimeout == def.tcpTimeout && it.rcvConcurrency == def.rcvConcurrency) { "network config before the test: $it" }
+    }
+    networkAndServers(alice)
+    toggleSocks("Use SOCKS proxy?")
+    poll(what = "the SOCKS proxy on with the proxy timeouts, keeping the changed per-KB timeout") {
+      storedSetting(USE_SOCKS) == "true" && coreNetworkConfig().let {
+        it.socksProxy != null && it.tcpConnectTimeout == proxyDef.tcpConnectTimeout && it.tcpTimeout == proxyDef.tcpTimeout &&
+          it.rcvConcurrency == proxyDef.rcvConcurrency && it.tcpTimeoutPerKb == CUSTOM_PER_KB
+      }
+    }
+    toggleSocks("Use direct Internet connection?")
+    poll(what = "the SOCKS proxy off with the direct timeouts back, keeping the changed per-KB timeout") {
+      storedSetting(USE_SOCKS) == "false" && coreNetworkConfig().let {
+        it.socksProxy == null && it.tcpConnectTimeout == def.tcpConnectTimeout && it.tcpTimeout == def.tcpTimeout &&
+          it.rcvConcurrency == def.rcvConcurrency && it.tcpTimeoutPerKb == CUSTOM_PER_KB
+      }
+    }
+  }
+
+  @Test fun socks_wrongConfigAlert() = uiTest {
+    val alice = app("alice")
+    val network = networkAndServers(alice)
+    toggleSocks("Use SOCKS proxy?")
+    poll(what = "the SOCKS proxy on in the core") { storedSetting(USE_SOCKS) == "true" && coreNetworkConfig().socksProxy != null }
+    val socksBefore = coreNetworkConfig().socksProxy
+    val socks = network.socks()
+    check(editableText(Ui.Socks.Host) == "localhost" && editableText(Ui.Socks.Port) == "9050") { "SOCKS fields: `${editableText(Ui.Socks.Host)}`:`${editableText(Ui.Socks.Port)}`" }
+    replaceText(Ui.Socks.Host, "proxy.example")
+    socks.saveAndReconnect()
+    poll(what = "the `$WRONG_PROXY_TITLE` alert") { seesText(WRONG_PROXY_TITLE) && seesText(WRONG_PROXY_TEXT) && exists(ALERT_CONFIRM) }
+    click(ALERT_CONFIRM)
+    poll(what = "the alert to close") { !AlertManager.shared.hasAlertsShown() }
+    check(appPrefs.networkProxy.get() == NetworkProxy() && coreNetworkConfig().socksProxy == socksBefore && exists(Ui.Socks.Save)) {
+      "the rejected proxy was kept: stored ${appPrefs.networkProxy.get()}, core ${coreNetworkConfig().socksProxy}"
+    }
+    replaceText(Ui.Socks.Host, PROXY_HOST)
+    replaceText(Ui.Socks.Port, PROXY_PORT)
+    socks.saveAndReconnect()
+    poll(what = "the new proxy stored and applied, with SOCKS proxy settings still open") {
+      appPrefs.networkProxy.get().let { it.host == PROXY_HOST && it.port.toString() == PROXY_PORT } &&
+        coreNetworkConfig().socksProxy?.contains("$PROXY_HOST:$PROXY_PORT") == true && exists(Ui.Socks.Save) && !AlertManager.shared.hasAlertsShown()
+    }
+    click(Ui.Socks.Reset)
+    poll(what = "the fields reset to localhost:9050") { editableText(Ui.Socks.Host) == "localhost" && editableText(Ui.Socks.Port) == "9050" }
+    check(coreNetworkConfig().socksProxy?.contains("$PROXY_HOST:$PROXY_PORT") == true && appPrefs.networkProxy.get().host == PROXY_HOST) {
+      "`Reset to defaults` saved before `Save and reconnect`: ${coreNetworkConfig().socksProxy}"
+    }
+    socks.saveAndReconnect()
+    poll(what = "the default proxy stored and applied") { appPrefs.networkProxy.get() == NetworkProxy() && coreNetworkConfig().socksProxy == socksBefore }
+  }
+
+  @Test fun socks_unsavedAlert() = uiTest {
+    val alice = app("alice")
+    val storedBefore = storedSetting(PROXY)
+    val network = networkAndServers(alice)
+    var socks = network.socks()
+    check(editableText(Ui.Socks.Host) == "localhost" && editableText(Ui.Socks.Port) == "9050") { "SOCKS fields: `${editableText(Ui.Socks.Host)}`:`${editableText(Ui.Socks.Port)}`" }
+    for ((field, invalid) in listOf(Ui.Socks.Port to "70000", Ui.Socks.Host to "bad@host")) {
+      replaceText(field, invalid)
+      click(Ui.Socks.Save)
+      settle()
+      check(!AlertManager.shared.hasAlertsShown() && storedSetting(PROXY) == storedBefore) { "Save acted on the invalid `$invalid`" }
+    }
+    socks.back()
+    check(!AlertManager.shared.hasAlertsShown() && storedSetting(PROXY) == storedBefore) { "leaving with invalid fields asked to save or saved" }
+    socks = network.socks()
+    check(editableText(Ui.Socks.Host) == "localhost" && editableText(Ui.Socks.Port) == "9050") { "the invalid values were kept" }
+    replaceText(Ui.Socks.Port, PROXY_PORT)
+    goBack()
+    awaitUnsavedAlert()
+    click(ALERT_DISMISS)
+    poll(what = "`SOCKS proxy settings` closed by `Exit without saving`") { !exists(Ui.Socks.Save) && exists(Ui.Network.SaveServers) }
+    check(storedSetting(PROXY) == storedBefore) { "`Exit without saving` saved the port: ${storedSetting(PROXY)}" }
+    socks = network.socks()
+    check(editableText(Ui.Socks.Port) == "9050") { "the discarded port is shown: ${editableText(Ui.Socks.Port)}" }
+    replaceText(Ui.Socks.Port, PROXY_PORT)
+    goBack()
+    awaitUnsavedAlert()
+    click(ALERT_CONFIRM)
+    poll(what = "the port stored, `SOCKS proxy settings` still open") {
+      !AlertManager.shared.hasAlertsShown() && appPrefs.networkProxy.get().port.toString() == PROXY_PORT && exists(Ui.Socks.Save) && editableText(Ui.Socks.Port) == PROXY_PORT
+    }
+    check(coreNetworkConfig().socksProxy == null && storedSetting(USE_SOCKS) != "true") { "saving the proxy settings turned the SOCKS proxy on: ${coreNetworkConfig().socksProxy}" }
+    socks.back()
+    check(!AlertManager.shared.hasAlertsShown()) { "leaving after the save asked to save again" }
+  }
+
+  @Test fun advNet_transportIsolation() = uiTest {
+    val alice = app("alice")
+    check(coreNetworkConfig().sessionMode == TransportSessionMode.Session && storedSetting(SESSION_MODE) != TransportSessionMode.Server.name) { "transport isolation before the test: ${coreNetworkConfig().sessionMode}" }
+    var network = networkAndServers(alice)
+    var adv = network.advanced()
+    check("App session" in textsOf(Ui.AdvancedNetwork.SessionMode)) { "`Transport isolation`: ${textsOf(Ui.AdvancedNetwork.SessionMode)}" }
+    pickSessionMode(TransportSessionMode.Server, listOf(TransportSessionMode.User to "Chat profile", TransportSessionMode.Session to "App session", TransportSessionMode.Server to "Server"), TransportSessionMode.Entity)
+    poll(what = "`Server` on `Transport isolation`") { "Server" in textsOf(Ui.AdvancedNetwork.SessionMode) }
+    adv.saveAndReconnect()
+    poll(what = "transport isolation by server stored and applied to the core") {
+      storedSetting(SESSION_MODE) == TransportSessionMode.Server.name && coreNetworkConfig().sessionMode == TransportSessionMode.Server
+    }
+    adv.back()
+    network.close()
+    click(Ui.Settings.Version)
+    click(Ui.Settings.DeveloperTools)
+    click(Ui.DevTools.ShowOptions)
+    poll(what = "developer tools stored as on") { storedSetting("DeveloperTools") == "true" }
+    closeDeveloperTools()
+    network = networkAndServers(alice)
+    adv = network.advanced()
+    pickSessionMode(TransportSessionMode.Entity, listOf(TransportSessionMode.Server to "Server", TransportSessionMode.Entity to "Connection"), null)
+    poll(what = "`Connection` on `Transport isolation`") { "Connection" in textsOf(Ui.AdvancedNetwork.SessionMode) }
+    adv.saveAndReconnect()
+    poll(what = "transport isolation by connection stored and applied to the core") {
+      storedSetting(SESSION_MODE) == TransportSessionMode.Entity.name && coreNetworkConfig().sessionMode == TransportSessionMode.Entity
+    }
+  }
+
+  private fun UiScope.toggleSocks(title: String) {
+    click(Ui.Network.UseSocks)
+    poll(what = "the `$title` alert with `Confirm`") { seesText(title) && exists(ALERT_CONFIRM) && "Confirm" in textsOf(ALERT_CONFIRM) }
+    click(ALERT_CONFIRM)
+    poll(what = "the `$title` alert to close") { !AlertManager.shared.hasAlertsShown() }
+  }
+
+  private fun UiScope.awaitUnsavedAlert() =
+    poll(what = "the `$UPDATE_TITLE` alert with `Save` and `Exit without saving`") {
+      seesText(UPDATE_TITLE) && "Save" in textsOf(ALERT_CONFIRM) && "Exit without saving" in textsOf(ALERT_DISMISS)
+    }
+
+  private fun UiScope.pickSessionMode(mode: TransportSessionMode, shown: List<Pair<TransportSessionMode, String>>, hidden: TransportSessionMode?) {
+    val row = Ui.AdvancedNetwork.SessionMode
+    click(row)
+    poll(what = "the transport isolation options") { exists(row.option(mode)) && !exists(Ui.AdvancedNetwork.Save) }
+    for ((value, title) in shown) check(title in textsOf(row.option(value))) { "option $value is not `$title`: ${textsOf(row.option(value))}" }
+    if (hidden != null) check(!exists(row.option(hidden))) { "option $hidden is offered without developer tools" }
+    click(row.option(mode))
+    goBack()
+    poll(what = "back on `Advanced settings` from the transport isolation options") { !exists(row.option(mode)) && exists(Ui.AdvancedNetwork.Save) }
+  }
+
+  @Test fun socks_onionHostsOptions() = uiTest {
+    val alice = app("alice")
+    coreNetworkConfig().let { check(it.socksProxy == null && !it.requiredHostMode) { "network config before the test: $it" } }
+    check(storedSetting(REQUIRED_HOST_MODE) != "true") { "`.onion` hosts are stored as required before the test" }
+    val network = networkAndServers(alice)
+    var socks = network.socks()
+    check("No" in socks.onionHosts() && "When available" !in socks.onionHosts()) { "`Use .onion hosts` with the SOCKS proxy off: ${socks.onionHosts()}" }
+    click(Ui.Socks.OnionHosts)
+    settle()
+    check(exists(Ui.Socks.Save) && !exists(Ui.Socks.OnionHosts.option(OnionHosts.REQUIRED))) { "`Use .onion hosts` opened its options with the SOCKS proxy off" }
+    socks.back()
+    click(Ui.Network.UseSocks)
+    poll(what = "the `Use SOCKS proxy?` alert with `Confirm`") { seesText("Use SOCKS proxy?") && exists(ALERT_CONFIRM) && "Confirm" in textsOf(ALERT_CONFIRM) }
+    click(ALERT_CONFIRM)
+    poll(what = "the SOCKS proxy on in the stored settings and the core") { storedSetting(USE_SOCKS) == "true" && coreNetworkConfig().socksProxy != null }
+    socks = network.socks()
+    poll(what = "`Use .onion hosts` at `When available` with the SOCKS proxy on") { "When available" in socks.onionHosts() }
+    click(Ui.Socks.OnionHosts)
+    click(Ui.Socks.OnionHosts.option(OnionHosts.REQUIRED))
+    poll(what = "`Required` with its footer") { "Required" in socks.onionHosts() && seesText(ONION_REQUIRED_FOOTER, substring = true) }
+    socks.saveAndReconnect()
+    poll(what = "`.onion` hosts required in the stored settings and the core") {
+      storedSetting(HOST_MODE) == HostMode.OnionViaSocks.name && storedSetting(REQUIRED_HOST_MODE) == "true" &&
+        coreNetworkConfig().let { it.hostMode == HostMode.OnionViaSocks && it.requiredHostMode }
+    }
+    val after = restart()
+    poll(what = "chat running after the restart") { chatModel.chatRunning.value == true }
+    coreNetworkConfig().let { check(it.socksProxy != null && it.hostMode == HostMode.OnionViaSocks && it.requiredHostMode) { "network config after the restart: $it" } }
+    val again = networkAndServers(after).socks()
+    poll(what = "`Use .onion hosts` still `Required` after the restart") { "Required" in again.onionHosts() }
+  }
+
+  @Test fun socks_trafficRoutedThroughProxy() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    SocksProxy.start()
+    connect(bob)
+    alice.chatList.open("bob").send("direct")
+    bob.expectsMessage("alice> direct", CONNECT_TIMEOUT_MS)
+    check(SocksProxy.connections().isEmpty()) { "the app used the SOCKS proxy before it was enabled: ${SocksProxy.connections()}" }
+    backToChatList()
+    val network = networkAndServers(alice)
+    network.socks().apply { saveProxy(SOCKS_HOST, SocksProxy.port); back() }
+    check(coreNetworkConfig().socksProxy == null && SocksProxy.connections().isEmpty()) {
+      "saving the proxy with `Use SOCKS proxy` off changed the network: ${coreNetworkConfig().socksProxy}, ${SocksProxy.connections()}"
+    }
+    network.enableSocks()
+    poll(what = "the core using the SOCKS proxy on port ${SocksProxy.port}") { coreNetworkConfig().socksProxy?.endsWith(":${SocksProxy.port}") == true }
+    val smp = localSmpServer()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "a connection to ${smp.hostnames.first()}:${smp.port} through the SOCKS proxy with random credentials") {
+      SocksProxy.connections().any { it.host == smp.hostnames.first() && it.port.toString() == smp.port && !it.username.isNullOrEmpty() }
+    }
+    network.close()
+    escape()
+    poll(what = "the settings to close to the chat list") { !exists(Ui.Settings.Network) && exists(Ui.ChatList.Search) }
+    alice.chatList.open("bob").send("via proxy")
+    bob.expectsMessage("alice> via proxy", CONNECT_TIMEOUT_MS)
+  }
+
+  @Test fun advNet_privateRoutingMode() = uiTest {
+    val alice = app("alice")
+    coreNetworkConfig().let { check(it.smpProxyMode == SMPProxyMode.Always && it.smpProxyFallback == SMPProxyFallback.AllowProtected) { "network config before the test: $it" } }
+    check(storedSetting(PROXY_MODE) != SMPProxyMode.Unknown.name && storedSetting(PROXY_FALLBACK) != SMPProxyFallback.Prohibit.name) { "private routing is stored as changed before the test" }
+    val adv = networkAndServers(alice).advanced()
+    check("Always" in textsOf(Ui.AdvancedNetwork.ProxyMode) && "When IP hidden" in textsOf(Ui.AdvancedNetwork.ProxyFallback)) {
+      "private routing rows before the test: ${textsOf(Ui.AdvancedNetwork.ProxyMode)}, ${textsOf(Ui.AdvancedNetwork.ProxyFallback)}"
+    }
+    adv.pick(Ui.AdvancedNetwork.ProxyMode, SMPProxyMode.Never)
+    poll(what = "`Never` on `Private routing`") { "Never" in textsOf(Ui.AdvancedNetwork.ProxyMode) }
+    click(Ui.AdvancedNetwork.ProxyFallback)
+    settle()
+    check(exists(Ui.AdvancedNetwork.Save) && !exists(Ui.AdvancedNetwork.ProxyFallback.option(SMPProxyFallback.Prohibit))) {
+      "`Allow downgrade` opened its options with private routing off"
+    }
+    adv.pick(Ui.AdvancedNetwork.ProxyMode, SMPProxyMode.Unknown)
+    adv.pick(Ui.AdvancedNetwork.ProxyFallback, SMPProxyFallback.Prohibit)
+    poll(what = "`Unknown servers` and `No` on the private routing rows") {
+      "Unknown servers" in textsOf(Ui.AdvancedNetwork.ProxyMode) && "No" in textsOf(Ui.AdvancedNetwork.ProxyFallback)
+    }
+    adv.saveAndReconnect()
+    poll(what = "private routing stored and applied to the core") {
+      storedSetting(PROXY_MODE) == SMPProxyMode.Unknown.name && storedSetting(PROXY_FALLBACK) == SMPProxyFallback.Prohibit.name &&
+        coreNetworkConfig().let { it.smpProxyMode == SMPProxyMode.Unknown && it.smpProxyFallback == SMPProxyFallback.Prohibit }
+    }
+    val after = restart()
+    poll(what = "chat running after the restart") { chatModel.chatRunning.value == true }
+    coreNetworkConfig().let { check(it.smpProxyMode == SMPProxyMode.Unknown && it.smpProxyFallback == SMPProxyFallback.Prohibit) { "network config after the restart: $it" } }
+    networkAndServers(after).advanced()
+    check("Unknown servers" in textsOf(Ui.AdvancedNetwork.ProxyMode) && "No" in textsOf(Ui.AdvancedNetwork.ProxyFallback)) {
+      "private routing rows after the restart: ${textsOf(Ui.AdvancedNetwork.ProxyMode)}, ${textsOf(Ui.AdvancedNetwork.ProxyFallback)}"
+    }
+  }
+
+  @Test fun advNet_timeoutsSaved() = uiTest {
+    val alice = app("alice")
+    val before = coreNetworkConfig()
+    for (t in TIMEOUTS) check(t.core(before) != t.new && storedSetting(t.pref) != t.new.toString()) { "${t.name} is already ${t.new} before the test: $before" }
+    val adv = networkAndServers(alice).advanced()
+    for (t in TIMEOUTS) {
+      check(adv.value(t.name) == t.oldText) { "${t.name} shows `${adv.value(t.name)}` instead of `${t.oldText}`" }
+      adv.select(t.name, t.new)
+      poll(what = "${t.name} showing `${t.newText}`") { adv.value(t.name) == t.newText }
+    }
+    adv.saveAndReconnect()
+    poll(what = "all ${TIMEOUTS.size} values stored and applied to the core") {
+      TIMEOUTS.all { storedSetting(it.pref) == it.new.toString() } && coreNetworkConfig().let { c -> TIMEOUTS.all { it.core(c) == it.new } }
+    }
+    val after = restart()
+    poll(what = "chat running after the restart") { chatModel.chatRunning.value == true }
+    coreNetworkConfig().let { c -> check(TIMEOUTS.all { it.core(c) == it.new }) { "network config after the restart: $c" } }
+    val again = networkAndServers(after).advanced()
+    for (t in TIMEOUTS) check(again.value(t.name) == t.newText) { "${t.name} shows `${again.value(t.name)}` after the restart" }
+  }
+
+  @Test fun advNet_keepAlive() = uiTest {
+    val alice = app("alice")
+    check(storedSetting(KEEP_ALIVE) != "false" && coreNetworkConfig().tcpKeepAlive == KeepAliveOpts.defaults) { "keep-alive before the test: ${coreNetworkConfig().tcpKeepAlive}" }
+    var adv = networkAndServers(alice).advanced()
+    check(adv.value("tcpKeepIdle") == "30 sec" && adv.value("tcpKeepCnt") == "4") { "TCP_KEEPIDLE `${adv.value("tcpKeepIdle")}`, TCP_KEEPCNT `${adv.value("tcpKeepCnt")}`" }
+    click(Ui.AdvancedNetwork.KeepAlive)
+    poll(what = "the TCP_KEEP* options turned into plain rows") {
+      !exists(Ui.AdvancedNetwork.Setting("tcpKeepIdle")) && !exists(Ui.AdvancedNetwork.Setting("tcpKeepCnt")) && seesText("TCP_KEEPIDLE") && seesText("TCP_KEEPCNT")
+    }
+    adv.saveAndReconnect()
+    poll(what = "keep-alive stored as off") { storedSetting(KEEP_ALIVE) == "false" }
+    val after = restart()
+    poll(what = "chat running after the restart") { chatModel.chatRunning.value == true }
+    adv = networkAndServers(after).advanced()
+    check(exists(Ui.AdvancedNetwork.KeepAlive) && seesText("TCP_KEEPIDLE") && !exists(Ui.AdvancedNetwork.Setting("tcpKeepIdle"))) { "keep-alive is on again after the restart" }
+    click(Ui.AdvancedNetwork.KeepAlive)
+    adv.select("tcpKeepIdle", 60)
+    adv.select("tcpKeepCnt", 8)
+    poll(what = "TCP_KEEPIDLE `60 sec` and TCP_KEEPCNT `8`") { adv.value("tcpKeepIdle") == "60 sec" && adv.value("tcpKeepCnt") == "8" }
+    adv.saveAndReconnect()
+    poll(what = "keep-alive stored as on with the new values and applied to the core") {
+      storedSetting(KEEP_ALIVE) == "true" && storedSetting("NetworkTCPKeepIdle") == "60" && storedSetting("NetworkTCPKeepCnt") == "8" &&
+        coreNetworkConfig().tcpKeepAlive == KeepAliveOpts(keepIdle = 60, keepIntvl = KeepAliveOpts.defaults.keepIntvl, keepCnt = 8)
+    }
+  }
+
+  @Test fun advNet_resetToDefaults() = uiTest {
+    val alice = app("alice")
+    saveNetworkConfigViaApi(NetCfg.defaults.copy(tcpTimeoutPerKb = 20_000, smpPingCount = 5))
+    val adv = networkAndServers(alice).advanced()
+    check(adv.value("tcpTimeoutPerKb") == "0.02 sec" && adv.value("smpPingCount") == "5") {
+      "the saved values are not shown: `${adv.value("tcpTimeoutPerKb")}`, `${adv.value("smpPingCount")}`"
+    }
+    click(Ui.AdvancedNetwork.Reset)
+    poll(what = "the defaults shown after `Reset to defaults`") {
+      adv.value("tcpTimeoutPerKb") == "0.01 sec" && adv.value("smpPingCount") == "3" && adv.value("tcpConnectTimeout") == "15 sec"
+    }
+    check(storedSetting(PER_KB) == "20000" && storedSetting(PING_COUNT) == "5" && coreNetworkConfig().let { it.tcpTimeoutPerKb == 20_000L && it.smpPingCount == 5 }) {
+      "`Reset to defaults` applied the defaults before `Save and reconnect`: ${coreNetworkConfig()}"
+    }
+    adv.saveAndReconnect()
+    poll(what = "the defaults stored and applied to the core") {
+      storedSetting(PER_KB) == "10000" && storedSetting(PING_COUNT) == "3" && coreNetworkConfig().let { it.tcpTimeoutPerKb == 10_000L && it.smpPingCount == 3 }
+    }
+  }
+
+  @Test fun advNet_unsavedChangesAlert() = uiTest {
+    val alice = app("alice")
+    val network = networkAndServers(alice)
+    network.advanced().back()
+    check(!AlertManager.shared.hasAlertsShown()) { "leaving `Advanced settings` without changes showed an alert" }
+    var adv = network.advanced()
+    adv.select("smpPingCount", 5)
+    goBack()
+    poll(what = "the `$UPDATE_TITLE` alert with `Save and reconnect` and `Exit without saving`") {
+      seesText(UPDATE_TITLE) && exists(ALERT_CONFIRM) && "Save and reconnect" in textsOf(ALERT_CONFIRM) && "Exit without saving" in textsOf(ALERT_DISMISS)
+    }
+    click(ALERT_DISMISS)
+    adv.awaitClosed()
+    check(storedSetting(PING_COUNT) != "5" && coreNetworkConfig().smpPingCount == 3) { "`Exit without saving` saved the change: ${coreNetworkConfig()}" }
+    adv = network.advanced()
+    check(adv.value("smpPingCount") == "3") { "PING count shows `${adv.value("smpPingCount")}` after `Exit without saving`" }
+    adv.select("smpPingCount", 8)
+    goBack()
+    poll(what = "the `$UPDATE_TITLE` alert") { seesText(UPDATE_TITLE) && exists(ALERT_CONFIRM) }
+    click(ALERT_CONFIRM)
+    adv.awaitClosed()
+    poll(what = "PING count 8 stored and applied to the core") { storedSetting(PING_COUNT) == "8" && coreNetworkConfig().smpPingCount == 8 }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/NetworkServersTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/NetworkServersTest.kt
new file mode 100644
index 0000000000..030f8fcb2d
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/NetworkServersTest.kt
@@ -0,0 +1,272 @@
+package chat.simplex.app.ui.settings
+
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.TestServers
+import chat.simplex.app.ui.harness.UNREACHABLE_HOST
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.addCustomSmpServerViaApi
+import chat.simplex.app.ui.harness.coreOperators
+import chat.simplex.app.ui.harness.customServers
+import chat.simplex.app.ui.harness.customSmpServer
+import chat.simplex.app.ui.harness.goBack
+import chat.simplex.app.ui.harness.hostOf
+import chat.simplex.app.ui.harness.networkAndServers
+import chat.simplex.app.ui.harness.openNetworkFromSettings
+import chat.simplex.app.ui.harness.unreachableSmpServer
+import chat.simplex.common.model.ConditionsAcceptance
+import chat.simplex.common.model.OperatorTag
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import chat.simplex.common.views.helpers.AlertManager
+import org.junit.Test
+
+private const val TEST_FAILED = "Server test failed!"
+private const val TEST_SERVERS = "Test servers"
+private const val SOME_FAILED = "Some servers failed the test:"
+private const val NO_MESSAGE_SERVERS = "No message servers."
+private const val ACCEPTED_ON = "Conditions accepted on:"
+private const val CONDITIONS_HEADING = "SimpleX Chat Operators Privacy Policy and Conditions of Use"
+private const val INVALID_ADDRESS = "not a server address"
+private val CONFIRM = Ui.Alert.Confirm(Ui.AlertSource.Shared)
+private val DISMISS = Ui.Alert.Dismiss(Ui.AlertSource.Shared)
+
+private fun listsServer(alertText: String, host: String): Boolean = Regex("\\s${Regex.escape(host)}: ").containsMatchIn(alertText)
+
+class NetworkServersTest : UiTest() {
+  @Test fun operators_enableDisableOperator() = uiTest {
+    val alice = app("alice")
+    val simplex = coreOperators().single { it.operatorTag == OperatorTag.SimpleX }
+    val flux = coreOperators().single { it.operatorTag == OperatorTag.Flux }
+    check(!simplex.enabled && !flux.enabled && simplex.conditionsAcceptance.let { it is ConditionsAcceptance.Required && it.deadline == null }) {
+      "operators before the test: $simplex, $flux"
+    }
+    val network = networkAndServers(alice)
+    poll(what = "the `Network & servers` sections") {
+      seesText("Preset servers") && exists(Ui.Network.Operator(flux.operatorId)) && seesText("Messages and files") && seesText("Your servers") &&
+        seesText("Use SOCKS proxy") && seesText("SOCKS proxy settings") && seesText("Advanced network settings") && seesText("Save servers") &&
+        seesText("Calls") && seesText("WebRTC ICE servers")
+    }
+    check(!network.edited(Ui.Network.Operator(simplex.operatorId))) { "the SimpleX Chat row is marked as edited before the test" }
+    var operator = network.operator(simplex.operatorId)
+    poll(what = "`${simplex.tradeName} servers` with the operator off") { seesText("${simplex.tradeName} servers") }
+    check(!seesText(TEST_SERVERS) && !seesText(ACCEPTED_ON, substring = true)) { "the disabled operator shows its servers or accepted conditions" }
+    operator.info()
+    simplex.legalName?.let { name -> check(seesText(name)) { "`Network operator` without `$name`: ${texts().take(30)}" } }
+    operator.closeInfo()
+    operator.toggleUse()
+    poll(what = "`Use ${simplex.tradeName}` with the conditions text and `Accept conditions`") {
+      seesText("Use ${simplex.tradeName}") && exists(Ui.Operator.AcceptConditions) && seesText(CONDITIONS_HEADING, substring = true)
+    }
+    click(Ui.Operator.AcceptConditions)
+    poll(what = "the operator on with its servers and the conditions accepted") {
+      !exists(Ui.Operator.AcceptConditions) && exists(Ui.Operator.Use) && seesText(TEST_SERVERS) && seesText(ACCEPTED_ON, substring = true)
+    }
+    coreOperators().single { it.operatorId == simplex.operatorId }.let {
+      check(it.conditionsAcceptance.conditionsAccepted && !it.enabled) { "after `Accept conditions`, before `Save servers`: $it" }
+    }
+    operator.back()
+    poll(what = "the SimpleX Chat row marked as edited") { network.edited(Ui.Network.Operator(simplex.operatorId)) }
+    network.save(Ui.Network.Operator(simplex.operatorId))
+    coreOperators().let { ops ->
+      check(ops.single { it.operatorId == simplex.operatorId }.enabled && !ops.single { it.operatorId == flux.operatorId }.enabled) { "operators after saving: $ops" }
+    }
+    operator = network.operator(simplex.operatorId)
+    operator.toggleUse()
+    poll(what = "the operator off without the conditions sheet") { exists(Ui.Operator.Use) && !seesText(TEST_SERVERS) && !exists(Ui.Operator.AcceptConditions) }
+    operator.back()
+    poll(what = "the SimpleX Chat row marked as edited again") { network.edited(Ui.Network.Operator(simplex.operatorId)) }
+    network.save(Ui.Network.Operator(simplex.operatorId))
+    coreOperators().single { it.operatorId == simplex.operatorId }.let {
+      check(!it.enabled && it.conditionsAcceptance.conditionsAccepted) { "the operator after turning it off and saving: $it" }
+    }
+  }
+
+  @Test fun yourServers_testServers_allPass() = uiTest {
+    val alice = app("alice")
+    val smp = customServers().smpServers.single { it.enabled }
+    val xftp = customServers().xftpServers.single { it.enabled }
+    check(smp.tested == null && xftp.tested == null) { "the local servers are marked as tested before the test: $smp, $xftp" }
+    val network = networkAndServers(alice)
+    check(!network.edited(Ui.Network.YourServers)) { "`Your servers` is marked as edited before the test" }
+    val servers = network.yourServers()
+    poll(what = "the local SMP and XFTP servers under `Message servers` and `Media & file servers`") {
+      seesText("Message servers") && seesText("Media & file servers") &&
+        hostOf(smp.server) in textsOf(Ui.Servers.Server(smp.server)) && hostOf(xftp.server) in textsOf(Ui.Servers.Server(xftp.server))
+    }
+    servers.testAll()
+    check(!AlertManager.shared.hasAlertsShown() && !seesText(TEST_FAILED)) { "a local server failed the test: ${texts().take(40)}" }
+    servers.back()
+    poll(what = "`Your servers` marked as edited with the test results") { network.edited(Ui.Network.YourServers) }
+    network.save(Ui.Network.YourServers)
+    customServers().let { saved ->
+      check(saved.smpServers.single { it.server == smp.server }.tested == true && saved.xftpServers.single { it.server == xftp.server }.tested == true) {
+        "test results in the core after saving: $saved"
+      }
+    }
+  }
+
+  @Test fun yourServers_testServers_someFail() = uiTest {
+    val alice = app("alice")
+    val smp = customServers().smpServers.single { it.enabled }
+    val unreachable = unreachableSmpServer()
+    val network = networkAndServers(alice)
+    val servers = network.yourServers()
+    val new = servers.add()
+    new.enterAddress(unreachable)
+    new.test()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `$TEST_FAILED` alert for the new server") { seesText(TEST_FAILED) && exists(CONFIRM) }
+    check(!seesText(SOME_FAILED, substring = true)) { "testing one server showed the all-servers failure text" }
+    click(CONFIRM)
+    poll(what = "the alert to close") { !AlertManager.shared.hasAlertsShown() }
+    new.toggleUse()
+    new.back()
+    poll(what = "the new server listed in `Your servers`") { exists(Ui.Servers.Server(unreachable)) && UNREACHABLE_HOST in textsOf(Ui.Servers.Server(unreachable)) }
+    servers.testAll()
+    var failed: String? = null
+    poll(what = "the `$TEST_FAILED` alert listing the failed servers") {
+      failed = texts().firstOrNull { it.startsWith(SOME_FAILED) }
+      seesText(TEST_FAILED) && failed != null
+    }
+    check(listsServer(failed!!, UNREACHABLE_HOST) && !listsServer(failed!!, hostOf(smp.server)!!)) { "failed servers in the alert: $failed" }
+    click(CONFIRM)
+    poll(what = "the alert to close") { !AlertManager.shared.hasAlertsShown() }
+    servers.back()
+    network.save(Ui.Network.YourServers)
+    val saved = customServers().smpServers
+    check(customSmpServer(UNREACHABLE_HOST)?.let { it.enabled && it.tested == false } == true && saved.single { it.server == smp.server }.tested == true) {
+      "message servers in the core after saving: $saved"
+    }
+  }
+
+  @Test fun yourServers_addSmpManually() = uiTest {
+    val alice = app("alice")
+    val smp2 = TestServers.start("smp2")
+    TestServers.stop("smp2")
+    val host = hostOf(smp2)!!
+    check(customSmpServer(host) == null) { "smp2 is in the core before it is added: ${customServers().smpServers}" }
+    var network = networkAndServers(alice)
+    val servers = network.yourServers()
+    val new = servers.add()
+    new.enterAddress(smp2)
+    new.test()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the `$TEST_FAILED` alert while smp2 is stopped") { seesText(TEST_FAILED) && exists(CONFIRM) }
+    click(CONFIRM)
+    poll(what = "the alert to close") { !AlertManager.shared.hasAlertsShown() }
+    TestServers.start("smp2")
+    new.test()
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the test of the running smp2 to finish") { UiIdle.inFlight().isEmpty() }
+    check(!AlertManager.shared.hasAlertsShown() && !seesText(TEST_FAILED)) { "the running smp2 failed the test: ${texts().take(40)}" }
+    new.toggleUse()
+    new.back()
+    poll(what = "smp2 listed in `Your servers`") { exists(Ui.Servers.Server(smp2)) && host in textsOf(Ui.Servers.Server(smp2)) }
+    servers.back()
+    poll(what = "`Your servers` marked as edited") { network.edited(Ui.Network.YourServers) }
+    network.save(Ui.Network.YourServers)
+    val saved = customSmpServer(host) ?: throw AssertionError("smp2 is not in the core after saving: ${customServers().smpServers}")
+    check(saved.enabled && saved.tested == true) { "smp2 in the core after saving: $saved" }
+    network.close()
+    network = openNetworkFromSettings()
+    network.yourServers()
+    poll(what = "smp2 listed after reopening `Your servers`") { exists(Ui.Servers.Server(saved.server)) && host in textsOf(Ui.Servers.Server(saved.server)) }
+  }
+
+  @Test fun newServer_invalidAddress() = uiTest {
+    val alice = app("alice")
+    val before = customServers()
+    val network = networkAndServers(alice)
+    val servers = network.yourServers()
+    val new = servers.add()
+    new.enterAddress(INVALID_ADDRESS)
+    new.back()
+    poll(what = "the `Invalid server address!` alert") { seesText("Invalid server address!") && seesText("Check server address and try again.") && exists(CONFIRM) }
+    click(CONFIRM)
+    poll(what = "the alert to close") { !AlertManager.shared.hasAlertsShown() }
+    check(exists(Ui.Servers.Server(before.smpServers.single { it.enabled }.server)) && !exists(Ui.Servers.Server(INVALID_ADDRESS))) {
+      "`Your servers` after the invalid address: ${texts().take(40)}"
+    }
+    servers.back()
+    check(!network.edited(Ui.Network.YourServers)) { "`Your servers` is marked as edited after the invalid address" }
+    check(customServers() == before) { "the core servers changed: ${customServers()}" }
+  }
+
+  @Test fun serverView_toggleUseAndSave() = uiTest {
+    val alice = app("alice")
+    val smp = customServers().smpServers.single { it.enabled }
+    val second = addCustomSmpServerViaApi(unreachableSmpServer())
+    var network = networkAndServers(alice)
+    var servers = network.yourServers()
+    servers.open(second).apply { toggleUse(); back() }
+    servers.back()
+    poll(what = "`Your servers` marked as edited") { network.edited(Ui.Network.YourServers) }
+    network.save(Ui.Network.YourServers)
+    check(customSmpServer(UNREACHABLE_HOST)?.enabled == false && customServers().smpServers.single { it.server == smp.server }.enabled) {
+      "message servers after turning the second one off: ${customServers().smpServers}"
+    }
+    val after = restart()
+    poll(what = "chat running after the restart") { chatModel.chatRunning.value == true }
+    check(customSmpServer(UNREACHABLE_HOST)?.enabled == false) { "the second server is on again after the restart: ${customServers().smpServers}" }
+    network = networkAndServers(after)
+    servers = network.yourServers()
+    check(!seesText(NO_MESSAGE_SERVERS)) { "`$NO_MESSAGE_SERVERS` is shown with the local server on" }
+    servers.open(smp.server).apply { toggleUse(); back() }
+    poll(what = "`$NO_MESSAGE_SERVERS` in `Your servers`") { seesText(NO_MESSAGE_SERVERS) }
+    servers.back()
+    poll(what = "`$NO_MESSAGE_SERVERS` on `Network & servers`") { seesText(NO_MESSAGE_SERVERS) && network.edited(Ui.Network.YourServers) }
+    click(Ui.Network.SaveServers)
+    poll(what = "app work to finish after `Save servers`") { UiIdle.inFlight().isEmpty() }
+    check(!AlertManager.shared.hasAlertsShown() && network.edited(Ui.Network.YourServers)) { "`Save servers` acted with no message servers: ${texts().take(40)}" }
+    check(customServers().smpServers.single { it.server == smp.server }.enabled) { "the local server was turned off in the core" }
+    servers = network.yourServers()
+    servers.open(smp.server).apply { toggleUse(); back() }
+    poll(what = "`$NO_MESSAGE_SERVERS` gone with the local server on") { !seesText(NO_MESSAGE_SERVERS) && exists(Ui.Servers.Add) }
+    servers.open(second).apply { toggleUse(); back() }
+    servers.back()
+    poll(what = "`Your servers` marked as edited") { network.edited(Ui.Network.YourServers) }
+    network.save(Ui.Network.YourServers)
+    check(customSmpServer(UNREACHABLE_HOST)?.enabled == true) { "the second server after turning it on again: ${customServers().smpServers}" }
+  }
+
+  @Test fun serverView_deleteServer() = uiTest {
+    val alice = app("alice")
+    val smp = customServers().smpServers.single { it.enabled && hostOf(it.server) != UNREACHABLE_HOST }
+    val second = addCustomSmpServerViaApi(unreachableSmpServer())
+    val network = networkAndServers(alice)
+    val servers = network.yourServers()
+    poll(what = "both message servers listed") { exists(Ui.Servers.Server(second)) && exists(Ui.Servers.Server(smp.server)) }
+    servers.open(second).delete()
+    poll(what = "the deleted server gone from `Your servers` with the local server still listed") {
+      !exists(Ui.Servers.Server(second)) && exists(Ui.Servers.Server(smp.server))
+    }
+    servers.back()
+    poll(what = "`Your servers` marked as edited") { network.edited(Ui.Network.YourServers) }
+    network.save(Ui.Network.YourServers)
+    check(customSmpServer(UNREACHABLE_HOST) == null && customServers().smpServers.any { it.server == smp.server && it.enabled }) {
+      "message servers after deleting the second one: ${customServers().smpServers}"
+    }
+  }
+
+  @Test fun network_unsavedServersAlert_save() = uiTest {
+    val alice = app("alice")
+    val second = addCustomSmpServerViaApi(unreachableSmpServer())
+    networkAndServers(alice).close()
+    check(!AlertManager.shared.hasAlertsShown()) { "leaving `Network & servers` without changes showed an alert" }
+    var network = openNetworkFromSettings()
+    network.yourServers().apply { open(second).apply { toggleUse(); back() }; back() }
+    goBack()
+    poll(what = "the `Save servers?` alert with `Save` and `Exit without saving`") {
+      seesText("Save servers?") && exists(CONFIRM) && "Save" in textsOf(CONFIRM) && "Exit without saving" in textsOf(DISMISS)
+    }
+    click(DISMISS)
+    network.awaitClosed()
+    check(customSmpServer(UNREACHABLE_HOST)?.enabled == true) { "`Exit without saving` saved the change: ${customServers().smpServers}" }
+    network = openNetworkFromSettings()
+    check(!network.edited(Ui.Network.YourServers)) { "the discarded change is still pending" }
+    network.yourServers().apply { open(second).apply { toggleUse(); back() }; back() }
+    goBack()
+    poll(what = "the `Save servers?` alert") { seesText("Save servers?") && exists(CONFIRM) }
+    click(CONFIRM)
+    network.awaitClosed()
+    poll(what = "the change saved in the core") { customSmpServer(UNREACHABLE_HOST)?.enabled == false }
+  }
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/PrivacyTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/PrivacyTest.kt
index de87eb162d..22478cfa75 100644
--- a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/PrivacyTest.kt
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/PrivacyTest.kt
@@ -1,15 +1,58 @@
 package chat.simplex.app.ui.settings
 
 import chat.simplex.app.ui.harness.App
+import chat.simplex.app.ui.harness.CONNECT_TIMEOUT_MS
+import chat.simplex.app.ui.harness.CliPeer
 import chat.simplex.app.ui.harness.UiScope
 import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.backToChatList
 import chat.simplex.app.ui.harness.connect
+import chat.simplex.app.ui.harness.groupId
+import chat.simplex.app.ui.harness.hostGroup
+import chat.simplex.app.ui.harness.itemStatus
+import chat.simplex.app.ui.harness.linkGroupWithDirectMessages
+import chat.simplex.app.ui.harness.ownGroup
+import chat.simplex.app.ui.harness.switchAwayFromChat
+import chat.simplex.app.ui.harness.visitNotesAndBack
+import chat.simplex.app.ui.harness.yourPrivacy
+import chat.simplex.common.model.CIFile
+import chat.simplex.common.model.CIFileStatus
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.model.ChatInfo
+import chat.simplex.common.model.GroupMemberStatus
+import chat.simplex.common.model.MsgContent
+import chat.simplex.common.model.User
+import chat.simplex.common.model.UserMsgReceiptSettings
+import chat.simplex.common.platform.appFilesDir
+import chat.simplex.common.platform.chatController
 import chat.simplex.common.platform.chatModel
+import chat.simplex.common.platform.getAppFilePath
 import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiIdle
+import chat.simplex.common.views.helpers.AlertManager
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
 import org.junit.Test
+import java.io.File
 
 private const val SHOW_PREVIEWS = "PrivacyShowChatPreviews"
 private const val MESSAGE = "hello from bob"
+private const val ACCEPT_IMAGES = "PrivacyAcceptImages"
+private const val BLUR_RADIUS = "PrivacyMediaBlurRadius"
+private const val RECEIPTS_SET = "PrivacyDeliveryReceiptsSet"
+private const val ASKED_TO_RECEIVE = "Asked to receive the image"
+private const val FIXTURE_JPG = "tests/fixtures/test.jpg"
+private val BLUR_OPTIONS = listOf(0 to "Off", 12 to "Soft", 24 to "Medium", 48 to "Strong")
+private const val SAVE_DRAFT = "PrivacySaveLastDraft"
+private const val KEPT_DRAFT = "draft kept for bob"
+private const val LOST_DRAFT = "draft not kept"
+private const val ENCRYPT_FILES = "PrivacyEncryptLocalFiles"
+private const val MEMBER_HI = "hi from the group"
+private const val NOTES = "Private notes"
+private const val RECEIPTS_TITLE = "Delivery receipts!"
+private val JPEG_MAGIC = listOf(0xFF.toByte(), 0xD8.toByte(), 0xFF.toByte())
+private val CONFIRM = Ui.Alert.Confirm(Ui.AlertSource.Shared)
+private val DISMISS = Ui.Alert.Dismiss(Ui.AlertSource.Shared)
 
 class PrivacyTest : UiTest() {
   @Test fun morePrivacy_showLastMessages() = uiTest {
@@ -31,6 +74,270 @@ class PrivacyTest : UiTest() {
     poll(what = "bob's message on the row again") { MESSAGE in after.chatList.rowTexts("bob") }
   }
 
+  @Test fun privacy_autoAcceptImagesOff() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    check(storedSetting(ACCEPT_IMAGES) != "false") { "Auto-accept images is stored as off before it is turned off" }
+    val privacy = yourPrivacy(alice)
+    click(Ui.Privacy.AcceptImages)
+    poll(what = "Auto-accept images stored as off") { storedSetting(ACCEPT_IMAGES) == "false" && !appPrefs.privacyAcceptImages.get() }
+    privacy.close()
+    bob.sendsImage(1)
+    val chat = alice.chatList.open("bob")
+    val first = chat.itemId("bob's first image") { it.content.msgContent is MsgContent.MCImage }
+    poll(what = "the app to finish handling bob's first image") { UiIdle.inFlight().isEmpty() }
+    check(fileOf(first)?.fileStatus is CIFileStatus.RcvInvitation && ASKED_TO_RECEIVE in descriptionsOf(Ui.Chat.Item(first))) {
+      "the first image was not left to be received: ${fileOf(first)?.fileStatus}, ${descriptionsOf(Ui.Chat.Item(first))}"
+    }
+    check(appFilesDir.listFiles().isNullOrEmpty()) { "files were saved with Auto-accept images off: ${appFilesDir.listFiles()?.map { it.name }}" }
+    backToChatList()
+    val again = yourPrivacy(alice)
+    click(Ui.Privacy.AcceptImages)
+    poll(what = "Auto-accept images stored as on") { storedSetting(ACCEPT_IMAGES) == "true" && appPrefs.privacyAcceptImages.get() }
+    again.close()
+    bob.sendsImage(2)
+    val chatAgain = alice.chatList.open("bob")
+    val second = chatAgain.itemId("bob's second image") { it.content.msgContent is MsgContent.MCImage && it.id != first }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's second image to be received without a tap") { fileOf(second)?.fileStatus is CIFileStatus.RcvComplete }
+    check(fileOf(first)?.fileStatus is CIFileStatus.RcvInvitation) { "turning Auto-accept images on received the earlier image: ${fileOf(first)?.fileStatus}" }
+  }
+
+  @Test fun privacy_blurMediaOptions() = uiTest {
+    val alice = app("alice")
+    val privacy = yourPrivacy(alice)
+    check(textOf(Ui.Privacy.BlurMedia) == "Off" && storedSetting(BLUR_RADIUS) != "24") { "blur before the change: ${textOf(Ui.Privacy.BlurMedia)}, stored ${storedSetting(BLUR_RADIUS)}" }
+    click(Ui.Privacy.BlurMedia)
+    for ((radius, name) in BLUR_OPTIONS) {
+      check(name in textsOf(Ui.Privacy.BlurMedia.option(radius))) { "blur option $radius is not `$name`: ${textsOf(Ui.Privacy.BlurMedia.option(radius))}" }
+    }
+    click(Ui.Privacy.BlurMedia.option(24))
+    poll(what = "Medium blur shown and stored") { textOf(Ui.Privacy.BlurMedia) == "Medium" && storedSetting(BLUR_RADIUS) == "24" }
+    privacy.close()
+    val after = restart()
+    yourPrivacy(after)
+    assertEquals("Medium", textOf(Ui.Privacy.BlurMedia))
+    assertEquals(24, appPrefs.privacyMediaBlurRadius.get())
+  }
+
+  @Test fun receipts_contactsAndGroupsToggles_peerReceipts() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    clearReceiptsChoiceViaApi()
+    connect(bob)
+    ownGroup(alice, "team", bob)
+    backToChatList()
+    val direct = "@${bob.contactId("alice")}"
+    val team = "#${bob.groupId("team")}"
+    bob sends "@alice d0"
+    bob sends "#team g0"
+    awaitReceipt(bob, direct, "d0")
+    awaitReceipt(bob, team, "g0")
+    check(storedSetting(RECEIPTS_SET) != "true") { "the receipts choice is stored before any toggle" }
+    yourPrivacy(alice).more()
+    click(Ui.Privacy.ReceiptsContacts)
+    poll(what = "contact receipts off and the receipts choice stored") { !user().sendRcptsContacts && user().sendRcptsSmallGroups && storedSetting(RECEIPTS_SET) == "true" }
+    check(!AlertManager.shared.hasAlertsShown()) { "turning contact receipts off without overrides asked for confirmation" }
+    bob sends "@alice d1"
+    bob sends "#team g1"
+    awaitReceived(alice, "bob", "d1")
+    awaitReceived(alice, "team", "g1")
+    click(Ui.Privacy.ReceiptsGroups)
+    poll(what = "group receipts off") { !user().sendRcptsSmallGroups }
+    click(Ui.Privacy.ReceiptsContacts)
+    poll(what = "contact receipts on again") { user().sendRcptsContacts }
+    bob sends "@alice d2"
+    bob sends "#team g2"
+    awaitReceived(alice, "bob", "d2")
+    awaitReceived(alice, "team", "g2")
+    click(Ui.Privacy.ReceiptsGroups)
+    poll(what = "group receipts on again") { user().sendRcptsSmallGroups }
+    bob sends "#team g3"
+    awaitReceipt(bob, direct, "d2")
+    awaitReceipt(bob, team, "g3")
+    assertEquals("d1 sent while contact receipts were off", "sndSent", bob.itemStatus(direct, "d1"))
+    assertEquals("g1 sent while only contact receipts were off", "sndRcvd", bob.itemStatus(team, "g1"))
+    assertEquals("g2 sent while group receipts were off", "sndSent", bob.itemStatus(team, "g2"))
+  }
+
+  @Test fun privacy_autoAcceptGroupInvitations() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    hostGroup(bob, "club", "alice")
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's invitation to club pending for alice") { membershipStatus("club") == GroupMemberStatus.MemInvited }
+    check(!user().autoAcceptGroupInvitations && !coreUser().autoAcceptGroupInvitations) { "group invitations are auto-accepted before the setting is turned on" }
+    val privacy = yourPrivacy(alice)
+    click(Ui.Privacy.AutoAcceptGroupInvitations)
+    poll(what = "group invitations auto-accepted in the model and the core") { user().autoAcceptGroupInvitations && coreUser().autoAcceptGroupInvitations }
+    privacy.close()
+    hostGroup(bob, "team", "alice")
+    bob.eventually("#team: alice joined the group", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice connected to team without accepting the invitation") { membershipStatus("team") == GroupMemberStatus.MemConnected }
+    check(membershipStatus("club") == GroupMemberStatus.MemInvited) { "the invitation received before the setting was turned on was accepted: ${membershipStatus("club")}" }
+  }
+
+  @Test fun privacy_autoAcceptContactRequestsInGroups() = uiTest {
+    val alice = app("alice"); val cath = cli("cath")
+    linkGroupWithDirectMessages(alice, "team", cath).close()
+    backToChatList()
+    check(!user().autoAcceptMemberContacts && !coreUser().autoAcceptMemberContacts && directChat("cath") == null) { "member contacts are auto-accepted, or cath is a contact, before the setting is turned on" }
+    val privacy = yourPrivacy(alice)
+    click(Ui.Privacy.AutoAcceptMemberContacts)
+    poll(what = "member contact requests auto-accepted in the model and the core") { user().autoAcceptMemberContacts && coreUser().autoAcceptMemberContacts }
+    privacy.close()
+    cath sends "@#team alice $MEMBER_HI"
+    cath.eventuallyAll(
+      lines = listOf(
+        "member #team alice does not have direct connection, creating",
+        "contact for member #team alice is created",
+        "sent invitation to connect directly to member #team alice",
+      ),
+      messages = listOf("@alice $MEMBER_HI"),
+      timeoutMs = CONNECT_TIMEOUT_MS,
+    )
+    cath.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice's direct chat with cath connected without accepting") { directChat("cath")?.chatInfo?.ready == true }
+    alice.chatList.open("cath").itemId(MEMBER_HI)
+    poll(what = "the message field without `Accept` or `Reject`") { exists(Ui.Chat.Message) && !exists(Ui.Chat.RequestAccept) && !exists(Ui.Chat.RequestReject) }
+  }
+
+  @Test fun morePrivacy_messageDraftDisabledClears() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    val bobId = alice.chatList.chatId("bob")
+    alice.chatList.open("bob")
+    typeInto(Ui.Chat.Message, KEPT_DRAFT)
+    visitNotesAndBack(alice, "bob")
+    poll(what = "the draft restored with `Message draft` on") { editableText(Ui.Chat.Message) == KEPT_DRAFT }
+    switchAwayFromChat(alice)
+    poll(what = "the draft on bob's row") { alice.chatList.rowTexts("bob").any { it.endsWith(" $KEPT_DRAFT") } }
+    check(storedSetting(SAVE_DRAFT) != "false") { "`Message draft` is stored as off before it is turned off" }
+    val privacy = yourPrivacy(alice).more()
+    click(Ui.Privacy.SaveDraft)
+    poll(what = "`Message draft` stored as off") { storedSetting(SAVE_DRAFT) == "false" }
+    privacy.closeMore()
+    privacy.close()
+    poll(what = "bob's row without the draft") { alice.chatList.rowTexts("bob").let { "bob" in it && it.none { t -> t.endsWith(" $KEPT_DRAFT") } } }
+    alice.chatList.open("bob")
+    poll(what = "bob's field empty after turning `Message draft` off") { chatModel.chatId.value == bobId && editableText(Ui.Chat.Message).isNullOrEmpty() }
+    typeInto(Ui.Chat.Message, LOST_DRAFT)
+    visitNotesAndBack(alice, "bob")
+    poll(what = "bob's field empty after leaving the chat") { chatModel.chatId.value == bobId && editableText(Ui.Chat.Message).isNullOrEmpty() }
+    switchAwayFromChat(alice)
+    check(alice.chatList.rowTexts("bob").none { it.endsWith(" $LOST_DRAFT") }) { "a draft was saved with `Message draft` off: ${alice.chatList.rowTexts("bob")}" }
+  }
+
+  @Test fun morePrivacy_encryptLocalFilesOff() = uiTest {
+    val alice = app("alice"); val bob = cli("bob")
+    connect(bob)
+    check(storedSetting(ENCRYPT_FILES) != "false") { "`Encrypt local files` is stored as off before it is turned off" }
+    bob.sendsImage(1)
+    val chat = alice.chatList.open("bob")
+    val first = chat.itemId("bob's first image") { it.content.msgContent is MsgContent.MCImage }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's first image received") { fileOf(first)?.fileStatus is CIFileStatus.RcvComplete }
+    fileOf(first)!!.let { check(it.fileSource?.cryptoArgs != null && !storedAsPlainJpeg(it)) { "the first image is not stored encrypted: ${it.fileSource}" } }
+    backToChatList()
+    val privacy = yourPrivacy(alice).more()
+    click(Ui.Privacy.EncryptLocalFiles)
+    poll(what = "`Encrypt local files` stored as off and applied") { storedSetting(ENCRYPT_FILES) == "false" && UiIdle.inFlight().isEmpty() }
+    privacy.closeMore()
+    privacy.close()
+    bob.sendsImage(2)
+    val again = alice.chatList.open("bob")
+    val second = again.itemId("bob's second image") { it.content.msgContent is MsgContent.MCImage && it.id != first }
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's second image received") { fileOf(second)?.fileStatus is CIFileStatus.RcvComplete }
+    fileOf(second)!!.let { check(it.fileSource?.cryptoArgs == null && storedAsPlainJpeg(it)) { "the second image is not stored as the plain JPEG: ${it.fileSource}" } }
+    fileOf(first)!!.let { check(it.fileSource?.cryptoArgs != null && !storedAsPlainJpeg(it)) { "turning encryption off changed the first image: ${it.fileSource}" } }
+  }
+
+  @Test fun deliveryReceiptsStartupView_enable() = uiTest {
+    app("alice")
+    turnOffContactReceiptsViaApi()
+    clearReceiptsChoiceViaApi()
+    restart()
+    awaitReceiptsView()
+    check(!coreUser().sendRcptsContacts && storedSetting(RECEIPTS_SET) == "false") { "contact receipts are on, or the choice is stored, before Enable" }
+    click(Ui.DeliveryReceipts.Enable)
+    poll(what = "contact receipts on in the core, the choice stored and the chat list shown") {
+      coreUser().sendRcptsContacts && storedSetting(RECEIPTS_SET) == "true" && !exists(Ui.DeliveryReceipts.Enable) && exists(Ui.ChatList.Search)
+    }
+    val after = restart()
+    poll(what = "the chat list after the restart") { after.chatList.shown(NOTES) }
+    check(!exists(Ui.DeliveryReceipts.Enable) && !seesText(RECEIPTS_TITLE)) { "`$RECEIPTS_TITLE` shown again after Enable" }
+  }
+
+  @Test fun deliveryReceiptsStartupView_skip() = uiTest {
+    app("alice")
+    turnOffContactReceiptsViaApi()
+    clearReceiptsChoiceViaApi()
+    restart()
+    awaitReceiptsView()
+    click(Ui.DeliveryReceipts.Skip)
+    awaitReceiptsDisabledAlert()
+    click(CONFIRM)
+    poll(what = "the chat list after OK") { !AlertManager.shared.hasAlertsShown() && !exists(Ui.DeliveryReceipts.Enable) && exists(Ui.ChatList.Search) }
+    check(storedSetting(RECEIPTS_SET) == "false" && !coreUser().sendRcptsContacts) { "OK stored the choice or turned contact receipts on" }
+    restart()
+    awaitReceiptsView()
+    click(Ui.DeliveryReceipts.Skip)
+    awaitReceiptsDisabledAlert()
+    click(DISMISS)
+    poll(what = "the chat list and the choice stored after `Don't show again`") {
+      !AlertManager.shared.hasAlertsShown() && exists(Ui.ChatList.Search) && storedSetting(RECEIPTS_SET) == "true"
+    }
+    check(!coreUser().sendRcptsContacts) { "`Don't show again` turned contact receipts on" }
+    val after = restart()
+    poll(what = "the chat list after the restart") { after.chatList.shown(NOTES) }
+    check(!exists(Ui.DeliveryReceipts.Enable) && !seesText(RECEIPTS_TITLE)) { "`$RECEIPTS_TITLE` shown again after `Don't show again`" }
+  }
+
+  private fun CliPeer.sendsImage(fileId: Int) {
+    this sends "/img @alice $FIXTURE_JPG"
+    this expectsMessage "/f @alice $FIXTURE_JPG"
+    this expects "use /fc $fileId to cancel sending"
+    eventually("completed uploading file $fileId (test.jpg) for alice", CONNECT_TIMEOUT_MS)
+  }
+
+  private fun fileOf(id: Long): CIFile? = chatModel.chatsContext.chatItems.value.firstOrNull { it.id == id }?.file
+
+  private fun user(): User = chatModel.currentUser.value!!
+
+  private fun clearReceiptsChoiceViaApi() = appPrefs.privacyDeliveryReceiptsSet.set(false)
+
+  private fun coreUser(): User = runBlocking { chatController.listUsers(null) }.first { it.user.activeUser }.user
+
+  private fun turnOffContactReceiptsViaApi() {
+    val u = user()
+    runBlocking { chatController.apiSetUserContactReceipts(u, UserMsgReceiptSettings(enable = false, clearOverrides = false)) }
+    chatModel.currentUser.value = u.copy(sendRcptsContacts = false)
+  }
+
+  private fun membershipStatus(group: String): GroupMemberStatus? =
+    (chatModel.chats.value.firstOrNull { it.chatInfo.chatViewName == group }?.chatInfo as? ChatInfo.Group)?.groupInfo?.membership?.memberStatus
+
+  private fun directChat(name: String) =
+    chatModel.chats.value.firstOrNull { (it.chatInfo as? ChatInfo.Direct)?.contact?.displayName == name }
+
+  private fun storedAsPlainJpeg(file: CIFile): Boolean {
+    val bytes = File(getAppFilePath(file.fileSource!!.filePath)).readBytes()
+    return bytes.size.toLong() == file.fileSize && bytes.take(JPEG_MAGIC.size) == JPEG_MAGIC
+  }
+
+  private fun UiScope.awaitReceiptsView() =
+    poll(what = "the `$RECEIPTS_TITLE` screen with Enable and `Don't enable`") {
+      seesText(RECEIPTS_TITLE) && exists(Ui.DeliveryReceipts.Enable) && exists(Ui.DeliveryReceipts.Skip) && !exists(Ui.ChatList.Search)
+    }
+
+  private fun UiScope.awaitReceiptsDisabledAlert() =
+    poll(what = "the `Delivery receipts are disabled!` alert with OK and `Don't show again`") {
+      seesText("Delivery receipts are disabled!") && seesText("You can enable them later via app Your privacy settings.") &&
+        "OK" in textsOf(CONFIRM) && "Don't show again" in textsOf(DISMISS)
+    }
+
+  private fun UiScope.awaitReceipt(peer: CliPeer, chatRef: String, text: String) =
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "${peer.name} to get alice's receipt for `$text`") { peer.itemStatus(chatRef, text) == "sndRcvd" }
+
+  private fun UiScope.awaitReceived(app: App, chat: String, text: String) =
+    poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice to receive `$text` in $chat") { app.chatList.chat(chat).chatItems.any { it.content.text == text } }
+
   private fun UiScope.toggleShowLastMessages(app: App) {
     app.settings()
     click(Ui.Settings.Privacy)
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/SettingsRootTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/SettingsRootTest.kt
new file mode 100644
index 0000000000..927ae9ef34
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/SettingsRootTest.kt
@@ -0,0 +1,106 @@
+package chat.simplex.app.ui.settings
+
+import chat.simplex.app.ui.harness.ChatDataScreen
+import chat.simplex.app.ui.harness.UiScope
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.WhatsNewScreen
+import chat.simplex.app.ui.harness.chatRunningInCore
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import chat.simplex.common.ui.UiKey
+import chat.simplex.common.ui.theme.CurrentColors
+import chat.simplex.common.ui.theme.DefaultTheme
+import chat.simplex.common.ui.theme.DefaultThemeMode
+import org.junit.Test
+
+private const val CURRENT_THEME = "CurrentTheme"
+private const val CHAT_STOPPED = "Chat is stopped"
+private const val ABOUT_TEXT = "Private and secure messaging."
+
+private class SettingsRow(val name: String, val key: UiKey, val title: String, val content: String) {
+  fun shown(s: UiScope): Boolean = s.seesText(title) && s.seesText(content)
+}
+
+private val APPEARANCE = SettingsRow("Appearance", Ui.Settings.Appearance, "Appearance", "Color mode")
+private val PRIVACY = SettingsRow("Your privacy", Ui.Settings.Privacy, "Your privacy", "More privacy")
+private val HELP = SettingsRow("Help & support", Ui.Settings.Help, "Help & support", "How to use it")
+private val CHAT_DATA = SettingsRow("Chat data", Ui.Settings.Database, "Chat data", "Database passphrase & export")
+private val NETWORK = SettingsRow("Network & servers", Ui.Settings.Network, "Network & servers", "Advanced network settings")
+private val CALLS = SettingsRow("Audio & video calls", Ui.Settings.Calls, "Your calls", "Always use relay")
+private val VERSION = SettingsRow("the version row", Ui.Settings.Version, "App version", "Developer tools")
+private val ROWS = listOf(APPEARANCE, PRIVACY, HELP, CHAT_DATA, NETWORK, CALLS, VERSION)
+
+class SettingsRootTest : UiTest() {
+  @Test fun settingsRoot_rowsOpenTheirScreens() = uiTest {
+    val alice = app("alice")
+    alice.settings()
+    poll(what = "Your settings with all its rows") { seesText("Your settings") && ROWS.all { exists(it.key) } }
+    check(ROWS.none { it.shown(this) }) { "a settings screen is shown before any row was clicked: ${ROWS.filter { it.shown(this) }.map { it.name }}" }
+    for (row in ROWS) {
+      click(row.key)
+      poll(what = "${row.name} open in place of Your settings, and no other settings screen") {
+        row.shown(this) && !exists(Ui.Settings.Appearance) && ROWS.none { it !== row && seesText(it.content) }
+      }
+      escape()
+      poll(what = "Your settings again after closing ${row.name}") { exists(Ui.Settings.Appearance) && !seesText(row.content) }
+    }
+    escape()
+    poll(what = "Your settings to close") { !exists(Ui.Settings.Appearance) && exists(Ui.ChatList.Search) }
+  }
+
+  @Test fun settingsRoot_itemsDisabledWhenChatStopped() = uiTest {
+    val alice = app("alice")
+    alice.settings()
+    check(CHAT_STOPPED !in descriptionsOf(Ui.Settings.Database)) { "Chat data is marked as stopped while the chat runs" }
+    click(Ui.Settings.Database)
+    waitFor(Ui.Database.Management)
+    ChatDataScreen(this).management()
+    click(Ui.Database.RunChat)
+    poll(what = "the Stop chat? alert with Stop") { seesText("Stop chat?") && "Stop" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+    click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    poll(what = "the chat stopped on screen and in the core") { seesText(CHAT_STOPPED) && chatModel.chatRunning.value == false && !chatRunningInCore() }
+    escape()
+    poll(what = "Chat data again") { !exists(Ui.Database.RunChat) && exists(Ui.Database.Management) }
+    escape()
+    poll(what = "Your settings with Chat data marked as stopped") { exists(Ui.Settings.Privacy) && CHAT_STOPPED in descriptionsOf(Ui.Settings.Database) }
+    for (row in listOf(PRIVACY, NETWORK, CALLS)) {
+      click(row.key)
+      settle()
+      check(exists(Ui.Settings.Appearance) && !row.shown(this)) { "${row.name} opened while the chat is stopped" }
+    }
+    click(Ui.Settings.Help)
+    poll(what = "Help & support opening while the chat is stopped") { exists(Ui.Help.HowToUse) && !exists(Ui.Settings.Appearance) }
+    click(Ui.Help.HowToUse)
+    settle()
+    check(exists(Ui.Help.HowToUse) && !seesText("Welcome alice!")) { "How to use it opened while the chat is stopped" }
+    click(Ui.Help.WhatsNew)
+    settle()
+    check(exists(Ui.Help.WhatsNew) && !WhatsNewScreen(this).shown()) { "What's new opened while the chat is stopped" }
+    click(Ui.Help.About)
+    poll(what = "About SimpleX Chat opening while the chat is stopped") { seesText(ABOUT_TEXT) && !exists(Ui.Help.HowToUse) }
+  }
+
+  @Test fun userPicker_colorModeSwitcher() = uiTest {
+    val alice = app("alice")
+    val systemMode = CurrentColors.value.base.mode
+    val flipped = if (systemMode == DefaultThemeMode.LIGHT) DefaultThemeMode.DARK else DefaultThemeMode.LIGHT
+    check(CurrentColors.value.name == DefaultTheme.SYSTEM_THEME_NAME && storedSetting(CURRENT_THEME).let { it == null || it == DefaultTheme.SYSTEM_THEME_NAME }) {
+      "the color mode is not System before the switch: ${CurrentColors.value.name}, stored ${storedSetting(CURRENT_THEME)}"
+    }
+    alice.userPicker()
+    click(Ui.UserPicker.ColorMode)
+    poll(what = "the opposite color mode applied and stored") { CurrentColors.value.base.mode == flipped && storedSetting(CURRENT_THEME) == themeName(flipped) }
+    click(Ui.UserPicker.ColorMode)
+    poll(what = "the first color mode applied again, stored as an explicit theme") {
+      CurrentColors.value.base.mode == systemMode && storedSetting(CURRENT_THEME) == themeName(systemMode)
+    }
+    rightClick(Ui.UserPicker.ColorMode)
+    poll(what = "the System color mode applied and stored") {
+      CurrentColors.value.name == DefaultTheme.SYSTEM_THEME_NAME && storedSetting(CURRENT_THEME) == DefaultTheme.SYSTEM_THEME_NAME
+    }
+  }
+
+  private fun themeName(mode: DefaultThemeMode): String =
+    if (mode == DefaultThemeMode.LIGHT) DefaultTheme.LIGHT.themeName else appPrefs.systemDarkTheme.get()!!
+}
diff --git a/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/VersionDevToolsTest.kt b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/VersionDevToolsTest.kt
new file mode 100644
index 0000000000..9010edaef1
--- /dev/null
+++ b/apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/settings/VersionDevToolsTest.kt
@@ -0,0 +1,90 @@
+package chat.simplex.app.ui.settings
+
+import chat.simplex.app.ui.harness.UiTest
+import chat.simplex.app.ui.harness.chatConsole
+import chat.simplex.app.ui.harness.closeDeveloperTools
+import chat.simplex.app.ui.harness.consoleShows
+import chat.simplex.app.ui.harness.developerTools
+import chat.simplex.common.BuildConfigCommon
+import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.platform.appPlatform
+import chat.simplex.common.platform.chatController
+import chat.simplex.common.platform.chatModel
+import chat.simplex.common.ui.Ui
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+private const val DEVELOPER_TOOLS = "DeveloperTools"
+private const val SHOW_FOOTER = "Show: Database IDs and Transport isolation option."
+private const val HIDE_FOOTER = "Hide: Database IDs and Transport isolation option."
+private const val CONTACTS_CMD = "/contacts"
+private const val SQL_CMD = "/sql chat select 1"
+private const val SQL_BLOCKED = "error chat commandError Failed reading: empty"
+private const val ONE_HAND_CARD_SHOWN = "OneHandUICardShown"
+private const val TALK_TO_SOMEONE = "Talk to someone"
+
+class VersionDevToolsTest : UiTest() {
+  @Test fun version_screenShowsVersions() = uiTest {
+    val alice = app("alice")
+    val (name, code) =
+      if (appPlatform.isDesktop) BuildConfigCommon.DESKTOP_VERSION_NAME to BuildConfigCommon.DESKTOP_VERSION_CODE
+      else BuildConfigCommon.ANDROID_VERSION_NAME to BuildConfigCommon.ANDROID_VERSION_CODE
+    val core = runBlocking { chatController.apiGetVersion() } ?: error("the core did not return its version")
+    alice.settings()
+    assertEquals("$name ($code)", textOf(Ui.Settings.Version))
+    check(!seesText("App build: $code")) { "the build is shown before the version screen opened" }
+    click(Ui.Settings.Version)
+    poll(what = "the App version screen with the app build and the core and simplexmq versions") {
+      seesText("App version") && seesText("App version: v$name") && seesText("App build: $code") &&
+        seesText("Core version: v${core.version}") && seesText("simplexmq: v${core.simplexmqVersion} (${core.simplexmqCommit.take(7).padStart(2)})")
+    }
+  }
+
+  @Test fun dev_showDeveloperOptionsSection() = uiTest {
+    val alice = app("alice")
+    developerTools(alice)
+    check(storedSetting(DEVELOPER_TOOLS) != "true" && seesText(HIDE_FOOTER) && !seesText(SHOW_FOOTER) && !seesText("Enable logs")) {
+      "developer options before the switch: stored ${storedSetting(DEVELOPER_TOOLS)}, texts ${texts().take(40)}"
+    }
+    click(Ui.DevTools.ShowOptions)
+    poll(what = "the Developer options section with the Show footer, stored as on") {
+      storedSetting(DEVELOPER_TOOLS) == "true" && seesText(SHOW_FOOTER) && !seesText(HIDE_FOOTER) && seesText("Enable logs") && seesText("Show internal errors")
+    }
+    click(Ui.DevTools.ShowOptions)
+    poll(what = "the Developer options section hidden with the Hide footer, stored as off") {
+      storedSetting(DEVELOPER_TOOLS) == "false" && seesText(HIDE_FOOTER) && !seesText(SHOW_FOOTER) && !seesText("Enable logs") && !seesText("Show internal errors")
+    }
+  }
+
+  @Test fun console_sendCommand() = uiTest {
+    val alice = app("alice")
+    chatConsole(alice)
+    check(!consoleShows("> $CONTACTS_CMD") && !consoleShows("> $SQL_CMD")) { "the commands are in the console before they were sent" }
+    typeInto(Ui.Chat.Message, CONTACTS_CMD)
+    click(Ui.Chat.Send)
+    poll(what = "the command and the core's contactsList response in the console, and the field cleared") {
+      consoleShows("> $CONTACTS_CMD") && consoleShows("< * contactsList") && editableText(Ui.Chat.Message).isNullOrEmpty()
+    }
+    typeInto(Ui.Chat.Message, SQL_CMD)
+    click(Ui.Chat.Send)
+    poll(what = "the /sql command and the error response in the console") { consoleShows("> $SQL_CMD") && consoleShows("< error chat") }
+    val items = chatModel.terminalItems.value
+    val cmd = items.indexOfLast { it.label == "> $SQL_CMD" }
+    assertEquals("the response to $SQL_CMD without SimpleX Lock and developer tools", SQL_BLOCKED, items.getOrNull(cmd + 1)?.details)
+  }
+
+  @Test fun dev_resetAllHints() = uiTest {
+    val alice = app("alice")
+    waitFor(Ui.ChatList.Search)
+    check(appPrefs.oneHandUICardShown.get() && !appPrefs.hintPreferences.all { it.isUnchanged() } && !exists(Ui.ChatList.OneHandCard) && !seesText(TALK_TO_SOMEONE)) {
+      "the hints are already reset before Reset all hints: card shown ${exists(Ui.ChatList.OneHandCard)}, onboarding shown ${seesText(TALK_TO_SOMEONE)}"
+    }
+    developerTools(alice)
+    click(Ui.DevTools.ResetHints)
+    poll(what = "every hint preference back to its default, the one-hand card hint stored as not shown") {
+      appPrefs.hintPreferences.all { it.isUnchanged() } && storedSetting(ONE_HAND_CARD_SHOWN) == "false"
+    }
+    closeDeveloperTools("the connect onboarding in place of the chat list") { seesText(TALK_TO_SOMEONE) && !exists(Ui.ChatList.Search) }
+  }
+}
diff --git a/apps/multiplatform/scripts/uitest-android.sh b/apps/multiplatform/scripts/uitest-android.sh
index d022af3bca..c74c00e725 100755
--- a/apps/multiplatform/scripts/uitest-android.sh
+++ b/apps/multiplatform/scripts/uitest-android.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 # Usage: scripts/uitest-android.sh <app.apk> <androidTest.apk> [am instrument -e args...]
-# Needs scripts/uitest.sh to have run once (it builds the CLI and test servers and writes build/uitest/env.properties).
+# Needs scripts/uitest.sh to have run once, or `scripts/uitest.sh --prepare-only` (it builds the CLI and test servers and writes build/uitest/env.properties).
 # Env:
 #   UITEST_SERIAL  adb serial of the device or emulator to use; when unset, a Waydroid instance is claimed with scripts/waydroid/wd.sh
 #   WD_SH          another wd.sh to use (default scripts/waydroid/wd.sh; see scripts/waydroid/README.md)
@@ -25,10 +25,10 @@ bridge_log="$out/bridge.log"
 avail_mb=$(awk '/^MemAvailable:/ {print int($2 / 1024)}' /proc/meminfo)
 [ "$avail_mb" -ge 4500 ] || { echo "uitest-android: only $avail_mb MB available, need 4500 (bridge + Waydroid); free memory first" >&2; exit 1; }
 java="${JAVA_HOME:+$JAVA_HOME/bin/}java"
-[ -s "$mp/build/uitest/env.properties" ] || { echo "uitest-android: run scripts/uitest.sh once first; it builds the CLI and test servers and writes build/uitest/env.properties" >&2; exit 1; }
+[ -s "$mp/build/uitest/env.properties" ] || { echo "uitest-android: run scripts/uitest.sh (or scripts/uitest.sh --prepare-only) once first; it builds the CLI and test servers and writes build/uitest/env.properties" >&2; exit 1; }
 cp_file="$mp/build/uitest/bridge.classpath"
 h="$mp/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness"
-bridge_srcs="$h/UiBridge.kt $h/CliPeer.kt $h/VtScreen.kt $h/TestServers.kt $h/UiEnv.kt $h/UiJvm.kt $mp/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ServersConfig.kt $mp/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PeerLines.kt"
+bridge_srcs="$h/UiBridge.kt $h/CliPeer.kt $h/VtScreen.kt $h/TestServers.kt $h/Socks5Stub.kt $h/UiEnv.kt $h/UiJvm.kt $mp/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/ServersConfig.kt $mp/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/PeerLines.kt"
 wd_pid=
 cleanup() {
   [ -z "${bridge_pid:-}" ] || kill -TERM "$bridge_pid" 2>/dev/null || true
@@ -80,7 +80,7 @@ else
 fi
 adb -s "$serial" install -r -t "$test_apk"
 step "APKs installed"
-for p in 7777 $((base + 1)) $((base + 2)); do adb -s "$serial" reverse "tcp:$p" "tcp:$p" >/dev/null; done
+for p in 7777 $((base + 1)) $((base + 2)) $((base + 11)) $((base + 12)) $((base + 20)) $((base + 90)); do adb -s "$serial" reverse "tcp:$p" "tcp:$p" >/dev/null; done
 prepare_app() {
   adb -s "$serial" shell pm clear "$pkg" >/dev/null
   adb -s "$serial" shell settings put global heads_up_notifications_enabled 0
diff --git a/apps/multiplatform/scripts/uitest.sh b/apps/multiplatform/scripts/uitest.sh
index c0c268d790..6c9bda668c 100755
--- a/apps/multiplatform/scripts/uitest.sh
+++ b/apps/multiplatform/scripts/uitest.sh
@@ -1,5 +1,7 @@
 #!/bin/sh
 # Usage: scripts/uitest.sh [gradle args]   e.g. --tests '*ChatListMenuTest', -PuiForks=2, -PuiForkEvery=N
+#        scripts/uitest.sh --prepare-only   only the CLI, test servers, peer template and build/uitest/env.properties (for uitest-android.sh)
+# Env: UITEST_CLI and UITEST_SERVERS, absolute paths of a prebuilt CLI and uitest-servers (cabal -f uitest), skip the cabal build.
 # Runs the desktop UI tests (common/src/uiTestShared + desktopTest/.../ui) in a private network namespace with local servers.
 # Needs cabal/GHC for the CLI peers and test servers, and the desktop native libs (./gradlew :desktop:cmakeBuildAndCopy).
 # Results: common/build/reports/tests/desktopUiTest/pass1; run directories (failure screenshots) in build/uitest/run-*.
@@ -17,6 +19,12 @@ if [ "${1:-}" = "--inside" ]; then
   SIMPLEX_UITEST_RUNNER=1 ./gradlew -g "$home" --offline --no-daemon "$kotlin_in_process" :common:desktopUiTest -PuiRunDir="$run" -PuiPass=1 "$@"
   exit $?
 fi
+prepare_only=
+if [ "${1:-}" = "--prepare-only" ]; then
+  shift
+  [ "$#" -eq 0 ] || { echo "uitest: --prepare-only takes no other arguments" >&2; exit 1; }
+  prepare_only=1
+fi
 
 avail_mb=$(awk '/^MemAvailable:/ {print int($2 / 1024)}' /proc/meminfo)
 [ "$avail_mb" -ge 3000 ] || { echo "uitest: only $avail_mb MB available, need 3000; free memory first" >&2; exit 1; }
@@ -28,9 +36,17 @@ mkdir -p "$run/jvmtmp" "$run/cache"
 ls -1dt build/uitest/run-* 2>/dev/null | tail -n +7 | xargs -r rm -rf
 
 repo=$(cd ../.. && pwd)
-(cd "$repo" && cabal build -O0 -f uitest --builddir=dist-uitest exe:simplex-chat exe:uitest-servers)
-cli=$(cd "$repo" && cabal list-bin -O0 -f uitest --builddir=dist-uitest exe:simplex-chat)
-servers=$(cd "$repo" && cabal list-bin -O0 -f uitest --builddir=dist-uitest exe:uitest-servers)
+if [ -n "${UITEST_CLI:-}${UITEST_SERVERS:-}" ]; then
+  for exe in "${UITEST_CLI:-}" "${UITEST_SERVERS:-}"; do
+    case "$exe" in /*) [ -x "$exe" ] ;; *) false ;; esac || { echo "uitest: UITEST_CLI and UITEST_SERVERS must both be absolute paths of executables" >&2; exit 1; }
+  done
+  cli=$UITEST_CLI
+  servers=$UITEST_SERVERS
+else
+  (cd "$repo" && cabal build -O0 -f uitest --builddir=dist-uitest exe:simplex-chat exe:uitest-servers | tail -n 1)
+  cli=$(cd "$repo" && cabal list-bin -O0 -f uitest --builddir=dist-uitest exe:simplex-chat | tail -n 1)
+  servers=$(cd "$repo" && cabal list-bin -O0 -f uitest --builddir=dist-uitest exe:uitest-servers | tail -n 1)
+fi
 
 peer_template() {
   t="$run/peer-template.tmp"
@@ -45,13 +61,26 @@ peer_template() {
 peer_template &
 template_pid=$!
 
+lib=common/src/commonMain/cpp/desktop/libs/linux-x86_64/libapp-lib.so
+cat > build/uitest/env.properties <<ENV
+libAppLib=$PWD/$lib
+runDir=$run
+repoRoot=$repo
+cli=$cli
+servers=$servers
+ENV
+if [ -n "$prepare_only" ]; then
+  wait "$template_pid"
+  echo "uitest: prepared $run and build/uitest/env.properties"
+  exit 0
+fi
+
 [ -d common/src/commonMain/cpp/desktop/libs/linux-x86_64 ] || { echo "uitest: native libs missing in common/src/commonMain/cpp/desktop/libs/linux-x86_64; build the desktop app once (./gradlew :desktop:cmakeBuildAndCopy)" >&2; exit 1; }
 prepare_key=$({
   find . -path ./build -prune -o -path ./.gradle -prune -o -path '*/build' -prune -o \( -name '*.gradle.kts' -o -name gradle.properties -o -name '*.versions.toml' \) -type f -print
   find common/src/commonMain/cpp -path '*/libs' -prune -o -type f -print
 } | LC_ALL=C sort | xargs sha256sum | sha256sum; ls -l --time-style=full-iso common/src/commonMain/cpp/desktop/libs/linux-x86_64 | grep -v libapp-lib.so)
 prepare_key=$(printf '%s' "$prepare_key" | sha256sum | cut -d' ' -f1)
-lib=common/src/commonMain/cpp/desktop/libs/linux-x86_64/libapp-lib.so
 if [ "$prepare_key" = "$(cat build/uitest/prepare.key 2>/dev/null)" ] && [ -f "$lib" ]; then
   echo "uitest: build files and native libs unchanged, skipping the outside Gradle step"
 else
@@ -60,14 +89,6 @@ else
   ./gradlew -g "$home" --stop >/dev/null 2>&1 || true
   echo "$prepare_key" > build/uitest/prepare.key
 fi
-
-cat > build/uitest/env.properties <<ENV
-libAppLib=$PWD/$lib
-runDir=$run
-repoRoot=$repo
-cli=$cli
-servers=$servers
-ENV
 wait "$template_pid"
 
 case " $* " in
diff --git a/plans/ui-tests/2026-10-10-desktop-ui-test-dsl-plan.md b/plans/ui-tests/2026-10-10-desktop-ui-test-dsl-plan.md
index 5d57496ff1..53934d850f 100644
--- a/plans/ui-tests/2026-10-10-desktop-ui-test-dsl-plan.md
+++ b/plans/ui-tests/2026-10-10-desktop-ui-test-dsl-plan.md
@@ -128,21 +128,35 @@ Sections 3–11 remain the design. This section describes what is implemented in
   - typing: write, wait until the input line equals the text (1.5 s unchanged window), else erase with DEL and retype (5 attempts); Enter, and Enter once more if the line still holds the text after 500 ms;
   - `VtScreen` is the terminal model.
 - **Android `CliPeer`** talks to the host through `Bridge`: TCP `127.0.0.1:7777` (fixed, through `adb reverse`), a 60 s read timeout, one connection per instrumentation process.
-- **The bridge** (`UiBridge.kt`, in the desktop harness; the Android runner starts it as a host JVM) owns `TestServers` and desktop `CliPeer`s, serves one client at a time, and stops all peers when the client disconnects. Protocol, one line per command:
+- **The bridge** (`UiBridge.kt`, in the desktop harness; the Android runner starts it as a host JVM) owns `TestServers` and desktop `CliPeer`s, serves one client at a time, and when the client disconnects stops all peers and the SOCKS stub and restores the server baseline. Protocol, one line per command:
   - `servers` → `ok <smp1> <xftp1>`;
+  - `remotePort` → `ok <port>`: the port a bridge CLI peer acting as a remote-desktop controller listens on (`TestServers.remoteCtrlPort`, port base + 90; the Android runner forwards it with `adb reverse`);
   - `start <name> <flags, comma-separated>` → `ok` once the peer has started;
   - `type <name> <text>` → `ok`;
   - `drain <name>` → `lines N`, then N lines;
   - `stop <name>` → `ok`;
+  - `server start|stop|reset|address <name>` → `ok [<address>]`, `server baseline` → `ok` (0.5.6);
+  - `socks start` → `ok <port>`, `socks connections` → `lines N` + N lines, `socks stop` → `ok` (0.5.6);
   - any failure → `err <message>`.
 
   Matching runs device-side in `PeerLines`. Bridge peer directories (`<bridge jvm>/bridge-peers/<nanoTime>-<name>`) are not deleted.
+- **Remote desktop** (`RemoteScreens.kt`, shared): a current-build CLI peer plays either side; no Haskell or core change is needed.
+  - CLI as the mobile host (desktop GUI controller, 04 §K): `setDeviceName`, `connectRemoteCtrl(invitation)` → `RemoteCtrlOffer(ctrlName, sessionCode)`, `verifyRemoteCtrl(code)` → controller name, `stopRemoteCtrl()`. The invitation is read with "Share link" (developer tools on) from the in-memory clipboard. Inside the runner's namespace the only interface is `lo`, so the app's TLS server (random port) offers 127.0.0.1 and the CLI connects to it; no multicast is involved for a new pairing.
+  - CLI as the controller (Android GUI host, 05 §12): `startRemoteHost(port)` sends `/start remote host new addr=127.0.0.1 iface="lo" port=<port>` and returns the invitation; `awaitRemoteHostCode()`, `awaitNewRemoteHost()` → host name. The controller runs in the bridge on the host, listens on `Bridge.remoteCtrlPort()` (port base + 90, all interfaces), and the device reaches 127.0.0.1:<port> through `adb reverse`, so no Waydroid bridge address or multicast is needed.
+  - GUI: `linkMobile(app)` → `LinkMobileScreen` (`deviceName()`, `addMobile()` → invitation), `linkMobileHost(app, mobile, name)` → remote host id, `awaitMobileSession(name)`; `useFromDesktop(app)` → `ConnectDesktopScreen` (`deviceName()`, `paste`, `connect`, `confirm(code)`, `awaitConnected(desktopName, code)`), `linkToDesktop(app, controller, desktopName, port)`. Cleanup through the API: `endMobileSessionViaApi(mobile)`, `endDesktopSessionViaApi(controller)`; a test must not end with a session open, because stopping the peer afterwards makes the app switch profiles during the next reset.
 
 ### 0.5.6 Servers
 
-- `tests/UITestServers.hs` (cabal flag `uitest`, `exe:uitest-servers`) takes `<dir> <portBase>`, runs **`smp1` only** (persistent store, port base + 1), prints `ready smp1 smp://…@localhost:<port>` and exits on stdin EOF. It has no control protocol.
-- `TestServers`: 120 slots (`slot-<k>.lock` in the run directory), base 20000 + 100 k. It is spawned under `setpriv --pdeathsig KILL` from the test thread during the first reset (in the bridge, from its main thread).
-- `configureServers(smp, xftp)` disables the operator groups and adds a custom group with `smp1` and `xftp1` (base + 2). Since 2026-10-19 `uitest-servers` also runs the XFTP server (`xftpServerConfig` from `tests/ChatClient.hs`, files in `<servers>/xftp1`) and prints `ready xftp1 …`; CLI peers get `--xftp-server`. `CliPeer.createFile(name, content)` writes a file on the peer's host (Android: through the bridge `file` command). Any XFTP test fails until P1b.
+- `tests/UITestServers.hs` (cabal flag `uitest`, `exe:uitest-servers`) takes `<dir> <portBase>`, starts `smp1` (`localhost`, base + 1) and `xftp1` (`localhost`, base + 2) at launch, prints `ready <name> <address>` for each, and exits on stdin EOF. `smp2` (`127.0.0.1`, base + 11) and `xftp2` (`127.0.0.1`, base + 12) start only on request; the different host is needed because `/_servers` rejects two servers with the same host. Each server keeps its store in `<servers>/<name>` (SMP: `persistentServerStoreCfg`, so queues and undelivered messages survive a restart; XFTP: store log and files). Control protocol on stdin, one line per command, answered on stdout (server log lines are ignored):
+  - `start <name>` → `ready <name> <address>` once it listens (also when it already runs);
+  - `stop <name>` → `stopped <name>` after the server has saved its store and closed its port (`cancel` of its thread, which runs the server's own `finally` save);
+  - `reset <name>` → `ready <name> <address>`: stop, delete `<servers>/<name>`, start ("restarted without its store", for AUTH/expired-file rows);
+  - any failure → `error <name|-> <message>`.
+- `TestServers` (desktop harness): 120 slots (`slot-<k>.lock` in the run directory), base 20000 + 100 k. It is spawned under `setpriv --pdeathsig KILL` from the test thread during the first reset (in the bridge, from its main thread). **Per JVM**: each test JVM (Gradle fork) has its own slot, its own `uitest-servers` and its own port block, and the tests of one JVM run one at a time, so a test that stops a server affects only itself; with `-PuiForks=N` there are N independent server sets. Android runs its tests one at a time against the one bridge. API (same names on both platforms; Android's `TestServers` object in `android/.../harness/CliPeer.kt` sends `server <cmd> <name>` to the bridge): `start(name): String` (the address), `stop(name)`, `reset(name): String`, `address(name): String` (fails if the server is not running), `restoreBaseline()`. `restoreBaseline()` runs in every reset (desktop `resetForTest`, Android `resetForTest` through the bridge, and the bridge when its client disconnects): it stops `smp2`/`xftp2` and starts `smp1`/`xftp1` if a previous test left them stopped; with nothing changed it sends no command. `smp1`/`xftp1` keep their stores across tests (each test's databases are new, so old queues are unused).
+- `configureServers(smp, xftp)` disables the operator groups and adds a custom group with `smp1` and `xftp1`. CLI peers get `-s` and `--xftp-server` from `PeerFlags(smpServer = "smp1", xftpServer = "xftp1")` (server names; Android passes `smp=<name>`/`xftp=<name>` in the bridge `start` flags), so a peer can live on `smp2`. `CliPeer.createFile(name, content)` writes a file on the peer's host (Android: through the bridge `file` command).
+- **SOCKS stub** (`Socks5Stub.kt`, desktop harness): an RFC 1928 CONNECT-only SOCKS5 server with no-auth and RFC 1929 username/password (the app's default "isolate" mode sends a random username), IPv4/IPv6/domain targets, bound to `127.0.0.1:<base + 20>`; it records each CONNECT as `SocksConnection(host, port, username)` (uiTestShared `ServersConfig.kt`) and relays the bytes. Tests use `SocksProxy.start()`, `SocksProxy.port`, `SocksProxy.connections()`; the harness stops it at the end of every test. On Android the stub runs in the bridge (`socks start` → `ok <port>`, `socks connections` → `lines N` + `<host> <port> <username|->`, `socks stop`), and the device reaches it through `adb reverse`.
+- **Ports in a JVM's block**: base + 1 `smp1`, + 2 `xftp1`, + 11 `smp2`, + 12 `xftp2`, + 20 SOCKS stub. `uitest-android.sh` reverses all five.
+- Outages in tests stay short: the agents back off (message retries stay at about 2 s for the first 10 s, then grow ×1.5; a failed connection is cached for 3 s, `persistErrorInterval`), so a server is started again within a few seconds and waits after the start use `CONNECT_TIMEOUT_MS`.
 
 ### 0.5.7 Helpers and timeouts
 
@@ -211,7 +225,7 @@ The rules for test authors are in `apps/multiplatform/common/src/uiTestShared/RE
   - claims the Waydroid instance and starts it in the background if needed;
   - starts the bridge (`setsid java -cp … UiBridge 7777`) and kills it by `$!` on exit;
   - installs the app APK unless its sha256 and `lastUpdateTime` match the stamp, and always the test APK;
-  - `adb reverse` for 7777, base + 1 and base + 2.
+  - `adb reverse` for 7777, base + 1, base + 2 and base + 90 (the remote-desktop controller port, 0.5.5).
 - Each pass: `pm clear`, grants POST_NOTIFICATIONS, CAMERA and RECORD_AUDIO, then `am instrument -w -r`. After "Process crashed" it resumes with `-e notClass <finished tests>` (at most 4 passes).
 - Output in `build/uitest-android/run-<timestamp>/`:
   - `results.txt`, one line per test, `<class>#<test> <code>`: 0 pass, −2 fail, −3/−4 skipped, or `crashed`;
@@ -244,11 +258,11 @@ UITEST_SERIAL=<serial> scripts/uitest-android.sh <app.apk> <test.apk>   # anothe
 | 7.2, 7.3 | fixtures (`app(…, fixture)`, `restart(fixture)`); `RecordingNtfManager`, `UiTestPlatform` and the seams of 11.2; deleting `dataDir/tmp`; the `CC.ShowVersion` check; the lock-screen restart path and the alert exit of the restart poll; the `changingActiveUserMutex` check, manual `migrationState` handling, and the `OnboardingSharedState`/`BadgeStore` roots |
 | 7.4, 7.5 | `UiDriver`/`UiNode`/`InProcessDriver`; `MR.strings` lookups and exactly-one matching; `hold`, `dragTo`, `hover`, `clickAtTextRange`, `press(key, modifiers)`, `wait(d)`, `composeField()` (placeholder); the report directory with semantics dump, peer tails and command log (only the failure PNG and the message exist) |
 | 7.6, 7.7, 7.8 | `UiFiles` dialog responders (pending dialogs are only completed empty at reset); `LocalClipboard`; a throwing URI handler; toast and notification recording; screenshots; coverage |
-| 8.1 | the Stable CLI and `CliVersion`; `--mute` (the D-Bus notification concern of 8.3 stands); `--xftp-server`; `$HOME/Downloads`; the start–stop–start cycle; the `! `/`> `/`\ ` typing rule; `PeerFlags.key`, `PeerServers`; `expectsAny`, `repeatUntil`; `stop`/`start`/`snapshot`/`restore` inside a test; `RelayPeer`; mobile hosts |
-| 8.2 | `smp2`, `xftp2`, the names resolver, the control protocol, `restoreBaseline` (`xftp1` is served since 2026-10-19) |
+| 8.1 | the Stable CLI and `CliVersion`; `--mute` (the D-Bus notification concern of 8.3 stands); `--xftp-server`; `$HOME/Downloads`; the start–stop–start cycle; the `! `/`> `/`\ ` typing rule; `PeerFlags.key` (`PeerServers` is built as `PeerFlags.smpServer`/`xftpServer`, 0.5.6); `expectsAny`, `repeatUntil`; `stop`/`start`/`snapshot`/`restore` inside a test; `RelayPeer`; mobile hosts |
+| 8.2 | the names resolver, `register`/`clear-names` (`smp2`, `xftp2`, the control protocol and `restoreBaseline` are built, 0.5.6) |
 | 9.1–9.3 | `GuiUser`, `ChatRow` and the typed row classes; `uiTest(realTimes)`, `app(name, onboarded, fixture)`, `connect(gui, peer)`, `relay`, `mobileHost`, `servers`, `allowUncaught`, `screenshot`, `shouldHave`; the one-`app()`-per-test rule; `…CompatStableTest` subclasses |
 | 10.1 | `CatalogueTraceabilityTest`, stub generation, the catalogue in the repo; a traceability rule for the desktop-only (`chat.simplex.app.ui.desktop`) and Android-only (`chat.simplex.app.ui`, `chat.simplex.app.ui.back`) packages |
-| 11 | local HTTP and SOCKS stubs, committed media fixtures, multicast tests, server control, SQL fixtures |
+| 11 | the local HTTP stub, committed media fixtures, multicast tests, SQL fixtures (the SOCKS stub and server control are built, 0.5.6) |
 | Android | notification tests; the 10-run exit check; `wd.sh net isolate` in the runner; `testTagsAsResourceId` and `ui-test-manifest` (not needed by the instrumented layer); the debug network-security-config (approved, 13) |
 
 ## Terms
@@ -1550,6 +1564,8 @@ Each entry gives the symptom, the cause (how it was confirmed), and the fix or m
 51. **The notification shade took window focus on Waydroid.** A "bob Connected" heads-up left the expanded shade focused (`mCurrentFocus=NotificationShade`), and every later Espresso action failed with `RootViewWithoutFocusException`. The runner disables heads-up notifications and each Android reset collapses the shade (environment setup, not app behaviour under test).
 52. **Native allocator deadlock under arm64 translation stalls the whole process.** Several threads in `scudo::HybridMutex::lockSlow` (`wd.sh bt`) block every thread, the in-process watchdog and the signal catcher included, so a run hung for over an hour twice. `uitest-android.sh` now force-stops the app when the instrumentation output has not changed for `UITEST_STALL_S` (420 s); the pass ends abnormally, the stuck test is reported as `crashed`, and the run resumes. A pass is resumed after any abnormal end (`INSTRUMENTATION_RESULT: shortMsg=…`: "Process crashed", or an ANR such as `keyDispatchingTimedOut` when the main thread is the one stuck). Environmental (Waydroid libndk), not an app result.
 53. **Typing into the Android message field right after a chat opened was lost**: the composer resets the field while the chat opens. Without the old retry loop, the helper now waits for the field to be stable and lets the screen settle before the single `replaceText`.
+54. **Database re-encryption, export and import are slow under arm64 translation** (Android on Waydroid, 2026-10-20). "Database encrypted!" arrived after 26 s and 44 s, and once after more than 30 s with no tracked API call in flight, so a 30 s wait failed although the encryption had succeeded. Waits for these database operations use `DB_WORK_TIMEOUT_MS` (120 s, `DatabaseScreens.kt`); every other wait keeps its normal timeout.
+55. **Disabled rows inside a clickable container cannot be found** (2026-10-22). The user picker container is clickable (to close the picker, `UserPicker.desktop.kt:103`, `UserPicker.android.kt:142`), and rows disabled while the chat is stopped have no click handler, so their semantics merge into the container and `exists`/`waitFor`, which search the merged tree, never see their keys. `UserPickerTest.userPickerDisabledWhenChatStopped` is `@Ignore`d. Fix, not done: look up keyed nodes in the unmerged tree in both `UiScope`s (as `click` already does), checking that no absence assertion changes meaning.
 
 ### 15.4.1 Open flake: a CLI member's group join not completed (desktop, 2 of 5 runs)
 
@@ -1618,6 +1634,45 @@ Fixed in the same review: `createGroup_opensChatAndInviteSheet` now checks the o
 
 6. **Android: Back on the invite-members sheet right after creating a group sometimes closes the group chat too** (`BackKeyTest.back_closesContactAndGroupInfo`, 2 of 3 runs on 2026-10-19; the screen returns to the chat list instead of team's chat). The sheet registers two Back handlers (`ModalView` and `AddGroupMembersView.kt:44`), and the chat under it registers its own on Android (`ChatView.kt` `if (appPlatform.isAndroid && chatsCtx.secondaryContextFilter == null) BackHandler`); Android gives Back to the most recently registered enabled handler, so a re-registration of the chat's handler after the sheet opened would close the chat. Mechanism plausible, not confirmed. The test is marked `@KnownAppIssue("15.5 item 6", intermittent = true)`.
 
+7. **Importing a file that is not a chat archive deletes all data** (`DatabaseView.kt:730-757`, `Archive.hs:122-136`; found 2026-10-20 by `ChatDataTest.dbMgmt_importInvalidArchive`). Steps: Settings → Chat data → Database passphrase & export → Import database → choose a file that is not a zip → Import.
+   - `importArchive` calls `apiDeleteStorage()` before the archive is checked; the core closes both stores and deletes the chat and agent databases, their `.bak` backups, files, assets and temp.
+   - `apiImportArchive` then fails ("Parsing of archive structure failed: Cannot locate end of central directory") and throws a `java.lang.Exception`; both handlers catch only `Error` (`DatabaseView.kt:752,757`), so "Error importing chat database" is never shown.
+   - `stopChatRunBlockStartChat` then starts chat on the closed store: the user sees "Error starting chat" with "failed to list users … (withTransaction: database closed)", the old chat list stays on screen from memory, and chat cannot start.
+   - After an app restart new empty databases are created with the stored key and there is no user, so desktop shows the welcome screen (`Core.kt:153-168`; derived from code, the test does not restart). Every profile, contact and message is lost, backups included.
+   - The test requires the error alert and that alice and her note are still there; it is marked `@KnownAppIssue("15.5 item 7")`. Fix idea, not done: validate (or extract to a temporary location) before deleting storage, and catch `Exception` in the import handlers.
+
+8. **Unsaved group preference and member admission edits are discarded when any group event arrives** (`GroupPreferences.kt:44-45`, `MemberAdmission.kt:35-36`). The edit state is `rememberSaveable(gInfo, …)`, keyed on the whole `GroupInfo`; every new message replaces it with a new object (new timestamps, `ChatModel.kt` `addChatItem` → `updateChatInfo`), which re-initialises both the edited and the saved copy. The edit silently reverts and leaving the screen no longer asks "Save preferences?". Test: `GroupPreferencesTest.groupPrefs_unsavedEditsKeptWhenMessageArrives`, marked `@KnownAppIssue("15.5 item 8")`. Fix idea, not done: key the state on `groupInfo.groupId` and the saved preferences, not the whole object.
+
+9. **`DropdownSelection.Custom.hashCode()` recurses forever** (`CustomTimePicker.kt:157-163`). `(this as? Custom).hashCode()` resolves to `Any?.hashCode()`, which calls the overridden `hashCode()` again (the comment says the cast prevents this; it does only for the data class, which generates its own `hashCode`). `toString()` of the object uses `hashCode()`, so logging or hashing `Custom` throws `StackOverflowError`. Found when a test key stringified the option; no user-visible path is known, and the keys now map options to seconds (`optionKey`).
+
+10. **Suspected, not reproduced: an empty message can be sent to a chat opened while Enter is pressed** (`ComposeView.kt` ~1396 and 1020-1023). All chats share one compose state, swapped one frame after `chatModel.chatId` changes; in that frame the send button is enabled from the previous chat's text, and `sendMessage` reads `composeState.value` later inside its coroutine, after the swap. Seen once as an empty `#team alice>` line in `forward_destinationProhibitsContent_alert` before `ChatListScreen.open()` waited for the chat to open.
+
+11. **`chatRunning` is set before the core is started** (`SimpleXAPI.kt` `startChat`: `chatModel.chatRunning.value = true` at :709, `apiStartChat()` at :723 after `startReceiver()` and `setLocalDeviceName`). Opening a chat in that window fails with `chatNotStarted` and shows "Failed to load chat — Please update the app and contact developers." Seen in `dbMgmt_importArchive_restoresData` after "Start chat?" (2026-10-20); the window is milliseconds for a person, so the impact is small. The test now waits for the core to report the chat running.
+
+12. **"Inappropriate content" reports are sent with a reason the core does not know** (`ChatModel.kt:5452-5461` serialises `ReportReason.Illegal` as `"illegal"`; the core's reasons are `spam`, `content`, `community`, `profile`, `other`, `Protocol.hs:287-302`; iOS `ChatTypes.swift:5958-5969` does the same). The core stores it as `RRUnknown "illegal"`, so CLI moderators, bots and the directory service see `report illegal`; app-to-app it round-trips because both apps map `"illegal"` back. A `content` report from the CLI shows in the apps as the raw word "content". Test: `MemberReportTest.report_member_spam_moderatorsReceive` (the content report is sent last), marked `@KnownAppIssue("15.5 item 12")`. Fix idea, not done: serialise as `"content"` and accept both when decoding.
+
+13. **Cancelling a live message and starting another within 3 s sends two live messages** (`SendMsgView.kt:546-552`). Each start launches an update loop `delay(3000); while (liveMessage != null) { update(); delay(3000) }`; cancel sets `liveMessage = null`, but a loop sleeping in `delay` does not see it, and when a new live message starts before it wakes, the old loop keeps running beside the new one. Both call `updateLiveMessage` while `sent == false`, so each starts its own live message: the contact gets two "[LIVE started] … hi!" messages (seen as `[on/off/8]` and `[on/off/9]` on 2026-10-20), and one of them stays live forever. Test: `LiveMessageTest.liveMessage_boltButton_emptyStart`, marked `@KnownAppIssue("15.5 item 13", intermittent = true)`. Fix idea, not done: cancel the previous loop's job when the live message ends, or run one loop per `LiveMessage` instance.
+
+14. **After leaving a group the app can show the membership as connected again** (desktop, seen once on 2026-10-20 in `LeaveDeleteClearTest.leaveGroup_thenDeleteLocalCopy`). After "Leave group" the core replied (`LeftMemberUser`, applied by `leaveGroup` in `SimpleXAPI.kt:3722-3729`), bob printed "alice left the group" and the row showed "you left", yet the reopened group info listed "alice, you: connected", offered "Leave group" instead of "Delete group", and the compose field was an ordinary "Message" field. `GroupChatInfoView` reads the group from `chatModel.chats`, so the model's `membership` had reverted. Likely the same mechanism as item 1: a group event carrying a `GroupInfo` read before the leave, applied after the reply. Not confirmed. Marked `@KnownAppIssue("15.5 item 14", intermittent = true)`.
+
+15. **Core: removing several members at once breaks the removed members' copies of the group** (found 2026-10-20 by `MemberListTest.memberSelection_blockUnblockAndRemoveMultiple`; deterministic). `APIRemoveMembers` (`Commands.hs:3132`, `deleteMemsSend` :3206) sends one batch with an `XGrpMemDel` per removed member to every member, removed ones included. On a removed member, the event for their own removal runs `deleteGroupConnections` (`Subscriber.hs:3734-3740`, :4176 → `Internal.hs:2176` → `Store/Shared.hs:992`), which deletes the connection the batch arrived on; the next event's `saveGroupRcvMsg` (`Internal.hs:2928` → `Store/Messages.hs:276`) inserts into `msg_deliveries` with that connection id and fails `FOREIGN KEY constraint failed` (`chat_schema.sql:708`). The member sees "chat db error … FOREIGN KEY constraint failed", the rest of the batch is rolled back, and the other removed members stay "connected" in their copy of the group. With N members removed, N−1 hit it. No core test removes several members in one command. Fix idea, not done: stop applying a batch after one's own removal, or delete connection records after the whole batch. Marked `@KnownAppIssue("15.5 item 15")`.
+
+16. **An open contact info keeps the contact's old full name and bio after a profile update** (`ChatInfoView.kt:72`: `chat` is kept in `remember(contact.id)`, and `ChatInfoHeader` → `ChatInfoDescription` read that stale `chat.chatInfo`; `updateChatInfo` replaces the `Chat` with a copy, so the remembered one never changes). The display name updates, the full name, bio and image do not until the info is reopened. Test: `ContactInfoTest.contactInfoHeaderFollowsProfileUpdate`, marked `@KnownAppIssue("15.5 item 16")`. Fix idea: read `chatInfo` from the live model.
+
+17. **Desktop: the reaction chip's right-click menu shows a stale member list** (`ChatItemView.kt:204` `.onRightClick { showReactionsMenu() }` → `contextMenuOpenDetector`, `Modifier.desktop.kt:81`, keyed on `Unit`, so the closure keeps `r.userReacted` and the count from the first composition). After alice adds 👍 to bob's 👍, right-click lists only "bob", not "bob" and "you". Android uses long press through `combinedClickable` and is not affected. Test: `ReactionTest.reaction_chipClickOthers_adds`, marked `@KnownAppIssue("15.5 item 17", intermittent = true)` (passes on Android). The detector's keying is from memory of the Compose source; the run's stale list matches it.
+
+18. **A pending connection you joined is labelled "connection established" with an empty description** (`Commands.hs:3897-3899` stores `ConnSndReady` after the fast handshake's `sqSecured`; `ConnStatus.initiated` is null for `SndReady`, `ChatModel.kt:3341`, so `displayName` takes the branch commented "this should not be in the chat list", `ChatModel.kt:3276-3278`; iOS `ChatTypes.swift:2784-2786` is the same). Expected "accepted invitation" / "via one-time link". Test: `PendingConnectionTest.pendingInfoAcceptedShowsNoLink`, marked `@KnownAppIssue("15.5 item 18")`.
+
+19. **Suspected, not reproduced: a member–contact merge does not reach an open group info** (found by reading code on 2026-10-20). The Kotlin app has no handler for the core event `contactAndMemberAssociated` (`Subscriber.hs:3193,3200`), so while group info stays open after the core associates a member with an existing contact, the member keeps `memberContactId = null` and its "Message" button takes the "create member contact" path. `GroupLinksTest.groupLink_existingContactMergedWithMember` reopens group info and does not exercise this.
+
+20. **Core: pasting the full link of a group you are joining offers a second join request** (deterministic; `JoiningTest.connectPlan_connectingProhibit`). After "Join group" on a prepared group whose host is offline, the full group link's plan is `CPError`, so the app shows "Connect via link?" with "Use current profile" / "Use new incognito profile" instead of "Group already exists!". `groupJoinRequestPlan` (`Commands.hs:4767-4785`) does not find the group (`getGroupInfoByGroupLinkHash`, `Store/Groups.hs:2913`, excludes `GSMemUnknown`, the prepared membership's status until the host accepts) but finds the host-member connection (`RcvGroupMsgConnection`) and throws "found connection entity is not RcvDirectMsgConnection"; `contactRequestPlan` has the `RcvGroupMsgConnection _ gInfo _ -> groupPlan gInfo …` branch that this function lacks. Marked `@KnownAppIssue("15.5 item 20")`.
+
+21. **Member info of a member who left reverts the member to connected** (deterministic; `MemberInfoTest.memberInfo_deleteMessagesOfLeftMember`). Tapping the avatar on a left member's old message passes the item's `chatDir.groupMember` snapshot (`ChatView.kt:2094`, status connected); `APIGroupMemberInfo` fails with `CONN NOT_FOUND` because `xGrpLeave` deleted the connection (`Subscriber.hs:3817`), and the fallback `?: member` (`ChatView.kt:521-536`) upserts the stale snapshot over `MemLeft`. The correct "Delete member messages" layout flashes, then "Remove member" and "Block for all" are offered for a member who has left. Marked `@KnownAppIssue("15.5 item 21")`.
+
+22. **The selection toolbar is not rechecked when a selected message is deleted by the peer** (deterministic; `MultiSelectTest.select_itemDeletedByPeer_recheck`). `SelectableChatItemToolbars.kt:127-130` reruns `recheckItems` only when `chatInfo`, the `chatItems` list object or the selection change; a received deletion goes through `upsertChatItem`, which replaces the item in place (`ChatModel.kt` ~698), so the list object is the same and Forward stays enabled (and `deleteForEveryoneEnabled` stale) for a message that is now marked deleted. Marked `@KnownAppIssue("15.5 item 22")`.
+
+23. **The SimpleX Lock notice is not offered to users with more than three chats** (`App.kt:94-105`; `LockDesktopTest.lock_noticeOfferedWithManyChats`, marked `@KnownAppIssue("15.5 item 23", intermittent = true)`). `startChat` sets `localUserCreated = true` (`SimpleXAPI.kt:706`) before `getUserChatData` loads the chats (`:707`); that shows the main screen, whose one-shot `LaunchedEffect(showAdvertiseLAAlert)` tests `chatModel.chats.size > 3` while the list is still empty and never runs again. The more chats, the slower the load, so the users the notice is for are the most likely to miss it.
+
 ### 15.6 Catalogue corrections applied from passing tests (exhaustive pass)
 
 - 01:34 and 01:8: accepting conditions enables the operators selected in onboarding, not all preset ones.
diff --git a/plans/ui-tests/catalogue/00-legend.md b/plans/ui-tests/catalogue/00-legend.md
index eaf997f6b3..b094c10e34 100644
--- a/plans/ui-tests/catalogue/00-legend.md
+++ b/plans/ui-tests/catalogue/00-legend.md
@@ -123,80 +123,80 @@ Each sub-area (a `###` section) is one test class, or several consecutive classe
 | 01 | 3 | Chat list | `chatListScrollToTopOnTitleClick` | `ChatListToolbarSearchTest` | 16 | 0 |
 | 01 | 3 | Chat list | `unreadFilterToggle` | `ChatListFiltersListsTest` | 24 | 0 |
 | 01 | 3 | Chat list | `previewShowsLastTextMessage` | `ChatListRowsTest` | 17 | 0 |
-| 01 | 3 | Chat list | `contactMenuMarkRead` | `ChatListMenusPendingTest` | 12 | 0 |
+| 01 | 3 | Chat list | `contactMenuMarkRead` | `ChatListMenusPendingTest` | 11 | 0 |
 | 01 | 3 | Chat list | `contactRequestMenuAccept` | `ChatListRequestsCardsTest`, `ChatListRequestsCardsCompatTest`, `ChatListRequestsCardsCompatStableTest` | 24 | 0 |
-| 01 | 4 | Servers summary | `serversSummaryOpensFromIndicator` | `ServersSummaryTest` | 10 | 0 |
-| 01 | 5 | User picker and profiles | `userPickerOpensAndShowsCurrentUser` | `UserPickerTest` | 11 | 0 |
-| 01 | 5 | User picker and profiles | `profilesListShowsAllVisible` | `ChatProfilesTest` | 21 | 0 |
-| 01 | 5 | User picker and profiles | `editProfileDisplayName` | `ProfileEditTest` | 12 | 0 |
-| 01 | 6 | New chat sheet and contacts | `newChatSheetShowsActions` | `NewChatSheetTest` | 17 | 0 |
-| 01 | 7 | 1-time link (create / share / QR / incognito / profile) | `createOneTimeLinkShowsLinkAndQr` | `OneTimeLinkTest`, `OneTimeLinkCompatTest`, `OneTimeLinkCompatStableTest` | 17 | 0 |
-| 01 | 8 | Paste link and connection plans (contact, invitation, address, bot, name, signature, URI and link-card links) | `pasteLinkInvalidTextAlert` | `ConnectPlanTest`, `ConnectPlanCompatTest`, `ConnectPlanCompatStableTest` | 29 | 0 |
-| 01 | 9 | Connecting a prepared chat (compose area) | `preparedContactInvitationConnectButton` | `PreparedChatTest` | 11 | 0 |
-| 01 | 10 | Pending connection info screen | `pendingInfoInvitedShowsLinkQrShare` | `PendingConnectionTest` | 7 | 0 |
-| 01 | 11 | Address screens | `addressScreenNoAddressShowsCreate` | `AddressTest` | 22 | 0 |
+| 01 | 4 | Servers summary | `serversSummaryShowsLocalSmpConnected` | `ServersSummaryTest` | 7 | 0 |
+| 01 | 5 | User picker and profiles | `userPickerOpensAndShowsCurrentUser` | `UserPickerTest` | 5 | 0 |
+| 01 | 5 | User picker and profiles | `profilesListShowsAllVisible` | `ChatProfilesTest` | 14 | 0 |
+| 01 | 5 | User picker and profiles | `editProfileDisplayName` | `ProfileEditTest` | 7 | 0 |
+| 01 | 6 | New chat sheet and contacts | `newChatSheetShowsActions` | `NewChatSheetTest` | 10 | 0 |
+| 01 | 7 | 1-time link (create / share / QR / incognito / profile) | `createOneTimeLinkShowsLinkAndQr` | `OneTimeLinkTest`, `OneTimeLinkCompatTest`, `OneTimeLinkCompatStableTest` | 14 | 0 |
+| 01 | 8 | Paste link and connection plans (contact, invitation, address, bot, name, signature, URI and link-card links) | `pasteLinkInvalidTextAlert` | `ConnectPlanTest` | 15 | 0 |
+| 01 | 9 | Connecting a prepared chat (compose area) | `preparedContactInvitationConnectButton` | `PreparedChatTest` | 6 | 0 |
+| 01 | 10 | Pending connection info screen | `pendingInfoInvitedSharesWorkingLink` | `PendingConnectionTest` | 5 | 0 |
+| 01 | 11 | Address screens | `addressScreenNoAddressShowsCreate` | `AddressTest` | 12 | 0 |
 | 01 | 12 | SimpleX name | `simplexNameEntryShownWithAddress` | `SimplexNameTest` | 8 | 0 |
-| 01 | 13 | Contact info screen | `contactInfoOpensFromChatHeader` | `ContactInfoTest` | 28 | 0 |
-| 01 | 14 | Preferences | `contactPrefsDisappearingMessagesAllow` | `ContactPreferencesTest` | 12 | 0 |
-| 01 | 15 | Delete contact variants | `deleteContactOnlyConversation` | `DeleteContactTest` | 10 | 0 |
-| 02 | A | Chat view shell, toolbar, banner | `directChat_opens_showsToolbarAndBanner` | `ChatShellTest` | 11 | 0 |
-| 02 | B | Composing and sending text, links, mentions, commands | `sendText_sendButton_peerReceives` | `ComposeTest` | 28 | 0 |
-| 02 | C | Live messages | `liveMessage_menuStart_alertConfirm_peerSeesStarted` | `LiveMessageTest` | 10 | 0 |
-| 02 | D | Timed / disappearing messages | `timed_send30s_bothSidesDelete` | `TimedMessageTest` | 6 | 0 |
+| 01 | 13 | Contact info screen | `contactInfoSetLocalAlias` | `ContactInfoTest` | 24 | 0 |
+| 01 | 14 | Preferences | `contactPrefsSaveNotifiesContactAndEnforces` | `ContactPreferencesTest` | 4 | 0 |
+| 01 | 15 | Delete contact variants | `deleteContactOnlyConversation` | `DeleteContactTest` | 7 | 0 |
+| 02 | A | Chat view shell, toolbar, banner | `directChat_opens_showsToolbarAndBanner` | `ChatShellTest` | 8 | 0 |
+| 02 | B | Composing and sending text, links, mentions, commands | `sendText_sendButton_peerReceives` | `ComposeTest` | 21 | 0 |
+| 02 | C | Live messages | `liveMessage_menuStart_alertConfirm_peerSeesStarted` | `LiveMessageTest` | 5 | 0 |
+| 02 | D | Timed / disappearing messages | `timed_send30s_bothSidesDelete` | `TimedMessageTest` | 5 | 0 |
 | 02 | E | Voice messages | `voice_record_send_peerReceivesVoice` | `VoiceMessageTest` | 11 | 0 |
-| 02 | F | Attachments – sending | `attach_sheet_showsImageVideoFile` | `SendAttachmentTest`, `SendAttachmentCompatTest`, `SendAttachmentCompatStableTest` | 21 | 1 |
-| 02 | G | Receiving files: download, cancel, errors, save, viewers | `rcvImage_autoReceived_renders` | `ReceiveFileTest` | 20 | 0 |
-| 02 | H | Replies / quotes | `reply_menu_sendQuoted_peerSeesQuote` | `ReplyTest`, `ReplyCompatTest`, `ReplyCompatStableTest` | 7 | 0 |
-| 02 | I | Edit and history | `edit_menu_updatesPeer` | `EditMessageTest`, `EditMessageCompatTest`, `EditMessageCompatStableTest` | 12 | 0 |
-| 02 | J | Delete / reveal / blocked | `delete_ownForMe_localOnly` | `DeleteMessageTest`, `DeleteMessageCompatTest`, `DeleteMessageCompatStableTest` | 8 | 0 |
-| 02 | K | Multi-select and selection toolbar | `select_enterMode_showsCounterToolbar` | `MultiSelectTest` | 9 | 0 |
-| 02 | L | Forwarding | `forward_contactToContact_peerSeesForwarded` | `ForwardTest` | 17 | 0 |
-| 02 | M | Reactions | `reaction_add_peerSeesAdded` | `ReactionTest`, `ReactionCompatTest`, `ReactionCompatStableTest` | 8 | 0 |
-| 02 | N | Copy / Share / Save / text selection | `copy_text_toClipboardAndToast` | `CopyShareTest` | 9 | 0 |
-| 02 | O | Reports, member side | `report_member_spam_moderatorsReceive` | `MemberReportTest` | 7 | 0 |
-| 02 | P | Chat item info | `info_sent_showsSentAt` | `ItemInfoTest` | 15 | 0 |
-| 02 | Q | Unread handling, scrolling, pagination | `unread_openChat_scrollsToFirstUnread` | `UnreadScrollTest` | 18 | 0 |
-| 02 | R | Search and content filters | `search_direct_filtersResults` | `ChatSearchTest` | 11 | 0 |
-| 02 | S | Draft persistence | `draft_text_restoredAfterChatSwitch` | `DraftTest` | 8 | 0 |
+| 02 | F | Attachments – sending | `attachFile_withText_peerReceivesTextAndFile` | `SendAttachmentTest`, `SendAttachmentCompatTest`, `SendAttachmentCompatStableTest` | 14 | 1 |
+| 02 | G | Receiving files: download, cancel, errors, save, viewers | `rcvImage_autoReceived_renders` | `ReceiveFileTest` | 19 | 0 |
+| 02 | H | Replies / quotes | `reply_menu_sendQuoted_peerSeesQuote` | `ReplyTest`, `ReplyCompatTest`, `ReplyCompatStableTest` | 6 | 0 |
+| 02 | I | Edit and history | `edit_menu_updatesPeer` | `EditMessageTest`, `EditMessageCompatTest`, `EditMessageCompatStableTest` | 5 | 0 |
+| 02 | J | Delete / reveal / blocked | `delete_ownForEveryone_peerSeesMarkedDeleted` | `DeleteMessageTest`, `DeleteMessageCompatTest`, `DeleteMessageCompatStableTest` | 4 | 0 |
+| 02 | K | Multi-select and selection toolbar | `select_toggle_updatesCounter` | `MultiSelectTest` | 3 | 0 |
+| 02 | L | Forwarding | `forward_contactToContact_peerSeesForwarded` | `ForwardTest` | 9 | 0 |
+| 02 | M | Reactions | `reaction_add_peerSeesAdded` | `ReactionTest`, `ReactionCompatTest`, `ReactionCompatStableTest` | 5 | 0 |
+| 02 | N | Copy / Share / Save / text selection | `copy_text_toClipboardAndToast` | `CopyShareTest` | 5 | 0 |
+| 02 | O | Reports, member side | `report_member_spam_moderatorsReceive` | `MemberReportTest` | 2 | 0 |
+| 02 | P | Chat item info | `info_sent_showsSentAt` | `ItemInfoTest` | 10 | 0 |
+| 02 | Q | Unread handling, scrolling, pagination | `unread_openChat_scrollsToFirstUnread` | `UnreadScrollTest` | 12 | 0 |
+| 02 | R | Search and content filters | `search_direct_filtersResults` | `ChatSearchTest` | 6 | 0 |
+| 02 | S | Draft persistence | `draft_onlyLastChatKept` | `DraftTest` | 5 | 0 |
 | 02 | T | Status icons and delivery | `status_direct_sentThenDelivered` | `ItemStatusTest`, `ItemStatusCompatTest`, `ItemStatusCompatStableTest` | 9 | 0 |
-| 02 | U | Special items | `e2eeInfo_direct_pq` | `SpecialItemTest`, `SpecialItemCompatTest`, `SpecialItemCompatStableTest` | 19 | 1 |
-| 02 | V | Private notes | `notes_sendText_saved` | `NotesTest` | 7 | 0 |
-| 02 | W | Context menus and keyboard | `contextMenu_rightClick_opens` | `ContextMenuTest` | 5 | 0 |
+| 02 | U | Special items | `featureOffer_accept_updatesPrefs` | `SpecialItemTest`, `SpecialItemCompatTest`, `SpecialItemCompatStableTest` | 16 | 1 |
+| 02 | V | Private notes | `notes_sendText_saved` | `NotesTest` | 5 | 0 |
+| 02 | W | Context menus and keyboard | `contextMenu_itemsMatrix_byItemType` | `ContextMenuTest` | 1 | 0 |
 | 02 | X | Rare states and out-of-reach rows | `call_webrtcSession_connects` | `ChatEdgeCasesTest` | 4 | 2 |
-| 03 | 1 | Create group | `createGroup_buttonDisabledForEmptyOrInvalidName` | `CreateGroupTest` | 12 | 0 |
-| 03 | 2 | Invite members | `inviteMembers_listsOnlyEligibleContacts` | `InviteMembersTest`, `InviteMembersCompatTest`, `InviteMembersCompatStableTest` | 11 | 0 |
-| 03 | 3 | Group info screen rows | `groupInfo_headerShowsProfileAndCopiesName` | `GroupInfoTest` | 13 | 0 |
-| 03 | 4 | Group profile and welcome message | `editGroupProfile_renameNotifiesMembers` | `GroupProfileTest` | 14 | 0 |
-| 03 | 5 | Group preferences | `groupPrefs_disappearingOnWithTtl` | `GroupPreferencesTest` | 19 | 1 |
-| 03 | 6 | Member admission and review | `memberAdmission_enableReviewAll` | `MemberAdmissionTest` | 16 | 2 |
-| 03 | 7 | Group link | `groupLink_createdAutomatically` | `GroupLinkTest` | 14 | 0 |
-| 03 | 8 | Joining (alice as joiner), connect-plan states, invitations | `joinGroup_pasteShortLinkPrepareAndJoin` | `JoiningTest`, `JoiningCompatTest`, `JoiningCompatStableTest` | 24 | 0 |
-| 03 | 9 | Member list and multi-select | `memberList_rolesAndStatuses` | `MemberListTest` | 10 | 0 |
-| 03 | 10 | Member info | `memberInfo_openShowsSections` | `MemberInfoTest` | 28 | 0 |
-| 03 | 11 | Member contacts | `memberContact_createAndSendInvitation` | `MemberContactTest` | 5 | 0 |
-| 03 | 12 | Support chats, «Chats with members» / «Chat with admins» | `supportChat_memberSendsToAdmins` | `SupportChatTest` | 13 | 0 |
-| 03 | 13 | Reports, moderator side | `reports_moderatorBannerAndCounts` | `ModeratorReportTest` | 9 | 0 |
-| 03 | 14 | Moderation | `moderate_markDeletedForAll` | `ModerationTest` | 6 | 0 |
-| 03 | 15 | Mentions, notification side | `mentions_mentionsOnlyMuteStillNotifies` | `MentionNotificationTest` | 2 | 0 |
-| 03 | 16 | Group events and history | `groupEvents_memberConnectedMerged` | `GroupEventsTest` | 8 | 0 |
-| 03 | 17 | Leave, delete, clear | `leaveGroup_notifiesMembers` | `LeaveDeleteClearTest` | 8 | 0 |
+| 03 | 1 | Create group | `createGroup_buttonDisabledForEmptyOrInvalidName` | `CreateGroupTest` | 9 | 0 |
+| 03 | 2 | Invite members | `inviteMembers_listsOnlyEligibleContacts` | `InviteMembersTest`, `InviteMembersCompatTest`, `InviteMembersCompatStableTest` | 8 | 0 |
+| 03 | 3 | Group info screen rows | `groupInfo_headerShowsProfileAndCopiesName` | `GroupInfoTest` | 11 | 0 |
+| 03 | 4 | Group profile and welcome message | `editGroupProfile_renameNotifiesMembers` | `GroupProfileTest` | 10 | 0 |
+| 03 | 5 | Group preferences | `groupPrefs_ownerChangesNotifyAndRestrictMembers` | `GroupPreferencesTest` | 6 | 1 |
+| 03 | 6 | Member admission and review | `memberAdmission_unsavedChangesAlert` | `MemberAdmissionTest` | 7 | 2 |
+| 03 | 7 | Group link | `groupLink_cliJoinsViaShortLink` | `GroupLinkTest` | 9 | 0 |
+| 03 | 8 | Joining (alice as joiner), connect-plan states, invitations | `joinGroup_pasteShortLinkPrepareAndJoin` | `JoiningTest`, `JoiningCompatTest`, `JoiningCompatStableTest` | 17 | 0 |
+| 03 | 9 | Member list and multi-select | `memberList_rolesAndStatuses` | `MemberListTest` | 5 | 0 |
+| 03 | 10 | Member info | `memberInfo_openShowsSections` | `MemberInfoTest` | 22 | 0 |
+| 03 | 11 | Member contacts | `memberContact_createAndSendInvitation` | `MemberContactTest` | 4 | 0 |
+| 03 | 12 | Support chats, «Chats with members» / «Chat with admins» | `supportChat_memberSendsToAdmins` | `SupportChatTest` | 6 | 0 |
+| 03 | 13 | Reports, moderator side | `reports_moderatorBannerAndCounts` | `ModeratorReportTest` | 5 | 0 |
+| 03 | 14 | Moderation | `moderate_markDeletedForAll` | `ModerationTest` | 4 | 0 |
+| 03 | 15 | Mentions, notification side | `mentions_mentionsOnlyMuteCountsOnlyMentionsForOtherProfile` | `MentionNotificationTest` | 2 | 0 |
+| 03 | 16 | Group events and history | `groupEvents_memberConnectedMerged` | `GroupEventsTest` | 6 | 0 |
+| 03 | 17 | Leave, delete, clear | `leaveGroup_thenDeleteLocalCopy` | `LeaveDeleteClearTest` | 7 | 0 |
 | 03 | 18 | Channels: alice as owner, with relays and CLI subscribers | `createChannel_noRelaysBlocksCreation` | `ChannelOwnerCreateTest` | 16 | 0 |
 | 03 | 18 | Channels: alice as owner, with relays and CLI subscribers | `channel_broadcastPlaceholderAndDelivery` | `ChannelOwnerBroadcastTest` | 15 | 0 |
 | 03 | 18 | Channels: alice as owner, with relays and CLI subscribers | `channelSubscribers_listAndCount` | `ChannelOwnerManageTest` | 27 | 1 |
 | 03 | 19 | Channels: alice as subscriber, with a CLI owner and relays | `joinChannel_pasteLinkOpenChannel` | `ChannelSubscriberTest` | 26 | 0 |
-| 03 | 20 | Business chats | `business_customerConnectsCreatesBusinessChat` | `BusinessChatTest` | 16 | 0 |
-| 04 | A | Settings root and global keys | `settingsRoot_listsDesktopItems` | `SettingsRootTest` | 7 | 0 |
-| 04 | B | Privacy (Your privacy, More privacy, receipts) | `privacy_sectionsAndFooter` | `PrivacyTest` | 24 | 0 |
-| 04 | C | SimpleX Lock (desktop passcode) and self-destruct | `lock_enable_setsPasscode` | `LockTest` | 22 | 0 |
-| 04 | D | Appearance | `appearance_language_switch` | `AppearanceTest` | 24 | 0 |
-| 04 | E | Network & servers | `network_rootLayout` | `NetworkServersTest` | 22 | 0 |
-| 04 | E | Network & servers | `socks_enable_confirm` | `NetworkProxyTest` | 21 | 0 |
+| 03 | 20 | Business chats | `business_autoReplyWelcome` | `BusinessChatTest` | 9 | 0 |
+| 04 | A | Settings root and global keys | `settingsRoot_rowsOpenTheirScreens` | `SettingsRootTest` | 5 | 0 |
+| 04 | B | Privacy (Your privacy, More privacy, receipts) | `privacy_sectionsAndFooter` | `PrivacyTest` | 22 | 0 |
+| 04 | C | SimpleX Lock (desktop passcode) and self-destruct | `lock_enable_setsPasscode` | `LockTest` | 12 | 0 |
+| 04 | D | Appearance | `appearance_language_switch` | `AppearanceTest` | 18 | 0 |
+| 04 | E | Network & servers | `operators_enableDisableOperator` | `NetworkServersTest` | 18 | 0 |
+| 04 | E | Network & servers | `socks_enable_confirm` | `NetworkProxyTest` | 15 | 0 |
 | 04 | F | Audio & video calls | `calls_screenLayout_noLockScreenOption` | `CallSettingsTest` | 6 | 0 |
-| 04 | G | Chat data, database, encryption, startup DB errors | `chatData_layout` | `ChatDataTest` | 21 | 2 |
-| 04 | G | Chat data, database, encryption, startup DB errors | `dbEncrypt_setFirstPassphrase` | `DatabaseEncryptionTest` | 14 | 1 |
+| 04 | G | Chat data, database, encryption, startup DB errors | `chatData_ttlDecrease_alertConfirm` | `ChatDataTest` | 12 | 1 |
+| 04 | G | Chat data, database, encryption, startup DB errors | `dbEncrypt_changePassphrase` | `DatabaseEncryptionTest` | 7 | 1 |
 | 04 | H | Migrate to/from device | `migrateFrom_stopsChatAndAuth` | `MigrationTest` | 15 | 6 |
-| 04 | I | App version, update checker, developer tools | `version_screenShowsVersions` | `VersionDevToolsTest` | 15 | 0 |
-| 04 | J | Help & support | `help_layout` | `HelpTest` | 8 | 2 |
+| 04 | I | App version, update checker, developer tools | `version_screenShowsVersions` | `VersionDevToolsTest` | 13 | 0 |
+| 04 | J | Help & support | `help_layoutHowToUseAndAbout` | `HelpTest` | 4 | 2 |
 | 04 | K | Remote desktop: "Link a mobile" (the desktop GUI is the controller, the CLI is the mobile host) | `linkMobile_layout` | `RemoteDesktopTest` | 17 | 0 |
 | 04 | L | Supporter perks (badge-display screens excluded) | `badges_supportScreenLayout` | `SupporterPerksTest` | 8 | 1 |
 | 04 | M | Out of reach in-process | `tray_closeToTrayBehaviour` | `SettingsOutOfReachTest` | 8 | 8 |
diff --git a/plans/ui-tests/catalogue/01-onboarding-chatlist-connect-profiles.md b/plans/ui-tests/catalogue/01-onboarding-chatlist-connect-profiles.md
index cc85b3ee2b..607d68bf5e 100644
--- a/plans/ui-tests/catalogue/01-onboarding-chatlist-connect-profiles.md
+++ b/plans/ui-tests/catalogue/01-onboarding-chatlist-connect-profiles.md
@@ -1,6 +1,6 @@
 # UI test catalogue 1: onboarding, chat list, connecting, profiles, address, contact info
 
-Rows follow `00-legend.md` (paths, row format, Needs codes, users and CLI output, ownership). Each row has the exact strings.xml labels, file:line, test names, the GUI and CLI checks with matching Haskell tests, and blockers. Totals: **331 test cases, none of them `@Ignore`**, in 15 sections (details in `## Count` at the end).
+Rows follow `00-legend.md` (paths, row format, Needs codes, users and CLI output, ownership). Each row has the exact strings.xml labels, file:line, test names, the GUI and CLI checks with matching Haskell tests, and blockers. Totals: **312 test cases, none of them `@Ignore`**, in 15 sections (details in `## Count` at the end).
 
 ## Setup every test needs
 1. **Compose the real root** (`App.kt` → `AppScreen`/`MainPage`) so that `AlertManager.shared`/`privacySensitive.showInView()` (`C/App.kt:242,255`) render alerts. Alerts are material `AlertDialog` popups and the menus are `DropdownMenu` popups; both can be found with `onAllNodes`. `DefaultDialog` (a separate AWT window, `D/views/helpers/DefaultDialog.desktop.kt:25`) is defined but never used, so it doesn't block anything.
@@ -49,7 +49,7 @@ Rows follow `00-legend.md` (paths, row format, Needs codes, users and CLI output
 | Startup | What's New | Automatic 1 s after the chat list when the stored `whatsNewVersion` differs from the last version (including unset); Settings → "Help & support" → "What's new" | `C/views/onboarding/WhatsNewView.kt:68,1030`; `ChatListView.kt:219-228` | `whatsNewNotShownForNewUser` | The onboarding profile screen calls `setLastVersionDefault` when it is composed (`WelcomeView.kt:345-347`; the mobile layout at :305-307), so after the chat list has been shown for 2 s (the auto-open fires 1 s after its first composition, `ChatListView.kt:225`) no What's New modal is open | ONBOARD | – |
 | Startup | Updated conditions | What's New with "View updated conditions": as in 04 `operators_reviewAcceptConditions`, the console sends `/_servers <userId> <json>` with the SimpleX Chat operator `enabled: true`, then `restart()`; the core returns `UCAReview` with `showNotice` while the conditions were never notified (`src/Simplex/Chat/Operators.hs:117-129`), and the chat list opens What's New with `updatedConditions` after 1 s (`ChatListView.kt:219-228`) | `WhatsNewView.kt:72-81,197-216` | `whatsNewShowsViewUpdatedConditions` | What's New shows "View updated conditions"; opening it already calls `setConditionsNotified` (`/_conditions_notified`, `WhatsNewView.kt:71-79`), so the core's `currentConditions.notifiedAt` is set; the link opens `UsageConditionsView` in the Review state, titled "Updated conditions" with "Accept conditions" (`NetworkAndServers.kt:790-805`) | RESTART | `conditionsAction.shouldShowNotice` is core state |
 
-### 3. Chat list (93 tests)
+### 3. Chat list (92 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
@@ -60,7 +60,7 @@ Rows follow `00-legend.md` (paths, row format, Needs codes, users and CLI output
 | Toolbar | Subscription indicator | Icon next to "Chats" | `ChatListView.kt:668`; `ServersSummaryView.kt:120,349` | `subscriptionIndicatorServerDown` | Stopping the local SMP server lowers the subscribed share | SRVCTL | 1 s polling. alice first creates a 1-time link so a queue is subscribed; with no subscriptions and no session the indicator stays in the fresh-install state (`ServersSummaryView.kt:92-94`) |
 | Toolbar | New chat | Floating button "Start new chat" (bottom bar in one-hand mode) | `ChatListView.kt:102,479-501,585-605` | `newChatButtonOpensNewChatSheet` | With "Reachable app toolbars" on (Pref OneHandUI, default true, `SimpleXAPI.kt:275`) there is no FAB and the bottom-bar button "Start new chat" opens the "New chat" sheet (`ChatListView.kt:241-249,585-605`); with it off, the FAB "Start new chat" opens it (`:251-264,479-501`); with chat stopped neither button exists (the FAB needs `chatRunning == true`, :262, and the bar button is added only in the `else` branch of `if (stopped)`, :545,560,569,585-605), so the FAB's grey disabled state (:482,497) is unreachable | — | – |
 | Search | Text search | "Search or paste SimpleX link" | `ChatListView.kt:788,1541-1569` | `searchFiltersByDisplayName`, `searchFiltersByAlias`, `searchMatchesPendingConnectionAlias`, `searchNoChatsFound`, `searchClearsWhenFilterChanges` | Filters on `anyNameContains` and the pending-connection alias (a pending connection matches only its alias, `ChatListView.kt:1563`). Empty result shows "No chats found". Changing filter clears the text (`ChatListView.kt:1132`); while text is entered the unread toggle is hidden (:811-824), so the filter is changed with a preset or list chip. The open chat is always listed whatever the search (:1554,1557). Haskell: `testFilterSearch` (ChatList.hs) | P | – |
-| Search | Paste link | Paste a SimpleX link into search | `ChatListView.kt:836-845,887` | `searchPasteLinkTriggersConnectPlan`, `searchPasteKnownContactLinkFiltersToContact`, `searchPasteKnownGroupLinkFiltersToGroup` | Field shows the link's description, e.g. "SimpleX contact address (via <host>)" or "SimpleX group link (via <host>)" (`simplexLinkText`, `ChatModel.kt:5157-5160`), and becomes read-only (disabled, :804). A known contact/group filters the list to that chat with no alert; an unknown link with profile data shows the open-chat alert (profile name, "Open new chat", "Cancel"), and "Cancel" clears the field (§8) | P | The app reacts to any text change (`ChatListView.kt:836-845`), so the tests enter the link text directly (Compose's own paste reads `LocalClipboard`, which the harness does not provide) |
+| Search | Paste link | Paste a SimpleX link into search | `ChatListView.kt:836-845,887` | `searchPasteLinkTriggersConnectPlan`, `searchPasteKnownContactLinkFiltersToContact`, `searchPasteKnownGroupLinkFiltersToGroup` | Field shows the link's description, e.g. "SimpleX contact address (via <host>)" or "SimpleX group link (via <host>)" (`simplexLinkText`, `ChatModel.kt:5157-5160`), and becomes read-only (disabled, :804). A known contact/group filters the list to that chat with no alert; an unknown link with profile data shows the open-chat alert (profile name, "Open new chat", "Cancel"), and "Cancel" clears the field (§8); `searchPasteLinkTriggersConnectPlan` then has bob delete the address (`/da`, `View.hs:1123-1127`) and pastes it again: the plan fails with SMP AUTH and the alert "Connection link removed" / "Your contact removed this link, or it was a one-time link that was already used.…" (`connection_error_auth`, `C/model/SimpleXAPI.kt:1757-1764`) shows with no plan alert; "OK" clears the field and no chat with bob is created (covers §8 "Deleted link → error") | P | The app reacts to any text change (`ChatListView.kt:836-845`), so the tests enter the link text directly (Compose's own paste reads `LocalClipboard`, which the harness does not provide) |
 | Search | Name candidate | Type `bobby` or `@bob.simplex` (bare words need 5+ characters) | `ChatListView.kt:1152,1168,1207` | `searchNameShowsConnectToNameRow` | Row "Connect to bobby.testing" / "Connect to @bob.simplex"; "bob" shows no row | — | The row comes from local parsing (`ChatListView.kt:846-847,1158-1161`), with no peer or names server |
 | Search | Name candidate | Type `bobby` (bare words of 5+ characters get `.testing`) or `@bob.simplex` | `ChatListView.kt:1152,1168,1207` | `searchKnownNameFiltersChat` | A known name filters to that chat. Haskell: `Names.hs` `testConnectByName` | P, NAMES | NAMES: `uitest-servers` names mode with the mock registry (plan §8.2); GUI servers need the names role (`enableNamesRole`, `tests/ChatClient.hs:488`) |
 | Filters | Unread | Filter icon next to search; empty state "No unread chats" (tap to clear) | `ChatListView.kt:747,1244-1257` | `unreadFilterToggle`, `unreadFilterEmptyState` | Shows only chats with `unreadTag` (`C/model/ChatModel.kt:1460-1464`): unread messages in unmuted chats, unread mentions in mentions-only groups, and "Mark unread" chats; a muted chat with unread messages is hidden (checked once that chat's row shows the unread count with the filter still off, then the filter is turned on, `ChatPreviewView.kt:460-498`, `ChatModel.kt:1460-1464`: the CLI prints its message when it is sent, before it reaches alice, and a chat without unread messages would be hidden anyway). Empty state "No unread chats" (tap clears the filter). Haskell: `testFilterUnread`, `testFilterFavoriteOrUnread` | P | Icon has no description |
@@ -85,7 +85,7 @@ Rows follow `00-legend.md` (paths, row format, Needs codes, users and CLI output
 | Contact menu | Prepared contact | Row of a prepared contact before "Connect" | `ChatListNavLinkView.kt:279-299` | `contactMenuForNotReadyContactOnlyDelete` | A prepared contact (link typed into the chat-list search → "Open new chat", before "Connect") has no active connection, so the menu shows only "Delete" (`ChatListNavLinkView.kt:288`) | P | The link is typed into the chat-list search (`ChatListView.kt:837-844`). "Delete" opens "Confirm contact deletion?" (`C/views/chat/ChatInfoView.kt:231-246,421-426`) |
 | Group menu | Mute modes | Row menu "Mute"/"Mute all"/"Unmute" | `ChatListNavLinkView.kt:321-351` | `groupMenuMuteModesAllMentionsNone` | Menu label "Mute" moves All→Mentions, then "Mute all" moves Mentions→None, then "Unmute" moves None→All (`hasMentions` is true for every group, `C/model/ChatModel.kt:1830`); the row icon follows the mode. Haskell: `testMuteGroup`. Leave, delete and archive reports from this menu are in catalogue 03 | P | – |
 | Notes menu | Notes | "Mark unread", "Clear" → "Clear private notes?" | `ChatListNavLinkView.kt:355,449` | `notesMenuMarkUnreadAndClear` | With one note sent the menu offers "Mark unread" and "Clear" (`ChatListNavLinkView.kt:355-362`); "Mark unread" sets the unread mark; "Clear" shows "Clear private notes?" / "All messages will be deleted - this cannot be undone!" (`C/views/chat/ChatInfoView.kt:508-516`), and its "Clear" empties the notes and resets the chat stats, the unread mark included (`C/model/ChatModel.kt:803-816`). Haskell: `testNotes` (`tests/ChatTests/Local.hs:48` "/_unread chat *1 on"); `testFiles` (`Local.hs:164-165` "/clear *" → "notes: all messages are removed") | — | – |
-| Pending conn | Row and menu | Row after creating a 1-time link; menu "Set contact name", "Delete"; click | `ContactConnectionView.kt:23`; `ChatListNavLinkView.kt:143-162,582,775` | `pendingConnectionMenuSetName`, `pendingConnectionClickOpensInfo` | `pendingConnectionClickOpensInfo`: the row reads "invited to connect" / "you shared one-time link" (`ChatModel.kt:3251,3266`; its add-link icon, `ContactConnectionView.kt:26`, has the same description "profile image placeholder" as the link icon, so the texts tell the two apart), and a click opens the §10 screen "You invited a contact" with "One-time invitation link" and the name field, unfocused (`ChatView.kt:827`); `pendingConnectionMenuSetName`: "Set contact name" opens the same screen with the name field focused (`focusAlias = true`, `ChatListNavLinkView.kt:590`), and the name typed there renames the row | — | – |
+| Pending conn | Row and menu | Row after creating a 1-time link; menu "Set contact name", "Delete"; click | `ContactConnectionView.kt:23`; `ChatListNavLinkView.kt:143-162,582,775` | `pendingConnectionMenuSetName` | `pendingConnectionMenuSetName`: "Set contact name" opens the same screen with the name field focused (`focusAlias = true`, `ChatListNavLinkView.kt:590`), and the name typed there renames the row | — | `pendingConnectionClickOpensInfo` merged into `pendingInfoInvitedSharesWorkingLink` (row texts "invited to connect" / "you shared one-time link" are no longer checked) |
 | Pending conn | Row and menu | Row after creating a 1-time link; menu "Set contact name", "Delete"; click | `ContactConnectionView.kt:23`; `ChatListNavLinkView.kt:143-162,582,775` | `pendingConnectionMenuDeleteInitiated` | "Delete pending connection?" with "The contact you shared this link with will NOT be able to connect!"; the CLI first repeats `/_connect plan 1 <link>` until it prints `error: connection authorization failed - …` (the GUI's deletion reaches the server later, in a background thread, simplexmq `Agent.hs:1013-1015`; the plan reads the link from the server, `Library/Commands.hs:4431`), then a CLI `/c` with the deleted link prints "error: connection authorization failed…". Haskell: `testShortLinkDeletedInvitation` (H/Profiles.hs:4268) for deletion; `testPlanShortLinkInvitation` (H/Profiles.hs:3895-3932) for "/_connect plan" and "/c" printing "error: connection authorization failed" on a link the server no longer serves (View.hs:2922-2924); before the deletion reaches the server the plan prints "invitation link: ok to connect" (View.hs:2241) | P | – |
 | Pending conn | Accepted connection row | Row after alice pastes the CLI's full 1-time link ("The invitation link for old clients:") and taps "Use current profile" while the CLI is stopped, then dismisses "Connection request sent!"; menu "Delete" | `ContactConnectionView.kt:26`; `ChatListNavLinkView.kt:582,775`; `ConnectPlan.kt:103-113,417-421` | `pendingAcceptedRowIcon`, `pendingConnectionMenuDeleteAccepted` | The row reads "accepted invitation" / "via one-time link" (`ChatModel.kt:3252,3273`; the link icon, `ContactConnectionView.kt:26`, has the same description as the add-link icon); delete shows "The connection you accepted will be cancelled!" | P, PEERCTL, CB | The connection stays pending only while the link's creator is stopped. A short link would create a prepared contact instead. The current-build peer is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) |
 | Requests | Contact request (contact row) | CLI `/c <gui address>` → a contact row with "Open to accept"; row menu "Accept" / "Reject" | `C/views/chatlist/ChatPreviewView.kt:192`; `C/views/chatlist/ChatListNavLinkView.kt:279-286,527-557`; core `src/Simplex/Chat/Store/ContactRequest.hs:84-107,195-215` | `contactRequestMenuAccept`, `contactRequestMenuReject` | Every new request creates a contact (`createRequestEntity` → `createContact'`), shown as a contact row with "Open to accept", which both tests wait for once CLI `/c <address>` prints "connection request sent!". Accept: CLI "alice: contact is connected". Reject: the row is removed and the CLI prints nothing (its next command, `/u`, prints "user profile: bob"). Haskell: `testUserContactLink` (1362), `testRejectContactAndDeleteUserContact` (1817) | P, S | – |
@@ -102,134 +102,134 @@ Rows follow `00-legend.md` (paths, row format, Needs codes, users and CLI output
 | Center pane | Placeholder | No chat selected | `C/App.kt:407-416` | `noSelectedChatPlaceholder` | "No selected chat" | — | – |
 | Empty | Empty list | A user with no chats | `ChatListView.kt:449-462` | `youHaveNoChatsEmptyState` | "You have no chats" | FIXTURE (user without chats) | Every new user gets a notes folder and the "Ask SimpleX Team" card (core `src/Simplex/Chat/Library/Commands.hs:470-478`), so the empty list needs a fixture database |
 
-### 4. Servers summary (10 tests)
+### 4. Servers summary (7 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Servers | Servers info | Click the subscription indicator → "Servers info"; "Reconnect all servers" | `C/views/chatlist/ChatListView.kt:638-655`; `C/views/chatlist/ServersSummaryView.kt:691,929` | `serversSummaryOpensFromIndicator`, `serversSummaryReconnectAll` | "Servers info" opens ("No info, try to reload" before stats load); "Reconnect all servers" → "Reconnect servers?" → confirm, no error alert | — | – |
-| Servers | Servers info with traffic | "Servers info"; "Messages" tab; "Showing info for" dropdown "All profiles"/"Current profile" (2+ visible users only); "Reset all statistics"; server row → "SMP server" → "Reconnect"; "Details" | `C/views/chatlist/ServersSummaryView.kt:691,706-712,389,958,592,652` | `serversSummaryShowsLocalSmpConnected`, `serversSummaryAllVsCurrentProfile`, `serversSummarySmpServerDetail`, `serversSummaryDetailedStats`, `serversSummaryReconnectServer`, `serversSummaryResetStats` | `serversSummaryShowsLocalSmpConnected`: local SMP listed under "Connected servers" with message counts; `serversSummaryAllVsCurrentProfile`: with one user there is no "Showing info for" row (`ServersSummaryView.kt:708-713`); once the second, connection-less user is active, "All profiles" (the default, :694) still lists the local SMP server under "Connected servers", and "Current profile" lists no servers and shows "-" for "Messages sent" (`currentUserSMP`, :828-849; `numOrDash`, `Section.kt:381`); `serversSummarySmpServerDetail`: clicking the server row opens "SMP server" with "Server address" (the local server) and "Statistics" "Messages sent"/"Messages received" (:177-190, 558-611); `serversSummaryDetailedStats`: "Details" opens "Detailed statistics" with "Sent messages" › "Sent total" and "Received messages" › "Received total" (:313-317, 452-470); `serversSummaryReconnectServer`: "Reconnect server?"; `serversSummaryResetStats`: "Reset all statistics?" / "Reset" zeroes the counters | P | The test connects a CLI peer and exchanges messages first, because a server is listed only once it has sessions, subscriptions or stats (`src/Simplex/Chat/Stats.hs:216-229`); `serversSummaryAllVsCurrentProfile` also creates a second user |
+| Servers | Servers info | Click the subscription indicator → "Servers info"; "Reconnect all servers" | `C/views/chatlist/ChatListView.kt:638-655`; `C/views/chatlist/ServersSummaryView.kt:694,932` |  | "Servers info" opens ("No info, try to reload" before stats load); "Reconnect all servers" → "Reconnect servers?" → confirm, no error alert | — | `serversSummaryOpensFromIndicator` merged into `serversSummaryShowsLocalSmpConnected`; `serversSummaryReconnectAll` merged into `serversSummaryResetStatsAndReconnectAll` |
+| Servers | Servers info with traffic | "Servers info"; "Messages" tab; "Showing info for" dropdown "All profiles"/"Current profile" (2+ visible users only); "Reset all statistics"; server row → "SMP server" → "Reconnect"; "Details" | `C/views/chatlist/ServersSummaryView.kt:694,709-715,179-194,304-322,932-979,562-588` | `serversSummaryShowsLocalSmpConnected`, `serversSummaryAllVsCurrentProfile`, `serversSummaryDetailedStats`, `serversSummaryReconnectServer`, `serversSummaryResetStatsAndReconnectAll` | `serversSummaryShowsLocalSmpConnected`: "Servers info" is absent before the indicator is clicked; after bob's message the local SMP host (key `Ui.ServersSummary.SmpServer(host)`, host parsed from the configured server) is listed under "Connected servers", and "Messages sent", "Messages received" and "Active connections" are counts, not "-"; clicking the server row opens "SMP server" with "Server address" (the local host) and its own "Messages received"/"Active connections" counts; `serversSummaryAllVsCurrentProfile`: with one user there is no "Showing info for" row (`ServersSummaryView.kt:709-715`); once the second, connection-less user is active, "Showing info for" (key `Ui.ServersSummary.UserCategory`, :815-827) reads "All profiles" (the default, :697) and still lists the local SMP server under "Connected servers" with alice's sent messages counted, and "Current profile" lists no servers and shows "-" for "Messages sent" (`currentUserSMP`, :831-833; `numOrDash`, `Section.kt:381`); `serversSummarySmpServerDetail`: clicking the server row opens "SMP server" with "Server address" (the local server) and "Statistics" "Messages sent"/"Messages received" (:177-190, 558-611); `serversSummaryDetailedStats`: "Details" opens "Detailed statistics" with "Sent messages" › "Sent total" and "Received messages" › "Received total" (:313-317, 452-470); `serversSummaryReconnectServer`: "Reconnect server?"; `serversSummaryResetStatsAndReconnectAll`: "Reset all statistics?" ("Servers statistics will be reset - this cannot be undone!") / "Reset" turns "Messages sent"/"Messages received" to "-" and "Details" › "Subscribed" to "-"; then "Reconnect all servers" → "Reconnect servers?" ("Reconnect all connected servers to force message delivery. It uses additional traffic.") → confirm; bob's next message is counted under "Messages received", no "Error reconnecting servers", and "Details" › "Subscribed" counts the resubscription (agent `processSubResults` increments `connSubscribed`) | P | The test connects a CLI peer and exchanges messages first, because a server is listed only once it has sessions, subscriptions or stats (`src/Simplex/Chat/Stats.hs:216-229`); `serversSummaryAllVsCurrentProfile` also creates a second user; `serversSummarySmpServerDetail` merged into `serversSummaryShowsLocalSmpConnected`; `serversSummaryResetStats` merged into `serversSummaryResetStatsAndReconnectAll` |
 | Servers | Servers info, files | Click the subscription indicator → "Servers info" → "Files" | `C/views/chatlist/ServersSummaryView.kt:691,876-906` | `serversSummaryFilesTabShowsXftp` | After alice sends a file to the CLI peer (she attaches it by typing its path, `D/platform/PlatformTextField.desktop.kt:97-110`), the "Files" tab lists the local XFTP server | P, XFTP | The file transfer has to come first: an unused XFTP server is not listed (`src/Simplex/Chat/Stats.hs:260-263`) |
 | Servers | Servers info share | Click the subscription indicator → "Servers info" → share button | `C/views/chatlist/ChatListView.kt:641-652` | `serversSummaryShareJson` | Share copies the pretty-printed `PresentedServersSummary` JSON to the clipboard stub | CB | The share button appears only when Servers info is opened after a summary was loaded: open it, wait for the stats, close it, then reopen it |
 
-### 5. User picker and profiles (44 tests)
+### 5. User picker and profiles (26 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Picker | Open, current user | Click the profile button | `C/views/chatlist/UserPicker.kt:46,211-215`; `D/views/chatlist/UserPicker.desktop.kt:90` | `userPickerOpensAndShowsCurrentUser`, `userPickerCurrentUserOpensProfileEditor` | Current profile shown; clicking it opens "Your current profile" | — | Clicking outside closes the picker |
+| Picker | Open, current user | Click the profile button | `C/views/chatlist/UserPicker.kt:164-181,211-215,222-302,378-417`; `D/views/chatlist/UserPicker.desktop.kt:90` | `userPickerOpensAndShowsCurrentUser` | The picker shows the current user's row with "alice" and the rows "Create SimpleX address", "Chat preferences", "Your chat profiles", "Link a mobile" (Android: "Use from desktop") and "Settings"; clicking the current user opens "Your current profile" with "alice" in the name field and closes the picker (`UserPicker.kt:174-180`); "Chat preferences" opens "Your preferences" (`UserPicker.kt:240-256`; `Preferences.kt:73`); "Settings" opens "Your settings" (`UserPicker.kt:409-417`; `SettingsView.kt:102`); on desktop "Link a mobile" opens the screen with "This device name" (`UserPicker.kt:396-407`; `C/views/remote/ConnectMobileView.kt:96-97`). Each row closes the picker | — | Clicking outside closes the picker; `userPickerCurrentUserOpensProfileEditor`, `userPickerChatPreferencesRow`, `userPickerLinkAMobileRow` and `userPickerSettingsRow` merged into `userPickerOpensAndShowsCurrentUser`; Android opens no "Use from desktop" screen (it starts desktop discovery), only its label is checked |
 | Picker | Switch profile | Inactive avatars row (desktop) | `UserPicker.kt:161-176,238-249`; `UserPicker.desktop.kt:27` | `userPickerSwitchProfile` | Active user changes; the chat list reloads. Haskell: `testCreateSecondUser` (H/Direct.hs:1968) | — | Avatars have no text; match by display name. The second user is created in the test |
-| Picker | Unread per user, muted user | Badge on inactive avatars | `UserPicker.desktop.kt:64-66`; `UserPicker.kt:639` | `userPickerUnreadBadgePerUser`, `userPickerMutedUserGrayBadge` | Count matches the CLI messages sent to the second user; grey when muted | P | – |
-| Picker | Option rows | "Create SimpleX address"/"Your SimpleX address", "Chat preferences", "Your chat profiles", "Link a mobile", "Settings" | `UserPicker.kt:219-302,348-396` | `userPickerAddressRowLabelCreateVsYour`, `userPickerChatPreferencesRow`, `userPickerLinkAMobileRow`, `userPickerSettingsRow`, `userPickerDisabledWhenChatStopped`, `userPickerHiddenUsersNotListed` | Labels change with state ("Your SimpleX address" once an address exists; "Linked mobiles" after a pairing is tested in 04 §K); with chat stopped the current-user, address, "Chat preferences", "Your chat profiles" and "Link a mobile" rows are disabled and "Settings" stays enabled; hidden users absent; `userPickerChatPreferencesRow`: "Chat preferences" opens "Your preferences" (`UserPicker.kt:225-231`; `Preferences.kt:73`); `userPickerLinkAMobileRow`: "Link a mobile" opens the screen titled "Link a mobile" with "This device name" (`UserPicker.kt:368-377`; `C/views/remote/ConnectMobileView.kt:94-95`); `userPickerSettingsRow`: "Settings" opens "Your settings" (`UserPicker.kt:381-393`; `SettingsView.kt:99`) | — | – |
-| Profiles | List and add | "Your chat profiles" → "Add profile" → "Create profile" | `C/views/usersettings/UserProfilesView.kt:38,150`; `WelcomeView.kt:61,369` | `profilesListShowsAllVisible`, `profilesAddProfile`, `profilesAddProfileInvalidName`, `profilesAddProfileDuplicateNameError`, `profilesActivateByTap`, `profilesSearchByName` | `profilesListShowsAllVisible`: with users "work" and a hidden "secret" created through the API, the list shows the rows "alice" and "work" but not "secret" (a hidden non-active user is listed only when the search text is its password, `filteredUsers`, `UserProfilesView.kt:305-315`), then "Add profile" and the footer "Tap to activate profile." (:176-188); `profilesAddProfile`: "Add profile" → "Create profile" with a name creates the profile, makes it active and lists it (`apiCreateActiveUser`, `WelcomeView.kt:369-385`); `profilesAddProfileInvalidName`: a name such as "?bob" shows the red info icon and keeps "Create profile" disabled; the icon opens "Invalid name!" / "Correct name to bob?", and confirming puts "bob" in the field (`WelcomeView.kt:120-131,157,480-499`; `mkValidName "?alice"` is `"alice"`, `tests/ValidNames.hs:14`); `profilesAddProfileDuplicateNameError`: a duplicate name shows the "Duplicate display name!" alert ("You already have a chat profile with the same display name. Please choose another name.", `SimpleXAPI.kt:987-991`); `profilesActivateByTap`: clicking another profile's row makes it the active user and the chat list shows its chats (`changeActiveUser`, `UserProfilesView.kt:56-64`); `profilesSearchByName`: typing part of a name lists only the profiles whose name contains it, ignoring case, and hides "Add profile" (`filteredUsers`, `UserProfilesView.kt:305-315`; :181-185) | — | – |
-| Profiles | Hidden-profile notice | Open with 2+ users | `UserProfilesView.kt:190-202` | `profilesHiddenNoticeFirstTime` | "Make profile private!" / "Don't show again" | — | – |
-| Profiles | Hide and unhide | Right-click a user → "Hide" → "Hide profile": "Password to show", "Confirm password", "Save profile password"; search a password; "Unhide" → "Unhide profile" / "Profile password" / "Unhide chat profile" | `UserProfilesView.kt:99-142,208-255,263,305-328`; `HiddenProfileView.kt:27` | `profilesHideProfileWithPassword`, `profilesHidePasswordMismatchDisabled`, `profilesRevealHiddenByPasswordInSearch`, `profilesActivateHiddenViaSearchPassword`, `profilesUnhideActiveRequiresPassword`, `profilesHideOnlyWhenMoreThanOneVisible` | `profilesHideProfileWithPassword`: "Hide" on the non-active user, both passwords typed and "Save profile password" close the screen; the user's row leaves the list (a hidden non-active user is listed only for its password, `filteredUsers`, `UserProfilesView.kt:305-315`) and the "Enter password in search" banner shows for 10 s (:129-140, 166-171); `profilesHidePasswordMismatchDisabled`: while "Confirm password" differs from "Password to show", "Save profile password" stays disabled (`HiddenProfileView.kt:69-70,79`); `profilesRevealHiddenByPasswordInSearch`: a typed password reveals the hidden user; `profilesActivateHiddenViaSearchPassword`: clicking the revealed row makes it the active user and the chat list shows its chats (`changeActiveUser` with the typed password, `UserProfilesView.kt:56-64,324-325`); `profilesUnhideActiveRequiresPassword`: "Unhide" of the active hidden user asks for "Profile password"; `profilesHideOnlyWhenMoreThanOneVisible`: with one visible user (the other one hidden), the visible user's menu has no "Hide" ("Mute" and "Delete" remain, `UserProfilesView.kt:231-251`). Core side: `testUserPrivacy` (H/Direct.hs:2752) | — | Banner timing is 10 s; a second user is created in the test |
+| Picker | Unread per user, muted user | Badge on inactive avatars | `D/views/chatlist/UserPicker.desktop.kt:67-69`; `apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/chatlist/UserPicker.android.kt:96-98`; `UserPicker.kt:457-468,668`; `C/model/ChatModel.kt:1042-1050` | `userPickerUnreadBadgePerUser`, `userPickerMutedUserGrayBadge` | `userPickerUnreadBadgePerUser`: the CLI (contact of both alice and work) sends 2 messages to work and 1 to alice while alice is active: work's avatar shows `2` and the active alice's none; after switching to work, alice's avatar shows `1` and work's none, and the "Your chat profiles" rows show the same counts; `userPickerMutedUserGrayBadge`: grey when muted | P | The badge colour is not observable (no description), so `userPickerMutedUserGrayBadge` is not written yet |
+| Picker | Option rows | "Create SimpleX address"/"Your SimpleX address", "Chat preferences", "Your chat profiles", "Link a mobile", "Settings" | `UserPicker.kt:163,211-215,222-330,378-417`; `UserPicker.android.kt:83-87`; `UserPicker.desktop.kt:55-60` | `userPickerDisabledWhenChatStopped` | `userPickerDisabledWhenChatStopped`: "Chat preferences" opens "Your preferences" while chat runs; after `stopChatAsync`, tapping the current user, "Create SimpleX address", "Chat preferences", "Your chat profiles" and "Link a mobile" (Android: "Use from desktop") opens none of their screens (the rows are `disabled = stopped`, `UserPicker.kt:215,237,256,326,392,405`; a tap on them falls through to the picker's scrim and closes it), while "Settings" still opens "Your settings". The label change "Create SimpleX address" → "Your SimpleX address" is checked in §11 `createAddressNoContactsSharesAutomatically`; "Linked mobiles" after a pairing is tested in 04 §K | — | `userPickerAddressRowLabelCreateVsYour` merged into `createAddressNoContactsSharesAutomatically`; `userPickerChatPreferencesRow`, `userPickerLinkAMobileRow` and `userPickerSettingsRow` merged into `userPickerOpensAndShowsCurrentUser`; `userPickerHiddenUsersNotListed` merged into `profilesHideProfileWithPassword` (it checks that the hidden work is absent from the picker) |
+| Profiles | List and add | "Your chat profiles" → "Add profile" → "Create profile" | `C/views/usersettings/UserProfilesView.kt:39,58-66,176-191,307-317`; `WelcomeView.kt:64,128-139,166-176,373-390`; `SimpleXAPI.kt:1018-1030` | `profilesListShowsAllVisible`, `profilesAddProfile`, `profilesAddProfileInvalidName` | `profilesListShowsAllVisible`: with users "work" and a hidden "secret" (hidden through the API), the list shows the rows "alice" and "work" but not "secret" (a hidden non-active user is listed only when the search text is its password, `filteredUsers`, `UserProfilesView.kt:307-317`), "Add profile" and the footer "Tap to activate profile." (:177-191); clicking work's row makes it the active user with its group and without alice's (`changeActiveUser`, :58-66); typing "ALI" lists only alice, ignoring case, and hides "Add profile" (:181-188); `profilesAddProfile`: "Add profile" → "Create profile" with a name creates the profile, makes it active and lists it (`apiCreateActiveUser`, `WelcomeView.kt:373-390`); `profilesAddProfileInvalidName`: "?bob" shows the red info icon and "Create profile" does nothing; the icon opens "Invalid name!" / "Correct name to bob?", and confirming puts "bob" in the field (`WelcomeView.kt:128-139,166-176,483-500`; `mkValidName "?alice"` is `"alice"`, `tests/ValidNames.hs:14`); then "alice" (the existing user) shows the "Duplicate display name!" alert ("You already have a chat profile with the same display name. Please choose another name.", `SimpleXAPI.kt:1018-1030`) and no profile is created | — | `profilesSearchByName` and `profilesActivateByTap` merged into `profilesListShowsAllVisible`; `profilesAddProfileDuplicateNameError` merged into `profilesAddProfileInvalidName` |
+| Profiles | Hidden-profile notice | Open with 2+ users | `UserProfilesView.kt:191-204` | `profilesHiddenNoticeFirstTime` | With one profile the notice is not shown; with two (the pref turned on after work is created): "Make profile private!" / "You can hide or mute a user profile - hold it for the menu." with "OK" (keeps Pref ShowHiddenProfilesNotice=true, shown again next time) and "Don't show again" (stores false; not shown again) (`UserProfilesView.kt:193-203`) | — | – |
+| Profiles | Hide and unhide | Right-click a user → "Hide" → "Hide profile": "Password to show", "Confirm password", "Save profile password"; search a password; "Unhide" → "Unhide profile" / "Profile password" / "Unhide chat profile" | `UserProfilesView.kt:101-114,227-258,264-305,307-332`; `HiddenProfileView.kt:27` | `profilesHideProfileWithPassword`, `profilesHidePasswordMismatchDisabled`, `profilesUnhideActiveRequiresPassword` | `profilesHideProfileWithPassword`: "Hide" on the non-active user, both passwords typed and "Save profile password" close the screen; the user's row leaves the profiles list and the user picker; its name in search lists nothing, its password lists it, and clicking the revealed row makes it the active user with its chats (`filteredUsers`, `changeActiveUser` with the typed password, `UserProfilesView.kt:58-66,307-317,326-327`); the "Enter password in search" banner is `profilesHideShowsPasswordHint` (§15.5 item 5); `profilesHidePasswordMismatchDisabled`: while "Confirm password" differs from "Password to show", "Save profile password" does nothing (`HiddenProfileView.kt:69-70,79`); `profilesUnhideActiveRequiresPassword`: with work hidden and active (hidden through the API), alice is the only visible profile and her menu has "Mute" and "Delete" but no "Hide" (`visibleUsersCount > 1`, :233); work's menu has "Unhide" and "Delete" only; "Unhide" opens "Unhide profile" with "Profile password" and "Unhide chat profile" (`passwordEntryRequired`, :101-114,329-330; `ProfileActionView`, :264-305), a wrong password does nothing, and the right one unhides work and closes the screen. Core side: `testUserPrivacy` (H/Direct.hs:2752) | — | Banner timing is 10 s; a second user is created in the test; `profilesRevealHiddenByPasswordInSearch` and `profilesActivateHiddenViaSearchPassword` merged into `profilesHideProfileWithPassword`; `profilesHideOnlyWhenMoreThanOneVisible` merged into `profilesUnhideActiveRequiresPassword` (the positive branch, "Hide" with two visible profiles, is `profilesHideProfileWithPassword`) |
 | Profiles | Hidden user not listed or counted | Hide a user that has a contact with the CLI peer | `UserProfilesView.kt:305-315`; `ChatListView.kt:621-625` | `profilesHiddenNotListedAfterHide` | The hidden user is absent from "Your chat profiles"; CLI messages to it don't light the profile button's unread mark, checked once the CLI's `/_get chat @<id of its contact with the hidden user> count=1` (repeated, as in §13 `contactInfoSendReceiptsDefault`) shows the message's `itemStatus` `sndRcvd`: alice's core has then received it (new users send receipts, `src/Simplex/Chat/Store/Profiles.hs:143`), while the CLI prints the sent message before delivery | P | – |
-| Profiles | Mute | Menu "Mute"/"Unmute" | `UserProfilesView.kt:115-128,389` | `profilesMuteUnmute`, `profilesMutedAlertDontShowAgain` | `profilesMuteUnmute`: "Muted when inactive!" alert; notifications-off icon on the row, gone after "Unmute"; `profilesMutedAlertDontShowAgain`: "Don't show again" closes the alert and sets Pref ShowMuteProfileAlert=false (`UserProfilesView.kt:119,389-397`), and muting again after "Unmute" shows no alert | — | – |
+| Profiles | Mute | Menu "Mute"/"Unmute" | `UserProfilesView.kt:116-128,238-248,390-399` | `profilesMuteUnmute` | With the alert preference on (the harness turns it off, the test restores the app default): "Mute" on work shows "Muted when inactive!" / "You will still receive calls and notifications from muted profiles when they are active."; "OK" closes it, work is muted (`showNtfs` false) and its menu offers "Unmute" instead of "Mute"; "Unmute" restores it; muting again and choosing "Don't show again" stores Pref ShowMuteProfileAlert=false, and the next mute shows no alert; after `restart()` work's menu still offers "Unmute" (stored in the core) | — | `profilesMutedAlertDontShowAgain` merged into `profilesMuteUnmute`. The notifications-off icon has no description, so the menu label is checked instead |
 | Profiles | Delete with peer check | Menu "Delete" → "Delete chat profile?" with "Profile and server connections" / "Local profile data only" | `UserProfilesView.kt:67-97,330-375` | `profilesDeleteInactiveWithConnections`, `profilesDeleteInactiveLocalDataOnly` | With connections: the queues are deleted on the server in a background thread (`deleteUser'` → `deleteConnectionsAsync_`, simplexmq `Agent.hs:898-901, 1007-1015`), so the CLI sends repeatedly, every 2 s with a deadline, until sending gets `[<deleted profile name>, contactId: <id>, connId: <id>] error: connection authorization failed - this could happen if connection was deleted, …` (H/Direct.hs:2270). Local only: a CLI send prints no error within `wait(5 s)` (the queues stay on the server). Haskell: `testDeleteUser` (H/Direct.hs:2211) | P | – |
-| Profiles | Delete active / last / hidden | Menu "Delete" → "Delete chat profile?" with "Profile and server connections" / "Local profile data only" | `UserProfilesView.kt:327-364`; `UserPicker.kt:252` | `profilesDeleteActiveSwitchesToNext`, `profilesDeleteLastVisibleShowsCreateChatProfile`, `profilesDeleteHiddenActiveRequiresPassword` | Deleting the active user activates the next visible one; deleting the last visible user shows the picker with "Create chat profile"; the active hidden user's deletion asks for "Profile password" → "Delete chat profile" | — | – |
-| Profile edit | Your current profile, peer notified | Picker → current user: "Profile name:", "Full name:" (only when different), "Bio:", "Add description"/"Edit description", "Edit image"/"Delete image", "Save and notify contacts" | `C/views/usersettings/UserProfileView.kt:32,61,166-246` | `editProfileDisplayName`, `editProfileBio`, `editProfileDescription`, `editProfileUnsavedChangesAlertSave` | CLI: "contact alice changed to alice2" / "use @alice2 <message> to send messages"; "contact alice updated bio: …"; "contact alice updated description: …" (`src/Simplex/Chat/View.hs:2342`); `editProfileUnsavedChangesAlertSave`: after changing the name to alice2, leaving shows "Save preferences?", and its "Save and notify contacts" saves it: the CLI prints "contact alice changed to alice2" (`UserProfileView.kt:104,288-293`). Haskell: `testUpdateProfile` (H/Profiles.hs:208) | P | – |
-| Profile edit | Your current profile, local checks | Picker → current user: "Profile name:", "Full name:" (only when different), "Bio:", "Add description"/"Edit description", "Edit image"/"Delete image", "Save and notify contacts" | `C/views/usersettings/UserProfileView.kt:93-99,201,218-226,238,288-305`; `C/model/SimpleXAPI.kt:1930` | `editProfileFullNameShownOnlyIfDifferent`, `editProfileBioTooLarge`, `editProfileUnsavedChangesAlertExit`, `editProfileNameUsedByOtherUserError`, `editProfileSaveDisabledWhenUnchanged` | "Full name:" shown only when it is non-empty and differs from the name; an over-limit bio shows the error icon next to "Bio:"; clicking it shows the "Bio too large" alert; Save is disabled; after changing the name, leaving the screen shows "Save preferences?" / "Save and notify contacts" / "Exit without saving" (`UserProfileView.kt:288-293`), and "Exit without saving" closes it, and reopening the user picker shows "alice" (the picker closed 500 ms after the profile screen opened, `UserPicker.kt:170-174`); a name used by another user shows "Duplicate display name!"; Save is disabled while nothing changed | — | `editProfileNameUsedByOtherUserError` creates a second user; `editProfileFullNameShownOnlyIfDifferent` sets a full name through the API first |
+| Profiles | Delete active / last / hidden | Menu "Delete" → "Delete chat profile?" with "Profile and server connections" / "Local profile data only" | `UserProfilesView.kt:331-376`; `UserPicker.kt:252` | `profilesDeleteActiveSwitchesToNext`, `profilesDeleteLastVisibleShowsCreateChatProfile`, `profilesDeleteHiddenActiveRequiresPassword` | Deleting the active user activates the next visible one (`profilesDeleteActiveSwitchesToNext`: alice, with contact bob, is deleted with "Profile and server connections"; work becomes active, alice leaves the profiles list, the chat list shows work's group and not bob, and the CLI's sends to alice end with `connection authorization failed`); deleting the last visible user shows the picker with "Create chat profile"; the active hidden user's deletion asks for "Profile password" → "Delete chat profile" | — | – |
+| Profile edit | Your current profile, peer notified | Picker → current user: "Profile name:", "Full name:" (only when different), "Bio:", "Add description"/"Edit description", "Edit image"/"Delete image", "Save and notify contacts" | `C/views/usersettings/UserProfileView.kt:32,61,121-160,166-246` | `editProfileDisplayName`, `editProfileBioAndFullName`, `editProfileDescription`, `editProfileUnsavedChangesAlertExitAndSave` | CLI: "contact alice changed to alice2" / "use @alice2 <message> to send messages"; "contact alice updated bio: …"; "contact alice updated full name: …"; "contact alice updated description: …" (`src/Simplex/Chat/View.hs:2342-2365`); `editProfileBioAndFullName`: "Full name:" is absent while the full name is empty and Save is disabled before a change; a typed bio is saved ("contact alice updated bio: loves cats"); after a full name is set through the API, the editor shows "Full name:" with it and an edited full name reaches the CLI ("contact alice updated full name: Alice Jones", `UserProfileView.kt:48,203-210,230,303-304`); `editProfileUnsavedChangesAlertExitAndSave`: after changing the name to carol, leaving shows "Save preferences?" with "Save and notify contacts" / "Exit without saving"; "Exit without saving" closes the editor and alice stays alice; reopened, it shows "alice"; then a change to alice2 saved through the alert's "Save and notify contacts" reaches the CLI as "contact alice changed to alice2" (a saved carol would have printed "contact alice changed to carol" first) (`UserProfileView.kt:101-117,290-298`). Haskell: `testUpdateProfile` (H/Profiles.hs:208); `editProfileDescription`: "Add description" opens the description editor in place of the fields; after typing and Back the link reads "Edit description", and "Save and notify contacts" gives the CLI "contact alice updated description: I like long walks"; reopened, the editor holds the saved text (`UserProfileView.kt:121-160,233-237`) | P | `editProfileBio` renamed to `editProfileBioAndFullName` (absorbs `editProfileFullNameShownOnlyIfDifferent`); `editProfileUnsavedChangesAlertSave` and `editProfileUnsavedChangesAlertExit` merged into `editProfileUnsavedChangesAlertExitAndSave` |
+| Profile edit | Your current profile, local checks | Picker → current user: "Profile name:", "Full name:" (only when different), "Bio:", "Add description"/"Edit description", "Edit image"/"Delete image", "Save and notify contacts" | `C/views/usersettings/UserProfileView.kt:93-99,201,218-226,238,288-305`; `C/model/SimpleXAPI.kt:1930` |  | "Full name:" shown only when it is non-empty and differs from the name; an over-limit bio shows the error icon next to "Bio:"; clicking it shows the "Bio too large" alert; Save is disabled; after changing the name, leaving the screen shows "Save preferences?" / "Save and notify contacts" / "Exit without saving" (`UserProfileView.kt:288-293`), and "Exit without saving" closes it, and reopening the user picker shows "alice" (the picker closed 500 ms after the profile screen opened, `UserPicker.kt:170-174`); a name used by another user shows "Duplicate display name!"; Save is disabled while nothing changed | — | `editProfileNameUsedByOtherUserError` creates a second user; `editProfileFullNameShownOnlyIfDifferent` merged into `editProfileBioAndFullName`; `editProfileUnsavedChangesAlertExit` merged into `editProfileUnsavedChangesAlertExitAndSave`; `editProfileBioTooLarge`, `editProfileNameUsedByOtherUserError` and `editProfileSaveDisabledWhenUnchanged` merged into `editProfileInvalidNameDisablesSave` |
 | Profile edit | Your current profile, image | Picker → current user → "Edit image" / "Delete image" | `C/views/usersettings/UserProfileView.kt:178-186,263-286` | `editProfileImageSetAndDelete` | An image chosen from a file appears on the profile and is saved with "Save and notify contacts" (`chatModel.currentUser.profile.image` is set); "Delete image" clears it and saving stores no image. An image-only change sends no peer-visible line (`src/Simplex/Chat/View.hs:2334`), so the test has no peer | FD | Image picker is a bottom sheet; the file dialog is completed by the test |
-| Profile edit | Name validation, user switch | Picker → current user ("Your current profile") | `C/views/usersettings/UserProfileView.kt:35-37,298-310` | `editProfileInvalidNameDisablesSave`, `editProfileClosesOnUserSwitch` | An invalid or empty name disables Save; switching the active user with `changeActiveUser(null, <second userId>, null)` from test code (the path the user picker uses; a raw `/_user` switches the core but not `chatModel.currentUser`, which the editor watches, UserProfileView.kt:32-36, SimpleXAPI.kt:747) closes the editor | — | `editProfileClosesOnUserSwitch` needs a second user (created in the test) |
+| Profile edit | Name validation, user switch | Picker → current user ("Your current profile") | `C/views/usersettings/UserProfileView.kt:32-37,93-99,191-246,298-310`; `C/model/SimpleXAPI.kt:1960-1972` | `editProfileInvalidNameDisablesSave`, `editProfileClosesOnUserSwitch` | `editProfileInvalidNameDisablesSave`: Save is disabled with nothing changed, enabled for "alice2" and disabled again when the name is changed back; disabled for a blank name; "?alice2" shows the invalid-name icon with Save disabled, and the icon's "Invalid name!" / "Correct name to alice2?" fixes it; a 161-byte bio shows the error icon next to "Bio:" with Save disabled, and the icon opens "Bio too large" (`bioFitsLimit`, `MAX_BIO_LENGTH_BYTES = 160`, `WelcomeView.kt:57-61`); a 160-byte bio is accepted; the name of the other user "work" saves to the "Duplicate display name!" alert and the editor stays with alice unchanged (`CEUserExists`, `src/Simplex/Chat/Library/Commands.hs:4084-4089`; `SimpleXAPI.kt:1965-1966`); `editProfileClosesOnUserSwitch`: switching the active user with `changeActiveUser(null, <second userId>, null)` from test code (the path the user picker uses; a raw `/_user` switches the core but not `chatModel.currentUser`, which the editor watches, UserProfileView.kt:32-36, SimpleXAPI.kt:747) closes the editor | — | `editProfileClosesOnUserSwitch` needs a second user (created in the test) |
 
-### 6. New chat sheet and contacts (17 tests)
+### 6. New chat sheet and contacts (10 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| New chat | Sheet | "Start new chat" → "New chat": "Create 1-time link", "Paste link", "Create group", "Create public channel"; "Your contacts" | `C/views/newchat/NewChatSheet.kt:43,111,186-207` | `newChatSheetShowsActions`, `newChatSheetCreateGroupEntry`, `newChatSheetCreateChannelEntry` | The four actions are shown; the group and channel entries open their creation screens | — | Group and channel flows are another area |
+| New chat | Sheet | "Start new chat" → "New chat": "Create 1-time link", "Paste link", "Create group", "Create public channel"; "Your contacts" | `C/views/newchat/NewChatSheet.kt:45,66-70,112,189-199` | `newChatSheetShowsActions` | The four actions are shown with their labels ("Paste link / Scan" on Android); "Create group" opens "Create secret group" and "Create public channel" opens the channel screen ("Channel name", "Configure relays"), each in place of the sheet, and Back returns to the sheet | — | `newChatSheetCreateGroupEntry` and `newChatSheetCreateChannelEntry` merged into `newChatSheetShowsActions`. Group and channel flows are another area |
 | New chat | Contacts list order | "Start new chat" → "New chat": "Create 1-time link", "Paste link", "Create group", "Create public channel"; "Your contacts" | `C/views/newchat/NewChatSheet.kt:85,420-437,648` | `newChatSheetContactsListSorted` | Order: card, contact with request, request, recent (`NewChatSheet.kt:85,648`) | P, RESTART, FIXTURE (request without contact) | The card is the built-in "Ask SimpleX Team" card (`src/Simplex/Chat/Library/Commands.hs:470`); the request row is made as in §3 `contactRequestLegacyRowWantsToConnect` |
-| Contacts | Contact rows | Tap / right-click a contact row | `C/views/contacts/ContactListNavView.kt:31-140`; `ContactPreviewView.kt:21` | `newChatSheetContactTapOpensChat`, `newChatSheetContactWithRequestOpensChat`, `newChatSheetContactMenuDelete` | Opens the chat and closes the sheet; a contact with a pending request opens its chat with the accept bar (`ContactListNavView.kt:56`); delete runs §15 | P | – |
+| Contacts | Contact rows | Tap / right-click a contact row | `C/views/contacts/ContactListNavView.kt:31-157`; `ContactPreviewView.kt:21` | `newChatSheetContactWithRequestOpensChat` | `newChatSheetContactWithRequestOpensChat`: with contact bob and cath's address request (a contact with a pending request), "Your contacts" lists both; bob's menu "Delete" → "Delete contact" → "Delete and notify contact" gives bob's CLI "alice deleted contact with you" and removes bob from the sheet (`DeleteContactAction`, `ContactListNavView.kt:145-157`; dialog as §15); tapping cath opens her chat with the "Reject" / "Accept" bar and closes the sheet (`ContactListNavView.kt:55-61`) | P | `newChatSheetContactTapOpensChat` merged into `newChatSheetSearchFiltersContacts`; `newChatSheetContactMenuDelete` merged into `newChatSheetContactWithRequestOpensChat` |
 | Contacts | Contact card | Card "Tap to Connect" → "Connect with %1$s?" with "Use current profile" / "Use new incognito profile" / "Cancel" | `ContactListNavView.kt:62-70`; `ChatListNavLinkView.kt:824,886` | `contactCardConnectCurrentProfile`, `contactCardConnectIncognito` | "Connection request sent!"; CLI "alice wants to connect to you!" (incognito: "<rand> wants to connect to you!"); after `/ac`, connected. Haskell: `testPlanAddressContactViaAddress` (2341) | P, RESTART, FIXTURE (contact without connection carrying the CLI's address, inserted after the CLI's /ad) | Group members never become contact cards and the only built-in card ("Ask SimpleX Team") points at public servers, so the card is a fixture; cards are hidden from the main chat list |
-| Contacts | Search and filter | "Search or paste SimpleX link"; favourites filter icon; "No filtered contacts" | `NewChatSheet.kt:476,578,608-666` | `newChatSheetSearchFiltersContacts`, `newChatSheetSearchIncludesArchived`, `newChatSheetFavoritesFilterToggle`, `newChatSheetNoFilteredContacts` | Archived contacts included while searching; the favourites filter icon toggles Pref ShowUnreadAndFavorites, and while it is on the list keeps only favourite contacts (`NewChatSheet.kt:579-580,642`); "No filtered contacts" | P | – |
+| Contacts | Search and filter | "Search or paste SimpleX link"; favourites filter icon; "No filtered contacts" | `NewChatSheet.kt:142-150,220-259,575-593,617-655,657-663` | `newChatSheetSearchFiltersContacts`, `newChatSheetFavoritesFilterToggle` | `newChatSheetSearchFiltersContacts`: with contacts bob and cath, "Your contacts" lists both; "CA" lists only cath and hides the header; "zzz" shows "No filtered contacts" and no contact; tapping cath (searched by "ca") opens cath's chat and closes the sheet, and a message sent there reaches cath; `newChatSheetFavoritesFilterToggle`: with bob a favourite and cath not, the filter icon stores Pref ShowUnreadAndFavorites=true and lists only bob; a second tap stores false and lists both (`ToggleFilterButton`, `NewChatSheet.kt:575-593`; `filterChat`, :640-642); archived contacts while searching are checked in `archivedContactsSendMessageRestores` | P | `newChatSheetSearchIncludesArchived` merged into `archivedContactsSendMessageRestores` |
 | Contacts | Search and filter | "Search or paste SimpleX link"; favourites filter icon; "No filtered contacts" | `NewChatSheet.kt:476,578,608-666` | `newChatSheetPasteLinkInSearchConnects` | A pasted link runs the plan and closes the sheet | P, CB | – |
 | Contacts | Search and filter | "Search or paste SimpleX link"; favourites filter icon; "No filtered contacts" | `NewChatSheet.kt:476,578,608-666` | `newChatSheetConnectToNameRow` | Typing a name shows the row "Connect to %s" (bare words of 5+ characters get `.testing`, e.g. "Connect to bobby.testing"; `@bob.simplex` is kept as typed); tapping it shows the CLI's profile alert over the sheet; «Open new chat» opens the prepared chat and closes the sheet (`closeAllModalsEverywhere`, ConnectPlan.kt:726-740) | P, NAMES | – |
-| Contacts | Archived contacts | "Archived contacts" row → list | `NewChatSheet.kt:210-258,669` | `archivedContactsListAndOpen`, `archivedContactsSendMessageRestores` | After "Only delete conversation" bob leaves the chat list and the "Archived contacts" row (shown only while some contact is archived, `NewChatSheet.kt:226-258`) lists bob; opening bob there and sending "hi" gives `bob <# "alice> hi"`, puts bob back in the chat list with the preview "hi", and the "Archived contacts" row disappears. Haskell: `testDeleteConversationKeepContact` (609) | P | – |
+| Contacts | Archived contacts | "Archived contacts" row → list | `NewChatSheet.kt:183-187,202-259,657-663,672-760` | `archivedContactsSendMessageRestores` | No "Archived contacts" row while no contact is archived; after "Only delete conversation" bob leaves the chat list, the row "Archived contacts" appears and "Your contacts" lists cath but not bob (`NewChatSheet.kt:220-259`); searching "bo" lists the archived bob and hides the row (`contactTypesSearchTargets`, :657-663); clearing the search hides bob again; the row opens the archived list with bob only; tapping bob opens his chat and closes the sheet; "hi" sent there gives `bob <# "alice> hi"`, puts bob back in the chat list with the preview "hi", and the sheet lists him under "Your contacts" with no "Archived contacts" row. Haskell: `testDeleteConversationKeepContact` (609) | P | `archivedContactsListAndOpen` and `newChatSheetSearchIncludesArchived` merged into `archivedContactsSendMessageRestores` |
 
-### 7. 1-time link (create / share / QR / incognito / profile) (17 tests)
+### 7. 1-time link (create / share / QR / incognito / profile) (14 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Invite | Create link | "Create 1-time link" → tabs "1-time link"/"Connect via link"; "Creating link…"; "Share this 1-time invite link"; "Or show this code" | `C/views/newchat/NewChatView.kt:53,182,468,799` | `createOneTimeLinkShowsLinkAndQr` | Link text and QR shown. Haskell: `testAddContact` | — | "Or show this code" is drawn upper-case (`NewChatView.kt:507`): match it ignoring case or by its key |
+| Invite | Create link | "Create 1-time link" → tabs "1-time link"/"Connect via link"; "Creating link…"; "Share this 1-time invite link"; "Or show this code" | `C/views/newchat/NewChatView.kt:56,185,474-518,808` | `createOneTimeLinkShowsLinkAndQr` | Before: no link and no "QR Code" image; after: the link text, "Share this 1-time invite link", "OR SHOW THIS CODE", the "QR Code" image and alice in "Share profile". Haskell: `testAddContact` | — | "Or show this code" is drawn upper-case (`NewChatView.kt:507`): match it ignoring case or by its key |
 | Invite | Copy and share | Copy and share icons on the link | `NewChatView.kt:716-766` | `oneTimeLinkCopyToClipboard`, `oneTimeLinkShareButton` | Clipboard stub gets the short `simplex:`/https link | CB | Icons have no description |
 | Invite | CLI connects | CLI `/c <link>` | – | `oneTimeLinkCliConnectsViaShortLink` | CLI "confirmation sent!", then "alice: contact is connected"; GUI row turns into contact "bob". Haskell: `testShortLinkInvitation` (H/Profiles.hs:3879) | P, S | – |
-| Invite | CLI connects | CLI `/c <link>` | – | `oneTimeLinkCliConnectsViaFullLink` | CLI "confirmation sent!", then "alice: contact is connected"; GUI row turns into contact "bob". Haskell: `testAddContact` (H/Direct.hs:191; full link in every matrix case) | P, S, DT | The "Full link"/"Short link" toggle is visible only with developer tools (`NewChatView.kt:585`) |
-| Invite | Short/full toggle | "Full link"/"Short link" | `NewChatView.kt:585` | `oneTimeLinkShortFullToggleRequiresDevTools` | Hidden without developer tools | DT | – |
+| Invite | CLI connects | CLI `/c <link>` | `NewChatView.kt:508,594-605` | `oneTimeLinkCliConnectsViaFullLink` | Without developer tools the link screen has no "Full link" toggle (key `Ui.Link.ShortLinkToggle`) and the link shown is the short one (no `/invitation#/?v=`); with developer tools turned on the toggle reads "Full link", and clicking it turns the link text into the full link and the toggle into "Short link"; CLI `/c <full link>` prints "confirmation sent!", then "alice: contact is connected", and bob's row appears. Haskell: `testAddContact` (H/Direct.hs:191; full link in every matrix case) | P, S, DT | The "Full link"/"Short link" toggle is visible only with developer tools (`NewChatView.kt:595`); developer tools are turned on through the pref (`enableDeveloperToolsViaApi`), a precondition |
+| Invite | Short/full toggle | "Full link"/"Short link" | `NewChatView.kt:594-605` |  | Hidden without developer tools | DT | `oneTimeLinkShortFullToggleRequiresDevTools` merged into `oneTimeLinkCliConnectsViaFullLink` |
 | Invite | Error and retry | SMP server down | `NewChatView.kt:190-194,211` | `oneTimeLinkCreationErrorShowsRetry` | "Connection error" alert with "Retry"/"Cancel"; after "Cancel", the refresh icon with "Retry"; after the server is started again, tapping it shows the link | SRVCTL | The app's agent caches a failed server connection for 3 s (`persistErrorInterval`, 3 s in the app and in `testAgentCfg`; only some Haskell tests set it to 0, e.g. `H/Profiles.hs:253`), so the retry happens more than 3 s after the failure, after the server is started again |
-| Invite | Keep unused | Close without using the link | `NewChatView.kt:70-100` | `oneTimeLinkKeepUnusedAlertKeep`, `oneTimeLinkKeepUnusedAlertDelete` | "Keep unused invitation?" / "You can view invitation link again in connection details." / "Keep" / "Delete"; `oneTimeLinkKeepUnusedAlertKeep`: "Keep" only closes the alert, and the pending row ("invited to connect") stays in the chat list; `oneTimeLinkKeepUnusedAlertDelete`: "Delete" removes the row, and the command log has `/_delete :<connId> full notify=on` (`NewChatView.kt:82-88`; `C/model/SimpleXAPI.kt:1854-1858,4270`) | — | – |
-| Invite | Keep unused | Close without using the link | `NewChatView.kt:70-100` | `oneTimeLinkUsedNoAlert` | No alert after the link was copied or shared | CB | – |
+| Invite | Keep unused | Close without using the link | `NewChatView.kt:73-103,729,761,768` | `oneTimeLinkKeepUnusedAlert` | "Keep unused invitation?" / "You can view invitation link again in connection details." / "Keep" / "Delete"; "Delete" removes the pending connection, and the CLI's plan for that link ends in `connection authorization failed`; a link shared by tapping it (clipboard/share) closes without the alert and its pending connection stays; "Keep" only closes the alert, the pending connection stays, and the CLI connects with the kept link ("alice: contact is connected") | P, CB | `oneTimeLinkKeepUnusedAlertKeep` and `oneTimeLinkKeepUnusedAlertDelete` merged into `oneTimeLinkKeepUnusedAlert` |
+| Invite | Keep unused | Close without using the link | `NewChatView.kt:73-103` |  | No alert after the link was copied or shared | CB | `oneTimeLinkUsedNoAlert` merged into `oneTimeLinkKeepUnusedAlert` |
 | Invite | Save the QR code by clicking it | "Create 1-time link" → click the QR code ("QR Code", `image_descr_qr_code`, strings.xml:897) → choose a folder → choose a file for the copy → close the sheet | `C/views/newchat/QRCode.kt:89-99`; `D/views/helpers/Utils.desktop.kt:239-252`; `D/platform/Share.desktop.kt:25-43`; `NewChatView.kt:498,510,76-96` | `oneTimeLinkQrClickSavesPng` | The first save dialog is directories-only; after `respondSave(<dir>)` the folder holds one `IMG_<ts>.png`; a second save dialog awaits and `respondSave(<file>)` writes a copy there; closing the sheet shows no "Keep unused invitation?" alert (`onShare` → `markShowingInvitationUsed`, ChatModel.kt:1249-1251). Optionally decode the PNG with BoofCV (already an app dependency, QRCode.kt) and compare it with `chatModel.showingInvitation`'s short link | FD | The same click exists on every QR code (address, group link, member address, server, Link a mobile); one row covers the code path |
 | Invite | Learn more | ⓘ "Learn more" end button | `NewChatView.kt:611`; `AddContactLearnMore.kt:17` | `oneTimeLinkLearnMore` | "One-time invitation link" text | — | – |
-| Invite | Incognito / profile | "Share profile" row → "Select chat profile" (search field) → "Incognito" or another profile | `NewChatView.kt:288-465,524-580` | `oneTimeLinkSwitchToIncognito`, `oneTimeLinkSwitchBackFromIncognito`, `oneTimeLinkChangeToOtherProfile`, `oneTimeLinkChangeToHiddenProfileViaPassword` | `oneTimeLinkSwitchToIncognito`: footer "A new random profile will be shared." (absent before); CLI sees a random name ("<rand>: contact is connected"), and alice's contact bob is incognito (`contactConnIncognito`); `oneTimeLinkSwitchBackFromIncognito`: choosing the active profile again puts its name back in the "Share profile" row and removes the footer (`NewChatView.kt:559-578`); the core recreates the link for that user (`APIChangeConnectionUser`, `src/Simplex/Chat/Library/Commands.hs:2157-2185`), and a CLI connecting with the new link prints "alice: contact is connected"; `oneTimeLinkChangeToOtherProfile`: GUI switches active user; CLI "<other profile>: contact is connected"; `oneTimeLinkChangeToHiddenProfileViaPassword`: the hidden profile is listed in "Select chat profile" only after its password is typed in the search field (`filteredProfiles`, `NewChatView.kt:768-777`); choosing it makes it the active user, and the CLI prints "<hidden profile>: contact is connected". Haskell: `testSetConnectionIncognito` (2574), `testResetConnectionIncognito`, `testChangePCCUser` (3054), `testChangePCCUserFromIncognito`, `testShortLinkInvitationSetIncognito`, `testShortLinkInvitationChangeUser` | P | A hidden profile is chosen by typing its password in the search field |
+| Invite | Incognito / profile | "Share profile" row → "Select chat profile" (search field) → "Incognito" or another profile | `NewChatView.kt:293-471,522-588,777-786` | `oneTimeLinkSwitchToIncognito`, `oneTimeLinkSwitchBackFromIncognito`, `oneTimeLinkChangeToOtherProfile`, `oneTimeLinkChangeToHiddenProfileViaPassword` | `oneTimeLinkSwitchToIncognito`: footer "A new random profile will be shared." (absent before); CLI sees a random name ("<rand>: contact is connected"), and alice's contact bob is incognito (`contactConnIncognito`); `oneTimeLinkSwitchBackFromIncognito`: choosing "Incognito" stores Pref Incognito=true, so the next link is created incognito (footer shown, "Incognito" in the "Share profile" row); choosing the active profile again stores Incognito=false, puts its name back in the "Share profile" row and removes the footer (`NewChatView.kt:334,392,522-586`); the core recreates the link for that user (`APIChangeConnectionUser`, `src/Simplex/Chat/Library/Commands.hs:2166-2193`), and a CLI connecting with the new link prints "alice: contact is connected" and alice's contact bob is not incognito; `oneTimeLinkChangeToOtherProfile`: GUI switches active user and shows a new link; CLI "<other profile>: contact is connected", and the first link's plan ends in `connection authorization failed` (the old connection is deleted, Commands.hs:2192); `oneTimeLinkChangeToHiddenProfileViaPassword`: the hidden profile is listed in "Select chat profile" only after its password is typed in the search field (`filteredProfiles`, `NewChatView.kt:768-777`); choosing it makes it the active user, and the CLI prints "<hidden profile>: contact is connected". Haskell: `testSetConnectionIncognito` (2574), `testResetConnectionIncognito`, `testChangePCCUser` (3054), `testChangePCCUserFromIncognito`, `testShortLinkInvitationSetIncognito`, `testShortLinkInvitationChangeUser` | P | A hidden profile is chosen by typing its password in the search field |
 | Invite | Incognito info | ⓘ next to "Incognito" in "Select chat profile" | `NewChatView.kt:248-265,403`; `C/views/usersettings/IncognitoView.kt:18` | `oneTimeLinkIncognitoInfoButton` | ⓘ next to "Incognito" opens the incognito info screen ("Incognito mode") | — | – |
 
-### 8. Paste link and connection plans (contact, invitation, address, bot, name, signature, URI and link-card links) (29 tests)
+### 8. Paste link and connection plans (contact, invitation, address, bot, name, signature, URI and link-card links) (15 tests)
 
-Entry for every row: New chat › "Paste link" → "Paste the link you received" → "Tap to paste link" (reads the clipboard stub). The same plans run from chat-list search, the new-chat search, a tapped link card, or a `simplex:` URI. Code: `C/views/newchat/NewChatView.kt:628,671`, `C/views/newchat/ConnectPlan.kt:24-406`. Assert the CLI-side `/_connect plan` output where noted.
+Entry for every row: New chat › "Paste link" → "Paste the link you received" → "Tap to paste link" (reads the clipboard stub). The same plans run from chat-list search, the new-chat search, a tapped link card, or a `simplex:` URI. Code: `ConnectView` `C/views/newchat/NewChatView.kt:635`, `PasteLinkView` `:678-720`, `C/views/newchat/ConnectPlan.kt:24-406`. Assert the CLI-side `/_connect plan` output where noted. The tests use the chat-list search ("Search or paste SimpleX link", `ChatListView.kt:873-881,924-934`) except `pasteLinkInvalidTextAlert`: on Android "Paste link / Scan" opens the QR scanner at once (`NewChatSheet.kt:62-64`), so a test on that route starts with `assumeCamera()`. The search filters Known contacts into the list instead of an alert (`ChatListView.kt:929`), so Known alerts are tested through the link card in a message (`FramedItemView.kt:409-411`).
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Paste | Invalid or empty clipboard | "Tap to paste link" | `NewChatView.kt:671-699` | `pasteLinkInvalidTextAlert`, `pasteLinkClipboardEmptyNoop` | `pasteLinkInvalidTextAlert`: "Invalid link!" / "The text you pasted is not a SimpleX link."; `pasteLinkClipboardEmptyNoop`: with no text on the clipboard, clicking "Tap to paste link" does nothing: no alert, and the row stays (`NewChatView.kt:675`) | CB | – |
-| Plan | Progress and cancel | Paste the CLI's short link into "Search or paste SimpleX link" | `C/model/ChatModel.kt:55-61`; `ChatListView.kt:561-567`; `C/views/chat/ChatView.kt:304` | `planProgressIndicatorAndCancel` | With the link's SMP server stopped the plan fails at once and the retry alert "Connection error" ("Retry" / "Cancel") opens (`sendCmdWithRetry`, `C/model/SimpleXAPI.kt:845-874`); the plan stays pending behind it, so the toolbar spinner appears after 1 s (no text on desktop); "Cancel" ends the plan, the spinner goes away and the search is cleared | P, SRVCTL, CB | "Loading profile…" text is Android-only (`ChatView.kt:304`) |
-| Invitation | Short link: OK | CLI `/c` short link | `ConnectPlan.kt:91-102,700` | `planInvitationShortLinkOpenNewChat` | Alert with the CLI profile "bob" and "Open new chat" (`ConnectPlan.kt:711-727`); it opens bob's prepared chat, whose banner reads "Tap Connect to chat" and whose compose area shows "Connect" (§9, `ChatView.kt:2257-2259`). Haskell: `testShortLinkInvitationPrepareContact` (4077; Ok plan with short-link data) | P, CB | – |
-| Invitation | Full link: OK | CLI's "The invitation link for old clients:" line | `ConnectPlan.kt:103-113,448,408` | `planInvitationFullLinkUseCurrentProfile`, `planInvitationFullLinkUseIncognito`, `planInvitationFullLinkCancel` | "Connect via one-time link?" / "Your profile will be sent to the contact that you received this link from." → "Use current profile" / "Use new incognito profile" / "Cancel" → "Connection request sent!" / "You will be connected when your contact's device is online, please wait or check later!"; CLI "alice: contact is connected" (incognito: "<rand>: contact is connected"; Cancel: no request, no pending row). Haskell: `testPlanInvitationLinkOk` (486), `testConnectIncognitoInvitationLink` (2462) | P, S, CB | Stable CLI is a good full-link source. The current-build peer is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full link; the stable CLI (v7.0.3) prints it without any option (its `View.hs` has no `showFullLinks` gate) |
-| Invitation | Own link | Paste the GUI's own 1-time link | `ConnectPlan.kt:114-123` | `planOwnInvitationConnectToYourself` | "Connect to yourself?" / "This is your own one-time link!" (buttons in the error colour); "Use current profile" (`ConnectPlan.kt:470-476`) → dismiss "Connection request sent!" (`ConnectPlan.kt:417-433`); this gives two contacts, both shown as "alice". Haskell: `testPlanInvitationLinkOwn` (507) | CB | – |
-| Invitation | Already connecting | Paste the full link → "Use current profile" → dismiss "Connection request sent!"; paste the same link again before CLI is online | `ConnectPlan.kt:124-142` | `planInvitationAlreadyConnectingFullLink` | "Already connecting!" / "You are already connecting via this one-time link!". Haskell: `testPlanInvitationLinkConnecting` (543) | P, PEERCTL, CB | Stop the CLI process after it creates the link. The current-build peer is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full link |
-| Invitation | Known | Paste after connecting | `ConnectPlan.kt:143-152,519` | `planInvitationKnownContactOpenChat` | Pasting the short link again after connecting: the profile alert "bob" has "Open chat", not "Open new chat" (`ConnectPlan.kt:533`), and opens bob's chat with the banner "Your contact" (`ChatView.kt:2267`) and the messages already exchanged. Haskell: `testShortLinkInvitationPrepareContact` (H/Profiles.hs:4103) | P, CB | "Known" happens only for short links (H/Direct.hs:502-503) |
+| Paste | Invalid or empty clipboard | "Tap to paste link" | `NewChatView.kt:681-698` | `pasteLinkInvalidTextAlert` | With no text on the clipboard, clicking "Tap to paste link" does nothing: no alert, and the row stays (`NewChatView.kt:682`); with a web link: "Invalid link!" / "The text you pasted is not a SimpleX link." and the row stays; with alice's own address: the row is replaced by the link and "Connect to yourself?" opens, "Cancel" brings the row back | CB | `pasteLinkClipboardEmptyNoop` merged into `pasteLinkInvalidTextAlert`. Android: needs a camera (`assumeCamera()`), and `setClipboardText(null)` clears the clip (API 28), because an empty clip is text `""`, which the app rejects as invalid |
+| Plan | Progress and cancel | Paste the CLI's short link into "Search or paste SimpleX link" | `C/model/ChatModel.kt:55-61`; `ChatListView.kt:561-567`; `C/views/chat/ChatView.kt:304` | `planProgressIndicatorAndCancel` | With the link's SMP server stopped the plan fails at once and the retry alert "Connection error" ("Retry" / "Cancel") opens (`sendCmdWithRetry`, `C/model/SimpleXAPI.kt:877-913`); the plan stays pending behind it, so the toolbar spinner appears after 1 s (no text on desktop); "Cancel" ends the plan, the spinner goes away and the search is cleared | P, SRVCTL, CB | "Loading profile…" text is Android-only (`ChatView.kt:304`) |
+| Invitation | Short link: OK | CLI `/c` short link | `ConnectPlan.kt:91-102,700` |  | Alert with the CLI profile "bob" and "Open new chat" (`ConnectPlan.kt:711-727`); it opens bob's prepared chat, whose banner reads "Tap Connect to chat" and whose compose area shows "Connect" (§9, `ChatView.kt:2262`). Haskell: `testShortLinkInvitationPrepareContact` (4077; Ok plan with short-link data) | P, CB | `planInvitationShortLinkOpenNewChat` merged into `preparedContactInvitationConnectButton` (§9): its steps are that test's first half |
+| Invitation | Full link: OK | CLI's "The invitation link for old clients:" line | `ConnectPlan.kt:103-113,448,408` |  | "Connect via one-time link?" / "Your profile will be sent to the contact that you received this link from." → "Use current profile" / "Use new incognito profile" / "Cancel" → "Connection request sent!" / "You will be connected when your contact's device is online, please wait or check later!"; CLI "alice: contact is connected" (incognito: "<rand>: contact is connected"; Cancel: no request, no pending row). Haskell: `testPlanInvitationLinkOk` (486), `testConnectIncognitoInvitationLink` (2462) | P, CB | `planInvitationFullLinkUseCurrentProfile` and `planInvitationFullLinkCancel` merged into `planInvitationAlreadyConnectingFullLink` (both buttons clicked there); `planInvitationFullLinkUseIncognito` merged into `planAddressRepeatConnectionRequest` (the incognito button of the same alert function, with a peer-visible random name). Current CLI only (`PeerFlags(fullLinks = true)`, `--show-full-links`, `src/Simplex/Chat/Options.hs:435`); a stable-CLI variant needs `CliVersion` (plan §0.5.11) |
+| Invitation | Own link | Paste the GUI's own address, then its own 1-time link | `ConnectPlan.kt:114-123,182-193` | `planOwnInvitationConnectToYourself` | Own address first: "Connect to yourself?" / "This is your own SimpleX address!" with "Use current profile" / "Use new incognito profile" / "Cancel" (`ConnectPlan.kt:463-503`); "Use current profile" → "Connection request sent!" / "You will be connected when your connection request is accepted…" and a row "alice" with "Open to accept" (alice's own request: `alice_1` in `testPlanAddressOwn`, H/Profiles.hs:2194-2200). Then the kept 1-time link: "Connect to yourself?" / "This is your own one-time link!" (buttons in the error colour); "Use current profile" (`ConnectPlan.kt:469-476`) → "Connection request sent!" / "You will be connected when your contact's device is online…" (`connectViaUri`, `ConnectPlan.kt:408-433`); this gives two connected contacts named "alice" and the 1-time link is no longer pending. Haskell: `testPlanInvitationLinkOwn` (507), `testPlanAddressOwn` (2181) | CB | Also covers §8 "Address: Own address" (same alert function) |
+| Invitation | Already connecting | Paste the full link → "Cancel"; paste it again → "Use current profile" → dismiss "Connection request sent!"; paste the same link again while the CLI process is stopped | `ConnectPlan.kt:124-142` | `planInvitationAlreadyConnectingFullLink` | "Cancel" creates no pending connection; the third paste shows "Already connecting!" / "You are already connecting via this one-time link!" (not "Connect via one-time link?") and no second pending connection; after the CLI process restarts it prints "alice: contact is connected" and alice has a contact bob and no pending row. Haskell: `testPlanInvitationLinkConnecting` (543) | P, PEERCTL, CB | The CLI process is stopped (`bob.stop()`) after creating the link and started again (`bob.start()`, same database) at the end, as the Haskell test runs the inviter offline; `/_stop` in the CLI ends the process ("simplex-chat: AsyncCancelled", `src/Simplex/Chat/Core.hs:101-106`), so it cannot be used; once connected, the core forgets `conn_req_inv` and the plan would be "ok" again (H/Direct.hs:502-503). Current CLI with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`). Also covers the "Use current profile" and "Cancel" buttons of "Full link: OK" |
+| Invitation | Known | Paste after connecting | `ConnectPlan.kt:143-152,519` |  | Pasting the short link again after connecting: the profile alert "bob" has "Open chat", not "Open new chat" (`ConnectPlan.kt:533`), and opens bob's chat with the banner "Your contact" (`ChatView.kt:2270`) and the messages already exchanged. Haskell: `testShortLinkInvitationPrepareContact` (H/Profiles.hs:4103) | P, CB | `planInvitationKnownContactOpenChat` merged into `planViaChatItemLinkCard`: the same `showOpenKnownContactAlert` (`ConnectPlan.kt:519-541`); the search route filters Known contacts and the paste route needs a camera on Android. "Known" happens only for short links (H/Direct.hs:502-503); invitation Known in the core: H/Profiles.hs:4078-4080 |
 | Invitation | Known: prepared contact | Paste the short link of a prepared contact | `ConnectPlan.kt:143-152,519` | `planInvitationConnectingPreparedOpensKnown` | Pasting the short link of a prepared contact shows the profile alert with "Open new chat" (before Connect) / "Open chat" (after). Haskell: `testShortLinkInvitationPrepareContact` (4088-4089, Profiles.hs) | P, CB | The core never returns Connecting with a contact; a prepared or connecting contact plans as Known (`src/Simplex/Chat/Library/Commands.hs:4655-4662`) |
-| Invitation | Deleted link → error | CLI deletes the invitation (`/_delete :1`, prints `connection :1 deleted`, `H/Profiles.hs:4279-4280`; the queue is deleted on the server later, in a background thread: `deleteAgentConnectionAsync`, `Library/Commands.hs:1381`, simplexmq `Agent.hs:1013-1015`), repeats `/_connect plan 1 <short link>` until it prints `error: connection authorization failed - …` (the plan reads the link from the server, `Library/Commands.hs:4431`), then alice pastes it | `C/model/SimpleXAPI.kt:1722-1728` | `planInvitationDeletedLinkError` | The plan call fails with SMP AUTH and the alert "Connection link removed" / "Your contact removed this link, or it was a one-time link that was already used.…" appears | P, CB | – |
-| Address | Short link: OK | CLI `/ad` short link | `ConnectPlan.kt:155-168` | `planAddressShortLinkOpenNewChat` | Profile alert "bob" with "Open new chat" (`ConnectPlan.kt:711-727`); it opens bob's prepared chat with the banner "Tap Connect to send request" (`ChatView.kt:2260`). Haskell: `testShortLinkAddressPrepareContact` (4188; Ok plan with short-link data) | P, CB | – |
-| Address | Full link: OK | CLI full address | `ConnectPlan.kt:169-181` | `planAddressFullLinkConnectAlert` | "Connect via contact address?" → "Use current profile" → "Connection request sent!" / "You will be connected when your connection request is accepted…"; CLI "alice wants to connect to you!"; after `/ac`, connected. Haskell: `testUserContactLink` | P, S, CB | The current-build peer is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full link; the stable CLI (v7.0.3) prints it without any option (its `View.hs` has no `showFullLinks` gate) |
-| Address | Own address | Paste own address | `ConnectPlan.kt:182-193` | `planOwnAddressConnectToYourself` | "Connect to yourself?" / "This is your own SimpleX address!" with "Use current profile" / "Use new incognito profile" (`ConnectPlan.kt:463-484`); "Use current profile" shows "Connection request sent!", and a contact row "alice" with "Open to accept" appears (alice's own request: `alice_1` in `testPlanAddressOwn`, H/Profiles.hs:2194-2200). Haskell: `testPlanAddressOwn` (2181) | CB | – |
-| Address | Repeat request | Paste the full address → "Use current profile" → dismiss "Connection request sent!"; paste it again while pending | `ConnectPlan.kt:194-205` | `planAddressRepeatConnectionRequest` | "Repeat connection request?" / "You have already requested connection via this address!". Haskell: `testPlanAddressConnecting` (2229; ConnectingConfirmReconnect plan) | P, CB | The request stays pending while the CLI doesn't run `/ac`. The current-build peer is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full link |
+| Invitation | Deleted link → error | bob deletes his address (`/da`, prints "Your chat address is deleted - accepted contacts will remain connected." / "To create a new chat address use /ad", `View.hs:1123-1127`; the address is gone on the server at once, H/Profiles.hs:4273-4277), then alice pastes it | `C/model/SimpleXAPI.kt:1757-1764` |  | The plan call fails with SMP AUTH and the alert "Connection link removed" / "Your contact removed this link, or it was a one-time link that was already used.…" appears | P, CB | `planInvitationDeletedLinkError` re-targeted to a deleted address and merged into `searchPasteLinkTriggersConnectPlan` (§3 Search, whose existing steps are the opposite state). A deleted invitation is removed on the server later, in a background thread (`deleteAgentConnectionAsync`), which needs a peer polling loop (`repeatUntil`, plan §0.5.11) |
+| Address | Short link: OK | CLI `/ad` short link | `ConnectPlan.kt:155-168` |  | Profile alert "bob" with "Open new chat" (`ConnectPlan.kt:711-727`); it opens bob's prepared chat with the banner "Tap Connect to send request" (`ChatView.kt:2263`). Haskell: `testShortLinkAddressPrepareContact` (4188; Ok plan with short-link data) | P, CB | `planAddressShortLinkOpenNewChat` merged into `preparedContactAddressSendRequestWithMessage` (§9): its first half |
+| Address | Full link: OK | CLI full address | `ConnectPlan.kt:169-181` |  | "Connect via contact address?" → "Use new incognito profile" → "Connection request sent!" / "You will be connected when your connection request is accepted…"; CLI "<rand> wants to connect to you!" with a random name; after `/ac`, connected incognito. Haskell: `testUserContactLink` | P, CB | `planAddressFullLinkConnectAlert` merged into `planAddressRepeatConnectionRequest`. Current CLI only (`PeerFlags(fullLinks = true)`); a stable-CLI variant needs `CliVersion` (plan §0.5.11) |
+| Address | Own address | Paste own address | `ConnectPlan.kt:182-193` |  | "Connect to yourself?" / "This is your own SimpleX address!" with "Use current profile" / "Use new incognito profile" (`ConnectPlan.kt:463-503`); "Use current profile" shows "Connection request sent!", and a contact row "alice" with "Open to accept" appears (alice's own request: `alice_1` in `testPlanAddressOwn`, H/Profiles.hs:2194-2200). Haskell: `testPlanAddressOwn` (2181) | CB | `planOwnAddressConnectToYourself` merged into `planOwnInvitationConnectToYourself` (same alert function) |
+| Address | Repeat request | Paste the full address → "Use new incognito profile" → dismiss "Connection request sent!"; paste it again while pending → "Cancel" | `ConnectPlan.kt:194-205` | `planAddressRepeatConnectionRequest` | The CLI prints "<rand> wants to connect to you!" (not alice), "to accept: /ac <rand>", "to reject: /rc <rand> (the sender will NOT be notified)" (`View.hs:1267-1272`); the second paste shows "Repeat connection request?" / "You have already requested connection via this address!" (not "Connect via contact address?"); after "Cancel" and `/ac <rand>` the CLI's next line is "<rand>: accepting contact request…" (no second request) and alice has an incognito contact bob. Haskell: `testPlanAddressConnecting` (2229; ConnectingConfirmReconnect plan) | P, CB | The request stays pending while the CLI doesn't run `/ac`. Current CLI with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`). Also covers "Full link: OK" (address) and the incognito button of "Full link: OK" (invitation) |
 | Address | Connecting, prohibited | After Connect on a prepared contact (CLI not yet accepted), paste the CLI's full address | `ConnectPlan.kt:206-215` | `planAddressConnectingProhibitOpensKnown` | Profile alert with "Open chat" | P, CB | ConnectingProhibit comes only from the full-address lookup (`src/Simplex/Chat/Library/Commands.hs:4686-4687`); the short address plans as Known. The current-build peer is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full link |
-| Address | Known | After connecting, paste the address again | `ConnectPlan.kt:216-246` | `planAddressKnownContactOpenChat` | "Open chat". Haskell: `testPlanAddressOkKnown` (2147) | P, CB | – |
-| Address | Contact via address | With a contact card for the CLI's address, paste the address | `ConnectPlan.kt:216-246` | `planAddressContactViaAddressOpensChat` | Pasting the address shows "Open chat" and opens the card's chat. Haskell: `testPlanAddressContactViaAddress` (2341) | P, CB, RESTART, FIXTURE (contact without connection carrying the CLI's address) | The card is inserted between `restart()` steps after the CLI's `/ad` (as in §6) |
+| Address | Known | After connecting, paste the address again | `ConnectPlan.kt:216-231` |  | "Open chat". Haskell: `testPlanAddressOkKnown` (2147) | P, CB | `planAddressKnownContactOpenChat` merged into `planViaChatItemLinkCard` (bob's card in bob's chat) |
+| Address | Contact via address | With a contact card for the CLI's address, paste the address | `ConnectPlan.kt:232-246` | `planAddressContactViaAddressOpensChat` | Pasting the address shows "Open chat" and opens the card's chat. Haskell: `testPlanAddressContactViaAddress` (2341) | P, CB, RESTART, FIXTURE (contact without connection carrying the CLI's address) | The card is inserted between `restart()` steps after the CLI's `/ad` (as in §6) |
 | Address | Deleted contact | After the CLI deletes the contact (`/d alice`) and alice's chat-list row shows the item "deleted contact" (the deletion has reached her, as in `contactDeletedByPeerShowsDeleted`), paste the address again | `ConnectPlan.kt:155-168`; `src/Simplex/Chat/Library/Commands.hs:4688` | `planAddressDeletedContactReconnect` | The plan is Ok again: the prepare alert "Open new chat" (short link), and connecting gives a new contact. Until alice has processed the deletion the plan is still Known and the alert offers "Open chat" (`contactDeleted`, `src/Simplex/Chat/Library/Commands.hs:4519,4688-4689`). Haskell: `testPlanAddressContactDeletedReconnected` (2276), `testShortLinkAddressDeleteContact` (4230) | P, CB | – |
-| Bot | Bot address | CLI profile with peerType bot | `ConnectPlan.kt:720`; `ComposeView.kt:1807` | `planBotAddressShowsBotIcon` | After "Open new chat": the banner "Tap Connect to use bot" (`ChatView.kt:2260`), the chat row "Open to use bot" (`ChatPreviewView.kt:189`) and a "Connect" button instead of the contact-request composer (`ComposeView.kt:1806-1812`); the alert's cube icon (`ConnectPlan.kt:720`) has the generic description "profile image placeholder", so it is checked in the screenshot only | P, CB | Set the bot profile through the CLI `/_profile` JSON |
-| Signature | Signed address card | CLI `/share address @alice` → tap the card in the chat list | `ChatPreviewView.kt:355-367`; `ConnectPlan.kt:807` | `planSignedAddressCardVerified` | Info line "Link signature verified." in the profile alert. Haskell: `testShareAddressViaChat` (3937; verified owner signature) | P | The CLI runs `/ad` before `/share address @alice` |
-| Signature | Failed signature verification | A tampered signed address card: bob runs `/ad` and `/share address @alice` (a genuinely signed card), reads the item with `/_get chat @<alice's contact id> count=1` (the real CLI prints JSON, `View.hs:129`, including `ownerSig` and its `chatBinding`; the peer's output model joins the line if it wraps, plan §8.1), and re-sends the card with `/_send @<alice's contact id> json [{"msgContent":{"type":"chat",…,"ownerSig":{…the same chatBinding, an altered ownerSig}}}]`; alice keeps the signature because the binding matches her connection (`Library/Subscriber.hs:1931-1938`) | `ConnectPlan.kt:809`, `FramedItemView.kt:407` | `planOwnerSignatureFailed` | Tapping the tampered card plans the link with its `ownerSig`; `verifyLinkOwner` returns `OVFailed "signature verification failed"` (`Library/Commands.hs:4751-4760`) and the alert shows "⚠️ Signature verification failed: signature verification failed." (`ConnectPlan.kt:809`, strings.xml:586, `Commands.hs:4760`) | P | The sender drops `ownerSig` only when forwarding (`Library/Commands.hs:1158-1164`); `/_send … json` passes it through (`Protocol.hs:882-886`) |
-| Names | Connect by name | "Connect to @bob.simplex" row, or paste a name | `ChatListView.kt:1207`; `ConnectPlan.kt:81-89` | `planConnectByNameContact` | Profile alert with name caption. Haskell: `testConnectByName` | P, NAMES | – |
-| Names | Name not found | "Connect to @bob.simplex" row, or paste a name | `ChatListView.kt:1207`; `C/model/SimpleXAPI.kt:1707-1710` | `planConnectByNameNotFound` | Alert "Name not found". Haskell: `testConnectByNameNotFound` | NAMES | – |
+| Bot | Bot address | CLI profile with peerType bot | `ConnectPlan.kt:720`; `ComposeView.kt:1822-1827` |  | After "Open new chat": the banner "Tap Connect to use bot" (`ChatView.kt:2263`), the chat row "Open to use bot" (`ChatPreviewView.kt:190-191`) and a "Connect" button instead of the contact-request composer (`ComposeView.kt:1821-1834`) | P, CB | `planBotAddressShowsBotIcon` merged into `preparedBotConnect` (§9): the alert's cube icon (`ConnectPlan.kt:720`) has only the generic description "profile image placeholder", so the name's icon claim is not tested; its checkable parts are there. The CLI sets the bot profile through `/_profile` JSON |
+| Signature | Signed address card | CLI `/share address @alice` → tap the card in the chat list | `ChatPreviewView.kt:355-367`; `ConnectPlan.kt:807` |  | Info line "Link signature verified." in the profile alert. Haskell: `testShareAddressViaChat` (3937; verified owner signature) | P | `planSignedAddressCardVerified` merged into `planViaChatItemLinkCard` (cath's chat-list card) |
+| Signature | Failed signature verification | A tampered signed address card: bob runs `/ad` and `/share address @alice` (a genuinely signed card), reads the item with `/_get chat @<alice's contact id> count=1` (the real CLI prints JSON, `View.hs:129`, including `ownerSig` and its `chatBinding`; the peer's output model joins the line if it wraps, plan §8.1), and re-sends the card with `/_send @<alice's contact id> json [{"msgContent":{"type":"chat",…,"ownerSig":{…the same chatBinding, an altered ownerSig}}}]`; alice keeps the signature because the binding matches her connection (`Library/Subscriber.hs:1931-1938`) | `ConnectPlan.kt:809`, `FramedItemView.kt:406-417` | `planOwnerSignatureFailed` | Tapping the tampered card plans the link with its `ownerSig`; `verifyLinkOwner` returns `OVFailed "signature verification failed"` (`Library/Commands.hs:4751-4760`) and the alert shows "⚠️ Signature verification failed: signature verification failed." (`ConnectPlan.kt:809`, strings.xml:586, `Commands.hs:4760`) | P | The sender drops `ownerSig` only when forwarding (`Library/Commands.hs:1158-1164`); `/_send … json` passes it through (`Protocol.hs:882-886`) |
+| Names | Connect by name | "Connect to @bob.simplex" row, or paste a name | `ChatListView.kt:1248,1253`; `ConnectPlan.kt:81-89` | `planConnectByNameContact` | Profile alert with name caption. Haskell: `testConnectByName` | P, NAMES | – |
+| Names | Name not found | "Connect to @bob.simplex" row, or paste a name | `ChatListView.kt:1248,1253`; `C/model/SimpleXAPI.kt:1743-1746` | `planConnectByNameNotFound` | Alert "Name not found". Haskell: `testConnectByNameNotFound` | NAMES | – |
 | Names | Name of a contact and a channel | Type `bob.simplex` (no `@` or `#` prefix) → "Connect to bob.simplex" row | `ChatListView.kt:1207`; `ConnectPlan.kt:81-89` | `planConnectByNameOtherKindButton` | Second button "Join channel #bob" when the name also resolves to a channel that doesn't claim the domain (the argument is the other name's short form, not the typed text: `ConnectPlan.kt:84-88`, `ChatModel.kt:5224-5227`; when the channel claims it, the channel is primary and the button reads "Connect to @bob.simplex", Commands.hs:4451-4454, H/Names.hs:356-360). Haskell: `testConnectByNameContactAndChannel` (H/Names.hs:381, `/_connect plan 1 acme.simplex`) | P, NAMES, RELAY | The channel needs a chat relay. Only a bare domain gets the other kind (`src/Simplex/Chat/Library/Commands.hs:4446-4474`); an `@`-prefixed name parses as a short contact name with no other kind (`Commands.hs:4477-4478`) |
-| URI | SimpleX link in message text | Click a SimpleX link in a received message's text | `C/views/chat/item/TextItemView.kt:373`; `C/views/helpers/Utils.kt:599-600`; `ChatListView.kt:775-784` | `planOpenedViaSimplexUriHandler` | The plan alert appears (`openVerifiedSimplexUri` → `connectIfOpenedViaUri` → `planAndConnect`) | P | The CLI sends its 1-time link as message text. `chatModel.appOpenUrl` is set only when there is no current user (ChatListView.kt:777-778) and by Android (`MainActivity.kt:149`) |
-| Card | Link card in a message | bob runs `/ad` then `/share address @alice`; alice opens bob's chat and clicks the card | `C/views/chat/item/FramedItemView.kt:400-410`; `C/views/newchat/ConnectPlan.kt:155-168` | `planViaChatItemLinkCard` | The profile alert for bob with "Link signature verified." and "Open new chat" (the card plans as ok to connect with a verified owner signature, `H/Profiles.hs:3937-3955`) | P | Distinct from the chat-list card of `planSignedAddressCardVerified` |
-| Card | Link card contents | CLI `/ad`, then `/share address @alice`; open the chat with bob | `C/views/chat/item/CIChatLinkHeader.kt:18-78`; `C/views/chat/item/FramedItemView.kt:402-416`; `C/model/ChatModel.kt:5111-5121` | `linkCardInMessageShowsNameAndSignedInfoLine` | The received item shows the card: "bob", the info line "Contact address (from owner)" (`chat_link_contact_address` + `chat_link_from_owner`, strings.xml:580-582) and "Tap to open" (strings.xml:576); no text below the card (the message text equals the link, `APIShareMyAddress`, `Library/Commands.hs:1247-1259`). bob prints `bob <# "@alice contact address of @bob (signed):"` and the link (as in `testShareAddressViaChat`, tests/ChatTests/Profiles.hs:3944-3946) | P | Same setup as `planSignedAddressCardVerified`; could instead extend `planViaChatItemLinkCard`'s verification |
+| URI | SimpleX link in message text | Click a SimpleX link in a received message's text | `C/views/chat/item/TextItemView.kt:474`; `C/views/helpers/Utils.kt:607-609`; `ChatListView.kt:782-796` | `planOpenedViaSimplexUriHandler` | The plan alert appears (`openVerifiedSimplexUri` → `connectIfOpenedViaUri` → `planAndConnect`) | P | The CLI sends its 1-time link as message text. `chatModel.appOpenUrl` is set only when there is no current user (ChatListView.kt:777-778) and by Android (`MainActivity.kt:149`) |
+| Card | Link card in a message | cath (connected by 1-time link) and bob (connected through his address) run `/ad` and `/share address @alice`; alice pastes cath's address, taps cath's chat-list card, then the cards in bob's and cath's chats | `C/views/chat/item/FramedItemView.kt:406-417`; `ChatPreviewView.kt:355-367`; `C/views/newchat/ConnectPlan.kt:155-168,216-231,519-541,700-735` | `planViaChatItemLinkCard` | Pasted address (no signature): "Open new chat" without "Link signature verified."; cath's chat-list card and cath's card in her chat: "Link signature verified." and "Open new chat" (`ConnectPlan.kt:725`), which opens a second, prepared chat "cath" ("Tap Connect to send request"); each card shows the name, "Contact address (from owner)" and "Tap to open" and no link text; bob's card (Known contact): "Open chat" without the signature line, which keeps bob's chat open and creates no chat, and bob's next line is alice's next message. The CLIs print `@alice contact address of @<name> (signed):` and the link (`View.hs:2443-2459`). Haskell: `testShareAddressViaChat` (H/Profiles.hs:3912-3929) | P | Also covers "Signed address card", "Link card contents", "Address: Known" and "Invitation: Known" (same alert function) |
+| Card | Link card contents | CLI `/ad`, then `/share address @alice`; open the chat with bob | `C/views/chat/item/CIChatLinkHeader.kt:18-78`; `C/views/chat/item/FramedItemView.kt:406-417`; `C/model/ChatModel.kt:5144-5154` |  | The received item shows the card: "bob", the info line "Contact address (from owner)" (`chat_link_contact_address` + `chat_link_from_owner`, strings.xml:581,583) and "Tap to open" (strings.xml:577); no text below the card (the message text equals the link, `APIShareMyAddress`, `Library/Commands.hs:1257-1269`) | P | `linkCardInMessageShowsNameAndSignedInfoLine` merged into `planViaChatItemLinkCard` |
 
-### 9. Connecting a prepared chat (compose area) (11 tests)
+### 9. Connecting a prepared chat (compose area) (6 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Prepared | Invitation | Prepared chat: banner "Tap Connect to chat", button "Connect" | `ComposeView.kt:652,1799-1805`; `ChatView.kt:2251-2268` | `preparedContactInvitationConnectButton`, `preparedContactBannerTexts`, `preparedContactRowOpenToConnect` | `preparedContactInvitationConnectButton`: "Connect" connects; CLI "alice: contact is connected". Haskell: `testShortLinkInvitationPrepareContact` (`/_connect contact @2 text hello`); `preparedContactBannerTexts`: the banner reads "Tap Connect to chat" before connecting and "Your contact" once connected (`ChatView.kt:2257-2267`); `preparedContactRowOpenToConnect`: the prepared chat's row in the chat list reads "Open to connect" (`ChatPreviewView.kt:190-191`), and clicking it opens the chat with the "Connect" button | P | – |
-| Prepared | Address request | "Tap Connect to send request"; send button → "Send contact request?" with "Send request" / "Send request without message" / "Add message" | `ComposeView.kt:672-691,1806-1819` | `preparedContactAddressSendRequestWithMessage`, `preparedContactAddressSendRequestWithoutMessage`, `preparedContactSendRequestAlertAddMessage`, `preparedContactAfterConnectShowsContactShouldAccept` | With text: "Send request" / "Cancel"; empty: "Send request without message" / "Add message" ("Add message" closes the alert and sends nothing: the CLI prints no request, `ComposeView.kt:684-689`). CLI "alice wants to connect to you!" (plus "alice> hello" when sent with text); GUI shows "contact should accept…". Haskell: `testShortLinkAddressPrepareContact` | P | – |
-| Prepared | Bot | Bot profile → "Connect" | `ComposeView.kt:1807-1812` | `preparedBotConnect` | The compose area shows only "Connect" (bolt icon, no message field; a non-bot address gets the send-request field, `ComposeView.kt:1813-1818`); after "Connect" bob prints `alice: accepting contact request...`, `alice: you can send messages to contact`, `alice: contact is connected`, and alice's compose area shows the message field. Haskell: `testShortLinkAddressChangeAutoReply` (H/Profiles.hs:5219-5237) | P | CLI sets peerType bot through `/_profile` and turns on `/auto_accept on` for its address; the connection is accepted without approval because of `/auto_accept on`, not because bob is a bot |
-| Prepared | Profile and incognito before connecting | Compose profile picker ("Your profile", "Incognito") | `C/views/chat/ComposeContextProfilePickerView.kt:34`; `ComposeView.kt:1686` | `preparedContactChangeProfileBeforeConnect`, `preparedContactIncognitoBeforeConnect` | `preparedContactChangeProfileBeforeConnect`: with a second user alice2 (created in the test) picked, the CLI prints "alice2: contact is connected", not alice (`ComposeContextProfilePickerView.kt:80-94`; H/Profiles.hs:4780-4797); `preparedContactIncognitoBeforeConnect`: with "Incognito" picked the CLI prints "<rand>: contact is connected" with a random name, not alice (H/Profiles.hs:4716-4721); after connecting the picker is gone. Haskell: `testShortLinkChangePreparedContactUser` (4762), `testShortLinkInvitationConnectPreparedContactIncognito` (4705) | P | – |
-| Prepared | Retry | Stop SMP during connect | `ComposeView.kt:667-669`; `C/views/chat/ComposeContextProfilePickerView.kt:128-140` | `preparedContactConnectRetryAfterServerError` | Error, then a second attempt succeeds; after the failed attempt, choosing another profile shows "Can't change profile". Haskell: `testShortLinkAddressConnectRetry` | P, SRVCTL | The app's agent caches a failed server connection for 3 s (`persistErrorInterval`, 3 s in the app and in `testAgentCfg`; only some Haskell tests set it to 0, e.g. `H/Profiles.hs:253`), so the retry happens more than 3 s after the failure, after the server is started again |
+| Prepared | Invitation | Prepared chat: banner "Tap Connect to chat", button "Connect" | `sendConnectPreparedContact` `ComposeView.kt:654-672`, Inv branch `:1815-1820`; banner `ChatView.kt:2254-2271` | `preparedContactInvitationConnectButton` | Paste the CLI's short 1-time link → profile alert "bob" with "Open new chat" → bob's prepared chat: the banner "Tap Connect to chat", a single "Connect" button and no message field; the row reads "Open to connect" (`ChatPreviewView.kt:192-193`); "Connect" connects: the CLI's next line is "alice: contact is connected", the message field replaces "Connect", a message reaches bob, and the row no longer reads "Open to connect". Haskell: `testShortLinkInvitationPrepareContact` | P | `preparedContactBannerTexts` and `preparedContactRowOpenToConnect` merged here; also covers §8 "Invitation: Short link: OK". The "Your contact" banner after connecting is not asserted: on a small Android screen the feature and e2e items push it out of composition |
+| Prepared | Address request | "Tap Connect to send request"; send button → "Send contact request?" with "Send request" / "Send request without message" / "Add message" | alert `ComposeView.kt:674-693`; `SendContactRequestView` `:1538-1568`; branch `:1821-1834` | `preparedContactAddressSendRequestWithMessage` | "Connect" with an empty field: "Send request without message" / "Add message"; "Add message" closes the alert and sends nothing (the one request bob prints later carries the message); with "hello" typed "Connect" hides and the send button asks "Send request" / "Cancel"; "Send request" → the CLI prints "alice wants to connect to you!", the two hint lines and "alice> hello" (in either order); the field clears and the chat shows "contact should accept…" (`ChatView.kt:873-890`) until `/ac alice`, whose next line is the acceptance (one request only). Haskell: `testShortLinkAddressPrepareContact` | P | `preparedContactSendRequestAlertAddMessage` and `preparedContactAfterConnectShowsContactShouldAccept` merged here; also covers §8 "Address: Short link: OK". `preparedContactAddressSendRequestWithoutMessage` merged into `previewContactShouldAcceptForAddress` (§3 Rows), which already does Connect → "Send request without message" → "alice wants to connect to you!" |
+| Prepared | Bot | Bot profile → "Connect" | `ComposeView.kt:1822-1827` | `preparedBotConnect` | The banner "Tap Connect to use bot" and the row "Open to use bot" (not "Open to connect"); the compose area shows only "Connect" (bolt icon, no message field; a non-bot address gets the send-request field, `ComposeView.kt:1828-1833`); one tap connects with no request alert: bob prints `alice: contact is connected`, alice's compose area shows the message field and the "Bot" banner, and a message reaches bob | P | CLI sets peerType bot through `/_profile` and turns on `/auto_accept on` for its address; the connection is accepted without approval because of `/auto_accept on`, not because bob is a bot. Also covers §8 "Bot: Bot address" |
+| Prepared | Profile and incognito before connecting | Compose profile picker ("Your profile", "Incognito") | `changeProfile` `C/views/chat/ComposeContextProfilePickerView.kt:80-112`; picker shown at `ComposeView.kt:1701-1707` | `preparedContactChangeProfileBeforeConnect`, `preparedContactIncognitoBeforeConnect` | `preparedContactChangeProfileBeforeConnect`: with a second user alice2 (created in the test) picked, the CLI prints "alice2: contact is connected", not alice (`ComposeContextProfilePickerView.kt:80-112`; H/Profiles.hs:4780-4797); `preparedContactIncognitoBeforeConnect`: with "Incognito" picked the CLI prints "<rand>: contact is connected" with a random name, not alice (H/Profiles.hs:4716-4721); after connecting the picker is gone. Haskell: `testShortLinkChangePreparedContactUser` (4762), `testShortLinkInvitationConnectPreparedContactIncognito` (4705) | P | – |
+| Prepared | Retry | Stop SMP during connect | `ComposeView.kt:669-671`; `C/views/chat/ComposeContextProfilePickerView.kt:114-119,139-140,178-179` | `preparedContactConnectRetryAfterServerError` | Error, then a second attempt succeeds; after the failed attempt, choosing another profile shows "Can't change profile". Haskell: `testShortLinkAddressConnectRetry` | P, SRVCTL | The app's agent caches a failed server connection for 3 s (`persistErrorInterval`, 3 s in the app and in `testAgentCfg`; only some Haskell tests set it to 0, e.g. `H/Profiles.hs:253`), so the retry happens more than 3 s after the failure, after the server is started again |
 
-### 10. Pending connection info screen (7 tests)
+### 10. Pending connection info screen (5 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Pending | Info screen | Click a pending row / "Set contact name": "You invited a contact" or "You accepted connection"; "One-time invitation link", QR, "Share 1-time link", "Learn more", "Delete" | `C/views/newchat/ContactConnectionInfoView.kt:33,77,159`; `ChatView.kt:824-827` | `pendingInfoInvitedShowsLinkQrShare` | "You invited a contact", "One-time invitation link", QR, "Share 1-time link" (clipboard stub) | CB | – |
-| Pending | Info screen | Click a pending row / "Set contact name": "You invited a contact" or "You accepted connection"; "One-time invitation link", QR, "Share 1-time link", "Learn more", "Delete" | `C/views/newchat/ContactConnectionInfoView.kt:33,77,159`; `ChatView.kt:824-827` | `pendingInfoAcceptedShowsNoLink` | "You accepted connection", no link | P, PEERCTL | The CLI that created the link is stopped so the connection stays pending. The current-build peer is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full link, which the test types into search (that starts the plan, ChatListView.kt:833-845), taps "Use current profile" in "Connect via one-time link?", dismisses "Connection request sent!" (`ConnectPlan.kt:103-113,417-433`), then clicks the pending row; no `CB` is needed |
-| Pending | Info screen | Click a pending row / "Set contact name": "You invited a contact" or "You accepted connection"; "One-time invitation link", QR, "Share 1-time link", "Learn more", "Delete" | `C/views/newchat/ContactConnectionInfoView.kt:33,77,159`; `ChatView.kt:824-827` | `pendingInfoIncognitoShown`, `pendingInfoLearnMore`, `pendingInfoDelete` | Incognito row "Incognito"; "Learn more" opens a page titled "One-time invitation link" with "To connect, your contact can scan QR code or use the link in the app." (`ContactConnectionInfoView.kt:68-72,140,145`; `C/views/newchat/AddContactLearnMore.kt:19-20`), a text the info screen doesn't show; delete alert as in §3 | — | – |
-| Pending | Alias | Field "Set contact name…" | `ContactConnectionInfoView.kt:126-128,193` | `pendingInfoSetAliasPersistsToContact` | After "friend" is typed into "Set contact name…", the pending row reads "friend" (`ChatModel.kt:3243`); after the CLI connects (`bob <## "alice: contact is connected"`), the contact's row and chat title read "friend", not "bob" (`localAlias.ifEmpty`, `ChatModel.kt:1912`). Haskell: `testSetConnectionAlias` (3247; alias carried to the contact) | P | – |
-| Pending | Group-link pending | Join a group through a full link | `ContactConnectionInfoView.kt:127-128` | `pendingInfoGroupLinkHidesAlias` | No alias editor | P, PEERCTL | The host is stopped so the group-link join stays pending. The current-build peer is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full link, which the test types into search (that starts the plan, ChatListView.kt:833-845), taps "Use current profile" in "Join group?", dismisses "Connection request sent!" (`ConnectPlan.kt:264-275,417-433`), then clicks the pending row; no `CB` is needed |
+| Pending | Info screen | Click a pending row / "Set contact name": "You invited a contact" or "You accepted connection"; "One-time invitation link", QR, "Share 1-time link", "Learn more", "Delete" | `C/views/newchat/ContactConnectionInfoView.kt:108-150,159-171`; `ChatView.kt:826-830` | `pendingInfoInvitedSharesWorkingLink` | "You invited a contact", "One-time invitation link", "You will be connected when your contact's device is online, please wait or check later!" and "Share 1-time link" (no "You accepted connection"); "Share 1-time link" puts the link on the clipboard stub (empty before); the CLI connects with it (`confirmation sent!`, "alice: contact is connected") and bob replaces the pending connection. The QR code is not observable (renamed from `pendingInfoInvitedShowsLinkQrShare`) | CB | – |
+| Pending | Info screen | Click a pending row / "Set contact name": "You invited a contact" or "You accepted connection"; "One-time invitation link", QR, "Share 1-time link", "Learn more", "Delete" | `C/views/newchat/ContactConnectionInfoView.kt:33,77,159`; `ChatView.kt:824-827` | `pendingInfoAcceptedShowsNoLink` | "You accepted connection" with the contact-online text, "Set contact name…" and "Learn more", without "You invited a contact", "One-time invitation link" or "Share 1-time link"; the alias "dentist" typed there is kept on the pending connection and carried to bob's contact when the CLI comes online (`createDirectContact` copies the connection alias, `src/Simplex/Chat/Store/Direct.hs:454`) | P, PEERCTL | The CLI that created the link is stopped so the connection stays pending. The current-build peer is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full link, which the test types into search (that starts the plan, ChatListView.kt:833-845), taps "Use current profile" in "Connect via one-time link?", dismisses "Connection request sent!" (`ConnectPlan.kt:103-113,417-433`), then clicks the pending row "accepted invitation" (helper `joinOneTimeLinkInSearch`); no `CB` is needed |
+| Pending | Info screen | Click a pending row / "Set contact name": "You invited a contact" or "You accepted connection"; "One-time invitation link", QR, "Share 1-time link", "Learn more", "Delete" | `C/views/newchat/ContactConnectionInfoView.kt:33,77,159`; `ChatView.kt:824-827` | `pendingInfoIncognitoShown`, `pendingInfoDelete` | `pendingInfoIncognitoShown`: of two kept invitations, the plain one's info has no "Incognito" row and the footer "Your profile alice will be shared."; the one switched to incognito on the 1-time link screen has the "Incognito" row and the footer "A new random profile will be shared." (`ContactConnectionInfoView.kt:88-106,148`); its "Learn more" opens a page titled "One-time invitation link" with "To connect, your contact can scan QR code or use the link in the app." (`ContactConnectionInfoView.kt:68-72,140,145`; `C/views/newchat/AddContactLearnMore.kt:19-20`), a text the info screen doesn't show; `pendingInfoDelete`: "Delete" on the info screen → "Delete pending connection?" / "invited to connect\n\nThe contact you shared this link with will NOT be able to connect!" / "Delete" removes the row and closes the info (`chatId` null); the CLI's plan for the link then fails and `/c` fails with "error: connection authorization failed" | — | `pendingInfoLearnMore` merged into `pendingInfoIncognitoShown` |
+| Pending | Alias | Field "Set contact name…" | `ContactConnectionInfoView.kt:126-128,193` |  | After "friend" is typed into "Set contact name…", the pending row reads "friend" (`ChatModel.kt:3243`); after the CLI connects (`bob <## "alice: contact is connected"`), the contact's row and chat title read "friend", not "bob" (`localAlias.ifEmpty`, `ChatModel.kt:1912`). Haskell: `testSetConnectionAlias` (3247; alias carried to the contact) | P | `pendingInfoSetAliasPersistsToContact` merged into `searchFiltersByAlias` (§3): it types the alias into the same info screen's field (opened by the row's "Set contact name" menu, `namePendingConnection`), lets the CLI connect and checks the contact is listed as "friend" |
+| Pending | Group-link pending | Join a group through a full link | `ContactConnectionInfoView.kt:114-128` | `pendingInfoGroupLinkHidesAlias` | Next to a kept 1-time invitation, whose info has the alias field (`Ui.Info.Alias`), the group-link connection's info reads "You will be connected to group when the group host's device is online, please wait or check later!" and has no alias field | P, PEERCTL | The host is stopped so the group-link join stays pending. The current-build peer is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full link, which the test types into search (that starts the plan, ChatListView.kt:833-845), taps "Use current profile" in "Join group?", dismisses "Connection request sent!" (`ConnectPlan.kt:264-275,417-433`), then clicks the pending row; no `CB` is needed |
 
-### 11. Address screens (22 tests)
+### 11. Address screens (12 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Address | No address | Picker "Create SimpleX address" → "SimpleX address": "For social media" › "Create SimpleX address"; "Or to share privately" › "Create 1-time link"; "SimpleX address or 1-time link?" | `C/views/usersettings/UserAddressView.kt:41,272-322,462,478`; `UserAddressLearnMore.kt:27` | `addressScreenNoAddressShowsCreate`, `addressCreateOneTimeLinkButton`, `addressLearnMore` | `addressScreenNoAddressShowsCreate`: "For social media" › "Create SimpleX address", "Or to share privately" › "Create 1-time link", and "SimpleX address or 1-time link?" (`UserAddressView.kt:307-321`); `addressCreateOneTimeLinkButton`: "Create 1-time link" opens NewChatView on the 1-time link with "Share this 1-time invite link" (:462-474; `NewChatView.kt:500`); `addressLearnMore`: "SimpleX address or 1-time link?" opens "Address or 1-time link?" with "Share address publicly", "Share 1-time link with a friend" and "Connection security" (`UserAddressLearnMore.kt:27-50`) | — | – |
-| Address | Create | "Create SimpleX address" | `UserAddressView.kt:74-113` | `createAddressNoContactsSharesAutomatically` | No contacts: no alert; the address is created and shared at once ("Share with SimpleX contacts" is on in "Address settings") | — | – |
-| Address | Create | "Create SimpleX address" | `UserAddressView.kt:74-113` | `createAddressWithContactsAsksToShare`, `createAddressWithContactsAsksToShareCancel` | With contacts: "Share address with SimpleX contacts?" / "Share" (`createAddressWithContactsAsksToShare` taps "Share"); CLI "alice set new contact address, use /info alice to view". Cancel: the address is created but not shared, and the CLI prints nothing. Haskell: `testProfileLink` (1550) | P | – |
+| Address | No address | Picker "Create SimpleX address" → "SimpleX address": "For social media" › "Create SimpleX address"; "Or to share privately" › "Create 1-time link"; "SimpleX address or 1-time link?" | `C/views/usersettings/UserAddressView.kt:41,295-312,466-489`; `UserAddressLearnMore.kt:27-50` | `addressScreenNoAddressShowsCreate` | "For social media" › "Create SimpleX address", "Or to share privately" › "Create 1-time link", and "SimpleX address or 1-time link?", with no "Share address" or "Delete address" (`UserAddressView.kt:295-312`); "SimpleX address or 1-time link?" opens "Address or 1-time link?" with "Share address publicly", "Share 1-time link with a friend" and "Connection security" (`UserAddressLearnMore.kt:27-50`), and Back returns to the address screen; "Create 1-time link" opens NewChatView on the 1-time link with "Share this 1-time invite link" and a created link, and no address is created (:466-480; `NewChatView.kt:500`) | — | `addressCreateOneTimeLinkButton` and `addressLearnMore` merged into `addressScreenNoAddressShowsCreate` |
+| Address | Create | "Create SimpleX address" | `UserAddressView.kt:74-113`; `UserPicker.kt:224-238` | `createAddressNoContactsSharesAutomatically` | The user picker row reads "Create SimpleX address"; with no contacts "Create SimpleX address" shows no alert and creates the address shared at once (`setProfileAddress(true)`, `UserAddressView.kt:105-108`); the picker row then reads "Your SimpleX address" and opens the existing address (`UserPicker.kt:226`); a CLI that connects afterwards gets the address in alice's profile: its `/i @alice` prints "contact address: <link>" (`src/Simplex/Chat/View.hs:1901`) | P | `userPickerAddressRowLabelCreateVsYour` merged into `createAddressNoContactsSharesAutomatically` |
+| Address | Create | "Create SimpleX address" | `UserAddressView.kt:76-114` |  | With contacts: "Share address with SimpleX contacts?" / "Share"; CLI "alice set new contact address, use /info alice to view". Cancel: the address is created but not shared, and the CLI prints nothing. Haskell: `testProfileLink` (1550) | P | `createAddressWithContactsAsksToShare` merged into `addressDelete` (`AddressTest`), which taps "Share" in this alert and waits for the CLI line; `createAddressWithContactsAsksToShareCancel` merged into `addressSettingsShareWithContactsOnOff` |
 | Address | Show and share | QR, "Share address", "Share via chat" | `UserAddressView.kt:343-366` | `addressQrAndShareAddress` | QR and "Share address": the clipboard gets the short link | CB | – |
-| Address | Show and share | QR, "Share address", "Share via chat" | `UserAddressView.kt:343-366` | `addressShareViaChat` | Share via chat opens the share list; pick bob: bob's chat opens with the address card in the compose preview (`ComposeView.kt:1651-1665`); click send; CLI "alice> contact address of @alice (signed):" followed by the link line (no signature line: it is printed only in the test view, `src/Simplex/Chat/View.hs:1006-1007`). Haskell: `testShareAddressViaChat` | P | – |
+| Address | Show and share | QR, "Share address", "Share via chat" | `UserAddressView.kt:360-367,453-462`; `C/views/chatlist/ShareListView.kt:202`; `ComposeView.kt:1668-1680` | `addressShareViaChat` | "Share via chat" opens the share list with bob and without "Private notes" (local chats are excluded for an address, `ShareListView.kt:202`); picking bob opens his chat with the address card in the compose preview and Send enabled with no typed text (`ComposeView.kt:1668-1680`); Send gives the CLI "alice> contact address of @alice (signed):" followed by alice's address link (no signature line: it is printed only in the test view, `src/Simplex/Chat/View.hs:2443-2459`). Haskell: `testShareAddressViaChat` | P | – |
 | Address | Upgrade | "Upgrade address" → "Upgrade address?" → "Upgrade" (`UserAddressView.kt:225-240`) | `UserAddressView.kt:202-269,348-353` | `addressUpgradeShortLink` | "Upgrade address" disappears and the "Short link" / "Full link" toggle appears (`UserAddressView.kt:343-349`) | FIXTURE (address without short link) | `shouldBeUpgraded` only happens for old addresses |
-| Address | Business | Toggle "Business address" | `UserAddressView.kt:367-372,625` | `addressBusinessToggleAutoEnablesAutoAccept` | Footer "Add your team members to the conversations."; turning it on forces "Auto-accept" on | — | Customer connections and business chats are catalogue 03 §20 |
-| Address | Settings | "Address settings": "Share with SimpleX contacts", "Auto-accept", "Accept incognito", "Welcome message" ("Enter welcome message… (optional)"), "Save" | `UserAddressView.kt:498-582,585-622,650-673,739-775` | `addressSettingsShareWithContactsOn`, `addressSettingsShareWithContactsOff`, `addressSettingsShareCancelReverts`, `addressAutoAcceptOn`, `addressAutoAcceptOff`, `addressWelcomeMessage` | `addressSettingsShareWithContactsOn`: "Share address with SimpleX contacts?" / "Share", then CLI "alice set new contact address, use /info alice to view" (`src/Simplex/Chat/View.hs:2338`); `addressSettingsShareWithContactsOff`: "Stop sharing address?" / "Stop sharing", then CLI "alice removed contact address"; `addressSettingsShareCancelReverts`: "Cancel" in either alert puts the toggle back and the CLI prints nothing (`UserAddressView.kt:585-622`); `addressAutoAcceptOn`: CLI "connection request sent!" then connected without approval; `addressAutoAcceptOff`: a new address has Auto-accept off (`autoAccept = null`, `UserAddressView.kt:84`), so the test first turns it on; turning it off then saves at once, like turning it on (:650-673); a CLI connecting then prints "connection request sent!" and alice's list gets a contact row "Open to accept" (`ChatPreviewView.kt:192-193`; the core creates a contact for every request, Store/ContactRequest.hs:84-107), with no connection until alice accepts; `addressWelcomeMessage`: alice first turns Auto-accept on (turning it on clears the welcome text and saves at once, :650-662), then enters "hello!" and taps "Save"; a CLI connecting then gets "alice> hello!" (the welcome is sent when the request is accepted, `src/Simplex/Chat/Library/Commands.hs:1471-1479`). Haskell: `testProfileLink`, `testUserContactLinkAutoAccept` (1631), `testAutoReplyMessage` (1927), `testShortLinkAddressChangeAutoReply` | P | – |
-| Address | Settings save button | "Address settings" → "Welcome message", "Save" | `UserAddressView.kt:576,778-781` | `addressSettingsSaveDisabledWhenUnchanged` | "Save" is disabled until the welcome message changes, and disabled again after saving (:576, 778-781) | — | – |
+| Address | Business | Toggle "Business address" | `UserAddressView.kt:369-374,629-653,655-679` | `addressBusinessToggleAutoEnablesAutoAccept` | Turning "Business address" on shows the footer "Add your team members to the conversations." and saves a business address with auto-accept on; "Address settings" then shows "Auto-accept" disabled (`UserAddressView.kt:660`); a CLI `/c <address>` prints "connection request sent!" and "#alice: joining the group...", and alice gets a customer business chat named after the CLI. Turning it off hides the footer and keeps auto-accept on (:644-650): a second CLI is auto-accepted as a plain contact ("alice: contact is connected"). Haskell: `testBusinessAddress` (1952) | P | Customer connections and business chats are catalogue 03 §20 |
+| Address | Settings | "Address settings": "Share with SimpleX contacts", "Auto-accept", "Accept incognito", "Welcome message" ("Enter welcome message… (optional)"), "Save" | `UserAddressView.kt:89-108,524-590,591-631,655-679,763-781` | `addressSettingsShareWithContactsOnOff`, `addressAutoAcceptWelcomeMessage` | `addressSettingsShareWithContactsOnOff`: bob is alice's contact, so "Create SimpleX address" asks "Share address with SimpleX contacts?" / "Share" / "Cancel" (`UserAddressView.kt:89-104`); "Cancel" creates the address without sharing it; in "Address settings" the "Share with SimpleX contacts" toggle asks the same, "Cancel" keeps it off (tapping it again asks to share, not to stop), and "Share" gives the CLI "alice set new contact address, use /info alice to view" (`src/Simplex/Chat/View.hs:2350`); turning it off asks "Stop sharing address?" / "Stop sharing", "Cancel" keeps it on, and "Stop sharing" gives the CLI "alice removed contact address" (`UserAddressView.kt:591-631`); the shared state is checked in the user's profile after each answer; `addressAutoAcceptWelcomeMessage`: a new address has Auto-accept off (`autoAccept = null`, `UserAddressView.kt:86`), so a first CLI's `/c` prints "connection request sent!" and alice's list gets its "Open to accept" row (`ChatPreviewView.kt:192-193`; the core creates a contact for every request, Store/ContactRequest.hs:84-107); alice turns Auto-accept on (saved at once, with the welcome text cleared, :660-668), types "hello!" as the welcome message and taps "Save" (the welcome is sent when the request is accepted, `src/Simplex/Chat/Library/Commands.hs:1471-1479`); a second CLI then prints "connection request sent!", "alice: contact is connected" and "alice> hello!" with no approval; turning Auto-accept off saves at once with no welcome (:669-676), and a third CLI gets an "Open to accept" row again while the first CLI's request is still pending. Haskell: `testProfileLink`, `testUserContactLinkAutoAccept` (1631), `testAutoReplyMessage` (1929), `testShortLinkAddressChangeAutoReply` | P | `addressAutoAcceptOn`, `addressAutoAcceptOff` and `addressWelcomeMessage` merged into `addressAutoAcceptWelcomeMessage`; `addressSettingsShareWithContactsOn`, `addressSettingsShareWithContactsOff`, `addressSettingsShareCancelReverts` and `createAddressWithContactsAsksToShareCancel` merged into `addressSettingsShareWithContactsOnOff` |
+| Address | Settings save button | "Address settings" → "Welcome message", "Save" | `UserAddressView.kt:576,778-781` |  | "Save" is disabled until the welcome message changes, and disabled again after saving (:576, 778-781) | — | `addressSettingsSaveDisabledWhenUnchanged` merged into `addressSettingsUnsavedChangesAlertExitAndSave` |
 | Address | Settings | "Address settings": "Share with SimpleX contacts", "Auto-accept", "Accept incognito", "Welcome message" ("Enter welcome message… (optional)"), "Save" | `UserAddressView.kt:498-582,585-622,650-673,739-775` | `addressAutoAcceptIncognito` | alice turns "Auto-accept" on (a new address has it off, and turning it on saves at once with incognito off, `UserAddressView.kt:650-662`); "Accept incognito" is then drawn (only while Auto-accept is on, :564-567), and she turns it on and taps "Save" (the toggle alone only edits the settings, :739-753); then CLI `/c <address>`: the CLI is connected with a random profile of alice | P, FIXTURE (address without short-link data) | "Accept incognito" is hidden when short-link data is set |
-| Address | Unsaved settings | Close with changes | `UserAddressView.kt:528-545,808` | `addressSettingsUnsavedChangesAlertSave`, `addressSettingsUnsavedChangesAlertExit` | "Save settings?" / "Save SimpleX address settings" / "Exit without saving", after the welcome message is edited; `addressSettingsUnsavedChangesAlertSave`: the command log has `/_address_settings <uid> {…}` (`C/model/SimpleXAPI.kt:4289`), the screen closes, and reopening "Address settings" shows the new welcome message; `addressSettingsUnsavedChangesAlertExit`: the screen closes with no `/_address_settings` command, and reopening shows the old one | — | – |
-| Address | Delete | "Delete address" → "Delete address?" | `UserAddressView.kt:147-166,676` | `addressDelete`, `addressDeleteKeepsPendingRequests` | "Delete address?" with "All your contacts will remain connected. Profile update will be sent to your contacts." (address shared: bob is alice's contact before the address is created, so creating it asks "Share address with SimpleX contacts?" and the test taps "Share", `UserAddressView.kt:86-103`; "All your contacts will remain connected." when sharing is off) / "Delete"; each CLI contact gets "alice removed contact address". After a new CLI first repeats `/_connect plan 1 <link>` until it prints `error: connection authorization failed - …` (the GUI's deletion reaches the server later, in a background thread, simplexmq `Agent.hs:1013-1015`; the plan reads the link from the server, `Library/Commands.hs:4485`), then its `/c` fails with "error: connection authorization failed…"; `addressDeleteKeepsPendingRequests`: a request a CLI sent before the deletion keeps its "Open to accept" row, and its menu "Accept" gives that CLI's "alice: contact is connected" (H/Profiles.hs:1853-1862). Haskell: `testProfileLink`, `testRejectContactAndDeleteUserContact`, `testKeepConnectionRequests`, `testShortLinkDeletedAddress` (short link) | P | – |
+| Address | Unsaved settings | Close with changes | `UserAddressView.kt:524-560,789-793,808-816` | `addressSettingsUnsavedChangesAlertExitAndSave` | "Save" with nothing changed saves nothing (the address record is not replaced; `saveAddressSettingsButton` is disabled, :789-793); after the welcome message is edited, leaving shows "Save settings?" / "Save SimpleX address settings" / "Exit without saving" (`UserAddressView.kt:535-551,808-816`); "Exit without saving" closes the screen without saving, and reopening shows the old (empty) message; "Save SimpleX address settings" saves it and closes, and reopening shows it; editing again and tapping "Save" saves it, and leaving then shows no alert (the saved state follows the save) | — | `addressSettingsUnsavedChangesAlertSave` and `addressSettingsUnsavedChangesAlertExit` merged into `addressSettingsUnsavedChangesAlertExitAndSave`; `addressSettingsSaveDisabledWhenUnchanged` merged into it |
+| Address | Delete | "Delete address" → "Delete address?" | `UserAddressView.kt:149-168,682-691` | `addressDelete`, `addressDeleteKeepsPendingRequests` | `addressDelete`: bob is alice's contact before the address is created, so "Create SimpleX address" asks "Share address with SimpleX contacts?" (`UserAddressView.kt:89-104`); "Share" gives bob's CLI "alice set new contact address, use /info alice to view"; a second CLI's `/_connect plan 1 <link>` prints "contact address: ok to connect"; "Delete address" shows "Delete address?" with "All your contacts will remain connected. Profile update will be sent to your contacts." ("All your contacts will remain connected." when sharing is off) / "Delete"; the screen goes back to "Create SimpleX address" and bob's CLI gets "alice removed contact address". The second CLI then repeats `/_connect plan 1 <link>` until it prints `error: connection authorization failed - …` (the GUI's deletion reaches the server later, in a background thread, `Library/Commands.hs:2500`; the plan reads the link from the server), and its `/c` fails with "error: connection authorization failed…"; `addressDeleteKeepsPendingRequests`: a request a CLI sent before the deletion keeps its "Open to accept" row, and its menu "Accept" gives that CLI's "alice: contact is connected" (H/Profiles.hs:1853-1862). Haskell: `testProfileLink`, `testRejectContactAndDeleteUserContact`, `testKeepConnectionRequests`, `testShortLinkDeletedAddress` (4262) | P | – |
 
 ### 12. SimpleX name (8 tests)
 
@@ -239,44 +239,44 @@ Entry for every row: New chat › "Paste link" → "Paste the link you received"
 | Name | Set name | Address screen → "Get SimpleX name (BETA)", or with a name set the name row under the "Your SimpleX name" section → "Set SimpleX name", placeholder "@yourname.testing" (hard-coded literal, `UserAddressView.kt:385`), "Save", "How to register a test name", "Remove name" | `C/views/usersettings/SetSimplexNameView.kt:42`; `UserAddressView.kt:375-405` | `simplexNameSaveConfirmBroadcast`, `simplexNameSaveNotOwnAddressError`, `simplexNameRemove`, `simplexNameUnsavedChangesAlert`, `simplexNameRemovedWhenAddressDeleted` | "Save" shows "Profile update will be sent to your SimpleX contacts." / "Save" (name registered to alice's address with `register alice.simplex contact=<alice's address>`); confirming saves it, and the address screen shows the section "Your SimpleX name" with the row "alice.simplex" in place of "Get SimpleX name (BETA)" (`UserAddressView.kt:375-378`). A name registered without alice's address shows "Error saving name" / "The SimpleX name alice.simplex is registered without SimpleX address. Add your SimpleX address to the name via the registration page.". With a name set, "Remove name" clears the field and "Save" removes it: the row reads "Get SimpleX name (BETA)" again and the "Your SimpleX name" section title is gone. `simplexNameUnsavedChangesAlert`: leaving with a changed valid name shows "Save SimpleX name?" / "Save" / "Exit without saving", and "Exit without saving" returns to the address screen, which still reads "Get SimpleX name (BETA)" (`SetSimplexNameView.kt:102-121`). After "Delete address" and "Create SimpleX address", the entry reads "Get SimpleX name (BETA)" again. Haskell: `testSetNameNotOwnAddress` (core error NoValidLink), `testAddressDeleteRemovesName` | NAMES | The not-own name is registered with `register alice.simplex` and no `contact=` (using a CLI peer's address instead would need P). The sale countdown depends on the clock |
 | Name | Set name | Address screen → "Get SimpleX name (BETA)", or with a name set the name row under the "Your SimpleX name" section → "Set SimpleX name", placeholder "@yourname.testing" (hard-coded literal, `UserAddressView.kt:385`), "Save", "How to register a test name", "Remove name" | `C/views/usersettings/SetSimplexNameView.kt:42`; `UserAddressView.kt:375-405` | `simplexNameRegisterLinkOpensBrowser` | "How to register a test name" shows the "Open web link?" alert first (`SetSimplexNameView.kt:178`); opening it records `https://simplex.domains/#testing` in the URI stub | URI | The sale countdown depends on the clock |
 
-### 13. Contact info screen (28 tests)
+### 13. Contact info screen (24 tests)
 
 Entry for every row: open the chat → click the header → `ChatInfoView`.
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Info | Header and alias | Header, field "Set contact name…" | `C/views/chat/ChatInfoView.kt:56,711,822,1352` | `contactInfoOpensFromChatHeader`, `contactInfoSetLocalAlias`, `contactInfoClearLocalAlias` | `contactInfoOpensFromChatHeader`: clicking the chat title opens contact info with the contact's name in the header and the field "Set contact name…" (`ChatInfoView.kt:711-730`); `contactInfoSetLocalAlias`: after "friend" is typed (saved 500 ms after the last key, `ChatInfoView.kt:865-870`), the chat-list row reads "friend" instead of "bob" (`ChatModel.kt:1912`); `contactInfoClearLocalAlias`: after clearing the field the list shows the contact's display name again. Haskell: `testSetAlias` (3043) | P | – |
-| Info | Header and alias | Header, field "Set contact name…" | `C/views/chat/ChatInfoView.kt:56,711,822,1352` | `contactInfoHeaderShowsNameBioCopy` | Name and bio; copying shows "Copied to clipboard" | P, CB, TOAST | – |
-| Info | Action buttons | "search", "call", "video", "Mute"/"Unmute" | `ChatInfoView.kt:574-578,880-1059` | `contactInfoSearchButton`, `contactInfoMuteButtonToggles`, `contactInfoCallProhibitedAlert`, `contactInfoAllowCallsAlert` | `contactInfoSearchButton`: "search" (disabled while the chat has no items) opens the search field in the chat toolbar (`ChatInfoView.kt:880-901`; `ChatView.kt:435-437`); `contactInfoMuteButtonToggles`: "Mute" turns the contact's notifications off: the button then reads "Unmute" and the chat-list row shows the mute icon; "Unmute" turns them back on (:904-924); `contactInfoCallProhibitedAlert`: both sides allow calls by default (`src/Simplex/Chat/Types/Preferences.hs:561`), so the CLI first runs `/set calls @alice no`; once alice's "Contact preferences" show "Contact allows" "no" for "Audio/video calls", "call" shows "Calls prohibited!" / "Please ask your contact to enable calls." (`!allowedCallsByPrefs`, `ChatInfoView.kt:1009,1053-1058`); `contactInfoAllowCallsAlert`: alice sets "Audio/video calls" "You allow" to "no" in "Contact preferences" and taps "Save and notify contact", while the CLI keeps its default "yes" (the alert needs the contact's preference to be exactly yes, not always: `needToAllowCallsToContact`, `ChatInfoView.kt:972-977`); "call" then shows "Allow calls?" / "You need to allow your contact to call to be able to call them." / "Allow", and "Allow" makes the CLI print "alice updated preferences for you:" and an "Audio/video calls: enabled …" line (`allowFeatureToContact`, `SimpleXAPI.kt:2623-2631`) | P | – |
+| Info | Header and alias | Header, field "Set contact name…" | `C/views/chat/ChatInfoView.kt:56,711,822,1352` | `contactInfoSetLocalAlias`, `contactInfoClearLocalAlias` | `contactInfoOpensFromChatHeader`: clicking the chat title opens contact info with the contact's name in the header and the field "Set contact name…" (`ChatInfoView.kt:711-730`); `contactInfoSetLocalAlias`: after "friend" is typed (saved 500 ms after the last key, `ChatInfoView.kt:865-870`), the chat-list row reads "friend" instead of "bob" (`ChatModel.kt:1912`); `contactInfoClearLocalAlias`: with "friend" set through the API and the app restarted, the row reads "friend" and the field holds "friend"; after clearing the field the alias is empty in the model, the row reads "bob" again, and with bob not the open chat, search "fri" hides him while "bo" lists him. Haskell: `testSetAlias` (3043) | P | `contactInfoOpensFromChatHeader` merged into `contactInfoHeaderShowsNameBioCopy` |
+| Info | Header and alias | Header, field "Set contact name…" | `C/views/chat/ChatInfoView.kt:58-76,716-790` | `contactInfoHeaderShowsNameBioCopy`, `contactInfoHeaderFollowsProfileUpdate` | `contactInfoHeaderShowsNameBioCopy`: clicking the chat title opens contact info with "bob" (key `Ui.Info.Name`) and the name field, no full name or bio; after the CLI sets full name "Robert Brown" and bio "Plays the cello" (`/_profile 1 {...}`, "user full name changed to Robert Brown …"), reopened info shows both; clicking the name copies "bob" to the (emptied) clipboard; `contactInfoHeaderFollowsProfileUpdate`: with info open while the profile changes, the full name and bio should appear: `@KnownAppIssue`, `ChatInfoView` keeps `chat` in `remember(contact.id)` and `ChatInfoDescription` reads the stale `chat.chatInfo` | P, CB | – |
+| Info | Action buttons | "search", "call", "video", "Mute"/"Unmute" | `ChatInfoView.kt:577-582,886-1069` | `contactInfoSearchButton`, `contactInfoMuteButtonToggles`, `contactInfoAllowCallsAlert` | `contactInfoSearchButton`: "search" (disabled while the chat has no items) opens the search field in the chat toolbar (`ChatInfoView.kt:880-901`; `ChatView.kt:435-437`); `contactInfoMuteButtonToggles`: "Mute" (key `Ui.Info.Mute`) turns the contact's notifications off (`enableNtfs` None): the button then reads "Unmute" and the chat-list row shows the mute icon ("Notifications"); reopened info reads "Unmute", which turns them back on and removes the icon (:910-930); `contactInfoAllowCallsAlert`: alice sets "Audio/video calls" "You allow" to "no" in "Contact preferences" and taps "Save and notify contact" (the CLI prints "alice updated preferences for you:" / "Audio/video calls: off (you allow: default (yes), contact allows: no)"), while the CLI keeps its default "yes" (the alert needs the contact's preference to be exactly yes, not always: `needToAllowCallsToContact`, `ChatInfoView.kt:983-988`); in reopened contact info "call" (key `Ui.Info.Call`) then shows "Allow calls?" / "You need to allow your contact to call to be able to call them." / "Allow", and "Allow" makes the CLI print "alice updated preferences for you:" / "Audio/video calls: enabled (you allow: default (yes), contact allows: yes)" (`allowFeatureToContact`, `SimpleXAPI.kt:2658-2666`); then the CLI runs `/set calls @alice no` (both sides allow calls by default, `src/Simplex/Chat/Types/Preferences.hs:561`), and once alice's contact has the contact preference "no", "call" in reopened info shows "Calls prohibited!" / "Please ask your contact to enable calls." and not "Allow calls?" (`!allowedCallsByPrefs`, `ChatInfoView.kt:1020-1021,1065-1070`) | P | `contactInfoCallProhibitedAlert` merged into `contactInfoAllowCallsAlert`. Info is reopened after each preference change because `CallButton` reads the alerts' conditions from `chat`, which `ChatInfoView` keeps in `remember(contact.id)` (same cause as §15.5 item 16) |
 | Info | Action buttons | "search", "call", "video", "Mute"/"Unmute" | `ChatInfoView.kt:574-578,880-1059` | `contactInfoCallButtonsStubbed` | Clicking "call" makes the URI stub record `http://localhost:<port>/simplex/call/?token=<token>` (`D/views/call/CallView.desktop.kt:167`; nothing is recorded before), and the active-call area appears (icon "audio call", `D/views/chatlist/ChatListView.desktop.kt:85,144`), whose right-click menu has "Hang up" (:58, 63, 123-124, 91-99, 150-158) | P, URI | – |
-| Info | Incognito section | Contact connected incognito | `ChatInfoView.kt:583-591` | `contactInfoIncognitoSection` | "Your random profile" with a name equal to the CLI's contact name | P | – |
-| Info | Verification | "Verify security code"/"View security code" → "Security code", "Mark verified", "Clear verification" | `ChatInfoView.kt:158-185,1208`; `VerifyCodeView.kt:27,56` | `contactInfoVerifyCodeMatchesCli`, `contactInfoMarkVerified`, `contactInfoClearVerification` | The code on screen with whitespace and line breaks removed equals the code line of CLI `/code alice` with spaces removed (the screen splits the code into 24-character lines, `VerifyCodeView.kt:65,132-136`; the core compares codes without spaces, `src/Simplex/Chat/Types.hs:1997-2000`) (the real CLI prints "alice security code:", the code, then a "pass this code to your contact…" hint; only the test view prints the bare code, `src/Simplex/Chat/View.hs:2020-2023`); `contactInfoMarkVerified`: the info row reads "Verify security code"; "Mark verified" closes the "Security code" screen (`VerifyCodeView.kt:40-45`), the info row then reads "View security code" (`ChatInfoView.kt:1208-1215`) and reopens the screen showing "bob is verified", its status line `verified` (plan §4; `VerifyCodeView.kt:66-72`), and bob's contact is `verified` in the model; `contactInfoClearVerification`: on the verified contact "Clear verification" leaves the screen open, which turns to "bob is not verified" with "Mark verified" back (`VerifyCodeView.kt:66-72,105-108`), and the info row reads "Verify security code" again. Haskell: `testMarkContactVerified` (3116) | P | "Scan code" is mobile only |
-| Info | Send receipts | "Send receipts": yes / no / default (yes) | `ChatInfoView.kt:84-88,203-229,1228` | `contactInfoSendReceiptsNo`, `contactInfoSendReceiptsDefault` | The CLI sends a message, then reads its status with `/_get chat @<alice's contact id> count=1` (JSON, View.hs:129; id from `contactId`, plan §8.1): with "default (yes)", the command is repeated until `itemStatus` is `sndRcvd` (the receipt reaches the CLI some time after the sent echo, and the real CLI prints no event for it); with "no", a read after `wait(5 s)` still shows no `sndRcvd` (absence needs a bounded wait). The terminal never prints ⩗ (`showReceipts` is off in the real CLI, `src/Simplex/Chat.hs:119`). Haskell: `testConfigureDeliveryReceipts` (`/receipts @bob on`) | P | – |
-| Info | Message TTL | "Delete messages after": never / 1 day… | `ChatInfoView.kt:90-98,620-623,1405-1452` | `contactInfoChatTtlEnable`, `contactInfoChatTtlDisable` | `contactInfoChatTtlEnable`: picking "1 day" (from "default (never)") asks "Enable automatic message deletion?"; "Delete messages" leaves `/_ttl <uid> @<contactId> 86400` in the command log (`C/model/SimpleXAPI.kt:4231`) and the picker reads "1 day"; `contactInfoChatTtlDisable`: then picking "never" asks "Disable automatic message deletion?"; "Disable delete messages" leaves `/_ttl <uid> @<contactId> 0` and the picker reads "never" ("Cancel" reverts the picker, `ChatInfoView.kt:1427`). Haskell: `testSetDirectChatTTL` (2930) | P | – |
-| Info | Encryption, address, servers | Rows "E2E encryption" ("Quantum resistant"), "Address" with "Share address", "Servers" › "Network status", "Receiving via", "Sending via" | `ChatInfoView.kt:626-679` | `contactInfoE2eeQuantumResistant`, `contactInfoContactAddressSection`, `contactInfoServersSection`, `contactInfoNetworkStatusAlert` | `contactInfoE2eeQuantumResistant`: row "E2E encryption" reads "Quantum resistant"; `contactInfoContactAddressSection`: "Address" section with "Share address" shown when CLI shared its address (`/pa on`); `contactInfoServersSection`: "Receiving via" and "Sending via" show localhost; `contactInfoNetworkStatusAlert`: clicking "Network status" shows the alert "Network status" / "You are connected to the server used to receive messages from this connection." (`ChatInfoView.kt:645-653`; `SimpleXAPI.kt:7652-7654`) | P | "E2E encryption" / "Quantum resistant" are hard-coded literals (`ChatInfoView.kt:629`), not strings.xml labels |
-| Info | Change address | "Change receiving address" → "Change receiving address?" / "Change"; "Abort changing address" → "Abort" | `ChatInfoView.kt:117-143,1166-1184,1361-1378` | `contactInfoSwitchAddress` | CLI "alice started changing address for you" then "alice changed address for you". Haskell: `testSwitchContact` (3024) | P | – |
-| Info | Change address | "Change receiving address" → "Change receiving address?" / "Change"; "Abort changing address" → "Abort" | `ChatInfoView.kt:117-143,1166-1184,1361-1378` | `contactInfoAbortSwitchAddress` | Stop smp1; "Change receiving address" → "Change"; "Abort changing address" is enabled → "Abort"; start smp1; messages flow. Haskell: `testAbortSwitchContact` (3039) | P, SRVCTL | smp1 is stopped before "Change receiving address" → "Change", so the switch stays in `RSSwitchStarted` and "Abort changing address" is enabled (`canAbortSwitch`, `ChatInfoView.kt:662-665`); smp1 is started again after "Abort". With the server up the agent reaches `RSSendingQADD` at once (simplexmq Agent.hs:2879-2881), which is abortable only below agent version 8 (Store.hs:210-219); `testAbortSwitchContact` uses `testCfgVPrev` for that reason. Same approach as 03 `memberInfo_abortSwitchAddress` |
+| Info | Incognito section | Contact connected incognito | `ChatInfoView.kt:587-595` | `contactInfoIncognitoSection` | bob, connected through an incognito link, sees a random name for alice ("<rand>: contact is connected"); bob's contact info shows "Your random profile" with that name; cath's info (a plain connection) shows neither | P | – |
+| Info | Verification | "Verify security code"/"View security code" → "Security code", "Mark verified", "Clear verification" | `ChatInfoView.kt:158-185,1208`; `VerifyCodeView.kt:27,56` | `contactInfoVerifyCodeMatchesCli`, `contactInfoMarkVerified`, `contactInfoClearVerification` | The code on screen with whitespace and line breaks removed equals the code line of CLI `/code alice` with spaces removed (the screen splits the code into 24-character lines, `VerifyCodeView.kt:65,132-136`; the core compares codes without spaces, `src/Simplex/Chat/Types.hs:1997-2000`) (the real CLI prints "alice security code:", the code, then a "pass this code to your contact…" hint; only the test view prints the bare code, `src/Simplex/Chat/View.hs:2020-2023`); `contactInfoMarkVerified`: the info row reads "Verify security code"; "Mark verified" closes the "Security code" screen (`VerifyCodeView.kt:40-45`), the info row then reads "View security code" (`ChatInfoView.kt:1208-1215`) and reopens the screen showing "bob is verified", its status line `verified` (plan §4; `VerifyCodeView.kt:66-72`), and bob's contact is `verified` in the model; `contactInfoClearVerification`: with bob verified through the API and the app restarted, the info row reads "View security code" and the header name carries the shield (inline content placeholder U+FFFD before "bob"); "Clear verification" leaves the screen open, which turns to "bob is not verified" with "Mark verified" back (`VerifyCodeView.kt:66-72,105-108`), bob is not verified in the model, and after Back the info row reads "Verify security code" and the shield is gone. Haskell: `testMarkContactVerified` (3116) | P | "Scan code" is mobile only; the mismatch branch ("Incorrect code") needs "Scan code" (camera) |
+| Info | Send receipts | "Send receipts": yes / no / default (yes) | `ChatInfoView.kt:84-88,206-232,1244-1258` | `contactInfoSendReceiptsNo` | The CLI reads each message's status with `/_get chat @<alice's contact id>` (JSON, View.hs:129; id from `contactId`, plan §8.1), repeated until `itemStatus` is `sndRcvd` (the receipt reaches the CLI some time after the sent echo, and the real CLI prints no event for it): `r0`, sent while "Send receipts" (key `Ui.Info.SendReceipts`) reads "default (yes)", gets its receipt; after "no" (saved as `sendRcpts = false`) alice receives `r1`; after "default (yes)" again (`sendRcpts = null`) `r2` gets its receipt, and `r1` is still `sndSent` (a receipt for `r1` would have been sent before `r2`'s, so `r2` is the sentinel). The terminal never prints ⩗ (`showReceipts` is off in the real CLI, `src/Simplex/Chat.hs:119`). Haskell: `testConfigureDeliveryReceipts` (`/receipts @bob on`) | P | `contactInfoSendReceiptsDefault` merged into `contactInfoSendReceiptsNo` |
+| Info | Message TTL | "Delete messages after": never / 1 day… | `ChatInfoView.kt:90-98,624-626,1426-1500`; `C/views/chat/group/GroupChatInfoView.kt:953-967` | `contactInfoChatTtlEnable` | Picking "1 day" (from "default (never)", key `Ui.Info.Ttl`) asks "Enable automatic message deletion?" / "Delete messages"; "Cancel" reverts the picker to "default (never)" and sets no TTL (`ChatInfoView.kt:1448-1449`); picking "1 day" again and "Delete messages" sets the chat TTL, which the app reads back from the core (`afterSetChatTTL`, `apiGetChat`) as `chatItemTTL` 86400, and the picker reads "1 day", also in reopened info; then picking "never" asks "Disable automatic message deletion?" / "Disable delete messages", which reads back `chatItemTTL` 0 and the picker reads "never". Haskell: `testSetDirectChatTTL` (2930) | P | `contactInfoChatTtlDisable` merged into `contactInfoChatTtlEnable` |
+| Info | Encryption, address, servers | Rows "E2E encryption" ("Quantum resistant"), "Address" with "Share address", "Servers" › "Network status", "Receiving via", "Sending via" | `ChatInfoView.kt:626-679` | `contactInfoE2eeQuantumResistant`, `contactInfoContactAddressSection`, `contactInfoServersSection` | `contactInfoE2eeQuantumResistant`: row "E2E encryption" reads "Quantum resistant"; `contactInfoContactAddressSection`: no "Share address…" or footer while the CLI's address is not in its profile; after `/pa on` ("new contact address set") the open info shows "Share address…" and "You can share this address with your contacts to let them connect with bob."; the shared link makes the CLI's plan print "contact address: own address"; `contactInfoServersSection`: "Receiving via" and "Sending via" (keys `Ui.Info.ReceivingVia`/`SendingVia`) show the local host, and clicking each copies a server whose host, port and key hash equal the configured local SMP server; clicking "Network status" shows the alert "Network status" / "You are connected to the server used to receive messages from this connection." (`ChatInfoView.kt:645-653`; `SimpleXAPI.kt:7652-7654`) | P | "E2E encryption" / "Quantum resistant" are hard-coded literals (`ChatInfoView.kt:629`), not strings.xml labels; `contactInfoNetworkStatusAlert` merged into `contactInfoServersSection` |
+| Info | Change address | "Change receiving address" → "Change receiving address?" / "Change"; "Abort changing address" → "Abort" | `ChatInfoView.kt:117-143,1166-1184,1361-1378` | `contactInfoSwitchAddress` | "Change receiving address" (key `Ui.Info.SwitchAddress`) is shown without "Abort changing address"; with the CLI stopped, "Change receiving address?" / "Receiving address will be changed to a different server. Address change will complete after sender comes online." / "Change" closes the info and adds "changing address…"; reopened info shows "Abort changing address" (switch at `RSSendingQADD`); after the CLI starts it prints "alice started changing address for you" and "alice changed address for you", the chat gets "you changed address", reopened info shows no "Abort changing address", and the CLI's next message arrives. Haskell: `testSwitchContact` (3031) | P, PEERCTL | – |
+| Info | Change address | "Change receiving address" → "Change receiving address?" / "Change"; "Abort changing address" → "Abort" | `ChatInfoView.kt:117-143,1166-1184,1361-1378` | `contactInfoAbortSwitchAddress` | Stop smp1; "Change receiving address" → "Change"; "Abort changing address" is enabled → "Abort"; start smp1; messages flow. Haskell: `testAbortSwitchContact` (3039) | P, SRVCTL | smp1 is stopped before "Change receiving address" → "Change", so the switch stays in `RSSwitchStarted` and "Abort changing address" is enabled (`canAbortSwitch`, `ChatInfoView.kt:662-665`); smp1 is started again after "Abort". With the server up the agent reaches `RSSendingQADD` at once (simplexmq Agent.hs:2879-2881), which is abortable only below agent version 8 (Store.hs:210-219); `testAbortSwitchContact` uses `testCfgVPrev` for that reason. Same approach as 03 `memberInfo_abortSwitchAddress`. Shared `ContactInfoTest` ("Abort changing address" has the key `Ui.Info.AbortSwitchAddress`): after "Abort" the abort row is gone and "Change receiving address" is back; after `start("smp1")` alice's message reaches bob, bob's reply reaches alice, and alice's chat has no address-change item. Fails if the switch cannot be aborted while it waits for the server, or the abort breaks the connection |
 | Info | Fix connection | "Fix connection" (runs at once, no confirmation) | `ChatInfoView.kt:144-149,193,600-602` | `contactInfoFixConnection` | CLI "alice: connection synchronization agreed" then "alice: connection synchronized". Haskell: `testSyncRatchet` (3242), roles swapped | P, RESTART, FIXTURE (alice's own database copy restored) | alice must be the desynchronised side: copy her database, exchange messages, restore the copy between `restart()` steps, then receive a CLI message. Restoring the CLI's copy desynchronises the CLI instead |
-| Info | Clear, theme, developer | "Clear chat"; "Chat theme"; "For console" ("Local name", "Database ID", "Debug delivery") | `ChatInfoView.kt:608-616,681-705,1252` | `contactInfoClearChat`, `contactInfoWallpaperEntry` | "Clear chat?" (text "bob" and "All messages will be deleted - this cannot be undone! The messages will be deleted ONLY for you.") / "Clear" (`ChatInfoView.kt:497-503`); after "Clear" the messages exchanged before are gone from the chat while bob stays in the chat list; "Chat theme" opens the wallpaper editor, checked by its "Set default theme" (`ThemeModeEditor.kt:523`), since its title "Chat theme" (:250) equals the button label on the info screen | P | "Renegotiate encryption" is commented out (`ChatInfoView.kt:603-605`) |
+| Info | Clear, theme, developer | "Clear chat"; "Chat theme"; "For console" ("Local name", "Database ID", "Debug delivery") | `ChatInfoView.kt:608-616,681-705,1252` | `contactInfoClearChat`, `contactInfoWallpaperEntry` | "Clear chat?" (text "bob" and "All messages will be deleted - this cannot be undone! The messages will be deleted ONLY for you.") / "Clear" (`ChatInfoView.kt:497-503`); after "Clear" the info closes and the messages exchanged before are gone from the chat while bob stays active, ready and listed; the CLI's `/tail @alice 2` still shows "alice> hello" and "@alice hi there", and messages flow both ways afterwards; "Chat theme" opens the wallpaper editor, checked by its "Set default theme" (`ThemeModeEditor.kt:523`), since its title "Chat theme" (:250) equals the button label on the info screen | P | "Renegotiate encryption" is commented out (`ChatInfoView.kt:603-605`) |
 | Info | Clear, theme, developer | "Clear chat"; "Chat theme"; "For console" ("Local name", "Database ID", "Debug delivery") | `ChatInfoView.kt:608-616,681-705,1252` | `contactInfoDeveloperSection` | "For console" ("Local name", "Database ID", "Debug delivery"); "Message queue info" alert | P, DT | "Renegotiate encryption" is commented out (`ChatInfoView.kt:603-605`) |
-| Info | Contact not ready | Pending contact | `ChatInfoView.kt:593-606,644` | `contactInfoNotReadyContactHidesSections` | No verify/preferences/servers sections | P | alice connects through the CLI's address; the CLI never sends `/ac`, so the contact stays not ready |
+| Info | Contact not ready | Pending contact | `ChatInfoView.kt:597-611,649-684,911-930` | `contactInfoNotReadyContactHidesSections` | After "Connect" → "Send request without message" on the prepared contact from the CLI's address, the not-ready contact's info has "Delete contact" and a disabled "Mute" but no "Verify security code", "Contact preferences", "Receiving via" or "Change receiving address"; after the CLI's `/ac alice` and "alice: contact is connected", all of them are shown and "Mute" is enabled | P | alice opens the CLI's address as a prepared chat (search, "Open new chat") and sends the request; the CLI accepts only after the first check |
 
-### 14. Preferences (12 tests)
+### 14. Preferences (4 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Contact prefs | Per contact | Info → "Contact preferences": "Disappearing messages" ("You allow" toggle, "Delete after"), then "Delete for everyone", "Message reactions", "Voice messages", "Audio/video calls", each with a "You allow" dropdown (always/yes/no/default (…)); every section has "Contact allows"; "Reset", "Save and notify contact" | `C/views/chat/ContactPreferences.kt:28,77,126,161,209,220` | `contactPrefsDisappearingMessagesAllow`, `contactPrefsFullDeletion`, `contactPrefsReactions`, `contactPrefsVoice`, `contactPrefsCalls`, `contactPrefsResetRevertsChanges`, `contactPrefsUnsavedAlertSave`, `contactPrefsUnsavedAlertExit`, `contactPrefsContactAllowsReflectsPeer` | each change is saved with "Save and notify contact", after which the CLI prints "alice updated preferences for you:" and one line for the changed feature, named as in `chatFeatureNameText` (`src/Simplex/Chat/Types/Preferences.hs:68-76`; `src/Simplex/Chat/View.hs:2062-2076`): `contactPrefsDisappearingMessagesAllow`: on a new contact "You allow" is already on and "Delete after" is shown (the default user preference allows it, `src/Simplex/Chat/Types/Preferences.hs:556`; `contactUserPrefsToFeaturesAllowed`, `SimpleXAPI.kt:6301-6306`; `ContactPreferences.kt:190`); turning "You allow" off hides "Delete after", and saving prints a "Disappearing messages: off …" line; turning it on again shows "Delete after" set to 1 day (`?: 86400`, `ContactPreferences.kt:184`), and saving prints a "Disappearing messages: enabled …" line; `contactPrefsFullDeletion`: a "Full deletion: …" line; `contactPrefsReactions`: a "Message reactions: …" line; `contactPrefsVoice`: e.g. "Voice messages: enabled (you allow: default (yes), contact allows: always)"; once the CLI has set voice to no (as `testSetContactPrefs` does), "Voice messages: enabled for you (you allow: default (no), contact allows: always)" (`prefEnabled`, `Preferences.hs:1146-1153`); `contactPrefsCalls`: an "Audio/video calls: …" line; `contactPrefsResetRevertsChanges`: after a change, "Reset" restores the saved values and disables "Reset" and "Save and notify contact" again; the CLI prints nothing (`ContactPreferences.kt:67-69,120-124,210-219`); `contactPrefsUnsavedAlertSave`: leaving with changes shows "Save preferences?", and "Save and notify contact" saves (the CLI prints the update); `contactPrefsUnsavedAlertExit`: "Exit without saving" closes, and the CLI prints nothing; `contactPrefsContactAllowsReflectsPeer`: after the CLI runs `/set voice @alice no`, the "Voice messages" section's "Contact allows" row reads "no" (`ContactPreferences.kt:152-155`; `FeatureAllowed.text`, `SimpleXAPI.kt:6351-6356`). Haskell: `testSetContactPrefs` (3279), `testFeatureOffers`, `testAllowFullDeletionContact` | P | The Files preference is not shown for contacts (group only) |
-| User prefs | Global | Picker "Chat preferences" → "Your preferences" | `C/views/usersettings/Preferences.kt:25,65,168,179` | `userPrefsTimedMessagesAndTtl`, `userPrefsFullDeleteReactionsVoiceCalls`, `userPrefsResetAndUnsavedAlert` | "Save and notify contacts"; each CLI contact gets the preferences update. `userPrefsResetAndUnsavedAlert`: after a change, "Reset" restores the saved values and disables "Reset" and "Save and notify contacts" again, and the CLI prints nothing (`Preferences.kt:58,108-112,168-177`); leaving with a change shows "Save preferences?": "Exit without saving" closes and the CLI prints nothing (reopening shows the saved values), "Save and notify contacts" saves and the CLI prints the update (:47-50, 179-187). Haskell: `testUpdateMultipleUserPrefs` | P | – |
+| Contact prefs | Per contact | Info → "Contact preferences": "Disappearing messages" ("You allow" toggle, "Delete after"), then "Delete for everyone", "Message reactions", "Voice messages", "Audio/video calls", each with a "You allow" dropdown (always/yes/no/default (…)); every section has "Contact allows" and a footer saying who can use the feature; "Reset", "Save and notify contact" | `C/views/chat/ContactPreferences.kt:29,78,127,164,214,225` | `contactPrefsSaveNotifiesContactAndEnforces`, `contactPrefsResetAndUnsavedAlert` | Saving with "Save and notify contact" makes the CLI print "alice updated preferences for you:" and one line per changed feature, in the order and names of `allChatFeatures` / `chatFeatureNameText` (`src/Simplex/Chat/Types/Preferences.hs:69-91`; `src/Simplex/Chat/View.hs:2074-2093`). `contactPrefsSaveNotifiesContactAndEnforces`: first, with the defaults, a CLI deletion of its own message only marks it deleted in alice's chat and the CLI's `+1 @alice hi` reaction is added; on a new contact every footer says both can use the feature except "Irreversible message deletion is prohibited in this chat.", and "Delete after" is shown (the default user preference allows disappearing messages, `src/Simplex/Chat/Types/Preferences.hs:556`; `ContactPreferences.kt:194`); alice turns disappearing messages off ("Delete after" hidden), sets full deletion to "always" and reactions, voice and calls to "no" (each footer changes before saving), saves, and the CLI prints exactly "Disappearing messages: off (you allow: default (yes), contact allows: no)", "Full deletion: enabled for you (you allow: default (no), contact allows: always)", "Message reactions: off (you allow: default (yes), contact allows: no)", "Voice messages: off (you allow: default (yes), contact allows: no)", "Audio/video calls: off (you allow: default (yes), contact allows: no)"; then the features are enforced: the CLI's deletion of a new message prints "message deleted" and removes it from alice's chat, its reaction fails with "bad chat command: feature not allowed Message reactions", and alice's voice button shows "Allow voice messages?" (`SendMsgView.kt:580-588`, `ComposeView.kt:1374-1379`), whose "Allow" makes the CLI print "Voice messages: enabled (you allow: default (yes), contact allows: yes)"; finally turning disappearing messages on again shows "Delete after" set to "1 day" (`?: 86400`, `ContactPreferences.kt:188`) and the CLI prints "Disappearing messages: enabled (you allow: yes (1 day), contact allows: yes (1 day))" (the core copies the contact's TTL into the CLI's own preference, `Library/Subscriber.hs:2809-2817`); `contactPrefsResetAndUnsavedAlert`: after the CLI runs `/set voice @alice no` ("you updated preferences for alice:" / "Voice messages: off (you allow: no, contact allows: yes)"), the open screen's voice footer changes to "Voice messages are prohibited in this chat." (`ContactPreferences.kt:152-161`); a reactions change is undone by "Reset" (back to "default (yes)", `ContactPreferences.kt:69-71`) and leaving then shows no alert; leaving with a change shows "Save preferences?" with "Save and notify contact" / "Exit without saving" (:57, 225-232): "Exit without saving" keeps the saved value, "Save and notify contact" saves, and the CLI's next lines are the single update "Message reactions: off (you allow: default (yes), contact allows: no)" (nothing was sent by Reset or Exit). Haskell: `testSetContactPrefs` (3254), `testFeatureOffers`, `testAllowFullDeletionContact`, `testEnableTimedMessagesContact` | P | The Files preference is not shown for contacts (group only). `contactPrefsDisappearingMessagesAllow`, `contactPrefsFullDeletion`, `contactPrefsReactions`, `contactPrefsVoice` and `contactPrefsCalls` merged into `contactPrefsSaveNotifiesContactAndEnforces`; `contactPrefsResetRevertsChanges`, `contactPrefsUnsavedAlertSave`, `contactPrefsUnsavedAlertExit` and `contactPrefsContactAllowsReflectsPeer` merged into `contactPrefsResetAndUnsavedAlert` |
+| User prefs | Global | Picker "Chat preferences" → "Your preferences" | `C/views/usersettings/Preferences.kt:26,66,119-131,134-169,171-189` | `userPrefsFullDeleteReactionsVoiceCalls`, `userPrefsResetAndUnsavedAlert` | "Save and notify contacts"; each CLI contact gets the preferences update. `userPrefsFullDeleteReactionsVoiceCalls`: with bob and cath connected, the footers first read the defaults (disappearing messages, reactions, voice and calls "…only if your contact allows them.", full deletion "Contacts can mark messages for deletion; you will be able to view them."); alice turns disappearing messages off (key `Ui.UserPrefs.Timed`) and sets full deletion to "always" and reactions, voice and calls to "no" (keys `Ui.UserPrefs.Allow(feature)`); every footer changes before saving and nothing is saved yet; after "Save and notify contacts" each CLI prints exactly "alice updated preferences for you:", "Disappearing messages: off (you allow: default (yes), contact allows: no)", "Full deletion: enabled for you (you allow: default (no), contact allows: always)", "Message reactions: off (you allow: default (yes), contact allows: no)", "Voice messages: off (you allow: default (yes), contact allows: no)", "Audio/video calls: off (you allow: default (yes), contact allows: no)", and alice's profile holds the new preferences. `userPrefsResetAndUnsavedAlert`: after a change, "Reset" restores the saved values and disables "Reset" and "Save and notify contacts" again, and the CLI prints nothing (`Preferences.kt:58,108-112,168-177`); leaving with a change shows "Save preferences?": "Exit without saving" closes and the CLI prints nothing (reopening shows the saved values), "Save and notify contacts" saves and the CLI prints the update (:47-50, 179-187). Haskell: `testUpdateMultipleUserPrefs` | P | `userPrefsTimedMessagesAndTtl` merged into `userPrefsFullDeleteReactionsVoiceCalls` (the disappearing-messages toggle); the profile-level "Delete after" picker is not covered (its CLI output depends on the TTL the core copies into the contact's own preference, `Library/Subscriber.hs:2809-2817`) |
 
-### 15. Delete contact variants (10 tests)
+### 15. Delete contact variants (7 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Delete | Active contact | Row menu "Delete" or info "Delete contact" → "Delete contact?" with "Only delete conversation" / "Delete contact" / "Cancel" | `ChatInfoView.kt:231-281` | `deleteContactOnlyConversation`, `deleteConversationNoticeDontShowAgain`, `deleteContactCancel` | `deleteContactOnlyConversation`: bob's row leaves the chat list, and a later `bob #> "@alice hi"` still reaches alice (the contact stays): the row comes back with the preview "hi" and opening it shows "hi" without the earlier messages; `deleteConversationNoticeDontShowAgain`: "Conversation deleted!" / "You can send messages to bob from Archived contacts." / "Don't show again"; `deleteContactCancel`: "Cancel" closes the alert; the chat and its messages stay and the CLI prints nothing (`ChatInfoView.kt:271-276`). Haskell: `testDeleteConversationKeepContact` (609) | P | – |
-| Delete | Delete contact | "Delete contact" → second alert "Contact will be deleted - this cannot be undone!" with "Keep conversation" switch, "Delete without notification", "Delete and notify contact" | `ChatInfoView.kt:306-362,459,471` | `deleteContactAndNotify`, `deleteContactWithoutNotification`, `deleteContactKeepConversation`, `deleteContactFromInfoClosesChat` | `deleteContactAndNotify`: CLI "alice deleted contact with you"; `deleteContactWithoutNotification`: the row is removed and the CLI prints nothing (`notify = false`, `ChatInfoView.kt:334-342`); `deleteContactKeepConversation`: with the pre-set `showDeleteContactNotice` cleared (the test is about the notice, which is read when the action runs, `ChatInfoView.kt:337-339,346-348`), "Contact deleted!" notice and the row stays; `deleteContactFromInfoClosesChat`: deleting from contact info closes the info view and the chat (`ChatInfoView.kt:487-492`). Haskell: `testDeleteContactDeletesProfile` (571), `testDeleteContactKeepConversation` (591) | P | – |
-| Delete | Archived contact | Contact with `chatDeleted` → "Confirm contact deletion?" | `ChatInfoView.kt:364-419` | `deleteArchivedContactConfirm` | "Confirm contact deletion?" with "Delete and notify contact" / "Delete without notification" / "Cancel" (`ChatInfoView.kt:366-412`); each delete option removes the contact: "Delete and notify contact" leaves `/_delete @<id> full notify=on` in the Log and bob prints "alice deleted contact with you" (`C/model/SimpleXAPI.kt:4270,7334`; `src/Simplex/Chat/View.hs:461`); "Delete without notification" leaves `/_delete @<id> full notify=off` and bob prints nothing | P | The contact is archived with "Only delete conversation" (`ChatInfoView.kt:258`; the core sets `chatDeleted`, `Library/Commands.hs:1372`); for the second option alice and bob connect again after the first deletion and the new contact is archived the same way |
-| Delete | Not-ready contact | Pending contact → "Delete" → "Confirm contact deletion?" → "Confirm" | `ChatInfoView.kt:421-457` | `deleteNotReadyContactConfirm` | Removed | P | alice connects through the CLI's address; the CLI never sends `/ac` |
-| Delete | Deleted by peer | CLI `/d alice` (full deletion, notify on by default, `Library/Commands.hs:6281,6474-6482`; the real CLI's contact 2 is its "Ask SimpleX Team" card, plan §8.1) | – | `contactDeletedByPeerShowsDeleted` | CLI "alice: contact is deleted". The GUI row shows the item "deleted contact" with the inactive overlay icon. In the chat the compose field shows "contact deleted" (disabled); clicking it shows "You can't send messages!" (`C/views/chat/SendMsgView.kt:101-112`). Haskell: `testDeleteContactKeepConversation` (receiving side) | P | Owned here (legend); catalogue 02 has no duplicate |
+| Delete | Active contact | Row menu "Delete" or info "Delete contact" → "Delete contact?" with "Only delete conversation" / "Delete contact" / "Cancel" | `ChatInfoView.kt:251-296` | `deleteContactOnlyConversation` | "Cancel" closes the alert and keeps the chat and its messages (`ChatInfoView.kt:274-279`); "Only delete conversation" (with the pre-set `showDeleteConversationNotice` turned on, the notice is read when the action runs, `ChatInfoView.kt:262`) shows "Conversation deleted!" / "You can send messages to bob from Archived contacts." / "Don't show again", which turns the notice off on disk; bob's row leaves the chat list and the "Contacts" filter while cath stays (`ChatListView.kt:1597,1627`), and a later `bob sends "@alice hi"` reaches alice (the contact stays): the row comes back under "Contacts" with the preview "hi", opening it shows "hi" without the earlier messages, and alice's reply is bob's next CLI line. Haskell: `testDeleteConversationKeepContact` (609) | P | `deleteConversationNoticeDontShowAgain` and `deleteContactCancel` merged into `deleteContactOnlyConversation` |
+| Delete | Delete contact | "Delete contact" → second alert "Contact will be deleted - this cannot be undone!" with "Keep conversation" switch, "Delete without notification", "Delete and notify contact" | `ChatInfoView.kt:309-366,463-473,475-500` | `deleteContactAndNotify`, `deleteContactWithoutNotification`, `deleteContactKeepConversation` | `deleteContactAndNotify`: CLI "alice deleted contact with you"; `deleteContactWithoutNotification`: from contact info, the info view and the chat close (`ChatInfoView.kt:491-494`), bob's row is removed while cath's stays, and bob's CLI prints nothing: alice then deletes cath with "Delete and notify contact" from the row menu, cath prints "alice deleted contact with you", and bob's next CLI line is the answer to his `/u` (`notify = false`, `ChatInfoView.kt:340`); `deleteContactKeepConversation`: with the pre-set `showDeleteContactNotice` turned on (`ChatInfoView.kt:341,351`), "Keep conversation" on and "Delete and notify contact" show "Contact deleted!" / "You can still view conversation with bob in the list of chats." ("OK" keeps the notice on), the CLI prints "alice deleted contact with you", the row stays with its messages and the chat shows "contact deleted" in place of the message field (`ChatModel.kt:1711`). Haskell: `testDeleteContactDeletesProfile` (571), `testDeleteContactKeepConversation` (591) | P | `deleteContactFromInfoClosesChat` merged into `deleteContactWithoutNotification` |
+| Delete | Archived contact | Contact with `chatDeleted` → "Confirm contact deletion?" | `ChatInfoView.kt:242-243,368-423` | `deleteArchivedContactConfirm` | bob and cath are archived with "Only delete conversation"; cath's chat, opened from New chat › "Archived contacts", → contact info "Delete contact" shows "Confirm contact deletion?" / "cath\n\nContact will be deleted - this cannot be undone!" with "Delete and notify contact" / "Delete without notification" / "Cancel" (keys `Ui.Alert.Option(Shared, "deleteAndNotify" / "deleteWithoutNotification" / "cancel")`) and not "Delete contact?"; "Cancel" keeps cath archived; "Delete without notification" removes cath; bob's archived chat → "Delete and notify contact" removes bob and bob prints "alice deleted contact with you" (`src/Simplex/Chat/View.hs:461`); cath's next CLI line is the answer to her `/u` (no notification) | P | The contacts are archived with "Only delete conversation" (`ChatInfoView.kt:258`; the core sets `chatDeleted`, `Library/Commands.hs:1372`); cath is deleted first so that bob's notification is the sentinel for hers |
+| Delete | Not-ready contact | Pending contact → "Delete" → "Confirm contact deletion?" → "Confirm" | `ChatInfoView.kt:244-245,425-461` | `deleteNotReadyContactConfirm` | Contact info "Delete contact" on the not-ready contact shows "Confirm contact deletion?" / "bob\n\nContact will be deleted - this cannot be undone!" with only "Confirm" / "Cancel" (keys `Ui.Alert.Option(Shared, "confirm" / "cancel")`); "Cancel" keeps bob; "Confirm" removes bob's chat and closes contact info and the chat; the core forgot the contact: pasting bob's address into search plans it as new again ("Open new chat", not the Known contact) | P | alice connects through the CLI's address (prepared chat, "Connect" → "Send request without message"); the CLI never sends `/ac` |
+| Delete | Deleted by peer | CLI `/d alice` (full deletion, notify on by default, `Library/Commands.hs:6281,6474-6482`; the real CLI's contact 2 is its "Ask SimpleX Team" card, plan §8.1) | – | `contactDeletedByPeerShowsDeleted` | CLI "alice: contact is deleted". Alice's open chat gets the item "deleted contact" (`RcvDirectEvent.ContactDeleted`, `C/model/ChatModel.kt:5543`), the contact becomes inactive, and the compose field shows "contact deleted" instead of the message field (`ChatModel.kt:1711`; `SendMsgView.kt:85`). Haskell: `testDeleteContactKeepConversation` (receiving side) | P | Owned here (legend); catalogue 02 has no duplicate. Clicking the disabled field ("You can't send messages!", `SendMsgView.kt:104-114`) is not tested: the harness waits for a node to be enabled before clicking it |
 
 ---
 
@@ -294,17 +294,17 @@ Entry for every row: open the chat → click the header → `ChatInfoView`.
 |---|---|---|
 | 1 Onboarding | 18 | 0 |
 | 2 What's New | 5 | 0 |
-| 3 Chat list | 93 | 0 |
-| 4 Servers summary | 10 | 0 |
-| 5 User picker and profiles | 44 | 0 |
-| 6 New chat sheet and contacts | 17 | 0 |
-| 7 1-time link (create / share / QR / incognito / profile) | 17 | 0 |
-| 8 Paste link and connection plans (contact, invitation, address, bot, name, signature, URI and link-card links) | 29 | 0 |
-| 9 Connecting a prepared chat (compose area) | 11 | 0 |
-| 10 Pending connection info screen | 7 | 0 |
-| 11 Address screens | 22 | 0 |
+| 3 Chat list | 92 | 0 |
+| 4 Servers summary | 7 | 0 |
+| 5 User picker and profiles | 26 | 0 |
+| 6 New chat sheet and contacts | 10 | 0 |
+| 7 1-time link (create / share / QR / incognito / profile) | 14 | 0 |
+| 8 Paste link and connection plans (contact, invitation, address, bot, name, signature, URI and link-card links) | 15 | 0 |
+| 9 Connecting a prepared chat (compose area) | 6 | 0 |
+| 10 Pending connection info screen | 5 | 0 |
+| 11 Address screens | 12 | 0 |
 | 12 SimpleX name | 8 | 0 |
-| 13 Contact info screen | 28 | 0 |
-| 14 Preferences | 12 | 0 |
-| 15 Delete contact variants | 10 | 0 |
-| **Total** | **331** | **0** |
+| 13 Contact info screen | 24 | 0 |
+| 14 Preferences | 4 | 0 |
+| 15 Delete contact variants | 7 | 0 |
+| **Total** | **253** | **0** |
diff --git a/plans/ui-tests/catalogue/02-chat-view-messages.md b/plans/ui-tests/catalogue/02-chat-view-messages.md
index 590bcac78e..a5195b5904 100644
--- a/plans/ui-tests/catalogue/02-chat-view-messages.md
+++ b/plans/ui-tests/catalogue/02-chat-view-messages.md
@@ -18,56 +18,56 @@ Controls without a label today (selection-toolbar delete/forward, status ticks,
 
 ---
 
-### A. Chat view shell, toolbar, banner (11 tests)
+### A. Chat view shell, toolbar, banner (8 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Shell | Open direct / group chat | Click the chat in the list | CV:98, CV:918, CV:1194 | `directChat_opens_showsToolbarAndBanner`, `groupChat_opens_showsBannerGroup` | Title = display name ("bob" / "team"); the banner at the top of the message list shows a second node with that name and the avatar above it (CV:2318-2325), so the name is found both in the toolbar and in the list. The context line is not asserted by these tests | P | |
+| Shell | Open direct / group chat | Click the chat in the list | CV:98, CV:918, CV:1194, CV:1450, CV:1583-1617, CIV:691-697 | `directChat_opens_showsToolbarAndBanner` | No chat toolbar before the chat opens; then the toolbar title (`Ui.Chat.Bar` title) holds "bob", the banner shows "Your contact" (CV:2275) and bob's encryption info item reads "…protected by **quantum resistant e2e encryption**…" (`e2ee_info_pq`, CIV:691-697) and not "end-to-end encryption"; bob sets his full name with `/_profile 1 {"displayName":"bob","fullName":"Robert Brown"}` (`user full name changed to Robert Brown (your 1 contacts are notified)`), and the toolbar title adds "Robert Brown" under "bob" (CV:1606), absent before; clicking the title opens bob's contact info (`Ui.Info.Alias` and `Ui.Info.Name` "bob", absent before the click) | P | `groupChat_opens_showsBannerGroup` merged into `chatBanner_contextText_perChatType`; `toolbarTitle_click_opensChatInfo` and `e2eeInfo_direct_pq` merged into `directChat_opens_showsToolbarAndBanner` |
 | Shell | Open notes chat | Click the chat in the list | CV:98, CV:1240-1254, CV:1339 | `notes_opens_showsSearchAndContentFilterIcons` | Notes show the search icon ("Search") and the content-filter icon (always added on desktop, CV:1339; `ContentFilter.alwaysShow` includes Images and Links, CV:3987) | — | Notes title is not clickable (CV:1446) |
-| Banner | Chat banner context line | Scroll to the top of the chat | CV:2251-2380 | `chatBanner_contextText_perChatType` | "Your contact", "Group", "Your group", "Bot" shown under the name | P | bob is alice's contact ("Your contact"); alice creates #team ("Your group", `MemCreator`, CV:2279-2282); bob creates #club and adds alice, who accepts ("Group"); then bob sets `peerType: bot` through `/_profile` (as in 02:48; a profile update rewrites the contact's peer type, `Store/Direct.hs:741`) and his banner reads "Bot" (`contact.isBot`, CV:2264-2265). Direct: `testContactClear`, where the Haskell test client's `/_get chat` shows `(1,"chat banner")` (test-view output, not a peer assertion) |
-| Toolbar | Title opens chat info | Click the title | CV:400 | `toolbarTitle_click_opensChatInfo` | Contact info opens with the field "Set contact name…" (`C/views/chat/ChatInfoView.kt:845`), absent before the click | P | |
-| Toolbar | ⋮ menu items, notification toggle | "More" → menu | CV:1296, 1305-1331, 1356-1374 | `toolbarMenu_direct_items`, `toolbarMenu_group_items`, `toolbarMenu_muteUnmute_togglesNtfMode` | Direct: "Search" plus the notification toggle. Group: "Invite members" (`icon_descr_add_members`) or "Group link", "Search", plus the notification toggle. The toggle switches the chat's notification mode (`testMuteContact`) | P | This section owns the toolbar menu, including mute (`00-legend.md`) |
+| Banner | Chat banner context line | Open each chat | CV:2251-2380, CIV:700-702 | `chatBanner_contextText_perChatType` | bob's banner reads "Your contact"; alice's own #team (`emptyGroup`) has "team" in the toolbar, "Your group" (`MemCreator`, CV:2289) in the banner and its `SndGroupE2EEInfo` item reads "…protected by end-to-end encryption with perfect forward secrecy…" (`e2ee_info_no_pq`, CIV:700-702) without "quantum resistant"; bob hosts #club and alice joins (`hostGroup`, `joinGroupFromList`): "club" in the toolbar and "Group" (CV:2290) in the banner; then bob becomes a bot (`becomeBot`: `/_profile` with `peerType: bot`, `/u` prints `user profile: bob (bot)`) and bob's banner reads "Bot" (CV:2273) instead of "Your contact" | P | The banner item is created on connection, on group creation and on the group invitation (`Library/Subscriber.hs:677, 3900`, `Library/Commands.hs:4353`). The "Tap Join group" (invited) and business contexts are not asserted |
+| Toolbar | Title opens chat info | Click the title | CV:1450 | | Contact info opens (`Ui.Info.Alias`, `Ui.Info.Name` "bob"), absent before the click | P | `toolbarTitle_click_opensChatInfo` merged into `directChat_opens_showsToolbarAndBanner` |
+| Toolbar | ⋮ menu items, notification toggle | "More" (`Ui.Chat.BarMenu`) → menu | CV:1296-1302, 1305-1331, 1359-1378 | `toolbarMenu_direct_items`, `toolbarMenu_group_items` | `toolbarMenu_direct_items`: once bob's contact is ready, "Search" (`Ui.Chat.BarMenuItem("search")`) and the notification item (`BarMenuItem("ntf")`) labelled "Mute", no "Invite members"; "Mute" sets bob's `enableNtfs` to none and the item then reads "Unmute"; "Unmute" sets it back to all and the item reads "Mute"; "Search" opens the search field. `toolbarMenu_group_items`: in alice's own #team the menu has "Invite members" (`BarMenuItem("addMembers")`), "Search" and "Mute"; "Invite members" opens the invite sheet listing bob; the notification item cycles "Mute" (→ mentions) → "Mute all" (→ none) → "Unmute" (→ all) (`MsgFilter.nextMode`/`text`, `C/model/SimpleXAPI.kt:5509-5523`); in bob's #club, where alice is a member (`canAddMembers` false, CV:1307), the menu has "Search" and "Mute" but neither "Invite members" nor "Group link" | P | This section owns the toolbar menu, including mute (`00-legend.md`). `toolbarMenu_muteUnmute_togglesNtfMode` merged into `toolbarMenu_direct_items` (the group cycle is in `toolbarMenu_group_items`). The "Group link" branch (incognito membership) is not covered |
 | Toolbar | ⋮ menu items in a channel | "More" → menu in a channel alice owns | CV:1305-1331, 1356-1374 | `toolbarMenu_channel_items` | "Channel link", "Search", plus the notification toggle (CV:1356-1374) | P, RELAY | |
 | Toolbar | Start call | Call icon → "Audio call" / "Video call" (`icon_descr_audio_call` / `icon_descr_video_call`, lower-case in strings.xml and capitalised at runtime, CV:1545/1551; the driver looks them up capitalised) | CV:1289, 1542-1556, 906 | `toolbarCall_audio_opensCallLink` | The `LocalUriHandler` stub records `http://localhost:<port>/simplex/call/?token=<token>` (`D/views/call/CallView.desktop.kt:167`) and the GUI shows the active-call area (icon "audio call", `D/views/chatlist/ChatListView.desktop.kt:85,144`), whose right-click menu has "Hang up" (:58, 63, 123-124, 91-99, 150-158; the call state text "starting…" goes only to the browser page, :140-152). bob prints nothing: the invitation is sent only after the browser page reports its capabilities (`D/views/call/CallView.desktop.kt:41-43`), and the stub doesn't run the page (plan §7.6) | P, URI | The call icon gets a key in K2 |
 | Toolbar | Call when no browser can be opened | The `LocalUriHandler` stub is set to throw; call icon → "Audio call" | `D/views/call/CallView.desktop.kt:157-174`, `C/views/call/CallManager.kt:75-97`, `C/App.kt:226-238` | `callStart_browserUnavailable_showsAlertAndEnds` | Alert "Error opening browser" / "The default web browser is required for calls. Please configure the default browser in the system, and share more information with the developers." (`unable_to_open_browser_title`/`_desc`, strings.xml:1291-1292); the call ends at once (`endCall` sets `showCallView` false and `activeCall` null, CallManager.kt:81-86), so no outgoing-call waiting state remains under the alert. bob prints nothing: the invitation is sent only from the `Capabilities` response (CallView.desktop.kt:40-46), and `apiEndCall` fails silently with no current call (`APIEndCall` → `withCurrentCall` throws `CENoCurrentCall`, `Library/Commands.hs:1579-1583, 4232-4240`; `apiEndCall` returns false, `C/model/SimpleXAPI.kt:2160-2163`) | P, URI | The throwing mode is a harness option of the recording `LocalUriHandler` (plan §7.6), not a new Needs code. `endCall` also calls `AppLock.appWasHidden()` (CallManager.kt:82); irrelevant with the lock off |
 
-### B. Composing and sending text, links, mentions, commands (28 tests)
+### B. Composing and sending text, links, mentions, commands (21 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Send | Send button | Click "Send Message" | SMV:452 | `sendText_sendButton_peerReceives` | `bob <# "alice> hello there 🙂"` (`testAddContact`) | P | |
-| Send | No send button for empty text; disabled for whitespace | Empty compose; then type spaces | SMV:71-72, 138-167 | `sendButton_hiddenWhenEmpty_disabledForWhitespace` | With empty text the microphone and the live-message bolt are shown instead of the send button; with whitespace-only text the send button is shown disabled | P | |
-| Multiline | Shift+Enter inserts a newline | Shift+Enter, then Enter | PTF:125-133 | `multiline_shiftEnter_peerReceivesTwoLines`, `multiline_received_rendersBothLines` | `multiline_shiftEnter_peerReceivesTwoLines`: `bob <# "alice> hello"`, `bob <## "there"` (`testMultilineMessage`); `multiline_received_rendersBothLines`: after bob `types` `@alice "hello\nthere"` (plan §8.1: the sent item prints as `@alice hello` / `there`, which `sends` would not match, H/Direct.hs:999-1001), alice's received item shows "hello" and "there" on two lines | P | |
+| Send | Send button | Type text, click "Send Message" | SMV:457-490, CMP:181 | `sendText_sendButton_peerReceives` | Empty field: the voice button ("Record voice message") and the live bolt (`Ui.Chat.Live`) are shown and there is no send button (SMV:74-75, 158-172); "   " shows the send button disabled and no bolt (CMP:181); then "hello there 🙂" and a click on the send button: `bob <# "alice> hello there 🙂"` (`testAddContact`) and the field clears | P | `sendButton_hiddenWhenEmpty_disabledForWhitespace` merged in. Enter on desktop is exercised by every `chat.send`; its blank-text branch is in `multiline_shiftEnter_peerReceivesTwoLines` |
+| Send | No send button for empty text; disabled for whitespace | Empty compose; then type spaces | SMV:74-77, 158-172 | | With empty text the microphone and the live-message bolt are shown instead of the send button; with whitespace-only text the send button is shown disabled | P | `sendButton_hiddenWhenEmpty_disabledForWhitespace` merged into `sendText_sendButton_peerReceives` |
+| Multiline | Shift+Enter inserts a newline | Enter on "   ", then "hello", Shift+Enter, "there", Enter | PTF:128-140 | `multiline_shiftEnter_peerReceivesTwoLines`, `multiline_received_rendersBothLines` | `multiline_shiftEnter_peerReceivesTwoLines` (desktop, `ComposeDesktopTest`): Enter on "   " leaves the field unchanged (PTF:138); Shift+Enter turns "hello" into "hello\n" without sending (PTF:129-137); then `bob <# "alice> hello"`, `bob <## "there"` as bob's first lines (`testMultilineMessage`); `multiline_received_rendersBothLines`: after bob `types` `@alice "hello\nthere"` (plan §8.1: the sent item prints as `@alice hello` / `there`, which `sends` would not match, H/Direct.hs:999-1001), alice's received item shows "hello" and "there" on two lines | P | Shift+Enter is desktop-only |
 | Group | Group send | Enter in a group | CMP:720 | `groupSend_allMembersReceive` | `bob <# "#team alice> hello"`, `cath <# "#team alice> hello"` (`testGroupCheckMessages`) | P ×2 | Send only after cath prints `#team: member alice is connected`; before that the host forwards the message and cath's line ends with ` [>>]` (measured) |
-| Markdown | Rendering, secret reveal, text on CLI | bob `types` ``@alice *bold* _it_ ~st~ !1 red! `code` #sec#`` (plan §8.1: the CLI prints markdown with the markers of bold, italic, strike and colour removed, so `sends` can't match) / click #secret# / alice sends the same text | `C/views/chat/item/TextItemView.kt` | `markdown_received_rendersBoldItalicCodeStrikeSecretColor`, `markdown_secret_clickReveals`, `markdown_sent_peerSeesTextWithoutMarkers` | The item's semantics `Text` is an `AnnotatedString` whose span styles mark bold, italic, code, strike, secret and colour; the secret span changes on click; bob's own sent line is ``@alice bold it st red `code` #sec#`` (read with `expectsMessage`), and for alice's message the CLI shows ``alice> bold it st red `code` #sec#`` (bold, italic, strike and colour markers removed, code and secret kept: `src/Simplex/Chat/View.hs:2362, 2461-2462`, `Styled.hs:38-47`) | P | Styles are asserted on the annotated string, not on pixels |
+| Markdown | Rendering, secret reveal, text on CLI | bob `types` ``@alice *bold* _it_ ~st~ !1 red! `code` #sec#`` (plan §8.1: the CLI prints markdown with the markers of bold, italic, strike and colour removed, so `sends` can't match) / click #secret# / alice sends ``*bold* _italic_ ~strike~ `code` `` | `C/views/chat/item/TextItemView.kt:272, 313-320` | `markdown_received_rendersBoldItalicCodeStrikeSecretColor`, `markdown_secret_clickReveals`, `markdown_sent_rendersFormatted_peerGetsMarkers` | The item's semantics `Text` is an `AnnotatedString` whose span styles mark bold, italic, code, strike, secret and colour; the secret span changes on click. `markdown_sent_rendersFormatted_peerGetsMarkers`: alice's own bubble reads "bold italic strike code" with no `*bold*`, `_italic_`, `~strike~` or `` `code` `` left; bob gets ``alice> bold italic strike `code` `` (bold, italic and strike markers removed, code kept: `src/Simplex/Chat/View.hs:2474`, `Styled.hs:43-47`), and bob's `/? @alice *bold*` (search over the stored text) finds it, so the markers reached bob verbatim | P | Styles are asserted on the annotated string, not on pixels. `markdown_sent_peerSeesTextWithoutMarkers` renamed to `markdown_sent_rendersFormatted_peerGetsMarkers` |
 | Emoji | Large emoji for short emoji-only text | Receive "👍" | CIV:575 | `emojiOnly_rendersLargeEmoji` | Rendered without a bubble | P | |
 | Links | Open-link alert | Click a URL | `C/views/chat/item/TextItemView.kt:371, 533-574` | `link_click_showsOpenWebLinkAlert`, `link_openClean_opensSanitizedUri` | "Open web link?". For a plain URL (`http://127.0.0.1/page`) the alert has "Open"; for a URL with a tracking parameter (`http://127.0.0.1/page?utm_source=test`) it has "Open full link" / "Open clean link" / "Cancel", and "Open clean link" makes the `LocalUriHandler` stub record the URL without `utm_source` | P, URI | The link span is clicked at its bounds, computed from the text node's `GetTextLayoutResult` semantics action (no app change) |
-| Previews | First-time alert with "Enable", fetch, cancel | Type `http://127.0.0.1:<port>/page` | CMP:459-524, 1854 | `linkPreview_firstTimeAlert_enable_fetchesPreview`, `linkPreview_sent_peerReceivesLinkContent`, `linkPreview_cancel_sendsPlainText` | `linkPreview_firstTimeAlert_enable_fetchesPreview`: "Enable link previews?" with "Disable" / "Enable"; "Enable" fetches the page and the compose area shows the preview with the page's `og:title` and the URL (CMP:479-483, `C/views/helpers/LinkPreviews.kt:168-180`). `bob <# "alice> http://127.0.0.1:<port>/page"`; bob's `/_get content types @<alice's contact id>` (plan §8.1 `contactId`; only the API form exists, `Library/Commands.hs:6108`) prints `Chat content types: link` in `linkPreview_sent_peerReceivesLinkContent` (format from `testLinkContentFilter`); in `linkPreview_cancel_sendsPlainText` the cancelled preview sends plain text, so it prints `Chat content types: text` | P, HTTP | The local HTTP server serves Open Graph tags. `localhost` URLs don't parse as links, so the address is `127.0.0.1`. `privacyLinkPreviewsShowAlert` is pre-set except in `linkPreview_firstTimeAlert_enable_fetchesPreview`. Turning the "Send link previews" setting off is owned by catalogue 04 (`00-legend.md`) |
-| Previews | First-time alert with "Disable"; received card | Type `http://127.0.0.1/page` → "Disable"; bob sends a link message that carries its preview | CMP:478-487, `C/views/chat/item/FramedItemView.kt:396`, `C/views/helpers/LinkPreviews.kt:196` | `linkPreview_firstTimeAlert_disable_noPreview`, `linkPreview_received_rendersCard` | Disable: no preview card is fetched or shown (CMP:483-485). Received: bob sends an `MCLink` with a `preview` via `/_send @<alice's contact id> json [{"msgContent": {"type": "link", "text": "http://127.0.0.1/page", "preview": {…}}}]` (as in `testLinkContentFilter`); the GUI renders the card: the "link preview image" image, the preview's title and description, and the URL (`LinkPreviews.kt:194-218`) | P | The CLI doesn't fetch previews, so no HTTP server is needed. `privacyLinkPreviewsShowAlert` is pre-set except in `linkPreview_firstTimeAlert_disable_noPreview` |
+| Previews | First-time alert with "Enable", fetch, cancel | Type `http://127.0.0.1:<port>/cat.png` → "Enable" → send; type `see http://127.0.0.1:<port>/dog.png` → "cancel link preview" → send | CMP:459-524, 615-631, 1871-1893 | `linkPreview_enable_peerReceivesLink_cancelSendsText` | Desktop (`ComposeDesktopTest`). "Enable link previews?" with `Ui.Alert.Option(Shared, "enable")`, and no request reaches the server before the choice; "Enable" fetches `/cat.png` once and the compose area shows the preview (title "cat.png", "link preview image", "cancel link preview"; image URLs get the file name as title, `C/views/helpers/LinkPreviews.kt:91-94`); after Send `bob <# "alice> http://127.0.0.1:<port>/cat.png"`, alice's bubble shows the card, and bob's `/_get content types @<alice's contact id>` prints `Chat content types: link` (format from `testLinkContentFilter`); the second link is fetched without the alert; after "cancel link preview" the message goes as text: `bob <# "alice> see …/dog.png"` and `Chat content types: link, text` | P, HTTP | `linkPreview_firstTimeAlert_enable_fetchesPreview`, `linkPreview_sent_peerReceivesLinkContent` and `linkPreview_cancel_sendsPlainText` merged into `linkPreview_enable_peerReceivesLink_cancelSendsText`. The test's JDK HTTP server serves a PNG for any path; an `.png` path skips the HTML fetch (LinkPreviews.kt:91-94). `localhost` URLs don't parse as links, so the address is `127.0.0.1`. Desktop-only: Android blocks cleartext HTTP (no network security config). The test turns `privacyLinkPreviewsShowAlert` back on through the API. Turning the "Send link previews" setting off is owned by catalogue 04 (`00-legend.md`) |
+| Previews | First-time alert with "Disable"; received card | Type `http://127.0.0.1/page` → "Disable"; bob sends a link message that carries its preview | CMP:478-487, `C/views/chat/item/FramedItemView.kt:396`, `C/views/helpers/LinkPreviews.kt:196` | `linkPreview_firstTimeAlert_disable_noPreview`, `linkPreview_received_rendersCard` | Disable: no preview card is fetched or shown (CMP:483-485). Received: bob sends an `MCLink` with a `preview` via `/_send @<alice's contact id> json [{"msgContent": {"type": "link", "text": "http://127.0.0.1/page", "preview": {…}}}]` (as in `testLinkContentFilter`); the GUI renders the card: the "link preview image" image, the preview's title and description, and the URL (`LinkPreviews.kt:196-221`, FramedItemView.kt:400-401); bob's earlier plain text with a link has no card | P | The CLI doesn't fetch previews, so no HTTP server is needed. `privacyLinkPreviewsShowAlert` is pre-set except in `linkPreview_firstTimeAlert_disable_noPreview` |
 | Previews | SimpleX links get no preview | Type a SimpleX link | CMP:435-445 | `linkPreview_simplexLink_noPreview` | No preview card is fetched or shown, checked after `wait(2 s)` (a web link starts its preview only after a 1500 ms debounce, CMP:471-474, 503-513) | P | |
-| Mentions | "@" picker, filter, received mention, edit adds a mention | Type "@b" in a group, pick a member | CV:1043, MEN:37-160 | `mention_picker_select_insertsAndSends`, `mention_picker_filtersByName`, `mention_received_ofMe_highlighted`, `mention_editAddsMention` | `mention_picker_select_insertsAndSends`: picking bob puts "@bob " in the compose field; after sending, `bob <# "#team alice!> hello @bob"`, `cath <# "#team alice> hello @bob"` (`testMemberMention`); `mention_picker_filtersByName`: "@b" lists bob but not cath (members whose name contains the typed text, MEN:83); `mention_received_ofMe_highlighted`: after bob sends `#team hello @alice`, alice's item shows "@alice" in the primary colour, while a mention of another member keeps the text colour (`C/views/chat/item/TextItemView.kt:259-260`); `mention_editAddsMention`: alice edits her "hello" into "hello @bob" with the picker; edited lines never carry the `!` marker (`ttyFromGroupEdited`, `src/Simplex/Chat/View.hs:3103-3104`): `bob <# "#team alice> [edited] hello @bob"`, `cath <# "#team alice> [edited] hello @bob"` (as cath's edit in `testMemberMention`, H/Groups.hs:7990-8000) | P ×2 | This catalogue owns composing mentions (`00-legend.md`) |
-| Mentions | Mention limit | Mention bob, cath and dan, then type "@" | MEN:213, 231, 265-280 | `mention_maxReached_showsLimit` | Limit message (GUI only) "You can mention up to 3 members per message!" (`max_group_mentions_per_message_reached` formatted with 3, MEN:274); every picker row except the mention under the cursor is disabled (MEN:230-231) | P ×3 | Limit is 3 (CMP:58); the box appears only once three distinct members are mentioned (MEN:213), so the group needs three peers |
-| Commands | Bot command menu | Click the "//" button or type "/" | CMP:1283-1296 ("//" at CMP:1293), CMD:36-244, CV:1051 | `commandsMenu_slash_showsBotCommands`, `commandsMenu_selectCommand_sendsToBot`, `commandsMenu_commandWithParams_insertsKeyword`, `commandsMenu_submenu_navigateBack`, `commandsMenu_filterByPrefix` | `commandsMenu_slash_showsBotCommands`: "//" or "/" opens the menu with "Help" `/help`, "Order" `/order` and the submenu row "More" (CMD:80-81,146-160); `commandsMenu_selectCommand_sendsToBot`: clicking "Help" sends at once and clears the compose field: `bob <# "alice> /help"` (CMD:157-160); `commandsMenu_commandWithParams_insertsKeyword`: clicking "Order" puts "/order <number>" in the compose field without sending; bob prints nothing (CMD:154-156); `commandsMenu_submenu_navigateBack`: "More" shows "Status" `/status` under a back row labelled "More"; clicking the back row shows the top list again (CMD:112-122,188-191); `commandsMenu_filterByPrefix`: typing "/or" lists only "Order", and "/st" lists "Status" from the submenu (keyword starts with the typed text, submenus included, CMD:48-61,82-83) | P | Here the peer bob acts as a bot: before alice connects it sets `peerType: bot` and `preferences.commands` through `/_profile`. No Haskell test covers this; command JSON is in `src/Simplex/Chat/Types/Preferences.hs:420`. Its commands: `help` ("Help"), `order` ("Order", params `<number>`) and the menu "More" with `status` ("Status") |
-| Compose | Clear-text (x) button | Type four or more lines, click (x) | SMV:315, PTF:204 | `compose_clearTextButton_clears` | The (x) appears only for text of four or more lines; after the click the field is empty | P | The icon gets a key in K2 |
+| Mentions | "@" picker, filter, received mention, edit adds a mention | Type "@b" in a group, pick a member | CV:1043, MEN:37-160 | `mention_picker_select_insertsAndSends`, `mention_received_ofMe_highlighted`, `mention_editAddsMention` | `mention_picker_select_insertsAndSends`: picking bob puts "@bob " in the compose field; after sending, `bob <# "#team alice!> hello @bob"`, `cath <# "#team alice> hello @bob"` (`testMemberMention`); `mention_received_ofMe_highlighted`: after bob sends `#team hello @alice`, alice's item shows "@alice" in the primary colour, while a mention of another member keeps the text colour (`C/views/chat/item/TextItemView.kt:259-260`); `mention_editAddsMention`: alice edits her "hello": the field is replaced with "hello @b", the picker lists bob and not cath (MEN:85), picking bob gives "hello @bob " and she types "there"; edited lines never carry the `!` marker (`ttyFromGroupEdited`, `src/Simplex/Chat/View.hs:3103-3104`): `bob <# "#team alice> [edited] hello @bob there"`, `cath <# "#team alice> [edited] hello @bob there"` (as cath's edit in `testMemberMention`, H/Groups.hs:7990-8000); the edited item mentions bob (item `mentions["bob"]`, sent as `cs.memberMentions`, CMP:819) | P ×2 | This catalogue owns composing mentions (`00-legend.md`). `mention_picker_filtersByName` merged into `mention_maxReached_showsLimit` ("@b" lists bob but neither cath nor dan, members whose name contains the typed text, MEN:85). The mention colour is not in the semantics text, so `mention_received_ofMe_highlighted` needs the annotated string (desktop only) |
+| Mentions | Mention limit; picker filter | Type "@b", pick bob; type "@", pick cath; type "@", pick dan; type "@" | MEN:85, 215, 233, 269-283 | `mention_maxReached_showsLimit` | "@b" lists bob but neither cath nor dan (MEN:85); with one and with two mentions "@" lists all three members enabled and no limit message; after the third mention "@" shows the limit message (GUI only) "You can mention up to 3 members per message!" (`max_group_mentions_per_message_reached` formatted with 3, MEN:277) and every picker row is disabled (MEN:233) | P ×3 | Limit is 3 (CMP:60); the box appears only once three distinct members are mentioned (MEN:215), so the group needs three peers (`ownGroupOfThree`). `mention_picker_filtersByName` merged in. Nothing is sent: the limit is GUI-only |
+| Commands | Bot command menu | Click the "//" button (`Ui.Chat.CommandsButton`) or type "/" | CMP:1297-1312 ("//" at CMP:1309), CMD:36-250, CV:1051 | `commandsMenu_slash_showsBotCommands`, `commandsMenu_selectCommand_sendsToBot` | `commandsMenu_slash_showsBotCommands`: no menu before; "//" opens the menu with "Help" `/help`, "Order" `/order` and the submenu row "More" (`Ui.Chat.Command(keyword)`, `Ui.Chat.CommandMenu(label)`, CMD:149-213), without the submenu's commands; "More" shows "Status" `/status` and "Cost" `/cost` under a back row labelled "More" (`Ui.Chat.CommandsBack`, CMD:114-147, 195); the back row shows the top list again (CMD:122); "//" again closes the menu; typing "/or" lists only "Order"; "/st" lists "Status" from the submenu and not "Cost" (keyword starts with the typed text, submenus included, CMD:51-63, 79-87); "/" lists the top commands (CMD:82); `commandsMenu_selectCommand_sendsToBot`: clicking "Order" puts "/order <number>" in the compose field without sending and closes the menu (CMD:158-161); alice completes it to "/order 7" and sends it, and it is bob's next line `bob <# "alice> /order 7"`; clicking "Help" sends at once and clears the compose field: `bob <# "alice> /help"` (CMD:162-164) | P | Here the peer bob acts as a bot: before alice connects it sets `peerType: bot` and `preferences.commands` through `/_profile` (`becomeBotWithCommands`; `/u` prints `Bot commands:`). No Haskell test covers this; command JSON is in `src/Simplex/Chat/Types/Preferences.hs:420`. Its commands: `help` ("Help"), `order` ("Order", params `<number>`) and the menu "More" with `status` ("Status") and `cost` ("Cost", the negative control for "/st"). `commandsMenu_submenu_navigateBack` and `commandsMenu_filterByPrefix` merged into `commandsMenu_slash_showsBotCommands`; `commandsMenu_commandWithParams_insertsKeyword` merged into `commandsMenu_selectCommand_sendsToBot` |
+| Compose | Clear-text (x) button | Type three lines, then a fourth, click (x), then send "hello\nthere" | SMV:125, 320-327, PTF:208 (desktop), `A/platform/PlatformTextField.android.kt:201` | `compose_clearTextButton_clears` | No (x) (`Ui.Chat.ClearText`) for three lines; it appears for four; after the click the field is empty and the (x) gone; the next message is bob's first: `bob <# "alice> hello"`, `bob <## "there"`, so the cleared text was never sent | P | |
 
-### C. Live messages (10 tests)
+### C. Live messages (5 tests)
 While a live message is open, `SendMsgView.kt:534-544` runs a loop of finite animations, and the 3 s update loop (SMV:545-550, `delay(3000)` on a composition scope) sends the updates. The harness runs every test with a manual clock that its poll loop keeps in step with real time (plan §6), so the animation loop can't block a lookup and the update loop runs at its real pace.
 
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Live | Start from the send-button menu | Right-click send → "Send live message" → alert "Live message!" → "Send" | SMV:180-200, 523-572 | `liveMessage_menuStart_alertConfirm_peerSeesStarted`, `liveMessage_typingUpdates_peerSeesUpdates`, `liveMessage_finish_peerSeesEnded` | `bob <# "alice> [LIVE started] use /show [on/off/<bob's item id>] hello"`, then `bob <# "alice> [LIVE ended] hello there"` (`testDirectLiveMessage`). For the typing-updates test bob first runs `/show on` (prints `ok`) and then prints `alice> [LIVE] hello …` for each 3-s update; without `/show on` the CLI prints nothing between started and ended (View.hs:869) | P | Updates go out every 3 s |
-| Live | Bolt button with empty text | Click the bolt, confirm "Live message!" with "Send", then type "hi" | SMV:156-166, CMP:1153-1160 | `liveMessage_boltButton_emptyStart` | Nothing is sent until text is typed; then `bob <# "alice> [LIVE started] use /show [on/off/<bob's item id>] hi"` (the real line has the item id, View.hs:2378) | P | The bolt gets its own key in K2; `liveMessageAlertShown` is not pre-set, so the first click shows the "Live message!" alert (SMV:560-571) |
-| Live | Cancel an empty live message | Click "Cancel live message" | SMV:170-174 | `liveMessage_cancelEmpty_nothingSent` | Nothing reaches the CLI | P | |
-| Live | Alert shown once only | Start twice with the bolt (empty field, SMV:162) | SMV:561-571 | `liveMessage_alertShownOnce` | First start shows "Live message!"; its "Send" starts the live message (and sets `liveMessageAlertShown`); after it ends, the second start shows no alert | P | |
+| Live | Start from the send-button menu, updates, finish | Type "hello", right-click send → "Send live message" (`Ui.Chat.SendLive`) → alert "Live message!" → "Send"; type " there,"; type " bob", click send | SMV:194-205, 529-582, CMP:863, 1153-1186 | `liveMessage_menuStart_alertConfirm_peerSeesStarted` | bob runs `/show on` (prints `ok`) first. `bob <# "alice> [LIVE started] use /show [on/off/<bob's item id>] hello"` as the next line; alice's bubble has the "LIVE" header; after " there," the 3-s update gives `bob <# "alice> [LIVE] hello there,"` as the next line and the same bubble reads "hello there,"; after the click, `bob <# "alice> [LIVE ended] hello there, bob"` (`testDirectLiveMessage`), the field clears and the bubble loses "LIVE"; a later "bye" is bob's next message | P | `liveMessage_typingUpdates_peerSeesUpdates` and `liveMessage_finish_peerSeesEnded` merged in. An update sends text up to the last word end (`truncateToWords`, CMP:1139-1150), so the typed suffix ends with "," to send it whole; the ended line is read with `eventuallyMessage` because a 3-s update ("hello there, ") may go out before the click. Without `/show on` the CLI prints nothing between started and ended (View.hs:869-873) |
+| Live | Bolt button with empty text, cancel, alert once | Click the bolt (`Ui.Chat.Live`), confirm "Live message!" with "Send", click "Cancel live message"; click the bolt again, type "hi!", click send | SMV:158-178, 529-582, CMP:1153-1164, 1526-1529 | `liveMessage_boltButton_emptyStart` | The empty start shows "Cancel live message" in place of the bolt and a placeholder item (`isLiveDummy`); cancel brings the bolt back and removes the placeholder; the second start shows no alert; bob's first line is `alice> [LIVE started] use /show [on/off/<bob's item id>] hi!` (nothing was sent before), then `bob <# "alice> [LIVE ended] hi!"` | P | `liveMessageAlertShown` is not pre-set, so the first click shows the "Live message!" alert (SMV:567-580). `liveMessage_cancelEmpty_nothingSent` and `liveMessage_alertShownOnce` merged in |
+| Live | Cancel an empty live message | Click "Cancel live message" | SMV:175-178, CMP:1526-1529 | | Nothing reaches the CLI | P | `liveMessage_cancelEmpty_nothingSent` merged into `liveMessage_boltButton_emptyStart` |
+| Live | Alert shown once only | Start twice with the bolt (empty field, SMV:166-170) | SMV:567-580 | | First start shows "Live message!"; its "Send" starts the live message (and sets `liveMessageAlertShown`); the second start shows no alert | P | `liveMessage_alertShownOnce` merged into `liveMessage_boltButton_emptyStart` |
 | Live | Group live message | Same, in a group | CMP:1150 | `liveMessage_group_membersSeeLive` | `bob <# "#team alice> [LIVE started] use /show [on/off/<bob's item id>] hello"`, `cath <# "#team alice> [LIVE started] use /show [on/off/<cath's item id>] hello"` (View.hs:2378) … `bob <# "#team alice> [LIVE ended] hello there"`, `cath <# "#team alice> [LIVE ended] hello there"` (`testGroupLiveMessage`) | P ×2 | |
-| Live | Chat switch commits the message to the original chat | Switch chat mid-message | CMP:1381-1395 | `liveMessage_chatSwitch_sendsToOriginalChat` | The original CLI peer gets `[LIVE ended]` | P | |
-| Live | History in Info, received badge | bob `types` `/live @alice hello` (plan §8.1; no echo); alice sees the received message with the "LIVE" label; then bob `types` ` there`, whose Enter ends the live message as "hello there" (Terminal/Input.hs:101-110,186-196); alice opens its Info | `C/views/chat/item/FramedItemView.kt:287-288` | `liveMessage_info_historyHasVersions`, `liveMessage_received_showsLiveBadge` | History has at least 2 versions: the oldest "hello", the newest "hello there"; "LIVE" label on the received message | P | No live option in notes is covered by §V `notes_menu_noReplyLiveTimed` |
+| Live | Chat switch commits the message to the original chat | Start a live message "hello" in bob's chat, open Private notes | CMP:1397-1411 | `liveMessage_chatSwitch_sendsToOriginalChat` | bob's next line after `[LIVE started] … hello` is `bob <# "alice> [LIVE ended] hello"` once the notes are opened (the message goes to the chat it was composed in, CMP:1401); the notes open with an empty field and no "hello" note; back in bob's chat the item is no longer live and the field is empty; a later "bye" is bob's next line | P | |
+| Live | History in Info, received badge | bob `/_send @<alice's contact id> live=on text hello`; `/last_item_id @alice` gives bob's item id; `/_update item @<id> <item id> live=on text hello there`; then `/_update item … text hello there` ends it; alice opens its Info | `C/views/chat/item/FramedItemView.kt:290-291`, INFO:322-343 | `liveMessage_received_showsLiveBadge` | The received bubble has the "LIVE" header while live, shows "hello there" in place after the update, and loses "LIVE" when bob ends it; Info → History lists "hello there" (current) above "hello" | P | `liveMessage_info_historyHasVersions` merged in. The API commands replace `/live`, whose live input mode the CLI peer's typing check can't drive. No live option in notes is covered by §V `notes_menu_noReplyLiveTimed` |
 
-### D. Timed / disappearing messages (6 tests)
+### D. Timed / disappearing messages (5 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Timed | Send with a 30-second timer; both sides delete | Right-click send → "Disappearing message" → "30 seconds" (under the menu header "Send disappearing message") | SMV:201-211, 272-312 | `timed_send30s_bothSidesDelete` | `bob <# "alice> hello!"` (`testDirectTimedMessage`); after 30 s the GUI item is gone, and bob's `/tail @alice 1` no longer shows it | P, SLOW | Waits at least 30 s for the deletion. bob is started with `--mark-read`: a received timed item starts its timer only when read (`src/Simplex/Chat/Library/Commands.hs:1307-1310`). The real CLI prints no deletion line (`timed message deleted: …` is test-view only, `src/Simplex/Chat/View.hs:937`) |
-| Timed | Timer options; custom time | Right-click send → "Disappearing message" | SMV:201-211, 272-312 | `timed_menuOptions_listed`, `timed_customTime_sendsWithChosenTtl` | Menu header "Send disappearing message" (SMV:278-283); options "30 seconds", "1 minute", "5 minutes", "Custom time" → "Delete after" → "Send"; the item is sent with the chosen TTL (item meta, plan §4) | P | No wait for deletion: the custom time is at least 1 minute (the picker's default is 5 minutes, SMV:298), so the item is still there at the end-of-test screenshot |
-| Timed | Menu hidden when the feature is off | bob runs `/set disappear @alice no` (prints `you updated preferences for alice:` / `Disappearing messages: off (you allow: no, contact allows: yes)`, `H/Profiles.hs:3563-3565`; both sides default to allowing it, `src/Simplex/Chat/Types/Preferences.hs:556`); once alice's "Contact preferences" (chat info) show "Contact allows" "no" for "Disappearing messages" (the CLI prints before the change reaches alice: `updateContactPrefs` only queues `XInfo`, `Library/Commands.hs:4114-4127`, applied on receipt, `Library/Subscriber.hs:2793-2796`), alice right-clicks send | SMV:201 | `timed_menuHidden_whenFeatureOff` | No "Disappearing message" item | P | |
-| Timed | Chat-level timer | CLI `/set disappear @alice yes 3` (`Library/Commands.hs:6404`, a decimal TTL is accepted, :6627-6641); then alice sends `hi` and bob sends `@alice hey` (`H/Profiles.hs:3553`), alice only once the feature row shows "3 sec" (Notes) | `C/views/chat/item/CIMetaView.kt:86-91` | `timed_chatPref_receivedMessagesDisappear`, `timed_meta_showsTimerAndTtl` | The new feature item joins the connection's merged feature row (`C/model/ChatModel.kt:3453-3461`, as 02:259-260 describe), which shows "3 sec" beside the timer icon (`C/views/chat/item/CIChatFeatureView.kt:103-114`); after right-click → "Expand" the item reads "Disappearing messages: 3 sec" (`C/model/ChatModel.kt:4329-4331`); the received item disappears after 3 s once read; after 3 s bob's `/tail @alice 2` no longer lists `hi` or `hey` (`testEnableTimedMessagesContact`; the real CLI prints no deletion line, `src/Simplex/Chat/View.hs:937`). The item meta shows the timer icon and no TTL text, because the item TTL equals the chat TTL (CIMetaView.kt:89); the TTL (3) is asserted through `ItemMetaKey.timedTtl` (plan §4) | P | bob runs with `--mark-read` (plan §8.1 `PeerFlags`), so his received `hi` starts its timer. alice sends `hi` only after the merged row shows "3 sec": her core copies bob's TTL on receipt (`Library/Subscriber.hs:2788-2792, 2806-2815`) and the CLI prints before delivery, so an earlier `hi` would carry no TTL. `timed_meta_showsTimerAndTtl` ends after both items are gone, so the end-of-test screenshot doesn't race their deletion |
+| Timed | Send with a 30-second timer; both sides delete | Type "hello!"; right-click send → "Disappearing message" (`Ui.Chat.SendTimed`) → "30 seconds" (`SendTimed.option(30)`) | SMV:206-218, 279-321, `C/views/chat/item/CIMetaView.kt:86-91` | `timed_send30s_bothSidesDelete` | The menu is closed before the right-click; then the header "Send disappearing message" with "30 seconds", "1 minute", "5 minutes" and "Custom time"; after "30 seconds" bob prints `alice> hello!`, alice's item has a 30 s timer and "30s" (`shortTimeText`) in its meta (the TTL differs from the chat TTL, none); bob's `/item info @alice hello!` shows `to be deleted at:` 28–40 s after `sent at:` (`viewChatItemInfo`, `src/Simplex/Chat/View.hs:806-820`); the item disappears from alice's chat, then bob's `/tail @alice 1` no longer ends with `alice> hello!` (asked once a second) | P, SLOW | Waits about 30 s: core timers run on the wall clock, not the paused Compose clock. bob is started with `--mark-read`: a received timed item starts its timer when read (`src/Simplex/Chat/Library/Commands.hs:1307-1310`), and the CLI marks it read before printing it (`src/Simplex/Chat/Terminal/Output.hs:149`). The real CLI prints no deletion line (`src/Simplex/Chat/View.hs:937`). `timed_menuOptions_listed` merged into `timed_send30s_bothSidesDelete` |
+| Timed | Timer options; custom time | Right-click send → "Disappearing message" → "Custom time" (`SendTimed.option("custom")`) → "Delete after" picker | SMV:279-321, `C/views/helpers/CustomTimePicker.kt:51-82`, `D/views/helpers/CustomTimePicker.desktop.kt:58-70` | `timed_customTime_sendsWithChosenTtl` | The picker opens at the default 5 minutes (`customDisappearingMessageTime` 300, `C/model/SimpleXAPI.kt:261`; value dropdown `Ui.TimePicker.Value` shows "5"); picking 2 (`Value.option(120)`) and "Send" (`Ui.TimePicker.Confirm`) sends `alice> custom` with a 120 s timer and "2m" in the meta; bob's item info shows deletion 118–130 s after sending; `CustomDisappearingMessageTime` is stored as 120 (not before) | P | Desktop only (`TimedMessageDesktopTest`): Android's picker is a wheel (`A/views/helpers/CustomTimePicker.android.kt`). No wait for deletion. `timed_menuOptions_listed` merged into `timed_send30s_bothSidesDelete` |
+| Timed | Menu hidden when the feature is off | alice first sends "allowed" with "30 seconds" (bob prints `alice> allowed`); bob runs `/set disappear @alice no` (prints `you updated preferences for alice:` / `Disappearing messages: off (you allow: no, contact allows: yes)`, `H/Profiles.hs:3563-3565`); once alice's contact has the feature off (`featureEnabled(TimedMessages)` false; the CLI prints before the change reaches alice: `updateContactPrefs` only queues `XInfo`, `Library/Commands.hs:4114-4127`, applied on receipt, `Library/Subscriber.hs:2793-2796`), alice types and right-clicks send | SMV:206 | `timed_menuHidden_whenFeatureOff` | The send menu shows "Send live message" (`Ui.Chat.SendLive`) but no "Disappearing message" | P | |
+| Timed | Chat-level timer | CLI `/set disappear @alice yes 10` (`timed_chatPref_receivedMessagesDisappear`) or `yes 120` (`timed_meta_showsTimerAndTtl`) (`Library/Commands.hs:6404`, a decimal TTL is accepted, :6627-6641); alice sends only once her contact's `timedMessagesTTL` equals bob's | `C/views/chat/item/CIMetaView.kt:86-91` | `timed_chatPref_receivedMessagesDisappear`, `timed_meta_showsTimerAndTtl` | `timed_chatPref_receivedMessagesDisappear`: `hi` and bob's `hey` disappear from alice's chat after the timer; the message sent before the timer stays; bob's `/tail @alice 1` no longer ends with them. `timed_meta_showsTimerAndTtl`: with the 120 s chat timer alice sends "chat timer" normally and "own timer" through "Disappearing message" → "30 seconds"; "chat timer" has the 120 s TTL and no TTL text in its meta (the item TTL equals the chat TTL, CIMetaView.kt:89), "own timer" has 30 s and "30s"; bob's item info shows deletion 118–130 s and 28–40 s after sending | P | bob runs with `--mark-read`, so his received items start their timers. alice sends only after the TTL reached her: her core copies bob's TTL on receipt (`Library/Subscriber.hs:2788-2792, 2806-2815`) and the CLI prints before delivery, so an earlier message would carry no TTL. `timed_meta_showsTimerAndTtl` does not wait for deletion |
 
 ### E. Voice messages (11 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
@@ -82,14 +82,14 @@ While a live message is open, `SendMsgView.kt:534-544` runs a loop of finite ani
 | Record | Play the recorded preview before sending | In notes: "Record voice message" (tap), stop → preview; play, pause, drag the slider | CMP:1212-1218, `C/views/chat/ComposeVoiceView.kt:53-84, 106-134` | `voice_preview_playPauseAndSeek` | While recording the play button is disabled and the duration counts up (`RecordingInProgressSlider`); after stop the button is enabled and shows the total duration; play → pause icon and the text follows playback progress; pause keeps the position; dragging the slider seeks (`AudioPlayer.seekTo`); the item is not sent | REC, AV | The play button's content description is "File" (`icon_descr_file`, ComposeVoiceView.kt:65): K2 key needed. Notes chat avoids a peer (as `voice_notes_recordAndSave`) |
 | Notes | Voice in notes | Record in notes | CMP:578 | `voice_notes_recordAndSave` | Item saved | REC | |
 
-### F. Attachments – sending (21 tests, 1 ignored)
+### F. Attachments – sending (14 tests, 1 ignored)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Attach | Attachment sheet | "Attach" → "Image" / "Video" / "File" | CMP:1299-1332, ATT:13-26, CMPD:15-38 | `attach_sheet_showsImageVideoFile` | Three buttons | P | |
-| File | Send a file, with text | "File" → dialog | CMP:343, 935 | `attachFile_send_peerReceivesOffer`, `attachFile_withText_peerReceivesTextAndFile` | `bob <# "alice> sends file test.pdf (266.0 KiB / 272376 bytes)"`, `bob <## "use /fr 1 … to receive it"` (the elided part is `[<dir>/` or-bar `<path>]`) (`testXFTPFileTransfer`); `bob <# "alice> hi, sending a file"` (`runTestMessageWithFile`) | P, S, XFTP, FD | |
-| File | Cancel the file preview | "File" → dialog → (x) | CMP:343 | `attachFile_cancelPreview_nothingSent` | The preview is removed; nothing reaches the CLI | P, FD | |
-| Image | Compressed image, multiple images, caption on last only | "Image" → dialog (multi-select) | CMP:360-414, 877-899 | `attachImage_send_peerReceivesCompressedImage`, `attachImages_multiple_sentAsSeparateMessages`, `attachImage_textOnLastImageOnly` | One "sends file …jpg" per image, each ≤255 KiB (`testSendImage`, `testSendMultiFilesDirect`); `attachImage_textOnLastImageOnly`: two images sent with text "caption" — bob prints the first `alice> sends file …` with no text line before it, then `alice> caption` and the second `alice> sends file …` (CMP:894-896; `tests/ChatTests/Files.hs:516-517`) | P, XFTP, FD | |
-| Image | Cancel the image preview | "Image" → dialog → (x) | CMP:360-414 | `attachImage_cancelPreview` | The preview is removed; nothing reaches the CLI | P, FD | |
+| Attach | Attachment sheet | "Attach" → "Image" / "Video" / "File" | CMP:1299-1332, ATT:13-26, CMPD:15-38 | | Three buttons | P | `attach_sheet_showsImageVideoFile` merged into `attachFile_withText_peerReceivesTextAndFile` (the sheet is checked open, with "Close sheet" on its scrim and Image, Video and File, before the file is picked; Android also shows Camera) |
+| File | Send a file, with text | "File" → dialog | CMP:343, 935 | `attachFile_withText_peerReceivesTextAndFile` | `bob <# "alice> sends file test.pdf (266.0 KiB / 272376 bytes)"`, `bob <## "use /fr 1 … to receive it"` (the elided part is `[<dir>/` or-bar `<path>]`) (`testXFTPFileTransfer`); `bob <# "alice> hi, sending a file"` (`runTestMessageWithFile`) | P, S, XFTP, FD | `attachFile_send_peerReceivesOffer` merged into `attachFile_withText_peerReceivesTextAndFile`. Shared: the file is picked through the chooser (`openFile`: the desktop open dialog, Android `ACTION_GET_CONTENT`); bob then receives it with `/fr 1` |
+| File | Cancel the file preview | "File" → dialog → (x) | CMP:343 | | The preview is removed; nothing reaches the CLI | P, FD | `attachFile_cancelPreview_nothingSent` merged into `attachFile_withText_peerReceivesTextAndFile` (the preview is cancelled first; bob's first line is then the later message's text) |
+| Image | Compressed image, multiple images, caption on last only | "Image" → dialog (multi-select) | CMP:360-414, 877-899 | `attachImage_textOnLastImageOnly` | One "sends file …jpg" per image, each ≤255 KiB (`testSendImage`, `testSendMultiFilesDirect`); `attachImage_textOnLastImageOnly`: two images sent with text "caption" — bob prints the first `alice> sends file …` with no text line before it, then `alice> caption` and the second `alice> sends file …` (CMP:894-896; `tests/ChatTests/Files.hs:516-517`) | P, XFTP, FD | `attachImage_send_peerReceivesCompressedImage` and `attachImages_multiple_sentAsSeparateMessages` merged into `attachImage_textOnLastImageOnly` (desktop `SendAttachmentDesktopTest`: two images are picked at once through the open-multiple dialog, and the shared `openFile` returns one file; one picked image on both platforms is `attachImage_withQuote_peerSeesQuote`). Each offer must be named `IMG_….jpg` (compressed by `saveImage`, `C/views/helpers/Utils.kt:187-192`) and be at most 261120 bytes |
+| Image | Cancel the image preview | "Image" → dialog → (x) | CMP:360-414 | | The preview is removed; nothing reaches the CLI | P, FD | `attachImage_cancelPreview` merged into `attachImage_textOnLastImageOnly` (a single picked image is cancelled first; bob's first offer then has no caption before it and the caption follows it) |
 | GIF | Animated image sent uncompressed | "Image" → .gif | CMP:372-381 | `attachGif_sentUncompressedAnimated` | CLI file size equals the source size | P, XFTP, FD | The sent GIF keeps playing on the real clock (`images/files.gif` loops forever), so its image node is volatile in screenshots (plan §7.7) |
 | Video | Send video | "Video" → dialog | CMP:388-409 | `attachVideo_send_peerReceivesVideo` | "sends file video_….mp4" | P, XFTP, FD, AV | The preview frame comes from the audio/video seam |
 | Video | Undecodable video | "Video" → dialog → the undecodable file | CMP:388-409 | `attachVideo_undecodable_showsAlert` | The alert "Decoding error" / "The video cannot be decoded. Please, try a different video or contact developers." and no preview; the video is dropped (CMP:399-408), so nothing reaches the CLI | P, FD, AV | The missing preview frame comes from the audio/video seam |
@@ -98,190 +98,191 @@ While a live message is open, `SendMsgView.kt:534-544` runs a loop of finite ani
 | Paste | Ctrl+V of an audio-only .webm | Put the absolute path of the audio-only .webm on the in-memory clipboard, press Ctrl+V, send; then the same with the .webm that has a video track | PTF:144-145, CMP:1516, CMP:290-314 | `pasteFileList_webmAudio_sentAsFile` | The .webm without video goes as a file (`bob <# "alice> sends file …webm (…)"`); a second .webm with a video track is sent as a video | P, XFTP, CB, AV | `hasVideoTrack` (`D/platform/VideoPlayer.desktop.kt:269`, a libvlc parse) must be part of the audio/video seam (plan §11.2), which reports "no video track" for this file |
 | Paste | Ctrl+V image | Ctrl+V with an image on the clipboard | PTF:146-150 | `ctrlV_clipboardImage_attachesPng` | The compose area shows the image preview with "Cancel image preview" (`C/views/chat/ComposeImageView.kt:67`), absent before Ctrl+V | P, IMGCB | When the clipboard text isn't a file list, Ctrl+V reads an image from the AWT system clipboard (PTF:150); the clipboard seam (plan §11.2) replaces it |
 | Drag & drop | Drop files | Drop on the chat | CV:980-988, CMP:290-314 | `dragDrop_files_attach` | The file preview with the file's name and "Cancel file preview" appears (`C/views/chat/ComposeFileView.kt:36,41`) | IGNORE: OS drag and drop onto the window | The drop target (`desktopOnExternalDrag`) needs an AWT drop event, and the compose state it feeds is local to `ChatView` (CV:148). The attach path behind it is covered through Ctrl+V of a file list (`ctrlV_clipboardFiles_attaches`, `pasteFileList_webmAudio_sentAsFile`) |
-| Limits | Large file | Pick a file over 1 GB | CMP:327-341 | `attachFile_tooLarge_showsLargeFileAlert` | "Large file!" | P, FD (sparse file over 1 GB) | The badge upsell button isn't asserted (badge display excluded) |
-| Limits | Group files off; attach disabled while editing | Attach in a group with files off; attach while editing | CMP:1304-1318 | `attach_groupFilesProhibited_buttonDisabled`, `attach_disabled_whileEditing` | `attach_groupFilesProhibited_buttonDisabled`: in a group with files off the attach button is disabled (grey, not clickable: `attachmentEnabled` excludes `isGroupAndProhibitedFiles`, CMP:1299-1330), so no alert opens (the "Files and media prohibited!" alert at CMP:1304-1310 is not reachable from the main chat; `testProhibitFiles` covers the core side); `attach_disabled_whileEditing`: the attach button is disabled while editing | P | |
-| Image | Image with quote | bob sends `@alice hi alice`; alice replies to it with an image captioned `hey bob` (`tests/ChatTests/Files.hs:295-304`) | CMP:877-899, 947-950 | `attachImage_withQuote_peerSeesQuote` | `bob <# "alice> > hi alice"`, `bob <## "      hey bob"`, `bob <# "alice> sends file IMG_….jpg (…)"` (`testSendImageWithTextAndQuote`; the GUI names compressed images `IMG_<timestamp>.jpg`, Utils.kt:184) | P, XFTP, FD | |
+| Limits | Large file | Pick a file over 1 GB | CMP:327-341 | `attachFile_tooLarge_showsLargeFileAlert` | "Large file!" | P, FD (sparse file over 1 GB) | The badge upsell button isn't asserted (badge display excluded). Shared: a sparse file of `MAX_FILE_SIZE_XFTP` + 1 bytes (`C/views/helpers/Utils.kt:135`) is picked through the chooser; after "OK" no preview remains and bob's next line is the following text message |
+| Limits | Group files off; attach disabled while editing | Attach in a group with files off; attach while editing | CMP:204-212, 1313-1346 | `attach_groupFilesProhibited_buttonDisabled` | In alice's own #team the attach button ("Attach") is enabled; while she edits her "draft" it is disabled (`attachmentDisabled`, CMP:206) and enabled again after (x) "Cancel"; after she turns "Files and media" off in "Group preferences" (saved: the group's `files` preference is off) the attach button is disabled (grey, not clickable: `attachmentEnabled` excludes `isGroupAndProhibitedFiles`, CMP:1328-1333), so no alert opens (the "Files and media prohibited!" alert at CMP:1320-1326 is not reachable from the main chat; `testProhibitFiles` covers the core side); text can still be sent | — | `attach_disabled_whileEditing` merged into `attach_groupFilesProhibited_buttonDisabled`. No peer: alice's group has no members |
+| Image | Image with quote | bob sends `@alice hi alice`; alice replies to it with an image captioned `hey bob` (`tests/ChatTests/Files.hs:295-304`) | CMP:877-899, 947-950 | `attachImage_withQuote_peerSeesQuote` | `bob <# "alice> > hi alice"`, `bob <## "      hey bob"`, `bob <# "alice> sends file IMG_….jpg (…)"` (`testSendImageWithTextAndQuote`; the GUI names compressed images `IMG_<timestamp>.jpg`, Utils.kt:184) | P, XFTP, FD | Shared `SendAttachmentTest`: alice replies to bob's message through the menu, and a generated 64×64 JPEG (`jpegFile`) is picked with `openFile` (desktop: the open-multiple dialog answered with that one file; Android: `ACTION_PICK`, answered by the harness, `A/views/helpers/GetImageView.android.kt:218-242`); bob receives the image with `/fr 1`. Fails if the quote is dropped from media sends (CMP:965) or the image is sent uncompressed (CMP:885) |
 | Image | Group image | Image in a group | CMP:877-899 | `attachImage_group_allMembersReceive` | `bob <# "#team alice> sends file IMG_….jpg (…)"` and `cath <# "#team alice> sends file IMG_….jpg (…)"` (`testGroupSendImage`) | P ×2, XFTP, FD | |
 
-### G. Receiving files: download, cancel, errors, save, viewers (20 tests)
+### G. Receiving files: download, cancel, errors, save, viewers (19 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
 | Image | Auto-receive a small image | bob `/img @alice tests/fixtures/test.jpg` | `C/views/chat/item/CIImageView.kt` | `rcvImage_autoReceived_renders` | `bob <## "completed uploading file 1 (test.jpg) for alice"`; the image is received without a tap and shown | P, XFTP | Auto-receive limit `MAX_IMAGE_SIZE_AUTO_RCV` (`C/views/helpers/Utils.kt:119`), with "Auto-accept images" on (default). Turning the setting off is owned by catalogue 04 |
-| Image | Click to download a large image | bob sends an image over the auto-receive limit with `/_send @<alice's contact id> json [{"filePath": …, "msgContent": {"type": "image", …}}]` (`/img` refuses files over 522240 bytes, Library/Commands.hs:3497-3498) | `C/views/chat/item/CIImageView.kt`, CV:599 | `rcvImage_large_clickDownloads` | The image shows the icon "Asked to receive the image" (file status `rcvInvitation`, `C/views/chat/item/CIImageView.kt:89`); after a click the item's file status (`FileStatusKey`, plan §4) becomes `rcvComplete` and the icon is gone (:92) | P, XFTP | `/f` would send a file message, not an image (Library/Commands.hs:3487-3491). The image is a JPEG over 522240 bytes generated by the harness into the peer's directory (fixture list in the header) |
+| Image | Click to download a large image | bob sends an image over the auto-receive limit with `/_send @<alice's contact id> json [{"filePath": "website/src/img/simplex_mobile.png", "msgContent": {"type": "image", …}}]` (`/img` refuses files over 522240 bytes, Library/Commands.hs:3497-3498), then a small one with `/img` | `C/views/chat/item/CIImageView.kt:89, 232-241`, `C/model/SimpleXAPI.kt:3068` | `rcvImage_large_clickDownloads` | Once the small image, sent after the large one, is received without a click, the large one (714372 bytes, over `MAX_IMAGE_SIZE_AUTO_RCV`) is still `rcvInvitation` and shows the icon "Asked to receive the image" (CIImageView.kt:89); after a click on its preview (`Ui.Chat.ItemFile(id).part("preview")`) the file status becomes `rcvComplete`, the full image (`Ui.Chat.ItemFile`) replaces the preview, the icon is gone and the stored file has the source's size and PNG header | P, XFTP | `/f` would send a file message, not an image (Library/Commands.hs:3487-3491). The large image is a repo file (`website/src/img/simplex_mobile.png`, 1684×3178), as the peer resolves paths against the repo root on both platforms |
 | File | Download by clicking the icon or "Download" | Click / menu | `C/views/chat/item/CIFileView.kt:75-84`, CIV:452-463 | `rcvFile_clickIcon_receives`, `rcvFile_menuDownload_receives` | The item's file status (`FileStatusKey`, plan §4) goes from `rcvInvitation` to `rcvComplete` (the icon loses its download arrow, which has no description, `CIFileView.kt:162,172`), and the received file's bytes equal the source's | P, XFTP | |
-| File | Waiting alert | `stop xftp1`; bob `/f @alice tests/fixtures/test.pdf`; alice clicks the file, then clicks it again; `start xftp1` | CIFileView:86-98, 163 | `rcvFile_acceptedBeforeUpload_showsWaitingAlert` | The file item reaches alice although bob's upload can't start; after the first click it shows the waiting icon (`RcvAccepted`, CIFileView:163) and the second click shows "Waiting for file" / "File will be received when your contact completes uploading it."; after `start xftp1`, `bob <## "completed uploading file 1 (test.pdf) for alice"` (View.hs:500) and alice's file completes (explicit 30 s timeout) | P, XFTP, SRVCTL | The server is stopped before bob sends, so the accepted file waits for as long as it is down (measured with CLIs: the invitation arrived after 0.5 s, `RcvAccepted` held for 8 s; after the start the upload completed in 4.8 s and the receive in 5.3 s). bob's chunk-creation retries stay at 2 s for the first 10 s of the outage, then grow ×1.5 (`messageRetryInterval.riFast`, simplexmq `Agent/Env/SQLite.hs:205-219`), so the outage stays under about 10 s (plan §11.1 Server control) |
+| File | Waiting alert | `stop xftp1`; bob `/f @alice tests/fixtures/test.pdf`; alice clicks the file, then clicks it again; `start xftp1` | CIFileView:86-98, 163 | `rcvFile_acceptedBeforeUpload_showsWaitingAlert` | The file item reaches alice although bob's upload can't start; after the first click it shows the waiting icon (`RcvAccepted`, CIFileView:163) and the second click shows "Waiting for file" / "File will be received when your contact completes uploading it."; after `start xftp1`, `bob <## "completed uploading file 1 (test.pdf) for alice"` (View.hs:500) and alice's file completes (explicit 30 s timeout) | P, XFTP, SRVCTL | The server is stopped before bob sends, so the accepted file waits for as long as it is down (measured with CLIs: the invitation arrived after 0.5 s, `RcvAccepted` held for 8 s; after the start the upload completed in 4.8 s and the receive in 5.3 s). bob's chunk-creation retries stay at 2 s for the first 10 s of the outage, then grow ×1.5 (`messageRetryInterval.riFast`, simplexmq `Agent/Env/SQLite.hs:205-219`), so the outage stays under about 10 s (plan §11.1 Server control). Shared `ReceiveFileTest`: bob sends a generated text file (`createFile`, so the received bytes can be compared on both platforms) instead of `test.pdf`; after `start("xftp1")` the received file's bytes equal bob's. Fails if the accepted file does not wait for the upload (an error instead), the second click shows no waiting alert, or the download does not resume after the server is back |
 | Cancel | Stop receiving, then download again | bob `/f @alice tests/fixtures/test.pdf`; after `bob <## "completed uploading file 1 (test.pdf) for alice"` (View.hs:500), `stop xftp1`; alice clicks the file; "Stop file" → "Stop receiving file?" → "Stop"; `start xftp1`; alice clicks the file again | CIV:483-485, 1378, CIFileView:164-166 | `rcvFile_stopReceiving_thenRedownload` | After the first click the item shows the download at 0 (progress circle, `CIFSRcvTransfer 0 1`, Library/Internal.hs:929-943) and stays there while xftp1 is down; after "Stop" it returns to the not-downloaded state (download icon, `RcvInvitation`, Library/Commands.hs:3559); after the start, the second click receives the file, and the file on disk matches the source (as in `testXFTPCancelRcvRepeat`) | P, XFTP, SRVCTL | The server is stopped after bob's upload and before alice's click, so the download can't finish before "Stop" (measured with CLIs: `progress 0%` held for 8 s, `/fc` → `not accepted yet`, re-download 0.26 s after the start). A refused connection is not a host error, so no warning replaces the progress (simplexmq `Agent/Client.hs:1627-1636`); no request is in flight when the server stops, so no short timeouts are needed |
-| Cancel | Sender revokes (CLI); GUI revokes | bob `/fc 1`; "Revoke file" → "Revoke file?" → "Revoke" (alice attaches the file by typing its path, PTF:97-110) | `C/model/ChatModel.kt:4698-4730` | `rcvFile_senderRevoked_showsCancelled`, `sndFile_revoke_peerSeesCancelled` | `rcvFile_senderRevoked_showsCancelled`: bob runs `/f @alice tests/fixtures/test.pdf`, waits for `completed uploading file 1 (test.pdf) for alice`, then `/fc 1` → `bob <## "cancelled sending file 1 (test.pdf)"` (View.hs:2471); alice's item's file status (`FileStatusKey`, plan §4) becomes `rcvCancelled` (drawn as the cancelled-file icon, which has no description, CIFileView.kt:173). `sndFile_revoke_peerSeesCancelled`: alice revokes → `bob <## "alice cancelled sending file 1 (test.pdf)"` (View.hs:2466; `testXFTPDeleteUploadedFile`) | P, XFTP | |
+| Cancel | Sender revokes (CLI); GUI revokes | bob `/fc 1`; "Revoke file" → "Revoke file?" → "Revoke" (alice attaches the file by typing its path, PTF:97-110) | `C/model/ChatModel.kt:4698-4730` | `rcvFile_senderRevoked_noDownload`, `sndFile_revoke_peerSeesCancelled` | `rcvFile_senderRevoked_showsCancelled`: bob runs `/f @alice tests/fixtures/test.pdf`, waits for `completed uploading file 1 (test.pdf) for alice`, then `/fc 1` → `bob <## "cancelled sending file 1 (test.pdf)"` (View.hs:2471); alice's item's file status (`FileStatusKey`, plan §4) becomes `rcvCancelled` (drawn as the cancelled-file icon, which has no description, CIFileView.kt:173). `sndFile_revoke_peerSeesCancelled`: alice revokes → `bob <## "alice cancelled sending file 1 (test.pdf)"` (View.hs:2466; `testXFTPDeleteUploadedFile`) | P, XFTP | `rcvFile_senderRevoked_showsCancelled` is implemented as `rcvFile_senderRevoked_noDownload` (`FilesTest`: the revoked file's menu no longer offers "Download"). `sndFile_revoke_peerSeesCancelled` (shared) attaches the file through the chooser, revokes it once its status is `sndComplete` ("Revoke file", `Ui.Chat.ItemMenu(id, "cancelFile")`), and then bob's `/fr 1` prints `file cancelled: …` (`testXFTPDeleteUploadedFile`) |
 | Cancel | GUI stops during upload | "Stop file" → "Stop sending file?" → "Stop" (alice attaches the file by typing its path, PTF:97-110) | CIV:483-485, 1378, `C/model/ChatModel.kt:4709-4716` | `sndFile_stopDuringUpload` | `bob <# "alice> sends file test.pdf (266.0 KiB / 272376 bytes)"`, then after "Stop" `bob <## "alice cancelled sending file 1 (test.pdf)"`; the GUI item's file status (`FileStatusKey`, plan §4) becomes `sndCancelled` (`CIFileView.kt:153`) | P, XFTP, SRVCTL | The XFTP server is stopped before sending, so the upload can't finish first |
 | Errors | Auth error | Click the failed item | CIFileView:100-101, 255-271 | `rcvFile_xftpAuthError_showsFileErrorAlert` | "File error" (`testXFTPRcvError` FileErrAuth) | P, XFTP, SRVCTL | bob runs `/f @alice tests/fixtures/test.pdf`; after `bob <## "completed uploading file 1 (test.pdf) for alice"` (View.hs:500) and before the GUI receives, the XFTP server is restarted without its store (`reset xftp1`). A reset during bob's upload would hang his chunk request (plan §11.1 Server control) and alice's file description would never arrive, so her click would show the waiting alert instead |
 | Errors | Send error | alice first shortens the network timeouts: Settings > "Network & servers" > "Advanced network settings" > "Protocol timeout per KB" → "0.003 sec" (the lowest entry, 2500 µs) → "Save and reconnect" → "Update network settings?" → "Update"; then version row > "Developer tools" > "Chat console": `/network socks=off timeout=1`. She sends the 150 MB file (attached by typing its path, PTF:97-110); at the item's first visible upload progress, `reset xftp1`; she clicks the failed item | CIFileView:104-105, 255-271, `C/views/usersettings/networkAndServers/AdvancedNetworkSettings.kt:133-142, 285-288, 342, 556-563`, `C/views/usersettings/DeveloperView.kt:32` | `sndFile_xftpResetDuringUpload_showsFileError` | "File error" within an explicit 40 s timeout after the reset: the upload gets AUTH, a permanent error, so the agent sends SFERR (SndError) | P, XFTP, SRVCTL | An upload in flight at the reset hangs until its request timeout: TCP connection background timeout + protocol background timeout + 4096 KB × the per-KB timeout (simplexmq `Transport/HTTP2/Client.hs:189-194, 209-210` adds the connection timeout to the chunk timeout, `FileTransfer/Client.hs:209-214, 300-306`); the retry, 2 s later, reaches the restarted server and gets AUTH at once. Measured with CLIs: 75 s with CLI defaults, 118 s with the GUI defaults (`C/model/SimpleXAPI.kt:5256-5258`), 57 s with the lowest values the UI offers (so the console step is needed), 19.9 s with these settings; 0.2–2.3 s when the reset falls between two chunk uploads. `/network socks=off timeout=1` sets the protocol timeouts to 1 s (3 s background) and the TCP connection timeouts to 1.5 s (4.5 s background) and keeps the per-KB value (Library/Commands.hs:396-401, 1904-1907); its host mode (public) changes nothing with no SOCKS proxy and the local servers. Worst case: 4.5 + 3 + 10.24 + 2 ≈ 20 s. The settings are saved before the console command, because saving them sends the GUI's own config (AdvancedNetworkSettings.kt:133-142) and would undo it. The 150 MB file leaves about 3–4 s between the first visible progress (at about +6 s) and the last chunk (upload done at +10 s); the 17 MB file left only about 0.4 s (plan §11.1 Server control) |
 | Errors | Temporary file error | bob sends a file that isn't auto-received; alice turns SOCKS on and "Use .onion hosts" to "Required" (04 §E `socks_onionHostsOptions`), then clicks the file | CIFileView:102-103, 106-107 | `rcvFile_temporaryError_showsTemporaryFileError` | Download fails with BROKER HOST (no onion host: `PCEIncompatibleHost`, simplexmq `Messaging/Client.hs:530-541`, `Agent/Client.hs:1297`; host choice fails before any SOCKS connection, so no stub is needed) and the core sets `CIFSRcvWarning` (`Library/Subscriber.hs:429-433`); clicking the item shows "Temporary file error" | P, XFTP | The same setting reaches `SndWarning` |
 | Errors | Expired file | Click the expired item | CIFileView:257-276 | `rcvFile_expired_showsFileExpired` | "File expired" | P, XFTP, SRVCTL, RESTART, FIXTURE (expired file) | The alert needs an Auth or NoFile receive error first (CIFileView:257): bob runs `/f @alice tests/fixtures/test.pdf`, and the XFTP server is reset after `bob <## "completed uploading file 1 (test.pdf) for alice"` (View.hs:500; a reset during the upload leaves alice without the file description, as in `rcvFile_xftpAuthError_showsFileErrorAlert`), alice's receive then fails, and, between two `restart()` steps, the received file's expiry is moved into the past in the GUI database |
-| Deleted | Sender marks deleted before accept | bob broadcast-deletes | CIV:557-567, 698-700 (`MarkedDeletedItemDropdownMenu`), `C/views/chat/item/MarkedDeletedItemView.kt` | `rcvFile_senderDeletedItem_cannotReceive` | bob sends a text-and-file message (`/_send @<alice's contact id> json [{"filePath": …, "msgContent": {"type": "text", "text": "hi, sending a file"}}]`) and broadcast-deletes it; the GUI item reads "marked deleted" and its menu has no "Download" (`testSenderMarkItemDeleted`) | P, XFTP | |
-| Open | Click completed file | Click | CIFileView:107-121 | `rcvFile_clickCompleted_opensSaveDialog` | Save dialog | P, XFTP, FD | |
+| Deleted | Sender marks deleted before accept | bob broadcast-deletes | CIV:557-567, 698-700 (`MarkedDeletedItemDropdownMenu`), `C/views/chat/item/MarkedDeletedItemView.kt` | `rcvFile_senderDeletedItem_cannotReceive` | bob sends a text-and-file message (`/_send @<alice's contact id> json [{"filePath": …, "msgContent": {"type": "text", "text": "hi, sending a file"}}]`) and broadcast-deletes it; the GUI item reads "marked deleted" and its menu has no "Download" (`testSenderMarkItemDeleted`) | P, XFTP | bob deletes by text (`\@alice hi, sending a file` → `message marked deleted`); the menu offers "Download" before the deletion and only "Reveal" and the rest after it |
+| Open | Click a file; click completed file | Click a not-received `list.txt`, then click it again once received | CIFileView:78-128, 204, 245-256 | `rcvFile_clickCompleted_opensSaveDialog` | Desktop (`ReceiveFileDesktopTest`): the first click receives the file and, once it is received, opens the save dialog (`OpenWhenReceivedEffect`, CIFileView:204, 253-256); a second click on the completed file opens the save dialog again (CIFileView:113-123); both saved files have bob's text | P, XFTP, FD | Desktop only: on Android a click on a received file opens an Open/Save menu (CIFileView:190-201). A markdown file opens the viewer instead (CIFileView:111-112, `rcvFile_clickIcon_receives`) |
 | Open | File missing on disk | Delete the received file on disk, then click the item and open its menu | CIFileView:108-124, `C/model/ChatModel.kt:4610-4614` | `rcvFile_missingOnDisk_clickDoesNothing` | The click opens no dialog and records no toast; the menu has no "Save", "Share", "Copy" or "Forward" | P, XFTP, TOAST, FD | FD only asserts that no save dialog is awaiting; "File not found" appears only when connected to a remote host (CIFileView:111-120; catalogue 04 §K) |
-| Viewer | Full-screen image; click closes it | Click the image; click the full-screen image | `D/views/chat/item/CIImageView.desktop.kt:30`, `C/views/chat/item/ImageFullScreenView.kt:82, 173-177` | `rcvImage_click_opensFullScreen`, `fullScreen_click_closes` | Full-screen view opens; a click closes it (desktop has no gallery paging) | P, XFTP | |
+| Viewer | Full-screen image; click closes it | Click the image; click the full-screen image | `D/views/chat/item/CIImageView.desktop.kt:30`, `C/views/chat/item/ImageFullScreenView.kt:82, 173-177`, `C/views/chat/item/CIImageView.kt:138` (`Ui.Chat.ItemFile`, on the loaded image only) | `rcvImage_click_opensFullScreen` | Full-screen view opens; a click closes it (desktop has no gallery paging) | P, XFTP | `fullScreen_click_closes` merged into `rcvImage_click_opensFullScreen` (shared; the full-screen page is `Ui.Chat.FullScreenMedia`) |
 | Video | Received video preview and download | bob `/_send @<alice's contact id> json [{"filePath": "<mp4>", "msgContent": {"type": "video", "text": "", "image": "<preview data URI>", "duration": <s>}}]` | `C/views/chat/item/CIVideoView.kt`, `C/model/SimpleXAPI.kt:3034` | `rcvVideo_previewAndDownload` | The preview from the message content is shown; an mp4 of 1023 KB or less (`apps/multiplatform/common/src/desktopTest/resources/uitest-fixtures/small.mp4`) is received without a click (`MAX_VIDEO_SIZE_AUTO_RCV`, `C/views/helpers/Utils.kt:121`), a larger one (`website/src/video/connect.mp4`, 1.9 MB) after a click on the download icon | P, XFTP, AV | |
 | Group | Group file | bob `/f #team tests/fixtures/test.pdf`; click the file in #team | `C/views/chat/item/CIFileView.kt:75-84` | `rcvFile_group_receive` | bob prints `bob <## "completed uploading file 1 (test.pdf) for #team"`; after the click the file icon shows complete and the file on disk matches the source (`testXFTPGroupFileTransfer`) | P, XFTP | |
 
-### H. Replies / quotes (7 tests)
+### H. Replies / quotes (6 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
 | Reply | Reply | Right-click → "Reply" | CIV:407-416, CMP:1260 | `reply_menu_sendQuoted_peerSeesQuote`, `reply_cancelContext` | `reply_menu_sendQuoted_peerSeesQuote`: `bob <# "alice> > hello! how are you?"`, `bob <## "      all good - you?"` (`testDirectMessageQuotedReply`); `reply_cancelContext`: "Cancel" (x) on the reply bar removes the quote and keeps the typed text (`C/views/chat/ContextItemView.kt:148-151`, CMP:1260-1262); the message then arrives without a quote: `bob <# "alice> <text>"` | P, S | |
-| Jump | Jump to quoted message, including one not loaded yet; deleted original | Click the quote | CV:3200-3228, 3139, `C/views/chat/item/FramedItemView.kt:655` | `quote_click_scrollsToQuotedAndHighlights`, `quote_click_unloadedItem_loadsAround`, `quote_click_deleted_showsNoMessageAlert` | Original highlighted; "No message" / "This message was deleted or not received yet." | P | The unloaded case uses a 300-message batch, as in `testDirectMessageDeleteMultipleManyBatches`. For the deleted case alice deletes the original with "Delete for me" (an original that bob deletes for everyone under default prefs is only marked deleted and keeps its id, so the click scrolls to it: the quote's item id is null only when the row is gone, CV:3209-3225, `Store/Messages.hs:2715-2718`) |
-| Group | Group reply | Reply to bob in a group | — | `reply_group_peerSeesMemberQuote` | `bob <# "#team alice!> > bob …"`, `cath <# "#team alice> > bob …"` (`testGroupMessageQuotedReply`) | P ×2 | |
+| Jump | Jump to quoted message, including one not loaded yet; deleted original | Click the quote | CV:3200-3238, 3139, `C/views/chat/item/FramedItemView.kt:655-665` | `reply_received_showsQuote_clickScrollsToOriginal`, `quote_click_deleted_showsNoMessageAlert` | `reply_received_showsQuote_clickScrollsToOriginal` (`ReceivedMessagesTest`): bob's reply quoting alice's message, 30 messages later, scrolls the original into view when its quote is clicked; `quote_click_deleted_showsNoMessageAlert`: a click on the quote of an existing message shows no alert; after alice deletes the original with "Delete for me" the click shows "No message" / "This message was deleted or not received yet." (CV:3234) | P | `quote_click_scrollsToQuotedAndHighlights` renamed to `reply_received_showsQuote_clickScrollsToOriginal` (the existing test; the highlight is not observable in the semantics; on Android the test is skipped, plan 15.4.1c); `quote_click_unloadedItem_loadsAround` merged into §Q `pagination_quoteOutsidePage_jumpLoadsOriginal` (120 messages, the quote loads the page around the original). For the deleted case alice deletes the original with "Delete for me" (an original that bob deletes for everyone under default prefs is only marked deleted and keeps its id, so the click scrolls to it: the quote's item id is null only when the row is gone, CV:3219-3235, `Store/Messages.hs:2715-2718`) |
+| Group | Group reply | Reply to bob in a group | — | `reply_group_peerSeesMemberQuote` | `bob <# "#team alice!> > bob …"`, `cath <# "#team alice> > bob …"` (`testGroupMessageQuotedReply`) | P ×2 | The test then replies to alice's own reply: `bob <# "#team alice> > alice …"`, `cath <# "#team alice> > alice …"`, and the GUI quote reads "you" instead of "bob" |
 | Rules | Reply replaces edit | "Edit" an own message, then "Reply" on another | CIV:407-416 | `reply_whileEditing_replacesEdit` | The edit context and the edited text are replaced by an empty compose quoting the chosen item | P | No Reply in notes is covered by §V `notes_menu_noReplyLiveTimed` |
 
-### I. Edit and history (12 tests)
+### I. Edit and history (5 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Edit | Edit | "Edit" → change text → Enter | CIV:464-469, CMP:806 | `edit_menu_updatesPeer`, `edit_unchanged_noUpdate`, `edit_cancel_clearsCompose`, `edit_metaShowsEditedIcon` | `edit_menu_updatesPeer`: `bob <# "alice> [edited] hey 👋"` (`testDirectMessageUpdate`); `edit_unchanged_noUpdate`: submitting an unchanged edit prints nothing on bob and the item's meta stays not edited (core "message didn't change", same test); `edit_cancel_clearsCompose`: "Cancel" (x) on the edit bar empties the compose field (`clearState`, CMP:1263-1265); the item keeps its text and bob prints nothing; `edit_metaShowsEditedIcon`: after the edit the item's meta shows the edit icon (`C/views/chat/item/CIMetaView.kt:83-84`) | P, S | |
-| Keyboard | Up arrow edits last message | Up arrow on empty compose | PTF:138, CMP:1185 | `edit_upArrow_editsLastMessage` | Edit mode with the last own message | P | |
-| Receive | Received edit; edit keeps quote | bob `! @alice <new text>` (edits his last message to alice; `! @alice (<old text>) <new text>` picks an earlier one; `EditMessage`, `Library/Commands.hs:6343`) | — | `edit_received_updatesBubble`, `edit_quotedReply_keepsQuote` | The GUI bubble shows the edited text and the edited state (item meta, plan §4); the quote is kept | P | |
-| Receive | Edit image caption | bob updates the caption of a sent image | — | `edit_imageCaption_updates` | The image item's caption changes from the original "old caption" to "new caption" (the old text is gone) and the item is marked edited (`ItemMetaKey.edited`, plan §4) | P, XFTP | |
-| Edit | Edit the caption of alice's own image or file | alice sends `test.jpg` with the text "hi" ("Image" → dialog), and `test.pdf` with "doc" ("File" → dialog); "Edit" on each → replace the text with "hello" / "new doc" → Enter | CIV:464-469, CMP:123-136, CMP:264-278, CMP:1207-1223, `C/views/chat/ComposeImageView.kt:63-70`, `C/views/chat/ComposeFileView.kt:37-46` | `edit_ownImage_previewWithoutCancel`, `edit_ownFile_previewWithoutCancel` | While editing, the compose area shows the image thumbnail / the file name "test.pdf" with no "Cancel image preview" / "Cancel file preview" button (`cancelEnabled = !editing && !inProgress`, CMP:1210, 1222) and the field holds "hi" / "doc"; after Enter bob prints `bob <# "alice> [edited] hello"` / `bob <# "alice> [edited] new doc"` (`ttyFromContactEdited` + `ttyMsgContent`, `src/Simplex/Chat/View.hs:3066-3067`, :2431-2438); the image/file itself is not re-sent (no new "sends file" line) | P, XFTP, FD | Voice items are not editable (CIV:464), so ComposeVoiceView never appears in edit mode; MCChat items get no preview while editing (CMP:276) |
-| Rules | No Edit on received, own voice or forwarded | — | CIV:464 | `edit_notOffered_forReceivedVoiceForwarded` | The item menu has no "Edit" for a received item, alice's recorded voice message or a forwarded item (the core would refuse a forwarded edit, `testForwardEditProhibited`) | P, XFTP, REC | |
-| Rules | Group edit | "Edit" in a group | CIV:464-469 | `edit_group_membersSeeEdited` | bob and cath print `bob <# "#team alice> [edited] hey 👋"` / `cath <# "#team alice> [edited] hey 👋"` (`testGroupMessageUpdate`) | P ×2 | |
+| Edit | Edit; unchanged edit; cancel; edited state | "Edit" → (x) "Cancel"; "Edit" → Enter unchanged; "Edit" → change text → Enter | CIV:468-473, CMP:808-827, CMP:1265-1267, `C/views/chat/ContextItemView.kt:148-151` | `edit_menu_updatesPeer` | (x) "Cancel" on the edit bar (prefilled with "hello") empties the compose field (`clearState`, CMP:1265-1267); submitting the unchanged text sends nothing (core `viewItemNotChanged` prints only on the sender, `src/Simplex/Chat/View.hs:917-920`); after the real edit bob prints `bob <# "alice> [edited] hey 👋"` as the very next line after `alice> hello` (`testDirectMessageUpdate`), so the cancel and the unchanged submit sent nothing; the same bubble shows "hey 👋" and not "hello", and the item is edited in the model (`meta.itemEdited`); the item info history lists both versions, newest first, the newest marked "(current)" (§P `info_history_listsVersions`) | P, S | `edit_unchanged_noUpdate`, `edit_cancel_clearsCompose`, `edit_metaShowsEditedIcon` and §P `info_history_listsVersions` merged into `edit_menu_updatesPeer`; the edited icon has no content description (`C/views/chat/item/CIMetaView.kt:83-84`, :198-199), so the edited state is checked in the model and through the 2-version history. Class `EditMessageTest` (moved from `MessagingTest`) |
+| Keyboard | Up arrow edits last message | Up arrow on empty compose | PTF:141-142, CMP:1187-1192 | `edit_upArrow_editsLastMessage` | With an empty field, Up opens the edit bar on alice's last own message "second" although bob's "from bob" is newer (`findLast { it.meta.editable }`); after Enter bob prints `bob <# "alice> [edited] second!"`; with "x" in the field, Up leaves the field as "x" and opens no edit bar | P | Desktop only (`desktop/EditMessageDesktopTest`): the Up handler exists only in the desktop text field. `editPrevMessage` also does nothing while a context item or a preview is shown (CMP:1188) |
+| Receive | Received edit | bob `! @alice <new text>` (edits his last message to alice; `! @alice (<old text>) <new text>` picks an earlier one; `EditMessage`, `Library/Commands.hs:6343`) | — | `edit_received_updatesBubble` | The GUI bubble shows "hello" before the edit; after it the same bubble shows "hey" and not "hello", and the item is edited in the model (item meta, plan §4) | P | `edit_quotedReply_keepsQuote` dropped: the quote is kept by the core, the app sends only the content (CMP:818) and upserts the result, so no app change breaks only this; covered by `testDirectMessageUpdate` (`tests/ChatTests/Direct.hs:704-714`) |
+| Receive | Edit image caption | bob updates the caption of a sent image | — | | Dropped: the same app receive path as `edit_received_updatesBubble` (`chatItemUpdateNotify`, `C/model/SimpleXAPI.kt:3090-3091`), plus XFTP cost | P, XFTP | `edit_imageCaption_updates` dropped |
+| Edit | Edit the caption of alice's own file | alice pastes the path of `report.txt` into the compose field (desktop attach route, as `FilesDesktopTest.paste_filePathText_attachesFile`), types "doc", sends; "Edit" → replace the text with "new doc" → Enter | CIV:468-473, CMP:123-136, CMP:264-278, CMP:1220-1225, `C/views/chat/ComposeFileView.kt:37-46` | `edit_ownFile_keepsFileWithoutPreview` | Before sending the preview has "Cancel file preview"; while editing, the compose area shows the edit bar (file icon + "doc") and no file preview (`C/views/chat/ComposeView.kt:1768` skips `previewView()` for a FilePreview while editing), so no "Cancel file preview", and the field holds "doc"; after the edit the item is still a file item showing "report.txt"; after Enter bob prints `bob <# "alice> [edited] new doc"` (`ttyFromContactEdited` + `ttyMsgContent`, `src/Simplex/Chat/View.hs:3066-3067`, :2431-2438); the file itself is not re-sent: the next line is the sentinel `bob <# "alice> ping"` | P, XFTP | Desktop only (`desktop/EditMessageDesktopTest`, path-paste attach). `edit_ownImage_previewWithoutCancel` dropped for now: image attach needs file-dialog support on both platforms; the same `cancelEnabled` rule is covered by the file variant (CMP:1212). Voice items are not editable (CIV:468), so ComposeVoiceView never appears in edit mode; MCChat items get no preview while editing (CMP:276) |
+| Rules | No Edit on received or forwarded | — | CIV:468 | `edit_notOffered_forReceivedOrForwarded` | The item menu offers "Edit" on alice's own message, but not on bob's received message or on alice's forwarded copy of it (forwarded to bob's own chat; the core would refuse a forwarded edit, `testForwardEditProhibited`; `editable = deletable && isNothing itemForwarded`, `src/Simplex/Chat/Messages.hs:538-550`) | P | Renamed from `edit_notOffered_forReceivedVoiceForwarded`; the voice branch (CIV:468 `!is MCVoice`) needs REC and belongs in §E as a menu check; `editable` also expires after 24 h (`Messages.hs:544-550`), not reachable in a UI test |
+| Rules | Group edit | "Edit" in a group | CIV:468-473, CMP:812-818 | | Dropped (P2): bob and cath would print `bob <# "#team alice> [edited] hey 👋"` / `cath <# "#team alice> [edited] hey 👋"` (`testGroupMessageUpdate`); not worth 2 peers plus group setup | P ×2 | `edit_group_membersSeeEdited` dropped |
 
-### J. Delete / reveal / blocked (8 tests)
+### J. Delete / reveal / blocked (4 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Delete | Delete own message | "Delete" → "Delete message?" → "Delete for me" / "For everyone" | CIV:869-915, 1390-1424 | `delete_ownForMe_localOnly`, `delete_ownForEveryone_peerSeesMarkedDeleted`, `delete_forEveryone_fullDeletion_peerSeesDeleted` | `delete_ownForMe_localOnly`: "Delete for me" removes the item from alice's chat; bob prints nothing; `delete_ownForEveryone_peerSeesMarkedDeleted`: warning "Message will be marked for deletion…", then "For everyone": `bob <# "alice> [marked deleted] hello"`; `delete_forEveryone_fullDeletion_peerSeesDeleted`: after bob runs `/set delete @alice always` (full deletion of alice's messages needs bob's consent) and alice's "Contact preferences" show "Contact allows" "always" for "Delete for everyone" (the CLI prints before the change reaches alice: `updateContactPrefs` only queues `XInfo`, `Library/Commands.hs:4114-4127`, applied on receipt, `Library/Subscriber.hs:2793-2796`): "Message will be deleted - this cannot be undone!" and `bob <# "alice> [deleted] hey"` (`testAllowFullDeletionContact`) | P, S | |
-| Delete | Delete received; received marked-deleted with Reveal/Hide; received full delete | Menu | CIV:503-519, 950-972, `C/views/chat/item/MarkedDeletedItemView.kt` | `delete_received_onlyForMe`, `markedDeleted_received_revealHide`, `delete_received_fullDelete_removed` | `delete_received_onlyForMe`: "Delete message?" offers only "Delete for me", because received items are never deletable for everyone (CIV:1391-1421; `deletable'`, `src/Simplex/Chat/Messages.hs:542-549`); the item disappears and bob prints nothing; `markedDeleted_received_revealHide`: after bob deletes for everyone the item shows "marked deleted"; the menu offers "Reveal", which shows the text, then "Hide"; `delete_received_fullDelete_removed`: with full deletion allowed, bob's broadcast delete removes the item from the GUI chat (`testAllowFullDeletionContact`) | P | For the full-delete test alice first sets "Delete for everyone" to "always" for bob in contact preferences (setup only; the preferences screen is owned by catalogue 01 §14) |
-| Display | Blocked by admin; consecutive deleted items collapsed | bob (owner) runs `/block for all #team cath` (`Library/Commands.hs:6276`); cath sends one message, bob a normal one, then cath two more; for the collapsed count, after another normal message bob deletes two consecutive messages of his own for everyone (`\ #team <text>` for each, `Library/Commands.hs:6341,2687-2690`) | MarkedDeletedItemView:68-110; `C/model/ChatModel.kt:3453-3455` | `blockedByAdmin_items_showBlocked`, `markedDeleted_consecutive_collapsedCount` | One blocked item reads "blocked by admin", two or more consecutive read "%d messages blocked by admin"; the two deleted items read "2 messages marked deleted" (a run mixing blocked and deleted items would read "%d messages marked deleted": all share one merge category) (`testBlockForAllMarkedBlocked`) | P ×2 | Moderation itself is owned by catalogue 03 §14 (`00-legend.md`) |
+| Delete | Delete own message; full deletion | "Delete" → "Delete message?" → "Delete for me" / "For everyone"; the same for a 2-message selection | CIV:873-920, 1402-1436, CV:325-349 | `delete_ownForEveryone_peerSeesMarkedDeleted`, `delete_forEveryone_fullDeletion_peerSeesDeleted` | `delete_ownForEveryone_peerSeesMarkedDeleted`: warning "Message will be marked for deletion…", then "For everyone": `bob <# "alice> [marked deleted] hello"`; `delete_forEveryone_fullDeletion_peerSeesDeleted`: under default preferences "Delete message?" says "Message will be marked for deletion. The recipient(s) will be able to reveal this message." with both buttons, and "Delete for me" removes the item from alice's chat only (bob's next line is the later `alice> two`); after bob runs `/set delete @alice always` (`bob <## "you updated preferences for alice:"`, `bob <## "Full deletion: enabled for contact (you allow: always, contact allows: no)"`) and the change reaches alice (the CLI prints before it does: `updateContactPrefs` only queues `XInfo`, `Library/Commands.hs:4114-4127`, applied on receipt, `Library/Subscriber.hs:2793-2796`), the warning is "Message will be deleted - this cannot be undone!", "For everyone" prints `bob <# "alice> [deleted] two"` and removes the item from alice's chat; a 2-message selection then warns "Messages will be deleted - this cannot be undone!" and "For everyone" prints `[deleted]` for both (`testAllowFullDeletionContact`) | P, S | `delete_ownForMe_localOnly` merged into `delete_forEveryone_fullDeletion_peerSeesDeleted` |
+| Delete | Delete received; received marked-deleted with Reveal/Hide, collapsed count and range select; received full delete | Menu | CIV:507-523, 958-983, 561-573 (Reveal), 484-486 (Hide), `C/views/chat/item/MarkedDeletedItemView.kt:48-111` | `delete_received_onlyForMe`, `markedDeleted_received_revealHide` | `delete_received_onlyForMe`: "Delete message?" offers only "Delete for me", because received items are never deletable for everyone (CIV:1402-1436; `deletable'`, `src/Simplex/Chat/Messages.hs:542-549`); the item disappears and bob prints nothing; `markedDeleted_received_revealHide`: after bob deletes "one" for everyone (`\@alice one`, `bob <## "message marked deleted"`) the item shows "marked deleted" without its text; after he deletes the next one, "two", the row reads "2 messages marked deleted" (MDV:69-78) while "keep" is unchanged; "Reveal" shows both texts, "Hide" collapses them again; "Select" on the collapsed row gives "Selected 2" (`selectUnselectChatItem` range, CV:3353-3366); after alice allows full deletion for bob (precondition through the API: `bob <## "alice updated preferences for you:"`, `bob <## "Full deletion: enabled for you (you allow: default (no), contact allows: always)"`), bob's broadcast delete of "three" (`bob <## "message deleted"`) removes it from alice's chat (`C/model/SimpleXAPI.kt:3131-3135`) | P | `delete_received_fullDelete_removed`, `markedDeleted_consecutive_collapsedCount` and §K `select_mergedEvents_selectsWholeRange` (on a deleted-items range) merged into `markedDeleted_received_revealHide`; the full-deletion preference is set through the API (`allowFullDeletionViaApi`), the preferences screen is owned by catalogue 01 §14 |
+| Display | Blocked by admin | bob (owner) runs `/block for all #team cath` (`Library/Commands.hs:6276`); cath sends one message, then another | MarkedDeletedItemView:48-111 (count :69-78); `C/model/ChatModel.kt:3485-3487` | | One blocked item reads "blocked by admin", two consecutive read "2 messages blocked by admin" (`testBlockForAllMarkedBlocked`) | P ×2 | `blockedByAdmin_items_showBlocked` dropped: both labels are asserted by 03 §14 `GroupLinksTest.memberInfo_blockForAllNotifiesMembers`; `markedDeleted_consecutive_collapsedCount` merged into `markedDeleted_received_revealHide` (direct chat, no group needed). Moderation itself is owned by catalogue 03 §14 (`00-legend.md`) |
 
-### K. Multi-select and selection toolbar (9 tests)
+### K. Multi-select and selection toolbar (3 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Select | Enter / toggle / leave selection mode | "Select"; click items; (x) | CIV:936, CV:3342, SEL:24-50 | `select_enterMode_showsCounterToolbar`, `select_toggle_updatesCounter`, `select_close_exitsMode` | `select_enterMode_showsCounterToolbar`: "Select" on an item selects it and the toolbar reads "Selected 1" (CV:1967, SEL:33-36); `select_toggle_updatesCounter`: clicking a second item gives "Selected 2", unselecting both gives "Nothing selected"; `select_close_exitsMode`: after (x) (SEL:30) the counter toolbar is gone and the chat toolbar ("bob") and the compose field are back (CV:298, 1170-1176) | P | Selection circles get keys in K2 |
-| Delete | Delete selection | Trash icon → "Delete %d messages?" | CV:327-347, SEL:95-101 | `selectDelete_forEveryone_peerSeesBoth`, `selectDelete_mixed_onlyForMe` | `selectDelete_forEveryone_peerSeesBoth`: `bob <# "alice> [marked deleted] hello"` and `… hey` (`testDirectMessageDeleteMultiple`); `selectDelete_mixed_onlyForMe`: with one of alice's and one of bob's messages selected, "Delete 2 messages?" warns "Messages will be deleted - this cannot be undone!" and offers only "Delete for me" (SEL:157; CV:330-339; CIV:1437-1448); both items disappear and bob prints nothing | P | |
-| Forward | Forward selection | Forward icon | CV:361-384 | `selectForward_multiple_peerReceives` | `testForwardContactToContactMulti` | P ×2 | |
-| Rules | Count limits; merged events; item deleted while selected | 300 messages; collapsed events | SEL:144-145, 130-172 | `select_limits_forward20_delete200`, `select_mergedEvents_selectsWholeRange`, `select_itemDeletedByPeer_recheck` | `select_limits_forward20_delete200`: forward disabled above 20, delete above 200; `select_mergedEvents_selectsWholeRange`: "Select" on a collapsed events row selects every event in it: the toolbar reads "Selected N" for the N collapsed events (`selectUnselectChatItem`, CV:3342-3372; SEL:36); `select_itemDeletedByPeer_recheck`: when bob deletes a selected message of his for everyone, it stays selected but the forward button becomes disabled (marked-deleted items can't be forwarded, SEL:161; recheck on item change, SEL:125-127) | P | Moderating a selection is owned by catalogue 03 §14 |
+| Select | Enter / toggle / leave selection mode | "Select"; click items; (x) | CIV:936, CV:2238-2243, CV:3345-3381, SEL:25-51, CV:1172-1178 | `select_toggle_updatesCounter` | "Select" on bob's "one" replaces the chat toolbar ("bob") with "Selected 1" and enables Delete (SEL:34-38); clicking items (received and sent) gives "Selected 2", "Selected 3", and unselecting them counts down to "Nothing selected" with Delete disabled (SEL:145); after (x) "Back" (SEL:31, `C/views/helpers/DefaultTopAppBar.kt:140-146`) the counter and the buttons toolbar are gone, the chat toolbar is back and all three messages are kept | P | `select_enterMode_showsCounterToolbar`, `select_close_exitsMode` merged into `select_toggle_updatesCounter`. "The compose field is back" is not observable: in selection mode SEL:82 composes a hidden measuring `ComposeView` with the same `chat.compose` key, so the buttons toolbar (`Ui.Chat.Selection.part("delete")`) is checked instead. Selection circles need no key: clicking the item toggles it |
+| Delete | Delete selection | Trash icon → "Delete %d messages?" | CV:325-349, SEL:97-104, SEL:159, CIV:1438-1463 | `selectDelete_forEveryone_peerSeesBoth` | With one of alice's and one of bob's messages selected, "Delete 2 messages?" warns "Messages will be deleted - this cannot be undone!" and offers only "Delete for me" (SEL:159; CV:330-335); both items disappear and bob prints nothing (his next lines are the later marked-deleted ones); with two of alice's messages selected it warns "Messages will be marked for deletion. The recipient(s) will be able to reveal these messages." and "For everyone" prints `bob <# "alice> [marked deleted] hi"` and `… bye` (`testDirectMessageDeleteMultiple`); alice sees them collapsed as "2 messages marked deleted" | P | `selectDelete_mixed_onlyForMe` merged into `selectDelete_forEveryone_peerSeesBoth` |
+| Forward | Forward selection | Forward icon | CV:361-384 | | `testForwardContactToContactMulti` | P ×2 | `selectForward_multiple_peerReceives` merged into §L `forwardPlan_filesNotAccepted_alertOptions` (a 4-item selection is forwarded to cath through the selection toolbar and cath prints the forwarded texts) |
+| Rules | Item deleted while selected | bob deletes a selected message | SEL:128-130, SEL:164 | `select_itemDeletedByPeer_recheck` | `select_itemDeletedByPeer_recheck`: with bob's "one" and alice's "mine" selected, Forward and Delete are enabled; when bob deletes "one" for everyone it stays selected ("Selected 2") but Forward becomes disabled while Delete stays enabled (marked-deleted items can't be forwarded, SEL:164; recheck on item change, SEL:128-130); unselecting "one" gives "Selected 1" with Forward enabled again | P | `select_mergedEvents_selectsWholeRange` merged into §J `markedDeleted_received_revealHide` (deleted-items range, the same CV:3353-3366 logic; the group-events variant stays with 03 §16 if wanted); `select_limits_forward20_delete200` dropped: 300 messages and 201 clicks (no select-all in the main chat) for two comparisons (SEL:145-146). Moderating a selection is owned by catalogue 03 §14 |
 
-### L. Forwarding (17 tests)
+### L. Forwarding (9 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Forward | Forward to a contact, with a comment | "Forward" → "Forward message…" list → pick cath → send | CV:638, ShareListView.kt:151, CMP:727-755 | `forward_contactToContact_peerSeesForwarded`, `forward_withComment_sendsCommentQuoted`, `forward_cancelContext` | `forward_contactToContact_peerSeesForwarded`: `cath <# "alice> -> forwarded"`, `cath <## "      hi"` (`testForwardContactToContact`); `forward_withComment_sendsCommentQuoted`: with a comment, cath then prints `cath <# "alice> >> hi"`, `cath <## "      <comment>"` (the comment quotes the last forwarded item, CMP:843-848); `forward_cancelContext`: "Cancel" (x) on the forwarding bar removes it (CMP:1266-1268); nothing is forwarded and cath prints nothing | P ×2 | |
-| Destinations | Contact→group, group→contact, group→group | Same | — | `forward_contactToGroup`, `forward_groupToContact`, `forward_groupToGroup` | `forward_contactToGroup`: `cath <# "#team alice> -> forwarded"`, `cath <## "      hi"` (`testForwardContactToGroup`, H/Forward.hs:205-227); `forward_groupToContact`: `cath <# "alice> -> forwarded"`, `cath <## "      hi"` (`testForwardGroupToContact`, :249-271); `forward_groupToGroup`: `cath <# "#club alice> -> forwarded"`, `cath <## "      hi"` (`testForwardGroupToGroup`, :273-299) | P ×2 | |
-| Destinations | To notes, notes→contact | Same | `C/views/chat/item/FramedItemView.kt:316-343` | `forward_toNotes_showsSavedFrom`, `forward_fromNotes_toContact` | To notes: the item shows a two-row header, "saved from" over "bob" (`testForwardContactToNotes`); from notes to cath: cath prints a plain `cath <# "alice> hi"` with no "-> forwarded" line (`testForwardNotesToContact`) | P | |
-| Source | Go to source; received forwarded header | Hover → arrow button; receive a forwarded message | CIV:284-302, `C/views/chat/item/FramedItemView.kt:345` | `forwarded_goToSource_opensOriginalChat`, `forwarded_received_showsHeader` | The arrow opens the chat with bob at the original item; the received item's header reads "forwarded" (`cath <# "alice> -> forwarded"` in `testForwardContactToContact`) | P ×2 | The arrow button gets a key in K2 |
-| Files | Forward a file | Forward a downloaded file | — | `forward_file_peerReceivesFile` | `testForwardFileContactToContact` | P ×2, XFTP | |
-| Plan | Undownloaded files; nothing to forward; Download button | Forward a selection with files not downloaded | CV:3695-3753, 3002 | `forwardPlan_filesNotAccepted_alertOptions`, `forwardPlan_nothingToForward`, `forwardPlan_downloadButton_receivesFiles` | "Forward %1$s message(s)?", "%1$d file(s) were not downloaded.", "Forward messages without files?", buttons "Forward" / "Download" / "Cancel"; "Nothing to forward!"; `forwardPlan_downloadButton_receivesFiles`: after "Download" no destination list opens and nothing is forwarded; the command log has `/freceive <fileId> …` for each file (CV:3014-3022; `C/model/SimpleXAPI.kt:2228-2241,4303`), and each file item's status (`FileStatusKey`, plan §4) becomes `rcvComplete` | P, XFTP | |
-| Rules | No Forward for deleted/live; items deleted after selection | — | CIV:470-478, CMP:747-752 | `forward_notOffered_forDeletedOrLive`, `forward_itemsDeletedAfterSelection_alert` | `forward_notOffered_forDeletedOrLive`: the menu of a marked-deleted item has no "Forward", and neither has any item's menu while alice's live message is in progress (CIV:124, 470-473); `forward_itemsDeletedAfterSelection_alert`: "%1$s messages not forwarded" | P | In the second test alice selects bob's messages, including his last one, clicks Forward and picks the destination; only then does bob delete them (a selected item that is already marked deleted turns the toolbar's Forward off, `C/views/chat/SelectableChatItemToolbars.kt:113,161,170`). alice sends once bob's chat-list row shows the marked-deleted preview (`C/views/chatlist/ChatPreviewView.kt:253`): the alert comes only when the core returns fewer items than were selected (CMP:747-752), i.e. after alice has processed bob's deletions |
-| Rules | Destination whose preferences prohibit the content | bob hosts group `team` with alice and runs `/set files #team off`; bob `/img @alice tests/fixtures/test.jpg`; alice waits until the image is received (auto-accepted; "Forward" is offered only for a loaded file, CIV:471, `C/model/ChatModel.kt:4610-4614`), then "Forward" on the image → pick "team" | `C/views/chatlist/ShareListView.kt:30-56`; `C/views/chatlist/ShareListNavLinkView.kt:43-58, 70-75` | `forward_destinationProhibitsContent_alert` | "team" is listed but disabled-looking; clicking it shows "Cannot send message" / "Selected chat preferences prohibit this message." (strings.xml:573-574); the group chat doesn't open and no forwarding bar appears; bob prints nothing in `#team` | P, XFTP | After bob's `/set files #team off` (CLI `Files and media: off`, `testProhibitFiles`, tests/ChatTests/Files.hs:1248-1259) alice's group gets a "Files and media: off" feature item; wait for it before forwarding. The same alert covers voice to a contact that prohibits voice and SimpleX links (also "Share via chat" of an address or channel link, which always counts as a SimpleX link, ShareListView.kt:54-56) to a group with "SimpleX links" off |
+| Forward | Forward to a contact, with a comment; cancel the forwarding bar; forward into a chat with a draft | "Forward" → "Forward message…" list → pick cath → send | CV:638-643, ShareListNavLinkView.kt:31-44, forwardItem CMP:729-757 (worktree) | `forward_contactToContact_peerSeesForwarded`, `forward_withComment_sendsCommentQuoted` | `forward_contactToContact_peerSeesForwarded`: `cath <# "alice> -> forwarded"`, `cath <## "      hi"` (`testForwardContactToContact`); `forward_withComment_sendsCommentQuoted`: "Cancel" (x) on the forwarding bar (CMP:1268-1270, the (x) is `described("Cancel")`, ContextItemView.kt:148-151) removes it and nothing is forwarded; alice leaves a draft in cath's chat, forwards again into it with a comment: the draft is hidden while the bar is shown (CV:154), cath's first lines are the forward `cath <# "alice> -> forwarded"`, `cath <## "      hi"` and then the comment `cath <# "alice> >> hi"`, `cath <## "      <comment>"` (the comment quotes the last forwarded item, CMP:845-855), and the draft is back in the compose field (CMP:997-999) | P ×2 | Tests: `forward_contactToContact_peerSeesForwarded`, `forward_withComment_sendsCommentQuoted` (`forward_cancelContext` and §S `draft_forwardIntoChatWithDraft_restoresDraftAfterSend` merged into it) |
+| Destinations | Contact→group, group→contact, notes→contact; go to source | Forward bob's message into own group `team`; forward cath's group message to bob and click its arrow; forward a note to bob | CMP:732-738; the arrow CIV:297-304 | `forward_acrossChatTypes_peersReceiveAndSourceOpens` | `cath <# "#team alice> -> forwarded"`, `cath <## "      hi"` (`testForwardContactToGroup`, H/Forward.hs:205-227); `bob <# "alice> -> forwarded"`, `bob <## "      hi"` (`testForwardGroupToContact`, :249-271); alice's forwarded item shows a one-row "forwarded" header without the group name; its arrow opens team at cath's original item; from notes bob prints a plain `bob <# "alice> memo"` with no "-> forwarded" line (`testForwardNotesToContact`, :334-345) | P ×2 | The arrow (CIV:297-304) is composed whenever the item has a source; hover (desktop) or tapping the bubble (Android, CIV:335-337) only changes how it looks. Key `Ui.Chat.Item(id).part("goTo")` Tests: `forward_acrossChatTypes_peersReceiveAndSourceOpens` (`forward_contactToGroup`, `forward_groupToContact`, `forward_fromNotes_toContact`, `forwarded_goToSource_opensOriginalChat` merged into it); `forward_groupToGroup` dropped (same app path, the difference is in the core, `testForwardGroupToGroup`) |
+| Destinations | To notes | Same | `C/views/chat/item/FramedItemView.kt:319-351` | `forward_toNotes_showsSavedFrom` | To notes: the item shows a two-row header, "saved from" over "bob" (`testForwardContactToNotes`) | P | Tests: `forward_toNotes_showsSavedFrom` (`forward_fromNotes_toContact` merged into `forward_acrossChatTypes_peersReceiveAndSourceOpens`) |
+| Source | Received forwarded header | Receive a forwarded message | `C/views/chat/item/FramedItemView.kt:348-350`, `C/model/ChatModel.kt:4220-4233` | `forwarded_received_showsHeader` | bob forwards cath's message to alice (`bob <# "@alice <- @cath"`, Forward.hs:414-417): alice's item has a one-row "forwarded" header that doesn't name cath and no go-to-source arrow (`CIFFUnknown`); bob's ordinary message has no header | P ×2 | Tests: `forwarded_received_showsHeader` (`forwarded_goToSource_opensOriginalChat` merged into `forward_acrossChatTypes_peersReceiveAndSourceOpens`) |
+| Files | Forward a file | Download the file from the plan alert, then "Forward" on it | CIV:475-483, `C/model/ChatModel.kt:4643-4647` |  | `cath <# "alice> -> forwarded"`, `cath <## "      notes_1.md"`, `cath <# "alice> sends file notes_1.md (…)"` and cath receives it (`testForwardFileContactToContact`; the core copies the file under a unique name, Commands.hs:1189) | P ×2, XFTP | Tests: `forward_file_peerReceivesFile` merged into `forwardPlan_downloadButton_receivesFiles` |
+| Plan | Undownloaded files; nothing to forward; Download button | Forward a selection with files not downloaded | CV:3698-3756 (alert), 3004-3051 (Download / Forward buttons) | `forwardPlan_filesNotAccepted_alertOptions`, `forwardPlan_downloadButton_receivesFiles` | "Forward %1$s message(s)?", "%1$d file(s) were not downloaded.", "Forward messages without files?", buttons "Forward" / "Download" / "Cancel"; with an undownloaded file without text the title counts only the forwardable items ("Forward 3 message(s)?" for 4 selected, core `hasContent`, Commands.hs:1085-1094); "Nothing to forward!" shows "Cancel" and "Download" and no "Forward"; `forwardPlan_downloadButton_receivesFiles`: after "Download" no destination list opens, the file item becomes `RcvComplete` and its menu now offers "Forward" | P ×2, XFTP | Keys `Ui.Alert.Option(Shared, "forward" | "download")` Tests: `forwardPlan_filesNotAccepted_alertOptions`, `forwardPlan_downloadButton_receivesFiles` (`forwardPlan_nothingToForward` merged into it) |
+| Rules | No Forward for deleted items; items deleted after selection | — | CIV:475-483, CMP:749-754 |  | The menu of a marked-deleted item has no "Forward", a live text message's has; "%1$s messages not forwarded" ("1 messages not forwarded") / "Messages were deleted after you selected them." | P ×2 | alice selects bob's messages, clicks Forward and picks the destination; only then does bob delete one (a selected item that is already marked deleted turns the toolbar's Forward off, `C/views/chat/SelectableChatItemToolbars.kt:113,161,170`). alice sends once bob's chat-list row shows the marked-deleted preview (`C/views/chatlist/ChatPreviewView.kt:253`): the alert comes only when the core returns fewer items than were selected (CMP:749-754). Suggest §C checks that the item menu has no "Forward" during a live message Tests: `forward_notOffered_forDeletedOrLive`: deleted half merged into `forwardPlan_downloadButton_receivesFiles`, live half dropped (live messages are owned by §C); `forward_itemsDeletedAfterSelection_alert` merged into `forwardPlan_filesNotAccepted_alertOptions` |
+| Rules | Destination whose preferences prohibit the content | bob hosts group `team` with alice; bob `/img @alice tests/fixtures/test.jpg`; alice waits until the image is received (auto-accepted; "Forward" is offered only for a loaded file, CIV:476, `C/model/ChatModel.kt:4643-4647`), forwards it to "team" and cancels; bob runs `/set files #team off`; "Forward" on the image → pick "team" | `C/views/chatlist/ShareListView.kt:30-58`; `C/views/chatlist/ShareListNavLinkView.kt:46-63, 75-80` | `forward_destinationProhibitsContent_alert` | While files are on, team opens with the forwarding bar; after `/set files #team off` clicking it shows "Cannot send message" / "Selected chat preferences prohibit this message." (strings.xml:574-575); the group chat doesn't open; the image can still go to Private notes; bob prints nothing in `#team` before alice's later message | P, XFTP | After bob's `/set files #team off` (CLI `Files and media: off`, `testProhibitFiles`, tests/ChatTests/Files.hs:1248-1259) alice's group gets a "Files and media: off" feature item; wait for it before forwarding. The same alert covers voice to a contact that prohibits voice and SimpleX links (also "Share via chat" of an address or channel link, which always counts as a SimpleX link, ShareListView.kt:54-56) to a group with "SimpleX links" off |
+| Destinations | Search the destination list (shown with 8 or more chats) | "Forward" → Search icon → type | ShareListView.kt:166-170, 198-202; ChatListView.kt:1584-1612 | `forward_searchDestinations_filtersList` | With 8 chats, typing "bob" leaves bob and the group "bobcats"; the groups "jobs" and "team" and Private notes disappear; picking "bobcats" opens it with the forwarding bar | P | Groups created via the API + restart, as ChatListToolbarSearchTest. Key `Ui.Share.Bar` (search field `Ui.Share.Bar.part("search")`) |
 
-### M. Reactions (8 tests)
+### M. Reactions (5 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Add/remove | Add from menu; click own chip to remove; click someone else's chip to add | Menu emoji row (👍 👎 😀 😂 😢 ❤ 🚀 ✅) | CIV:351-374, 194-200, CV:693 | `reaction_add_peerSeesAdded`, `reaction_chipClick_removes`, `reaction_chipClickOthers_adds`, `reaction_row_hidesAlreadyAdded` | `reaction_add_peerSeesAdded`: 👍 from the menu on bob's own "hi": `bob <# "alice> >> hi"` (the real CLI marks the peer's own message with `>>`, measured), `bob <## "    + 👍"` (`testSetMessageReactions`); `reaction_chipClick_removes`: clicking alice's own 👍 chip removes it: `bob <# "alice> > hi"`, `bob <## "    - 👍"`; `reaction_chipClickOthers_adds`: after bob reacts with `+1 alice hi`, clicking his "👍" chip adds alice's reaction: the chip shows "2" (CIV:194-200,227-234) and bob prints `bob <# "alice> > hi"`, `bob <## "    + 👍"` (H/Direct.hs:3336-3355); `reaction_row_hidesAlreadyAdded`: once alice has added 👍, the menu's emoji row no longer offers 👍 (CIV:351-358) | P, S | bob is started with `--reactions` (v7.0.3 has the same switch); without it he prints nothing (`src/Simplex/Chat/View.hs:985-987`) |
+| Add/remove | Add from menu; click own chip to remove; click someone else's chip to add | Menu emoji row (👍 👎 😀 😂 😢 ❤ 🚀 ✅) | CIV:351-374, 194-200, CV:693 | `reaction_add_peerSeesAdded`, `reaction_chipClickOthers_adds` | `reaction_add_peerSeesAdded`: 👍 from the menu on bob's own "hi": `bob <# "alice> >> hi"` (the real CLI marks the peer's own message with `>>`, measured), `bob <## "    + 👍"` (`testSetMessageReactions`); `reaction_chipClick_removes`: clicking alice's own 👍 chip removes it: `bob <# "alice> > hi"`, `bob <## "    - 👍"`; `reaction_chipClickOthers_adds`: after bob reacts with `+1 alice hi`, clicking his "👍" chip adds alice's reaction: the chip shows "2" (CIV:194-200,227-234) and bob prints `bob <# "alice> > hi"`, `bob <## "    + 👍"` (H/Direct.hs:3336-3355); `reaction_row_hidesAlreadyAdded`: once alice has added 👍, the menu's emoji row no longer offers 👍 (CIV:351-358) | P, S | bob is started with `--reactions` (v7.0.3 has the same switch); without it he prints nothing (`src/Simplex/Chat/View.hs:985-987`). `reaction_chipClick_removes` and `reaction_row_hidesAlreadyAdded` merged into `reaction_chipClickOthers_adds` (bob reacts first, alice adds by clicking his chip, then removes hers by clicking it again; the menu row is checked before, after adding and after removing) |
 | Receive | Received reaction count | alice reacts 👍 to her "hi", then bob `+1 alice hi` | CIV:228-236 | `reaction_received_chipCount` | Chip shows 👍 with count 2 after both react | P | |
-| Who reacted | Chip menu: direct names | Right-click the chip | CIV:158-207 | `reaction_chipMenu_direct_showsNames` | Contact name plus "you" | P | |
-| Who reacted | Chip menu: group members, click opens member info | Right-click the chip in a group | CIV:158-207 | `reaction_chipMenu_group_membersAndOpenInfo` | After bob and cath react 👍 to alice's message in #team, the menu lists "bob" and "cath" (CIV:168-169; `testSetGroupMessageReactions`); clicking "cath" opens cath's member info, where alice, the owner, sees "Change role" with "member" (`C/views/chat/group/GroupMemberInfoView.kt:607-611`) | P ×2 | |
+| Who reacted | Chip menu: direct names | Right-click the chip | CIV:158-207 | | Contact name plus "you" | P | `reaction_chipMenu_direct_showsNames` merged into `reaction_chipClickOthers_adds` (with the count at 2 the chip menu lists "bob" and "you", `Ui.Chat.ReactionMember`; clicking "bob" opens his contact info) |
+| Who reacted | Chip menu: group members, click opens member info | Right-click the chip in a group | CIV:158-207 | `reaction_chipMenu_group_membersAndOpenInfo` | After bob and cath react 👍 to alice's message in #team, the menu lists "bob" and "cath" (CIV:168-169; `testSetGroupMessageReactions`); clicking "cath" opens cath's member info, where alice, the owner, sees "Change role" with "member" (`C/views/chat/group/GroupMemberInfoView.kt:607-611`) | P ×2 | That cath's member info opened is shown by its "Block member?" alert naming her ("All new messages from cath will be hidden!"), which the test cancels |
 | Prefs | Reactions disabled in a direct chat | bob disallows reactions (`/_set prefs @<alice's contact id> {"reactions":{"allow":"no"}}`) | CIV:404 | `reaction_disabled_noMenuRow` | Once alice's "Contact preferences" show "Contact allows" "no" for "Message reactions" (the CLI prints before the change reaches alice: `updateContactPrefs` only queues `XInfo`, `Library/Commands.hs:4114-4127`, applied on receipt, `Library/Subscriber.hs:2793-2796`), the item menu in the chat with bob has no emoji row | P | Direct chat (contact preference); group reactions off is owned by catalogue 03 §5 |
 
-### N. Copy / Share / Save / text selection (9 tests)
+### N. Copy / Share / Save / text selection (5 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Copy | Copy text | "Copy" | CIV:444-449, CIVD (copyItemToClipboard) | `copy_text_toClipboardAndToast` | Clipboard content; toast "Copied to clipboard" | P, CB, TOAST | |
-| Copy | Copy a file item (copies its path) | "Copy" | CIVD (copyItemToClipboard) | `copy_fileItem_copiesPath` | Clipboard has the file path; toast "Copied to clipboard" | P, XFTP, CB, TOAST | |
-| Share | Share text | "Share" | CIV:425-443, SHR:20-23 | `share_text_copiesToClipboard` | Clipboard has the text | P, CB | |
-| Share | Share a file | "Share" | CIV:425-443, SHR:24-42 | `share_file_savesViaDialog` | Save dialog; toast "File saved" | P, XFTP, FD, TOAST | |
-| Save | Save image; save encrypted file | "Save" | CIVD (SaveContentItemAction) | `save_image_writesFile`, `save_encryptedFile_decrypts` | Bytes equal the source | P, XFTP, FD | |
-| Rules | Copy/Share hidden without content | — | CIV:419-423 | `copyShare_hidden_whenNoContent` | The menu of a received file with no text that isn't downloaded has no "Copy" and no "Share"; after download both appear | P, XFTP | |
-| Selection | Drag-select across messages, then the Copy button or Ctrl+C | Mouse drag | TSEL:354, 528-551 | `textSelection_dragAcrossItems_copyButton`, `textSelection_ctrlC_copies` | Clipboard has the selected text | P, CB | `performMouseInput` drags from inside the first keyed item node's bounds to inside the last one's (positions taken from the nodes, not fixed coordinates) |
+| Copy | Copy text | "Copy" | CIV:444-449, CIVD (copyItemToClipboard) | `copy_text_toClipboardAndToast` | Clipboard content; toast "Copied to clipboard" | P, CB, TOAST | Desktop `CopyShareDesktopTest` (toasts are read from `simplexWindowState.toasts`, which the test window does not draw); Android copy is `copyAndroid_text_noToast` (05) |
+| Copy | Copy a file item (copies its path) | "Copy" | CIVD (copyItemToClipboard) | `copy_fileItem_copiesPath` | Clipboard has the file path; toast "Copied to clipboard" | P, XFTP, CB, TOAST | Desktop `CopyShareDesktopTest`: the copied path names a decrypted copy whose text equals bob's file |
+| Share | Share text | "Share" | CIV:425-443, SHR:20-23 | | Clipboard has the text | P, CB | `share_text_copiesToClipboard` merged into `copy_text_toClipboardAndToast` (desktop `CopyShareDesktopTest`; Android shares through an intent) |
+| Share | Share a file | "Share" | CIV:425-443, SHR:24-42 | | Save dialog; toast "File saved" | P, XFTP, FD, TOAST | `share_file_savesViaDialog` merged into `copy_fileItem_copiesPath` (desktop `CopyShareDesktopTest`) |
+| Save | Save image; save encrypted file | "Save" | CIVD (SaveContentItemAction) | `save_encryptedFile_decrypts` | Bytes equal the source | P, XFTP, FD | Shared, through the chooser (desktop save dialog, Android `ACTION_CREATE_DOCUMENT`). `save_image_writesFile` deferred: on desktop images are saved by the same `SaveContentItemAction` branch as files (`D/views/chat/item/ChatItemView.desktop.kt:39`), and on Android an image is saved to the gallery (`saveImage`, `A/views/chat/item/ChatItemView.android.kt:34-40`), not through a chooser the harness answers |
+| Rules | Copy/Share hidden without content | — | CIV:419-423 | | The menu of a received file with no text that isn't downloaded has no "Copy" and no "Share"; after download both appear | P, XFTP | `copyShare_hidden_whenNoContent` merged into `save_encryptedFile_decrypts` (the menu is checked before and after the download) |
+| Selection | Drag-select across messages, then the Copy button or Ctrl+C | Mouse drag | TSEL:216-229, 352-361, 548-575 | `textSelection_dragAcrossItems_copyButton`, `textSelection_ctrlC_copies` | `textSelection_dragAcrossItems_copyButton`: a drag from bob's first message to his third shows the selection Copy button and leaves the clipboard unchanged; the button puts exactly the three texts, oldest first and joined by line breaks, on the clipboard (the fourth and fifth messages stay out) and hides itself; `textSelection_ctrlC_copies`: a drag that starts in the compose field selects nothing (no Copy button, Ctrl+C leaves the clipboard unchanged); a drag across one message shows the Copy button and Ctrl+C copies exactly that text; a click on another message clears the selection, after which Ctrl+C copies nothing | P, CB | Desktop `TextSelectionDesktopTest` (selection exists only on desktop, CV:168). `drag` presses inside the top-left corner of the first node and releases inside the bottom-right corner of the last, in steps with frames between them, so the first and last messages are selected whole. The Copy button has the key `Ui.Chat.TextSelectionCopy` |
 
-### O. Reports, member side (7 tests)
+### O. Reports, member side (2 tests)
 Here the GUI user **alice** is a plain member who reports; bob (CLI) is the owner, cath (CLI) a moderator and dan (CLI) a plain member whose message is reported. This is `testGroupMemberReports` with the roles rewritten (there alice is the owner, bob the moderator, cath the author and dan the reporter). The moderator side (reports bar, reports view, archive, delete) is owned by catalogue 03 §13 (`00-legend.md`).
 
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Send report | Report a message as a member | "Report" → "Report reason?" → "Spam" → header "Report spam: only group moderators will see it." → check button | CIV:493-495, 999-1042, CMP:1238, 788-804 | `report_member_spam_moderatorsReceive`, `report_reasons_allListed`, `report_sentAlert_dontShowAgain`, `report_cancelReason` | `report_member_spam_moderatorsReceive`: `bob <# "#jokes (support: alice) alice> > dan inappropriate joke"`, `bob <## "      report spam"`, and the same two lines on cath; `report_reasons_allListed`: "Report reason?" lists "Spam", "Inappropriate content", "Community guidelines violation", "Inappropriate profile", "Another reason"; `report_sentAlert_dontShowAgain`: alert "Report sent to moderators" with "Don't show again" (`testGroupMemberReports`); `report_cancelReason`: "Cancel" in "Report reason?" closes it with no report bar in compose (CIV:1031-1035); bob and cath print nothing | P ×3 | |
-| Visibility | Report not shown to other members | alice reports dan's message | CIV:493-495 | `report_notVisibleToOtherMembers` | Owner bob and moderator cath print the report line; dan prints nothing for it (`testGroupMemberReports`, `cath </`) | P ×3 | |
-| Rules | Not offered to moderators / own messages; group preference off | — | CIV:493 | `report_notOffered_forModeratorOrOwn`, `report_groupPrefOff_notOffered` | No "Report" in the menu | P ×3 | For the moderator case bob makes alice a moderator first (`/mr jokes alice moderator`) and alice opens the menu once her chat shows the event "changed your role to moderator"; for the preference case bob runs `/set reports #jokes off` and alice opens the menu once her "Group preferences" show "Member reports" "off" (the CLI prints both when they are queued: `APIMembersRole`, `Library/Commands.hs:2947`, and `sendGroupMessage … XGrpInfo`, :4156; alice applies them on receipt, `Library/Subscriber.hs:1111,1119`) |
+| Send report | Report a message as a member | "Report" → "Report reason?" → a reason → compose header → check button; "Cancel" | CIV:493-500, 1011-1051; CMP:164-172, 791-807, 866-867, 1241-1256; SMV:139-141 | `report_member_spam_moderatorsReceive` | bob (CLI) hosts `team`; alice and cath (CLI) are plain members; cath wrote the reported message. "Report reason?" lists "Spam", "Inappropriate content", "Community guidelines violation", "Inappropriate profile", "Another reason" and "Cancel"; "Cancel" closes it with no report header in compose and nothing sent (bob's next lines are the first report). For each reason the compose header ("Report spam: …", "Report violation: …", "Report member profile: …", "Report other: …", "Report content: …" + "only group moderators will see it.") and bob's `#team (support: alice) alice> > cath inappropriate joke` followed by `      report spam` (`report community`, `report profile`, `report other: fake giveaway`, `report content`); the check button is enabled with an empty field, except for "Another reason", which needs a comment. Alert "Report sent to moderators" / "You can view your reports in Chat with admins." after the first report ("OK"), again after the second ("Don't show again"), and not after the third. After the reports alice's next message is the next line on both bob and cath (cath never printed a report) (`testGroupMemberReports`) | P ×2 | `report_reasons_allListed`, `report_sentAlert_dontShowAgain`, `report_cancelReason` merged into `report_member_spam_moderatorsReceive`. `@KnownAppIssue("15.5 item NEW")`: the apps send "Inappropriate content" as `reason=illegal` (C/model/ChatModel.kt:5452-5461, `/_report` C/model/SimpleXAPI.kt:4237), which the core parses as an unknown reason (`Protocol.hs:287-302` knows `content`), so the CLI prints `report illegal`; the content report is sent last, after every other check |
+| Visibility | Report not shown to other members | alice reports cath's message | CIV:493-500 | | Owner bob prints the report lines; cath, the author and a plain member, prints alice's later message as her next line (`testGroupMemberReports`, `cath </`) | P ×2 | `report_notVisibleToOtherMembers` merged into `report_member_spam_moderatorsReceive` |
+| Rules | Not offered to moderators / own messages; group preference off | — | CIV:493-500; C/model/ChatModel.kt:3512-3527 | `report_notOffered_forOwnModeratorOrPrefOff` | alice is a plain member of bob's (CLI host) group: "Report" is in the menu of bob's message and not in the menu of her own; not offered after `/set reports #team off` (bob prints `Member reports: off`), offered again after `/set reports #team on`; after `/mr team alice moderator` the owner's message offers neither "Report" nor "Moderate" (`memberToModerate`: the owner's role is higher) | P | `report_notOffered_forModeratorOrOwn` renamed to `report_notOffered_forOwnModeratorOrPrefOff`; `report_groupPrefOff_notOffered` and `moderate_notOfferedForHigherRole` (03 §14) merged into `report_notOffered_forOwnModeratorOrPrefOff`. alice opens each menu once her model shows the new preference or role (`APIMembersRole`, `Library/Commands.hs:2947`; `XGrpInfo`, :4156; applied on receipt, `Library/Subscriber.hs:1111,1119`); each menu is closed through "Select" and Back |
 
-### P. Chat item info (15 tests)
+### P. Chat item info (10 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Details | Sent / received details | "Info" | CV:714-757, INFO:254-317 | `info_sent_showsSentAt`, `info_received_showsReceivedAt` | "Sent message", "Sent at", "Received message", "Received at" (CLI equivalent: `/_get item info` in `testDirectMessageEditHistory`) | P | |
+| Details | Sent / received / deleted details | "Info" on alice's message, on bob's, and on bob's after he deletes it (`\@alice theirs`) | CV:714-757, INFO:257-271 | `info_sent_showsSentAt` | Sent: "Sent message", "Sent at" = `localTimestamp(itemTs)`, no "Received at"/"Deleted at"; received: "Received message", "Sent at" = `localTimestamp(itemTs)`, "Received at" = `localTimestamp(createdAt)`, no "Deleted at"; marked deleted: "Deleted at" = `localTimestamp(deletedTs)` (CLI equivalent: `/_get item info` in `testDirectMessageEditHistory`) | P | `info_received_showsReceivedAt` and `info_deleted_showsDeletedAt` (row "Rows") merged into `info_sent_showsSentAt` |
 | Details | Developer rows | "Info" with developer tools on | INFO:254-317 | `info_devTools_showsDbIdAndStatuses` | "Database ID", "Message status", "File status" | P, XFTP, DT | The item is a received file (bob `/f`), so "File status" is shown (INFO:301-303) |
-| History | Edit history | "Info" (history is shown directly; "History" is a tab only when there are two or more tabs) | INFO:319-342 | `info_history_listsVersions` | The history lists every version, newest first, the newest marked "(current)" (`item_info_current`, ChatItemInfoView.kt:103-108; `current_version_timestamp` is only in the shared text, :633-634); an unedited message shows one version (Library/Commands.hs:733) | P | |
+| History | Edit history | "Info" (history is shown directly; "History" is a tab only when there are two or more tabs) | INFO:319-343 | | The history lists every version, newest first, the newest marked "(current)" (`item_info_current`, ChatItemInfoView.kt:105-110; `current_version_timestamp` is only in the shared text, :633-634); an unedited message shows one version (Library/Commands.hs:733) | P | `info_history_listsVersions` merged into §I `edit_menu_updatesPeer` (one version before the edit, two after) |
 | History | Copy a history version | Right-click a version | INFO:319-342 | `info_historyBubble_copy` | Clipboard has the version text | P, CB | |
-| Delivery | Group delivery statuses | "Delivery" tab | INFO:374-445 | `info_delivery_groupMemberStatuses` | The "Delivery" tab lists bob and cath with their status icons (`testSendGroupDeliveryReceipts`) | P ×2 | An empty status list is `Nothing` (Library/Commands.hs:735), and then there is no "Delivery" tab at all (INFO:505-507), so "No delivery information" can't appear |
-| Delivery | Live update on receipts | cath is stopped; alice sends "hi" in #team; once its status is delivered-partial (bob's receipt), she right-clicks it > "Info" > "Delivery"; then cath is started | INFO:374-445, CV:739-751 | `info_delivery_liveUpdatesOnReceipt` | The tab shows bob delivered and cath sent; after the start, `cath <# "#team alice> hi"` and cath's status turns delivered without reopening the modal (`testSendGroupDeliveryReceipts`) | P ×2, PEERCTL | The open modal reloads only on `ChatItemsStatusesUpdated` events for the item that arrive while it is open (CV:739-751); with both peers online the receipts arrive within milliseconds, before the modal can open, so cath is stopped before the send to hold her sent state (as `status_group_partialThenComplete`) |
-| Tabs | Quote, forwarded, saved | "In reply to", "Forwarded", "Saved" tabs | INFO:344-372 | `info_quoteTab_showsQuoted`, `info_forwardedTab_showsSource`, `info_notes_savedTab` | Quote tab: heading "In reply to" and the quoted message (INFO:349); forwarded tab: heading "Forwarded from" and the source item; in notes the tab is "Saved", with heading "Saved from" (INFO:365) | P | |
-| Rows | Disappears at, deleted at, moderated at | — | INFO:264-276 | `info_timed_showsDisappearsAt`, `info_deleted_showsDeletedAt`, `info_moderated_showsModeratedAt` | "Disappears at", "Deleted at", "Moderated at" | P | |
-| Misc | Share button | Share button | CV:731-734 | `info_share_copiesText` | Clipboard has the info text | P, CB | |
-| Misc | Closes on chat switch | Open another chat | CV:753 | `info_closesOnChatSwitch` | The info modal closes | P | |
+| Delivery | Group delivery recipients | "Info" on a direct message, then on alice's message in #team | INFO:377-424, 469-511 | `info_delivery_listsGroupMembers` | The direct message's info has no "Delivery" tab; the group message's info opens on the "Delivery" tab with rows (`Ui.ItemInfo.Member`) for bob and cath (`testSendGroupDeliveryReceipts`) | P ×2 | An empty status list is `Nothing` (Library/Commands.hs:735), and then there is no "Delivery" tab at all (INFO:505-507), so "No delivery information" can't appear. The per-member status (the status icons' content descriptions, INFO:418, 564-568) is asserted in `info_delivery_liveUpdatesOnReceipt`. `info_delivery_groupMemberStatuses` renamed to `info_delivery_listsGroupMembers` |
+| Delivery | Live update on receipts | cath is stopped; alice sends "hi" in #team; once its status is delivered-partial (bob's receipt), she right-clicks it > "Info" > "Delivery"; then cath is started | INFO:374-445, 564-568, CV:739-751 | `info_delivery_liveUpdatesOnReceipt` | The tab shows bob "received" and cath "sent" (the status icons' content descriptions: `icon_descr_sent_msg_status_rcvd` / `icon_descr_sent_msg_status_sent`, INFO:418, 564-568); after the start, `cath <# "#team alice> hi"` and cath's status turns "received" without reopening the modal (`testSendGroupDeliveryReceipts`). Fails if the open modal stops reloading on `ChatItemsStatusesUpdated` (CV:746) | P ×2, PEERCTL | The open modal reloads only on `ChatItemsStatusesUpdated` events for the item that arrive while it is open (CV:739-751); with both peers online the receipts arrive within milliseconds, before the modal can open, so cath is stopped before the send to hold her sent state (as `status_group_partialThenComplete`) |
+| Tabs | Quote, forwarded, saved | "In reply to", "Forwarded", "Saved" tabs (the tab icons' content descriptions) | INFO:132-168, 215-235, 453-460, 511-520 | `info_quoteTab_showsQuoted`, `info_forwardedTab_showsSource` | `info_quoteTab_showsQuoted`: the info of a message without a quote has no "In reply to" tab; the info of alice's reply opens on the history, and the "In reply to" tab shows the heading "In reply to" and bob's quoted "question" (`Ui.ItemInfo.Quote`, INFO:139); `info_forwardedTab_showsSource`: bob's "hi" forwarded into alice's #team: its info has the "Forwarded" tab with the heading "Forwarded from", bob as the source (`Ui.ItemInfo.ForwardedFrom`) and "Recipient(s) can't see who this message is from."; clicking the source opens bob's chat and closes the info (INFO:217-224); forwarded into Private notes, the info ("Saved message") has the "Saved" tab with "Saved from" and bob, without the recipients line (INFO:230-233, 368) | P | `info_notes_savedTab` merged into `info_forwardedTab_showsSource` |
+| Rows | Disappears at, deleted at, moderated at | — | INFO:259-290 | `info_timed_showsDisappearsAt`, `info_moderated_showsModeratedAt` | `info_timed_showsDisappearsAt`: a message without a timer has no "Disappears at"; "timed", sent with "Disappearing message" → "5 minutes" (`SendTimed.option(300)`), shows "Disappears at" = `localTimestamp(deleteAt)` (INFO:281); `info_moderated_showsModeratedAt`: bob's "spam" in alice's #team has no "Moderated at" or "Deleted at"; after alice moderates it (`bob <# "#team bob> [marked deleted by alice] spam"`) its info shows "Moderated at" = `localTimestamp(deletedTs)` (INFO:274) and no "Deleted at" | P | `info_deleted_showsDeletedAt` merged into `info_sent_showsSentAt` |
+| Misc | Share button | Share button (`Ui.ItemInfo.Share`) | CV:733-737, INFO:578-650, SHR:20-23 | `info_share_copiesText` | Desktop (`ItemInfoDesktopTest`): the clipboard gets the info text of alice's reply: "# Sent message", "Sent at: <itemTs>", the "## In reply to" section with bob's "question" and the "## History" section ending with "<ts> (current)" / "answer" | P, CB | Desktop only: Android shares through an intent. `info_closesOnChatSwitch` merged into `info_share_copiesText` |
+| Misc | Closes on chat switch | Open another chat | CV:755-757 | | The info closes when alice opens Private notes from the chat list (`KeyChangeEffect(chatModel.chatId.value)`, CV:755) | P | `info_closesOnChatSwitch` merged into `info_share_copiesText` (desktop: the list stays visible next to the info) |
 
-### Q. Unread handling, scrolling, pagination (18 tests)
+### Q. Unread handling, scrolling, pagination (12 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Unread | Opens at first unread; marked read after it is visible; not marked behind compose; unread flag cleared on open | CLI sends 30 messages while another chat is open | CV:1842-1869, 3073-3096, 3483 | `unread_openChat_scrollsToFirstUnread`, `unread_visibleItems_markedReadAfterDelay`, `unread_itemsHiddenBehindCompose_notMarked`, `unreadChatFlag_clearedOnOpen` | `unread_openChat_scrollsToFirstUnread`: the chat opens at the first of the 30 unread messages, not at the newest (CV:1842-1869); `unread_visibleItems_markedReadAfterDelay`: messages in view are marked read 600 ms after they appear and the chat's unread count drops by them (CV:3073-3096; `testMarkReadDirect`); `unread_itemsHiddenBehindCompose_notMarked`: an unread message that lies wholly behind the compose bar is not marked read, and the unread count still includes it after 600 ms (CV:3082-3090); `unreadChatFlag_clearedOnOpen`: a chat marked with "Mark unread" loses the unread flag when opened (`markUnreadChatAsRead`, CV:187,3483-3500; `testAddContact` `/_unread`) | P | Mark-read waits 600 ms |
-| Scroll buttons | Top unread button; right-click "Mark read"; bottom counter / arrow | Click / right-click | CV:2574-2736, 3255-3303 | `unreadFab_top_click_scrollsToOldestUnread`, `unreadFab_top_rightClick_markRead`, `bottomFab_counter_scrollsToBottom`, `bottomFab_arrow_whenScrolledUp` | `unreadFab_top_click_scrollsToOldestUnread`: the top button shows the count of unread items above the view; a click makes the oldest unread item visible at the top (CV:2600-2624, 2697-2716); `unreadFab_top_rightClick_markRead`: "Mark read"; unread count goes to 0; `bottomFab_counter_scrollsToBottom`: the bottom button shows the count of unread items below the view, and a click makes the last item visible (CV:2594-2598, 2628-2645, 3265-3282); `bottomFab_arrow_whenScrolledUp`: scrolled up with nothing unread below, the bottom button shows the arrow and no count, and a click makes the last item visible (CV:2647-2652, 3283-3298) | P | Scroll buttons get keys in K2 |
-| New messages | Auto-scroll at bottom; keep position when scrolled up | CLI sends | CV:2518-2551 | `newMessage_atBottom_autoScrolls`, `newMessage_scrolledUp_keepsPosition` | At the bottom, the new item becomes the last visible item (the list scrolls to index 0, CV:2534-2535); when scrolled up, the same items stay in view, shifted by only 39 dp (CV:2519, 2537) | P | |
-| Pagination | Older messages on scroll up; banner at top; newer after a jump; initial page around first unread | 300-message batch | CV:2739-2830 | `pagination_scrollUp_loadsOlder`, `pagination_reachTop_showsBanner`, `pagination_afterAround_scrollDownLoadsNewer`, `pagination_initial_aroundFirstUnread` | `pagination_scrollUp_loadsOlder`: with all 300 marked read first (row menu "Mark read"; unread chats open around the first unread item, `ChatListNavLinkView.kt:230`, H/Direct.hs:400-403), the chat opens with the newest 100 messages loaded (`INITIAL_COUNT` on desktop, `C/model/SimpleXAPI.kt:4609`); scrolling up loads older pages of 100 (`PRELOAD_COUNT`, :4610; CV:2779-2812) until "1"; `pagination_reachTop_showsBanner`: once the oldest message is loaded the chat banner (contact name, "Your contact") shows above it (the core's chat-banner item, CV:2402-2411); `pagination_afterAround_scrollDownLoadsNewer`: after a jump that loads the chat around an old message (CV:3158-3172), scrolling down loads newer pages (`ChatPagination.After`, CV:2814-2828) until "300" is shown; `pagination_initial_aroundFirstUnread`: with "1"–"150" marked read through the core before the chat is opened (`/_read chat items @<bob's contact id> <id1>,<id2>,…` in the console, as `H/Direct.hs:406-407`, parser `Library/Commands.hs:6134`; no GUI action marks exactly that range), the chat opens with "151", the first unread message, in view and "1" not loaded (the core's initial page is the area around the first unread, `testChatPaginationInitial` H/Direct.hs:403) | P | |
+| Unread | Opens at first unread; marked read after it is visible; not marked behind compose; unread flag cleared on open | CLI sends 60 messages while no chat is open | CV:189, 1853-1874, 3081-3102, 3491 | `unread_openChat_scrollsToFirstUnread`, `unread_itemsHiddenBehindCompose_notMarked`, `unreadChatFlag_clearedOnOpen` | `unread_openChat_scrollsToFirstUnread`: with bob's 60 unread messages "m1"–"m60" (row badge "60"), the chat opens with "m1" in view and "m60" neither shown nor read (CV:1853-1874); "m1" is marked read after it is visible, and the row badge and the scroll-down button then show the same count N, 0 < N < 60 (CV:3081-3102); the scroll-down button (with the count) makes "m60" visible and read, the messages skipped by the scroll stay unread and the row and the scroll-up button show their count (CV:2635-2652, 2705-2707); right-click / long-press on the scroll-up button → "Mark read" clears every count (CV:2711-2740); `unread_itemsHiddenBehindCompose_notMarked`: an unread message that lies wholly behind the compose bar is not marked read, and the unread count still includes it after 600 ms (CV:3088-3096); `unreadChatFlag_clearedOnOpen`: the notes folder marked with "Mark unread" (empty badge on the row) loses the mark when opened, and the mark is still gone after a restart (`markUnreadChatAsRead`, CV:189, 3491-3508; `testAddContact` `/_unread`) | P, RESTART | `unread_visibleItems_markedReadAfterDelay` merged into `unread_openChat_scrollsToFirstUnread`. `unread_itemsHiddenBehindCompose_notMarked` not written: it needs an item placed behind the compose bar, which the harness cannot do without coordinates |
+| Scroll buttons | Top unread button; right-click "Mark read"; bottom counter / arrow | Click / right-click | CV:2581-2740, 3263-3310 | `unreadFab_top_click_scrollsToOldestUnread` | `unreadFab_top_click_scrollsToOldestUnread`: the top button shows the count of unread items above the view; a click makes the oldest unread item visible at the top (CV:2606-2630, 2717-2729) | P | `unreadFab_top_rightClick_markRead` and `bottomFab_counter_scrollsToBottom` merged into `unread_openChat_scrollsToFirstUnread`; `bottomFab_arrow_whenScrolledUp` merged into `pagination_quoteOutsidePage_jumpLoadsOriginal`. `unreadFab_top_click_scrollsToOldestUnread` not written: the button reacts to press/release interactions observed by composition (`interactionSourceWithDetection`, GestureDetector.kt:217-247), and a synthetic tap emits both before a recomposition, so the harness click cannot be relied on |
+| New messages | Auto-scroll at bottom; keep position when scrolled up | CLI sends | CV:2525-2558 | | At the bottom, the new item becomes visible (CV:2542-2543); when scrolled up, the item in view stays in view and the scroll-down button counts the new message (CV:2544-2545) | P | `newMessage_atBottom_autoScrolls` and `newMessage_scrolledUp_keepsPosition` merged into `pagination_quoteOutsidePage_jumpLoadsOriginal` |
+| Pagination | Older messages on scroll up; banner at top; newer after a jump; initial page around first unread; jump to a quoted message outside the loaded page | 120–300-message batch | CV:2739-2830, 3147-3196 | `pagination_quoteOutsidePage_jumpLoadsOriginal`, `pagination_scrollUp_loadsOlder`, `pagination_afterAround_scrollDownLoadsNewer`, `pagination_initial_aroundFirstUnread` | `pagination_quoteOutsidePage_jumpLoadsOriginal`: alice's "the original", 120 messages from bob and bob's reply quoting it; with the chat marked read (row menu) it opens with the newest page, without "the original" (`INITIAL_COUNT`, `C/model/SimpleXAPI.kt:4681`); clicking the quote loads the page around it and scrolls to it (CV:3147-3196), and the scroll-down button shows the arrow without a count (CV:2654-2659, 3290-3305); a new message from bob keeps "the original" in view and the button counts 1 (CV:2544-2545); the button scrolls to the new message, which is read; the next message from bob scrolls into view by itself (CV:2542-2543); `pagination_scrollUp_loadsOlder`: 300 messages "p1"–"p300" sent by alice through the API (`sendTextsViaApi`, a precondition; own messages are never unread, so the chat opens on the newest page); the chat opens with exactly the newest `INITIAL_COUNT` (100 on desktop, 75 on Android, `C/model/SimpleXAPI.kt:4681`) and no chat banner; scrolling up (`scrollChatTowardOlder`) loads older pages of 100 (`PRELOAD_COUNT`, CV:2787-2818) until the chat banner ("Your contact", the core's chat-banner item, CV:2409) shows, and then "p1"–"p300" are all loaded, in order. Fails if `ChatPagination.Before` is not requested (CV:2810); `pagination_afterAround_scrollDownLoadsNewer`: alice's "the original", then 360 messages "n1"–"n360" and a reply quoting "the original" sent through the API; clicking the quote loads 200 messages after it (`Around`, CV:3164-3178), leaving a gap between "n200" and the newest page; scrolling down (`scrollChatTowardNewer`) loads "n201" before "n200" comes into view (`ChatPagination.After`, CV:2822-2837), and by the time "far reply" is in view all 360 are loaded, in order. Fails if `ChatPagination.After` is not requested (CV:2836): the gap is then filled only from the newest page once "n200" is already in view; `pagination_initial_aroundFirstUnread`: with "1"–"150" marked read through the core before the chat is opened (`/_read chat items @<bob's contact id> <id1>,<id2>,…` in the console, as `H/Direct.hs:406-407`, parser `Library/Commands.hs:6134`; no GUI action marks exactly that range), the chat opens with "151", the first unread message, in view and "1" not loaded (the core's initial page is the area around the first unread, `testChatPaginationInitial` H/Direct.hs:403) | P | `pagination_reachTop_showsBanner` merged into `pagination_scrollUp_loadsOlder`. The scroll helpers use the list's `ScrollBy` semantics action (positive = toward older in the reversed chat list) and fail if an item moves the other way |
 | Dates | Date separators; floating date while scrolling | — | CV:3061, 2894 | `dateSeparator_betweenDays`, `floatingDate_whileScrolling` | `dateSeparator_betweenDays`: the separator shows the backdated day's date (`getTimestampDateText`, ChatModel.kt:3944; it appears only where an item's date differs from the previous one's, CV:3770). `floatingDate_whileScrolling`: the floating date shows while scrolling over the backdated items (it appears only when their date differs from today's, CV:2943-2945) | P, RESTART, FIXTURE (backdated items), REALTIME | Between two `restart()` steps, some received items are backdated by a day in the GUI database. Runs with `uiTest(realTimes = true)` (plan §7.7): the fixed display clock would put every item on one date |
-| Groups | Avatar shown once per run; click avatar opens member info | — | CV:2026-2103, 3787 | `groupRcv_consecutiveMessages_avatarOnce`, `groupRcv_avatarClick_opensMemberInfo` | Only the first item in a run of bob's consecutive messages shows bob's avatar and name (CV:2026-2030, 3787); a click on the avatar opens bob's member info | P | |
+| Groups | Avatar shown once per run; click avatar opens member info | — | CV:2026-2103, 3787 | `groupRcv_consecutiveMessages_avatarOnce`, `groupRcv_avatarClick_opensMemberInfo` | Only the first item in a run of bob's consecutive messages shows bob's avatar and name (CV:2026-2030, 3787); a click on cath's avatar opens cath's member info, shown by its "Block member for all?" alert naming cath and not bob (CV:2095) | P | |
 
-### R. Search and content filters (11 tests)
+### R. Search and content filters (6 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Search | Search in direct / group; go to a result; close search | ⋮ "Search"; result arrow | CV:279-290, 800-812, CIV:286-292 | `search_direct_filtersResults`, `search_group_filtersResults`, `search_goToResult_opensAroundItem`, `search_close_restoresAll` | `search_direct_filtersResults`: the chat shows only the matching items: the items matching "ello ther", as in `testAddContact` (whose `/_get chat @2 count=100 search=ello ther` uses the test client's id; the oracle is the item list, not a command run here); `search_group_filtersResults`: in #team with "hello", "hi there" and "hey team", searching "team" leaves only "hey team" (H/Groups.hs:499); `search_goToResult_opensAroundItem`: the search button on a result closes the search field and shows the item with its non-matching neighbours (CIV:286-291; CV:1834-1838; `ChatPagination.Around`, `C/views/chatlist/ChatListNavLinkView.kt:227-228`); `search_close_restoresAll`: closing the search shows all items again, the non-matching ones included (CV:800-812) | P | |
-| Search | Search in notes | Notes: search icon | CV:279-290, 800-812 | `search_notes_filtersResults` | With the notes "keep in mind" and "ahoy!", searching "keep" leaves "keep in mind" and hides "ahoy!" (`testNotes`) | — | |
-| Filter | Content filter menu, files, images, reset | Gallery icon → "Images" / "Videos" / "Voice messages" / "Files" / "All messages" | CV:1339-1354, 1475-1531, 856, 3973 | `contentFilter_menu_listsAvailableTypes`, `contentFilter_files`, `contentFilter_images`, `contentFilter_allMessages_resets` | The menu lists the types present in the chat plus "Images" and "Links" (always shown); "All messages" appears only while a filter is active. With bob's text "received", the file message "hi, sending a file" (test.jpg sent as a file, `runTestMessageWithFile`) and an image, "Files" leaves only the file message, "Images" only the image, and "All messages" shows all three again | P, XFTP | The gallery icon gets a key in K2 |
-| Filter | Links filter; filter with search text | Gallery icon → "Links" | CV:1339-1354, 3973 | `contentFilter_links_showsOnlyLinks`, `contentFilter_withSearchText` | `contentFilter_links_showsOnlyLinks`: only link messages remain: the items `testLinkContentFilter` gets from `/_get chat @2 content=link count=100` (the test client's id; the oracle is the item list, not a command run here); `contentFilter_withSearchText`: with "Links" on and search text typed, only the link messages containing that text remain (the search runs with the filter's content tag, CV:279-290) | P | |
+| Search | Search in direct / group; go to a result; close search | ⋮ "Search"; result button | CV:279-290, 800-812, 1217-1225, CIV:276-294 | `search_direct_filtersResults`, `search_group_filtersResults`, `search_goToResult_opensAroundItem` | `search_direct_filtersResults`: the chat shows only the matching items: the items matching "ello ther", as in `testAddContact` (whose `/_get chat @2 count=100 search=ello ther` uses the test client's id; the oracle is the item list, not a command run here); `search_group_filtersResults`: in #team with bob's "apples and pears" and "plums" and alice's "pears for bob", searching "pears" leaves bob's and alice's matching messages and hides "plums"; changing the text to "apples" leaves only bob's message (H/Groups.hs:499); `search_goToResult_opensAroundItem`: the go-to button is shown only in search; on a result it closes the search field and shows the item with its non-matching neighbours "alpha" and "omega" (CIV:286-294; CV:1840-1844; `ChatPagination.Around`, `C/views/chatlist/ChatListNavLinkView.kt:235-236`) | P | `search_close_restoresAll` merged into `search_notes_filtersResults` (Android Back is also covered by `BackKeyTest.back_closesChatSearchBeforeChat`) |
+| Search | Search in notes; close search | Notes: search icon; Back | CV:279-290, 800-812, 1217-1225, 1243-1256 | `search_notes_filtersResults` | With the notes "keep in mind" and "ahoy!", searching "keep" leaves "keep in mind" and hides "ahoy!" (`testNotes`); closing the search (desktop: the Back arrow of the search bar; Android: system Back) removes the search field and shows both notes again (CV:1217-1225) | — | The notes search button gets a key (`Ui.Chat.SearchButton`) |
+| Filter | Content filter menu, files, images, links, filter with search text, reset | Gallery icon → "Images" / "Files" / "Links" / "All messages" | CV:858-870, 1340-1356, 1434-1445, 1487-1530, 3977-3995 | `contentFilter_types_filterAndReset` | In #team, after bob's "no links here", "check out https://example.com", "see https://simplex.chat", the file list.txt, an image (`/img`) and "last words" arrive while another chat is open: the menu lists "Images", "Files" and "Links" and not "Videos", "Voice messages" or "All messages" (CV:858-870); "Files" leaves only list.txt; the menu (now the icon in the search field) offers "All messages"; "Images" leaves only the image; "Links" leaves both text messages with a URL (the core filters by `has_link`, `Store/Messages.hs:1545-1549`, `testLinkContentFilter`); typing "example" leaves only "check out https://example.com" (CV:279-290); "All messages" removes the search field and loads every message again, "last words" in view | P, XFTP | `contentFilter_menu_listsAvailableTypes`, `contentFilter_files`, `contentFilter_images` and `contentFilter_allMessages_resets` merged into `contentFilter_types_filterAndReset`. The gallery icon and the menu items get keys (`Ui.Chat.ContentFilter`, `.option(<filter>)`, `.option("all")`) |
+| Filter | Links filter; filter with search text; types updated while the chat is open | Gallery icon → "Links"; a file note added in the open notes | CV:858-870, 189-210, 802-815 | `contentFilter_fileAddedInOpenChat_listsFiles` | `contentFilter_fileAddedInOpenChat_listsFiles` (desktop: the notes filter is a bar button only on desktop): the empty notes' menu lists "Images" and "Links" without "Files"; after a file note is sent in the open notes, the menu lists "Files" | — | `contentFilter_links_showsOnlyLinks` and `contentFilter_withSearchText` merged into `contentFilter_types_filterAndReset`. `contentFilter_fileAddedInOpenChat_listsFiles` is `@KnownAppIssue("15.5 item NEW")`: the available types are fetched only when a chat opens and when search closes through an item jump (`updateAvailableContent`, CV:206, 812), so "Files" is missing until the chat is reopened |
 
-### S. Draft persistence (8 tests)
+### S. Draft persistence (5 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Drafts | Text, quote, edit state restored after switching chats; only last chat kept; cleared when sending becomes impossible; forwarding into a chat with a draft | Type, switch chat, come back | CMP:1381-1467, 996-1010 | `draft_text_restoredAfterChatSwitch`, `draft_withQuote_restored`, `draft_editingState_restored`, `draft_onlyLastChatKept`, `draft_clearedWhenSendDisabled`, `draft_forwardIntoChatWithDraft_restoresDraftAfterSend` | `draft_text_restoredAfterChatSwitch`: typed text is back after switching away and back; `draft_withQuote_restored`: the text and the reply bar are back; `draft_editingState_restored`: the edit bar and the edited text are back; `draft_onlyLastChatKept`: type in bob's chat, switch to cath's and type, switch to a third chat: back in bob's chat the compose field is empty, back in cath's chat her text is restored (one draft slot, CMP:1407-1422); `draft_clearedWhenSendDisabled`: with a draft in bob's chat, after bob runs `/d alice` (sending now fails with "contact deleted", `C/model/ChatModel.kt:1696`) the compose field is emptied and the draft dropped (CMP:1429-1434); `draft_forwardIntoChatWithDraft_restoresDraftAfterSend`: forwarding into cath's chat while it has a draft sends the forward (`cath <# "alice> -> forwarded"`), then the draft is back in the compose field (CMP:995-996) | P | The "Message draft" setting and its effect are owned by catalogue 04 (`00-legend.md`) |
-| Drafts | Attachment restored after switching chats | Put a file path on the in-memory clipboard, press Ctrl+V in the compose field, switch chat, come back | CMP:1381-1467, PTF:144-145, CMP:1516 | `draft_withAttachment_restored` | The file preview is restored in the compose area | P, CB | |
-| Drafts | Voice recording finished on switch | Record, switch chat | CMP:1408-1415 | `draft_voiceRecording_finishedOnSwitch` | The recording becomes a voice preview in the draft | P, REC | |
+| Drafts | Text, quote, edit state restored after switching chats; only last chat kept; draft cleared after send; cleared when sending becomes impossible | Type, switch chat, come back | CMP:1395-1481, 997-1012 | `draft_onlyLastChatKept`, `draft_withQuote_restored`, `draft_clearedWhenSendDisabled` | `draft_onlyLastChatKept`: type in bob's chat, switch to cath's and type, switch to notes: only cath's row shows a draft; back in bob's chat the compose field is empty, back in cath's chat her text is restored (one draft slot, CMP:1421-1435); sending it delivers it and cath's row then shows the sent text, not the draft (CMP:836-838); `draft_withQuote_restored`: a reply and then an edit each survive a visit to notes (text and context bar back, nothing shown in notes) and are sent as `bob <# "alice> > question"` and `bob <# "alice> [edited] hello world"`; `draft_clearedWhenSendDisabled`: with text in bob's chat, after bob runs `/d alice` (sending now fails with "contact deleted", `C/model/ChatModel.kt:1711`) the compose field is emptied and no draft is kept (CMP:1443-1448); a draft in cath's chat survives a visit to bob's chat (the order the comment at CMP:1441-1442 guards, desktop only) | P ×2 | The "Message draft" setting and its effect are owned by catalogue 04 (`00-legend.md`). Drafts are held in memory only (ChatModel.kt:255-257) and do not survive an app restart; the harness `restart()` restarts only the core, so a "persists" test would pass falsely Tests: `draft_onlyLastChatKept` (`draft_text_restoredAfterChatSwitch` merged into it), `draft_withQuote_restored` (`draft_editingState_restored` merged into it), `draft_clearedWhenSendDisabled`; `draft_forwardIntoChatWithDraft_restoresDraftAfterSend` merged into §L `forward_withComment_sendsCommentQuoted` |
+| Drafts | Attachment restored after switching chats | Enter the file's absolute path into the compose field (PTF:99-107), switch chat, come back | CMP:1395-1481, PTF:99-107 | `draft_withAttachment_restored` | The file preview ("Cancel file preview", report.txt) is restored in the compose area and sending it delivers the file: `bob <# "alice> sends file report.txt (…)"` | P, XFTP | Desktop-only: pasting a path is desktop code Tests: `draft_withAttachment_restored` (desktop `DraftDesktopTest`) |
+| Drafts | Voice recording finished on switch | Record, switch chat | CMP:1422-1426 | `draft_voiceRecording_finishedOnSwitch` | The recording becomes a voice preview in the draft | P, REC | Blocked: REC seam not built (plan §0.5.11) |
 
 ### T. Status icons and delivery (9 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
 | Receipts | Sent then delivered | bob is stopped; alice sends "hi"; then bob is started | `C/views/chat/item/CIMetaView.kt:99-108`, `C/model/ChatModel.kt:4025-4049` | `status_direct_sentThenDelivered` | The GUI item's status (typed semantics, plan §4) is sent while bob is stopped and turns delivered after the start (`testSendDeliveryReceipts`); after the start the CLI only prints `bob <# "alice> hi"` | P, S, PEERCTL | With bob online his receipt arrives within milliseconds of the send, so he is stopped before the send to hold the sent state |
 | Receipts | Peer receipts off | bob runs `/receipts @alice off` (prints `ok`, `H/Direct.hs:3424`; new CLI users send receipts by default, `Store/Profiles.hs:143`), then alice sends "hi" | `C/views/chat/item/CIMetaView.kt:99-108`, `C/model/ChatModel.kt:4025-4049` | `status_receiptsOff_staysSent` | The GUI item's status (typed semantics, plan §4) is still sent after `wait(5 s)` (`testConfigureDeliveryReceipts`); the CLI only prints `bob <# "alice> hi"` | P, S | |
-| Receipts | Group partial then complete | cath is stopped; alice sends "hi" in #team; then cath is started | `C/views/chat/item/CIMetaView.kt:99-108`, `C/model/ChatModel.kt:4036-4039` | `status_group_partialThenComplete` | The item status is delivered-partial after bob's receipt and delivered-complete after cath's (`testSendGroupDeliveryReceipts`); `bob <# "#team alice> hi"`, then after the start `cath <# "#team alice> hi"` | P ×2, S, PEERCTL | With both peers online the two receipts arrive within milliseconds, so cath is stopped to hold the partial state |
-| Errors | Auth error alert | bob deletes the contact without notifying: `/d alice notify=off` (`chatDeleteMode`, `Library/Commands.hs:6281, 6474-6481`; prints `alice: contact is deleted`, as the API form in `H/Direct.hs:981-982`; a plain `/d alice` notifies alice and disables her compose field); the queue is deleted on the server later, in a background thread (`deleteAgentConnectionsAsync'`, `Library/Commands.hs:1378`; simplexmq `Agent.hs:1013-1015`), so bob repeats `/get servers summary 1` until its JSON shows `"_connDeleted":1` (counted when the server confirms the deletion, simplexmq `Agent/Client.hs:2122-2124`); then alice sends | CIV:130-138, `C/model/ChatModel.kt:4051-4061` | `status_authError_clickShowsDeliveryError` | "Message delivery error" (`testRepeatAuthErrorsDisableContact`) | P | |
-| Errors | Pending while the server is down | Stop the SMP server, send | CIMetaView:99-109, `C/model/ChatModel.kt:4031` | `status_pending_whileServerDown` | The item stays pending (item meta status sndNew); no warning appears | P, SRVCTL | |
-| Errors | Delivery warning alert | bob is stopped; alice sends 17 messages to bob | CIV:130-138, `C/model/ChatModel.kt:4051-4061` | `status_quotaExceeded_warningAlert` | Clicking the warning icon shows "Message delivery warning" | P, PEERCTL | The test server's quota is 16 messages per queue (plan §8.2); the agent sends MWARN on QUOTA (simplexmq Agent.hs:2632) |
+| Receipts | Group partial then complete | alice owns #team with bob and cath (`ownGroupWithTwo`); cath is stopped; alice sends "hi"; then cath is started | `C/model/ChatModel.kt:4096-4101` (`shouldKeepOldSndCIStatus`), `C/model/SimpleXAPI.kt:3077-3089`, `src/Simplex/Chat/Messages.hs:1097-1110` | `status_group_partialThenComplete` | After `bob <# "#team alice> hi"` the item status (model) is delivered, partial; after the start `cath <# "#team alice> hi"` and the status turns delivered, complete (`testSendGroupDeliveryReceipts`) | P ×2, S, PEERCTL | With both peers online the two receipts arrive within milliseconds, so cath is stopped to hold the partial state. The status icons have no content description, so the status is read from the model |
+| Errors | Auth error alert | alice sends "before" (delivered); bob deletes the contact without notifying: `/d alice notify=off` (`chatDeleteMode`, `Library/Commands.hs:6719-6727`; prints `alice: contact is deleted`; a plain `/d alice` notifies alice and disables her compose field); the queue is deleted on the server later, in a background thread (`deleteAgentConnectionsAsync'`, `Library/Internal.hs:3164-3167`), so bob repeats `/get servers summary 1` once a second until its JSON shows `"_connDeleted":1`; then alice sends "after" | CIV:133-141, `C/model/ChatModel.kt:4083-4093`, `src/Simplex/Chat/Library/Subscriber.hs:751-754` | `status_authError_clickShowsDeliveryError` | Clicking the delivered "before" shows no alert; "after" gets the auth send error (model `CISSndError(Auth)`), and clicking it shows "Message delivery error" / "Wrong key or unknown connection - most likely this connection is deleted." (`snd_error_auth`), closed with OK | P | |
+| Errors | Pending while the server is down | Stop the SMP server, send | CIMetaView:99-109, `C/model/ChatModel.kt:4031` | `status_pending_whileServerDown` | The item stays pending (item meta status sndNew); no warning appears | P, SRVCTL | Shared `ItemStatusTest`: "before" is sent with smp1 up (sent or delivered); after `TestServers.stop("smp1")` "while down" is still sndNew once the send call has returned; after `start("smp1")` bob receives it and its status turns sent or delivered. Fails if a message sent while the server is unreachable is marked failed or warned, or not delivered after the server is back |
+| Errors | Delivery warning alert | bob is stopped; alice sends 17 messages m1…m17 to bob | CIV:133-141, `C/model/ChatModel.kt:4083-4093`, `src/Simplex/Chat/Library/Subscriber.hs:748-750` | `status_quotaExceeded_warningAlert` | m17 gets a quota send warning (model `SndWarning(Quota)`) and m1 does not; clicking m17 shows "Message delivery warning" / "Capacity exceeded - recipient did not receive previously sent messages." (`snd_error_quota`), closed with OK | P, PEERCTL | The test server's quota is 16 messages per queue (plan §8.2): the 17th write returns QUOTA (simplexmq `MsgStore/STM.hs:151-163`) and the agent sends MWARN (simplexmq `Agent.hs:2575-2586`) |
 | Meta | Unread dot | Receive a message | CIMetaView:93-116 | `status_rcvNew_dotUntilRead` | The item's status (item meta, plan §4) is new until the item is read | P | The sent-via-proxy icon and the encrypted-file lock belong to their settings in catalogue 04 (`00-legend.md`) |
 | Meta | Signature verified | The CLI owner posts with `/_send #1(as_group=on) sign=on text hello` (`testChannelAsGroupSign`; channel messages are unsigned by default) | CIMetaView:117-121 | `meta_signature_verified` | The item's meta shows it as signed (item meta, plan §4) | P, RELAY | Signed messages come from a channel with relays |
 | Meta | Signature missing alert | bob (current CLI) creates group `team` and runs `/set signatures #team on` (`Library/Commands.hs:6407`) before he adds alice and cath, so their invitations carry it (alice's GUI shows no sign of the preference in a regular group: no feature item, `regularGroupFeatures`, `Types/Preferences.hs:317-319`, and "Group preferences" has no row for it, `C/views/chat/group/GroupPreferences.kt:192-220`, so a later change could reach her after cath's message); cath is a v7.0.3 CLI (`cli("cath", CliVersion.Stable(<stable tag>))`), which signs only in groups with relays (v7.0.3 `Library/Internal.hs:2214-2221`), and sends `#team hi` | CIV:130-138, `C/model/ChatModel.kt:2730-2733`, CIMetaView:118-121 | `meta_signature_missingAlert` | cath's item in alice's group shows the signature-missing mark (`MVSigMissing` for an unsigned message when the group allows signatures, `Types/Shared.hs:170-172`, `Messages.hs:420-424`, `Library/Internal.hs:3047`); tapping it shows the "Signature missing" alert | P ×2 | Uses the stable CLI in every run (not `S`, which means "also with stable"). Depends on the stable tag: v7.0.3 (the default) signs only with relays; the test reads cath's version (`/v`) and is skipped through a JUnit assumption, with that reason, when the run's stable release signs in groups without relays |
 
-### U. Special items (19 tests, 1 ignored)
+### U. Special items (16 tests, 1 ignored)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| E2EE | Encryption info item, direct | New chat | CIV:684-696 | `e2eeInfo_direct_pq` | "…**quantum resistant e2e encryption**…" | P | The stable CLI (v7.0.3) also negotiates quantum-resistant encryption, so there is no separate old-peer case |
-| E2EE | Encryption info item, group | New group | CIV:684-696 | `e2eeInfo_group_noPq` | "…**end-to-end encryption**…" | P | |
-| Features | Contact changes a preference; offer with "Accept"; timed offer "Set 1 day" | bob `/set voice @alice no`; `/set delete @alice yes`; for the timed offer alice first turns "Disappearing messages" off for bob (saves `{allow: no, ttl: null}`; with her default `yes` there would be no offer, CIFeaturePreferenceView.kt:30, ChatModel.kt:1953-1954), then bob runs `/set disappear @alice no`, then `/set disappear @alice yes` with no TTL (Commands.hs:3629-3634, 6641), so alice's TTL stays unset (a TTL from bob would be copied into alice's pref, Subscriber.hs:2786-2792, and the link would read "Accept") | CIV:757-789, `C/views/chat/item/CIFeaturePreferenceView.kt:33` | `featureItem_contactChangesPref_shown`, `featureOffer_accept_updatesPrefs`, `featureOffer_timed_set1Day` | `featureItem_contactChangesPref_shown`: bob's `/set voice @alice no` turns voice off for both sides (`prefEnabled`, `Types/Preferences.hs:1147-1153`), so alice gets a "Voice messages: off" feature item; it directly follows the five feature items created on connection, so it joins their merged icon row (`CIMergeCategory.ChatFeature`, `C/model/ChatModel.kt:3457-3461`; `mergedFeatures`, `CIChatFeatureView.kt:75-92`) and shows no text; the test right-clicks the row → "Expand" (`expand_verb`, CIV:529-541), then the newest feature item reads "Voice messages: off" and the earlier ones use the GUI feature names, e.g. "Delete for everyone: off" (`full_deletion`; the core says "Full deletion"); `featureOffer_accept_updatesPrefs`: the offer shows "Accept" → `bob <## "alice updated preferences for you:"` (`testFeatureOffers`); `featureOffer_timed_set1Day`: the timed offer shows "Set 1 day" (alice's TTL is unset), and clicking it allows disappearing messages for bob with a 1-day TTL (`allowFeatureToContact(…, 86400)` (ChatView's `acceptFeature`), `CIFeaturePreferenceView.kt:32-34`); the link then disappears from the item and bob prints `bob <## "alice updated preferences for you:"` followed by a "Disappearing messages: …" line (`src/Simplex/Chat/View.hs:2062-2076`) | P | No message is sent between connecting and bob's `/set voice`, so the new item always joins the connection's feature run (see `featureItems_merged_iconRowExpandHide`). Group-preference feature items are owned by catalogue 03 §5 |
-| Features | Merged feature items: icon row, Expand, Hide | alice connects with bob; open the chat; right-click the feature row → "Expand", then right-click an item → "Hide" | CIV:529-541, CIV:757-788, `C/views/chat/item/CIChatFeatureView.kt:28-48, 75-114`, `C/model/ChatModel.kt:3453-3461` | `featureItems_merged_iconRowExpandHide` | After connecting, alice's chat shows one row of five feature icons (one `CIRcvChatFeature` per UI feature, `createFeatureEnabledItems_`, `Library/Internal.hs:3253-3257`, `Types/Preferences.hs:82-91`); "Expand" (`expand_verb`) shows five items "Disappearing messages: off", "Delete for everyone: off", "Message reactions: enabled", "Voice messages: enabled", "Audio/video calls: enabled" (`featureText`, ChatModel.kt:4329-4339; defaults `defaultChatPrefs`, Types/Preferences.hs:553-564); "Hide" (`hide_verb`) collapses them back to the icon row | P | The icons have no content description (CIChatFeatureView.kt:105): K2 key needed. A later feature item that directly follows this run joins the row; `featureItem_contactChangesPref_shown` expands it first |
+| E2EE | Encryption info item, direct | New chat | CIV:691-697 | | "…**quantum resistant e2e encryption**…" | P | `e2eeInfo_direct_pq` merged into `directChat_opens_showsToolbarAndBanner`. The stable CLI (v7.0.3) also negotiates quantum-resistant encryption, so there is no separate old-peer case |
+| E2EE | Encryption info item, group | New group | CIV:700-702 | | "…**end-to-end encryption**…" | P | `e2eeInfo_group_noPq` merged into `chatBanner_contextText_perChatType` |
+| Features | Contact changes a preference; offer with "Accept"; timed offer "Set 1 day" | bob `/set voice @alice no`; `/set delete @alice yes`; for the timed offer alice first turns "Disappearing messages" off for bob (saves `{allow: no, ttl: null}`; with her default `yes` there would be no offer, CIFeaturePreferenceView.kt:30, ChatModel.kt:1953-1954), then bob runs `/set disappear @alice no`, then `/set disappear @alice yes` with no TTL (Commands.hs:3629-3634, 6641), so alice's TTL stays unset (a TTL from bob would be copied into alice's pref, Subscriber.hs:2786-2792, and the link would read "Accept") | CIV:757-789, `C/views/chat/item/CIFeaturePreferenceView.kt:33` | `featureOffer_accept_updatesPrefs`, `featureOffer_timed_set1Day` | `featureItem_contactChangesPref_shown`: bob's `/set voice @alice no` turns voice off for both sides (`prefEnabled`, `Types/Preferences.hs:1147-1153`), so alice gets a "Voice messages: off" feature item; it directly follows the five feature items created on connection, so it joins their merged icon row (`CIMergeCategory.ChatFeature`, `C/model/ChatModel.kt:3457-3461`; `mergedFeatures`, `CIChatFeatureView.kt:75-92`) and shows no text; the test right-clicks the row → "Expand" (`expand_verb`, CIV:529-541), then the newest feature item reads "Voice messages: off" and the earlier ones use the GUI feature names, e.g. "Delete for everyone: off" (`full_deletion`; the core says "Full deletion"); `featureOffer_accept_updatesPrefs`: the offer shows "Accept" → `bob <## "alice updated preferences for you:"` (`testFeatureOffers`); `featureOffer_timed_set1Day`: the timed offer shows "Set 1 day" (alice's TTL is unset), and clicking it allows disappearing messages for bob with a 1-day TTL (`allowFeatureToContact(…, 86400)` (ChatView's `acceptFeature`), `CIFeaturePreferenceView.kt:32-34`); the link then disappears from the item and bob prints `bob <## "alice updated preferences for you:"` followed by a "Disappearing messages: …" line (`src/Simplex/Chat/View.hs:2062-2076`) | P | No message is sent between connecting and bob's `/set voice`, so the new item always joins the connection's feature run (see `featureItems_merged_iconRowExpandHide`). Group-preference feature items are owned by catalogue 03 §5. `featureItem_contactChangesPref_shown` merged into `featureItems_merged_iconRowExpandHide`. The offers' "Accept" / "Set 1 day" links are spans of one `ClickableText` (CIFeaturePreferenceView.kt:44-48): clicking them needs a key per link |
+| Features | Merged feature items: icon row, Expand, Hide | alice connects with bob and opens the chat; bob runs `/set voice @alice no` (prints `you updated preferences for alice:` / `Voice messages: off (you allow: no, …)`); right-click the feature row → "Expand" (`ItemMenu(id, "expand")`), then → "Hide" (`ItemMenu(id, "collapse")`) | CIV:510-545, CIV:757-788, `C/views/chat/item/CIChatFeatureView.kt:28-48, 75-114`, `C/model/ChatModel.kt:3453-3461` | `featureItems_merged_iconRowExpandHide` | After connecting, the five `CIRcvChatFeature` items (`createFeatureEnabledItems_`, `Library/Internal.hs:3267-3271`, `Types/Preferences.hs:82-91`) are one row, keyed by the newest item, with no feature text; bob's change (voice off for both sides, `prefEnabled`, `Types/Preferences.hs:1147-1153`) adds a sixth item that joins the row (the row is now keyed by it, the older ones are not rendered) and shows no text; "Expand" (`expand_verb`) shows every item with its text: "Voice messages: off" and the connection's "Disappearing messages: off", "Delete for everyone: off" (`full_deletion`; the core says "Full deletion"), "Message reactions: enabled", "Voice messages: enabled", "Audio/video calls: enabled" (`featureText`, `C/model/ChatModel.kt:4361-4366`); "Hide" (`hide_verb`) collapses them back into the icon row | P | The icons have no content description (CIChatFeatureView.kt:105), so the collapsed row is checked by the absence of the items and their texts. No message is sent between connecting and bob's `/set voice`, so the new item joins the connection's feature run. `featureItem_contactChangesPref_shown` merged into `featureItems_merged_iconRowExpandHide` |
 | Invitation | Expired invitation item label | — | `C/views/chat/item/CIGroupInvitationView.kt:80` | `groupInvitation_expired` | "Group invitation expired" | IGNORE: code that is unused — the core never sets the `CIGISExpired` status (`src/Simplex/Chat/Messages/CIContent.hs:282`), so the label can't appear | The rest of the invitation item (tap to join, incognito label, sent item) is owned by catalogue 03 §8 (`00-legend.md`) |
 | Calls | Incoming call item with answer; ended states | bob `/call @alice` (`SendCallInvitation` with `defaultCallType`, a video call with encryption, `Library/Commands.hs:6147`, Call.hs:180-181), `/_call end @<alice's contact id>` (no name form) | CIV:600, CV:616-627, `C/views/chat/item/CICallItemView.kt:32-58` | `callItem_incoming_answerButton`, `callItem_endedStates` | `callItem_incoming_answerButton`: "Answer call"; `callItem_endedStates`: bob ends the call with `/_call end` before alice answers, so alice's item shows the red call icon with content description "Missed call" (`CICallItemView.kt:39`; no Text) and "Answer call" is gone, and the chat-list preview reads "missed call" (`CICallStatus.text`, ChatModel.kt:5374) (`Library/Subscriber.hs:3135-3139`; the "ended" state needs a connected WebRTC call, which the browser stub can't give) | P, URI, AV | Answering launches the browser through the `LocalUriHandler` stub (URI only in `callItem_incoming_answerButton`) |
 | Calls | Incoming call alert: accept, reject, ignore | bob `/call @alice` (the same invitation `inviteToCall` sends as `/_call invite @<alice's contact id> {"media":"video","capabilities":{"encryption":true}}`, `tests/ChatTests/Direct.hs:1389-1394`: `defaultCallType`, Call.hs:180-181; `bob <## "ok"`) | `C/App.kt:253-254`, `C/views/call/IncomingCallAlertView.kt:27-79`, `C/views/call/CallManager.kt:27-58, 99-111` | `callAlert_incoming_acceptRejectIgnore` | The alert shows bob's profile, "e2e encrypted video call" and "Reject", "Ignore", "Accept". "Accept" closes the alert and opens the call view, which launches the browser: the `LocalUriHandler` stub records the call page link (`D/views/call/CallView.desktop.kt:157-174`). "Reject" (after a new invitation) closes the alert and the call item shows the rejected state ("Rejected call" icon, CICallItemView.kt:40); bob prints nothing, because rejecting sends no message (`APIRejectCall`, `src/Simplex/Chat/Library/Commands.hs:1530-1540`). "Ignore" closes the alert only (`activeCallInvitation` cleared, IncomingCallAlertView.kt:40-43); the item stays incoming | P, S, URI, AV | v7.0.3 has the same `/call @<name>` command (its Commands.hs:5483). bob ends each invitation with `/_call end @<alice's contact id>` before sending the next one |
 | Calls | Answering a call whose invitation is gone | bob invites; once alice's chat shows the incoming call item with "Answer call" (`CICallItemView.kt:32-58`; bob's `/call` prints `ok` when the invitation is queued, and alice's `calls` row exists only after it arrives), between two `restart()` steps the `calls` row is deleted from the GUI database; click "Answer call" | CV:616-627 | `callItem_answerEnded_showsAlert` | "Call already ended!" | P, RESTART, FIXTURE (calls row deleted), AV | The item stays pending but `apiGetCallInvitations` returns nothing |
-| Events | Delete a whole merged range | Members join; right-click the collapsed events → "Delete" | CIV:530-543, 605-643, `C/views/chat/ChatItemsMerger.kt` | `events_merged_deleteRange` | "Delete %d messages?" / "Messages will be deleted - this cannot be undone!" with only "Delete for me" (`forAll = false`, CIV:886-902, 1426-1448); after it the collapsed events row is gone | P ×2 | Rendering, expanding and role-change event items are owned by catalogue 03 §16 (`00-legend.md`) |
+| Events | Delete a whole merged range | Members join; right-click the collapsed events → "Delete" | CIV:878-925, 1446-1471, `C/views/chat/ChatItemsMerger.kt` | `events_merged_deleteRange` | In alice's #team the "connected" events of bob and cath are one row; its "Delete" shows "Messages will be deleted - this cannot be undone!" with only "Delete for me" (`forAll = false`, CIV:907-912); after it both events are gone, while alice's later "keep" and the group's encryption info stay | P ×2 | Rendering, expanding and role-change event items are owned by catalogue 03 §16 (`00-legend.md`) |
 | Member contact | Open direct chat from member contact item | "Open" | `C/views/chat/item/CIMemberCreatedContactView.kt:46` | `memberContact_openButton_opensDirectChat` | The group item reads "requested connection" with an "Open" button; "Open" opens the direct chat (setup as in `testMemberContactMessage`; the group has "Direct messages" on: alice-created groups start with it off, `C/views/newchat/AddGroupView.kt:160-162`, so alice turns it on in "Group preferences", or bob hosts with `/g`) | P | Creating and accepting member contacts is owned by catalogue 03 §11 |
 | Errors | Decryption error with Fix connection; skipped-messages error without dev tools; sync events | "Fix connection" → "Fix connection?" → "Fix" | CIV:709-721, `C/views/chat/item/CIRcvDecryptionError.kt:51-227`, `C/views/chat/item/IntegrityErrorItemView.kt:32-83` | `decryptionError_fixConnection_syncs`, `integrityError_hiddenWithoutDevTools`, `syncEvents_shownAsEvents` | `decryptionError_fixConnection_syncs`: after "Fix": `bob <## "alice: connection synchronization agreed"` (`testSyncRatchet`); `integrityError_hiddenWithoutDevTools`: without developer tools the skipped-messages item is hidden; `syncEvents_shownAsEvents`: alice's chat then shows the event items "agreeing encryption…", "encryption agreed" and "encryption ok" (the initiator's started/agreed/synchronized items, H/Direct.hs:3262; `ratchetSyncStatusToText`, `C/model/ChatModel.kt:5557-5565`; CIV:749-756) | P, RESTART, FIXTURE (GUI database copy) | As in `setupDesynchronizedRatchet`, but on the GUI side: with the core stopped, the GUI database is copied; the decryption error comes from restoring that old copy after more messages; the skipped IDs come from a CLI process that opens the copy (with the GUI's key) and consumes messages before the GUI continues |
 | Errors | Skipped-messages error with developer tools | As above, developer tools on | `C/views/chat/item/IntegrityErrorItemView.kt:32-83` | `integrityError_skipped_devToolsVisible` | The item reads "%1$d skipped message(s)" (e.g. "3 skipped message(s)"; setup as in `testMsgDecryptError`) | P, DT, RESTART, FIXTURE (GUI database copy) | Same fixture as the row above |
 | Other | Invalid data item | — | CIV:798, `C/views/chat/item/CIInvalidJSONView.kt:30` | `invalidJson_item_rendered` | "invalid data" | P, RESTART, FIXTURE (unparseable chat item) | A chat item row with unparseable content, written with the core stopped. The welcome message item is owned by catalogue 03 §4 |
 | Other | Legacy deleted item | alice sends "hi" to bob; between two `restart()` steps alice's row is rewritten: `UPDATE chat_items SET item_content = '{"sndDeleted":{"deleteMode":"broadcast"}}', item_content_tag = 'sndDeleted' WHERE item_text = 'hi'` | CIV:588-598, 705-706; `C/views/chat/item/DeletedItemView.kt:19-43` | `legacyDeletedItem_rendered` | The item shows italic "deleted" (`deleted_description`, strings.xml:49; ChatModel.kt:4261) in a sent bubble with its meta; its menu has only "Info", "Delete" and "Select" | P, RESTART, FIXTURE (legacy deleted item) | The core no longer creates these contents (`Messages/CIContent.hs:145-146`) but still decodes them (`DBJCISndDeleted`, :591, `singleFieldJSON`, :748), so only pre-4.3 databases have them |
 
-### V. Private notes (7 tests)
+### V. Private notes (5 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
 | Notes | Send | Compose in notes | CMP:580-585 | `notes_sendText_saved` | The note "keep in mind" appears in the notes chat as a local item (as in `testNotes`), and is still there after a restart | RESTART | No peer; clearing notes is owned by catalogue 01 (notes menu) |
-| Notes | Menu rules, edit | Menus in notes | CMP:580-585, CIV:407 | `notes_menu_noReplyLiveTimed`, `notes_edit_updates` | The menu has no Reply, live or timed options; an edited note shows the new text | — | No peer |
-| Notes | Attach image/file, delete (removes file), image filter | Attach in notes | CMP:580-585, CIV:1391 | `notes_attachImage_storedLocally`, `notes_attachFile_storedLocally`, `notes_delete_removesFile`, `notes_contentFilterImages` | `notes_attachImage_storedLocally`: the image appears as a note; `notes_attachFile_storedLocally`: the file appears as a note; `notes_delete_removesFile`: after delete the file is removed from the files folder (as in `testFiles`); `notes_contentFilterImages`: the content filter "Images" shows the image note and not the file note (CV:3980) | FD | Delete offers only "Delete for me" |
+| Notes | Menu rules, edit, delete, nothing sent to contacts | Menus in notes | CMP:580-585, CIV:412, 1405-1438 | `notes_editDelete_staysLocal` | With bob connected, in notes "keep in mind", "ahoy!", "scratch": the menu of a note has "Edit" and no "Reply" (CIV:412); "ahoy!" edited to "Greetings." updates the same note; deleting "scratch" offers "Delete for me" and not "Delete for everyone" (CIV:1406) and removes it; after a restart the notes are "keep in mind" and "Greetings."; alice's next message to bob is the next line bob prints (nothing from the notes reached him) | P, RESTART | `notes_menu_noReplyLiveTimed` and `notes_edit_updates` merged into `notes_editDelete_staysLocal` (the live and timed send options are not checked) |
+| Notes | Attach image/file, delete (removes file), image filter | Attach in notes; Ctrl+V of a copied file path (desktop) | CMP:580-585, PTF.desktop:145-151, CIV:1425 | `notes_attachImage_storedLocally`, `notes_pasteFile_storedLocally_deleteRemovesFile`, `notes_contentFilterImages` | `notes_attachImage_storedLocally`: the image appears as a note; `notes_pasteFile_storedLocally_deleteRemovesFile` (desktop): Ctrl+V with a file path on the clipboard shows the file preview without typing the path (PTF.desktop:145-151); the sent note's file is a copy in the app's files with the same content; "Delete for me" (no "Delete for everyone") removes the note and its stored copy, not the pasted original (as in `testFiles`); `notes_contentFilterImages`: the content filter "Images" shows the image note and not the file note (CV:3984) | FD | `notes_attachFile_storedLocally` and `notes_delete_removesFile` merged into `notes_pasteFile_storedLocally_deleteRemovesFile` |
 
-### W. Context menus and keyboard (5 tests)
+### W. Context menus and keyboard (1 tests)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Menus | Right-click and long-press open the menu | Right-click / long-press | CIV:327-335, 388-553 | `contextMenu_rightClick_opens`, `contextMenu_longPress_opens` | `contextMenu_rightClick_opens` and `contextMenu_longPress_opens`: on bob's text item the menu opens with "Reply" and "Copy" (CIV:408,445), which are absent before | P | |
-| Menus | Menu items per item type | Right-click each item type | CIV:388-553 | `contextMenu_itemsMatrix_byItemType` | In alice's chat with bob, below the reactions row on message items: alice's sent text "hi": "Reply", "Share", "Copy", "Edit", "Forward", "Info", "Delete", "Select"; bob's received text: the same without "Edit"; bob's file offer (`/f @alice tests/fixtures/test.pdf`, not yet received): "Reply", "Download", "Info", "Delete", "Select" (no "Share", "Copy" or "Forward": no text and the file is not loaded; CIV:407-485); bob's text after he runs `\ @alice hi` (deleted for everyone under default prefs, so only marked deleted): "Reveal", "Info", "Delete", "Select" (CIV:557-568, 698-700); the merged row of the five feature items created on connection: "Expand", "Delete", "Select" (CIV:531-542); the single "contact bob changed to …" event after bob runs `/p bob Bobby` (`RcvDirectEventContent` has no merge category, `C/model/ChatModel.kt:3475-3476`): "Delete", "Select" (CIV:544-551); the call item: "Delete", "Select" (CIV:600-603, 376-384); deleted content: bob creates #club, adds alice, who accepts, and runs `/set delete #club on`; after `\\ #club @alice hi` alice's sent "hi" becomes moderated content (`Store/Messages.hs:2847-2860`, as in testGroupModerateFullDelete): "Info", "Delete", "Select" (CIV:557-568) | P, XFTP, AV | The call item comes from an incoming invitation, whose alert plays the ringtone (IncomingCallAlertView.kt:30-33) |
-| Keys | Enter does nothing when send is disabled; Esc closes the item-info modal | Keys | PTF:134 | `enter_whenSendDisabled_noop`, `escape_closesItemInfoModal` | Nothing sent; the info modal closes | P | Esc goes through the harness `escape()` (plan §7.4), which invokes `simplexWindowState.backstack` as the window's key handler does |
+| Menus | Right-click and long-press open the menu | Right-click / long-press | CIV:327-335, 388-553 | | The menu opens on right-click (desktop) and long-press (Android) | P | `contextMenu_rightClick_opens` and `contextMenu_longPress_opens` merged into `contextMenu_itemsMatrix_byItemType` (`rightClick` is a long-press on Android) |
+| Menus | Menu items per item type; Copy | Right-click each item type | CIV:388-575, 703-705 | `contextMenu_itemsMatrix_byItemType` | Below the reactions row, in alice's chat with bob: bob's text "copy me": "Reply", "Share", "Copy", "Forward", "Info", "Delete", "Select" (no "Edit"); "Copy" puts "copy me" on the clipboard (CIV:450); bob's file offer (`/f @alice offer.txt`, not received): "Reply", "Download", "Info", "Delete", "Select" (no "Share", "Copy" or "Forward": no text and the file is not loaded; CIV:424-485); bob's text after he runs `\@alice to be deleted` (marked deleted under default prefs): "Reveal", "Info", "Delete", "Select" (CIV:562-575, 703-705). Not covered: alice's sent text (Edit is covered by `EditMessageTest.edit_notOffered_forReceivedOrForwarded`), merged feature items, the profile-change event, call items and moderated content | P, XFTP | The Copy item gets a key (`Ui.Chat.ItemMenu(id, "copy")`); Share is found by its text |
+| Keys | Enter does nothing when send is disabled; Esc closes the item-info modal | Keys | PTF:134 | | Nothing sent; the info modal closes | P | `enter_whenSendDisabled_noop` merged into `multiline_shiftEnter_peerReceivesTwoLines` (ComposeDesktopTest: Enter on a blank message leaves it unsent); `escape_closesItemInfoModal` merged into `ItemInfoTest` (`ItemInfoScreen.close()` closes the info with `escape()`). Esc on an open context menu is not tested: the harness `escape()` invokes the window back stack, not a key event, and the window's Esc handler (DesktopApp.kt:126) is not part of the test scene |
 
 ### X. Rare states and out-of-reach rows (4 tests, 2 ignored)
 | Area | Feature | Trigger | File:line | Test case(s) | Verification | Needs | Notes |
@@ -298,28 +299,28 @@ Seam use (plan §11.2): REC — 9 (four recording tests, `voice_disabledWhileRec
 ## Count
 | Section | Tests | Ignored |
 |---|---|---|
-| A Shell, toolbar, banner | 11 | 0 |
-| B Composing, links, mentions, commands | 28 | 0 |
-| C Live messages | 10 | 0 |
-| D Timed messages | 6 | 0 |
+| A Shell, toolbar, banner | 8 | 0 |
+| B Composing, links, mentions, commands | 21 | 0 |
+| C Live messages | 5 | 0 |
+| D Timed messages | 5 | 0 |
 | E Voice | 11 | 0 |
-| F Sending attachments | 21 | 1 |
-| G Receiving files | 20 | 0 |
-| H Replies | 7 | 0 |
-| I Edit | 12 | 0 |
-| J Delete / reveal / blocked | 8 | 0 |
-| K Multi-select | 9 | 0 |
-| L Forwarding | 17 | 0 |
-| M Reactions | 8 | 0 |
-| N Copy / share / save | 9 | 0 |
-| O Reports, member side | 7 | 0 |
-| P Item info | 15 | 0 |
-| Q Unread / scroll / pagination | 18 | 0 |
-| R Search / filters | 11 | 0 |
-| S Drafts | 8 | 0 |
+| F Sending attachments | 14 | 1 |
+| G Receiving files | 19 | 0 |
+| H Replies | 6 | 0 |
+| I Edit | 5 | 0 |
+| J Delete / reveal / blocked | 4 | 0 |
+| K Multi-select | 3 | 0 |
+| L Forwarding | 9 | 0 |
+| M Reactions | 5 | 0 |
+| N Copy / share / save | 5 | 0 |
+| O Reports, member side | 2 | 0 |
+| P Item info | 10 | 0 |
+| Q Unread / scroll / pagination | 12 | 0 |
+| R Search / filters | 6 | 0 |
+| S Drafts | 5 | 0 |
 | T Status icons | 9 | 0 |
-| U Special items | 19 | 1 |
-| V Private notes | 7 | 0 |
-| W Context menus / keyboard | 5 | 0 |
+| U Special items | 16 | 1 |
+| V Private notes | 5 | 0 |
+| W Context menus / keyboard | 1 | 0 |
 | X Rare states and out-of-reach rows | 4 | 2 |
-| **Total** | **280** | **4** |
+| **Total** | **190** | **4** |
diff --git a/plans/ui-tests/catalogue/03-groups-channels-business.md b/plans/ui-tests/catalogue/03-groups-channels-business.md
index 51395bd099..d769bee186 100644
--- a/plans/ui-tests/catalogue/03-groups-channels-business.md
+++ b/plans/ui-tests/catalogue/03-groups-channels-business.md
@@ -3,7 +3,7 @@
 Groups, channels and business chats, mapped to the desktop code and the core tests: **312 test cases in 20 sections, 4 of them `@Ignore`** (see `## Count`). Format, Needs codes, user names and ownership of overlapping features follow `00-legend.md`.
 
 **How to read the tables**
-- The GUI user is **alice** (display name only). CLI peers are bob, cath, dan and eve; their role in a row (host, moderator, member, joiner, customer, team member, channel owner) is given in the Notes or Verification text. Chat relays are headless CLI processes started by the harness (`--relay --headless`, plan §8.1); they have no terminal, so their side is never asserted as CLI lines — relay effects are asserted on the GUI or on a peer's CLI.
+- The GUI user is **alice** (display name only). CLI peers are bob, cath, dan and eve; their role in a row (host, moderator, member, joiner, customer, team member, channel owner) is given in the Notes or Verification text. Chat relays are CLI peers started in relay mode (`cli("relay1", PeerFlags(relay = true))`, §0); they type commands and print events like any peer, so relay-side lines can be asserted.
 - When a Haskell test is cited, its lines are rewritten for these roles: the GUI user's own output is asserted on the GUI, and CLI lines name the GUI user `alice` without a full name.
 - Labels in «» are the exact English values from `apps/multiplatform/common/src/commonMain/moko-resources/base/strings.xml`.
 - **Group info** means: click the chat title in the group's toolbar.
@@ -11,8 +11,8 @@ Groups, channels and business chats, mapped to the desktop code and the core tes
 
 ## 0. Harness facts (setup, not tests)
 
-- **Relays.** The harness starts each relay as `simplex-chat --relay --headless --user-display-name <relayN> -d <dir> -s <smp1> --xftp-server <xftp1>` (plan §8.1; `--relay-web-domain relay.example.com --relay-web-dir <dir>` together for channel webpages, `src/Simplex/Chat/Options.hs:295-298`). Headless mode creates the relay address on first start and prints `Chat relay address is created:` with the link (`src/Simplex/Chat/Core.hs:190-196`); the harness reads it and registers the relay in alice's servers. Registering a relay through the UI is tested in catalogue 04.
-  - A relay can't type commands. Rows where a relay must leave or reject (`/leave`) stop the relay (`PEERCTL`), run the command once on its database with the same options as the running relay, `simplex-chat --relay -d <dir> -s <smp1> --xftp-server <xftp1> -e "<command>" -t 3` with stdin `/dev/null` (`--execute`, Options.hs:381; `-t` is the wait after the command, kept at 3 s so async effects such as `/da`'s server-side deletion complete before the process exits; plan §8.1), and start it again.
+- **Relays.** A relay is a CLI peer in relay mode: `cli("relay1", PeerFlags(relay = true))` runs `simplex-chat --relay --user-display-name relay1 -d <dir> -s <smp1> --xftp-server <xftp1>` under a pty like any other peer (desktop `CliPeer`; on Android the bridge starts it with `start relay1 relay`). On the first start the CLI asks `Create relay address (Yn):` (`src/Simplex/Chat/Core.hs:181-196`); the harness answers `y` and reads the link printed after `Chat relay address is created:` into `relay.relayAddress` (on Android the bridge replies `ok <link>`). `registerChatRelaysViaApi(relay, …)` adds relays to alice's custom server group (a precondition; registering a relay through the UI is tested in catalogue 04); a CLI owner registers its relay with `/relays name=relay1 <link>` and creates the channel with `/public group relays=1 #team` (`CliPeer.createChannel`, as prepareChannel' `H/Groups.hs:9743`). The web flags (`--relay-web-domain relay.example.com --relay-web-dir <dir>`, `src/Simplex/Chat/Options.hs:295-298`) are not wired yet: rows with `RELAY (web flags)` stay blocked.
+  - Relays type commands like any peer (`/leave #team`, `/da`), so no stop/run/restart cycle is needed for them; `PEERCTL` on a relay row means the relay is stopped or restarted (`relay.stop()`, `relay.start()`), which keeps its database and address.
 - **CLI subscribers** join with `/c <shortLink>` (testConnectChannelCLI, `H/Groups.hs:9206`, which runs with `testOptsNoFullLinks`). The `/_connect plan` + `/_prepare group` route of the Haskell helpers is not usable from a real CLI: the plan's link data is printed only in test view (`src/Simplex/Chat/View.hs:2281`).
 - **Group host helpers:** `createGroup2'` (`H/Utils.hs:815`) and `fullAddMember` (`H/Utils.hs:917`). On the peer you will see `#team: alice invites you to join the group as member` and `use /j team to accept`.
 - **Member screening on a CLI host:** `/set admission review #team all` (`H/Groups.hs:3684`). The "pending approval" path (as opposed to review) needs Haskell `chatHooks`, which a CLI process can't set (see the `IGNORE` rows in §6).
@@ -23,160 +23,165 @@ Groups, channels and business chats, mapped to the desktop code and the core tes
 
 ---
 
-### 1. Create group (12 tests)
+### 1. Create group (9 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Name validation | New chat ▸ «Create group» ▸ «Create secret group» | V/newchat/NewChatSheet.kt:197; V/newchat/AddGroupView.kt:136-168 | `createGroup_buttonDisabledForEmptyOrInvalidName`, `createGroup_invalidNameAlertOffersFix` | `createGroup_buttonDisabledForEmptyOrInvalidName`: «Create group» row disabled while the name is empty or invalid (V/newchat/AddGroupView.kt:167); `createGroup_invalidNameAlertOffersFix`: for `a_1` the red info icon opens «Invalid name!» / «Correct name to a-1?», and confirming puts `a-1` in the field (V/newchat/AddGroupView.kt:141-145; V/WelcomeView.kt:485-499) | — | — |
+| Name validation | New chat ▸ «Create group» ▸ «Create secret group» | V/newchat/NewChatSheet.kt:197; V/newchat/AddGroupView.kt:137-171 | `createGroup_buttonDisabledForEmptyOrInvalidName` | Clicking «Create group» with the name empty (no red info icon) and with `a_1` creates nothing (V/newchat/AddGroupView.kt:170); for `a_1` the red info icon opens «Invalid name!» / «Correct name to a-1?», confirming puts `a-1` in the field and removes the icon (V/newchat/AddGroupView.kt:143-146; V/WelcomeView.kt:490-504); «Create group» then creates `a-1`, the only group | — | `createGroup_invalidNameAlertOffersFix` merged into `createGroup_buttonDisabledForEmptyOrInvalidName` |
 | Create, then invite step | «Create group» | V/newchat/AddGroupView.kt:43-57 | `createGroup_opensChatAndInviteSheet` | The group chat opens with its feature items and the «Invite members» sheet | — | Defaults to history ON (AddGroupView.kt:162) |
-| Skip inviting | «Create group» ▸ «Skip inviting members» | V/chat/group/AddGroupMembersView.kt:165-188,255 | `createGroup_skipInviting` | «Skip inviting members» closes the sheet and leaves the group chat open | P | The sheet shows «Skip inviting members» only when alice has at least one contact |
+| Skip inviting | «Create group» ▸ «Skip inviting members» | V/chat/group/AddGroupMembersView.kt:166-193,258 | `createGroup_skipInviting` | «Skip inviting members» is shown (and «Invite to group» is not) while no contact is selected; selecting bob swaps them, unselecting swaps back (AddGroupMembersView.kt:188); «Skip inviting members» closes the sheet and leaves the group chat open; bob receives no invitation: alice's next direct message is his next CLI line | P | The sheet shows «Skip inviting members» only when alice has at least one contact |
 | Group image | Edit-image button / delete-image button | V/newchat/AddGroupView.kt:117-125 | `createGroup_withProfileImage`, `createGroup_removeImageBeforeCreate` | `createGroup_withProfileImage`: the avatar is shown in the chat list and in the Group info header; `createGroup_removeImageBeforeCreate`: the delete-image button (shown only while an image is chosen) clears it before «Create group», and the group is created with no image: the chat list and Group info show the default group icon (V/newchat/AddGroupView.kt:119-124) | FD | Image chosen through the completed file dialog |
 | Same name | Create "team" twice | — | `createGroup_sameNameGetsLocalSuffix` | Developer tools «Local name» shows `team_1` (testGroupSameName, H/Groups.hs:870) | DT | — |
-| Incognito group | «Incognito» toggle ▸ «Create group» | V/newchat/AddGroupView.kt:59-62,170; V/chat/group/GroupLinkView.kt:119-123,288-296 | `createGroupIncognito_opensGroupLinkStep`, `createGroupIncognito_inviteMembersProhibited` | The «Group link» step opens and creates the link by itself: QR code, «Share link», «Continue» (no «Delete link»). In Group info the «Invite members» row keeps its label in the secondary (grey) colour, and tapping it shows the alert «Can't invite contacts!» (V/chat/group/GroupChatInfoView.kt:757-758; V/chatlist/ChatListNavLinkView.kt:920-925) | — | — |
-| Incognito group, CLI joiner | «Incognito» toggle ▸ «Create group» ▸ link to CLI | V/newchat/AddGroupView.kt:59-62 | `createGroupIncognito_cliJoinerSeesIncognitoHost` | CLI `/c <link>` gives `connection request sent!`, `#team: joining the group...`, `#team: you joined the group`; when alice sends hello, the CLI shows `#team <incognito>> hello` (testNewGroupIncognito, H/Groups.hs:572) | P | — |
+| Incognito group | «Incognito» toggle ▸ «Create group» | V/newchat/AddGroupView.kt:59-62,170; V/chat/group/GroupLinkView.kt:119-123,288-296 |  | The «Group link» step opens and creates the link by itself: QR code, «Share link», «Continue» (no «Delete link»). In Group info the «Invite members» row keeps its label in the secondary (grey) colour, and tapping it shows the alert «Can't invite contacts!» (V/chat/group/GroupChatInfoView.kt:757-758; V/chatlist/ChatListNavLinkView.kt:920-925) | — | `createGroupIncognito_opensGroupLinkStep` and `createGroupIncognito_inviteMembersProhibited` merged into `createGroupIncognito_cliJoinerSeesIncognitoHost` |
+| Incognito group, CLI joiner | «Incognito» toggle ▸ «Create group» ▸ link to CLI | V/newchat/AddGroupView.kt:59-62 | `createGroupIncognito_cliJoinerSeesIncognitoHost` | CLI `/c <link>` gives `connection request sent!`, `#team: joining the group...`, `#team: you joined the group`; when alice sends hello, the CLI shows `#team <incognito>> hello` (testNewGroupIncognito, H/Groups.hs:572) | P | Also checks the link step and the «Can't invite contacts!» alert of row 35; the «Incognito» switch is keyed `Ui.NewGroup.Incognito` (V/newchat/NewChatView.kt:860-881) |
 | Prefs/admission during invite | «Set group preferences» / «Set member admission» | V/chat/group/AddGroupMembersView.kt:178-185 | `createGroup_setPreferencesDuringInviteStep`, `createGroup_setAdmissionDuringInviteStep` | `createGroup_setPreferencesDuringInviteStep`: «Set group preferences» opens «Group preferences»; turning «Delete for everyone» on and «Save and notify group members» leave `/_group_profile #<groupId> {…}` in the command log (C/model/SimpleXAPI.kt:4210), and Group info ▸ «Group preferences» later shows it on; `createGroup_setAdmissionDuringInviteStep`: «Set member admission» opens «Member admission»; «Review members» «all» and «Save and notify group members» leave the same command, and Group info ▸ «Group preferences» ▸ «Member admission» later shows «all» (V/chat/group/AddGroupMembersView.kt:52-66) | P | Rows only appear when alice has at least one contact |
 
-### 2. Invite members (11 tests)
+### 2. Invite members (8 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Who appears in the list | Group info ▸ «Invite members» | V/chat/group/AddGroupMembersView.kt:96-111,165-175 | `inviteMembers_listsOnlyEligibleContacts`, `inviteMembers_searchFiltersContacts` | `inviteMembers_listsOnlyEligibleContacts`: current members and not-ready contacts are excluded: with bob a member, the list shows cath and not bob; `inviteMembers_searchFiltersContacts`: with bob and cath both listed, typing "ca" leaves only cath (name match ignoring case, `getContactsToAdd`, V/chat/group/AddGroupMembersView.kt:96-111) | P ×2 | — |
+| Who appears in the list | Group info ▸ «Invite members» | V/chat/group/AddGroupMembersView.kt:97-112,166-176,331-384 | `inviteMembers_listsOnlyEligibleContacts` | `inviteMembers_listsOnlyEligibleContacts`: current members are excluded: with bob a member, the list shows cath and the incognito contact dan and not bob; tapping dan shows «Can't invite contact!» and leaves «No contacts selected»; inviting the selected cath gives her CLI `#team: alice invites you to join the group as member` / `use /j team to accept`, and dan's next CLI line is alice's later direct message (testCantInviteContactIncognito, H/Profiles.hs:2864); `inviteMembers_searchFiltersContacts`: with bob and cath both listed, typing "ca" leaves only cath (name match ignoring case, `getContactsToAdd`, V/chat/group/AddGroupMembersView.kt:97-112) | P ×3 | `inviteMembers_searchFiltersContacts` merged into `inviteMembers_selectionCounterAndClear` (typing "CA" leaves only cath; clearing the search keeps cath selected) |
 | No contacts to invite | Group info ▸ «Invite members» | V/chat/group/AddGroupMembersView.kt:165-175 | `inviteMembers_noContactsToAdd` | «No contacts to add» when alice has no eligible contacts | — | — |
-| Selection | contact rows, «Clear» | V/chat/group/AddGroupMembersView.kt:266-298 | `inviteMembers_selectionCounterAndClear` | Selecting two contacts shows «2 contact(s) selected» and «Clear»; «Clear» unselects both and shows «No contacts selected» (V/chat/group/AddGroupMembersView.kt:272-292) | P ×2 | — |
-| Role picker | «New member role» | V/chat/group/AddGroupMembersView.kt:223-240 | `inviteMembers_rolePickerLimitedToOwnRole` | An admin alice is not offered «owner» | P ×2 | bob is the CLI host, alice an admin |
-| Send invitation | «Invite to group» | V/chat/group/AddGroupMembersView.kt:67-85 | `inviteMembers_singleContactAsMember`, `inviteMembers_asObserver` | CLI: `#team: alice invites you to join the group as <role>`, with `member` for `inviteMembers_singleContactAsMember` (the default role, V/chat/group/AddGroupMembersView.kt:39) and `observer` for `inviteMembers_asObserver` (picked as «observer» in «New member role» first); after `/j team`: `#team: you joined the group`. alice sees the member row «connected» (fullAddMember H/Utils.hs:917; the «You sent group invitation» item is tested in §8) | P, S | — |
+| Selection | contact rows, «Clear» | V/chat/group/AddGroupMembersView.kt:266-298 | `inviteMembers_selectionCounterAndClear` | Selecting two contacts shows «2 contact(s) selected» and «Clear»; «Clear» unselects both and shows «No contacts selected» (V/chat/group/AddGroupMembersView.kt:272-292) | P ×2 | Also checks the search (row 43) and, after inviting only cath, «You sent group invitation» in cath's chat and none in bob's (row §8 `groupInvitation_hostSeesSentInvitationItem`) |
+| Role picker | «New member role» | V/chat/group/AddGroupMembersView.kt:223-240 |  | An admin alice is not offered «owner» | P ×2 | bob is the CLI host, alice an admin. `inviteMembers_rolePickerLimitedToOwnRole` merged into `memberInfo_roleReadOnlyForHigherRole` (§10): the picker offers observer…admin, not owner; inviting cath as admin gives her CLI `#team: alice invites you to join the group as admin` |
+| Send invitation | «Invite to group» | V/chat/group/AddGroupMembersView.kt:67-85 | `inviteMembers_singleContactAsMember`, `inviteMembers_asObserver` | CLI: `#team: alice invites you to join the group as <role>`, with `member` for `inviteMembers_singleContactAsMember` (the default role, V/chat/group/AddGroupMembersView.kt:41) and `observer` for `inviteMembers_asObserver` (picked as «observer» in «New member role» first, V/chat/group/AddGroupMembersView.kt:224-242); after `/j team`: `#team: you joined the group`. alice sees the member row «connected» (with «observer» for `inviteMembers_asObserver`, whose CLI `#team hi` then gives `#team: you don't have permission to send messages`) (fullAddMember H/Utils.hs:917; the «You sent group invitation» item is tested in §8) | P, S | — |
 | Send invitation to several | select both contacts ▸ «New member role» = «admin» ▸ «Invite to group» | V/chat/group/AddGroupMembersView.kt:39,67-85,223-240 | `inviteMembers_multipleContactsAsAdmin` | Each CLI: `#team: alice invites you to join the group as admin`; both member rows appear (createGroup3' H/Utils.hs:842) | P ×2, S | — |
-| Incognito contact | contact with theater-mask icon | V/chat/group/AddGroupMembersView.kt:329-379 | `inviteMembers_incognitoContactProhibited` | «Can't invite contact!» (testCantInviteContactIncognito, H/Profiles.hs:2864) | P | Contact connected incognito |
-| Re-add invited member | Group info ▸ «Invite members» again | V/chat/group/AddGroupMembersView.kt:96-111 | `inviteMembers_reAddInvitedMember` | bob, invited but not yet joined, is still in the list (only current members are excluded). Inviting him again gives the CLI a second `#team: alice invites you to join the group as member` / `use /j team to accept` (testGroupReAddInvited, H/Groups.hs:909) | P | — |
+| Incognito contact | contact with theater-mask icon | V/chat/group/AddGroupMembersView.kt:331-384 | | «Can't invite contact!» (testCantInviteContactIncognito, H/Profiles.hs:2864) | P | Contact connected incognito; `inviteMembers_incognitoContactProhibited` merged into `inviteMembers_listsOnlyEligibleContacts` |
+| Re-add invited member | Group info ▸ «Invite members» again | V/chat/group/AddGroupMembersView.kt:97-112 | `inviteMembers_reAddInvitedMember` | bob, invited but not yet joined (member row «invited»), is still in the list (only current members are excluded). Inviting him again gives the CLI a second `#team: alice invites you to join the group as member` / `use /j team to accept` (testGroupReAddInvited, H/Groups.hs:909) | P | — |
 | Entry points on the group info screen | info action «Invite», «Invite members» row | V/chat/group/GroupChatInfoView.kt:440,764 | `inviteMembers_infoScreenEntryPoints` | Both open the same sheet | — | The toolbar ⋮ entry is tested in catalogue 02 (§A) |
 
-### 3. Group info screen rows (13 tests)
+### 3. Group info screen rows (11 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
 | Header | Group info | V/chat/group/GroupChatInfoView.kt:963-1011 | `groupInfo_headerShowsProfileAndCopiesName` | Clicking the name shows toast «Copied to clipboard» (GroupChatInfoView.kt:972) and fills the clipboard | CB, TOAST | — |
-| Local alias | «Set chat name…» | V/chat/group/GroupChatInfoView.kt:591,1395 | `groupInfo_setLocalAlias`, `groupInfo_clearLocalAlias` | `groupInfo_setLocalAlias`: chat list and Group info show the alias (core behaviour: testSetGroupAlias, H/Profiles.hs:3265); `groupInfo_clearLocalAlias`: after the field is cleared they show the group's own name again (`displayName` is the alias or the profile name, C/model/ChatModel.kt:2515) | — | — |
-| Action buttons by role | top row | V/chat/group/GroupChatInfoView.kt:599-619 | `groupInfo_actionButtonsByRole` | Owner/admin: search, «Invite», mute. Member: search, mute | P | bob is the CLI host for the member case |
+| Local alias | «Set chat name…» | V/chat/group/GroupChatInfoView.kt:595,1412 | `groupInfo_setLocalAlias` | Typing «Work» in «Set chat name…» renames the chat-list row to «Work» (core behaviour: testSetGroupAlias, H/Profiles.hs:3240); after `restart()` the row still reads «Work» and group info shows the profile name «team» in the header with «Work» in the field; clearing the field turns the row back into «team» (`displayName` is the alias or the profile name, C/model/ChatModel.kt:2546) | RESTART | `groupInfo_clearLocalAlias` merged into `groupInfo_setLocalAlias` |
+| Action buttons by role | top row | V/chat/group/GroupChatInfoView.kt:603-623,687-713 | `groupInfo_actionButtonsByRole` | As a member of bob's group: «Search» and «Mute», no «Invite», and no «Create group link», «Invite members», «Chats with members» or «Member reports» rows; after bob runs `/mr team alice admin`, «Invite» and all four rows appear; «Create group link» creates the link and the row becomes «Group link», which opens the link screen | P | bob is the CLI host; the owner case is exercised by every alice-hosted test |
 | Search | «search» | V/chat/group/GroupChatInfoView.kt:394 | `groupInfo_searchButton` | Opens chat search; disabled when the chat has no items (GroupChatInfoView.kt:401): a new group already has feature items, so the disabled case clears the chat first | — | — |
-| Mute cycle | «Unmute» / «Mute all» / «Mute» | V/chat/group/GroupChatInfoView.kt:419; C/model/SimpleXAPI.kt:5437 | `groupInfo_muteCycleWithMentions` | All → Mentions → None → All; the row's mute icon follows (core behaviour: testMuteGroup, H/Direct.hs:1854) | — | — |
-| Send receipts | «Send receipts» | V/chat/group/GroupChatInfoView.kt:733-738,1057-1085 | `groupInfo_sendReceiptsOption` | Yes/No/default dropdown (testConfigureGroupDeliveryReceipts, H/Groups.hs:4429) | — | — |
+| Mute cycle | «Unmute» / «Mute all» / «Mute» | V/chat/group/GroupChatInfoView.kt:421-440; C/model/SimpleXAPI.kt:5509-5523 | `groupInfo_muteCycleWithMentions` | The group info button reads «Mute» → «Mute all» → «Unmute» → «Mute» while the mode goes All → Mentions → None → All; at None the row shows the mute icon («Notifications» description), and reopening group info still reads «Unmute»; back at All the icon is gone (core behaviour: testMuteGroup, H/Direct.hs:1861) | — | — |
+| Send receipts | «Send receipts» | V/chat/group/GroupChatInfoView.kt:95-99,739,1065-1080 | `groupInfo_sendReceiptsOption` | team starts at «default (…)»; choosing «no» saves `sendRcpts = false`; after `restart()` team still shows «no» while another group (club, made through the API) stays at «default (…)» (testConfigureGroupDeliveryReceipts, H/Groups.hs:4473) | RESTART | A real CLI prints receipts only in test view (`showReceipts`, src/Simplex/Chat/View.hs:850-854), so no peer proof is possible |
 | Send receipts, large group | «Send receipts» | V/chat/group/GroupChatInfoView.kt:733-738 | `groupInfo_sendReceiptsDisabledOver20Members` | Above 20 members the row shows «disabled»; clicking it shows the alert «Receipts are disabled» (GroupChatInfoView.kt:1072-1084) | P ×21, SLOW | Only current (joined) members count (`memberCurrent`, GroupChatInfoView.kt:734; `MemInvited -> false`, C/model/ChatModel.kt:2918), so this needs 21 joined CLI members |
 | Chat theme | «Chat theme» | V/chat/group/GroupChatInfoView.kt:740 | `groupInfo_chatThemeOpensEditor` | Wallpaper editor opens | — | Theme details are in catalogue 04 |
 | Delete-after (TTL) | «Delete messages after» | V/chat/group/GroupChatInfoView.kt:749,946 | `groupInfo_setChatTTL` | Confirmation alert «Enable automatic message deletion?» / «Delete messages» (ChatInfoView.kt:1417-1425), then the chosen value is selected; the progress spinner lasts only for the API call and one reload, so it is not asserted | — | — |
 | Developer tools | — | V/chat/group/GroupChatInfoView.kt:848 | `groupInfo_developerToolsRows` | Local name and Database ID rows | DT | — |
 | Prefs footer | Group info | V/chat/group/GroupChatInfoView.kt:726-729 | `groupInfo_prefsFooterForGroup` | «Only group owners can change group preferences.» | — | The channel and business footers are tested by `channelInfo_ownerRows` (§18) and `businessInfo_rowsForBusinessSide` (§20) |
-| Members section | «%1$s members» | V/chat/group/GroupChatInfoView.kt:754-773 | `groupInfo_membersSectionCountAndSelfRow` | Count includes self; self row reads «you: %1$s» (runtime-formatted with alice's name) | P | — |
+| Members section | «%1$s members» | V/chat/group/GroupChatInfoView.kt:759-777 | | Count includes self; self row reads «you: %1$s» (runtime-formatted with alice's name) | P | `groupInfo_membersSectionCountAndSelfRow` merged into `memberList_rolesAndStatuses` («1 members» → «3 members», «you: creator») |
 
-### 4. Group profile and welcome message (14 tests)
+### 4. Group profile and welcome message (10 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Edit profile | «Edit group profile» | V/chat/group/GroupProfileView.kt:32-207 | `editGroupProfile_renameNotifiesMembers`, `editGroupProfile_shortDescription` | «Save group profile». CLI after a rename: `alice updated group #team: (signed)` / `changed to #my_team`. CLI after setting «Short description:»: `alice updated group #team: (signed)` / `description changed to: <text>` (testUpdateGroupProfile, H/Groups.hs:1594) | P ×2 | «Group full name:» only shows when it already differs from the name |
+| Edit profile | «Edit group profile» | V/chat/group/GroupProfileView.kt:33-210 | `editGroupProfile_renameNotifiesMembers` | «Save group profile». CLI after a rename: `alice updated group #team: (signed)` / `changed to #my_team`, and Group info shows `my_team`. CLI after then setting «Short description:»: `alice updated group #my_team: (signed)` / `description changed to: Our team`, shown in the Group info header (testUpdateGroupProfile, H/Groups.hs:1638; the description line is printed only when the name is unchanged, View.hs:2126) | P | «Group full name:» only shows when it already differs from the name; `editGroupProfile_shortDescription` merged into `editGroupProfile_renameNotifiesMembers` |
 | Edit profile image | «Edit group profile» ▸ edit image | V/chat/group/GroupProfileView.kt:93-98, 120-127 | `editGroupProfile_changeImage` | New avatar in Group info; each CLI member prints `alice updated group #team: (signed)` / `profile image updated` | P ×2, FD | — |
 | Edit profile, local checks | «Edit group profile» | V/chat/group/GroupProfileView.kt:32-207 | `editGroupProfile_unsavedChangesAlert`, `editGroupProfile_descriptionTooLarge` | Unsaved-changes alert on close after a valid edit (an over-long description closes without it, GroupProfileView.kt:73-75,103,209-210): «Save preferences?» with «Save and notify group members» / «Exit without saving» (GroupProfileView.kt:215-222); the «Short description:» field becomes invalid above 160 bytes (WelcomeView.kt:54-57), an info icon opens «Description too large», and save is disabled | — | — |
-| Edit profile as a member | Group info | V/chat/group/GroupChatInfoView.kt:714-717 | `editGroupProfile_hiddenForNonOwner` | No «Edit group profile» row for a member | P | bob is the CLI host |
-| Welcome message, members | «Add welcome message» / «Welcome message» | V/chat/group/WelcomeMessageView.kt:37-197 | `welcomeMessage_addNotifiesMembers`, `welcomeMessage_newMemberReceivesItFirst` | «Save and update group profile». CLI: `welcome message changed to:`. A new member joining a group with no messages gets `#team alice> Welcome to the team!` as the first item (testGroupDescription, H/Groups.hs:1712); the order after history items is tested in §16 (`history_welcomeAfterHistory`) | P ×2 | — |
-| Welcome message, editor | «Add welcome message» | V/chat/group/WelcomeMessageView.kt:37-197 | `welcomeMessage_previewRendersMarkdown`, `welcomeMessage_tooLongDisablesSave`, `welcomeMessage_unsavedChangesAlert`, `welcomeMessage_clearRemovesIt` | `welcomeMessage_previewRendersMarkdown`: «Enter welcome message…», then «Preview» shows the text rendered as markdown, with «Copy» (V/chat/group/WelcomeMessageView.kt:137-157); `welcomeMessage_tooLongDisablesSave`: over 1200 bytes shows «Message too large» and disables «Save and update group profile» (:111-113,130-132); `welcomeMessage_unsavedChangesAlert`: leaving with changes shows «Save welcome message?» with «Save and update group profile» / «Exit without saving», or, when the text is too long, «Welcome message is too long» with «Exit without saving» (:61-66,199-214); `welcomeMessage_clearRemovesIt`: clearing removes the message from the profile | — | — |
-| Welcome message as a member | Group info ▸ «Welcome message» | V/chat/group/WelcomeMessageView.kt:97,135-139 | `welcomeMessage_readOnlyForMember` | Read-only view showing bob's text, with the «Copy» icon (WelcomeMessageView.kt:135-139,191) | P | bob is the CLI host and first runs `/set welcome #team <text>` (`Library/Commands.hs:6294`; `H/Groups.hs:1730`): a non-owner sees «Welcome message» only when the group has one (GroupChatInfoView.kt:718) |
-| Welcome message received | alice joins a group whose host set a welcome message | — (core: the host sends the description as a message on join, testGroupDescription H/Groups.hs:1746-1749) | `welcomeMessage_receivedAsFirstItem` | alice's group chat shows bob's welcome message as a received message right after joining, before any later messages (history items, if any, come before it) (testGroupDescription, H/Groups.hs:1712, roles swapped) | P | bob is the CLI host |
+| Edit profile as a member | Group info | V/chat/group/GroupChatInfoView.kt:715-718 | | No «Edit group profile» row for a member | P | bob is the CLI host; `editGroupProfile_hiddenForNonOwner` merged into `welcomeMessage_receivedAsFirstItem` |
+| Welcome message, members | «Add welcome message» / «Welcome message» | V/chat/group/WelcomeMessageView.kt:37-199 | `welcomeMessage_addNotifiesMembers`, `welcomeMessage_newMemberReceivesItFirst` | «Save and update group profile». `welcomeMessage_addNotifiesMembers`: CLI `alice updated group #team: (signed)` / `welcome message changed to:` / `Welcome to the team!`, and the Group info row turns from «Add welcome message» into «Welcome message»; clearing the text and saving gives `alice updated group #team: (signed)` / `welcome message removed` and «Add welcome message» again (WelcomeMessageView.kt:43-49; View.hs:2128). `welcomeMessage_newMemberReceivesItFirst`: a new member joining a group with no messages gets `#team alice> Welcome to the team!` as the first line after `#team: you joined the group` (testGroupDescription, H/Groups.hs:1756); the order after history items is tested in §16 (`history_welcomeAfterHistory`) | P ×2 | — |
+| Welcome message, editor | «Add welcome message» | V/chat/group/WelcomeMessageView.kt:37-199 | `welcomeMessage_previewRendersMarkdown`, `welcomeMessage_tooLongDisablesSave`, `welcomeMessage_unsavedChangesAlert` | `welcomeMessage_previewRendersMarkdown`: «Enter welcome message…», then «Preview» shows the text rendered as markdown, with «Copy» (V/chat/group/WelcomeMessageView.kt:137-157); `welcomeMessage_tooLongDisablesSave`: over 1200 bytes shows «Message too large» and disables «Save and update group profile» (:111-113,130-132); `welcomeMessage_unsavedChangesAlert`: leaving with changes shows «Save welcome message?» with «Save and update group profile» / «Exit without saving», or, when the text is too long, «Welcome message is too long» with «Exit without saving» (:61-66,199-214) | — | `welcomeMessage_clearRemovesIt` merged into `welcomeMessage_addNotifiesMembers` |
+| Welcome message as a member | Group info ▸ «Welcome message» | V/chat/group/WelcomeMessageView.kt:99,137-141 | | Read-only view showing bob's text, with the «Copy» icon (WelcomeMessageView.kt:137-141,192-202) | P | bob is the CLI host and first runs `/set welcome #team <text>` (`Library/Commands.hs:6294`; `H/Groups.hs:1730`): a non-owner sees «Welcome message» only when the group has one (GroupChatInfoView.kt:719); `welcomeMessage_readOnlyForMember` merged into `welcomeMessage_receivedAsFirstItem` |
+| Welcome message received | alice joins a group whose host set a welcome message | — (core: the host sends the description as a message on join, `sendHistory`, src/Simplex/Chat/Library/Internal.hs:1417-1452) | `welcomeMessage_receivedAsFirstItem` | alice's group chat shows bob's welcome message as the first received message right after joining, before bob's later `after welcome` (history items, if any, come before it) (testGroupDescription, H/Groups.hs:1756, roles swapped). Group info then shows «Welcome message» and no «Edit group profile»; «Welcome message» opens bob's text read-only with «Copy», no editor and no «Save and update group profile» (WelcomeMessageView.kt:99,137-141) | P | bob is the CLI host and runs `/set welcome #team <text>` before `/a team alice` |
 
-### 5. Group preferences (19 tests, 1 ignored)
+### 5. Group preferences (6 tests, 1 ignored)
 
 Group info ▸ «Group preferences»; `V/chat/group/GroupPreferences.kt:36-360`.
 
-On every save, CLI members print `alice updated group #team: (signed)` / `updated group preferences:` / `<Feature>: …`, and alice's chat gets a matching event item.
+On every save, CLI members print `alice updated group #team: (signed)` / `updated group preferences:` / `<Feature>: …` (`src/Simplex/Chat/View.hs:2113-2147`, features in `regularGroupFeatures` order, `src/Simplex/Chat/Types/Preferences.hs:280-293,318-335`), and alice's chat gets a matching event item. Rows marked "merged into" are asserted inside the named test; their old names are kept in brackets for traceability.
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| «Disappearing messages» + «Delete after» | Group info ▸ «Group preferences» | :109-118,292-303 | `groupPrefs_disappearingOnWithTtl`, `groupPrefs_disappearingMessageExpires`, `groupPrefs_disappearingOff` | `groupPrefs_disappearingOnWithTtl`: bob prints `alice updated group #team: (signed)`, `updated group preferences:`, `Disappearing messages: on (3 sec)` (testEnableTimedMessagesGroup, H/Profiles.hs:3584-3595); `groupPrefs_disappearingMessageExpires`: GUI groups start with it off (as for `groupPrefs_disappearingOff` below), so alice first turns it on (3 s) and saves; with bob started with `--mark-read`, `hi` is gone from bob's `/tail #team 1` after 3 s (the real CLI prints no deletion line, `src/Simplex/Chat/View.hs:937`); `groupPrefs_disappearingOff`: GUI groups start with it off (V/newchat/AddGroupView.kt:160-162; `defaultGroupPrefs`, `src/Simplex/Chat/Types/Preferences.hs:569-586`), so alice first turns it on (3 s) and saves; after turning it off and saving, bob prints `alice updated group #team: (signed)`, `updated group preferences:`, `Disappearing messages: off`, and a later `hey` is still in his `/tail #team 1` after 3 s (H/Profiles.hs:3608-3620) | P | Use the custom time picker for a short TTL; bob runs with `--mark-read` (plan §8.1 `PeerFlags`) so his received item starts its timer |
-| «Direct messages» + «Enabled for» | Group info ▸ «Group preferences» | :119-125,304-313 | `groupPrefs_directMessagesOff_memberInfoProhibited`, `groupPrefs_directMessagesForOwnersOnly` | alice-created groups start with «Direct messages» off (V/newchat/AddGroupView.kt:160-162; `defaultGroupPrefs`, `src/Simplex/Chat/Types/Preferences.hs:573`). `groupPrefs_directMessagesOff_memberInfoProhibited`: alice first turns it on and saves (CLI `Direct messages: on`), then turns it off and saves: `Direct messages: off`; `groupPrefs_directMessagesForOwnersOnly`: from the default, alice turns it on, sets «Enabled for» to owners and saves: `Direct messages: on for owners`. In both cases the CLI member's `@cath hi` gets `bad chat command: direct messages not allowed`. Only with off does alice's member-info message button show «Can't message group member»; with on-for-owners alice (owner) keeps an active message button (testProhibitDirectMessages H/Profiles.hs:3483; testGroupPrefsDirectForRole :3683) | P ×2 | The member must not be alice's contact (cath joins via the group link): for a known contact member info opens the contact instead (V/chat/group/GroupMemberInfoView.kt:497-534) |
-| «Delete for everyone» | Group info ▸ «Group preferences» | :126-131 | `groupPrefs_fullDeleteOn` | `Full deletion: on` (testUpdateGroupPrefs, H/Profiles.hs:3391) | P | — |
-| «Message reactions» | Group info ▸ «Group preferences» | :132-137 | `groupPrefs_reactionsOff_hidesReactionMenu` | CLI `Message reactions: off`; the reaction row and the reaction items of the item menu are absent (V/chat/item/ChatItemView.kt:157,404). A CLI `+1 #team hi` is rejected with `bad chat command: feature not allowed Message reactions` (src/Simplex/Chat/Library/Commands.hs:1004-1005) | P | — |
-| «Voice messages» off | Group info ▸ «Group preferences» | :138-144; V/chat/SendMsgView.kt:142-148,585-594 | `groupPrefs_voiceOff_showsNotAllowed` | alice (owner) saves «Voice messages» off and the CLI prints `Voice messages: off`. alice's microphone button gets the disabled look, and tapping it shows «Voice messages prohibited!» / «Only group owners can enable voice messages.» | P | «Voice messages not allowed» appears only while editing a voice item (ComposeView.kt:1737-1746) |
-| «Voice messages» for admins | Group info ▸ «Group preferences» | :138-144; V/chat/SendMsgView.kt:142-148,585-594 | `groupPrefs_voiceForAdminsOnly` | The CLI host bob runs `/set voice #team on admin`; once alice's (member) «Group preferences» show «Enabled for» «admins» under «Voice messages» (the CLI prints the change when it is queued, `sendGroupMessage … XGrpInfo`, src/Simplex/Chat/Library/Commands.hs:4156, and alice applies it on receipt, src/Simplex/Chat/Library/Subscriber.hs:1119), she sees the disabled microphone and the same alert | P | bob is the CLI host and alice a member |
-| «Files and media» + role | Group info ▸ «Group preferences» | :145-151 | `groupPrefs_filesForOwnersOnly` | `Files and media: on for owners`; CLI member `bad chat command: feature not allowed Files and media` (testGroupPrefsFilesForRole, H/Profiles.hs:3752) | P, XFTP | — |
-| «SimpleX links» + role | Group info ▸ «Group preferences» | :152-158 | `groupPrefs_simplexLinksForOwnersOnly` | `SimpleX links: on for owners`; a CLI member's message with a SimpleX link gets `bad chat command: feature not allowed SimpleX links` (testGroupPrefsSimplexLinksForRole, H/Profiles.hs:3787) | P | — |
-| «Member reports» | Group info ▸ «Group preferences» | :159-164 | `groupPrefs_reportsToggleDisabled` | Toggle is shown disabled | — | Hard-coded `disabled = true` |
-| «Visible history» | Group info ▸ «Group preferences» | :165-170 | `groupPrefs_historyOff_newMemberGetsNoHistory` | `Recent history: off`; new member gets no `[>>]` items (testGroupHistoryPreferenceOff, H/Groups.hs:6040) | P ×2 | — |
-| «Chat with admins» | Group info ▸ «Group preferences» | :217 | `groupPrefs_supportToggleDisabledInGroups` | Toggle is shown disabled for groups | — | — |
-| «Sign messages» | Group info ▸ «Group preferences» | :219-221 | `groupPrefs_signMessages` | — | IGNORE: commented-out code ("Sign messages", GroupPreferences.kt:219-221; plan §11.3) | — |
-| Reset / save / unsaved | Group info ▸ «Group preferences» | :241-251,352 | `groupPrefs_resetRestoresSaved`, `groupPrefs_unsavedChangesAlert` | `groupPrefs_resetRestoresSaved`: after a preference is toggled, «Reset» restores its saved value, «Reset» and «Save and notify group members» turn disabled again (:248), and the command log has no `/_group_profile`; `groupPrefs_unsavedChangesAlert`: «Save preferences?» / «Save and notify group members» / «Exit without saving» | — | — |
-| Read-only for members | Group info ▸ «Group preferences» | :314-327 | `groupPrefs_readOnlyForMember`, `groupPrefs_receivedUpdateShownAsEvent` | `groupPrefs_readOnlyForMember`: each preference shows its value as text with no toggle, and «Reset» / «Save and notify group members» are absent (GroupPreferences.kt:241-251,282,314-327); `groupPrefs_receivedUpdateShownAsEvent`: alice sees a `Voice messages: off` item after the CLI host runs `/set voice #team off` | P | bob is the CLI host |
+| Owner restricts several preferences in one save | Group info ▸ «Group preferences» | :109-170,282-313; C/views/helpers/CustomTimePicker.kt:83-142; C/views/helpers/ExposedDropDownSettingRow.kt:161-178 | `groupPrefs_ownerChangesNotifyAndRestrictMembers` | Before the save: bob's 👍 on `hi` is shown and alice's item menu offers 👎; «Delete after» and «Enabled for» under «Direct messages» are absent, «Enabled for» under «Voice messages» is present. alice turns on «Disappearing messages» («Delete after» `1 day`, picks 1 week), turns on «Direct messages» («Enabled for» `all members`, picks owners), turns on «Delete for everyone», turns off «Message reactions» and «Voice messages» («Enabled for» disappears), sets «Files and media» to admins and «SimpleX links» to owners, turns off «Visible history», and saves. bob's next lines are exactly `alice updated group #team: (signed)`, `updated group preferences:`, `Disappearing messages: on (1 week)`, `Direct messages: on for owners`, `Full deletion: on`, `Message reactions: off`, `Voice messages: off`, `Files and media: on for admins`, `SimpleX links: on for owners`, `Recent history: off`. alice's item menu then has «Reply» but no reactions (V/chat/item/ChatItemView.kt:404); her microphone shows «Voice messages prohibited!» / «Only group owners can enable voice messages.» (V/chat/SendMsgView.kt:377-388,587-596; C/model/ChatModel.kt:2573-2586). bob's `+^ #team hi`, `#team <link>` and `/f #team <file>` get `bad chat command: feature not allowed Message reactions` / `… SimpleX links` / `… Files and media` (src/Simplex/Chat/Library/Commands.hs:839,1014-1015,4963-4968), while alice (owner) sends the same link and bob receives it. A second save turning disappearing messages off and reactions on gives exactly `Disappearing messages: off`, `Message reactions: on`; the item menu offers 👎 again and bob's `+^ #team hi` gives `added 🚀` (testUpdateGroupPrefs H/Profiles.hs:3391; testGroupPrefsFilesForRole :3727-3748; testGroupPrefsSimplexLinksForRole :3762-3781; reactions H/Groups.hs:4380-4389) | P, XFTP | bob is an invited member (contact); never tap the microphone while voice is allowed |
+| «Disappearing messages» + «Delete after» | Group info ▸ «Group preferences» | :109-118,292-303; C/views/helpers/CustomTimePicker.kt:83-142; TTL list C/model/SimpleXAPI.kt:5624-5625 |  | On with 1 week, then off (`:115` keeps the old TTL with `enable = OFF`; the core prints no parameter when off, `src/Simplex/Chat/Types/Preferences.hs:951-956`). groupPrefs_disappearingMessageExpires is dropped: expiry is core timers (testEnableTimedMessagesGroup H/Profiles.hs:3559) and the app's part, removing an expired item on `ChatItemsDeleted`, is the path of 02 §D `timed_send30s_bothSidesDelete` | P | GUI groups start with it off from the core default (`defaultGroupPrefs`, `src/Simplex/Chat/Types/Preferences.hs:569-586`) Tests: merged into groupPrefs_ownerChangesNotifyAndRestrictMembers (was groupPrefs_disappearingOnWithTtl, groupPrefs_disappearingOff) |
+| «Direct messages» + «Enabled for» | Group info ▸ «Group preferences» | :119-125,304-313; V/chat/group/GroupMemberInfoView.kt:497-544, alert :742-747 | `groupPrefs_directMessagesForOwnersOnly` | bob joins by the group link (not alice's contact). With «Direct messages» off (core default, `src/Simplex/Chat/Types/Preferences.hs:573`; not set by `V/newchat/AddGroupView.kt`, which only turns history on) alice's member-info message button shows «Can't message group member» / «Direct messages between members are prohibited in this group.», and bob's `@alice hi` gets `bad chat command: direct messages not allowed`. «Enabled for» is absent while off; alice turns it on («Enabled for» `all members`), picks owners and saves: bob prints `alice updated group #team: (signed)`, `updated group preferences:`, `Direct messages: on for owners`. bob (member) is still refused (src/Simplex/Chat/Library/Commands.hs:2597-2632), and alice's message button now opens a direct chat with bob instead of the alert (testProhibitDirectMessages H/Profiles.hs:3476-3499; testGroupPrefsDirectForRole :3658) | P | Stops before sending, so §11 `memberContact_createAndSendInvitation` is not duplicated |
+| «Direct messages» off in member info | Group info ▸ member ▸ «Message» | V/chat/group/GroupMemberInfoView.kt:531-543 |  | The prohibited branch is the first half of `groupPrefs_directMessagesForOwnersOnly` | P | — Tests: merged into groupPrefs_directMessagesForOwnersOnly (was groupPrefs_directMessagesOff_memberInfoProhibited) |
+| «Delete for everyone» | Group info ▸ «Group preferences» | :126-131 |  | `Full deletion: on` | P | — Tests: merged into groupPrefs_ownerChangesNotifyAndRestrictMembers (was groupPrefs_fullDeleteOn) |
+| «Message reactions» | Group info ▸ «Group preferences» | :132-137; V/chat/item/ChatItemView.kt:404 (menu), :159-160 (chip) |  | Off: no reactions in alice's item menu, bob's reaction refused; on again: 👎 offered, bob's reaction accepted | P | — Tests: merged into groupPrefs_ownerChangesNotifyAndRestrictMembers (was groupPrefs_reactionsOff_hidesReactionMenu) |
+| «Voice messages» off | Group info ▸ «Group preferences» | :138-144; V/chat/SendMsgView.kt:140-151,377-388,587-596 |  | alice (owner) saves it off; her microphone shows «Voice messages prohibited!» / «Only group owners can enable voice messages.» | P | «Voice messages not allowed» appears only while editing a voice item (ComposeView.kt:1737-1746) Tests: merged into groupPrefs_ownerChangesNotifyAndRestrictMembers (was groupPrefs_voiceOff_showsNotAllowed) |
+| «Voice messages» for admins | Group info ▸ «Group preferences» | :138-144,324-326; V/chat/SendMsgView.kt:377-388,587-596 |  | bob (CLI host) runs `/set voice #team on admin`; alice (member) sees the `Voice messages: on (admins)` item, the same microphone alert, and «Enabled for» «admins» in her read-only preferences | P | bob is the CLI host and alice a member Tests: merged into groupPrefs_readOnlyForMember (was groupPrefs_voiceForAdminsOnly) |
+| «Files and media» + role | Group info ▸ «Group preferences» | :145-151; src/Simplex/Chat/Library/Commands.hs:4963-4968 |  | Set to admins (bob is a member, so the role gate is the same): `Files and media: on for admins`; bob's `/f #team <file>` gets `bad chat command: feature not allowed Files and media` (testGroupPrefsFilesForRole H/Profiles.hs:3727) | P, XFTP | The attach-button UI is owned by 02 §F Tests: merged into groupPrefs_ownerChangesNotifyAndRestrictMembers (was groupPrefs_filesForOwnersOnly) |
+| «SimpleX links» + role | Group info ▸ «Group preferences» | :152-158; V/chat/ComposeView.kt:1751; src/Simplex/Chat/Library/Commands.hs:839 |  | Owner side: `SimpleX links: on for owners`, bob's link message refused, alice's accepted (testGroupPrefsSimplexLinksForRole H/Profiles.hs:3762). Member side: with bob's `/set links #team on owner`, alice's typed link shows «SimpleX links not allowed» and the send button is disabled; after `/set links #team on` the banner goes and bob receives her link | P | — Tests: merged into groupPrefs_ownerChangesNotifyAndRestrictMembers and groupPrefs_readOnlyForMember (was groupPrefs_simplexLinksForOwnersOnly) |
+| «Member reports» | Group info ▸ «Group preferences» | :159-164 (`disabled = true` at :161) |  | Toggle is disabled, «Message reactions» is enabled | — | Hard-coded `disabled = true` Tests: merged into groupPrefs_unsavedChangesAlert (was groupPrefs_reportsToggleDisabled) |
+| «Visible history» | Group info ▸ «Group preferences» | :165-170 |  | Save mapping only: `Recent history: off`. The join-based half (no `[>>]` items for a new member, H/Groups.hs:6344) is dropped: core behaviour, and a second joiner adds a join (plan §15.4.1). History on is asserted in `review_acceptAsMember` (`[>>]` after acceptance) | P | — Tests: merged into groupPrefs_ownerChangesNotifyAndRestrictMembers (was groupPrefs_historyOff_newMemberGetsNoHistory) |
+| «Chat with admins» | Group info ▸ «Group preferences» | :217 |  | Toggle is disabled for groups | — | — Tests: merged into groupPrefs_unsavedChangesAlert (was groupPrefs_supportToggleDisabledInGroups) |
+| «Sign messages» | Group info ▸ «Group preferences» | :219-221 (inside the channel branch :218-240) | `groupPrefs_signMessages` | — | IGNORE: commented-out code ("Sign messages", GroupPreferences.kt:219-221; plan §11.3) | — |
+| Reset / save / unsaved | Group info ▸ «Group preferences» | :64-68,78-80,241-251,340-360 | `groupPrefs_unsavedChangesAlert` | alice toggles «Message reactions» (footer «Allow message reactions.» → «Prohibit messages reactions.»), «Reset» restores it, and Back then closes with no alert (Reset/Save are `SectionItemView`s with no disabled semantics, so the disabled state is checked by effect). After a second toggle, Back shows «Save preferences?» / «Save and notify group members» / «Exit without saving»; «Exit without saving» closes and keeps reactions on (model and reopened screen); a third toggle saved through «Save and notify group members» is in the model and still shown after `restart()`. The toggles of «Member reports» and «Chat with admins» are disabled. (was also groupPrefs_resetRestoresSaved) | — | No network |
+| Read-only for members | Group info ▸ «Group preferences» | :241,282,314-327; V/chat/group/MemberAdmission.kt:91-98,117-131; V/chat/group/GroupChatInfoView.kt:636-639,693-696 | `groupPrefs_readOnlyForMember` | bob (CLI host) invites alice. Her preferences show values as text: no toggles, no «Reset» / «Save and notify group members», «Members can send voice messages.» / «Members can send SimpleX links.»; «Member admission» shows «Review members» «off» with no dropdown, and changes to «all» live after bob's `/set admission review #team all`. After `/set voice #team on admin` alice sees the `Voice messages: on (admins)` item (a message before it prevents feature-item merging, C/model/ChatModel.kt:3485-3493) and the voice alert; the SimpleX-links banner as in the row above. Group info shows «Chat with admins» and no «Chats with members»; after bob's `/mr #team alice moderator` it shows «Chats with members» («No chats with members») and no «Chat with admins». (was also groupPrefs_receivedUpdateShownAsEvent, memberAdmission_readOnlyForNonOwner; `review_moderatorAcceptsMember`'s moderator-only row visibility) | P | bob is the CLI host |
+| Unsaved edits while a message arrives | Group info ▸ «Group preferences» | :37-44 (`rememberSaveable(gInfo, …)`); C/model/ChatModel.kt:466-489,573-582 | `groupPrefs_unsavedEditsKeptWhenMessageArrives` | alice toggles «Message reactions» off without saving; bob's `#team hello` arrives; the footer still says «Prohibit messages reactions.», and saving gives bob `Message reactions: off` | P | Probe for a suspected app bug (the edit is reset when the group's `GroupInfo` is replaced); becomes `@KnownAppIssue` if it reproduces. MemberAdmission.kt:34-35 has the same pattern |
 
-### 6. Member admission and review (16 tests, 2 ignored)
+### 6. Member admission and review (7 tests, 2 ignored)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Admission setting | «Group preferences» ▸ «Member admission» ▸ «Review members» off/all | V/chat/group/MemberAdmission.kt:27-156 | `memberAdmission_enableReviewAll`, `memberAdmission_readOnlyForNonOwner` | CLI: `alice updated group #team: (signed)` / `changed member admission rules` (testGLinkReviewMember, H/Groups.hs:3684); `memberAdmission_readOnlyForNonOwner`: for a member «Review members» shows its value as text with no dropdown, and there are no «Reset» / save buttons (V/chat/group/MemberAdmission.kt:91-98,117-131) | P | bob is the CLI host for the read-only case |
-| Admission setting, unsaved | «Member admission» | V/chat/group/MemberAdmission.kt:27-156 | `memberAdmission_unsavedChangesAlert` | «Save admission settings?» / «Save and notify group members» / «Exit without saving» (MemberAdmission.kt:148-155) | — | — |
-| alice as host reviews a CLI joiner | «Chats with members» ▸ pending row ▸ compose «Reject»/«Accept» | V/chat/group/MemberSupportView.kt:88-96,166-290; V/chat/ComposeContextPendingMemberActionsView.kt:25-126; V/chat/ComposeView.kt:1715-1729 | `review_pendingMemberListedInChatsWithMembers`, `review_hostChatsWithPendingMember`, `review_acceptAsMember`, `review_acceptAsObserver`, `review_rejectPendingMember`, `review_acceptFromLongPressMenu` | `review_pendingMemberListedInChatsWithMembers`: bob is listed first with status «pending review» and the flag icon on the row (V/chat/group/MemberSupportView.kt:91,174-175,254-258); the group row in alice's chat list shows the primary-colour flag (moderator side, V/chatlist/ChatPreviewView.kt:390-391); `review_hostChatsWithPendingMember`: clicking the row opens the chat with bob, and a message alice sends there reaches only him: `bob <# "#team (support) alice> hi"` (as eve's lines in testGLinkReviewMember, H/Groups.hs:3740-3743); `review_acceptAsMember`: «Accept» opens «Accept member» / «Member will join the group, accept member?»; «Accept as member» leads to CLI `#team: you joined the group` plus history; `review_acceptAsObserver`: «Accept as observer» leads to the same CLI lines, and bob's role in Group info is «observer»; `review_rejectPendingMember`: «Reject» opens «Reject member?», and confirming leads to CLI `#team: alice removed you from the group (signed)` / `use /d #team to delete the group` (the removal lines follow the pattern of testGLinkDeletePendingApprovalMember :3986-3988); `review_acceptFromLongPressMenu`: right-click on the pending row in «Chats with members» offers «Accept», which opens the same «Accept member» alert; «Accept as member» leads to CLI `#team: you joined the group` (MemberSupportView.kt:147,272-276; V/chat/ComposeContextPendingMemberActionsView.kt:84-110). Review flow: testGLinkReviewMember H/Groups.hs:3678-3785 | P | bob is the CLI joiner |
-| alice as moderator reviews | as above | same | `review_moderatorAcceptsMember` | CLI host: `#team: alice accepted cath to the group (will introduce remaining members)` (H/Groups.hs:3775, names substituted) | P ×2 | bob is the CLI host, cath the joiner |
-| alice as joiner pending review | «Paste link» with the link of a CLI group that has review on ▸ «Open group» ▸ «Join group» | V/newchat/NewChatView.kt:673-675; V/chat/ChatView.kt:246-256; C/model/ChatModel.kt:1711,1746 | `joinerPendingReview_supportChatAutoOpens`, `joinerPendingReview_messagesAdmins`, `joinerPendingReview_acceptedByAdmin`, `joinerPendingReview_rejected` | Support chat opens automatically; main compose shows «reviewed by admins»; the group row shows the grey (pending) flag. CLI host sees `#team (support: alice) alice> hello`; after `/accept member #team @alice` (`Library/Commands.hs:6274`) history appears for alice and the main compose field is enabled («reviewed by admins» gone, C/model/ChatModel.kt:1711-1713); after `/rm team alice` alice's compose shows «removed from group» (testGLinkDeletePendingApprovalMember H/Groups.hs:3985-3988, roles swapped) | P, CB | bob is the CLI host; review applies only to members who join by link (src/Simplex/Chat/Library/Commands.hs:2881-2886) |
-| Host "pending approval" | — | H/Groups.hs:3614 (testGLinkApproveMember) | `admission_hostPendingApproval` | — | IGNORE: host "pending approval" needs Haskell `chatHooks` (plan §11.3) | — |
-| Join rejected by host hook | — | H/Groups.hs:3585 (testGLinkRejectBlockedName) | `admission_joinRejectedByHook` | — | IGNORE: "join rejected" needs Haskell `chatHooks` (plan §11.3) | — |
+| Admission setting | «Group preferences» ▸ «Member admission» ▸ «Review members» off/all | V/chat/group/MemberAdmission.kt:27-156 |  | Enabling «all» and saving is the setup of every `review_*` test; its effect (the next link joiner is pending review) is asserted there. CLI form `/set admission review #team all` (H/Groups.hs:3728) | P | — Tests: merged into review_acceptAsMember (was memberAdmission_enableReviewAll); read-only case merged into groupPrefs_readOnlyForMember (was memberAdmission_readOnlyForNonOwner) |
+| Admission setting, unsaved | «Member admission» | V/chat/group/MemberAdmission.kt:50-55,83-90,148-156 | `memberAdmission_unsavedChangesAlert` | «Review members» «off» → «all»; Back shows «Save admission settings?» / «Save and notify group members» / «Exit without saving»; «Exit without saving» keeps it unset (model) and the reopened screen shows «off»; selecting again and confirming saves «all» (model, reopened screen) | — | Admission changes create no chat item for alice |
+| alice as host accepts a CLI joiner as member | «Chats with members» ▸ pending row ▸ compose «Accept» | V/chat/group/MemberSupportView.kt:88-96,134-150,166-178; V/chat/ComposeContextPendingMemberActionsView.kt:24-126; V/chat/ComposeView.kt:1730-1744 | `review_acceptAsMember` | alice's «Chats with members» first shows «No chats with members»; she enables review «all» through «Member admission» and creates a link; bob joins (`connection request sent!`, then in any order `#team: alice accepted you to the group, pending review`, `#team: joining the group...`, `#team: you joined the group, connecting to group moderators for admission to group`, View.hs:1347,1362,1387). alice's main-group `before review` does not reach bob. bob's row shows `bob` / «pending review»; it opens his support chat with «New member wants to join the group.» and «Reject» / «Accept». alice's support message reaches bob as `#team (support) alice> hi` (scope-marked, his next line) and is not added to alice's main chat; bob's `#team (support) hello` appears there. «Accept» ▸ «Accept member» / «Member will join the group, accept member?» ▸ «Accept as member»: bob's next two lines are exactly `#team: you joined the group` and `#team alice> before review [>>]` (no support message in the history), the support chat closes, bob's row shows «member»; reopened, his support chat has no «Accept» / «Reject»; alice's `after accept` is bob's next line (testGLinkReviewMember H/Groups.hs:3725-3830). (was also review_pendingMemberListedInChatsWithMembers, review_hostChatsWithPendingMember; §12 chatsWithMembers_emptyState, the open part of chatsWithMembers_listSearchAndOpen) | P | bob is the CLI joiner. The row flag icons (MemberSupportView.kt:254-260, V/chatlist/ChatPreviewView.kt:393-396) have no content description and are not asserted. Review is enabled before bob connects (the admission=all bypass race needs a concurrent profile update) |
+| alice as host accepts as observer from the row menu | «Chats with members» ▸ pending row ▸ right click / long press ▸ «Accept» | V/chat/group/MemberSupportView.kt:147,269-276; V/helpers/Section.kt:262; V/chat/ComposeContextPendingMemberActionsView.kt:98-103 | `review_acceptAsObserver` | The row menu's «Accept» opens the same «Accept member» alert; «Accept as observer» gives bob `#team: you joined the group` and his row «observer»; bob's `#team hi` gets `#team: you don't have permission to send messages` (View.hs:2831-2833); alice's later message reaches him. (was also review_acceptFromLongPressMenu) | P | bob is the CLI joiner |
+| alice as host rejects a CLI joiner | «Chats with members» ▸ pending row ▸ compose «Reject» | V/chat/ComposeContextPendingMemberActionsView.kt:42-54,73-82; V/chat/group/MemberSupportView.kt:89 | `review_rejectPendingMember` | «Reject» opens «Reject member?» with «Reject» / «Cancel»; «Cancel» keeps bob pending and sends nothing (alice's next support message is bob's next line); confirming gives bob exactly `#team: alice removed you from the group (signed)` / `use /d #team to delete the group` (View.hs:537, H/Groups.hs:4029-4032), the support chat closes and «Chats with members» shows «No chats with members». (was also §12 chatsWithMembers_removedMemberChatGone and the after-state of chatsWithMembers_emptyState) | P | bob is the CLI joiner |
+| alice as moderator reviews | as above | same |  | Accepting as moderator runs the same app code as `review_acceptAsMember` / `review_acceptAsObserver`; the moderator-only «Chats with members» row (V/chat/group/GroupChatInfoView.kt:693-696) is asserted in `groupPrefs_readOnlyForMember`. The full row needs a second CLI peer and two extra handshakes (plan §15.4.1); core path H/Groups.hs:3819-3820 | — | — Tests: dropped (was review_moderatorAcceptsMember) |
+| alice as joiner pending review | Link of a CLI group with review on (joined through the API, joining by link is §8) | V/chat/ChatView.kt:248-258; C/model/ChatModel.kt:1726-1729; C/model/SimpleXAPI.kt:3300-3320 | `joinerPendingReview_acceptedByAdmin` | bob (CLI host) has `/set admission review #team all`; after alice joins (`alice: accepting request to join group #team...`, `#team: alice connected and pending review`, View.hs:542,1371) and opens the group, «Chat with admins» opens by itself with «Please wait for group moderators to review your request to join the group.»; on desktop the group's compose shows «reviewed by admins» (on Android the support chat covers it). alice's support message reaches bob as `#team (support: alice) alice> hello admins`; bob's `#team while pending` does not reach alice while his later `#team (support: alice) hi alice` does. After `/accept member #team alice` (`#team: alice accepted`, View.hs:1374-1377; parser src/Simplex/Chat/Library/Commands.hs:6519) the support chat closes, «reviewed by admins» is gone, and alice's `hi all` is bob's next line. (was also joinerPendingReview_supportChatAutoOpens, joinerPendingReview_messagesAdmins; joinerPendingReview_rejected dropped: after `/rm` the app shows the generic «removed from group» state, C/model/ChatModel.kt:1761, the path of any removed member, core-tested at H/Groups.hs:4011-4034) | P | bob is the CLI host; review applies only to members who join by link (src/Simplex/Chat/Types.hs:1459-1464, Library/Internal.hs:1059); bob's group has history off (core default), so `while pending` never arrives |
+| Host "pending approval" | — | H/Groups.hs:3658 (testGLinkApproveMember) | `admission_hostPendingApproval` | — | IGNORE: host "pending approval" needs Haskell `chatHooks` (plan §11.3) | — |
+| Join rejected by host hook | — | H/Groups.hs:3629 (testGLinkRejectBlockedName) | `admission_joinRejectedByHook` | — | IGNORE: "join rejected" needs Haskell `chatHooks` (plan §11.3) | — |
 
-### 7. Group link (14 tests)
+### 7. Group link (9 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Create | Group info ▸ «Create group link» | V/chat/group/GroupLinkView.kt:30-169 | `groupLink_createdAutomatically` | «Group link» opens and creates the link by itself: QR code, «Initial role», «Share link», «Delete link» | — | — |
-| Full/short toggle | «Group link» ▸ «Full link»/«Short link» | V/chat/group/GroupLinkView.kt:232-239; V/newchat/NewChatView.kt:585-596 | `groupLink_toggleFullShortLink` | The toggle switches the QR code between the short and full link. It is shown for groups with a short link, not for channels, and only with developer tools on | DT | — |
-| Share link | «Share link» | V/chat/group/GroupLinkView.kt:255-262 | `groupLink_shareCopiesShortLink` | «Share link» copies the short link to the clipboard | CB | — |
+| Create | Group info ▸ «Create group link» | V/chat/group/GroupLinkView.kt:30-169 |  | «Group link» opens and creates the link by itself: QR code, «Initial role», «Share link», «Delete link» | — | `groupLink_createdAutomatically` merged into `groupLink_cliJoinsViaFullLink` (its first steps) |
+| Full/short toggle | «Group link» ▸ «Full link»/«Short link» | V/chat/group/GroupLinkView.kt:232-239; V/newchat/NewChatView.kt:594-605 |  | The toggle switches the QR code between the short and full link. It is shown for groups with a short link, not for channels, and only with developer tools on | DT | `groupLink_toggleFullShortLink` merged into `groupLink_cliJoinsViaFullLink` |
+| Share link | «Share link» | V/chat/group/GroupLinkView.kt:252-262 |  | «Share link» copies the short link to the clipboard | CB | `groupLink_shareCopiesShortLink` merged into `groupLink_cliJoinsViaFullLink` (the first share is the short link) |
 | CLI joins (short link) | CLI `/c <link>` | V/chat/group/GroupLinkView.kt:250-265 | `groupLink_cliJoinsViaShortLink` | CLI `/c` gives `connection request sent!`, `#team: joining the group...`, `#team: you joined the group`; alice gets «invited via your group link» (testGroupLink, H/Groups.hs:3086) | P | — |
-| CLI joins (full link) | «Full link» toggle ▸ CLI `/c <full link>` | V/chat/group/GroupLinkView.kt:250-265 | `groupLink_cliJoinsViaFullLink` | CLI `/c` gives `connection request sent!`, `#team: joining the group...`, `#team: you joined the group`; alice gets «invited via your group link» (testGroupLink, H/Groups.hs:3086) | P, DT | The «Full link»/«Short link» toggle is visible only with developer tools (NewChatView.kt:585) |
-| Initial role | «Initial role» member/observer | V/chat/group/GroupLinkView.kt:133-145,305-320 | `groupLink_initialRoleObserver`, `groupLink_changeInitialRoleBackToMember` | `groupLink_initialRoleObserver`: observer joiner: `#team: you don't have permission to send messages` (testGroupLinkMemberRole, H/Groups.hs:3350,3384-3385); `groupLink_changeInitialRoleBackToMember`: after «Initial role» is set back to «member» (`apiGroupLinkMemberRole`, V/chat/group/GroupLinkView.kt:133-145), the next CLI joiner joins as a member: its `#team hi` is delivered and shows in alice's group (as bob's `#team hey now` after promotion, H/Groups.hs:3391-3392) | P | — |
-| Delete link | «Delete link» | V/chat/group/GroupLinkView.kt:146-162 | `groupLink_deleteKeepsMembers`, `groupLink_deletedLinkRejectsJoin` | `groupLink_deleteKeepsMembers`: «Delete link?» / «All group members will remain connected.»; the member who joined stays and still gets alice's messages; `groupLink_deletedLinkRejectsJoin`: the CLI first repeats `/_connect plan 1 <link>` until it prints `error: connection authorization failed - …` (the GUI's deletion reaches the server later, in a background thread, simplexmq `Agent.hs:1013-1015`; the plan reads the link from the server, `Library/Commands.hs:4546`), then a CLI connecting with the deleted link gets `error: connection authorization failed - this could happen if connection was deleted, secured with different credentials, or due to a bug - please re-create the connection` (`src/Simplex/Chat/View.hs:2922-2924`; same as with a deleted address, H/Profiles.hs:1835-1841), and alice's group gets no new member | P | — |
+| CLI joins (full link) | «Full link» toggle ▸ CLI `/c <full link>` | V/chat/group/GroupLinkView.kt:226-262; V/newchat/NewChatView.kt:594-605 | `groupLink_cliJoinsViaFullLink` | Group info shows «Create group link» and no «Group link» row; «Create group link» opens «Group link», which creates the link by itself: the QR code, «Initial role» (key `Ui.GroupLink.Role`), «Share link» and «Delete link», and no «Full link» toggle without developer tools; «Share link» shares the short link (no `/contact#/?v=`); with developer tools on the toggle (key `Ui.Link.ShortLinkToggle`) reads «Full link», and after clicking it («Short link») «Share link» shares the full link; CLI `/c <full link>` gives `connection request sent!`, `#team: joining the group...`, `#team: you joined the group`, and bob is listed as connected in alice's members (testGroupLink, H/Groups.hs:3086) | P, DT, CB | The «Full link»/«Short link» toggle is visible only with developer tools (NewChatView.kt:595); developer tools are turned on through the pref (`enableDeveloperToolsViaApi`), a precondition |
+| Initial role | «Initial role» member/observer | V/chat/group/GroupLinkView.kt:134-146,307-321 | `groupLink_initialRoleObserver` | «Initial role» (key `Ui.GroupLink.Role`) reads «member»; after «observer» is picked the core's link role is observer (`apiGetGroupLink`), and bob, joining with the shared link, gets `#team: you don't have permission to send messages` for `#team hi there` (testGroupLinkMemberRole, H/Groups.hs:3428-3429); after «Initial role» is set back to «member» (`apiGroupLinkMemberRole`, V/chat/group/GroupLinkView.kt:134-146) and the core's role is member again, cath joins with the same link as a member: her `#team hello from cath` shows in alice's group, and bob's `hi there` never does (as bob's `#team hey now` after promotion, H/Groups.hs:3435-3436) | P | `groupLink_changeInitialRoleBackToMember` merged into `groupLink_initialRoleObserver` |
+| Delete link | «Delete link» | V/chat/group/GroupLinkView.kt:147-163,281-289 | `groupLink_deleteKeepsMembers` | «Delete link» → «Delete link?» / «All group members will remain connected.» / «Delete»; the screen then offers «Create link»; the member who joined (bob) stays connected in alice's members and gets alice's next message; for the deleted link the CLI (cath) first repeats `/_connect plan 1 <link>` until it prints `error: connection authorization failed - …` (the GUI's deletion reaches the server later, in a background thread, simplexmq `Agent.hs:1013-1015`; the plan reads the link from the server, `Library/Commands.hs:4546`), then a CLI connecting with the deleted link gets `error: connection authorization failed - this could happen if connection was deleted, secured with different credentials, or due to a bug - please re-create the connection` (`src/Simplex/Chat/View.hs:2922-2924`; same as with a deleted address, H/Profiles.hs:1835-1841), and alice's group gets no new member | P | `groupLink_deletedLinkRejectsJoin` merged into `groupLink_deleteKeepsMembers` |
 | Creation step | Incognito group creation (§1) ▸ «Continue» | V/chat/group/GroupLinkView.kt:119-123,279-296 | `groupLink_creationStepContinue` | After the link is created by itself, «Continue» closes the step and leaves the group chat open; this step has no «Delete link» | — | The step opens only from incognito group creation; opening it is tested by `createGroupIncognito_opensGroupLinkStep` |
-| Rejoin / merge | CLI `/c <link>` | V/chat/group/GroupLinkView.kt:250-265 | `groupLink_memberRejoinsAfterDeletingGroup`, `groupLink_existingContactMergedWithMember` | Rejoin: CLI `/l team`, `/d #team`, then `/c <link>` again gives `connection request sent!` … `#team: you joined the group`, and alice sees bob as a member again (testGroupLinkDeleteGroupRejoin, H/Groups.hs:2793). Merge: bob, already alice's contact, joins via the link; CLI `contact and member are merged: alice, #team alice_1` / `use @alice <message> to send messages`, and alice's member row for bob opens the existing contact (testGroupLinkExistingContactMerged, H/Groups.hs:3542) | P | — |
+| Rejoin / merge | CLI `/c <link>` | V/chat/group/GroupLinkView.kt:250-265 | `groupLink_memberRejoinsAfterDeletingGroup`, `groupLink_existingContactMergedWithMember` | Rejoin: CLI `/l team`, `/d #team`, then `/c <link>` again gives `connection request sent!` … `#team: you joined the group`, and alice sees bob as a member again (testGroupLinkDeleteGroupRejoin, H/Groups.hs:2793). Merge: bob, already alice's contact, joins via the link; CLI `contact and member are merged: alice, #team alice_1` / `use @alice <message> to send messages`; in reopened group info bob's member is linked to the existing contact and alice has no second chat with bob; the member's «Message» button (`Ui.MemberInfo.Message`, V/chat/group/GroupMemberInfoView.kt:499-513) opens the existing chat, and alice's message there reaches bob as `alice> …` (testGroupLinkExistingContactMerged, H/Groups.hs:3586) | P | `groupLink_existingContactMergedWithMember` reopens group info after the merge: the app has no handler for the core's `contactAndMemberAssociated` event (`Library/Subscriber.hs:3193,3200`), so members loaded before the merge keep `memberContactId = null` until group info reloads them |
 | Upgrade old link | «Upgrade group link» | V/chat/group/GroupLinkView.kt:57-88,241-249 | `groupLink_upgradeOldLink` | «Upgrade group link» opens «Upgrade group link?»; «Upgrade» adds a short link, and the «Upgrade group link» row disappears | FIXTURE (group link without short-link data) | Only shown for links without short-link data; the fixture database is created by a pre-short-link CLI release on the GUI database path |
 | Share old link | «Share link» ▸ «Upgrade group link?» ▸ «Share old link» | V/chat/group/GroupLinkView.kt:72-117,255-258 | `groupLink_shareOldLink` | «Share old link» puts the existing link, not upgraded, on the clipboard (the full link in `https://simplex.chat/` form when there is no short link, C/model/SimpleXAPI.kt:7342-7351) | FIXTURE (group link without short-link data), CB | — |
 
-### 8. Joining (alice as joiner), connect-plan states, invitations (24 tests)
+### 8. Joining (alice as joiner), connect-plan states, invitations (17 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Short link → prepared group | New chat ▸ «Paste link» ▸ alert «Open group» ▸ «Join group» | V/newchat/ConnectPlan.kt:249-263,750-805; V/chat/ComposeView.kt:1767-1774,693 | `joinGroup_pasteShortLinkPrepareAndJoin`, `joinGroup_preparedShowsWelcomeBeforeJoin`, `joinGroup_preparedJoinIncognito`, `joinGroup_preparedChangeProfile` | Banner «Tap Join group». `joinGroup_preparedShowsWelcomeBeforeJoin`: with the host's `/set welcome #team Welcome!`, the prepared group chat already shows "Welcome!" before «Join group» (testGroupShortLinkWelcome H/Profiles.hs:4611-4628). CLI host: `<name>: accepting request to join group #team...`, `#team: <name> joined the group`, where `<name>` is `alice`, the incognito name for `joinGroup_preparedJoinIncognito`, and the second profile's name for `joinGroup_preparedChangeProfile` (testShortLinkPrepareGroup H/Profiles.hs:4538; testGroupShortLinkWelcome :4611; testShortLinkConnectPreparedGroupIncognito :4870; testShortLinkChangePreparedGroupUser :4908) | P, CB | Incognito comes from the app pref or the profile picker (ComposeContextProfilePickerView); `joinGroup_preparedChangeProfile` needs a second chat profile, picked in the profile picker |
-| Full link alert | paste full link | V/newchat/ConnectPlan.kt:264-276,448-504,408-437 | `joinGroup_fullLinkCurrentProfile`, `joinGroup_fullLinkIncognito`, `joinGroup_cancelAlert` | `joinGroup_fullLinkCurrentProfile`: «Join group?»; «Use current profile» → «Connection request sent!»; the host prints `alice: accepting request to join group #team...` then `#team: alice joined the group` (`src/Simplex/Chat/View.hs:536`); `joinGroup_fullLinkIncognito`: «Use new incognito profile» → the host sees a random name: `<rand>: accepting request to join group #team...` (testGroupLinkInviteeIncognito, H/Groups.hs:3483-3500); `joinGroup_cancelAlert`: «Cancel» closes the alert without connecting: no group appears in alice's list and the host prints nothing (V/newchat/ConnectPlan.kt:493-498) | P, CB | The current-build host is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full group link |
+| Short link → prepared group | New chat ▸ «Paste link» ▸ alert «Open group» ▸ «Join group» | V/newchat/ConnectPlan.kt:249-263,750-805; V/chat/ComposeView.kt:1767-1774,693 | `joinGroup_pasteShortLinkPrepareAndJoin`, `joinGroup_preparedJoinIncognito`, `joinGroup_preparedChangeProfile` | Banner «Tap Join group». `joinGroup_preparedShowsWelcomeBeforeJoin`: with the host's `/set welcome #team Welcome!`, the prepared group chat already shows "Welcome!" before «Join group» (testGroupShortLinkWelcome H/Profiles.hs:4611-4628). CLI host: `<name>: accepting request to join group #team...`, `#team: <name> joined the group`, where `<name>` is `alice`, the incognito name for `joinGroup_preparedJoinIncognito`, and the second profile's name for `joinGroup_preparedChangeProfile` (testShortLinkPrepareGroup H/Profiles.hs:4538; testGroupShortLinkWelcome :4611; testShortLinkConnectPreparedGroupIncognito :4870; testShortLinkChangePreparedGroupUser :4908) | P, CB | Incognito comes from the app pref or the profile picker (ComposeContextProfilePickerView); `joinGroup_preparedChangeProfile` needs a second chat profile, picked in the profile picker. The tests enter the link in the chat-list search field, which plans typed links (V/chatlist/ChatListView.kt:833-845). `joinGroup_preparedShowsWelcomeBeforeJoin` merged into `joinGroup_pasteShortLinkPrepareAndJoin` |
+| Full link alert | paste full link | V/newchat/ConnectPlan.kt:264-276,448-504,408-437 | `joinGroup_fullLinkCurrentProfile`, `joinGroup_fullLinkIncognito` | `joinGroup_fullLinkCurrentProfile`: «Join group?»; «Use current profile» → «Connection request sent!»; the host prints `alice: accepting request to join group #team...` then `#team: alice joined the group` (`src/Simplex/Chat/View.hs:536`); `joinGroup_fullLinkIncognito`: «Use new incognito profile» → the host sees a random name: `<rand>: accepting request to join group #team...` (testGroupLinkInviteeIncognito, H/Groups.hs:3483-3500); `joinGroup_cancelAlert`: «Cancel» closes the alert without connecting: no group appears in alice's list and the host prints nothing (V/newchat/ConnectPlan.kt:493-498) | P, CB | The current-build host is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full group link. `joinGroup_cancelAlert` merged into `joinGroup_fullLinkCurrentProfile` (Cancel first, then the host's next line is the accepted join) |
 | Retry after server error | prepared group ▸ «Join group» while smp1 is stopped | V/chat/ComposeView.kt:693; C/model/SimpleXAPI.kt:842-869,891-901 | `joinGroup_retryAfterServerError` | Alert «Connection error» with «Retry»; start smp1, «Retry» → CLI host bob: `alice: accepting request to join group #team...`, `#team: alice joined the group` (core behaviour: testShortLinkGroupRetry, H/Profiles.hs:4645) | P, SRVCTL, CB | The app's agent caches a failed server connection for 3 s (`persistErrorInterval`, 3 s in the app and in `testAgentCfg`; only some Haskell tests set it to 0, e.g. `H/Profiles.hs:253`), so «Retry» comes more than 3 s after the failure, after smp1 is started again |
-| Plan: known | paste again | V/newchat/ConnectPlan.kt:322-336,645-688 | `connectPlan_knownGroupOpensGroup`, `connectPlan_knownGroupShowsRole` | `connectPlan_knownGroupOpensGroup`: the alert names "team" and «Open group» opens the group chat; `connectPlan_knownGroupShowsRole`: alice joined through the link with its default role member, so the alert reads «You are a member» (with an observer role it would read «You are an observer») (V/newchat/ConnectPlan.kt:645-688) (testPlanGroupLinkKnown, H/Groups.hs:4094) | P, CB | — |
-| Plan: own link | paste own link | V/newchat/ConnectPlan.kt:277-285,553-643 | `connectPlan_ownGroupLinkOpenGroup`, `connectPlan_ownGroupLinkJoinAsSecondMember` | «Join your group?» ▸ «Open group» opens the group; «Join your group?» ▸ «Use current profile» → a second "team" group appears in the chat list (testPlanGroupLinkOwn, H/Groups.hs:2931) | CB | — |
-| Plan: connecting | — | V/newchat/ConnectPlan.kt:286-321 | `connectPlan_connectingAllowsReconnect`, `connectPlan_connectingProhibit` | Host bob stopped. `connectPlan_connectingAllowsReconnect`: paste bob's full link, «Use current profile», paste it again → «Repeat join request?» with «Use current profile» / «Use new incognito profile» in red (ConnectPlan.kt:286-297; testPlanGroupLinkConnecting, H/Groups.hs:4132). `connectPlan_connectingProhibit`: paste the short link, «Open group», «Join group», then paste bob's full link → «Group already exists!» (ConnectPlan.kt:302-306; the group is found by `via_group_link_uri_hash`, stored at src/Simplex/Chat/Store/Shared.hs:964 and read at src/Simplex/Chat/Store/Groups.hs:2867; membership not yet active, src/Simplex/Chat/Library/Commands.hs:4715-4716). Pasting the short link again gives the known-group alert instead (Commands.hs:4537,4584-4588) | P, PEERCTL, CB | The current-build host is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full group link. CLI host stopped. «Already joining the group!» needs the deprecated pre-`x.grp.link.inv` host protocol and is not tested |
+| Plan: known | paste again | V/newchat/ConnectPlan.kt:322-336,645-688 |  | `connectPlan_knownGroupOpensGroup`: the alert names "team" and «Open group» opens the group chat; `connectPlan_knownGroupShowsRole`: alice joined through the link with its default role member, so the alert reads «You are a member» (with an observer role it would read «You are an observer») (V/newchat/ConnectPlan.kt:645-688) (testPlanGroupLinkKnown, H/Groups.hs:4094) | P, CB | `connectPlan_knownGroupOpensGroup` and `connectPlan_knownGroupShowsRole` merged into `joinGroup_pasteShortLinkPrepareAndJoin` (alice pastes the link again after joining, from Private notes) |
+| Plan: own link | paste own link | V/newchat/ConnectPlan.kt:277-285,553-643 | `connectPlan_ownGroupLinkJoinAsSecondMember` | «Join your group?» ▸ «Open group» opens the group; «Join your group?» ▸ «Use current profile» → a second "team" group appears in the chat list (testPlanGroupLinkOwn, H/Groups.hs:2931); a message sent in the first team arrives in the second | CB | `connectPlan_ownGroupLinkOpenGroup` merged into `connectPlan_ownGroupLinkJoinAsSecondMember` |
+| Plan: connecting | — | V/newchat/ConnectPlan.kt:286-321 | `connectPlan_connectingAllowsReconnect`, `connectPlan_connectingProhibit` | Host bob stopped. `connectPlan_connectingAllowsReconnect`: paste bob's full link, «Use current profile», paste it again → «Repeat join request?» with «Use current profile» / «Use new incognito profile» in red (ConnectPlan.kt:286-297; testPlanGroupLinkConnecting, H/Groups.hs:4132). `connectPlan_connectingProhibit`: paste the short link, «Open group», «Join group», then paste bob's full link → «Group already exists!» (ConnectPlan.kt:302-306; the group is found by `via_group_link_uri_hash`, stored at src/Simplex/Chat/Store/Shared.hs:964 and read at src/Simplex/Chat/Store/Groups.hs:2867; membership not yet active, src/Simplex/Chat/Library/Commands.hs:4715-4716). Pasting the short link again gives the known-group alert instead (Commands.hs:4537,4584-4588) | P, PEERCTL, CB | The current-build host is started with `--show-full-links` (`src/Simplex/Chat/Options.hs:435`) so it prints the full group link. CLI host stopped. «Already joining the group!» needs the deprecated pre-`x.grp.link.inv` host protocol and is not tested. `connectPlan_connectingProhibit` checks the full-link alert, that no second group or pending connection is created, and the join completing once bob starts; the short-link re-paste is not asserted |
 | Plan: rejoin | — | V/newchat/ConnectPlan.kt:249-276 (`GroupLinkPlan.Ok`) | `connectPlan_rejoinAfterLeaving` | Plan is OK again after leaving (testPlanGroupLinkLeaveRejoin, H/Groups.hs:2973) | P, CB | — |
 | Plan: newer version required | bob (CLI channel owner) changes the channel's stored type: `/sql chat UPDATE group_profiles SET group_type='group' WHERE group_profile_id=(SELECT group_profile_id FROM groups WHERE local_display_name='team')` (`/sql chat` is unguarded in the CLI, src/Simplex/Chat/Library/Commands.hs:676, 6097), then `/gp team team <new description>` republishes the link data with that type (:4154); alice types the link into the chat-list search field, which plans typed links (`ChatListView.kt:833-845`) | V/newchat/ConnectPlan.kt:364-380 | `connectPlan_groupLinkRequiresNewerVersion` | Any link type other than channel gives `GLPUpdateRequired` (Commands.hs:4549, 4582); the GUI shows the open-chat alert with the subtitle «This group requires a newer version of the app. Please update the app to join.» | P, RELAY | — |
 | Invitation item and row (compatibility) | invitation item in the direct chat with bob; group row in the chat list | V/chat/item/CIGroupInvitationView.kt:26,75-118; V/chatlist/ChatListNavLinkView.kt:196-199,902-917 | `groupInvitation_tapToJoin`, `groupInvitation_tapRowShowsJoinAlert` | Item in the direct chat: «You are invited to group» / «Tap to join»; tapping it joins. Tapping the group row opens the «Join group?» alert; «Join» joins. CLI host: `#team: alice joined the group` (createGroup2', H/Utils.hs:815) | P, S | bob is the CLI host |
-| Sent invitation item | alice invites bob from her group | V/chat/item/CIGroupInvitationView.kt:75-118 | `groupInvitation_hostSeesSentInvitationItem` | In alice's direct chat with bob: «You sent group invitation»; bob's CLI prints `#team: alice invites you to join the group as member` | P, S | alice is the host |
-| Invitation menu, delete | group row menu | V/chatlist/ChatListNavLinkView.kt:303-336,475-483,486-506; V/chat/group/GroupChatInfoView.kt:212-234 | `groupInvitation_joinFromChatListMenu`, `groupInvitation_deleteInvitation` | Row menu «Join»/«Delete»; `groupInvitation_joinFromChatListMenu`: «Join» joins, and the CLI host prints `#team: alice joined the group` (`apiJoinGroup`, V/chatlist/ChatListNavLinkView.kt:488-510); `groupInvitation_deleteInvitation`: «Delete» → «Delete group?» («Group will be deleted for you - this cannot be undone!») → «Delete» removes the invitation (testGroupDeleteWhenInvited H/Groups.hs:882) | P | bob is the CLI host |
+| Sent invitation item | alice invites bob from her group | V/chat/item/CIGroupInvitationView.kt:75-118 |  | In alice's direct chat with bob: «You sent group invitation»; bob's CLI prints `#team: alice invites you to join the group as member` | P, S | alice is the host. `groupInvitation_hostSeesSentInvitationItem` merged into `inviteMembers_selectionCounterAndClear` (§2), which runs with the current CLI only |
+| Invitation menu, delete | group row menu | V/chatlist/ChatListNavLinkView.kt:303-336,475-483,486-506; V/chat/group/GroupChatInfoView.kt:212-234 | `groupInvitation_deleteInvitation` | Row menu «Join»/«Delete»; `groupInvitation_joinFromChatListMenu`: «Join» joins, and the CLI host prints `#team: alice joined the group` (`apiJoinGroup`, V/chatlist/ChatListNavLinkView.kt:488-510); `groupInvitation_deleteInvitation`: «Delete» → «Delete group?» («Group will be deleted for you - this cannot be undone!») → «Delete» removes the invitation (testGroupDeleteWhenInvited H/Groups.hs:882); the host is not notified: its next line is the join of the second invitation | P | bob is the CLI host. `groupInvitation_joinFromChatListMenu` merged into `groupInvitation_deleteInvitation` (two invitations, team deleted, club joined) |
 | Invitation joining state | row tap after accepting | V/chatlist/ChatListNavLinkView.kt:196-200,944-950 | `groupInvitation_tapAfterAcceptShowsJoiningAlert` | bob is stopped once alice's chat list shows the invitation row (`/a team alice` prints its line when the invitation is queued, before delivery); alice accepts; a tap on the row shows «Joining group»; start bob → `#team: alice joined the group` | P, PEERCTL | bob is the CLI host |
 | Incognito invitation | invitation from a contact connected incognito | V/chat/item/CIGroupInvitationView.kt:75-118 | `groupInvitation_incognitoContactJoinsIncognito` | Item label «Tap to join incognito»; alice joins with her incognito profile; the host sees the incognito name | P | bob is the CLI host, connected to alice incognito |
 | Invitation removed by the host | bob deletes the group (or the invitation) before alice joins; the invitation's queue is deleted on the server later, in a background thread (`deleteMembersConnections'` / `deleteMemberConnection'`, src/Simplex/Chat/Library/Internal.hs:2173-2185; simplexmq `Agent.hs:1013-1015`), so bob repeats `/get servers summary 1` until its JSON shows `"_connDeleted":1` (counted when the server confirms the deletion, simplexmq `Agent/Client.hs:2122-2124`); then alice taps «Tap to join» / «Join» | C/model/SimpleXAPI.kt:2436-2438 | `groupInvitation_joinAfterHostDeleted_showsExpiredAlert` | Joining fails with SMP AUTH: alert «Invitation expired!» / «Group invitation is no longer valid, it was removed by sender.»; the group is deleted from alice's chat list. (The «Group invitation expired» item label is unreachable: the core never sets `CIGISExpired`, src/Simplex/Chat/Messages/CIContent.hs:282.) | P | bob is the CLI host |
 
-### 9. Member list and multi-select (10 tests)
+### 9. Member list and multi-select (5 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Rows | Group info member list | V/chat/group/GroupChatInfoView.kt:778-811,1099-1176 | `memberList_rolesAndStatuses` | alice creates #team and invites bob as «admin», then cath as «member» (picked in «New member role»); after both `/j team`: alice's own row reads «you: creator» with «owner» (GroupChatInfoView.kt:772,1150-1152); bob «connected» with «admin»; cath «connected» with no role text, as only owner, admin, moderator and observer are shown (GroupChatInfoView.kt:1104-1107; the host sees both invitees as connected, `/ms team` in H/Groups.hs:437-442); after alice blocks cath for herself (member info «Block member» → «Block member?» / «Block»), cath's row shows «blocked» (GroupChatInfoView.kt:1102-1103; `blocked`, C/model/ChatModel.kt:2857) | P ×2 | — |
+| Rows | Group info member list | V/chat/group/GroupChatInfoView.kt:84-88,759-818,1110-1187 | `memberList_rolesAndStatuses` | alice creates #team («1 members», own row «you: creator» with «owner») and invites cath as «member» first, then bob as «admin» (picked in «New member role»): «3 members»; after both `/j team`: bob «connected» with «admin», cath «connected» with no role text, as only owner, admin, moderator and observer are shown (GroupChatInfoView.kt:1112-1120); bob is listed above cath although invited later, because rows are sorted by role (GroupChatInfoView.kt:88) | P ×2 | The «blocked» row label is checked by `memberInfo_blockForMeHidesMessages` (§10) |
 | Search | search row (over 8 members) | V/chat/group/GroupChatInfoView.kt:766 | `memberList_searchOver8Members` | Filters by name | P ×9 | Members may be invited-only, which avoids 9 joins |
-| Right-click menu as admin | member row | V/chat/group/GroupChatInfoView.kt:1184-1230 | `memberList_contextMenuAsAdmin` | «Block for all», «Remove member», «Select» | P | alice is the owner |
-| Right-click menu as member | member row | V/chat/group/GroupChatInfoView.kt:1184-1230 | `memberList_contextMenuAsMember` | «Block member» | P ×2 | bob is the CLI host, cath another member |
-| Multi-select toolbar | «Select» ▸ bottom toolbar | V/chat/group/GroupChatInfoView.kt:861-943; V/chat/group/GroupMembersToolbar.kt:23 | `memberSelection_removeMultiple`, `memberSelection_blockForAllMultiple`, `memberSelection_unblockForAllMultiple`, `memberSelection_changeRoleToObserver`, `memberSelection_selectAllExcludesModerators` | `memberSelection_removeMultiple`: «Remove members?» → «Remove» (the other button is «Remove and delete messages», GroupChatInfoView.kt:362-389); each removed member's CLI prints `#team: alice removed you from the group (signed)` and their rows leave the member list; `memberSelection_blockForAllMultiple`: «Block members for all?» / «Block for all»; the unselected member prints `#team: alice blocked bob (signed)` and `#team: alice blocked cath (signed)` (testBlockForAllMultipleMembers, H/Groups.hs:7681-7683); `memberSelection_unblockForAllMultiple`: with both blocked members selected, the toolbar's block button unblocks: «Unblock members for all?» / «Unblock for all»; the unselected member prints `#team: alice unblocked bob (signed)` and `#team: alice unblocked cath (signed)` (H/Groups.hs:7697-7700); `memberSelection_changeRoleToObserver`: «Change role?» / «Change»; each selected member prints `#team: alice changed your role from member to observer (signed)` (V/chat/group/GroupMembersToolbar.kt:80; V/chat/group/GroupMemberInfoView.kt:993-1005); `memberSelection_selectAllExcludesModerators`: with dan made a moderator first, the select-all button selects only bob and cath (members below moderator, V/chat/group/GroupChatInfoView.kt:925-935) | P ×3 | Toolbar icons have null content descriptions; found by their keys |
+| Right-click menu as admin | member row | V/chat/group/GroupChatInfoView.kt:1195-1225 | | «Block for all», «Remove member», «Select»; «Unblock for all» instead of «Block for all» on a member blocked for all | P | `memberList_contextMenuAsAdmin` merged into `memberSelection_blockUnblockAndRemoveMultiple` |
+| Right-click menu as member | member row | V/chat/group/GroupChatInfoView.kt:1184-1230 |  | «Block member» | P ×2 | bob is the CLI host, cath another member. `memberList_contextMenuAsMember` merged into `memberInfo_blockedByAdminShownToMember` (§10): «Block member» then «Unblock member» from the row menu, no moderator items, and no menu once cath is blocked by admin (GroupChatInfoView.kt:1228) |
+| Multi-select toolbar | «Select» ▸ bottom toolbar | V/chat/group/GroupChatInfoView.kt:866-948; V/chat/group/GroupMembersToolbar.kt:25 | `memberSelection_blockUnblockAndRemoveMultiple`, `memberSelection_selectAllExcludesModerators` | `memberSelection_blockUnblockAndRemoveMultiple` (bob, cath, dan members): «Select» on bob, tap cath («Selected 2»), toolbar block ▸ «Block members for all?» / «Block for all»: dan prints `#team: alice blocked bob (signed)` and `#team: alice blocked cath (signed)` (testBlockForAllMultipleMembers, H/Groups.hs:7938) and both rows read «blocked»; selecting both again, the same button unblocks: «Unblock members for all?» / «Unblock for all», dan prints `#team: alice unblocked bob (signed)` and `… cath (signed)`; selecting both again, toolbar delete ▸ «Remove members?» («Remove» / «Remove and delete messages», GroupChatInfoView.kt:364-393) ▸ «Remove»: bob and cath print `#team: alice removed you from the group (signed)`, dan prints `#team: alice removed bob from the group (signed)` and `… cath …`, and group info reads «2 members» with only dan listed; `memberSelection_selectAllExcludesModerators`: with dan made a moderator first, tapping dan in selection mode leaves «Selected 1», and the select-all button selects only bob and cath («Selected 2», members below moderator, GroupChatInfoView.kt:928-941); toolbar role ▸ «Change role?» / «Change»: bob and cath print `#team: alice changed your role from member to observer (signed)`, dan prints the two `changed the role of …` lines and then alice's next message, so his own role did not change (V/chat/group/GroupMemberInfoView.kt:1004-1018) | P ×3 | `memberSelection_removeMultiple`, `memberSelection_blockForAllMultiple` and `memberSelection_unblockForAllMultiple` merged into `memberSelection_blockUnblockAndRemoveMultiple`; `memberSelection_changeRoleToObserver` merged into `memberSelection_selectAllExcludesModerators`. Toolbar icons have null content descriptions; found by their keys |
 | Member inactive | alice is in group `team` with bob; `restart(fixture)` sets `quota_err_counter = 5` on alice's connection to bob (`/sql chat UPDATE connections SET quota_err_counter=5 WHERE group_member_id=<bob's local group_member_id>`, the row id, not the MemberId) | H/Groups.hs:7743; V/chat/group/GroupChatInfoView.kt:1117-1118; C/model/ChatModel.kt:2057 | `memberList_memberInactive` | `connInactive` is true at 5 or more, and the member list shows bob as "inactive" | P, FIXTURE, RESTART | The real state needs five slow-retry quota warnings (about 41 minutes: 5 min growing ×1.5, simplexmq Env/SQLite.hs:213-218), so a fixture sets it |
 
-### 10. Member info (28 tests)
+### 10. Member info (22 tests)
 
 Click a member row; `V/chat/group/GroupMemberInfoView.kt`.
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
 | Sections | Group info ▸ member row | :474-731,749 | `memberInfo_openShowsSections` | Header, «Member» section with «Group» and «Change role» (alice is the owner), «Servers» | P | — |
-| Change role | Group info ▸ member row | :149-158,607-611,906,968-991 | `memberInfo_changeRoleToAdmin`, `memberInfo_changeRoleDismissRestores`, `memberInfo_changeRoleOfInvitedMember` | `memberInfo_changeRoleToAdmin`: «Change role?» / «Change». CLI: `#team: alice changed your role from member to admin (signed)`; `memberInfo_changeRoleDismissRestores`: dismissing «Change role?» puts the role picker back to the current role, and the CLI prints nothing (V/chat/group/GroupMemberInfoView.kt:149-155,986-988); `memberInfo_changeRoleOfInvitedMember`: for an invited member: `#team: alice invites you to join the group as member` (testUpdateMemberRole, H/Groups.hs:1641-1664) | P | For `memberInfo_changeRoleOfInvitedMember` alice invites bob with «New member role» admin, then changes him to member before he joins (choosing the current role does nothing, :150); the CLI also prints `use /j team to accept` |
+| Change role | Group info ▸ member row | :151-160,979-1000 | `memberInfo_changeRoleToAdmin`, `memberInfo_changeRoleToObserverCannotSend`, `memberInfo_changeRoleOfInvitedMember` | `memberInfo_changeRoleToAdmin`: «Change role?» / «Change». CLI: `#team: alice changed your role from member to admin (signed)`; `memberInfo_changeRoleToObserverCannotSend`: choosing «observer» opens «Change role?» with «The role will be changed to "observer". Everyone in the group will be notified.»; «Cancel» puts the role picker back to «member» (V/chat/group/GroupMemberInfoView.kt:151-160) and bob prints nothing (his next line is the real change); «Change» → bob: `#team: alice changed your role from member to observer (signed)`; bob's group info row shows «observer» (V/chat/group/GroupChatInfoView.kt:1106-1114); bob's `#team hi` prints `#team: you don't have permission to send messages`; `memberInfo_changeRoleOfInvitedMember`: for an invited member: `#team: alice invites you to join the group as member` (testUpdateMemberRole, H/Groups.hs:1641-1664) | P | `memberInfo_changeRoleDismissRestores` merged into `memberInfo_changeRoleToObserverCannotSend`. For `memberInfo_changeRoleOfInvitedMember` alice invites bob with «New member role» admin, then changes him to member before he joins (choosing the current role does nothing, :152); the CLI also prints `use /j team to accept` |
 | Role of a higher member | Group info ▸ member row | :605-612; C/model/ChatModel.kt:2939-2955 | `memberInfo_roleReadOnlyForHigherRole` | The role row is read-only for a member with a higher role | P | bob is the CLI owner, alice an admin; bob invites her as admin (`/a team alice admin`, src/Simplex/Chat/Library/Commands.hs:6272), so she is an admin when she joins (a later `/mr` would print before it reached her, and as a plain member her role row is read-only too); open bob's member info |
-| Block for me (alice is a plain member) | Group info ▸ member row | :456-472,1022-1048 | `memberInfo_blockForMeHidesMessages`, `memberInfo_unblockForMe` | `memberInfo_blockForMeHidesMessages`: «Block member?» / «Block»; that member's later messages show as «blocked» (V/chat/item/FramedItemView.kt:277-278; V/chat/item/MarkedDeletedItemView.kt:105-106; testMuteGroup, H/Direct.hs:1920); `memberInfo_unblockForMe`: «Unblock member» → «Unblock member?» / «Unblock»; that member's messages sent afterwards show normally (V/chat/group/GroupMemberInfoView.kt:1034-1043); the CLI prints nothing either way | P ×2 | Moderators and above can't block for self (:695-698) |
-| Block for all | Group info ▸ member row | :431-453,1064-1127 | `memberInfo_blockForAllNotifiesMembers`, `memberInfo_unblockForAll`, `memberInfo_blockedByAdminShownToMember` | `memberInfo_blockForAllNotifiesMembers`: «Block member for all?» / «Block for all». cath's CLI: `#team: alice blocked bob (signed)`; bob's CLI prints nothing; bob's later messages print nothing on cath's CLI (src/Simplex/Chat/View.hs:399-402,613); cath's `/tail #team 1` shows `#team bob> <text> [blocked by admin]` (View.hs:777-779; testBlockForAllMarkedBlocked, H/Groups.hs:7259); `memberInfo_unblockForAll`: «Unblock member for all?» / «Unblock for all»; cath's CLI: `#team: alice unblocked bob (signed)`, and bob's next message prints on cath's CLI again (H/Groups.hs:7697-7705); `memberInfo_blockedByAdminShownToMember` (alice a member, bob the CLI host blocks cath): cath's member info shows the disabled «Blocked by admin» row | P ×2 | — |
-| Remove | Group info ▸ member row | :253-365,843-865 | `memberInfo_removeMember`, `memberInfo_removeMemberWithMessages`, `memberInfo_deleteMessagesOfLeftMember`, `memberInfo_reAddRemovedMember` | `memberInfo_removeMember`: «Remove member?» «Remove». CLI: `#team: alice removed you from the group (signed)`; `memberInfo_removeMemberWithMessages`: «Remove and delete messages». CLI: `#team: alice removed you from the group with all messages (signed)`; `memberInfo_deleteMessagesOfLeftMember`: for a member who left: «Delete member messages» → «Delete member messages?» / «Delete messages»; `memberInfo_reAddRemovedMember`: the removed member's contact is offered again in «Invite members» (V/chat/group/AddGroupMembersView.kt:96-110); inviting him prints `#team_1: alice invites you to join the group as member` / `use /j team_1 to accept`, and after `/j team_1` he is back in alice's member list (testGroupRemoveAdd :1102-1135; testDeleteMemberWithMessages :2011; testDeleteMemberMessagesLeftRemoved :2114) | P ×2 | — |
-| Message / call buttons | Group info ▸ member row | :485-543,734-746 | `memberInfo_messageOpensKnownContact`, `memberInfo_callButtonsShowSendMessageAlert` | «message» opens the existing direct chat with bob; for a member who is not a contact, «call»/«video» show «Can't call group member» / «Send message to enable calls.» | P | For `memberInfo_messageOpensKnownContact` bob is alice's contact; for `memberInfo_callButtonsShowSendMessageAlert` bob joins through alice's group link, and alice first turns «Direct messages» on in «Group preferences» (alice-created groups start with it off, V/newchat/AddGroupView.kt:160-162; with it off the buttons show «Direct messages between members are prohibited in this group.», V/chat/group/GroupMemberInfoView.kt:535-543) |
-| Call buttons, direct messages off | Group info ▸ member row | :535-540 | `memberInfo_callButtonsDirectMessagesProhibitedAlert` | Direct messages off: «call»/«video» show «Can't call group member» / «Direct messages between members are prohibited in this group.» | P | The member is not alice's contact; the message button's alert is tested by `groupPrefs_directMessagesOff_memberInfoProhibited` |
-| Verify security code | Group info ▸ member row | :213-243,555-565 | `memberInfo_verifyCodeMatchesCli`, `memberInfo_markVerifiedShowsShield`, `memberInfo_clearVerification` | The code on screen with whitespace and line breaks removed equals the code line of CLI `/code #team alice` with spaces removed (the screen splits it into 24-character lines, V/chat/VerifyCodeView.kt:65,132-136) (the real CLI prints `#team alice security code:`, the code, then a hint, `src/Simplex/Chat/View.hs:2021-2023`); `memberInfo_markVerifiedShowsShield`: «Mark verified» closes the code screen (V/chat/VerifyCodeView.kt:40-45); bob's member info header is `verified` (plan §4; V/chat/group/GroupMemberInfoView.kt:775) and his row becomes «View security code», which reopens the screen showing «bob is verified», its status line `verified` (V/chat/VerifyCodeView.kt:66-72; V/chat/ChatInfoView.kt:1208-1215); `memberInfo_clearVerification`: «Clear verification» turns it back to «bob is not verified» and the row to «Verify security code» (V/chat/VerifyCodeView.kt:105-106) (testMarkGroupMemberVerified, H/Direct.hs:3152) | P | — |
-| Connection stats | Group info ▸ member row | :633-680 | `memberInfo_connectionStatsShowServers`, `memberInfo_networkStatusAlert` | «Receiving via» / «Sending via» show the local server address; clicking the status row opens the «Network status» alert (:637-643) | P | — |
+| Block for me (alice is a plain member) | Group info ▸ member row | :458-474,806-824,1033-1055 | `memberInfo_blockForMeHidesMessages` | bob (CLI) hosts; alice and cath (CLI) are members. «Block member» → «Block member?» / «All new messages from cath will be hidden!» / «Block»; the row turns to «Unblock member» and cath's group info row shows «blocked»; alice's next message is the next line on cath's and bob's CLIs (nothing was sent); cath's later message shows as «blocked» for alice (V/chat/item/MarkedDeletedItemView.kt:93-110; testMuteGroup, H/Direct.hs:1861) while bob prints it and her earlier message keeps its text; «Unblock member» → «Unblock member?» / «Messages from cath will be shown!» / «Unblock»; cath's next message shows with its text, and cath's next line is alice's following message | P ×2 | `memberInfo_unblockForMe` merged into `memberInfo_blockForMeHidesMessages`. Moderators and above can't block for self (:458-474) |
+| Block for all | Group info ▸ member row | :431-453,826-846,1064-1130 | `memberInfo_blockForAllNotifiesMembers`, `memberInfo_unblockForAll`, `memberInfo_blockedByAdminShownToMember` | `memberInfo_blockForAllNotifiesMembers`: «Block member for all?» / «Block for all». cath's CLI: `#team: alice blocked bob (signed)`; bob's CLI prints nothing; bob's later messages print nothing on cath's CLI (src/Simplex/Chat/View.hs:399-402,613); cath's `/tail #team 1` shows `#team bob> <text> [blocked by admin]` (View.hs:777-779; testBlockForAllMarkedBlocked, H/Groups.hs:7563); `memberInfo_unblockForAll`: bob is blocked for all through the API (precondition; cath prints `#team: alice blocked bob (signed)`); bob's `while blocked` shows «blocked by admin»; his member info offers «Unblock for all» → «Unblock member for all?» / «Messages from bob will be shown!» / «Unblock for all»; cath's next line is `#team: alice unblocked bob (signed)` (the blocked message never printed); the row turns back to «Block for all»; bob's next message prints on cath's CLI and shows with its text in alice's chat (H/Groups.hs:7618-7625); `memberInfo_blockedByAdminShownToMember` (alice a member, bob the CLI host blocks cath): cath's member info shows the disabled «Blocked by admin» row | P ×2 | — |
+| Remove | Group info ▸ member row | :255-366,848-862 | `memberInfo_removeMember`, `memberInfo_removeMemberWithMessages`, `memberInfo_deleteMessagesOfLeftMember`, `memberInfo_reAddRemovedMember` | `memberInfo_removeMember`: «Remove member?» «Remove». CLI: `#team: alice removed you from the group (signed)`; `memberInfo_removeMemberWithMessages`: «Remove member?» «Remove and delete messages» (:322-327). bob: `#team: alice removed you from the group with all messages (signed)`, `use /d #team to delete the group`; cath: `#team: alice removed bob from the group with all messages (signed)`; member info closes and bob's earlier message shows «moderated by alice» (C/model/ChatModel.kt:750-790); `memberInfo_deleteMessagesOfLeftMember`: for a member who left: «Delete member messages» → «Delete member messages?» / «Delete messages»; `memberInfo_reAddRemovedMember`: the removed member's contact is offered again in «Invite members» (V/chat/group/AddGroupMembersView.kt:96-110); inviting him prints `#team_1: alice invites you to join the group as member` / `use /j team_1 to accept`, and after `/j team_1` he is back in alice's member list (testGroupRemoveAdd :1146; testDeleteMemberWithMessages :2055-2133; testDeleteMemberMarkMessagesDeleted :2136-2155; testDeleteMemberMessagesLeftRemoved :2158) | P ×2 | `memberInfo_deleteMessagesOfLeftMember` opens the left member's info from her message avatar (V/chat/ChatView.kt:2095), as left members are not listed in Group info (GroupChatInfoView.kt:86-88); bob prints `#team: alice removed cath from the group with all messages (signed)` and her message shows «moderated by alice» |
+| Message / call buttons | Group info ▸ member row | :101-106,485-543,734-746 | `memberInfo_messageOpensKnownContact` | `memberInfo_messageOpensKnownContact`: «message» (:513) opens the existing direct chat with bob, without creating a second one, and closes group and member info; a message sent there reaches bob as `alice> <text>`; for a member who is not a contact, «call»/«video» show «Can't call group member» / «Send message to enable calls.» | P | For `memberInfo_messageOpensKnownContact` bob is alice's contact; for `memberInfo_callButtonsShowSendMessageAlert` bob joins through alice's group link, and alice first turns «Direct messages» on in «Group preferences» (alice-created groups start with it off, V/newchat/AddGroupView.kt:160-162; with it off the buttons show «Direct messages between members are prohibited in this group.», V/chat/group/GroupMemberInfoView.kt:535-543). `memberInfo_callButtonsShowSendMessageAlert` merged into `memberInfo_callButtonsDirectMessagesProhibitedAlert` (direct messages turned on after the prohibited case) |
+| Call buttons, direct messages off | Group info ▸ member row | :535-540 | `memberInfo_callButtonsDirectMessagesProhibitedAlert` | Direct messages off: «call»/«video» show «Can't call group member» / «Direct messages between members are prohibited in this group.» | P | The member is not alice's contact; the message button's alert is tested by `groupPrefs_directMessagesOff_memberInfoProhibited`. Both branches: «call» and «video» with direct messages off, then on («Send message to enable calls.», :527-533); bob joins through alice's group link |
+| Verify security code | Group info ▸ member row | :213-243,555-565 | `memberInfo_verifyCodeMatchesCli` | The code on screen with whitespace and line breaks removed equals the code line of CLI `/code #team alice` with spaces removed (the screen splits it into 24-character lines, V/chat/VerifyCodeView.kt:65,132-136) (the real CLI prints `#team alice security code:`, the code, then a hint, `src/Simplex/Chat/View.hs:2021-2023`); `memberInfo_markVerifiedShowsShield`: «Mark verified» closes the code screen (V/chat/VerifyCodeView.kt:40-45); bob's member info header is `verified` (plan §4; V/chat/group/GroupMemberInfoView.kt:775) and his row becomes «View security code», which reopens the screen showing «bob is verified», its status line `verified` (V/chat/VerifyCodeView.kt:66-72; V/chat/ChatInfoView.kt:1208-1215); `memberInfo_clearVerification`: «Clear verification» turns it back to «bob is not verified» and the row to «Verify security code» (V/chat/VerifyCodeView.kt:105-106) (testMarkGroupMemberVerified, H/Direct.hs:3152) | P | `memberInfo_markVerifiedShowsShield` and `memberInfo_clearVerification` merged into `memberInfo_verifyCodeMatchesCli`; the header shield has no description, so the row label and `GroupMember.verified` are checked |
+| Connection stats | Group info ▸ member row | :633-680 |  | «Receiving via» / «Sending via» show the local server address; clicking the status row opens the «Network status» alert (:637-643) | P | `memberInfo_connectionStatsShowServers` and `memberInfo_networkStatusAlert` merged into `memberInfo_switchAddress` (§10 row «Change receiving address») |
 | Connection failed section | Group info ▸ member row: bob (host) and cath run with `-s <smp2>`, alice on smp1; alice joins `team` first; smp1 is stopped; cath joins by bob's link: she receives `XGrpMemIntro` about alice and creates her invitation on smp2, and bob's `XGrpMemFwd` to alice waits for smp1 (`Library/Subscriber.hs:3337-3394`); after bob has received cath's `x.grp.mem.inv` and forwarded it (no CLI line marks it; resetting smp2 earlier would delete the undelivered message, so P1's run of the recipe picks the sync point, e.g. a read of a copy of bob's database, since §6 rules out sleeps), `servers.reset("smp2")` deletes cath's queue, then smp1 starts; alice's `joinAgentConnectionAsync` (`Subscriber.hs:3394`) secures the deleted queue and gets a permanent AUTH (agent `cmdError` → `ERR`, simplexmq `Agent.hs:2430-2439`), and the core marks the connection failed (`Subscriber.hs:179`, `CEvtGroupMemberUpdated` :1315-1319) | `GroupMemberInfoView.kt:682-688`, `C/model/ChatModel.kt:2060-2064` | `memberInfo_connectionFailedSection` | cath's member info shows the "Connection failed" section | P ×2, SMP2, SRVCTL | bob and cath use `cli(…, servers = PeerServers(smp = "smp2"))` (plan §9.2). cath is started (ready) before smp1 is stopped. The smp1 outage spans cath's join, bob's forwarding and the sync point, so it can exceed 10 s; alice's resubscription to smp1 and bob's `XGrpMemFwd` delivery retries back off ×1.5 after 10 s, so the final wait for the section passes an explicit timeout of about half the outage plus 5 s (plan §11.1 Server control). The recipe follows the core and agent code; P1 runs it once (plan §12) |
 | Change receiving address | Group info ▸ member row | :159-192,647-656 | `memberInfo_switchAddress` | CLI: `#team: alice started changing address for you` → `…changed address for you` (testSwitchGroupMember H/Direct.hs:3067) | P | — |
 | Abort address change | Group info ▸ member row | :647-656 | `memberInfo_abortSwitchAddress` | Stop smp1; «Change receiving address» → «Change receiving address?»; «Abort changing address» is enabled (switch still in `RSSwitchStarted`) → «Abort changing address?» / «Abort»; start smp1; the row is gone and messages flow (core: testAbortSwitchGroupMember H/Direct.hs:3085 uses an older agent version for the same reason) | P, SRVCTL | Server stopped before the switch starts |
@@ -184,39 +189,39 @@ Click a member row; `V/chat/group/GroupMemberInfoView.kt`.
 | Member address | Group info ▸ member row | :576-591 | `memberInfo_memberAddressConnect` | QR, «Share address», «Connect» → address plan | P | Peer has an address in its profile. strings.xml defines `share_address` twice (:572 «Share address…», :1957 «Share address»); a moko 0.27.1 desktop build with the same duplicate bundles `share_address = Share address` |
 | Developer tools | Group info ▸ member row | :701-729 | `memberInfo_debugDeliveryQueueInfo` | «Message queue info» alert | P, DT | — |
 
-### 11. Member contacts (5 tests)
+### 11. Member contacts (4 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Create | member info «message» ▸ compose «Send direct message to connect» | V/chat/group/GroupMemberInfoView.kt:108-139; V/chat/ComposeView.kt:638,1781-1793 | `memberContact_createAndSendInvitation`, `memberContact_incognitoMemberSharesIncognitoProfile` | The peer first runs `/set accept member contacts on` (as testMemberContactMessage does, H/Groups.hs:4818). CLI: `#team alice is creating direct contact alice with you`, `alice> hi`, `alice: you can send messages to contact`, `alice: contact is connected` (testMemberContactMessage H/Groups.hs:4814); `memberContact_incognitoMemberSharesIncognitoProfile`: in a group alice created with «Incognito» (§1), the same lines carry alice's incognito name instead of `alice` (`#team <incognito name> is creating direct contact <incognito name> with you`, `<incognito name>> hi`; testMemberContactIncognito :5028, :5079-5083). Without auto-accept the peer prints `#team alice requests to create direct contact with you` (View.hs:1559-1567) | P | bob joins through alice's group link, so he is not alice's contact; alice first turns «Direct messages» on in «Group preferences» (alice-created groups start with it off, V/newchat/AddGroupView.kt:160-162; with it off member info has no «message» button that creates a contact, and the core refuses with `direct messages not allowed`, `Library/Commands.hs:3355`) |
-| Accept / reject | compose «Accept» / «Reject» | V/chat/ComposeContextGroupDirectInvitationActionsView.kt:25-160; V/chat/ComposeView.kt:1830-1838 | `memberContact_acceptRequest`, `memberContact_rejectRequest`, `memberContact_acceptIncognito` | CLI sends `@#team @alice <text>` (`SendMemberContactMessage`, `Library/Commands.hs:6336`, :2617-2630: creates the member contact and sends the invitation; the real CLI prints no ids, only "contact for member #team alice is created", `View.hs:279`). `memberContact_acceptRequest`: after «Accept», the CLI prints `alice: contact is connected` (testMemberContactAccept :5268); `memberContact_rejectRequest`: «Reject» ▸ «Reject contact request» («The sender will NOT be notified.») ▸ «Reject» closes the chat and removes it from the chat list, and the CLI prints nothing (`notify = false`, V/chat/ComposeContextGroupDirectInvitationActionsView.kt:127-149); `memberContact_acceptIncognito`: with alice a member incognito (her group created with «Incognito»; bob's command names her incognito name instead of `alice`), after «Accept» the CLI prints `<alice's incognito name>: contact is connected` (testMemberContactAcceptIncognito :5311) | P | bob is not alice's contact (he joins through alice's group link), and the group has «Direct messages» on: alice-created groups start with it off (V/newchat/AddGroupView.kt:160-162), so alice turns it on in «Group preferences» first, or bob hosts with `/g` and alice joins through bob's group link; with it off the CLI's `@#team @alice` fails with `direct messages not allowed` (`Library/Commands.hs:2624`) |
+| Create | member info «message» ▸ compose «Send direct message to connect» | V/chat/group/GroupMemberInfoView.kt:110-125; V/chat/ComposeView.kt:641-652,1799-1810 | `memberContact_createAndSendInvitation`, `memberContact_incognitoMemberSharesIncognitoProfile` | The peer first runs `/set accept member contacts on` (as testMemberContactMessage does, H/Groups.hs:4858). `memberContact_createAndSendInvitation`: alice has no direct chat with bob; member info «message» opens a new direct chat with bob showing «Send direct message to connect»; sending «hi» makes bob print `#team alice is creating direct contact alice with you`, `alice> hi`, `alice: you can send messages to contact`, `alice: contact is connected`; the context line disappears and bob's reply reaches the direct chat; `memberContact_incognitoMemberSharesIncognitoProfile`: in a group alice created with «Incognito» (§1), the same lines carry alice's incognito name instead of `alice` (`#team <incognito name> is creating direct contact <incognito name> with you`, `<incognito name>> hi`; testMemberContactIncognito :5028, :5079-5083). Without auto-accept the peer prints `#team alice requests to create direct contact with you` (View.hs:1559-1567) | P | bob joins through alice's group link, so he is not alice's contact; alice first turns «Direct messages» on in «Group preferences» (alice-created groups start with it off, V/newchat/AddGroupView.kt:160-162; with it off member info has no «message» button that creates a contact, and the core refuses with `direct messages not allowed`, `Library/Commands.hs:2632`) |
+| Accept / reject | compose «Accept» / «Reject» | V/chat/ComposeContextGroupDirectInvitationActionsView.kt:27-160; V/chat/ComposeView.kt:1847-1856 | `memberContact_acceptAndRejectRequests`, `memberContact_acceptIncognito` | CLI sends `@#team alice hi` (`SendMemberContactMessage`, `Library/Commands.hs:2625-2641`, parser :6581; creates the member contact and sends the invitation: `member #team alice does not have direct connection, creating`, `contact for member #team alice is created`, `sent invitation to connect directly to member #team alice`, `@alice hi`). `memberContact_acceptAndRejectRequests`: bob's chat shows «hi» with «Accept» and «Reject» in place of the message field; after «Accept» bob prints `alice: contact is connected` (testMemberContactAccept :5312) and alice's next message reaches him; cath's request: «Reject» ▸ «Reject contact request» («The sender will NOT be notified.») ▸ «Reject» removes cath's chat from the list, and the next line cath prints is alice's later group message (`notify = false`, V/chat/ComposeContextGroupDirectInvitationActionsView.kt:129-149); `memberContact_acceptIncognito`: with alice a member incognito (her group created with «Incognito»; bob's command names her incognito name instead of `alice`), after «Accept» the CLI prints `<alice's incognito name>: contact is connected` (testMemberContactAcceptIncognito :5355) | P ×2 | `memberContact_rejectRequest` merged into `memberContact_acceptAndRejectRequests` (renamed from `memberContact_acceptRequest`). bob and cath are not alice's contacts (they join through alice's group link), and the group has «Direct messages» on: alice-created groups start with it off (V/newchat/AddGroupView.kt:160-162), so alice turns it on in «Group preferences» first; with it off the CLI's `@#team alice` fails with `direct messages not allowed` (`Library/Commands.hs:2632`) |
 
 The "requested connection" event item and its «Open» button are tested in catalogue 02 (§U).
 
-### 12. Support chats, «Chats with members» / «Chat with admins» (13 tests)
+### 12. Support chats, «Chats with members» / «Chat with admins» (6 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Member side | Group info ▸ «Chat with admins» | V/chat/group/GroupChatInfoView.kt:478-509,636; V/chat/group/MemberSupportChatView.kt:159 | `supportChat_memberSendsToAdmins`, `supportChat_memberReceivesAdminReply`, `supportChat_unreadBannerInGroupChat`, `supportChat_hiddenWhenDisabledWithoutChat`, `supportChat_search` | CLI host sees `#team (support: alice) alice> hello`; the host's reply appears in alice's support chat; the «%d messages» banner (runtime-formatted, e.g. "2 messages"; V/chat/ChatView.kt:1730) (testSupportPreferenceGroup H/Groups.hs:9092; testScopedSupportSingleModerator :8150). `supportChat_search`: the support chat's «Search» icon opens a search field, and typing "hello" leaves only alice's "hello" and hides the host's reply, a text without "hello" (V/chat/group/MemberSupportChatView.kt:106-108,119-121). After bob runs `/set support #team off` and alice's «Group preferences» show «Chat with admins» «off» (the CLI prints the change when it is queued, `sendGroupMessage … XGrpInfo`, src/Simplex/Chat/Library/Commands.hs:4156; alice applies it on receipt, src/Simplex/Chat/Library/Subscriber.hs:1119), Group info has no «Chat with admins» row while alice has no support chat; if she already has one, the row stays (GroupChatInfoView.kt:634-636; testSupportPreferenceGroup H/Groups.hs:9108-9126) | P | — |
-| Admin side | Group info ▸ «Chats with members» | V/chat/group/MemberSupportView.kt:34-332; V/chat/group/GroupMemberInfoView.kt:408 | `chatsWithMembers_listSearchAndOpen`, `chatsWithMembers_markRead`, `chatsWithMembers_deleteChat`, `chatsWithMembers_bannerInGroupChat`, `supportChat_adminOpensFromMemberInfo`, `chatsWithMembers_removedMemberChatGone` | `chatsWithMembers_listSearchAndOpen`: bob's row is listed; typing part of his name keeps it, other text hides it (V/chat/group/MemberSupportView.kt:99-103); clicking it opens bob's support chat with his message (:134-145); `chatsWithMembers_markRead`: the row menu's «Mark read» (shown only while the chat has unread items) removes the unread badge from bob's row (:182-212,277-282); `chatsWithMembers_bannerInGroupChat`: with one unread support chat the group chat shows the banner «1 chat with a member», and clicking it opens «Chats with members» (V/chat/ChatView.kt:1706-1731); `supportChat_adminOpensFromMemberInfo`: bob's member info «Chat with member» opens his support chat (V/chat/group/GroupMemberInfoView.kt:408-424). `chatsWithMembers_deleteChat`: after «Delete chat» (row menu, then the «Delete chat with member?» alert, MemberSupportView.kt:284,295), the member's chat disappears from «Chats with members» (core behaviour: testScopedSupportSingleModerator, H/Groups.hs:8172-8173). A member who left or was removed is no longer listed in «Chats with members» (MemberSupportView.kt:89) | P | — |
-| Admin side, empty | Group info ▸ «Chats with members» | V/chat/group/MemberSupportView.kt:118-121 | `chatsWithMembers_emptyState` | «No chats with members» | — | — |
-| Admin side, disabled | Group info ▸ «Chats with members» | V/chat/group/MemberSupportView.kt:118-121 | `chatsWithMembers_disabledState` | bob (CLI owner) runs `/set support #team off`; alice (moderator) sees «Chats with members are disabled» | P | alice can't turn support off herself (`groupPrefs_supportToggleDisabledInGroups`) |
+| Member side | Group info ▸ «Chat with admins» | V/chat/group/GroupChatInfoView.kt:478-509,636; V/chat/group/MemberSupportChatView.kt:159 | `supportChat_memberSendsToAdmins`, `supportChat_search` | CLI host sees `#team (support: alice) alice> hello`; the host's reply appears in alice's support chat; the «%d messages» banner (runtime-formatted, e.g. "2 messages"; V/chat/ChatView.kt:1730) (testSupportPreferenceGroup H/Groups.hs:9092; testScopedSupportSingleModerator :8150). `supportChat_search`: the support chat's «Search» icon opens a search field, and typing "hello" leaves only alice's "hello" and hides the host's reply, a text without "hello" (V/chat/group/MemberSupportChatView.kt:106-108,119-121). After bob runs `/set support #team off` and alice's «Group preferences» show «Chat with admins» «off» (the CLI prints the change when it is queued, `sendGroupMessage … XGrpInfo`, src/Simplex/Chat/Library/Commands.hs:4156; alice applies it on receipt, src/Simplex/Chat/Library/Subscriber.hs:1119), Group info has no «Chat with admins» row while alice has no support chat; if she already has one, the row stays (GroupChatInfoView.kt:634-636; testSupportPreferenceGroup H/Groups.hs:9108-9126) | P | `supportChat_memberReceivesAdminReply` and `supportChat_unreadBannerInGroupChat` merged into `supportChat_memberSendsToAdmins`: bob (CLI host) sends two support messages, the banner reads «2 messages» and «Chat with admins» shows 2 unread; reading clears the banner; a third message gives «1 messages», and the banner opens the support chat; cath (plain member) receives none of the support messages (sentinel group message). `supportChat_hiddenWhenDisabledWithoutChat` merged into `chatsWithMembers_disabledState`: off hides the row, on brings it back, after alice's support message off keeps it |
+| Admin side | Group info ▸ «Chats with members» | V/chat/group/MemberSupportView.kt:34-332; V/chat/group/GroupMemberInfoView.kt:408 | `chatsWithMembers_listSearchAndOpen`, `chatsWithMembers_markRead`, `supportChat_adminOpensFromMemberInfo` | `chatsWithMembers_listSearchAndOpen`: bob's row is listed; typing part of his name keeps it, other text hides it (V/chat/group/MemberSupportView.kt:99-103); clicking it opens bob's support chat with his message (:134-145); `chatsWithMembers_markRead`: the row menu's «Mark read» (shown only while the chat has unread items) removes the unread badge from bob's row (:182-212,277-282); `chatsWithMembers_bannerInGroupChat`: with one unread support chat the group chat shows the banner «1 chat with a member», and clicking it opens «Chats with members» (V/chat/ChatView.kt:1706-1731); `supportChat_adminOpensFromMemberInfo`: bob's member info «Chat with member» opens his support chat (V/chat/group/GroupMemberInfoView.kt:408-424). `chatsWithMembers_deleteChat`: after «Delete chat» (row menu, then the «Delete chat with member?» alert, MemberSupportView.kt:284,295), the member's chat disappears from «Chats with members» (core behaviour: testScopedSupportSingleModerator, H/Groups.hs:8172-8173). A member who was removed is no longer listed in «Chats with members» (MemberSupportView.kt:89): asserted in `review_rejectPendingMember`. Clicking a row to open the member's support chat is also asserted in `review_acceptAsMember` | P | — Tests: `chatsWithMembers_listSearchAndOpen`, `chatsWithMembers_markRead`, `chatsWithMembers_deleteChat`, `chatsWithMembers_bannerInGroupChat`, `supportChat_adminOpensFromMemberInfo`; removed member merged into review_rejectPendingMember (was chatsWithMembers_removedMemberChatGone). `chatsWithMembers_bannerInGroupChat` and `chatsWithMembers_deleteChat` merged into `chatsWithMembers_markRead` (banner «2 chats with members» on desktop, «2 chat(s)» on Android, then «1 chat…» after bob's chat is read; «Mark read» absent once read). `chatsWithMembers_listSearchAndOpen` also replies in cath's support chat: cath receives `#team (support) alice> hi cath`, bob receives nothing (sentinel). `supportChat_adminOpensFromMemberInfo` also checks that «Chat with member» is hidden while bob is a moderator with no support chat (GroupMemberInfoView.kt:553-557), and that the reply reaches bob as `#team (support) alice> on it` and not the main chat |
+| Admin side, empty | Group info ▸ «Chats with members» | V/chat/group/MemberSupportView.kt:116-123 |  | «No chats with members» before the first joiner (`review_acceptAsMember`) and after the only pending member is rejected (`review_rejectPendingMember`) | — | — Tests: merged into review_acceptAsMember and review_rejectPendingMember (was chatsWithMembers_emptyState) |
+| Admin side, disabled | Group info ▸ «Chats with members» | V/chat/group/MemberSupportView.kt:118-121 | `chatsWithMembers_disabledState` | bob (CLI owner) runs `/set support #team off`; alice (moderator) sees «Chats with members are disabled» | P | alice can't turn support off herself (`groupPrefs_supportToggleDisabledInGroups`). Also covers `supportChat_hiddenWhenDisabledWithoutChat` (row «Member side»); alice is promoted with `/mr team alice moderator` after support is off |
 
-### 13. Reports, moderator side (9 tests)
+### 13. Reports, moderator side (5 tests)
 
 The member side (composing a report, reasons, sent alert, not offered, preference off, not visible to other members) is in catalogue 02 (§O).
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| alice as moderator handles reports | chat banner «1 report»; Group info «Member reports»; chat-list menu «Archive reports» | V/chat/ChatView.kt:1680-1705; V/chat/group/GroupReportsView.kt:31-94; V/chat/item/ChatItemView.kt:391-400,1045; V/chatlist/ChatListNavLinkView.kt:338-342 | `reports_moderatorBannerAndCounts`, `reports_openReportsView`, `reports_archiveForMe`, `reports_archiveForAllModerators`, `reports_deleteReport`, `reports_archiveAllFromChatList`, `reports_moderateReportedMessageMarksReport` | `reports_moderatorBannerAndCounts`: CLI reporter: `/report #team spam <text>`; the chat shows the banner «1 report», «2 reports» after a second one (V/chat/ChatView.kt:1678-1703), and the chat-list row shows the red flag (V/chatlist/ChatPreviewView.kt:388-389); `reports_openReportsView`: clicking the banner opens «Member reports» with the reports (V/chat/group/GroupReportsView.kt:49); `reports_archiveForMe`: «Archive report?» «For me»: the report shows «archived report» (V/chat/item/MarkedDeletedItemView.kt:93-100) and the banner count drops; `reports_archiveForAllModerators`: «For all moderators»: a CLI moderator prints `#team (support: <reporter>) <reporter>> [marked deleted by alice] report spam`, while the reporter's copy is unchanged (`/_delete reports … broadcast`, H/Groups.hs:7958-7963); `reports_deleteReport`: the report's «Delete report» → «Delete message?» offers only «Delete for me» (reports are never deleted for everyone, V/chat/item/ChatItemView.kt:394-397,1391); the report disappears and the banner count drops; `reports_archiveAllFromChatList`: «Archive all reports?»; `reports_moderateReportedMessageMarksReport`: moderating the reported message also archives its report: the report shows «archived report» and the banner goes (H/Groups.hs:7876-7890, report `[marked deleted by you]`). testGroupMemberReports, H/Groups.hs:7815 | P ×2 | — |
+| alice as moderator handles reports | chat banner «1 report»; Group info «Member reports»; chat-list menu «Archive reports» | V/chat/ChatView.kt:1666-1707,3439-3475; V/chat/group/GroupReportsView.kt:79-94; V/chat/group/GroupChatInfoView.kt:697-703,1044-1059; V/chat/item/ChatItemView.kt:396-405,1058-1107,1405-1437; V/chatlist/ChatListNavLinkView.kt:346-350,654-663,1030-1046; V/chat/item/MarkedDeletedItemView.kt:93-100 | `reports_moderatorBannerAndCounts`, `reports_archiveForMeForAllModeratorsAndAll`, `reports_moderateReportedMessageMarksReport` | alice owns `team`; bob and cath (CLI) are members; bob reports cath's messages with `/report #team <reason> <text>` (bob prints `#team (support) > cath <text>` / `      report <reason>`). `reports_moderatorBannerAndCounts`: no banner before; the chat shows the banner «1 report», then «2 reports» (V/chat/ChatView.kt:1666-1707); group info «Member reports» shows the count 2; clicking the banner opens «Member reports» with both reports and their reasons («Spam», «Community guidelines violation»); a report's «Delete report» → «Delete message?» offers only «Delete for me» (reports are never deleted for everyone, V/chat/item/ChatItemView.kt:1405-1437); the report disappears, the other stays, and the banner drops to «1 report»; alice's next message is the next line on bob and cath (cath, a plain member, never printed a report); `reports_archiveForMeForAllModeratorsAndAll`: cath is made a moderator through the API (precondition) and prints each of bob's three reports (`#team (support: bob) bob> > cath <text>` / `      report <reason>`); «Archive report?» offers «For me» and «For all moderators»; «For me» turns the first report into «archived report»; «For all moderators» turns the third into «archived report» and cath's next line is `#team (support: bob) bob> [marked deleted by alice] report profile` (so «For me» sent nothing); the second stays active (the archived reports are not adjacent, so they are not collapsed into one item, V/chat/item/MarkedDeletedItemView.kt:43-75) and the banner shows «1 report»; the chat-list row menu «Archive reports» → «Archive all reports?» / «All reports will be archived for you.» / «Archive» leaves no active report and no banner; alice's next message is cath's next line (`/_delete reports … broadcast`, H/Groups.hs:8230-8266); `reports_moderateReportedMessageMarksReport`: moderating the reported message prints `#team cath> [marked deleted by alice] bad joke` on cath and bob, and bob also prints `#team: 1 messages deleted by member alice` for his report; the message shows «moderated by alice», the banner goes, group info «Member reports» has no count, and the report shows «archived report» there (H/Groups.hs:8180-8196, report `[marked deleted by you]`). testGroupMemberReports, H/Groups.hs:8119 | P ×2 | `reports_openReportsView` and `reports_deleteReport` merged into `reports_moderatorBannerAndCounts`; `reports_archiveForMe`, `reports_archiveForAllModerators` and `reports_archiveAllFromChatList` merged into `reports_archiveForMeForAllModeratorsAndAll`. The chat-list row's red flag (V/chatlist/ChatPreviewView.kt:388-389) has no description and is not checked |
 | alice as moderator selects reports and jumps to a reported message | Group info «Member reports» ▸ report menu «Select» ▸ select a second report ▸ toolbar delete icon (archives when every selected item is an active received report); report ▸ click its quoted message | V/chat/item/ChatItemView.kt:392-400; V/chat/SelectableChatItemToolbars.kt:95-102,158,167; V/chat/ChatView.kt:1063-1090,3472-3481; V/chat/item/ChatItemView.kt:1056-1090; V/chat/item/FramedItemView.kt:294-301; V/chat/ChatView.kt:1900-1909 | `reports_selectMultipleArchive`, `reports_tapReportJumpsToReportedMessage` | Two CLI reports (bob and cath each `/report #team spam <text>` on different messages). Select both → delete icon → «Archive 2 reports?» with «For me» / «For all moderators»; «For me» removes both from «Member reports» and the banner count drops to 0. Clicking the quoted message inside a report in «Member reports» sets `scrollToItemId`; the main group chat (no secondary filter, :1900-1909) scrolls to the reported message while the reports pane stays open on desktop (it closes only on Android, :1903-1905) (testGroupMemberReports, H/Groups.hs:7815) | P ×2 | The toolbar icon is the delete icon in both modes; `canArchiveReports` (SelectableChatItemToolbars.kt:158) switches its action to archiving |
 
-### 14. Moderation (6 tests)
+### 14. Moderation (4 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Moderate | message menu «Moderate»; selection toolbar for several messages | V/chat/item/ChatItemView.kt:489-492,918 | `moderate_markDeletedForAll`, `moderate_fullDeleteWhenEnabled`, `moderate_multipleSelected`, `moderate_notOfferedForHigherRole` | `moderate_markDeletedForAll`: «Delete member message?» / «The message will be marked as moderated for all members.» CLI: `#team cath> [marked deleted by alice] hi` (testGroupModerate H/Groups.hs:1788); `moderate_fullDeleteWhenEnabled`: with full deletion on, the alert says «The message will be deleted for all members.» and the CLI prints `#team cath> [deleted by alice] hi` (…FullDelete :1871, lines :1901-1905); `moderate_multipleSelected`: the selection toolbar's flag button opens «Delete 2 messages of members?»; each message prints `[marked deleted by alice]` on the CLI (…Multiple :1835-1864; V/chat/item/ChatItemView.kt:1473-1479); `moderate_notOfferedForHigherRole`: with alice a moderator (the CLI host invites her as moderator, `/a team alice moderator`, so the role is hers when she joins; a plain member gets no «Moderate» on any message), a message from a member with a higher role (e.g. the owner host) has no «Moderate» in its menu (`memberToModerate`, C/model/ChatModel.kt:3480-3484; V/chat/item/ChatItemView.kt:489-492) | P ×2 | — |
-| Received moderation, own delete | — | — | `moderate_receivedModerationShown`, `groupMessage_deleteOwnForEveryone` | `moderate_receivedModerationShown`: «moderated by %s» on the moderated item; `groupMessage_deleteOwnForEveryone`: «Delete» ▸ «For everyone» on alice's message: each CLI prints `#team alice> [marked deleted] <text>` (testGroupMessageDelete, H/Groups.hs:1395, :1466-1469, cath's role) | P ×2 | — |
+| Moderate | message menu «Moderate»; selection toolbar for several messages | V/chat/item/ChatItemView.kt:494-500,925-939,1476-1496; V/chat/SelectableChatItemToolbars.kt:107; V/chat/ChatView.kt:351-362 | `moderate_markDeletedForAll`, `moderate_fullDeleteWhenEnabled`, `moderate_multipleSelected` | `moderate_markDeletedForAll`: «Delete member message?» / «The message will be marked as moderated for all members.» CLI: `#team cath> [marked deleted by alice] hi` (testGroupModerate H/Groups.hs:1832); `moderate_fullDeleteWhenEnabled`: with full deletion on, the alert says «The message will be deleted for all members.» and the CLI prints `#team cath> [deleted by alice] hi` (…FullDelete :1915, lines :1946-1949); `moderate_multipleSelected`: bob's and cath's messages selected («Selected 2»); the selection toolbar's flag button opens «Delete 2 messages of members?» / «The messages will be marked as moderated for all members.» / «Delete»; bob and cath each print `#team bob> [marked deleted by alice] spam one` then `#team cath> [marked deleted by alice] spam two` (…Multiple :1879-1913); alice's two items collapse into «2 messages moderated by alice» (V/chat/item/MarkedDeletedItemView.kt:43-75) and selection mode ends | P ×2 | `moderate_notOfferedForHigherRole` merged into `report_notOffered_forOwnModeratorOrPrefOff` (02 §O) |
+| Received moderation, own delete | — | — | `groupMessage_deleteOwnForEveryone` | `moderate_receivedModerationShown`: «moderated by %s» on the moderated item; `groupMessage_deleteOwnForEveryone`: «Delete» ▸ «For everyone» on alice's message: each CLI prints `#team alice> [marked deleted] <text>` (testGroupMessageDelete, H/Groups.hs:1395, :1466-1469, cath's role) | P ×2 | `moderate_receivedModerationShown` merged into `memberInfo_blockedByAdminShownToMember` (§10): bob's `\\ #team @cath <text>` shows «moderated by bob» on cath's message for the member alice |
 
 ### 15. Mentions, notification side (2 tests)
 
@@ -224,22 +229,22 @@ Composing mentions (picker, filter, limit of 3, received highlight) is in catalo
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Mentions-only mute, blocked member | group muted to mentions; member blocked for all | C/model/ChatModel.kt:1794-1801 (`ntfsEnabled`) | `mentions_mentionsOnlyMuteStillNotifies`, `mentions_blockedMemberMentionIgnored` | A mention from a CLI member still notifies under mentions-only mute; a mention from a blocked member is ignored, checked once its item shows «blocked by admin» and the app is idle (`UiIdle`; the notification decision runs in the same background job, `SimpleXAPI.kt:3012-3037`; the CLI prints the message when it is sent, before it reaches alice) (testMuteGroup; testBlockForAllMentionsIgnored H/Groups.hs:7347) | P ×2, NTF | — |
+| Mentions-only mute, blocked member | group muted to mentions; member blocked for all | C/model/ChatModel.kt:1812-1817 (`ntfsEnabled`); C/model/SimpleXAPI.kt:3059 | `mentions_mentionsOnlyMuteCountsOnlyMentionsForOtherProfile`, `mentions_blockedMemberMentionIgnored` | `mentions_mentionsOnlyMuteCountsOnlyMentionsForOtherProfile`: alice mutes bob's #team to mentions with the group info button («Mute all» next), switches to a new profile «work», and bob sends `@alice one`, `plain`, `@alice two`: the inactive profile's unread count grows by exactly 2 (the same `ntfsEnabled` decision as the notification), the profile button shows its badge and the user picker shows the count; back in alice's profile, team holds all three messages; `mentions_blockedMemberMentionIgnored`: a mention from a blocked member is ignored, checked once its item shows «blocked by admin» and the app is idle (`UiIdle`; the notification decision runs in the same background job, `SimpleXAPI.kt:3047-3074`; the CLI prints the message when it is sent, before it reaches alice) (testMuteGroup; testBlockForAllMentionsIgnored H/Groups.hs:7651) | P, NTF | `mentions_mentionsOnlyMuteStillNotifies` renamed: notifications are not observable without NTF, so it checks the other-profile unread count, which `SimpleXAPI.kt:3059` gates with the same `ntfsEnabled(cItem)`. `mentions_blockedMemberMentionIgnored` not written: the core drops a blocked member's mentions before the item reaches the app (`Library/Subscriber.hs:2280-2290`), so the app has no code to break here beyond what `mentionIconWithMultipleUnread` covers; it needs NTF to add value |
 
-### 16. Group events and history (8 tests)
+### 16. Group events and history (6 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Event items | group chat | V/chat/item/ChatItemView.kt:608-619; CIEventView | `groupEvents_memberConnectedMerged`, `groupEvents_roleChangeItems`, `groupEvents_memberLeftAndRemoved`, `groupEvents_groupProfileUpdated`, `groupEvents_expandCollapsed` | `groupEvents_memberConnectedMerged`: one merged item «cath and bob connected» (newest first, `C/model/ChatModel.kt:1164-1181`, V/chat/item/ChatItemView.kt:605-622); `groupEvents_roleChangeItems`: «changed your role to %s» with the new role; `groupEvents_memberLeftAndRemoved`: bob's leaving adds a received «left» event (on its own, or inside a merged row of adjacent received events after «Expand», C/model/ChatModel.kt:3462-3470), and removing cath adds «you removed cath»; `groupEvents_groupProfileUpdated`: «updated group profile»; `groupEvents_expandCollapsed`: «%d group events» with «Expand»/«Hide» | P ×2 | alice is the host (bob and cath join) for `groupEvents_memberConnectedMerged`, `groupEvents_memberLeftAndRemoved`, `groupEvents_expandCollapsed`; bob is the CLI host for `groupEvents_roleChangeItems` and `groupEvents_groupProfileUpdated`; cath joins only after bob prints `#team: you joined the group` and alice's chat shows bob's «connected» item, so the merged names come in a fixed order; cath is unused in `groupEvents_roleChangeItems` and `groupEvents_groupProfileUpdated` |
-| History for new members | group chat | — | `history_newCliMemberReceivesHistory`, `history_guiJoinerReceivesHistory`, `history_welcomeAfterHistory` | CLI: `#team alice> hello [>>]` (testGroupHistory H/Groups.hs:5948; …GroupLink :5992); `history_guiJoinerReceivesHistory`: alice, joining bob's group through its link after bob's "hello" and cath's "hey!", sees both in the group chat (testGroupHistoryGroupLink :5992-6028, alice in cath's role); with a welcome message the new member gets the history items first, then `#team alice> <welcome>` (testGroupHistoryWelcomeMessage :6692) | P ×2 | — |
+| Event items | group chat | V/chat/item/ChatItemView.kt:535-548,610-640,987-1009; C/model/ChatModel.kt:1179-1197,3485-3510 | `groupEvents_memberConnectedMerged`, `groupEvents_roleChangeItems`, `groupEvents_memberLeftAndRemoved` | `groupEvents_memberConnectedMerged`: after bob and cath join alice's group, one row «cath and bob connected» (or «bob and cath connected») stands for both events; «Expand» shows each `connected` event on its own row, «Hide» merges them again; `groupEvents_roleChangeItems`: bob (CLI host) runs `/mr team alice admin` and alice's chat shows «changed your role to admin» on its own row (`UserRole` has no merge category); bob then changes the welcome message twice and the two «updated group profile» events collapse into «2 group events», which «Expand» splits into two rows; `groupEvents_memberLeftAndRemoved`: bob's leaving adds a received «left» event (on its own, or inside a merged row of adjacent received events after «Expand», C/model/ChatModel.kt:3485-3510), and removing cath adds «you removed cath» | P ×2 | `groupEvents_expandCollapsed` merged into `groupEvents_memberConnectedMerged`; `groupEvents_groupProfileUpdated` merged into `groupEvents_roleChangeItems`. `groupEvents_memberLeftAndRemoved` not written yet (lower value: removal is checked by `memberInfo_removeMember` and `memberSelection_blockUnblockAndRemoveMultiple`) |
+| History for new members | group chat | V/chat/group/GroupPreferences.kt:166-170 | `history_newCliMemberReceivesHistory`, `history_guiJoinerReceivesHistory`, `history_welcomeAfterHistory` | `history_newCliMemberReceivesHistory`: alice sends «hello» in her new group, invites cath, and cath prints `#team alice> hello [>>]` after `#team: you joined the group` (testGroupHistory H/Groups.hs:6250); alice then turns «Visible history» off in «Group preferences» (cath prints `Recent history: off`), invites dan, and dan's next lines are `#team: you joined the group`, `#team: member cath is connected` and alice's later message, with no `[>>]` line (testGroupHistoryPreferenceOff :6344); `history_guiJoinerReceivesHistory`: alice, joining bob's group through its link after bob's "hello" and cath's "hey!", sees both in the group chat (testGroupHistoryGroupLink :6294, alice in cath's role); with a welcome message the new member gets the history items first, then `#team alice> <welcome>` (testGroupHistoryWelcomeMessage) | P ×2 | `history_guiJoinerReceivesHistory` and `history_welcomeAfterHistory` not written in this batch |
 
-### 17. Leave, delete, clear (8 tests)
+### 17. Leave, delete, clear (7 tests)
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| Leave | «Leave group» / chat-list «Leave» | V/chat/group/GroupChatInfoView.kt:253-276,828-838 | `leaveGroup_notifiesMembers`, `leaveGroup_thenDeleteLocalCopy`, `leaveGroup_fromChatListMenu` | `leaveGroup_notifiesMembers`: «Leave group?» → «Leave» … CLI: `#team: alice left the group (signed)`; compose shows «you left»; `leaveGroup_thenDeleteLocalCopy`: after leaving, Group info offers «Delete group» (`canDelete`, C/model/ChatModel.kt:2524-2525); «Delete group?» with «Group will be deleted for you - this cannot be undone!» → «Delete» removes the group from the chat list, and the CLI prints nothing (V/chat/group/GroupChatInfoView.kt:212-251); `leaveGroup_fromChatListMenu`: the chat-list «Leave» opens the same «Leave group?», and the CLI prints `#team: alice left the group (signed)` | P | — |
-| Delete | «Delete group» / chat-list «Delete» | V/chat/group/GroupChatInfoView.kt:212-251 | `deleteGroup_ownerDeletesForAll`, `deleteGroup_memberSeesGroupDeleted`, `deleteGroup_fromChatListMenu` | «Delete group?» → «Delete»: «Group will be deleted for all members - this cannot be undone!». CLI: `#team: alice deleted the group (signed)` / `use /d #team to delete the local copy of the group` (testGroupDelete H/Groups.hs:834). When bob (CLI host) runs `/d #team`, alice's compose shows «group is deleted»; `deleteGroup_fromChatListMenu`: the group row's menu «Delete» opens the same «Delete group?» alert, and «Delete» removes the row with the same CLI lines (V/chatlist/ChatListNavLinkView.kt:475-484) | P ×2 | — |
-| Clear / removed | «Clear chat» | V/chat/ChatInfoView.kt:497-505 | `clearChat_removesLocalItemsOnly`, `removedFromGroup_composeDisabled` | «Clear chat?» → «Clear»: the items are gone from alice's chat, the group stays in the chat list, and bob's `/tail #team` still shows them; compose «removed from group» | P | — |
+| Leave | «Leave group» / chat-list «Leave» | V/chat/group/GroupChatInfoView.kt:254-277,824-840 | `leaveGroup_thenDeleteLocalCopy`, `leaveGroup_fromChatListMenu` | `leaveGroup_thenDeleteLocalCopy`: a current member's Group info offers «Leave group» and no «Delete group»; «Leave group?» with «You will stop receiving messages from this group. Chat history will be preserved.» → «Leave»: CLI `#team: alice left the group (signed)`; compose shows «you left» (C/model/ChatModel.kt:1762); Group info then offers «Delete group» and no «Leave group» (`canDelete`, C/model/ChatModel.kt:2555-2556); «Delete group?» with «Group will be deleted for you - this cannot be undone!» → «Delete» removes the group from the chat list, and the CLI prints nothing: alice's next direct message is bob's next line (V/chat/group/GroupChatInfoView.kt:213-252); `leaveGroup_fromChatListMenu`: the chat-list «Leave» opens the same «Leave group?», and the CLI prints `#team: alice left the group (signed)` | P | `leaveGroup_notifiesMembers` merged into `leaveGroup_thenDeleteLocalCopy` |
+| Delete | «Delete group» / chat-list «Delete» | V/chat/group/GroupChatInfoView.kt:213-252 | `deleteGroup_ownerDeletesForAll`, `deleteGroup_memberSeesGroupDeleted`, `deleteGroup_fromChatListMenu` | «Delete group?» → «Delete»: «Group will be deleted for all members - this cannot be undone!». CLI: `#team: alice deleted the group (signed)` / `use /d #team to delete the local copy of the group` (testGroupDelete H/Groups.hs:834). When bob (CLI host) runs `/d #team`, alice's chat gets the «deleted group» item, her compose shows «group is deleted» (C/model/ChatModel.kt:1760), and Group info offers only «Delete group»; `deleteGroup_fromChatListMenu`: the group row's menu «Delete» opens the same «Delete group?» alert, and «Delete» removes the row with the same CLI lines (V/chatlist/ChatListNavLinkView.kt:475-484) | P ×2 | — |
+| Clear / removed | «Clear chat» | V/chat/ChatInfoView.kt:500-509 | `clearChat_removesLocalItemsOnly`, `removedFromGroup_composeDisabled` | `clearChat_removesLocalItemsOnly`: «Clear chat?» with «All messages will be deleted - this cannot be undone! The messages will be deleted ONLY for you.» → «Clear»: the items are gone from alice's chat, she stays a current member, bob's later message arrives, and alice's next message is bob's next CLI line (no leave or delete reached him); `removedFromGroup_composeDisabled`: after bob's `/rm team alice`, alice's chat gets «removed you», her compose shows «removed from group» (C/model/ChatModel.kt:1761) and Group info offers only «Delete group» | P | — |
 
 ### 18. Channels: alice as owner, with relays and CLI subscribers (58 tests, 1 ignored)
 
@@ -247,11 +252,11 @@ Composing mentions (picker, filter, limit of 3, received highlight) is in catalo
 |---|---|---|---|---|---|---|
 | Create channel without relays | New chat ▸ «Create public channel» | V/newchat/AddChannelView.kt:41-586 | `createChannel_noRelaysBlocksCreation` | «Enable at least one chat relay to create a channel.» | — | No relay configured |
 | Create channel, one relay | «Create public channel» ▸ «Creating channel» | V/newchat/AddChannelView.kt:41-586 | `createChannel_singleRelayCompletesAndShowsLink` | «Creating channel» progress step; once the relay is active, on desktop the channel opens with the «Channel link» modal automatically (core behaviour: prepareChannel' H/Groups.hs:9374) | RELAY | — |
-| Create channel, cancel or relay error | «Create public channel» ▸ «Creating channel» | V/newchat/AddChannelView.kt:358-536 | `createChannel_cancelAndDelete`, `createChannel_relayAddressDeletedShowsError` | «Cancel and delete channel» ▸ «Cancel creating channel?»: «Wait» keeps the step, «Cancel» deletes the channel; «Error creating channel» when the relay address was deleted (core behaviour: testChannelCreateDeletedRelay H/Groups.hs:12055) | RELAY, PEERCTL | cancel: the relay is stopped after registration, so the step stays at "0/1 relays active" (runtime-formatted from «%1$d/%2$d relays active», AddChannelView.kt:440); error: the relay runs `/da` as in §0 before alice creates the channel |
+| Create channel, cancel or relay error | «Create public channel» ▸ «Creating channel» | V/newchat/AddChannelView.kt:358-536 | `createChannel_cancelAndDelete`, `createChannel_relayAddressDeletedShowsError` | «Cancel and delete channel» ▸ «Cancel creating channel?»: «Wait» keeps the step, «Cancel» deletes the channel; «Error creating channel» when the relay address was deleted (core behaviour: testChannelCreateDeletedRelay H/Groups.hs:12055) | RELAY, PEERCTL | cancel: the relay is stopped after registration, so the step stays at "0/1 relays active" (runtime-formatted from «%1$d/%2$d relays active», AddChannelView.kt:440); error: the relay types `/da` (§0) before alice creates the channel |
 | Create channel with image | «Create public channel» ▸ image | V/newchat/AddChannelView.kt:41-586 | `createChannel_withImage` | The channel avatar shows in the chat list and Group info | RELAY, FD | — |
 | Create channel, two relays | «Create public channel» ▸ «Creating channel» | V/newchat/AddChannelView.kt:395-445 | `createChannel_twoRelaysProgress` | The progress step counts «%1$d/%2$d relays active» out of 2; when both relays are active it closes and the channel opens with «Channel link»; «Chat relays» then shows both relays as «active» (prepareChannel2Relays H/Groups.hs:9400) | RELAY ×2 | Both relays registered by the harness |
 | Create channel, partial relays | «Creating channel» with one relay stopped | V/newchat/AddChannelView.kt:41-586 | `createChannel_continueWithPartialRelays` | «Not all relays connected»; continuing creates the channel with one active relay | RELAY ×2, PEERCTL | The second relay is stopped before creation |
-| Owner info rows | Group info | V/chat/group/GroupChatInfoView.kt:607-610,640-681,818-846,999-1009 | `channelInfo_ownerRows`, `channelInfo_subscriberCountUpdates`, `channelInfo_leaveHiddenForSoleOwner` | `channelInfo_ownerRows`: «Link» action button, «Channel link», «Subscribers», «Chat relays», «Delete channel», «Advanced options», and the footer «Only channel owners can change channel preferences.» (GroupChatInfoView.kt:726-729); `channelInfo_subscriberCountUpdates`: «%1$d subscribers» shows 3 after the two CLI subscribers join (the owner is counted; core behaviour: H/Groups.hs:9293, 4 with three subscribers); `channelInfo_leaveHiddenForSoleOwner`: there is no «Leave channel» while alice is the only owner (V/chat/group/GroupChatInfoView.kt:828-838) | RELAY, P ×2 | — |
+| Owner info rows | Group info | V/chat/group/GroupChatInfoView.kt:607-610,640-681,818-846,999-1009 | `channelInfo_ownerRows`, `channelInfo_subscriberCountUpdates`, `channelInfo_leaveHiddenForSoleOwner` | `channelInfo_ownerRows`: «Link» action button, «Channel link», «Subscribers», «Chat relays», «Delete channel», «Advanced options», and the footer «Only channel owners can change channel preferences.» (GroupChatInfoView.kt:726-729); `channelInfo_subscriberCountUpdates`: «%1$d subscribers» shows 3 after the two CLI subscribers join (the owner is counted; core behaviour: H/Groups.hs:9293, 4 with three subscribers); `channelInfo_leaveHiddenForSoleOwner`: there is no «Leave channel» while alice is the only owner (V/chat/group/GroupChatInfoView.kt:828-838) | RELAY, P ×2 | `channelInfo_subscriberCountUpdates` (written 2026-10-20, not yet run): by code reading the owner's count may stay at «1 subscriber», because the core sends the updated count only in `joinedGroupMemberConnecting` (`Library/Subscriber.hs` `memberAnnouncedToView`), whose app handler updates only the member (`C/model/SimpleXAPI.kt` `is CR.JoinedGroupMemberConnecting`, `upsertGroupMember`); if the first run fails there, record it in plan §15.5 and mark the test `@KnownAppIssue` |
 | Channel SimpleX name | Group info ▸ «Get SimpleX name (BETA)» ▸ «Set SimpleX name» | V/chat/group/GroupChatInfoView.kt:670-680; V/usersettings/SetSimplexNameView.kt:182-190 | `channelName_setSimplexName`, `channelName_removeSimplexName` | After saving, the row shows the name under «Channel SimpleX name»; «Remove name» then «Save» restores «Get SimpleX name (BETA)» | RELAY, NAMES | Name registered in the mock registry for the channel link |
 | Channel link | «Channel link» ▸ «Share link» | V/chat/group/GroupLinkView.kt:219,250-262 | `channelLink_shareCopiesLink` | The channel link is on the clipboard | RELAY, CB | No role picker, no delete |
 | Channel link via chat, CLI join | «Share via chat»; CLI `/c` | V/chat/group/GroupLinkView.kt:266-278 | `channelLink_shareViaChatToContactSigned`, `channelLink_shareViaChatToGroup`, `channelLink_cliSubscriberJoins` | CLI: direct `alice> link to join channel #team (signed):` (testShareChannelDirect H/ChatRelays.hs:244); group `#<group> alice> link to join channel #team:` (unsigned, testShareChannelGroup :295); `/c` lines from testConnectChannelCLI H/Groups.hs:9206 | RELAY, P | — |
@@ -259,7 +264,7 @@ Composing mentions (picker, filter, limit of 3, received highlight) is in catalo
 | Broadcast a file | attach in the channel | V/chat/ComposeView.kt:1841-1847 | `channel_broadcastFile` | The CLI subscriber prints `#team> sends file <name> (<size> / <bytes> bytes) [>>]` and `use /fr <n> … to receive it [>>]` (the elided part is `[<dir>/` or-bar `<path>]`) (testChannelMessageFile H/Groups.hs:12193, 12215-12216; View.hs:2508,2513) | RELAY, P, XFTP, FD | — |
 | Owner relay bar | compose relay bar, expanded | V/chat/ComposeView.kt:1890-1985 | `channel_ownerRelayBarStates` | After both relays are removed, expanding the compose relay bar shows «Add relays to restore message delivery.» | RELAY ×2 | alice removes both relays in «Chat relays» ▸ «Remove relay» |
 | Chat relays view | «Chat relays» ▸ «Add relay» ▸ «Add relays»; right-click «Remove relay» | V/chat/group/ChannelRelaysView.kt:27-207; V/chat/group/AddGroupRelayView.kt:33-240; V/chat/group/GroupMemberInfoView.kt:613-632 | `channelRelays_listShowsActive`, `channelRelays_addRelay`, `channelRelays_noAvailableRelays`, `channelRelays_removeRelay`, `channelRelays_removeLastRelayWarning`, `channelRelays_relayMemberInfo` | The list shows each relay's status («active» for relay1, V/chat/group/ChannelRelaysView.kt:178-193); an added relay becomes «active»; with both relays in the channel, «Add relay» opens «Add relays» showing «No available relays» (AddGroupRelayView.kt:114); a removed relay leaves the list; removing the last active relay shows «Remove relay?» / «This is the last active relay. Removing it will prevent message delivery to subscribers.» (GroupChatInfoView.kt:284); relay member info has «Relay link», «Share relay address» (core behaviour: testChannelAddRelay H/Groups.hs:11244; …RemoveRelay :11621) | RELAY ×2 | The channel is created with relay1 only; the harness registers relay2 in alice's servers after creation (`channelRelays_addRelay` adds it; `channelRelays_noAvailableRelays` runs after it is added) |
-| Relay leaves or rejects | the relay runs `/leave #team` (stopped, `-e`, restarted) | V/chat/group/ChannelRelaysView.kt:27-207 | `channelRelays_relayLeftShowsRemovedByOperator`, `channelRelays_rejectedRelayStatus` | The relay's status shows «removed by operator»; after alice removes the relay that left («Remove relay») and adds it again («Add relay»), it shows «rejected» (testChannelRelayLeave H/Groups.hs:10997; testRelayRejectAfterLeave :11816) | RELAY ×2, P, PEERCTL | Relay commands as in §0 |
+| Relay leaves or rejects | the relay types `/leave #team` | V/chat/group/ChannelRelaysView.kt:27-207 | `channelRelays_relayLeftShowsRemovedByOperator`, `channelRelays_rejectedRelayStatus` | The relay's status shows «removed by operator»; after alice removes the relay that left («Remove relay») and adds it again («Add relay»), it shows «rejected» (testChannelRelayLeave H/Groups.hs:10997; testRelayRejectAfterLeave :11816) | RELAY ×2, P | Relay commands as in §0 |
 | Subscribers | «Subscribers» ▸ member info | V/chat/group/ChannelMembersView.kt:27-166; C/model/ChatModel.kt:2944-2962 | `channelSubscribers_listAndCount`, `channelSubscribers_promoteToContributor`, `channelSubscribers_demoteToSubscriber`, `channelSubscribers_blockForAll`, `channelSubscribers_removeSubscriber`, `channelSubscribers_verifyCodeViaMembershipKeys` | `channelSubscribers_listAndCount`: «Subscribers» lists alice and both CLI subscribers under «3 subscribers» (V/chat/group/ChannelMembersView.kt:60-75); `channelSubscribers_promoteToContributor`: the role picker offers «subscriber» and «contributor» only; «contributor» → CLI `#team: alice changed your role from observer to member (signed)` (promoteChannelMember H/Groups.hs:9308-9317); `channelSubscribers_demoteToSubscriber`: back to «subscriber» → CLI `#team: alice changed your role from member to observer (signed)`; `channelSubscribers_blockForAll`: «Block subscriber for all?» → the other subscriber prints `#team: alice blocked <name> (signed)` (testChannelBlockMemberSigned :10263-10268); `channelSubscribers_removeSubscriber`: «Remove subscriber?» → CLI `#team: alice removed you from the group (signed)` / `use /d #team to delete the group` (testChannelRemoveMemberSigned :10741-10751); `channelSubscribers_verifyCodeViaMembershipKeys`: «Verify security code» shows the same code the subscriber's CLI prints for `/code #team alice`, and «Mark verified» marks the subscriber verified (testChannelMemberSecurityCode :9329-9353) | RELAY, P ×2 | — |
 | Profile / welcome | «Edit channel profile», «Add welcome message» | V/chat/group/GroupProfileView.kt:110-174 | `channelProfile_editNotifiesSubscribers`, `channelProfile_linkWorksAfterUpdate`, `channelWelcome_setNotifiesSubscribers`, `channelWelcome_newSubscriberSeesWelcome` | `channelProfile_editNotifiesSubscribers`: `alice updated group #team: (signed)` (testChannelUpdateProfileSigned H/Groups.hs:9982); `channelProfile_linkWorksAfterUpdate`: after a name change the subscribers print `alice updated group #team: (signed)` / `changed to #<new name> …`, and a new CLI subscriber can still join with the channel link (testChannelLinkAfterProfileUpdate :10014-10047); `channelWelcome_setNotifiesSubscribers`: subscribers print `alice updated group #team: (signed)`, `welcome message changed to:`, `<text>` (H/Groups.hs:9991-10010); `channelWelcome_newSubscriberSeesWelcome`: a new CLI subscriber (dan) joins with the channel link after the welcome was set (testChannelLinkAfterWelcomeUpdate :10049); its `/show welcome #team` prints `Welcome message:` / `<text>` (View.hs:2157) — the joined profile carries the welcome | RELAY, P | — |
 | Channel preferences | «Channel preferences» | V/chat/group/GroupPreferences.kt:218-240 | `channelPrefs_fullDeleteOn`, `channelPrefs_reactionsOff`, `channelPrefs_historyOff`, `channelPrefs_enableChatWithAdminsConfirm`, `channelPrefs_enableChatWithAdminsDismissReverts`, `channelPrefs_groupOnlyRowsAbsent` | `channelPrefs_fullDeleteOn`: «Delete for everyone» on, «Save and notify channel subscribers» → subscribers print `alice updated group #team: (signed)`, `updated group preferences:`, `Full deletion: on` (testChannelUpdatePrefsSigned H/Groups.hs:10143-10165); `channelPrefs_reactionsOff`: the same lines ending `Message reactions: off`; `channelPrefs_historyOff`: the same lines ending `Recent history: off` (`groupFeatureNameText`, `src/Simplex/Chat/Types/Preferences.hs:250-263`); `channelPrefs_enableChatWithAdminsConfirm`: «Enable chats with admins?» / «Enable», then saving prints `Chat with admins: on` after the update lines (toggledSupport, H/Groups.hs:12115-12119; testSupportPreferenceChannel :9140); `channelPrefs_enableChatWithAdminsDismissReverts`: dismissing «Enable chats with admins?» turns the toggle back off (V/chat/group/GroupPreferences.kt:230-238); `channelPrefs_groupOnlyRowsAbsent`: «Channel preferences» has only «Disappearing messages», «Delete for everyone», «Message reactions», «Visible history» and «Chat with admins»: no «Member admission», «Direct messages», «Voice messages», «Files and media», «SimpleX links» or reports row (V/chat/group/GroupPreferences.kt:192-240) | RELAY, P | — |
@@ -285,18 +290,18 @@ Composing mentions (picker, filter, limit of 3, received highlight) is in catalo
 | Plans | paste the channel link | V/newchat/ConnectPlan.kt:322-336,664 | `connectPlan_knownChannelSubscriber` | «You are a subscriber», «Open channel» | P, RELAY, CB | — |
 | Plans (own channel, relay address) | paste alice's own channel link or a relay address | V/newchat/ConnectPlan.kt:35-42,566-597 | `connectPlan_ownChannelLink`, `connectPlan_relayAddressRejected` | «Your channel» ▸ «Open channel»; «Relay address» alert | RELAY, CB | alice creates the channel herself (as in §18) |
 
-### 20. Business chats (16 tests)
+### 20. Business chats (9 tests)
 
 Enabling the business address is a catalogue-01 setting; here the address is set up by the harness through that flow.
 
 | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|
-| alice as business | CLI customer connects to alice's business address | V/usersettings/UserAddressView.kt:571,625-648 | `business_customerConnectsCreatesBusinessChat`, `business_autoReplyWelcome`, `business_customerProfileUpdateRenamesChat` | CLI customer: `#alice: joining the group...`, then the welcome message from alice; customer `/p <new name>` followed by a message renames the business chat on alice's side (testBusinessAddress H/Profiles.hs:1950; testBusinessUpdateProfiles :2014, names substituted) | P | bob is the customer |
-| Business-side info | Group info | V/chat/group/GroupChatInfoView.kt:684,714,759-763; V/chat/group/AddGroupMembersView.kt:144,190 | `businessInfo_rowsForBusinessSide`, `business_addTeamMember`, `business_promoteCustomerToAdmin`, `business_removeMemberChatWording`, `business_deleteChat` | No link / «Chats with members» / edit profile; «Chat preferences», «Add team members», «Invite to chat»; `businessInfo_rowsForBusinessSide` also checks the footer «Only chat owners can change preferences.» (GroupChatInfoView.kt:726-729). Team member CLI: `#bob: alice invites you to join the group as member`; the customer CLI is told that the team member was added (testBusinessAddress, names substituted); `business_promoteCustomerToAdmin`: «admin» in bob's member info shows «Change role?» / «The role will be changed to "admin". Everyone in the chat will be notified.» (GroupMemberInfoView.kt:968-985); after «Change» bob's CLI prints a line ending `changed your role from member to admin (signed)` (View.hs:1421-1429); `business_removeMemberChatWording`: «Remove member» shows «Remove member?» / «Member will be removed from chat - this cannot be undone!» (GroupMemberInfoView.kt:305-311); `business_deleteChat`: «Delete chat» shows «Delete chat?» / «Chat will be deleted for all members - this cannot be undone!», and «Delete» removes the chat (GroupChatInfoView.kt:212-227,822-826) | P ×2 | bob is the customer, cath the team member |
+| alice as business | CLI customer connects to alice's business address | V/usersettings/UserAddressView.kt:571,625-648 | `business_autoReplyWelcome`, `business_customerProfileUpdateRenamesChat` | CLI customer: `#alice: joining the group...`, then the welcome message from alice; customer `/p <new name>` followed by a message renames the business chat on alice's side (testBusinessAddress H/Profiles.hs:1950; testBusinessUpdateProfiles :2014, names substituted) | P | bob is the customer. `business_customerConnectsCreatesBusinessChat` merged into `business_addTeamMember` (the customer chat is also created in catalogue 01 `addressBusinessToggleAutoEnablesAutoAccept`) |
+| Business-side info | Group info | V/chat/group/GroupChatInfoView.kt:684,714,759-763; V/chat/group/AddGroupMembersView.kt:144,190 | `business_addTeamMember`, `business_promoteCustomerToAdmin` | No link / «Chats with members» / edit profile; «Chat preferences», «Add team members», «Invite to chat»; `businessInfo_rowsForBusinessSide` also checks the footer «Only chat owners can change preferences.» (GroupChatInfoView.kt:726-729). Team member CLI: `#bob: alice invites you to join the group as member`; the customer CLI is told that the team member was added (testBusinessAddress, names substituted); `business_promoteCustomerToAdmin`: «admin» in bob's member info shows «Change role?» / «The role will be changed to "admin". Everyone in the chat will be notified.» (GroupMemberInfoView.kt:968-985); after «Change» bob's CLI prints a line ending `changed your role from member to admin (signed)` (View.hs:1421-1429); `business_removeMemberChatWording`: «Remove member» shows «Remove member?» / «Member will be removed from chat - this cannot be undone!» (GroupMemberInfoView.kt:305-311); `business_deleteChat`: «Delete chat» shows «Delete chat?» / «Chat will be deleted for all members - this cannot be undone!», and «Delete» removes the chat (GroupChatInfoView.kt:212-227,822-826) | P ×2 | bob is the customer, cath the team member. `businessInfo_rowsForBusinessSide` and `business_deleteChat` merged into `business_addTeamMember` (customer CLI: `#alice: alice_1 added cath to the group (connecting...)`, `#alice: new member cath is connected`; after «Delete chat» bob and cath print that the group was deleted). `business_removeMemberChatWording` merged into `business_promoteCustomerToAdmin` (after the promotion, «Remove member» on bob with the chat wording, and bob prints that he was removed) |
 | alice as customer, connecting | paste business address ▸ «Open new chat» ▸ send request | V/newchat/ConnectPlan.kt:700-748; V/chat/ComposeView.kt:1775-1780 | `customer_connectToBusinessAddress`, `customer_connectWithRequestMessage` | Banner «Business connection». CLI business: `#alice: accepting business address request...`; with a request message, `#alice alice_1> Hello!` comes first, then the accepting line (H/Profiles.hs:4426,4490, names substituted) | P, CB | bob is the business |
-| alice as customer, known business | paste the business address again after connecting | V/newchat/ConnectPlan.kt:322-336,645-690 | `customer_knownBusinessPlan` | «Open chat» with the known business chat | P, CB | bob is the business |
+| alice as customer, known business | paste the business address again after connecting | V/newchat/ConnectPlan.kt:322-336,645-690 |  | «Open chat» with the known business chat | P, CB | bob is the business. `customer_knownBusinessPlan` merged into `customer_connectToBusinessAddress` |
 | alice as customer, still connecting | paste the business address again while the join is pending | V/newchat/ConnectPlan.kt:322-336,645-690 | `connectPlan_businessPendingOpensKnownChat` | The known-chat alert with «Open chat» opens the pending business chat (the core returns the known prepared group for the short link, src/Simplex/Chat/Library/Commands.hs:4536) | P, PEERCTL, CB | bob (business, auto-accept) is stopped before alice sends the request (after she opens the prepared chat), so the join stays pending: the request waits in his address queue on the SMP server, while a running bob would accept it within milliseconds (H/Profiles.hs:1955 `/auto_accept on business`) |
-| alice as customer, in the chat | business chat | V/chat/group/GroupChatInfoView.kt:253-262,759-763,829-838 | `customer_seesTeamMemberAdded`, `customer_chatInfoRows`, `customer_addFriendsWhenPromoted`, `customer_leaveChat` | `customer_seesTeamMemberAdded`: team member added event; `customer_chatInfoRows`: Group info shows «Chat preferences» with the footer «Only chat owners can change preferences.», the members list without «Add friends», and «Leave chat» (V/chat/group/GroupChatInfoView.kt:719-729,752-763,829-838; adding needs admin, C/model/ChatModel.kt:2527-2528); `customer_addFriendsWhenPromoted`: «Add friends» after promotion; `customer_leaveChat`: «Leave chat?» | P ×2 | bob is the business, cath a team member |
+| alice as customer, in the chat | business chat | V/chat/group/GroupChatInfoView.kt:253-262,759-763,829-838 | `customer_seesTeamMemberAdded`, `customer_addFriendsWhenPromoted` | `customer_seesTeamMemberAdded`: team member added event; `customer_chatInfoRows`: Group info shows «Chat preferences» with the footer «Only chat owners can change preferences.», the members list without «Add friends», and «Leave chat» (V/chat/group/GroupChatInfoView.kt:719-729,752-763,829-838; adding needs admin, C/model/ChatModel.kt:2527-2528); `customer_addFriendsWhenPromoted`: «Add friends» after promotion; `customer_leaveChat`: «Leave chat?» | P ×2 | bob is the business, cath a team member. `customer_chatInfoRows` and `customer_leaveChat` merged into `customer_seesTeamMemberAdded` (cath's message reaches alice; «Leave chat» → bob and cath print `#alice: alice_1 left the group`) |
 
 "Owner contact on connect plan" is read as the owner-signature check on shared channel cards (`joinChannel_viaSharedSignedCard`).
 
@@ -306,24 +311,24 @@ By Needs: 83 tests need a chat relay (`RELAY`: 82 in §18–§19 and `connectPla
 
 | Section | Tests | Ignored |
 |---|---|---|
-| 1 Create group | 12 | 0 |
-| 2 Invite members | 11 | 0 |
-| 3 Group info rows | 13 | 0 |
-| 4 Profile / welcome | 14 | 0 |
-| 5 Group preferences | 19 | 1 |
-| 6 Admission / review | 16 | 2 |
-| 7 Group link | 14 | 0 |
-| 8 Joining / connect plan / invitations | 24 | 0 |
-| 9 Member list / selection | 10 | 0 |
-| 10 Member info | 28 | 0 |
-| 11 Member contacts | 5 | 0 |
-| 12 Support chats | 13 | 0 |
-| 13 Reports (moderator side) | 9 | 0 |
-| 14 Moderation | 6 | 0 |
+| 1 Create group | 9 | 0 |
+| 2 Invite members | 8 | 0 |
+| 3 Group info rows | 11 | 0 |
+| 4 Profile / welcome | 10 | 0 |
+| 5 Group preferences | 6 | 1 |
+| 6 Admission / review | 7 | 2 |
+| 7 Group link | 9 | 0 |
+| 8 Joining / connect plan / invitations | 17 | 0 |
+| 9 Member list / selection | 5 | 0 |
+| 10 Member info | 22 | 0 |
+| 11 Member contacts | 4 | 0 |
+| 12 Support chats | 6 | 0 |
+| 13 Reports (moderator side) | 5 | 0 |
+| 14 Moderation | 4 | 0 |
 | 15 Mentions (notification side) | 2 | 0 |
-| 16 Events / history | 8 | 0 |
-| 17 Leave / delete / clear | 8 | 0 |
+| 16 Events / history | 6 | 0 |
+| 17 Leave / delete / clear | 7 | 0 |
 | 18 Channels — owner | 58 | 1 |
 | 19 Channels — subscriber | 26 | 0 |
-| 20 Business chats | 16 | 0 |
-| **Total** | **312** | **4** |
+| 20 Business chats | 9 | 0 |
+| **Total** | **231** | **4** |
diff --git a/plans/ui-tests/catalogue/04-settings-database-remote.md b/plans/ui-tests/catalogue/04-settings-database-remote.md
index 955e5c2453..07eae0762f 100644
--- a/plans/ui-tests/catalogue/04-settings-database-remote.md
+++ b/plans/ui-tests/catalogue/04-settings-database-remote.md
@@ -31,81 +31,81 @@ Every settings and non-chat screen of the desktop app, mapped to UI test cases:
 
 ---
 
-### A. Settings root and global keys (7 tests)
+### A. Settings root and global keys (5 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Root | Desktop item list | Settings | `US/SettingsView.kt:81-144` | `settingsRoot_listsDesktopItems` | "Your settings" title; "Appearance", "Your privacy", "Help & support", "Chat data", "Migrate to another device", "Supporter perks"; under "Advanced settings": "Network & servers", "Audio & video calls", version row "<DESKTOP_VERSION_NAME> (<DESKTOP_VERSION_CODE>)" (e.g. "7.1-beta.6 (167)", no "v" prefix); NO "Notifications" item (Android-only, :124) and no shutdown item | — | – |
-| Root | Disabled when stopped | Settings | `SettingsView.kt:103-127,213` | `settingsRoot_itemsDisabledWhenChatStopped` | After `/_stop`: privacy, migrate, network and calls are disabled; Chat data shows the "Chat is stopped" red icon (contentDescription) | — | Stop the chat via Chat data first |
+| Root | Rows open their screens | Settings > each row, then Esc | `US/SettingsView.kt:101-133` | `settingsRoot_rowsOpenTheirScreens` | Every row opens its screen in place of "Your settings" (title plus a text only that screen has): Appearance ("Color mode"), "Your privacy" ("More privacy"), "Help & support" ("How to use it"), "Chat data" ("Database passphrase & export"), "Network & servers" ("Advanced network settings"), "Your calls" ("WebRTC ICE servers"), the version row → "App version" ("Developer tools"); no other row's screen is shown; Esc returns to "Your settings" and the next Esc closes it | — | Shared (both platforms). `keyboard_escClosesTopModal` merged into `settingsRoot_rowsOpenTheirScreens`. The desktop item list (no "Notifications", no shutdown item) is not asserted |
+| Root | Disabled when stopped | Settings, after stopping the chat in Chat data > "Database passphrase & export" | `SettingsView.kt:106,126,130,162-163,213-221` | `settingsRoot_itemsDisabledWhenChatStopped` | Before the stop Chat data has no "Chat is stopped" icon; after "Stop chat?" > Stop it has (contentDescription); taps on "Your privacy", "Network & servers" and "Audio & video calls" open nothing; "Help & support" still opens, where "How to use it" and "What's new" open nothing and "About SimpleX Chat" opens | — | Shared. `help_disabledItemsWhenStopped` merged into `settingsRoot_itemsDisabledWhenChatStopped`. Migrate is not tapped (enabled, it opens the full-screen migration flow) |
 | Root | Crowdfunding | Settings > "Crowdfunding on Wefunder" | `SettingsView.kt:132-141` | `settingsRoot_crowdfundingOpensGetStake` | GetStakeView opens (`C/views/onboarding/WhatsNewView.kt:1173`; title "Invest in\nSimpleX Chat", a hard-coded literal with a line break at `WhatsNewView.kt:1200`, joined into one line when the page is in the centre of the window (`WhatsNewView.kt:1201`)); "Learn more on Wefunder" records `https://wefunder.com/simplex.chat?utm_source=app` in the URI stub (`WhatsNewView.kt:1232-1236`) | URI | `crowdfundingAvailable()` is true on desktop |
-| Picker | Color mode switch (click) | Picker > moon/sun icon on the Settings row | `US/Appearance.kt:738-768` | `userPicker_colorModeSwitcherClick` | Pref CurrentTheme toggles LIGHT/DARK; Log `/_save app settings` | — | – |
-| Picker | Color mode switch (right-click) | Picker > right-click the moon/sun icon | `US/Appearance.kt:738-768` | `userPicker_colorModeSwitcherRightClickSystem` | Right-click, after a left click has set LIGHT/DARK, sets SYSTEM plus toast "System mode"; a second `/_save app settings` in the Log (each save runs 300 ms after its click and a newer click cancels a pending one, Appearance.kt:778-782) | TOAST | Right-click uses `onRightClick` |
-| Global keys | Esc closes modal | Settings > Appearance, press Esc | `DesktopApp.kt:125-130`, `D/platform/Back.desktop.kt:9` | `keyboard_escClosesTopModal` | The top modal pops; the next Esc closes Settings | — | Uses `escape()` (harness fact 2) |
+| Picker | Color mode switch | Picker > moon/sun icon on the Settings row: click, click, right-click (long press on Android) | `US/Appearance.kt:743-772` | `userPicker_colorModeSwitcher` | From System: the first click applies and stores (Pref CurrentTheme) the mode opposite to the system one, the second click the system mode as an explicit theme (LIGHT or the dark theme name), the right-click SYSTEM again (`CurrentColors.value.name`) | — | Shared. The "System mode" toast and the `/_save app settings` log are not asserted |
+| Picker | Color mode switch (right-click) | Picker > right-click the moon/sun icon | `US/Appearance.kt:752` |  | – | — | `userPicker_colorModeSwitcherRightClickSystem` merged into `userPicker_colorModeSwitcher` |
+| Global keys | Esc closes modal | Settings > Appearance, press Esc | `DesktopApp.kt:125-130`, `D/platform/Back.desktop.kt:9` |  | – | — | `keyboard_escClosesTopModal` merged into `settingsRoot_rowsOpenTheirScreens` |
 | Global keys | Esc dismisses alert | Settings > "Network & servers" > "Use SOCKS proxy" (alert "Use SOCKS proxy?"), press Esc | `C/views/helpers/AlertManager.kt:126-141`, `NS/NetworkAndServers.kt:101-125` | `keyboard_escDismissesAlert` | The alert is dismissed, the switch stays off, no `/_network` appears in the Log, and Network & servers stays open | — | `press(Key.Escape)` on the dialog root (harness fact 2): AlertManager registers no back handler, so `escape()` would close the modal under the alert instead |
 
 User picker rows, profile switching, profile editing (including the invalid-name and close-on-user-switch checks reached from Settings), the chat-profiles list and user chat preferences are owned by catalogue 01 (§5, §14).
 
-### B. Privacy (Your privacy, More privacy, receipts) (24 tests)
+### B. Privacy (Your privacy, More privacy, receipts) (22 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
 | Privacy | Layout | Settings > "Your privacy" | `US/PrivacySettings.kt:55-117`, `D/views/usersettings/PrivacySettings.desktop.kt` | `privacy_sectionsAndFooter` | Sections "Device" (SimpleX Lock only), "Chats", "Files", "Auto-accept" (footer names the current profile), then an untitled section with the "More privacy" item | — | No screen-protection option on desktop |
-| Privacy | Link previews off | "Send link previews" | `PrivacySettings.kt:66-71` | `privacy_linkPreviewsOff_noPreview` | Pref PrivacyLinkPreviews=false; a link to `http://127.0.0.1:<port>/page` is sent without a preview and bob receives plain text | P (bob), HTTP | 04 owns turning the setting off; previews with the setting on are in catalogue 02 §B. `localhost` isn't parsed as a link; use 127.0.0.1 |
-| Privacy | Remove link tracking | "Remove link tracking" | `PrivacySettings.kt:72-76`, `C/views/chat/ComposeView.kt:1023-1069` | `privacy_removeLinkTracking` | Pref PrivacySanitizeLinks; with the setting on, `utm_*` parameters are removed from the URL in the compose field while typing, and bob receives the URL without them; with it off, the URL is kept as typed | P (bob) | 04 owns this setting and its effect (legend) |
-| Privacy | Auto-accept images off | "Auto-accept images" | `PrivacySettings.kt:81` | `privacy_autoAcceptImagesOff` | Pref PrivacyAcceptImages=false; bob sends an image (`/img`); once the image item is in alice's chat with bob (the CLI prints the sent image before it reaches her, so an earlier check would pass before any receipt could start), and the app is idle (`UiIdle`: the auto-download decision runs in the same background job right after the item is added, `SimpleXAPI.kt:3012-3037`), no `/freceive <fileId>` (`SimpleXAPI.kt:4304`) appears in the Log and the image stays undownloaded | P (bob), XFTP | 04 owns turning the setting off; automatic receipt with the setting on is in catalogue 02 §G |
-| Privacy | Blur media | "Blur media" (Off/Soft/Medium/Strong) | `PrivacySettings.kt:311-333` | `privacy_blurMediaOptions` | Pref PrivacyMediaBlurRadius = 0/12/24/48 | — | The blur itself is visual only; the pref is asserted |
-| Auto-accept | Group invitations | "Group invitations" | `PrivacySettings.kt:98-103,357` | `privacy_autoAcceptGroupInvitations` | Log `/_set accept group invitations <userId> on` (`SimpleXAPI.kt:4134`); bob invites, GUI joins without action (`H/Profiles.hs` testAutoAcceptGroupInvitations) | P (bob) | – |
-| Auto-accept | Member contact requests | "Contact requests in groups" | `PrivacySettings.kt:92-97,349` | `privacy_autoAcceptContactRequestsInGroups` | Log `/_set accept member contacts <userId> on` (`SimpleXAPI.kt:4133`); a member's contact request is auto-accepted | P ×2 (bob, cath) | bob hosts `team` (`/g team`, so "Direct messages" is on; alice-created groups start with it off, `AddGroupView.kt:160-162`, and with it off the request fails with "direct messages not allowed", `src/Simplex/Chat/Library/Commands.hs:2624`) and invites alice and cath. cath, who is not alice's contact, sends `@#team alice hi`: only a sender who isn't already alice's contact creates a member-contact request, an existing contact just sends a direct message (`Commands.hs:2621-2633`). alice takes no action; cath prints `alice: contact is connected` |
+| Privacy | Link previews off | "Send link previews" | `PrivacySettings.kt:67-73`, `C/views/chat/ComposeView.kt:1078` | `privacy_linkPreviewsOff_noPreview` | Pref PrivacyLinkPreviews=false; a link to `http://127.0.0.1:<port>/off.jpg` typed in bob's chat shows no compose preview, the local site gets no request (checked once the app is idle: the preview job waits 1.5 s, `ComposeView.kt:462-503`), and bob's `/_get chat` JSON has the item as `"type":"text"`; with the setting back on, `on.jpg` shows the "link preview image" and its title in the compose area, bob's item is `"type":"link"` with preview title `on.jpg`, and the site was asked only for `/on.jpg` | P (bob), HTTP | Desktop-only (`PrivacyDesktopTest`): the local site is a JDK `HttpServer`, and Android blocks cleartext HTTP to 127.0.0.1 (the app has no network security config), so the on-branch control cannot get a preview there. A URL path ending in `.jpg` makes the preview fetch only the image (`LinkPreviews.kt:90-94`). The CLI prints only the text of a link message, so bob's item type is read from `/_get chat` (`View.hs` `CRApiChat` → `viewJSON`). `localhost` isn't parsed as a link; use 127.0.0.1 |
+| Privacy | Remove link tracking | "Remove link tracking" | `PrivacySettings.kt:74-80`, `C/views/chat/ComposeView.kt:1026-1070` | `privacy_removeLinkTracking` | Pref PrivacySanitizeLinks (default off); with it off, `https://example.com/page?q=chat&utm_source=app` entered in bob's compose field stays as typed and bob receives it unchanged; after turning it on (stored `true`), the same text becomes `https://example.com/page?q=chat` in the field (the whitelisted `q` stays, `utm_source` goes, `src/Simplex/Chat/Markdown.hs` `sanitizeUri`) and bob receives the cleaned URL | P (bob) | Desktop-only (`PrivacyDesktopTest`): the text is put in with `enterText`, and on Android the message field is a native EditText that only `typeInto`/`replaceText` reach, and both wait for the field to hold the typed text, which sanitizing changes. Link previews are turned off first (precondition) so no preview fetch to example.com runs. 04 owns this setting and its effect (legend) |
+| Privacy | Auto-accept images off | "Auto-accept images" | `PrivacySettings.kt:84`, `SimpleXAPI.kt:3047-3074` | `privacy_autoAcceptImagesOff` | Pref PrivacyAcceptImages=false; bob sends an image (`/img`); once the image item is in alice's chat with bob and the app is idle (`UiIdle`: the auto-download decision runs in the same tracked `withBGApi` job right after the item is added, `SimpleXAPI.kt:3047-3074`), the image is still `RcvInvitation`, its item shows "Asked to receive the image" and nothing is saved in the app files folder; with the setting back on, bob's second image is received without a tap while the first stays `RcvInvitation` | P (bob), XFTP | 04 owns turning the setting off; automatic receipt with the setting on is also in catalogue 02 §G (`rcvImage_autoReceived_renders`) |
+| Privacy | Blur media | "Blur media" (Off/Soft/Medium/Strong) | `PrivacySettings.kt:316-338` | `privacy_blurMediaOptions` | The row shows "Off" (pref unset); the options are Off/Soft/Medium/Strong (0/12/24/48); "Medium" shows on the row and stores PrivacyMediaBlurRadius=24, and after `restart()` the row still shows "Medium" | RESTART | The blur itself is visual only; the pref and the row text are asserted |
+| Auto-accept | Group invitations | "Group invitations" | `PrivacySettings.kt:102-107,365-372` | `privacy_autoAcceptGroupInvitations` | bob invites alice to `club` with the setting off: alice's membership stays `MemInvited`; turning the switch on sets `autoAcceptGroupInvitations` in the model and the core (`/_set accept group invitations <userId> on`, `SimpleXAPI.kt:1079`); bob then invites alice to `team` and prints `#team: alice joined the group` with no action from alice, whose membership becomes `MemConnected`, while `club` stays `MemInvited` (the core decides on receipt, `Library/Subscriber.hs:2723`) | P (bob) | – |
+| Auto-accept | Member contact requests | "Contact requests in groups" | `PrivacySettings.kt:96-101,356-363` | `privacy_autoAcceptContactRequestsInGroups` | alice hosts `team` with "Direct messages" on and cath joined through the group link (`linkGroupWithDirectMessages`, so cath is not alice's contact); turning the switch on sets `autoAcceptMemberContacts` in the model and the core (`/_set accept member contacts <userId> on`); cath sends `@#team alice hi from the group` (prints the three "creating direct contact" lines and `@alice …`), then prints `alice: contact is connected` with no action from alice; alice's new chat with cath has the message and the message field, with no "Accept"/"Reject" | P (cath) | The off branch (Accept/Reject shown) is `memberContact_acceptAndRejectRequests` (catalogue 03). Only a sender who is not already alice's contact creates a member-contact request (`Commands.hs:2621-2633`) |
 | More privacy | Last messages | Settings > Your privacy > "More privacy" > "Show last messages" | `PrivacySettings.kt:125-132` | `morePrivacy_showLastMessages` | Pref PrivacyShowChatPreviews; chat list preview text disappears | P (bob) | – |
-| More privacy | Drafts off | "Message draft" | `PrivacySettings.kt:133-142` | `morePrivacy_messageDraftDisabledClears` | Pref PrivacySaveLastDraft=false; text typed in bob's chat is gone from the compose field after opening cath's chat and returning | P ×2 (bob, cath) | 04 owns turning the setting off; draft behaviour with the setting on (the default) is in catalogue 02 §S |
+| More privacy | Drafts off | "Message draft" | `PrivacySettings.kt:139-148`, `C/views/chat/ComposeView.kt:1428` | `morePrivacy_messageDraftDisabledClears` | With the setting on (default) text typed in bob's chat is restored after visiting the notes and shows as the draft on bob's row; turning "Message draft" off stores PrivacySaveLastDraft=false and removes that draft from bob's row and field; text typed afterwards is gone from the field after visiting the notes and returning, and no draft shows on bob's row | P (bob) | 04 owns turning the setting off; draft behaviour with the setting on is in catalogue 02 §S |
 | More privacy | Verify names | "Verify SimpleX names" | `PrivacySettings.kt:143-147` | `morePrivacy_verifySimplexNamesPref` | Pref PrivacyVerifySimplexNames (default off); bob's profile carries a registered SimpleX name; with the pref on, opening bob's contact info verifies the name automatically (`C/views/chat/SimplexNameView.kt:63-65`, shown at `C/views/chat/ChatInfoView.kt:760`): once bob's `contact.profile.contactDomainVerified` is true (polled, `SimplexNameView.kt:125,130`; the link is also absent while the spinner shows and after a failed verification, :38-60, 76-96) the name has no "Verify name" link (its check icon, :80-84,111-115, has no description, so it shows only in the screenshot); with it off, the name shows the "Verify name" link (`SimplexNameView.kt:89-96`) until it is clicked | P (bob), NAMES | – |
-| More privacy | Encrypt files | "Encrypt local files" | `PrivacySettings.kt:158-160` | `morePrivacy_encryptLocalFilesOn`, `morePrivacy_encryptLocalFilesOff` | Log `/_files_encrypt on/off`; the received file on disk differs from (or equals) the fixture bytes (`H/Files.hs` testXFTPFileTransferEncrypted) | P (bob), XFTP | – |
+| More privacy | Encrypt files | "Encrypt local files" | `PrivacySettings.kt:165-167`, `SimpleXAPI.kt:2273` | `morePrivacy_encryptLocalFilesOff` | bob sends an image (auto-received): with the setting on (default) the file has `cryptoArgs` and is not the plain JPEG on disk (size differs from `fileSize` or no JPEG header); after turning it off (stored `false`) bob's second image has no `cryptoArgs` and is stored as the plain JPEG (size equals `fileSize`, JPEG header), and the first one stays encrypted | P (bob), XFTP | `morePrivacy_encryptLocalFilesOn` merged into `morePrivacy_encryptLocalFilesOff`. The received file is encrypted according to the pref passed to `/freceive` (`SimpleXAPI.kt:2273`); the core `/_files_encrypt` (`PrivacySettings.kt:166`) covers sent files and is not asserted |
 | More privacy | Protect IP | "Protect IP address" | `PrivacySettings.kt:161-170` | `morePrivacy_protectIpAsksForUnknownXftp`, `morePrivacy_protectIpOffDownloadsSilently` | Pref PrivacyAskToApproveRelays and the footer text change (PrivacySettings.kt:164-170): on, "The app will ask to confirm downloads from unknown file servers (except .onion or when SOCKS proxy is enabled)."; off, "Without Tor or VPN, your IP address will be visible to file servers."; on: clicking bob's file shows "Unknown servers!" (`SimpleXAPI.kt:2309`); off: no alert, the Log has `/freceive <fileId> approved_relays=on …` (:2235, 4303) and the file downloads | P (bob, using the second XFTP server), XFTP2 | bob uses `cli(…, servers = PeerServers(xftp = "xftp2"))` (plan §9.2) |
 | More privacy | Show encryption | "Show encryption" | `PrivacySettings.kt:162`, `C/views/chat/item/CIMetaView.kt:82,111-114` | `morePrivacy_showEncryptionToggle` | Pref PrivacyShowEncryption; bob sends a file and the GUI receives it (the icon needs the downloaded file, `C/views/chat/item/CIFileView.kt:210`); with the setting on, the item shows the lock icon (`ItemMetaKey` `encrypted`); with it off, no lock icon | P (bob), XFTP | 04 owns this setting and the lock icon |
 | More privacy | Notification preview | "Show preview" > Message text / Contact name / Hidden | `PrivacySettings.kt:173-195`, `US/NotificationsSettingsView.kt:81` | `morePrivacy_notificationPreviewModes` | Pref NotificationPreviewMode per mode; when bob messages, the recording notification manager records a notification call | P (bob), NTF | One test iterating over the 3 modes. The preview text is built inside the desktop notification manager (`D/model/NtfManager.desktop.kt:100-102`), below the recording notification manager, so the test asserts the pref and that a notification call was recorded (plan §7.6) |
-| Receipts | Contacts toggle (no overrides) | "Send delivery receipts to" > "Contacts" | `PrivacySettings.kt:199-266,386` | `receipts_contactsToggle_noOverrides` | Log `/_set receipts contacts <userId> <on/off> clear_overrides=off` (no overrides exist, so the app passes `clearOverrides = false`, `PrivacySettings.kt:261-262`; `SimpleXAPI.kt:4127`); Pref PrivacyDeliveryReceiptsSet goes from false to true; no alert (`H/Direct.hs` testConfigureDeliveryReceipts) | P (bob) | The harness pre-set of `privacyDeliveryReceiptsSet` is cleared first (the startup prompt is checked only in `startChat`, so it does not appear without a restart) |
+| Receipts | Contacts and groups toggles (no overrides) | "Send delivery receipts to" > "Contacts", "Small groups (max 20)" | `PrivacySettings.kt:202-290,386-423` | `receipts_contactsAndGroupsToggles_peerReceipts` | bob reads his sent items' status from `/_get chat` JSON (`meta.itemStatus.type`; the CLI prints receipts only in test view, `View.hs` `viewChatItemStatusUpdated`): with the defaults, bob's direct `d0` and group `g0` become `sndRcvd`; "Contacts" off (no alert; PrivacyDeliveryReceiptsSet becomes true) → `d1` stays `sndSent` while `g1` still gets a receipt; "Small groups" off and "Contacts" on → `d2` gets a receipt and `g2` stays `sndSent`; "Small groups" on → `g3` gets one. Each "stays `sndSent`" is checked after a later item on the same connection got its receipt (receipts arrive in order) | P (bob) | alice hosts `team` with bob. The harness pre-set of PrivacyDeliveryReceiptsSet is cleared first (`clearReceiptsChoiceViaApi`). Each toggle waits until alice has the previous items, because the core reads the setting when it receives a message (`Library/Subscriber.hs` `checkSendRcpt`) |
 | Receipts | Contacts toggle (with overrides) | "Send delivery receipts to" > "Contacts" | `PrivacySettings.kt:199-266,386` | `receipts_contactsOverrideAlert_keep`, `receipts_contactsOverrideAlert_forAll`, `receipts_contactsOverrideAlert_cancel` | Alert "Disable receipts?" with "Disable (keep overrides)" / "Disable for all" / "Cancel"; Log `/_set receipts contacts <userId> off clear_overrides=<off/on>` or nothing on cancel (`H/Direct.hs` testConfigureDeliveryReceipts) | P (bob) | bob's contact has receipts explicitly turned on first through the GUI: bob's contact info > "Send receipts" > "yes" (`C/views/chat/ChatInfoView.kt:84-87,1228-1239`). A console `/receipts @bob on` replies only `ok` and does not update the GUI's chat model, which the alert counts overrides from (`PrivacySettings.kt:248-256`), so no alert would show; an "off" override is not counted when disabling (`PrivacySettings.kt:253-264`) |
-| Receipts | Groups toggle (no overrides) | "Small groups (max 20)" | `PrivacySettings.kt:224-281,394` | `receipts_groupsToggle` | Log `/_set receipts groups <userId> <on/off> clear_overrides=off` (no contact or group overrides exist, so the app passes `clearOverrides = false`, `PrivacySettings.kt:267-279`; `SimpleXAPI.kt:4131`) (`H/Groups.hs` testConfigureGroupDeliveryReceipts) | P | A group with bob is set up first |
+| Receipts | Groups toggle (no overrides) | "Small groups (max 20)" | `PrivacySettings.kt:229-290,386-423` |  | Log `/_set receipts groups <userId> <on/off> clear_overrides=off` (no contact or group overrides exist, so the app passes `clearOverrides = false`, `PrivacySettings.kt:272-286`; `SimpleXAPI.kt:4131`) (`H/Groups.hs` testConfigureGroupDeliveryReceipts) | P | `receipts_groupsToggle` merged into `receipts_contactsAndGroupsToggles_peerReceipts` |
 | Receipts | Groups toggle (with overrides) | "Small groups (max 20)" | `PrivacySettings.kt:224-281,394` | `receipts_groupsOverrideAlert` | Alert "Disable receipts for groups?" with "Disable (keep group overrides)" / "Disable for all groups" / "Cancel"; Log `/_set receipts groups <userId> off clear_overrides=<off/on>` or nothing on cancel (`PrivacySettings.kt:452-481`; `H/Groups.hs` testConfigureGroupDeliveryReceipts) | P | A group with bob is set up first, with group receipts turned on through the GUI: group info > "Send receipts" > "yes" (`C/views/chat/group/GroupChatInfoView.kt:93-96,735`). A console `/receipts #<group> on` does not update the GUI's chat model (`PrivacySettings.kt:262-270`), so no alert would show; an "off" override is not counted when disabling (`PrivacySettings.kt:268-279`) |
-| Startup | Receipts prompt | app start with PrivacyDeliveryReceiptsSet=false | `US/SetDeliveryReceiptsView.kt:22-122`, `SimpleXAPI.kt:679-681`, `C/App.kt:371` | `deliveryReceiptsStartupView_enable`, `deliveryReceiptsStartupView_skip` | "Delivery receipts!" → "Enable" sends `/set receipts all on`; "Don't enable" shows the "Delivery receipts are disabled!" alert | RESTART | 04 owns this prompt; the harness pre-set of `privacyDeliveryReceiptsSet` is cleared, then the core restarted |
+| Startup | Receipts prompt | app start with PrivacyDeliveryReceiptsSet=false | `US/SetDeliveryReceiptsView.kt:22-122`, `SimpleXAPI.kt:712-714`, `C/App.kt:372` | `deliveryReceiptsStartupView_enable`, `deliveryReceiptsStartupView_skip` | Contact receipts are turned off and the choice cleared (preconditions), then `restart()`: "Delivery receipts!" with "Enable" and "Don't enable" replaces the chat list. `_enable`: "Enable" turns contact receipts on in the core (`/set receipts all on`), stores PrivacyDeliveryReceiptsSet=true and shows the chat list; after another restart the screen is not shown. `_skip`: "Don't enable" → "Delivery receipts are disabled!" (OK / "Don't show again"); OK shows the chat list, stores nothing and leaves receipts off, so the next restart shows the screen again; "Don't show again" stores the choice, receipts stay off, and the next restart shows no screen | RESTART | 04 owns this prompt; the harness pre-set of `privacyDeliveryReceiptsSet` is cleared through the API (precondition) |
 
-### C. SimpleX Lock (desktop passcode) and self-destruct (22 tests)
+### C. SimpleX Lock (desktop passcode) and self-destruct (12 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Lock | Enable | Settings > Your privacy > "SimpleX Lock" > "Enable lock" | `PrivacySettings.kt:639-673`, `C/views/localauth/SetAppPasscodeView.kt:13` | `lock_enable_setsPasscode` | "New Passcode" → digits + Enter → "Confirm passcode" → alert "Passcode set!"; Pref PerformLA=true, LocalAuthenticationLockDelay=30, EncryptedAppPassphrase decodes (Base64) to the digits | — | Only PASSCODE mode on desktop (`LAMode.default`) |
-| Lock | Cancel | same > Cancel | `PrivacySettings.kt:659-663` | `lock_enable_cancelKeepsOff` | PerformLA stays false | — | – |
-| Lock | Mismatch | same, wrong confirmation | `SetAppPasscodeView.kt:27-55` | `lock_enable_confirmMismatch` | Not saved; stays on the confirm step | — | – |
-| Lock | Lock after | "Lock after" | `PrivacySettings.kt:809-842` | `lock_lockAfterOptions` | "10 seconds", "30 seconds", "1 minutes", "3 minutes", "10 minutes", "Immediately"; Pref LocalAuthenticationLockDelay | — | Lock enabled first |
-| Lock | Change passcode | "Change passcode" | `PrivacySettings.kt:588-610` | `lock_changePasscode_success`, `lock_changePasscode_wrongCurrent` | "Current Passcode" → new → "Passcode changed!"; wrong current gives "Authentication failed" | — | Lock enabled first |
-| Lock | Disable | toggle off | `PrivacySettings.kt:670-672`, `C/AppLock.kt:185` | `lock_disable_requiresPasscode` | Passcode prompt, then PerformLA=false | — | Lock enabled first |
-| Lock | Startup screen | restart with lock on | `App.kt:210-224`, `C/views/localauth/LocalAuthView.kt:18-49` | `lock_screenOnStartup_correct`, `lock_screenOnStartup_wrong_showsUnlock` | "Enter Passcode" / "Submit"; `lock_screenOnStartup_correct`: the right passcode and "Submit" close the passcode screen and show the chat list "Chats" (`LocalAuthView.kt:35-39`, `C/AppLock.kt:162-163`, `App.kt:210-224`); `lock_screenOnStartup_wrong_showsUnlock`: a wrong passcode shows the "Authentication failed" alert (`laFailedAlert`, `C/AppLock.kt:164-168`), then the "Unlock" button | RESTART | – |
-| Lock | Relock | after background | `AppLock.kt:271-290`, `DesktopApp.kt:184-206` | `lock_relocksAfterDelay` | With "Lock after" set to "10 seconds", an immediate `appWasHidden()` + `recheckAuthState()` leaves the chat list; after `wait(10 s)` the recheck shows "Enter Passcode" (the delay is measured with `System.nanoTime()`, `AppLock.kt:269, 277-279`, not the test clock; `DesktopApp.kt:186-192`) | — | Lock enabled first; window focus is simulated (harness fact 7) |
-| Lock | Protected actions | "Migrate to another device"; version row > "Developer tools" > "Chat console"; a profile action inside Picker > "Your chat profiles"; Chat data > "Database passphrase & export" > "Chat is running" off → "Stop chat?" → "Stop" | `SettingsView.kt:473-520`, `US/DeveloperView.kt:32`, `C/views/database/DatabaseView.kt:296-307,443-451,462-466`, `UserPicker.kt:268-297` | `lock_protectedActionsPrompt`, `profiles_actionsRequireAuthOnceWhenLocked` | Prompts "Open migration screen" / "Open chat console" / "Change chat profiles" / "Stop chat" (one test iterating over the 4 actions); opening "Your chat profiles" itself does not prompt; its first profile action prompts, and later actions in the same screen don't (stateGetOrPut "authorized", `UserPicker.kt:274-292`) | — | Lock enabled first |
-| Lock | Notice | chat list with >3 chats | `App.kt:93-104`, `AppLock.kt:36-45` | `lock_noticeOfferedWithManyChats` | "SimpleX Lock" alert → "Turn on" starts the passcode flow; Pref LANoticeShown | RESTART | 04 owns this notice. The check runs once at first composition (`App.kt:94-103`), so the pre-set of `laNoticeShown` is cleared, chats are created until `chatModel.chats.size > 3` (local groups via the console; the size counts the notes folder and the "Ask SimpleX Team" card, so two are enough), and the core restarted (harness fact 4) |
-| Lock | Keyboard entry | passcode screen | `C/views/localauth/PasscodeView.kt:34-62` | `lock_passcodeKeyboardKeys` | Digits, NumPad, Backspace, Ctrl+Backspace clears, Enter submits only when ≥4 digits | — | – |
-| Lock | On-screen keypad | Settings > Your privacy > "SimpleX Lock" > "Enable lock" → "New Passcode": click 1 2 3 4 5, backspace, the dots, clear (x), then 1 2 3 4 → "Save" → "Confirm passcode": 1 2 3 4 → "Confirm" | `C/views/localauth/PasswordEntry.kt:22-48, 50-69, 101-145`; `C/views/localauth/PasscodeView.kt:64-84, 130-131` | `lock_passcodeKeypad_digitsBackspaceClearReveal` | Five clicks show "●●●●●"; backspace leaves "●●●●"; clicking the dots shows "1234" and clicking again masks it; clear (x) empties the field and "Save" is disabled (fewer than 4 digits, PasscodeView.kt:81); after confirming, "Passcode set!" and PerformLA=true as in `lock_enable_setsPasscode` | — | Desktop always uses the vertical keypad (PasscodeView.kt:130-131). Clear and backspace have no content description and digits are plain text: K4 keys needed |
-| Self-destruct | Enable | "Enable self-destruct" | `PrivacySettings.kt:569-586,761-776` | `selfDestruct_enable`, `selfDestruct_cannotEqualAppPasscode` | "Current Passcode" → "Set passcode" ("Enable self-destruct passcode") → "Confirm passcode" → "Self-destruct passcode enabled!"; Pref LocalAuthenticationSelfDestruct=true; with the app passcode typed as the new one, "Save" stays disabled and Enter is ignored (`SetAppPasscodeView.kt:54-55`, `PasscodeView.kt:53-56,81`) | — | Lock enabled first |
-| Self-destruct | Info | info icon | `PrivacySettings.kt:745-758` | `selfDestruct_infoView` | "Self-destruct" page with 3 items | — | Lock enabled first (the section shows only with the lock on, `PrivacySettings.kt:697`) |
-| Self-destruct | Display name | "New display name:" | `PrivacySettings.kt:716-730` | `selfDestruct_displayNamePersisted` | Pref LocalAuthenticationSelfDestructDisplayName | — | Lock and self-destruct enabled first (`PrivacySettings.kt:697`) |
-| Self-destruct | Change | "Change self-destruct passcode" → "Current Passcode" (the app passcode) → new digits → "Save" → same digits → "Confirm" | `PrivacySettings.kt:612-637`; `C/views/localauth/SetAppPasscodeView.kt:13-61` | `selfDestruct_changePasscode` | "Self-destruct passcode changed!"; EncryptedSelfDestructPassphrase decodes to the new digits | — | Lock and self-destruct enabled first (`PrivacySettings.kt:697`) |
-| Self-destruct | Trigger | restart, enter the self-destruct code | `LocalAuthView.kt:26-31,51-102` | `selfDestruct_triggeredOnLockScreen` | DB deleted, new profile with that display name, bob contact gone, the app passcode becomes the self-destruct code | RESTART, P (bob) | – |
-| Self-destruct | Disable | toggle off → "Current Passcode" (the app passcode) | `PrivacySettings.kt:569-583,511-514` | `selfDestruct_disable` | Pref LocalAuthenticationSelfDestruct=false; prefs EncryptedSelfDestructPassphrase and InitializationVectorSelfDestructPassphrase unset (`DatabaseUtils.kt:36-40`; the Keystore delete does nothing on desktop, `Cryptor.desktop.kt:12-14`) | — | Lock and self-destruct enabled first (`PrivacySettings.kt:697`) |
+| Lock | Enable | Settings > Your privacy > "SimpleX Lock" > "Enable lock" | `PrivacySettings.kt:649-681`, `C/views/localauth/SetAppPasscodeView.kt:13`, `C/views/localauth/PasswordEntry.kt:53-74` | `lock_enable_setsPasscode` | "SimpleX Lock" shows "Off" and there are no "Lock after", "Change passcode" or self-destruct options; "Enable lock" → "New Passcode" → keypad 1234 → "Cancel" keeps the lock off; again → 1234 → "Save" → "Confirm passcode" (button "Confirm") → 1243 → "Confirm" does nothing (still the confirm step, no alert, nothing stored) → backspace ×2, 34 → "Confirm" → alert "Passcode set!"; Pref PerformLA=true, LocalAuthenticationLockDelay=30, EncryptedAppPassphrase decodes (Base64) to 1234; "Lock after" shows "30 seconds", "Change passcode" and "Enable self-destruct" appear, and "SimpleX Lock" shows "Passcode" | — | Desktop-only (`LockDesktopTest`): Android uses system authentication (`LAMode.default`). The keypad digits, backspace, clear and the passcode buttons are keyed (`passcode.*`) |
+| Lock | Cancel | same > Cancel | `PrivacySettings.kt:667-671` |  | PerformLA stays false | — | `lock_enable_cancelKeepsOff` merged into `lock_enable_setsPasscode` |
+| Lock | Mismatch | same, wrong confirmation | `SetAppPasscodeView.kt:27-55` |  | Not saved; stays on the confirm step | — | `lock_enable_confirmMismatch` merged into `lock_enable_setsPasscode` |
+| Lock | Lock after | "Lock after" | `PrivacySettings.kt:819-852` |  | "10 seconds", "30 seconds", "1 minutes", "3 minutes", "10 minutes", "Immediately"; Pref LocalAuthenticationLockDelay | — | `lock_lockAfterOptions` merged into `lock_relocksAfterDelay` |
+| Lock | Change passcode | "Change passcode" | `PrivacySettings.kt:596-618` | `lock_changePasscode_newPasscodeUnlocks` | "Current Passcode" with a wrong code gives "Authentication failed" and keeps the stored passcode; with the right one → "New Passcode" ("App passcode") → 5678 → "Confirm passcode" → "Passcode changed!"; EncryptedAppPassphrase decodes to 5678 and after `restart()` 5678 unlocks the lock screen | RESTART | Desktop-only (`LockDesktopTest`). Lock enabled first. `lock_changePasscode_success` and `lock_changePasscode_wrongCurrent` merged into `lock_changePasscode_newPasscodeUnlocks` |
+| Lock | Disable | toggle off | `PrivacySettings.kt:678-680`, `C/AppLock.kt:230-267` | `lock_disable_requiresPasscode` | Toggling off asks "Enter Passcode" / "Disable SimpleX Lock"; a wrong code gives "Authentication failed" and keeps PerformLA=true and the passcode; the right code stores PerformLA=false, removes EncryptedAppPassphrase and hides "Lock after" and "Change passcode"; after `restart()` the app opens without a passcode screen | RESTART | Desktop-only (`LockDesktopTest`). Lock enabled first |
+| Lock | Startup screen | restart with lock on | `App.kt:118-134,212-224`, `C/views/localauth/LocalAuthView.kt:18-49`, `C/AppLock.kt:141-183` | `lock_screenOnStartup_wrongThenCorrect` | After `restart()`: "Enter Passcode" / "Unlock" with "Submit", the app not authorized; a wrong passcode shows the "Authentication failed" alert (`laFailedAlert`), then the "Unlock" button; "Unlock" asks again, and the right passcode closes the screen, authorizes the app, and a note can be written in Private notes | RESTART | Desktop-only (`LockDesktopTest`). The chat list stays composed under the lock screen (`App.kt:136-224`), so the locked state is checked with `AppLock.userAuthorized`. `lock_screenOnStartup_correct` and `lock_screenOnStartup_wrong_showsUnlock` merged into `lock_screenOnStartup_wrongThenCorrect` |
+| Lock | Relock | after background | `AppLock.kt:271-290`, `DesktopApp.kt:184-206`, `PrivacySettings.kt:819-852` | `lock_relocksAfterDelay` | With the default "30 seconds", an immediate `appWasHidden()` + `recheckAuthState()` keeps the app authorized; "Lock after" lists "10 seconds", "30 seconds", "1 minutes", "3 minutes", "10 minutes", "Immediately"; "Immediately" shows on the row and stores LocalAuthenticationLockDelay=0, and the next hide + recheck shows "Enter Passcode", which the passcode unlocks | — | Desktop-only (`LockDesktopTest`). Lock enabled first; window focus is simulated (harness fact 7). "Immediately" replaces a real 10 s wait (the delay is measured with `System.nanoTime()`, `AppLock.kt:269, 277-279`, not the test clock). The "Lock after" options row is merged here |
+| Lock | Protected actions | version row > "Developer tools" > "Chat console"; "Migrate to another device"; Chat data > "Database passphrase & export" > "Chat is running" off → "Stop chat?" → "Stop"; a profile action inside Picker > "Your chat profiles" | `SettingsView.kt:109,483-530`, `US/DeveloperView.kt:33`, `C/views/database/DatabaseView.kt:474-497`, `UserPicker.kt:290-318` | `lock_protectedActionsPrompt`, `profiles_actionsRequireAuthOnceWhenLocked` | `lock_protectedActionsPrompt`: "Open chat console" (reason "Log in using your credential") opens the console only after the passcode; "Open migration screen" with a wrong passcode leaves only "Unlock" (no "Migrate device"), "Unlock" asks again, "Cancel" leaves "Unlock" again, and Esc closes it back to the settings without the migration screen; "Stop chat" with a wrong passcode shows "Authentication failed" and the chat keeps running, with the passcode the chat stops. `profiles_actionsRequireAuthOnceWhenLocked`: opening "Your chat profiles" does not prompt; "Add profile" prompts "Change chat profiles" and opens the new profile screen only after the passcode; muting alice in the same screen does not prompt (stateGetOrPut "authorized"); after closing and reopening the screen, unmuting prompts again and acts only after the passcode | — | Desktop-only (`LockDesktopTest`). Lock enabled first through the UI. The "Unlock" button of `doWithAuth` is keyed `Ui.Lock.Unlock` |
+| Lock | Notice | chat list with >3 chats | `App.kt:94-104`, `AppLock.kt:34-56,112-131` | `lock_noticeOfferedWithManyChats` | With LANoticeShown cleared and at most 3 chats, a restart shows no alert and keeps LANoticeShown=false; with three more groups (`apiNewGroup`) a restart shows "SimpleX Lock" ("To protect your information, turn on SimpleX Lock.") with "Turn on" and stores LANoticeShown=true; "Turn on" → "New Passcode" → 1234 → "Confirm passcode" → 1234 → "SimpleX Lock turned on"; PerformLA=true and the passcode stored | RESTART | Desktop-only (`LockDesktopTest`): Android asks for the lock mode first (`AppLock.kt:44-46`). 04 owns this notice. The check runs once at first composition (`App.kt:95-103`), so the pre-set of `laNoticeShown` is cleared and the core restarted (harness fact 4) |
+| Lock | Keyboard entry | Settings > Your privacy > "SimpleX Lock" > "Enable lock" → "New Passcode" | `C/views/localauth/PasscodeView.kt:34-62` | `lock_passcodeKeyboardKeys` | Keys One, Two, Three show "●●●" (clicking it reveals "123"); Enter with 3 digits does nothing; NumPad4 adds "4"; Backspace removes it; Ctrl+Backspace clears; NumPad5, Six, NumPad7, Eight then Enter go to "Confirm passcode"; Five…Eight and NumPadEnter give "Passcode set!" and EncryptedAppPassphrase decodes to 5678 | — | Desktop-only (`LockDesktopTest`); keys go to the focused passcode view through `onRoot().performKeyInput` |
+| Lock | On-screen keypad | Settings > Your privacy > "SimpleX Lock" > "Enable lock" → "New Passcode": click 1 2 3 4 5, backspace, the dots, clear (x), then 1 2 3 4 → "Save" → "Confirm passcode": 1 2 3 4 → "Confirm" | `C/views/localauth/PasswordEntry.kt:22-48, 50-69, 101-145`; `C/views/localauth/PasscodeView.kt:64-84, 130-131` | `lock_passcodeKeypad_digitsBackspaceClearReveal` | Five clicks show "●●●●●"; backspace leaves "●●●●"; clicking the dots shows "1234" and clicking again masks it; clear (x) empties the field and "Save" does nothing, nor with 3 digits (fewer than 4, PasscodeView.kt:81); with 4 digits "Save" → "Confirm passcode" → "Passcode set!" and PerformLA=true | — | Desktop always uses the vertical keypad (PasscodeView.kt:130-131). The dots text is keyed `Ui.Passcode.Entered` (`PasswordEntry.kt:47`) |
+| Self-destruct | Enable | "Enable self-destruct" | `PrivacySettings.kt:577-594,770-785` |  | "Current Passcode" → "Set passcode" ("Enable self-destruct passcode") → "Confirm passcode" → "Self-destruct passcode enabled!"; Pref LocalAuthenticationSelfDestruct=true; with the app passcode typed as the new one, "Save" stays disabled (`SetAppPasscodeView.kt:54-55`, `PasscodeView.kt:81`) | — | `selfDestruct_enable` and `selfDestruct_cannotEqualAppPasscode` merged into `selfDestruct_triggeredOnLockScreen` |
+| Self-destruct | Info | the "Enable self-destruct" row (outside the switch) | `PrivacySettings.kt:711-726,757-771` |  | "Self-destruct" page with the intro and 3 items; self-destruct stays off | — | `selfDestruct_infoView` merged into `selfDestruct_changePasscode` |
+| Self-destruct | Display name | "New display name:" | `PrivacySettings.kt:725-738` |  | Pref LocalAuthenticationSelfDestructDisplayName | — | `selfDestruct_displayNamePersisted` merged into `selfDestruct_triggeredOnLockScreen` |
+| Self-destruct | Change | "Change self-destruct passcode" → "Current Passcode" (the app passcode) → new digits → "Save" → same digits → "Confirm" | `PrivacySettings.kt:624-649,744`; `C/views/localauth/SetAppPasscodeView.kt:13-61` | `selfDestruct_changePasscode` | The info row opens the "Self-destruct" page (intro and 3 items) without turning it on; self-destruct is enabled with 4321 (UI); the change asks for the app passcode, shows "New Passcode" naming "Self-destruct", and ends with "Self-destruct passcode changed!": EncryptedSelfDestructPassphrase decodes to 8765, the app passcode stays 1234; then the disable row's checks (below) run, and after a restart entering 8765 is a wrong passcode ("Authentication failed", alice's profile kept) and 1234 unlocks | RESTART | Desktop-only (`LockDesktopTest`). `selfDestruct_infoView` and `selfDestruct_disable` merged into `selfDestruct_changePasscode` |
+| Self-destruct | Trigger | enable, restart, enter the self-destruct code | `PrivacySettings.kt:577-594,725-738,770-785`, `LocalAuthView.kt:26-31,51-102` | `selfDestruct_triggeredOnLockScreen` | Enable: "Current Passcode" → "Set passcode" ("Enable self-destruct passcode"); the app passcode is refused ("Save" does nothing, still "Set passcode"); 4321 → "Confirm passcode" → "Self-destruct passcode enabled!", LocalAuthenticationSelfDestruct=true, EncryptedSelfDestructPassphrase decodes to 4321; "New display name:" `wiped` is stored. After `restart()` 4321 on the lock screen wipes the data: the app opens as `wiped`, the core lists only `wiped`, bob's chat is gone; EncryptedAppPassphrase decodes to 4321 and the self-destruct passcode, flag and name are cleared; after another `restart()` 4321 unlocks as the app passcode without a second wipe | RESTART, P (bob) | Desktop-only (`LockDesktopTest`). Lock enabled first. Not checked: that bob can no longer reach alice (his messages still reach the old server queue and nothing in his CLI changes) |
+| Self-destruct | Disable | toggle off → "Current Passcode" (the app passcode) | `PrivacySettings.kt:519-522,581-597` |  | A wrong passcode gives "Authentication failed" and keeps it on; the app passcode sets LocalAuthenticationSelfDestruct=false, unsets EncryptedSelfDestructPassphrase and InitializationVectorSelfDestructPassphrase (`DatabaseUtils.kt:36-40`; the Keystore delete does nothing on desktop, `Cryptor.desktop.kt:12-14`) and hides the name field and "Change self-destruct passcode" | — | `selfDestruct_disable` merged into `selfDestruct_changePasscode` |
 
-### D. Appearance (24 tests)
+### D. Appearance (18 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Appearance | Language | Settings > "Appearance" > "Language" (the string is "LANGUAGE", title-cased in code: strings.xml:1566, `US/Appearance.kt:1134`) | `D/views/usersettings/Appearance.desktop.kt:43-66`, `US/Appearance.kt:1101` | `appearance_language_switch`, `appearance_language_backToSystem` | Pref AppLanguage=de / null; after `poll` for the 200 ms delayed write, Settings is closed and the Picker reopened, and it shows the localized "Settings" (screens composed before the change keep their strings: the full recomposition is the Window key at `D/DesktopApp.kt:123-124`, which tests don't render) | — | `Locale.getDefault()` is JVM-wide ("system" restores `defaultLocale`, `D/platform/AppCommon.desktop.kt:19`); the next reset restores English (`PrefStores.restore()` calls `Locale.setDefault(Locale.ENGLISH)`, plan §7.3). The test's `finally` only keeps the rest of this test and its failure report in English |
-| Appearance | One-hand UI | "Reachable app toolbars" / "Reachable chat toolbar" | `Appearance.desktop.kt:64-67` | `appearance_reachableAppToolbars`, `appearance_reachableChatToolbarVisibility` | Pref OneHandUI / ChatBottomBar; the chat toolbar row is visible only when OneHandUI is on and ChatBottomBar is off | — | On desktop ChatBottomBar is true by default and no desktop UI sets it false (`SimpleXAPI.kt:276,8722`), so the test writes `appPrefs.chatBottomBar = false` directly, checks that the row appears with OneHandUI on, and that turning it on hides the row |
-| Themes | Color mode | "Color mode" (System/Light/Dark) | `Appearance.kt:566-579,1144` | `appearance_colorMode_systemLightDark` | Pref CurrentTheme; `CurrentColors.value.base`; Log `/_save app settings` | — | – |
-| Themes | Dark mode colors | "Dark mode colors" (Dark/SimpleX/Black) | `Appearance.kt:582-591,1165` | `appearance_darkModeColors` | Pref SystemDarkTheme | — | – |
-| Themes | Wallpaper preset | preset grid | `Appearance.kt:313-440,538` | `appearance_wallpaperPreset_select` | `themes.yaml` (harness fact 3) holds the preset wallpaper for the current base theme; Pref CurrentThemeIds is updated; Log `/_save app settings` | — | – |
-| Themes | Own image | "+" tile / "Remove image" | `Appearance.kt:495-505,547-564` | `appearance_wallpaperImage_import`, `appearance_wallpaperImage_remove` | File created/deleted in the wallpapers dir; WallpaperType.Image | FD | – |
-| Themes | Per-user theme | "Apply to" | `Appearance.kt:894-950,771-788` | `appearance_themeDestination_perUser` | "Apply to" > alice, then a wallpaper preset is chosen; Log `/_set theme user <userId> {…}` (apiSetUserUIThemes, `SimpleXAPI.kt:4278`); the user's `uiThemes` is set; `themes.yaml` is unchanged | — | – |
-| Customize | Colors | "Customize theme" > "Interface colors" > "Accent"…, "Reset colors" | `Appearance.kt:613-735,952-1099` | `customizeTheme_editInterfaceColor`, `customizeTheme_resetColors` | `themes.yaml` holds the edited accent for the current base theme (`SimpleXAPI.kt:388-391`); after "Reset colors" it no longer has it | DT (hex field) | The hex field is used instead of dragging the colour picker |
+| Appearance | Language | Settings > "Appearance" > "Language" (the string is "LANGUAGE", title-cased in code: strings.xml:1566, `US/Appearance.kt:1140`) | `D/views/usersettings/Appearance.desktop.kt:52-64`, `US/Appearance.kt:1108-1148` | `appearance_language_switch` | Choose "Deutsch": Pref AppLanguage=de and `Locale.getDefault()` is German after the 200 ms delayed write; with Appearance and Settings closed, the reopened Picker's settings row reads "Einstellungen" and the reopened Settings' Appearance row "Darstellung"; choosing "System" again clears AppLanguage, restores English, and the rows read "Settings" / "Appearance" (screens composed before the change keep their strings: the full recomposition is the Window key at `D/DesktopApp.kt:123-124`, which tests don't render) | — | Desktop (`AppearanceDesktopTest`). `appearance_language_backToSystem` merged into `appearance_language_switch`. `Locale.getDefault()` is JVM-wide ("system" restores `defaultLocale`, `D/platform/AppCommon.desktop.kt:19`); the next reset restores English (`PrefStores.restore()` calls `Locale.setDefault(Locale.ENGLISH)`, plan §7.3). Persistence across a restart is not testable: `restart()` does not run `applyAppLocale` (desktop `initApp`, `AppCommon.desktop.kt:46-50`) and `CommonPrefs.reload()` resets the locale to English |
+| Appearance | One-hand UI | "Reachable app toolbars" / "Reachable chat toolbar" | `Appearance.desktop.kt:66-69`, `Appearance.android.kt:109-114`, `C/views/chatlist/ChatListView.kt:267-268,575-595` | `appearance_reachableAppToolbars`, `appearance_reachableChatToolbarVisibility` | `appearance_reachableAppToolbars` (shared): with OneHandUI on (default) the chat list has the toolbar new-chat button and no floating one; turning "Reachable app toolbars" off stores OneHandUI=false and the chat list shows the floating button instead; turning it on again restores the toolbar button. `appearance_reachableChatToolbarVisibility` (not written): Pref ChatBottomBar; the chat toolbar row is visible only when OneHandUI is on and ChatBottomBar is off | — | On desktop ChatBottomBar is true by default and no desktop UI sets it false (`SimpleXAPI.kt:276,8722`), so `appearance_reachableChatToolbarVisibility` would write `appPrefs.chatBottomBar = false` directly, check that the row appears with OneHandUI on, and that turning it on hides the row |
+| Themes | Color mode | "Color mode" (System/Light/Dark) and "Dark mode colors" (Dark/SimpleX/Black) | `Appearance.kt:569-598,1150-1192` | `appearance_colorMode_systemLightDark` | Light: `CurrentColors.value.base` LIGHT, Pref CurrentTheme=LIGHT, the row reads "Light"; "Dark mode colors" = Black stores SystemDarkTheme=BLACK and keeps the light theme; Dark then applies BLACK (background = `BlackColorPalette.background`, CurrentTheme=BLACK, rows "Dark" / "Black"); SimpleX in dark mode applies at once (CurrentTheme=SIMPLEX); System stores SYSTEM and `CurrentColors.value.name` is SYSTEM | — | Shared. `appearance_darkModeColors` merged into `appearance_colorMode_systemLightDark`. Dark-mode persistence across a restart is `appearance_settingsPersistAcrossRestart`. The "Dark mode colors" label is checked only after a theme change (its state is keyed on `systemDarkTheme.get()`, re-read on recomposition) |
+| Themes | Dark mode colors | "Dark mode colors" (Dark/SimpleX/Black) | `Appearance.kt:588-598,1178-1192` |  | – | — | `appearance_darkModeColors` merged into `appearance_colorMode_systemLightDark` |
+| Themes | Wallpaper preset | preset grid | `Appearance.kt:316-448,470-533` | `appearance_wallpaperPreset_select` | In Light, the default wallpaper is "school"; tapping "flowers" applies it (`CurrentColors.value.wallpaper.type`) and `themes.yaml` (harness fact 3) holds it for the LIGHT theme selected by CurrentThemeIds; Dark shows its own default "school" and `themes.yaml` has no flowers for DARK; Light shows flowers again, and after a restart | RESTART | Shared. On Android the presets are a horizontal row; "flowers" is the third tile and needs no scrolling |
+| Themes | Own image | "+" tile / "Remove image" | `Appearance.kt:363-395,495-505,547-566` | `appearance_wallpaperImage_import` | Before: no image wallpaper and no "Remove image"; the "+" tile with a JPEG chosen in the file dialog makes the wallpaper `WallpaperType.Image`, copies the file byte-for-byte into the wallpapers folder and stores its name as the theme's `wallpaper.imageFile` in `themes.yaml`, and "Remove image" appears; "Remove image" removes the image wallpaper, deletes the copy and the stored image, and hides itself | FD | Shared. `appearance_wallpaperImage_remove` merged into `appearance_wallpaperImage_import`. The JPEG is made with the app's own encoder (`jpegFile`). The "+" tile and "Remove image" are keyed |
+| Themes | Per-user theme | "Apply to" | `Appearance.kt:470-483,531,776-792,899-950` | `appearance_themeDestination_perUser` | "Apply to" > alice (the row then reads "alice"), then the "flowers" preset: the current user's `uiThemes` holds it for the current mode, the core's user (`/users`, `listUsers`) has it after the 300 ms delayed `/_set theme user` (apiSetUserUIThemes, `SimpleXAPI.kt:4278`), and `themes.yaml` is byte-identical with no flowers theme | — | Shared |
+| Customize | Colors | "Customize theme" > "Interface colors" > "Accent", "Reset colors" | `Appearance.kt:618-700,958-1103` | `customizeTheme_editInterfaceColor` | Before: no "Reset colors"; typing `#ff0000` in the hex field makes `CurrentColors.value.colors.primary` red and `themes.yaml` hold accent `#ffff0000` for the current base theme (`SimpleXAPI.kt:388-391`); back in Customize theme "Reset colors" shows; after it, the default accent is applied, `themes.yaml` has no accent and "Reset colors" is gone | DT (hex field) | Shared. `customizeTheme_resetColors` merged into `customizeTheme_editInterfaceColor`. The hex field is used instead of dragging the colour picker; developer tools are switched on through the pref (precondition) |
 | Customize | Chat colors | "Chat colors": after choosing an image wallpaper, "Scale" (a dropdown, shown only for an image) = Fit, and hex values typed for "Wallpaper background", "Wallpaper accent", "Sent message", "Received message" | `Appearance.kt:1188-1276`, `ui/theme/Theme.kt:225-231` | `customizeTheme_wallpaperScaleAndChatColors` | `themes.yaml` holds, for the current base theme, `wallpaper.scaleType: fit` (`@SerialName("fit")`, ChatWallpaper.kt:267; written `scaleType: "fit"`), `wallpaper.background`/`tint` and the sent/received colours equal to the typed values (stored as `#ffrrggbb` in lower case, ThemeManager.kt:125) (`SimpleXAPI.kt:246, 388-391`) | FD (wallpaper image), DT | – |
-| Customize | Theme file | "Export theme" / "Import theme" | `Appearance.kt:700-732` | `customizeTheme_exportTheme`, `customizeTheme_importTheme`, `customizeTheme_importInvalidTheme` | Export: after the accent is set to `#FF0000`, the file written via saveDialog (proposed name "simplex.theme", `Appearance.kt:715`) is YAML with `base:` and `accent: "#ffff0000"` (export writes `toReadableHex()`, lower case with alpha, ThemeManager.kt:227-238, Theme.kt:204-212) and no `themeId` line (:710-714; `ui/theme/Theme.kt:184-185,304-308`); import: a file with `base: LIGHT` and `colors: {accent: "#00FF00"}` makes `themes.yaml` (harness fact 3) hold accent `#00FF00` for the light theme and logs `/_save app settings` (:718-725); invalid YAML shows "Import theme error" (`C/views/helpers/Utils.kt:157-171`) and `themes.yaml` stays byte-identical | FD | – |
+| Customize | Theme file | "Export theme" / "Import theme" | `Appearance.kt:705-738`, `C/views/helpers/Utils.kt:165-180` | `customizeTheme_exportImportTheme` | Export: with the accent set to red (precondition, `ThemeManager.saveAndApplyThemeColor`), the file written via saveDialog (proposed name "simplex.theme") is YAML whose `base` is the current base theme, `colors.accent` is `#ffff0000` (export writes `toReadableHex()`, lower case with alpha, ThemeManager.kt:227-238) and has no `themeId` line (:718-719); after "Reset colors", importing that file applies red again, stores it in `themes.yaml` and stores CurrentTheme = the base theme; importing invalid YAML shows "Import theme error" and `themes.yaml` stays byte-identical | FD | Shared (Android answers the CREATE_DOCUMENT / GET_CONTENT intents). `customizeTheme_exportTheme`, `customizeTheme_importTheme` and `customizeTheme_importInvalidTheme` merged into `customizeTheme_exportImportTheme` |
 | Tray | Close to tray | (section) | `Appearance.desktop.kt:72-75,97-110` | `appearance_closeToTray_hiddenWithoutTray` | "Close to tray" absent when `trayIsAvailable`=false (headless) | — | The real tray behaviour is an `IGNORE` row in §M |
 | Toolbars | App toolbars | "App toolbars" > "Transparency" / "Blur" | `Appearance.kt:94-178` | `appearance_toolbarTransparency`, `appearance_toolbarBlur` | Pref InAppBarsAlpha / AppearanceBarsBlurRadius | — | Blur shows only if `deviceSupportsBlur` or the pref is >0. Test baseline is blur off (`AppearanceBarsBlurRadius` = 0, plan 7.2/11.1, for performance), so `appearance_toolbarBlur` starts from 0 and sets a non-zero radius |
 | Shape | Message shape | "Message shape" > "Corner" slider, "Tail" | `Appearance.kt:181-208` | `appearance_messageShapeCornerAndTail` | Pref ChatItemRoundness / ChatItemTail | — | – |
@@ -114,46 +114,46 @@ User picker rows, profile switching, profile editing (including the invalid-name
 | Zoom | Zoom | "Zoom" | `Appearance.desktop.kt:112-153` | `appearance_zoom_sliderAndReset` | Pref DensityScale in 1.0..2.0 | — | – |
 | Persistence | Restart | restart after changing settings | – | `appearance_settingsPersistAcrossRestart` | Theme, font and zoom restored | RESTART | – |
 
-### E. Network & servers (43 tests)
+### E. Network & servers (33 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Root | Layout | Settings > "Network & servers" | `NS/NetworkAndServers.kt:158-317` | `network_rootLayout` | "Preset servers" (operator rows), "Messages and files": "Your servers", "Use SOCKS proxy", "SOCKS proxy settings", "Advanced network settings", "Save servers" (disabled), "Calls": "WebRTC ICE servers"; no connection-status section (Android-only) | — | – |
-| Operators | Toggle | operator row > "Use servers" | `NS/OperatorView.kt:47-168,547-600,878` | `operators_enableDisableOperator` | Turning "Use servers" on opens "Use SimpleX Chat" (`use_servers_of_operator_x`, "Use %s" with the operator name; conditions are not accepted in a fresh DB, `OperatorView.kt:571-583`); "Accept conditions" sends `/_accept_conditions <conditionsId> <operatorId>` and turns the switch on (`OperatorView.kt:614-623`). Unsaved indicator appears; "Save servers" sends `/_servers` and reads the servers back. Turning it off needs no conditions (`/_operators <json>` is used only by onboarding) (`H/Direct.hs` testOperators) | — | Toggling only; preset servers are unreachable in the namespace |
+| Root | Layout | Settings > "Network & servers" | `NS/NetworkAndServers.kt:161-320` | | "Preset servers" (operator rows), "Messages and files": "Your servers", "Use SOCKS proxy", "SOCKS proxy settings", "Advanced network settings", "Save servers", "Calls": "WebRTC ICE servers" | — | `network_rootLayout` merged into `operators_enableDisableOperator` (checked before the operator is opened); the Android-only connection-status section is not checked in the shared test |
+| Operators | Toggle | operator row > "Use servers" | `NS/OperatorView.kt:175-260,553-700`, `NS/NetworkAndServers.kt:683-720` | `operators_enableDisableOperator` | With SimpleX Chat off (harness) and its conditions `Required` with no deadline: the operator screen "SimpleX Chat servers" has no "Test servers" and no "Conditions accepted on:"; "Use servers" on opens "Use SimpleX Chat" with the conditions text (heading "SimpleX Chat Operators Privacy Policy and Conditions of Use") and "Accept conditions" (`OperatorView.kt:571-583`); accepting closes it, the switch is on, "Test servers" and "Conditions accepted on: …" show, and the core has the conditions accepted but the operator still off; the operator row on Network & servers shows the `edited` mark, "Save servers" clears it and the core (`/_operators`) has the operator on, Flux still off; "Use servers" off needs no conditions, and after "Save servers" the core has it off with the conditions still accepted | — | Toggling only; preset servers are unreachable in the namespace. Also covers `operators_infoView` and `network_rootLayout` |
 | Operators | Conditions | "Review conditions" / "Accepted conditions" | `NetworkAndServers.kt:188-228,726-830` | `operators_reviewAcceptConditions` | "Accept conditions" sends `/_accept_conditions <conditionsId> <operatorIds>` (`SimpleXAPI.kt:4228`); conditions text comes from core | RESTART | The harness disables both operators, so the button is hidden. The UI can't enable an operator without accepting its conditions (`OperatorView.kt:571-583`), after which reopening shows "Accepted conditions". So the console sends `/_servers <userId> <json>` with the SimpleX Chat operator `enabled: true`, then the core is restarted, because `chatModel.conditions` is reloaded only in `initChatController` (`C/platform/Core.kt:143`) or after "Save servers" (`conditionsAction` is also read once when the screen opens, `NS/NetworkAndServers.kt:169,219`). "Review conditions" then shows; after accepting, reopening shows "Accepted conditions". After the restart What's New with "View updated conditions" opens by itself (01 `whatsNewShowsViewUpdatedConditions`); the test closes it first |
 | Operators | Roles | "Use for messages", "To receive", "For private routing", "To resolve names", "Use for files", "To send" | `OperatorView.kt:246-460`, `NetworkAndServers.kt:950-993` | `operators_roleToggles_validation` | With the operator enabled first (conditions accepted in the "Use SimpleX Chat" sheet; role sections show only for an enabled operator, `OperatorView.kt:242`) and smp1's "To receive" set to "no" in its server view (`ProtocolServerView.kt:215`; otherwise smp1 keeps receiving by default, `src/Simplex/Chat/Operators.hs:190-193`): turning off the operator's "To receive" shows the footer "No servers to receive messages." and disables "Save servers" (`SimpleXAPI.kt:4922-4923`; `T/OperatorTests.hs`) | — | – |
-| Operators | Info | operator info | `OperatorView.kt:503` | `operators_infoView` | "Network operator" page | — | – |
-| Servers | Add SMP | "Your servers" > "Add server" > "Enter server manually" | `NS/ProtocolServersView.kt:32-300`, `NS/NewServerView.kt:15-154` | `yourServers_addSmpManually` | "New server" → address → "Test server" ✓ → back (adds it to "Your servers", `NS/NewServerView.kt:26-36`) → "Save servers" on Network & servers; Log `/_servers <uid> […]` (a JSON array of operator groups, `SimpleXAPI.kt:4224`); reopening shows it (testGetSetSMPServers) | SMP2 | Adds the second local SMP server |
+| Operators | Info | operator info | `OperatorView.kt:509` | | "Network operator" page with the operator's legal name | — | `operators_infoView` merged into `operators_enableDisableOperator` |
+| Servers | Add SMP | "Your servers" > "Add server" > "Enter server manually" | `NS/ProtocolServersView.kt:32-300`, `NS/NewServerView.kt:15-154` | `yourServers_addSmpManually` | "New server" → address → "Test server" ✓ → back (adds it to "Your servers", `NS/NewServerView.kt:26-36`) → "Save servers" on Network & servers; Log `/_servers <uid> […]` (a JSON array of operator groups, `SimpleXAPI.kt:4224`); reopening shows it (testGetSetSMPServers) | SMP2, SRVCTL | Adds the second local SMP server (`TestServers.start("smp2")`, host `127.0.0.1`). Shared `NetworkServersTest`: the address is first tested with smp2 stopped ("Server test failed!"), then again after `start("smp2")` (no alert); "Use for new connections" on, back, "Save servers"; the core has smp2 enabled with `tested = true`, and it is listed after reopening. Fails if "Test server" does not contact the typed server, or the result or the new server is not saved |
 | Servers | Add XFTP | same | same | `yourServers_addXftpManually` | Listed under "Media & file servers" (testGetSetXFTPServers) | XFTP2 | – |
-| Servers | Test all | "Test servers" | `ProtocolServersView.kt:237-260,382-410` | `yourServers_testServers_allPass` | Log `/_server test`; all local servers pass (testTestSMPServerConnection, testTestXFTPServer) | — | – |
-| Servers | Test all (failure) | "Test servers" | `ProtocolServersView.kt:237-260,349-380` | `yourServers_testServers_someFail` | Alert "Server test failed!" whose text starts "Some servers failed the test:" and names the failed server (testTestSMPServerConnection) | — | A server address on an unused port from the JVM's port block (plan §8.2) is added first |
-| Servers | Invalid | NewServerView | `NewServerView.kt:101-154` | `newServer_invalidAddress` | "Invalid server address!" | — | – |
+| Servers | Test all | "Test servers" | `ProtocolServersView.kt:239-262,352-410` | `yourServers_testServers_allPass` | "Your servers" lists the local SMP and XFTP servers (host text) under "Message servers" and "Media & file servers"; "Test servers" finishes ("Add server" clickable again) with no "Server test failed!" alert; the `edited` mark appears on "Your servers" and after "Save servers" the core has both servers with `tested = true` (testTestSMPServerConnection, testTestXFTPServer) | — | Both are untested in the core before; the test status icon has no description, so the persisted `tested` flag is the check |
+| Servers | Test all (failure) | "Add server" > "Enter server manually" > "Test server", then "Test servers" | `ProtocolServersView.kt:265-300,352-410`, `NewServerView.kt:36-52` | `yourServers_testServers_someFail` | "Test server" on the new server shows "Server test failed!" without the all-servers text; after "Use for new connections" on and back, the server is listed; "Test servers" shows "Server test failed!" whose text starts "Some servers failed the test:" and names `127.0.0.2:` but not the local server's host; after "Save servers" the core has the new server enabled with `tested = false` and the local one with `tested = true` (testTestSMPServerConnection) | — | The failing server is `smp://<local key hash>@127.0.0.2:1` (loopback, connection refused, a host different from the local server so no duplicate-host error; replaces the port-block address of plan §8.2, which the Android bridge cannot share). A new server starts with "Use for new connections" off (`UserServer.empty`) |
+| Servers | Invalid | NewServerView | `NewServerView.kt:101-154` | `newServer_invalidAddress` | "not a server address" entered, back: "Invalid server address!" / "Check server address and try again." (`NewServerView.kt:146-152`); the address is not listed, "Your servers" has no `edited` mark and the core servers are unchanged | — | The valid-address branch (server added) is in `yourServers_testServers_someFail` |
 | Servers | Preset host | NewServerView | `NewServerView.kt:130-140` | `newServer_presetHostAddedToOperator` | "Operator server" / "Server added to operator %s." | — | – |
-| Servers | Server view | tap server | `NS/ProtocolServerView.kt:35-293` | `serverView_toggleUseAndSave`, `serverView_deleteServer` | `serverView_toggleUseAndSave`: "Use for new connections" off (`ProtocolServerView.kt:258-265`), back, "Save servers": the Log's `/_servers <uid> […]` (a JSON array, pretty-printed: `json`, `SimpleXAPI.kt:4224,6546-6551`) has that server with `"enabled": false`, and reopening shows the toggle off; `serverView_deleteServer`: "Delete server" removes the row from "Your servers" (`OperatorView.kt:108-115`; `ProtocolServersView.kt:106,474-483`), and after "Save servers" the Log's `/_servers <uid> […]` has the server with `"deleted": true` (`UserServer`, `SimpleXAPI.kt:5001-5009`) | — | Both act on a second SMP server added by address (host `127.0.0.1`, not tested) and saved first: with smp1 the only enabled message server, turning it off or deleting it blocks "Save servers" (`noServersErrs`, `src/Simplex/Chat/Operators.hs:543-548`), and an unsaved server is dropped without `"deleted"` (`ProtocolServersView.kt:484-491`); the second server is unreachable and never contacted, so this is not `SMP2` |
+| Servers | Server view | tap server | `NS/ProtocolServerView.kt:37-293`, `OperatorView.kt:96-135` | `serverView_toggleUseAndSave`, `serverView_deleteServer` | `serverView_toggleUseAndSave`: "Use for new connections" off on the second server, back, "Save servers" (the `edited` mark clears): the core has it with `enabled = false` and smp1 on, still after `restart()`; then smp1 off too shows "No message servers." in "Your servers" and on Network & servers, and "Save servers" does nothing (no alert, the `edited` mark stays, the core keeps smp1 on; `noServersErrs`, `src/Simplex/Chat/Operators.hs:543-548`; the core would reject it with "Error saving servers"); smp1 on again clears the error, and the second server on again is saved enabled; `serverView_deleteServer`: "Delete server" closes the view and removes the row while smp1 stays listed (`ProtocolServersView.kt:472-490`), and after "Save servers" the core no longer lists the server | RESTART | Both act on a second SMP server `smp://<local key hash>@127.0.0.2:1` added through the API first (`addCustomSmpServerViaApi`): with smp1 the only enabled message server, turning it off or deleting it blocks "Save servers", and an unsaved server is dropped without `"deleted"`; the second server is never contacted, so this is not `SMP2`. Also covers `servers_validationErrorsBlockSave` |
 | Servers | Per-server roles | "Your servers" > tap smp1 > "Use for messages": "To receive" / "For private routing" / "To resolve names" | `NS/ProtocolServerView.kt:197-242` | `serverView_perServerRoles` | Shown for an enabled SMP server (`ProtocolServerView.kt:199`); options "default (yes)" / "yes" / "no" ("To resolve names": "default (no)") (`ProtocolServerView.kt:228-234`); after "Save servers" the Log `/_servers <userId> […]` (a JSON array) carries the server's roles and reopening shows them; "To receive" = "no" on smp1, the only enabled SMP server, shows the footer "No servers to receive messages." in "Your servers" (`ProtocolServersView.kt:116-120`) | — | – |
 | Servers | QR | "Your servers" > tap smp1 | `ProtocolServerView.kt:203-207` | `serverView_addToAnotherDeviceQr` | Section "Add to another device" with a QR image (contentDescription `image_descr_qr_code`, `QRCode.kt:83`; shown only for a valid address) | — | Display only |
-| Servers | Unsaved | back with changes | `NetworkAndServers.kt:61-80,899` | `network_unsavedServersAlert_save`, `network_unsavedServersAlert_exit` | "Save servers?" offers "Save" / "Exit without saving"; "Save": Log `/_servers <uid> […]` (`SimpleXAPI.kt:4224`) and reopening shows the change; "Exit without saving": no `/_servers <uid> […]` (only the plain `/_servers <uid>` read on reopening), and the change is gone | — | – |
-| Servers | Validation | remove all receive servers | `NetworkAndServers.kt:282-298` | `servers_validationErrorsBlockSave` | Deleting the only message server (smp1) in "Your servers" shows the footer "No message servers."; "Save servers" is disabled ("Errors in servers configuration." appears only for errors without their own text, e.g. two servers with the same host, `NetworkAndServers.kt:281-291`) | — | – |
+| Servers | Unsaved | back with changes | `NetworkAndServers.kt:64-82,909` | `network_unsavedServersAlert_save` | Back with no change closes Network & servers with no alert; with the second server's "Use for new connections" off, back shows "Save servers?" with "Save" / "Exit without saving"; "Exit without saving" closes it, the core keeps the server on and reopening shows no `edited` mark; "Save" closes it and the core has the server off | — | `network_unsavedServersAlert_exit` merged into `network_unsavedServersAlert_save`. The second server is added through the API first, as in `serverView_toggleUseAndSave` |
+| Servers | Validation | remove all receive servers | `NetworkAndServers.kt:286-302` | | "No message servers." footer; "Save servers" does nothing | — | `servers_validationErrorsBlockSave` merged into `serverView_toggleUseAndSave` (turning off the only enabled message server instead of deleting it) |
 | Relays | Add/test | "Add server" > "Chat relay" > "New chat relay" | `NS/ChatRelayView.kt:66-110,346-408` | `chatRelays_addAndTest` | Address + name → "Test relay" ✓ → added to the unsaved list on going back (`ChatRelayView.kt:92-104`), sent in `/_servers` after "Save servers" (`H/ChatRelays.hs` testGetSetChatRelays, testChatRelayTest) | RELAY | The relay's address is the link its headless process prints after "Chat relay address is created:" on first start (plan §8.1); the harness does not pre-register this relay in the GUI's servers |
 | Relays | Invalid input | same | `ChatRelayView.kt:38-60,80-90` | `chatRelays_invalidNameOrAddress` | "Invalid relay name!" / "Invalid relay address!" | — | Input validation only |
-| Relays | Test fails | same | `ChatRelayView.kt:295` | `chatRelays_testFails` | The relay's address is entered, then the relay deletes it (`RelayPeer.run("/da")`, plan §8.1); "Test relay" shows "Relay test failed!" (`H/ChatRelays.hs` testChatRelayTest, scenario 3, RTSGetLink) | RELAY, PEERCTL | A contact address is not a relay link, so "Test relay" stays disabled for it (`ChatRelayView.kt:58-64,302`) |
+| Relays | Test fails | same | `ChatRelayView.kt:295` | `chatRelays_testFails` | The relay's address is entered, then the relay deletes it (the relay types `/da`, catalogue 03 §0); "Test relay" shows "Relay test failed!" (`H/ChatRelays.hs` testChatRelayTest, scenario 3, RTSGetLink) | RELAY | A contact address is not a relay link, so "Test relay" stays disabled for it (`ChatRelayView.kt:58-64,302`) |
 | Relays | Relay view | tap relay | `ChatRelayView.kt:111-320` | `chatRelays_toggleUseAndDelete` | On the custom relay in "Your servers": the "Use for new channels" switch (the only one, under the "Use relay" section header, `ChatRelayView.kt:286,311-317`) off, back: the relay row shows the do-not-disturb icon and its name in the secondary colour (`ChatRelayView.kt:331,337-341`); "Save servers": the Log's `/_servers <uid> […]` has the relay with `"enabled": false`; reopen the relay → "Delete relay": the view closes with no alert and the relay row is gone (`OperatorView.kt:150-153`; deleted relays are skipped, `ProtocolServersView.kt:93`) | RELAY | – |
-| SOCKS | Toggle | "Use SOCKS proxy" | `NetworkAndServers.kt:97-153,336` | `socks_enable_confirm`, `socks_disable_confirm` | "Use SOCKS proxy?" / "Use direct Internet connection?" → "Confirm"; Log `/_network {…}` with `"socksProxy"` on enable and without it on disable (`explicitNulls = false`, `SimpleXAPI.kt:6550`; JSON arguments are pretty-printed over several lines, :6547); timeouts still at the direct defaults switch to the proxy defaults on enable, and back on disable | — | – |
-| SOCKS | Validation | "SOCKS proxy settings" > "Host"/"Port" | `NetworkAndServers.kt:365-458,654-664` | `socks_settings_validation` | Save disabled for an invalid host or port | — | – |
+| SOCKS | Toggle | "Use SOCKS proxy" | `NetworkAndServers.kt:100-153,361-365` | `socks_enable_confirm` | With a changed per-KB timeout (precondition): "Use SOCKS proxy?" → "Confirm" stores NetworkUseSocksProxy=true and the core gets a `socksProxy` with the proxy defaults for the connect/TCP timeouts and receive concurrency while the changed per-KB timeout is kept; "Use direct Internet connection?" → "Confirm" removes `socksProxy`, restores the direct defaults and keeps the per-KB timeout | — | `socks_disable_confirm` merged into `socks_enable_confirm` |
+| SOCKS | Validation | "SOCKS proxy settings" > "Host"/"Port" | `NetworkAndServers.kt:441-452,663-670` |  | Save does nothing for port `70000` or host `bad@host`; leaving with invalid fields closes without an alert and keeps nothing | — | `socks_settings_validation` merged into `socks_unsavedAlert` |
 | SOCKS | Auth | "Proxy authentication" > "Use random credentials", "Username", "Password" | `NetworkAndServers.kt:503-530,557` | `socks_settings_authModes` | Footer text per mode; Pref NetworkProxyHostPort JSON | — | – |
-| SOCKS | Onion | "Use .onion hosts": No / When available / Required | `NetworkAndServers.kt:574-612` | `socks_onionHostsOptions` | Enabled only with SOCKS on and random credentials; Pref NetworkHostMode / NetworkRequiredHostMode | — | Option persistence only; real Tor is an `IGNORE` row in §M |
-| SOCKS | Save/reset | "Save and reconnect" (+ "Update network settings?") / "Reset to defaults" | `NetworkAndServers.kt:534-551` | `socks_saveAndReconnect`, `socks_resetToDefaults` | Log `/_network`; fields reset to localhost:9050 | — | "Use SOCKS proxy" is enabled first; with it off the button is "Save" and only the pref is written, with no `/_network` (`NetworkAndServers.kt:428-430,546-549`) |
-| SOCKS | Core reject | same | `NetworkAndServers.kt:430-441,666` | `socks_wrongConfigAlert` | "Error saving proxy" / "Make sure proxy configuration is correct." (`showWrongProxyConfigAlert`, `NetworkAndServers.kt:666-671`); prefs rolled back (`:437-439`) | — | "Use SOCKS proxy" is enabled first (the core is called only then, `NetworkAndServers.kt:428`); the test enters the host `proxy.example`, which passes `validHost` (only `@` is rejected, `:654-655`), but the core accepts only IPv4/IPv6 SOCKS hosts ("SOCKS5 host should be IPv4 or IPv6 address", simplexmq `ee66dd68` `Transport/Client.hs:263`), so `apiSetNetworkConfig` fails |
-| SOCKS | Unsaved | back | `NetworkAndServers.kt:459-470,563` | `socks_unsavedAlert` | "Update network settings?" with "Save" while "Use SOCKS proxy" is off ("Save and reconnect" while it is on, `NetworkAndServers.kt:465`) / "Exit without saving"; with the proxy off, after a host or port edit: "Save" writes Pref NetworkProxyHostPort with the new host and port, sends no `/_network`, and "SOCKS proxy settings" stays open with "Save" disabled (it closes only after a successful `/_network`, `:428-434`); "Exit without saving" closes it and the pref keeps its old value | — | – |
+| SOCKS | Onion | "Use .onion hosts": No / When available / Required | `NetworkAndServers.kt:370-560,578-621` | `socks_onionHostsOptions` | With SOCKS off the dropdown shows "No" and does not open (`NetworkAndServers.kt:607-617`); "Use SOCKS proxy" > "Confirm" stores NetworkUseSocksProxy=true and the core has a `socksProxy`; then it shows "When available", "Required" shows its footer, "Save and reconnect" > "Update" stores NetworkHostMode=OnionViaSocks and NetworkRequiredHostMode=true and the core (`/network`) has `hostMode` onionViaSocks with `requiredHostMode`; after `restart()` the core still has both and the dropdown shows "Required" | RESTART | Option persistence only; real Tor is an `IGNORE` row in §M. The proxy at localhost:9050 is never contacted (no connections) |
+| SOCKS | Save/reset | "Save and reconnect" (+ "Update network settings?") / "Reset to defaults" | `NetworkAndServers.kt:534-551` |  | `127.0.0.1:9150` saved with "Use SOCKS proxy" on is stored and applied to the core and the screen stays open; "Reset to defaults" puts localhost/9050 in the fields without saving; saving then applies the default proxy | — | `socks_saveAndReconnect` and `socks_resetToDefaults` merged into `socks_wrongConfigAlert` |
+| SOCKS | Core reject | same | `NetworkAndServers.kt:428-441,675-680` | `socks_wrongConfigAlert` | With "Use SOCKS proxy" on (UI): host `proxy.example` → "Save and reconnect" → "Update" gives "Error saving proxy" / "Make sure proxy configuration is correct."; the pref is rolled back to the default proxy, the core keeps its proxy and the screen stays open; then the save/reset row's checks (above) | — | The core accepts only IPv4/IPv6 SOCKS hosts ("SOCKS5 host should be IPv4 or IPv6 address", simplexmq `Transport/Client.hs`), so `apiSetNetworkConfig` fails |
+| SOCKS | Unsaved | back | `NetworkAndServers.kt:459-470,563` | `socks_unsavedAlert` | With the proxy off: the validation row's checks (above); after a port edit, back → "Update network settings?" with "Save" / "Exit without saving"; "Exit without saving" closes it, stores nothing and the reopened screen shows 9050; "Save" stores the port in NetworkProxyHostPort, the screen stays open with the new port, the core gets no `socksProxy` and leaving asks nothing | — | – |
 | SOCKS | Real proxy | enable + send | – | `socks_trafficRoutedThroughProxy` | The SOCKS stub (on a non-9050 loopback port) sees the CONNECT to the local SMP server; bob receives the message | P (bob), SOCKS | The stub must support RFC 1929 username/password auth (default mode isolates by credentials) and domain-name addressing |
-| Advanced | Private routing | "Advanced network settings" > "Private routing" / "Allow downgrade" | `NS/AdvancedNetworkSettings.kt:233-238,350-417` | `advNet_privateRoutingMode`, `advNet_privateRoutingFallback` | Options Always / Unknown servers / Unprotected / Never and Yes / When IP hidden / No; `advNet_privateRoutingMode`: "Never", then "Save and reconnect" opens "Update network settings?" (`AdvancedNetworkSettings.kt:190-193,556-563`), and its "Update" logs `/_network` with `"smpProxyMode": "never"` (default `"always"`; `encodeDefaults = true` puts the key in every `/_network`, `SimpleXAPI.kt:5356-5364,6546-6551`), Pref NetworkSMPProxyMode=Never, and "Allow downgrade" is disabled (`AdvancedNetworkSettings.kt:235`); `advNet_privateRoutingFallback`: "No", then "Save and reconnect" → "Update" logs `"smpProxyFallback": "prohibit"` (default `"allowProtected"`, `SimpleXAPI.kt:5368-5375`), Pref NetworkSMPProxyFallback=Prohibit (enum name, :364-366, 3881-3882) | — | – |
+| Advanced | Private routing | "Advanced network settings" > "Private routing" / "Allow downgrade" | `NS/AdvancedNetworkSettings.kt:236-238,353-421` | `advNet_privateRoutingMode` | Rows show "Always" / "When IP hidden" first; "Never" (`SectionViewSelectableCards`) makes "Allow downgrade" not open (`AdvancedNetworkSettings.kt:238`); "Unknown servers" and "No", then "Save and reconnect" > "Update" (`AdvancedNetworkSettings.kt:566-573`) store NetworkSMPProxyMode=Unknown, NetworkSMPProxyFallback=Prohibit and the core (`/network`) has `smpProxyMode` unknown and `smpProxyFallback` prohibit; after `restart()` the core and the rows keep them | RESTART | `advNet_privateRoutingFallback` merged into `advNet_privateRoutingMode` |
 | Advanced | Message status | "Show message status" | `AdvancedNetworkSettings.kt:236` | `advNet_showMessageStatus_sentViaProxy` | Pref showSentViaProxy (applies at once); with the setting on, a message to bob (whose queue is on the second SMP server, so it goes via private routing) shows the proxy icon (`ItemMetaKey` `sentViaProxy`); with it off, no icon | P (bob on the second SMP server), SMP2 | 04 owns this setting and the proxy icon. bob uses `cli(…, servers = PeerServers(smp = "smp2"))` (plan §9.2) |
-| Advanced | Isolation | "Transport isolation" | `AdvancedNetworkSettings.kt:241-243`, `NetworkAndServers.kt:615-652` | `advNet_transportIsolation` | Options "Chat profile" / "App session" / "Server" (`TransportSessionMode.safeValues`, `SimpleXAPI.kt:5404`); Pref NetworkSessionMode; `/_network` sessionMode | — | "Connection" appears only with developer tools (§I) |
+| Advanced | Isolation | "Transport isolation" | `AdvancedNetworkSettings.kt:244-246`, `NetworkAndServers.kt:624-662` | `advNet_transportIsolation` | The row shows "Chat profile"; its options are "Chat profile" / "App session" / "Server" without "Connection"; "Server" + "Save and reconnect" stores NetworkSessionMode=Server and sets the core `sessionMode`; with developer tools turned on (UI) the reopened options add "Connection" (`TransportSessionMode.Entity`), which saves as Entity | — | `dev_devToolsExtraSessionModes` merged into `advNet_transportIsolation`. The row and its options are keyed |
 | Advanced | Web port | "TCP port for messaging" > "Use web port" | `AdvancedNetworkSettings.kt:245-255` | `advNet_webPort` | Footer text; Pref NetworkSMPWebPortServers | — | – |
-| Advanced | Timeouts | "TCP connection timeout", "TCP connection bg timeout", "Protocol timeout", "Protocol background timeout", "Protocol timeout per KB", "PING interval", "PING count" | `AdvancedNetworkSettings.kt:258-307` | `advNet_timeoutsSaved` | Matching Network* prefs (e.g. `networkTCPTimeoutPerKb`, `SimpleXAPI.kt:463`, for "Protocol timeout per KB"); `/_network` JSON | — | One test iterating over the 7 fields |
-| Advanced | Keep-alive | "Enable TCP keep-alive" | `AdvancedNetworkSettings.kt:308-331,419` | `advNet_keepAlive` | TCP_KEEPIDLE / INTVL / CNT enabled or disabled; prefs | — | – |
-| Advanced | Reset/unsaved | "Reset to defaults" / back | `AdvancedNetworkSettings.kt:144,337-344,565` | `advNet_resetToDefaults`, `advNet_unsavedChangesAlert` | `advNet_resetToDefaults`: after a value is changed, "Reset to defaults" puts every field back to the defaults (`NetCfg.defaults`, or `NetCfg.proxyDefaults` with SOCKS on) and is then disabled; nothing is applied until "Save and reconnect" (`AdvancedNetworkSettings.kt:144-148,187,337-340`); `advNet_unsavedChangesAlert`: leaving with changes shows "Update network settings?" with "Save and reconnect" / "Exit without saving" | — | – |
-| Advanced | Persist | restart | `C/model/SimpleXAPI.kt:666` | `advNet_persistAcrossRestart` | `/_network` re-sent on start with the saved values | RESTART | – |
+| Advanced | Timeouts | "TCP connection timeout", "TCP connection bg timeout", "Protocol timeout", "Protocol background timeout", "Protocol timeout per KB", "PING interval", "PING count" | `AdvancedNetworkSettings.kt:261-311,442-562`, `C/model/SimpleXAPI.kt:696-699,3866-3940` | `advNet_timeoutsSaved` | Each of the 7 dropdowns shows its default (15 / 45 / 10 / 30 / 0.01 / 1200 sec, 3) and then the new value (20 / 60 / 15 / 45 / 0.02 / 600 sec, 5); "Save and reconnect" > "Update" stores the matching Network* prefs (e.g. `networkTCPTimeoutPerKb`) and the core (`/network`) has the values; after `restart()` the core has them again (re-sent by `startChat`) and the dropdowns show them | RESTART | One test iterating over the 7 fields. Also covers `advNet_persistAcrossRestart` |
+| Advanced | Keep-alive | "Enable TCP keep-alive" | `AdvancedNetworkSettings.kt:312-334,424-438` | `advNet_keepAlive` | Off: the TCP_KEEPIDLE / INTVL / CNT dropdowns become plain rows; "Save and reconnect" > "Update" stores NetworkEnableKeepAlive=false and after `restart()` they are still plain rows; on again with TCP_KEEPIDLE 60 and TCP_KEEPCNT 8, saved: prefs NetworkEnableKeepAlive=true, NetworkTCPKeepIdle=60, NetworkTCPKeepCnt=8 and the core `tcpKeepAlive` {60, 15, 8} | RESTART | The core's `tcpKeepAlive: null` decodes to the defaults (`NetCfg`, `SimpleXAPI.kt:5312`), so the off state is checked through the prefs and the screen after the restart |
+| Advanced | Reset/unsaved | "Reset to defaults" / back | `AdvancedNetworkSettings.kt:147-171,341-346,575-583` | `advNet_resetToDefaults`, `advNet_unsavedChangesAlert` | `advNet_resetToDefaults`: with 0.02 sec per KB and PING count 5 saved first (`saveNetworkConfigViaApi`), "Reset to defaults" shows 0.01 sec / 3 / 15 sec while the prefs and the core keep 20000 / 5; "Save and reconnect" > "Update" stores and applies 10000 / 3; `advNet_unsavedChangesAlert`: back with no change closes with no alert; with PING count 5, back shows "Update network settings?" with "Save and reconnect" / "Exit without saving"; "Exit without saving" closes it, the pref and the core keep 3 and reopening shows 3; with 8, "Save and reconnect" closes it and stores and applies 8 | — | – |
+| Advanced | Persist | restart | `C/model/SimpleXAPI.kt:696-699` | | `/_network` re-sent on start with the saved values | RESTART | `advNet_persistAcrossRestart` merged into `advNet_timeoutsSaved` |
 | Remote | Hidden when remote | with a remote host connected | `NetworkAndServers.kt:262-269`, `AdvancedNetworkSettings.kt:232` | `network_remoteHostHidesLocalSettings` | SOCKS and advanced sections hidden | P (mobile host) | Pairing as in §K |
 
 ### F. Audio & video calls (6 tests)
@@ -165,39 +165,39 @@ User picker rows, profile switching, profile editing (including the invalid-name
 | ICE | Edit | "WebRTC ICE servers" > "Configure ICE servers" switch on > type one server per line > "Save"; "Edit" reopens the editor | `US/RTCServers.kt:29-209` | `iceServers_saveCustom`, `iceServers_invalidRejected`, `iceServers_resetToDefaults` | Pref WebrtcICEServers; an invalid or duplicate line gives "Error saving ICE servers"; switching "Configure ICE servers" off gives "Use SimpleX Chat servers?" → "Confirm" and sets the pref to null | — | – |
 | ICE | 2nd entry | Settings > Network & servers > "WebRTC ICE servers" | `NetworkAndServers.kt:302-304` | `iceServers_openFromNetworkScreen` | The ICE screen opens: "Your ICE servers" with the switch "Configure ICE servers" (`US/RTCServers.kt:103,111`), absent on Network & servers, whose entry row has the same label "WebRTC ICE servers" | — | – |
 
-### G. Chat data, database, encryption, startup DB errors (35 tests, 3 ignored)
+### G. Chat data, database, encryption, startup DB errors (19 tests, 2 ignored)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Chat data | Layout | Settings > "Chat data" | `C/views/database/DatabaseView.kt:107-179` | `chatData_layout` | "Messages" > "Delete messages after", "Database passphrase & export", "Files & media" | — | – |
-| TTL | Change | "Delete messages after" | `DatabaseView.kt:73-84,330-375,810-850` | `chatData_ttlIncrease_noAlert`, `chatData_ttlDecrease_alertConfirm`, `chatData_ttlDecrease_alertCancel` | `chatData_ttlIncrease_noAlert`: a longer period is applied with no alert (the alert shows only when the period gets shorter, `DatabaseView.kt:79`) and Log `/_ttl <uid> <secs>`; decrease: "Enable automatic message deletion?" → "Delete messages"; Log `/_ttl <uid> <secs>`; cancel reverts (testSetChatItemTTL) | — | Setting or lowering the TTL expires older items at once (plan §11.1, TTL expiry) |
+| Chat data | Layout | Settings > "Chat data" | `C/views/database/DatabaseView.kt:107-179` |  | "Messages" > "Delete messages after", "Database passphrase & export", "Files & media" | — | Merged into `chatData_ttlDecrease_alertConfirm` (the footer naming the current profile); every item is acted on by a test of this section |
+| TTL | Change | "Delete messages after" | `DatabaseView.kt:73-84,330-375,810-850` | `chatData_ttlDecrease_alertConfirm` | bob sends an old (backdated) and a recent message; the footer names alice; "1 day": "Enable automatic message deletion?" → "Cancel" leaves "never" in the picker and the core; again → "Delete messages": 1 day in the picker and the core, the old message is deleted at once (bob's row preview and chat show only the recent one); "1 week" (longer) applies with no alert (the alert shows only when the period gets shorter, `DatabaseView.kt:79`) (testSetChatItemTTL) | P | Includes the former `chatData_ttlIncrease_noAlert`, `chatData_ttlDecrease_alertCancel` and `chatData_layout`. The old message is backdated with `/sql chat UPDATE chat_items SET created_at = …` (contact items expire by `created_at`, `Store/Messages.hs:3621`); setting or lowering the TTL expires older items at once (`Library/Commands.hs:1894-1903`) |
 | TTL | Custom | console `/_ttl <uid> 30`, then restart | `DatabaseView.kt:353-359` | `chatData_ttlCustomSecondsShown` | Extra seconds option listed | RESTART | The picker's value is reloaded only on profile switch or start (`SimpleXAPI.kt:770`), so the console change needs a restart |
-| TTL | Per profile | switch user | `DatabaseView.kt:49,131-139` | `chatData_ttlPerProfile` | Footer names the user; value per user (testUsersDifferentCIExpirationTTL) | — | A second user profile is created first |
+| TTL | Per profile | switch user | `DatabaseView.kt:52,131-139,161-163` | `chatData_ttlPerProfile` | alice sets 1 week (with the deletion alert); a new profile `work` shows its own footer, "never" and "Delete files for all chat profiles" (alice alone saw "Delete all files"); work's 1 day is stored for work only (`/_ttl <userId>` per user in the core) and switching back shows alice's footer and 1 week | — | `chatData_deleteFilesLabelForMultipleProfiles` merged into `chatData_ttlPerProfile`. The second profile is created through the UI (testUsersDifferentCIExpirationTTL) |
 | TTL | Expiry | seconds TTL | – | `chatData_ttlExpiresMessages` | After the expiration thread's first run, reopening bob's chat no longer shows the backdated items: the test reopens it until they are gone, with a deadline (background expiration deletes rows without a UI event, `Library/Commands.hs:5781-5792, 5965-5998`, so items already on screen and the chat-list preview stay until reloaded) | P (bob), FIXTURE (backdated items), RESTART, SLOW | Expiry on startup (plan §11.1, TTL expiry): the TTL is set while the items are still new, the core is stopped, bob's items are backdated (`item_ts` and `created_at` by more than the TTL), the core restarted, and the test waits for the expiration thread's first run 30 s after start |
-| Files | Delete | "Delete all files" | `DatabaseView.kt:157-176,854-870` | `chatData_deleteFilesAndMedia` | "%d file(s) with total size of %s" → "Delete files and media?" → "Delete"; `/_stop`, files removed, `/_start main=on` (`SimpleXAPI.kt:4140`); "No received or sent files" | P (bob), XFTP | – |
-| Files | Label | with 2 users | `DatabaseView.kt:164` | `chatData_deleteFilesLabelForMultipleProfiles` | "Delete files for all chat profiles" | — | A second user profile is created first |
-| DB mgmt | Layout | "Database passphrase & export" | `DatabaseView.kt:181-328` | `dbMgmt_layout` | "Chat database": "Database passphrase", "Open database folder", "Export database", "Import database", "Delete database"; "Run chat" | — | – |
-| DB mgmt | Run chat | "Chat is running" toggle | `DatabaseView.kt:378-512` | `dbMgmt_stopChat`, `dbMgmt_startChat` | "Stop chat?" → "Stop"; Log `/_stop` / `/_start main=on` (`SimpleXAPI.kt:4140`); Pref ChatStopped (testStopStartChat) | — | – |
-| DB mgmt | Stopped restart | restart while stopped | `Core.kt:59-66` | `dbMgmt_stoppedStatePersistsRestart` | Start-chat-after-restart alert | RESTART | – |
-| DB mgmt | Export blocked | "Export database" on a fresh DB | `DatabaseView.kt:251-255,455` | `dbMgmt_exportProhibitedWithRandomPassphrase` | "Set passphrase to export" and the "Database passphrase" screen (`DatabaseEncryptionView`, DatabaseView.kt:251-255; `DatabaseEncryptionView.kt:120`) | — | Desktop default (harness fact 8) |
-| DB mgmt | Export | same, after a passphrase is set | `DatabaseView.kt:606-660` | `dbMgmt_exportArchive` | Log `/_db export {…}`; zip at the saveDialog path; Pref ChatArchiveName/Time; the chat stays stopped afterwards ("Chat is stopped" toggle off; `exportArchive` returns false, `DatabaseView.kt:630`) (testMaintenanceMode, …WithFiles) | FD | – |
-| DB mgmt | Import | "Import database" | `DatabaseView.kt:202-210,675-756` | `dbMgmt_importArchive_restoresData` | The export leaves the chat stopped (`exportArchive` returns false, `DatabaseView.kt:630`), so after it alice turns the "Chat is stopped" switch on (it then reads "Chat is running", `DatabaseView.kt:384-394`) before bob sends a message, which she receives; then "Import chat database?" → "Import"; `/_db import`; "Chat database imported"; then "Encrypted database" / "Enter passphrase…" (the import removes the stored key, `DatabaseView.kt:724`) → type the exported database's passphrase → "Save passphrase and open chat"; a message from bob received after the export is gone | FD, P (bob) | – |
-| DB mgmt | Import (invalid) | "Import database" | `DatabaseView.kt:202-210,675-756` | `dbMgmt_importInvalidArchive` | "Error importing chat database" for a bad zip | IGNORE: known app bug: the import error alert is never shown (plan §11.3) | `apiImportArchive` throws `Exception` (`SimpleXAPI.kt:1128`) but `importArchive` catches only `Error` (`DatabaseView.kt:740,745`), so the alert never shows and the chat restarts on storage `/_db delete` already removed (`DatabaseView.kt:718`). Confirm in the real app and report it when the test is written |
-| DB mgmt | Settings import | same | `DatabaseView.kt:723`, `Core.kt:144-152` | `dbMgmt_importRestoresAppSettings` | The archive is exported with Pref PrivacyLinkPreviews=false ("Send link previews" off; the export saves the app settings into the database first, `DatabaseView.kt:645`), then the pref is set back to true; after the import and the passphrase prompt ("Save passphrase and open chat"), `initChatController` applies the archive's settings (`DatabaseView.kt:723`, `Core.kt:144-152`), so PrivacyLinkPreviews is false again and ShouldImportAppSettings is false (testAppSettings) | FD | – |
-| DB mgmt | Delete | "Delete database" | `DatabaseView.kt:783-808` | `dbMgmt_deleteDatabase` | "Delete chat profile?" → "Delete"; "Chat database deleted"; the onboarding welcome screen with "Link a mobile" and "Create your profile" appears without a restart (`Core.kt:153-166`) | — | – |
+| Files | Delete | "Delete all files" | `DatabaseView.kt:157-176,854-870` | `chatData_deleteFilesAndMedia` | "1 file(s) with total size of %s" → "Delete files and media?" → "Delete"; `/_stop`, files removed, `/_start main=on` (`SimpleXAPI.kt:4140`); "No received or sent files", the files folder empty, the chat running again (core `/_check running`); the image and text messages stay and alice's reply reaches bob | P (bob), XFTP | – |
+| Files | Label | with 2 users | `DatabaseView.kt:161-163` |  | "Delete files for all chat profiles" | — | `chatData_deleteFilesLabelForMultipleProfiles` merged into `chatData_ttlPerProfile` |
+| DB mgmt | Layout | "Database passphrase & export" | `DatabaseView.kt:181-328` |  | "Chat database": "Database passphrase", "Open database folder", "Export database", "Import database", "Delete database"; "Run chat" | — | Merged into `dbMgmt_importArchive_restoresData` and the other DB mgmt tests, which act on every item; "Open database folder" is `dbMgmt_openDatabaseFolder` (IGNORE) |
+| DB mgmt | Run chat | "Chat is running" toggle | `DatabaseView.kt:378-512` | `dbMgmt_stopAndStartChat` | Switch off: "Stop chat?" → "Cancel" keeps "Chat is running"; → "Stop": "Chat is stopped" and the footer "You must use the most recent version of your chat database on one device ONLY…", Pref ChatStopped=true, core `/_check running` stopped; switch on: "Chat is running", ChatStopped=false; the message bob sent while stopped arrives and alice's reply reaches bob (testStopStartChat) | P | Replaces `dbMgmt_stopChat` and `dbMgmt_startChat` (the start is the second half of the same scenario) |
+| DB mgmt | Stopped restart | restart while stopped | `Core.kt:59-66,226-236` | `dbMgmt_stoppedStatePersistsRestart` | Restart while stopped: "Start chat?" / "Chat is stopped. If you already used this database on another device, you should transfer it back before starting chat." → "Cancel" keeps it stopped (core, Pref ChatStopped=true, the "Chat is stopped" icon on the settings "Chat data" row); after the next restart "OK" starts it, bob's message sent while stopped arrives and alice's message reaches bob | P, RESTART | Desktop-only (`ChatDataDesktopTest`): on Android the harness relaunches the activity while start-up awaits the alert (plan §15.4 item 10 risk) |
+| DB mgmt | Export blocked | "Export database" on a fresh DB | `DatabaseView.kt:251-255,455` |  | "Set passphrase to export" and the "Database passphrase" screen (`DatabaseEncryptionView`, DatabaseView.kt:251-255; `DatabaseEncryptionView.kt:123`) | — | Merged into `dbMgmt_importArchive_restoresData` |
+| DB mgmt | Export | same, after a passphrase is set | `DatabaseView.kt:606-660` |  | Log `/_db export {…}`; zip at the saveDialog path; Pref ChatArchiveName/Time; the chat stays stopped afterwards ("Chat is stopped" toggle off; `exportArchive` returns false, `DatabaseView.kt:630`) (testMaintenanceMode, …WithFiles) | FD | Merged into `dbMgmt_importArchive_restoresData` (the zip holds both databases; Pref ChatArchiveName/Time is not asserted) |
+| DB mgmt | Import | "Import database" | `DatabaseView.kt:202-210,675-756` | `dbMgmt_importArchive_restoresData` | "Export database" first shows "Set passphrase to export" and the passphrase screen, where alice sets one; then the export writes a zip with `simplex_v1_chat.db` and `simplex_v1_agent.db` to the saveDialog path and leaves the chat stopped (`exportArchive` returns false, `DatabaseView.kt:630`); she turns the switch on ("Chat is running") and writes a private note; "Import database" → "Import chat database?" → "Import"; `/_db import`; "Chat database imported"; "Encrypted database" / "Save passphrase and open chat" (the import removes the stored key, `DatabaseView.kt:724`) → the exported database's passphrase; "Start chat?" (the import's stop left Pref ChatStopped=true, `DatabaseView.kt:512`, so `runChat` asks, `DatabaseErrorView.kt:226-228`) → "OK"; bob's message and the note from before the export are there, the note written after the export is gone, Pref PrivacyLinkPreviews is the archive's false again with ShouldImportAppSettings=false, and alice's message reaches bob (testMaintenanceMode, testAppSettings) | FD, P | Includes `dbMgmt_exportProhibitedWithRandomPassphrase`, `dbMgmt_exportArchive`, `dbMgmt_importRestoresAppSettings` and the import path of `dbError_saveAndOpen`. The change after the export is a local note, not a message from bob: alice's delivery receipt for it would move her ratchet past the archived state, so messaging bob after the import would break (the "most recent version… on one device ONLY" rule) |
+| DB mgmt | Import (invalid) | "Import database" | `DatabaseView.kt:202-210,675-756` | `dbMgmt_importInvalidArchive` | "Error importing chat database" for a file that is not a zip, and alice's data is still there (the core lists alice; her note is on the Private notes row) | FD | `@KnownAppIssue` (plan §15.5 item ?), by code reading: `importArchive` deletes the storage first (`/_db delete`, `DatabaseView.kt:718`; the core also removes the `.bak` files, `Archive.hs:122-135`), then `apiImportArchive` throws `Exception` (`SimpleXAPI.kt:1160-1164`, throw at :1163) but only `Error` is caught (`DatabaseView.kt:740,745`); `stopChatRunBlockStartChat` swallows it and starts the chat on the closed, deleted store (`DatabaseView.kt:535-542`), which shows "Error starting chat"; the databases are gone, so the next start shows onboarding |
+| DB mgmt | Settings import | same | `DatabaseView.kt:723`, `Core.kt:144-152` |  | The archive is exported with Pref PrivacyLinkPreviews=false ("Send link previews" off; the export saves the app settings into the database first, `DatabaseView.kt:645`), then the pref is set back to true; after the import and the passphrase prompt ("Save passphrase and open chat"), `initChatController` applies the archive's settings (`DatabaseView.kt:723`, `Core.kt:144-152`), so PrivacyLinkPreviews is false again and ShouldImportAppSettings is false (testAppSettings) | FD | Merged into `dbMgmt_importArchive_restoresData` |
+| DB mgmt | Delete | "Delete database" | `DatabaseView.kt:783-808` | `dbMgmt_deleteDatabase` | "Delete chat profile?" → "Cancel" keeps alice (core user list); → "Delete"; "Chat database deleted"; the onboarding welcome screen appears without a restart (`Core.kt:153-169`) and the core has no users | — | – |
 | DB mgmt | Folder | "Open database folder" | `DatabaseView.kt:239-246`, `D/platform/Files.desktop.kt:33-48` | `dbMgmt_openDatabaseFolder` | The OS file manager opens the data dir | IGNORE: OS folder opener (`desktopOpenDir`), until the seam in plan §13 is approved (plan §11.3) | `Desktop.isDesktopSupported()` is false headless, so the call silently does nothing |
 | DB mgmt | Remote | with a mobile connected | `DatabaseView.kt:217-229,297-301` | `dbMgmt_disconnectMobilesWhenRemote` | "Disconnect mobiles" row; run toggle disabled | P (mobile host) | Pairing as in §K |
-| Encryption | First passphrase | "Database passphrase" | `C/views/database/DatabaseEncryptionView.kt:42-215,423-487`, `D/views/database/DatabaseEncryptionView.desktop.kt` | `dbEncrypt_setFirstPassphrase` | "New passphrase…", "Confirm new passphrase…", "Update database passphrase" (`DatabaseEncryptionView.kt:197`; "Set passphrase" is used only in migration) → "Change database passphrase?" → "Update" (the current key is pre-filled with the random key, `DatabaseEncryptionView.kt:49`); Log `/_db encryption` (obfuscated); "Database encrypted!"; Pref InitialRandomDBPassphrase=false (testDatabaseEncryption) | — | – |
-| Encryption | Change | same | `DatabaseEncryptionView.kt:147-200,444-450` | `dbEncrypt_changePassphrase`, `dbEncrypt_wrongCurrentPassphrase` | "Current passphrase…" → "Update database passphrase" → "Update"; "Wrong passphrase!" | — | – |
-| Encryption | Store | "Save passphrase in settings" | `DatabaseEncryptionView.desktop.kt:22-56,105-112` | `dbEncrypt_removeFromSettings`, `dbEncrypt_saveToSettings` | "Remove passphrase from settings?" → "Remove"; Pref StoreDBPassphrase / EncryptedDBPassphrase (Base64) | — | A passphrase is set first (harness fact 8: the switch is disabled with the random passphrase, `DatabaseEncryptionView.kt:130`). Turning the switch on sets StoreDBPassphrase=true; EncryptedDBPassphrase (Base64) is written by the next "Update database passphrase" |
-| Encryption | Footers | – | `DatabaseEncryptionView.desktop.kt:58-83` | `dbEncrypt_footerStates` | Random passphrase, stored: "The passphrase is stored in settings as plaintext." and "Database is encrypted using a random passphrase, you can change it." (:69-72); own passphrase set with "Save passphrase in settings" on: the first line and "Please note: you will NOT be able to recover or change passphrase if you lose it." (:69-70,73-74); after the switch is turned off and "Remove" confirmed: "You have to enter passphrase every time the app starts - it is not stored on the device." and the same note (:79-81); switch turned on again, not yet stored: "The passphrase will be stored in settings as plaintext after you change it or restart the app." (:76-77); the unencrypted branch (:66-67) is `dbEncrypt_footerUnencrypted` | — | – |
-| Encryption | Unencrypted DB | "Database passphrase" on an unencrypted DB | `DatabaseEncryptionView.desktop.kt:66-67,95-101`, `DatabaseEncryptionView.kt:165-175` | `dbEncrypt_footerUnencrypted` | The footer "Your chat database is not encrypted - set passphrase to protect it." (`DatabaseEncryptionView.desktop.kt:66-67`); setting a passphrase shows "Encrypt database?" → "Encrypt" (:85-91), after which that footer is gone | FIXTURE (unencrypted DB) | A desktop DB always gets a random key and the UI can't set an empty one (`DatabaseEncryptionView.kt:180`) |
-| Startup DB | Passphrase prompt | restart with the passphrase not stored | `C/views/database/DatabaseErrorView.kt:37-120,290-340`, `App.kt:150-155` | `dbError_enterPassphraseOnStartup_open`, `dbError_wrongPassphrase` | "Encrypted database" / "Enter passphrase…" / "Open chat"; wrong gives "Wrong passphrase!" | RESTART | – |
-| Startup DB | Save and open | restart with StoreDBPassphrase=true and no stored key (EncryptedDBPassphrase cleared before the restart) | `DatabaseErrorView.kt:98-104` | `dbError_saveAndOpen` | "Encrypted database" / "Save passphrase and open chat"; after the passphrase is typed and that button clicked, Pref EncryptedDBPassphrase (cleared before the restart) is non-empty again (`ksDatabasePassword.set`, `DatabaseErrorView.kt:53`) and the chat list "Chats" appears | RESTART | – |
-| Startup DB | Upgrade confirm | restart with developer tools + "Confirm database upgrades" | `DatabaseErrorView.kt:107-120`, `Core.kt:79-104` | `dbError_upgradeConfirmation` | "Database upgrade", "Migrations: 20260925_badge_bindings" (the migration whose down-SQL the fixture applied, the last in `src/Simplex/Chat/Store/SQLite/Migrations.hs:356`; `DatabaseErrorView.kt:77-78,115`), "Upgrade and open chat" | FIXTURE (latest migration's down-SQL applied, its `migrations` row deleted), RESTART, DT | The fixture deletes the `migrations` row in the same `/sql chat` call, because the down-SQL only drops a table and two columns (M20260925_badge_bindings.hs:28-36) and the row would otherwise leave nothing to upgrade |
-| Startup DB | Downgrade | restart | `DatabaseErrorView.kt:146-152,281-287` | `dbError_incompatibleDowngrade` | "Incompatible database version" / "database version is newer than the app, but no down migration for: %s" | FIXTURE (extra fake row in `migrations`), RESTART | – |
-| Startup DB | Restore backup | restart | `DatabaseErrorView.kt:184-210,256-279` | `dbError_restoreBackup` | "Restore database backup" → "Restore database backup?" → "Restore"; the button disappears and EncryptionStartedAt is cleared; entering the backup's passphrase then opens the chat | FIXTURE (EncryptionStartedAt set, `*.bak` files that open with the stored key, main files encrypted with another key), RESTART | If the main DB opens, `initChatController` clears EncryptionStartedAt (`Core.kt:140`) and the error screen never shows; `restoreDb` only copies the backup (`DatabaseErrorView.kt:268-279`). The button shows only if both `.bak` files exist and each one's mtime is at least EncryptionStartedAt − 10 s, evaluated when the screen is composed (`DatabaseErrorView.kt:45, 256-267`), so the fixture sets EncryptionStartedAt before copying the `.bak` files |
-| Startup DB | Folder | "Open database folder" on a startup database error screen | `DatabaseErrorView.kt:118-177,322-332`, `D/platform/Files.desktop.kt:33-48` | `dbError_openDatabaseFolder` | The OS file manager opens the data dir | IGNORE: OS folder opener (`desktopOpenDir`), until the seam in plan §13 is approved (plan §11.3) | The button is shown on the migration, SQL, keychain, invalid-confirmation and unknown-error screens (`DatabaseErrorView.kt:118-177`), not on the passphrase screens ("Wrong passphrase!" / "Encrypted database", `:83-104`); `Desktop.isDesktopSupported()` is false headless, so `desktopOpenDir` silently does nothing |
+| Encryption | First passphrase | "Database passphrase" | `C/views/database/DatabaseEncryptionView.kt:44-224,433-496`, `D/views/database/DatabaseEncryptionView.desktop.kt` |  | "New passphrase…", "Confirm new passphrase…", "Update database passphrase" (`DatabaseEncryptionView.kt:205`; "Set passphrase" is used only in migration) → "Change database passphrase?" → "Update" (the current key is pre-filled with the random key, `DatabaseEncryptionView.kt:52`); Log `/_db encryption` (obfuscated); "Database encrypted!"; Pref InitialRandomDBPassphrase=false (testDatabaseEncryption) | — | Merged into `dbEncrypt_changePassphrase` (and set through the UI in `dbMgmt_importArchive_restoresData` and `dbEncrypt_removeFromSettings`). Android starts from an unencrypted template: "Encrypt database?" → "Encrypt" |
+| Encryption | Change | same | `DatabaseEncryptionView.kt:147-207,453-463` | `dbEncrypt_changePassphrase` | Own passphrase set first (row above); "Current passphrase…" with a wrong value → "Update database passphrase" → "Change database passphrase?" → "Update": "Wrong passphrase!" / "Please enter correct current passphrase." and the stored passphrase unchanged; the screen reopened with the right one: "Database encrypted!" and a new stored passphrase; after a restart the chat opens without a prompt, bob's earlier message is there and alice's message reaches bob (testDatabaseEncryption) | P, RESTART | Includes `dbEncrypt_setFirstPassphrase` and `dbEncrypt_wrongCurrentPassphrase`. A wrong current passphrase leaves the chat stopped (`DatabaseView.kt:541`), which the test does not assert |
+| Encryption | Store | "Save passphrase in settings" | `DatabaseEncryptionView.desktop.kt:22-56,105-112`, `DatabaseEncryptionView.kt:133-145,300-312` | `dbEncrypt_removeFromSettings` | Own passphrase set first; switch off: "Remove passphrase from settings?" → "Cancel" keeps Pref EncryptedDBPassphrase; → "Remove": EncryptedDBPassphrase removed at once, StoreDBPassphrase=false; restart: the passphrase prompt (Startup DB rows below), the right passphrase opens the chat without storing it; switch on (no alert): StoreDBPassphrase=true, nothing stored yet; restart: "Save passphrase and open chat" stores it; the next restart has no prompt | RESTART | Includes `dbEncrypt_saveToSettings`, `dbEncrypt_footerStates`, `dbError_enterPassphraseOnStartup_open`, `dbError_wrongPassphrase` and `dbError_saveAndOpen`. The switch is disabled with the random passphrase (`DatabaseEncryptionView.kt:133`). Android: "Save passphrase in Keystore", "Remove passphrase from Keystore?" and the Keystore footers |
+| Encryption | Footers | – | `DatabaseEncryptionView.desktop.kt:58-83` |  | Random passphrase, stored: "The passphrase is stored in settings as plaintext." and "Database is encrypted using a random passphrase, you can change it." (:69-72); own passphrase set with "Save passphrase in settings" on: the first line and "Please note: you will NOT be able to recover or change passphrase if you lose it." (:69-70,73-74); after the switch is turned off and "Remove" confirmed: "You have to enter passphrase every time the app starts - it is not stored on the device." and the same note (:79-81); switch turned on again, not yet stored: "The passphrase will be stored in settings as plaintext after you change it or restart the app." (:76-77); the unencrypted branch (:66-67) is `dbEncrypt_footerUnencrypted` | — | Merged into `dbEncrypt_removeFromSettings` (own passphrase stored, removed, and will-be-stored footers; the random-passphrase footer is not asserted) |
+| Encryption | Unencrypted DB | "Database passphrase" on an unencrypted DB | `DatabaseEncryptionView.desktop.kt:66-67,95-101`, `DatabaseEncryptionView.kt:169-184` | `dbEncrypt_footerUnencrypted` | The footer "Your chat database is not encrypted - set passphrase to protect it." (`DatabaseEncryptionView.desktop.kt:66-67`); setting a passphrase shows "Encrypt database?" → "Encrypt" (:85-91), after which that footer is gone | FIXTURE (unencrypted DB) | A desktop DB always gets a random key and the UI can't set an empty one (`DatabaseEncryptionView.kt:185-190`, `newKey.value.isEmpty()` at :187) |
+| Startup DB | Passphrase prompt | restart with the passphrase not stored | `C/views/database/DatabaseErrorView.kt:37-120,290-340`, `App.kt:150-155` |  | "Encrypted database" / "Enter passphrase…" / "Open chat"; wrong gives "Wrong passphrase!" | RESTART | Merged into `dbEncrypt_removeFromSettings` (reached after "Remove"; a wrong passphrase, then the right one, typed without clearing the field) |
+| Startup DB | Save and open | restart with StoreDBPassphrase=true and no stored key (EncryptedDBPassphrase cleared before the restart) | `DatabaseErrorView.kt:98-104` |  | "Encrypted database" / "Save passphrase and open chat"; after the passphrase is typed and that button clicked, Pref EncryptedDBPassphrase (cleared before the restart) is non-empty again (`ksDatabasePassword.set`, `DatabaseErrorView.kt:55`) and the chat list "Chats" appears | RESTART | Merged into `dbEncrypt_removeFromSettings` (storing switched on, no stored key; the state is reached through the UI, not by clearing settings) and `dbMgmt_importArchive_restoresData` (after the import) |
+| Startup DB | Upgrade confirm | restart with developer tools + "Confirm database upgrades" | `DatabaseErrorView.kt:109-121`, `Core.kt:79-104` | `dbError_upgradeConfirmation` | "Database upgrade", "Migrations: 20260925_badge_bindings" (the migration whose down-SQL the fixture applied, the last in `src/Simplex/Chat/Store/SQLite/Migrations.hs:356`; `DatabaseErrorView.kt:79-81,117`), "Upgrade and open chat" | FIXTURE (latest migration's down-SQL applied, its `migrations` row deleted), RESTART, DT | The fixture deletes the `migrations` row in the same `/sql chat` call, because the down-SQL only drops a table and two columns (M20260925_badge_bindings.hs:28-36) and the row would otherwise leave nothing to upgrade |
+| Startup DB | Downgrade | restart | `DatabaseErrorView.kt:148-154,283-289` | `dbError_incompatibleDowngrade` | "Incompatible database version" / "File: simplex_v1_chat.db" / "Error: database version is newer than the app, but no down migration for: 29991231_uitest_newer"; no passphrase field and no chat list | FIXTURE (`migrations` row `29991231_uitest_newer` with no down migration, added by `/sql chat`), RESTART | The name sorts after every app migration, so the check gives `MTRENoDown` (simplexmq `Agent/Store/Migrations.hs`); shared, the Android harness reaches the screen with `restart(ready = …)` |
+| Startup DB | Restore backup | restart | `DatabaseErrorView.kt:184-197,258-281` | `dbError_restoreBackup` | "Restore database backup" → "Restore database backup?" → "Restore"; the button disappears and EncryptionStartedAt is cleared; entering the backup's passphrase then opens the chat | FIXTURE (EncryptionStartedAt set, `*.bak` files that open with the stored key, main files encrypted with another key), RESTART | If the main DB opens, `initChatController` clears EncryptionStartedAt (`Core.kt:140`) and the error screen never shows; `restoreDb` only copies the backup (`DatabaseErrorView.kt:270-281`). The button shows only if both `.bak` files exist and each one's mtime is at least EncryptionStartedAt − 10 s, evaluated when the screen is composed (`DatabaseErrorView.kt:47, 258-268`), so the fixture sets EncryptionStartedAt before copying the `.bak` files |
+| Startup DB | Folder | "Open database folder" on a startup database error screen | `DatabaseErrorView.kt:118-177,325-335`, `D/platform/Files.desktop.kt:33-48` | `dbError_openDatabaseFolder` | The OS file manager opens the data dir | IGNORE: OS folder opener (`desktopOpenDir`), until the seam in plan §13 is approved (plan §11.3) | The button is shown on the migration, SQL, keychain, invalid-confirmation and unknown-error screens (`DatabaseErrorView.kt:118-177`), not on the passphrase screens ("Wrong passphrase!" / "Encrypted database", `:83-104`); `Desktop.isDesktopSupported()` is false headless, so `desktopOpenDir` silently does nothing |
 
 The onboarding passphrase step is owned by catalogue 01 §1.
 
@@ -221,36 +221,36 @@ The onboarding passphrase step is owned by catalogue 01 §1.
 | To | Resume | restart mid-migration | `MigrateToDevice.kt:55-82`, Pref MigrationToStage | `migrateTo_resumeAfterRestart` | Restart at the "Enter passphrase" step → after restart "Migrate here" reopens at "Enter passphrase" (a restart during "Downloading archive" drops the migration) | P, XFTP, CB, RESTART, ONBOARD | Migrate-to is reachable only from onboarding (`WelcomeView.kt:206-212`) |
 | From | Resume | restart mid-migration | Pref MigrationFromStage (`SimpleXAPI.kt:209`) | `migrateFrom_resumeAfterRestart` | – | IGNORE: unused code — `migrationFromStage` is declared but never read or written, so there is no resume to test (plan §11.3) | – |
 
-### I. App version, update checker, developer tools (15 tests)
+### I. App version, update checker, developer tools (13 tests)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Version | Info | Settings > version row (§A) | `US/VersionInfoView.kt:24-55` | `version_screenShowsVersions` | "App version" screen: "App version: v%s", "App build: %s", "Core version: v%s", "simplexmq: v%s (%2s)"; `/version` in Log | — | – |
+| Version | Info | Settings > version row (§A) | `US/SettingsView.kt:353-360`, `US/VersionInfoView.kt:24-55` | `version_screenShowsVersions` | The version row reads "<VERSION_NAME> (<VERSION_CODE>)" (the platform's `BuildConfigCommon` values); the "App version" screen shows "App version: v<name>", "App build: <code>", "Core version: v<core>", "simplexmq: v<simplexmq> (<first 7 of the commit>)", the core values from `apiGetVersion` | — | Shared |
 | Updates | Channel | "Check for updates" (Disabled/Stable/Beta) | `D/views/usersettings/SettingsView.desktop.kt:14-26`, `D/views/helpers/AppUpdater.kt:161-200` | `updates_channelDropdown` | Pref AppUpdateChannel | — | The network check is an `IGNORE` row in §M. Selecting Stable/Beta starts a 24 h `withLongRunningApi` job, so the test ends by selecting "Disabled" (`setupUpdateChecker` cancels the job, `AppUpdater.kt:162-165`): the job is untracked (`idle = false`, plan §6) and would otherwise outlive the test in this JVM |
 | Updates | Notice | after onboarding, once there are more than 3 chats | `apps/multiplatform/desktop/src/jvmMain/kotlin/chat/simplex/desktop/Main.kt:67-89`, `AppUpdater.kt:127-158` | `updates_noticeDialog` | "Check for updates" alert with "Stable"/"Beta"/"Disable"; Pref AppUpdateNoticeShown. Shown only when AppUpdateNoticeShown=false, onboarding is complete, more than 3 chats exist and no call invitation is active (`Main.kt:69-73`) | RESTART | 04 owns this notice. The check runs once at startup (desktop `Main.kt:79-87`), so the pre-set of `appUpdateNoticeShown` is cleared, chats are created until `chatModel.chats.size > 3` (local groups via the console; the size counts the notes folder and the "Ask SimpleX Team" card, so two are enough), and the core restarted (harness fact 4); the platform object comes from harness fact 5. The test ends by selecting "Disabled" in Settings, which cancels the 24 h update job: it is untracked (`idle = false`, plan §6) and would otherwise outlive the test in this JVM |
-| Dev | Console | version > "Developer tools" > "Chat console" | `US/DeveloperView.kt:32`, `C/views/TerminalView.kt:37-66` | `console_sendCommand` | Type `/v` + send; cmd and response items rendered | — | The console's line list is volatile in screenshots (wall-clock times, core events in arrival order; plan §7.7) |
-| Dev | /sql guard | console | `TerminalView.kt:46-53` | `console_sqlBlockedWithoutLockAndDevTools` | The response line reads `< error chat` (SimpleXAPI.kt:6597, 7786); clicking it opens the details, `error chat commandError Failed reading: empty` (TerminalView.kt:177-193, SimpleXAPI.kt:6602, 7769, 7872) | — | The console's line list is volatile in screenshots (plan §7.7) |
-| Dev | Hints | "Reset all hints" | `SettingsView.kt:328-347`, `SimpleXAPI.kt:278-291` | `dev_resetAllHints` | Enabled at start (the harness pre-sets change hint prefs, `SimpleXAPI.kt:278-293`); after tapping, all hint prefs are defaults and the row is disabled | — | – |
-| Dev | Dev options | "Show developer options" | `DeveloperView.kt:37-64` | `dev_showDeveloperOptionsSection` | Pref DeveloperTools; "Developer options" section and footer | — | – |
+| Dev | Console | version > "Developer tools" > "Chat console" | `US/DeveloperView.kt:32`, `C/views/TerminalView.kt:37-66` | `console_sendCommand` | Type `/contacts` + Send: the console shows "> /contacts" and the core's "< * contactsList" and the field clears; then `/sql chat select 1` + Send: "> /sql chat select 1" and "< error chat", and the item after the command holds `error chat commandError Failed reading: empty` (SimpleX Lock and developer tools are off) | — | Shared. `console_sqlBlockedWithoutLockAndDevTools` merged into `console_sendCommand`. `/contacts` is used because the app never sends it (the version screen sends `/version`, so its response line is not unique); lines are matched by their label suffix (they start with the wall-clock time). The details screen is not opened (the lines have no keys) |
+| Dev | /sql guard | console | `TerminalView.kt:47-56` |  | – | — | `console_sqlBlockedWithoutLockAndDevTools` merged into `console_sendCommand` |
+| Dev | Hints | "Reset all hints" | `SettingsView.kt:332-351`, `SimpleXAPI.kt:282-299` | `dev_resetAllHints` | At start some hint prefs differ from their defaults (harness pre-sets) and the chat list has no one-hand UI card; after "Reset all hints" every hint pref is at its default and OneHandUICardShown is stored false; back on the chat list the connect onboarding ('Talk to someone') replaces the chat list, because alice has no conversations | — | Shared. The disabled row is not checked: a disabled `SectionItemView` has no Disabled semantics |
+| Dev | Dev options | "Show developer options" | `DeveloperView.kt:35-65` | `dev_showDeveloperOptionsSection` | Off: footer "Hide: Database IDs and Transport isolation option.", no "Enable logs"; on: Pref DeveloperTools=true, footer "Show: …", "Enable logs" and "Show internal errors" shown; off again: Pref false, the rows gone and the "Hide: …" footer back | — | Shared |
 | Dev | Logs | "Enable logs" | `DeveloperView.kt:44-49` | `dev_enableLogs` | Pref LogLevel DEBUG/WARNING | DT | – |
 | Dev | Confirm upgrades | "Confirm database upgrades" | `DeveloperView.kt:50` | `dev_confirmDbUpgradesPref` | Pref ConfirmDBUpgrades (functional check is in §G) | DT | – |
 | Dev | Console window | "Show console in new window" | `DeveloperView.kt:51-60`, `DesktopApp.kt:210-232` | `dev_showConsoleInNewWindow_requiresAuth` | Passcode prompt when locked; Pref TerminalAlwaysVisible | DT | Lock enabled first; the second Window itself is an `IGNORE` row in §M |
 | Dev | Errors / slow calls | "Show internal errors" / "Show slow API calls" | `DeveloperView.kt:61-62` | `dev_showInternalErrors`, `dev_showSlowApiCalls` | Prefs ShowInternalErrors / ShowSlowApiCalls | DT | – |
 | Dev | Link mode | "Deprecated options" > "SimpleX links" (Description/Full link) | `DeveloperView.kt:66-73`, `PrivacySettings.kt:288-309` | `dev_simplexLinksMode` | Pref PrivacySimplexLinkMode; a link from bob renders as description vs full | P (bob) | – |
 | Dev | Terminal link | "Install SimpleX Chat for terminal" | `SettingsView.kt:316` | `dev_installTerminalLink` | "Open external link?" with the GitHub URL → "Open" (`C/views/helpers/Utils.kt:613-624`); URI stub gets `https://github.com/simplex-chat/simplex-chat` | URI | – |
-| Dev | Extra modes | Transport isolation with developer tools | `NetworkAndServers.kt:622-626` | `dev_devToolsExtraSessionModes` | With developer tools on, "Connection" (`TransportSessionMode.Entity`) is added to "Chat profile" / "App session" / "Server" | DT | – |
+| Dev | Extra modes | Transport isolation with developer tools | `NetworkAndServers.kt:630-634` |  | With developer tools on, "Connection" (`TransportSessionMode.Entity`) is added to "Chat profile" / "App session" / "Server" | DT | `dev_devToolsExtraSessionModes` merged into `advNet_transportIsolation` |
 
-### J. Help & support (8 tests, 2 ignored)
+### J. Help & support (4 tests, 2 ignored)
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Help | Layout | Settings > "Help & support" | `SettingsView.kt:146-185` | `help_layout` | "How to use it", "What's new", "About SimpleX Chat", "Follow SimpleX Network News", "Send questions and ideas", "Send us email", "Contribute", "Star on GitHub" (no "Rate the app") | — | What's New itself is owned by catalogue 01 §2 |
-| Help | How to | "How to use it" | `US/HelpView.kt:18`, `C/views/chatlist/ChatHelpView.kt:26` | `help_howToUse` | "Welcome <name>!" + help text | — | – |
-| About | About | "About SimpleX Chat" | `C/views/onboarding/SimpleXInfo.kt:44` | `help_aboutSimplex` | Onboarding-style info without action buttons | — | – |
+| Help | Layout | Settings > "Help & support" | `SettingsView.kt:150-188` | `help_layoutHowToUseAndAbout` | "How to use it", "What's new", "About SimpleX Chat", "Follow SimpleX Network News", "Send questions and ideas", "Send us email", "Star on GitHub"; "Rate the app" only on Android; "Contribute" unless a Play Store build; "How to use it" opens "Welcome alice!" with "Thank you for installing SimpleX Chat!"; "About SimpleX Chat" opens "Private and secure messaging." without the onboarding buttons ("Why SimpleX is built." absent) | — | Shared. `help_howToUse` and `help_aboutSimplex` merged into `help_layoutHowToUseAndAbout`. What's New itself is owned by catalogue 01 §2 |
+| Help | How to | "How to use it" | `US/HelpView.kt:18`, `C/views/chatlist/ChatHelpView.kt:26` |  | – | — | `help_howToUse` merged into `help_layoutHowToUseAndAbout` |
+| About | About | "About SimpleX Chat" | `C/views/onboarding/SimpleXInfo.kt:47-66` |  | – | — | `help_aboutSimplex` merged into `help_layoutHowToUseAndAbout` |
 | Contact | SimpleX links | "Follow SimpleX Network News" / "Send questions and ideas" | `SettingsView.kt:74-78,166-169` | `help_followNews_opensSimplexUri`, `help_chatWithFounder_opensSimplexUri` | The channel / address opens | IGNORE: destination on public servers, unreachable in the namespace (plan §11.3) | `openVerifiedSimplexUri` connects straight to the public servers (`C/views/helpers/Utils.kt:599-600`), bypassing the `LocalUriHandler` stub |
-| Contact | Email | "Send us email" | `SettingsView.kt:170` | `help_sendEmail_mailto` | URI stub gets `mailto:chat@simplex.chat` | URI | – |
-| Support | Links | "Contribute" / "Star on GitHub" | `SettingsView.kt:255-293` | `help_contributeAndStar` | Each shows "Open external link?" → "Open"; URI stub gets `https://github.com/simplex-chat/simplex-chat#contribute` (`SettingsView.kt:256`) / `https://github.com/simplex-chat/simplex-chat` | URI | – |
-| Help | Stopped | chat stopped | `SettingsView.kt:159-169` | `help_disabledItemsWhenStopped` | How to / What's new / contact links disabled | — | – |
+| Contact | Email | "Send us email" | `SettingsView.kt:173` |  | – | URI | `help_sendEmail_mailto` merged into `help_contributeAndStar` |
+| Support | Links | "Send us email" / "Contribute" / "Star on GitHub" | `SettingsView.kt:173,259-297`, `C/views/helpers/Utils.kt:613-634` | `help_contributeAndStar` | "Send us email" records `mailto:chat@simplex.chat` in the URI stub at once; "Contribute" shows "Open external link?" with the URL: Cancel opens nothing, Open records `https://github.com/simplex-chat/simplex-chat#contribute`; "Star on GitHub" > Open records `https://github.com/simplex-chat/simplex-chat` | URI | Desktop (`HelpDesktopTest`: the URI stub is desktop-only). `help_sendEmail_mailto` merged into `help_contributeAndStar` |
+| Help | Stopped | chat stopped | `SettingsView.kt:162-171` |  | – | — | `help_disabledItemsWhenStopped` merged into `settingsRoot_itemsDisabledWhenChatStopped` |
 
 ### K. Remote desktop: "Link a mobile" (the desktop GUI is the controller, the CLI is the mobile host) (17 tests)
 
@@ -266,11 +266,11 @@ The invitation reaches the test through "Share link" into the CB stub (needs dev
 | Remote | Layout | Picker > "Link a mobile" | `C/views/remote/ConnectMobileView.kt:45-149` | `linkMobile_layout` | "This device name" field, "Discoverable via local network", "Devices": "This device" ✓, "Link a mobile" (with a "+" icon) | — | – |
 | Remote | Device name | name field | `ConnectMobileView.kt:59-66,152-167` | `linkMobile_deviceNameChange` | Log `/set device name X`; Pref DeviceNameForRemoteAccess; the CLI prints "connecting new remote controller: X, v…" | P (mobile host) | – |
 | Remote | Multicast pref | toggle | `ConnectMobileView.kt:98-100` | `linkMobile_multicastToggle` | Pref OfferRemoteMulticast; reconnecting a stored host sends `/start remote host 1 multicast=<on/off>` (`multicast=` is only sent for stored hosts, `SimpleXAPI.kt:4311`) | P (mobile host) | – |
-| Remote | Pair | "Link a mobile" (the "+" row) | `ConnectMobileView.kt:262-348,170-246` | `linkMobile_newPairing_verifyAndConnect` | QR + "Waiting for mobile to connect:"; after connect: "Verify connection", section "Connected mobile" showing "New mobile device" (italic; the host's name isn't known before verification, `ConnectMobileView.kt:221-223`), and the "Verify code on mobile" code shown by the GUI is the first 23 characters of the CLI's session code (`ConnectMobileView.kt:234`); then the GUI switches to the remote host (`startRemote`) | P (mobile host), CB, DT | – |
-| Remote | Use remote | chat list | `UserPicker.kt:493-547` | `linkMobile_remoteChatsVisible_sendMessage` | The mobile's chats are shown; send to bob → bob receives (remoteMessageTest) | P ×2 (mobile host, bob) | – |
+| Remote | Pair | "Link a mobile" (the "+" row) | `ConnectMobileView.kt:262-348,170-246` | `linkMobile_newPairing_verifyAndConnect` | QR + "Waiting for mobile to connect:"; after connect: "Verify connection", section "Connected mobile" showing "New mobile device" (italic; the host's name isn't known before verification, `ConnectMobileView.kt:221-223`), and the "Verify code on mobile" code shown by the GUI is the first 23 characters of the CLI's session code (`ConnectMobileView.kt:234`); then the GUI switches to the remote host (`startRemote`) | P (mobile host), CB, DT | Desktop-only (`RemoteDesktopTest`). The name the CLI prints in `connecting new remote controller:` and `session started with` is the one in "This device name"; after the switch the user picker shows the mobile's pill (`userPicker.device[<rhId>]`), "This device" and the mobile's profile. The test ends the session through the API (`endMobileSessionViaApi`) |
+| Remote | Use remote | chat list | `UserPicker.kt:493-547` | `linkMobile_remoteChatsVisible_sendMessage` | The mobile's chats are shown; send to bob → bob receives (remoteMessageTest) | P ×2 (mobile host, bob), CB, DT | Desktop-only (`RemoteDesktopTest`). The desktop has no chat with bob before pairing; the mobile's chat row is keyed with the host id (`chatList.row[<rhId>:<chatId>]`); bob receives `mobile> hi from desktop` and his reply shows on the desktop. Pairing goes through "Share link" (`linkMobileHost`), so CB and DT |
 | Remote | Switch | DevicePill "This device" / "Mobile" | `UserPicker.kt:660-679` | `linkMobile_switchLocalRemote` | After "Mobile" the list shows the mobile's contact bob and none of alice's chats; after "This device" alice's chats return and bob's row is gone (`switchUIRemoteHost(null)`, `UserPicker.kt:660-664`; `UserPicker.kt:513-539`; switchRemoteHostTest, `tests/RemoteTests.hs:507-531`) | P ×2 (mobile host, bob) | – |
-| Remote | Disconnect (desktop) | pill wifi button / "Connected to mobile" > "Disconnect" | `ConnectMobileView.kt:430-453`, `UserPicker.kt:607-618` | `linkMobile_disconnectFromDesktop` | The CLI prints "remote controller stopped" (stopDesktop) | P (mobile host) | – |
-| Remote | Disconnect (mobile) | CLI `/stop remote ctrl` | – | `linkMobile_mobileStopsSession` | GUI back to local; host not connected (stopMobile) | P (mobile host) | – |
+| Remote | Disconnect (desktop) | pill wifi button / "Connected to mobile" > "Disconnect" | `ConnectMobileView.kt:430-453`, `UserPicker.kt:607-618` | `linkMobile_disconnectFromDesktop` | The CLI prints "remote controller stopped" (stopDesktop) | P (mobile host), CB, DT | Desktop-only (`RemoteDesktopTest`): the pill's wifi button (`userPicker.device[<rhId>].disconnect`); afterwards alice's profile is back and the user picker shows only "This device" |
+| Remote | Disconnect (mobile) | CLI `/stop remote ctrl` | – | `linkMobile_mobileStopsSession` | GUI back to local; host not connected (stopMobile) | P (mobile host), CB, DT, TOAST | Desktop-only (`RemoteDesktopTest`): also the toast "Mobile <b>…</b> was disconnected" (`remote_host_was_disconnected_toast`, `C/model/SimpleXAPI.kt:3518-3522`), once; afterwards the user picker shows only "This device" and alice's profile |
 | Remote | Stored pairing | tap the stored "Mobile" row | `ConnectMobileView.kt:350-428` | `linkMobile_reconnectStoredPairing` | With a stored host the user-picker row and the screen title read "Linked mobiles" (`UserPicker.kt:370`, `ConnectMobileView.kt:94`); "Scan from mobile" QR; reconnect works; the CLI prints "connecting remote controller 1: …" (`startRemoteStored`) | P (mobile host) | – |
 | Remote | Delete host | right-click > "Delete" | `ConnectMobileView.kt:70-77,126-138` | `linkMobile_deleteHost` | Log `/delete remote host <id>`; row removed | P (mobile host) | The host is paired and stored first |
 | Remote | Port | port field ("Random"), info icon | `ConnectMobileView.kt:455-520` | `linkMobile_customPortRefreshQr`, `linkMobile_openPortInfo` | QR marked stale → "Refresh" restarts with that port; "Open port in firewall" alert | — | The custom port is taken from the JVM's port block (plan §8.2), so parallel JVMs don't collide |
@@ -311,17 +311,17 @@ Android-only features are not desktop features and simply have no rows (and no `
 
 | Section | Tests | Ignored |
 |---|---|---|
-| A. Settings root and global keys | 7 | 0 |
-| B. Privacy | 24 | 0 |
-| C. SimpleX Lock and self-destruct | 22 | 0 |
-| D. Appearance | 24 | 0 |
-| E. Network & servers | 43 | 0 |
+| A. Settings root and global keys | 5 | 0 |
+| B. Privacy | 22 | 0 |
+| C. SimpleX Lock and self-destruct | 12 | 0 |
+| D. Appearance | 18 | 0 |
+| E. Network & servers | 33 | 0 |
 | F. Audio & video calls | 6 | 0 |
-| G. Chat data / database | 35 | 3 |
+| G. Chat data / database | 19 | 2 |
 | H. Migration | 15 | 6 |
-| I. Version / developer tools | 15 | 0 |
-| J. Help & support | 8 | 2 |
+| I. Version / developer tools | 13 | 0 |
+| J. Help & support | 4 | 2 |
 | K. Remote desktop | 17 | 0 |
 | L. Supporter perks | 8 | 1 |
 | M. Out of reach in-process | 8 | 8 |
-| **Total** | **232** | **20** |
\ No newline at end of file
+| **Total** | **180** | **19** |
\ No newline at end of file
diff --git a/plans/ui-tests/catalogue/05-android-carryover.md b/plans/ui-tests/catalogue/05-android-carryover.md
index 61aac38d62..3afe59a810 100644
--- a/plans/ui-tests/catalogue/05-android-carryover.md
+++ b/plans/ui-tests/catalogue/05-android-carryover.md
@@ -204,7 +204,7 @@ Rules used by many rows; the tables name every row they apply to, as `R<n>` plus
 | 02:138 | `edit_metaShowsEditedIcon` | ADAPT | R2: as above | `A/platform/PlatformTextField.android.kt:60-63` |
 | 02:139 | `edit_upArrow_editsLastMessage` | DESKTOP-ONLY | R2: no Up-arrow handling | `D/platform/PlatformTextField.desktop.kt:138-140` |
 | 02:142 | `edit_ownImage_previewWithoutCancel` | ADAPT | R3: the image comes from the gallery stub; R2: the edit is sent with the send button | `A/views/chat/ComposeView.android.kt:40,58-65` |
-| 02:142 | `edit_ownFile_previewWithoutCancel` | ADAPT | R3: the file comes from the "File" stub; R2: as above | `A/views/chat/ComposeView.android.kt:44,74-77` |
+| 02:142 | `edit_ownFile_keepsFileWithoutPreview` | ADAPT | R3: the file comes from the "File" stub; R2: as above | `A/views/chat/ComposeView.android.kt:44,74-77` |
 | 02:143 | `edit_notOffered_forReceivedVoiceForwarded` | ADAPT | R10 (`REC`) for alice's recorded voice message | `A/platform/RecAndPlay.android.kt:17-98` |
 | 02:167 | `forwarded_goToSource_opensOriginalChat` | ADAPT | No hover: the arrow button is always composed (faded until activated) and is tapped directly; tapping the forwarded bubble toggles it to full visibility | `C/views/chat/item/ChatItemView.kt:243-302,330-332` |
 | 02:178 | `reaction_chipMenu_direct_showsNames` | ADAPT | R1 (long-press the chip) | `C/views/chat/item/ChatItemView.kt:200-207` |
diff --git a/plans/ui-tests/catalogue/05-android-only.md b/plans/ui-tests/catalogue/05-android-only.md
index 7324b6a46e..31064921a5 100644
--- a/plans/ui-tests/catalogue/05-android-only.md
+++ b/plans/ui-tests/catalogue/05-android-only.md
@@ -72,9 +72,9 @@ Catalogue 01 §1 owns the shared onboarding rows (profile name rules, operators,
 | Area | Feature | Entry path (labels) | Main file:line | Test case(s) | Verification (GUI / CLI) | Needs | Notes |
 |---|---|---|---|---|---|---|---|
 | Onboarding | Welcome screen (Android) | First launch, stage `Step1_SimpleXInfo` | `C/views/onboarding/SimpleXInfo.kt:44-58,104-160`; `A/views/onboarding/SimpleXInfo.android.kt:11-16` | `androidOnboardingWelcomeShowsGetStarted` | "Get started" and "Why SimpleX is built."; no "Link a mobile" and no "Create your profile" (desktop labels); "Get started" opens "Your profile" | ONBOARD | Desktop counterpart: 01 `onboardingWhySimplexIsBuiltOpensHowItWorks` |
-| Onboarding | Create profile (mobile layout) | "Get started" → "Your profile" | `C/views/WelcomeView.kt:236-300` | `androidOnboardingCreateProfileMobileLayout` | Title "Your profile", "On your phone, not on servers.", "No account. No phone. No email. No ID.…", field "Enter profile name…", button "Create profile"; the soft keyboard opens on the field and the image shrinks while it is open (`WelcomeView.kt:245-248`) | ONBOARD, IME | Name validation rows are 01's |
-| Onboarding | "Migrate" button | "Your profile" app bar → "Migrate" | `C/views/WelcomeView.kt:201-225,242`; `C/views/migration/MigrateToDevice.kt:200-216` | `androidOnboardingMigrateButtonOpensScanAndPaste` | The button reads "Migrate" (desktop: "Migrate from another device"); the migration screen shows "Scan QR code" (camera section, §4) above "Or paste archive link" and "Or import archive file" | ONBOARD, PERM (CAMERA granted) | The scan itself is `qrScan_migrationLink` (§5) |
-| Onboarding | No passphrase step | "Create profile" | `C/views/WelcomeView.kt:399-405`; `C/views/helpers/DatabaseUtils.kt:51-60` | `androidOnboardingNoPassphraseStepAfterProfile` | After "Create profile" the next screen is "Your network", never "Setup database passphrase"; prefs: `storeDBPassphrase = true`, `initialRandomDBPassphrase = true`, and `DatabaseUtils.ksDatabasePassword.get()` returns the random key from the Keystore | ONBOARD | Desktop goes to the passphrase step (01 setup item 6) |
+| Onboarding | Create profile (mobile layout) | "Get started" → "Your profile" | `C/views/WelcomeView.kt:236-300` | `androidOnboardingCreateProfileMobileLayout` | Title "Your profile", "On your phone, not on servers.", "No account. No phone. No email. No ID.…", field "Enter profile name…", button "Create profile" (disabled until a name is typed); the soft keyboard opens on the field; the app-bar button reads "Migrate" and opens the migration screen with "Scan QR code", "Or paste archive link" and "Or import archive file" | ONBOARD, IME | Name validation rows are 01's |
+| Onboarding | "Migrate" button | "Your profile" app bar → "Migrate" | `C/views/WelcomeView.kt:201-225,242`; `C/views/migration/MigrateToDevice.kt:200-216` | | The button reads "Migrate" (desktop: "Migrate from another device"); the migration screen shows "Scan QR code" (camera section, §4) above "Or paste archive link" and "Or import archive file" | ONBOARD, PERM (CAMERA granted) | `androidOnboardingMigrateButtonOpensScanAndPaste` merged into `androidOnboardingCreateProfileMobileLayout`. The scan itself is `qrScan_migrationLink` (§5) |
+| Onboarding | No passphrase step | "Create profile" | `C/views/WelcomeView.kt:399-405`; `C/views/helpers/DatabaseUtils.kt:51-60` | | After "Create profile" the next screen is "Your network", never "Setup database passphrase"; prefs: `storeDBPassphrase = true`, `initialRandomDBPassphrase = true`, and `DatabaseUtils.ksDatabasePassword.get()` returns the random key from the Keystore | ONBOARD | `androidOnboardingNoPassphraseStepAfterProfile` merged into `keystore_freshDb_randomPassphraseFooter`. Desktop goes to the passphrase step (01 setup item 6) |
 | Onboarding | Your network (Android) | "Your network" | `C/views/onboarding/YourNetwork.kt:58-133,200-226` | `androidYourNetworkShowsSetupNotifications` | "Your network", "Setup routers" (operator logos) and "Setup notifications" with the bolt icon (mode Instant), "Continue" | ONBOARD | Desktop has no notifications button (01 `onboardingYourNetworkShowsSetupRouters`) |
 | Onboarding | Notifications mode screen | "Setup notifications" | `C/views/onboarding/SetNotificationsMode.kt:24-62` | `onboardingNotifications_cardsAndDefault` | Title "Private notifications", link "How it affects battery", cards "Instant" ("App always runs in background"), "Periodic" ("Check messages every 10 minutes"), "When app is running" ("No background service"), button "OK"; "Instant" is selected (`NotificationsMode.default = SERVICE`, `C/model/SimpleXAPI.kt:8588-8594`) | ONBOARD | – |
 | Onboarding | Select a mode | tap "Periodic" → "OK" | `SetNotificationsMode.kt:39-57`; `YourNetwork.kt:56,105-109,201-206` | `onboardingNotifications_selectPeriodicReturns` | "Periodic" is highlighted; "OK" returns to "Your network", whose "Setup notifications" icon is now the timer; the pref is unchanged until "Continue" | ONBOARD | The choice is kept in `rememberSaveable` until "Continue" |
@@ -93,10 +93,10 @@ Notifications in SimpleX on Android come only from the app's own process: there
 | Area | Feature | Entry path (labels) | Main file:line | Test case(s) | Verification (GUI / system) | Needs | Notes |
 |---|---|---|---|---|---|---|---|
 | Settings | "Notifications" item | Settings | `US/SettingsView.kt:122-126` | `ntfSettings_rootItemIconAndStoppedState` | Under "Advanced settings": "Notifications" between "Network & servers" and "Audio & video calls"; its icon is the bolt, or bolt-off in mode OFF; disabled after the chat is stopped (Chat data) | — | 04 `settingsRoot_listsDesktopItems` asserts it is absent on desktop |
-| Settings | Notifications screen | Settings > "Notifications" | `US/NotificationsSettingsView.kt:23-63` | `ntfSettings_layoutShowsCurrentMode` | Title "Notifications"; row "Notification service" with the current mode's title in grey ("Always on" for SERVICE, "Starts periodically", "Runs when app is open") | — | – |
-| Settings | Mode picker | "Notification service" | `US/NotificationsSettingsView.kt:28-34,65-117` | `ntfSettings_modePickerOptions` | Page "Notification service" lists "Runs when app is open" ("App can receive notifications only when it's running, no background service will be started"), "Starts periodically" ("Checks new messages every 10 minutes for up to 1 minute"), "Always on" ("Background service is always running – notifications will be shown as soon as the messages are available."); the current one is checked | — | – |
-| Settings | Switch to OFF | picker > "Runs when app is open" | `US/NotificationsSettingsView.kt:146-149`; `APP/SimplexApp.kt:217-244` | `ntfMode_switchToOff_stopsServiceAndReceivers` | From SERVICE: Pref `notificationsMode = OFF`; the "SimpleX Chat service" notification disappears (`SimplexService.isServiceStarted` false); `StartReceiver`/`AppUpdateReceiver` disabled; unique work `SimplexAutoRestartWorkerPeriodic` cancelled; the Settings icon turns to bolt-off; no alert | SYSNTF | The test starts in SERVICE mode with the service running |
-| Settings | Switch to Periodic | picker > "Starts periodically" | `APP/SimplexApp.kt:217-244,178-184`; `APP/MessagesFetcherWorker.kt:15-40` | `ntfMode_switchToPeriodic_schedulesFetcher` | From SERVICE: Pref `notificationsMode = PERIODIC`; service notification gone; receivers disabled; the fetcher work `chat.simplex.app.debug.UNIQUE_MESSAGES_FETCHER` is enqueued (after `ActivityScenario.recreate()` if not already) | SYSNTF | – |
+| Settings | Notifications screen | Settings > "Notifications" | `US/NotificationsSettingsView.kt:23-63` | | Title "Notifications"; row "Notification service" with the current mode's title in grey ("Always on" for SERVICE, "Starts periodically", "Runs when app is open") | — | `ntfSettings_layoutShowsCurrentMode` merged into `ntfMode_switchToService_startsForegroundService` |
+| Settings | Mode picker | "Notification service" | `US/NotificationsSettingsView.kt:28-34,65-117` | | Page "Notification service" lists "Runs when app is open" ("App can receive notifications only when it's running, no background service will be started"), "Starts periodically" ("Checks new messages every 10 minutes for up to 1 minute"), "Always on" ("Background service is always running – notifications will be shown as soon as the messages are available."); the current one is checked | — | `ntfSettings_modePickerOptions` merged into `ntfMode_switchToService_startsForegroundService` |
+| Settings | Switch to OFF | picker > "Runs when app is open" | `US/NotificationsSettingsView.kt:146-149`; `APP/SimplexApp.kt:217-244` | | From SERVICE: Pref `notificationsMode = OFF`; the "SimpleX Chat service" notification disappears (`SimplexService.isServiceStarted` false); `StartReceiver`/`AppUpdateReceiver` disabled; unique work `SimplexAutoRestartWorkerPeriodic` cancelled; the Settings icon turns to bolt-off; no alert | SYSNTF | `ntfMode_switchToOff_stopsServiceAndReceivers` merged into `ntfMode_switchToService_startsForegroundService`. The test starts in SERVICE mode with the service running |
+| Settings | Switch to Periodic | picker > "Starts periodically" | `APP/SimplexApp.kt:217-244,178-184`; `APP/MessagesFetcherWorker.kt:15-40` | `ntfMode_switchToPeriodic_schedulesFetcher` | From OFF: Pref `notificationsMode = PERIODIC`; "Starts periodically" checked with its description; no service notification; receivers disabled; the fetcher work `chat.simplex.app.debug.UNIQUE_MESSAGES_FETCHER` is enqueued at once; back on "Runs when app is open" it is cancelled | SYSNTF | – |
 | Settings | Switch to Always on | picker > "Always on" | `APP/SimplexApp.kt:217-236`; `APP/SimplexService.kt:47-62,165-204,348-361` | `ntfMode_switchToService_startsForegroundService` | From OFF: Pref `notificationsMode = SERVICE`; within a few seconds the ongoing, silent notification "SimpleX Chat service" / "Receiving messages…" with action "Hide" is active (channel id `chat.simplex.app.SIMPLEX_SERVICE_NOTIFICATION`, importance low); receivers enabled | SYSNTF | The code restarts the service once if the system destroyed it within 2 s (`SimplexApp.kt:226-232`) |
 | Service | "Hide" action | service notification > "Hide" | `APP/SimplexService.kt:193-201` | `serviceNotification_hideOpensChannelSettings` | Sending the action's `PendingIntent` fires `Settings.ACTION_CHANNEL_NOTIFICATION_SETTINGS` with `EXTRA_APP_PACKAGE` = the app and `EXTRA_CHANNEL_ID` = `chat.simplex.app.SIMPLEX_SERVICE_NOTIFICATION` (recorded and stubbed) | SYSNTF, INTENTS | A `PendingIntent.send()` from the test process goes through the system, so whether Espresso-Intents records it is open question 5; if it doesn't, this row asserts the system settings screen with `SYSUI` instead |
 | Service | Tap the service notification | service notification body | `APP/SimplexService.kt:178-188` | `serviceNotification_tapOpensApp` | With the app backgrounded from the chat list, sending the content intent brings `MainActivity` back to the chat list (a plain `getActivity` intent, `APP/SimplexService.kt:179-181`, so `MainActivity` gets `onNewIntent` and is not recreated) | SYSNTF, BG | – |
@@ -121,17 +121,17 @@ Which items notify is shared logic (`notifyMessageReceived`, `C/platform/NtfMana
 |---|---|---|---|---|---|---|---|
 | Messages | Background message | app in background; bob `@alice hello` | `APP/model/NtfManager.android.kt:102-158` | `sysNtf_message_backgroundShowsTitleAndText` | One notification on channel "SimpleX Chat messages" (`chat.simplex.app.MESSAGE_NOTIFICATION`) with title "bob" and text "hello", in group `chat.simplex.app.MESSAGE_NOTIFICATION`, plus the group summary (id 0); auto-cancel set | P, BG, SYSNTF | Channels exist once `POST_NOTIFICATIONS` is granted (`NtfManager.android.kt:55-57,297-304`) |
 | Messages | Group message | app in background; bob `#team hi all` | `C/platform/NtfManager.kt:39-50` | `sysNtf_groupMessage_titleIsGroup` | Title "team", text "hi all" (no sender prefix) | P, BG, SYSNTF | bob creates the group and invites alice, who joins before going to the background |
-| Messages | Foreground: only other chats | app open on the chat with bob; bob and cath both send | `C/platform/NtfManager.kt:40-47`; `A/platform/Notifications.android.kt:3` | `sysNtf_foreground_onlyForChatsNotOpen` | No notification for bob's message (his chat is open); one for cath's | P ×2 (bob, cath), SYSNTF | – |
-| Messages | Tap opens the chat | send the notification's content intent | `APP/model/NtfManager.android.kt:127,270-286`; `APP/MainActivity.kt:121-130`; `C/platform/NtfManager.kt:70-83`; `C/views/chat/ChatView.kt:761-765` | `sysNtf_tapOpensChat` | `MainActivity` is recreated and opens the chat with bob showing "hello"; the notification is gone once "hello" is marked read (`ntfManager.cancelNotificationsForChat`; `contentIntent.send()` is not a user click, so auto-cancel does not apply) | P, BG, SYSNTF | Setup item 8 |
+| Messages | Foreground: only other chats | app open on the chat with bob; bob and cath both send | `C/platform/NtfManager.kt:40-47`; `A/platform/Notifications.android.kt:3` | `sysNtf_foreground_onlyForChatsNotOpen` | No notification for bob's message (his chat is open); one for cath's | P ×2 (bob, cath), SYSNTF | Android-only test class `SystemNotificationsAndroidTest`, run in the foreground with no `BG`. Also asserts the notification's group `chat.simplex.app.MESSAGE_NOTIFICATION`, auto-cancel flag and the group summary, and that muting cath cancels her shown notification (`ChatListNavLinkView.kt` `updateChatSettings`) |
+| Messages | Tap opens the chat | send the notification's content intent | `APP/model/NtfManager.android.kt:127,270-286`; `APP/MainActivity.kt:121-130`; `C/platform/NtfManager.kt:70-83`; `C/views/chat/ChatView.kt:761-765` | `sysNtf_tapOpensChat` | `MainActivity` is recreated and opens the chat with bob showing "hello"; the notification is gone once "hello" is marked read (`ntfManager.cancelNotificationsForChat`; `contentIntent.send()` is not a user click, so auto-cancel does not apply) | P, BG, SYSNTF | Setup item 8. Implemented in the foreground with the chat list open (no `BG`): a chat that is not open notifies there too, and `contentIntent.send()` recreates `MainActivity` the same way; the test finishes every `MainActivity` at its end (setup item 4) |
 | Messages | Summary tap shows the chat list | send the summary's content intent with a chat open | `APP/model/NtfManager.android.kt:142-149`; `C/platform/NtfManager.kt:85-97` | `sysNtf_summaryTapShowsChatList` | The open chat closes and the chat list shows | P, BG, SYSNTF | – |
-| Messages | Reading cancels the notification | open the chat from the chat list instead | `C/views/chat/ChatView.kt:760-790`; `APP/model/NtfManager.android.kt:75-86` | `sysNtf_openingChatCancelsItsNotification` | After the chat is opened and its items marked read, the chat's notification and the empty group summary are cancelled (asserted with a wait: the summary check counts `activeNotifications` right after the cancel, `NtfManager.android.kt:78-85`) | P, BG, SYSNTF | – |
+| Messages | Reading cancels the notification | open the chat from the chat list instead | `C/views/chat/ChatView.kt:760-790`; `APP/model/NtfManager.android.kt:75-86` |  | After the chat is opened and its items marked read, the chat's notification and the empty group summary are cancelled (asserted with a wait: the summary check counts `activeNotifications` right after the cancel, `NtfManager.android.kt:78-85`) | P, BG, SYSNTF | `sysNtf_openingChatCancelsItsNotification` merged into `sysNtf_foreground_onlyForChatsNotOpen` (the chat's own notification is asserted cancelled; the summary cancellation is not asserted, since `cancelNotificationsForChat` counts `activeNotifications` right after `cancel`, `NtfManager.android.kt:78-85`) |
 | Messages | Deleted last message | bob sends, then deletes it (`\ @alice hello`) while the notification is shown | `C/model/SimpleXAPI.kt:3078-3094` | `sysNtf_deletedMessageUpdatesNotification` | The notification is replaced by one with text "marked deleted" (or "deleted" with full deletion) | P, BG, SYSNTF | `hasNotificationsForChat` returns true only on Android (desktop always returns false, `D/model/NtfManager.desktop.kt:58`) (`NtfManager.android.kt:268`) |
 | Messages | Preview "Contact name" and "Hidden" | Settings > "Your privacy" > "Show preview" | `APP/model/NtfManager.android.kt:108-115` | `sysNtf_previewContactName`, `sysNtf_previewHidden` | Contact name: title "bob", text "new message"; Hidden: title "Contact hidden:", text "new message"; in both modes the notification has no large icon (`largeIcon` is set only for notifications with actions, i.e. contact requests, `NtfManager.android.kt:111-115`) | P, BG, SYSNTF | 04 `morePrivacy_notificationPreviewModes` tests the setting itself |
 | Messages | Secret text hidden | bob sends `#secret#` markdown | `C/platform/NtfManager.kt:134-150` | `sysNtf_secretMarkdownHidden` | Text "..." in place of the secret part | P, BG, SYSNTF | – |
-| Messages | Muted chat, muted profile | chat muted (row menu "Mute"); for the profile: a second profile active, the first muted in "Your chat profiles" (menu "Mute", `UserProfilesView.kt:237-241`) | `C/model/ChatModel.kt:1794-1801, 1381-1386`; `APP/model/NtfManager.android.kt:103` | `sysNtf_mutedChat_noNotification`, `sysNtf_mutedProfile_noNotification` | No notification for a muted chat; none for messages to the muted, inactive profile (the active profile always notifies, `showNotifications` is `activeUser` or `showNtfs`) | P, BG, SYSNTF | Muting UI is 01's |
+| Messages | Muted chat, muted profile | chat muted (row menu "Mute"); for the profile: a second profile active, the first muted in "Your chat profiles" (menu "Mute", `UserProfilesView.kt:237-241`) | `C/model/ChatModel.kt:1794-1801, 1381-1386`; `APP/model/NtfManager.android.kt:103` | `sysNtf_mutedProfile_noNotification` | No notification for a muted chat; none for messages to the muted, inactive profile (the active profile always notifies, `showNotifications` is `activeUser` or `showNtfs`) | P, BG, SYSNTF | Muting UI is 01's. `sysNtf_mutedChat_noNotification` merged into `sysNtf_foreground_onlyForChatsNotOpen` (a muted chat's message, with bob's later notification as the sentinel) |
 | Messages | Message to another profile | second profile active; bob messages the first | `C/platform/NtfManager.kt:70-83` | `sysNtf_otherProfile_tapSwitchesProfile` | The notification carries the first profile's `userId`; tapping it switches the active profile and opens bob's chat | P, BG, SYSNTF | – |
-| Requests | Contact request with "Accept" | alice has an address; bob `/c <address>` (bob: "connection request sent!") | `C/platform/NtfManager.kt:28-37,52-68`; `APP/model/NtfManager.android.kt:130-141,310-329` | `sysNtf_contactRequest_acceptAction` | Notification title "bob", text "New contact request", one action "Accept", and the app icon as the large icon (bob has no profile image, `APP/model/NtfManager.android.kt:111-115`); sending the action accepts: bob prints "alice: contact is connected" and the request notification is cancelled | P, BG, SYSNTF | The action goes through `NtfActionReceiver`, without opening the app |
-| Requests | Contact connected | alice's 1-time link; bob `/c <link>` (bob: "confirmation sent!") | `C/platform/NtfManager.kt:21-26` | `sysNtf_contactConnected` | Notification title "bob", text "Connected" | P, BG, SYSNTF | – |
+| Requests | Contact request with "Accept" | alice has an address; bob `/c <address>` (bob: "connection request sent!") | `C/platform/NtfManager.kt:28-37,52-68`; `APP/model/NtfManager.android.kt:130-141,310-329` | `sysNtf_contactRequest_acceptAction` | Notification title "bob", text "New contact request", one action "Accept", and the app icon as the large icon (bob has no profile image, `APP/model/NtfManager.android.kt:111-115`); sending the action accepts: bob prints "alice: contact is connected" and the request notification is cancelled | P, BG, SYSNTF | The action goes through `NtfActionReceiver`, without opening the app. Implemented in the foreground with the chat list open (no `BG`); `displayNotification` has no foreground check for requests |
+| Requests | Contact connected | alice's 1-time link; bob `/c <link>` (bob: "confirmation sent!") | `C/platform/NtfManager.kt:21-26` |  | Notification title "bob", text "Connected" | P, BG, SYSNTF | `sysNtf_contactConnected` merged into `sysNtf_contactRequest_acceptAction` (after Accept the request notification is replaced by bob's "Connected" one, `C/model/SimpleXAPI.kt` `CR.ContactConnected`) |
 | Permission | Denied: nothing posted | `POST_NOTIFICATIONS` denied | `APP/model/NtfManager.android.kt:151-157` | `sysNtf_permissionDenied_nothingPosted` | A background message posts no notification; the chat list's unread counter still updates | P, BG, PERM (POST_NOTIFICATIONS denied), SYSNTF | `canAskToEnableNotifications` is pre-set to false, as in §4 `notificationPermission_grantedLater_reenablesAsking`: after `pm clear` the chat list would otherwise launch the system permission dialog on first composition (`C/views/chatlist/ChatListView.kt:276-283`) |
 | Calls | Call invitation in background | app in background; bob `/call @alice` (bob: "ok") | `C/views/call/CallManager.kt:11-25`; `APP/model/NtfManager.android.kt:160-226` | `sysNtf_callInvitation_backgroundShowsAcceptReject` | Notification on channel "SimpleX Chat calls" (`chat.simplex.app.CALL_NOTIFICATION_2`), id -1, category call, title "bob", text "e2e encrypted video call", actions "Accept" and "Reject", insistent flag set; the in-app alert is composed in the background (`activeCallInvitation` is set, `C/App.kt:253-254`, `C/views/call/CallManager.kt:17-18`) but plays no ringtone (`sentNotification = true`, `C/views/call/IncomingCallAlertView.kt:30-34`) | P, BG, SYSNTF | `/call` sends the default type, a video call with encryption (02 `callAlert_incoming_acceptRejectIgnore`). Screen is on and unlocked, so the branch for an unlocked screen is used (`NtfManager.android.kt:176-190`; it still sets an empty full-screen intent, :183,188, which no assertion checks) |
 | Calls | Reject from the notification | send the "Reject" action | `APP/model/NtfManager.android.kt:317-322`; `C/views/call/CallManager.kt:96-110` | `sysNtf_callInvitation_rejectAction` | The call notification is cancelled; the chat with bob shows the item "rejected call"; bob prints nothing (rejection is local, `src/Simplex/Chat/Library/Commands.hs:1530-1541`) | P, BG, SYSNTF | – |
@@ -183,7 +183,7 @@ Carry-over note: on desktop `ClipboardManager.shareText` copies the text and sho
 
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification (GUI / CLI / intents) | Needs | Notes |
 |---|---|---|---|---|---|---|---|
-| Attach | Attachment sheet | chat with bob > attach (paperclip) | `A/views/helpers/ChooseAttachmentView.android.kt:13-30` | `attachSheet_androidShowsCameraImageVideoFile` | Four buttons: "Camera", "Image", "Video", "File" | P | Camera capture is §5 |
+| Attach | Attachment sheet | chat with bob > attach (paperclip) | `A/views/helpers/ChooseAttachmentView.android.kt:13-30` | | Four buttons: "Camera", "Image", "Video", "File" | P | `attachSheet_androidShowsCameraImageVideoFile` merged into `attachSheet_keyboardOpen_fullyExpanded`. Camera capture is §5 |
 | Attach | Attachment sheet above the keyboard | chat with bob; tap the message field so the soft keyboard opens, then attach (paperclip) | `C/views/chat/ChatView.kt:160,990-1000`; `C/views/helpers/ChooseAttachmentView.kt:18-37` | `attachSheet_keyboardOpen_fullyExpanded` | The sheet opens fully expanded (`skipHalfExpanded = true`): "Camera", "Image", "Video" and "File" are displayed and their bounds end above the keyboard's top edge (`WindowInsets.ime`) | P, IME, VIEW | Regression guard for PR #7570: the sheet has `imePadding()`, so with the keyboard open it is taller than half the screen and used to stop half-expanded with the buttons under the keyboard |
 | Attach | Several images from the gallery | "Image" | `A/views/chat/ComposeView.android.kt:40,58-65`; `A/views/helpers/GetImageView.android.kt:218-242` | `attachGallery_twoImages_sendsEach` | Fires `ACTION_PICK` with type `image/*` and no data (`setType` clears the `INTERNAL_CONTENT_URI` given to the constructor, SDK `Intent.java:10294-10297`), `EXTRA_ALLOW_MULTIPLE`; the stub returns two URIs in `ClipData`; two image previews; sending → bob prints `alice> sends file IMG_….jpg (…)` twice | P, XFTP, INTENTS | – |
 | Attach | More than 10 images | "Image", stub returns 11 | `A/views/helpers/GetImageView.android.kt:229-237` | `attachGallery_elevenImages_alertKeepsTen` | Alert "Too many images!" / "Only 10 images can be sent at the same time"; ten previews | P, INTENTS | – |
@@ -211,19 +211,19 @@ Carry-over note: on desktop `ClipboardManager.shareText` copies the text and sho
 |---|---|---|---|---|---|---|---|
 | Text | Share text to a contact | `ACTION_SEND`, `text/plain`, `EXTRA_TEXT` "hello from share" | `APP/MainActivity.kt:164-174`; `C/views/chatlist/ShareListView.kt:145-155` | `shareIn_text_toContact` | The share list titled "Share message…" lists the chats; tapping bob opens his chat with "hello from share" in the message field; sending → `bob <# "alice> hello from share"` | INTENT, P, VIEW | – |
 | Media | One image | `ACTION_SEND`, `image/jpeg`, `EXTRA_STREAM` | `APP/MainActivity.kt:176-181` | `shareIn_image_toContact` | Title "Share media…"; in bob's chat an image preview; sending → `bob <# "alice> sends file IMG_….jpg (…)"` | INTENT, P, XFTP | – |
-| Media | Several images | `ACTION_SEND_MULTIPLE`, `image/*`, two URIs | `APP/MainActivity.kt:192-204` | `shareIn_multipleImages_toContact` | Two image previews; sending → two "sends file" lines on bob | INTENT, P, XFTP | – |
+| Media | Several images | `ACTION_SEND_MULTIPLE`, `image/*`, two URIs | `APP/MainActivity.kt:192-204` |  | Two image previews; sending → two "sends file" lines on bob | INTENT, P, XFTP | `shareIn_multipleImages_toContact` merged into `shareIn_image_toContact` (one image with `ACTION_SEND`, then two with `ACTION_SEND_MULTIPLE`, same peer) |
 | Media | Video | `ACTION_SEND`, `video/mp4` | `APP/MainActivity.kt:176-181,211-212` | `shareIn_video_toContact` | "Share media…"; a video preview; sending → `alice> sends file …mp4 (…)` on bob | INTENT, P, XFTP, AV | – |
-| File | Any other file | `ACTION_SEND`, `application/pdf`, `EXTRA_STREAM` | `APP/MainActivity.kt:183-189` | `shareIn_file_toContact` | Title "Share file…"; a file preview "test.pdf"; sending → `bob <# "alice> sends file test.pdf (266.0 KiB / 272376 bytes)"` | INTENT, P, XFTP | – |
+| File | Any other file | `ACTION_SEND`, `application/pdf`, `EXTRA_STREAM` | `APP/MainActivity.kt:183-189` | `shareIn_file_toContact` | Title "Share file…"; a file preview "test.pdf"; sending → `bob <# "alice> sends file test.pdf (266.0 KiB / 272376 bytes)"` | INTENT, P, XFTP | Implemented with a small `share-notes.pdf` text file from the exchange dir plus `EXTRA_TEXT`: bob gets the caption, the file offer `(N bytes / N bytes)` and receives the file |
 | File | Text file with a stream | `ACTION_SEND`, `text/plain`, `EXTRA_STREAM` (a `.log`) and `EXTRA_TEXT` | `APP/MainActivity.kt:164-171` | `shareIn_textWithStream_sharedAsFileWithText` | "Share file…"; the compose area has the file and the text; sending → bob gets the text and `sends file …log` | INTENT, P, XFTP, VIEW | – |
-| Errors | Non-`content:` stream | `ACTION_SEND`, `image/jpeg`, `EXTRA_STREAM` = `file:///sdcard/x.jpg` | `APP/MainActivity.kt:179`; `C/views/helpers/Utils.kt:528-533` | `shareIn_fileSchemeUri_invalidPathAlert` | Alert "Invalid file path" / "You shared an invalid file path. Report the issue to the app developers."; no share list | INTENT | – |
-| Errors | Multiple non-media files | `ACTION_SEND_MULTIPLE`, `application/pdf` | `APP/MainActivity.kt:192-207` | `shareIn_sendMultipleNonMedia_onlyClosesChat` | The open chat and modals close, but no share list appears (only image and video lists are handled) | INTENT, P | The manifest declares `SEND_MULTIPLE` only for `image/*`; the explicit intent bypasses the filter (Needs table) |
-| Navigation | Share while a chat and a modal are open | chat with bob open, Settings open; deliver `ACTION_SEND` | `APP/MainActivity.kt:160-162`; `C/App.kt:111-116` | `shareIn_closesOpenChatAndModals` | Settings and the chat close and the share list shows | INTENT, P | – |
-| Prefs | File to a group with files off | group "team" where bob ran `/set files #team off`; share a file | `C/views/chatlist/ShareListNavLinkView.kt:43-75` | `shareIn_fileToGroupWithFilesOff_alert` | The "team" row is greyed; tapping it shows "Cannot send message" / "Selected chat preferences prohibit this message."; bob's direct chat is still selectable | INTENT, P | – |
-| Prefs | SimpleX link to a group with links off | `/set links #team off`; share text containing bob's 1-time link | `C/views/chatlist/ShareListView.kt:34-35,81-85`; `ShareListNavLinkView.kt:44-55` | `shareIn_simplexLinkToGroupWithLinksOff_alert` | Same alert for "team" | INTENT, P | – |
-| Navigation | Toolbar back | the back arrow in the share list (one profile) | `C/views/chatlist/ShareListView.kt:128-140` | `shareIn_toolbarBack_dropsSharedContent` | The chat list returns; opening bob's chat shows an empty message field | INTENT, P, VIEW | – |
+| Errors | Non-`content:` stream | `ACTION_SEND`, `image/jpeg`, `EXTRA_STREAM` = `file:///sdcard/x.jpg` | `APP/MainActivity.kt:179`; `C/views/helpers/Utils.kt:528-533` | `shareIn_fileSchemeUri_invalidPathAlert` | Alert "Invalid file path" / "You shared an invalid file path. Report the issue to the app developers."; no share list | INTENT | Implemented for all four `showWrongUriAlert` sites (`APP/MainActivity.kt:168,179,186,201`): `image/jpeg`, `SEND_MULTIPLE` with one `content:` and one `file:` URI, `text/plain` with a stream, `application/pdf`; Private notes stands in for the open chat |
+| Errors | Multiple non-media files | `ACTION_SEND_MULTIPLE`, `application/pdf` | `APP/MainActivity.kt:192-207` | `shareIn_sendMultipleNonMedia_onlyClosesChat` | The open chat and modals close, but no share list appears (only image and video lists are handled) | INTENT, P | The manifest declares `SEND_MULTIPLE` only for `image/*`; the explicit intent bypasses the filter (Needs table). Private notes stands in for bob's chat (no peer needed) |
+| Navigation | Share while a chat and a modal are open | chat with bob open, Settings open; deliver `ACTION_SEND` | `APP/MainActivity.kt:160-162`; `C/App.kt:111-116` |  | Settings and the chat close and the share list shows | INTENT, P | `shareIn_closesOpenChatAndModals` merged into `shareIn_text_toContact` (bob's chat with his contact info open when the share arrives) |
+| Prefs | File to a group with files off | group "team" where bob ran `/set files #team off`; share a file | `C/views/chatlist/ShareListNavLinkView.kt:43-75` | `shareIn_fileToGroupWithFilesOff_alert` | The "team" row is greyed; tapping it shows "Cannot send message" / "Selected chat preferences prohibit this message."; bob's direct chat is still selectable | INTENT, P | Implemented with two empty groups alice owns, created through the API with the preference off (precondition): `nofiles` (files off) and `nolinks` (SimpleX links off); each is the other's selectable control, in place of bob's direct chat |
+| Prefs | SimpleX link to a group with links off | `/set links #team off`; share text containing bob's 1-time link | `C/views/chatlist/ShareListView.kt:34-35,81-85`; `ShareListNavLinkView.kt:44-55` |  | Same alert for "team" | INTENT, P | `shareIn_simplexLinkToGroupWithLinksOff_alert` merged into `shareIn_fileToGroupWithFilesOff_alert` (each group is the other's selectable control) |
+| Navigation | Toolbar back | the back arrow in the share list (one profile) | `C/views/chatlist/ShareListView.kt:128-140` |  | The chat list returns; opening bob's chat shows an empty message field | INTENT, P, VIEW | `shareIn_toolbarBack_dropsSharedContent` merged into `shareIn_chatStopped_showsStoppedIcon` (its running-chat half leaves the share list with the toolbar back arrow). The empty-message-field check is replaced by `sharedContent` being null, since the share list is shown exactly while it is set (`C/App.kt:376-384`) |
 | Navigation | System Back | Back key in the share list | `APP/MainActivity.kt:91-118` | `shareIn_systemBack_dropsContentAndFinishes` | No `BackHandler` is active, so `onBackPressed` drops the shared content and finishes the activity (API 33); relaunching shows the chat list | INTENT, BACK | – |
 | Profiles | Choose the profile before the chat | two profiles; the toolbar profile button | `C/views/chatlist/ShareListView.kt:105-127` | `shareIn_switchProfileBeforeChoosingChat` | With more than one visible profile the toolbar shows the profile image; it opens the profile picker; choosing the second profile lists its chats; sharing to its contact cath reaches cath | INTENT, P ×2 (bob, cath) | bob is the first profile's contact, cath the second's |
-| State | Chat stopped | stop the chat, then share | `C/views/chatlist/ShareListView.kt:170-185` | `shareIn_chatStopped_showsStoppedIcon` | The share list toolbar shows the red "Chat is stopped" icon; tapping it shows "You can start chat via app Settings / Database or by restarting the app." | INTENT | – |
+| State | Chat stopped | stop the chat, then share | `C/views/chatlist/ShareListView.kt:170-185` | `shareIn_chatStopped_showsStoppedIcon` | The share list toolbar shows the red "Chat is stopped" icon; tapping it shows "You can start chat via app Settings / Database or by restarting the app." | INTENT | Also asserts the rows are not tappable while stopped (no click action, `ShareListNavLinkView.kt:89`) and are while running; the chat is stopped through Chat data > Database passphrase & export |
 
 ### 8. Opening links from other apps (8 tests)
 
@@ -237,8 +237,8 @@ Carry-over note: on desktop `ClipboardManager.shareText` copies the text and sho
 | Links | No data | `ACTION_VIEW` without data | `APP/MainActivity.kt:151` | `appLink_noData_showsInvalidLinkAlert` | Alert "Invalid link" / "Please check that SimpleX link is correct." | INTENT | – |
 | Links | Before onboarding is complete | deliver bob's short 1-time link (as `appLink_oneTimeLink_opensPlan`) on the welcome screen, then finish onboarding | `C/App.kt:243-251`; `C/views/chatlist/ChatListView.kt:777-778` | `appLink_beforeOnboarding_openedAfterCompletion` | Nothing happens during onboarding; after "Accept" on the conditions screen the plan alert with bob's profile and "Open new chat" opens | INTENT, ONBOARD, P | Onboarding then calls `useLocalServers()` before the plan connects (01 setup item 3) |
 | Links | While locked | SimpleX Lock (passcode) on, app backgrounded past the delay; deliver the link | `C/App.kt:210-251` | `appLink_whileLocked_openedAfterUnlock` | The passcode screen shows first; after the correct passcode the plan alert with bob's profile and "Open new chat" opens | INTENT, P, BG | Lock set up as 04 `lock_enable_setsPasscode` |
-| Links | While the chat is stopped | stop the chat, deliver the link, start the chat | `C/App.kt:243-249` | `appLink_whileChatStopped_openedAfterStart` | No alert while stopped; after starting the chat (Chat data) the plan alert with bob's profile and "Open new chat" opens | INTENT, P | – |
-| Manifest | Which links open the app | resolve implicit `ACTION_VIEW` intents with `PackageManager.queryIntentActivities` | `MAN:68-119` | `appLink_intentFilter_matchesOnlyConnectionPaths` | `simplex:/…`, `https://simplex.chat/contact#…`, `/invitation#…`, `/a#…`, `/c#…`, `/g#…`, `/i#…` and the `smp*.simplex.im` / `smp*.simplexonflux.com` hosts resolve to `MainActivity`; `https://simplex.chat/crowdfunding/`, `https://simplex.chat/blog/` and `https://localhost/a#…` don't | — | Path filters are exact or `/x/` prefixes (`MAN:107-118`). Verified-link (autoVerify) state is not asserted; the query uses flags 0 and an intent with no categories, because on Android 12+ a `BROWSABLE`+`DEFAULT` or `MATCH_DEFAULT_ONLY` web-intent query is filtered by domain verification, which fails offline for the debug APK |
+| Links | While the chat is stopped | stop the chat, deliver the link, start the chat | `C/App.kt:243-249` | `appLink_whileChatStopped_openedAfterStart` | No alert while stopped; after starting the chat (Chat data) the plan alert with bob's profile and "Open new chat" opens | INTENT, P | The chat is stopped and started in Chat data > Database passphrase & export; the test stops at the prepared chat (the connection itself is `appLink_oneTimeLink_opensPlan`) |
+| Manifest | Which links open the app | resolve implicit `ACTION_VIEW` intents with `PackageManager.queryIntentActivities` | `MAN:68-119` | `appLink_intentFilter_matchesOnlyConnectionPaths` | `simplex:/…`, `https://simplex.chat/contact#…`, `/invitation#…`, `/a#…`, `/c#…`, `/g#…`, `/i#…` and the `smp*.simplex.im` / `smp*.simplexonflux.com` hosts resolve to `MainActivity`; `https://simplex.chat/crowdfunding/`, `https://simplex.chat/blog/` and `https://localhost/a#…` don't | — | Path filters are exact or `/x/` prefixes (`MAN:107-118`). Verified-link (autoVerify) state is not asserted; the query uses flags 0 and an intent with no categories, because on Android 12+ a `BROWSABLE`+`DEFAULT` or `MATCH_DEFAULT_ONLY` web-intent query is filtered by domain verification, which fails offline for the debug APK. `simplexchat:/…` (the app-link scheme, `MAN:77-84`) is also asserted to resolve |
 
 ### 9. Calls on Android (19 tests, 6 ignored)
 
@@ -296,10 +296,10 @@ On Android a new database gets a random passphrase that is stored encrypted with
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification (GUI / prefs) | Needs | Notes |
 |---|---|---|---|---|---|---|---|
 | Keystore | Fresh database | Settings > "Chat data" > "Database passphrase & export" > "Database passphrase" | `A/views/database/DatabaseEncryptionView.android.kt:21-83`; `C/views/database/DatabaseEncryptionView.kt:120-143` | `keystore_freshDb_randomPassphraseFooter` | The switch "Save passphrase in Keystore" is on and disabled (random passphrase); footers "Android Keystore (<storage>) is used to securely store passphrase - it allows notification service to work." and "Database is encrypted using a random passphrase, you can change it."; `<storage>` is the value of `cryptor.keyStorage(…)` ("Secure element", "TEE" or "Software", `A/platform/Cryptor.android.kt:74-90`) | — | The test compares the storage label with `DatabaseUtils.ksDatabasePassword.storage()` rather than a fixed value |
-| Keystore | Set a passphrase while stored | "New passphrase…", "Confirm new passphrase…", "Update database passphrase" | `A/views/database/DatabaseEncryptionView.android.kt:95-103` | `keystore_changePassphrase_storedAlert` | Alert "Change database passphrase?" / "Database encryption passphrase will be updated and stored in the Keystore." + "Please store passphrase securely, you will NOT be able to change it if you lose it." / "Update"; afterwards the random-passphrase footer is replaced by "Please note: you will NOT be able to recover or change passphrase if you lose it." and the switch is enabled | — | Desktop wording: 04 `dbEncrypt_setFirstPassphrase` |
+| Keystore | Set a passphrase while stored | "New passphrase…", "Confirm new passphrase…", "Update database passphrase" | `A/views/database/DatabaseEncryptionView.android.kt:95-103` | | Alert "Change database passphrase?" / "Database encryption passphrase will be updated and stored in the Keystore." + "Please store passphrase securely, you will NOT be able to change it if you lose it." / "Update"; afterwards the random-passphrase footer is replaced by "Please note: you will NOT be able to recover or change passphrase if you lose it." and the switch is enabled | — | `keystore_changePassphrase_storedAlert` merged into `keystore_freshDb_randomPassphraseFooter`. Desktop wording: 04 `dbEncrypt_setFirstPassphrase` |
 | Keystore | Remove from the Keystore | switch off after a passphrase is set | `C/views/database/DatabaseEncryptionView.kt:131-139`; `A/views/database/DatabaseEncryptionView.android.kt:105-113` | `keystore_removePassphrase_alertAndFooter` | Alert "Remove passphrase from Keystore?" / "Notifications will be delivered only until the app stops!" + "Please store passphrase securely, you will NOT be able to access chat if you lose it." / "Remove"; then footers "You have to enter passphrase every time the app starts - it is not stored on the device." and the "Please note" line; prefs `storeDBPassphrase = false`, `DatabaseUtils.ksDatabasePassword.get()` is null | — | – |
 | Keystore | Restart asks for the passphrase | after removal, `restart()` | `C/views/database/DatabaseErrorView.kt:220-235,295-312` | `keystore_removed_restartAsksPassphrase` | The start screen asks for the passphrase; "Open chat" with the right one shows the chat list | RESTART | 04 `dbError_enterPassphraseOnStartup_open` owns the screen; this row checks the Android path into it |
-| Keystore | Done key submits | same screen, the keyboard's Done key | `C/views/database/DatabaseErrorView.kt:295-312` | `keystore_passphrasePrompt_imeDoneSubmits` | With the passphrase typed, the soft keyboard's Done action opens the chat (`KeyboardActions(onDone)` is set only on Android) | RESTART, IME | – |
+| Keystore | Done key submits | same screen, the keyboard's Done key | `C/views/database/DatabaseErrorView.kt:295-312` | | With the passphrase typed, the soft keyboard's Done action opens the chat (`KeyboardActions(onDone)` is set only on Android) | RESTART, IME | `keystore_passphrasePrompt_imeDoneSubmits` merged into `keystore_keyMissing_showsNotFoundAlert` |
 | Keystore | Store it again | switch on with the passphrase not stored | `C/views/database/DatabaseEncryptionView.kt:131-133,293-299`; `A/views/database/DatabaseEncryptionView.android.kt:76-78` | `keystore_reEnable_footerUntilRestart` | Pref `storeDBPassphrase = true` at once; footer "Android Keystore will be used to securely store passphrase after you restart the app or change passphrase - it will allow receiving notifications." | — | – |
 | Keystore | Key missing from the Keystore | delete the Keystore entry of the database passphrase in-process, then `restart()` | `A/platform/Cryptor.android.kt:23-35` | `keystore_keyMissing_showsNotFoundAlert` | Alert "Wrong database passphrase" / "Passphrase not found in Keystore, please enter it manually. This may have happened if you restored the app's data using a backup tool. If it's not the case, please contact developers."; the passphrase prompt follows | RESTART | The entry's alias is "databasePassword" (`C/views/helpers/DatabaseUtils.kt:13`); the alert is shown once per process (`warningShown`). A failing decryption (not a missing key) gives "Error reading database passphrase" instead and is not tested |
 | Keystore | Lock passcodes in the Keystore | set the lock passcode and a self-destruct passcode; inspect prefs | `C/views/helpers/DatabaseUtils.kt:15-19` | `keystore_lockPasscodesStoredEncrypted` | `EncryptedAppPassphrase` / `EncryptedSelfDestructPassphrase` prefs hold Keystore-encrypted bytes that do not decode to the digits (desktop stores Base64 of the plain value, 04 harness fact 3); `ksAppPassword.get()` returns the digits | — | Lock set up as 04 §C |
@@ -320,9 +320,9 @@ This is the other side of 04 §K: the Android app is the mobile host and a curre
 | Entry | User picker row | user picker | `C/views/chatlist/UserPicker.kt:352-368` | `useFromDesktop_pickerRowOpensConnectScreen` | The row "Use from desktop" (desktop shows "Link a mobile" here) opens "Connect to desktop"; disabled when the chat is stopped | — | – |
 | Layout | Without developer tools | "Connect to desktop" | `C/views/remote/ConnectDesktopView.kt:127-144,351-370` | `useFromDesktop_layoutWithoutDevTools` | "This device name" field (Pref `deviceNameForRemoteAccess`) and "Scan QR code from desktop" with the camera section; no "Desktop address" section and no "Linked desktops" row (none stored) | PERM (CAMERA granted) | – |
 | Layout | Paste field | developer tools on | `C/views/remote/ConnectDesktopView.kt:372-413` | `useFromDesktop_pasteFieldStates` | "Desktop address" with "Paste desktop address" (disabled while the clipboard is empty) and "Connect to desktop" (disabled until an address is set); pasting shows the address in an editable field | CB, DT | The clipboard is the system one, which keeps its clip across tests; it is empty here because the reset clears it (setup item 4, R13); "Paste desktop address" reads the clipboard once when the screen is drawn (`disabled = !clipboard.hasText()`, `C/views/remote/ConnectDesktopView.kt:380`), so the clip is set before the screen is opened (reopen "Connect to desktop" after changing it) |
-| Pairing | Connect and verify | paste the invitation > "Connect to desktop" | `C/views/remote/ConnectDesktopView.kt:146-171,259-286,501-537`; `C/model/SimpleXAPI.kt:3499-3507` | `useFromDesktop_pasteVerifyConfirm_connected` | "Connecting to desktop" with "My desktop (new)" and the version, then "Verify connection": section "Connected to desktop", "Verify code with desktop" showing the first 23 characters of the controller's code, "Confirm", "Disconnect"; "Confirm" → title "Connected to desktop", section "Connected desktop" "My desktop", "Session code", "Disconnect"; the controller prints the step 3 lines | P (controller), CB, DT | The session code comparison is the test's own check: GUI text = controller code `.take(23)` |
+| Pairing | Connect and verify | paste the invitation > "Connect to desktop" | `C/views/remote/ConnectDesktopView.kt:146-171,259-286,501-537`; `C/model/SimpleXAPI.kt:3499-3507` | `useFromDesktop_pasteVerifyConfirm_connected` | "Connecting to desktop" with "My desktop (new)" and the version, then "Verify connection": section "Connected to desktop", "Verify code with desktop" showing the first 23 characters of the controller's code, "Confirm", "Disconnect"; "Confirm" → title "Connected to desktop", section "Connected desktop" "My desktop", "Session code", "Disconnect"; the controller prints the step 3 lines | P (controller), CB, DT | The session code comparison is the test's own check: GUI text = controller code `.take(23)`. Written (`UseFromDesktopAndroidTest`): the controller is a bridge CLI peer that listens on 127.0.0.1 at port base + 90, which the runner forwards to the device with `adb reverse` (`Bridge.remoteCtrlPort()`, `startRemoteHost(port)` sends `addr=127.0.0.1 iface="lo"`), instead of step 1's Waydroid bridge address, so it works on any adb device; the host name the controller prints is the "This device name" field's value; the test ends the session through the API (`endDesktopSessionViaApi`) |
 | Pairing | Device name reaches the controller | set "This device name" to "Android test" before pairing | `C/views/remote/ConnectDesktopView.kt:130-137,458-463` | `useFromDesktop_deviceNameShownToController` | The controller prints `new remote host 1 added: Android test`; Pref `deviceNameForRemoteAccess = "Android test"` | P (controller), CB, DT | – |
-| Use | Controller drives the Android core | after pairing, controller `/switch remote host 1`, `/contacts`, `@bob hi from desktop` | `src/Simplex/Chat/Remote.hs` | `useFromDesktop_controllerSendsAsAndroidUser` | Controller prints `Using remote host 1 (<name>)` and `bob` for `/contacts`; bob receives `alice> hi from desktop`; Android's chat with bob has the sent item | P ×2 (controller, bob), CB, DT | As `remoteMessageTest` (`tests/RemoteTests.hs:260-280`) |
+| Use | Controller drives the Android core | after pairing, controller `/switch remote host 1`, `/contacts`, `@bob hi from desktop` | `src/Simplex/Chat/Remote.hs` | `useFromDesktop_controllerSendsAsAndroidUser` | Controller prints `Using remote host 1 (<name>)` and `bob` for `/contacts`; bob receives `alice> hi from desktop`; Android's chat with bob has the sent item | P ×2 (controller, bob), CB, DT | As `remoteMessageTest` (`tests/RemoteTests.hs:260-280`). Written (`UseFromDesktopAndroidTest`): a new session already makes the host the controller's current one (`src/Simplex/Chat/Remote.hs:216`), so the test sends no `/switch remote host 1` and does not check `Using remote host 1`; it ends the session through the API, closes "Connect to desktop" with Back and checks the sent item in alice's chat with bob |
 | Stop | Disconnect from Android | "Disconnect" on "Connected to desktop" | `C/views/remote/ConnectDesktopView.kt:335-337,551-561`; `C/views/chatlist/UserPicker.kt:361-363`; `C/model/SimpleXAPI.kt:3622-3629` | `useFromDesktop_disconnectFromAndroid` | The controller prints `remote host 1 stopped`; "Connect to desktop" closes (this Disconnect also calls the modal's `close`) and the chat list shows Android's own chats (`switchToLocalSession`) | P (controller), CB, DT | – |
 | Stop | Close while connected | Back (or the close button) on "Connected to desktop" | `C/views/remote/ConnectDesktopView.kt:47-56,581-589` | `useFromDesktop_closeWhileConnected_asksToDisconnect` | Alert "Disconnect desktop?" / "Only one device can work at the same time" / "Disconnect"; confirming stops the session and closes the screen | P (controller), CB, DT, BACK | – |
 | Stop | Controller stops | controller `/stop remote host 1` | `C/model/SimpleXAPI.kt:3508-3530` | `useFromDesktop_controllerStops_noAlert` | Android leaves the session without an alert (reason `Disconnected`) and shows "Connect to desktop" | P (controller), CB, DT | – |
@@ -360,7 +360,7 @@ This is the other side of 04 §K: the Android app is the mobile host and a curre
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification (GUI / prefs) | Needs | Notes |
 |---|---|---|---|---|---|---|---|
 | Layout | One pane | open bob's chat from the chat list | `C/App.kt:313-360` | `layout_onePane_chatReplacesList` | The chat slides over the list: while it is open no chat-list row is displayed; desktop shows both side by side (`C/App.kt:429`, `DesktopScreen`) | P | Carried-over 01/02 rows navigate through screen objects (setup item 6) |
-| Layout | Reachable toolbars by default | fresh profile | `C/model/SimpleXAPI.kt:275-276`; `C/views/chatlist/ChatListView.kt:569-605` | `layout_reachableToolbarsDefault_bottomBars` | With the defaults (`oneHandUI = chatBottomBar = true`) the chat-list search field and toolbar and the chat's app bar are at the bottom of the screen (their bounds' top is in the lower half) | P | – |
+| Layout | Reachable toolbars by default | fresh profile | `C/model/SimpleXAPI.kt:275-276`; `C/views/chatlist/ChatListView.kt:569-605` | | With the defaults (`oneHandUI = chatBottomBar = true`) the chat-list search field and toolbar and the chat's app bar are at the bottom of the screen (their bounds' top is in the lower half) | P | `layout_reachableToolbarsDefault_bottomBars` merged into `appearanceAndroid_interfaceSectionToolbars` |
 | Appearance | Interface section | Settings > "Appearance" | `A/views/usersettings/Appearance.android.kt:72-122` | `appearanceAndroid_interfaceSectionToolbars` | "Reachable app toolbars" on; "Reachable chat toolbar" shown only while it is on; turning app toolbars off moves the bars to the top; turning it on again also sets `chatBottomBar = true` | — | Desktop: 04 `appearance_reachableAppToolbars`; replaces 04 `appearance_reachableChatToolbarVisibility` on Android |
 | Appearance | Language recreates the activity | "Language" > "Deutsch", then "System" | `A/views/usersettings/Appearance.android.kt:89-104`; `A/helpers/Locale.kt:10-36` | `appearanceAndroid_languageRecreatesActivity` | After about 200 ms the activity is recreated and the whole UI is German at once (Settings title "Einstellungen"); "System" restores English; Pref `appLanguage = "de"`, then `= null` | — | Desktop changes the pref and re-reads strings (04 `appearance_language_switch`) |
 | Appearance | App icon | "App icon" section, the dark-blue icon | `A/views/usersettings/Appearance.android.kt:40-63,130-152,161-165`; `MAN:133-155` | `appearanceAndroid_appIconSwitchesLauncherAlias` | The dark-blue icon gets the border; `PackageManager` reports `.MainActivity_dark_blue` enabled and `.MainActivity_default` disabled; choosing the default icon reverses it | — | Restored at the end of the test; component names use the `chat.simplex.app` namespace with the debug application id |
@@ -378,7 +378,7 @@ This is the other side of 04 §K: the Android app is the mobile host and a curre
 | Compose | Clear-text button for wrapped text | type one paragraph without line breaks that wraps to four or more lines of the message field | `A/platform/PlatformTextField.android.kt:196`; `C/views/chat/SendMsgView.kt:314-322` | `compose_editText_clearButtonForWrappedParagraph` | The clear-text (x) button appears once the `EditText` shows four lines (`lineCount >= 4`), although the text has no "\n"; it is absent at three lines; tapping it clears the field | P, VIEW | Desktop counts "\n"-separated lines (`D/platform/PlatformTextField.desktop.kt:204`), so a wrapped paragraph shows no (x) there; typed line breaks are 02 `compose_clearTextButton_clears` |
 | Compose | Keyboard for reply and edit | "Reply" / "Edit" on an item | `A/platform/PlatformTextField.android.kt:75-84,185-190` | `compose_replyAndEdit_showKeyboard` | The field gets focus and the soft keyboard opens (100 ms after "Reply", 300 ms after "Edit") | P, IME, VIEW | – |
 | Compose | Enter inserts a line break | chat with bob; type "hello", press Enter, type "there", tap the send button | `A/platform/PlatformTextField.android.kt:60-63,99-132`; `C/views/chat/SendMsgView.kt:177,452-490` | `compose_enterKeyInsertsNewline_sendButtonSends` | After Enter the field holds "hello" and a line break and bob prints nothing; the send button ("Send Message") then sends both lines: `bob <# "alice> hello"`, `bob <## "there"` | P, IME, VIEW | The multi-line `EditText` (`maxLines = 16`) has no key listener and never calls `onDone`, `onUpArrow` or `onFilesPasted`; desktop sends on Enter and inserts the line break on Shift+Enter (`D/platform/PlatformTextField.desktop.kt:123-137`). Replaces 02 `multiline_shiftEnter_peerReceivesTwoLines` on Android (`05-android-carryover.md`) |
-| Compose | Field above the keyboard | focus the message field | `MAN:61`; `C/views/chat/ComposeView.kt` | `layout_composeStaysAboveKeyboard` | With the keyboard open the compose area's bottom is above the keyboard (`adjustResize` + IME insets) and the last message stays visible | P, IME, VIEW | – |
+| Compose | Field above the keyboard | focus the message field | `MAN:61`; `C/views/chat/ComposeView.kt` | | With the keyboard open the compose area's bottom is above the keyboard (`adjustResize` + IME insets) and the last message stays visible | P, IME, VIEW | `layout_composeStaysAboveKeyboard` merged into `compose_replyAndEdit_showKeyboard` |
 | Compose | Connect progress strip in a chat | bob sends his 1-time short link (`@alice <link>`); SMP traffic then goes through a SOCKS stub that accepts the CONNECT and never answers; alice taps the link in bob's chat | `C/views/newchat/ConnectPlan.kt:48-53,77-79`; `C/model/ChatModel.kt:48-77`; `C/views/chat/ChatView.kt:61-91,168-185,303-305` | `connectProgress_inChatStripAndCancel` | After 1 s a strip above the message field shows a progress indicator, "Loading profile…" and the close icon "Cancel"; tapping the icon removes the strip, and no plan alert or connection-error alert follows when the plan's command fails at the proxy's connect timeout; tapping the link again and pressing Back cancels the plan as the chat closes (Android only, `ChatView.kt:168-174`): the chat list's toolbar shows no progress indicator (`C/views/chatlist/ChatListView.kt:561-567`) | P, SOCKS (stub holds the CONNECT unanswered), BACK, SLOW | Desktop shows only the toolbar indicator (01 `planProgressIndicatorAndCancel`). The stub runs in the instrumentation process; SOCKS is set through the network config before the tap (04 §E owns the UI), which switches the timeouts to `NetCfg.proxyDefaults` (30 s interactive connect timeout, `C/model/SimpleXAPI.kt:5263-5271`) |
 | Compose | Custom disappearing time | long-press send > "Disappearing message" > "Custom time" | `C/views/chat/SendMsgView.kt:296-311`; `A/views/helpers/CustomTimePicker.android.kt:15-105` | `timedCustom_androidWheelPickerSetsTtl` | "Delete after" shows two wheels (number and unit); scrolling them to "2" and "minutes" and "Send" sends the message with a 120 s TTL | P | Desktop picker: 02 `timed_customTime_sendsWithChosenTtl` |
 | User picker | Bottom sheet | tap the profile image | `A/views/chatlist/UserPicker.android.kt:127-201`; `C/views/chatlist/UserPicker.kt:195-215,300-330` | `userPickerAndroid_bottomSheetLayoutAndDismiss` | A bottom sheet with the profiles row, the address row, "Chat preferences", "Your chat profiles", "Use from desktop" and "Settings" with the colour-mode switch; swiping it down or tapping the dimmed area closes it | — | – |
@@ -392,10 +392,10 @@ This is the other side of 04 §K: the Android app is the mobile host and a curre
 | Area | Feature | Entry path | Main file:line | Test case(s) | Verification (GUI / system) | Needs | Notes |
 |---|---|---|---|---|---|---|---|
 | Settings | Root items | Settings | `US/SettingsView.kt:80-149`; `A/views/usersettings/SettingsView.android.kt:31-34` | `settingsAndroid_rootListsAndroidItems` | "Your settings": "Appearance", "Your privacy", "Help & support", "Chat data", "Migrate to another device"; "Supporter perks"; under "Advanced settings": "Network & servers", "Notifications", "Audio & video calls", "Shutdown", and the version row "<ANDROID_VERSION_NAME> (<ANDROID_VERSION_CODE>)"; "Crowdfunding on Wefunder" (foss build) | — | Desktop list: 04 `settingsRoot_listsDesktopItems` |
-| Settings | Shutdown alert | "Shutdown" | `A/views/usersettings/SettingsView.android.kt:31-71` | `settingsAndroid_shutdownAlertCancel` | Alert "Shutdown?" / "Notifications will stop working until you re-launch the app" with "Cancel", "Restart" and "Shutdown" (red); "Cancel" closes it and nothing else happens | — | – |
+| Settings | Shutdown alert | "Shutdown" | `A/views/usersettings/SettingsView.android.kt:31-71` | | Alert "Shutdown?" / "Notifications will stop working until you re-launch the app" with "Cancel", "Restart" and "Shutdown" (red); "Cancel" closes it and nothing else happens | — | `settingsAndroid_shutdownAlertCancel` merged into `settingsAndroid_rootListsAndroidItems` |
 | Settings | Shutdown and Restart | "Shutdown" / "Restart" in that alert | `A/views/usersettings/SettingsView.android.kt:36-45` | `settingsAndroid_shutdownAndRestartEndProcess` | – | IGNORE: the action ends the app process, which is the instrumentation process | `WorkManager` work is cancelled and the service stopped before the exit |
 | Help | "Rate the app" | Settings > "Help & support" > "Support the project" | `US/SettingsView.kt:171-180,267-281` | `helpAndroid_rateTheAppOpensMarket` | The row "Rate the app" (Android only) fires `ACTION_VIEW` with `market://details?id=chat.simplex.app`, recorded and stubbed with `INTENTS` so nothing launches (R13); "Contribute" and "Star on GitHub" are also listed (foss) | INTENTS | The `https://play.google.com/…` fallback is unreachable: `openUriCatching` (`C/views/helpers/Utils.kt:605-611`) swallows the exception, so `runCatching` never fails (`US/SettingsView.kt:267-271`) |
-| Version | Version screen | the version row | `US/VersionInfoView.kt:30-52`; `A/views/usersettings/SettingsView.android.kt:21-29` | `versionAndroid_showsAndroidBuildAndDevTools` | "App version" page: "App version: v<ANDROID_VERSION_NAME>", "App build: <ANDROID_VERSION_CODE>", "Core version: v…", and the "Developer tools" row | — | Desktop: 04 `version_screenShowsVersions` |
+| Version | Version screen | the version row | `US/VersionInfoView.kt:30-52`; `A/views/usersettings/SettingsView.android.kt:21-29` | | "App version" page: "App version: v<ANDROID_VERSION_NAME>", "App build: <ANDROID_VERSION_CODE>", "Core version: v…", and the "Developer tools" row | — | `versionAndroid_showsAndroidBuildAndDevTools` merged into `settingsAndroid_rootListsAndroidItems`. Desktop: 04 `version_screenShowsVersions` |
 | Version | Developer options | "Developer tools" with developer tools on | `US/DeveloperView.kt:40-63` | `devToolsAndroid_noConsoleWindowOption` | "Developer options" lists "Enable logs", "Confirm database upgrades", "Show internal errors", "Show slow API calls"; no "Show console in new window" (desktop only) | DT | – |
 | Network | Network connection status | Settings > "Network & servers" | `NS/NetworkAndServers.kt:306-316`; `A/helpers/NetworkObserver.kt:56-92` | `networkAndroid_connectionStatusOnline` | Section "Network connection" with the network type ("Cellular", "WiFi", "Wired ethernet" or "Other") and a green dot described "Connected" | — | Waydroid's network type is not fixed here; the test compares with `ConnectivityManager` |
 | Network | Offline status | airplane mode on | `A/helpers/NetworkObserver.kt:68-92` | `networkAndroid_connectionStatusOffline` | After about 3 s the row shows "No network connection" with a red dot; turning airplane mode off restores the type and the green dot | SHELL | Restored at the end of the test; open question 12 |
diff --git a/plans/ui-tests/drafts/design-A-connect.md b/plans/ui-tests/drafts/design-A-connect.md
new file mode 100644
index 0000000000..38ff6151b0
--- /dev/null
+++ b/plans/ui-tests/drafts/design-A-connect.md
@@ -0,0 +1,775 @@
+# Design A: connecting to people (catalogue 01 §8 and §9)
+
+Status: design only, nothing implemented. Written 2026-10-20 against `~/wt-uitest` (branch `nd/desktop-ui-tests`,
+HEAD `8927c1892`). Every `file:line` below was read in this tree; paths are relative to `apps/multiplatform/common/src/`
+unless they start with `src/` or `tests/` (Haskell, repo root). UI strings are from
+`commonMain/moko-resources/base/strings.xml` (the brief said `MR/base`; that path does not exist).
+
+Rules followed: `uiTestShared/README.md` (whole guide), plan §0.5, legend `catalogue/00-legend.md`.
+`status.py`: none of the 40 names in §8/§9 has a test yet.
+
+## 0. Summary
+
+| # | Test (file / class) | Catalogue rows covered | Peers | Route |
+|---|---|---|---|---|
+| 1 | `pasteLinkInvalidTextAlert` (main/ConnectPlanTest) | §8 Paste (`pasteLinkInvalidTextAlert`, `pasteLinkClipboardEmptyNoop`) | 0 | New chat › Paste link |
+| 2 | `planOwnInvitationConnectToYourself` (ConnectPlanTest) | §8 Invitation own link, Address own address | 0 | search |
+| 3 | `planInvitationAlreadyConnectingFullLink` (ConnectPlanTest) | §8 Invitation full link (`…UseCurrentProfile`, `…Cancel`), Already connecting | 1 (full links) | search |
+| 4 | `planAddressRepeatConnectionRequest` (ConnectPlanTest) | §8 Address full link (`planAddressFullLinkConnectAlert`, incognito button), Repeat request | 1 (full links) | search |
+| 5 | `planViaChatItemLinkCard` (ConnectPlanTest) | §8 Card in message, Signed address card (chat list), Card contents, Address Known, Invitation Known (same alert code) | 2 | chat-item card, chat-list card, search |
+| 6 | extend existing `searchPasteLinkTriggersConnectPlan` (ChatListToolbarSearchTest) | §8 Deleted link → error (re-targeted to a deleted address) | (existing 1) | search |
+| 7 | `preparedContactInvitationConnectButton` (main/PreparedChatTest) | §8 Invitation short link OK; §9 Invitation (3 names) | 1 | search |
+| 8 | `preparedContactAddressSendRequestWithMessage` (PreparedChatTest) | §8 Address short link OK; §9 Address request (`…WithMessage`, `…AlertAddMessage`, `…AfterConnectShowsContactShouldAccept`) | 1 | search |
+| 9 | `preparedBotConnect` (PreparedChatTest) | §8 Bot address; §9 Bot | 1 | search |
+| 10 | `preparedContactIncognitoBeforeConnect` (PreparedChatTest) | §9 Profile/incognito (incognito half) | 1 | search |
+| 11 | `preparedContactChangeProfileBeforeConnect` (PreparedChatTest) | §9 Profile/incognito (profile half) | 1 | search |
+
+10 new tests plus one extension of an existing test. Each plan alert kind (Ok short with link data, Ok full without it,
+OwnLink ×2, Connecting, ConnectingConfirmReconnect, Known, error) and each compose-area variant (invitation Connect,
+address request with/without message, bot Connect, profile picker: incognito / other profile) is exercised once, and
+every alert button (`Use current profile`, `Use new incognito profile`, `Cancel`, `Open new chat`, `Open chat`) is
+clicked at least once.
+
+### Why the chat-list search is the main entry
+
+- New chat › "Paste link" on Android opens the QR scanner at once (`newchat/NewChatSheet.kt:62-64`,
+  `showQRCodeScanner = appPlatform.isAndroid`); Waydroid has no camera and leaving the scanner crashes the app (plan
+  §15.5 item 4). A paste-route test must start with `assumeCamera()` and is skipped on Waydroid. So only test 1 (the
+  paste row's own behaviour) uses that route.
+- The search field (`Ui.ChatList.Search`, existing key, `chatlist/ChatListView.kt:837`) runs the same `planAndConnect`
+  (`ChatListView.kt:873-881,924-934`) on both platforms with no camera and no clipboard. Its one difference: Known
+  contacts are filtered into the list instead of an alert (`filterKnownContact`, `ChatListView.kt:929`), which an
+  existing test already covers (`searchPasteKnownContactLinkFiltersToContact`). The "Open chat" alert of Known plans is
+  therefore tested through the chat-item card (test 5), which calls `planAndConnect` with no filter
+  (`chat/item/FramedItemView.kt:409-411`).
+
+## 1. App changes (keys only)
+
+All are no-ops unless `uiTestHooksEnabled` (`Modifier.ui`, `common/ui/Ui.kt:18`). Every key below is clicked by a test.
+
+| Key | Ui.kt change | Element (file:line) | Used by |
+|---|---|---|---|
+| `Ui.NewChat.PasteLink` | new: `val PasteLink = UiKey("newChat.pasteLink")` in `object NewChat` (`Ui.kt:53-56`) | the "Paste link" / "Paste link / Scan" action: third argument `null` → `Ui.NewChat.PasteLink` at `commonMain/kotlin/chat/simplex/common/views/newchat/NewChatSheet.kt:193` | 1 |
+| `Ui.Link.Paste` | new: `val Paste = UiKey("link.paste")` in `object Link` (`Ui.kt:142-146`) | "Tap to paste link" row: `SectionItemView({ … }, uiKey = Ui.Link.Paste) {` at `views/newchat/NewChatView.kt:681` | 1 |
+| `Ui.Alert.Option(Ui.AlertSource.PrivacySensitive, "useCurrentProfile")`, `…"useIncognito"`, `…"cancel"` | none (existing `Option` family, `Ui.kt:202`) | the three `SectionItemView`s of `askCurrentOrIncognitoProfileAlert`: `views/newchat/ConnectPlan.kt:469` ("Use current profile"), `:477` ("Use new incognito profile"), `:493` ("Cancel"); add `uiKey = …` (SectionItemView takes `uiKey` before `content`, `views/helpers/Section.kt:200-210`, same call shape as `usersettings/UserProfilesView.kt:85`). The alert is always `AlertManager.privacySensitive` (`ConnectPlan.kt:463`). | 1, 2, 3, 4 |
+| `Ui.Chat.Connect` | none (existing, `Ui.kt:151`) | also on `ConnectButtonView`: `var modifier = Modifier.height(57.dp).fillMaxWidth().ui(Ui.Chat.Connect)` at `views/chat/ComposeView.kt:1576`. Today the key is only on the address-request button (`ComposeView.kt:1563`); the invitation and bot "Connect" (`:1816-1827`) and "Join group" (`:1785`) have none. Same meaning, mutually exclusive branches (`:1782-1835`). | 7, 9, 10, 11 |
+| `Ui.Chat.PickerUser(userId)` | new: `fun PickerUser(userId: Long) = UiKey("chat.picker.user", userId)` in `object Chat` | `ProfilePickerUserOption` row: `.ui(Ui.Chat.PickerUser(user.userId))` in the `Row` modifier at `views/chat/ComposeContextProfilePickerView.kt:124-127` | 10, 11 |
+| `Ui.Chat.PickerIncognito` | new: `val PickerIncognito = UiKey("chat.picker.incognito")` | `IncognitoOption` row modifier at `ComposeContextProfilePickerView.kt:167-170` (the nested ⓘ at `:194-205` is avoided by `tapPointInNode`) | 10 |
+| `Ui.Chat.Item(id).part("chatLink")` | none (`part` is generic, as `.part("quote")` at `FramedItemView.kt:297`) | chat-link card: `Modifier.ui(Ui.Chat.Item(ci.id).part("chatLink")).combinedClickable(` at `views/chat/item/FramedItemView.kt:409` | 5 |
+| `Ui.ChatList.Row(id, rh).part("link")` | none (existing, already on the link-preview thumbnail `chatlist/ChatPreviewView.kt:326`) | chat-link card thumbnail on the row: `Modifier.fillMaxSize().ui(Ui.ChatList.Row(chat.id, chat.remoteHostId).part("link")).clickable { … }` at `chatlist/ChatPreviewView.kt:357` | 5 |
+
+Not added: no key on the alert's profile image, the bot icon, banners or info lines (read by text), and none on
+`showOpenChatAlert`'s "connect other" button (names need `NAMES`).
+
+## 2. Harness additions
+
+| Helper | File | Signature and body sketch |
+|---|---|---|
+| `setClipboardText` | desktop `desktopTest/…/harness/UiTest.kt` and Android `android/…/harness/UiTest.kt` (same name on both `UiScope`s, plan §0.5.1) | desktop: `fun setClipboardText(text: String?) { clipboard.content = text?.let { AnnotatedString(it) } }` (`TestClipboard`, `TestRoot.kt:11-15`); Android: `fun setClipboardText(text: String?) = UiTestApp.onMain { val cm = androidAppContext.getSystemService(ClipboardManager::class.java); if (text == null) cm.clearPrimaryClip() else cm.setPrimaryClip(ClipData.newPlainText("uitest", text)) }` (`clearPrimaryClip` needs API 28; an empty clip is not "no text": `getText()` would return `""`, which the app treats as invalid, `NewChatView.kt:682-694`) |
+| `planOption(name)`, `planDismiss` | new `uiTestShared/…/harness/ConnectScreens.kt` | `fun planOption(name: String) = Ui.Alert.Option(Ui.AlertSource.PrivacySensitive, name)`; `val planDismiss = Ui.Alert.Dismiss(Ui.AlertSource.PrivacySensitive)` (next to the existing `planConfirm`, `ChatListFilterScreens.kt:98`, which moves here) |
+| `UiScope.openPasteLink(app)` | `ConnectScreens.kt` | `app.newChat(); click(Ui.NewChat.PasteLink); poll(what = "the `Paste the link you received` section with `Tap to paste link`") { seesText("Paste the link you received") && "Tap to paste link" in textsOf(Ui.Link.Paste) }` |
+| `UiScope.openNewChatFromSearch(link, name): ChatScreen` | `ConnectScreens.kt` | `enterLinkInSearch(link)`; `poll(CONNECT_TIMEOUT_MS, "the plan alert for `$name` with `Open new chat`") { exists(planConfirm) && "Open new chat" in textsOf(planConfirm) && seesText(name) }`; `click(planConfirm)`; `poll(what = "`$name`'s prepared chat open") { chatModel.chats.value.firstOrNull { it.chatInfo.chatViewName == name && it.chatInfo.nextConnectPrepared }?.id?.let { it == chatModel.chatId.value } == true }`; `return ChatScreen(this)`. Used by 7–11 (the plan alert itself is asserted inside the poll). |
+| `ChatScreen.chatLinkItemId(): Long` | `Screens.kt` (`ChatScreen`, next to `itemId`, `Screens.kt:222-229`) | `poll(what = "a chat link card") { id = chatModel.chatsContext.chatItems.value.lastOrNull { it.content.msgContent is MsgContent.MCChat }?.id; id != null && s.exists(Ui.Chat.Item(id!!)) }` |
+| `CliPeer.createAddress(business = false, autoAccept = true)` | change `ChatListFilterScreens.kt:80-88` | add `autoAccept`; when `false`, skip `/auto_accept` and consume the rest of the `/ad` output with `eventually("to delete it: /da (accepted contacts will remain connected)")` (`src/Simplex/Chat/View.hs:1144-1154`). Existing callers unchanged. |
+| `CliPeer.createFullAddress(): String` | `ChatListFilterScreens.kt` | peer started with `PeerFlags(fullLinks = true)`: `this sends "/ad"; this expects "Your new chat address is created!"; return eventuallyMatching(Regex("The contact link for old clients: (\\S+)")).groupValues[1]` (`View.hs:1154`) |
+| `CliPeer.createFullOneTimeLink(): String` | `Helpers.kt` (next to `createOneTimeLink`, `Helpers.kt:56-61`) | `this types "/c"; eventually("The invitation link for old clients:"); return nextLine()` (`View.hs:1071-1086`) |
+| `CliPeer.becomeBot()` | `ChatListFilterScreens.kt` | `this sends """/_profile 1 {"displayName":"$name","fullName":"","peerType":"bot"}"""; this sends "/u"; eventually("user profile: $name (bot)"); this expects "use /p <name> [<bio>] to change it"` (`/_profile` parser `Library/Commands.hs:6399`; `peerType` text `"bot"`, `Types.hs:766-778`; `/u` lines `View.hs:1579-1592`, suffix ` (bot)` `View.hs:1597`). The `/u` round trip flushes whatever `/_profile` printed (preference lines, if any). Must run before `/ad` so the address link data carries the bot profile. |
+| `PeerLines.eventuallyAll(lines, messages = emptyList(), timeoutMs)` | `PeerLines.kt` (next to `eventuallyMatching`, `PeerLines.kt:46-52`) | waits until every `lines` entry is present exactly and every `messages` entry matches after `stripTime`, then `dropThrough` the last matched index. Needed because the CLI prints a contact request and its message in either order (Haskell uses `<###`, `tests/ChatTests/Profiles.hs:4184-4187`). |
+
+No `quiesce()` is added to hide a race; existing uses after setup only.
+
+## 3. Tests
+
+Conventions in the pseudo-code: `alice = app("alice")`; `waitAlert(title)` = `poll(CONNECT_TIMEOUT_MS, "…") { seesText(title) }`
+when the alert follows a network plan, plain `poll` otherwise. Alert bodies of `askCurrentOrIncognitoProfileAlert`
+end with the link (`ConnectPlan.kt:83,108`), so they are matched with `seesText(text, substring = true)`.
+
+---
+
+### Test 1. `pasteLinkInvalidTextAlert` — `main/ConnectPlanTest`
+
+Rows: §8 "Paste: Invalid or empty clipboard" (both names; `pasteLinkClipboardEmptyNoop` merged).
+
+**Scenario.** The user opens New chat › Paste link and taps "Tap to paste link": with nothing copied nothing happens;
+with a web link copied they are told it is not a SimpleX link; with a SimpleX link copied the connection plan starts.
+
+**Fails if** the paste row stops reading the clipboard correctly or stops rejecting non-SimpleX text. Mutations:
+- `views/newchat/NewChatView.kt:682` `?: return@SectionItemView` → `?: AnnotatedString("")`: the empty clipboard shows
+  "Invalid link!" → step 2 fails;
+- delete the `null -> AlertManager.shared.showAlertMsg(…)` branch at `NewChatView.kt:694-697` (make it `null -> {}`) →
+  step 3 fails;
+- `NewChatView.kt:684-688` drop the `withBGApi { connect(…) }` call → step 4 fails (no plan alert).
+
+**Setup.** No peer. `val address = alice.userPicker().createAddress()` (`Screens.kt:127-130`; returns alice's own
+address; on desktop it also lands on the clipboard stub, so step 2 clears it).
+
+**Steps and assertions.**
+```kotlin
+assumeCamera()                                   // Android: the paste screen starts the scanner (§15.5 item 4)
+val address = alice.userPicker().createAddress()
+openPasteLink(alice)                              // NEW, ConnectScreens.kt
+// 2. empty clipboard: nothing happens
+setClipboardText(null)                            // NEW
+click(Ui.Link.Paste)
+settle()
+assert(exists(Ui.Link.Paste) && "Tap to paste link" in textsOf(Ui.Link.Paste))    // presence first
+assert(!seesText("Invalid link!") && !exists(Ui.Alert.Confirm(Ui.AlertSource.Shared)) && !exists(planConfirm))
+// 3. web link: rejected
+setClipboardText("https://example.com/invite")
+click(Ui.Link.Paste)
+poll { seesText("Invalid link!") && seesText("The text you pasted is not a SimpleX link.") }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll { !seesText("Invalid link!") && exists(Ui.Link.Paste) }                         // row still offered
+// 4. positive control: a SimpleX link starts the plan
+setClipboardText(address)
+click(Ui.Link.Paste)
+poll { seesText("Connect to yourself?") && !exists(Ui.Link.Paste) }                   // row replaced by the link
+click(planOption("cancel"))
+poll { !seesText("Connect to yourself?") && exists(Ui.Link.Paste) }                   // cleanup resets the row
+```
+Strings: "Paste the link you received" (`paste_the_link_you_received`), "Tap to paste link", "Invalid link!"
+(`invalid_contact_link`), "The text you pasted is not a SimpleX link.", "Connect to yourself?"
+(`connect_plan_connect_to_yourself`). The positive control is what makes steps 2–3 meaningful (a dead row would also
+show no alert); it uses alice's own address so no peer is needed. Opposite-first: step 2 asserts the row and the
+absence of alerts before step 3 expects an alert.
+
+**Keys:** `Ui.NewChat.PasteLink`, `Ui.Link.Paste`, `planOption("cancel")` (new); `Ui.Alert.Confirm(Shared)`,
+`planConfirm` (existing).
+**Peer:** none.
+**Platform:** desktop runs it; Android skips on devices without a camera (Waydroid) via `assumeCamera()` (guide §3
+table), and needs `setClipboardText` with `clearPrimaryClip`. **Flakiness:** none expected; the empty-clipboard check
+is a `settle()` followed by presence + absence, as the guide requires.
+
+---
+
+### Test 2. `planOwnInvitationConnectToYourself` — `ConnectPlanTest`
+
+Rows: §8 "Invitation: Own link" and "Address: Own address" (`planOwnAddressConnectToYourself` merged; same alert
+function, different text and outcome).
+
+**Scenario.** A user pastes their own SimpleX address and then their own 1-time link. Each time the app warns
+"Connect to yourself?"; choosing "Use current profile" really connects (address: a request from yourself; 1-time link:
+two contacts both named after you).
+
+**Fails if** own links stop being recognised or the current-profile button connects incognito. Mutations:
+- `ConnectPlan.kt:182-193`: replace the `ContactAddressPlan.OwnLink` body by the Ok-without-data branch (title
+  `connect_via_contact_link`) → "Connect to yourself?" never shows → fails;
+- `ConnectPlan.kt:114-123`: same for `InvitationLinkPlan.OwnLink` (title `connect_via_invitation_link`) → fails;
+- `ConnectPlan.kt:472` `incognito = false` → `true`: the joining side shares a random profile, so only one of the two
+  new contacts is named "alice" → the final count fails.
+
+**Setup.** No peer. Address via `alice.userPicker().createAddress()` (`Screens.kt:127-130`); 1-time link kept as a
+pending connection via `keepOneTimeLink(alice)` (`ChatListFilterScreens.kt:29-39`).
+
+**Steps and assertions.** Address first, because after the 1-time link part three chats are named "alice".
+```kotlin
+val address = alice.userPicker().createAddress()
+alice.chatList.row("Private notes")
+assert(chatModel.chats.value.none { it.chatInfo.chatViewName == "alice" })                // opposite state
+enterLinkInSearch(address)                                                                 // ChatListFilterScreens.kt:100
+poll(CONNECT_TIMEOUT_MS) { seesText("Connect to yourself?") && seesText("This is your own SimpleX address!", substring = true) &&
+  exists(planOption("useCurrentProfile")) && exists(planOption("useIncognito")) && exists(planOption("cancel")) }
+click(planOption("useCurrentProfile"))
+poll { seesText("Connection request sent!") &&
+  seesText("You will be connected when your connection request is accepted, please wait or check later!") }
+click(planConfirm)
+alice.chatList.request("alice")                         // Screens.kt:57-62: row "alice" with "Open to accept"
+
+val link = keepOneTimeLink(alice)
+val contactsNamedAlice = { chatModel.chats.value.filter { (it.chatInfo as? ChatInfo.Direct)?.contact?.let { c -> c.profile.displayName == "alice" && c.sndReady } == true } }
+assert(contactsNamedAlice().isEmpty())
+enterLinkInSearch(link)
+poll(CONNECT_TIMEOUT_MS) { seesText("Connect to yourself?") && seesText("This is your own one-time link!", substring = true) }
+click(planOption("useCurrentProfile"))
+poll { seesText("Connection request sent!") &&
+  seesText("You will be connected when your contact's device is online, please wait or check later!") }
+click(planConfirm)
+poll(CONNECT_TIMEOUT_MS, "two contacts named alice, connected to each other") {
+  contactsNamedAlice().size == 2 && contactsNamedAlice().all { exists(Ui.ChatList.Row(it.id)) } &&
+    chatModel.chats.value.none { it.chatInfo is ChatInfo.ContactConnection } }
+```
+Strings: "This is your own SimpleX address!", "This is your own one-time link!", "Connection request sent!", both
+"You will be connected when …" texts (`strings.xml:925-928,2824-2829`). The two "You will be connected" texts also
+check the link-type mapping in `connectViaUri` (`ConnectPlan.kt:418-431`). Expected core outcome: two contacts
+`alice_1`/`alice_2` (`tests/ChatTests/Direct.hs:507-525`, `testPlanInvitationLinkOwn`) and a request `alice_1`
+(`testPlanAddressOwn`, `Profiles.hs:2183`).
+
+**Keys:** `planOption("useCurrentProfile")`, `…("useIncognito")`, `…("cancel")` (only `useCurrentProfile` clicked here;
+presence of the other two shows the three-button alert). **Peer:** none.
+**Platform:** shared, no differences (alerts and the list are visible on both; `request()` waits for the row).
+**Flakiness:** the self-connection crosses the server → `CONNECT_TIMEOUT_MS`.
+
+---
+
+### Test 3. `planInvitationAlreadyConnectingFullLink` — `ConnectPlanTest`
+
+Rows: §8 "Invitation: Full link: OK" (`planInvitationFullLinkUseCurrentProfile`, `planInvitationFullLinkCancel`) and
+"Invitation: Already connecting".
+
+**Scenario.** Someone with an old client sends a full 1-time link. The user pastes it: "Connect via one-time link?".
+"Cancel" does nothing; "Use current profile" sends the request. Pasting the same link again while the contact is offline
+says "Already connecting!". When the contact comes online, they are connected.
+
+**Fails if** a second paste of a link in progress offers to connect again, or "Cancel" connects. Mutations:
+- `ConnectPlan.kt:134-140`: show the "Connect via one-time link?" alert (call `askCurrentOrIncognitoProfileAlert` as in
+  `:105-112`) instead of `connect_plan_already_connecting` → third paste fails;
+- `ConnectPlan.kt:493-496` "Cancel" calls `connectViaUri(…, incognito = false, …)` → a pending connection appears after
+  step 1 → fails;
+- `ConnectPlan.kt:429` swap the INVITATION/CONTACT texts → "contact's device is online" text missing → fails.
+
+**Setup.** `val bob = cli("bob", PeerFlags(fullLinks = true))` (`UiTest.kt:304-306`, `CliPeer.kt:391`).
+`val full = bob.createFullOneTimeLink()` (NEW). CLI output parsed: `pass this invitation link to your contact (via another
+channel): `, ``, short link, ``, `and ask them to connect: /c <invitation_link_above>`, `The invitation link for old
+clients:`, full link (`View.hs:1071-1086`). Then `bob sends "/_stop"; bob.eventually("chat stopped")` (`Commands.hs:6310`,
+`View.hs:123`): bob stays offline, so alice's connection stays in progress (the core forgets `conn_req_inv` once
+connected, `tests/ChatTests/Direct.hs:502-503`, which would turn the plan back to "ok"; Haskell gets the same state by
+closing the inviter, `testPlanInvitationLinkConnecting`, `Direct.hs:543-556`). `/_stop` is a CLI command, not PEERCTL.
+
+**Steps and assertions.**
+```kotlin
+alice.chatList.row("Private notes")
+val pending = { chatModel.chats.value.count { it.chatInfo is ChatInfo.ContactConnection } }
+// 1. Cancel
+enterLinkInSearch(full)
+poll(what = "the full-link alert") { searchShowsLink("SimpleX one-time invitation") && seesText("Connect via one-time link?") &&
+  seesText("Your profile will be sent to the contact that you received this link from.", substring = true) }
+click(planOption("cancel"))
+poll { !seesText("Connect via one-time link?") && editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search) }
+quiesce(); assert(pending() == 0)                             // presence: the list and an editable search are shown
+// 2. Use current profile
+enterLinkInSearch(full)
+poll { seesText("Connect via one-time link?") }
+click(planOption("useCurrentProfile"))
+poll { seesText("Connection request sent!") && seesText("You will be connected when your contact's device is online, please wait or check later!") }
+click(planConfirm)
+poll { pending() == 1 && editableText(Ui.ChatList.Search).isNullOrEmpty() }
+// 3. Again while bob is offline
+enterLinkInSearch(full)
+poll { seesText("Already connecting!") && seesText("You are already connecting via this one-time link!", substring = true) &&
+  !seesText("Connect via one-time link?") }
+click(planConfirm)
+poll { !seesText("Already connecting!") && pending() == 1 }    // no second connection
+// 4. bob comes online
+bob sends "/_start"; bob.eventually("chat started")
+bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+poll(CONNECT_TIMEOUT_MS) { alice.chatList.shown("bob") && pending() == 0 }
+```
+Opposite-first: step 1 and 2 show the "ok" alert for the same link that step 3 must show as "Already connecting!".
+
+**Expected peer output.** `chat stopped`; after `/_start`: `chat started`, possibly subscription lines, then
+`alice: contact is connected` (`View.hs:1508`). Nothing alice did in steps 1 and 3 reaches bob: step 1 sends nothing
+and step 3 only shows an alert; an extra connection from step 3 would be visible as `pending() == 2`.
+**Keys:** `planOption("cancel")`, `planOption("useCurrentProfile")`, `planConfirm`.
+**Platform:** shared; no differences. **Flakiness:** bob being stopped removes the race between alice's second paste
+and the handshake; network waits use `CONNECT_TIMEOUT_MS`.
+**Class:** the name's row has no `S`, so `ConnectPlanTest`. The merged full-link rows have `S`; a stable-CLI run cannot
+pass `--show-full-links` (unknown option) and prints the full link as its only link, so a compat variant needs
+`CliVersion` (plan §0.5.11, not built). See question Q2.
+
+---
+
+### Test 4. `planAddressRepeatConnectionRequest` — `ConnectPlanTest`
+
+Rows: §8 "Address: Full link: OK" (`planAddressFullLinkConnectAlert`, here through "Use new incognito profile") and
+"Address: Repeat request".
+
+**Scenario.** The user pastes an old-format contact address and chooses an incognito profile; the owner sees a request
+from a random name. Pasting the address again while the request is pending asks "Repeat connection request?"; the user
+cancels; when the owner accepts, they are connected under the random name.
+
+**Fails if** the incognito button sends the real profile, or a pending request is not recognised. Mutations:
+- `ConnectPlan.kt:480` `incognito = true` → `false` → bob prints `alice wants to connect to you!` → `assertNotEquals`
+  fails;
+- `ConnectPlan.kt:194-205`: show `connect_via_contact_link` instead of `connect_plan_repeat_connection_request` → fails;
+- `ConnectPlan.kt:428` swap CONTACT/INVITATION text → fails.
+
+**Setup.** `val bob = cli("bob", PeerFlags(fullLinks = true))`; `val full = bob.createFullAddress()` (NEW; no
+auto-accept). Parsed line: `The contact link for old clients: <link>` (`View.hs:1154`). A full address has no link data,
+so the plan is `CAPOk Nothing` → `askCurrentOrIncognitoProfileAlert` (`ConnectPlan.kt:169-181`).
+
+**Steps and assertions.**
+```kotlin
+alice.chatList.row("Private notes")
+enterLinkInSearch(full)
+poll(CONNECT_TIMEOUT_MS) { searchShowsLink("SimpleX contact address") && seesText("Connect via contact address?") &&
+  seesText("Your profile will be sent to the contact that you received this link from.", substring = true) }
+click(planOption("useIncognito"))
+poll { seesText("Connection request sent!") && seesText("You will be connected when your connection request is accepted, please wait or check later!") }
+click(planConfirm)
+val rand = bob.eventuallyMatching(Regex("(\\S+) wants to connect to you!"), CONNECT_TIMEOUT_MS).groupValues[1]
+assertNotEquals("alice", rand)
+bob expects "to accept: /ac $rand"
+bob expects "to reject: /rc $rand (the sender will NOT be notified)"
+// repeat
+enterLinkInSearch(full)
+poll { seesText("Repeat connection request?") && seesText("You have already requested connection via this address!", substring = true) &&
+  !seesText("Connect via contact address?") }
+click(planOption("cancel"))
+poll { !seesText("Repeat connection request?") && editableText(Ui.ChatList.Search).isNullOrEmpty() }
+// accept
+bob sends "/ac $rand"
+assertTrue(bob.nextLine().startsWith("$rand: accepting contact request"))   // nothing (a second request) came before it
+bob.eventually("$rand: contact is connected", CONNECT_TIMEOUT_MS)
+poll(CONNECT_TIMEOUT_MS) { (alice.chatList.chat("bob").chatInfo as? ChatInfo.Direct)?.contact?.let { it.contactConnIncognito && it.sndReady } == true }
+```
+**Expected peer output.** `<rand> wants to connect to you!`, `to accept: /ac <rand>`, `to reject: /rc <rand> (the sender
+will NOT be notified)` (`View.hs:1267-1272`); after `/ac`: `<rand>: accepting contact request...` (or `…, you can send
+messages to contact`, `View.hs:1259-1262`), then `<rand>: contact is connected`. `nextLine()` right after `/ac` proves
+no second request was printed. The final model check is secondary; the peer line is the source of truth.
+**Keys:** `planOption("useIncognito")`, `planOption("cancel")`, `planConfirm`.
+**Platform/flakiness:** shared, none; `CONNECT_TIMEOUT_MS` for the request and the connection. Same `S`/stable remark
+as test 3.
+
+---
+
+### Test 5. `planViaChatItemLinkCard` — `ConnectPlanTest`
+
+Rows: §8 "Card: Link card in a message", "Signature: Signed address card" (`planSignedAddressCardVerified`, chat-list
+card), "Card: Link card contents" (`linkCardInMessageShowsNameAndSignedInfoLine`), "Address: Known"
+(`planAddressKnownContactOpenChat`), and "Invitation: Known" (`planInvitationKnownContactOpenChat`; same
+`showOpenKnownContactAlert`, `ConnectPlan.kt:519-541`).
+
+**Scenario.** Two contacts share their addresses in chat. cath (connected by 1-time link) is not yet known by her
+address: tapping her card shows her profile, "Link signature verified." and "Open new chat", which opens a new chat to
+request. bob (connected through that address) is known: tapping his card shows "Open chat" and returns to his chat,
+creating nothing.
+
+**Fails if** the card loses its signature or the known-contact alert offers a new chat. Mutations:
+- `FramedItemView.kt:411` drop `linkOwnerSig = mc.ownerSig` → no "Link signature verified." in step d → fails;
+- `ChatPreviewView.kt:357` drop `linkOwnerSig = mc.ownerSig` → step b fails;
+- `ConnectPlan.kt:725` `information = null` → steps b, d fail;
+- `ConnectPlan.kt:533` always `connect_plan_open_new_chat` → step c fails;
+- `chat/item/CIChatLinkHeader.kt:68` `signed = false` → "Contact address (from owner)" missing → fails.
+
+**Setup.**
+```kotlin
+val alice = app("alice"); val bob = cli("bob"); val cath = cli("cath")
+connect(cath)                                                     // Helpers.kt:26-32 (1-time link)
+val bobAddress = bob.createAddress()                              // auto_accept on (ChatListFilterScreens.kt:80-88)
+joinLink(bobAddress)                                              // ChatListFilterScreens.kt:62-67, API precondition
+bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+val cathAddress = cath.createAddress()
+cath sends "/share address @alice"; cath.eventuallyMessage("@alice contact address of @cath (signed):"); cath expects cathAddress
+bob sends "/share address @alice";  bob.eventuallyMessage("@alice contact address of @bob (signed):");   bob expects bobAddress
+val bobId = alice.chatList.chatId("bob"); val cathId = alice.chatList.chatId("cath")
+quiesce()
+```
+CLI lines: `ttyMsgContent` for `MCChat` prints `contact address of @<name> (signed):` then the link
+(`View.hs:2443-2459`); the sent item gets `@alice ` and a time prefix (handled by `eventuallyMessage`). `joinLink` makes
+bob a Known contact by address exactly as `searchPasteKnownContactLinkFiltersToContact` relies on. The signature is kept
+because the binding matches alice's connection (`src/Simplex/Chat/Library/Subscriber.hs:1931-1938`,
+`testShareAddressViaChat` `Profiles.hs:3912-3929`).
+
+**Steps and assertions.**
+```kotlin
+// a. negative control: the same address pasted without the card's signature
+enterLinkInSearch(cathAddress)
+poll(CONNECT_TIMEOUT_MS) { exists(planConfirm) && "Open new chat" in textsOf(planConfirm) && seesText("cath") }
+assert(!seesText("Link signature verified."))
+click(planDismiss); poll { !exists(planConfirm) && editableText(Ui.ChatList.Search).isNullOrEmpty() }
+// b. chat-list card thumbnail
+backToChatList()
+click(Ui.ChatList.Row(cathId).part("link"))
+poll(CONNECT_TIMEOUT_MS) { seesText("cath") && seesText("Link signature verified.") && "Open new chat" in textsOf(planConfirm) }
+click(planDismiss)
+// c. known contact: bob's card in bob's chat
+val bobChat = alice.chatList.open("bob")
+val bobCard = bobChat.chatLinkItemId()                                       // NEW
+poll { textsOf(Ui.Chat.Item(bobCard)).containsAll(listOf("bob", "Contact address (from owner)", "Tap to open")) }
+click(Ui.Chat.Item(bobCard).part("chatLink"))
+poll(CONNECT_TIMEOUT_MS) { "Open chat" in textsOf(planConfirm) && seesText("bob") && !seesText("Link signature verified.") }
+click(planConfirm)
+poll { chatModel.chatId.value == bobId && chatModel.chats.value.count { it.chatInfo.chatViewName == "bob" } == 1 }
+bobChat.send("still here")                                                   // Screens.kt:274-277
+bob.expectsMessage("alice> still here", CONNECT_TIMEOUT_MS)                  // nothing else reached bob
+// d. cath's card in cath's chat: verified, "Open new chat"
+backToChatList()
+val cathChat = alice.chatList.open("cath")
+val cathCard = cathChat.chatLinkItemId()
+poll { textsOf(Ui.Chat.Item(cathCard)).let { t -> t.containsAll(listOf("cath", "Contact address (from owner)", "Tap to open")) && cathAddress !in t } }
+click(Ui.Chat.Item(cathCard).part("chatLink"))
+poll(CONNECT_TIMEOUT_MS) { seesText("Link signature verified.") && "Open new chat" in textsOf(planConfirm) }
+click(planConfirm)
+poll { chatModel.chatId.value != cathId && seesText("Tap Connect to send request") &&
+  chatModel.chats.value.count { it.chatInfo.chatViewName == "cath" } == 2 }
+```
+Strings: "Open new chat" / "Open chat" (`strings.xml:18,15`), "Link signature verified." (`:586`), "Contact address"
++ " (from owner)" (`:581,583`, joined in `common/model/ChatModel.kt:5144-5154`), "Tap to open" (`:577`), "Tap Connect to
+send request" (`:552`). Opposite pairs inside the test: unsigned (a) vs signed (b, d); Known "Open chat" (c) vs Ok "Open
+new chat" (d).
+
+**Expected peer output.** Plans read the link data from the server only; no peer is contacted. Step c's
+`expectsMessage` as the next bob line proves "Open chat" sent no connection request (a request would print
+`alice wants to connect…`/accepting lines first). cath prints nothing after her share; any error line fails the test
+(harness §0.5.8).
+**Keys:** `Ui.Chat.Item(id).part("chatLink")`, `Ui.ChatList.Row(id).part("link")` (new uses), `planConfirm`,
+`planDismiss`.
+**Platform.** Shared. `backToChatList()` before the row thumbnail and between chats (guide §3: on Android the chat
+covers the list). **Flakiness:** two peers; `connect`/`joinLink` waits are network-bound (`CONNECT_TIMEOUT_MS`); the
+cards are found by content type, not by position.
+
+---
+
+### Test 6. Extend `searchPasteLinkTriggersConnectPlan` (`main/ChatListToolbarSearchTest.kt:186-197`)
+
+Row: §8 "Invitation: Deleted link → error" (`planInvitationDeletedLinkError`), re-targeted to a deleted address and
+merged into the existing test.
+
+**Why an extension.** The existing test already does the opposite state: paste bob's address in search → profile alert
+with "Open new chat" → dismiss → search cleared. A new test would start with exactly those steps (guide §5: no
+prefixes; extend the existing test). The catalogue's invitation setup needs async server deletion and a peer polling
+loop (`repeatUntil`, plan §0.5.11, not built); an address deleted with `/da` is gone on the server at once
+(`tests/ChatTests/Profiles.hs:4273-4277`, the next connect fails with AUTH).
+
+**Fails if** the AUTH error of a plan stops being explained. Mutation: delete the `SMPErrorType.AUTH` branch at
+`common/model/SimpleXAPI.kt:1757-1764` → no "Connection link removed" → fails.
+
+**Added steps** (after the existing last line):
+```kotlin
+bob sends "/da"
+bob expects "Your chat address is deleted - accepted contacts will remain connected."
+bob expects "To create a new chat address use /ad"
+enterLinkInSearch(address)
+poll(CONNECT_TIMEOUT_MS) { seesText("Connection link removed") && seesText("Your contact removed this link", substring = true) }
+assert(!exists(planConfirm))
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll { !seesText("Connection link removed") && editableText(Ui.ChatList.Search).isNullOrEmpty() && isEnabled(Ui.ChatList.Search) &&
+  chatModel.chats.value.none { it.chatInfo.chatViewName == "bob" } }
+```
+CLI output: `View.hs:1123-1127` `viewUserContactLinkDeleted` (the two lines above). The plan goes through `sendCmdWithRetry`; AUTH is
+not retryable (`SimpleXAPI.kt:926-945`), so `apiConnectResponseAlert` shows `connection_error_auth` /
+`connection_error_auth_desc` (`strings.xml:215-216`). No keys. Shared, no platform difference.
+
+---
+
+### Test 7. `preparedContactInvitationConnectButton` — `main/PreparedChatTest`
+
+Rows: §8 "Invitation: Short link: OK" (`planInvitationShortLinkOpenNewChat`); §9 "Prepared: Invitation"
+(`preparedContactInvitationConnectButton`, `preparedContactBannerTexts`, `preparedContactRowOpenToConnect`).
+
+**Scenario.** The user pastes a 1-time link, sees the sender's profile, taps "Open new chat", sees a chat that says "Tap
+Connect to chat" with a single "Connect" button (the row reads "Open to connect"); taps it; they are connected and can
+message.
+
+**Fails if** the invitation compose area shows the wrong control or Connect doesn't connect. Mutations:
+- `ComposeView.kt:1815-1820`: use `SendContactRequestView` for `ConnectionMode.Inv` → a message field appears →
+  `!exists(Ui.Chat.Message)` fails;
+- `chat/ChatView.kt:2262` banner text → fails; `chatlist/ChatPreviewView.kt:192-193` → row text fails;
+- `ConnectPlan.kt:93` invert the `contactSLinkData_ != null` test → "Connect via one-time link?" instead of the
+  profile alert → `openNewChatFromSearch` fails;
+- `ComposeView.kt:657` `incognito = true` → bob prints a random name → fails.
+
+**Setup.** `val bob = cli("bob"); val link = bob.createOneTimeLink()` (`Helpers.kt:56-61`, short link); then
+`bob.eventually("and ask them to connect: /c <invitation_link_above>")` so the rest of the `/c` output is consumed and
+the next bob line is the connection (`View.hs:1073-1078`).
+
+**Steps and assertions.**
+```kotlin
+alice.chatList.row("Private notes")
+assert(chatModel.chats.value.none { it.chatInfo.chatViewName == "bob" })
+val chat = openNewChatFromSearch(link, "bob")                                 // NEW
+poll { seesText("Tap Connect to chat") && "Connect" in textsOf(Ui.Chat.Connect) && !exists(Ui.Chat.Message) }
+backToChatList()
+poll { "Open to connect" in alice.chatList.rowTexts("bob") }
+alice.chatList.open("bob")
+click(Ui.Chat.Connect)
+assertEquals("alice: contact is connected", bob.nextLine(CONNECT_TIMEOUT_MS))  // first and only line
+poll(CONNECT_TIMEOUT_MS) { exists(Ui.Chat.Message) && !exists(Ui.Chat.Connect) && !seesText("Tap Connect to chat") &&
+  (alice.chatList.chat("bob").chatInfo as ChatInfo.Direct).contact.sndReady }
+chat.send("hi")
+bob.expectsMessage("alice> hi", CONNECT_TIMEOUT_MS)
+backToChatList(); poll { "Open to connect" !in alice.chatList.rowTexts("bob") }
+```
+Strings: "Open new chat", "Tap Connect to chat" (`:551`), "Connect" (`compose_view_connect`, `:636`), "Open to connect"
+(`:511`). The "Your contact" banner (`ChatView.kt:2270`) is not asserted: after connecting, feature and e2e items are
+added above the composer and on a small Android screen the banner can scroll out of composition, so its absence would
+not mean much and its presence is not guaranteed; the composer change and the peer exchange are the outcome.
+**Expected peer output.** `alice: contact is connected` (`View.hs:1508`), then `alice> hi`; `nextLine` proves nothing
+came before (e.g. a message).
+**Keys:** `Ui.Chat.Connect` on `ConnectButtonView` (new placement); `Ui.ChatList.Search`, `planConfirm`,
+`Ui.Chat.Message`, `Ui.ChatList.Row` (existing).
+**Platform:** `backToChatList()` + `open()` to read the row (Android covers the list); no other difference.
+**Flakiness:** plan alert and connection wait `CONNECT_TIMEOUT_MS`.
+
+---
+
+### Test 8. `preparedContactAddressSendRequestWithMessage` — `PreparedChatTest`
+
+Rows: §8 "Address: Short link: OK" (`planAddressShortLinkOpenNewChat`); §9 "Prepared: Address request"
+(`preparedContactAddressSendRequestWithMessage`, `preparedContactSendRequestAlertAddMessage`,
+`preparedContactAfterConnectShowsContactShouldAccept`). `preparedContactAddressSendRequestWithoutMessage` is already
+done by `ChatListRowsTest.previewContactShouldAcceptForAddress` (`ChatListRowsTest.kt:171-188`: Connect → "Send request
+without message" → `alice wants to connect to you!` → row "contact should accept…"); this test covers the other two
+branches of the same alert.
+
+**Scenario.** The user opens a prepared chat from a contact address ("Tap Connect to send request", a message field and
+a "Connect" button). Tapping Connect with no text asks "Send contact request?"; "Add message" closes the alert without
+sending. They type "hello": the Connect button hides, the send button asks again with "Send request" / "Cancel"; they
+send. The owner sees the request with the message; the chat says "contact should accept…" until the owner accepts.
+
+**Fails if** the message is not sent with the request, or "Add message" sends. Mutations:
+- `ComposeView.kt:662` `msg = mc` → `msg = null` → bob never prints `alice> hello` → fails;
+- `ComposeView.kt:686-691` dismiss runs `sendConnectPreparedContact()` → the request goes out without text; step B then
+  has no prepared chat (no alert) → fails;
+- `ComposeView.kt:1556` drop `if (composeState.value.whitespaceOnly)` → Connect stays with text → fails;
+- `ComposeView.kt:1822-1834` invert `isBot` → no message field → fails; `ChatView.kt:2263`, `ChatView.kt:882-883` → fail.
+
+**Setup.** `val bob = cli("bob"); val address = bob.createAddress(autoAccept = false)` (changed helper).
+
+**Steps and assertions.**
+```kotlin
+alice.chatList.row("Private notes")
+val chat = openNewChatFromSearch(address, "bob")
+poll { seesText("Tap Connect to send request") && exists(Ui.Chat.Message) && "Connect" in textsOf(Ui.Chat.Connect) }
+// A. empty: Add message
+click(Ui.Chat.Connect)
+poll { seesText("Send contact request?") && "Send request without message" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) &&
+  "Add message" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared)) }
+click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+poll { !seesText("Send contact request?") && exists(Ui.Chat.Connect) }
+// B. with text: Send request
+typeInto(Ui.Chat.Message, "hello")
+poll { !exists(Ui.Chat.Connect) && isEnabled(Ui.Chat.Send) }                  // both branches of whitespaceOnly
+pressEnter(Ui.Chat.Message)                                                    // desktop Enter / Android taps Send
+hideKeyboard()
+poll { seesText("Send contact request?") && "Send request" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) &&
+  "Cancel" in textsOf(Ui.Alert.Dismiss(Ui.AlertSource.Shared)) }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+bob.eventuallyAll(listOf("alice wants to connect to you!", "to accept: /ac alice", "to reject: /rc alice (the sender will NOT be notified)"),
+  messages = listOf("alice> hello"), timeoutMs = CONNECT_TIMEOUT_MS)            // NEW
+poll { editableText(Ui.Chat.Message).isNullOrEmpty() && chat.itemId("hello") > 0 && seesText("contact should accept…") }
+// C. owner accepts
+bob sends "/ac alice"
+assertTrue(bob.nextLine().startsWith("alice: accepting contact request"))     // one request only
+bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+poll(CONNECT_TIMEOUT_MS) { !seesText("contact should accept…") && (alice.chatList.chat("bob").chatInfo as ChatInfo.Direct).contact.sndReady }
+chat.send("hi"); bob.expectsMessage("alice> hi", CONNECT_TIMEOUT_MS)
+```
+Strings: "Tap Connect to send request", "Send contact request?", "Send request without message", "Add message", "Send
+request", "Cancel", "contact should accept…" (`strings.xml:552,635-640,801,514`). "contact should accept…" is the line
+above the composer (`ChatView.kt:309-317,873-890`), so it is on screen on both platforms. The alert text with `<b>`
+(`:638`) is not matched.
+**Expected peer output.** As `testShortLinkAddressPrepareContact` (`Profiles.hs:4176-4192`) with roles swapped: the
+request line and `alice> hello` in either order, the two hint lines; after `/ac alice`:
+`alice: accepting contact request, you can send messages to contact` (or `...`), `alice: contact is connected`.
+**Keys:** existing only (`Ui.Chat.Connect` on `ComposeView.kt:1563`, `Ui.Chat.Message`, `Ui.Chat.Send`, alert keys).
+**Platform:** `hideKeyboard()` after sending (Android IME may cover the stacked alert's buttons); `pressEnter` already
+maps to the Send tap on Android. **Flakiness:** the request/message order is handled by `eventuallyAll`.
+
+---
+
+### Test 9. `preparedBotConnect` — `PreparedChatTest`
+
+Rows: §8 "Bot: Bot address" (`planBotAddressShowsBotIcon`: its name claims the alert's cube icon, which has only the
+generic description, so the name is not used; its checkable parts are merged here); §9 "Prepared: Bot".
+
+**Scenario.** The user opens a bot's address: the chat says "Tap Connect to use bot" and offers only "Connect" (no
+message field, no request alert); the row reads "Open to use bot". One tap connects; the chat then has a message field
+and the "Bot" banner.
+
+**Fails if** a bot address is treated as a person's address. Mutations: `ComposeView.kt:1822` `isBot` → `false` →
+`SendContactRequestView` with a message field → `!exists(Ui.Chat.Message)` fails; `ChatView.kt:2263` → banner fails;
+`chatlist/ChatPreviewView.kt:190` → row fails.
+
+**Setup.** `val bob = cli("bob"); bob.becomeBot(); val address = bob.createAddress()` (auto_accept on, so the
+connection completes without `/ac`; the acceptance comes from `/auto_accept`, not from being a bot).
+
+**Steps and assertions.**
+```kotlin
+alice.chatList.row("Private notes")
+openNewChatFromSearch(address, "bob")
+poll { seesText("Tap Connect to use bot") && "Connect" in textsOf(Ui.Chat.Connect) && !exists(Ui.Chat.Message) &&
+  !seesText("Tap Connect to send request") }
+backToChatList(); poll { alice.chatList.rowTexts("bob").let { "Open to use bot" in it && "Open to connect" !in it } }
+val chat = alice.chatList.open("bob")
+click(Ui.Chat.Connect)
+poll { !seesText("Send contact request?") }                                    // no request alert for a bot
+bob.eventually("alice: contact is connected", CONNECT_TIMEOUT_MS)
+poll(CONNECT_TIMEOUT_MS) { exists(Ui.Chat.Message) && !exists(Ui.Chat.Connect) && seesText("Bot") && !seesText("Tap Connect to use bot") }
+chat.send("hi"); bob.expectsMessage("alice> hi", CONNECT_TIMEOUT_MS)
+```
+Opposite pair across tests 8/9: same prepared-address chat type, message field present (8) vs absent (9).
+Strings: "Tap Connect to use bot" (`:553`), "Open to use bot" (`:512`), "Bot" (`chat_banner_bot`, `:556`), "Connect".
+The "Bot" banner is shown right after connecting with few items; if Android scrolls it away (see test 7 note), drop that
+one assertion rather than wait for it.
+**Expected peer output.** `alice: accepting contact request...`, `alice: you can send messages to contact`,
+`alice: contact is connected` (shape from `testShortLinkAddressChangeAutoReply`, `Profiles.hs:5217-5222`; skipped by
+`eventually`), then `alice> hi` as the next line.
+**Keys:** `Ui.Chat.Connect` on `ConnectButtonView` (new placement). **Platform:** list via `backToChatList()`.
+**Flakiness:** none beyond network waits.
+
+---
+
+### Test 10. `preparedContactIncognitoBeforeConnect` — `PreparedChatTest`
+
+Row: §9 "Profile and incognito before connecting" (incognito half).
+
+**Scenario.** In a prepared chat the user opens "Your profile", picks "Incognito" and taps Connect: the contact sees a
+random name; afterwards the picker is gone.
+
+**Fails if** the picker's choice is not used when connecting. Mutations: `ComposeView.kt:657` →
+`val incognito = false` → bob prints `alice: contact is connected` → fails;
+`ComposeContextProfilePickerView.kt:175` drop `appPrefs.incognito.set(true)` → fails; `ComposeView.kt:1701` drop
+`chat.chatInfo.nextConnectPrepared &&` → picker still shown after connecting → fails.
+
+**Setup.** `val bob = cli("bob"); val link = bob.createOneTimeLink(); bob.eventually("and ask them to connect: /c <invitation_link_above>")`.
+
+**Steps and assertions.**
+```kotlin
+val aliceId = chatModel.currentUser.value!!.userId
+openNewChatFromSearch(link, "bob")
+poll { seesText("Your profile") && exists(Ui.Chat.PickerUser(aliceId)) && !exists(Ui.Chat.PickerIncognito) }   // current: alice
+click(Ui.Chat.PickerUser(aliceId))                                            // expands the list
+poll { exists(Ui.Chat.PickerIncognito) }
+click(Ui.Chat.PickerIncognito)
+poll { exists(Ui.Chat.PickerIncognito) && !exists(Ui.Chat.PickerUser(aliceId)) }   // collapsed, Incognito selected
+click(Ui.Chat.Connect)
+val shared = bob.eventuallyMatching(Regex("(\\S+): contact is connected"), CONNECT_TIMEOUT_MS).groupValues[1]
+assertNotEquals("alice", shared)
+poll(CONNECT_TIMEOUT_MS) { !seesText("Your profile") && !exists(Ui.Chat.PickerIncognito) && exists(Ui.Chat.Message) }
+```
+Picker states from `ComposeContextProfilePickerView.kt:121-302`: collapsed shows only the selected option
+(`CurrentSelection`, `:272-296`); a click on the selected user expands (`:129-131`); Incognito collapses and sets the
+preference (`:170-177`). Strings: "Your profile" (`:1005`), "Incognito" (`:2238`).
+**Expected peer output.** `<random>: contact is connected` (incognito joiner: `Profiles.hs:4692-4699`).
+**Keys:** `Ui.Chat.PickerUser`, `Ui.Chat.PickerIncognito` (new), `Ui.Chat.Connect`.
+**Platform:** none; the picker sits above the composer on both. The incognito preference is global
+(`appPrefs.incognito`) and restored by the reset (`PrefStores.restore`, plan §0.5.3). **Flakiness:** none.
+
+---
+
+### Test 11. `preparedContactChangeProfileBeforeConnect` — `PreparedChatTest`
+
+Row: §9 "Profile and incognito before connecting" (profile half).
+
+**Scenario.** With two profiles, the user opens a link under "alice", switches the prepared chat to "alice2" in the
+picker (the app switches the active profile and keeps the chat open) and connects: the contact sees "alice2".
+
+**Fails if** changing the profile doesn't move the prepared contact. Mutations:
+`ComposeContextProfilePickerView.kt:83` skip `apiChangePreparedContactUser` (treat as success) → bob prints `alice:` →
+fails; `:99-104` drop `changeActiveUser_` → active user stays alice → fails.
+
+**Setup.**
+```kotlin
+val alice = app("alice"); val bob = cli("bob")
+alice.userPicker().profiles().apply { add("alice2"); close() }      // Screens.kt:137-164 (as UserPickerTest.kt:16)
+alice.userPicker().switchTo("alice")                                // Screens.kt:142-148
+val link = bob.createOneTimeLink(); bob.eventually("and ask them to connect: /c <invitation_link_above>")
+```
+alice2 gets alice's servers (new users copy the current user's servers, `Library/Commands.hs:488-500`), so it uses the
+local `smp1`.
+
+**Steps and assertions.**
+```kotlin
+val aliceId = chatModel.users.first { it.user.displayName == "alice" }.user.userId
+val alice2Id = chatModel.users.first { it.user.displayName == "alice2" }.user.userId
+openNewChatFromSearch(link, "bob")
+val bobChatId = chatModel.chatId.value
+poll { exists(Ui.Chat.PickerUser(aliceId)) && !exists(Ui.Chat.PickerUser(alice2Id)) }
+click(Ui.Chat.PickerUser(aliceId))
+poll { exists(Ui.Chat.PickerUser(alice2Id)) }
+click(Ui.Chat.PickerUser(alice2Id))
+poll { chatModel.currentUser.value?.userId == alice2Id && chatModel.chatId.value == bobChatId &&
+  exists(Ui.Chat.PickerUser(alice2Id)) && !exists(Ui.Chat.PickerUser(aliceId)) }
+click(Ui.Chat.Connect)
+assertEquals("alice2: contact is connected", bob.nextLine(CONNECT_TIMEOUT_MS))
+```
+**Expected peer output.** `alice2: contact is connected` (as `robert: contact is connected`,
+`testShortLinkChangePreparedContactUser`, `Profiles.hs:4737-4770`), as bob's next line.
+**Keys:** `Ui.Chat.PickerUser` (new), `Ui.Chat.Connect`. **Platform:** none. **Flakiness:** the user switch is awaited
+on the model and the picker state before Connect.
+
+## 4. Rows not kept
+
+| Row (name) | Decision | Reason |
+|---|---|---|
+| `pasteLinkClipboardEmptyNoop` | merged → test 1 | same screen and action |
+| `planProgressIndicatorAndCancel` | drop | needs `SRVCTL` (stop the SMP server), not built (plan §0.5.11, 8.2/11) |
+| `planInvitationShortLinkOpenNewChat` | merged → test 7 | its steps are test 7's first half |
+| `planInvitationFullLinkUseCurrentProfile`, `planInvitationFullLinkCancel` | merged → test 3 | same alert, both buttons clicked there |
+| `planInvitationFullLinkUseIncognito` | merged (button) → test 4 | the incognito button of the same alert function is clicked in test 4 with a peer-visible result; a second peer test for the same button adds cost only |
+| `planOwnAddressConnectToYourself` | merged → test 2 | same alert function |
+| `planInvitationKnownContactOpenChat` | merged → test 5 | same `showOpenKnownContactAlert` (`ConnectPlan.kt:519-541`); Known reaches an alert only via paste/URI/card (search filters it, `ChatListView.kt:929`), and the paste route is camera-gated on Android; invitation Known in the core is covered by Haskell (`Profiles.hs:4078-4080`) |
+| `planInvitationConnectingPreparedOpensKnown` | drop | the alert exists only on the paste route (camera-gated) before Connect; the search route filters, and clearing a link from the read-only search field needs Back while a chat is open (unverified on desktop). Only `ConnectPlan.kt:533`'s `nextConnectPrepared` branch would be added; low value |
+| `planInvitationDeletedLinkError` | merged → test 6 (extension) | re-targeted to a deleted address (deterministic, `/da`); the invitation variant needs async deletion + `repeatUntil` (not built). Catalogue row to be corrected |
+| `planAddressShortLinkOpenNewChat` | merged → test 8 | first half of test 8 |
+| `planAddressFullLinkConnectAlert` | merged → test 4 | |
+| `planAddressConnectingProhibitOpensKnown` | drop | the plan comes only from a full-address lookup after Connect on a prepared contact (`Library/Commands.hs:4761`); search filters it and the alert is the same `showOpenKnownContactAlert` as test 5; core behaviour is Haskell-covered |
+| `planAddressKnownContactOpenChat` | merged → test 5 | |
+| `planAddressContactViaAddressOpensChat` | drop | needs `FIXTURE` + `RESTART` (contact card without connection), not built |
+| `planAddressDeletedContactReconnect` | drop | the UI branch is the ordinary Ok/Known alert already tested; the deletion logic is core (`testPlanAddressContactDeletedReconnected`, `testShortLinkAddressDeleteContact`); low UI regression value for a 1-peer test |
+| `planBotAddressShowsBotIcon` | merged → test 9 | the icon is not observable (generic description); the checkable parts are in test 9 |
+| `planSignedAddressCardVerified`, `linkCardInMessageShowsNameAndSignedInfoLine` | merged → test 5 | |
+| `planOwnerSignatureFailed` | drop for now (high-value follow-up) | needs the genuine `ownerSig`/`chatBinding` JSON read back from `/_get chat` (one very long CLI line) and re-sent; fragile without a JSON peer helper. Recommended once a `CliPeer.json(cmd)` reader exists |
+| `planConnectByNameContact`, `planConnectByNameNotFound` | drop | need `NAMES` (names-mode SMP + resolver), not built |
+| `planConnectByNameOtherKindButton` | drop | needs `NAMES` + `RELAY` |
+| `planOpenedViaSimplexUriHandler` | drop | clicking a link inside message text needs a text-range click (`clickAtTextRange`, plan §0.5.11 7.4); the card and search routes run the same `planAndConnect` |
+| `planViaChatItemLinkCard` | kept as test 5 | |
+| `preparedContactBannerTexts`, `preparedContactRowOpenToConnect` | merged → test 7 | |
+| `preparedContactAddressSendRequestWithoutMessage` | already covered | `ChatListRowsTest.previewContactShouldAcceptForAddress` |
+| `preparedContactSendRequestAlertAddMessage`, `preparedContactAfterConnectShowsContactShouldAccept` | merged → test 8 | |
+| `preparedContactConnectRetryAfterServerError` | drop | needs `SRVCTL` |
+
+Group-link plans are owned by catalogue 03 §8 (legend ownership table) and are not in area A.
+
+## 5. Catalogue corrections (file:line drift, checked 2026-10-20)
+
+| Catalogue says | Actual |
+|---|---|
+| §8 intro `NewChatView.kt:628,671` | `ConnectView` `NewChatView.kt:635`, `PasteLinkView` `:678-720` (click handler `:681-698`) |
+| Paste row `NewChatView.kt:671-699`, empty check `:675` | `:681-698`, empty check `:682` |
+| Progress row `SimpleXAPI.kt:845-874` | `sendCmdWithRetry` `SimpleXAPI.kt:877-913` |
+| Invitation OK `ChatView.kt:2257-2259` | banner `ChatView.kt:2262` |
+| Own link `ConnectPlan.kt:470-476` | `:469-476` (button), `connectViaUri` alert `:424-433` |
+| Known `ChatView.kt:2267` | `ChatView.kt:2270` |
+| Deleted link `SimpleXAPI.kt:1722-1728` | AUTH alert `SimpleXAPI.kt:1757-1764` |
+| Address OK `ChatView.kt:2260` | `ChatView.kt:2263` |
+| Own address `ConnectPlan.kt:463-484` | alert `:463-503` |
+| Address Known `ConnectPlan.kt:216-246` | Known `:216-231`, ContactViaAddress `:232-246` |
+| Bot `ComposeView.kt:1807`, `:1806-1812`; `ChatPreviewView.kt:189` | `ComposeView.kt:1822-1827` (bot), `:1821-1834`; `ChatPreviewView.kt:190-191` |
+| Failed signature `FramedItemView.kt:407` | card `FramedItemView.kt:406-417` (click `:409-411`) |
+| Names `ChatListView.kt:1207`; `SimpleXAPI.kt:1707-1710` | `ChatListView.kt:1248` (key) / `:1253` (`planAndConnect`); NOT_FOUND alert `SimpleXAPI.kt:1743-1746` |
+| URI `TextItemView.kt:373`; `Utils.kt:599-600`; `ChatListView.kt:775-784` | `TextItemView.kt:474`; `Utils.kt:607-609`; `connectIfOpenedViaUri` `ChatListView.kt:782-796` |
+| Card `FramedItemView.kt:400-410`; `ChatModel.kt:5111-5121` | `FramedItemView.kt:406-417`; `infoLine` `ChatModel.kt:5144-5154` |
+| §9 `ComposeView.kt:652,1799-1805`; `ChatView.kt:2251-2268`; `ChatPreviewView.kt:190-191` | `sendConnectPreparedContact` `ComposeView.kt:654-672`, Inv branch `:1815-1820`; banner `ChatView.kt:2254-2271`; row `ChatPreviewView.kt:192-193` |
+| §9 address `ComposeView.kt:672-691,1806-1819` | alert `:674-693`; `SendContactRequestView` `:1538-1568`; branch `:1821-1834` |
+| §9 bot `ComposeView.kt:1807-1812` | `:1822-1827` |
+| §9 picker `ComposeContextProfilePickerView.kt:80-94`; `ComposeView.kt:1686` | `changeProfile` `:80-112`; picker shown at `ComposeView.kt:1701-1707` |
+| §9 retry `ComposeView.kt:667-669`; picker alert `:128-140` | `:669-671`; "Can't change profile" alert `:114-119`, used at `:139-140,178-179` |
+| §9 bot row cites `testShortLinkAddressChangeAutoReply` as the bot reference | that test has no bot; it only shows auto-accept output |
+| Legend strings path | `commonMain/moko-resources/base/strings.xml` (correct in the legend; the brief's `MR/base` is not a path) |
+
+Row edits needed after implementation: rename/re-describe `planInvitationDeletedLinkError` (address, `/da`, merged into
+`searchPasteLinkTriggersConnectPlan`), mark merged names, and drop `planBotAddressShowsBotIcon`'s icon claim.
+
+## 6. Suspected app issues (report only)
+
+1. **Double `hideAlert()` on "Open new chat".** `showOpenChatAlert`'s confirm button runs `onConfirm()` then
+   `hideAlert()` (`views/helpers/AlertManager.kt:402-405`), and `showPrepareContactAlert`'s `onConfirm` first calls
+   `AlertManager.privacySensitive.hideAlert()` itself (`ConnectPlan.kt:727-729`; same in `showPrepareGroupAlert`
+   `:777-778`). Two alerts are popped; if another privacy-sensitive alert is under it, it disappears unseen. Low impact;
+   not reproduced.
+2. **Profile change on API failure still switches the active user.** `ComposeContextProfilePickerView.kt:80-111`: when
+   `apiChangePreparedContactUser` returns `null`, `changeActiveUser_(…, keepingChatId = chat.id)` still runs, so the app
+   switches to the new user while the prepared contact stays with the old one, and the kept chat belongs to the other
+   user. Error path only; not reproduced.
+3. **Empty clipboard text vs no clipboard text.** `NewChatView.kt:682` returns silently for no text but an empty string
+   reaches `strConnectTarget("")` and shows "Invalid link!". Cosmetic; noted because test 1's Android helper must clear
+   the clip, not set it to `""`.
+4. Known: the Android paste screen starts the camera and crashes without one (plan §15.5 item 4) — the reason only test
+   1 uses that route.
+
+## 7. Questions (with suggested answers)
+
+- **Q1. Merge test 6 into the existing `searchPasteLinkTriggersConnectPlan`?** Suggested: yes (no new reset or peer;
+  the existing body is the required opposite state). Alternative: a new `planDeletedAddressLinkError` that repeats the
+  first five lines (violates the no-prefix rule).
+- **Q2. Full-link rows marked `S`:** keep tests 3/4 current-CLI only (`ConnectPlanTest`) and leave the stable-peer
+  variant for when `CliVersion` exists? Suggested: yes; the stable CLI rejects `--show-full-links`.
+- **Q3. Test 1 on Android:** keep it shared with `assumeCamera()` (skipped on Waydroid, like
+  `connectBannerCardOpensPasteLink`), rather than desktop-only? Suggested: shared; it runs on real devices.
+- **Q4. `ConnectScreens.kt`:** a new harness file for the connect helpers (and moving `planConfirm` there) vs adding
+  them to `ChatListFilterScreens.kt`? Suggested: new file; `ChatListFilterScreens.kt` already mixes filters, links and
+  peers.
+- **Q5. `planOwnerSignatureFailed`:** worth adding a `CliPeer` JSON-reading helper now (security-relevant warning), or
+  defer? Suggested: defer to a follow-up with that helper.
diff --git a/plans/ui-tests/drafts/design-B-group-admission-prefs.md b/plans/ui-tests/drafts/design-B-group-admission-prefs.md
new file mode 100644
index 0000000000..f37e8b1fd1
--- /dev/null
+++ b/plans/ui-tests/drafts/design-B-group-admission-prefs.md
@@ -0,0 +1,652 @@
+# Design B: group preferences, member admission and review (catalogue 03 §5, §6, parts of §12)
+
+Status: design only, nothing implemented. Worktree `~/wt-uitest` (branch `nd/desktop-ui-tests`, HEAD `8927c1892`).
+Paths: `C/` = `apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/`, `V/` = `C/views/`,
+`T/` = `apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/`, `H/` = `tests/ChatTests/`,
+Haskell core paths are under `src/Simplex/Chat/`. UI strings are from
+`apps/multiplatform/common/src/commonMain/moko-resources/base/strings.xml` (the `resources/MR/base/strings.xml` path in the
+brief does not exist). Every file:line below was read on 2026-10-20 in this worktree.
+
+## 0. Summary
+
+- 35 catalogue rows (§5: 19, §6: 16) plus 4 rows of §12 are reduced to **10 tests + 3 `@Ignore` stubs**:
+  5 in `GroupPreferencesTest`, 5 in `MemberAdmissionTest`. 8 of the 10 need exactly one group join; 2 need no peer.
+- Peer-side proof everywhere it exists: exact CLI preference lines (`expects`, consecutive), CLI rejections
+  (`bad chat command: …`, `#team: you don't have permission to send messages`), support-scope delivery
+  (`#team (support) alice> …`), and "next line" sentinels proving a pending member got nothing else.
+- Two infrastructure decisions need your answer before implementation (§3): **D1** scoped compose keys for typing in
+  a support chat (two compose fields exist at once on both platforms), **D2** a small order-insensitive peer wait.
+- One likely app bug found by reading (§6.1): unsaved edits on «Group preferences» / «Member admission» are discarded
+  whenever the group's `GroupInfo` changes in the model, e.g. when any message arrives in the group. Proposed as a
+  probe test (T5) that becomes `@KnownAppIssue` if it reproduces.
+- The admission=all bypass race (no `withGroupLock` in `APIAcceptMember`, `Library/Commands.hs:2922-2940`) is not
+  targeted; the review tests avoid it by enabling review before the joiner connects and running `quiesce()` (setup
+  only) before accepting.
+
+## 1. Row-by-row decisions
+
+`keep` = has its own test; `merge → Tn` = asserted inside test Tn (catalogue row moves to Tn's name); `drop` = no
+test (reason). Corrected file:line in the right column; the catalogue's line numbers are from master `d72f68e6d` and
+many drifted.
+
+### §5 Group preferences (19 rows, 1 ignored)
+
+| Row (catalogue name) | Decision | Corrected references / notes |
+|---|---|---|
+| `groupPrefs_disappearingOnWithTtl` | merge → T2 | `V/chat/group/GroupPreferences.kt:109-118` (toggle), `:292-303` (TTL row), `C/views/helpers/CustomTimePicker.kt:83-140`; TTL list `C/model/SimpleXAPI.kt:5624-5625` (600, 3600, 86400, 1 week, 30 d, 90 d, off). H/Profiles.hs:3559 (not 3584) |
+| `groupPrefs_disappearingMessageExpires` | **drop** | Expiry is core timers (`H/Profiles.hs:3559` testEnableTimedMessagesGroup); the app's only part, removing an expired item on the `ChatItemsDeleted` event, is the same path as 02 §D `timed_send30s_bothSidesDelete`; needs `SLOW` + real time. T2 proves the TTL reaches members (`Disappearing messages: on (1 week)`) |
+| `groupPrefs_disappearingOff` | merge → T2 (second save) | `GroupPreferences.kt:115` keeps the old TTL with `enable = OFF`; core prints no param when off (`Types/Preferences.hs:951-956`) |
+| `groupPrefs_directMessagesOff_memberInfoProhibited` | merge → T3 | member-info branches `V/chat/group/GroupMemberInfoView.kt:497-544` (515 on, 531-543 prohibited), alert `:742-747`. GUI groups start with DM off from the core default (`Types/Preferences.hs:573`), not from `AddGroupView.kt` (its `:164` only sets history on) |
+| `groupPrefs_directMessagesForOwnersOnly` | keep = T3 | role row `GroupPreferences.kt:304-313`; core gate `Library/Commands.hs:2632`; H/Profiles.hs:3658 (not 3683) |
+| `groupPrefs_fullDeleteOn` | merge → T2 | `:126-131`; the row's whole verification was the CLI line, which T2 asserts |
+| `groupPrefs_reactionsOff_hidesReactionMenu` | merge → T2 | menu gate `V/chat/item/ChatItemView.kt:404` (not 157), chip `:159-160`; core `Library/Commands.hs:1014-1015` (not 1004) |
+| `groupPrefs_voiceOff_showsNotAllowed` | merge → T2 (owner) | `V/chat/SendMsgView.kt:140-151,377-388`, alert `:587-596` (not 585-594); gate `C/model/ChatModel.kt:2540` `voice.on(membership)` |
+| `groupPrefs_voiceForAdminsOnly` | merge → T4 | same code; alice is the member |
+| `groupPrefs_filesForOwnersOnly` | merge → T2 (as «admins», role mapping) | `:145-151`; core rejection `Library/Commands.hs:4963-4968`; H/Profiles.hs:3727 (not 3752). The attach-button UI is owned by 02 §F (legend) |
+| `groupPrefs_simplexLinksForOwnersOnly` | merge → T2 (owner side, CLI rejection, owner allowed) and T4 (member-side banner) | `:152-158`; banner `V/chat/ComposeView.kt:1751,1754,1757`; core `Library/Commands.hs:839`; H/Profiles.hs:3762 (not 3787) |
+| `groupPrefs_reportsToggleDisabled` | merge → T1 (one assertion) | `:159-164` `disabled = true` at `:161` |
+| `groupPrefs_historyOff_newMemberGetsNoHistory` | merge → T2 (save mapping only); join-based part **dropped** | Sending history is core (`H/Groups.hs:6344`, not 6040); the app part is the toggle mapping, proved by `Recent history: off`. History **on** delivery is asserted in T6 (`[>>]` after acceptance). A second joiner would add a join and its flake (plan §15.4.1) for core-only coverage |
+| `groupPrefs_supportToggleDisabledInGroups` | merge → T1 (one assertion) | `:217` `SupportPreference(disabled = true)` |
+| `groupPrefs_signMessages` | keep as `@Ignore` stub | `:219-221` commented out, inside the channel branch (`:218-240`), not the group branch |
+| `groupPrefs_resetRestoresSaved` | merge → T1 | `:78-80`, buttons `:241-251,341-350`. `isEnabled` is always true on `SectionItemView` keys (guide §2), so "Reset/Save disabled" is checked by effect: Back closes with no alert |
+| `groupPrefs_unsavedChangesAlert` | keep = T1 | `:64-68`, alert `:352-359` |
+| `groupPrefs_readOnlyForMember` | keep = T4 | `:282,314-327`; owner-only buttons `:241` |
+| `groupPrefs_receivedUpdateShownAsEvent` | merge → T4 | item text `C/model/ChatModel.kt:4311-4312,4361-4371` gives `Voice messages: on (admins)`; feature items merge with adjacent feature items (`ChatModel.kt:3485-3493`, merged view shows icons only, `V/chat/item/CIChatFeatureView.kt:28-42`), so T4 puts a message before the change |
+
+### §6 Member admission and review (16 rows, 2 ignored)
+
+| Row | Decision | Corrected references / notes |
+|---|---|---|
+| `memberAdmission_enableReviewAll` | merge → T6 | The effect (the next link joiner is pending) is stronger than the existing-member line; enabling uses the screen's Save. `V/chat/group/MemberAdmission.kt:37-49,83-90,117-125`. CLI `/set admission review #team all` is at H/Groups.hs:3728 (not 3684) |
+| `memberAdmission_readOnlyForNonOwner` | merge → T4 | `MemberAdmission.kt:91-98,126-131` |
+| `memberAdmission_unsavedChangesAlert` | keep = T7 | `MemberAdmission.kt:50-55,148-156` |
+| `review_pendingMemberListedInChatsWithMembers` | merge → T6 | status text `V/chat/group/MemberSupportView.kt:174-175` («pending review»). The row flag icons (`MemberSupportView.kt:254-260`, `V/chatlist/ChatPreviewView.kt:393-396`, not 390-391) have `contentDescription = null`: not observable, not asserted, and not to be keyed (guide §4) |
+| `review_hostChatsWithPendingMember` | merge → T6 | open `MemberSupportView.kt:134-146`; compose actions `V/chat/ComposeView.kt:1730-1744` (not 1715-1729). "Reaches only him" cannot be shown with one member; T6 proves scope delivery and that a main-group message did not reach the pending member |
+| `review_acceptAsMember` | keep = T6 | `V/chat/ComposeContextPendingMemberActionsView.kt:56-68,84-113,115-126` |
+| `review_acceptAsObserver` | keep = T8 | `:98-103` |
+| `review_rejectPendingMember` | keep = T9 | `:42-54,73-82` |
+| `review_acceptFromLongPressMenu` | merge → T8 | `MemberSupportView.kt:147,269-276`; long press = right click via `SectionItemViewLongClickable` `.onRightClick` (`V/helpers/Section.kt:262`) |
+| `review_moderatorAcceptsMember` | **drop**, its distinct part → T4 | Accepting as moderator runs the same app code as T6/T8; the only moderator-specific UI is the «Chats with members» row visibility (`V/chat/group/GroupChatInfoView.kt:693-696`), asserted in T4 when bob promotes alice. The full row needs a second CLI peer, alice's join and the pending joiner's introduction to alice (two extra network handshakes, plan §15.4.1). Core path: H/Groups.hs:3819-3820 |
+| `joinerPendingReview_supportChatAutoOpens` | merge → T10 | `V/chat/ChatView.kt:248-258` (not 246-256) |
+| `joinerPendingReview_messagesAdmins` | merge → T10 | — |
+| `joinerPendingReview_acceptedByAdmin` | keep = T10 | `C/model/ChatModel.kt:1726-1729` («reviewed by admins»); auto-close of the support chat on acceptance `C/model/SimpleXAPI.kt:3300-3320` (not in the catalogue; T10 asserts it). CLI `/accept member` parser `Library/Commands.hs:6519` (not 6274) |
+| `joinerPendingReview_rejected` | **drop** | After `/rm`, the app shows the generic removed state (`ChatModel.kt:1761`, «removed from group») through the same path as any removed member; core-tested (H/Groups.hs:4011-4034, not 3985). Costs a join for no app code that T10 or other removal tests do not reach. Re-add if a pending-specific removal bug shows up (the Android support-chat dispose rule `V/chat/group/MemberSupportChatView.kt:33-45` would then belong in an Android-only test) |
+| `admission_hostPendingApproval` | keep as `@Ignore` stub | H/Groups.hs:3658 (not 3614) |
+| `admission_joinRejectedByHook` | keep as `@Ignore` stub | H/Groups.hs:3629 (not 3585) |
+
+### §12 rows used as the review flow's continuation
+
+| Row | Decision |
+|---|---|
+| `chatsWithMembers_emptyState` | merge → T6 (opposite state before the joiner) and T9 (state after rejection) |
+| `chatsWithMembers_listSearchAndOpen` | open part merged → T6; search part stays in §12 |
+| `chatsWithMembers_removedMemberChatGone` | merge → T9 (`MemberSupportView.kt:89`) |
+| `chatsWithMembers_disabledState` | not touched (needs `/set support off`, §12's own scenario) |
+
+## 2. Test list
+
+| # | Test (class) | Rows covered | Peers | Joins |
+|---|---|---|---|---|
+| T1 | `groupPrefs_unsavedChangesAlert` (GroupPreferencesTest) | unsavedChangesAlert, resetRestoresSaved, reportsToggleDisabled, supportToggleDisabledInGroups | — | 0 |
+| T2 | `groupPrefs_ownerChangesNotifyAndRestrictMembers` (GroupPreferencesTest), new name | disappearingOnWithTtl, disappearingOff, fullDeleteOn, reactionsOff_hidesReactionMenu, voiceOff_showsNotAllowed, filesForOwnersOnly, simplexLinksForOwnersOnly (owner side), historyOff (mapping) | bob | 1 (invitation) |
+| T3 | `groupPrefs_directMessagesForOwnersOnly` (GroupPreferencesTest) | directMessagesForOwnersOnly, directMessagesOff_memberInfoProhibited | bob | 1 (link) |
+| T4 | `groupPrefs_readOnlyForMember` (GroupPreferencesTest) | readOnlyForMember, receivedUpdateShownAsEvent, voiceForAdminsOnly, simplexLinksForOwnersOnly (member side), memberAdmission_readOnlyForNonOwner, moderator visibility of «Chats with members» | bob (host) | 1 (invitation) |
+| T5 | `groupPrefs_unsavedEditsKeptWhenMessageArrives` (GroupPreferencesTest), new row | probe for finding §6.1 | bob | 1 (invitation) |
+| T6 | `review_acceptAsMember` (MemberAdmissionTest) | review_acceptAsMember, memberAdmission_enableReviewAll, review_pendingMemberListedInChatsWithMembers, review_hostChatsWithPendingMember, chatsWithMembers_emptyState, chatsWithMembers_listSearchAndOpen (open) | bob (joiner) | 1 (link, pending) |
+| T7 | `memberAdmission_unsavedChangesAlert` (MemberAdmissionTest) | memberAdmission_unsavedChangesAlert | — | 0 |
+| T8 | `review_acceptAsObserver` (MemberAdmissionTest) | review_acceptAsObserver, review_acceptFromLongPressMenu | bob (joiner) | 1 (link, pending) |
+| T9 | `review_rejectPendingMember` (MemberAdmissionTest) | review_rejectPendingMember, chatsWithMembers_removedMemberChatGone, chatsWithMembers_emptyState (after) | bob (joiner) | 1 (link, pending) |
+| T10 | `joinerPendingReview_acceptedByAdmin` (MemberAdmissionTest) | joinerPendingReview_acceptedByAdmin, supportChatAutoOpens, messagesAdmins | bob (host) | 1 (alice via link, pending) |
+| — | `groupPrefs_signMessages`, `admission_hostPendingApproval`, `admission_joinRejectedByHook` | `@Ignore` stubs with the catalogue reasons | — | 0 |
+
+Files: `T/groups/GroupPreferencesTest.kt`, `T/groups/MemberAdmissionTest.kt` (class map, legend). New screen helpers
+go in a new `T/harness/GroupPrefsScreens.kt` (pattern of `ChatList*Screens.kt`), two small additions to
+`T/harness/Screens.kt` (`GroupInfoScreen`, `MemberInfoScreen`), one helper in `T/harness/PeerLines.kt` (D2).
+
+Joins are minimised by: no test needs more than one join; tests that only check screen logic (T1, T7) use
+`emptyGroup` with no peer; alice joins as a member by invitation (no review applies to invitations,
+`src/Simplex/Chat/Types.hs:1459-1464` is reached only from the link-join path `Library/Internal.hs:1059`).
+
+## 3. Decisions needed before implementation
+
+**D1. Typing in a support chat (T6, T9, T10).** A support chat is a second `ChatView` in a modal
+(`V/chat/group/MemberSupportChatView.kt:159-173`) while the group's `ChatView` stays composed: desktop shows it in the
+center pane next to the end pane (`C/App.kt:390-427,443-452`), Android draws the modal over it. Both compose fields
+carry `Ui.Chat.Message` (`C/platform/PlatformTextField.desktop.kt:121`, `…android.kt:101`) and both send buttons
+`Ui.Chat.Send` (`V/chat/SendMsgView.kt:467`), so `typeInto`/`pressEnter` fail with two matching nodes, and the Android
+harness's Espresso `isAssignableFrom(EditText)` (`android/…/harness/UiTest.kt:249-257,295-303`) is ambiguous.
+- Option A (recommended; §12 needs the same for every support-chat send): key the compose field by context.
+  - `Ui.kt`: `Message = UiKey("chat.compose")`, `Send = Message.part("send")`, `ScopeMessage = UiKey("chat.compose", "scope")`, `ScopeSend = ScopeMessage.part("send")` (tags `chat.compose.send`, `chat.compose[scope]`, `chat.compose.send[scope]`; tests use the constants, no literal `chat.send` exists).
+  - `V/chat/ComposeView.kt:1494`: pass `uiKey = if (chatsCtx.secondaryContextFilter == null) Ui.Chat.Message else Ui.Chat.ScopeMessage` to `SendMsgView`.
+  - `V/chat/SendMsgView.kt:37` new `uiKey: UiKey` parameter (before the lambdas); `:81` passes it to `PlatformTextField`; `SendMsgButton` (`:454`, calls at `:138,248,258`) gets `uiKey.part("send")` in place of the constant at `:467`.
+  - `C/platform/PlatformTextField.kt:12` expect + both actuals: `uiKey` parameter before `onDone`; Android also sets `editText.tag = uiKey.tag` when `uiTestHooksEnabled`.
+  - Android harness: `isMessageField(key) = key.id == Ui.Chat.Message.id`; Espresso matchers add `withTagValue(equalTo(key.tag))`; `pressEnter(key)` clicks `key.part("send")`.
+  - 6 app files, keys only, no-ops in release.
+- Option B (no app change): drop the GUI→peer support sends; T6/T9/T10 keep only peer→GUI support messages
+  (bob's `#team (support) …` shown to alice). Loses the strongest checks of `review_hostChatsWithPendingMember` and
+  `joinerPendingReview_messagesAdmins`.
+
+**D2. `PeerLines.eventuallyAll(timeoutMs, vararg lines)`** (T6, T8, T9): the joiner's three pending-join lines come
+in no guaranteed order (`<###` in H/Groups.hs:3750-3756). `eventually` on one of them can drop another into
+"skipped" and break the next-line sentinel. Sketch (in `T/harness/PeerLines.kt`):
+```kotlin
+fun eventuallyAll(timeoutMs: Long, vararg want: String) {
+  await(timeoutMs, "$name: all of ${want.toList()}") { synchronized(lines) { want.all { w -> lines.any { it == w || stripTime(it) == w } } } }
+  synchronized(lines) { dropThrough(want.maxOf { w -> lines.indexOfFirst { it == w || stripTime(it) == w } }) }
+}
+```
+Lines before the last wanted one go to `skipped`, so error lines among them still fail the test.
+
+## 4. Keys to add (all on elements a test clicks, or the support-chat field it types into)
+
+| Key (`C/ui/Ui.kt`) | App element (file:line) | Change |
+|---|---|---|
+| `Ui.GroupInfo.Preferences` | `V/chat/group/GroupChatInfoView.kt:1033-1039` `GroupPreferencesButton` → `SettingsActionItem` | pass existing `uiKey` |
+| `Ui.GroupInfo.MemberSupport` | `GroupChatInfoView.kt:1016-1030` `MemberSupportButton` → `SettingsActionItemWithContent` | add `uiKey: UiKey? = null` before `content` in `V/usersettings/SettingsView.kt:394`, forward to `SectionItemView` |
+| `Ui.GroupPrefs.MemberAdmission` | `V/chat/group/GroupPreferences.kt:257-263` | `SettingsActionItem(…, uiKey)` |
+| `Ui.GroupPrefs.Toggle(feature)` = `UiKey("groupPrefs.toggle", feature.name)` | call `GroupPreferences.kt:283`; `PreferenceToggleWithIcon` `V/usersettings/SettingsView.kt:456-473` | new `uiKey` before `onChange`, on `DefaultSwitch(modifier = Modifier.ui(uiKey))` (the switch has real Disabled semantics, so `isEnabled` works) |
+| `Ui.GroupPrefs.Role(feature)` + `.option(role ?: "null")` | `GroupPreferences.kt:305` `ExposedDropDownSettingRow` | existing `uiKey`; options keyed by `C/views/helpers/ExposedDropDownSettingRow.kt:77` |
+| `Ui.GroupPrefs.Ttl` + `.option("DropdownValue(value=604800)")` | `GroupPreferences.kt:294`; `C/views/helpers/CustomTimePicker.kt:83-91,114` | new `uiKey` before `onSelected`, forwarded. The option arg is the private data class `DropdownSelection.DropdownValue`'s `toString`; the helper owns that string (fragile but stable for a data class) |
+| `Ui.GroupPrefs.Reset`, `Ui.GroupPrefs.Save` | `GroupPreferences.kt:343,346` | `SectionItemView(…, uiKey)` |
+| `Ui.MemberAdmission.Review` + `.option(MemberCriteria.All)` / `.option("null")` | `V/chat/group/MemberAdmission.kt:118-125` | existing `uiKey` |
+| `Ui.MemberAdmission.Save` | `MemberAdmission.kt:142` | `SectionItemView(…, uiKey)` |
+| `Ui.MemberSupport.Row(groupMemberId)` | `V/chat/group/MemberSupportView.kt:134-150` `SectionItemViewLongClickable` | existing `uiKey` |
+| `Ui.MemberSupport.RowMenu(groupMemberId, "accept")` | `MemberSupportView.kt:273` `ItemAction` | existing `uiKey` |
+| `Ui.Chat.PendingReject`, `Ui.Chat.PendingAccept` | `V/chat/ComposeContextPendingMemberActionsView.kt:42-49,56-63` | `.ui(…)` first in the `Column` modifiers (as `Ui.Chat.RequestAccept`, `ComposeContextContactRequestActionsView.kt:68,88`) |
+| `Ui.Alert.Option(Shared, "acceptAsMember")`, `(Shared, "acceptAsObserver")` | `ComposeContextPendingMemberActionsView.kt:91,98` (buttons-column alert has no keys, `V/helpers/AlertManager.kt:75-105`) | `SectionItemView(…, uiKey = …)` (pattern `GroupMemberInfoView.kt:318`) |
+| `Ui.MemberInfo.Message` | `V/chat/ChatInfoView.kt:1065` `InfoViewActionButton`; `GroupMemberInfoView.kt:882-895` `OpenChatButton`; uses at `GroupMemberInfoView.kt:512,517,519,533` | `uiKey` before `onClick` on `InfoViewActionButton` (on its `IconButton`), forwarded by `OpenChatButton`; only one of the four exists at a time |
+| `Ui.Chat.ScopeMessage`, `Ui.Chat.ScopeSend` | see D1 | — |
+
+Reused without change: `Ui.Alert.Confirm/Dismiss(Shared)` (dialog `AlertManager.kt:160,164`, stacked `:201,205`,
+message `:251`), `Ui.GroupInfo.CreateLink`, `Ui.GroupLink.Share`, `Ui.GroupInfo.Member`, `Ui.Chat.Item`,
+`Ui.Chat.ItemMenu(id, "select"|"reply")`, `Ui.Chat.ItemReaction`, `Ui.Chat.ReactionChip`, `Ui.Chat.Message/Send`,
+`described("Record voice message")` (the mic `IconButton` merges its icon's description,
+`V/chat/SendMsgView.kt:377-388`, string `icon_descr_record_voice_message`), `described("Back")`.
+
+Not keyed on purpose: flag icons, `InfoRow` values (read through unique footer texts instead), «Cancel» in the
+accept alert (never clicked).
+
+## 5. New helpers (`T/harness/GroupPrefsScreens.kt` unless noted)
+
+```kotlin
+// Screens.kt, GroupInfoScreen
+fun preferences(): GroupPreferencesScreen { s.click(Ui.GroupInfo.Preferences); return GroupPreferencesScreen(s) }
+fun chatsWithMembers(): MemberSupportScreen { s.click(Ui.GroupInfo.MemberSupport); return MemberSupportScreen(s) }
+fun close() { s.escape(); s.poll(what = "group info to close") { !ModalManager.end.hasModalsOpen() } }   // callers close sub-screens first, one Back each
+// Screens.kt, MemberInfoScreen
+fun message() = s.click(Ui.MemberInfo.Message)
+
+class GroupPreferencesScreen(private val s: UiScope) {
+  init { s.poll(what = "the `Group preferences` screen") { s.seesText("Group preferences") && s.exists(Ui.GroupPrefs.MemberAdmission) } }
+  fun toggle(f: GroupFeature) = s.click(Ui.GroupPrefs.Toggle(f))
+  fun role(f: GroupFeature, r: GroupMemberRole?) { s.click(Ui.GroupPrefs.Role(f)); s.click(Ui.GroupPrefs.Role(f).option(r ?: "null")) }
+  fun ttl(seconds: Int) { s.click(Ui.GroupPrefs.Ttl); s.click(Ui.GroupPrefs.Ttl.option("DropdownValue(value=$seconds)")) }
+  fun reset() = s.click(Ui.GroupPrefs.Reset)
+  fun save() = s.click(Ui.GroupPrefs.Save)
+  fun admission(): MemberAdmissionScreen { s.click(Ui.GroupPrefs.MemberAdmission); return MemberAdmissionScreen(s) }
+  fun backExpectingAlert(title: String) { s.goBack(); s.poll(what = "the `$title` alert") { s.seesText(title) } }
+  fun backClosing() { s.goBack(); s.poll(what = "group preferences to close without an alert") { !s.exists(Ui.GroupPrefs.MemberAdmission) && !s.seesText("Save preferences?") } }
+}
+
+class MemberAdmissionScreen(private val s: UiScope) {
+  init { s.poll(what = "the `Member admission` screen") { s.seesText("Member admission") && s.seesText("Review members before admitting (\"knocking\").") } }
+  fun review(): List<String> = s.textsOf(Ui.MemberAdmission.Review)
+  fun select(c: MemberCriteria?) { s.click(Ui.MemberAdmission.Review); s.click(Ui.MemberAdmission.Review.option(c ?: "null")) }
+  fun save() = s.click(Ui.MemberAdmission.Save)
+}
+
+fun UiScope.enableReviewAll(info: GroupInfoScreen, group: String) {
+  val adm = info.preferences().admission()
+  adm.select(MemberCriteria.All); adm.save()
+  poll(what = "review=all saved for #$group") { groupInfoOf(group).groupProfile.memberAdmission?.review == MemberCriteria.All }
+  goBack(); goBack()
+}
+
+class MemberSupportScreen(private val s: UiScope) {
+  fun empty() = s.poll(what = "`No chats with members`") { s.seesText("No chats with members") }
+  fun rowTexts(name: String): List<String> = s.textsOf(Ui.MemberSupport.Row(memberId(name)))
+  fun open(name: String): SupportChatScreen { s.click(Ui.MemberSupport.Row(memberId(name))); return SupportChatScreen(s).also { it.waitOpen() } }
+  fun menuAccept(name: String) { val id = memberId(name); s.openContextMenu(Ui.MemberSupport.Row(id)); s.click(Ui.MemberSupport.RowMenu(id, "accept")) }
+  private fun memberId(name: String): Long // poll chatModel.groupMembers like GroupInfoScreen.memberId (Screens.kt:337-344)
+}
+
+class SupportChatScreen(private val s: UiScope) {
+  fun waitOpen() = s.poll(what = "the support chat") { chatModel.secondaryChatsContext.value != null && ModalManager.end.hasModalOpen(ModalViewId.SECONDARY_CHAT) }
+  fun items(): List<ChatItem> = chatModel.secondaryChatsContext.value?.chatItems?.value.orEmpty()
+  fun itemId(text: String): Long // as ChatScreen.itemId (Screens.kt:222-229) over items()
+  fun send(text: String) { s.typeInto(Ui.Chat.ScopeMessage, text); s.poll(what = "the support send button to be enabled") { s.isEnabled(Ui.Chat.ScopeSend) }; s.pressEnter(Ui.Chat.ScopeMessage); s.poll(what = "the support message field to clear") { s.editableText(Ui.Chat.ScopeMessage).isNullOrEmpty() }; s.hideKeyboard() }
+  fun acceptVia(option: String) { s.click(Ui.Chat.PendingAccept); acceptAlert(option) }
+  fun reject() = s.click(Ui.Chat.PendingReject)
+}
+
+fun UiScope.acceptAlert(option: String) {
+  poll(what = "the `Accept member` alert") { seesText("Accept member") && seesText("Member will join the group, accept member?") && seesText("Accept as member") && seesText("Accept as observer") }
+  click(Ui.Alert.Option(Ui.AlertSource.Shared, option))
+}
+
+fun UiScope.pendingLinkJoin(app: App, joiner: CliPeer, group: String): GroupInfoScreen {
+  val info = emptyGroup(app, group).groupInfo()
+  info.chatsWithMembers().empty(); goBack()
+  enableReviewAll(info, group)
+  val link = info.createLink()
+  info.close()
+  joiner sends "/c $link"
+  joiner expects "connection request sent!"
+  joiner.eventuallyAll(CONNECT_TIMEOUT_MS, "#$group: alice accepted you to the group, pending review", "#$group: you joined the group, connecting to group moderators for admission to group")
+  quiesce()
+  return info
+}
+```
+`groupInfoOf(name)` = `(app.chatList.chat(name).chatInfo as ChatInfo.Group).groupInfo`. Alice's side of the pending
+join is checked by each test on the «Chats with members» row (that screen loads the members itself,
+`MemberSupportView.kt:44-46`), so the helper waits only for the joiner's lines and app quiet (setup only). The helper
+sets up review through the UI, which is part of T6's scenario; T8/T9 reuse it as setup (their own steps diverge
+right after, so they are not prefixes of T6).
+
+## 6. Tests
+
+Conventions in pseudo-code: `alice = app("alice")`, `bob = cli("bob")`; `chat` is a `ChatScreen`; every CLI line
+listed is exact; "next line" = `expects`/`expectsMessage`, which proves nothing else arrived.
+
+### T1 `groupPrefs_unsavedChangesAlert` (GroupPreferencesTest, no peer, 0 joins)
+
+- Scenario: the owner changes a preference, resets it, leaves without saving, then saves through the alert; the
+  hard-coded disabled toggles stay disabled.
+- Fails if: Back closes with unsaved changes (`GroupPreferences.kt:66` → `close()` always); Reset does nothing
+  (`:79` removed); «Exit without saving» saves (`:357-358` swapped); Save does not reach the core (`:49` replaced by a
+  model-only update; caught after `restart()`); the reports or support toggle becomes enabled (`:161`, `:217`).
+- Steps:
+```kotlin
+val alice = app("alice")
+val info = emptyGroup(alice, "team").groupInfo()
+var prefs = info.preferences()
+check(isEnabled(Ui.GroupPrefs.Toggle(GroupFeature.Reactions)))                         // negative control
+check(!isEnabled(Ui.GroupPrefs.Toggle(GroupFeature.Reports)) && !isEnabled(Ui.GroupPrefs.Toggle(GroupFeature.Support)))
+poll { seesText("Allow message reactions.") }                                         // opposite first
+prefs.toggle(Reactions); poll { seesText("Prohibit messages reactions.") && !seesText("Allow message reactions.") }
+prefs.reset();           poll { seesText("Allow message reactions.") }
+prefs.backClosing()                                                                    // no alert after reset
+prefs = info.preferences(); prefs.toggle(Reactions)
+prefs.backExpectingAlert("Save preferences?")
+check("Save and notify group members" in textsOf(Ui.Alert.Confirm(Shared)) && "Exit without saving" in textsOf(Ui.Alert.Dismiss(Shared)))
+click(Ui.Alert.Dismiss(Shared)); poll { !exists(Ui.GroupPrefs.MemberAdmission) }
+prefs = info.preferences(); poll { seesText("Allow message reactions.") }              // not saved
+prefs.toggle(Reactions); prefs.backExpectingAlert("Save preferences?"); click(Ui.Alert.Confirm(Shared))
+poll { !exists(Ui.GroupPrefs.MemberAdmission) && groupInfoOf("team").fullGroupPreferences.reactions.enable == GroupFeatureEnabled.OFF }
+info.close(); restart()
+alice.chatList.open("team").groupInfo().preferences(); poll { seesText("Prohibit messages reactions.") }
+```
+- Strings: footers `allow_message_reactions` «Allow message reactions.», `prohibit_message_reactions_group`
+  «Prohibit messages reactions.» (sic), `save_preferences_question`, `save_and_notify_group_members`,
+  `exit_without_saving`, `group_preferences`.
+- Optional extra evidence (catalogue's original check): the command log `chatModel.terminalItems` has no
+  `/_group_profile` before the confirm step (legend "Log").
+- Platform: `goBack()` = Back arrow (desktop) / system Back (Android); both reach `ModalView`'s `close`
+  (`V/helpers/ModalView.kt:42,62`). Flakiness: none (no network).
+
+### T2 `groupPrefs_ownerChangesNotifyAndRestrictMembers` (GroupPreferencesTest, bob, 1 join)
+
+- Scenario: the owner restricts eight preferences in one save; the member is told exactly what changed and is
+  refused; the owner's own UI hides reactions and blocks voice; the owner then reverts two of them.
+- Fails if: any `applyPrefs(preferences.copy(X = …))` writes the wrong field or value
+  (`GroupPreferences.kt:111-169`, e.g. `:135` `copy(reactions=…)` → `copy(fullDelete=…)`); the role dropdown's value is
+  dropped (`:310` `onSelected(enableFeature.value, value)` → `null`); the TTL pick is ignored (`:107`); the role row is
+  shown while off (`:304`); the reaction menu ignores the preference (`ChatItemView.kt:404`); the mic ignores it
+  (`ChatModel.kt:2540` → `true`).
+- Setup: `connect(bob)` (Helpers.kt:26-32), `val chat = ownGroup(alice, "team", bob)` (Screens.kt:377-391; bob prints
+  `#team: alice invites you to join the group as member`, `use /j team to accept`, `#team: you joined the group`).
+  `val link = bob.createOneTimeLink()` (Helpers.kt:56-61), `val file = bob.createFile("p.txt", "x")`
+  (`common/src/desktopTest/…/harness/CliPeer.kt:15-16`; Android through the bridge `file` command).
+- Steps and assertions:
+```kotlin
+chat.send("hi");            bob.expectsMessage("#team alice> hi", CONNECT_TIMEOUT_MS)
+bob sends "+1 #team hi";    bob expects "added 👍"
+val hi = chat.itemId("hi"); poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's 👍 on hi") { exists(Ui.Chat.ReactionChip(hi, "👍")) }
+rightClick(Ui.Chat.Item(hi)); waitFor(Ui.Chat.ItemMenu(hi, "select")); check(exists(Ui.Chat.ItemReaction(hi, "👎")))   // opposite first
+click(Ui.Chat.ItemMenu(hi, "select")); escape(); poll { !exists(Ui.Chat.Selection.part("title")) }
+quiesce()                                                                              // see §6.1
+val info = chat.groupInfo(); val p = info.preferences()
+check(!exists(Ui.GroupPrefs.Ttl) && !exists(Ui.GroupPrefs.Role(DirectMessages)) && exists(Ui.GroupPrefs.Role(Voice)))
+p.toggle(TimedMessages); poll { "1 day" in textsOf(Ui.GroupPrefs.Ttl) }; p.ttl(7 * 86400)
+p.toggle(DirectMessages); poll { "all members" in textsOf(Ui.GroupPrefs.Role(DirectMessages)) }; p.role(DirectMessages, Owner)
+p.toggle(FullDelete); p.toggle(Reactions); p.toggle(Voice); poll { !exists(Ui.GroupPrefs.Role(Voice)) }
+p.role(Files, Admin); p.role(SimplexLinks, Owner); p.toggle(History)
+p.save()
+bob.expectsMessage("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS)   // next line after `added 👍`: nothing else arrived
+bob expects "updated group preferences:"
+bob expects "Disappearing messages: on (1 week)"
+bob expects "Direct messages: on for owners"
+bob expects "Full deletion: on"
+bob expects "Message reactions: off"
+bob expects "Voice messages: off"
+bob expects "Files and media: on for admins"
+bob expects "SimpleX links: on for owners"
+bob expects "Recent history: off"
+p.backClosing(); info.close()
+rightClick(Ui.Chat.Item(hi)); waitFor(Ui.Chat.ItemMenu(hi, "select")); check(!exists(Ui.Chat.ItemReaction(hi, "👎")) && exists(Ui.Chat.ItemMenu(hi, "reply")))
+click(Ui.Chat.ItemMenu(hi, "select")); escape(); poll { !exists(Ui.Chat.Selection.part("title")) }
+click(described("Record voice message"))
+poll { seesText("Voice messages prohibited!") && seesText("Only group owners can enable voice messages.") }; click(Ui.Alert.Confirm(Shared))
+bob sends "+^ #team hi";        bob expects "bad chat command: feature not allowed Message reactions"
+bob sends "#team $link";        bob expects "bad chat command: feature not allowed SimpleX links"
+bob sends "/f #team $file";     bob expects "bad chat command: feature not allowed Files and media"
+chat.send(link);                bob.expectsMessage("#team alice> $link", CONNECT_TIMEOUT_MS)    // owner allowed (role gate, other branch)
+val p2 = chat.groupInfo().preferences()
+p2.toggle(TimedMessages); poll { !exists(Ui.GroupPrefs.Ttl) }; p2.toggle(Reactions); p2.save()
+bob.expectsMessage("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS); bob expects "updated group preferences:"
+bob expects "Disappearing messages: off"; bob expects "Message reactions: on"
+p2.backClosing(); /* close group info */
+rightClick(Ui.Chat.Item(hi)); waitFor(Ui.Chat.ItemMenu(hi, "select")); check(exists(Ui.Chat.ItemReaction(hi, "👎")))   // both branches
+click(Ui.Chat.ItemMenu(hi, "select")); escape()
+bob sends "+^ #team hi"; bob expects "added 🚀"
+```
+- Peer lines: View.hs `viewGroupUpdated` `src/Simplex/Chat/View.hs:2113-2147` (header `:2122`, list `:2129-2137` in
+  `regularGroupFeatures` order `Types/Preferences.hs:280-293,318-319`), text `groupPrefStateText`
+  `Types/Preferences.hs:951-962`, TTL text `:969-990` («1 week»), `CECommandError` → `bad chat command: …`
+  (`View.hs:2879`); reaction lines from H/Groups.hs:4380-4389; files and links from H/Profiles.hs:3747-3748,3778-3781.
+  None of these match `PeerLines.ERROR_LINE` (`PeerLines.kt:105`), and all are consumed with `expects`.
+- UI strings: `delete_after`, `feature_roles_all_members` «all members», `voice_messages_prohibited`,
+  `only_group_owners_can_enable_voice`. `1 day` from `CustomTimeUnit.toText` (`C/model/SimpleXAPI.kt:5836`, `ttl_day`).
+- Platform: desktop keeps the chat visible next to group info; Android covers it, so every chat action follows
+  closing the modals (as `memberInfo_blockForAllNotifiesMembers`, `T/groups/GroupLinksTest.kt:81-84`). Never tap the
+  mic while voice is allowed (desktop records through VLC, `common/src/desktopMain/…/platform/RecAndPlay.desktop.kt:31-40`;
+  Android has RECORD_AUDIO granted).
+- Flakiness: one invitation join; `quiesce()` before opening the screen so no group event replaces `GroupInfo`
+  while editing (finding §6.1); the menu is dismissed through Select + Escape (pattern `T/chat/FilesTest.kt:79-84`).
+- If you prefer smaller tests: split off the second save as its own test only at the cost of one more join (it
+  needs the first save as setup, so the guide's prefix rule argues for keeping it here).
+
+### T3 `groupPrefs_directMessagesForOwnersOnly` (GroupPreferencesTest, bob, 1 join)
+
+- Scenario: in a group with DMs off the owner cannot message a member from member info; she enables DMs for owners
+  only; the member is still refused, the owner can now open a direct chat.
+- Fails if: the member-info branch ignores the preference (`GroupMemberInfoView.kt:515` → `false`: alert stays) or
+  ignores the role (`.on(groupInfo.membership)` → `.on`, not observable on alice as owner, so the role is checked on
+  the peer); the role is not saved (`GroupPreferences.kt:122-123` drops `role`); the «Enabled for» row shows while
+  off or not when on (`:304`).
+- Setup: `val info = emptyGroup(alice, "team").groupInfo(); val link = info.createLink()`; `bob sends "/c $link"`,
+  `bob expects "connection request sent!"`, `bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)`
+  (pattern `T/groups/GroupLinksTest.kt:18-28`); bob is not alice's contact, so member info shows the group branches
+  (`GroupMemberInfoView.kt:498`). `quiesce()`.
+- Steps:
+```kotlin
+info.member("bob").message()
+poll { seesText("Can't message group member") && seesText("Direct messages between members are prohibited in this group.") }
+click(Ui.Alert.Confirm(Shared)); goBack()
+bob sends "@alice hi"; bob expects "bad chat command: direct messages not allowed"
+val p = info.preferences(); check(!exists(Ui.GroupPrefs.Role(DirectMessages)))
+p.toggle(DirectMessages); poll { "all members" in textsOf(Ui.GroupPrefs.Role(DirectMessages)) }
+p.role(DirectMessages, Owner); p.save()
+bob.expectsMessage("alice updated group #team: (signed)", CONNECT_TIMEOUT_MS); bob expects "updated group preferences:"; bob expects "Direct messages: on for owners"
+p.backClosing()
+bob sends "@alice hi"; bob expects "bad chat command: direct messages not allowed"        // role gate
+info.member("bob").message()
+poll(what = "a direct chat with bob opened instead of the alert") {
+  (chatModel.chats.value.firstOrNull { it.id == chatModel.chatId.value }?.chatInfo as? ChatInfo.Direct)?.contact?.displayName == "bob" && !seesText("Can't message group member")
+}
+```
+- Peer: `@alice` for a non-contact member goes to `SendMemberContactMessage` (`Library/Commands.hs:2597-2611`), refused
+  at `:2632`. The last step stops before sending, so §11 `memberContact_createAndSendInvitation` is not duplicated
+  (`createMemberContact` `GroupMemberInfoView.kt:109-124` only creates the contact and opens the chat).
+- Strings: `cant_send_message_to_member_alert_title` «Can't message group member»,
+  `direct_messages_are_prohibited_in_group`.
+- Platform: member info is an end-pane modal on desktop, full screen on Android; after `message()` succeeds the app
+  calls `closeAll()`. Flakiness: one link join.
+
+### T4 `groupPrefs_readOnlyForMember` (GroupPreferencesTest, bob host, 1 join)
+
+- Scenario: alice, a member of bob's group, sees preferences and admission read-only; host changes appear live and
+  as a chat item; voice for admins only blocks her mic; links for owners only blocks her send with a banner until bob
+  allows links for all; after bob makes her a moderator «Chats with members» appears and «Chat with admins» goes.
+- Fails if: a member gets toggles or Save (`GroupPreferences.kt:282` → `if (true)`, or `:241`); admission is editable
+  for members (`MemberAdmission.kt:117` / `:91`); the mic ignores the role (`ChatModel.kt:2540`); the links banner
+  ignores the role (`ChatModel.kt:2582` → `p.simplexLinks.on`) or does not clear when allowed (`ComposeView.kt:1751`);
+  the moderator gate breaks (`GroupChatInfoView.kt:693` / `:637-639`).
+- Setup: `connect(bob); hostGroup(bob, "team", "alice"); joinGroupFromList(alice, bob, "team")` (Helpers.kt:42-48,
+  69-78). `val link = bob.createOneTimeLink()`. bob's group has core defaults (voice on, links on, support on,
+  `Types/Preferences.hs:568-586`).
+- Steps:
+```kotlin
+val chat = alice.chatList.open("team")
+var p = chat.groupInfo().preferences()
+check(!exists(Ui.GroupPrefs.Toggle(Voice)) && !seesText("Save and notify group members") && !seesText("Reset"))
+check(seesText("Members can send voice messages.") && seesText("Members can send SimpleX links.") && !seesText("admins"))
+val adm = p.admission(); check(!exists(Ui.MemberAdmission.Review) && seesText("off") && !seesText("all"))
+bob sends "/set admission review #team all"; bob expects "changed member admission rules"
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "alice's read-only admission to show all") { seesText("all") }
+goBack(); p.backClosing(); /* close group info */
+bob sends "#team before voice"; chat.itemId("before voice")                            // breaks feature-item merging
+bob sends "/set voice #team on admin"; bob expects "updated group preferences:"; bob expects "Voice messages: on for admins"
+val ev = chat.itemId("Voice messages: on (admins)"); check(textsOf(Ui.Chat.Item(ev)).any { "Voice messages: on (admins)" in it })
+click(described("Record voice message"))
+poll { seesText("Voice messages prohibited!") && seesText("Only group owners can enable voice messages.") }; click(Ui.Alert.Confirm(Shared))
+p = chat.groupInfo().preferences(); poll { seesText("Members can send voice messages.") && seesText("Enabled for") && seesText("admins") }
+p.backClosing(); /* close group info */
+bob sends "/set links #team on owner"; bob expects "updated group preferences:"; bob expects "SimpleX links: on for owners"
+poll(timeoutMs = CONNECT_TIMEOUT_MS) { !groupInfoOf("team").groupFeatureEnabled(GroupFeature.SimplexLinks) }
+typeInto(Ui.Chat.Message, link)
+poll { seesText("SimpleX links not allowed") && !isEnabled(Ui.Chat.Send) }
+bob sends "/set links #team on"; bob expects "updated group preferences:"; bob expects "SimpleX links: on"
+poll(timeoutMs = CONNECT_TIMEOUT_MS) { !seesText("SimpleX links not allowed") && isEnabled(Ui.Chat.Send) }
+pressEnter(Ui.Chat.Message); bob.expectsMessage("#team alice> $link", CONNECT_TIMEOUT_MS)
+var gi = chat.groupInfo(); poll { seesText("Chat with admins") && !exists(Ui.GroupInfo.MemberSupport) }
+gi.close()
+bob sends "/mr #team alice moderator"; bob.eventuallyMatching(Regex("#team: you changed the role of alice to moderator( \\(signed\\))?"))
+gi = chat.groupInfo(); poll(timeoutMs = CONNECT_TIMEOUT_MS) { exists(Ui.GroupInfo.MemberSupport) && !seesText("Chat with admins") }
+gi.chatsWithMembers().empty()
+```
+- Peer lines: own `/set` outputs as H/Profiles.hs:3389-3391,3769-3770; admission `View.hs:2139-2141`;
+  `/mr` parser `Library/Commands.hs:6520`, output `View.hs:1437` (exact `(signed)` suffix to confirm on the first run,
+  then replace the regex by the exact line). `/accept`-free.
+- Strings: `group_members_can_send_voice`, `group_members_can_send_simplex_links`, `feature_enabled_for`,
+  `feature_roles_admins`, `simplex_links_not_allowed`, `button_support_chat` «Chat with admins», `member_support`,
+  `no_support_chats`, `member_criteria_off`/`member_criteria_all`, item text `featureText` (`ChatModel.kt:4361-4371`).
+  «off»/«all» are checked only while the admission screen is the top modal (only one modal is composed).
+- Platform: the link banner sits above the compose field; on Android `hideKeyboard()` is not needed before reading
+  it. Flakiness: one invitation join; each host change is awaited in the model or on screen with
+  `CONNECT_TIMEOUT_MS` (event delivery). Optional split: links + moderator visibility into a second test (+1 join).
+
+### T5 `groupPrefs_unsavedEditsKeptWhenMessageArrives` (GroupPreferencesTest, bob, 1 join; probe, then `@KnownAppIssue`)
+
+- Scenario: the owner is editing preferences when a member writes in the group; her unsaved edit stays.
+- Why: `GroupPreferencesView` keys both states on `gInfo` (`GroupPreferences.kt:43-44`
+  `rememberSaveable(gInfo, …)`), and `gInfo` is re-derived from the model (`:37-41`). Every new item replaces the
+  chat's `ChatInfo` (`ChatModel.kt:573-582` → `updateChatInfo` `:466-489`), and `GroupInfo` carries `chatTs`,
+  `updatedAt`, `groupSummary`, `membersRequireAttention` (`ChatModel.kt:2505-2525`). If the event's `GroupInfo`
+  differs from the model's, the edit silently resets. `MemberAdmission.kt:34-35` has the same pattern.
+- Steps: `ownGroup(alice, "team", bob)`; `quiesce()`; open preferences; `toggle(Reactions)`;
+  `poll { seesText("Prohibit messages reactions.") }`; `bob sends "#team hello"`;
+  `poll(CONNECT) { chatModel.chatsContext.chatItems.value.any { it.content.text == "hello" } }`; `settle()`;
+  `check(seesText("Prohibit messages reactions."))`; `save()`; bob expects the three lines ending
+  `Message reactions: off`.
+- Fails if the bug exists (that is the point). Run it once unannotated: if it fails at the `check`, add
+  `@KnownAppIssue("15.5 item 7", "<exact check message>")` and a plan §15.5 entry; if it passes, keep it unannotated
+  as a regression test for any future `rememberSaveable(gInfo)` change, or drop it if you think the trigger is too
+  narrow. A stronger trigger if a message does not change `GroupInfo`: a member leaving (`bob sends "/l team"`,
+  updates `groupSummary`), then check the footer only.
+
+### T6 `review_acceptAsMember` (MemberAdmissionTest, bob joiner, 1 join)
+
+- Scenario: the owner turns on review, a link joiner waits as «pending review» in «Chats with members», the owner
+  talks to him there, accepts him as member, and he gets history and later messages.
+- Fails if: Save on the admission screen does nothing (`MemberAdmission.kt:37-49`; bob would join without review and
+  print `#team: you joined the group` only); the pending member is not listed (`MemberSupportView.kt:89`) or shows his
+  role instead of status (`:174`); the compose actions do not appear for a pending member or stay for an accepted one
+  (`ComposeView.kt:1735`); «Accept as member» sends the wrong role (`ComposeContextPendingMemberActionsView.kt:93` →
+  `Observer`: row shows «observer») or nothing (`:62`).
+- Steps:
+```kotlin
+val alice = app("alice"); val bob = cli("bob")
+val info = pendingLinkJoin(alice, bob, "team")       // includes: «No chats with members» first, enableReviewAll, link
+val chat = ChatScreen(this)
+chat.send("before review")                            // main group; bob is pending
+val cwm = chat.groupInfo().chatsWithMembers()
+poll(timeoutMs = CONNECT_TIMEOUT_MS) { cwm.rowTexts("bob").let { "bob" in it && "pending review" in it } }
+val sc = cwm.open("bob")
+poll { sc.items().any { it.content.text == "New member wants to join the group." } && "Accept" in textsOf(Ui.Chat.PendingAccept) && "Reject" in textsOf(Ui.Chat.PendingReject) }
+sc.send("hi")
+bob.expectsMessage("#team (support) alice> hi", CONNECT_TIMEOUT_MS)   // next line: "before review" never reached bob
+bob sends "#team (support) hello"; sc.itemId("hello")
+sc.acceptVia("acceptAsMember")
+bob.eventuallyAll(CONNECT_TIMEOUT_MS, "#team: you joined the group", "#team alice> before review [>>]")
+poll(timeoutMs = CONNECT_TIMEOUT_MS) { chatModel.secondaryChatsContext.value == null && cwm.rowTexts("bob").let { "member" in it && "pending review" !in it } }
+cwm.open("bob"); sc.itemId("hello"); check(!exists(Ui.Chat.PendingAccept) && !exists(Ui.Chat.PendingReject))   // other branch
+/* close modals */ chat.send("after accept"); bob.expectsMessage("#team alice> after accept", CONNECT_TIMEOUT_MS)
+```
+- Peer lines: `View.hs:1387` (accepted you, pending review), `:1350-1363` (`connecting to group moderators…`), support
+  echo format H/Groups.hs:3787-3800, history `[>>]` H/Groups.hs:3823-3826. With alice as the only moderator bob prints
+  no `member … is connected` lines. The history order after acceptance is deterministic on one connection but D2 makes
+  the test independent of it; `after accept` as the next line proves no duplicate history or stray group line.
+- Strings: `member_support`, `no_support_chats`, `group_member_status_pending_review`, `group_member_role_member`,
+  `rcv_group_event_new_member_pending_review` «New member wants to join the group.», `accept_pending_member_button`,
+  `reject_pending_member_button`, `accept_pending_member_alert_title` «Accept member»,
+  `accept_pending_member_alert_question`, `…_confirmation_as_member`, `…_confirmation_as_observer`.
+- Platform: on Android `SupportChatScreen.send` hides the soft keyboard (the actions sit right above the field);
+  on desktop the main chat is visible beside the support chat, which is why D1 is needed. Desktop plan §15.5 item 2
+  (first tap after typing lost) is avoided because `click` focuses a focusable target first
+  (`common/src/desktopTest/…/harness/UiTest.kt:229-235`); if `PendingAccept` turns out not focusable, record it.
+- Flakiness: one link join with review (plan §15.4.1 applies); `quiesce()` once after the join (setup), never between
+  user actions; accept happens with no profile update in flight (the known race needs a concurrent profile update).
+
+### T7 `memberAdmission_unsavedChangesAlert` (MemberAdmissionTest, no peer, 0 joins)
+
+- Scenario: the owner selects «all», leaves without saving, comes back, selects again and saves through the alert.
+- Fails if: Back closes with changes (`MemberAdmission.kt:52`); the selection is not applied (`:85-89`); the alert's
+  buttons are swapped (`:153-154`).
+- Steps:
+```kotlin
+val info = emptyGroup(alice, "team").groupInfo(); val p = info.preferences()
+var a = p.admission(); poll { "off" in a.review() }
+a.select(MemberCriteria.All); poll { "all" in a.review() }
+goBack(); poll { seesText("Save admission settings?") && "Save and notify group members" in textsOf(Ui.Alert.Confirm(Shared)) && "Exit without saving" in textsOf(Ui.Alert.Dismiss(Shared)) }
+click(Ui.Alert.Dismiss(Shared)); poll { !seesText("Review members before admitting (\"knocking\").") }
+check(groupInfoOf("team").groupProfile.memberAdmission?.review == null)
+a = p.admission(); poll { "off" in a.review() }
+a.select(MemberCriteria.All); goBack(); poll { seesText("Save admission settings?") }; click(Ui.Alert.Confirm(Shared))
+poll { groupInfoOf("team").groupProfile.memberAdmission?.review == MemberCriteria.All && !seesText("Save admission settings?") }
+a = p.admission(); poll { "all" in a.review() }
+```
+- Strings: `member_admission`, `admission_stage_review` «Review members», `admission_stage_review_descr`,
+  `save_admission_question`, `member_criteria_off`/`_all`. Admission changes create no chat item for alice, so the
+  model and the reopened screen are the evidence; T6 proves a saved «all» takes effect.
+
+### T8 `review_acceptAsObserver` (MemberAdmissionTest, bob joiner, 1 join)
+
+- Scenario: the owner accepts a pending joiner from the row's context menu as observer; he can read but not post.
+- Fails if: the menu item is missing (`MemberSupportView.kt:272-276`); «Accept as observer» sends `Member`
+  (`ComposeContextPendingMemberActionsView.kt:100`: bob's post is accepted, `expects` fails).
+- Steps: `val info = pendingLinkJoin(alice, bob, "team")`; `val cwm = ChatScreen(this).groupInfo().chatsWithMembers()`;
+  `poll { "pending review" in cwm.rowTexts("bob") }`; `cwm.menuAccept("bob")`; `acceptAlert("acceptAsObserver")`;
+  `bob.eventually("#team: you joined the group", CONNECT_TIMEOUT_MS)`;
+  `poll(CONNECT) { "observer" in cwm.rowTexts("bob") && "pending review" !in cwm.rowTexts("bob") }`;
+  `bob sends "#team hi"`; `bob expects "#team: you don't have permission to send messages"` (`View.hs:2831-2833`);
+  close modals; `chat.send("for observers")`; `bob.expectsMessage("#team alice> for observers", CONNECT_TIMEOUT_MS)`.
+  The GUI group has no prior messages, so no `[>>]` lines precede (history on, nothing to send).
+- Platform: `openContextMenu` right click (desktop) / long press (Android), `Section.kt:262`.
+
+### T9 `review_rejectPendingMember` (MemberAdmissionTest, bob joiner, 1 join)
+
+- Scenario: the owner opens the pending joiner's chat, cancels a reject, then rejects; he is removed and his chat
+  disappears from «Chats with members».
+- Fails if: «Reject» opens the accept flow or nothing (`ComposeContextPendingMemberActionsView.kt:48`); Cancel rejects
+  (`AlertManager.kt:160` wiring); the removed member's row stays (`MemberSupportView.kt:89`).
+- Steps:
+```kotlin
+pendingLinkJoin(alice, bob, "team"); val cwm = ChatScreen(this).groupInfo().chatsWithMembers()
+val sc = cwm.open("bob")
+sc.reject(); poll { seesText("Reject member?") && "Reject" in textsOf(Ui.Alert.Confirm(Shared)) && "Cancel" in textsOf(Ui.Alert.Dismiss(Shared)) }
+click(Ui.Alert.Dismiss(Shared)); poll { !seesText("Reject member?") && exists(Ui.Chat.PendingReject) }
+sc.send("still pending"); bob.expectsMessage("#team (support) alice> still pending", CONNECT_TIMEOUT_MS)   // Cancel sent nothing
+sc.reject(); poll { seesText("Reject member?") }; click(Ui.Alert.Confirm(Shared))
+bob.expectsMessage("#team: alice removed you from the group (signed)", CONNECT_TIMEOUT_MS); bob expects "use /d #team to delete the group"
+poll(CONNECT) { chatModel.secondaryChatsContext.value == null }; cwm.empty()
+```
+- Peer: `View.hs:537` + `groupPreserved`; H/Groups.hs:4029-4032. The removal is the next line after `still pending`
+  (`expectsMessage` with `CONNECT_TIMEOUT_MS`; `stripTime` is a no-op on event lines), so nothing else reached bob.
+- Strings: `reject_pending_member_alert_title` «Reject member?», `reject_pending_member_button`, `cancel_verb`,
+  `no_support_chats`. With D1 option B, replace the `still pending` sentinel by `bob sends "#team (support) ping"` and
+  check that the next bob line after Confirm is the removal.
+
+### T10 `joinerPendingReview_acceptedByAdmin` (MemberAdmissionTest, bob host, 1 join)
+
+- Scenario: alice joins a group whose host reviews members; the support chat opens by itself, the main compose says
+  «reviewed by admins», she writes to the admins and gets their reply; group messages sent while she waits do not
+  reach her; after the host accepts her the support chat closes and she can post.
+- Fails if: the support chat does not open (`ChatView.kt:248-258`); the compose is not blocked while pending
+  (`ChatModel.kt:1726-1729`); the support chat does not close on acceptance (`SimpleXAPI.kt:3306-3319`); the app
+  shows the pending main-group message.
+- Setup (bob): `val link = bob.createGroupLink("team")` (`T/harness/ChatListFilterScreens.kt:88-94`: `/g team`,
+  `/create link #team`, `Group link is created!`); `bob sends "/set admission review #team all"`;
+  `bob expects "changed member admission rules"`. Alice joins with `joinLink(link)`
+  (`ChatListFilterScreens.kt:62-67`; API precondition, joining by link is owned by §8);
+  `bob.eventuallyAll(CONNECT_TIMEOUT_MS, "alice: accepting request to join group #team...", "#team: alice connected and pending review")`
+  (`View.hs:542,1371`); `poll(CONNECT) { groupInfoOf("team").membership.memberStatus == GroupMemberStatus.MemPendingReview }`; `quiesce()`.
+- Steps:
+```kotlin
+val chat = alice.chatList.open("team")
+val sc = SupportChatScreen(this); sc.waitOpen()
+poll { seesText("Chat with admins") && sc.items().any { it.content.text == "Please wait for group moderators to review your request to join the group." } }
+if (appPlatform.isDesktop) poll { seesText("reviewed by admins") }       // main chat stays visible only on desktop
+sc.send("hello admins"); bob.expectsMessage("#team (support: alice) alice> hello admins", CONNECT_TIMEOUT_MS)
+bob sends "#team while pending"
+bob sends "#team (support: alice) hi alice"; sc.itemId("hi alice")
+check(chatModel.chatsContext.chatItems.value.none { it.content.text == "while pending" })   // later message arrived, earlier group one did not
+bob sends "/accept member #team alice"; bob expects "#team: alice accepted"
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the support chat to close after acceptance") { chatModel.secondaryChatsContext.value == null && !ModalManager.end.hasModalsOpen() }
+poll { !seesText("reviewed by admins") }
+chat.send("hi all"); bob.expectsMessage("#team alice> hi all", CONNECT_TIMEOUT_MS)
+```
+- Notes: bob's group has history off (core default), so `while pending` never arrives; the check after acceptance
+  could repeat after `hi all`. The auto-close uses a real-time `delay(1000)` on `Dispatchers.Default`
+  (`SimpleXAPI.kt:3313-3317`), not tracked by `UiIdle`; `poll` waits for it in real time.
+- Strings: `support_chat` «Chat with admins» (title, `MemberSupportChatView.kt:111`), `reviewed_by_admins`,
+  `snd_group_event_user_pending_review`.
+- Platform: on Android the support chat covers the group chat and closing it while pending also closes the group
+  chat (`MemberSupportChatView.kt:33-45`), so the test never closes it while pending; the «reviewed by admins» check
+  before acceptance is desktop-only (real UI difference, guide §3). Flakiness: one link join.
+
+## 6.1 Suspected app findings (report, do not fix)
+
+1. **Unsaved group preference / admission edits are discarded when the group's `GroupInfo` changes**
+   (`GroupPreferences.kt:43-44`, `MemberAdmission.kt:34-35`, model replacement `ChatModel.kt:466-489,573-582`).
+   Realistic in any active group: the owner toggles several preferences, a message or member event arrives, the
+   toggles snap back with no notice, and Save sends only what was changed after the reset. T5 probes it.
+2. **Save through the unsaved-changes alert closes the screen even when the save fails**
+   (`GroupPreferences.kt:46-60`, `MemberAdmission.kt:37-48`: `afterSave()` runs whether or not `apiUpdateGroup`
+   returned a group). Minor; the API error alert is probably shown, but the edits are lost. Not tested (needs a
+   failing core call).
+3. **The «SimpleX links not allowed» state can be stale when link previews are off**
+   (`ComposeView.kt:1087`: `hasSimplexLink` includes the group permission at typing time, so a later prohibition is
+   not shown until the text changes; with previews on, `:509` does not include it and `:1751` re-checks). Minor; not
+   tested (the harness keeps previews on).
+4. Not a bug, catalogue correction: «Direct messages» off in GUI groups comes from the core default
+   (`Types/Preferences.hs:573`), not from `AddGroupView.kt` (it sets only history on, `:164`).
+5. Cosmetic: `strings.xml:2317` `<string name="chat_preferences_off">off</string>`` has a stray backtick after the
+   element (outside the string value, harmless).
+
+## 7. Catalogue edits to apply after the tests pass
+
+- §5: rows merged as in §1 (names moved into T1–T4's `Test case(s)` cells); new names
+  `groupPrefs_ownerChangesNotifyAndRestrictMembers` and `groupPrefs_unsavedEditsKeptWhenMessageArrives`; removed
+  `groupPrefs_disappearingMessageExpires` and the join-based history test; Needs: T1 `—`, T2 `P, XFTP`, T3–T5 `P`.
+- §6: `memberAdmission_enableReviewAll` → T6, `memberAdmission_readOnlyForNonOwner` → T4, `review_*` merges as in §1,
+  `review_moderatorAcceptsMember` and `joinerPendingReview_rejected` removed with the reasons above;
+  `joinerPendingReview_*` Needs become `P` (no `CB`: the link comes from the CLI and `joinLink` uses the API).
+- §12: `chatsWithMembers_emptyState` and `chatsWithMembers_removedMemberChatGone` move into T6/T9.
+- All corrected file:line references from §1; Haskell line numbers as listed.
+- Recount with `tools/recount.py` and regenerate the class map (legend "Count rules").
+
+## 8. Mutation checklist for the PR (one per test, must turn the test red)
+
+| Test | Mutation |
+|---|---|
+| T1 | `GroupPreferences.kt:66` `if (preferences == currentPreferences) close() else …` → `close()` |
+| T2 | `GroupPreferences.kt:135` `copy(reactions = …)` → `copy(fullDelete = …)` |
+| T3 | `GroupMemberInfoView.kt:515` condition → `false` |
+| T4 | `GroupPreferences.kt:282` `if (groupInfo.isOwner)` → `if (true)` |
+| T5 | (probe) remove `gInfo` from `rememberSaveable` keys at `GroupPreferences.kt:43-44` should make it pass if it failed |
+| T6 | `ComposeContextPendingMemberActionsView.kt:93` `GroupMemberRole.Member` → `Observer` |
+| T7 | `MemberAdmission.kt:153-154` swap `onConfirm`/`onDismiss` |
+| T8 | `ComposeContextPendingMemberActionsView.kt:100` `Observer` → `Member` |
+| T9 | `MemberSupportView.kt:89` drop the `MemRemoved` filter |
+| T10 | `SimpleXAPI.kt:3306-3319` remove the auto-close block |
diff --git a/plans/ui-tests/drafts/design-C-database.md b/plans/ui-tests/drafts/design-C-database.md
new file mode 100644
index 0000000000..f797bded7b
--- /dev/null
+++ b/plans/ui-tests/drafts/design-C-database.md
@@ -0,0 +1,689 @@
+# Design C: database tests (catalogue 04 §G)
+
+Status: design only. Nothing below has been built or run. All file:line references were read in `~/wt-uitest` on 2026-10-20 (branch `nd/desktop-ui-tests`); paths are relative to `apps/multiplatform/common/src/` unless they start with `android/`, `src/` (Haskell core) or `plans/`. UI strings are from `commonMain/moko-resources/base/strings.xml`: the brief's `resources/MR/base` path does not exist, and the legend's path is the right one.
+
+## 0. Summary and decisions that need approval
+
+Selected: **10 tests**: 7 shared, 2 desktop-only and 1 shared known-issue test. Together they cover 25 of the 35 rows. Of the rest, 7 rows are deferred, 2 stay IGNORE and 1 is dropped. The tests aim at data-loss and lock-out regressions: change passphrase, remove and re-save the passphrase, startup passphrase prompt, stop/start, stopped state across restart, export + import (data, settings, real messaging afterwards), invalid import, delete database, "Delete messages after", and the incompatible-database screen.
+
+The work needs these test enablers. **Each one needs user approval** (diff-scope rule):
+
+| # | Change | Where | Needed by |
+|---|---|---|---|
+| H1 | File-chooser responders `saveFileAs(file) { action }`, `openFile(file) { action }` and `exchangeDir()` on both `UiScope`s. Desktop completes `simplexWindowState.saveDialog/openDialog` (public `DialogState.isAwaiting`/`onResult`, `desktopMain/.../DesktopApp.kt:294-308`). Android stubs `ACTION_CREATE_DOCUMENT`/`ACTION_GET_CONTENT` with Espresso-Intents, answered with a `FileProvider` URI. No app change. | `desktopTest/.../harness/UiTest.kt`, `android/.../harness/UiTest.kt` | T4, T5 |
+| H2 | `restart(ready, what)` parameter on both `UiScope.restart`. The defaults keep today's behaviour. | both `UiTest.kt` | T7 on Android, T8 (desktop) |
+| H3 | Shared `UiScope.typeSecret(key, text)` in `Helpers.kt`, a copy of the private `HiddenProfilesTest.kt:148-152`. The two existing private copies (also `OnboardingTest.kt:302-307`) stay untouched unless you approve removing them. | `uiTestShared/.../harness/Helpers.kt` | T4–T8 |
+| H4 | A new screen file `DatabaseScreens.kt` (navigation and form helpers only). | `uiTestShared/.../harness/` | all |
+| K | App keys only (section 4): `Ui.Settings.Database`, `Ui.Database.*` (8), `Ui.DbPassphrase.*` (5), plus a `uiKey` parameter on `TtlOptions` and on the expect/actual `SavePassphraseSetting`. | `commonMain`, `desktopMain`, `androidMain` | all |
+| C | Catalogue edits: merged rows get one name, IGNORE → `@KnownAppIssue` for `dbMgmt_importInvalidArchive`, file:line corrections (section 5). Plan §15.5 gets new items 7–9 (section 6). | `plans/ui-tests/catalogue/04-…md`, plan | — |
+
+Without H2, T7 (`dbEncrypt_removeFromSettings`) becomes desktop-only (`DatabaseEncryptionDesktopTest`) and T8 cannot be written. Without H1, T4 and T5 cannot be written; the alternative is calling `exportChatArchive`/`importArchive` directly, which is not allowed because it bypasses the feature under test.
+
+## 1. Harness and app facts that shape the design (verified)
+
+1. **The reset survives anything these tests leave behind.** Desktop `resetForTest` (`desktopTest/.../harness/UiTestApp.kt:60-86`): `stopCore` skips `chatCloseStore` when the controller is null (the state after a DB-error screen, :117-119). It then deletes the DB files, `PrefStores.restore()` rewrites `settings.properties` from the boot capture (StoreDBPassphrase, EncryptedDBPassphrase, InitialRandomDBPassphrase, ChatStopped, PrivacyLinkPreviews), and `DbTemplate.installIfPresent` (`DbTemplate.kt:16-22`) copies the template and writes its key. A changed or removed passphrase, a stopped chat, a deleted or imported DB and a pending DB-error screen therefore do not leak into the next test. If a test ends with no controller, `UiTest.kt:60-63` re-inits an empty core. Android does the same (`android/.../UiTestApp.kt:74-98`, `DbTemplate.install` :141-148 removes the Keystore alias when the template key is empty).
+2. **Android template is decrypted** (`android/.../UiTestApp.kt:37-45`). On Android the database passphrase screen therefore starts in the "not encrypted" state: footer "Your chat database is not encrypted - set passphrase to protect it." (`androidMain/.../DatabaseEncryptionView.android.kt:66-67`), and the first passphrase goes through "Encrypt database?" / "Encrypt". Desktop starts from the random key: "Change database passphrase?" / "Update" (`DatabaseEncryptionView.kt:172-182`). Both end in "Database encrypted!" (:485), use the same `Ui.Alert.Confirm` key, and afterwards show the "Current passphrase…" field (:147). A shared helper can therefore set the first passphrase without a platform branch. `DbTemplate.install` sets `initialRandomDBPassphrase=true` on Android too, so export is prohibited on both platforms until a passphrase is set.
+3. **Neither `restart()` can wait for a "Start chat?" alert, and Android `restart()` cannot reach a DB-error screen.**
+   - Desktop `restart()` (`desktopTest/.../UiTest.kt:93-102`) polls `chatDbStatus != null && !ctrlInitInProgress`. While "Start chat?" is pending, `initChatController` is suspended in `startChat().await()` (`Core.kt:170`, alert at `Core.kt:226-236`) with `ctrlInitInProgress` true, so the poll times out.
+   - Android `restart()` (`android/.../UiTest.kt:86-96`) needs `chatRunning == true && currentUser != null`, which never happens on a passphrase prompt.
+   - Desktop restart into a DB-error screen already works: `OnboardingTest.kt:156-158` does it. Hence H2.
+4. **The desktop file chooser is a plain `CompletableDeferred`.** `FileChooserLauncher.launch` awaits `simplexWindowState.saveDialog/openDialog.awaitResult` (`desktopMain/.../platform/Files.desktop.kt:69-83`). The AWT dialog is composed only by the real window (`DesktopApp.kt:135-165`), never in the test scene, and the harness currently completes pending dialogs empty at reset (`Reset.kt:85-94`).
+   - On Android the launcher is `rememberLauncherForActivityResult` with `CreateDocument`/`GetContent` (`androidMain/.../Files.android.kt:37-43`). The harness already stubs every external intent as RESULT_CANCELED (`android/.../UiTest.kt:138`); a later `intending` stub takes precedence.
+   - `getFileName(uri)` on Android queries `OpenableColumns.DISPLAY_NAME` (`Utils.android.kt:231-243`), so a `file://` URI gives `null` and the import silently does nothing (`DatabaseView.kt:758-775`). It must be a `content://` URI from the app's own `FileProvider` (`android/src/main/res/xml/file_paths.xml`: `files-path /`, authority `"$APPLICATION_ID.provider"`, used at `Utils.android.kt:167`).
+   - The file must live under `context.filesDir`. The import's `apiDeleteStorage` removes only `files/app_files`, `files/assets` and `files/temp_files` (`src/Simplex/Chat/Archive.hs:122-135`), so `files/uitest-exchange/` survives it. The next reset's `deleteChatDatabaseFilesAndState` deletes `filesDir` recursively (`DatabaseView.kt:569`), which cleans it up.
+5. **Masked fields.** `PassphraseField` uses `PasswordVisualTransformation` (`DatabaseEncryptionView.kt:382-385`), so `typeInto`/`replaceText`, which compare `EditableText` with the typed text, cannot be used. Tests type with `typeSecret` and compare lengths (H3). To retype, reopen the screen: the fields are `remember`ed per composition (:52-54).
+6. **Setting a shorter TTL deletes immediately.** `APISetChatItemTTL` runs `expireChatItems user newTTL True` synchronously when the TTL gets shorter (`src/Simplex/Chat/Library/Commands.hs:1894-1903`). For contacts the deletion is by `chat_items.created_at` only (`src/Simplex/Chat/Store/Messages.hs:3621`). Backdating `created_at` alone keeps the item last by `item_ts`, so it stays the chat-list preview until it is deleted. `/sql chat` runs arbitrary SQL (`Commands.hs:686`); there is a precedent for a `CC.Console("/sql chat …")` precondition at `ChatListRequestsCardsCompatTest.kt:27`.
+7. **Export leaves the chat stopped.** `exportArchive` returns false (`DatabaseView.kt:630`), so `stopChatRunBlockStartChat` does not restart the chat (:541).
+8. **Import ends with a passphrase prompt and then a "Start chat?" alert.**
+   - The import removes the stored key (`DatabaseView.kt:724`). Its stop set `ChatStopped=true` (`stopChatAsync` :509-513), and the follow-up `startChat` fails before `controller.startChat`, which is what resets `ChatStopped` (`SimpleXAPI.kt:724`).
+   - So "Save passphrase and open chat" runs `runChat` with `startChat = ::showStartChatAfterRestartAlert` (`DatabaseErrorView.kt:226-228`), and "Start chat?" appears. The catalogue row omits this alert.
+9. **Core-side "chat running".** `CC.CheckChatRunning()` (`SimpleXAPI.kt:4002`) answers `CR.ChatRunning` or `CR.ChatStopped`. It reads core state, not `chatModel.chatRunning`, which the app sets itself. It serves as the persisted/core-level evidence where no peer can observe the state.
+
+## 2. Row decisions
+
+KEEP = selected now. MERGE = folded into the named test. DEFER = the row stays, not in this batch. DROP = remove the row. Corrected file:line references are in section 5.
+
+| Catalogue row (line) | Test name(s) | Decision | Reason |
+|---|---|---|---|
+| 172 Layout | `chatData_layout` | MERGE → T1 | Its only non-trivial content, the footer naming the current profile, is asserted in T1; every item is acted on by some test, so a missing item fails there. |
+| 173 TTL change | `chatData_ttlIncrease_noAlert`, `…Decrease_alertConfirm`, `…Decrease_alertCancel` | KEEP as T1 (`chatData_ttlDecrease_alertConfirm`), the other two MERGE | Same screen and picker. The cancel, confirm and increase branches of one condition (`DatabaseView.kt:79-83`) belong in one test. |
+| 174 TTL custom seconds | `chatData_ttlCustomSecondsShown` | DEFER | Cosmetic; needs a console command and a restart. |
+| 175 TTL per profile | `chatData_ttlPerProfile` | DEFER | Needs a second profile; lower data-loss value than T1. T1 checks the footer names the current user. |
+| 176 TTL expiry | `chatData_ttlExpiresMessages` | DEFER (partly covered by T1) | T1 covers the immediate expiry when the TTL is set (`Commands.hs:1899-1901`), which is what the user triggers. Background expiry at start (30 s thread) stays SLOW/FIXTURE. |
+| 177 Delete files | `chatData_deleteFilesAndMedia` | KEEP as T9 (lower priority) | Data loss: deleting files must keep messages and restart the chat. |
+| 178 Files label | `chatData_deleteFilesLabelForMultipleProfiles` | DEFER | Label only. |
+| 179 DB mgmt layout | `dbMgmt_layout` | DROP | Pure layout: every row in it is clicked by T2–T6, and the desktop-only "Open database folder" is IGNORE. |
+| 180 Run chat | `dbMgmt_stopChat`, `dbMgmt_startChat` | KEEP merged as T2 `dbMgmt_stopAndStartChat` (rename) | `startChat` is the second half of the same scenario; separate tests would be prefixes of each other. |
+| 181 Stopped restart | `dbMgmt_stoppedStatePersistsRestart` | KEEP desktop-only as T8 | Needs H2. On Android, relaunching the activity while init awaits the alert risks the plan §15.4 item 10 freeze. |
+| 182 Export blocked | `dbMgmt_exportProhibitedWithRandomPassphrase` | MERGE → T4 | It is the opposite state of T4's export step. |
+| 183 Export | `dbMgmt_exportArchive` | MERGE → T4 | "Importable" is proven only by importing; a separate export test would be a prefix of T4. |
+| 184 Import | `dbMgmt_importArchive_restoresData` | KEEP as T4 | The data-loss core. |
+| 185 Import invalid | `dbMgmt_importInvalidArchive` | KEEP as T5, IGNORE → `@KnownAppIssue` | A known app bug is a visible result per the guide §6, not IGNORE; it also wipes all data (§6 B1). |
+| 186 Settings import | `dbMgmt_importRestoresAppSettings` | MERGE → T4 | One precondition and one assertion on T4's import. |
+| 187 Delete DB | `dbMgmt_deleteDatabase` | KEEP as T6 | — |
+| 188 Open folder | `dbMgmt_openDatabaseFolder` | stays IGNORE | `Desktop.isDesktopSupported()` false headless (`Files.desktop.kt:37`). |
+| 189 Remote | `dbMgmt_disconnectMobilesWhenRemote` | DEFER | Needs a mobile host (§K harness not built). |
+| 190 First passphrase | `dbEncrypt_setFirstPassphrase` | MERGE → T3 | T3 sets the first passphrase through the UI and asserts its outcome; a separate test would be T3's prefix. |
+| 191 Change | `dbEncrypt_changePassphrase`, `dbEncrypt_wrongCurrentPassphrase` | KEEP as T3, wrong-current MERGE | A wrong current passphrase followed by the correct one proves the DB still uses the old key. |
+| 192 Store | `dbEncrypt_removeFromSettings`, `dbEncrypt_saveToSettings` | KEEP as T7, save MERGE | One scenario: stop storing the passphrase, then store it again. |
+| 193 Footers | `dbEncrypt_footerStates` | MERGE → T7 | The footers are the on-screen evidence of each storage state T7 passes through. |
+| 194 Unencrypted | `dbEncrypt_footerUnencrypted` | DEFER | Desktop needs an unencrypted-DB FIXTURE. On Android it is the harness start state (§1.2), but asserting it in a shared test would branch on harness state. |
+| 195 Startup prompt | `dbError_enterPassphraseOnStartup_open`, `dbError_wrongPassphrase` | MERGE → T7 | The prompt is reached naturally after "Remove". `OnboardingTest.onboardingPassphrasePersistsAcrossRestart` (desktop only) covers the same view from onboarding; T7 adds the settings path and Android. |
+| 196 Save and open | `dbError_saveAndOpen` | MERGE → T7 (also T4) | T7 reaches it with "Save passphrase in settings" on and no stored key, exactly the row's state, without editing settings by hand. |
+| 197 Upgrade confirm | `dbError_upgradeConfirmation` | DEFER | Needs a down-SQL fixture and developer tools (SQL fixtures not built, plan §0.5.11). |
+| 198 Downgrade | `dbError_incompatibleDowngrade` | KEEP desktop-only as T10 (lower priority) | The fixture is one in-test `/sql chat INSERT INTO migrations`; this is the screen a user sees after installing an older app. It becomes shared if H2 is approved. |
+| 199 Restore backup | `dbError_restoreBackup` | DEFER | Needs `.bak` files under another key and EncryptionStartedAt; not reachable through the UI (backups are deleted on the next chat start, `SimpleXAPI.kt:726-729`). |
+| 200 Error folder | `dbError_openDatabaseFolder` | stays IGNORE | Same as 188. |
+
+## 3. The tests
+
+Shared tests: package `chat.simplex.app.ui.settings`, classes per the class map: `ChatDataTest` for the `chatData_*`/`dbMgmt_*` names, `DatabaseEncryptionTest` for the `dbEncrypt_*`/`dbError_*` names. Desktop-only tests: `chat.simplex.app.ui.desktop.ChatDataDesktopTest` and `DatabaseEncryptionDesktopTest`.
+
+Existing helpers cited (desktop `UiTest.kt`; Android has the same names):
+
+| Helper | Location | Helper | Location | Helper | Location |
+|---|---|---|---|---|---|
+| `app` | :86 | `waitFor` | :136 | `cli` | :304 |
+| `restart` | :93 | `click` | :206 | `poll` | :308 |
+| `textOf` | :104 | `enterText` | :232 | `seesDescription` | :348 |
+| `storedSetting` | :112 | `textsOf` | :273 | `seesText` | :351 |
+| `exists` | :134 | `escape` | :200 | | |
+
+- Android: `app` :80, `restart` :86, `storedSetting` :331.
+- `connect` `Helpers.kt:26`.
+- `App.settings()` `Screens.kt:31`; `chatList.open` :81, `.rowTexts` :92, `.row` :52; `ChatScreen.itemTexts` :240, `.send` :274.
+- `backToChatList` `ChatListToolbarScreens.kt:60`.
+- Peer: `sends` `PeerLines.kt:17`, `expectsMessage` :29.
+- `AlertManager.shared.hasAlertsShown()` `AlertManager.kt:54`.
+- New helpers are named `NEW` and specified in section 4.
+
+---
+
+### T1 `chatData_ttlDecrease_alertConfirm` (shared, `ChatDataTest`)
+
+Rows: 173 (all three names), 172. Needs: P (bob).
+
+**Scenario.** Alice has an old message and a recent one from bob. She sets "Delete messages after" to 1 day. "Cancel" in the warning changes nothing. "Delete messages" removes the old message and keeps the recent one. Raising the period to 1 week asks nothing.
+
+**This test fails if:**
+- the confirmation does not apply the TTL. Mutation: `DatabaseView.kt:339` `onConfirm = { setCiTTL(…) }` → `onConfirm = {}`; the expired message stays;
+- Cancel applies it anyway: `:340` `onDismiss = { setCiTTL(m, rhId, selectedChatItemTTL, progressIndicator, appFilesCountAndSize) }`; the core TTL becomes Day after Cancel;
+- the increase asks for confirmation: `:79` `if (it < oldValue)` → `if (it != oldValue)`; an alert appears for 1 week.
+
+**Setup.** `val alice = app("alice"); val bob = cli("bob"); connect(bob)`. `bob sends "@alice kept message"`, then `bob sends "@alice expired message"`. `poll { "expired message" in alice.chatList.rowTexts("bob") }`. Then `val expiredId = alice.chatList.chat("bob").chatItems.last().id` and `backdateItemViaSql(expiredId)` (NEW, test-private): `CC.Console("/sql chat UPDATE chat_items SET created_at = '2020-01-01 00:00:00' WHERE chat_item_id = $expiredId")`. The result must not be an `API.Error`. A fixed old literal avoids depending on the timestamp format, and `item_ts` is left alone so the item stays the preview.
+
+**Steps and assertions** (opposite state first):
+```kotlin
+val data = chatData(alice)                                   // NEW: settings > "Chat data"
+check(seesText("This setting applies to messages in your current chat profile alice.", substring = true))
+check(data.ttlText() == "never" && coreTtl() == ChatItemTTL.None)   // coreTtl = runBlocking { chatController.getChatItemTTL(null) } (SimpleXAPI.kt:1481)
+data.selectTtl(ChatItemTTL.Day)                               // NEW: click(Ui.Database.Ttl); click(Ui.Database.Ttl.option(ChatItemTTL.Day))
+poll("the deletion alert") { seesText("Enable automatic message deletion?") && "Delete messages" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+poll("TTL back to never") { !AlertManager.shared.hasAlertsShown() && data.ttlText() == "never" }
+check(coreTtl() == ChatItemTTL.None)
+data.selectTtl(ChatItemTTL.Day); poll(alert as above); click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll("TTL 1 day in the picker and the core") { data.ttlText() == "1 day" && coreTtl() == ChatItemTTL.Day }
+data.selectTtl(ChatItemTTL.Week)
+poll("TTL 1 week without an alert") { data.ttlText() == "1 week" && coreTtl() == ChatItemTTL.Week }
+check(!AlertManager.shared.hasAlertsShown())
+data.close()                                                  // NEW: escape + poll to the chat list
+poll("bob's preview is the kept message") { alice.chatList.rowTexts("bob").let { "kept message" in it && "expired message" !in it } }
+val texts = alice.chatList.open("bob").itemTexts()
+check("kept message" in texts && "expired message" !in texts)
+```
+The bob row's preview is the screen evidence: `afterSetCiTTL` reloads the chats (`DatabaseView.kt:841-851`).
+
+Strings: "Chat data", "Delete messages after", "never", "1 day", "1 week", "Enable automatic message deletion?", "Delete messages", "Cancel", "This setting applies to messages in your current chat profile".
+
+**Keys:** `Ui.Settings.Database`, `Ui.Database.Ttl` (section 4).
+
+**Harness impact:** the TTL lives in the DB, which the reset deletes; nothing to clean.
+
+**Platform and flakiness.** Shared. On Android the dropdown is a popup; `click` handles popups, as in `AppearanceScreen.colorMode`. The option key's argument is the `ChatItemTTL` object, whose tag uses `toString()`, stable within one process. No timing risk: the deletion is synchronous before `setCiTTL` returns, and the picker poll waits for it.
+
+---
+
+### T2 `dbMgmt_stopAndStartChat` (shared, `ChatDataTest`; replaces `dbMgmt_stopChat` and `dbMgmt_startChat`)
+
+Rows: 180. Needs: P (bob).
+
+**Scenario.** Alice opens "Database passphrase & export" and turns off "Chat is running". "Cancel" keeps it running; "Stop" stops it. While stopped, bob's message is not received. Turning the chat on delivers it, and alice can reply.
+
+**This test fails if:**
+- stopping does not stop the core: `DatabaseView.kt:510` `m.controller.apiStopChat()` removed; `CheckChatRunning` still says running;
+- starting does not restart it: `:428` `m.controller.startChat(user)` removed; bob's message never arrives and bob never gets the reply;
+- the confirmation is skipped: `:396` `stopChatAlert()` → `authStopChat(chatModel)`; no "Stop chat?" alert.
+
+**Steps:**
+```kotlin
+val alice = app("alice"); val bob = cli("bob"); connect(bob)
+val db = chatData(alice).management()                         // NEW: click(Ui.Database.Management)
+check(seesText("Chat is running") && coreRunning())           // coreRunning = sendCmd(null, CC.CheckChatRunning()).result is CR.ChatRunning
+click(Ui.Database.RunChat)
+poll { seesText("Stop chat?") && seesText("Stop chat to export, import or delete chat database. You will not be able to receive and send messages while the chat is stopped.") }
+click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+poll { !AlertManager.shared.hasAlertsShown() && seesText("Chat is running") }; check(coreRunning())
+click(Ui.Database.RunChat); poll(alert); check("Stop" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)))
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll("chat stopped on screen, on disk and in the core") {
+  seesText("Chat is stopped") && seesText("You must use the most recent version of your chat database on one device ONLY", substring = true) &&
+  storedSetting("ChatStopped") == "true" && !coreRunning()
+}
+bob sends "@alice sent while stopped"
+check(chatModel.chats.value.first { it.chatInfo.chatViewName == "bob" }.chatItems.none { it.text == "sent while stopped" })
+click(Ui.Database.RunChat)
+poll { seesText("Chat is running") && storedSetting("ChatStopped") == "false" && coreRunning() }
+db.close()
+poll(CONNECT_TIMEOUT_MS, "bob's queued message after start") { "sent while stopped" in alice.chatList.rowTexts("bob") }
+alice.chatList.open("bob").send("back online")
+bob expectsMessage "alice> back online"
+```
+The model check before the start alone is weak, because delivery may simply not have happened yet. The core-level `!coreRunning()` proves the stop; the arrival after start proves nothing was lost.
+
+**Keys:** `Ui.Database.Management`, `Ui.Database.RunChat`.
+
+**Harness impact:** the test ends running. If it fails while stopped, `stopCore` skips `stopChatAsync` and the reset continues normally.
+
+**Platform:** shared. On desktop `stopChat` closes `ModalManager.end` (center) modals only (`DatabaseView.kt:496-498`); the settings modal is in `ModalManager.start` and stays. Flakiness: the arrival waits on the network, hence `CONNECT_TIMEOUT_MS`.
+
+---
+
+### T3 `dbEncrypt_changePassphrase` (shared, `DatabaseEncryptionTest`)
+
+Rows: 190, 191 (both names). Needs: P (bob), RESTART.
+
+**Scenario.**
+1. Alice sets her own database passphrase.
+2. She then tries to change it with a wrong current passphrase: "Wrong passphrase!".
+3. She reopens the screen and changes it with the correct current one: "Database encrypted!".
+4. After an app restart the chat opens without a prompt, bob's earlier message is still there, and messaging works. The agent DB was re-keyed too.
+
+**This test fails if:**
+- the new key is not stored: `DatabaseEncryptionView.kt:478` `ksDatabasePassword.set(new)` → `set(currentKey.value)`; the restart lands on the "Wrong database passphrase" screen instead of the chat list;
+- the wrong current passphrase is not recognised: `:455` branch removed; the alert shows "Error encrypting database" instead;
+- the re-key is not done: `:450` replaced with `null`; the stored key P2 does not open the DB at restart.
+
+**Steps:**
+```kotlin
+val alice = app("alice"); val bob = cli("bob"); connect(bob)
+bob sends "@alice before passphrase change"; poll { "before passphrase change" in alice.chatList.rowTexts("bob") }
+val pass = chatData(alice).management().passphrase()          // NEW: click(Ui.Database.Passphrase); waitFor(Ui.DbPassphrase.New)
+check(!exists(Ui.DbPassphrase.Current))                        // random or unencrypted DB: no current field (:147)
+check(storedSetting("InitialRandomDBPassphrase") == "true")    // precondition only (harness-set)
+pass.setFirst(P1)                                              // NEW, section 4
+check(exists(Ui.DbPassphrase.Current) && storedSetting("InitialRandomDBPassphrase") == "false")
+val storedAfterFirst = storedSetting("EncryptedDBPassphrase")
+pass.change(current = "wrong-$P1", new = P2)                   // NEW: types, clicks Update, confirms "Change database passphrase?"/"Update"
+poll { seesText("Wrong passphrase!") && seesText("Please enter correct current passphrase.") }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+check(storedSetting("EncryptedDBPassphrase") == storedAfterFirst)
+pass.reopen()                                                  // NEW: escape to "Database passphrase & export", click(Ui.Database.Passphrase); fresh fields
+pass.change(current = P1, new = P2)
+poll { seesText("Database encrypted!") }; click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll("chat restarted and the new key stored") { chatModel.chatRunning.value == true && storedSetting("EncryptedDBPassphrase").let { it != null && it != storedAfterFirst } }
+val after = restart()
+poll("chat list without a passphrase prompt") { after.chatList.shown("bob") && !seesText("Encrypted database") && !seesText("Wrong database passphrase") }
+val chat = after.chatList.open("bob")
+check("before passphrase change" in chat.itemTexts())
+chat.send("after passphrase change"); bob expectsMessage "alice> after passphrase change"
+```
+Strings: "Database passphrase", "New passphrase…", "Confirm new passphrase…", "Current passphrase…", "Update database passphrase", "Change database passphrase?", "Update", "Wrong passphrase!", "Please enter correct current passphrase.", "Database encrypted!".
+
+**Keys:** `Ui.Database.Passphrase`, `Ui.DbPassphrase.Current/New/Confirm/Update`.
+
+**Harness impact:** the reset restores the key (§1.1). The restart uses the stored key, and the default `restart()` works on both platforms.
+
+**Platform:**
+- Shared. The first-passphrase alert differs (§1.2); `setFirst` does not assert its title.
+- Android stores the key in the Keystore: `EncryptedDBPassphrase` is the Keystore-encrypted blob, which still changes on each set. Desktop stores it as plaintext Base64 (`desktopMain/.../Cryptor.desktop.kt:3-17`).
+- After typing on Android, call `hideKeyboard()` before `escape()`.
+
+**Flakiness.** `sqlcipher_export` under arm64 translation can take seconds. The waits are `poll` on states, extended while `apiStorageEncryption` is in flight. Run a Keystore smoke check on Waydroid once.
+
+**Note.** The wrong attempt leaves the chat stopped (§6 B3). The test does not assert the running state between the two attempts, so it stays green; the next `change` stops and restarts the chat itself (`DatabaseEncryptionView.kt:73`).
+
+---
+
+### T4 `dbMgmt_importArchive_restoresData` (shared, `ChatDataTest`)
+
+Rows: 182, 183, 184, 186 (and `dbError_saveAndOpen`'s screen). Needs: P (bob), FD (H1).
+
+**Scenario.**
+1. Alice tries to export. "Set passphrase to export" sends her to the passphrase screen, where she sets one.
+2. She exports to a file; the chat stops.
+3. She turns the chat back on and receives a new message from bob.
+4. She imports the archive and enters its passphrase.
+5. She is asked "Start chat?" and starts the chat.
+6. Bob's message from before the export is there, the newer one is gone, a setting saved in the archive is restored, and messaging bob still works.
+
+**This test fails if:**
+- the random-passphrase guard is lost: `DatabaseView.kt:251` → `if (false)`; no alert, and the save dialog opens at once;
+- the export never offers a file: `:617` `saveArchiveLauncher.launch(…)` removed;
+- the import does not import: `:722` `apiImportArchive(config)` removed; no bob after reopening;
+- settings are not restored: `:723` `shouldImportAppSettings.set(true)` removed; PrivacyLinkPreviews stays `true`.
+
+**File choosing.** H1 (section 4). `val zip = File(exchangeDir(), "export.zip")`.
+
+**Steps:**
+```kotlin
+val alice = app("alice"); val bob = cli("bob"); connect(bob)
+bob sends "@alice before export"; poll { "before export" in alice.chatList.rowTexts("bob") }
+setLinkPreviewsPrefDirectly(false)                             // NEW test-private: appPrefs.privacyLinkPreviews.set(false); precondition, not the feature
+check(storedSetting("PrivacyLinkPreviews") == "false")
+val db = chatData(alice).management()
+click(Ui.Database.Export)
+poll { seesText("Set passphrase to export") && seesText("Database is encrypted using a random passphrase. Please change it before exporting.") }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+waitFor(Ui.DbPassphrase.New)                                   // the passphrase screen opened (DatabaseView.kt:253-255)
+PassphraseScreen(this).setFirst(P)
+goBackTo(Ui.Database.Export)                                   // NEW: hideKeyboard(); escape(); poll exists
+check(!zip.exists())
+saveFileAs(zip) { click(Ui.Database.Export) }                  // H1
+poll("the archive written") { zip.length() > 0 && ZipFile(zip).use { z -> z.entries().toList().map { it.name }.containsAll(listOf("simplex_v1_chat.db", "simplex_v1_agent.db")) } }
+poll("chat left stopped after export") { seesText("Chat is stopped") }
+setLinkPreviewsPrefDirectly(true); check(storedSetting("PrivacyLinkPreviews") == "true")
+click(Ui.Database.RunChat); poll { seesText("Chat is running") }
+bob sends "@alice after export"
+db.close(); poll(CONNECT_TIMEOUT_MS) { "after export" in alice.chatList.rowTexts("bob") }
+chatData(alice).management()
+openFile(zip) { click(Ui.Database.Import) }                    // H1
+poll { seesText("Import chat database?") && "Import" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll(30_000) { seesText("Chat database imported") && seesText("Restart the app to use imported chat database.") }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll { seesText("Encrypted database") && seesText("Database passphrase is required to open chat.") && "Save passphrase and open chat" in textsOf(Ui.DbError.Open) }
+check(storedSetting("EncryptedDBPassphrase") == null)          // removed by the import (:724)
+typeSecret(Ui.DbError.Passphrase, P); click(Ui.DbError.Open)
+poll(30_000) { seesText("Start chat?") && seesText("Chat is stopped. If you already used this database on another device, you should transfer it back before starting chat.") }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll(30_000, "chat list with bob from the archive") { chatModel.chatRunning.value == true && alice.chatList.shown("bob") }
+check(storedSetting("PrivacyLinkPreviews") == "false" && storedSetting("ShouldImportAppSettings") == "false" && storedSetting("EncryptedDBPassphrase") != null)
+val chat = alice.chatList.open("bob")
+chat.itemTexts().let { check("before export" in it && "after export" !in it) }
+chat.send("after import"); bob expectsMessage "alice> after import"
+```
+Strings: "Export database", "Set passphrase to export", "Database is encrypted using a random passphrase. Please change it before exporting.", "Chat is stopped", "Chat is running", "Import database", "Import chat database?", "Import", "Chat database imported", "Restart the app to use imported chat database.", "Encrypted database", "Database passphrase is required to open chat.", "Save passphrase and open chat", "Start chat?", "Chat is stopped. If you already used this database on another device, you should transfer it back before starting chat.".
+
+**Keys:** `Ui.Database.Export`, `Ui.Database.Import`, `Ui.Database.RunChat`, and the existing `Ui.DbError.*`.
+
+**Why bob's "after import" works.** Alice sends nothing between the export and the import, so her archived sending ratchet is current. Bob must not send after the import: alice's archived receive state would report a skipped message (an integrity item), and the peer-error rule would not catch that on alice's side, but it would add noise.
+
+**Harness impact:** desktop `exchangeDir` lives in the test directory, deleted after a pass. Android `files/uitest-exchange` is deleted by the next reset (§1.4). Any "Start chat?" left pending by a failure leaks an awaiting job, which the next reset abandons after 30 s (`UiTestApp.drain`, `stopCore` clears `ctrlInitInProgress`): slow, but it recovers.
+
+**Platform:**
+- Shared through H1.
+- Desktop quirk, consistent here: the desktop import launcher keeps the `stopped` value from the screen's first composition (§6 B2). In this flow it equals the real value (false), because the management screen is recomposed after the passphrase screen closes and the chat is running at import time.
+- Android shows "Save passphrase in Keystore" (not acted on).
+
+**Flakiness.** The longest test (connect, re-key, export, import), estimated at 60–90 s on Android, within the 300 s watchdog.
+
+---
+
+### T5 `dbMgmt_importInvalidArchive` (shared, `ChatDataTest`, `@KnownAppIssue("15.5 item 7", "the Error importing chat database alert")`)
+
+Rows: 185. Needs: FD (H1). Replaces the row's IGNORE.
+
+**Scenario.** Alice imports a file that is not a chat archive. She must see "Error importing chat database", and her profile must still be there.
+
+**Today** (§6 B1): no alert. All data is wiped and onboarding appears. The test fails at the first poll and is reported as a skipped known issue. Once the bug is fixed, the mutation is reverting the fix.
+
+**Steps:**
+```kotlin
+val alice = app("alice")
+val notes = alice.chatList.open("Private notes"); notes.send("my note"); backToChatList()
+val bad = File(exchangeDir(), "not-an-archive.zip").apply { writeText("not a zip") }
+chatData(alice).management()
+openFile(bad) { click(Ui.Database.Import) }
+poll { seesText("Import chat database?") }; click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll(30_000, "the Error importing chat database alert") { seesText("Error importing chat database") }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll("alice and her note still there") { chatModel.currentUser.value?.displayName == "alice" && !exists(Ui.Onboarding.GetStarted) }
+check("my note" in alice.chatList.open("Private notes").itemTexts())
+```
+The second assertion (data kept) requires the fix to validate the archive before `apiDeleteStorage` (`DatabaseView.kt:718`). If maintainers decide the alert alone is the fix, drop the data assertion.
+
+**Harness impact:** today the test ends on onboarding with a fresh random-key DB, which the next reset deletes.
+
+---
+
+### T6 `dbMgmt_deleteDatabase` (shared, `ChatDataTest`)
+
+Rows: 187. Needs: none.
+
+**Scenario.** Alice deletes the database. "Cancel" keeps everything; "Delete" shows "Chat database deleted" and then the welcome screen without a restart. The core has no users.
+
+**This test fails if:** the deletion is skipped: `DatabaseView.kt:799` `deleteChatAsync(m)` removed; `listUsers` still returns alice. Or the app does not return to onboarding: `Core.kt:164` / `:168` `onboardingStage.set(Step1_SimpleXInfo)` removed.
+
+**Steps:**
+```kotlin
+val alice = app("alice"); alice.chatList.open("Private notes").send("to be deleted"); backToChatList()
+chatData(alice).management()
+click(Ui.Database.Delete)
+poll { seesText("Delete chat profile?") && seesText("This action cannot be undone - your profile, contacts, messages and files will be irreversibly lost.") && "Delete" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+poll { !AlertManager.shared.hasAlertsShown() && exists(Ui.Database.Delete) }
+check(listUsers().map { it.user.displayName } == listOf("alice"))   // runBlocking { chatController.listUsers(null) }
+click(Ui.Database.Delete); poll(alert); click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll(30_000) { seesText("Chat database deleted") && seesText("Restart the app to create a new chat profile.") }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll(30_000, "the welcome screen") { exists(Ui.Onboarding.GetStarted) && onboarding().stage == OnboardingStage.Step1_SimpleXInfo && chatModel.currentUser.value == null }
+check(listUsers().isEmpty())
+```
+**Keys:** `Ui.Database.Delete`.
+
+**Harness impact:** the app has already re-initialised a fresh DB (`stopChatRunBlockStartChat` → `startChat` → `initChatController`, `DatabaseView.kt:541-542, 414-426`), so the controller exists. The reset deletes it.
+
+**Platform:** shared. Desktop calls `startChatWithoutUser` (`Core.kt:157-166`); Android sets the stage (`Core.kt:168`). Both show `Ui.Onboarding.GetStarted` (as used by `OnboardingAndroidTest`).
+
+---
+
+### T7 `dbEncrypt_removeFromSettings` (shared with H2, else desktop-only; `DatabaseEncryptionTest`)
+
+Rows: 192 (both names), 193, 195 (both names), 196. Needs: RESTART.
+
+**Scenario.**
+1. Alice has her own passphrase, stored. She turns off "Save passphrase in settings": "Cancel" keeps it; "Remove" deletes the stored passphrase.
+2. On the next start she is asked for it. A wrong one is refused; the right one opens the chat and is not stored.
+3. She turns storing back on. On the next start she is asked once, through "Save passphrase and open chat", and after that the app starts without asking.
+
+**This test fails if:**
+- "Remove" leaves the passphrase on disk until the next start: `DatabaseEncryptionView.kt:309` `ksDatabasePassword.remove()` removed. The restart still prompts, because `Core.kt:75-77` removes the key then, but the pre-restart `EncryptedDBPassphrase == null` check fails. That is a plaintext-on-disk regression on desktop.
+- "Open chat" stores the passphrase: `DatabaseErrorView.kt:104-105` calls `saveAndRunChatOnClick`.
+- "Save passphrase and open chat" does not store it: `DatabaseErrorView.kt:55` removed; the last restart prompts again.
+- The footers are wrong: e.g. `DatabaseEncryptionView.desktop.kt:69` `if (storedKey.value)` inverted.
+
+**Steps.** Footer helper: `footer(desktop, android) = if (appPlatform.isDesktop) desktop else android` (real per-platform strings, expect/actual).
+```kotlin
+val alice = app("alice"); alice.chatList.open("Private notes").send("kept across restarts"); backToChatList()
+val pass = chatData(alice).management().passphrase(); pass.setFirst(P1)
+check(seesText(footer("The passphrase is stored in settings as plaintext.", "is used to securely store passphrase - it allows notification service to work."), substring = true)
+  && seesText("you will NOT be able to recover or change passphrase if you lose it.", substring = true))
+val stored = storedSetting("EncryptedDBPassphrase"); check(stored != null)
+click(Ui.DbPassphrase.Save)
+poll { seesText(footer("Remove passphrase from settings?", "Remove passphrase from Keystore?")) && "Remove" in textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+poll { !AlertManager.shared.hasAlertsShown() }; check(storedSetting("EncryptedDBPassphrase") == stored)
+click(Ui.DbPassphrase.Save); poll(alert); click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll { seesText("You have to enter passphrase every time the app starts - it is not stored on the device.") &&
+       storedSetting("EncryptedDBPassphrase") == null && storedSetting("StoreDBPassphrase") == "false" }
+var app = restart(ready = ::dbPrompted, what = "the passphrase prompt")   // H2; dbPrompted = chatDbStatus is ErrorNotADatabase && !ctrlInitInProgress
+poll { seesText("Encrypted database") && seesText("Database passphrase is required to open chat.") && "Open chat" in textsOf(Ui.DbError.Open) }
+typeSecret(Ui.DbError.Passphrase, P1.dropLast(1)); click(Ui.DbError.Open)
+poll(30_000) { seesText("Wrong passphrase!") && seesText("Enter correct passphrase.") }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+typeSecret(Ui.DbError.Passphrase, P1.takeLast(1)); click(Ui.DbError.Open)
+poll(30_000) { app.chatList.shown("Private notes") }
+check(storedSetting("EncryptedDBPassphrase") == null)
+check("kept across restarts" in app.chatList.open("Private notes").itemTexts()); backToChatList()
+chatData(app).management().passphrase()
+click(Ui.DbPassphrase.Save)                                    // switching on: no alert (setUseKeychain(true), :136)
+poll { seesText(footer("The passphrase will be stored in settings as plaintext after you change it or restart the app.",
+                       "Android Keystore will be used to securely store passphrase after you restart the app or change passphrase - it will allow receiving notifications.")) &&
+       storedSetting("StoreDBPassphrase") == "true" && storedSetting("EncryptedDBPassphrase") == null }
+app = restart(ready = ::dbPrompted, what = "the passphrase prompt")
+poll { seesText("Encrypted database") && "Save passphrase and open chat" in textsOf(Ui.DbError.Open) }
+typeSecret(Ui.DbError.Passphrase, P1); click(Ui.DbError.Open)
+poll(30_000) { app.chatList.shown("Private notes") && storedSetting("EncryptedDBPassphrase") != null }
+app = restart()
+poll("no prompt with the stored passphrase") { app.chatList.shown("Private notes") && !seesText("Encrypted database") }
+```
+Strings: "Save passphrase in settings" / "Save passphrase in Keystore" (not matched; acted on by key), "Remove passphrase from settings?" / "Remove passphrase from Keystore?", "Remove", "You have to enter passphrase every time the app starts - it is not stored on the device.", "The passphrase will be stored in settings as plaintext after you change it or restart the app.", "Android Keystore will be used to securely store passphrase after you restart the app or change passphrase - it will allow receiving notifications.", "Encrypted database", "Database passphrase is required to open chat.", "Open chat", "Wrong passphrase!", "Enter correct passphrase.", "Save passphrase and open chat".
+
+**Keys:** `Ui.DbPassphrase.Save`, and the existing `Ui.DbError.Passphrase/Open`.
+
+**Harness impact:** StoreDBPassphrase, EncryptedDBPassphrase and the Keystore alias are restored by the reset (§1.1). Every restart ends either on the chat list or on the prompt, so no pending init is left behind.
+
+**Platform:** shared only with H2 (Android restart into the prompt).
+- Android footer `keychain_is_storing_securely` contains a `%s` storage name that varies by device, so the match is on a substring.
+- Android "Remove" also warns "Notifications will be delivered only until the app stops!" (not asserted).
+
+**Flakiness.** Three restarts: about 10 s on desktop, longer on Android. The wrong-then-right typing reuses the `OnboardingTest` trick (the field keeps the text), so there is no field clearing and no retry.
+
+**Overlap.** `OnboardingTest.onboardingPassphrasePersistsAcrossRestart` (desktop) exercises the same prompt and wrong entry from onboarding. T7's path (settings "Remove") and its Android run are new. If you prefer, drop T7's wrong-entry step (2 lines).
+
+---
+
+### T8 `dbMgmt_stoppedStatePersistsRestart` (desktop-only, `desktop/ChatDataDesktopTest`; needs H2)
+
+Rows: 181. Needs: P (bob), RESTART.
+
+**Scenario.** Alice stops the chat and restarts the app. She is asked "Start chat?"; "Cancel" keeps it stopped. On the next start, "OK" starts it and bob's message sent while stopped arrives.
+
+**This test fails if:**
+- the stopped state is not honoured at start: `Core.kt:61` condition → `false`; the chat auto-starts with no alert;
+- Cancel starts it anyway: `Core.kt:182-185` `else` branch replaced by `chatController.startChat(user)`.
+
+**Steps:**
+```kotlin
+val alice = app("alice"); val bob = cli("bob"); connect(bob)
+chatData(alice).management(); click(Ui.Database.RunChat); poll(stop alert); click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll { seesText("Chat is stopped") && storedSetting("ChatStopped") == "true" }
+bob sends "@alice sent before restart"
+var app = restart(ready = ::startChatAsked, what = "the Start chat? alert")   // startChatAsked = chatDbStatus == OK && AlertManager.shared.hasAlertsShown()
+poll { seesText("Start chat?") && seesText("Chat is stopped. If you already used this database on another device, you should transfer it back before starting chat.") }
+click(Ui.Alert.Dismiss(Ui.AlertSource.Shared))
+poll { !chatModel.ctrlInitInProgress.value && chatModel.chatRunning.value == false }
+check(!coreRunning() && storedSetting("ChatStopped") == "true")
+app.settings(); poll { seesDescription("Chat is stopped") }    // SettingsView.kt:216-221 red icon on "Chat data"
+app = restart(ready = ::startChatAsked, what = "the Start chat? alert again")
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll(CONNECT_TIMEOUT_MS) { coreRunning() && "sent before restart" in app.chatList.rowTexts("bob") }
+check(storedSetting("ChatStopped") == "false")
+app.chatList.open("bob").send("started again"); bob expectsMessage "alice> started again"
+```
+**Harness impact:** a failure with the alert pending is handled as in T4.
+
+**Why desktop-only:** the Android restart relaunches the activity while `initChatController` awaits the alert (plan §15.4 item 10 risk). This is a harness limit, not a UI difference.
+
+---
+
+### T9 `chatData_deleteFilesAndMedia` (shared, `ChatDataTest`; lower priority)
+
+Rows: 177. Needs: P (bob), XFTP.
+
+**Scenario.** Alice has received an image and a text from bob. "Delete all files" asks "Delete files and media?"; "Delete" removes the files, keeps the messages, and leaves the chat running.
+
+**This test fails if:** the files are not deleted: `DatabaseView.kt:865` `deleteAppFiles()` removed; the footer still counts 1 file. Or the chat is not restarted afterwards: `:542` `startChat(…)` removed; bob never receives the reply.
+
+**Steps.**
+1. `bob sends "/img @alice tests/fixtures/test.jpg"`, then wait for "completed uploading file 1 (test.jpg) for alice" (as in `FilesTest.kt:55-58`). `bob sends "@alice kept text"`.
+2. Poll until alice's image is `RcvComplete`, as in `FilesTest`. This needs the chat open: open it, then `backToChatList()`.
+3. `chatData(alice)`, then `poll { seesText("1 file(s) with total size of", substring = true) }`.
+4. `click(Ui.Database.DeleteFiles)`, then `poll { seesText("Delete files and media?") && seesText("This action cannot be undone - all received and sent files and media will be deleted. Low resolution pictures will remain.") }`, then Confirm ("Delete").
+5. `poll(30_000) { seesText("No received or sent files") && appFilesDir.listFiles().isNullOrEmpty() && coreRunning() }`.
+6. `close()`; open bob's chat: "kept text" is still in `itemTexts()`. `send("files gone")`, then `bob expectsMessage "alice> files gone"`.
+
+**Keys:** `Ui.Database.DeleteFiles`.
+
+**Harness impact:** none; the reset deletes `filesDir` anyway (`DatabaseView.kt:569`).
+
+---
+
+### T10 `dbError_incompatibleDowngrade` (desktop-only, `desktop/DatabaseEncryptionDesktopTest`; shared if H2; lower priority)
+
+Rows: 198. Needs: FIXTURE (in-test SQL), RESTART.
+
+**Scenario.** The database has a migration the app does not know and that has no down migration, as when a newer app version used it. At start alice sees "Incompatible database version" with the reason, instead of a crash or the chat list.
+
+**This test fails if:** the error branch is wrong: `DatabaseErrorView.kt:148-154` (e.g. `MigrationError.Error` rendered as the upgrade screen), or `mtrErrorDescription` (`:283-289`) loses the migration list.
+
+**Steps:**
+1. `val alice = app("alice")`, then `check(chatModel.chatDbStatus.value == DBMigrationResult.OK)`.
+2. `addFutureMigrationViaSql()` (NEW, test-private): `CC.Console("/sql chat INSERT INTO migrations (name, ts, down) VALUES ('29991231_uitest_newer', '2999-12-31 00:00:00', NULL)")`. The `migrations` schema is at `src/Simplex/Chat/Store/SQLite/Migrations/chat_schema.sql:1-5`. The name sorts after every app migration, so the check yields `MTRENoDown` (simplexmq `Agent/Store/Migrations.hs:26-28` at the pinned `8bc4d360`).
+3. `restart()`. The default works on desktop, because init fails fast.
+4. `poll { seesText("Incompatible database version") && seesText("File: simplex_v1_chat.db") && seesText("Error: database version is newer than the app, but no down migration for: 29991231_uitest_newer") && !exists(Ui.DbError.Passphrase) && !exists(Ui.ChatList.Search) }`.
+
+**Harness impact:** controller null at the end; `UiTest.kt:60-63` re-inits, and the reset deletes the DB.
+
+## 4. New helpers and keys
+
+### H1 (both `UiTest.kt`, same names on both `UiScope`s)
+
+Desktop (`desktopTest/.../harness/UiTest.kt`, inside `UiScope`):
+```kotlin
+fun exchangeDir(): File = File(dir, "exchange").apply { mkdirs() }
+fun saveFileAs(file: File, action: () -> Unit) = answerDialog(simplexWindowState.saveDialog, "the save file dialog", file, action)
+fun openFile(file: File, action: () -> Unit) = answerDialog(simplexWindowState.openDialog, "the open file dialog", file, action)
+private fun answerDialog(d: DialogState<File?>, what: String, file: File, action: () -> Unit) {
+  action()
+  poll(what = what) { d.isAwaiting }
+  onEdt { d.onResult(file) }
+  poll(what = "$what to be answered") { !d.isAwaiting }
+}
+```
+Android (`android/.../harness/UiTest.kt`):
+```kotlin
+fun exchangeDir(): File = File(androidAppContext.filesDir, "uitest-exchange").apply { mkdirs() }
+fun saveFileAs(file: File, action: () -> Unit) = answerIntent(Intent.ACTION_CREATE_DOCUMENT, file, action)
+fun openFile(file: File, action: () -> Unit) = answerIntent(Intent.ACTION_GET_CONTENT, file, action)
+private fun answerIntent(intentAction: String, file: File, action: () -> Unit) {
+  val uri = FileProvider.getUriForFile(androidAppContext, "$APPLICATION_ID.provider", file)   // chat.simplex.common.helpers.APPLICATION_ID
+  Intents.intending(IntentMatchers.hasAction(intentAction)).respondWith(Instrumentation.ActivityResult(Activity.RESULT_OK, Intent().setData(uri)))
+  val before = Intents.getIntents().count { it.action == intentAction }
+  action()
+  poll(what = "the $intentAction request") { Intents.getIntents().count { it.action == intentAction } > before }
+}
+```
+The most recently added matching stub wins over the generic RESULT_CANCELED stub at :138. Stubs are reset by `Intents.release()` on `restart()`; T4 and T5 do not restart.
+
+### H2 (both `UiTest.kt`)
+
+Desktop:
+```kotlin
+fun restart(ready: () -> Boolean = { chatModel.chatDbStatus.value != null && !chatModel.ctrlInitInProgress.value }, what: String = "the app to start again"): App
+```
+The body is unchanged apart from `poll(timeoutMs = 30_000, what = what) { ready() }`.
+
+Android: same signature. The default is today's condition (`android/.../UiTest.kt:89-92`). `ready` replaces the poll between `restartCore` and the activity relaunch.
+
+### H3 (`uiTestShared/.../harness/Helpers.kt`)
+
+```kotlin
+fun UiScope.typeSecret(key: UiKey, text: String) {
+  val before = editableText(key).orEmpty().length
+  enterText(key, text)
+  poll(what = "field ${key.tag} to hold ${before + text.length} characters") { editableText(key)?.length == before + text.length }
+}
+```
+
+### H4 (`uiTestShared/.../harness/DatabaseScreens.kt`, new)
+
+```kotlin
+fun UiScope.chatData(app: App): ChatDataScreen { app.settings(); click(Ui.Settings.Database); waitFor(Ui.Database.Management); return ChatDataScreen(this) }
+class ChatDataScreen(private val s: UiScope) {
+  fun ttlText(): String? = s.textOf(Ui.Database.Ttl)
+  fun selectTtl(ttl: ChatItemTTL) { s.click(Ui.Database.Ttl); s.click(Ui.Database.Ttl.option(ttl)) }
+  fun management(): DatabaseManagementScreen { s.click(Ui.Database.Management); s.waitFor(Ui.Database.Export); return DatabaseManagementScreen(s) }
+  fun close() { s.escape(); s.poll(what = "Chat data to close") { !s.exists(Ui.Database.Management) && s.exists(Ui.Settings.Database) }
+                s.escape(); s.poll(what = "settings to close") { !s.exists(Ui.Settings.Database) && s.exists(Ui.ChatList.Search) } }
+}
+class DatabaseManagementScreen(private val s: UiScope) {
+  fun passphrase(): PassphraseScreen { s.click(Ui.Database.Passphrase); s.waitFor(Ui.DbPassphrase.New); return PassphraseScreen(s) }
+  fun close() { /* escape ×3 with a poll per level, as in PrivacyTest.closeMorePrivacy */ }
+}
+class PassphraseScreen(private val s: UiScope) {
+  fun setFirst(p: String) {
+    s.typeSecret(Ui.DbPassphrase.New, p); s.typeSecret(Ui.DbPassphrase.Confirm, p)
+    s.click(Ui.DbPassphrase.Update)
+    s.waitFor(Ui.Alert.Confirm(Ui.AlertSource.Shared)); s.click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    s.poll(timeoutMs = 30_000, what = "Database encrypted!") { s.seesText("Database encrypted!") }
+    s.click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+    s.poll(timeoutMs = 30_000, what = "chat running with the current-passphrase field") { chatModel.chatRunning.value == true && s.exists(Ui.DbPassphrase.Current) }
+  }
+  fun change(current: String, new: String) {
+    s.typeSecret(Ui.DbPassphrase.Current, current); s.typeSecret(Ui.DbPassphrase.New, new); s.typeSecret(Ui.DbPassphrase.Confirm, new)
+    s.click(Ui.DbPassphrase.Update)
+    s.poll(what = "the Change database passphrase? alert") { s.seesText("Change database passphrase?") && "Update" in s.textsOf(Ui.Alert.Confirm(Ui.AlertSource.Shared)) }
+    s.click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+  }
+  fun reopen() { s.hideKeyboard(); s.escape(); s.waitFor(Ui.Database.Passphrase); s.click(Ui.Database.Passphrase); s.waitFor(Ui.DbPassphrase.New) }
+}
+```
+
+### Keys (`commonMain/.../ui/Ui.kt` plus one-line app edits; all no-ops unless `uiTestHooksEnabled`)
+
+```kotlin
+object Settings { …; val Database = UiKey("settings.database") }
+object Database {
+  val Ttl = UiKey("database.ttl"); val Management = UiKey("database.management"); val DeleteFiles = UiKey("database.deleteFiles")
+  val Passphrase = UiKey("database.passphrase"); val Export = UiKey("database.export"); val Import = UiKey("database.import")
+  val Delete = UiKey("database.delete"); val RunChat = UiKey("database.runChat")
+}
+object DbPassphrase {
+  val Save = UiKey("dbPassphrase.save"); val Current = UiKey("dbPassphrase.current"); val New = UiKey("dbPassphrase.new")
+  val Confirm = UiKey("dbPassphrase.confirm"); val Update = UiKey("dbPassphrase.update")
+}
+```
+
+| Key | App file:line (acted-on element) | Edit |
+|---|---|---|
+| `Ui.Settings.Database` | `commonMain/.../views/usersettings/SettingsView.kt:200` (`SectionItemView(openDatabaseView)` in `DatabaseItem` :199-225) | `uiKey = Ui.Settings.Database` (the parameter exists, `Section.kt:209`) |
+| `Ui.Database.Ttl` (+ `.option(ttl)`) | `views/database/DatabaseView.kt:128` call; `TtlOptions` :347-375 | Add `uiKey: UiKey? = null` as the **last** parameter of `TtlOptions` (after `default`, so `GroupChatInfoView.kt:950` keeps compiling) and pass `uiKey = uiKey` to `ExposedDropDownSettingRow` (:367; parameter exists, `ExposedDropDownSettingRow.kt:172`; options keyed at :77). The call at :128 passes `uiKey = Ui.Database.Ttl`. |
+| `Ui.Database.Management` | `DatabaseView.kt:146-153` | `uiKey =` on `SettingsActionItem` (`SettingsView.kt:386`) |
+| `Ui.Database.DeleteFiles` | `DatabaseView.kt:159-162` | `uiKey =` on `SectionItemView` (T9 only) |
+| `Ui.Database.Passphrase` | `DatabaseView.kt:231-238` | `uiKey =` |
+| `Ui.Database.Export` | `DatabaseView.kt:247-265` | `uiKey =` |
+| `Ui.Database.Import` | `DatabaseView.kt:266-273` | `uiKey =` |
+| `Ui.Database.Delete` | `DatabaseView.kt:274-288` | `uiKey =` |
+| `Ui.Database.RunChat` | `DatabaseView.kt:390-400` (`DefaultSwitch` in `RunChatSetting`) | `modifier = Modifier.ui(Ui.Database.RunChat)` (parameter exists, `DefaultSwitch.kt:17`) |
+| `Ui.DbPassphrase.Save` | `DatabaseEncryptionView.kt:129-145` call; expect :253-261; actuals `desktopMain/.../DatabaseEncryptionView.desktop.kt:22-55` (switch :48), `androidMain/.../DatabaseEncryptionView.android.kt:22-55` (switch :48) | Add `uiKey: UiKey? = null` before `onCheckedChange` in the expect and both actuals; the actuals apply `modifier = Modifier.ui(uiKey)` to `DefaultSwitch`; the call at :129 passes `uiKey = Ui.DbPassphrase.Save`. `MigrateToDevice.kt:424` is unchanged (keyless). **Build both platforms** (plan §15.4 item 39). |
+| `Ui.DbPassphrase.Current` | `DatabaseEncryptionView.kt:151-157` (modifier :154) | `Modifier.ui(Ui.DbPassphrase.Current).padding(horizontal = DEFAULT_PADDING)` |
+| `Ui.DbPassphrase.New` | `:160-168` (modifier :163) | same pattern |
+| `Ui.DbPassphrase.Confirm` | `:192-202` (modifier :195) | same pattern |
+| `Ui.DbPassphrase.Update` | `:204` `SectionItemViewSpaceBetween` | `uiKey = Ui.DbPassphrase.Update` (parameter exists, `Section.kt:277`) |
+
+Existing keys reused: `Ui.DbError.Passphrase/Open` (`DatabaseErrorView.kt:307,320,339`), `Ui.Alert.Confirm/Dismiss` (`AlertManager.kt:160-205`), `Ui.Onboarding.GetStarted`, `Ui.ChatList.*`.
+
+## 5. Catalogue corrections
+
+Line numbers verified against the current tree.
+
+- Row 182: "`DatabaseEncryptionView.kt:120`" → `:123` (AppBarTitle "Database passphrase").
+- Row 185: "`SimpleXAPI.kt:1128`" → `:1160-1164` (throw at :1163). The Needs cell `IGNORE: known app bug…` is not a §11.3 reason; replace it with `FD` and mark the test `@KnownAppIssue` (T5). Add the data-wipe consequence to the note (§6 B1).
+- Row 184: after "Save passphrase and open chat", the app shows "Start chat?" / "Chat is stopped. If you already used this database on another device, you should transfer it back before starting chat." (`DatabaseErrorView.kt:226-228`), because the import's stop left `ChatStopped=true` (`DatabaseView.kt:512`).
+- Row 190: main file `DatabaseEncryptionView.kt:42-215,423-487` → `:44-224,433-496`. "Update database passphrase (`:197`)" → `:205`. "pre-filled with the random key, `:49`" → `:52`.
+- Row 191: `:147-200,444-450` → `:147-207,453-463`.
+- Row 192: "switch disabled with the random passphrase, `DatabaseEncryptionView.kt:130`" → `:133`.
+- Row 194: `DatabaseEncryptionView.kt:165-175` → `:169-184`; "`:180` (can't set an empty one)" → `:185-190` (`newKey.value.isEmpty()` at :187).
+- Row 196: "`ksDatabasePassword.set`, `DatabaseErrorView.kt:53`" → `:55`.
+- Row 197: "`DatabaseErrorView.kt:77-78,115`" → `:79-81,117`; `:107-120` → `:109-121`.
+- Row 198: `:146-152,281-287` → `:148-154,283-289`.
+- Row 199: `:184-210,256-279` → `:184-197,258-281`; "`:45, 256-267`" → `:47, 258-268`; "`:268-279`" → `:270-281`.
+- Row 200: "`:322-332`" → `:325-335`.
+- Merges: row 180 becomes `dbMgmt_stopAndStartChat`; rows 182/183/186 names leave the table (merged into `dbMgmt_importArchive_restoresData`); 173's increase/cancel names, 190, 191's wrong-current, 192's save, 193, 195, 196 merge as listed in section 2. Recount with `tools/recount.py` and regenerate the class map.
+- Legend: UI strings path is `commonMain/moko-resources/base/strings.xml` (correct in the legend; the brief's `resources/MR/base` is wrong).
+
+## 6. Suspected app bugs and harness findings (report, do not fix)
+
+- **B1 (data loss, by code reading; proposed plan §15.5 item 7). Importing an invalid archive silently wipes all data and lands on onboarding.**
+  - Mechanism, step by step:
+    1. `importArchive` deletes storage first (`DatabaseView.kt:718`).
+    2. `apiImportArchive` throws `Exception` (`SimpleXAPI.kt:1163`), but only `Error` is caught (`DatabaseView.kt:740,745`). No alert is shown, and `progressIndicator` stays `true` (set at :714).
+    3. `stopChatRunBlockStartChat` catches the throwable and restarts the chat (`:535-542`). `initChatController` creates a fresh random-key DB (`DatabaseUtils.kt:55-59`), and with no user the app shows onboarding (`Core.kt:153-169`).
+    4. The core's `.bak` copy is also gone: `deleteStorage` removes backups (`Archive.hs:128,135`) before `importArchive` would make them.
+  - Test: T5 (`@KnownAppIssue`). To confirm manually: desktop, "Import database", pick any non-zip file.
+- **B2 (desktop, minor; proposed item 8). Desktop file-chooser launchers keep the `onResult` lambda from their first composition** (`Files.desktop.kt:52-53`: `remember(rememberedValue)` with the default `null`; Android uses `rememberLauncherForActivityResult`, which is fresh).
+  - In `DatabaseManagementView` the import lambda captures `stopped` (`DatabaseView.kt:202-210`).
+  - Failing sequence: open the screen while the chat is stopped, start it with the toggle, then "Import database". The import then runs without stopping the chat, and the core refuses `/_db delete` with `CEChatNotStopped` (`Commands.hs:670,3810-3816`). The resulting `Exception` is swallowed (`DatabaseView.kt:527-529`) and the spinner stays forever.
+  - Not covered by a test; a known-issue test is possible if wanted.
+- **B3 (UX, apparently by design: comment at `DatabaseEncryptionView.kt:72`; proposed item 9). A failed passphrase change leaves the chat silently stopped.**
+  - `encryptDatabase` returns false (`:462,:470`), so `stopChatRunBlockStartChat` does not restart (`DatabaseView.kt:541`).
+  - `ChatStopped=true` is also left on disk, so the next app start asks "Start chat?".
+  - Messages are not received until the user notices "Chat is stopped" in settings.
+  - T3 does not assert the running state between attempts, so it stays green. A separate `@KnownAppIssue` test (set passphrase, wrong current, back, expect "Chat is running") is possible but would be a prefix of T3. Your decision.
+- **Harness facts** (for plan §15.4):
+  - Desktop `restart()` times out on a pending "Start chat?" alert (`Core.kt:170` keeps `ctrlInitInProgress` true), and Android `restart()` cannot reach any DB-error screen (§1.3). Proposed fix: H2.
+  - The Android template is decrypted, so Android passphrase tests start from the "not encrypted" state. The export-prohibited alert still says "encrypted using a random passphrase", only because the harness sets `InitialRandomDBPassphrase=true` (§1.2).
+  - Android `getFileName` needs a `content://` URI (§1.4), so file responders must go through the app's `FileProvider`.
+- **Not bugs, noted:**
+  - Export always leaves the chat stopped (`DatabaseView.kt:630`, documented in the catalogue).
+  - Opening "Database passphrase & export" again after a passphrase screen recomposes the management screen, because `ModalManager` composes only the top modal (as in plan §15.5 item 5). That is why B2 does not affect T4.
+
+## 7. Open questions (with proposed answers)
+
+1. Approve H1–H4 and the keys? Proposed: yes. All are test-side, apart from no-op keys and two `uiKey` parameters.
+2. T7: shared (needs H2 on Android) or desktop-only? Proposed: shared.
+3. T5: assert data kept, or only the alert? Proposed: both; the data wipe is the real harm.
+4. B3: add a known-issue test, or only report it? Proposed: report only; the code comment suggests the behaviour is intended.
+5. T9 and T10 (lower priority): include in the first batch? Proposed: T9 yes (data loss), T10 optional.
diff --git a/plans/ui-tests/drafts/design-D1-edit-delete-select.md b/plans/ui-tests/drafts/design-D1-edit-delete-select.md
new file mode 100644
index 0000000000..2cc69087d5
--- /dev/null
+++ b/plans/ui-tests/drafts/design-D1-edit-delete-select.md
@@ -0,0 +1,561 @@
+# Design D1: edit / history, delete / reveal, multi-select (catalogue 02 §I, §J, §K, §P history)
+
+Status: design only (2026-10-20). Nothing is implemented. All file:line references were read in `~/wt-uitest` (branch `nd/desktop-ui-tests`). Paths are relative to `apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/` unless they start with `apps/`, `src/`, `tests/` or `plans/`. Aliases: **CIV** `views/chat/item/ChatItemView.kt`, **CV** `views/chat/ChatView.kt`, **CMP** `views/chat/ComposeView.kt`, **SEL** `views/chat/SelectableChatItemToolbars.kt`, **INFO** `views/chat/ChatItemInfoView.kt`, **MDV** `views/chat/item/MarkedDeletedItemView.kt`, **API** `model/SimpleXAPI.kt`, **PTF** `apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/platform/PlatformTextField.desktop.kt`, **Screens** `apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/Screens.kt`.
+
+English strings are in `apps/multiplatform/common/src/commonMain/moko-resources/base/strings.xml` (the brief's `resources/MR/base/strings.xml` does not exist).
+
+## 0. Summary
+
+29 catalogue rows (I 12, J 8, K 9) plus P `info_history_listsVersions` collapse into **10 tests** (8 shared, 2 desktop-only), plus 2 optional changes that make existing tests stronger. Already done (`status.py`): `edit_menu_updatesPeer`, `edit_received_updatesBubble`, `delete_ownForEveryone_peerSeesMarkedDeleted`, `delete_received_onlyForMe`.
+
+| # | Test (catalogue name) | Class / file | Rows covered | Peers | Pri |
+|---|---|---|---|---|---|
+| T1 | `edit_menu_updatesPeer` (existing, extended) | `chat/EditMessageTest` (moved from `MessagingTest`, decision Q1) | I `edit_menu_updatesPeer`, `edit_unchanged_noUpdate`, `edit_cancel_clearsCompose`, `edit_metaShowsEditedIcon` (model only), P `info_history_listsVersions` | bob | P1 |
+| T2 | `edit_notOffered_forReceivedOrForwarded` (renamed from `…ForReceivedVoiceForwarded`) | `chat/EditMessageTest` | I rules row (voice part moved to §E) | bob | P1 |
+| T3 | `edit_upArrow_editsLastMessage` | `desktop/EditMessageDesktopTest` | I keyboard row | bob | P1 |
+| T4 | `edit_ownFile_previewWithoutCancel` | `desktop/EditMessageDesktopTest` | I own-caption row (file variant) | bob, XFTP | P2 |
+| T5 | `edit_group_membersSeeEdited` | `chat/EditMessageTest` | I group row | bob, cath | P2 |
+| T6 | `delete_forEveryone_fullDeletion_peerSeesDeleted` | `chat/DeleteMessageTest` | J `delete_ownForMe_localOnly`, `delete_forEveryone_fullDeletion_peerSeesDeleted`; K full-delete text of the selection alert | bob | P1 |
+| T7 | `markedDeleted_received_revealHide` | `chat/DeleteMessageTest` | J `markedDeleted_received_revealHide`, `markedDeleted_consecutive_collapsedCount`, `delete_received_fullDelete_removed`; K `select_mergedEvents_selectsWholeRange` (on a deleted-items range) | bob | P1 |
+| T8 | `select_toggle_updatesCounter` | `chat/MultiSelectTest` (new) | K `select_enterMode_showsCounterToolbar`, `select_toggle_updatesCounter`, `select_close_exitsMode` | bob | P1 |
+| T9 | `selectDelete_forEveryone_peerSeesBoth` | `chat/MultiSelectTest` | K `selectDelete_forEveryone_peerSeesBoth`, `selectDelete_mixed_onlyForMe` | bob | P1 |
+| T10 | `selectForward_multiple_peerReceives` | `chat/MultiSelectTest` | K `selectForward_multiple_peerReceives`, `select_itemDeletedByPeer_recheck` | bob, cath | P1 |
+
+Dropped: `edit_quotedReply_keepsQuote`, `edit_imageCaption_updates`, `edit_ownImage_previewWithoutCancel`, `blockedByAdmin_items_showBlocked`, `select_limits_forward20_delete200`, plus the voice branch of the edit rule and the edit-window branch (section 5).
+
+App changes are keys only, and **Ui.kt needs no new entries**: 6 call sites reuse `Ui.Chat.ItemMenu`, `Ui.Chat.Selection.part(...)` and `Ui.Alert.Option` (section 3).
+
+Class placement: the class map (`00-legend.md:150-152`) sends S rows to `EditMessageCompatTest` / `DeleteMessageCompatTest`. The stable-peer run is not wired (legend line 42), and the guide §5 forbids the `Compat` name unless the test really runs against the stable peer. Existing S tests (`edit_menu_updatesPeer`, `delete_ownForEveryone_peerSeesMarkedDeleted`) therefore live in plain classes, and so do these.
+
+## 1. Decisions to confirm (with recommendation)
+
+- **Q1. Extend `edit_menu_updatesPeer` in place or move it.** T1 starts with the existing test's steps (send "hello", Edit, "hey 👋"), so guide §5 says extend it, not add a new test. Options: (a) move it from `MessagingTest.kt:35-44` into `EditMessageTest` (its class-map class) and extend it there; (b) extend it in `MessagingTest`. **Recommend (a)**: it changes one existing test, so it needs your OK (memory: no scope expansion without permission).
+- **Q2. How alice allows full deletion in T7.** (a) A `ViaApi` precondition helper, `allowFullDeletionViaApi("bob")` (`apiSetContactPrefs`, as `HiddenProfilesTest.newGroupViaApi` does); (b) through the Contact preferences UI, which needs keys in `views/chat/ContactPreferences.kt` (owned by catalogue 01 §14). **Recommend (a)**: the preference UI is not what T7 tests, and guide §6 allows API setup for preconditions outside the feature when the helper name says so. Alternative: split that step into its own test (+1 reset).
+- **Q3. Selection-toolbar keys.** (a) `Ui.Chat.Selection.part("delete")` / `.part("forward")`, no Ui.kt edit (same pattern as `Ui.Chat.Item(id).part("quote")` at `views/chat/item/FramedItemView.kt:297`); (b) new named `Ui.Chat.SelectionDelete` / `SelectionForward`. **Recommend (a).**
+- **Q4. Two controls found by content description instead of a key**: the edit bar's (x), `described("Cancel")` (`views/chat/ContextItemView.kt:148-151`), and the selection bar's (x), `described("Back")` (`DefaultTopAppBar.kt:140-146` via SEL:31). Both are unique on screen in the states used, so no app change is needed. Fallback if either turns out ambiguous: a `modifier` parameter on `NavigationButtonClose`, which is a shared helper, so that would be a larger diff. **Recommend described().**
+- **Q5. T3 and T4 are desktop-only.** The Up arrow exists only on desktop (PTF:141). T4 attaches the file by pasting its path (desktop route, as `FilesDesktopTest.paste_filePathText_attachesFile`), not through the FD dialog the catalogue names. **Recommend yes.** A shared T4 needs FD support on both platforms.
+- **Q6. T5 (group edit) is P2.** It costs 2 peers plus group setup. It catches a group-only regression (`type = cInfo.chatType` in CMP:812-818). Keep or drop?
+- **Q7. Optional changes that make existing tests stronger** (section 4.11). Each one changes an existing test, so each needs your OK.
+
+## 2. Row-by-row verdict (code verified)
+
+### §I Edit and history (catalogue lines 138-144)
+
+| Row / test | Code (verified, corrected) | Verdict |
+|---|---|---|
+| `edit_menu_updatesPeer` | Edit item CIV:468-473 (catalogue says 464-469); `updateMessage` CMP:808-827, `UpdatedMessage(updateMsgContent(...))` CMP:818; edit-bar cancel → `clearState()` CMP:1265-1267 | **keep, extend (T1)** |
+| `edit_unchanged_noUpdate` | `apiUpdateChatItem` accepts `ChatItemNotChanged` (API:1336); core `viewItemNotChanged` prints only on the sender (`src/Simplex/Chat/View.hs:917-920`) | **merge into T1** (bob's next line proves nothing was sent) |
+| `edit_cancel_clearsCompose` | CMP:1265-1267; the edit bar's (x) has content description "Cancel" (`ContextItemView.kt:148-151`) | **merge into T1** |
+| `edit_metaShowsEditedIcon` | CIMetaView.kt:83-84 → `StatusIconText` :198-199, `Icon(icon, null, …)`: **no content description**, so the icon is not observable (guide §2: don't name a test after an unobservable visual) | **merge into T1** as a model check (`meta.itemEdited`); the visible proof is the 2-version history |
+| `edit_upArrow_editsLastMessage` | PTF:141-142 (catalogue says :138): Up only when the field is empty; `editPrevMessage` CMP:1187-1192 (catalogue says :1185): only with no context item and no preview, `findLast { it.meta.editable }` | **keep (T3, desktop)**, both branches |
+| `edit_received_updatesBubble` | done (`EditMessageTest.kt:9-19`) | done; optional strengthening (4.11) |
+| `edit_quotedReply_keepsQuote` | The quote is stored by the core; the app sends only `msgContent` (CMP:818) and upserts what comes back (API:3090) | **drop**: no app-side mutation breaks only this; covered by `testDirectMessageUpdate` (`tests/ChatTests/Direct.hs:704-714`) |
+| `edit_imageCaption_updates` | Same receive path as text, `chatItemUpdateNotify` (API:3090-3091) | **drop**: duplicates `edit_received_updatesBubble` and adds XFTP cost |
+| `edit_ownImage_previewWithoutCancel` | `MediaPreview` `cancelEnabled = !editing && !inProgress` CMP:1210-1212 | **drop for now** (needs image attach on both platforms; the file variant T4 covers the same rule and `updateMsgContent`) |
+| `edit_ownFile_previewWithoutCancel` | `FilePreview` CMP:1220-1225, `ComposeFileView.kt:37-46` (button only if `cancelEnabled`); `updateMsgContent` MCFile CMP:779; preview from `chatItemPreview` CMP:275 | **keep (T4, desktop paste route)** |
+| `edit_notOffered_forReceivedVoiceForwarded` | CIV:468 `meta.editable && msgContent !is MCVoice && !live`; core `editable = deletable && isNothing itemForwarded`, `deletable` only for `CISndMsgContent` younger than `nominalDay` (`src/Simplex/Chat/Messages.hs:538-550`) | **keep (T2) as `edit_notOffered_forReceivedOrForwarded`**; voice needs REC → move to §E; the 1-day window can't be reached in a UI test |
+| `edit_group_membersSeeEdited` | same CMP path with `type`/`scope` (CMP:812-818); CLI from `testGroupMessageUpdate` (`tests/ChatTests/Groups.hs:1307-1313`) | **keep (T5, P2)** |
+
+### §J Delete / reveal / blocked (lines 149-151)
+
+| Row / test | Code | Verdict |
+|---|---|---|
+| `delete_ownForMe_localOnly` | alert CIV:1399-1433 (catalogue says 1390-1424); "Delete for me" → `cidmInternal` CIV:1418 | **merge into T6** |
+| `delete_ownForEveryone_peerSeesMarkedDeleted` | done (`MessagingTest.kt:46-55`) | done; T6/T9 check the alert's mark-deleted text and the sent-side "marked deleted" display |
+| `delete_forEveryone_fullDeletion_peerSeesDeleted` | question text CIV:346-352 (`!sent \|\| fullDeleteAllowed \|\| Local`); `fullDeleteAllowed` CIV:125; local removal CV:3417-3421 | **keep (T6)** |
+| `delete_received_onlyForMe` | done (`DeleteMessageTest.kt:9-22`) | done |
+| `markedDeleted_received_revealHide` | render branch CIV:702-704 → `MarkedDeletedItemDropdownMenu` CIV:561-573 (Reveal :563-565); revealed → `MsgContentItemDropdownMenu` Hide CIV:484-486; Reveal/Hide actions CIV:958-980 (catalogue: 950-972); header "marked deleted" when revealed `FramedItemView.kt:286-287` | **keep (T7)** |
+| `delete_received_fullDelete_removed` | API:3131-3135 remove vs upsert | **merge into T7** |
+| `blockedByAdmin_items_showBlocked` | MDV:73-74 / :107-108 | **drop**: the single-item label is already asserted by `GroupLinksTest.memberInfo_blockForAllNotifiesMembers` (`groups/GroupLinksTest.kt:91-93`); the count branch could be one more step in that test (owner 03 §14) |
+| `markedDeleted_consecutive_collapsedCount` | MDV:48-81 (count :69-78, catalogue says 68-110); grouping `ChatItemsMerger.kt:46-48`, the newest item is rendered (CV:2402) | **merge into T7** (direct chat, no group needed) |
+
+### §K Multi-select (lines 156-159)
+
+| Row / test | Code | Verdict |
+|---|---|---|
+| `select_enterMode_showsCounterToolbar` / `select_toggle_updatesCounter` / `select_close_exitsMode` | counter SEL:25-51 (text :34-38, close :31, key `Ui.Chat.Selection` :48 → only `.part("title")`); toggle overlay CV:2238-2243; range logic CV:3345-3381 (catalogue says 3342); toolbar swap CV:1172-1178 | **merge into T8**. Correction: "the compose field is back" can't be asserted: in selection mode SEL:82 composes a hidden measuring `ComposeView` that also carries `Ui.Chat.Message`/`Ui.Chat.Send`; assert the buttons toolbar (`Selection.part("delete")`) is gone instead |
+| `selectDelete_forEveryone_peerSeesBoth` / `selectDelete_mixed_onlyForMe` | delete button SEL:97-104; `rDeleteForEveryoneEnabled` SEL:159 (catalogue says 157); question CV:330-335; dialog CIV:1435-1460 (`if (forAll)` :1451); mode CV:3399 | **merge into T9** |
+| `selectForward_multiple_peerReceives` | CV:363-389 (catalogue says 361-384), `forwardContent` CV:3681-3687 (chronological order) | **keep (T10)** |
+| `select_itemDeletedByPeer_recheck` | `LaunchedEffect(chatInfo, chatItems.value, selected)` SEL:127-129; forward rule SEL:163 (catalogue says 161) | **merge into T10** |
+| `select_mergedEvents_selectsWholeRange` | CV:3353-3366 (range via `getPrevShownChatItem`, the same for every merge category) | **merge into T7** using the collapsed "2 messages marked deleted" range (no group setup); the group-events variant stays with 03 §16 if wanted |
+| `select_limits_forward20_delete200` | SEL:145-146 | **drop**: needs 201 clicks (no "select all" in the main chat: `selectAll` is passed only in secondary contexts) and 300 messages; low value for the cost |
+
+### §P (line 207)
+
+`info_history_listsVersions`: INFO:319-343 (list :329-330, newest first, "(current)" on the first one INFO:105-110; catalogue says 103-108). An unedited item has one version (`src/Simplex/Chat/Library/Commands.hs` `APIGetChatItemInfo`: `if null versions then maybeToList $ mkItemVersion ci`). One tab only for a direct sent item (`numTabs` INFO:467-478), so the history is shown directly. **Merge into T1.**
+
+## 3. App keys (no Ui.kt change)
+
+| Key | Where (exact) | Change | Used by |
+|---|---|---|---|
+| `Ui.Chat.ItemMenu(cItem.id, "info")` | CIV:861-867, `ItemInfoAction` body | add `uiKey = Ui.Chat.ItemMenu(cItem.id, "info")` to its `ItemAction(...)` call (signature unchanged; all 6 callers get it) | T1 |
+| `Ui.Chat.ItemMenu(cItem.id, "reveal")` | CIV:959 `RevealItemAction` + call CIV:564 | new param `uiKey: UiKey? = null` **before** `reveal`; pass it to `ItemAction(..., uiKey = uiKey, onClick = …)`; at :564 `RevealItemAction(revealed, showMenu, Ui.Chat.ItemMenu(cItem.id, "reveal"), reveal)`. Other callers (:512, :665) unchanged (not acted on) | T7 |
+| `Ui.Chat.ItemMenu(cItem.id, "hide")` | CIV:971 `HideItemAction` + call CIV:485 | same pattern; at :485 `HideItemAction(revealed, showMenu, Ui.Chat.ItemMenu(cItem.id, "hide"), reveal)`; :510, :663 unchanged | T7 |
+| `Ui.Alert.Option(Ui.AlertSource.Shared, "forMe")` / `"forEveryone"` | CIV:1446-1449 and :1452-1455 (`deleteMessagesAlertDialog` TextButtons) | add `Modifier.ui(...)` as the second argument, exactly as the single-item dialog does at CIV:1421/:1428 | T6, T9 |
+| `Ui.Chat.Selection.part("delete")` | SEL:97 `IconButton({…}, enabled = …)` | `IconButton({…}, Modifier.ui(Ui.Chat.Selection.part("delete")), enabled = …)` | T6, T8, T9 |
+| `Ui.Chat.Selection.part("forward")` | SEL:115 | `IconButton({ forwardItems() }, Modifier.ui(Ui.Chat.Selection.part("forward")), enabled = …)` | T10 |
+
+Reused unchanged: `Ui.Chat.Item(id)`, `Ui.Chat.ItemMenu(id, "edit"/"delete"/"select"/"forward")`, `Ui.Chat.Message`, `Ui.Chat.Send`, `Ui.Chat.Bar.part("title")`, `Ui.Chat.Selection.part("title")`, `Ui.Share.Row`, `Ui.Alert.Option(Shared, "forMe"/"forEveryone")` (CIV:1421, 1428). Controls found by description: `described("Cancel")` (edit bar), `described("Back")` (selection close). The Reveal/Hide keys use a new `uiKey` parameter on private functions in one file, so there is no cross-module caller risk; both platforms still need building (guide §4).
+
+## 4. Tests
+
+Common constants (test-file private):
+```kotlin
+private val FOR_ME = Ui.Alert.Option(Ui.AlertSource.Shared, "forMe")
+private val FOR_EVERYONE = Ui.Alert.Option(Ui.AlertSource.Shared, "forEveryone")
+private val SEL_TITLE = Ui.Chat.Selection.part("title")
+private val SEL_DELETE = Ui.Chat.Selection.part("delete")
+private val SEL_FORWARD = Ui.Chat.Selection.part("forward")
+private const val MARK_ONE = "Message will be marked for deletion. The recipient(s) will be able to reveal this message."   // strings.xml:445
+private const val FULL_ONE = "Message will be deleted - this cannot be undone!"                                          // :443
+private const val MARK_MANY = "Messages will be marked for deletion. The recipient(s) will be able to reveal these messages." // :446
+private const val FULL_MANY = "Messages will be deleted - this cannot be undone!"                                        // :444
+```
+
+### 4.0 New screen helpers (add to `Screens.kt`, class `ChatScreen` at :207, plus a new `ItemInfoScreen`)
+
+```kotlin
+// ChatScreen
+fun select(text: String) { menu(text, "select"); s.waitFor(Ui.Chat.Selection.part("title")) }
+fun toggle(id: Long) = s.click(Ui.Chat.Item(id))                         // selection overlay CV:2238-2243 covers the item
+fun selectionTitle(): String? = Ui.Chat.Selection.part("title").let { k -> if (s.exists(k)) s.textsOf(k).firstOrNull() else null }
+fun forwardSelectionTo(chatName: String) {
+  s.click(Ui.Chat.Selection.part("forward"))
+  ChatListScreen(s).shareTo(chatName)
+  s.poll(what = "the send button to be enabled for forwarding") { s.isEnabled(Ui.Chat.Send) }
+  s.click(Ui.Chat.Send)
+}
+fun itemInfo(text: String): ItemInfoScreen {
+  menu(text, "info")
+  s.poll(what = "the item info with `Sent message` and `History`") { s.seesText("Sent message") && s.seesText("History") }
+  return ItemInfoScreen(s)
+}
+
+class ItemInfoScreen(private val s: UiScope) {
+  fun history(): List<String> = s.texts().dropWhile { it != "History" }.drop(1)
+  fun close() {
+    s.hideKeyboard(); s.escape()
+    s.poll(what = "the item info to close") { !ModalManager.end.hasModalsOpen() }
+  }
+}
+```
+`history()` relies on the info pane being later in the semantics tree than the chat. On desktop `EndPartOfScreen` follows `CenterPartOfScreen` (`App.kt:443-452`), so chat bubbles with the same text come before "History". The "History" heading (INFO:328) appears only in the info pane. Android: the modal is drawn after the chat; check on the first run.
+
+Desktop-only helper (private in `EditMessageDesktopTest`, mirrors desktop `UiTest.pressEnter` at `apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/harness/UiTest.kt:293-298`):
+```kotlin
+private fun UiScope.pressUp(key: UiKey) {
+  val node = ui.onNode(matcher(key))
+  ui.runOnUiThread { node.performKeyInput { pressKey(Key.DirectionUp) } }
+  ui.waitForIdle()
+}
+```
+
+Precondition helper (decision Q2):
+```kotlin
+private fun allowFullDeletionViaApi(contactName: String) {
+  val ct = (chatModel.chats.value.first { it.chatInfo.chatViewName == contactName }.chatInfo as ChatInfo.Direct).contact
+  val prefs = contactFeaturesAllowedToPrefs(contactUserPrefsToFeaturesAllowed(ct.mergedPreferences).copy(fullDelete = ContactFeatureAllowed.Always))  // API:6373, 6398, 6324
+  runBlocking { chatController.apiSetContactPrefs(null, ct.contactId, prefs) } ?: error("apiSetContactPrefs($contactName) failed")  // API:2021
+}
+```
+(The model is not updated. T7 tests received deletions, which the core decides.)
+
+### 4.1 T1 `edit_menu_updatesPeer` (extended)
+
+- **Scenario**: alice opens Edit on her message and cancels; opens it again and submits it unchanged; then edits it. bob sees exactly one edit. The item info shows both versions, newest first and marked "(current)".
+- **Fails if**:
+  - the edit isn't sent with the new text: CMP:818 `updateMsgContent(oldMsgContent)` → `oldMsgContent`;
+  - Cancel leaves the edit: delete `clearState()` at CMP:1266;
+  - the field isn't prefilled: CMP:128 `else -> editingItem.content.text` → `""`;
+  - the history is wrong: INFO:329-330 show only `versions.first()`, or `current = i == 0` → `i == versions.lastIndex`.
+- **Setup**: `app("alice")`, `cli("bob")`, `connect(bob)` (`Helpers.kt:26`).
+- **CLI** (from `testDirectMessageUpdate`, Direct.hs:672-674, and `View.hs:3079-3080`): `bob expectsMessage "alice> hello"`, then **as the very next line** `bob expectsMessage "alice> [edited] hey 👋"`.
+- **Steps / assertions**:
+```kotlin
+val chat = alice.chatList.open("bob")
+chat.send("hello"); bob expectsMessage "alice> hello"
+val id = chat.itemId("hello")
+chat.itemInfo("hello").run {
+  val h = history()
+  check(h.count { it == "(current)" } == 1 && h.indexOfFirst { it.startsWith("hello") } in 0 until h.indexOf("(current)") && h.none { "hey" in it }) { "unedited history: $h" }
+  close()
+}
+waitFor(Ui.Chat.Message); assertFalse("edit bar before Edit", exists(described("Cancel")))
+chat.menu("hello", "edit")
+poll(what = "the edit bar with `hello` in the message field") { editableText(Ui.Chat.Message) == "hello" && exists(described("Cancel")) }
+hideKeyboard(); click(described("Cancel"))
+poll(what = "the edit bar gone and the field empty") { !exists(described("Cancel")) && editableText(Ui.Chat.Message).isNullOrEmpty() }
+chat.menu("hello", "edit")
+poll(what = "`hello` in the message field") { editableText(Ui.Chat.Message) == "hello" }
+chat.replaceAndSend("hello")
+chat.menu("hello", "edit")
+chat.replaceAndSend("hey 👋")
+bob expectsMessage "alice> [edited] hey 👋"
+poll(what = "the same bubble showing `hey 👋`, not `hello`, edited in the model") {
+  chat.item(id)?.let { it.content.text == "hey 👋" && it.meta.itemEdited } == true &&
+    textsOf(Ui.Chat.Item(id)).let { t -> t.any { "hey 👋" in it } && t.none { "hello" in it } }
+}
+chat.itemInfo("hey 👋").run {
+  val h = history()
+  val newest = h.indexOfFirst { it.startsWith("hey 👋") }; val cur = h.indexOf("(current)"); val old = h.indexOfFirst { it.startsWith("hello") }
+  check(newest in 0 until cur && cur < old && h.count { it == "(current)" } == 1) { "edited history: $h" }
+  close()
+}
+```
+  - Opposite first: no edit bar before Edit; one version before the edit; "hello" in the bubble before.
+  - Negative control: the unchanged submit and the cancel produce no peer line (`expectsMessage` reads the next line).
+- **Strings**: "Sent message" (strings.xml:421), "History" (:423), "(current)" (:2016), "Cancel" (:801).
+- **Keys**: new `ItemMenu(id,"info")`; existing `ItemMenu(id,"edit")` (CIV:469).
+- **Platform**: Android long press via `menu`; `hideKeyboard()` before tapping (x) and before `escape()` in `close()` (guide §3). The info opens in the end pane (desktop) or full screen (Android).
+- **Flakiness**: `itemInfo` loads asynchronously (CV:716-760), and the poll waits for it. `escape()` closes the modal through its BackHandler (same as `GroupLinksTest.kt:83-86`).
+
+### 4.2 T2 `edit_notOffered_forReceivedOrForwarded`
+
+- **Scenario**: Edit appears in the menu of alice's own message, but not on bob's message or on a message alice forwarded.
+- **Fails if**: CIV:468 drops `cItem.meta.editable &&` (Edit shows on received items), or replaces it with `cItem.chatDir.sent` (Edit shows on the forwarded item; only the forwarded branch catches this).
+- **Setup / CLI**: `connect(bob)`; `bob sends "@alice theirs"`; alice sends "mine" → `bob expectsMessage "alice> mine"`.
+- **Steps**:
+```kotlin
+val chat = alice.chatList.open("bob")
+val received = chat.itemId("theirs")
+chat.send("mine"); bob expectsMessage "alice> mine"
+val mine = chat.itemId("mine")
+chat.forwardTo("theirs", "bob")                                     // Screens:257
+var fwd = 0L
+poll(what = "alice's forwarded copy of `theirs`") {
+  fwd = chatModel.chatsContext.chatItems.value.lastOrNull { it.content.text == "theirs" && it.meta.itemForwarded != null }?.id ?: 0L
+  fwd != 0L && exists(Ui.Chat.Item(fwd))
+}
+assertTrue(editOffered(mine)); assertFalse(editOffered(received)); assertFalse(editOffered(fwd))
+
+private fun UiScope.editOffered(id: Long): Boolean {
+  rightClick(Ui.Chat.Item(id)); waitFor(Ui.Chat.ItemMenu(id, "select"))
+  val offered = exists(Ui.Chat.ItemMenu(id, "edit"))
+  click(Ui.Chat.ItemMenu(id, "select")); waitFor(SEL_TITLE); escape()
+  poll(what = "selection mode to end") { !exists(SEL_TITLE) }
+  return offered
+}
+```
+  - Absence follows presence: "select" is waited for before reading "edit".
+  - "select" closes the menu the way `FilesTest.kt:80-84` does (there is no harness close-menu action).
+  - bob's "-> forwarded" lines are left unconsumed; they are not errors.
+- **Platform**: the share list must list the open chat (bob). If it doesn't, forward to "Private notes" (a forwarded note is not editable either, `Messages.hs:539`).
+- **Catalogue**: rename the row (section 6). The voice branch ("no Edit on own voice", CIV:468 `!is MCVoice`) belongs in §E's voice test as a menu check.
+
+### 4.3 T3 `edit_upArrow_editsLastMessage` (desktop)
+
+- **File**: `apps/multiplatform/common/src/desktopTest/kotlin/chat/simplex/app/ui/desktop/EditMessageDesktopTest.kt`, class `EditMessageDesktopTest : UiTest()`.
+- **Scenario**: with an empty field, Up edits alice's last own message, even when bob's message is newer. With text in the field, Up does nothing.
+- **Fails if**: PTF:141 drops `&& cs.message.text.isEmpty()` (Up with text enters edit), or CMP:1190 `findLast { it.meta.editable }` → `lastOrNull()` (picks bob's message), or PTF:142 `onUpArrow()` is removed.
+- **CLI**: `bob expectsMessage "alice> first"`, `"alice> second"`, `bob sends "@alice from bob"`, finally `bob expectsMessage "alice> [edited] second!"`.
+- **Steps**:
+```kotlin
+val chat = alice.chatList.open("bob")
+chat.send("first"); bob expectsMessage "alice> first"
+chat.send("second"); bob expectsMessage "alice> second"
+bob sends "@alice from bob"; chat.itemId("from bob")
+check(editableText(Ui.Chat.Message).isNullOrEmpty() && !exists(described("Cancel")))
+pressUp(Ui.Chat.Message)
+poll(what = "the edit bar with alice's last message `second`") { editableText(Ui.Chat.Message) == "second" && exists(described("Cancel")) }
+chat.replaceAndSend("second!")
+bob expectsMessage "alice> [edited] second!"
+typeInto(Ui.Chat.Message, "x")
+pressUp(Ui.Chat.Message)
+assertTrue("Up with text in the field", editableText(Ui.Chat.Message) == "x" && !exists(described("Cancel")))
+```
+  - The key handler is synchronous (PTF:141-143). `waitForIdle` in `pressUp` makes the immediate check valid, with no sleep.
+  - Focus: the field holds focus after `send`/`typeInto`. If `performKeyInput` needs explicit focus, `click(Ui.Chat.Message)` first.
+- **Flakiness**: none expected. The second branch's opposite (Up works) is proven by the first branch.
+
+### 4.4 T4 `edit_ownFile_previewWithoutCancel` (desktop, P2)
+
+- **Scenario**: alice sends a file with the caption "doc". While she edits it, the compose area shows the file preview without the cancel button. bob gets the edited caption, and the file is not sent again.
+- **Fails if**: CMP:1224 `cancelEnabled = !composeState.value.editing && …` → `!composeState.value.inProgress` (Cancel shown while editing), or CMP:779 `MsgContent.MCFile(msgText)` → `MsgContent.MCText(msgText)` (the core rejects the type change, so bob gets no edit), or CMP:275 `FilePreview` → `NoPreview`.
+- **Setup**: as `FilesDesktopTest.kt:13-32`: a temp `report.txt` with a fixed 31-character text.
+- **CLI** (`tests/ChatTests/Files.hs:91-92` pattern, `View.hs:2443-2444`):
+  - `bob.eventuallyMessage("alice> doc", CONNECT_TIMEOUT_MS)`;
+  - `bob expectsMessage "alice> sends file report.txt (31 bytes / 31 bytes)"`;
+  - `bob expects "use /fr 1 [<dir>/ | <path>] to receive it"`;
+  - later `bob expectsMessage "alice> [edited] new doc"`, then sentinel `bob expectsMessage "alice> ping"`.
+- **Steps**:
+```kotlin
+alice.chatList.open("bob"); waitFor(Ui.Chat.Message)
+enterText(Ui.Chat.Message, source.absolutePath)
+poll(what = "the report.txt preview with `Cancel file preview`") { seesDescription("Cancel file preview") && seesText("report.txt") && editableText(Ui.Chat.Message).isNullOrEmpty() }
+typeInto(Ui.Chat.Message, "doc"); click(Ui.Chat.Send)
+// CLI lines above
+val id = fileItemId("report.txt")   // as FilesTest: msgContent is MCFile && file.fileName == "report.txt"
+poll(what = "the sent preview cleared, one `report.txt` (the item)") { !seesDescription("Cancel file preview") && texts().count { it == "report.txt" } == 1 }
+rightClick(Ui.Chat.Item(id)); click(Ui.Chat.ItemMenu(id, "edit"))
+poll(what = "editing `doc` with a report.txt preview and no `Cancel file preview`") {
+  editableText(Ui.Chat.Message) == "doc" && texts().count { it == "report.txt" } == 2 && exists(described("Cancel")) && !seesDescription("Cancel file preview")
+}
+ChatScreen(this).replaceAndSend("new doc")
+bob expectsMessage "alice> [edited] new doc"
+ChatScreen(this).send("ping"); bob expectsMessage "alice> ping"
+```
+  - Opposite first: "Cancel file preview" is present before sending.
+  - Negative control: no second "sends file" line before "ping".
+- **Strings**: "Cancel file preview" (strings.xml:604).
+- **Risk**: the count of "report.txt" texts (item plus preview). Check on the first run that the file item renders the name as exactly one text node.
+
+### 4.5 T5 `edit_group_membersSeeEdited` (P2)
+
+- **Fails if**: CMP:813 `type = cInfo.chatType` → `ChatType.Direct` (direct edit still passes, group edit fails).
+- **Setup**: `connect(bob); connect(cath); val chat = ownGroup(alice, "team", bob, cath)` (Screens:377). Then `bob.eventuallyMatching(Regex("#team: (new )?member cath is connected"), CONNECT_TIMEOUT_MS)` and the same for cath/bob (as `GroupLinksTest.kt:52-53`).
+- **CLI** (Groups.hs:1300-1313):
+  - after `chat.send("hello")`: `bob.eventuallyMessage("#team alice> hello", CONNECT_TIMEOUT_MS)` and the same for cath;
+  - after `chat.menu("hello","edit"); chat.replaceAndSend("hey 👋")`: `bob expectsMessage "#team alice> [edited] hey 👋"` and `cath expectsMessage "#team alice> [edited] hey 👋"`.
+- **Flakiness**: open flake 15.4.1 (a CLI member's join not completed) applies to `ownGroup`.
+
+### 4.6 T6 `delete_forEveryone_fullDeletion_peerSeesDeleted`
+
+- **Scenario**:
+  1. Under default preferences, alice's Delete warns that the message "will be marked for deletion". "Delete for me" removes it only locally.
+  2. bob allows full deletion. Now the warning says it "cannot be undone", and "For everyone" removes the message on both sides.
+  3. The selection alert follows the same rule for two messages.
+- **Fails if**:
+  - CIV:347 drops `fullDeleteAllowed ||` (wrong single warning);
+  - CV:332 drops `fullDeleteAllowed ||` (wrong multi warning);
+  - CIV:1418 `cidmInternal` → `cidmBroadcast` (bob gets "[marked deleted] one" instead of "alice> two");
+  - CV:3418-3420 always upserts (alice keeps "two").
+- **CLI**:
+  - `bob expectsMessage "alice> one"`;
+  - `bob sends "/set delete @alice always"`, `bob expects "you updated preferences for alice:"`, `bob expects "Full deletion: enabled for contact (you allow: always, contact allows: no)"` (mirror of `testAllowFullDeletionContact`, `tests/ChatTests/Profiles.hs:3420-3422`);
+  - `bob expectsMessage "alice> two"` (sentinel for the delete-for-me);
+  - `bob expectsMessage "alice> [deleted] two"` (Profiles.hs:3428; `View.hs:3082-3084`);
+  - `"alice> three"`, `"alice> four"`, then `"alice> [deleted] three"`, `"alice> [deleted] four"`.
+- **Steps**:
+```kotlin
+val chat = alice.chatList.open("bob")
+chat.send("one"); bob expectsMessage "alice> one"; val one = chat.itemId("one")
+chat.menu("one", "delete")
+poll(what = "`Delete message?` saying it will be marked for deletion, with both buttons") { seesText("Delete message?") && seesText(MARK_ONE) && exists(FOR_ME) && exists(FOR_EVERYONE) }
+click(FOR_ME)
+poll(what = "`one` removed from alice's chat") { chat.item(one) == null && !exists(Ui.Chat.Item(one)) }
+bob sends "/set delete @alice always"; bob expects "you updated preferences for alice:"
+bob expects "Full deletion: enabled for contact (you allow: always, contact allows: no)"
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's full-deletion consent reaching alice") { alice.chatList.chat("bob").chatInfo.featureEnabled(ChatFeature.FullDelete) }
+chat.send("two"); bob expectsMessage "alice> two"; val two = chat.itemId("two")
+chat.menu("two", "delete")
+poll(what = "`Delete message?` saying it cannot be undone") { seesText(FULL_ONE) && !seesText(MARK_ONE) && exists(FOR_EVERYONE) }
+click(FOR_EVERYONE); bob expectsMessage "alice> [deleted] two"
+poll(what = "`two` removed, not marked deleted") { chat.item(two) == null && !exists(Ui.Chat.Item(two)) }
+chat.send("three"); bob expectsMessage "alice> three"; chat.send("four"); bob expectsMessage "alice> four"
+val three = chat.itemId("three"); val four = chat.itemId("four")
+chat.select("three"); chat.toggle(four); poll(what = "Selected 2") { chat.selectionTitle() == "Selected 2" }
+click(SEL_DELETE)
+poll(what = "`Delete 2 messages?` saying they cannot be undone, with For everyone") { seesText("Delete 2 messages?") && seesText(FULL_MANY) && exists(FOR_EVERYONE) }
+click(FOR_EVERYONE)
+bob expectsMessage "alice> [deleted] three"; bob expectsMessage "alice> [deleted] four"
+poll(what = "both removed and selection ended") { chat.item(three) == null && chat.item(four) == null && !exists(SEL_TITLE) }
+```
+  - The `featureEnabled` poll is a wait for a precondition (catalogue: the CLI prints before the change reaches alice), not an assertion.
+  - The mark-deleted multi text (opposite branch of CV:332) is asserted in T9.
+- **Strings**: "Delete message?" (:441), "Delete %d messages?" (:442), warnings :443-446, "Delete for me"/"For everyone" (:453-454).
+- **Keys**: new multi-dialog options and `SEL_DELETE`.
+- **Platform**: none beyond `menu` (long press on Android).
+
+### 4.7 T7 `markedDeleted_received_revealHide`
+
+- **Scenario**:
+  1. bob deletes one of his messages for everyone: alice sees "marked deleted".
+  2. After a second consecutive deletion, the two collapse into "2 messages marked deleted".
+  3. Reveal shows both texts; Hide collapses them again; Select on the collapsed row selects both.
+  4. Once alice allows full deletion, bob's next delete removes his message from her chat.
+- **Fails if**:
+  - MDV:69 `if (total <= 1)` → `if (true)` (no count);
+  - CIV:563-565 Reveal removed;
+  - CIV:484-486 Hide removed;
+  - CV:3353-3366 range branch removed (Select gives "Selected 1");
+  - API:3131-3135 `if (toChatItem == null) removeChatItem(...) else upsert` → always upsert (full-deleted "three" stays).
+- **CLI**:
+  - `bob sends "@alice keep"`, `"@alice one"`, `"@alice two"`;
+  - `bob sends "\\@alice one"` (echoed: not a message command, `src/Simplex/Chat/Terminal/Input.hs:64,90-100`), `bob expects "message marked deleted"` (`View.hs:941` + `chatItemDeletedText` :635-647);
+  - the same for "two";
+  - after the API helper: `bob expects "alice updated preferences for you:"`, `bob expects "Full deletion: enabled for you (you allow: default (no), contact allows: always)"` (Profiles.hs:3423-3424);
+  - `bob sends "@alice three"`, `bob sends "\\@alice three"`, `bob expects "message deleted"`.
+  - The core matches the text by prefix, newest first (`Store/Messages.hs:2741-2745`); "keep", "one", "two" and "three" are prefix-distinct.
+- **Steps**:
+```kotlin
+bob sends "@alice keep"; bob sends "@alice one"; bob sends "@alice two"
+val chat = alice.chatList.open("bob")
+val keep = chat.itemId("keep"); val one = chat.itemId("one"); val two = chat.itemId("two")
+check(textsOf(Ui.Chat.Item(one)).let { t -> t.any { "one" in it } && "marked deleted" !in t })
+bob sends "\\@alice one"; bob expects "message marked deleted"
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`one` shown as `marked deleted` without its text") { textsOf(Ui.Chat.Item(one)).let { t -> "marked deleted" in t && t.none { "one" in it } } }
+bob sends "\\@alice two"; bob expects "message marked deleted"
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`2 messages marked deleted` on one row") { "2 messages marked deleted" in textsOf(Ui.Chat.Item(two)) && !exists(Ui.Chat.Item(one)) }
+check(textsOf(Ui.Chat.Item(keep)).any { "keep" in it })
+chat.menu("two", "reveal")
+poll(what = "both texts revealed") { textsOf(Ui.Chat.Item(one)).any { "one" in it } && textsOf(Ui.Chat.Item(two)).any { "two" in it } }
+chat.menu("two", "hide")
+poll(what = "collapsed again") { "2 messages marked deleted" in textsOf(Ui.Chat.Item(two)) && !exists(Ui.Chat.Item(one)) }
+chat.menu("two", "select")
+poll(what = "the collapsed range selected as 2") { chat.selectionTitle() == "Selected 2" }
+escape(); poll(what = "selection mode to end") { !exists(SEL_TITLE) }
+allowFullDeletionViaApi("bob")
+bob expects "alice updated preferences for you:"
+bob expects "Full deletion: enabled for you (you allow: default (no), contact allows: always)"
+bob sends "@alice three"; val three = chat.itemId("three")
+bob sends "\\@alice three"; bob expects "message deleted"
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`three` removed from alice's chat") { chat.item(three) == null && !exists(Ui.Chat.Item(three)) }
+check(exists(Ui.Chat.Item(keep)) && "2 messages marked deleted" in textsOf(Ui.Chat.Item(two)))
+```
+  - Opposite first: text before deletion; single label before the count; collapsed before Reveal; "three" visible before its deletion.
+  - Negative control: "keep" is unaffected throughout.
+- **Strings**: "marked deleted" (:51), "%d messages marked deleted" (:52), "Selected %d" (:521).
+- **Keys**: `ItemMenu(id,"reveal")` (CIV:564), `ItemMenu(id,"hide")` (CIV:485).
+- **Platform**: `escape()` exits selection on both (counter-toolbar BackHandler SEL:27; used by `FilesTest.kt:83`).
+- **Flakiness**: the merged row's lazy-list key is the newest item (CV:2401), so "two" keeps its node when it collapses.
+
+### 4.8 T8 `select_toggle_updatesCounter`
+
+- **Scenario**: "Select" puts the chat into selection mode with "Selected 1". Clicking items toggles them (sent and received). Unselecting all shows "Nothing selected" with Delete disabled. (x) leaves selection mode with all messages kept.
+- **Fails if**: CV:2241 `select = !checked` → `select = true` (no unselect); SEL:34-38 count text; SEL:31 `NavigationButtonClose(onButtonClicked = null)` (close disabled); SEL:145 `count == 0 ||` removed (Delete enabled with nothing selected).
+- **Setup / CLI**: `connect(bob)`; `bob sends "@alice one"`, `"@alice two"`; alice sends "mine" → `bob expectsMessage "alice> mine"`.
+- **Steps**:
+```kotlin
+val chat = alice.chatList.open("bob")
+chat.send("mine"); bob expectsMessage "alice> mine"
+val one = chat.itemId("one"); val two = chat.itemId("two"); val mine = chat.itemId("mine")
+waitFor(Ui.Chat.Bar.part("title")); assertFalse(exists(SEL_TITLE)); assertFalse(exists(SEL_DELETE))
+chat.menu("one", "select")
+poll(what = "`Selected 1` instead of bob's chat bar, Delete enabled") { chat.selectionTitle() == "Selected 1" && !exists(Ui.Chat.Bar.part("title")) && isEnabled(SEL_DELETE) }
+chat.toggle(two);  poll(what = "Selected 2") { chat.selectionTitle() == "Selected 2" }
+chat.toggle(mine); poll(what = "Selected 3") { chat.selectionTitle() == "Selected 3" }
+chat.toggle(one);  poll(what = "Selected 2 after unselecting `one`") { chat.selectionTitle() == "Selected 2" }
+chat.toggle(two);  poll(what = "Selected 1") { chat.selectionTitle() == "Selected 1" }
+chat.toggle(mine); poll(what = "`Nothing selected` with Delete disabled") { chat.selectionTitle() == "Nothing selected" && exists(SEL_DELETE) && !isEnabled(SEL_DELETE) }
+click(described("Back"))
+poll(what = "selection ended with bob's chat bar back and all three messages kept") {
+  !exists(SEL_TITLE) && !exists(SEL_DELETE) && exists(Ui.Chat.Bar.part("title")) && listOf(one, two, mine).all { chat.item(it) != null && exists(Ui.Chat.Item(it)) }
+}
+```
+- **Strings**: "Selected %d" (:521), "Nothing selected" (:520), "Back" (:800, close icon description).
+- **Platform**:
+  - Android one-hand UI puts the counter toolbar at the bottom (CV:1177); keys don't care.
+  - Overlap: Android-only `BackKeyTest.back_exitsSelectionMode` enters selection and reaches "Selected 2" too, then tests Back. T8 tests the (x) and the toggles, so it is not a duplicate. Note it in the PR.
+- **Flakiness**: received items slide by `selectionOffset` (CV:2026), which `waitStable` in `click` handles. Do not use `exists(Ui.Chat.Message)` as "compose back" (hidden composer SEL:82).
+
+### 4.9 T9 `selectDelete_forEveryone_peerSeesBoth`
+
+- **Scenario**:
+  1. With one of alice's and one of bob's messages selected, Delete warns that they "cannot be undone" and offers only "Delete for me". Both disappear locally; bob sees nothing.
+  2. With two of alice's messages selected, Delete warns they "will be marked for deletion" and offers "For everyone". bob sees both marked deleted, and alice sees them collapsed.
+- **Fails if**: SEL:159 drops `ci.meta.deletable &&` (For everyone offered on a mixed selection); CIV:1451 `if (forAll)` → `if (true)`; CV:332-335 branches swapped; CV:3399 `if (forAll) cidmBroadcast` → `cidmInternal`.
+- **CLI** (`testDirectMessageDeleteMultiple`, Direct.hs:883-886):
+  - `bob expectsMessage "alice> hello"`;
+  - `bob sends "@alice hey"`;
+  - `bob expectsMessage "alice> hi"`, `"alice> bye"`;
+  - then, as the next lines, `bob expectsMessage "alice> [marked deleted] hi"` and `bob expectsMessage "alice> [marked deleted] bye"`.
+- **Steps**:
+```kotlin
+val chat = alice.chatList.open("bob")
+chat.send("hello"); bob expectsMessage "alice> hello"
+bob sends "@alice hey"
+chat.send("hi"); bob expectsMessage "alice> hi"; chat.send("bye"); bob expectsMessage "alice> bye"
+val hello = chat.itemId("hello"); val hey = chat.itemId("hey"); val hi = chat.itemId("hi"); val bye = chat.itemId("bye")
+chat.select("hello"); chat.toggle(hey); poll(what = "Selected 2") { chat.selectionTitle() == "Selected 2" }
+click(SEL_DELETE)
+poll(what = "`Delete 2 messages?` saying they cannot be undone, with Delete for me") { seesText("Delete 2 messages?") && seesText(FULL_MANY) && exists(FOR_ME) }
+assertFalse("For everyone offered for a selection with bob's message", exists(FOR_EVERYONE))
+click(FOR_ME)
+poll(what = "`hello` and `hey` removed, selection ended, `hi` kept") {
+  chat.item(hello) == null && chat.item(hey) == null && !exists(Ui.Chat.Item(hello)) && !exists(Ui.Chat.Item(hey)) && !exists(SEL_TITLE) && exists(Ui.Chat.Item(hi))
+}
+chat.select("hi"); chat.toggle(bye); poll(what = "Selected 2") { chat.selectionTitle() == "Selected 2" }
+click(SEL_DELETE)
+poll(what = "`Delete 2 messages?` saying they will be marked for deletion, with For everyone") { seesText(MARK_MANY) && exists(FOR_EVERYONE) }
+click(FOR_EVERYONE)
+bob expectsMessage "alice> [marked deleted] hi"
+bob expectsMessage "alice> [marked deleted] bye"
+poll(what = "alice's two messages collapsed into `2 messages marked deleted`") { "2 messages marked deleted" in textsOf(Ui.Chat.Item(bye)) && !exists(Ui.Chat.Item(hi)) }
+```
+  - The first deletion's "nothing to bob" is proven by bob's next lines being the marked-deleted ones.
+  - Both branches of the For everyone button and of the CV:332 text are covered (the full-delete text in T6).
+- **Keys**: `SEL_DELETE` and the multi-dialog options.
+
+### 4.10 T10 `selectForward_multiple_peerReceives`
+
+- **Scenario**:
+  1. alice selects her "hi" and bob's "hey" and "bye"; Forward is enabled.
+  2. bob deletes "bye" for everyone. It stays selected, but Forward turns off.
+  3. Unselecting "bye" turns Forward on again.
+  4. Forwarding to cath delivers "hi" and "hey" only.
+- **Fails if**: SEL:127 drops `chatItems.value` from the `LaunchedEffect` keys (Forward stays enabled after bob's delete); SEL:163 drops `ci.meta.itemDeleted == null`; CV:368 `itemIds.toList()` → `listOf(itemIds.first())` (only one forwarded).
+- **CLI** (`testForwardContactToContactMulti`, `tests/ChatTests/Forward.hs`):
+  - `bob expectsMessage "alice> hi"`, `bob sends "@alice hey"`, `"@alice bye"`;
+  - `bob sends "\\@alice bye"`, `bob expects "message marked deleted"`;
+  - `cath.eventuallyMessage("alice> -> forwarded", CONNECT_TIMEOUT_MS)`, `cath expects "      hi"`, `cath expectsMessage "alice> -> forwarded"`, `cath expects "      hey"`;
+  - sentinel `cath expectsMessage "alice> ping"`.
+- **Steps**:
+```kotlin
+connect(bob); connect(cath)
+val chat = alice.chatList.open("bob")
+chat.send("hi"); bob expectsMessage "alice> hi"
+bob sends "@alice hey"; bob sends "@alice bye"
+val hi = chat.itemId("hi"); val hey = chat.itemId("hey"); val bye = chat.itemId("bye")
+chat.select("hi"); chat.toggle(hey); chat.toggle(bye)
+poll(what = "Selected 3 with Forward enabled") { chat.selectionTitle() == "Selected 3" && isEnabled(SEL_FORWARD) }
+bob sends "\\@alice bye"; bob expects "message marked deleted"
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "`bye` marked deleted, still selected, Forward disabled") {
+  chat.item(bye)?.meta?.itemDeleted != null && chat.selectionTitle() == "Selected 3" && exists(SEL_FORWARD) && !isEnabled(SEL_FORWARD)
+}
+chat.toggle(bye)
+poll(what = "Selected 2 with Forward enabled again") { chat.selectionTitle() == "Selected 2" && isEnabled(SEL_FORWARD) }
+chat.forwardSelectionTo("cath")
+// cath lines above
+chat.send("ping"); cath expectsMessage "alice> ping"
+```
+  - Order: `forwardContent` takes items in chat order (CV:3684), so "hi" comes before "hey".
+  - After Send, alice's open chat is cath's (`forwardContent` closes the source chat, CV:3682), so `chat.send` goes to cath.
+
+### 4.11 Optional changes that make existing tests stronger (each needs your OK, Q7)
+
+- `EditMessageTest.edit_received_updatesBubble` (`EditMessageTest.kt:9-19`): assert "hello" is in the bubble before bob's edit and absent after (today it only checks "hey" is present).
+- `GroupLinksTest.memberInfo_blockForAllNotifiesMembers` (03 §14 owner): after "after block", bob sends one more message, and the single row reads "2 messages blocked by admin" (MDV:73-74). This replaces the dropped `blockedByAdmin_items_showBlocked`.
+
+## 5. Dropped rows and branches (reasons)
+
+| Row / branch | Reason |
+|---|---|
+| `edit_quotedReply_keepsQuote` | The quote is kept by the core; the app sends only the content (CMP:818) and upserts the result. No realistic app mutation fails only this; covered by Haskell `testDirectMessageUpdate`. |
+| `edit_imageCaption_updates` | Same app receive path as `edit_received_updatesBubble` (API:3090); +XFTP cost. |
+| `edit_ownImage_previewWithoutCancel` | Image attach on both platforms needs FD support; the cancel-while-editing rule and `updateMsgContent` are covered by the T4 file variant. Revisit when §F has an image-attach helper. |
+| Voice branch of the "no Edit" rule | Needs REC; belongs in §E (one menu check in the voice test). |
+| Edit window (24 h) branch | `deletable'` uses `nominalDay` at item load (`Messages.hs:544-550`); unreachable without clock control. |
+| `blockedByAdmin_items_showBlocked` | Single label already asserted by `GroupLinksTest.memberInfo_blockForAllNotifiesMembers`; count branch → 4.11. |
+| `select_limits_forward20_delete200` | 300 messages plus 201 individual clicks (no select-all in the main chat); the rule is two comparisons (SEL:145-146). Better as a unit test of `recheckItems`, outside this suite. |
+| Merged rows | `edit_unchanged_noUpdate`, `edit_cancel_clearsCompose`, `edit_metaShowsEditedIcon`, `info_history_listsVersions` → T1; `delete_ownForMe_localOnly` → T6; `markedDeleted_consecutive_collapsedCount`, `delete_received_fullDelete_removed`, `select_mergedEvents_selectsWholeRange` → T7; `select_enterMode_showsCounterToolbar`, `select_close_exitsMode` → T8; `selectDelete_mixed_onlyForMe` → T9; `select_itemDeletedByPeer_recheck` → T10. |
+
+## 6. Catalogue corrections (02)
+
+- I line 138: CIV:464-469 → CIV:468-473; CMP:806 → CMP:808-827; CMP:1263-1265 → CMP:1265-1267. `edit_metaShowsEditedIcon`: the icon has no content description (CIMetaView.kt:84, :198-199), so it can't be asserted visually; it is merged into `edit_menu_updatesPeer` (model `meta.itemEdited` plus the 2-version history).
+- I line 139: PTF:138 → PTF:141-142; CMP:1185 → CMP:1187-1192 (only with no context item and no preview; picks `findLast { meta.editable }`, i.e. alice's last own message, not the last item); desktop-only.
+- I line 142: CMP:1210, 1222 → CMP:1212, 1224; the file variant runs desktop-only through path paste.
+- I line 143: rename to `edit_notOffered_forReceivedOrForwarded`; CIV:464 → CIV:468; the voice part moves to §E; note that `editable` also expires after 24 h (`Messages.hs:538-550`, untestable).
+- J line 149: CIV:869-915 → CIV:873-920; CIV:1390-1424 → CIV:1399-1433; `delete_ownForMe_localOnly` merged into `delete_forEveryone_fullDeletion_peerSeesDeleted`.
+- J line 150: CIV:503-519 → CIV:507-523; CIV:950-972 → CIV:958-980. A marked-deleted item renders through CIV:702-704, so its Reveal is CIV:563-565; Hide on a revealed item is CIV:484-486. `delete_received_fullDelete_removed` is merged into `markedDeleted_received_revealHide`.
+- J line 151: MDV:68-110 → MDV:48-111 (count logic :69-78). `blockedByAdmin_items_showBlocked` is a duplicate of `GroupLinksTest.memberInfo_blockForAllNotifiesMembers` for the single case. `markedDeleted_consecutive_collapsedCount` is merged and works in a direct chat (no group needed).
+- K line 156: CV:3342 → CV:3345-3381; CV:298 → CV:300; CV:1170-1176 → CV:1172-1178. "The compose field is back" is not observable: SEL:82 composes a hidden `ComposeView` (with `Ui.Chat.Message`) in selection mode; check the buttons toolbar instead. The three tests merge into `select_toggle_updatesCounter`. The close (x) is `described("Back")` (SEL:31 → `DefaultTopAppBar.kt:140-146`).
+- K line 157: CV:327-347 → CV:325-349; SEL:95-101 → SEL:97-104; SEL:157 → SEL:159; CIV:1437-1448 → CIV:1435-1460. Merged into one test.
+- K line 158: CV:361-384 → CV:363-389.
+- K line 159: SEL:144-145 → SEL:145-146; SEL:161 → SEL:163; SEL:125-127 → SEL:127-129. `select_itemDeletedByPeer_recheck` → merged into `selectForward_multiple_peerReceives`. `select_mergedEvents_selectsWholeRange` → merged into `markedDeleted_received_revealHide` (deleted-items range, same CV:3353-3366 logic). `select_limits_forward20_delete200` dropped.
+- P line 207: ChatItemInfoView.kt:103-108 → :105-110; merged into `edit_menu_updatesPeer`.
+- Header line 5 says the selection-toolbar keys come "in K2". Concretely they are `Ui.Chat.Selection.part("delete")` / `.part("forward")` (SEL:97, :115); selection circles need no key (clicking the item toggles, CV:2238-2243).
+
+## 7. Suspected app issues (report only, plan §15.5 candidates)
+
+1. **Select-all button labelled "Back"**: `SelectAllButton` uses `stringResource(MR.strings.back)` as its icon description (SEL:57). Screen readers announce "Back" for "select all". In report/support selection it also sits next to the real (x) "Back", making `described("Back")` ambiguous there.
+2. **Selection toolbar buttons and the edited icon have no accessible labels**: Delete/Moderate/Forward icons pass `null` (SEL:98-121), and so does the edited mark (CIMetaView.kt:198-199). A minor accessibility gap (the catalogue already plans K2 keys for the toolbar).
+3. **A live hidden composer in selection mode**: SEL:82 composes a full `ComposeView` with `Chat.sampleData` behind the toolbar, only to measure its height. It duplicates the `chat.compose`/`chat.send` nodes. On desktop it may be reachable by keyboard focus (Tab) while the visible toolbar covers it. Unverified; worth a manual check before reporting.
+4. No functional bug found in the edit/delete/select logic read for this design.
+
+## 8. Cost and order
+
+- P1 (8 tests): T1, T2, T6, T7, T8, T9, T10 (T10 needs 2 peers), T3.
+- P2: T4 (XFTP), T5 (group).
+- Expected run time: about 1 reset plus 1-2 contact connections each; T5 adds group setup.
+- Implement in this order: keys (section 3) → Screens helpers (4.0) → T8/T9 (validate the selection keys) → T1/T2 → T6/T7 → T10 → desktop T3/T4 → T5.
+- One build at the end (memory: batch builds); compile both platforms because of the `uiKey` parameter.
diff --git a/plans/ui-tests/drafts/design-D2-forward-drafts.md b/plans/ui-tests/drafts/design-D2-forward-drafts.md
new file mode 100644
index 0000000000..325385011a
--- /dev/null
+++ b/plans/ui-tests/drafts/design-D2-forward-drafts.md
@@ -0,0 +1,526 @@
+# Design D2: forwarding (02 §L) and draft persistence (02 §S)
+
+Design only: no test code, keys or catalogue edits are made here. Rules: `apps/multiplatform/common/src/uiTestShared/README.md` (the guide), plan §0.5.
+
+- Paths are relative to `apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/` unless they start with `apps/`, `tests/` or `src/`. **CMP** = `views/chat/ComposeView.kt`, **CV** = `views/chat/ChatView.kt`, **CIV** = `views/chat/item/ChatItemView.kt`, **SEL** = `views/chat/SelectableChatItemToolbars.kt`, **SLV** = `views/chatlist/ShareListView.kt`, **SLN** = `views/chatlist/ShareListNavLinkView.kt`, **FIV** = `views/chat/item/FramedItemView.kt`, **CTX** = `views/chat/ContextItemView.kt`. Harness: `H/` = `apps/multiplatform/common/src/uiTestShared/kotlin/chat/simplex/app/ui/harness/`.
+- Line numbers are from the worktree `~/wt-uitest` at HEAD `8927c1892`, where the tests will be written. The catalogue cites master `d72f68e6d`, so its numbers differ (corrections at the end).
+- UI strings are from `apps/multiplatform/common/src/commonMain/moko-resources/base/strings.xml` (the brief's `resources/MR/base` path doesn't exist). "…" is U+2026.
+- CLI lines were checked against `src/Simplex/Chat/View.hs` and `tests/ChatTests/Forward.hs`.
+
+## 1. Result
+
+There are 11 new tests (10 shared, 1 desktop-only). The 2 existing tests are kept as they are. The 25 catalogue rows (17 in §L, 8 in §S) map as follows: 22 are covered, 1 row is added (share-list search), 1 is deferred (REC) and 1 is dropped (`forward_groupToGroup`). `forward_notOffered_forDeletedOrLive` is split: the deleted-item half is covered and the live half is dropped.
+
+| # | Test (class) | Catalogue names covered | Needs | Peers |
+|---|---|---|---|---|
+| — | `forward_contactToContact_peerSeesForwarded` (ForwardTest, exists) | same | P ×2 | bob, cath |
+| — | `forward_toNotes_showsSavedFrom` (ForwardTest, exists) | same | P | bob |
+| T1 | `forward_acrossChatTypes_peersReceiveAndSourceOpens` (ForwardTest, **new name**) | `forward_contactToGroup`, `forward_groupToContact`, `forward_fromNotes_toContact`, `forwarded_goToSource_opensOriginalChat` | P ×2 | bob, cath |
+| T2 | `forward_withComment_sendsCommentQuoted` (ForwardTest) | + `forward_cancelContext`, + §S `draft_forwardIntoChatWithDraft_restoresDraftAfterSend` | P ×2 | bob, cath |
+| T3 | `forwarded_received_showsHeader` (ForwardTest) | same | P ×2 | bob, cath |
+| T4 | `forwardPlan_filesNotAccepted_alertOptions` (ForwardTest) | + `forward_itemsDeletedAfterSelection_alert` (overlaps K `selectForward_multiple_peerReceives`) | P ×2, XFTP | bob, cath |
+| T5 | `forwardPlan_downloadButton_receivesFiles` (ForwardTest) | + `forwardPlan_nothingToForward`, `forward_file_peerReceivesFile`, deleted half of `forward_notOffered_forDeletedOrLive` | P ×2, XFTP | bob, cath |
+| T6 | `forward_destinationProhibitsContent_alert` (ForwardTest) | same | P, XFTP | bob |
+| T7 | `forward_searchDestinations_filtersList` (ForwardTest, **new row**) | — | P | bob |
+| T8 | `draft_onlyLastChatKept` (DraftTest) | + `draft_text_restoredAfterChatSwitch`, + "draft cleared after send" (not in the catalogue yet) | P ×2 | bob, cath |
+| T9 | `draft_withQuote_restored` (DraftTest) | + `draft_editingState_restored` | P | bob |
+| T10 | `draft_clearedWhenSendDisabled` (DraftTest) | same, + switch-order regression | P ×2 | bob, cath |
+| T11 | `draft_withAttachment_restored` (desktop `DraftDesktopTest`) | same | P, XFTP | bob |
+
+Merging was the rule throughout (guide §5: each test costs a reset plus peer connections). Where a merge crosses classes (T2 takes a §S row) or needs a new name (T1), it is a decision for you, listed in §7.
+
+## 2. Row triage (every §L and §S row)
+
+| Row (catalogue line) | Code verified (worktree) | Decision | Reason |
+|---|---|---|---|
+| L164 `forward_contactToContact_peerSeesForwarded` | CV:640-643, SLN:31-44, CMP:729-757 | keep (exists) | Already passing. Note: it opens bob's chat right after bob sends, which is the §15.4.1b flake pattern |
+| L164 `forward_withComment_sendsCommentQuoted` | CMP:845-855 (the comment quotes the last forwarded item, `quoted = message.id` at :850) | keep → T2 | |
+| L164 `forward_cancelContext` | CMP:1268-1270, CTX:148-151 | merge → T2 | Same setup; T2's comment lines prove nothing was sent by the cancelled attempt |
+| L165 `forward_contactToGroup` | CMP:732-738 | merge → T1 | contact→contact can't catch a from/to type mix-up in CMP:732-738; a cross-type test can |
+| L165 `forward_groupToContact` | same | merge → T1 | |
+| L165 `forward_groupToGroup` | same | **drop** | The app path is identical to T1's legs (type and id are passed through); the only difference is in the core (`testForwardGroupToGroup`). It would cost a second group and a third peer |
+| L166 `forward_toNotes_showsSavedFrom` | FIV:319-351 | keep (exists) | |
+| L166 `forward_fromNotes_toContact` | CMP:736-738 with `ChatType.Local` | merge → T1 | bob is already connected there |
+| L167 `forwarded_goToSource_opensOriginalChat` | CIV:286-305 (arrow), ChatModel.kt:4220-4226 | merge → T1 | On its own it would be a superset of the existing contact→contact test (guide §5, no prefixes). Correction: the arrow is always composed when the item has a source; hovering (desktop) or tapping the bubble (Android, CIV:334-336) changes only how it looks |
+| L167 `forwarded_received_showsHeader` | FIV:348-350, ChatModel.kt:4231-4233 | keep → T3 | This is where "the original sender is not leaked" is checked on the GUI |
+| L168 `forward_file_peerReceivesFile` | CIV:474-482, ChatModel.kt:4643-4647; core `forwardContent` (`src/Simplex/Chat/Library/Commands.hs:1180-1200`) | merge → T5 | Downloading through the plan alert's "Download" button avoids becoming a prefix of `FilesTest.rcvFile_menuDownload_receives` |
+| L169 `forwardPlan_filesNotAccepted_alertOptions` | CV:363-386, 3698-3756 | keep → T4 | |
+| L169 `forwardPlan_nothingToForward` | CV:3737-3752 | merge → T5 | T5's first step |
+| L169 `forwardPlan_downloadButton_receivesFiles` | CV:3004-3032 | keep → T5 | |
+| L170 `forward_notOffered_forDeletedOrLive` | CIV:474-477 | split: deleted half → T5; **live half dropped** | Live messages are owned by §C (`LiveMessageTest`), and starting one has no key or helper. Suggest §C checks that the item menu has no "forward" during a live message |
+| L170 `forward_itemsDeletedAfterSelection_alert` | CMP:749-754; core `forwardMsgContent` skips deleted items (`Commands.hs:5124`) | merge → T4 | T4 already has a multi-item forward to cath |
+| L171 `forward_destinationProhibitsContent_alert` | SLV:29-58, SLN:46-63, 75-80 | keep → T6 | |
+| S237 `draft_text_restoredAfterChatSwitch` | CMP:1421-1433 | merge → T8 | Its steps are contained in T8 |
+| S237 `draft_withQuote_restored` | CMP:1427-1429 (the whole `ComposeState` is saved) | keep → T9 | |
+| S237 `draft_editingState_restored` | same | merge → T9 | One peer, same switch pattern |
+| S237 `draft_onlyLastChatKept` | CMP:1427-1435 (one slot, ChatModel.kt:255-257) | keep → T8 | |
+| S237 `draft_clearedWhenSendDisabled` | CMP:1443-1448, ChatModel.kt:1711, 1778 | keep → T10 | Adds the switch-order regression that the comment at CMP:1441-1442 guards against |
+| S237 `draft_forwardIntoChatWithDraft_restoresDraftAfterSend` | CV:150-160 (the draft is hidden while forwarding), CMP:997-999 | merge → T2 | Same peers and forward flow |
+| S238 `draft_withAttachment_restored` | CMP:1427-1429; `D/platform/PlatformTextField.desktop.kt:99-107` (a pasted path becomes an attachment) | keep → T11, desktop-only | Needs is **P, XFTP**, not CB: the path is entered as text, as in `FilesDesktopTest.paste_filePathText_attachesFile` |
+| S239 `draft_voiceRecording_finishedOnSwitch` | CMP:1422-1426 | **defer** | Needs the REC seam, which is not built (plan §0.5.11, 7.2/11.2). Keep the row |
+| (new) draft across restart | ChatModel.kt:255-257: `draft`/`draftChatId` are plain `mutableStateOf`; nothing writes them to prefs or the database | **no test, no row** | The app does not keep drafts across a restart. The harness `restart()` restarts only the core, so `ChatModel.draft` survives it (H/CommonReset.kt runs only at reset) and a "persists" test would pass falsely. Harness finding in §6 |
+
+## 3. App changes (keys only)
+
+Every key below is on an element a test clicks or types into.
+
+| Key | Ui.kt | Where (worktree) | Used by |
+|---|---|---|---|
+| `Ui.Chat.Item(id).part("goTo")` | none (uses `part`, like `.part("quote")`) | CIV:273-279, the `IconButton` in `GoToItemInnerButton`: add `.ui(Ui.Chat.Item(cItem.id).part("goTo"))` to the modifier chain at :275 | T1 clicks it. T3 checks it is absent, which is allowed because T1 acts on it |
+| `Ui.Chat.Selection.part("forward")` | none | SEL:115: `IconButton({ forwardItems() }, Modifier.ui(Ui.Chat.Selection.part("forward")), enabled = …)` | T4, T5 |
+| `Ui.Alert.Option(Ui.AlertSource.Shared, "forward")` | none | CV:3041-3048 `ForwardButton`: `modifier = modifier.ui(…)` | T4 |
+| `Ui.Alert.Option(Ui.AlertSource.Shared, "download")` | none | CV:3014-3016 `DownloadFilesButton`: `modifier = modifier.ui(…)` | T5 (click), T4 (presence) |
+| `Ui.Share.Bar` → `Ui.Share.Bar.part("search")` | add `val Bar = UiKey("share.bar")` to `object Share` (Ui.kt:165-167) | SLV:142 `DefaultAppBar(…, uiKey = Ui.Share.Bar)`. The search field then gets the key at `views/helpers/DefaultTopAppBar.kt:87` | T7 |
+
+No new key is needed for these: the forwarding/reply/edit bar's (x), `described("Cancel")` (CTX:148-151, content description `cancel_verb`); the share-list search button, `described("Search")` (SLV:167-169, only composed with 8 or more chats); OK in `showAlertMsg`, `Ui.Alert.Confirm(Shared)` (`views/helpers/AlertManager.kt:251`). The existing keys used are `Ui.Chat.ItemMenu(id, "forward"|"select"|"reply"|"edit"|"download")`, `Ui.Share.Row`, `Ui.Chat.Send`, `Ui.Chat.Message` and `Ui.Chat.Selection.part("title")` (SEL:48 → DefaultTopAppBar.kt:42).
+
+`described("Cancel")` risk: on desktop the chat list is visible next to the chat. No other clickable with the exact description "Cancel" was found in the chat view or the chat list. If one appears, add `Ui.Chat.Message.part("contextCancel")` at CTX:148.
+
+## 4. Harness additions (no refactor of existing helpers)
+
+H/Screens.kt, `ChatScreen` (stateless, :207, so one instance serves whichever chat is open):
+```kotlin
+fun itemId(what: String, match: (ChatItem) -> Boolean): Long {          // same body as FilesTest.kt:99-107
+  var id: Long? = null
+  s.poll(timeoutMs = CONNECT_TIMEOUT_MS, what = what) {
+    id = chatModel.chatsContext.chatItems.value.lastOrNull(match)?.id; id != null && s.exists(Ui.Chat.Item(id!!))
+  }
+  return id!!
+}
+fun forwardItemTo(id: Long, chatName: String) {
+  s.rightClick(Ui.Chat.Item(id)); s.click(Ui.Chat.ItemMenu(id, "forward"))
+  ChatListScreen(s).shareTo(chatName)
+  s.poll(what = "the send button to be enabled for forwarding") { s.isEnabled(Ui.Chat.Send) }
+  s.click(Ui.Chat.Send)
+}
+fun select(vararg ids: Long) {
+  s.rightClick(Ui.Chat.Item(ids[0])); s.click(Ui.Chat.ItemMenu(ids[0], "select"))
+  ids.drop(1).forEach { s.click(Ui.Chat.Item(it)) }                    // the selection overlay, CV:2238-2242
+  s.poll(what = "`Selected ${ids.size}`") { "Selected ${ids.size}" in s.textsOf(Ui.Chat.Selection.part("title")) }
+}
+fun forwardSelected() = s.click(Ui.Chat.Selection.part("forward"))
+fun sendComposed() = enterWhenSendable()                               // the existing private fun, made reachable
+```
+`ChatListScreen` (H/Screens.kt):
+```kotlin
+fun shareSearch(text: String) { s.click(described("Search")); s.typeInto(Ui.Share.Bar.part("search"), text) }
+fun shareShown(name: String): Boolean = s.exists(Ui.Share.Row(chatId(name)))
+```
+H/Helpers.kt:
+```kotlin
+fun CliPeer.sendsFileTo(contact: String, path: String, fileId: Int, name: String) {   // FilesTest.kt:93-97 with the contact as a parameter
+  this sends "/f @$contact $path"; this expects "use /fc $fileId to cancel sending"
+  eventually("completed uploading file $fileId ($name) for $contact", CONNECT_TIMEOUT_MS)
+}
+fun CliPeer.receivesFile(fileId: Int, name: String, from: String) {
+  val dir = java.io.File(createFile(".fr-probe", "")).parent          // a host-side path on both platforms (Android: bridge `file`)
+  this sends "/fr $fileId $dir/"
+  eventually("completed receiving file $fileId ($name) from $from", CONNECT_TIMEOUT_MS)
+}
+fun newGroupsViaApi(vararg names: String) = names.forEach {           // precondition only, as at ChatListToolbarSearchTest.kt:42-45
+  runBlocking { chatController.apiNewGroup(null, incognito = false, GroupProfile(it, "", null)) } ?: error("apiNewGroup($it) failed")
+}
+```
+H/ChatListRowsScreens.kt (next to `switchAwayFromChat`, :7):
+```kotlin
+fun UiScope.visitNotesAndBack(app: App, name: String): ChatScreen {
+  backToChatList(); app.chatList.open("Private notes")
+  poll(what = "the notes folder with an empty field and no context bar") {
+    chatModel.chatId.value == app.chatList.chatId("Private notes") && editableText(Ui.Chat.Message).isNullOrEmpty() && !seesDescription("Context icon")
+  }
+  backToChatList(); return app.chatList.open(name)
+}
+```
+
+## 5. Tests
+
+Shared conventions:
+- "row ready" = `poll(what = "<text> on <name>'s row") { "<text>" in alice.chatList.rowTexts("<name>") }` before opening a chat a peer just wrote to. This avoids the §15.4.1b flake.
+- "bar" = the compose context bar, detected with `seesDescription("Context icon")` (CTX:122, `icon_descr_context`). It is absent when there is no context item.
+
+### T1 `forward_acrossChatTypes_peersReceiveAndSourceOpens` (ForwardTest)
+- **Scenario.** alice forwards bob's message into her group, forwards a group message to bob and follows its arrow back to the group, then forwards a note to bob.
+- **Fails if** forwarding between different chat types breaks, or the source arrow opens the wrong chat. Mutations:
+  - CMP:736 `fromChatType = fromChatInfo.chatType` → `chat.chatInfo.chatType`. The contact→group leg fails, while the existing contact→contact test stays green.
+  - CIV:300 `openChat(…, chatType, apiId, msgId)` → `openChat(…, cInfo.chatType, cInfo.apiId, cItem.id)`. alice stays in bob's chat.
+  - ChatModel.kt:4224 `ChatType.Group` → `ChatType.Direct`.
+  - FIV:325 `forwarded.groupType != null` → `true` (a two-row "forwarded from" header for an ordinary group).
+- **Setup:** `connect(bob)`, `connect(cath)`, `ownGroup(alice, "team", cath)` (H/Screens.kt:377), `backToChatList()`.
+- **Steps and assertions:**
+```kotlin
+bob sends "@alice hey"; row ready("bob", "hey")
+val chat = alice.chatList.open("bob"); chat.forwardTo("hey", "team")                     // Screens.kt:257
+cath.eventuallyMessage("#team alice> -> forwarded", CONNECT_TIMEOUT_MS); cath expects "      hey"
+cath sends "#team hello"
+val teamId = alice.chatList.chatId("team"); val bobId = alice.chatList.chatId("bob")
+poll(what = "team open after the forward") { chatModel.chatId.value == teamId }
+val original = chat.itemId("hello")
+chat.forwardTo("hello", "bob")
+bob.eventuallyMessage("alice> -> forwarded", CONNECT_TIMEOUT_MS); bob expects "      hello"
+val fwd = chat.itemId("hello")                                                            // now the item in bob's chat
+poll(what = "`forwarded` header without a source name") {
+  chatModel.chatId.value == bobId && textsOf(Ui.Chat.Item(fwd)).let { t -> "forwarded" in t && t.none { "forwarded from" in it || it == "team" } }
+}
+click(Ui.Chat.Item(fwd).part("goTo"))
+poll(what = "team's chat opened at cath's `hello`") { chatModel.chatId.value == teamId && exists(Ui.Chat.Item(original)) }
+backToChatList()
+val notes = alice.chatList.open("Private notes"); notes.send("memo"); notes.forwardTo("memo", "bob")
+bob.expectsMessage("alice> memo", CONNECT_TIMEOUT_MS)                                       // the next line, so no "-> forwarded" before it
+```
+- **CLI:** `CIFFUnknown -> "-> forwarded"` (View.hs:1026). The group form is from `testForwardContactToGroup` (Forward.hs:205-227). A forward from notes prints a plain item (`testForwardNotesToContact`, Forward.hs:334-345, `alice <# "@cath hi"`, `cath <# "alice> hi"`).
+- **Platform:**
+  - Android: `forwardTo` closes the chat, since `forwardItem` sets `chatId = null` (CV:641), and the share list replaces the chat list (`App.kt:376-384`). After the send, alice is in the destination chat, so the test doesn't call `backToChatList()` between legs except before opening notes.
+  - The arrow is composed on both platforms, so it is tapped directly.
+- **Flake risks:**
+  - cath's `#team hello` must be in alice's open team chat. `itemId` polls the model and the node.
+  - The click on the arrow happens while bob's chat may still be loading. `click` waits for the node.
+
+### T2 `forward_withComment_sendsCommentQuoted` (ForwardTest)
+- **Scenario.** alice starts forwarding bob's "hey" to cath and cancels it. She writes a draft in cath's chat and leaves. Then she forwards "hey" again with a comment. cath gets the forward and the comment quoting it, and alice's draft comes back in cath's compose field.
+- **Fails if:**
+  - cancel no longer removes the bar: CMP:1268-1270 lambda → `{}`;
+  - the comment is not sent or not quoted: CMP:845-855 removed, or `quoted = message.id` → `null` at :850;
+  - the draft is lost after the forward: CMP:998-999 removed;
+  - the draft is merged into the forward: CV:154, drop `(sharedContent !is SharedContent.Forward || …)`. The field then holds "unsent" next to the bar.
+- **Steps:**
+```kotlin
+connect(bob); connect(cath); bob sends "@alice hey"; row ready("bob", "hey")
+val chat = alice.chatList.open("bob"); val cathId = alice.chatList.chatId("cath")
+chat.menu("hey", "forward"); alice.chatList.shareTo("cath")
+poll(what = "cath's chat with the forwarding bar") { chatModel.chatId.value == cathId && seesDescription("Context icon") && isEnabled(Ui.Chat.Send) }
+click(described("Cancel"))
+poll(what = "the bar gone, nothing forwarded") { exists(Ui.Chat.Message) && !seesDescription("Context icon") && chatModel.chatsContext.chatItems.value.none { it.content.text == "hey" } }
+typeInto(Ui.Chat.Message, "unsent")
+backToChatList(); alice.chatList.open("bob")
+poll(what = "cath's row showing the draft") { alice.chatList.rowTexts("cath").any { it.endsWith(" unsent") } }
+chat.menu("hey", "forward"); alice.chatList.shareTo("cath")
+poll(what = "the bar with an empty field, the draft hidden") { chatModel.chatId.value == cathId && seesDescription("Context icon") && editableText(Ui.Chat.Message).isNullOrEmpty() }
+typeInto(Ui.Chat.Message, "see this"); poll(what = "send enabled") { isEnabled(Ui.Chat.Send) }; pressEnter(Ui.Chat.Message)
+cath.expectsMessage("alice> -> forwarded", CONNECT_TIMEOUT_MS); cath expects "      hey"
+cath expectsMessage "alice> >> hey"; cath expects "      see this"
+poll(what = "the draft back after the forward") { editableText(Ui.Chat.Message) == "unsent" && !seesDescription("Context icon") }
+```
+- `chat.send()` can't be used for the comment. Its poll for an empty field (Screens.kt:287) can miss the moment between clearing and the draft restore.
+- `>>`: `directQuote` prints `>>` when the item and the quote have the same direction (View.hs:1017-1019). On cath's side both are received from alice. The catalogue line agrees.
+- **Negative control:** cath's first line read is the second forward, and its comment follows. If the cancelled attempt had sent anything, a second `-> forwarded` would come where `>> hey` is expected.
+- **Platform:**
+  - After entering cath's chat through the share list, ComposeView is newly composed with an empty state (CV:150-160); `KeyChangeEffect` doesn't run on first composition. Verify on the first desktop run that the field really is empty.
+  - Android: no `hideKeyboard()` is needed before `pressEnter`.
+
+### T3 `forwarded_received_showsHeader` (ForwardTest)
+- **Scenario.** bob forwards to alice a message he received from cath. alice sees a "forwarded" header and nothing that names cath. bob's ordinary message has no header.
+- **Fails if:**
+  - the header is removed or renamed: FIV:348-350 deleted, or ChatModel.kt:4233 → `saved_description`;
+  - a received forward shows a two-row "forwarded from" header: FIV:327 `else -> false` → `true`;
+  - a received forward gets a source arrow: ChatModel.kt:4223 changed to give `Unknown` a target.
+- **Steps:**
+```kotlin
+connect(bob); connectPeers(bob, cath)                                    // Helpers.kt:34
+bob sends "@alice plain"
+cath sends "@bob secret"; bob.eventuallyMessage("cath> secret", CONNECT_TIMEOUT_MS)
+bob types "@alice <- @cath secret"                                       // not `sends`: the echo differs (plan 0.5 line 835)
+bob expectsMessage "@alice <- @cath"; bob expects "      secret"           // View.hs:1028, Forward.hs:414-417
+row ready("bob", "secret")
+val chat = alice.chatList.open("bob"); val plain = chat.itemId("plain"); val fwd = chat.itemId("secret")
+check("forwarded" !in textsOf(Ui.Chat.Item(plain))) { "an ordinary message shows a forwarded header" }
+poll(what = "the `forwarded` header with no source name") { textsOf(Ui.Chat.Item(fwd)).let { t -> "forwarded" in t && t.none { "forwarded from" in it || "cath" in it } } }
+assertFalse("a received forward offers a go-to-source arrow", exists(Ui.Chat.Item(fwd).part("goTo")))
+```
+- The recipient's item has `CIFFUnknown` (`forwardCIFF`, Commands.hs:1174-1178), so its `chatName` is "" and no arrow is composed.
+- **Platform:** none.
+
+### T4 `forwardPlan_filesNotAccepted_alertOptions` (ForwardTest)
+- **Scenario.** alice selects four of bob's messages, one of them a file she hasn't downloaded. The plan alert offers Forward, Download and Cancel, and she chooses Forward. She picks cath. bob deletes one of the messages before she sends. cath gets the other two in order, and alice sees "1 messages not forwarded".
+- **Fails if:**
+  - the plan check is skipped: CV:378 condition → `false`, so no alert;
+  - the forward is built from the wrong ids: CV:381/3043 pass `chatItemIds` instead of `forwardPlan.chatItemIds`, or CV:3684 drops the filter;
+  - the deleted-after-selection alert is gone: CMP:749-754 removed;
+  - the order changes: CV:3684 `.reversed()`.
+- **Steps:**
+```kotlin
+connect(bob); connect(cath)
+bob sends "@alice one"; bob.sendsFileTo("alice", bob.createFile("notes.md", NOTES), 1, "notes.md")
+bob sends "@alice two"; bob sends "@alice three"; row ready("bob", "three")
+val chat = alice.chatList.open("bob")
+val file = chat.itemId("the item of notes.md") { it.file?.fileName == "notes.md" }
+chat.select(chat.itemId("one"), file, chat.itemId("two"), chat.itemId("three"))
+chat.forwardSelected()
+poll(what = "the plan alert for 3 messages and 1 file") {
+  seesText("Forward 3 message(s)?") && seesText("1 file(s) were not downloaded.", substring = true) &&
+    seesText("Forward messages without files?", substring = true) && exists(Ui.Alert.Option(Ui.AlertSource.Shared, "forward")) &&
+    exists(Ui.Alert.Option(Ui.AlertSource.Shared, "download")) && seesText("Cancel")
+}
+click(Ui.Alert.Option(Ui.AlertSource.Shared, "forward"))
+poll(what = "the share list for several messages") { seesText("Forward messages…") }
+alice.chatList.shareTo("cath")
+poll(what = "cath's chat with `Forwarding 3 messages`") { chatModel.chatId.value == alice.chatList.chatId("cath") && seesText("Forwarding 3 messages") && isEnabled(Ui.Chat.Send) }
+bob sends "\\@alice three"; bob.eventually("message marked deleted")      // as ChatListRowsTest.previewDeletedMessage
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "bob's deletion processed by alice") { "marked deleted" in alice.chatList.rowTexts("bob") }
+click(Ui.Chat.Send)
+cath.expectsMessage("alice> -> forwarded", CONNECT_TIMEOUT_MS); cath expects "      one"
+cath expectsMessage "alice> -> forwarded"; cath expects "      two"
+poll(what = "the deleted-after-selection alert") { seesText("1 messages not forwarded") && seesText("Messages were deleted after you selected them.") }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+chat.send("end"); cath expectsMessage "alice> end"                          // sentinel: no file, no `three`
+```
+- Strings are from strings.xml:521, 522, 524, 526, 530, 531, 525, 571, 615 and 801.
+- The file without text is left out of the plan (`hasContent`, `MCFile t -> t /= ""`, Commands.hs:1085-1094), so the count is 3, not 4. `three` is dropped at send time because it is deleted (`forwardMsgContent`, Commands.hs:5124).
+- **Overlap:** this is a superset of K `selectForward_multiple_peerReceives` (`testForwardContactToContactMulti`). Suggest the K design keeps only the parts T4 doesn't cover, or drops it.
+- **Platform:**
+  - Selecting more items taps the overlay at CV:2238-2242, which lies above the item node. If `tapPointInNode` lands on the file item's own download button (`Ui.Chat.ItemFile`), the overlay still receives the tap because it is drawn on top. Verify on Android.
+  - The rows of the chat list behind the chat are composed on Android (BackKeyTest `back_chatToChatList` relies on this), so `rowTexts` works while cath's chat is open.
+- **Flake risk:** the deletion must reach alice before Send. The row poll handles this.
+
+### T5 `forwardPlan_downloadButton_receivesFiles` (ForwardTest)
+- **Scenario.**
+  - Forward is offered for a live text message but not for a message bob deleted, nor for a file alice hasn't downloaded.
+  - Forwarding the file alone says "Nothing to forward!" and offers Download.
+  - Download receives the file without opening the share list. The file's menu now offers Forward, and cath receives the forwarded file through XFTP.
+- **Fails if:**
+  - Forward is offered for deleted items: CIV:474 `cItem.meta.itemDeleted == null` removed;
+  - Forward is offered for files that aren't loaded: CIV:475 removed;
+  - Download doesn't call `receiveFiles`: CV:3020-3026 removed;
+  - Download also opens the share list: `forwardContent` added to the Download button;
+  - the file isn't copied into the forward: core regression, caught by cath's lines.
+- **Steps:**
+```kotlin
+connect(bob); connect(cath)
+bob sends "@alice kept"; bob sends "@alice gone"; bob sends "\\@alice gone"; bob.eventually("message marked deleted")
+bob.sendsFileTo("alice", bob.createFile("notes.md", NOTES), 1, "notes.md"); row ready("bob", "notes.md")
+val chat = alice.chatList.open("bob"); val bobId = alice.chatList.chatId("bob")
+val kept = chat.itemId("kept"); val gone = chat.itemId("gone")
+val file = chat.itemId("the item of notes.md") { it.file?.fileName == "notes.md" }
+menuCheck(kept) { exists(Ui.Chat.ItemMenu(kept, "forward")) }
+menuCheck(gone) { !exists(Ui.Chat.ItemMenu(gone, "forward")) }
+rightClick(Ui.Chat.Item(file)); waitFor(Ui.Chat.ItemMenu(file, "select"))
+check(exists(Ui.Chat.ItemMenu(file, "download")) && !exists(Ui.Chat.ItemMenu(file, "forward"))) { "menu of the offered file" }
+click(Ui.Chat.ItemMenu(file, "select")); chat.forwardSelected()
+poll(what = "`Nothing to forward!` with Download and no Forward") {
+  seesText("Nothing to forward!") && seesText("1 file(s) were not downloaded.") && !seesText("Forward messages without files?", substring = true) &&
+    exists(Ui.Alert.Option(Ui.AlertSource.Shared, "download")) && !exists(Ui.Alert.Option(Ui.AlertSource.Shared, "forward"))
+}
+click(Ui.Alert.Option(Ui.AlertSource.Shared, "download"))
+poll(what = "the alert closed, no share list") { !seesText("Nothing to forward!") && !seesText("Forward message…") && chatModel.chatId.value == bobId }
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "notes.md received") { chat.item(file)?.file?.fileStatus is CIFileStatus.RcvComplete }
+escape(); poll(what = "selection mode to end") { !exists(Ui.Chat.Selection.part("title")) }
+chat.forwardItemTo(file, "cath")                                          // the menu now has "forward": the opposite branch of CIV:475
+cath.expectsMessage("alice> -> forwarded", CONNECT_TIMEOUT_MS); cath expects "      notes_1.md"
+cath expectsMessage "alice> sends file notes_1.md (${NOTES.length} bytes / ${NOTES.length} bytes)"
+cath expects "use /fr 1 [<dir>/ | <path>] to receive it"
+cath.receivesFile(1, "notes_1.md", "alice")
+```
+- `menuCheck(id, cond)` is a private test helper: `rightClick`, `waitFor(ItemMenu(id, "select"))`, `check(cond)`, click "select", `escape()`, then poll until selection mode ends (the pattern of FilesTest.kt:78-84).
+- **Forwarded file name.** The core copies the file into alice's files folder under a unique name (`uniqueCombine`, Commands.hs:1189). `mediaFilePrefix` is `Nothing` for `MCFile`, so the name is `notes_1.md`. For a forward of a file with no text, the message line shows the item's file name (View.hs:795), as in `testForwardFileContactToContact` (Forward.hs:599-604).
+- **Size.** The size is the content size (`getFileContentsSize`, Commands.hs:5147), not the encrypted size.
+- **Platform:**
+  - `escape()` ends selection mode on both platforms (FilesTest, BackKeyTest `back_exitsSelectionMode`).
+  - `receivesFile` saves into the peer's host directory. On Android this goes through the bridge `file` command, so no bytes are compared on the device. alice's received bytes are already compared by FilesTest.
+- **Flake risk:** XFTP upload and download time. All file waits use `CONNECT_TIMEOUT_MS`.
+
+### T6 `forward_destinationProhibitsContent_alert` (ForwardTest)
+- **Scenario.**
+  - With files on in bob's group "team", alice can forward bob's image there; she cancels.
+  - After bob turns files off, picking "team" shows "Cannot send message", and the group chat doesn't open.
+  - The same image can still go to Private notes, and nothing ever reached the group.
+- **Fails if:**
+  - the check ignores the group setting: SLN:48 → `isMediaOrFileAttachment`, so step A shows the alert;
+  - the check is lost: SLN:48 → `false`, or SLN:54-58 always opens the chat;
+  - the alert opens the chat anyway: SLN:55 followed by `groupChatAction`.
+- **Steps:**
+```kotlin
+connect(bob); hostGroup(bob, "team", "alice"); joinGroupFromList(alice, bob, "team")        // Helpers.kt:42, 69
+bob sends "/img @alice $FIXTURE_JPG"; bob expectsMessage "/f @alice $FIXTURE_JPG"
+bob expects "use /fc 1 to cancel sending"; bob.eventually("completed uploading file 1 (test.jpg) for alice", CONNECT_TIMEOUT_MS)   // FilesTest.kt:55-58 (there file 2)
+backToChatList(); val chat = alice.chatList.open("bob"); val teamId = alice.chatList.chatId("team")
+val img = chat.itemId("bob's image") { it.content.msgContent is MsgContent.MCImage }
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the image received (Forward needs a loaded file)") { chat.item(img)?.file?.fileStatus is CIFileStatus.RcvComplete }
+rightClick(Ui.Chat.Item(img)); click(Ui.Chat.ItemMenu(img, "forward")); alice.chatList.shareTo("team")
+poll(what = "team open with the bar while files are on") { chatModel.chatId.value == teamId && seesDescription("Context icon") && isEnabled(Ui.Chat.Send) }
+click(described("Cancel")); poll(what = "the bar gone") { exists(Ui.Chat.Message) && !seesDescription("Context icon") }
+bob sends "/set files #team off"; bob expects "updated group preferences:"; bob expects "Files and media: off"      // Files.hs:1248-1251 (there alice is the owner)
+chat.itemId("`Files and media: off` in team") { it.content.text.startsWith("Files and media: off") }             // ChatModel.kt:4311, 4361-4368
+backToChatList(); alice.chatList.open("bob")
+rightClick(Ui.Chat.Item(img)); click(Ui.Chat.ItemMenu(img, "forward")); alice.chatList.shareTo("team")
+poll(what = "`Cannot send message`") { seesText("Cannot send message") && seesText("Selected chat preferences prohibit this message.") && chatModel.chatId.value == null }
+click(Ui.Alert.Confirm(Ui.AlertSource.Shared))
+poll(what = "still in the share list") { !seesText("Cannot send message") && seesText("Forward message…") && chatModel.chatId.value == null }
+alice.chatList.shareTo("Private notes")
+poll(what = "notes with the bar") { chatModel.chatId.value == alice.chatList.chatId("Private notes") && seesDescription("Context icon") }
+click(Ui.Chat.Send)
+val saved = chat.itemId("the image saved in notes") { it.content.msgContent is MsgContent.MCImage }
+poll(what = "`saved from` / `bob` on the saved image") { textsOf(Ui.Chat.Item(saved)).let { t -> t.any { "saved from" in it } && "bob" in t } }
+backToChatList(); alice.chatList.open("team").send("after")
+bob expectsMessage "#team alice> after"                                   // the next line: nothing reached #team before it
+```
+- Strings: strings.xml:574-575 and 570.
+- The alert is `showForwardProhibitedByPrefAlert` (SLN:75-80), and its OK carries `Ui.Alert.Confirm(Shared)`.
+- **Platform:** `joinGroupFromList` leaves alice in team's chat, so the test calls `backToChatList()` before opening bob's chat.
+- **Flake risk:** "Forward" is offered only once the image is loaded (CIV:475). The test polls for that first.
+
+### T7 `forward_searchDestinations_filtersList` (ForwardTest, new catalogue row)
+- **Scenario.** With eight chats, alice opens the forward list, taps Search and types "bob". Only bob and the group "bobcats" remain. The group "jobs" (which contains "ob"), the group "team" and Private notes disappear. Picking "bobcats" opens it with the forwarding bar.
+- **Fails if:**
+  - the search text is ignored: SLV:201 passes `""`;
+  - the button disappears: the SLV:166 threshold is raised (the test has exactly 8 chats);
+  - groups or contacts are excluded from matching: `filteredChats` (`views/chatlist/ChatListView.kt:1600-1608`).
+- **Steps:**
+```kotlin
+app("alice"); newGroupsViaApi("bobcats", "jobs", "team", "club", "news", "work")
+val alice = restart()                                                       // loads the groups into the model
+val bob = cli("bob"); connect(bob)
+bob sends "@alice hey"; row ready("bob", "hey")
+check(chatModel.chats.value.size == 8) { "precondition: 8 chats for the search button (SLV:166)" }
+alice.chatList.open("bob").menu("hey", "forward")
+poll(what = "the share list") { seesText("Forward message…") }
+for (n in listOf("bob", "bobcats", "jobs", "team", "Private notes")) scrollTo(Ui.Share.Row(alice.chatList.chatId(n)))   // all listed first
+alice.chatList.shareSearch("bob")
+poll(what = "only bob and bobcats listed for `bob`") {
+  alice.chatList.shareShown("bob") && alice.chatList.shareShown("bobcats") &&
+    !alice.chatList.shareShown("jobs") && !alice.chatList.shareShown("team") && !alice.chatList.shareShown("Private notes")
+}
+alice.chatList.shareTo("bobcats")
+poll(what = "bobcats opened with the bar") { chatModel.chatId.value == alice.chatList.chatId("bobcats") && seesDescription("Context icon") }
+```
+- The open-chat exemption in `filteredChats` (:1600) doesn't apply, because `chatId` is null while sharing.
+- The empty groups are listed because the creator's membership is active (ChatModel.kt:2530) and sending is allowed.
+- **Catalogue row to add (§L):** `| Destinations | Search the destination list (shown with 8 or more chats) | "Forward" → Search icon → type | SLV:166-170, 198-202; ChatListView.kt:1584-1612 | forward_searchDestinations_filtersList | … as above … | P | groups created via the API + restart, as ChatListToolbarSearchTest |`.
+- **Platform:** on Android the share list fills the screen and on desktop it replaces the chat list (`App.kt:376-384`). Either way there is one "Search" button.
+
+### T8 `draft_onlyLastChatKept` (DraftTest)
+- **Scenario.**
+  - alice types in bob's chat, then in cath's chat, then opens notes. Only cath's row shows a draft.
+  - bob's chat opens with an empty field, and cath's draft comes back.
+  - Sending it delivers it, and cath's row then shows the sent message, not the draft.
+- **Fails if:**
+  - the draft isn't saved on switch: CMP:1427-1430 removed;
+  - it isn't restored: CMP:1432-1433 removed;
+  - one chat's draft shows in another chat: CMP:1432 condition reduced to `chatModel.draft.value != null`;
+  - a sent draft stays in the model and on the row: CMP:836-838 removed. Visible because the row reads the draft whenever `draftChatId == chat.id` (ChatPreviewView.kt:231), even while the chat is open.
+- **Steps:**
+```kotlin
+connect(bob); connect(cath); val bobId = alice.chatList.chatId("bob"); val cathId = alice.chatList.chatId("cath")
+alice.chatList.open("bob"); typeInto(Ui.Chat.Message, "for bob")
+backToChatList(); alice.chatList.open("cath")
+poll(what = "cath's field empty: bob's draft not carried over") { chatModel.chatId.value == cathId && editableText(Ui.Chat.Message).isNullOrEmpty() }
+typeInto(Ui.Chat.Message, "for cath")
+switchAwayFromChat(alice)                                                  // ChatListRowsScreens.kt:7
+poll(what = "a draft on cath's row only") {
+  alice.chatList.rowTexts("cath").any { it.endsWith(" for cath") } && alice.chatList.rowTexts("bob").none { it.endsWith(" for bob") }
+}
+alice.chatList.open("bob")
+poll(what = "bob's field empty: only the last draft is kept") { chatModel.chatId.value == bobId && editableText(Ui.Chat.Message).isNullOrEmpty() }
+backToChatList(); val chat = alice.chatList.open("cath")
+poll(what = "cath's draft restored") { editableText(Ui.Chat.Message) == "for cath" }
+chat.sendComposed()
+cath.eventuallyMessage("alice> for cath", CONNECT_TIMEOUT_MS)
+poll(what = "cath's row with the sent text, no draft") { alice.chatList.rowTexts("cath").let { "for cath" in it && it.none { t -> t != "for cath" && t.endsWith(" for cath") } } }
+```
+- The draft row form (an icon placeholder, then " text") is the one `previewShowsDraft` uses (ChatListRowsTest.kt:50-53). That test (catalogue 01) checks only the positive row; T8 adds the negative control and the restore.
+- **Platform:** on Android every switch goes through the list (`backToChatList`). The final row check reads composed but covered rows while cath's chat is open; no Back is pressed, so `KeyChangeEffect` cannot hide the CMP:837 mutation.
+
+### T9 `draft_withQuote_restored` (DraftTest)
+- **Scenario.** A reply in progress and an edit in progress each survive a visit to another chat, and each is sent as a reply or an edit.
+- **Fails if** the saved draft drops its context item, e.g. CMP:1428 → `composeState.value.copy(contextItem = ComposeContextItem.NoContextItem)`. bob would then get plain `alice> answer` and a new `alice> hello world` instead of a quote and `[edited]`.
+- **Steps:**
+```kotlin
+connect(bob); bob sends "@alice question"; row ready("bob", "question")
+val chat = alice.chatList.open("bob"); chat.send("hello"); bob expectsMessage "alice> hello"
+check(!seesDescription("Context icon")) { "a context bar before Reply" }
+chat.menu("question", "reply"); typeInto(Ui.Chat.Message, "answer")
+visitNotesAndBack(alice, "bob")
+poll(what = "the reply draft restored") { editableText(Ui.Chat.Message) == "answer" && seesDescription("Context icon") }
+chat.sendComposed()
+bob expectsMessage "alice> > question"; bob expects "      answer"         // as MessagingTest.reply_menu_sendQuoted_peerSeesQuote
+chat.menu("hello", "edit"); poll(what = "the edit text") { editableText(Ui.Chat.Message) == "hello" }
+replaceText(Ui.Chat.Message, "hello world")
+visitNotesAndBack(alice, "bob")
+poll(what = "the edit draft restored") { editableText(Ui.Chat.Message) == "hello world" && seesDescription("Context icon") }
+chat.sendComposed()
+bob expectsMessage "alice> [edited] hello world"
+```
+- The quote direction is `>`, because bob's received item quotes his own sent message (View.hs:1019).
+- `visitNotesAndBack` also checks that notes shows neither the field text nor a bar (no leak).
+- **Platform:** none beyond `backToChatList`.
+
+### T10 `draft_clearedWhenSendDisabled` (DraftTest)
+- **Scenario.**
+  - bob deletes alice while she is typing in his chat. Her text is cleared and isn't kept as a draft.
+  - A draft in cath's chat survives a visit to bob's chat, where sending is impossible.
+- **Fails if:**
+  - the compose isn't cleared: CMP:1446 removed;
+  - the draft isn't dropped: CMP:1445 removed. Leaving bob's chat then saves "for bob" to his row;
+  - the effect at CMP:1443-1448 is moved above the `KeyChangeEffect` at CMP:1395. `clearState()` then empties the compose before it is saved, and CMP:1435 drops cath's draft. This is the regression the comment at CMP:1441-1442 describes; it is caught on desktop only (see Platform).
+- **Steps:**
+```kotlin
+connect(bob); connect(cath); val bobId = alice.chatList.chatId("bob"); val cathId = alice.chatList.chatId("cath")
+alice.chatList.open("bob"); typeInto(Ui.Chat.Message, "for bob")
+check(editableText(Ui.Chat.Message) == "for bob")
+bob sends "/d alice"; bob expects "alice: contact is deleted"              // View.hs:235, Direct.hs:585-586
+poll(timeoutMs = CONNECT_TIMEOUT_MS, what = "the field cleared once sending is impossible") {
+  !alice.chatList.chat("bob").chatInfo.sendMsgEnabled && exists(Ui.Chat.Message) && editableText(Ui.Chat.Message).isNullOrEmpty()
+}
+backToChatList(); alice.chatList.open("cath")
+poll(what = "no draft on bob's row") { chatModel.chatId.value == cathId && alice.chatList.rowTexts("bob").none { it.endsWith(" for bob") } }
+typeInto(Ui.Chat.Message, "for cath")
+backToChatList(); alice.chatList.open("bob"); poll(what = "bob's chat open") { chatModel.chatId.value == bobId }
+backToChatList(); alice.chatList.open("cath")
+poll(what = "cath's draft survives the visit to bob's chat") { editableText(Ui.Chat.Message) == "for cath" }
+```
+- **Overlap:** catalogue 01 `contactDeletedByPeerShowsDeleted` (not done) runs the same `/d alice` and checks the "contact deleted" field. That test should not also check the draft.
+- **Platform:** desktop reuses one ComposeView across chat switches (comment at CMP:1458), so the effect order matters there. On Android each chat composes a fresh ComposeView, the order mutation doesn't apply, and the test still passes. Name the platform in the PR.
+
+### T11 `draft_withAttachment_restored` (desktop `chat.simplex.app.ui.desktop.DraftDesktopTest`)
+- **Scenario.** alice attaches a file by pasting its path in bob's chat, switches to notes and back. The file preview is restored, and sending it delivers the file.
+- **Fails if** the saved draft loses its preview, e.g. CMP:1428 → `composeState.value.copy(preview = ComposePreview.NoPreview)`, or the attached file is deleted on switch (a `deleteUnusedFiles()` added to CMP:1421-1431).
+- **Steps** (pattern of `FilesDesktopTest`):
+```kotlin
+connect(bob); val source = File(createTempDirectory("uitest-draft").toFile(), "report.txt").apply { writeText(REPORT) }
+alice.chatList.open("bob"); waitFor(Ui.Chat.Message); check(!seesDescription("Cancel file preview"))
+enterText(Ui.Chat.Message, source.absolutePath)
+poll(what = "the preview of report.txt") { seesDescription("Cancel file preview") && seesText("report.txt") }
+alice.chatList.open("Private notes")
+poll(what = "notes without the preview") { chatModel.chatId.value == alice.chatList.chatId("Private notes") && !seesDescription("Cancel file preview") }
+alice.chatList.open("bob")
+poll(what = "the preview restored") { seesDescription("Cancel file preview") && seesText("report.txt") }
+click(Ui.Chat.Send)
+bob.eventuallyMessage("alice> sends file report.txt (${REPORT.length} bytes / ${REPORT.length} bytes)", CONNECT_TIMEOUT_MS)
+bob expects "use /fr 1 [<dir>/ | <path>] to receive it"
+```
+- Strings: "Cancel file preview" (strings.xml:604).
+- Do not use `!seesText("report.txt")` in notes. bob's row shows the file draft as `report.txt` (ChatPreviewView.kt:105-106), so only the content description is specific to the compose area.
+- **Why desktop-only:** pasting a path into the field is desktop code (`D/platform/PlatformTextField.desktop.kt:99-107`). Android has no equivalent without the file picker (FD).
+
+## 6. Findings
+
+Suspected app bugs. They are reported only, never fixed in a test PR. Each needs a confirming run before it goes into §15.5.
+1. **A draft is lost when forwarding into its chat and then leaving without sending.**
+   - CV:154 hides the draft while forwarding.
+   - If alice cancels the bar (CMP:1268-1270 clears only the context item) and leaves, the empty compose takes the `else` branch: `clearPrevDraft(prevChatId)` at CMP:1434-1436 deletes the draft.
+   - If she leaves with the bar still open, CMP:1421-1431 saves the forwarding state over her typed draft.
+   - Expected: the draft returns, as it does after a successful forward (CMP:997-999).
+   - Once confirmed, keep a test that exposes it: `draft_cancelForwardIntoChatWithDraft_keepsDraft` with `@KnownAppIssue`. T2 avoids the path by cancelling before the draft exists.
+2. **The forward list checks only voice for direct contacts** (SLN:31-44), but files and SimpleX links for groups (SLN:47-50). A contact whose Files preference is off (bots: CMP:1355 hides attach then) is not marked or blocked, so the user gets whatever the core returns instead of "Cannot send message". Not verified against the core.
+3. **Cosmetic:** a draft in a chat whose sending becomes impossible while another chat is open stays on that chat's row until the chat is opened. CMP:1443-1448 runs only for the open chat. Not verified.
+
+Harness finding (for §15.4): `restart()` restarts only the core (desktop UiTest.kt:93-103). In-memory model state such as `ChatModel.draft` survives it, but a real relaunch loses it. A "persists across restart" check of model-only state would pass falsely. Add this to the guide's Persistence paragraph.
+
+## 7. Decisions for you
+
+1. Merges across catalogue names (T1, T2, T4, T5, T8, T9). Each removes names from the catalogue and the Count/class map is regenerated. The alternative is separate tests at about one reset plus 1–2 peer connections each. Recommended: merge.
+2. Two placement questions:
+   - T2 takes the §S row `draft_forwardIntoChatWithDraft_restoresDraftAfterSend` into ForwardTest. Alternative: keep it in DraftTest as its own test (bob and cath again).
+   - T1 needs a new name (`forward_acrossChatTypes_peersReceiveAndSourceOpens`). Alternative: keep `forward_contactToGroup` as the name.
+3. T4 makes K `selectForward_multiple_peerReceives` redundant. Should the K design drop it?
+4. `forward_groupToGroup` dropped, the live half of `forward_notOffered_forDeletedOrLive` dropped, and `draft_voiceRecording_finishedOnSwitch` deferred until the REC seam exists.
+
+## 8. Catalogue corrections (02, lines at master `d72f68e6d` → what to write)
+
+- L164: "CMP:727-755" → "forwardItem CMP:729-757 (worktree)". Comment quoting "CMP:843-848" → "CMP:845-855". Cancel "CMP:1266-1268" → "CMP:1268-1270, the (x) is `described("Cancel")`, ContextItemView.kt:148-151".
+- L167: replace "Hover → arrow button" with "the arrow (CIV:296-303) is composed whenever the item has a source; hover (desktop) or tapping the bubble (Android, CIV:334-336) only changes how it looks".
+- L169: "CV:3695-3753, 3002" → "CV:3698-3756 (alert), 3004-3051 (Download / Forward buttons)". With an undownloaded file without text, the title counts only the forwardable items ("Forward 3 message(s)?" for 4 selected, core `hasContent`, Commands.hs:1085-1094). "Nothing to forward!" shows "Cancel" and "Download" and no "Forward".
+- L170: "CIV:470-478" → "CIV:474-482". "CMP:747-752" → "CMP:749-754". The alert title is "%1$s messages not forwarded" ("1 messages not forwarded").
+- L171: "strings.xml:573-574" → "574-575".
+- S237: "CMP:1381-1467" → "CMP:1395-1481". "996-1010" → "997-1012". "C/model/ChatModel.kt:1696" → ":1711". "CMP:1429-1434" → "CMP:1443-1448". "CMP:995-996" → "CMP:997-999". "CMP:1407-1422" → "CMP:1421-1435". Add: drafts are held in memory only (ChatModel.kt:255-257) and do not survive an app restart.
+- S238: Needs "P, CB" → "P, XFTP". Trigger: "enter the file's absolute path into the compose field (PlatformTextField.desktop.kt:99-107)", not Ctrl+V. The test is desktop-only.
+- S239: note "blocked: REC seam not built (plan §0.5.11)".
+- §L: add the T7 row (§5 T7). Add "draft cleared after send" to the S237 Feature cell.
diff --git a/scripts/ci/ui-tests/README.md b/scripts/ci/ui-tests/README.md
new file mode 100644
index 0000000000..91dfe13377
--- /dev/null
+++ b/scripts/ci/ui-tests/README.md
@@ -0,0 +1,71 @@
+# UI tests on GitHub's runners
+
+`.github/workflows/ui-tests.yml` runs the Compose UI tests on GitHub runners (Ubuntu 24.04): the desktop app's `:common:desktopUiTest`, and the Android app's instrumented tests in an emulator. It uses the same runners as local runs, `apps/multiplatform/scripts/uitest.sh` and `apps/multiplatform/scripts/uitest-android.sh`. How the tests are written: `apps/multiplatform/common/src/uiTestShared/README.md`.
+
+## Running it
+
+The workflow runs only when started by hand, on any branch. In the Actions tab, `ui-tests` → Run workflow, then choose the branch and the inputs. With the GitHub CLI:
+
+```sh
+gh workflow run ui-tests.yml --ref <branch>                                  # all desktop tests
+gh workflow run ui-tests.yml --ref <branch> -f platform=both
+gh workflow run ui-tests.yml --ref <branch> -f platform=android -f tests=chat.simplex.app.ui.main.ChatListRowsTest
+gh workflow run ui-tests.yml --ref <branch> -f tests='*ChatListRowsTest, chat.simplex.app.ui.chat.ComposeTest#sendText_sendButton_peerReceives'
+```
+
+| Input | Default | Does |
+|---|---|---|
+| `platform` | `desktop` | `desktop`, `android` or `both` |
+| `tests` | all tests | comma- or space-separated test classes (`chat.simplex.app.ui.main.ChatListRowsTest`) or methods (`Class#method`). Desktop also takes Gradle patterns with `*`; Android doesn't, and the plan job fails when it gets one |
+
+GitHub offers Run workflow, and accepts `gh workflow run`, only for a workflow whose file is on the default branch. Until `ui-tests.yml` is there, a branch can't be tested with it; once it is, the run uses the workflow file of the branch it is started on. A newer run on the same branch cancels the older one.
+
+Every run builds what the tests need from the branch's own code, and reuses an earlier build only when its sources are unchanged, as an artifact of the same branch named after a hash of its sources (30 days). The core libraries have the names and sources of `desktop-linux` and `android-emu`, so the three workflows reuse each other's builds on a branch. The CLI and `uitest-servers` (`ui-tests-bin-<hash>`) are built from `src/**`, `apps/simplex-chat/**`, the files under `tests/` that `uitest-servers` compiles (`UITestServers.hs`, `ChatClient.hs`, `NameResolver.hs`, `ChatTests/DBUtils.hs`, `ChatTests/DBUtils/**`), `cabal.project`, `simplex-chat.cabal`, `PRIVACY.md` and `build-bin.sh`. The workflow saves no Actions caches.
+
+## Jobs
+
+Without `tests`, each platform's tests run in four jobs at once; with `tests`, in one job per platform, named `selected`.
+
+| Job | Does | Time |
+|---|---|---|
+| `plan` | `plan.sh`: the platforms and the shards of each; finds earlier builds | 10 s |
+| `desktop-core` | desktop-linux's `build-core.sh`, when the desktop tests run | skipped when reused, about 24 min not |
+| `android-core` | android-emu's `build-core.sh`, when the Android tests run | skipped when reused, about 27 min not |
+| `bin` | `build-bin.sh`: `exe:simplex-chat` and `exe:uitest-servers` with `-O0 -f uitest`, as `uitest.sh` builds them locally | skipped when reused; to be measured |
+| `desktop` | one job per shard: `uitest.sh` with the prebuilt CLI and servers (`UITEST_CLI`, `UITEST_SERVERS`) | to be measured |
+| `android` | one job per shard: the debug APK and the test APK, the emulator, `uitest-android.sh` | to be measured |
+
+### Desktop shards
+
+Without `tests`, the desktop tests run in four jobs, one per test package: `chat`, `groups`, `main`, and `settings-desktop` (`settings`, the desktop-only `desktop` tests and the harness's own tests). Fixed packages keep a shard's name telling which area failed, need no timings, and don't move tests between shards as tests are added. The plan job fails when a test package that no shard names appears, so a new package can't go untested; add it to `plan.sh`. In each job `uitest.sh` runs as many test JVMs as memory allows (at most 4).
+
+`uitest.sh` runs the tests in their own user, PID and network namespaces (`unshare -rn --pid`), which Ubuntu 24.04 restricts: the job turns `kernel.apparmor_restrict_unprivileged_userns` off first, as android-emu's core build does for Nix, and checks that `unshare` works.
+
+### Android
+
+An emulator runs one test at a time, and the Android tests (about 450) run under ARM translation, likely too long for one job's 6 hours: without `tests` they are split by AndroidJUnitRunner's own sharding (`-e numShards 4 -e shardIndex <i>`), which assigns each test method to a shard by a hash of its name, the same in every pass of `uitest-android.sh`. Each shard job builds the APKs itself, since it compiles the host-side bridge anyway, whose classpath names files in the job's Gradle cache.
+
+The emulator is android-emu's (`install-sdk.sh`, `emulator.sh`): Google APIs x86_64, API 34, with KVM, running the app's arm64-v8a code under ARM translation. The APKs are built as android-emu builds its APK (`-Pandroid.injected.build.abi=arm64-v8a`, `:android:assembleFossDebug`), with `:android:assembleFossDebugAndroidTest` and `:common:uitestBridgeClasspath` in the same Gradle run, before `install-sdk.sh` points `ANDROID_HOME` at an SDK that has only the emulator. Without `local.properties` the debug app's id is `chat.simplex.app` (`UITEST_APP_ID`). `uitest.sh --prepare-only` writes the peer template and `build/uitest/env.properties` that the host-side bridge reads, without the desktop build; `uitest-android.sh` then runs with `UITEST_SERIAL` set to the emulator and `ADB` to the SDK's adb, and forwards the bridge's and the servers' ports with `adb reverse`.
+
+## Results
+
+The job summaries list the results: per test class for desktop (`desktop-linux/test-summary.py` on the JUnit XML; known-issue tests are counted as skipped), and per class with the failed and crashed tests for Android (`android-summary.py` on `results.txt`). A job fails when a test fails or, on Android, crashes. The artifacts (7 days):
+
+- `ui-tests-desktop-<shard>`: the HTML report and the JUnit XML (`common/build/{reports,test-results}/desktopUiTest`), and from the run directory the failure screenshots (`failures/`), the transcripts of the failed tests' CLI peers (`jvm-*/t<n>/peers/<name>/transcript.log`: a test's directory is kept only when it failed) and JVM crash logs;
+- `ui-tests-android-<shard>`: the run directory of `uitest-android.sh` (`results.txt`, `instrument-<pass>.txt`, `logcat.txt`, `timings.txt`, `failures/`, `bridge.log`), `emulator/emulator.log`, and the transcripts of the bridge's peers (all tests).
+
+## Diagnosing a failure
+
+Start from the failure message in the summary or the test report: a timed-out wait names what it waited for, the API calls still in flight and the first visible texts. Its screenshot in `failures/` is named after the JVM and the wait. The peers' transcripts show what each CLI peer printed, with timestamps, to tell an app failure from a peer or server one. The step log has each test's standard output. On Android, `instrument-<pass>.txt` has the stack traces, `logcat.txt` the app's log and the in-process watchdog's thread dumps, and `timings.txt` each test's phases; a test reported as `crashed` was running when the app process died, and the run resumed without it.
+
+## Known limits
+
+- **ARM translation on Android**, as android-emu's README describes: the app runs slower than on a phone and can crash in the translator. `uitest-android.sh` resumes after a crash (at most 4 passes), and force-stops the app when the instrumentation prints nothing for 420 s (`UITEST_STALL_S`).
+- **Memory**: `uitest.sh` needs 3000 MB free and `uitest-android.sh` 4500 MB besides the emulator; the runners have 16 GB.
+- The test JVMs per desktop job follow free memory, not the runner's 4 CPUs.
+
+## Scripts
+
+- `plan.sh`: the plan job's choices and the shards of both platforms.
+- `build-bin.sh`, `install-bin.sh`: the CLI and `uitest-servers`, built and installed for `uitest.sh` (`UITEST_CLI`, `UITEST_SERVERS`).
+- `android-summary.py`: the Android job summary.
diff --git a/scripts/ci/ui-tests/android-summary.py b/scripts/ci/ui-tests/android-summary.py
new file mode 100755
index 0000000000..46298479f1
--- /dev/null
+++ b/scripts/ci/ui-tests/android-summary.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+
+# Prints the results of an Android UI test run of apps/multiplatform/scripts/uitest-android.sh (its results.txt), and
+# adds them to the job summary on GitHub.
+# Usage: scripts/ci/ui-tests/android-summary.py <run dir>
+
+import collections
+import glob
+import os
+import sys
+
+run_dir = sys.argv[1]
+results = os.path.join(run_dir, "results.txt")
+if not os.path.isfile(results):
+    sys.exit(f"no results.txt in {run_dir}")
+
+outcomes = {"0": "passed", "-2": "failed", "-3": "skipped", "-4": "skipped", "crashed": "crashed"}
+columns = ["passed", "failed", "crashed", "skipped"]
+classes = collections.defaultdict(collections.Counter)
+problems = []
+with open(results) as f:
+    for line in f:
+        test, _, code = line.strip().rpartition(" ")
+        if not test:
+            continue
+        outcome = outcomes.get(code, f"code {code}")
+        cls = test.split("#")[0].removeprefix("chat.simplex.app.ui.")
+        classes[cls][outcome if outcome in columns else "failed"] += 1
+        if outcome not in ("passed", "skipped"):
+            problems.append(f"{test.removeprefix('chat.simplex.app.ui.')}: {outcome}")
+
+totals = collections.Counter()
+for counts in classes.values():
+    totals.update(counts)
+rows = ["| Class | " + " | ".join(c.capitalize() for c in columns) + " |", "|---" * (len(columns) + 1) + "|"]
+for cls in sorted(classes):
+    rows.append(f"| {cls} | " + " | ".join(str(classes[cls][c]) for c in columns) + " |")
+
+summary = [f"### Android UI tests: {sum(totals.values())} tests, " + ", ".join(f"{totals[c]} {c}" for c in columns), ""]
+summary += rows if classes else ["No test finished."]
+if problems:
+    summary += ["", "Failed or crashed:", ""] + [f"- {p}" for p in problems]
+shots = glob.glob(os.path.join(run_dir, "failures", "*"))
+if shots:
+    summary += ["", f"{len(shots)} failure screenshots are in the `failures` directory of the run's artifact."]
+print("\n".join(summary))
+if os.environ.get("GITHUB_STEP_SUMMARY"):
+    with open(os.environ["GITHUB_STEP_SUMMARY"], "a") as f:
+        f.write("\n".join(summary) + "\n")
diff --git a/scripts/ci/ui-tests/build-bin.sh b/scripts/ci/ui-tests/build-bin.sh
new file mode 100755
index 0000000000..8b04df676f
--- /dev/null
+++ b/scripts/ci/ui-tests/build-bin.sh
@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# Builds the CLI and uitest-servers, the UI tests' peers and local servers, as apps/multiplatform/scripts/uitest.sh
+# builds them (-O0, flag uitest), and packs the two executables.
+# Usage: scripts/ci/ui-tests/build-bin.sh <output .tar.gz>
+# The configuration is build-core.sh's but without client_library, which makes uitest-servers unbuildable.
+
+set -euo pipefail
+
+mkdir -p "$(dirname "$1")"
+out="$(cd "$(dirname "$1")" && pwd)/$(basename "$1")"
+flags=(-O0 -f uitest)
+exes=(simplex-chat uitest-servers)
+
+ghc --version
+cabal --version
+
+cat > cabal.project.local << EOF
+ignore-project: False
+jobs: \$ncpus
+
+package direct-sqlcipher
+    flags: +openssl
+EOF
+
+cabal build "${flags[@]}" "${exes[@]/#/exe:}"
+
+pkg=$(mktemp -d)
+for exe in "${exes[@]}"; do
+  # in a fresh project list-bin first prints git's output from syncing the source-repository-packages
+  cp "$(cabal list-bin "${flags[@]}" "exe:$exe" | tail -n 1)" "$pkg"
+done
+ldd "$pkg"/*
+if ldd "$pkg"/* | grep 'not found'; then
+  echo "error: the executables need these libraries"
+  exit 1
+fi
+du -sh "$pkg"/*
+
+tar -C "$pkg" -czf "$out" .
+ls -la "$out"
diff --git a/scripts/ci/ui-tests/install-bin.sh b/scripts/ci/ui-tests/install-bin.sh
new file mode 100755
index 0000000000..c464dc01ee
--- /dev/null
+++ b/scripts/ci/ui-tests/install-bin.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Unpacks the CLI and uitest-servers from build-bin.sh into <dir>, checks that the runner has their libraries, and puts
+# UITEST_CLI and UITEST_SERVERS in GITHUB_ENV, where apps/multiplatform/scripts/uitest.sh uses them instead of building.
+# Usage: scripts/ci/ui-tests/install-bin.sh <bin .tar.gz> <dir>
+
+set -euo pipefail
+
+mkdir -p "$2"
+dir=$(cd "$2" && pwd)
+tar -C "$dir" -xzf "$1"
+ls -la "$dir"
+if ldd "$dir/simplex-chat" "$dir/uitest-servers" | grep 'not found'; then
+  echo "error: the executables need these libraries"
+  exit 1
+fi
+
+if [ -n "${GITHUB_ENV:-}" ]; then
+  {
+    echo "UITEST_CLI=$dir/simplex-chat"
+    echo "UITEST_SERVERS=$dir/uitest-servers"
+  } >> "$GITHUB_ENV"
+fi
diff --git a/scripts/ci/ui-tests/plan.sh b/scripts/ci/ui-tests/plan.sh
new file mode 100755
index 0000000000..f28b43ad9c
--- /dev/null
+++ b/scripts/ci/ui-tests/plan.sh
@@ -0,0 +1,71 @@
+#!/bin/bash
+
+# Reads the ui-tests workflow's inputs and writes to GITHUB_OUTPUT which platforms run, and the desktop and Android
+# shards as matrices.
+# Usage: PLATFORM=desktop|android|both TESTS='<classes or patterns>' scripts/ci/ui-tests/plan.sh
+# Without TESTS, the desktop tests run in one shard per test package; a test package no shard names fails the plan, so
+# a new package can't go untested. The Android tests run in android_shards shards of AndroidJUnitRunner's own sharding
+# (-e numShards -e shardIndex). With TESTS (comma- or space-separated), one job per platform runs them: as Gradle
+# --tests filters on desktop, with Class#method written Class.method, and as `am instrument -e class` on Android.
+
+set -euo pipefail
+
+out=${GITHUB_OUTPUT:-/dev/null}
+ui=apps/multiplatform/common/src
+roots=("$ui/uiTestShared/kotlin/chat/simplex/app/ui" "$ui/desktopTest/kotlin/chat/simplex/app/ui")
+android_shards=4
+shards='[
+  {"shard": "chat", "tests": "chat.simplex.app.ui.chat.*"},
+  {"shard": "groups", "tests": "chat.simplex.app.ui.groups.*"},
+  {"shard": "main", "tests": "chat.simplex.app.ui.main.*"},
+  {"shard": "settings-desktop", "tests": "chat.simplex.app.ui.settings.* chat.simplex.app.ui.desktop.* chat.simplex.app.ui.harness.*"}
+]'
+
+case "${PLATFORM:-}" in
+  desktop) desktop=true android=false ;;
+  android) desktop=false android=true ;;
+  both) desktop=true android=true ;;
+  *)
+    echo "::error::platform must be desktop, android or both, not \"${PLATFORM:-}\""
+    exit 1
+    ;;
+esac
+
+allowed='^[A-Za-z0-9_.*#, ]*$'
+if ! [[ "${TESTS:-}" =~ $allowed ]]; then
+  echo "::error::tests may have only class names, patterns (* . # _), commas and spaces"
+  exit 1
+fi
+read -r -a tests <<< "${TESTS//,/ }"
+
+if [ "${#tests[@]}" -eq 0 ]; then
+  covered=$(jq -r '[.[].tests | split(" ")[] | sub("^chat\\.simplex\\.app\\.ui\\."; "") | sub("\\.\\*$"; "")] | join(" ")' <<< "$shards")
+  missing=$(find "${roots[@]}" -name '*Test.kt' | sed 's|.*/chat/simplex/app/ui/||' | cut -d/ -f1 | sort -u | while read -r pkg; do
+    case " $covered " in
+      *" $pkg "*) ;;
+      *) echo "chat.simplex.app.ui.$pkg" ;;
+    esac
+  done)
+  if [ -n "$missing" ]; then
+    echo "::error::no desktop shard runs the tests in $(paste -sd ' ' <<< "$missing") (add a shard in scripts/ci/ui-tests/plan.sh)"
+    exit 1
+  fi
+  matrix=$(jq -c . <<< "$shards")
+  android_matrix=$(jq -cn --argjson n "$android_shards" '[range($n) | {shard: "\(. + 1)-of-\($n)", args: "-e numShards \($n) -e shardIndex \(.)"}]')
+else
+  if [ "$android" = true ] && [[ "${tests[*]}" == *"*"* ]]; then
+    echo "::error::Android runs whole class names (or Class#method), not patterns with *"
+    exit 1
+  fi
+  desktop_tests="${tests[*]}"
+  matrix=$(jq -cn --arg tests "${desktop_tests//#/.}" '[{shard: "selected", tests: $tests}]')
+  android_classes=$(IFS=,; echo "${tests[*]}")
+  android_matrix=$(jq -cn --arg classes "$android_classes" '[{shard: "selected", args: "-e class \($classes)"}]')
+fi
+
+{
+  echo "desktop=$desktop"
+  echo "android=$android"
+  echo "desktop-shards=$matrix"
+  echo "android-shards=$android_matrix"
+} | tee -a "$out"
diff --git a/tests/UITestServers.hs b/tests/UITestServers.hs
index 06aae51b6d..2bd544943d 100644
--- a/tests/UITestServers.hs
+++ b/tests/UITestServers.hs
@@ -1,21 +1,39 @@
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE NamedFieldPuns #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 
 module Main (main) where
 
 import ChatClient (persistentServerStoreCfg, smpServerCfg, testServerKeyHash, xftpServerConfig, xftpServerFiles)
 import ChatTests.DBUtils
-import Control.Concurrent.Async (async, cancel)
+import Control.Concurrent.Async (Async, async, cancel, poll, waitCatchSTM)
 import Control.Concurrent.STM
+import Control.Exception (SomeException, try)
+import Data.IORef
+import qualified Data.Map.Strict as M
+import Data.Maybe (isNothing)
 import qualified Simplex.Messaging.TMap as TM
 import Simplex.FileTransfer.Server (runXFTPServerBlocking)
 import Simplex.Messaging.Server (runSMPServerBlocking)
 import Simplex.Messaging.Server.Env.STM (ServerConfig (..))
-import System.Directory (createDirectoryIfMissing)
+import System.Directory (createDirectoryIfMissing, removePathForcibly)
 import System.Environment (getArgs)
 import System.Exit (die)
 import System.IO
 
+data Protocol = SMP | XFTP
+
+data ServerDef = ServerDef {srvProtocol :: Protocol, srvPortOffset :: Int, srvHost :: String}
+
+serverDefs :: M.Map String ServerDef
+serverDefs =
+  M.fromList
+    [ ("smp1", ServerDef SMP 0 "localhost"),
+      ("xftp1", ServerDef XFTP 0 "localhost"),
+      ("smp2", ServerDef SMP 10 "127.0.0.1"),
+      ("xftp2", ServerDef XFTP 10 "127.0.0.1")
+    ]
+
 main :: IO ()
 main = do
   hSetBuffering stdout LineBuffering
@@ -25,33 +43,55 @@ main = do
       _ -> die "usage: uitest-servers <servers dir> <port base>"
   chatQueryStats <- TM.emptyIO
   agentQueryStats <- TM.emptyIO
-  let tmpPath = dir <> "/smp1"
-      ps = TestParams {tmpPath, portBase = base, printOutput = False, chatQueryStats, agentQueryStats}
-      cfg =
-        (smpServerCfg ps)
-          { serverStoreCfg = persistentServerStoreCfg tmpPath,
-            serverStatsLogFile = tmpPath <> "/smp-server-stats.daily.log",
-            prometheusMetricsFile = tmpPath <> "/smp-server-metrics.txt"
-          }
-  createDirectoryIfMissing True tmpPath
-  started <- newEmptyTMVarIO
-  server <- async $ runSMPServerBlocking started cfg Nothing
-  ok <- atomically $ takeTMVar started
-  putStrLn $
-    if ok
-      then "ready smp1 smp://" <> testServerKeyHash <> "@localhost:" <> show (base + 1)
-      else "error smp1 did not start"
-  let xps = ps {tmpPath = dir <> "/xftp1"}
-  createDirectoryIfMissing True (xftpServerFiles xps)
-  xftpStarted <- newEmptyTMVarIO
-  xftpServer <- async $ runXFTPServerBlocking xftpStarted (xftpServerConfig xps)
-  xftpOk <- atomically $ takeTMVar xftpStarted
-  putStrLn $
-    if xftpOk
-      then "ready xftp1 xftp://" <> testServerKeyHash <> "@localhost:" <> show (base + 2)
-      else "error xftp1 did not start"
-  waitForEOF
-  cancel xftpServer
-  cancel server
+  running <- newIORef (M.empty :: M.Map String (Async ()))
+  let serverDir name = dir <> "/" <> name
+      params name ServerDef {srvPortOffset} = TestParams {tmpPath = serverDir name, portBase = base + srvPortOffset, printOutput = False, chatQueryStats, agentQueryStats}
+      address ServerDef {srvProtocol, srvPortOffset, srvHost} = case srvProtocol of
+        SMP -> "smp://" <> testServerKeyHash <> "@" <> srvHost <> ":" <> show (base + srvPortOffset + 1)
+        XFTP -> "xftp://" <> testServerKeyHash <> "@" <> srvHost <> ":" <> show (base + srvPortOffset + 2)
+      runServer name d@ServerDef {srvProtocol} = do
+        let ps = params name d
+            path = tmpPath ps
+        started <- newEmptyTMVarIO
+        a <- case srvProtocol of
+          SMP -> do
+            createDirectoryIfMissing True path
+            let cfg =
+                  (smpServerCfg ps)
+                    { serverStoreCfg = persistentServerStoreCfg path,
+                      serverStatsLogFile = path <> "/smp-server-stats.daily.log",
+                      prometheusMetricsFile = path <> "/smp-server-metrics.txt"
+                    }
+            async $ runSMPServerBlocking started cfg Nothing
+          XFTP -> do
+            createDirectoryIfMissing True (xftpServerFiles ps)
+            async $ runXFTPServerBlocking started (xftpServerConfig ps)
+        atomically ((Right <$> takeTMVar started) `orElse` (Left <$> waitCatchSTM a)) >>= \case
+          Right True -> modifyIORef' running (M.insert name a) >> pure ("ready " <> name <> " " <> address d)
+          Right False -> cancel a >> pure ("error " <> name <> " did not start")
+          Left (Left e) -> pure ("error " <> name <> " " <> oneLine (show e))
+          Left (Right ()) -> pure ("error " <> name <> " exited while starting")
+      isRunning name = readIORef running >>= maybe (pure False) (fmap isNothing . poll) . M.lookup name
+      stopServer name = do
+        readIORef running >>= mapM_ cancel . M.lookup name
+        modifyIORef' running (M.delete name)
+      startServer name d = isRunning name >>= \up -> if up then pure ("ready " <> name <> " " <> address d) else stopServer name >> runServer name d
+      command line = case words line of
+        [cmd, name] | Just d <- M.lookup name serverDefs -> case cmd of
+          "start" -> startServer name d
+          "stop" -> stopServer name >> pure ("stopped " <> name)
+          "reset" -> stopServer name >> removePathForcibly (serverDir name) >> runServer name d
+          _ -> pure ("error " <> name <> " unknown command " <> cmd)
+        [_, name] -> pure ("error " <> name <> " unknown server")
+        _ -> pure ("error - unknown command " <> line)
+      respond line = try (command line) >>= putStrLn . either (\(e :: SomeException) -> "error " <> serverName line <> " " <> oneLine (show e)) id
+  respond "start smp1"
+  respond "start xftp1"
+  let loop = hIsEOF stdin >>= \eof -> if eof then pure () else getLine >>= respond >> loop
+  loop
+  readIORef running >>= mapM_ cancel . M.elems
   where
-    waitForEOF = hIsEOF stdin >>= \eof -> if eof then pure () else getLine >> waitForEOF
+    serverName line = case words line of
+      [_, name] -> name
+      _ -> "-"
+    oneLine = map (\c -> if c == '\n' then ' ' else c)