diff --git a/frontend/src/components/TerminalPanel.vue b/frontend/src/components/TerminalPanel.vue
index 64859db..74a0f3a 100644
--- a/frontend/src/components/TerminalPanel.vue
+++ b/frontend/src/components/TerminalPanel.vue
@@ -1,6 +1,9 @@
 <script setup>
 import { watch } from 'vue'
 import { useTerminal } from '../composables/useTerminal'
+import { useSettingsStore } from '../stores/settings'
+
+const settingsStore = useSettingsStore()
 
 const props = defineProps({
     sessionId: {
@@ -13,7 +16,7 @@ const props = defineProps({
     },
 })
 
-const { containerRef, isConnected, started, start, reconnect } = useTerminal(props.sessionId)
+const { containerRef, isConnected, started, start, reconnect, copyMode } = useTerminal(props.sessionId)
 
 // Lazy init: start the terminal only when the tab becomes active for the first time
 watch(
@@ -29,6 +32,20 @@ watch(
 
 <template>
     <div class="terminal-panel">
+        <!-- Mobile toolbar — copy mode toggle -->
+        <div v-if="settingsStore.isTouchDevice && started" class="mobile-toolbar">
+            <span class="toolbar-spacer"></span>
+            <wa-button
+                size="small"
+                :appearance="copyMode ? 'filled' : 'plain'"
+                :variant="copyMode ? 'brand' : 'neutral'"
+                @click="copyMode = !copyMode"
+            >
+                <wa-icon slot="start" name="copy"></wa-icon>
+                Copy
+            </wa-button>
+        </div>
+
         <div ref="containerRef" class="terminal-container"></div>
 
         <!-- Disconnect overlay -->
@@ -76,6 +93,19 @@ watch(
     overflow-y: auto !important;
 }
 
+.mobile-toolbar {
+    display: flex;
+    align-items: center;
+    gap: var(--wa-space-2xs);
+    padding: var(--wa-space-2xs) var(--wa-space-xs);
+    flex-shrink: 0;
+    border-bottom: 1px solid var(--wa-color-border-default);
+}
+
+.toolbar-spacer {
+    flex: 1;
+}
+
 .disconnect-overlay {
     position: absolute;
     inset: 0;
diff --git a/frontend/src/composables/useTerminal.js b/frontend/src/composables/useTerminal.js
index 8ee6316..940bf1c 100644
--- a/frontend/src/composables/useTerminal.js
+++ b/frontend/src/composables/useTerminal.js
@@ -4,7 +4,8 @@ import { ref, watch, onMounted, onUnmounted } from 'vue'
 import { Terminal } from '@xterm/xterm'
 import { FitAddon } from '@xterm/addon-fit'
 import { WebLinksAddon } from '@xterm/addon-web-links'
-import { ClipboardAddon } from '@xterm/addon-clipboard'
+// ClipboardAddon intentionally not loaded — Ctrl+V must reach the shell
+// (e.g. bash quoted-insert). Paste is handled by right-click / middle-click.
 import { useSettingsStore } from '../stores/settings'
 import { useDataStore } from '../stores/data'
 import { toast } from '../composables/useToast'
@@ -99,12 +100,31 @@ export function useTerminal(sessionId) {
     /** @type {boolean} */
     let intentionalClose = false
 
+    // ── Touch mode (mobile): scroll (default) vs copy ─────────────────────
+    const copyMode = ref(false)
+
+    /** Whether the active tmux pane is in alternate screen (less, vim, etc.) */
+    const paneAlternate = ref(false)
+
     // ── Touch selection state (mobile) ─────────────────────────────────────
     let selectStartCol = 0
     let selectStartRow = 0
     /** @type {AbortController | null} */
     let touchAbortController = null
 
+    // ── Mouse interception state (desktop, tmux mode) ─────────────────────
+    /** @type {AbortController | null} */
+    let mouseAbortController = null
+    /** Whether a mouse-drag selection is in progress */
+    let mouseIsSelecting = false
+    /** Start coordinates for mouse selection (terminal cells + screen pixels) */
+    let mouseStartCol = 0
+    let mouseStartRow = 0
+    let mouseStartX = 0
+    let mouseStartY = 0
+    /** Drag threshold in pixels before selection starts */
+    const MOUSE_DRAG_THRESHOLD = 3
+
     /**
      * Check whether tmux should actually be used for this session.
      * Tmux is skipped for draft and archived sessions.
@@ -157,8 +177,21 @@ export function useTerminal(sessionId) {
         }
 
         ws.onmessage = (event) => {
-            // Server sends raw PTY output as text
-            terminal?.write(event.data)
+            const data = event.data
+            // Detect JSON control messages from the server
+            if (data.charAt(0) === '{') {
+                try {
+                    const msg = JSON.parse(data)
+                    if (msg.type === 'pane_state') {
+                        paneAlternate.value = msg.alternate_on
+                        return
+                    }
+                } catch {
+                    // Not valid JSON — fall through to terminal.write
+                }
+            }
+            // Raw PTY output
+            terminal?.write(data)
         }
 
         ws.onclose = (event) => {
@@ -233,6 +266,10 @@ export function useTerminal(sessionId) {
 
     /** Whether the current touch gesture is a selection (vs scrollbar drag). */
     let touchIsSelecting = false
+    /** Y coordinate at touch start — used to compute scroll delta in scroll mode. */
+    let touchStartY = 0
+    /** Accumulated fractional scroll lines (sub-line deltas carry over). */
+    let scrollAccumulator = 0
 
     function onTouchStart(e) {
         // Ignore touches on the custom scrollbar — let xterm.js handle those via pointer events
@@ -240,28 +277,74 @@ export function useTerminal(sessionId) {
             touchIsSelecting = false
             return
         }
-        touchIsSelecting = true
         const touch = e.touches[0]
-        const coords = screenToTerminalCoords(touch.clientX, touch.clientY)
-        selectStartCol = coords.col
-        selectStartRow = coords.row
-        terminal?.clearSelection()
+        if (copyMode.value) {
+            // Copy mode: start text selection
+            touchIsSelecting = true
+            const coords = screenToTerminalCoords(touch.clientX, touch.clientY)
+            selectStartCol = coords.col
+            selectStartRow = coords.row
+            terminal?.clearSelection()
+        } else {
+            // Scroll mode: record start position
+            touchIsSelecting = false
+            touchStartY = touch.clientY
+            scrollAccumulator = 0
+        }
     }
 
     function onTouchMove(e) {
-        if (!touchIsSelecting || !terminal) return
+        if (!terminal) return
         const touch = e.touches[0]
-        const coords = screenToTerminalCoords(touch.clientX, touch.clientY)
-        const startOffset = selectStartRow * terminal.cols + selectStartCol
-        const currentOffset = coords.row * terminal.cols + coords.col
-        const length = currentOffset - startOffset
 
-        if (length > 0) {
-            terminal.select(selectStartCol, selectStartRow, length)
-        } else if (length < 0) {
-            terminal.select(coords.col, coords.row, -length)
+        if (copyMode.value && touchIsSelecting) {
+            // Copy mode: update text selection
+            const coords = screenToTerminalCoords(touch.clientX, touch.clientY)
+            const startOffset = selectStartRow * terminal.cols + selectStartCol
+            const currentOffset = coords.row * terminal.cols + coords.col
+            const length = currentOffset - startOffset
+
+            if (length > 0) {
+                terminal.select(selectStartCol, selectStartRow, length)
+            } else if (length < 0) {
+                terminal.select(coords.col, coords.row, -length)
+            }
+            e.preventDefault()
+        } else if (!copyMode.value) {
+            // Scroll mode: convert touch swipe into terminal scroll.
+            // Uses "natural" scrolling: swipe up → see content below, swipe down → see history.
+            const screenEl = terminal.element?.querySelector('.xterm-screen')
+            if (!screenEl) return
+            const deltaY = touchStartY - touch.clientY
+            touchStartY = touch.clientY
+            const rect = screenEl.getBoundingClientRect()
+            const cellHeight = rect.height / terminal.rows
+
+            scrollAccumulator += deltaY
+            // Process one line per cell-height of accumulated movement
+            while (Math.abs(scrollAccumulator) >= cellHeight) {
+                const direction = scrollAccumulator > 0 ? 1 : -1
+
+                if (paneAlternate.value) {
+                    // Pane is in alternate screen (less, vim, htop, etc.):
+                    // Send arrow keys — the app handles scrolling.
+                    wsSend({ type: 'input', data: direction > 0 ? '\x1b[B' : '\x1b[A' })
+                } else if (shouldUseTmux()) {
+                    // Shell prompt inside tmux: send SGR mouse wheel sequences.
+                    // tmux copy-mode handles the scrollback.
+                    const col = Math.max(1, Math.floor((touch.clientX - rect.left) / (rect.width / terminal.cols)) + 1)
+                    const row = Math.max(1, Math.floor((touch.clientY - rect.top) / cellHeight) + 1)
+                    const button = direction > 0 ? 65 : 64
+                    wsSend({ type: 'input', data: `\x1b[<${button};${col};${row}M` })
+                } else {
+                    // Raw shell (no tmux): scroll xterm.js viewport buffer.
+                    terminal.scrollLines(direction)
+                }
+
+                scrollAccumulator -= direction * cellHeight
+            }
+            e.preventDefault()
         }
-        e.preventDefault()
     }
 
     /**
@@ -288,6 +371,170 @@ export function useTerminal(sessionId) {
         }
     }
 
+    // ── Mouse interception (desktop, tmux mode) ─────────────────────────
+    //
+    // When tmux enables SGR mouse tracking, xterm.js converts all mouse
+    // events into escape sequences sent to the PTY instead of doing local
+    // text selection. A single capture-phase mousedown listener blocks all
+    // mouse buttons from reaching xterm.js (no SGR reports to tmux).
+    //
+    // - Left-button: preventDefault + custom selection via terminal.select()
+    // - Middle/right-click: stopPropagation only — browser default actions
+    //   (paste from X11 selection, context menu) flow through normally.
+    //   xterm.js handles the resulting paste event on its internal textarea.
+    // - Mouse wheel: NOT intercepted (tmux scrollback continues to work).
+
+    /**
+     * Select the word at the given terminal buffer coordinates.
+     * Reads the buffer line and expands around the click position
+     * using whitespace as word boundary.
+     */
+    function selectWordAt(col, row) {
+        if (!terminal) return
+        const line = terminal.buffer.active.getLine(row)
+        if (!line) return
+
+        let lineStr = ''
+        for (let i = 0; i < terminal.cols; i++) {
+            const cell = line.getCell(i)
+            lineStr += cell ? cell.getChars() || ' ' : ' '
+        }
+
+        // Expand left
+        let start = col
+        while (start > 0 && !/\s/.test(lineStr[start - 1])) start--
+        // Expand right
+        let end = col
+        while (end < terminal.cols - 1 && !/\s/.test(lineStr[end + 1])) end++
+
+        const length = end - start + 1
+        if (length > 0) {
+            terminal.select(start, row, length)
+        }
+    }
+
+    /**
+     * Select the entire line at the given terminal buffer row.
+     */
+    function selectLineAt(row) {
+        if (!terminal) return
+        terminal.select(0, row, terminal.cols)
+    }
+
+    /**
+     * Handle mousedown in capture phase on the terminal container.
+     * Intercepts left-button clicks to implement local text selection
+     * instead of letting xterm.js send SGR mouse reports to tmux.
+     */
+    function onMouseDownIntercept(e) {
+        // Let Shift+click pass through — xterm.js handles it as forced selection
+        if (e.shiftKey) return
+
+        // Block all mouse buttons from reaching xterm.js (prevents SGR mouse
+        // reports to tmux). Only preventDefault for left button — middle/right-click
+        // default actions (paste / context menu) must flow through normally.
+        e.stopPropagation()
+        if (e.button !== 0) return
+        e.preventDefault()
+
+        // Focus the terminal (xterm.js normally does this in its own mousedown)
+        terminal?.focus()
+
+        const coords = screenToTerminalCoords(e.clientX, e.clientY)
+
+        if (e.detail === 2) {
+            // Double-click: select word
+            selectWordAt(coords.col, coords.row)
+            return
+        }
+        if (e.detail >= 3) {
+            // Triple-click: select line
+            selectLineAt(coords.row)
+            return
+        }
+
+        // Single click: prepare for potential drag selection
+        mouseIsSelecting = false
+        mouseStartCol = coords.col
+        mouseStartRow = coords.row
+        mouseStartX = e.clientX
+        mouseStartY = e.clientY
+
+        terminal?.clearSelection()
+
+        // Track drag on document so we capture moves outside the terminal area
+        document.addEventListener('mousemove', onMouseMoveIntercept)
+        document.addEventListener('mouseup', onMouseUpIntercept)
+    }
+
+    /**
+     * Handle mousemove during a potential drag selection.
+     * Added on document, active only between mousedown and mouseup.
+     */
+    function onMouseMoveIntercept(e) {
+        if (!terminal) return
+
+        // Apply drag threshold before starting selection
+        if (!mouseIsSelecting) {
+            const dx = e.clientX - mouseStartX
+            const dy = e.clientY - mouseStartY
+            if (Math.abs(dx) < MOUSE_DRAG_THRESHOLD && Math.abs(dy) < MOUSE_DRAG_THRESHOLD) {
+                return
+            }
+            mouseIsSelecting = true
+        }
+
+        const coords = screenToTerminalCoords(e.clientX, e.clientY)
+        const startOffset = mouseStartRow * terminal.cols + mouseStartCol
+        const currentOffset = coords.row * terminal.cols + coords.col
+        const length = currentOffset - startOffset
+
+        if (length > 0) {
+            terminal.select(mouseStartCol, mouseStartRow, length)
+        } else if (length < 0) {
+            terminal.select(coords.col, coords.row, -length)
+        }
+    }
+
+    /**
+     * Handle mouseup — finalize selection and clean up document listeners.
+     * The existing onSelectionChange handler auto-copies to clipboard.
+     */
+    function onMouseUpIntercept() {
+        document.removeEventListener('mousemove', onMouseMoveIntercept)
+        document.removeEventListener('mouseup', onMouseUpIntercept)
+        mouseIsSelecting = false
+    }
+
+    /**
+     * Attach capture-phase mouse event listeners that intercept left-button
+     * click/drag and right/middle-click when in tmux mode on desktop.
+     * Mouse wheel events are NOT intercepted — they continue to flow to
+     * xterm.js for tmux scrolling.
+     */
+    function attachMouseInterceptListeners() {
+        if (!containerRef.value || settingsStore.isTouchDevice) return
+        if (!shouldUseTmux()) return
+
+        mouseAbortController = new AbortController()
+        const signal = mouseAbortController.signal
+
+        containerRef.value.addEventListener('mousedown', onMouseDownIntercept, { capture: true, signal })
+    }
+
+    /**
+     * Detach mouse interception listeners.
+     */
+    function detachMouseInterceptListeners() {
+        if (mouseAbortController) {
+            mouseAbortController.abort()
+            mouseAbortController = null
+        }
+        // Also clean up any lingering document-level drag listeners
+        document.removeEventListener('mousemove', onMouseMoveIntercept)
+        document.removeEventListener('mouseup', onMouseUpIntercept)
+    }
+
     /**
      * Initialize the xterm.js Terminal and attach it to the container,
      * then connect the WebSocket.
@@ -311,7 +558,7 @@ export function useTerminal(sessionId) {
         fitAddon = new FitAddon()
         terminal.loadAddon(fitAddon)
         terminal.loadAddon(new WebLinksAddon())
-        terminal.loadAddon(new ClipboardAddon())
+        // No ClipboardAddon — Ctrl+V goes to the shell, paste via right/middle-click
 
         terminal.open(containerRef.value)
 
@@ -350,6 +597,8 @@ export function useTerminal(sessionId) {
                     if (finalSelection) {
                         clipboardWrite(finalSelection)
                         toast.success('Copied to clipboard', { duration: 2000 })
+                        // Auto-exit copy mode after successful copy
+                        copyMode.value = false
                     }
                 }, 500)
             }
@@ -376,6 +625,10 @@ export function useTerminal(sessionId) {
         // Attach touch listeners for mobile text selection
         attachTouchListeners()
 
+        // Attach mouse interception for tmux mode on desktop
+        // (intercepts left-drag for selection, right/middle-click for paste)
+        attachMouseInterceptListeners()
+
         // Connect to the backend
         connectWs()
     }
@@ -403,6 +656,21 @@ export function useTerminal(sessionId) {
         connectWs()
     }
 
+    /**
+     * Send raw input data to the PTY (e.g. control characters).
+     * @param {string} data
+     */
+    function sendInput(data) {
+        wsSend({ type: 'input', data })
+    }
+
+    /**
+     * Focus the xterm.js terminal (e.g. after selecting from a dropdown).
+     */
+    function focusTerminal() {
+        terminal?.focus()
+    }
+
     /**
      * Clean up everything: terminal, WebSocket, observers.
      */
@@ -410,6 +678,7 @@ export function useTerminal(sessionId) {
         intentionalClose = true
 
         detachTouchListeners()
+        detachMouseInterceptListeners()
 
         if (resizeObserver) {
             resizeObserver.disconnect()
@@ -471,5 +740,5 @@ export function useTerminal(sessionId) {
         cleanup()
     })
 
-    return { containerRef, isConnected, started, start, reconnect }
+    return { containerRef, isConnected, started, start, reconnect, sendInput, focusTerminal, copyMode }
 }
diff --git a/src/twicc/terminal.py b/src/twicc/terminal.py
index 9922005..72b3dba 100644
--- a/src/twicc/terminal.py
+++ b/src/twicc/terminal.py
@@ -13,8 +13,10 @@
     { "type": "input", "data": "ls -la\n" }       — keyboard input
     { "type": "resize", "cols": 120, "rows": 30 }  — terminal resize
 
-  Server → Client (plain text frames):
-    Raw PTY output (no JSON wrapping for performance).
+  Server → Client:
+    Plain text frames — raw PTY output (no JSON wrapping for performance).
+    JSON text frames (when type field present) — control responses:
+      { "type": "pane_state", "alternate_on": true }  — pane screen mode
 """
 
 import asyncio
@@ -291,6 +293,115 @@ def kill_tmux_session(session_id: str) -> bool:
         return False
 
 
+def tmux_set_option(session_id: str, option: str, value: str) -> bool:
+    """Set a tmux session option.
+
+    Returns True on success, False on failure.
+    """
+    tmux_path = get_tmux_path()
+    if tmux_path is None:
+        return False
+
+    name = tmux_session_name(session_id)
+    try:
+        result = subprocess.run(
+            [tmux_path, "-L", TMUX_SOCKET_NAME, "set-option", "-t", name, option, value],
+            capture_output=True, timeout=5,
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, OSError):
+        return False
+
+
+def tmux_pane_is_alternate(session_id: str) -> bool:
+    """Check if the active pane of the active window is in alternate screen mode.
+
+    Alternate screen is used by full-screen apps (less, vim, htop, etc.).
+    This allows the frontend to choose the right scroll strategy:
+    - Alternate on: send arrow keys (the app handles scrolling)
+    - Alternate off: send mouse wheel (tmux copy-mode scrolls the buffer)
+    """
+    tmux_path = get_tmux_path()
+    if tmux_path is None:
+        return False
+
+    name = tmux_session_name(session_id)
+    try:
+        result = subprocess.run(
+            [tmux_path, "-L", TMUX_SOCKET_NAME, "display-message",
+             "-t", name, "-p", "#{alternate_on}"],
+            capture_output=True, text=True, timeout=5,
+        )
+        return result.stdout.strip() == "1"
+    except (subprocess.TimeoutExpired, OSError):
+        return False
+
+
+def _configure_tmux_scroll_bindings() -> None:
+    """Configure tmux mouse wheel bindings for proper scroll in all contexts.
+
+    Overrides the default WheelUpPane / WheelDownPane bindings so that:
+    - If the pane is already in copy-mode or the app captures the mouse
+      (e.g. vim with mouse): pass the mouse event through (send-keys -M).
+    - If the pane is in alternate screen mode (less, htop, etc.) WITHOUT
+      mouse capture: send arrow keys so the app scrolls natively.
+    - Otherwise (shell prompt): enter copy-mode for tmux scrollback.
+
+    These bindings are server-wide (shared by all twicc tmux sessions on
+    the same socket), so setting them repeatedly is harmless.
+    """
+    tmux_path = get_tmux_path()
+    if tmux_path is None:
+        return
+
+    condition = "#{||:#{pane_in_mode},#{mouse_any_flag}}"
+
+    for event, arrow_keys, normal_cmd in [
+        ("WheelUpPane", "Up Up Up", "copy-mode -e ; send-keys -M"),
+        ("WheelDownPane", "Down Down Down", "send-keys -M"),
+    ]:
+        alt_branch = (
+            f'if-shell -F "#{{alternate_on}}" '
+            f'"send-keys {arrow_keys}" '
+            f'"{normal_cmd}"'
+        )
+        subprocess.run(
+            [tmux_path, "-L", TMUX_SOCKET_NAME,
+             "bind-key", "-T", "root", event,
+             "if-shell", "-F", condition, "send-keys -M", alt_branch],
+            capture_output=True, timeout=5,
+        )
+
+
+# ── tmux pane state monitor ──────────────────────────────────────────────
+
+# Polling interval for detecting pane state changes (alternate screen)
+_PANE_POLL_INTERVAL = 2  # seconds
+
+
+async def _tmux_pane_monitor(session_id: str, send) -> None:
+    """Periodically check for tmux pane state changes and push updates.
+
+    Detects when the active pane switches between normal and alternate screen
+    (e.g., entering/exiting less or vim). Sends state to the frontend so
+    scroll behavior stays in sync.
+    """
+    prev_alternate = await asyncio.to_thread(tmux_pane_is_alternate, session_id)
+    try:
+        while True:
+            await asyncio.sleep(_PANE_POLL_INTERVAL)
+            alternate = await asyncio.to_thread(tmux_pane_is_alternate, session_id)
+            if alternate != prev_alternate:
+                prev_alternate = alternate
+                await send({"type": "websocket.send",
+                            "text": json.dumps({"type": "pane_state",
+                                                "alternate_on": alternate})})
+    except asyncio.CancelledError:
+        return
+    except Exception:
+        return
+
+
 # ── Raw ASGI WebSocket application ────────────────────────────────────────
 
 async def terminal_application(scope, receive, send):
@@ -353,6 +464,13 @@ async def terminal_application(scope, receive, send):
     # ── Accept connection ─────────────────────────────────────────────
     await send({"type": "websocket.accept"})
 
+    # Configure tmux session for scroll support
+    if use_tmux:
+        # Enable mouse mode so wheel events scroll the buffer (not command history)
+        tmux_set_option(session_id, "mouse", "on")
+        # Override default wheel bindings for proper scroll in less/htop/etc.
+        _configure_tmux_scroll_bindings()
+
     # ── PTY output reader task ────────────────────────────────────────
     # Uses add_reader for event-driven reading, and an asyncio.Queue
     # to bridge the sync callback to the async send loop.
@@ -441,10 +559,19 @@ async def receive_loop():
 
     recv_task = asyncio.create_task(receive_loop())
 
+    # ── tmux pane monitor (detects alternate screen changes) ─────────
+    monitor_task = None
+    if use_tmux:
+        monitor_task = asyncio.create_task(_tmux_pane_monitor(session_id, send))
+
     try:
         # Wait for either the PTY to die or the client to disconnect
+        tasks = [sender_task, recv_task]
+        if monitor_task:
+            tasks.append(monitor_task)
+
         done, pending = await asyncio.wait(
-            [sender_task, recv_task],
+            tasks,
             return_when=asyncio.FIRST_COMPLETED,
         )
 
@@ -467,4 +594,10 @@ async def receive_loop():
         logger.exception("Error in terminal WebSocket for session %s", session_id)
     finally:
         # ── Cleanup ───────────────────────────────────────────────────
+        if monitor_task and not monitor_task.done():
+            monitor_task.cancel()
+            try:
+                await monitor_task
+            except asyncio.CancelledError:
+                pass
         cleanup_pty(master_fd, child_pid)