@@ -1,9 +1,65 @@
 use std::fs;
 use std::io::BufWriter;
+use std::sync::OnceLock;
+use std::sync::mpsc;
 
 use arboard::{Clipboard, ImageData};
 use uuid::Uuid;
 
+// Persistent clipboard worker: holds a Clipboard instance alive so X11 keeps
+// responding to SelectionRequest events. Without this, Clipboard drops at the
+// end of each command → X11 releases ownership → clipboard content is lost.
+struct ClipboardWorker {
+    tx: mpsc::SyncSender<String>,
+}
+
+static CLIPBOARD_WORKER: OnceLock<ClipboardWorker> = OnceLock::new();
+
+fn get_clipboard_worker() -> &'static ClipboardWorker {
+    CLIPBOARD_WORKER.get_or_init(|| {
+        let (tx, rx) = mpsc::sync_channel::<String>(4);
+        std::thread::Builder::new()
+            .name("clipboard-writer".into())
+            .spawn(move || {
+                let mut cb = match Clipboard::new() {
+                    Ok(c) => c,
+                    Err(e) => {
+                        log::error!("clipboard worker init failed: {e}");
+                        return;
+                    }
+                };
+                while let Ok(text) = rx.recv() {
+                    if let Err(e) = cb.set_text(&text) {
+                        log::warn!("clipboard set_text failed: {e}");
+                    }
+                }
+            })
+            .ok();
+        ClipboardWorker { tx }
+    })
+}
+
+/// Write plain text to the system clipboard via a persistent arboard worker
+/// thread. Avoids WebKitGTK clipboard API hangs and X11 focus-stealing from
+/// repeated Clipboard::new() calls.
+#[tauri::command]
+pub fn clipboard_write_text(text: String) -> Result<(), String> {
+    get_clipboard_worker()
+        .tx
+        .send(text)
+        .map_err(|e| format!("clipboard write: {e}"))
+}
+
+/// Read plain text from the system clipboard. Returns None when empty.
+#[tauri::command]
+pub fn clipboard_read_text() -> Result<Option<String>, String> {
+    let mut cb = Clipboard::new().map_err(|e| format!("clipboard open: {e}"))?;
+    match cb.get_text() {
+        Ok(t) if !t.is_empty() => Ok(Some(t)),
+        _ => Ok(None),
+    }
+}
+
 /// Read the system clipboard. If it contains a usable image and no text takes
 /// priority, encode it as PNG into the OS temp dir and return the absolute
 /// path. If the clipboard holds text (even alongside an image), return None
 
@@ -64,6 +64,8 @@ pub fn run() {
             buttons::buttons_delete,
             buttons::buttons_reorder,
             clipboard::clipboard_save_image,
+            clipboard::clipboard_write_text,
+            clipboard::clipboard_read_text,
             general::general_get,
             general::general_set,
             tabs::tabs_load_state,
 
@@ -194,24 +194,26 @@ export function TerminalView(props: Props) {
     //
     // In both cases: local tabs get the local /tmp path; SSH tabs have the
     // PNG uploaded to the remote /tmp first and get the remote path.
-    const pasteImage = async () => {
-      if (!props.active) return;
+    // Returns true if an image was found and pasted, false if clipboard had no image.
+    const pasteImage = async (): Promise<boolean> => {
+      if (!props.active) return false;
       const conn = connections().find((c) => c.id === props.tab.connectionId);
-      if (!conn) return;
+      if (!conn) return false;
       const sid = props.tab.sessionId;
       const localPath = await api.clipboardSaveImage();
-      if (!localPath) return;
+      if (!localPath) return false;
       if (conn.kind === "local") {
         term?.paste(quoteShellPath(localPath) + " ");
         term?.focus();
-        return;
+        return true;
       }
-      if (!sid) return;
+      if (!sid) return false;
       setUploading(true);
       try {
         const remotePath = await api.sshUploadFile(sid, localPath);
         term?.paste(quoteShellPath(remotePath) + " ");
         term?.focus();
+        return true;
       } finally {
         setUploading(false);
       }
@@ -240,14 +242,23 @@ export function TerminalView(props: Props) {
       }
     }
 
-    // Ctrl+Shift+V: explicit image paste shortcut, bypasses paste event.
-    const onCtrlShiftV = (e: KeyboardEvent) => {
+    // Ctrl+Shift+V: paste image if clipboard has one, otherwise paste text.
+    const onCtrlShiftV = async (e: KeyboardEvent) => {
       if (!e.ctrlKey || !e.shiftKey || e.altKey || e.key !== "V") return;
       if (!props.active) return;
       e.preventDefault();
-      pasteImage().catch((err) =>
-        console.warn("clipboard image paste failed", err),
-      );
+      try {
+        const didImage = await pasteImage();
+        if (!didImage) {
+          const text = await api.clipboardReadText();
+          if (text) {
+            term?.paste(text);
+            term?.focus();
+          }
+        }
+      } catch (err) {
+        console.warn("clipboard paste failed", err);
+      }
     };
     window.addEventListener("keydown", onCtrlShiftV);
     onCleanup(() => window.removeEventListener("keydown", onCtrlShiftV));
@@ -299,19 +310,35 @@ export function TerminalView(props: Props) {
       return out.join("\n");
     });
 
-    // Auto-copy on selection: when the user finishes a mouse drag and there is
-    // a non-empty selection, push it to the OS clipboard.
-    const onMouseUp = () => {
+    // Auto-copy on selection: fires when the drag ends inside the terminal.
+    const onMouseUp = (e: MouseEvent) => {
+      if (e.button !== 0) return; // middle/right-click must not overwrite clipboard
       if (!term?.hasSelection()) return;
       const sel = term.getSelection();
       if (!sel) return;
-      navigator.clipboard.writeText(sel).catch((e) =>
+      api.clipboardWriteText(sel).catch((e) =>
         console.warn("clipboard write failed", e),
       );
     };
     host.addEventListener("mouseup", onMouseUp);
     onCleanup(() => host.removeEventListener("mouseup", onMouseUp));
 
+    // Ctrl+Shift+C: explicit copy shortcut. Covers the case where the drag
+    // ends outside the terminal (tab bar, etc.) and mouseup didn't fire on
+    // host. Uses native arboard to avoid WebKitGTK clipboard API hangs.
+    const onCopyKey = (e: KeyboardEvent) => {
+      if (!props.active || !e.ctrlKey || !e.shiftKey || e.altKey || e.key !== "C") return;
+      if (!term?.hasSelection()) return;
+      e.preventDefault();
+      const sel = term.getSelection();
+      if (!sel) return;
+      api.clipboardWriteText(sel).catch((e) =>
+        console.warn("clipboard write failed", e),
+      );
+    };
+    window.addEventListener("keydown", onCopyKey);
+    onCleanup(() => window.removeEventListener("keydown", onCopyKey));
+
     // Middle-click: just suppress the browser's auto-scroll affordance.
     // WebKitGTK already does X11-style primary-selection paste into the
     // focused textarea, which xterm forwards via onData — doing our own
 
@@ -97,6 +97,12 @@ export const api = {
    *  image (text-only or empty). */
   clipboardSaveImage: () => invoke<string | null>("clipboard_save_image"),
 
+  /** Write plain text to the OS clipboard via arboard (avoids WebKitGTK clipboard API hangs). */
+  clipboardWriteText: (text: string) => invoke<void>("clipboard_write_text", { text }),
+
+  /** Read plain text from the OS clipboard. Returns null when empty or image-only. */
+  clipboardReadText: () => invoke<string | null>("clipboard_read_text"),
+
   // Command buttons
   buttonsList: () => invoke<CommandButton[]>("buttons_list"),
   buttonsSave: (button: CommandButton) =>