diff --git a/android/app/build.gradle b/android/app/build.gradle
index bf87c98..382fcfb 100644
--- a/android/app/build.gradle
+++ b/android/app/build.gradle
@@ -15,8 +15,8 @@ android {
         applicationId "md.zennotes"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 20
-        versionName "1.1.18"
+        versionCode 21
+        versionName "1.1.19"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         aaptOptions {
              // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.
diff --git a/android/app/src/main/java/md/zennotes/ClipboardImageData.java b/android/app/src/main/java/md/zennotes/ClipboardImageData.java
new file mode 100644
index 0000000..224e873
--- /dev/null
+++ b/android/app/src/main/java/md/zennotes/ClipboardImageData.java
@@ -0,0 +1,37 @@
+package md.zennotes;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+
+final class ClipboardImageData {
+    static final int MAX_BYTES = 10 * 1024 * 1024;
+    static final class InvalidImage extends IOException {
+        InvalidImage(String message) { super(message); }
+    }
+    static byte[] read(InputStream stream, int limit) throws IOException {
+        if (stream == null) throw new InvalidImage("Could not read the pasted image.");
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        byte[] buffer = new byte[16384];
+        int size;
+        while ((size = stream.read(buffer)) != -1) {
+            if (size > limit - output.size()) throw new InvalidImage("Pasted images must be 10 MB or smaller.");
+            output.write(buffer, 0, size);
+        }
+        if (output.size() == 0) throw new InvalidImage("The pasted image is empty.");
+        return output.toByteArray();
+    }
+    static String mimeType(byte[] b) throws IOException {
+        if (b.length >= 8 && (b[0] & 255) == 137 && b[1] == 80 && b[2] == 78 && b[3] == 71 &&
+                b[4] == 13 && b[5] == 10 && b[6] == 26 && b[7] == 10) return "image/png";
+        if (b.length >= 3 && (b[0] & 255) == 255 && (b[1] & 255) == 216 && (b[2] & 255) == 255) return "image/jpeg";
+        if (b.length >= 6) {
+            String header = new String(b, 0, 6, StandardCharsets.US_ASCII);
+            if (header.equals("GIF87a") || header.equals("GIF89a")) return "image/gif";
+        }
+        if (b.length >= 12 && new String(b, 0, 4, StandardCharsets.US_ASCII).equals("RIFF") &&
+                new String(b, 8, 4, StandardCharsets.US_ASCII).equals("WEBP")) return "image/webp";
+        throw new InvalidImage("Paste a PNG, JPEG, GIF, or WebP image.");
+    }
+}
diff --git a/android/app/src/main/java/md/zennotes/ClipboardImageRead.java b/android/app/src/main/java/md/zennotes/ClipboardImageRead.java
new file mode 100644
index 0000000..38c369b
--- /dev/null
+++ b/android/app/src/main/java/md/zennotes/ClipboardImageRead.java
@@ -0,0 +1,45 @@
+package md.zennotes;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/** Own the temporary grant even while a provider has not returned a stream. */
+final class ClipboardImageRead implements AutoCloseable {
+    private final Runnable releasePermission;
+    private InputStream stream;
+    private boolean closed;
+
+    ClipboardImageRead(Runnable releasePermission) { this.releasePermission = releasePermission; }
+
+    InputStream attach(InputStream opened) throws IOException {
+        synchronized (this) {
+            if (!closed) { stream = opened; return opened; }
+        }
+        closeStream(opened);
+        throw new IOException("Image paste was cancelled.");
+    }
+
+    synchronized boolean isClosed() { return closed; }
+
+    synchronized void respondIfOpen(Runnable response) {
+        if (!closed) response.run();
+    }
+
+    @Override public void close() {
+        InputStream opened;
+        synchronized (this) {
+            if (closed) return;
+            closed = true;
+            opened = stream;
+            stream = null;
+        }
+        // Release the grant without waiting for provider I/O to finish.
+        try { releasePermission.run(); }
+        finally { closeStream(opened); }
+    }
+
+    private static void closeStream(InputStream stream) {
+        if (stream == null) return;
+        try { stream.close(); } catch (IOException | RuntimeException ignored) { /* already closed/revoked */ }
+    }
+}
diff --git a/android/app/src/main/java/md/zennotes/ImagePastePlugin.java b/android/app/src/main/java/md/zennotes/ImagePastePlugin.java
new file mode 100644
index 0000000..401bb38
--- /dev/null
+++ b/android/app/src/main/java/md/zennotes/ImagePastePlugin.java
@@ -0,0 +1,126 @@
+package md.zennotes;
+
+import android.content.res.AssetFileDescriptor;
+import android.os.CancellationSignal;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Base64;
+import androidx.core.view.inputmethod.InputConnectionCompat;
+import androidx.core.view.inputmethod.InputContentInfoCompat;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import java.io.InputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+
+@CapacitorPlugin(name = "ImagePaste")
+public class ImagePastePlugin extends Plugin {
+    private final Map<String, InputContentInfoCompat> pending = new HashMap<>();
+    private final Handler expiry = new Handler(Looper.getMainLooper());
+    private final ExecutorService reader = Executors.newSingleThreadExecutor();
+    private ClipboardImageRead activeRead;
+    private volatile boolean destroyed;
+
+    @Override public void load() {
+        ((ImagePasteWebView) getBridge().getWebView()).imageReceiver = this::receive;
+    }
+
+    @PluginMethod public void setEnabled(PluginCall call) {
+        boolean enabled = call.getBoolean("enabled", false);
+        getActivity().runOnUiThread(() -> {
+            if (destroyed) { call.reject("Image pasting is unavailable."); return; }
+            ((ImagePasteWebView) getBridge().getWebView()).setImagePasteEnabled(enabled);
+            call.resolve();
+        });
+    }
+
+    private synchronized boolean receive(InputContentInfoCompat content, int flags) {
+        if (destroyed || !hasListeners("image") || activeRead != null || !pending.isEmpty() || !"content".equals(content.getContentUri().getScheme())) return false;
+        boolean supported = false;
+        for (String type : ImagePasteWebView.IMAGE_TYPES) supported |= content.getDescription().hasMimeType(type);
+        if (!supported) return false;
+        try {
+            if ((flags & InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION) != 0) content.requestPermission();
+        } catch (RuntimeException error) { return false; }
+        String id = UUID.randomUUID().toString();
+        pending.put(id, content);
+        JSObject event = new JSObject();
+        event.put("id", id);
+        notifyListeners("image", event);
+        expiry.postDelayed(() -> release(id), 30000);
+        return true;
+    }
+
+    private synchronized InputContentInfoCompat take(String id) { return pending.remove(id); }
+    private void release(String id) {
+        InputContentInfoCompat content = take(id);
+        if (content != null) releasePermission(content);
+    }
+    private static void releasePermission(InputContentInfoCompat content) {
+        try { content.releasePermission(); } catch (RuntimeException ignored) { /* provider already revoked it */ }
+    }
+
+    // Plugin methods run off the UI thread. Never send arbitrary URIs through
+    // the JS bridge: read only the short-lived token from a user paste event.
+    @PluginMethod public synchronized void read(PluginCall call) {
+        if (destroyed) { call.reject("Image pasting is unavailable."); return; }
+        InputContentInfoCompat content = take(call.getString("id", ""));
+        if (content == null) { call.reject("The pasted image expired. Please paste it again."); return; }
+        CancellationSignal cancellation = new CancellationSignal();
+        ClipboardImageRead read = new ClipboardImageRead(() -> {
+            releasePermission(content);
+            try { cancellation.cancel(); } catch (RuntimeException ignored) { /* provider already gone */ }
+        });
+        activeRead = read;
+        try { reader.execute(() -> readImage(call, content, read, cancellation)); }
+        catch (RejectedExecutionException error) {
+            activeRead = null;
+            read.close();
+            call.reject("Image pasting is unavailable. Please reopen the note.");
+        }
+    }
+    private void readImage(PluginCall call, InputContentInfoCompat content, ClipboardImageRead read, CancellationSignal cancellation) {
+        try {
+            if (read.isClosed()) return;
+            byte[] bytes;
+            try (AssetFileDescriptor descriptor = getContext().getContentResolver()
+                    .openAssetFileDescriptor(content.getContentUri(), "r", cancellation)) {
+                InputStream stream = read.attach(descriptor == null ? null : descriptor.createInputStream());
+                bytes = ClipboardImageData.read(stream, ClipboardImageData.MAX_BYTES);
+            }
+            JSObject result = new JSObject();
+            result.put("mimeType", ClipboardImageData.mimeType(bytes));
+            result.put("base64", Base64.encodeToString(bytes, Base64.NO_WRAP));
+            read.respondIfOpen(() -> call.resolve(result));
+        } catch (ClipboardImageData.InvalidImage error) {
+            read.respondIfOpen(() -> call.reject(error.getMessage()));
+        } catch (IOException | RuntimeException error) {
+            read.respondIfOpen(() -> call.reject("Could not read the pasted image. Please copy it again."));
+        } finally {
+            read.close();
+            synchronized (this) { if (activeRead == read) activeRead = null; }
+        }
+    }
+
+    @PluginMethod public void discard(PluginCall call) {
+        release(call.getString("id", ""));
+        call.resolve();
+    }
+
+    @Override protected synchronized void handleOnDestroy() {
+        destroyed = true;
+        expiry.removeCallbacksAndMessages(null);
+        if (activeRead != null) { activeRead.close(); activeRead = null; }
+        reader.shutdownNow();
+        for (InputContentInfoCompat content : pending.values()) releasePermission(content);
+        pending.clear();
+    }
+}
diff --git a/android/app/src/main/java/md/zennotes/ImagePasteWebView.java b/android/app/src/main/java/md/zennotes/ImagePasteWebView.java
new file mode 100644
index 0000000..7c296fe
--- /dev/null
+++ b/android/app/src/main/java/md/zennotes/ImagePasteWebView.java
@@ -0,0 +1,36 @@
+package md.zennotes;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+import android.view.inputmethod.InputMethodManager;
+import androidx.core.view.inputmethod.EditorInfoCompat;
+import androidx.core.view.inputmethod.InputConnectionCompat;
+import androidx.core.view.inputmethod.InputContentInfoCompat;
+import com.getcapacitor.CapacitorWebView;
+
+/** Preserve Capacitor's keyboard handling and add Android's rich-content API. */
+public class ImagePasteWebView extends CapacitorWebView {
+    interface Receiver { boolean receive(InputContentInfoCompat content, int flags); }
+    static final String[] IMAGE_TYPES = {"image/png", "image/jpeg", "image/gif", "image/webp"};
+    private boolean imagePasteEnabled;
+    Receiver imageReceiver;
+
+    public ImagePasteWebView(Context context, AttributeSet attrs) { super(context, attrs); }
+
+    void setImagePasteEnabled(boolean enabled) {
+        if (imagePasteEnabled == enabled) return;
+        imagePasteEnabled = enabled;
+        InputMethodManager ime = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+        if (ime != null) ime.restartInput(this);
+    }
+
+    @Override public InputConnection onCreateInputConnection(EditorInfo info) {
+        InputConnection connection = super.onCreateInputConnection(info);
+        if (connection == null || !imagePasteEnabled) return connection;
+        EditorInfoCompat.setContentMimeTypes(info, IMAGE_TYPES);
+        return InputConnectionCompat.createWrapper(connection, info,
+                (content, flags, options) -> imagePasteEnabled && imageReceiver != null && imageReceiver.receive(content, flags));
+    }
+}
diff --git a/android/app/src/main/java/md/zennotes/MainActivity.java b/android/app/src/main/java/md/zennotes/MainActivity.java
index ce26fff..1f805e1 100644
--- a/android/app/src/main/java/md/zennotes/MainActivity.java
+++ b/android/app/src/main/java/md/zennotes/MainActivity.java
@@ -4,11 +4,13 @@
 import android.content.pm.PackageInfo;
 import android.os.Build;
 import android.os.Bundle;
+import android.os.SystemClock;
 import android.view.WindowManager;
 import android.webkit.WebView;
 
 import androidx.core.view.WindowCompat;
 import androidx.core.view.WindowInsetsControllerCompat;
+import androidx.core.splashscreen.SplashScreen;
 
 import android.webkit.WebResourceRequest;
 import android.webkit.WebResourceResponse;
@@ -24,12 +26,18 @@ public class MainActivity extends BridgeActivity {
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
+        // Install while the launch theme is still active, before Capacitor
+        // replaces it. One compat path for both pre-12 and modern Android.
+        long splashUntil = SystemClock.uptimeMillis() + 400;
+        SplashScreen splash = SplashScreen.installSplashScreen(this);
+        splash.setKeepOnScreenCondition(() -> SystemClock.uptimeMillis() < splashUntil);
         // App-local plugins must be registered before the bridge loads.
         registerPlugin(ShareInboxPlugin.class);
         registerPlugin(FolderPickerPlugin.class);
         registerPlugin(SafFsPlugin.class);
         registerPlugin(DirectUploadPlugin.class);
         registerPlugin(WidgetBridgePlugin.class);
+        registerPlugin(ImagePastePlugin.class);
         super.onCreate(savedInstanceState);
         // Cold-start share: the launch intent IS the share. Stash it now; the
         // WebView drains the inbox after the vault opens (importPendingShares).
diff --git a/android/app/src/main/res/drawable/zn_splash_icon.xml b/android/app/src/main/res/drawable/zn_splash_icon.xml
new file mode 100644
index 0000000..d7885ad
--- /dev/null
+++ b/android/app/src/main/res/drawable/zn_splash_icon.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- A non-adaptive, square logo in the 288dp splash canvas. The complete
+     rounded square fits inside Android's 192dp circular safe area, so the
+     system mask cannot clip its corners or distort the ring. -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <shape android:shape="rectangle">
+            <size android:width="288dp" android:height="288dp" />
+            <solid android:color="@android:color/transparent" />
+        </shape>
+    </item>
+    <item android:width="128dp" android:height="128dp" android:gravity="center">
+        <bitmap android:src="@mipmap/ic_launcher_foreground" android:gravity="fill" />
+    </item>
+</layer-list>
diff --git a/android/app/src/main/res/layout/capacitor_bridge_layout_main.xml b/android/app/src/main/res/layout/capacitor_bridge_layout_main.xml
new file mode 100644
index 0000000..78f64c8
--- /dev/null
+++ b/android/app/src/main/res/layout/capacitor_bridge_layout_main.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Same Capacitor layout/IDs; subclass only the keyboard input connection. -->
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent" android:layout_height="match_parent">
+    <md.zennotes.ImagePasteWebView android:id="@+id/webview"
+        android:layout_width="match_parent" android:layout_height="match_parent" />
+</androidx.coordinatorlayout.widget.CoordinatorLayout>
diff --git a/android/app/src/main/res/values/styles.xml b/android/app/src/main/res/values/styles.xml
index af9a126..85ec9c8 100644
--- a/android/app/src/main/res/values/styles.xml
+++ b/android/app/src/main/res/values/styles.xml
@@ -22,8 +22,9 @@
     </style>
 
     <style name="AppTheme.NoActionBarLaunch" parent="Theme.SplashScreen">
-        <item name="android:background">@drawable/splash</item>
-        <item name="android:windowBackground">@color/znBackground</item>
+        <item name="windowSplashScreenBackground">@color/znBackground</item>
+        <item name="windowSplashScreenAnimatedIcon">@drawable/zn_splash_icon</item>
+        <item name="postSplashScreenTheme">@style/AppTheme.NoActionBar</item>
         <item name="android:statusBarColor">@color/znBackground</item>
         <item name="android:navigationBarColor">@color/znBackground</item>
         <item name="android:windowLightStatusBar">false</item>
diff --git a/android/app/src/test/java/md/zennotes/ClipboardImageDataTest.java b/android/app/src/test/java/md/zennotes/ClipboardImageDataTest.java
new file mode 100644
index 0000000..9c90d4b
--- /dev/null
+++ b/android/app/src/test/java/md/zennotes/ClipboardImageDataTest.java
@@ -0,0 +1,25 @@
+package md.zennotes;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+
+public class ClipboardImageDataTest {
+    @Test public void boundedReadPreservesBytes() throws Exception {
+        byte[] data = {1, 2, 3, 4};
+        assertArrayEquals(data, ClipboardImageData.read(new ByteArrayInputStream(data), 4));
+    }
+    @Test public void overLimitAndEmptyInputFail() {
+        assertThrows(IOException.class, () -> ClipboardImageData.read(new ByteArrayInputStream(new byte[5]), 4));
+        assertThrows(IOException.class, () -> ClipboardImageData.read(new ByteArrayInputStream(new byte[0]), 4));
+    }
+    @Test public void checksImageSignaturesNotUntrustedMimeOrFilename() throws Exception {
+        assertEquals("image/png", ClipboardImageData.mimeType(new byte[]{(byte)137,80,78,71,13,10,26,10}));
+        assertEquals("image/jpeg", ClipboardImageData.mimeType(new byte[]{(byte)255,(byte)216,(byte)255,0}));
+        assertEquals("image/gif", ClipboardImageData.mimeType("GIF89a".getBytes()));
+        assertEquals("image/webp", ClipboardImageData.mimeType("RIFF0000WEBP".getBytes()));
+        assertThrows(IOException.class, () -> ClipboardImageData.mimeType("<svg onload='alert(1)'/>".getBytes()));
+        assertThrows(IOException.class, () -> ClipboardImageData.mimeType(new byte[0]));
+    }
+}
diff --git a/android/app/src/test/java/md/zennotes/ClipboardImageReadTest.java b/android/app/src/test/java/md/zennotes/ClipboardImageReadTest.java
new file mode 100644
index 0000000..e37c148
--- /dev/null
+++ b/android/app/src/test/java/md/zennotes/ClipboardImageReadTest.java
@@ -0,0 +1,105 @@
+package md.zennotes;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class ClipboardImageReadTest {
+    @Test public void cancelledReadCannotDispatchAResponse() {
+        AtomicInteger responses = new AtomicInteger();
+        ClipboardImageRead read = new ClipboardImageRead(() -> {});
+        read.respondIfOpen(responses::incrementAndGet);
+        read.close();
+        read.respondIfOpen(responses::incrementAndGet);
+        assertEquals(1, responses.get());
+    }
+
+    @Test public void teardownCannotInterleaveWithResponseDispatch() throws Exception {
+        AtomicInteger releases = new AtomicInteger();
+        CountDownLatch responding = new CountDownLatch(1);
+        CountDownLatch finishResponse = new CountDownLatch(1);
+        CountDownLatch closing = new CountDownLatch(1);
+        ClipboardImageRead read = new ClipboardImageRead(releases::incrementAndGet);
+        var worker = Executors.newFixedThreadPool(2);
+        try {
+            var response = worker.submit(() -> read.respondIfOpen(() -> {
+                responding.countDown();
+                try { assertTrue(finishResponse.await(2, TimeUnit.SECONDS)); }
+                catch (InterruptedException error) { throw new AssertionError(error); }
+                assertFalse(read.isClosed());
+            }));
+            assertTrue(responding.await(2, TimeUnit.SECONDS));
+            var teardown = worker.submit(() -> { closing.countDown(); read.close(); });
+            assertTrue(closing.await(2, TimeUnit.SECONDS));
+            assertEquals(0, releases.get());
+            finishResponse.countDown();
+            response.get(2, TimeUnit.SECONDS);
+            teardown.get(2, TimeUnit.SECONDS);
+            assertEquals(1, releases.get());
+        } finally {
+            finishResponse.countDown();
+            worker.shutdownNow();
+            read.close();
+        }
+    }
+
+    @Test public void closesStreamAndReleasesPermissionExactlyOnce() throws Exception {
+        AtomicInteger releases = new AtomicInteger();
+        AtomicInteger closes = new AtomicInteger();
+        ClipboardImageRead read = new ClipboardImageRead(releases::incrementAndGet);
+        read.attach(new ByteArrayInputStream(new byte[]{1}) {
+            @Override public void close() { closes.incrementAndGet(); }
+        });
+        read.close();
+        read.close();
+        assertTrue(read.isClosed());
+        assertEquals(1, releases.get());
+        assertEquals(1, closes.get());
+    }
+
+    @Test public void teardownWhileProviderIsOpeningReleasesGrantAndRejectsLateStream() {
+        AtomicInteger releases = new AtomicInteger();
+        AtomicInteger closes = new AtomicInteger();
+        ClipboardImageRead read = new ClipboardImageRead(releases::incrementAndGet);
+        read.close();
+        assertEquals(1, releases.get());
+        assertThrows(IOException.class, () -> read.attach(new ByteArrayInputStream(new byte[]{1}) {
+            @Override public void close() { closes.incrementAndGet(); }
+        }));
+        assertEquals(1, closes.get());
+        assertEquals(1, releases.get());
+    }
+
+    @Test public void teardownClosesAnInFlightReadWithoutWaitingForWorkerCompletion() throws Exception {
+        AtomicInteger releases = new AtomicInteger();
+        CountDownLatch started = new CountDownLatch(1);
+        CountDownLatch closed = new CountDownLatch(1);
+        ClipboardImageRead read = new ClipboardImageRead(releases::incrementAndGet);
+        InputStream stream = read.attach(new InputStream() {
+            @Override public int read() throws IOException {
+                started.countDown();
+                try { closed.await(); }
+                catch (InterruptedException error) { throw new IOException(error); }
+                return -1;
+            }
+            @Override public void close() { closed.countDown(); }
+        });
+        var worker = Executors.newSingleThreadExecutor();
+        try {
+            var result = worker.submit(() -> stream.read());
+            assertTrue(started.await(2, TimeUnit.SECONDS));
+            read.close();
+            assertEquals(1, releases.get());
+            assertEquals(Integer.valueOf(-1), result.get(2, TimeUnit.SECONDS));
+        } finally {
+            read.close();
+            worker.shutdownNow();
+        }
+    }
+}
diff --git a/capacitor.config.ts b/capacitor.config.ts
index 8e72174..c908fd6 100644
--- a/capacitor.config.ts
+++ b/capacitor.config.ts
@@ -20,7 +20,8 @@ const config: CapacitorConfig = {
     },
     SplashScreen: {
       launchAutoHide: true,
-      launchShowDuration: 400,
+      // MainActivity owns the compat launch splash, before the theme changes.
+      launchShowDuration: 0,
       backgroundColor: '#1d2021'
     }
   }
diff --git a/docs/android-issue-validation-2026-09-11.md b/docs/android-issue-validation-2026-09-11.md
new file mode 100644
index 0000000..c717b19
--- /dev/null
+++ b/docs/android-issue-validation-2026-09-11.md
@@ -0,0 +1,119 @@
+# Android issue pass — 11 September 2026
+
+Validation snapshot for work prepared on `release/1.1.19`. No release has
+been published and no GitHub issues were closed in this pass. Existing Cloud
+responsiveness work for #52 was preserved. Desktop, website, and iOS code
+were not changed. Commit/push was approved on 11 September; native verification
+remains pending. Status comments were posted on all eight open issues.
+
+## Issue-by-issue status
+
+| Issue | Change / finding | Verification still needed |
+| --- | --- | --- |
+| [#45](https://github.com/ZenNotes/zennotesandroid/issues/45) | Investigated the Google Play installer prompt. No source licensing check, `CHECK_LICENSE` permission, or Pairip/licensing strings found in the downloaded 1.1.15 and 1.1.18 universal APKs (all DEX files searched). This does **not** identify the cause or prove absence of protection. | Reproduce using the exact affected APK/install path; compare fresh and upgraded sideload installs; inspect Play Console automatic-protection settings. No settings were changed. |
+| [#48](https://github.com/ZenNotes/zennotesandroid/issues/48) | Give the Cloud footer a 44px row and lift the floating navigation, menu, and hint above it. The old footer selector stopped matching after upstream responsive-padding changes. | Native portrait/landscape check with Connect, Retry, and Review actions. |
+| [#49](https://github.com/ZenNotes/zennotesandroid/issues/49) | Make body/root/editor surfaces opaque and theme-colored instead of exposing the WebView backing color during compositing. **Mitigation, not a reproduced root-cause fix.** | Reproduce native selection-handle flicker on affected Android/WebView versions and verify this change actually stops it. |
+| [#50](https://github.com/ZenNotes/zennotesandroid/issues/50) | Navigate a wikilink only after a short completed tap. Reject drags, scrolling, long presses, existing/extended selection, cancellation, and multitouch; block delayed compatibility mouse events. | Native tap, scroll, long-press, and selection-handle tests, including a link whose rendered DOM disappears on touch. |
+| [#51](https://github.com/ZenNotes/zennotesandroid/issues/51) | Measure the docked selection toolbar and reserve real space in the flex editor, shrinking its scroller. Scroll-content padding alone allowed handles/text under the overlay. | Actual IME open/close, native selection extension near the bottom, landscape, rotation, and in-note search. |
+| [#53](https://github.com/ZenNotes/zennotesandroid/issues/53) | Replace the decorative pill with a 44px drag handle on all mobile sheets. Downward drag/swipe dismisses; short/cancelled gestures snap back. Keyboard/assistive activation closes the sheet. Content scrolling remains native. | Native drag, cancellation, list scrolling, nested Vaults/New Vault sheets, and TalkBack. |
+| [#54](https://github.com/ZenNotes/zennotesandroid/issues/54) | Add Android IME rich-content support to a Capacitor WebView subclass. Accept explicit keyboard image pastes only in an editable note, save through the existing vault asset path, and insert a wikilink. | Real Gboard clipboard PNG/JPEG/GIF/WebP, failed/revoked URI permissions, repeated paste, switching notes/vaults during paste, and Cloud delivery to another client. |
+| [#55](https://github.com/ZenNotes/zennotesandroid/issues/55) | Install AndroidX splash handling before Capacitor changes the launch theme; use the same square bitmap inside a square padded canvas on all versions. Disable the duplicate plugin launch splash. | Cold/warm launches on pre-12 and 12+ Android, portrait and landscape; verify icon proportions, no clipping, no double splash. |
+
+## Automated checks
+
+- `npm test`: 121 tests passed, including the existing Cloud suite.
+- `tsc --noEmit`: passed.
+- `npm run build`: passed; existing upstream JSXGraph direct-eval warning remains.
+- `npx cap sync android`: passed.
+- Gradle `:app:testDebugUnitTest :app:assembleDebug`: passed (9 Java tests).
+- `npm audit --omit=dev`: zero reported vulnerabilities.
+- `git diff --check`: passed.
+
+New regression tests were run failing before their corresponding changes,
+then passing. CSS/XML tests check contracts, not visual or device behavior.
+Java tests check bounded reads and signatures, not an actual IME session.
+They also check cancellation cleanup with late-opening and in-flight fake
+streams; native provider behavior still requires device verification.
+Sheet tests invoke the real component handlers with fake pointer events;
+they are not physical touch-device tests.
+
+A second-pass review caught WebP images receiving a JPEG filename in the
+self-hosted `RemoteVault` paste path. It now uses the shared filename helper;
+regressions through the real vault implementation cover WebP, safe suggested
+names, asset events/embeds, and existing PNG/JPEG/GIF behavior. This is distinct
+from the regular ZenNotes Cloud path, which uses `MobileVault`.
+
+Review also caught an in-flight URI grant missing from activity teardown.
+`ClipboardImageRead` now retains that grant until completion or cancellation,
+releases it exactly once, closes the tracked stream on teardown, and rejects
+and closes a stream returned by the provider after cancellation. Provider
+opening uses `openAssetFileDescriptor` with a `CancellationSignal`; teardown
+signals cancellation as well as releasing the grant. A misbehaving provider
+may still take time to return. Response dispatch and cancellation share one
+lock, so a closed read cannot subsequently dispatch a result into the bridge.
+Tests cover cancelled responses and teardown racing with dispatch.
+
+Play Console was checked read-only in the current browser account, but it
+only offered developer-account signup, not access to the app's settings.
+No account or protection settings were changed. This leaves #45 unresolved.
+
+## Browser fixture
+
+Run `npm run dev`, then open `/tooling/android-ui-check.html`. The fixture
+uses real CodeMirror, the shared selection toolbar, and the new sheet handle,
+but no native filesystem or account. It is not a replacement for an installed
+Android app test.
+
+Verified in Chromium:
+
+- 390×650 and 320×640: Cloud footer is 44px; floating button is above it.
+- Selection toolbar at 390×650: scroller ends at 474px, toolbar starts at 482px.
+- Simulated keyboard-reduced 390×380 viewport: scroller ends at 204px,
+  toolbar starts at 212px.
+- Close-handle keyboard activation dismisses the sheet.
+- Theme toggle gives body, root, and editor the same opaque background.
+- No app-origin errors observed; unrelated extension warnings were present.
+
+No Android emulator or iOS simulator was started in this pass, following the
+earlier CPU-load concern. Permission to run one Android emulator was requested
+but not yet received. The newly built APK has not been installed or launched.
+
+## Native image-paste constraints
+
+This is keyboard **Commit Content**, not background clipboard polling. It uses
+temporary `content://` permission grants, short-lived opaque tokens, bounded
+reads on a dedicated worker, and signature checks for PNG/JPEG/GIF/WebP. No
+new storage permission, service, dependency, or Cloud quota change is needed.
+Pasted image input is limited to 10 MiB to bound bridge/memory cost; larger
+files can still use the existing Attach flow, subject to normal Cloud limits.
+
+The note, vault, editor, document and selection must still match after loading
+the image. If they change, insertion is cancelled rather than writing into a
+different note. If an asset was already saved when the note changed, the user
+is told to insert it from the vault assets. URI permissions expire if JavaScript
+does not consume the paste, and are released on completion/failure/destruction.
+
+## Sources for platform decisions
+
+- [Android image keyboard / Commit Content API](https://developer.android.com/develop/ui/views/touch-and-input/image-keyboard)
+- [Android cancellable content-provider file access](https://developer.android.com/reference/android/content/ContentResolver#openAssetFileDescriptor(android.net.Uri,%20java.lang.String,%20android.os.CancellationSignal))
+- [Android splash-screen migration](https://developer.android.com/develop/ui/views/launch/splash-screen/migrate)
+- [Google Play installer-check guidance](https://support.google.com/googleplay/android-developer/answer/15621622?hl=en)
+
+## Release gate
+
+Do not mark these as shipped or close the issues solely from passing unit
+tests. Complete native checks and normal release review/CI. Commit/push has
+been approved, but release publication has not. Keep #45 open until the installer problem is reproduced and
+resolved, and #49 open until the reported flicker is actually verified fixed.
+The branch name is `release/1.1.19`, but version metadata is still 1.1.18 / code
+20; perform the normal version bump before building the release artifact.
+
+## Workflow skills used
+
+Issue resolution, systematic debugging, test-driven development, incremental
+implementation, Git workflow, modern web guidance, frontend UI engineering,
+browser testing, security hardening, code review, and documentation/ADRs guided
+the work. In particular, they kept native verification distinct from browser
+and unit checks, required regression coverage, and prompted the second-pass
+review. Commit/push was approved; native-device execution still needs approval.
diff --git a/docs/releases/v1.1.19/PLAY_STORE_DESCRIPTION.txt b/docs/releases/v1.1.19/PLAY_STORE_DESCRIPTION.txt
new file mode 100644
index 0000000..3f1c05c
--- /dev/null
+++ b/docs/releases/v1.1.19/PLAY_STORE_DESCRIPTION.txt
@@ -0,0 +1,46 @@
+ZenNotes is a local-first markdown notes app for writing, organizing, and connecting ideas without giving up ownership of your files.
+
+YOUR NOTES, YOUR FILES
+
+Every note is a plain .md file in a vault you control. Start with private on-device storage or choose any folder through Android's system folder picker. On-device and folder vaults work without an account.
+
+ZENNOTES CLOUD
+
+Connect an optional ZenNotes Cloud plan to:
+• Sync a vault across ZenNotes desktop, Android, and iPhone
+• Sync notes and attachments
+• Create manual and automatic daily backups
+• Restore a full vault or a single note from a backup
+• Publish notes to the web and manage their public links
+
+Cloud never replaces the free local-first workflow. Use it only when you want hosted sync, backup, or publishing.
+
+WRITE IN MARKDOWN
+
+Use a focused editor with headings, lists, tasks, tables, code, links, wikilinks, tags, callouts, footnotes, and frontmatter. A mobile formatting bar keeps common actions close to the keyboard.
+
+RICH, OFFLINE PREVIEW
+
+Render KaTeX math, Mermaid diagrams, JSXGraph, function plots, tables, callouts, and more directly on your device.
+
+ORGANIZE YOUR WAY
+
+Browse folders and tags, search the full vault, manage tasks, create periodic notes, and work with table databases stored as CSV.
+
+CAPTURE QUICKLY
+
+Create a quick note from the app or send text and links to ZenNotes from Android's share sheet.
+
+HOME SCREEN WIDGETS
+
+Start a note, open a recent one, or check today's tasks without opening the app. The widgets wear your theme and stay current as you write.
+
+ANDROID STORAGE, DONE RIGHT
+
+The default vault needs no storage permission. The folder option uses Android's Storage Access Framework and a scoped grant to the folder you choose. ZenNotes does not request all-files access.
+
+PRIVACY BY DEFAULT
+
+ZenNotes has no advertising or tracking. Local notes stay in the storage you choose. When you enable ZenNotes Cloud, the account identity, connected-device information, and vault content needed for the Cloud features you use are sent to the ZenNotes service. Payment details are handled by Stripe.
+
+ZenNotes is open source. Your vault remains useful outside the app because it is made of ordinary files.
diff --git a/docs/releases/v1.1.19/PLAY_STORE_METADATA.md b/docs/releases/v1.1.19/PLAY_STORE_METADATA.md
new file mode 100644
index 0000000..1a33aaa
--- /dev/null
+++ b/docs/releases/v1.1.19/PLAY_STORE_METADATA.md
@@ -0,0 +1,47 @@
+# Play Console metadata: ZenNotes 1.1.19
+
+Prepared 2026-09-11 for the 21 (1.1.19) production release.
+
+| Field | Value | Limit |
+| --- | --- | --- |
+| App name | ZenNotes: Markdown Notes | 30 |
+| Short description | see `SHORT_DESCRIPTION.txt` (unchanged) | 80 |
+| Full description | see `PLAY_STORE_DESCRIPTION.txt` (unchanged) | 4000 |
+| Release notes | see `WHATS_NEW.md` | 500 |
+| Promotional copy | see `PROMOTIONAL_TEXT.txt` | 170 |
+| Category | Productivity | n/a |
+| Application ID | md.zennotes | n/a |
+| Target version | 1.1.19, versionCode 21 | n/a |
+| Contact email | adib@lumarylabs.com | n/a |
+| Website | https://zennotes.org | n/a |
+| Privacy policy URL | https://zennotes.org/privacy | n/a |
+| Ads | Contains no ads | n/a |
+| Price | Existing listing unchanged | n/a |
+
+## Data safety
+
+No changes. The sync scan cache stores file paths, timestamps, sizes,
+hashes, and media metadata in app-private storage, not additional copies
+of note bodies. Keyboard image paste reads the image the keyboard hands
+over through a temporary URI grant and saves it into the vault like any
+other attachment. Existing optional Cloud data flows are unchanged. No
+new permissions, analytics, or third-party SDKs.
+
+## Release checks
+
+- Branch `release/1.1.19`, based on main `6759cb2`. Source pin unchanged
+  from main: `431907dfb63a59192ff414839673446564ee737e` (app core 2.47.0).
+- versionName, bridge `appVersion`, package.json, and the lockfile root
+  all read 1.1.19; versionCode 21 (Play Console showed 20 as the latest
+  production release before this one).
+- Release build at the pin: typecheck clean, 121/121 Node tests, 9 Java
+  tests, `bundleRelease` signed with the upload key, merged manifest
+  versionCode 21 / 1.1.19, AAB sha256
+  `cc93676c880a9e2b0e6f825b06a9e16299ed14b7d26283fdbed2b5a300423bfe`.
+- Pixel 7 API 35 emulator: debug build of the same tree installs and
+  launches, opens the ⊕ menu and the More sheet, and dismisses the sheet on a handle drag, with no crash in logcat. Browser fixture checks are in
+  `docs/android-issue-validation-2026-09-11.md`.
+- Not verified on hardware: typing during a live Cloud sync, Gboard image
+  paste, and the selection-handle flicker (#49).
+- After Play publishes, the GitHub release uses Play's signed universal
+  APK (app-key cert 9a8484df…), never a locally signed upload-key APK.
diff --git a/docs/releases/v1.1.19/PLAY_STORE_REVIEW_NOTES.md b/docs/releases/v1.1.19/PLAY_STORE_REVIEW_NOTES.md
new file mode 100644
index 0000000..8331b88
--- /dev/null
+++ b/docs/releases/v1.1.19/PLAY_STORE_REVIEW_NOTES.md
@@ -0,0 +1,40 @@
+# Play review and Data safety notes: ZenNotes 1.1.19
+
+## What changed
+
+- Cloud sync skips repeat reads for unchanged, acknowledged files, skips
+  a view refresh when nothing changed, batches incoming changes into one
+  refresh, and decodes large attachments in chunks.
+- Images offered by the keyboard (Gboard stickers, GIFs, a copied
+  screenshot) can be pasted into the note being edited; they are saved as
+  vault attachments. Android's keyboard Commit Content API with temporary
+  URI grants; no clipboard polling and no new permission.
+- Touch fixes in the editor: sheets dismiss by dragging their handle,
+  wikilinks open only on a completed tap, the selection toolbar and the
+  Cloud footer no longer cover content, and a single launch splash shows
+  a square icon on every Android version.
+- Comment replies made on the phone keep thread structure and authors.
+- App core 2.47.0.
+
+No native permission, manifest-permission, billing, or account-access
+changes.
+
+## Reviewer steps
+
+1. Open the app. A welcome note opens in reading mode; tap the pencil to
+   edit. No account is needed.
+2. With a keyboard that offers images (Gboard), pick a sticker or GIF
+   while editing: it is saved into the vault and embedded in the note.
+3. Tap the ⊕ button, then drag the handle at the top of the sheet down to
+   dismiss it.
+4. Select text and extend the selection with the handles: the toolbar
+   stays below the text.
+5. To exercise Cloud-specific behaviour, use the Cloud-enabled review
+   account provided through the approved review channel, link a
+   disposable test vault, and keep typing while syncs run.
+
+## Data safety
+
+Existing disclosures are unchanged. Cache metadata stays in app-private
+storage. Cloud remains optional; on-device and folder vaults keep their
+account-free behaviour and storage permissions.
diff --git a/docs/releases/v1.1.19/PROMOTIONAL_TEXT.txt b/docs/releases/v1.1.19/PROMOTIONAL_TEXT.txt
new file mode 100644
index 0000000..f631627
--- /dev/null
+++ b/docs/releases/v1.1.19/PROMOTIONAL_TEXT.txt
@@ -0,0 +1 @@
+Cloud sync with less repeat work, images pasted straight from the keyboard, sheets you can swipe away, and an editor that stays out of your way while you select text.
diff --git a/docs/releases/v1.1.19/RELEASE_NOTES.md b/docs/releases/v1.1.19/RELEASE_NOTES.md
new file mode 100644
index 0000000..225761b
--- /dev/null
+++ b/docs/releases/v1.1.19/RELEASE_NOTES.md
@@ -0,0 +1,114 @@
+# ZenNotes for Android 1.1.19: lighter sync, better touch
+
+Cloud sync stops redoing work it has already done, the editor handles
+touch more carefully, images paste straight from the keyboard, and the
+launch splash is the same on every Android version. Eight tracker
+reports (#48 to #55) plus the comment-sidecar fix; the app core moves to
+2.47.0 (pin `431907df`).
+
+## What changes on the phone
+
+- **Cloud sync does less repeat work (#52).** Once Cloud has
+  acknowledged a file, later scans reuse its fingerprint instead of
+  rereading and hashing the whole file; changed and unacknowledged files
+  are still read. A sync that changes nothing leaves the vault's views
+  alone, and incoming changes refresh the views once as a batch rather
+  than once per note. Large attachments are decoded in chunks with pauses
+  for the UI, and binary uploads reuse their base64 data instead of
+  encoding the same bytes twice. Conflict review still reads the real
+  file, including when the conflicting file was moved or already
+  acknowledged.
+- **Paste images from the keyboard (#54).** Gboard and other keyboards
+  that offer stickers, GIFs, or a copied screenshot can paste them
+  straight into the note you are editing. The image is saved through the
+  vault's normal asset path and embedded with a wikilink. PNG, JPEG, GIF,
+  and WebP up to 10 MiB; larger files still go through Attach. The paste
+  is accepted only inside an editable note, and if you switch note or
+  vault before the image arrives, nothing is written into the wrong
+  place.
+- **Sheets drag (#53).** The pill at the top of every mobile sheet is a
+  real 44 px handle: drag or swipe down to dismiss, short or cancelled
+  drags snap back, and keyboard or TalkBack activation closes the sheet.
+- **Wikilinks want a clean tap (#50).** A link opens only after a short
+  completed tap. Scrolling across a link, dragging a selection handle
+  over it, long-pressing it, or a second finger no longer navigates.
+- **Selection toolbar keeps off the text (#51).** With the keyboard open,
+  the docked selection toolbar takes real space in the editor layout, so
+  the scroller shrinks and handles and text stay visible above it.
+- **Cloud footer and floating buttons (#48).** The Cloud footer gets a
+  44 px row of its own and the floating navigation button, menu, and
+  hint sit above it, so Connect, Retry, and Review are tappable.
+- **Opaque editor surfaces (#49).** Body, root, and editor paint their
+  theme colour instead of exposing the WebView's backing colour during
+  compositing. A mitigation for the reported flicker while extending a
+  selection, not a reproduced root-cause fix.
+- **One splash, same icon everywhere (#55).** The AndroidX splash is
+  installed before Capacitor switches the theme, the icon sits on a
+  square padded canvas on every Android version, and the duplicate
+  plugin splash is off.
+- **Comment threads survive a phone edit.** A reply, resolve, or delete
+  on the phone no longer flattens every thread and drops the authors the
+  desktop or an assistant wrote into the sidecar; the shell reads and
+  writes comments through the shared normalizer, as desktop does. Landed
+  on main after 1.1.18 shipped (#61), so this is its first Play release.
+
+## Also in this update: app core 2.47
+
+- A wikilink that points at a file in the vault opens the file instead
+  of offering to create a missing note.
+- Switching Excalidraw drawings no longer overwrites the one you opened.
+- Cloud sync resumes when conflicted files already match, and local
+  tasks stay visible while Cloud conflicts wait.
+- Lockfile bumps for the smol-toml and hono advisories.
+
+## Under the hood
+
+- `src/bridge/cloud-sync-repository.ts` ports and hardens the iOS scan
+  cache: unknown timestamps, missing cache entries, and unacknowledged
+  content fall back to a full read, and a file changed during a read does
+  not seed a reusable entry. `cloud-sync-work.ts` yields to the UI with a
+  timer fallback for older WebViews; `cloud-sync-refresh.ts` tracks writes
+  and scan changes, including partial failed pulls, and keeps a failed
+  refresh for the next attempt. `MobileVault.rescan()` emits one resync
+  event under the app core's existing unsaved-edit protection. The cache
+  relies on the storage provider updating a file's modification time or
+  size; a same-size write that preserves both is not detected.
+- Image paste is Android's keyboard Commit Content API on a Capacitor
+  WebView subclass (`ImagePasteWebView`, `ImagePastePlugin`), not
+  clipboard polling: temporary `content://` grants, short-lived opaque
+  tokens, bounded reads on a worker thread with a `CancellationSignal`,
+  and PNG/JPEG/GIF/WebP signature checks. Grants are released exactly
+  once on completion, failure, or teardown. WebP keeps its filename in
+  the self-hosted `RemoteVault` path too.
+- `SheetHandle.tsx`, `wikilink-touch.ts`, and
+  `selection-toolbar-space.ts` carry the touch changes, each with
+  regression tests; `tooling/android-ui-check.html` is a browser fixture
+  for the layout contracts.
+- Splash: `MainActivity` installs the compat splash before Capacitor's
+  `onCreate`, `zn_splash_icon.xml` wraps the launcher bitmap in a square
+  inset, and `capacitor.config.ts` turns the plugin's launch splash off.
+- Pinned to upstream `431907df`: app core 2.47.0 plus the smol-toml and
+  hono lockfile fix. No desktop or backend changes ride along.
+
+No new permissions, services, or data collection. On-device and folder
+vaults continue to work without an account; self-hosted and ZenNotes
+Cloud vaults remain optional. The sync work pairs with ZenNotes for iOS
+1.9.9.
+
+## Validation (2026-09-11)
+
+- Release build at the pin: `npm run typecheck` clean, `npm test`
+  121/121, Gradle `testDebugUnitTest` (9 Java tests) and `bundleRelease`
+  signed with the upload key; merged manifest versionCode 21 / 1.1.19;
+  AAB sha256
+  `cc93676c880a9e2b0e6f825b06a9e16299ed14b7d26283fdbed2b5a300423bfe`.
+- Browser fixture at 390×650, 320×640, and a keyboard-reduced 390×380:
+  Cloud footer 44 px with the floating button above it; selection toolbar
+  starts below the scroller; handle keyboard activation dismisses the
+  sheet; body, root, and editor share one opaque background (details in
+  `docs/android-issue-validation-2026-09-11.md`).
+- Pixel 7 API 35 emulator: the debug build of the same tree installs as
+  versionCode 21, launches to the welcome note with the floating button
+  sitting above the Cloud footer, opens the ⊕ menu and the More sheet, dismisses the sheet on a downward drag of its handle (#53), and logcat shows no crash.
+- Not verified on hardware: typing while a real Cloud sync runs, Gboard
+  image paste on a device, and the selection-handle flicker (#49).
diff --git a/docs/releases/v1.1.19/SHORT_DESCRIPTION.txt b/docs/releases/v1.1.19/SHORT_DESCRIPTION.txt
new file mode 100644
index 0000000..91adbf0
--- /dev/null
+++ b/docs/releases/v1.1.19/SHORT_DESCRIPTION.txt
@@ -0,0 +1 @@
+Local-first markdown notes with optional sync, backups, and publishing.
diff --git a/docs/releases/v1.1.19/SOCIAL.md b/docs/releases/v1.1.19/SOCIAL.md
new file mode 100644
index 0000000..4550a85
--- /dev/null
+++ b/docs/releases/v1.1.19/SOCIAL.md
@@ -0,0 +1,27 @@
+# Social copy: ZenNotes Android 1.1.19
+
+## Short
+
+ZenNotes for Android 1.1.19: Cloud sync skips work it already did,
+images paste straight from your keyboard, sheets swipe away, and
+wikilinks stop firing while you scroll. App core 2.47 rides along.
+
+## Long
+
+This update is about the editor staying out of your way. Cloud sync no
+longer rereads notes and attachments it has already acknowledged, leaves
+the views alone when nothing changed, and refreshes once for a batch of
+incoming changes. Gboard and other keyboards can paste an image straight
+into the note you are editing. Every sheet's handle drags and swipes
+down to dismiss. Wikilinks open on a clean tap only, the selection
+toolbar and the Cloud footer keep off the content beneath them, and the
+launch splash shows the same square icon on every Android version.
+
+App core 2.47 comes with it: a wikilink to a file in the vault opens the
+file, switching Excalidraw drawings no longer overwrites the one you
+opened, sync resumes when conflicted files already match, and local
+tasks stay visible while Cloud conflicts wait. Comment replies made on
+the phone now keep every thread and author intact.
+
+No new permissions. Local and folder vaults still work without an
+account. The sync work pairs with ZenNotes for iOS 1.9.9.
diff --git a/docs/releases/v1.1.19/WHATS_NEW.md b/docs/releases/v1.1.19/WHATS_NEW.md
new file mode 100644
index 0000000..3ffe40a
--- /dev/null
+++ b/docs/releases/v1.1.19/WHATS_NEW.md
@@ -0,0 +1,11 @@
+Cloud sync does less repeat work, editor touch fixes, app core 2.47.
+
+• Sync skips rereading unchanged notes; incoming changes refresh once
+• Paste images from your keyboard into a note
+• Swipe down on a sheet's handle to dismiss it
+• Wikilinks open on a clean tap, not while scrolling or selecting
+• Selection toolbar and Cloud footer stay off the content under them
+• One launch splash, square icon everywhere
+• Comment replies keep every thread and author
+
+No new permissions.
diff --git a/docs/releases/v1.1.19/twitter-post.md b/docs/releases/v1.1.19/twitter-post.md
new file mode 100644
index 0000000..1180bf2
--- /dev/null
+++ b/docs/releases/v1.1.19/twitter-post.md
@@ -0,0 +1 @@
+ZenNotes for Android 1.1.19 is out: Cloud sync skips work it already did, images paste straight from your keyboard, sheets swipe away, and wikilinks stop firing while you scroll. App core 2.47 rides along. No new permissions.
diff --git a/package-lock.json b/package-lock.json
index 379096e..534ba41 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "zennotes-android",
-  "version": "1.1.18",
+  "version": "1.1.19",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "zennotes-android",
-      "version": "1.1.18",
+      "version": "1.1.19",
       "dependencies": {
         "@aparajita/capacitor-secure-storage": "^8.0.0",
         "@capacitor/android": "^8.5.1",
diff --git a/package.json b/package.json
index b787e9f..7f0697a 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "zennotes-android",
   "private": true,
-  "version": "1.1.18",
+  "version": "1.1.19",
   "type": "module",
   "description": "ZenNotes for Android — Capacitor shell over the ZenNotes app core",
   "homepage": "https://zennotes.org",
diff --git a/src/bridge/cloud-sync-refresh.test.ts b/src/bridge/cloud-sync-refresh.test.ts
new file mode 100644
index 0000000..196ec0d
--- /dev/null
+++ b/src/bridge/cloud-sync-refresh.test.ts
@@ -0,0 +1,60 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { trackCloudSyncChanges } from './cloud-sync-refresh.ts'
+
+describe('cloud sync refresh', () => {
+  it('retains a failed refresh for the next host operation', async () => {
+    const state = { changed: false }
+    const fs = { readdir: async () => [], stat: async () => null, readBase64: async () => '',
+      writeText: async () => {}, writeBase64: async () => {}, deleteFile: async () => {}, rename: async () => {} }
+    const first = trackCloudSyncChanges(fs, async () => { throw new Error('unavailable') }, state)
+    first.markChanged()
+    await assert.rejects(first.refresh(), /unavailable/)
+    let refreshes = 0
+    const next = trackCloudSyncChanges(fs, async () => { refreshes++ }, state)
+    await next.refresh()
+    await next.refresh()
+    assert.equal(refreshes, 1)
+  })
+  function fixture(failWrite = false) {
+    let refreshes = 0
+    const changes = trackCloudSyncChanges({
+      readdir: async () => [], stat: async () => null, readBase64: async () => '',
+      writeText: async () => { if (failWrite) throw new Error('disk full') },
+      writeBase64: async () => {}, deleteFile: async () => {}, rename: async () => {}
+    }, async () => { refreshes++ })
+    return { changes, count: () => refreshes }
+  }
+
+  it('does not refresh the editor after a read-only / no-op sync', async () => {
+    const { changes, count } = fixture()
+    await changes.fs.readdir('')
+    await changes.fs.readBase64('note.md')
+    await changes.refresh()
+    assert.equal(count(), 0)
+  })
+
+  it('refreshes once for a batch of pulled notes, assets, moves and deletions', async () => {
+    const { changes, count } = fixture()
+    await changes.fs.writeText('note.md', 'new content')
+    await changes.fs.writeBase64('image.png', 'AA==')
+    await changes.fs.rename('note.md', 'renamed.md')
+    await changes.fs.deleteFile('old.md')
+    await changes.refresh()
+    assert.equal(count(), 1)
+  })
+
+  it('still refreshes partial filesystem changes when a sync fails', async () => {
+    const { changes, count } = fixture(true)
+    await assert.rejects(changes.fs.writeText('note.md', 'partial'), /disk full/)
+    await changes.refresh()
+    assert.equal(count(), 1)
+  })
+
+  it('refreshes externally changed files found during scanning without a pull', async () => {
+    const { changes, count } = fixture()
+    changes.markChanged()
+    await changes.refresh()
+    assert.equal(count(), 1)
+  })
+})
diff --git a/src/bridge/cloud-sync-refresh.ts b/src/bridge/cloud-sync-refresh.ts
new file mode 100644
index 0000000..34f5ba7
--- /dev/null
+++ b/src/bridge/cloud-sync-refresh.ts
@@ -0,0 +1,30 @@
+import type { PortableCloudSyncFileSystem } from '@zennotes/shared-domain/cloud-sync-portable-filesystem'
+
+/** One host operation owns this tracker. Mark before writes: a native write
+ * can change the disk before rejecting. A no-op sync must not rebuild every
+ * editor surface, but partial failed pulls still need to become visible. */
+export function trackCloudSyncChanges(
+  fs: PortableCloudSyncFileSystem,
+  refresh: () => Promise<void>,
+  state = { changed: false }
+) {
+  const markChanged = () => { state.changed = true }
+  return {
+    markChanged,
+    fs: {
+      ...fs,
+      writeText: async (path: string, value: string) => { markChanged(); await fs.writeText(path, value) },
+      writeBase64: async (path: string, value: string) => { markChanged(); await fs.writeBase64(path, value) },
+      deleteFile: async (path: string) => { markChanged(); await fs.deleteFile(path) },
+      rename: async (from: string, to: string) => { markChanged(); await fs.rename(from, to) }
+    },
+    async refresh() {
+      if (!state.changed) return
+      state.changed = false
+      try { await refresh() } catch (error) {
+        state.changed = true
+        throw error
+      }
+    }
+  }
+}
diff --git a/src/bridge/cloud-sync-repository.test.ts b/src/bridge/cloud-sync-repository.test.ts
new file mode 100644
index 0000000..292c82e
--- /dev/null
+++ b/src/bridge/cloud-sync-repository.test.ts
@@ -0,0 +1,317 @@
+import assert from 'node:assert/strict'
+import { createHash } from 'node:crypto'
+import { describe, it } from 'node:test'
+import type { CloudSyncContent, CloudSyncMutation } from '@zennotes/bridge-contract/cloud-sync'
+import type {
+  CloudSyncLocalItem, CloudSyncState, CloudSyncStoredConflict
+} from '@zennotes/shared-domain/cloud-sync-engine'
+import type { CloudSyncRepository } from '@zennotes/shared-domain/cloud-sync-coordinator'
+
+import { loadMobileModule } from '../../tooling/load-mobile-module.ts'
+
+const { CachedCloudSyncRepository } = await loadMobileModule('./src/bridge/cloud-sync-repository')
+const { CloudSyncCoordinator } = await loadMobileModule('@zennotes/shared-domain/cloud-sync-coordinator')
+
+type StoredFile = { bytes: Buffer; mtime: number }
+function harness(initial: Record<string, string | Buffer> = { 'note.md': 'Hello' }) {
+  const files = new Map<string, StoredFile>(
+    Object.entries(initial).map(([path, body]) => [path, { bytes: Buffer.from(body), mtime: 1000 }])
+  )
+  let cache: unknown = null
+  let state: CloudSyncState | null = null
+  let clock = 1000
+  const reads: string[] = []
+  const failures = { cacheRead: false, cacheWrite: false, stateRead: false, directory: false, file: false }
+  let onRead: ((path: string) => void) | undefined
+  const put = (path: string, body: string | Buffer) => {
+    files.set(path, { bytes: Buffer.from(body), mtime: ++clock })
+  }
+  const stat = async (path: string) => {
+    const file = files.get(path)
+    if (file) return { type: 'file' as const, size: file.bytes.length, mtime: file.mtime }
+    if ([...files.keys()].some((name) => name.startsWith(path + '/'))) {
+      return { type: 'directory' as const, size: 0, mtime: 1000 }
+    }
+    return null
+  }
+  const readdir = async (directory: string) => {
+    if (failures.directory) throw new Error('Directory unavailable')
+    const entries = new Map<string, { name: string; type: 'file' | 'directory'; size: number; mtime: number }>()
+    const prefix = directory ? directory + '/' : ''
+    for (const [path, file] of files) {
+      if (!path.startsWith(prefix)) continue
+      const relative = path.slice(prefix.length)
+      const [name, nested] = relative.split('/')
+      entries.set(name, {
+        name, type: nested ? 'directory' : 'file',
+        size: nested ? 0 : file.bytes.length, mtime: nested ? 1000 : file.mtime
+      })
+    }
+    return [...entries.values()]
+  }
+  const readBase64 = async (path: string) => {
+    reads.push(path)
+    if (failures.file) throw new Error('File unavailable')
+    onRead?.(path)
+    const file = files.get(path)
+    if (!file) throw new Error('File missing')
+    return file.bytes.toString('base64')
+  }
+  const fs = {
+    readdir,
+    stat: async (path: string) => (await stat(path))?.type ?? null,
+    readBase64,
+    writeText: async (path: string, data: string) => put(path, data),
+    writeBase64: async (path: string, data: string) => put(path, Buffer.from(data, 'base64')),
+    deleteFile: async (path: string) => { files.delete(path) },
+    rename: async (from: string, to: string) => {
+      const file = files.get(from)
+      if (!file) throw new Error('File missing')
+      files.set(to, file)
+      files.delete(from)
+    }
+  }
+  const native = { readdirStrict: readdir, readBase64, statOrNull: stat, stat }
+  const store = {
+    loadTracked: async () => {
+      if (failures.stateRead) throw new Error('State unavailable')
+      return state
+    },
+    loadCache: async () => {
+      if (failures.cacheRead) throw new Error('Cache unavailable')
+      return cache
+    },
+    saveCache: async (next: unknown) => {
+      if (failures.cacheWrite) throw new Error('Cache unavailable')
+      cache = structuredClone(next)
+    }
+  }
+  const repository: CloudSyncRepository = new CachedCloudSyncRepository(fs, native, store)
+  function acknowledge(items: CloudSyncLocalItem[]) {
+    state = {
+      version: 1, vault_id: 'vault-1', cursor: 1,
+      items: Object.fromEntries(items.map((item, index) => [`item-${index}`, {
+        item_id: `item-${index}`, path: item.path, kind: item.kind, revision: 1,
+        sha256: item.content.sha256, byte_length: item.content.byte_length,
+        media_type: item.content.media_type
+      }]))
+    }
+  }
+  const coordinator = () => {
+    const mutations: CloudSyncMutation[] = []
+    const remote = {
+      manifest: async () => ({ data: [], cursor: state?.cursor ?? 0, next_page: null }),
+      changes: async () => ({ data: [], cursor: state?.cursor ?? 0, has_more: false }),
+      mutate: async (_vaultId: string, body: { mutations: CloudSyncMutation[] }) => {
+        // Serialization is deliberately real: a cache placeholder must never be uploaded.
+        mutations.push(...JSON.parse(JSON.stringify(body.mutations)))
+        return {
+          acknowledged: body.mutations.map((mutation) => ({
+            operation_id: mutation.operation_id, item_id: mutation.item_id, revision: 2, sequence: 1
+          })),
+          conflicts: [], cursor: 1
+        }
+      }
+    }
+    let id = 0
+    return {
+      mutations,
+      service: new CloudSyncCoordinator('vault-1', remote, repository, {
+        load: async () => state,
+        save: async (next: CloudSyncState) => { state = structuredClone(next) }
+      }, { itemId: () => `new-${++id}`, operationId: () => `op-${++id}` })
+    }
+  }
+  return {
+    files, reads, failures, repository, acknowledge, coordinator, put,
+    setReadHook: (hook: typeof onRead) => { onRead = hook },
+    get cache() { return cache }, set cache(next: unknown) { cache = next },
+    get state() { return state }, set state(next: CloudSyncState | null) { state = next }
+  }
+}
+
+function content(text: string): CloudSyncContent {
+  return {
+    encoding: 'utf8', data: text, sha256: createHash('sha256').update(text).digest('hex'),
+    byte_length: Buffer.byteLength(text), media_type: 'text/markdown'
+  }
+}
+
+function pending(path: string, local: CloudSyncContent, cloud = content('Other device')): CloudSyncStoredConflict {
+  return {
+    id: 'conflict-1', item_id: 'item-0', kind: 'content', sequence: 2,
+    base: { path, revision: 1, kind: 'text', content: content('Base') },
+    local: { path, revision: null, kind: 'text', content: local },
+    cloud: { path, revision: 2, kind: 'text', content: cloud }
+  }
+}
+
+describe('cached mobile Cloud scan', () => {
+  it('reads and hashes new text and binary files with the same portable semantics', async () => {
+    const bytes = Buffer.from([0, 255, 1, 128])
+    const h = harness({ 'note.md': 'Hello', 'assets/photo.png': bytes, '.zennotes/cache.json': '{}' })
+    const items = await h.repository.scan()
+    assert.deepEqual(items.map((item) => item.path), ['assets/photo.png', 'note.md'])
+    assert.equal(items[0].kind, 'binary')
+    assert.equal(items[0].content.data, bytes.toString('base64'))
+    assert.equal(items[0].content.sha256, createHash('sha256').update(bytes).digest('hex'))
+    assert.deepEqual(items[1].content, content('Hello'))
+  })
+
+  it('does not reread unchanged acknowledged files on the next sync', async () => {
+    const h = harness({ 'a.md': 'A', 'b.md': 'B', 'assets/p.png': Buffer.from([0, 255]) })
+    h.acknowledge(await h.repository.scan())
+    h.reads.length = 0
+    const result = await h.coordinator().service.sync()
+    assert.deepEqual(h.reads, [])
+    assert.equal(result.pushed, 0)
+    assert.equal(result.pendingConflicts.length, 0)
+  })
+
+  it('rereads only the edited file and uploads its complete current bytes', async () => {
+    const h = harness({ 'a.md': 'A', 'b.md': 'B' })
+    h.acknowledge(await h.repository.scan())
+    h.put('a.md', 'Changed')
+    h.reads.length = 0
+    const c = h.coordinator()
+    const result = await c.service.sync()
+    assert.deepEqual(h.reads, ['a.md'])
+    assert.equal(result.pushed, 1)
+    assert.equal(c.mutations[0].type, 'upsert')
+    if (c.mutations[0].type === 'upsert') assert.equal(c.mutations[0].content.data, 'Changed')
+  })
+
+
+  it('rereads a same-size edit when its modification time changes', async () => {
+    const h = harness()
+    h.acknowledge(await h.repository.scan())
+    h.put('note.md', 'World')
+    h.reads.length = 0
+    assert.equal((await h.repository.scan())[0].content.data, 'World')
+    assert.deepEqual(h.reads, ['note.md'])
+  })
+
+  it('rereads a size change even if a provider preserves the modification time', async () => {
+    const h = harness()
+    h.acknowledge(await h.repository.scan())
+    h.files.set('note.md', { bytes: Buffer.from('Longer content'), mtime: 1000 })
+    h.reads.length = 0
+    assert.equal((await h.repository.scan())[0].content.data, 'Longer content')
+    assert.deepEqual(h.reads, ['note.md'])
+  })
+
+  it('rereads files whose scanned content has not yet been acknowledged', async () => {
+    const h = harness()
+    await h.repository.scan()
+    h.reads.length = 0
+    assert.equal((await h.repository.scan())[0].content.data, 'Hello')
+    assert.deepEqual(h.reads, ['note.md'])
+  })
+
+  it('rereads an unacknowledged edit even when its fingerprint is cached', async () => {
+    const h = harness()
+    h.acknowledge(await h.repository.scan())
+    h.put('note.md', 'Local edit')
+    await h.repository.scan()
+    h.reads.length = 0
+    assert.equal((await h.repository.scan())[0].content.data, 'Local edit')
+    assert.deepEqual(h.reads, ['note.md'])
+  })
+
+  it('keeps rename and deletion semantics intact without uploading cached bytes', async () => {
+    const h = harness({ 'a.md': 'A', 'b.md': 'B' })
+    h.acknowledge(await h.repository.scan())
+    h.files.set('renamed.md', h.files.get('a.md')!)
+    h.files.delete('a.md')
+    h.files.delete('b.md')
+    const c = h.coordinator()
+    await c.service.sync()
+    assert.deepEqual(c.mutations.map((mutation) => mutation.type).sort(), ['delete', 'move'])
+    assert.equal(c.mutations.find((mutation) => mutation.type === 'move')?.path, 'renamed.md')
+    assert.deepEqual(Object.keys(h.cache as object), ['renamed.md'])
+  })
+
+  for (const failure of ['cacheRead', 'stateRead', 'cacheWrite'] as const) {
+    it(`falls back safely when ${failure} fails`, async () => {
+      const h = harness()
+      h.acknowledge(await h.repository.scan())
+      h.reads.length = 0
+      h.failures[failure] = true
+      const items = await h.repository.scan()
+      assert.equal(items[0].content.sha256, content('Hello').sha256)
+      if (failure !== 'cacheWrite') assert.deepEqual(h.reads, ['note.md'])
+    })
+  }
+
+  it('rebuilds a lost or malformed cache from actual file content', async () => {
+    const h = harness()
+    h.acknowledge(await h.repository.scan())
+    for (const damaged of [null, { 'note.md': { mtime: 1000, sha256: 'not-an-entry' } }]) {
+      h.cache = damaged
+      h.reads.length = 0
+      assert.equal((await h.repository.scan())[0].content.data, 'Hello')
+      assert.deepEqual(h.reads, ['note.md'])
+    }
+  })
+
+  for (const mtime of [0, -1, Number.NaN, Number.POSITIVE_INFINITY]) {
+    it(`does not trust unavailable or invalid modification time ${mtime}`, async () => {
+      const h = harness()
+      h.files.get('note.md')!.mtime = mtime
+      h.acknowledge(await h.repository.scan())
+      h.reads.length = 0
+      assert.equal((await h.repository.scan())[0].content.data, 'Hello')
+      assert.deepEqual(h.reads, ['note.md'])
+    })
+  }
+
+  it('does not cache a file that changes while its bytes are being read', async () => {
+    const h = harness()
+    h.setReadHook((path) => { h.put(path, 'World') })
+    h.acknowledge(await h.repository.scan())
+    h.setReadHook(undefined)
+    // Restore the old metadata as can happen with coarse timestamps: the
+    // unstable read must not leave a reusable cache entry for that fingerprint.
+    h.files.get('note.md')!.mtime = 1000
+    h.reads.length = 0
+    await h.repository.scan()
+    assert.deepEqual(h.reads, ['note.md'])
+  })
+
+  for (const failure of ['directory', 'file'] as const) {
+    it(`fails closed on a ${failure} read error, without manufacturing a deletion`, async () => {
+      const h = harness()
+      h.acknowledge(await h.repository.scan())
+      const priorCache = structuredClone(h.cache)
+      h.put('note.md', 'Unreadable new edit')
+      h.failures[failure] = true
+      const c = h.coordinator()
+      await assert.rejects(c.service.sync(), /unavailable/)
+      assert.deepEqual(c.mutations, [])
+      assert.deepEqual(h.cache, priorCache)
+    })
+  }
+})
+
+describe('cached scan with the pinned conflict coordinator', () => {
+  it('returns real bytes for review when pending local content matches acknowledged content', async () => {
+    const h = harness()
+    h.acknowledge(await h.repository.scan())
+    h.state!.pending_conflicts = { 'conflict-1': pending('note.md', content('Hello')) }
+    h.reads.length = 0
+    const details = await h.coordinator().service.getConflict('conflict-1')
+    assert.equal(details.local.text, 'Hello')
+    assert.deepEqual(h.reads, ['note.md'])
+  })
+
+  it('can locate and read a moved pending-conflict file even when its new path is acknowledged', async () => {
+    const h = harness({ 'renamed.md': 'Hello' })
+    h.acknowledge(await h.repository.scan())
+    h.state!.pending_conflicts = { 'conflict-1': pending('old.md', content('Hello')) }
+    h.reads.length = 0
+    const details = await h.coordinator().service.getConflict('conflict-1')
+    assert.equal(details.local.path, 'renamed.md')
+    assert.equal(details.local.text, 'Hello')
+    assert.deepEqual(h.reads, ['renamed.md'])
+  })
+})
diff --git a/src/bridge/cloud-sync-repository.ts b/src/bridge/cloud-sync-repository.ts
new file mode 100644
index 0000000..cf5063f
--- /dev/null
+++ b/src/bridge/cloud-sync-repository.ts
@@ -0,0 +1,297 @@
+/**
+ * PortableCloudSyncRepository with a scan cache. The upstream portable scan
+ * reads and hashes every file's full bytes across the native bridge on every
+ * sync run — a 60-second background cadence on app-core's auto-sync — which
+ * scales battery and memory cost with vault size. This subclass skips the
+ * read for files that are provably not needed:
+ *
+ *   skip ⇔ (mtime AND size unchanged since the last real read)
+ *          AND (that read's hash equals the acked sync state's hash)
+ *          AND (the file is not involved in a pending conflict)
+ *
+ * The engine (cloud-sync-engine planCloudSyncMutations) touches
+ * `content.data` only for items whose hash differs from the tracked state or
+ * that the state does not know. The host disables skipping for review and
+ * restore actions, which need real bytes even for acknowledged content.
+ * A skipped item's `data` property THROWS if unexpectedly consumed, rather
+ * than silently pushing content we never read.
+ *
+ * A lost cache or unknown timestamp causes a full read. Like other
+ * metadata-based caches, this relies on the provider updating mtime or size
+ * when content changes; same-size writes preserving mtime cannot be detected.
+ */
+import type {
+  CloudSyncContent,
+  CloudSyncItemKind
+} from '@zennotes/bridge-contract/cloud-sync'
+import {
+  cloudSyncPathKey,
+  normalizeCloudSyncPath,
+  shouldSyncVaultPath,
+  shouldTraverseCloudSyncDirectory
+} from '@zennotes/shared-domain/cloud-sync'
+import {
+  PortableCloudSyncRepository,
+  type PortableCloudSyncFileSystem
+} from '@zennotes/shared-domain/cloud-sync-portable-filesystem'
+import type { CloudSyncLocalItem, CloudSyncState } from '@zennotes/shared-domain/cloud-sync-engine'
+import type { NativeFs } from './native-fs'
+import { cloudSyncWorkBudget, decodeCloudSyncBase64 } from './cloud-sync-work'
+
+export interface ScanCacheEntry {
+  mtime: number
+  size: number
+  sha256: string
+  kind: CloudSyncItemKind
+  byte_length: number
+  media_type: string
+}
+
+export type ScanCache = Record<string, ScanCacheEntry>
+
+export interface ScanCacheStore {
+  loadTracked(): Promise<CloudSyncState | null>
+  loadCache(): Promise<unknown>
+  saveCache(cache: ScanCache): Promise<void>
+}
+
+export class CachedCloudSyncRepository extends PortableCloudSyncRepository {
+  constructor(
+    fs: PortableCloudSyncFileSystem,
+    private readonly native: Pick<NativeFs, 'readdirStrict' | 'readBase64' | 'statOrNull'>,
+    private readonly store: ScanCacheStore,
+    private readonly onChanged: () => void = () => {}
+  ) {
+    super(fs)
+  }
+
+  override async scan(): Promise<CloudSyncLocalItem[]> {
+    const trackedSha = trackedShaByPath(await this.store.loadTracked().catch(() => null))
+    const cache = normalizeScanCache(await this.store.loadCache().catch(() => null))
+    const nextCache: ScanCache = {}
+    const items: CloudSyncLocalItem[] = []
+    await this.walkCached('', trackedSha, cache, nextCache, items)
+    if (Object.keys(cache).some((path) => !nextCache[path])) this.onChanged()
+    // Cache loss is only a slow next scan — never let it fail the sync run.
+    await this.store.saveCache(nextCache).catch(() => {})
+    return items.sort((left, right) => left.path.localeCompare(right.path))
+  }
+
+  private async walkCached(
+    directory: string,
+    trackedSha: Map<string, string>,
+    cache: ScanCache,
+    nextCache: ScanCache,
+    items: CloudSyncLocalItem[]
+  ): Promise<void> {
+    // readdirStrict entries carry mtime and size, so validating the cache
+    // costs no extra stat calls on a hit. Fresh reads are checked again
+    // before their fingerprints can be reused on a later scan.
+    const entries = await this.native.readdirStrict(directory)
+    const checkpoint = cloudSyncWorkBudget()
+    for (const entry of entries) {
+      await checkpoint()
+      const relPath = directory ? `${directory}/${entry.name}` : entry.name
+      if (entry.type === 'directory') {
+        if (shouldTraverseCloudSyncDirectory(relPath)) {
+          await this.walkCached(relPath, trackedSha, cache, nextCache, items)
+        }
+        continue
+      }
+      if (!shouldSyncVaultPath(relPath)) continue
+
+      const path = normalizeCloudSyncPath(relPath)
+      const cached = cache[path]
+      if (
+        cached &&
+        cached.mtime === entry.mtime &&
+        cached.size === entry.size &&
+        trackedSha.get(cloudSyncPathKey(path)) === cached.sha256
+      ) {
+        nextCache[path] = cached
+        items.push(itemFromCache(path, cached))
+        continue
+      }
+
+      const item = await this.readItemFresh(path)
+      if (!cached || cached.mtime !== entry.mtime || cached.size !== entry.size || cached.sha256 !== item.content.sha256) {
+        this.onChanged()
+      }
+      // Never seed a reusable fingerprint from an unstable native read.
+      // Unknown provider timestamps are deliberately always cache misses.
+      const after = await this.native.statOrNull(path).catch(() => null)
+      if (validFingerprint(entry) && after?.type === 'file' &&
+          after.mtime === entry.mtime && after.size === entry.size &&
+          item.content.byte_length === entry.size) nextCache[path] = {
+        mtime: entry.mtime,
+        size: entry.size,
+        sha256: item.content.sha256,
+        kind: item.kind,
+        byte_length: item.content.byte_length,
+        media_type: item.content.media_type
+      }
+      items.push(item)
+    }
+  }
+
+  // ---------------------------------------------------------------------
+  // Preserve upstream readItem's encoding/hash semantics while yielding
+  // during large base64 decoding and avoiding a binary re-encode.
+  // ---------------------------------------------------------------------
+
+  private async readItemFresh(path: string): Promise<CloudSyncLocalItem> {
+    const { bytes, base64 } = await decodeCloudSyncBase64(await this.native.readBase64(path))
+    const text = decodeText(path, bytes)
+    return {
+      path,
+      kind: text === null ? 'binary' : 'text',
+      content: {
+        encoding: text === null ? 'base64' : 'utf8',
+        data: text === null ? base64 : text,
+        sha256: await sha256(bytes),
+        byte_length: bytes.byteLength,
+        media_type: mediaType(path, text !== null)
+      }
+    }
+  }
+}
+
+function itemFromCache(path: string, cached: ScanCacheEntry): CloudSyncLocalItem {
+  const content = {
+    encoding: cached.kind === 'text' ? 'utf8' : 'base64',
+    sha256: cached.sha256,
+    byte_length: cached.byte_length,
+    media_type: cached.media_type
+  } as CloudSyncContent
+  Object.defineProperty(content, 'data', {
+    enumerable: true,
+    get(): string {
+      throw new Error(
+        `Cloud sync tried to push ${path} from the scan cache without reading it — the engine's hash-equal items must never need content.`
+      )
+    }
+  })
+  return { path, kind: cached.kind, content }
+}
+
+function trackedShaByPath(state: CloudSyncState | null): Map<string, string> {
+  const out = new Map<string, string>()
+  if (!state || state.version !== 1 || !state.items) return out
+  for (const item of Object.values(state.items)) {
+    if (item && typeof item.path === 'string' && typeof item.sha256 === 'string') {
+      out.set(cloudSyncPathKey(item.path), item.sha256)
+    }
+  }
+  // Conflict review/resolution consumes actual bytes, even if a version is
+  // already acknowledged. Hash exclusions also cover moved local versions.
+  const paths = new Set<string>()
+  const hashes = new Set<string>()
+  for (const conflict of Object.values(state.pending_conflicts ?? {})) {
+    for (const snapshot of [conflict.base, conflict.local, conflict.cloud]) {
+      if (snapshot?.path) paths.add(cloudSyncPathKey(snapshot.path))
+      if (snapshot?.content?.sha256) hashes.add(snapshot.content.sha256)
+    }
+    for (const path of conflict.paused_paths ?? []) paths.add(cloudSyncPathKey(path))
+  }
+  for (const [path, hash] of out) {
+    if (paths.has(path) || hashes.has(hash)) out.delete(path)
+  }
+  return out
+}
+
+function validFingerprint(entry: { mtime?: number; size?: number }): boolean {
+  return typeof entry.mtime === 'number' && Number.isFinite(entry.mtime) && entry.mtime > 0 &&
+    typeof entry.size === 'number' && Number.isSafeInteger(entry.size) && entry.size >= 0
+}
+
+function normalizeScanCache(raw: unknown): ScanCache {
+  if (!raw || typeof raw !== 'object') return {}
+  const out: ScanCache = {}
+  for (const [path, value] of Object.entries(raw as Record<string, unknown>)) {
+    const entry = value as Partial<ScanCacheEntry> | null
+    if (
+      entry &&
+      validFingerprint(entry) &&
+      typeof entry.sha256 === 'string' &&
+      (entry.kind === 'text' || entry.kind === 'binary') &&
+      typeof entry.byte_length === 'number' &&
+      typeof entry.media_type === 'string'
+    ) {
+      out[path] = entry as ScanCacheEntry
+    }
+  }
+  return out
+}
+
+// Mirrored from upstream cloud-sync-portable-filesystem.ts — keep in lockstep.
+
+const TEXT_EXTENSIONS = new Set([
+  '.base',
+  '.css',
+  '.csv',
+  '.excalidraw',
+  '.htm',
+  '.html',
+  '.ini',
+  '.js',
+  '.json',
+  '.jsx',
+  '.md',
+  '.mdx',
+  '.svg',
+  '.toml',
+  '.ts',
+  '.tsx',
+  '.txt',
+  '.xml',
+  '.yaml',
+  '.yml'
+])
+
+const MEDIA_TYPES: Record<string, string> = {
+  '.css': 'text/css',
+  '.csv': 'text/csv',
+  '.gif': 'image/gif',
+  '.htm': 'text/html',
+  '.html': 'text/html',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.js': 'text/javascript',
+  '.json': 'application/json',
+  '.md': 'text/markdown',
+  '.pdf': 'application/pdf',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.toml': 'application/toml',
+  '.txt': 'text/plain',
+  '.webp': 'image/webp',
+  '.xml': 'application/xml',
+  '.yaml': 'application/yaml',
+  '.yml': 'application/yaml'
+}
+
+function decodeText(path: string, bytes: Uint8Array): string | null {
+  if (!TEXT_EXTENSIONS.has(extension(path))) return null
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(bytes)
+  } catch {
+    return null
+  }
+}
+
+function extension(path: string): string {
+  const name = path.slice(path.lastIndexOf('/') + 1)
+  const dot = name.lastIndexOf('.')
+  return dot < 0 ? '' : name.slice(dot).toLowerCase()
+}
+
+function mediaType(path: string, text: boolean): string {
+  return MEDIA_TYPES[extension(path)] ?? (text ? 'text/plain' : 'application/octet-stream')
+}
+
+async function sha256(bytes: Uint8Array<ArrayBuffer>): Promise<string> {
+  const digest = await crypto.subtle.digest('SHA-256', bytes.buffer)
+  return [...new Uint8Array(digest)]
+    .map((byte) => byte.toString(16).padStart(2, '0'))
+    .join('')
+}
diff --git a/src/bridge/cloud-sync-rescan.test.ts b/src/bridge/cloud-sync-rescan.test.ts
new file mode 100644
index 0000000..9c3fb95
--- /dev/null
+++ b/src/bridge/cloud-sync-rescan.test.ts
@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict'
+import { it } from 'node:test'
+import { loadMobileModule } from '../../tooling/load-mobile-module.ts'
+
+Object.defineProperty(globalThis, 'localStorage', { configurable: true, value: { getItem: () => null } })
+const { MobileVault, onVaultChange } = await loadMobileModule(['./src/bridge/vault-fs', './src/bridge/events'])
+
+it('batches a foreground/cloud refresh into one resync without triggering local autosync events', async () => {
+  const events: unknown[] = []
+  const unsubscribe = onVaultChange((event: unknown) => events.push(event))
+  const invalidated: string[] = []
+  const vault = {
+    settingsCache: {},
+    metaCache: new Map([
+      ['deleted.md', { meta: { updatedAt: 1 }, size: 1 }],
+      ['changed.md', { meta: { updatedAt: 1 }, size: 1 }]
+    ]),
+    listNotes: async () => [
+      { path: 'changed.md', updatedAt: 2, size: 2, folder: 'inbox' },
+      { path: 'new.md', updatedAt: 2, size: 2, folder: 'inbox' }
+    ],
+    invalidateMeta: (path: string) => invalidated.push(path),
+    folderOf: async () => 'inbox'
+  }
+  try {
+    await MobileVault.prototype.rescan.call(vault)
+    assert.deepEqual(events, [{ kind: 'change', path: '', folder: 'inbox', scope: 'resync' }])
+    assert.deepEqual(invalidated, ['deleted.md'])
+    assert.equal(vault.settingsCache, null)
+  } finally { unsubscribe() }
+})
diff --git a/src/bridge/cloud-sync-work.test.ts b/src/bridge/cloud-sync-work.test.ts
new file mode 100644
index 0000000..61a2480
--- /dev/null
+++ b/src/bridge/cloud-sync-work.test.ts
@@ -0,0 +1,41 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { decodeCloudSyncBase64, yieldToUi } from './cloud-sync-work.ts'
+
+describe('cloud sync cooperative work', () => {
+  it('decodes exact bytes, including padding, whitespace and data URLs', async () => {
+    for (const size of [0, 1, 2, 3, 49_151, 49_152, 49_153, 300_001]) {
+      const expected = Buffer.alloc(size)
+      for (let i = 0; i < size; i++) expected[i] = i % 256
+      const base64 = expected.toString('base64')
+      const result = await decodeCloudSyncBase64(`data:image/png;base64,\n${base64}\n`)
+      assert.deepEqual(Buffer.from(result.bytes), expected)
+      assert.equal(result.base64, base64)
+    }
+  })
+
+  it('lets pending input run before a large attachment finishes decoding', async () => {
+    const input = Buffer.alloc(8_100_000, 125).toString('base64')
+    let inputProcessed = false
+    const timer = setTimeout(() => { inputProcessed = true }, 0)
+    try {
+      const result = await decodeCloudSyncBase64(input)
+      assert.equal(inputProcessed, true)
+      assert.equal(result.bytes.length, 8_100_000)
+      assert.equal(result.bytes.at(-1), 125)
+    } finally {
+      clearTimeout(timer)
+    }
+  })
+
+  it('uses a real task boundary on older WebViews without scheduler.yield', async () => {
+    let inputProcessed = false
+    setTimeout(() => { inputProcessed = true }, 0)
+    await yieldToUi()
+    assert.equal(inputProcessed, true)
+  })
+
+  it('rejects malformed base64 instead of hashing damaged bytes', async () => {
+    await assert.rejects(decodeCloudSyncBase64('AA!A'))
+  })
+})
diff --git a/src/bridge/cloud-sync-work.ts b/src/bridge/cloud-sync-work.ts
new file mode 100644
index 0000000..2f47c18
--- /dev/null
+++ b/src/bridge/cloud-sync-work.ts
@@ -0,0 +1,41 @@
+/** Shared with the iOS shell. Async filesystem calls do not move the
+ * following JavaScript off the editor's thread. Give input a real turn.
+ * https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/yield
+ * The timer fallback also supports iOS 15 / older Android WebViews. */
+export function yieldToUi(): Promise<void> {
+  const scheduler = (globalThis as typeof globalThis & {
+    scheduler?: { yield?: () => Promise<void> }
+  }).scheduler
+  return scheduler?.yield ? scheduler.yield() : new Promise((resolve) => setTimeout(resolve, 0))
+}
+
+export function cloudSyncWorkBudget(): () => Promise<void> | undefined {
+  let started = performance.now()
+  return () => {
+    if (performance.now() - started < 8) return
+    return yieldToUi().then(() => { started = performance.now() })
+  }
+}
+
+/** Decode in bounded chunks instead of Uint8Array.from(string, callback),
+ * which visits every byte through an allocating JS iterator. Keep the
+ * original base64 for binary uploads rather than encoding the bytes again. */
+export async function decodeCloudSyncBase64(value: string): Promise<{
+  bytes: Uint8Array<ArrayBuffer>
+  base64: string
+}> {
+  if (value.length >= 262_144) await yieldToUi()
+  const base64 = (value.includes(',') ? value.slice(value.indexOf(',') + 1) : value).replace(/\s/g, '')
+  const padding = base64.endsWith('==') ? 2 : base64.endsWith('=') ? 1 : 0
+  const bytes = new Uint8Array(Math.max(0, Math.floor(base64.length * 3 / 4) - padding))
+  const checkpoint = cloudSyncWorkBudget()
+  let offset = 0
+  // Multiples of four keep each base64 chunk independently decodable.
+  for (let start = 0; start < base64.length; start += 65_536) {
+    const binary = atob(base64.slice(start, start + 65_536))
+    for (let i = 0; i < binary.length; i++) bytes[offset++] = binary.charCodeAt(i)
+    await checkpoint()
+  }
+  if (offset !== bytes.length) throw new Error('Invalid Cloud file encoding.')
+  return { bytes, base64 }
+}
diff --git a/src/bridge/mobile-bridge.ts b/src/bridge/mobile-bridge.ts
index 5d645f6..55dd987 100644
--- a/src/bridge/mobile-bridge.ts
+++ b/src/bridge/mobile-bridge.ts
@@ -130,7 +130,7 @@ import {
 import { folderForRelativePath, posixNormalize, sanitizeNoteTitle } from './vault-core'
 import { isPhoneViewport } from '../viewport'
 
-let appVersion = '1.1.18'
+let appVersion = '1.1.19'
 
 export async function loadNativeAppVersion(): Promise<string> {
   try {
diff --git a/src/bridge/mobile-cloud-sync.integration.test.ts b/src/bridge/mobile-cloud-sync.integration.test.ts
new file mode 100644
index 0000000..e481790
--- /dev/null
+++ b/src/bridge/mobile-cloud-sync.integration.test.ts
@@ -0,0 +1,306 @@
+import assert from 'node:assert/strict'
+import { createHash } from 'node:crypto'
+import { describe, it } from 'node:test'
+import type {
+  CloudSyncChange, CloudSyncContent, CloudSyncManifestItem, CloudSyncMutation
+} from '@zennotes/bridge-contract/cloud-sync'
+import type { CloudSyncState } from '@zennotes/shared-domain/cloud-sync-engine'
+import { loadMobileModule } from '../../tooling/load-mobile-module.ts'
+
+function textContent(text: string): CloudSyncContent {
+  return {
+    encoding: 'utf8', data: text, byte_length: Buffer.byteLength(text),
+    sha256: createHash('sha256').update(text).digest('hex'), media_type: 'text/markdown'
+  }
+}
+
+/** Real mobile adapter -> host service -> coordinator -> cached repository.
+ * Only Capacitor storage/auth/layout and the server boundary are fakes. */
+async function fixture(initial: Record<string, string> = { 'note.md': 'Original' }) {
+  const persisted = new Map<string, string>()
+  const files = new Map(Object.entries(initial).map(([path, data]) => [
+    path, { bytes: Buffer.from(data), mtime: 1000 }
+  ]))
+  const remoteItems = new Map<string, CloudSyncManifestItem>()
+  const revisions = new Map<string, CloudSyncManifestItem>()
+  const feed: CloudSyncChange[] = []
+  const reads: string[] = []
+  const refreshes: Record<string, string>[] = []
+  const uploaded: CloudSyncMutation[] = []
+  let cursor = 0
+  let clock = 1000
+  let failWritePath: string | null = null
+  let beforeChanges: (() => void) | undefined
+
+  const put = (path: string, bytes: string | Buffer) => {
+    files.set(path, { bytes: Buffer.from(bytes), mtime: ++clock })
+  }
+  function remoteText(path: string, text: string) {
+    const previous = [...remoteItems.values()].find((item) => item.path === path)
+    const itemId = previous?.item_id ?? 'remote-' + path
+    const content = textContent(text)
+    const revision = (previous?.revision ?? 0) + 1
+    const item: CloudSyncManifestItem = {
+      item_id: itemId, path, kind: 'text', revision, content,
+      sha256: content.sha256, byte_length: content.byte_length, media_type: content.media_type
+    }
+    remoteItems.set(itemId, item)
+    revisions.set(itemId + ':' + revision, structuredClone(item))
+    feed.push({
+      sequence: ++cursor, item_id: itemId, type: 'upsert', path,
+      previous_path: previous?.path ?? null, revision, content
+    })
+    return item
+  }
+  const remote = {
+    listVaults: async () => ({ data: [{ id: 'vault-1', name: 'Test vault' }] }),
+    manifest: async () => ({ data: [...remoteItems.values()], cursor, next_page: null }),
+    changes: async (_vaultId: string, after: number) => {
+      beforeChanges?.()
+      return { data: feed.filter((change) => change.sequence > after), cursor, has_more: false }
+    },
+    revision: async (_vaultId: string, itemId: string, revision: number) => {
+      const item = revisions.get(itemId + ':' + revision)
+      assert.ok(item)
+      return { data: { ...item, deleted: false } }
+    },
+    mutate: async (_vaultId: string, request: { mutations: CloudSyncMutation[] }) => {
+      uploaded.push(...JSON.parse(JSON.stringify(request.mutations)))
+      const acknowledged = request.mutations.map((mutation) => {
+        const previous = remoteItems.get(mutation.item_id)
+        const revision = (previous?.revision ?? 0) + 1
+        if (mutation.type === 'upsert') {
+          const item: CloudSyncManifestItem = {
+            item_id: mutation.item_id, path: mutation.path, kind: mutation.kind,
+            revision, content: structuredClone(mutation.content),
+            sha256: mutation.content.sha256, byte_length: mutation.content.byte_length,
+            media_type: mutation.content.media_type
+          }
+          remoteItems.set(item.item_id, item)
+          revisions.set(item.item_id + ':' + revision, structuredClone(item))
+          feed.push({
+            sequence: ++cursor, item_id: item.item_id, type: 'upsert', path: item.path,
+            previous_path: previous?.path ?? null, revision, content: item.content
+          })
+        } else {
+          assert.ok(previous)
+          if (mutation.type === 'delete') remoteItems.delete(mutation.item_id)
+          else remoteItems.set(mutation.item_id, { ...previous, path: mutation.path, revision })
+          feed.push({
+            sequence: ++cursor, item_id: mutation.item_id, type: mutation.type,
+            path: mutation.type === 'move' ? mutation.path : previous.path,
+            previous_path: previous.path, revision
+          })
+        }
+        return { operation_id: mutation.operation_id, item_id: mutation.item_id, revision, sequence: cursor }
+      })
+      return { acknowledged, conflicts: [], cursor }
+    }
+  }
+  const native = {
+    rootPath: 'ZenNotes/Test',
+    async readdirStrict(directory: string) {
+      const entries = new Map<string, { name: string; type: 'file' | 'directory'; size: number; mtime: number }>()
+      const prefix = directory ? directory + '/' : ''
+      for (const [path, file] of files) {
+        if (!path.startsWith(prefix)) continue
+        const [name, nested] = path.slice(prefix.length).split('/')
+        entries.set(name, {
+          name, type: nested ? 'directory' : 'file',
+          size: nested ? 0 : file.bytes.length, mtime: nested ? 1000 : file.mtime
+        })
+      }
+      return [...entries.values()]
+    },
+    async statOrNull(path: string) {
+      const file = files.get(path)
+      return file ? { type: 'file' as const, mtime: file.mtime, size: file.bytes.length } : null
+    },
+    async statVerified(path: string) { return files.has(path) ? 'file' : null },
+    async readBase64(path: string) {
+      reads.push(path)
+      const file = files.get(path)
+      assert.ok(file)
+      return file.bytes.toString('base64')
+    },
+    async writeText(path: string, data: string) {
+      put(path, data)
+      if (path === failWritePath) throw new Error('Native write failed after writing')
+    },
+    async writeBase64(path: string, data: string) {
+      put(path, Buffer.from(data, 'base64'))
+      if (path === failWritePath) throw new Error('Native write failed after writing')
+    },
+    async deleteFile(path: string) { files.delete(path) },
+    async mkdir(_path: string) {},
+    async rename(from: string, to: string) {
+      const file = files.get(from)
+      assert.ok(file)
+      files.set(to, file)
+      files.delete(from)
+    }
+  }
+  const vault = {
+    rootLabel: 'ZenNotes/Test', fs: native,
+    async rescan() {
+      refreshes.push(Object.fromEntries([...files].map(([path, file]) => [path, file.bytes.toString()])))
+    }
+  }
+  const api = await loadMobileModule('./src/bridge/mobile-cloud-sync', {
+    '@capacitor/filesystem': {
+      Directory: { Data: 'DATA', Cache: 'CACHE' }, Encoding: { UTF8: 'utf8' },
+      Filesystem: {
+        async readFile({ path }: { path: string }) {
+          if (!persisted.has(path)) throw Object.assign(new Error('Missing'), { code: 'OS-PLUG-FILE-0008' })
+          return { data: persisted.get(path)! }
+        },
+        async writeFile({ path, data }: { path: string; data: string }) { persisted.set(path, data) },
+        async deleteFile({ path }: { path: string }) { persisted.delete(path) }
+      }
+    },
+    '@capacitor/share': { Share: {} },
+    './vault-fs': { MobileVault: class {} },
+    './cloud-layout': { reconcileLayoutForCloudJoin: async () => {} },
+    './mobile-cloud-auth': {
+      authenticatedCredential: async () => ({ base_url: 'https://sync.example.test', token: 'test-only' }),
+      authenticatedClient: async () => remote,
+      getMobileCloudAccountStatus: async () => ({
+        state: 'connected', account: { base_url: 'https://sync.example.test' }
+      })
+    }
+  })
+  await api.linkMobileCloudVault(vault, 'vault-1')
+  const stateKey = () => [...persisted.keys()].find((path) => path.includes('/states/'))
+  return {
+    api, vault, files, reads, uploaded, refreshes, remoteText, put,
+    sync: () => api.syncMobileCloudVault(vault),
+    setFailWrite: (path: string | null) => { failWritePath = path },
+    setBeforeChanges: (callback: typeof beforeChanges) => { beforeChanges = callback },
+    clearState: () => { const key = stateKey(); if (key) persisted.delete(key) },
+    get state(): CloudSyncState {
+      const key = stateKey()
+      assert.ok(key)
+      return JSON.parse(persisted.get(key)!)
+    },
+    set state(value: CloudSyncState) {
+      const key = stateKey()
+      assert.ok(key)
+      persisted.set(key, JSON.stringify(value))
+    }
+  }
+}
+
+describe('mobile Cloud adapter wiring', () => {
+  it('does not rescan the vault or reread acknowledged bytes during a no-op sync', async () => {
+    const h = await fixture()
+    await h.sync()
+    h.refreshes.length = 0
+    h.reads.length = 0
+    const summary = await h.sync()
+    assert.equal(summary.pushed, 0)
+    assert.equal(summary.pulled, 0)
+    assert.deepEqual(h.refreshes, [])
+    assert.deepEqual(h.reads, [])
+  })
+
+  it('resynchronizes UI state once after a whole batch of pulled files', async () => {
+    const h = await fixture()
+    await h.sync()
+    h.refreshes.length = 0
+    h.remoteText('note.md', 'Remote update')
+    h.remoteText('second.md', 'Second note')
+    h.remoteText('folder/third.md', 'Third note')
+    const summary = await h.sync()
+    assert.equal(summary.pulled, 3)
+    assert.equal(h.refreshes.length, 1)
+    assert.deepEqual(h.refreshes[0], {
+      'note.md': 'Remote update', 'second.md': 'Second note', 'folder/third.md': 'Third note'
+    })
+    h.refreshes.length = 0
+    await h.sync()
+    assert.deepEqual(h.refreshes, [])
+  })
+
+  it('refreshes a newly discovered local edit even when nothing is downloaded', async () => {
+    const h = await fixture()
+    await h.sync()
+    h.refreshes.length = 0
+    h.put('note.md', 'Local changes')
+    const summary = await h.sync()
+    assert.equal(summary.pulled, 0)
+    assert.equal(summary.pushed, 1)
+    assert.deepEqual(h.refreshes, [{ 'note.md': 'Local changes' }])
+    const uploaded = h.uploaded.at(-1)
+    assert.equal(uploaded?.type, 'upsert')
+    if (uploaded?.type === 'upsert') assert.equal(uploaded.content.data, 'Local changes')
+  })
+
+  it('exposes partial native writes when a pull fails, and can retry safely', async () => {
+    const h = await fixture()
+    await h.sync()
+    h.refreshes.length = 0
+    h.remoteText('note.md', 'Remote update')
+    h.remoteText('second.md', 'Partially written')
+    h.setFailWrite('second.md')
+    await assert.rejects(h.sync(), /Native write failed/)
+    assert.deepEqual(h.refreshes, [{ 'note.md': 'Remote update', 'second.md': 'Partially written' }])
+    h.setFailWrite(null)
+    await h.sync()
+    assert.equal(h.files.get('note.md')?.bytes.toString(), 'Remote update')
+    assert.equal(h.files.get('second.md')?.bytes.toString(), 'Partially written')
+  })
+
+  it('keeps a conflicting local edit visible when a remote version arrives', async () => {
+    const h = await fixture()
+    await h.sync()
+    h.refreshes.length = 0
+    h.remoteText('note.md', 'Cloud replacement')
+    h.setBeforeChanges(() => {
+      h.setBeforeChanges(undefined)
+      h.put('note.md', 'Local replacement')
+    })
+    const summary = await h.sync()
+    assert.equal(summary.pending_conflicts.length, 1)
+    assert.equal(h.files.get('note.md')?.bytes.toString(), 'Local replacement')
+    assert.equal(h.refreshes.at(-1)?.['note.md'], 'Local replacement')
+    const details = await h.api.getMobileCloudConflict(h.vault, summary.pending_conflicts[0].id)
+    assert.equal(details.local.text, 'Local replacement')
+    assert.equal(details.cloud.text, 'Cloud replacement')
+  })
+
+  it('loads full pending-conflict review bytes despite an acknowledged warm scan cache', async () => {
+    const h = await fixture()
+    await h.sync()
+    const state = h.state
+    const [item] = Object.values(state.items)
+    state.pending_conflicts = {
+      [item.item_id]: {
+        id: item.item_id, item_id: item.item_id, kind: 'content', sequence: 2,
+        base: { path: item.path, revision: 1, kind: 'text', content: textContent('Base') },
+        local: { path: item.path, revision: null, kind: 'text', content: textContent('Original') },
+        cloud: { path: item.path, revision: 2, kind: 'text', content: textContent('Cloud replacement') }
+      }
+    }
+    h.state = state
+    h.reads.length = 0
+    const details = await h.api.getMobileCloudConflict(h.vault, item.item_id)
+    assert.equal(details.local.text, 'Original')
+    assert.equal(details.cloud.text, 'Cloud replacement')
+    assert.deepEqual(h.reads, ['note.md'])
+  })
+
+  it('loads full bootstrap review bytes when old scan cache survives a lost sync state', async () => {
+    const h = await fixture()
+    await h.sync()
+    const cloud = h.remoteText('note.md', 'Cloud replacement')
+    h.clearState()
+    h.reads.length = 0
+    const details = await h.api.getMobileCloudBootstrapConflict(h.vault, {
+      code: 'BOOTSTRAP_CONTENT_CONFLICT', item_id: cloud.item_id, path: cloud.path,
+      local_sha256: textContent('Original').sha256, remote_sha256: cloud.sha256
+    })
+    assert.equal(details.local.text, 'Original')
+    assert.equal(details.cloud.text, 'Cloud replacement')
+    assert.deepEqual(h.reads, ['note.md'])
+  })
+})
diff --git a/src/bridge/mobile-cloud-sync.ts b/src/bridge/mobile-cloud-sync.ts
index e4a7995..3854d96 100644
--- a/src/bridge/mobile-cloud-sync.ts
+++ b/src/bridge/mobile-cloud-sync.ts
@@ -26,7 +26,6 @@ import {
   type CloudSyncHostVault
 } from '@zennotes/shared-domain/cloud-sync-host-service'
 import {
-  PortableCloudSyncRepository,
   type PortableCloudSyncFileSystem
 } from '@zennotes/shared-domain/cloud-sync-portable-filesystem'
 import type { CloudSyncState } from '@zennotes/shared-domain/cloud-sync-engine'
@@ -37,10 +36,12 @@ import {
   authenticatedClient,
   getMobileCloudAccountStatus
 } from './mobile-cloud-auth'
-import { emitVaultChange } from './events'
+import { CachedCloudSyncRepository, type ScanCache } from './cloud-sync-repository'
+import { trackCloudSyncChanges } from './cloud-sync-refresh'
 import { isNotFoundError } from './fs-errors'
 
 const STORAGE_ROOT = 'zennotes-cloud-sync'
+const refreshStates = new WeakMap<MobileVault, { changed: boolean }>()
 
 const persistence: CloudSyncHostPersistence = {
   async loadLink(vaultKey: string): Promise<unknown> {
@@ -103,13 +104,7 @@ export async function deleteMobileCloudVault(vault: MobileVault): Promise<void>
 }
 
 export async function syncMobileCloudVault(vault: MobileVault): Promise<CloudSyncRunSummary> {
-  const summary = await service.sync(hostVault(vault))
-
-  if (summary.pulled > 0) {
-    emitVaultChange({ kind: 'change', path: '', folder: 'inbox', scope: 'resync' })
-  }
-
-  return summary
+  return service.sync(hostVault(vault, true))
 }
 
 export async function getMobileCloudConflict(
@@ -276,7 +271,7 @@ export async function restoreMobileCloudBackupNote(
   return service.restoreBackupNote(hostVault(vault), backupId, snapshotItemId)
 }
 
-function hostVault(vault: MobileVault): CloudSyncHostVault {
+function hostVault(vault: MobileVault, cacheScan = false): CloudSyncHostVault {
   const fs: PortableCloudSyncFileSystem = {
     // Sync must distinguish an unreadable provider from an empty vault.
     readdir: async (directory) =>
@@ -297,13 +292,35 @@ function hostVault(vault: MobileVault): CloudSyncHostVault {
     }
   }
 
+  const vaultKey = vault.rootLabel
+  const state = refreshStates.get(vault) ?? { changed: false }
+  refreshStates.set(vault, state)
+  const changes = trackCloudSyncChanges(fs, () => vault.rescan(), state)
   return {
-    key: vault.rootLabel,
-    repository: new PortableCloudSyncRepository(fs),
-    refresh: () => vault.rescan()
+    key: vaultKey,
+    repository: new CachedCloudSyncRepository(changes.fs, vault.fs, {
+      loadTracked: async () => {
+        // Review/restore actions always receive real bytes, not scan placeholders.
+        if (!cacheScan) return null
+        const link = await readJson(await linkPath(vaultKey))
+        if (!isRecord(link) || typeof link.base_url !== 'string' || typeof link.vault_id !== 'string') return null
+        return await readJson(await statePath(vaultKey, link.base_url, link.vault_id)) as CloudSyncState | null
+      },
+      loadCache: async () => readJson(await scanCachePath(vaultKey)),
+      saveCache: async (cache: ScanCache) => writeJson(await scanCachePath(vaultKey), cache)
+    }, changes.markChanged),
+    refresh: changes.refresh
   }
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object'
+}
+
+async function scanCachePath(vaultKey: string): Promise<string> {
+  return `${STORAGE_ROOT}/scan-cache/${await fingerprint(vaultKey)}.json`
+}
+
 async function linkPath(vaultKey: string): Promise<string> {
   return `${STORAGE_ROOT}/links/${await fingerprint(vaultKey)}.json`
 }
diff --git a/src/bridge/remote-vault-paste.test.ts b/src/bridge/remote-vault-paste.test.ts
new file mode 100644
index 0000000..57bd474
--- /dev/null
+++ b/src/bridge/remote-vault-paste.test.ts
@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { loadMobileModule } from '../../tooling/load-mobile-module.ts'
+
+async function paste(mimeType: string, suggestedName?: string) {
+  const uploads: Array<{ name: string; data: string; directory: string }> = []
+  const changes: unknown[] = []
+  const { RemoteVault } = await loadMobileModule('./src/bridge/remote-vault.ts', {
+    './events': { emitVaultChange: (event: unknown) => changes.push(event) }
+  })
+  const vault = new RemoteVault({
+    async uploadAsset(name: string, data: string, directory: string) {
+      uploads.push({ name, data, directory })
+      return { name, path: `${directory}/${name}` }
+    }
+  }, null, 'paste-test')
+  const result = await vault.importPastedImage({
+    mimeType, suggestedName, data: new Uint8Array([1, 2, 3])
+  })
+  return { result, uploads, changes }
+}
+
+test('remote keyboard WebP paste preserves its format and vault asset path', async () => {
+  const { result, uploads, changes } = await paste('image/webp')
+  assert.match(uploads[0].name, /^Pasted Image .*\.webp$/)
+  assert.equal(uploads[0].data, 'AQID')
+  assert.equal(uploads[0].directory, 'assets')
+  assert.equal(result.markdown, `![[assets/${uploads[0].name}]]`)
+  assert.equal(result.kind, 'image')
+  assert.deepEqual(changes, [{
+    kind: 'add', path: result.path, folder: 'inbox', scope: 'content'
+  }])
+})
+
+test('remote pasted-image names cannot introduce paths or break the embed', async () => {
+  const { result, uploads } = await paste('image/webp', '../picture [draft].webp')
+  assert.equal(uploads[0].name, 'picture -draft-.webp')
+  assert.equal(result.markdown, '![[assets/picture -draft-.webp]]')
+})
+
+test('remote paste retains PNG, JPEG and GIF extensions', async () => {
+  for (const [mime, extension] of [
+    ['image/png', '.png'], ['image/jpeg', '.jpg'], ['image/gif', '.gif']
+  ]) {
+    const { uploads } = await paste(mime, 'clipboard')
+    assert.equal(uploads[0].name, `clipboard${extension}`)
+  }
+})
diff --git a/src/bridge/remote-vault.ts b/src/bridge/remote-vault.ts
index ca9446a..5ecdde7 100644
--- a/src/bridge/remote-vault.ts
+++ b/src/bridge/remote-vault.ts
@@ -33,6 +33,7 @@ import type { VaultTask } from '@shared/tasks'
 import type { CustomTemplateFile, WriteTemplateInput } from '@bridge-contract/templates'
 import type { ImportedAsset } from '@shared/ipc'
 import { createAbsenceAwareReader } from '@shared/remote-absence'
+import { pastedImageFilename } from '@shared/pasted-image'
 import { emitVaultChange } from './events'
 import { importedAssetFilename } from './imported-assets'
 import { RemoteClient, RemoteRequestError } from './remote-client'
@@ -339,9 +340,8 @@ export class RemoteVault {
   async importPastedImage(input: PastedImageInput): Promise<ImportedAsset> {
     const bytes =
       input.data instanceof Uint8Array ? input.data : new Uint8Array(input.data as ArrayBuffer)
-    const ext = input.mimeType === 'image/png' ? '.png' : input.mimeType === 'image/gif' ? '.gif' : '.jpg'
-    const base = (input.suggestedName ?? 'Pasted image').replace(/\.[a-z0-9]+$/i, '')
-    const meta = await this.client.uploadAsset(`${base}${ext}`, bytesToBase64(bytes), 'assets')
+    const name = pastedImageFilename(input, new Date())
+    const meta = await this.client.uploadAsset(name, bytesToBase64(bytes), 'assets')
     emitVaultChange({ kind: 'add', path: meta.path, folder: 'inbox', scope: 'content' })
     return { name: meta.name, path: meta.path, markdown: `![[${meta.path}]]`, kind: 'image' }
   }
diff --git a/src/bridge/vault-fs.ts b/src/bridge/vault-fs.ts
index 3c028ff..e1b2ddd 100644
--- a/src/bridge/vault-fs.ts
+++ b/src/bridge/vault-fs.ts
@@ -1384,7 +1384,7 @@ export class MobileVault {
     }
   }
 
-  /** Foreground rescan: re-stat the tree, emit change events for anything new. */
+  /** Foreground/cloud rescan: refresh cached metadata and notify once. */
   async rescan(): Promise<void> {
     // Vault settings may have changed externally (desktop edit synced via
     // iCloud) — drop the cache so the next read sees the file.
@@ -1392,25 +1392,13 @@ export class MobileVault {
     const before = new Map<string, CachedMeta>(this.metaCache)
     const notes = await this.listNotes()
     const seen = new Set(notes.map((n) => n.path))
-    for (const note of notes) {
-      const prev = before.get(note.path)
-      if (!prev) {
-        emitVaultChange({ kind: 'add', path: note.path, folder: note.folder, scope: 'content' })
-      } else if (prev.meta.updatedAt !== note.updatedAt || prev.size !== note.size) {
-        emitVaultChange({ kind: 'change', path: note.path, folder: note.folder, scope: 'content' })
-      }
-    }
     for (const [path] of before) {
-      if (!seen.has(path)) {
-        this.invalidateMeta(path)
-        emitVaultChange({
-          kind: 'unlink',
-          path,
-          folder: (await this.folderOf(path)) ?? 'inbox',
-          scope: 'content'
-        })
-      }
+      if (!seen.has(path)) this.invalidateMeta(path)
     }
+    // A single resync refreshes assets/settings as well as notes and keeps
+    // remote changes from scheduling another local-change autosync. The
+    // app-core resync handler preserves open notes with unsaved edits.
+    emitVaultChange({ kind: 'change', path: '', folder: 'inbox', scope: 'resync' })
   }
 }
 
diff --git a/src/ui-mobile/MobileDrawer.tsx b/src/ui-mobile/MobileDrawer.tsx
index 7d0d7a6..89eb767 100644
--- a/src/ui-mobile/MobileDrawer.tsx
+++ b/src/ui-mobile/MobileDrawer.tsx
@@ -28,6 +28,7 @@ import { usePins, toggleNotePin, toggleFolderPin } from './pins'
 import { archiveNote, openNoteMenu, trashNote } from './note-actions'
 import { refreshVault } from './refresh'
 import { SwipeRow } from './SwipeRow'
+import { SheetHandle } from './SheetHandle'
 import { getStoragePref } from '../bridge/icloud'
 import {
   ICLOUD_VAULT_ROOT_PREFIX,
@@ -188,6 +189,7 @@ function NewVaultSheet({
     <>
       <div className="zn-mobile-sheet-backdrop" onClick={cancel} role="presentation" />
       <div className="zn-mobile-sheet" role="dialog" aria-label="New Vault">
+        <SheetHandle onDismiss={cancel} />
         <div className="zn-mobile-sheet-title">New Vault</div>
         <div className="zn-mobile-sheet-scroll">
           <input
@@ -416,6 +418,7 @@ export function VaultsSheet({ onClose }: { onClose: () => void }): React.JSX.Ele
     <>
       <div className="zn-mobile-sheet-backdrop" onClick={onClose} role="presentation" />
       <div className="zn-mobile-sheet" role="dialog" aria-label="Vaults">
+        <SheetHandle onDismiss={onClose} />
         <div className="zn-mobile-sheet-title">Vaults</div>
         <div className="zn-mobile-sheet-scroll">
           {busyLabel !== null && <p className="zn-mobile-sheet-note">{busyLabel}</p>}
@@ -1329,6 +1332,7 @@ function MobileDrawerBody(props: {
               role="presentation"
             />
             <div className="zn-mobile-sheet" role="menu" aria-label="Folder actions">
+              <SheetHandle onDismiss={() => setFolderMenu(null)} />
               <div className="zn-mobile-sheet-title zn-truncate">{folderMenu.name}</div>
               <div className="zn-mobile-sheet-scroll">
                 <div className="zn-mobile-sheet-group">
diff --git a/src/ui-mobile/MobileShell.tsx b/src/ui-mobile/MobileShell.tsx
index 24543fc..7bed1d2 100644
--- a/src/ui-mobile/MobileShell.tsx
+++ b/src/ui-mobile/MobileShell.tsx
@@ -46,6 +46,9 @@ import { installNoteRowGestures, NOTE_ROW_SELECTOR } from './note-row-gestures'
 import { NoteActionSheet } from './note-actions'
 import { installEditorKeyboardScroll } from './editor-keyboard-scroll'
 import { installEditorNativeTyping } from './editor-native-typing'
+import { installWikilinkTouchNavigation } from './wikilink-touch'
+import { SheetHandle } from './SheetHandle'
+import { installImagePaste } from './image-paste'
 import { getStartScreen, setStartScreen, type StartScreen } from './start-screen'
 import { useYouTubeLiteEmbeds } from './youtube-embed-shim'
 import { VaultsSheet, promptNewVault } from './MobileDrawer'
@@ -294,6 +297,7 @@ function ActionSheet({ onClose }: { onClose: () => void }): React.JSX.Element {
     <>
       <div className="zn-mobile-sheet-backdrop" onClick={onClose} role="presentation" />
       <div className="zn-mobile-sheet" role="menu" aria-label="Note actions">
+        <SheetHandle onDismiss={onClose} />
         <div className="zn-mobile-sheet-title">{dbTitle ?? title}</div>
         {hasNote && (
           <div className="zn-mobile-seg" role="group" aria-label="View mode">
@@ -402,6 +406,7 @@ function CreateSheet({ onClose }: { onClose: () => void }): React.JSX.Element {
     <>
       <div className="zn-mobile-sheet-backdrop" onClick={onClose} role="presentation" />
       <div className="zn-mobile-sheet" role="menu" aria-label="Create">
+        <SheetHandle onDismiss={onClose} />
         <div className="zn-mobile-sheet-title">Create</div>
         <div className="zn-mobile-sheet-scroll">
           <div className="zn-mobile-sheet-group">
@@ -731,22 +736,19 @@ function openWikilinkFromTouch(target: string): void {
  * Tap-to-follow wikilinks in the editor. The shared extension follows links
  * on `mousedown`, but on iOS the preceding touch moves the CodeMirror
  * selection, which reveals the raw `[[...]]` source and removes the rendered
- * link before any mouse event fires — so taps just placed the caret (spec 06
- * wants tap = navigate). Intercepting `touchstart` runs before CodeMirror.
+ * link before any mouse event fires. Remember the target at touchstart, but
+ * follow only after a short, stationary tap ends (#50).
  */
 function useWikilinkTapNavigation(): void {
   useEffect(() => {
-    const onTouchStart = (e: TouchEvent): void => {
-      const el = (e.target as HTMLElement | null)?.closest?.('.cm-wikilink')
-      const target = el instanceof HTMLElement ? el.dataset.target : undefined
-      if (!target) return
-      e.preventDefault()
-      e.stopPropagation()
-      openWikilinkFromTouch(target)
-    }
-    document.addEventListener('touchstart', onTouchStart, { capture: true, passive: false })
-    return () =>
-      document.removeEventListener('touchstart', onTouchStart, { capture: true } as never)
+    return installWikilinkTouchNavigation(document, {
+      open: openWikilinkFromTouch,
+      hasSelection: () => {
+        const selection = window.getSelection()
+        const view = useStore.getState().editorViewRef
+        return Boolean((selection && !selection.isCollapsed) || (view && !view.state.selection.main.empty))
+      }
+    })
   }, [])
 }
 
@@ -2290,6 +2292,7 @@ function KanbanMoveSheet(): React.JSX.Element | null {
         role="presentation"
       />
       <div className="zn-mobile-sheet" role="menu" aria-label="Move task to column">
+        <SheetHandle onDismiss={() => setState(null)} />
         <div className="zn-mobile-sheet-title">Move to…</div>
         <div className="zn-mobile-sheet-scroll">
           <div className="zn-mobile-sheet-group">
@@ -2930,6 +2933,7 @@ function useEditorNativeTyping(): void {
 }
 
 function MobileShellRoot(): React.JSX.Element {
+  useEffect(() => installImagePaste(), [])
   usePhoneLayoutBoot()
   useDrawerAutoClose()
   useSettingsMobilizer()
diff --git a/src/ui-mobile/SheetHandle.tsx b/src/ui-mobile/SheetHandle.tsx
new file mode 100644
index 0000000..60522e2
--- /dev/null
+++ b/src/ui-mobile/SheetHandle.tsx
@@ -0,0 +1,52 @@
+import { useRef } from 'react'
+import { shouldDismissSheet } from './sheet-drag'
+
+/** Only the handle owns the gesture; scrolling menu content stays native. */
+export function SheetHandle({ onDismiss }: { onDismiss: () => void }): React.JSX.Element {
+  const drag = useRef<{ id: number; x: number; y: number; at: number; sheet: HTMLElement } | null>(null)
+  const moved = useRef(false)
+  const reset = (): void => {
+    const sheet = drag.current?.sheet
+    sheet?.style.removeProperty('--zn-sheet-drag')
+    sheet?.removeAttribute('data-dragging')
+    drag.current = null
+  }
+  return <button
+    type="button"
+    className="zn-mobile-sheet-handle"
+    aria-label="Close menu"
+    onPointerDown={(event) => {
+      if (!event.isPrimary || event.button !== 0) return
+      const sheet = event.currentTarget.closest<HTMLElement>('.zn-mobile-sheet')
+      if (!sheet) return
+      moved.current = false
+      drag.current = { id: event.pointerId, x: event.clientX, y: event.clientY, at: event.timeStamp, sheet }
+      sheet.setAttribute('data-dragging', '')
+      event.currentTarget.setPointerCapture(event.pointerId)
+    }}
+    onPointerMove={(event) => {
+      const start = drag.current
+      if (!start || start.id !== event.pointerId) return
+      const dy = event.clientY - start.y
+      moved.current ||= Math.hypot(event.clientX - start.x, dy) > 4
+      start.sheet.style.setProperty('--zn-sheet-drag', `${Math.max(0, dy)}px`)
+    }}
+    onPointerUp={(event) => {
+      const start = drag.current
+      if (!start || start.id !== event.pointerId) return
+      const dx = event.clientX - start.x
+      const dy = event.clientY - start.y
+      moved.current ||= Math.hypot(dx, dy) > 4
+      const dismiss = shouldDismissSheet(dx, dy, event.timeStamp - start.at)
+      reset()
+      if (dismiss) { moved.current = true; onDismiss() }
+    }}
+    onPointerCancel={() => { moved.current = true; reset() }}
+    onLostPointerCapture={reset}
+    onClick={(event) => {
+      // Pointer click follows pointerup even after a short drag. Keyboard and
+      // assistive-tech activation (detail 0) remain an accessible close action.
+      if (!moved.current || event.detail === 0) onDismiss()
+    }}
+  ><span aria-hidden="true" /></button>
+}
diff --git a/src/ui-mobile/editor-keyboard-scroll.ts b/src/ui-mobile/editor-keyboard-scroll.ts
index e2b50ce..3110a56 100644
--- a/src/ui-mobile/editor-keyboard-scroll.ts
+++ b/src/ui-mobile/editor-keyboard-scroll.ts
@@ -30,20 +30,23 @@ import { Keyboard } from '@capacitor/keyboard'
 import { EditorView } from '@codemirror/view'
 import { StateEffect } from '@codemirror/state'
 import { useStore } from '@zennotes/app-core/store'
+import { installSelectionToolbarSpace, selectionToolbarInset } from './selection-toolbar-space'
 
 const TOOLBAR = '.zn-editor-toolbar'
 
 /** Bottom clearance CodeMirror must keep clear: the toolbar's height while it
  *  is mounted (it renders only while the keyboard is up over the editor). */
-function toolbarClearance(): number {
+function toolbarClearance(view: EditorView): number {
   const bar = document.querySelector<HTMLElement>(TOOLBAR)
   if (!bar) return 0
-  // Extra so the caret line isn't flush against the toolbar's top edge.
-  return Math.round(bar.getBoundingClientRect().height) + 8
+  // Only reserve actual overlap. When the selection bubble has already
+  // shrunk the scroller, adding the keyboard bar's full height again would
+  // needlessly consume the small amount of visible text above it.
+  return selectionToolbarInset(view.scrollDOM.getBoundingClientRect(), bar.getBoundingClientRect())
 }
 
-function marginSource(): { bottom: number } | null {
-  const bottom = toolbarClearance()
+function marginSource(view: EditorView): { bottom: number } | null {
+  const bottom = toolbarClearance(view)
   return bottom > 0 ? { bottom } : null
 }
 
@@ -86,6 +89,10 @@ export function revealCaretAboveKeyboardSoon(): void {
 /** Wire the margin source to every editor view and the reveal to the
  *  keyboard lifecycle. Returns the uninstaller. */
 export function installEditorKeyboardScroll(): () => void {
+  const removeSelectionSpace = installSelectionToolbarSpace(
+    () => useStore.getState().editorViewRef?.dom ?? null,
+    revealCaretAboveKeyboard
+  )
   const initial = useStore.getState().editorViewRef
   if (initial) ensureMargins(initial)
   const unsubscribe = useStore.subscribe((state, prev) => {
@@ -103,6 +110,7 @@ export function installEditorKeyboardScroll(): () => void {
   }
   window.addEventListener('resize', onResize)
   return () => {
+    removeSelectionSpace()
     unsubscribe()
     void didShow.then((h) => h.remove()).catch(() => {})
     window.removeEventListener('resize', onResize)
diff --git a/src/ui-mobile/image-paste-session.test.ts b/src/ui-mobile/image-paste-session.test.ts
new file mode 100644
index 0000000..0227645
--- /dev/null
+++ b/src/ui-mobile/image-paste-session.test.ts
@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { runImagePaste, type PasteContext } from './image-paste-session.ts'
+
+function setup() {
+  let context: PasteContext | null = { vault: {}, editor: {}, document: {}, path: 'note.md', from: 3, to: 3 }
+  const events: string[] = []
+  return {
+    events, change: (patch: Partial<PasteContext>) => { context = { ...context!, ...patch } },
+    options: {
+      current: () => context,
+      read: async () => { events.push('read'); return 'image' },
+      save: async (_: PasteContext, image: string) => { events.push(`save:${image}`); return 'asset' },
+      insert: (_: PasteContext, asset: string) => { events.push(`insert:${asset}`) }
+    }
+  }
+}
+test('keyboard paste reads, saves in the captured vault and inserts once (#54)', async () => {
+  const s = setup()
+  await runImagePaste(s.options)
+  assert.deepEqual(s.events, ['read', 'save:image', 'insert:asset'])
+})
+for (const patch of [{ path: 'other.md' }, { vault: {} }, { editor: {} }, { document: {} }, { from: 10 }]) {
+  test(`note/context change during image read cancels before saving: ${Object.keys(patch)[0]}`, async () => {
+    const s = setup()
+    await assert.rejects(runImagePaste({ ...s.options, read: async () => { s.change(patch); return 'image' } }), /changed/)
+    assert.deepEqual(s.events, [])
+  })
+}
+test('switching notes during storage write never inserts into the new note', async () => {
+  const s = setup()
+  await assert.rejects(runImagePaste({ ...s.options, save: async () => { s.change({ path: 'other.md' }); return 'asset' } }), /saved/)
+  assert.deepEqual(s.events, ['read'])
+})
+test('storage failure does not insert a broken reference', async () => {
+  const s = setup()
+  await assert.rejects(runImagePaste({ ...s.options, save: async () => { throw new Error('Disk full') } }), /Disk full/)
+  assert.deepEqual(s.events, ['read'])
+})
diff --git a/src/ui-mobile/image-paste-session.ts b/src/ui-mobile/image-paste-session.ts
new file mode 100644
index 0000000..c01b351
--- /dev/null
+++ b/src/ui-mobile/image-paste-session.ts
@@ -0,0 +1,21 @@
+export interface PasteContext { vault: object; editor: object; document: object; path: string; from: number; to: number }
+export async function runImagePaste<T, R>(options: {
+  current: () => PasteContext | null;
+  read: () => Promise<T>;
+  save: (context: PasteContext, image: T) => Promise<R>;
+  insert: (context: PasteContext, asset: R) => void;
+}): Promise<void> {
+  const context = options.current()
+  if (!context) throw new Error('Open an editable note before pasting an image.')
+  const unchanged = (): boolean => {
+    const current = options.current()
+    return current !== null && current.vault === context.vault && current.editor === context.editor &&
+      current.document === context.document && current.path === context.path &&
+      current.from === context.from && current.to === context.to
+  }
+  const image = await options.read()
+  if (!unchanged()) throw new Error('The note or cursor changed. Please paste the image again.')
+  const asset = await options.save(context, image)
+  if (!unchanged()) throw new Error('The image was saved in assets, but the note changed. Insert it from the vault assets.')
+  options.insert(context, asset)
+}
diff --git a/src/ui-mobile/image-paste.ts b/src/ui-mobile/image-paste.ts
new file mode 100644
index 0000000..aa5c62c
--- /dev/null
+++ b/src/ui-mobile/image-paste.ts
@@ -0,0 +1,77 @@
+import { Capacitor, registerPlugin, type PluginListenerHandle } from '@capacitor/core'
+import type { EditorView } from '@codemirror/view'
+import { useStore } from '@zennotes/app-core/store'
+import { formatImportedAssetsForInsertion } from '@zennotes/app-core/lib/editor-drops'
+import { activeVault } from '../bridge/mobile-bridge'
+import { decodeCloudSyncBase64 } from '../bridge/cloud-sync-work'
+import { runImagePaste, type PasteContext } from './image-paste-session'
+
+const ImagePaste = registerPlugin<{
+  setEnabled(options: { enabled: boolean }): Promise<void>;
+  read(options: { id: string }): Promise<{ base64: string; mimeType: string }>;
+  discard(options: { id: string }): Promise<void>;
+  addListener(event: 'image', listener: (event: { id: string }) => void): Promise<PluginListenerHandle>;
+}>('ImagePaste')
+
+function current(): PasteContext | null {
+  const state = useStore.getState()
+  const view = state.editorViewRef
+  const path = state.selectedPath
+  if (!state.vault || !view?.hasFocus || view.state.readOnly || !path || path.startsWith('zen://') ||
+      !view.contentDOM.contains(document.activeElement) || document.querySelector('[role="dialog"], [data-ctx-menu]')) return null
+  return { vault: activeVault(), editor: view, document: view.state.doc, path,
+    from: view.state.selection.main.from, to: view.state.selection.main.to }
+}
+
+export function installImagePaste(): () => void {
+  if (Capacitor.getPlatform() !== 'android') return () => {}
+  let live = true
+  let enabled = false
+  let busy = false
+  const sync = (): void => {
+    if (!live) return
+    // Do not restart the IME mid-paste when a store update arrives. The
+    // receiver's single-flight guard rejects overlapping image operations.
+    const next = current() !== null
+    if (next === enabled) return
+    enabled = next
+    void ImagePaste.setEnabled({ enabled }).catch(() => { enabled = false })
+  }
+  const onFocus = (): void => { queueMicrotask(sync) }
+  const listener = ImagePaste.addListener('image', ({ id }) => {
+    if (!live || busy || !current()) { void ImagePaste.discard({ id }).catch(() => {}); return }
+    busy = true
+    void runImagePaste({
+      current: () => live ? current() : null,
+      read: async () => {
+        const result = await ImagePaste.read({ id })
+        const { bytes } = await decodeCloudSyncBase64(result.base64)
+        return { data: bytes.buffer, mimeType: result.mimeType, suggestedName: null }
+      },
+      save: (context, image) => (context.vault as ReturnType<typeof activeVault>).importPastedImage(image),
+      insert: (context, asset) => {
+        const view = context.editor as EditorView
+        const before = context.from > 0 ? view.state.doc.sliceString(context.from - 1, context.from) : ''
+        const after = view.state.doc.sliceString(context.to, context.to + 1)
+        const insert = formatImportedAssetsForInsertion([asset], before, after)
+        view.dispatch({ changes: { from: context.from, to: context.to, insert },
+          selection: { anchor: context.from + insert.length } })
+        view.focus()
+      }
+    }).catch((error) => {
+      if (live) window.alert(error instanceof Error ? error.message : 'Could not paste the image.')
+    }).finally(() => { busy = false; sync() })
+  })
+  void listener.then(sync).catch(() => {})
+  document.addEventListener('focusin', onFocus)
+  document.addEventListener('focusout', onFocus)
+  const unsubscribe = useStore.subscribe(sync)
+  return () => {
+    live = false
+    unsubscribe()
+    document.removeEventListener('focusin', onFocus)
+    document.removeEventListener('focusout', onFocus)
+    void listener.then((handle) => handle.remove()).catch(() => {})
+    void ImagePaste.setEnabled({ enabled: false }).catch(() => {})
+  }
+}
diff --git a/src/ui-mobile/mobile-layout.test.ts b/src/ui-mobile/mobile-layout.test.ts
new file mode 100644
index 0000000..52ea69a
--- /dev/null
+++ b/src/ui-mobile/mobile-layout.test.ts
@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import test from 'node:test'
+import postcss from 'postcss'
+
+const css = postcss.parse(readFileSync(new URL('./mobile.css', import.meta.url), 'utf8'))
+function declaration(selector: string, property: string): string | undefined {
+  let result: string | undefined
+  css.walkRules(selector, (rule) => {
+    rule.walkDecls(property, (decl) => { result = decl.value })
+  })
+  return result
+}
+
+test('Cloud footer reserves a touch-sized row below the phone floating navigation (#48)', () => {
+  assert.equal(declaration('.zn-phone:has([data-cloud-sync-status])', '--zn-cloud-footer-height'), '44px')
+  assert.equal(declaration('.zn-phone .h-8:has([data-cloud-sync-status])', 'height'), 'var(--zn-cloud-footer-height)')
+  assert.equal(declaration('.zn-phone [data-cloud-sync-action]', 'min-height'), '44px')
+  for (const selector of ['.zn-mobile-fab', '.zn-mobile-fab-menu', '.zn-mobile-fab-hint']) {
+    assert.ok(declaration(selector, 'bottom')?.includes('var(--zn-cloud-footer-height, 0px)'), selector)
+  }
+})
+
+test('Android editor compositing surfaces always paint the active theme (#49)', () => {
+  for (const selector of ['.zn-mobile body', '.zn-mobile #root', '.zn-mobile .cm-editor']) {
+    assert.equal(declaration(selector, 'background'), 'rgb(var(--z-bg))', selector)
+  }
+})
+
+test('selection toolbar space shrinks the viewport instead of hiding text (#51)', () => {
+  assert.equal(declaration('.zn-phone .cm-editor', 'padding-bottom'), 'var(--zn-selection-clearance, 0px)')
+  assert.equal(declaration('.zn-phone .cm-editor', 'box-sizing'), 'border-box')
+})
diff --git a/src/ui-mobile/mobile.css b/src/ui-mobile/mobile.css
index 62c5757..12fcd1e 100644
--- a/src/ui-mobile/mobile.css
+++ b/src/ui-mobile/mobile.css
@@ -15,6 +15,18 @@
 .zn-mobile body {
   overscroll-behavior: none;
   -webkit-text-size-adjust: 100%;
+  background: rgb(var(--z-bg));
+}
+
+/* Android has no desktop window vibrancy behind the editor. An opaque,
+   theme-colored paint surface avoids exposing the WebView's backing color
+   when native selection handles cause a compositing update (#49). */
+.zn-mobile #root {
+  background: rgb(var(--z-bg));
+}
+
+.zn-mobile .cm-editor {
+  background: rgb(var(--z-bg)) !important;
 }
 
 /* App Store distribution: there is no in-app updater on iOS (any width —
@@ -50,7 +62,7 @@
   /* Balanced against the home-indicator zone: 20px in from the right, just
      above the indicator — hugging the edge with a tall bottom gap reads off. */
   right: calc(1.25rem + env(safe-area-inset-right));
-  bottom: calc(0.75rem + env(safe-area-inset-bottom));
+  bottom: calc(0.75rem + env(safe-area-inset-bottom) + var(--zn-cloud-footer-height, 0px));
   z-index: 41;
   display: none;
   align-items: center;
@@ -97,7 +109,7 @@
 .zn-mobile-fab-menu {
   position: fixed;
   right: calc(1.25rem + env(safe-area-inset-right));
-  bottom: calc(0.75rem + 54px + 0.875rem + env(safe-area-inset-bottom));
+  bottom: calc(0.75rem + 54px + 0.875rem + env(safe-area-inset-bottom) + var(--zn-cloud-footer-height, 0px));
   z-index: 41;
   display: none;
   flex-direction: column;
@@ -142,7 +154,7 @@
 .zn-mobile-fab-hint {
   position: fixed;
   right: calc(1.25rem + env(safe-area-inset-right));
-  bottom: calc(0.75rem + 54px + 0.875rem + env(safe-area-inset-bottom));
+  bottom: calc(0.75rem + 54px + 0.875rem + env(safe-area-inset-bottom) + var(--zn-cloud-footer-height, 0px));
   z-index: 41;
   display: none;
   flex-direction: column;
@@ -237,16 +249,40 @@
   box-shadow: 0 -18px 50px -20px rgb(0 0 0 / 0.6);
   padding: 0.5rem 0.875rem calc(0.75rem + env(safe-area-inset-bottom));
   animation: zn-sheet-up 0.26s cubic-bezier(0.32, 0.72, 0.22, 1);
+  translate: 0 var(--zn-sheet-drag, 0px);
+  transition: translate 180ms ease-out;
 }
 
-.zn-mobile-sheet::before {
-  content: '';
+.zn-mobile-sheet[data-dragging] {
+  transition: none;
+}
+
+.zn-mobile-sheet-handle {
   align-self: center;
+  flex: 0 0 44px;
+  width: 80px;
+  display: grid;
+  place-items: center;
+  border: 0;
+  background: transparent;
+  touch-action: none;
+  cursor: grab;
+}
+
+.zn-mobile-sheet-handle:focus-visible {
+  outline: 2px solid rgb(var(--z-accent));
+  border-radius: 8px;
+}
+
+.zn-mobile-sheet-handle span {
   width: 2.25rem;
   height: 0.3125rem;
   border-radius: 9999px;
   background: rgb(var(--z-grey-dim) / 0.55);
-  margin: 0.25rem 0 0.625rem;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .zn-mobile-sheet { animation: none; transition: none; }
 }
 
 .zn-mobile-sheet-title {
@@ -619,6 +655,21 @@
   display: none;
 }
 
+/* Cloud status is useful on phones; keep Connect/Retry/Review accessible.
+   The shared footer now uses responsive padding, so the old word-count
+   selector above no longer hides it. Reserve one row below the FAB (#48). */
+.zn-phone:has([data-cloud-sync-status]) {
+  --zn-cloud-footer-height: 44px;
+}
+
+.zn-phone .h-8:has([data-cloud-sync-status]) {
+  height: var(--zn-cloud-footer-height);
+}
+
+.zn-phone [data-cloud-sync-action] {
+  min-height: 44px;
+}
+
 /* Split view has no meaning on a phone. */
 .zn-mobile.zn-phone button[aria-label^='Split mode'] {
   display: none;
@@ -2116,6 +2167,14 @@
   max-width: calc(100vw - 16px);
 }
 
+/* The selection bubble must have its own space, including while native
+   selection handles are dragged (#51). This shrinks the flex scroller, not
+   merely its scrollable content. The shell measures the live bubble bounds. */
+.zn-phone .cm-editor {
+  box-sizing: border-box;
+  padding-bottom: var(--zn-selection-clearance, 0px);
+}
+
 /* Non-resizing keyboard mode (tablets — see wireKeyboard): the viewport
    keeps its full height, so lift the toolbar above the keyboard frame. */
 .zn-kb-noresize .zn-editor-toolbar {
diff --git a/src/ui-mobile/note-actions.tsx b/src/ui-mobile/note-actions.tsx
index e409dee..a4aa6bc 100644
--- a/src/ui-mobile/note-actions.tsx
+++ b/src/ui-mobile/note-actions.tsx
@@ -24,6 +24,7 @@ import { confirmApp } from '@zennotes/app-core/lib/confirm-requests'
 import { promptApp } from '@zennotes/app-core/lib/prompt-requests'
 import { buildMoveNotePrompt, parseMoveNoteTarget } from '@zennotes/app-core/lib/move-note'
 import { getPinnedNotes, toggleNotePin, usePins } from './pins'
+import { SheetHandle } from './SheetHandle'
 
 export type NoteRowKind = 'note' | 'archived' | 'trashed'
 
@@ -242,6 +243,7 @@ export function NoteActionSheet(): React.JSX.Element | null {
           under the sheet, and the list views' keyboard shortcuts must not
           fire through it — exactly what the marker gates for its own menus. */}
       <div className="zn-mobile-sheet" role="menu" aria-label="Note actions" data-ctx-menu="">
+        <SheetHandle onDismiss={closeNoteMenu} />
         <div className="zn-mobile-sheet-title zn-truncate">{target.title}</div>
         <div className="zn-mobile-sheet-scroll">
           <div className="zn-mobile-sheet-group">
diff --git a/src/ui-mobile/selection-toolbar-space.test.ts b/src/ui-mobile/selection-toolbar-space.test.ts
new file mode 100644
index 0000000..62c9bd9
--- /dev/null
+++ b/src/ui-mobile/selection-toolbar-space.test.ts
@@ -0,0 +1,18 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { selectionToolbarInset } from './selection-toolbar-space.ts'
+
+const editor = { top: 60, bottom: 440, left: 0, right: 390 }
+test('selection menu gets real editor space, not just scroll padding (#51)', () => {
+  assert.equal(selectionToolbarInset(editor, { top: 290, bottom: 410, left: 61, right: 329 }), 158)
+})
+test('selection clearance follows keyboard resize and menu growth', () => {
+  assert.equal(selectionToolbarInset({ ...editor, bottom: 340 }, { top: 190, bottom: 310, left: 61, right: 329 }), 158)
+  assert.equal(selectionToolbarInset(editor, { top: 250, bottom: 410, left: 61, right: 329 }), 198)
+})
+test('hidden, external, or nonoverlapping menus reserve no space', () => {
+  assert.equal(selectionToolbarInset(editor, null), 0)
+  assert.equal(selectionToolbarInset(editor, { top: 450, bottom: 570, left: 61, right: 329 }), 0)
+  assert.equal(selectionToolbarInset(editor, { top: 290, bottom: 410, left: 400, right: 668 }), 0)
+  assert.equal(selectionToolbarInset({ ...editor, bottom: 280 }, { top: 290, bottom: 410, left: 61, right: 329 }), 0)
+})
diff --git a/src/ui-mobile/selection-toolbar-space.ts b/src/ui-mobile/selection-toolbar-space.ts
new file mode 100644
index 0000000..eca2b43
--- /dev/null
+++ b/src/ui-mobile/selection-toolbar-space.ts
@@ -0,0 +1,51 @@
+type Rect = Pick<DOMRect, 'top' | 'bottom' | 'left' | 'right'>
+
+export function selectionToolbarInset(editor: Rect, toolbar: Rect | null): number {
+  if (!toolbar || toolbar.top >= editor.bottom || toolbar.bottom <= editor.top ||
+      toolbar.left >= editor.right || toolbar.right <= editor.left) return 0
+  return Math.ceil(Math.min(editor.bottom - editor.top, editor.bottom - toolbar.top + 8))
+}
+
+/** Reserve space in the flex editor itself. Padding inside its scroller is
+ * not sufficient: native selection handles can still enter an overlaid area.
+ * Measure the editor's border box, which stays stable as its scroller shrinks. */
+export function installSelectionToolbarSpace(getEditor: () => HTMLElement | null, reveal: () => void): () => void {
+  let editor: HTMLElement | null = null
+  let toolbar: HTMLElement | null = null
+  let frame = 0
+  const schedule = (): void => { if (!frame) frame = requestAnimationFrame(update) }
+  const sizes = new ResizeObserver(schedule)
+  function update(): void {
+    frame = 0
+    const nextEditor = getEditor()
+    const nextToolbar = document.documentElement.classList.contains('zn-phone')
+      ? document.querySelector<HTMLElement>('[data-selection-toolbar]') : null
+    if (editor !== nextEditor || toolbar !== nextToolbar) {
+      sizes.disconnect()
+      editor?.style.removeProperty('--zn-selection-clearance')
+      editor = nextEditor
+      toolbar = nextToolbar
+      if (editor) sizes.observe(editor)
+      if (toolbar) sizes.observe(toolbar)
+    }
+    if (!editor) return
+    const inset = selectionToolbarInset(editor.getBoundingClientRect(), toolbar?.getBoundingClientRect() ?? null)
+    const value = `${inset}px`
+    if (editor.style.getPropertyValue('--zn-selection-clearance') !== value) {
+      editor.style.setProperty('--zn-selection-clearance', value)
+      reveal()
+    }
+  }
+  const mutations = new MutationObserver(schedule)
+  mutations.observe(document.body, { childList: true, subtree: true })
+  mutations.observe(document.documentElement, { attributes: true, attributeFilter: ['class'] })
+  window.addEventListener('resize', schedule)
+  update()
+  return () => {
+    cancelAnimationFrame(frame)
+    sizes.disconnect()
+    mutations.disconnect()
+    window.removeEventListener('resize', schedule)
+    editor?.style.removeProperty('--zn-selection-clearance')
+  }
+}
diff --git a/src/ui-mobile/sheet-drag.test.ts b/src/ui-mobile/sheet-drag.test.ts
new file mode 100644
index 0000000..922666b
--- /dev/null
+++ b/src/ui-mobile/sheet-drag.test.ts
@@ -0,0 +1,13 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { shouldDismissSheet } from './sheet-drag.ts'
+
+test('dragging the handle down dismisses its sheet (#53)', () => {
+  assert.equal(shouldDismissSheet(4, 90, 500), true)
+  assert.equal(shouldDismissSheet(2, 30, 35), true)
+})
+test('a tap, short drag, horizontal swipe or upward drag keeps the sheet open', () => {
+  for (const [x, y, ms] of [[0, 0, 30], [0, 20, 500], [180, 90, 500], [0, -100, 200]]) {
+    assert.equal(shouldDismissSheet(x, y, ms), false)
+  }
+})
diff --git a/src/ui-mobile/sheet-drag.ts b/src/ui-mobile/sheet-drag.ts
new file mode 100644
index 0000000..fbd2a5f
--- /dev/null
+++ b/src/ui-mobile/sheet-drag.ts
@@ -0,0 +1,3 @@
+export function shouldDismissSheet(dx: number, dy: number, elapsed: number): boolean {
+  return dy > Math.abs(dx) && (dy >= 72 || (dy >= 24 && dy / Math.max(1, elapsed) >= 0.6))
+}
diff --git a/src/ui-mobile/sheet-handle.test.ts b/src/ui-mobile/sheet-handle.test.ts
new file mode 100644
index 0000000..ad278ee
--- /dev/null
+++ b/src/ui-mobile/sheet-handle.test.ts
@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { loadMobileModule } from '../../tooling/load-mobile-module.ts'
+
+const { SheetHandle } = await loadMobileModule('./src/ui-mobile/SheetHandle.tsx', {
+  react: { useRef: (current: unknown) => ({ current }) },
+  'react/jsx-runtime': { jsx: (type: unknown, props: unknown) => ({ type, props }) }
+})
+
+function setup() {
+  let dismissed = 0
+  const style = new Map<string, string>()
+  const attributes = new Set<string>()
+  const sheet = { style: { setProperty: (k: string, v: string) => style.set(k, v), removeProperty: (k: string) => style.delete(k) },
+    setAttribute: (k: string) => attributes.add(k), removeAttribute: (k: string) => attributes.delete(k) }
+  const target = { closest: () => sheet, setPointerCapture: () => {} }
+  const handle = SheetHandle({ onDismiss: () => { dismissed++ } }).props
+  const event = (x: number, y: number, timeStamp: number) => ({
+    isPrimary: true, button: 0, pointerId: 1, clientX: x, clientY: y, timeStamp, currentTarget: target
+  })
+  return { handle, event, style, attributes, dismissals: () => dismissed }
+}
+test('real sheet handle handlers move the sheet and dismiss exactly once', () => {
+  const s = setup()
+  s.handle.onPointerDown(s.event(50, 10, 0))
+  s.handle.onPointerMove(s.event(50, 110, 500))
+  assert.equal(s.style.get('--zn-sheet-drag'), '100px')
+  assert.equal(s.attributes.has('data-dragging'), true)
+  s.handle.onPointerUp(s.event(50, 110, 600))
+  s.handle.onClick({ detail: 1 })
+  assert.equal(s.dismissals(), 1)
+  assert.equal(s.style.has('--zn-sheet-drag'), false)
+  assert.equal(s.attributes.has('data-dragging'), false)
+})
+test('short/cancelled drags snap back and do not become close-button clicks', () => {
+  for (const cancel of [true, false]) {
+    const s = setup()
+    s.handle.onPointerDown(s.event(50, 10, 0))
+    s.handle.onPointerMove(s.event(50, 30, 500))
+    if (cancel) s.handle.onPointerCancel()
+    else s.handle.onPointerUp(s.event(50, 30, 600))
+    s.handle.onClick({ detail: 1 })
+    assert.equal(s.dismissals(), 0)
+    assert.equal(s.style.has('--zn-sheet-drag'), false)
+    s.handle.onClick({ detail: 0 })
+    assert.equal(s.dismissals(), 1, 'keyboard activation still closes')
+  }
+})
diff --git a/src/ui-mobile/splash-config.test.ts b/src/ui-mobile/splash-config.test.ts
new file mode 100644
index 0000000..472d842
--- /dev/null
+++ b/src/ui-mobile/splash-config.test.ts
@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict'
+import { readFileSync, existsSync } from 'node:fs'
+import test from 'node:test'
+
+const native = new URL('../../android/app/src/main/', import.meta.url)
+test('all Android versions use the same aspect-preserving splash (#55)', () => {
+  const theme = readFileSync(new URL('res/values/styles.xml', native), 'utf8')
+  assert.match(theme, /name="windowSplashScreenAnimatedIcon">@drawable\/zn_splash_icon/)
+  assert.match(theme, /name="postSplashScreenTheme">@style\/AppTheme.NoActionBar/)
+  const path = new URL('res/drawable/zn_splash_icon.xml', native)
+  assert.ok(existsSync(path))
+  const icon = readFileSync(path, 'utf8')
+  assert.match(icon, /android:width="128dp" android:height="128dp"/)
+  assert.match(icon, /@mipmap\/ic_launcher_foreground/)
+})
+test('splash installs before BridgeActivity switches theme, without a second plugin splash', () => {
+  const activity = readFileSync(new URL('java/md/zennotes/MainActivity.java', native), 'utf8')
+  const install = activity.indexOf('SplashScreen.installSplashScreen(this)')
+  assert.ok(install >= 0 && install < activity.indexOf('super.onCreate(savedInstanceState)'))
+  assert.match(readFileSync(new URL('../../capacitor.config.ts', import.meta.url), 'utf8'), /launchShowDuration: 0/)
+})
diff --git a/src/ui-mobile/wikilink-touch.test.ts b/src/ui-mobile/wikilink-touch.test.ts
new file mode 100644
index 0000000..0c539bf
--- /dev/null
+++ b/src/ui-mobile/wikilink-touch.test.ts
@@ -0,0 +1,66 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { installWikilinkTouchNavigation } from './wikilink-touch.ts'
+
+function setup() {
+  const target = new EventTarget()
+  let time = 0
+  let selected = false
+  const opened: string[] = []
+  const uninstall = installWikilinkTouchNavigation(target as unknown as Document, {
+    hasSelection: () => selected,
+    open: (link) => opened.push(link),
+    now: () => time
+  })
+  const element = { closest: () => ({ dataset: { target: 'A note' } }) }
+  const send = (type: string, x = 20, y = 20, fingers = 1): Event => {
+    const event = new Event(type, { cancelable: true })
+    Object.defineProperties(event, {
+      target: { value: element },
+      touches: { value: Array.from({ length: type === 'touchend' ? 0 : fingers }, (_, i) => ({ identifier: i, clientX: x, clientY: y })) },
+      changedTouches: { value: [{ identifier: 0, clientX: x, clientY: y }] }
+    })
+    target.dispatchEvent(event)
+    return event
+  }
+  return { opened, send, uninstall, tick: (ms: number) => { time += ms }, select: () => { selected = true } }
+}
+
+test('a wikilink opens only after a completed short tap (#50)', () => {
+  const s = setup()
+  s.send('touchstart')
+  assert.deepEqual(s.opened, [])
+  s.tick(100)
+  assert.equal(s.send('touchend').defaultPrevented, true)
+  assert.deepEqual(s.opened, ['A note'])
+  s.uninstall()
+})
+
+for (const action of ['drag', 'long drag', 'long press', 'selection', 'existing selection', 'scroll', 'cancel', 'multitouch']) {
+  test(`a ${action} does not activate a wikilink or its synthesized mouse event`, () => {
+    const s = setup()
+    if (action === 'existing selection') s.select()
+    s.send('touchstart')
+    if (action === 'drag') s.send('touchmove', 20, 70)
+    if (action === 'long drag') { s.send('scroll'); s.tick(2000) }
+    if (action === 'long press') s.tick(600)
+    if (action === 'selection') s.select()
+    if (action === 'scroll') s.send('scroll')
+    if (action === 'cancel') s.send('touchcancel')
+    if (action === 'multitouch') s.send('touchstart', 20, 20, 2)
+    s.send('touchend')
+    assert.deepEqual(s.opened, [])
+    assert.equal(s.send('mousedown').defaultPrevented, true)
+    s.tick(900)
+    assert.equal(s.send('mousedown').defaultPrevented, false)
+    s.uninstall()
+  })
+}
+
+test('cleanup removes gesture listeners', () => {
+  const s = setup()
+  s.uninstall()
+  s.send('touchstart')
+  s.send('touchend')
+  assert.deepEqual(s.opened, [])
+})
diff --git a/src/ui-mobile/wikilink-touch.ts b/src/ui-mobile/wikilink-touch.ts
new file mode 100644
index 0000000..b9aed2c
--- /dev/null
+++ b/src/ui-mobile/wikilink-touch.ts
@@ -0,0 +1,69 @@
+type Options = { hasSelection: () => boolean; open: (target: string) => void; now?: () => number }
+
+export function installWikilinkTouchNavigation(root: Document, options: Options): () => void {
+  const now = options.now ?? Date.now
+  let tap: { target: string; id: number; x: number; y: number; at: number } | null = null
+  let suppressMouseUntil = 0
+  let touchingLink = false
+  const linkAt = (event: Event): HTMLElement | null =>
+    (event.target as HTMLElement | null)?.closest?.<HTMLElement>('.cm-wikilink') ?? null
+  const cancel = (): void => { tap = null }
+  const start = (event: TouchEvent): void => {
+    tap = null
+    const target = linkAt(event)?.dataset.target
+    if (event.touches.length === 1) touchingLink = Boolean(target)
+    else touchingLink ||= Boolean(target)
+    if (!target) return
+    suppressMouseUntil = now() + 800
+    if (event.touches.length !== 1 || options.hasSelection()) return
+    const touch = event.touches[0]
+    tap = { target, id: touch.identifier, x: touch.clientX, y: touch.clientY, at: now() }
+    // Do not cancel touchstart: native scrolling and long-press selection
+    // must be able to take ownership. Save the target before CM reveals its
+    // Markdown source (and removes the link element).
+  }
+  const move = (event: TouchEvent): void => {
+    if (!tap) return
+    const touch = Array.from(event.touches).find((touch) => touch.identifier === tap?.id)
+    if (event.touches.length !== 1 || !touch || options.hasSelection() ||
+        Math.hypot(touch.clientX - tap.x, touch.clientY - tap.y) > 10) cancel()
+  }
+  const end = (event: TouchEvent): void => {
+    if (touchingLink) suppressMouseUntil = now() + 800
+    if (event.touches.length === 0) touchingLink = false
+    const candidate = tap
+    tap = null
+    if (!candidate || event.touches.length !== 0 || options.hasSelection()) return
+    const touch = Array.from(event.changedTouches).find((touch) => touch.identifier === candidate.id)
+    if (!touch || now() - candidate.at > 350 ||
+        Math.hypot(touch.clientX - candidate.x, touch.clientY - candidate.y) > 10) return
+    event.preventDefault()
+    event.stopPropagation()
+    options.open(candidate.target)
+  }
+  const mouse = (event: MouseEvent): void => {
+    // The desktop extension follows mousedown. Never let a touch's delayed
+    // compatibility event follow a link that we rejected as a drag/selection.
+    if (now() >= suppressMouseUntil || !linkAt(event)) return
+    const capabilities = (event as MouseEvent & { sourceCapabilities?: { firesTouchEvents: boolean } }).sourceCapabilities
+    if (capabilities?.firesTouchEvents === false) return
+    event.preventDefault()
+    event.stopImmediatePropagation()
+  }
+  root.addEventListener('touchstart', start, { capture: true, passive: true })
+  root.addEventListener('touchmove', move, { capture: true, passive: true })
+  root.addEventListener('touchend', end, { capture: true, passive: false })
+  root.addEventListener('touchcancel', cancel, { capture: true })
+  root.addEventListener('scroll', cancel, { capture: true })
+  root.addEventListener('mousedown', mouse, { capture: true })
+  root.addEventListener('click', mouse, { capture: true })
+  return () => {
+    root.removeEventListener('touchstart', start, { capture: true })
+    root.removeEventListener('touchmove', move, { capture: true })
+    root.removeEventListener('touchend', end, { capture: true })
+    root.removeEventListener('touchcancel', cancel, { capture: true })
+    root.removeEventListener('scroll', cancel, { capture: true })
+    root.removeEventListener('mousedown', mouse, { capture: true })
+    root.removeEventListener('click', mouse, { capture: true })
+  }
+}
diff --git a/tooling/android-ui-check.html b/tooling/android-ui-check.html
new file mode 100644
index 0000000..17c0c52
--- /dev/null
+++ b/tooling/android-ui-check.html
@@ -0,0 +1,3 @@
+<!doctype html>
+<html class="zn-mobile zn-phone"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Android issue regression fixture</title></head>
+<body><div id="root"></div><script type="module" src="./android-ui-check.tsx"></script></body></html>
diff --git a/tooling/android-ui-check.tsx b/tooling/android-ui-check.tsx
new file mode 100644
index 0000000..ab10e46
--- /dev/null
+++ b/tooling/android-ui-check.tsx
@@ -0,0 +1,68 @@
+/** Manual browser fixture: npm run dev, then /tooling/android-ui-check.html.
+ * Real CM editor, selection toolbar and sheet handle; no account or native
+ * filesystem. This does NOT replace Android IME/selection/splash testing. */
+import React, { useEffect, useRef, useState } from 'react'
+import { createRoot } from 'react-dom/client'
+import { EditorView } from '@codemirror/view'
+import { EditorState } from '@codemirror/state'
+import { EditorSelectionToolbar } from '@zennotes/app-core/components/EditorSelectionToolbar'
+import { installSelectionToolbarSpace } from '../src/ui-mobile/selection-toolbar-space'
+import { SheetHandle } from '../src/ui-mobile/SheetHandle'
+import '@zennotes/app-core/styles/index.css'
+import '../src/ui-mobile/mobile.css'
+
+function Fixture() {
+  const host = useRef<HTMLDivElement>(null)
+  const editor = useRef<EditorView | null>(null)
+  const [selection, setSelection] = useState(false)
+  const [sheet, setSheet] = useState(false)
+  const [result, setResult] = useState('Ready')
+  useEffect(() => {
+    const view = new EditorView({ parent: host.current!, state: EditorState.create({
+      doc: Array.from({ length: 80 }, (_, i) => `Line ${i + 1}: a note with enough text to scroll and select.`).join('\n'),
+      extensions: [EditorView.lineWrapping, EditorView.theme({ '&': { height: '100%' }, '.cm-scroller': { overflow: 'auto' } })]
+    }) })
+    editor.current = view
+    const remove = installSelectionToolbarSpace(() => view.dom, () => {
+      view.dispatch({ effects: EditorView.scrollIntoView(view.state.selection.main.head, { y: 'nearest' }) })
+    })
+    return () => { remove(); view.destroy() }
+  }, [])
+  const measure = () => {
+    const scroller = editor.current!.scrollDOM.getBoundingClientRect()
+    const bar = document.querySelector('[data-selection-toolbar]')?.getBoundingClientRect()
+    const fab = document.querySelector('.zn-mobile-fab')!.getBoundingClientRect()
+    const footer = document.querySelector('[data-cloud-sync-status]')!.parentElement!.getBoundingClientRect()
+    setResult(JSON.stringify({ editorClear: !bar || scroller.bottom <= bar.top,
+      fabClear: fab.bottom <= footer.top, scrollerBottom: Math.round(scroller.bottom),
+      menuTop: bar && Math.round(bar.top), footerHeight: footer.height }))
+  }
+  return <div style={{ height: '100dvh', display: 'flex', flexDirection: 'column' }}>
+    <div style={{ padding: 8, display: 'flex', gap: 12, flexWrap: 'wrap' }}>
+      <button onClick={() => { setSelection(!selection); document.documentElement.classList.toggle('zn-kb-open', !selection) }}>Toggle selection</button>
+      <button onClick={() => setSheet(true)}>Open sheet</button>
+      <button onClick={measure}>Check layout</button>
+      <button onClick={() => {
+        const light = document.documentElement.style.getPropertyValue('--z-bg') !== '250 250 250'
+        document.documentElement.style.setProperty('--z-bg', light ? '250 250 250' : '29 32 33')
+        document.documentElement.style.setProperty('--z-fg', light ? '30 30 30' : '235 219 178')
+      }}>Toggle theme</button>
+      <output style={{ width: '100%', fontSize: 12 }}>{result}</output>
+    </div>
+    <div ref={host} style={{ minHeight: 0, flex: 1 }} />
+    <div className="h-8" style={{ display: 'flex', alignItems: 'center', padding: '0 12px', flexShrink: 0 }}>
+      <span data-cloud-sync-status>Cloud disconnected</span><button data-cloud-sync-action style={{ marginLeft: 'auto' }}>Connect Cloud</button>
+    </div>
+    <button className="zn-mobile-fab" aria-label="Navigation">+</button>
+    {selection && <><div className="zn-editor-toolbar" style={{ height: 52 }}>Keyboard toolbar</div>
+      <EditorSelectionToolbar x={100} y={120} onWrap={() => {}} onLink={() => {}} onComment={() => {}} onBlockType={() => {}} onDismiss={() => setSelection(false)} />
+    </>}
+    {sheet && <><div className="zn-mobile-sheet-backdrop" onClick={() => setSheet(false)} />
+      <div className="zn-mobile-sheet" role="dialog" aria-label="Fixture sheet">
+        <SheetHandle onDismiss={() => { setSheet(false); setResult('Sheet dismissed') }} />
+        <div className="zn-mobile-sheet-title">Vault actions</div>
+        <div className="zn-mobile-sheet-scroll">{Array.from({ length: 20 }, (_, i) => <button key={i} className="zn-mobile-sheet-row">Menu item {i + 1}</button>)}</div>
+      </div></>}
+  </div>
+}
+createRoot(document.getElementById('root')!).render(<Fixture />)
diff --git a/tooling/load-mobile-module.ts b/tooling/load-mobile-module.ts
new file mode 100644
index 0000000..98ee3e0
--- /dev/null
+++ b/tooling/load-mobile-module.ts
@@ -0,0 +1,46 @@
+import { createRequire } from 'node:module'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const require = createRequire(resolve(root, '.zennotes-source/package.json'))
+
+/** Load real TypeScript modules with this mobile app's pinned source aliases. */
+export async function loadMobileModule(
+  entry: string | string[],
+  mocks: Record<string, Record<string, unknown>> = {}
+): Promise<Record<string, any>> {
+  const { build } = require('esbuild')
+  const result = await build({
+    stdin: {
+      contents: (Array.isArray(entry) ? entry : [entry]).map((path) => `export * from ${JSON.stringify(path)};`).join('\n'),
+      resolveDir: root,
+      loader: 'ts'
+    },
+    absWorkingDir: root,
+    tsconfig: resolve(root, 'tsconfig.json'),
+    bundle: true,
+    platform: 'node',
+    format: 'cjs',
+    write: false,
+    plugins: [{
+      name: 'mobile-test-boundaries',
+      setup(plugin: any) {
+        plugin.onResolve({ filter: /.*/ }, (args: { path: string }) =>
+          Object.hasOwn(mocks, args.path) ? { path: args.path, namespace: 'mobile-test-boundary' } : undefined
+        )
+        plugin.onLoad({ filter: /.*/, namespace: 'mobile-test-boundary' }, (args: { path: string }) => ({
+          contents: `module.exports = __mobileTestMocks[${JSON.stringify(args.path)}];`,
+          loader: 'js'
+        }))
+      }
+    }]
+  })
+  const module = { exports: {} }
+  const execute = new Function(
+    'require', 'module', 'exports', '__mobileTestMocks',
+    result.outputFiles[0].text + '\n//# sourceURL=' + entry
+  )
+  execute(require, module, module.exports, mocks)
+  return module.exports
+}