diff --git a/Sources/FileDropOverlayMouseDragButton.swift b/Sources/FileDropOverlayMouseDragButton.swift
new file mode 100644
index 000000000000..37ebfe24f5fc
--- /dev/null
+++ b/Sources/FileDropOverlayMouseDragButton.swift
@@ -0,0 +1,6 @@
+/// Identifies the mouse button whose AppKit drag target is captured.
+enum FileDropOverlayMouseDragButton: Hashable {
+    case left
+    case right
+    case other(Int)
+}
diff --git a/Sources/FileDropOverlayMouseDragTarget.swift b/Sources/FileDropOverlayMouseDragTarget.swift
new file mode 100644
index 000000000000..aac803e3f42b
--- /dev/null
+++ b/Sources/FileDropOverlayMouseDragTarget.swift
@@ -0,0 +1,10 @@
+import AppKit
+
+/// Weakly captures one AppKit view for the lifetime of a forwarded drag.
+final class FileDropOverlayMouseDragTarget {
+    weak var view: NSView?
+
+    init(view: NSView) {
+        self.view = view
+    }
+}
diff --git a/Sources/FileDropOverlayView.swift b/Sources/FileDropOverlayView.swift
index f0ccbbac1d75..f1351010a933 100644
--- a/Sources/FileDropOverlayView.swift
+++ b/Sources/FileDropOverlayView.swift
@@ -40,11 +40,14 @@ extension BrowserPaneDropTargetView: FileDropPaneTarget {
 /// Mouse events are forwarded to the views below via a hide-send-unhide pattern so clicks,
 /// scrolls, and other interactions pass through normally.
 final class FileDropOverlayView: NSView {
+    private typealias ForwardedMouseDragButton = FileDropOverlayMouseDragButton
+    private typealias ForwardedMouseDragTarget = FileDropOverlayMouseDragTarget
+
     /// Fallback handler when no terminal is found under the drop point.
     var onDrop: (([URL]) -> Bool)?
     private var isForwardingMouseEvent = false
-    private weak var forwardedMouseDragTarget: NSView?
-    private var forwardedMouseDragButton: ForwardedMouseDragButton?
+    private var forwardedMouseDragTargets:
+        [ForwardedMouseDragButton: ForwardedMouseDragTarget] = [:]
     /// The WKWebView currently receiving forwarded drag events, so we can
     /// synthesize draggingExited/draggingEntered as the cursor moves.
     weak var activeDragWebView: WKWebView?
@@ -74,12 +77,6 @@ final class FileDropOverlayView: NSView {
 
     required init?(coder: NSCoder) { fatalError("init(coder:) not implemented") }
 
-    private enum ForwardedMouseDragButton: Equatable {
-        case left
-        case right
-        case other(Int)
-    }
-
     private func dragButton(for event: NSEvent) -> ForwardedMouseDragButton? {
         switch event.type {
         case .leftMouseDown, .leftMouseUp, .leftMouseDragged:
@@ -111,6 +108,67 @@ final class FileDropOverlayView: NSView {
         }
     }
 
+    /// Clears one captured target, or every capture when `button` is nil.
+    /// All forwarded-drag reset paths go through this method so target and
+    /// button ownership cannot be cleared independently.
+    private func clearForwardedMouseDragState(
+        for button: ForwardedMouseDragButton? = nil,
+        reason: String
+    ) {
+#if DEBUG
+        let buttons: String
+        if let button {
+            buttons = String(describing: button)
+        } else {
+            buttons = forwardedMouseDragTargets.keys
+                .map(String.init(describing:))
+                .sorted()
+                .joined(separator: ",")
+        }
+        if !buttons.isEmpty {
+            dlog(
+                "overlay.forwardedDrag.reset reason=\(reason) " +
+                "button=\(buttons)"
+            )
+        }
+#endif
+        if let button {
+            forwardedMouseDragTargets.removeValue(forKey: button)
+        } else {
+            forwardedMouseDragTargets.removeAll(keepingCapacity: true)
+        }
+    }
+
+    private func repairForwardedMouseDragStateIfNeeded(for event: NSEvent) {
+        // A portal target can disappear independently for each button. Drop
+        // only the detached capture so another button's drag remains intact.
+        for button in Array(forwardedMouseDragTargets.keys) {
+            guard let target = forwardedMouseDragTargets[button]?.view else {
+                clearForwardedMouseDragState(for: button, reason: "targetDetached")
+                continue
+            }
+            guard target.window != nil else {
+                clearForwardedMouseDragState(for: button, reason: "targetDetached")
+                continue
+            }
+        }
+
+        if let eventButton = dragButton(for: event),
+           shouldTrackForwardedMouseDragStart(for: event.type),
+           forwardedMouseDragTargets[eventButton] != nil {
+            clearForwardedMouseDragState(for: eventButton, reason: "repeatedMouseDown")
+        }
+    }
+
+    private func isForwardedMouseDragMotion(_ eventType: NSEvent.EventType) -> Bool {
+        switch eventType {
+        case .leftMouseDragged, .rightMouseDragged, .otherMouseDragged:
+            return true
+        default:
+            return false
+        }
+    }
+
     // MARK: Hit-testing — participation is routed by DragOverlayRoutingPolicy so
     // file-drop, bonsplit tab drags, and sidebar tab reorder drags cannot conflict.
 
@@ -155,6 +213,7 @@ final class FileDropOverlayView: NSView {
     private func forwardEvent(_ event: NSEvent) {
         guard !isForwardingMouseEvent else { return }
         guard let window, let contentView = window.contentView else { return }
+        repairForwardedMouseDragStateIfNeeded(for: event)
         let eventButton = dragButton(for: event)
 
         isForwardingMouseEvent = true
@@ -166,30 +225,33 @@ final class FileDropOverlayView: NSView {
 
         let target: NSView?
         if let eventButton,
-           forwardedMouseDragButton == eventButton,
-           let activeTarget = forwardedMouseDragTarget,
+           (isForwardedMouseDragMotion(event.type)
+            || shouldTrackForwardedMouseDragEnd(for: event.type)),
+           let activeTarget = forwardedMouseDragTargets[eventButton]?.view,
            activeTarget.window != nil {
-            // Preserve normal AppKit mouse-delivery semantics: once a drag starts,
-            // keep routing dragged/up events to the original mouseDown target.
+            // Preserve normal AppKit mouse-delivery semantics: once a drag
+            // starts, keep routing dragged/up events to that button's original
+            // mouseDown target.
             target = activeTarget
         } else {
+            // A stale file-drop pasteboard can make the overlay receive a
+            // dragged/up event even though its down was delivered underneath.
+            // Recover the normal target in that case instead of dropping the
+            // event and leaving the underlying selection gesture incomplete.
             let point = contentView.convert(event.locationInWindow, from: nil)
             target = contentView.hitTest(point)
         }
 
         guard let target, target !== self else {
             if shouldTrackForwardedMouseDragEnd(for: event.type),
-               let eventButton,
-               forwardedMouseDragButton == eventButton {
-                forwardedMouseDragTarget = nil
-                forwardedMouseDragButton = nil
+               let eventButton {
+                clearForwardedMouseDragState(for: eventButton, reason: "targetUnavailable")
             }
             return
         }
 
         if shouldTrackForwardedMouseDragStart(for: event.type), let eventButton {
-            forwardedMouseDragTarget = target
-            forwardedMouseDragButton = eventButton
+            forwardedMouseDragTargets[eventButton] = ForwardedMouseDragTarget(view: target)
         }
 
         switch event.type {
@@ -207,10 +269,15 @@ final class FileDropOverlayView: NSView {
         }
 
         if shouldTrackForwardedMouseDragEnd(for: event.type),
-           let eventButton,
-           forwardedMouseDragButton == eventButton {
-            forwardedMouseDragTarget = nil
-            forwardedMouseDragButton = nil
+           let eventButton {
+            clearForwardedMouseDragState(for: eventButton, reason: "mouseUp")
+        }
+    }
+
+    override func viewDidMoveToWindow() {
+        super.viewDidMoveToWindow()
+        if window == nil {
+            clearForwardedMouseDragState(reason: "overlayDetached")
         }
     }
 
diff --git a/Sources/GhosttyMouseSessionLedger.swift b/Sources/GhosttyMouseSessionLedger.swift
new file mode 100644
index 000000000000..f51323832b2a
--- /dev/null
+++ b/Sources/GhosttyMouseSessionLedger.swift
@@ -0,0 +1,152 @@
+import AppKit
+import GhosttyKit
+
+/// Owns the button sessions that a ``GhosttyNSView`` has sent to one native
+/// Ghostty surface.
+///
+/// A session is bound to the runtime generation and native pointer that
+/// received its press.  Releasing a session therefore requires the same
+/// generation token; a later surface or press cannot be released by an older
+/// event.  Pointer coordinates are kept in the same ledger so a synthesized
+/// release uses the last event belonging to that surface.
+final class GhosttyMouseSessionLedger {
+    private(set) var activeSurface: SurfaceIdentity?
+    private(set) var pointerState: PointerState?
+    private var sessions: [Button: Session] = [:]
+    private var nextGeneration: UInt64 = 0
+
+    /// The buttons currently owned by this ledger.
+    var activeButtons: Set<Button> {
+        Set(sessions.keys)
+    }
+
+    /// Returns the sessions currently owned by `surface` in deterministic
+    /// button order.
+    func sessions(on surface: SurfaceIdentity?) -> [Session] {
+        guard let surface else { return [] }
+        return sessions.values
+            .filter { $0.surface == surface }
+            .sorted { lhs, rhs in
+                lhs.button.ordering < rhs.button.ordering
+            }
+    }
+
+    /// Whether the ledger owns a session for `button` on `surface`.
+    func hasSession(
+        for button: Button,
+        on surface: SurfaceIdentity?
+    ) -> Bool {
+        guard let surface else { return false }
+        return sessions[button]?.surface == surface
+    }
+
+    /// Returns the current session for `button` only when it belongs to
+    /// `surface`.
+    func session(
+        for button: Button,
+        on surface: SurfaceIdentity?
+    ) -> Session? {
+        guard let surface,
+              let session = sessions[button],
+              session.surface == surface else {
+            return nil
+        }
+        return session
+    }
+
+    /// Changes the native-surface identity and invalidates sessions from the
+    /// previous runtime.  This is the only transition that can replace the
+    /// ledger's surface owner.
+    @discardableResult
+    func transition(to surface: SurfaceIdentity?) -> Bool {
+        guard activeSurface != surface else { return false }
+        let hadState = !sessions.isEmpty || pointerState != nil
+        sessions.removeAll(keepingCapacity: true)
+        pointerState = nil
+        activeSurface = surface
+        return hadState
+    }
+
+    /// Invalidates all pointer state, including a detached surface.
+    func invalidate() {
+        sessions.removeAll(keepingCapacity: true)
+        pointerState = nil
+        activeSurface = nil
+    }
+
+    /// Records the latest pointer snapshot for the current surface.
+    ///
+    /// Callers must transition the ledger before recording.  A mismatched
+    /// snapshot is ignored rather than being allowed to move state to a
+    /// replacement runtime implicitly.
+    func rememberPointer(
+        _ pointer: PointerState,
+        on surface: SurfaceIdentity
+    ) {
+        guard activeSurface == surface else { return }
+        pointerState = pointer
+    }
+
+    /// Starts a new button session on the current surface.
+    @discardableResult
+    func begin(
+        _ button: Button,
+        on surface: SurfaceIdentity
+    ) -> Session? {
+        guard activeSurface == surface else { return nil }
+        nextGeneration &+= 1
+        let session = Session(
+            button: button,
+            generation: nextGeneration,
+            surface: surface
+        )
+        sessions[button] = session
+        return session
+    }
+
+    /// Finishes a session only when its generation still owns the button.
+    @discardableResult
+    func finish(_ session: Session) -> Bool {
+        guard sessions[session.button] == session else { return false }
+        sessions.removeValue(forKey: session.button)
+        return true
+    }
+
+    /// Finishes a button session by its generation token.
+    @discardableResult
+    func finish(
+        _ button: Button,
+        generation: UInt64
+    ) -> Bool {
+        guard let session = sessions[button],
+              session.generation == generation else {
+            return false
+        }
+        sessions.removeValue(forKey: button)
+        return true
+    }
+
+    /// Returns sessions that should receive a synthesized release.
+    ///
+    /// `physicalButtons` is a reconciliation signal, not ownership state. It
+    /// is supplied only from non-drag event boundaries; drag dispatch itself
+    /// never consults it. Explicitly forced session tokens are always returned
+    /// when they still belong to `surface`.
+    func sessionsNeedingRepair(
+        on surface: SurfaceIdentity,
+        physicalButtons: Int?,
+        forcedSessions: Set<Session>
+    ) -> [Session] {
+        guard activeSurface == surface else { return [] }
+        return sessions.values
+            .filter { session in
+                forcedSessions.contains(session)
+                    || physicalButtons.map {
+                        ($0 & session.button.pressedMouseButtonsMask) == 0
+                    } == true
+            }
+            .sorted { lhs, rhs in
+                lhs.button.ordering < rhs.button.ordering
+            }
+    }
+}
diff --git a/Sources/GhosttyMouseSessionLedgerButton.swift b/Sources/GhosttyMouseSessionLedgerButton.swift
new file mode 100644
index 000000000000..500cde0ea678
--- /dev/null
+++ b/Sources/GhosttyMouseSessionLedgerButton.swift
@@ -0,0 +1,59 @@
+import AppKit
+import GhosttyKit
+
+extension GhosttyMouseSessionLedger {
+    /// A button whose native press is owned by a terminal surface session.
+    enum Button: String, CaseIterable, Hashable, Sendable {
+        case left
+        case right
+        case middle
+
+        /// Creates a tracked button for a mouse-up event, if the event is one
+        /// of the buttons forwarded to Ghostty.
+        init?(mouseUpEvent: NSEvent) {
+            switch mouseUpEvent.type {
+            case .leftMouseUp:
+                self = .left
+            case .rightMouseUp:
+                self = .right
+            case .otherMouseUp:
+                guard mouseUpEvent.buttonNumber == 2 else { return nil }
+                self = .middle
+            default:
+                return nil
+            }
+        }
+
+        /// The corresponding libghostty button value.
+        var ghosttyButton: ghostty_input_mouse_button_e {
+            switch self {
+            case .left:
+                return GHOSTTY_MOUSE_LEFT
+            case .right:
+                return GHOSTTY_MOUSE_RIGHT
+            case .middle:
+                return GHOSTTY_MOUSE_MIDDLE
+            }
+        }
+
+        /// The AppKit bit used when reconciling an event-stream gap.
+        var pressedMouseButtonsMask: Int {
+            switch self {
+            case .left:
+                return 1 << 0
+            case .right:
+                return 1 << 1
+            case .middle:
+                return 1 << 2
+            }
+        }
+
+        var ordering: Int {
+            switch self {
+            case .left: return 0
+            case .right: return 1
+            case .middle: return 2
+            }
+        }
+    }
+}
diff --git a/Sources/GhosttyMouseSessionLedgerPointerState.swift b/Sources/GhosttyMouseSessionLedgerPointerState.swift
new file mode 100644
index 000000000000..c652007cadf5
--- /dev/null
+++ b/Sources/GhosttyMouseSessionLedgerPointerState.swift
@@ -0,0 +1,11 @@
+import AppKit
+import GhosttyKit
+
+extension GhosttyMouseSessionLedger {
+    /// Last pointer location and modifiers observed for the active surface.
+    struct PointerState {
+        let localPoint: NSPoint
+        let surfacePoint: NSPoint
+        let mods: ghostty_input_mods_e
+    }
+}
diff --git a/Sources/GhosttyMouseSessionLedgerSession.swift b/Sources/GhosttyMouseSessionLedgerSession.swift
new file mode 100644
index 000000000000..2295e26eef18
--- /dev/null
+++ b/Sources/GhosttyMouseSessionLedgerSession.swift
@@ -0,0 +1,10 @@
+import Foundation
+
+extension GhosttyMouseSessionLedger {
+    /// An opaque generation token for one button press.
+    struct Session: Hashable, Sendable {
+        let button: Button
+        let generation: UInt64
+        let surface: SurfaceIdentity
+    }
+}
diff --git a/Sources/GhosttyMouseSessionLedgerSurfaceIdentity.swift b/Sources/GhosttyMouseSessionLedgerSurfaceIdentity.swift
new file mode 100644
index 000000000000..4bf4ed4a6159
--- /dev/null
+++ b/Sources/GhosttyMouseSessionLedgerSurfaceIdentity.swift
@@ -0,0 +1,10 @@
+import Foundation
+
+extension GhosttyMouseSessionLedger {
+    /// Identity of the native surface that owns a session.
+    struct SurfaceIdentity: Hashable, Sendable {
+        let surfaceID: UUID
+        let runtimeGeneration: UInt64
+        let nativeAddress: UInt
+    }
+}
diff --git a/Sources/GhosttyNSView+ClipboardInputSequencing.swift b/Sources/GhosttyNSView+ClipboardInputSequencing.swift
index cf7fa3fa17ea..811542883d25 100644
--- a/Sources/GhosttyNSView+ClipboardInputSequencing.swift
+++ b/Sources/GhosttyNSView+ClipboardInputSequencing.swift
@@ -68,6 +68,7 @@ extension GhosttyNSView {
         ) { [weak self] deferredInput in
             self?.replayClipboardDeferredInput(deferredInput)
         }
+        scheduleMouseRepairAfterClipboardDrainIfNeeded()
     }
 
     func cancelClipboardRead(
@@ -82,6 +83,7 @@ extension GhosttyNSView {
         ) { [weak self] deferredInput in
             self?.replayClipboardDeferredInput(deferredInput)
         }
+        scheduleMouseRepairAfterClipboardDrainIfNeeded()
     }
 
     func cancelReservedClipboardRead(
@@ -98,6 +100,12 @@ extension GhosttyNSView {
         ) { [weak self] deferredInput in
             self?.replayClipboardDeferredInput(deferredInput)
         }
+        scheduleMouseRepairAfterClipboardDrainIfNeeded()
+    }
+
+    private func scheduleMouseRepairAfterClipboardDrainIfNeeded() {
+        guard !hasClipboardInputDeferral else { return }
+        reconcileGhosttyMouseButtons(reason: "clipboardInputDrained")
     }
 
     func routeInputDuringClipboardRead(_ event: NSEvent) -> Bool {
diff --git a/Sources/GhosttyTerminalView.swift b/Sources/GhosttyTerminalView.swift
index 739f740ab33b..afc13b457bf6 100644
--- a/Sources/GhosttyTerminalView.swift
+++ b/Sources/GhosttyTerminalView.swift
@@ -3929,6 +3929,15 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
     @MainActor static var debugTextInputEventHandler: ((GhosttyNSView, NSEvent) -> Bool)?
 #endif
     private var eventMonitor: Any?
+    /// Installed only while this surface owns a button session. Keeping the
+    /// mouse-up monitor demand-driven avoids fan-out across every terminal
+    /// view for ordinary clicks elsewhere in the window.
+    private var mouseUpEventMonitor: Any?
+    /// Observes releases delivered outside cmux while a terminal owns a
+    /// button session. Demand-driven: installed only while sessions exist.
+    private var globalMouseUpEventMonitor: Any?
+    private var applicationResignActiveObserver: NSObjectProtocol?
+    private var contextMenuEndObserver: NSObjectProtocol?
     nonisolated let terminalClipboardInputSequencer =
         TerminalClipboardInputSequencer<ClipboardDeferredInput, UInt>(
             maximumBufferedEvents: 256,
@@ -3950,7 +3959,25 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
     private var deferredSurfaceSizeNonMetalRetryCount = 0
     private var lastDrawableSize: CGSize = .zero
     private var isFindEscapeSuppressionArmed = false
-    private var hasPendingLeftMouseRelease = false
+    private typealias TrackedMouseButton = GhosttyMouseSessionLedger.Button
+    private typealias RememberedGhosttyMouseState = GhosttyMouseSessionLedger.PointerState
+    /// The surface view is the sole owner of Ghostty button-session state.
+    /// AppKit forwarding and clipboard sequencing feed this ledger rather than
+    /// maintaining independent pressed-button mirrors.
+    private let ghosttyMouseSessionLedger = GhosttyMouseSessionLedger()
+    /// Compatibility projection for the find overlay; ownership remains in
+    /// the surface ledger rather than a second mutable flag.
+    private var hasPendingLeftMouseRelease: Bool {
+        ghosttyMouseSessionLedger.hasSession(
+            for: .left,
+            on: currentGhosttyMouseSurfaceIdentity
+        )
+    }
+    /// Lifecycle cleanup runs after the current AppKit/SwiftUI callback so a
+    /// potentially blocking Ghostty release never stalls portal reconciliation.
+    /// The captured session tokens keep the task safe across a new press or
+    /// native runtime generation.
+    private var deferredGhosttyMouseRepairTask: Task<Void, Never>?
     let imageTransferPreparation: TerminalImageTransferPreparationService?
 #if DEBUG
     private var lastSizeSkipSignature: String?
@@ -3959,6 +3986,12 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
 
     private var hasUsableFocusGeometry: Bool { bounds.width > 1 && bounds.height > 1 }
 
+    var hasClipboardInputDeferral: Bool {
+        terminalClipboardInputSequencer.hasInputDeferral(
+            for: terminalSurface?.runtimeSurfaceGeneration ?? .max
+        )
+    }
+
     static func shouldRequestFirstResponderForMouseFocus(
         focusFollowsMouseEnabled: Bool,
         pressedMouseButtons: Int,
@@ -4150,15 +4183,130 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
 
     private func installEventMonitor() {
         guard eventMonitor == nil else { return }
-        eventMonitor = NSEvent.addLocalMonitorForEvents(matching: [.scrollWheel]) { [weak self] event in
+        eventMonitor = NSEvent.addLocalMonitorForEvents(
+            matching: [.scrollWheel]
+        ) { [weak self] event in
             return self?.localEventHandler(event) ?? event
         }
     }
 
+    private func installMouseUpEventMonitorIfNeeded() {
+        guard mouseUpEventMonitor == nil else { return }
+        mouseUpEventMonitor = NSEvent.addLocalMonitorForEvents(
+            matching: [.leftMouseUp, .rightMouseUp, .otherMouseUp]
+        ) { [weak self] event in
+            guard let self,
+                  !self.ghosttyMouseSessionLedger.activeButtons.isEmpty else {
+                return event
+            }
+            return self.localEventMouseUp(event)
+        }
+        globalMouseUpEventMonitor = NSEvent.addGlobalMonitorForEvents(
+            matching: [.leftMouseUp, .rightMouseUp, .otherMouseUp]
+        ) { [weak self] event in
+            self?.globalMouseUpEvent(event)
+        }
+        applicationResignActiveObserver = NotificationCenter.default.addObserver(
+            forName: NSApplication.didResignActiveNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.deferReleaseAllGhosttyMouseButtons(reason: "applicationDidResignActive")
+        }
+    }
+
+    private func removeMouseUpEventMonitorIfUnused() {
+        guard ghosttyMouseSessionLedger.activeButtons.isEmpty else { return }
+        if let mouseUpEventMonitor {
+            NSEvent.removeMonitor(mouseUpEventMonitor)
+            self.mouseUpEventMonitor = nil
+        }
+        if let globalMouseUpEventMonitor {
+            NSEvent.removeMonitor(globalMouseUpEventMonitor)
+            self.globalMouseUpEventMonitor = nil
+        }
+        if let applicationResignActiveObserver {
+            NotificationCenter.default.removeObserver(applicationResignActiveObserver)
+            self.applicationResignActiveObserver = nil
+        }
+    }
+
+    private func globalMouseUpEvent(_ event: NSEvent) {
+        guard let button = TrackedMouseButton(mouseUpEvent: event),
+              ghosttyMouseSessionLedger.hasSession(
+                  for: button,
+                  on: currentGhosttyMouseSurfaceIdentity
+              ),
+              !hasClipboardInputDeferral else {
+            return
+        }
+        // Global monitor callbacks have no view-local coordinate space. Keep
+        // the ledger's last point and release only the matching session token.
+        deferGhosttyMouseButtonRepair(
+            reason: "globalMouseUp.\(button.rawValue)",
+            forceButtons: Set([button])
+        )
+    }
+
+    private func removeContextMenuEndObserver() {
+        guard let contextMenuEndObserver else { return }
+        NotificationCenter.default.removeObserver(contextMenuEndObserver)
+        self.contextMenuEndObserver = nil
+    }
+
+    private func observeContextMenuEnd(
+        _ menu: NSMenu,
+        session: GhosttyMouseSessionLedger.Session
+    ) {
+        removeContextMenuEndObserver()
+        contextMenuEndObserver = NotificationCenter.default.addObserver(
+            forName: NSMenu.didEndTrackingNotification,
+            object: menu,
+            queue: .main
+        ) { [weak self] _ in
+            guard let self else { return }
+            self.removeContextMenuEndObserver()
+            self.releaseContextMenuMouseSession(session)
+        }
+    }
+
+    private func releaseContextMenuMouseSession(
+        _ session: GhosttyMouseSessionLedger.Session
+    ) {
+        guard session.button == .right else { return }
+        guard let terminalSurface,
+              let surfaceIdentity = currentGhosttyMouseSurfaceIdentity else {
+            resetGhosttyMouseButtonTracking()
+            return
+        }
+        guard ghosttyMouseSessionLedger.session(
+            for: .right,
+            on: surfaceIdentity
+        ) == session else { return }
+        guard let surface = terminalSurface.liveSurfaceForGhosttyAccess(
+            reason: "contextMenuMouseRelease"
+        ),
+        UInt(bitPattern: surface) == session.surface.nativeAddress,
+        currentGhosttyMouseSurfaceIdentity == surfaceIdentity else {
+            resetGhosttyMouseButtonTracking()
+            return
+        }
+        let mods = ghosttyMouseSessionLedger.pointerState?.mods ?? GHOSTTY_MODS_NONE
+        _ = sendGhosttyMouseButton(
+            surface,
+            state: GHOSTTY_MOUSE_RELEASE,
+            button: GHOSTTY_MOUSE_RIGHT,
+            mods: mods
+        )
+        _ = finishGhosttyMouseSession(session)
+    }
+
     private func localEventHandler(_ event: NSEvent) -> NSEvent? {
         switch event.type {
         case .scrollWheel:
             return localEventScrollWheel(event)
+        case .leftMouseUp, .rightMouseUp, .otherMouseUp:
+            return localEventMouseUp(event)
         default:
             return event
         }
@@ -4176,6 +4324,86 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         return event
     }
 
+    private func localEventMouseUp(_ event: NSEvent) -> NSEvent? {
+        guard let button = TrackedMouseButton(mouseUpEvent: event) else {
+            return event
+        }
+        let currentSurfaceIdentity = currentGhosttyMouseSurfaceIdentity
+        guard ghosttyMouseSessionLedger.hasSession(
+            for: button,
+            on: currentSurfaceIdentity
+        ) else {
+            // Only synchronize when this view's active session belongs to a
+            // replaced/detached runtime; unrelated button-ups stay constant
+            // time even while several terminal views are alive.
+            if ghosttyMouseSessionLedger.activeSurface != currentSurfaceIdentity {
+                synchronizeGhosttyMouseSurfaceIdentity()
+            }
+            return event
+        }
+        // The normal mouse-up path is buffered while a sequenced clipboard
+        // read is in flight. Let that event replay in order instead of
+        // synthesizing a release ahead of the queued gesture.
+        guard !hasClipboardInputDeferral else { return event }
+
+        // A same-window mouse-up must continue through AppKit's responder
+        // path. In particular, command-click release routing needs to run on
+        // ``mouseUp(with:)``; repairing here would consume the release before
+        // that path can resolve links. The next non-drag event reconciles a
+        if event.window == window, button == .left {
+            // Keep the event for command-click handling, then verify the same
+            // generation on the next main-actor turn. If the responder or
+            // overlay drops the up, the token is still active and is released;
+            // a normally handled up has already consumed the token. Right
+            // button releases are deliberately excluded: AppKit may enter
+            // menu tracking immediately after the down, and a deferred
+            // synthetic release must not run before `didEndTracking`.
+            deferGhosttyMouseButtonRepair(
+                reason: "localMouseUp.postDispatch.\(button.rawValue)",
+                forceButtons: Set([button])
+            )
+        } else {
+            // An out-of-window release has no normal responder path. Preserve
+            // the last point and repair this generation immediately.
+            reconcileGhosttyMouseButtons(
+                reason: "localMouseUp.\(button.rawValue)",
+                forceButtons: Set([button])
+            )
+        }
+        return event
+    }
+
+    @discardableResult
+    private func markGhosttyMouseButtonPressed(_ button: TrackedMouseButton) -> UInt64 {
+        guard let surfaceIdentity = currentGhosttyMouseSurfaceIdentity,
+              let session = ghosttyMouseSessionLedger.begin(
+                  button,
+                  on: surfaceIdentity
+              ) else {
+            return 0
+        }
+        installMouseUpEventMonitorIfNeeded()
+        return session.generation
+    }
+
+    @discardableResult
+    private func finishGhosttyMouseSession(
+        _ session: GhosttyMouseSessionLedger.Session
+    ) -> Bool {
+        let finished = ghosttyMouseSessionLedger.finish(session)
+        removeMouseUpEventMonitorIfUnused()
+        if session.button == .right {
+            removeContextMenuEndObserver()
+        }
+        return finished
+    }
+
+    private func resetGhosttyMouseButtonTracking() {
+        ghosttyMouseSessionLedger.invalidate()
+        removeMouseUpEventMonitorIfUnused()
+        removeContextMenuEndObserver()
+    }
+
     func attachSurface(_ surface: TerminalSurface) {
         let isSameSurface = terminalSurface === surface
         let isAlreadyAttached = surface.isAttached(to: self)
@@ -4189,6 +4417,8 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
             }
             titleUpdateSurfaceKey = nextTitleUpdateSurfaceKey
         }
+        let currentMouseSurfaceIdentity = currentGhosttyMouseSurfaceIdentity
+        let nextMouseSurfaceIdentity = ghosttyMouseSurfaceIdentity(for: surface)
         if !isSameSurface {
             if pendingKeyActionCount > 0,
                (pendingExplicitKeyDownSurface !== surface
@@ -4201,8 +4431,16 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
                 discardPendingPasteAfterSurfaceReady()
             }
             appliedColorScheme = nil
+            // Finish any sessions that still belong to the old surface before
+            // replacing the view's surface owner.
+            releaseAllGhosttyMouseButtonsSynchronously(reason: "attachSurface")
+            resetGhosttyMouseButtonTracking()
             // Reset any OSC 22 mouse shape carried over from the previous surface.
             updateGhosttyMouseShape(GHOSTTY_MOUSE_SHAPE_TEXT)
+        } else if currentMouseSurfaceIdentity != nextMouseSurfaceIdentity {
+            // A TerminalSurface can rebuild its native pointer without being
+            // replaced. Never send an old session to the replacement pointer.
+            resetGhosttyMouseButtonTracking()
         }
         terminalSurface = surface
         tabId = surface.tabId
@@ -4217,6 +4455,7 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         }
         applySurfaceBackground()
         applySurfaceColorScheme(force: !isSameSurface || !isAlreadyAttached)
+        synchronizeGhosttyMouseSurfaceIdentity()
     }
 
     private func queueExplicitKeyDownForInputDemand(_ event: NSEvent) {
@@ -4555,6 +4794,17 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         }
     }
 
+    override func viewWillMove(toWindow newWindow: NSWindow?) {
+        if newWindow == nil {
+            // AppKit invokes this lifecycle edge on the UI thread before the
+            // view can be deallocated. Release the native gesture here, while
+            // the owning surface is still available; deinit only performs
+            // nonisolated observer/ledger cleanup.
+            releaseAllGhosttyMouseButtonsSynchronously(reason: "viewWillMoveToWindow.nil")
+        }
+        super.viewWillMove(toWindow: newWindow)
+    }
+
     override func viewDidMoveToWindow() {
         super.viewDidMoveToWindow()
         if let windowObserver {
@@ -4579,7 +4829,12 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
             "pending=\(String(format: "%.1fx%.1f", Double(pendingSurfaceSize?.width ?? 0), Double(pendingSurfaceSize?.height ?? 0)))"
         )
 #endif
-        guard let window else { return }
+        guard let window else {
+            deferReleaseAllGhosttyMouseButtons(
+                reason: "viewDidMoveToWindow.nil"
+            )
+            return
+        }
 
         // Reconcile the already-started runtime with the real window backing context.
         terminalSurface?.attachToView(self)
@@ -5894,6 +6149,9 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
             imeConsumedKeyUps.removeAll()
             manualNamedKeyConsumedKeyUps.removeAll()
             desiredFocus = false
+            deferReleaseAllGhosttyMouseButtons(
+                reason: "resignFirstResponder"
+            )
             cancelKeyboardCopyMode()
             terminalSurface?.hostedView.cancelSuppressedFirstResponderFocusReapply()
             terminalSurface?.recordExternalFocusState(false)
@@ -6627,6 +6885,29 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         }
     }
 
+    private func sendSyntheticGhosttyMouseRelease(
+        _ surface: ghostty_surface_t,
+        button: ghostty_input_mouse_button_e,
+        mods: ghostty_input_mods_e
+    ) -> Bool {
+        // A lifecycle cancellation must not commit a selection or invoke a
+        // prompt/link action. Clear the selection before the release (so
+        // copy-on-select has nothing to publish), then move the native pointer
+        // outside the viewport (so prompt/link hit-testing cannot match).
+        if button == GHOSTTY_MOUSE_LEFT {
+            if ghostty_surface_has_selection(surface) {
+                _ = ghostty_surface_clear_selection(surface)
+            }
+            ghostty_surface_mouse_pos(surface, -1, -1, mods)
+        }
+        return sendGhosttyMouseButton(
+            surface,
+            state: GHOSTTY_MOUSE_RELEASE,
+            button: button,
+            mods: mods
+        )
+    }
+
 #if DEBUG
     @discardableResult
     private func sendTimedGhosttyKey(
@@ -6810,6 +7091,258 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         return ghostty_input_mods_e(rawValue: mods)
     }
 
+    private func ghosttyMouseSurfaceIdentity(
+        for terminalSurface: TerminalSurface
+    ) -> GhosttyMouseSessionLedger.SurfaceIdentity? {
+        guard let nativeSurface = terminalSurface.surface else { return nil }
+        return GhosttyMouseSessionLedger.SurfaceIdentity(
+            surfaceID: terminalSurface.id,
+            runtimeGeneration: terminalSurface.runtimeSurfaceGeneration,
+            nativeAddress: UInt(bitPattern: nativeSurface)
+        )
+    }
+
+    private var currentGhosttyMouseSurfaceIdentity:
+        GhosttyMouseSessionLedger.SurfaceIdentity? {
+        guard let terminalSurface else { return nil }
+        return ghosttyMouseSurfaceIdentity(for: terminalSurface)
+    }
+
+    /// Moves the ledger to the currently attached native runtime. A runtime
+    /// replacement clears old sessions before any event can reach the new
+    /// pointer, so stale releases are never sent across generations.
+    @discardableResult
+    private func synchronizeGhosttyMouseSurfaceIdentity() -> Bool {
+        let didChange = ghosttyMouseSessionLedger.transition(
+            to: currentGhosttyMouseSurfaceIdentity
+        )
+        if didChange {
+            cancelDeferredGhosttyMouseRepair()
+            removeMouseUpEventMonitorIfUnused()
+        }
+        return didChange
+    }
+
+    @discardableResult
+    private func rememberGhosttyMouseState(from event: NSEvent) -> RememberedGhosttyMouseState {
+        synchronizeGhosttyMouseSurfaceIdentity()
+        let localPoint = convert(event.locationInWindow, from: nil)
+        let surfacePoint = NSPoint(x: localPoint.x, y: bounds.height - localPoint.y)
+        let mods = mouseModsFromEvent(event)
+        let state = RememberedGhosttyMouseState(
+            localPoint: localPoint,
+            surfacePoint: surfacePoint,
+            mods: mods
+        )
+        if let surfaceIdentity = currentGhosttyMouseSurfaceIdentity {
+            ghosttyMouseSessionLedger.rememberPointer(state, on: surfaceIdentity)
+        }
+        return state
+    }
+
+    /// Synchronously reconciles the ledger at an AppKit event boundary. Drag
+    /// dispatch itself never calls this method, so a captured drag cannot be
+    /// released from an unrelated physical-button snapshot.
+    private func reconcileGhosttyMouseButtons(
+        reason: String,
+        forceButtons: Set<TrackedMouseButton> = []
+    ) {
+        guard let surface,
+              let surfaceIdentity = currentGhosttyMouseSurfaceIdentity else {
+            resetGhosttyMouseButtonTracking()
+            return
+        }
+        guard ghosttyMouseSessionLedger.activeSurface == surfaceIdentity else {
+            // The native pointer changed without a view attachment callback.
+            // Invalidate rather than risking a release on the replacement.
+            synchronizeGhosttyMouseSurfaceIdentity()
+            return
+        }
+        guard !ghosttyMouseSessionLedger.activeButtons.isEmpty else { return }
+
+        let physicalButtons = NSEvent.pressedMouseButtons
+        let forcedSessions = Set(
+            ghosttyMouseSessionLedger
+                .sessions(on: surfaceIdentity)
+                .filter { forceButtons.contains($0.button) }
+        )
+        performGhosttyMouseRepair(
+            reason: reason,
+            surface: surface,
+            surfaceIdentity: surfaceIdentity,
+            physicalButtons: physicalButtons,
+            forcedSessions: forcedSessions,
+            suppressSideEffects: false
+        )
+    }
+
+    private func performGhosttyMouseRepair(
+        reason: String,
+        surface: ghostty_surface_t,
+        surfaceIdentity: GhosttyMouseSessionLedger.SurfaceIdentity,
+        physicalButtons: Int?,
+        forcedSessions: Set<GhosttyMouseSessionLedger.Session>,
+        suppressSideEffects: Bool
+    ) {
+        guard let terminalSurface,
+              let validatedSurface = terminalSurface.liveSurfaceForGhosttyAccess(
+                  reason: "mouseRepair.\(reason)"
+              ),
+              UInt(bitPattern: validatedSurface) == surfaceIdentity.nativeAddress,
+              UInt(bitPattern: validatedSurface) == UInt(bitPattern: surface) else {
+            // `surface` can be a stale wrapper even when its pointer bits have
+            // not changed. The owning model's liveness seam quarantines that
+            // case; clear our session/monitor mirror before returning.
+            resetGhosttyMouseButtonTracking()
+            return
+        }
+        guard currentGhosttyMouseSurfaceIdentity == surfaceIdentity,
+              ghosttyMouseSessionLedger.activeSurface == surfaceIdentity else {
+            synchronizeGhosttyMouseSurfaceIdentity()
+            return
+        }
+        let sessions = ghosttyMouseSessionLedger.sessionsNeedingRepair(
+            on: surfaceIdentity,
+            physicalButtons: physicalButtons,
+            forcedSessions: forcedSessions
+        )
+        guard !sessions.isEmpty else { return }
+
+        let pointer = ghosttyMouseSessionLedger.pointerState
+        if let surfacePoint = pointer?.surfacePoint {
+            ghostty_surface_mouse_pos(
+                validatedSurface,
+                surfacePoint.x,
+                surfacePoint.y,
+                pointer?.mods ?? GHOSTTY_MODS_NONE
+            )
+        }
+
+#if DEBUG
+        let buttonList = sessions.map { $0.button.rawValue }.joined(separator: ",")
+        cmuxDebugLog(
+            "terminal.mouseRepair surface=\(terminalSurface.id.uuidString.prefix(5)) " +
+            "reason=\(reason) buttons=\(buttonList) physicalMask=\(physicalButtons.map(String.init) ?? "none")"
+        )
+#endif
+
+        for session in sessions {
+            guard ghosttyMouseSessionLedger.session(
+                for: session.button,
+                on: surfaceIdentity
+            ) == session else { continue }
+            if suppressSideEffects {
+                _ = sendSyntheticGhosttyMouseRelease(
+                    validatedSurface,
+                    button: session.button.ghosttyButton,
+                    mods: pointer?.mods ?? GHOSTTY_MODS_NONE
+                )
+            } else {
+                _ = sendGhosttyMouseButton(
+                    validatedSurface,
+                    state: GHOSTTY_MOUSE_RELEASE,
+                    button: session.button.ghosttyButton,
+                    mods: pointer?.mods ?? GHOSTTY_MODS_NONE
+                )
+            }
+            _ = finishGhosttyMouseSession(session)
+        }
+    }
+
+    func reconcileGhosttyMouseButtons(reason: String) {
+        reconcileGhosttyMouseButtons(reason: reason, forceButtons: [])
+    }
+
+    private func cancelDeferredGhosttyMouseRepair() {
+        deferredGhosttyMouseRepairTask?.cancel()
+        deferredGhosttyMouseRepairTask = nil
+    }
+
+    /// Defers lifecycle cleanup until the portal/layout callback has returned.
+    /// The immutable session tokens and surface identity make this an explicit
+    /// handoff, not a timing guard: a newer press or runtime cannot be touched
+    /// when the task runs.
+    private func deferGhosttyMouseButtonRepair(
+        reason: String,
+        forceButtons: Set<TrackedMouseButton> = [],
+        forceAll: Bool = false
+    ) {
+        guard currentGhosttyMouseSurfaceIdentity != nil,
+              let surfaceIdentity = currentGhosttyMouseSurfaceIdentity,
+              ghosttyMouseSessionLedger.activeSurface == surfaceIdentity else {
+            synchronizeGhosttyMouseSurfaceIdentity()
+            return
+        }
+        let sessions = Set(ghosttyMouseSessionLedger.sessions(on: surfaceIdentity))
+        guard !sessions.isEmpty else { return }
+        let forcedSessions = forceAll
+            ? sessions
+            : Set(sessions.filter { forceButtons.contains($0.button) })
+
+        cancelDeferredGhosttyMouseRepair()
+        deferredGhosttyMouseRepairTask = Task { @MainActor [weak self, surfaceIdentity, forcedSessions, reason, forceAll] in
+            // Yield once so Ghostty releases never run inside SwiftUI/AppKit
+            // hierarchy reconciliation. This is a cancellable, identity-bound
+            // lifecycle handoff rather than a poll or retry.
+            await Task.yield()
+            guard !Task.isCancelled, let self else { return }
+            guard let surface = self.surface else {
+                self.resetGhosttyMouseButtonTracking()
+                return
+            }
+            guard self.currentGhosttyMouseSurfaceIdentity == surfaceIdentity,
+                  self.ghosttyMouseSessionLedger.activeSurface == surfaceIdentity else {
+                self.synchronizeGhosttyMouseSurfaceIdentity()
+                return
+            }
+            self.performGhosttyMouseRepair(
+                reason: reason,
+                surface: surface,
+                surfaceIdentity: surfaceIdentity,
+                physicalButtons: forceAll ? nil : NSEvent.pressedMouseButtons,
+                forcedSessions: forcedSessions,
+                suppressSideEffects: true
+            )
+        }
+    }
+
+    private func releaseAllGhosttyMouseButtonsSynchronously(reason: String) {
+        guard let surface,
+              let surfaceIdentity = currentGhosttyMouseSurfaceIdentity else {
+            resetGhosttyMouseButtonTracking()
+            return
+        }
+        guard ghosttyMouseSessionLedger.activeSurface == surfaceIdentity else {
+            synchronizeGhosttyMouseSurfaceIdentity()
+            return
+        }
+        let sessions = Set(ghosttyMouseSessionLedger.sessions(on: surfaceIdentity))
+        guard !sessions.isEmpty else { return }
+        cancelDeferredGhosttyMouseRepair()
+        performGhosttyMouseRepair(
+            reason: reason,
+            surface: surface,
+            surfaceIdentity: surfaceIdentity,
+            physicalButtons: nil,
+            forcedSessions: sessions,
+            suppressSideEffects: true
+        )
+        resetGhosttyMouseButtonTracking()
+    }
+
+    fileprivate func deferReleaseAllGhosttyMouseButtons(reason: String) {
+        guard currentGhosttyMouseSurfaceIdentity != nil,
+              !ghosttyMouseSessionLedger.activeButtons.isEmpty else {
+            resetGhosttyMouseButtonTracking()
+            return
+        }
+        deferGhosttyMouseButtonRepair(reason: reason, forceAll: true)
+    }
+
+    fileprivate func deferReconcileGhosttyMouseButtons(reason: String) {
+        deferGhosttyMouseButtonRepair(reason: reason, forceAll: false)
+    }
+
     func beginFindEscapeSuppression() {
         isFindEscapeSuppressionArmed = true
     }
@@ -7013,29 +7546,37 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
 
     override func mouseDown(with event: NSEvent) {
         if routeInputDuringClipboardRead(event) { return }
-        #if DEBUG
-        let debugPoint = convert(event.locationInWindow, from: nil)
-        cmuxDebugLog("terminal.mouseDown surface=\(terminalSurface?.id.uuidString.prefix(5) ?? "nil") mods=[\(debugModifierString(event.modifierFlags))] clickCount=\(event.clickCount) point=(\(String(format: "%.0f", debugPoint.x)),\(String(format: "%.0f", debugPoint.y)))")
-        #endif
+        reconcileGhosttyMouseButtons(
+            reason: "mouseDown.preflight",
+            forceButtons: Set([.left])
+        )
         let shouldForwardTerminalActivation = terminalPointerShouldForwardActivation()
         // Treat pointer-down as explicit focus intent before forwarding any terminal activation.
         focusFromPointerDown()
         guard shouldForwardTerminalActivation else { return }
         guard let surface = surface else { return }
-        let eventPoint = convert(event.locationInWindow, from: nil)
+        // Focus activation can synchronously reparent or resize the portal.
+        // Convert the event after that transaction so the press lands in the
+        // current terminal geometry.
+        let mouseState = rememberGhosttyMouseState(from: event)
+        #if DEBUG
+        let debugPoint = mouseState.localPoint
+        cmuxDebugLog("terminal.mouseDown surface=\(terminalSurface?.id.uuidString.prefix(5) ?? "nil") mods=[\(debugModifierString(event.modifierFlags))] clickCount=\(event.clickCount) point=(\(String(format: "%.0f", debugPoint.x)),\(String(format: "%.0f", debugPoint.y)))")
+        #endif
+        let eventPoint = mouseState.localPoint
         trackMousePointIfUsable(eventPoint)
         // Only update mouse position on the first click to prevent unwanted cursor
         // movement during double-click selection (issue #1698)
         if event.clickCount == 1 {
-            ghostty_surface_mouse_pos(surface, eventPoint.x, bounds.height - eventPoint.y, mouseModsFromEvent(event))
+            ghostty_surface_mouse_pos(surface, mouseState.surfacePoint.x, mouseState.surfacePoint.y, mouseState.mods)
         }
         _ = sendGhosttyMouseButton(
             surface,
             state: GHOSTTY_MOUSE_PRESS,
             button: GHOSTTY_MOUSE_LEFT,
-            mods: mouseModsFromEvent(event)
+            mods: mouseState.mods
         )
-        hasPendingLeftMouseRelease = true
+        _ = markGhosttyMouseButtonPressed(.left)
     }
 
     override func mouseUp(with event: NSEvent) {
@@ -7048,26 +7589,44 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
     @discardableResult
     func forwardPendingLeftMouseDrag(with event: NSEvent) -> Bool {
         if routeInputDuringClipboardRead(event) { return true }
-        guard hasPendingLeftMouseRelease, let surface else { return false }
-        let eventPoint = convert(event.locationInWindow, from: nil)
+        synchronizeGhosttyMouseSurfaceIdentity()
+        guard let surface,
+              ghosttyMouseSessionLedger.hasSession(
+                  for: .left,
+                  on: currentGhosttyMouseSurfaceIdentity
+              ) else { return false }
+        let mouseState = rememberGhosttyMouseState(from: event)
+        let eventPoint = mouseState.localPoint
         trackMousePointIfUsable(eventPoint)
-        ghostty_surface_mouse_pos(surface, eventPoint.x, bounds.height - eventPoint.y, mouseModsFromEvent(event))
+        ghostty_surface_mouse_pos(surface, mouseState.surfacePoint.x, mouseState.surfacePoint.y, mouseState.mods)
         return true
     }
 
     @discardableResult
     func completePendingLeftMouseRelease(with event: NSEvent) -> Bool {
         if routeInputDuringClipboardRead(event) { return true }
-        guard hasPendingLeftMouseRelease else { return false }
-        hasPendingLeftMouseRelease = false
-        guard let surface else { return false }
-        let point = convert(event.locationInWindow, from: nil)
+        synchronizeGhosttyMouseSurfaceIdentity()
+        guard let surfaceIdentity = currentGhosttyMouseSurfaceIdentity,
+              let pendingSession = ghosttyMouseSessionLedger.session(
+                  for: .left,
+                  on: surfaceIdentity
+              ) else { return false }
+        let mouseState = rememberGhosttyMouseState(from: event)
+        guard let surface,
+              currentGhosttyMouseSurfaceIdentity == surfaceIdentity else {
+            // A portal can detach the runtime between the press and release.
+            // Clear our mirror even when there is no surface left to receive it.
+            resetGhosttyMouseButtonTracking()
+            return false
+        }
+        let point = mouseState.localPoint
         _ = dispatchCommandClickRelease(
             surface: surface,
             at: point,
             modifierFlags: event.modifierFlags,
-            mouseMods: mouseModsFromEvent(event)
+            mouseMods: mouseState.mods
         )
+        _ = finishGhosttyMouseSession(pendingSession)
         return true
     }
 
@@ -7798,8 +8357,8 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         // pointer (ghostty ignores a same-cell mouse_pos with new mods), so a
         // helper that synthesized the forwarding itself would keep passing
         // with the handler broken.
-        guard let cmdDown = debugFlagsChangedEvent(commandDown: true, at: clampedPoint),
-              let cmdUp = debugFlagsChangedEvent(commandDown: false, at: clampedPoint) else {
+        guard let cmdDown = makeFlagsChangedEvent(commandDown: true, at: clampedPoint),
+              let cmdUp = makeFlagsChangedEvent(commandDown: false, at: clampedPoint) else {
             return ["error": "Failed to construct flagsChanged events"]
         }
 
@@ -7826,7 +8385,7 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         ]
     }
 
-    private func debugFlagsChangedEvent(commandDown: Bool, at pointInView: NSPoint) -> NSEvent? {
+    private func makeFlagsChangedEvent(commandDown: Bool, at pointInView: NSPoint) -> NSEvent? {
         // ghostty_input_action_e.modifierActionForFlagsChanged distinguishes left-Cmd
         // presses by the device-side bit, so a bare .command is read as a
         // release.
@@ -7850,6 +8409,10 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
 
     override func rightMouseDown(with event: NSEvent) {
         if routeInputDuringClipboardRead(event) { return }
+        reconcileGhosttyMouseButtons(
+            reason: "rightMouseDown.preflight",
+            forceButtons: Set([.right])
+        )
         focusFromPointerDown()
         guard let surface = surface else { return }
         if !ghostty_surface_mouse_captured(surface) {
@@ -7857,30 +8420,47 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
             return
         }
 
-        let point = convert(event.locationInWindow, from: nil)
-        ghostty_surface_mouse_pos(surface, point.x, bounds.height - point.y, mouseModsFromEvent(event))
+        let mouseState = rememberGhosttyMouseState(from: event)
+        ghostty_surface_mouse_pos(surface, mouseState.surfacePoint.x, mouseState.surfacePoint.y, mouseState.mods)
         _ = sendGhosttyMouseButton(
             surface,
             state: GHOSTTY_MOUSE_PRESS,
             button: GHOSTTY_MOUSE_RIGHT,
-            mods: mouseModsFromEvent(event)
+            mods: mouseState.mods
         )
+        _ = markGhosttyMouseButtonPressed(.right)
     }
 
     override func rightMouseUp(with event: NSEvent) {
         if routeInputDuringClipboardRead(event) { return }
-        guard let surface = surface else { return }
-        if !ghostty_surface_mouse_captured(surface) {
+        synchronizeGhosttyMouseSurfaceIdentity()
+        let surfaceIdentity = currentGhosttyMouseSurfaceIdentity
+        let session = ghosttyMouseSessionLedger.session(
+            for: .right,
+            on: surfaceIdentity
+        )
+        let mouseState = rememberGhosttyMouseState(from: event)
+        guard let surface else {
+            if let session { _ = finishGhosttyMouseSession(session) }
+            return
+        }
+        let mouseCaptured = ghostty_surface_mouse_captured(surface)
+        if session != nil,
+           currentGhosttyMouseSurfaceIdentity == surfaceIdentity {
+            _ = sendGhosttyMouseButton(
+                surface,
+                state: GHOSTTY_MOUSE_RELEASE,
+                button: GHOSTTY_MOUSE_RIGHT,
+                mods: mouseState.mods
+            )
+            if let session {
+                _ = finishGhosttyMouseSession(session)
+            }
+        }
+        if !mouseCaptured {
             super.rightMouseUp(with: event)
             return
         }
-
-        _ = sendGhosttyMouseButton(
-            surface,
-            state: GHOSTTY_MOUSE_RELEASE,
-            button: GHOSTTY_MOUSE_RIGHT,
-            mods: mouseModsFromEvent(event)
-        )
     }
 
     override func otherMouseDown(with event: NSEvent) {
@@ -7889,19 +8469,24 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
             return
         }
         if routeInputDuringClipboardRead(event) { return }
+        reconcileGhosttyMouseButtons(
+            reason: "otherMouseDown.preflight",
+            forceButtons: Set([.middle])
+        )
         terminalSurface?.didReceiveExplicitInput()
         requestPointerFocusRecovery()
         window?.makeFirstResponder(self)
         guard let surface = surface else { return }
         terminalSurface?.didAcceptExplicitInput()
-        let point = convert(event.locationInWindow, from: nil)
-        ghostty_surface_mouse_pos(surface, point.x, bounds.height - point.y, mouseModsFromEvent(event))
+        let mouseState = rememberGhosttyMouseState(from: event)
+        ghostty_surface_mouse_pos(surface, mouseState.surfacePoint.x, mouseState.surfacePoint.y, mouseState.mods)
         _ = sendGhosttyMouseButton(
             surface,
             state: GHOSTTY_MOUSE_PRESS,
             button: GHOSTTY_MOUSE_MIDDLE,
-            mods: mouseModsFromEvent(event)
+            mods: mouseState.mods
         )
+        _ = markGhosttyMouseButtonPressed(.middle)
     }
 
     override func otherMouseUp(with event: NSEvent) {
@@ -7910,13 +8495,29 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
             return
         }
         if routeInputDuringClipboardRead(event) { return }
-        guard let surface = surface else { return }
-        _ = sendGhosttyMouseButton(
-            surface,
-            state: GHOSTTY_MOUSE_RELEASE,
-            button: GHOSTTY_MOUSE_MIDDLE,
-            mods: mouseModsFromEvent(event)
+        synchronizeGhosttyMouseSurfaceIdentity()
+        let surfaceIdentity = currentGhosttyMouseSurfaceIdentity
+        let session = ghosttyMouseSessionLedger.session(
+            for: .middle,
+            on: surfaceIdentity
         )
+        let mouseState = rememberGhosttyMouseState(from: event)
+        guard let surface else {
+            if let session { _ = finishGhosttyMouseSession(session) }
+            return
+        }
+        if session != nil,
+           currentGhosttyMouseSurfaceIdentity == surfaceIdentity {
+            _ = sendGhosttyMouseButton(
+                surface,
+                state: GHOSTTY_MOUSE_RELEASE,
+                button: GHOSTTY_MOUSE_MIDDLE,
+                mods: mouseState.mods
+            )
+            if let session {
+                _ = finishGhosttyMouseSession(session)
+            }
+        }
     }
 
     override func menu(for event: NSEvent) -> NSMenu? {
@@ -7933,20 +8534,36 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         for event: NSEvent,
         sendsTerminalPointerEvent: Bool
     ) -> NSMenu? {
+        removeContextMenuEndObserver()
+        guard let initialSurface = surface else { return nil }
+        if sendsTerminalPointerEvent, ghostty_surface_mouse_captured(initialSurface) {
+            // A terminal that owns a captured right drag must keep that drag
+            // alive; no context menu is created for the captured protocol.
+            return nil
+        }
+        reconcileGhosttyMouseButtons(
+            reason: "menu.preflight",
+            forceButtons: Set([.right])
+        )
+        window?.makeFirstResponder(self)
         guard let surface = surface else { return nil }
         if sendsTerminalPointerEvent, ghostty_surface_mouse_captured(surface) {
             return nil
         }
-
-        window?.makeFirstResponder(self)
+        let mouseState = rememberGhosttyMouseState(from: event)
+        var contextMenuSession: GhosttyMouseSessionLedger.Session?
         if sendsTerminalPointerEvent {
-            let point = convert(event.locationInWindow, from: nil)
-            ghostty_surface_mouse_pos(surface, point.x, bounds.height - point.y, mouseModsFromEvent(event))
+            ghostty_surface_mouse_pos(surface, mouseState.surfacePoint.x, mouseState.surfacePoint.y, mouseState.mods)
             _ = sendGhosttyMouseButton(
                 surface,
                 state: GHOSTTY_MOUSE_PRESS,
                 button: GHOSTTY_MOUSE_RIGHT,
-                mods: mouseModsFromEvent(event)
+                mods: mouseState.mods
+            )
+            _ = markGhosttyMouseButtonPressed(.right)
+            contextMenuSession = ghosttyMouseSessionLedger.session(
+                for: .right,
+                on: currentGhosttyMouseSurfaceIdentity
             )
         }
 
@@ -8026,6 +8643,9 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
             )
             linkItem.target = self
         }
+        if let contextMenuSession {
+            observeContextMenuEnd(menu, session: contextMenuSession)
+        }
         return menu
     }
 
@@ -8079,15 +8699,17 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
     }
     override func mouseMoved(with event: NSEvent) {
         if routeInputDuringClipboardRead(event) { return }
+        reconcileGhosttyMouseButtons(reason: "mouseMoved")
         maybeRequestFirstResponderForMouseFocus()
         guard let surface = surface else { return }
         let suppressCommandPathHover = shouldSuppressCommandPathHover(for: event.modifierFlags)
-        let eventPoint = convert(event.locationInWindow, from: nil)
+        let mouseState = rememberGhosttyMouseState(from: event)
+        let eventPoint = mouseState.localPoint
         trackMousePointIfUsable(eventPoint)
         ghostty_surface_mouse_pos(
             surface,
-            eventPoint.x,
-            bounds.height - eventPoint.y,
+            mouseState.surfacePoint.x,
+            mouseState.surfacePoint.y,
             hoverModsFromFlags(
                 event.modifierFlags,
                 suppressCommandPathHover: suppressCommandPathHover
@@ -8103,15 +8725,17 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
     override func mouseEntered(with event: NSEvent) {
         if routeInputDuringClipboardRead(event) { return }
         super.mouseEntered(with: event)
+        reconcileGhosttyMouseButtons(reason: "mouseEntered")
         maybeRequestFirstResponderForMouseFocus()
         guard let surface = surface else { return }
         let suppressCommandPathHover = shouldSuppressCommandPathHover(for: event.modifierFlags)
-        let eventPoint = convert(event.locationInWindow, from: nil)
+        let mouseState = rememberGhosttyMouseState(from: event)
+        let eventPoint = mouseState.localPoint
         trackMousePointIfUsable(eventPoint)
         ghostty_surface_mouse_pos(
             surface,
-            eventPoint.x,
-            bounds.height - eventPoint.y,
+            mouseState.surfacePoint.x,
+            mouseState.surfacePoint.y,
             hoverModsFromFlags(
                 event.modifierFlags,
                 suppressCommandPathHover: suppressCommandPathHover
@@ -8143,12 +8767,13 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
 
     override func mouseExited(with event: NSEvent) {
         if routeInputDuringClipboardRead(event) { return }
+        reconcileGhosttyMouseButtons(reason: "mouseExited")
         if wordPathHoverActive {
             wordPathHoverActive = false
             NSCursor.pop()
         }
         guard let surface = surface else { return }
-        if NSEvent.pressedMouseButtons != 0 {
+        if !ghosttyMouseSessionLedger.activeButtons.isEmpty {
             return
         }
         ghostty_surface_mouse_pos(surface, -1, -1, mouseModsFromEvent(event))
@@ -8156,13 +8781,15 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
 
     override func mouseDragged(with event: NSEvent) {
         if routeInputDuringClipboardRead(event) { return }
+        synchronizeGhosttyMouseSurfaceIdentity()
         guard let surface = surface else { return }
-        let eventPoint = convert(event.locationInWindow, from: nil)
+        let mouseState = rememberGhosttyMouseState(from: event)
+        let eventPoint = mouseState.localPoint
         trackMousePointIfUsable(eventPoint)
         // Forward the raw drag coordinates, including out-of-bounds positions.
         // Selection auto-scroll depends on libghostty observing the pointer leave
         // the viewport rather than a cached in-bounds hover point.
-        ghostty_surface_mouse_pos(surface, eventPoint.x, bounds.height - eventPoint.y, mouseModsFromEvent(event))
+        ghostty_surface_mouse_pos(surface, mouseState.surfacePoint.x, mouseState.surfacePoint.y, mouseState.mods)
     }
 
     override func rightMouseDragged(with event: NSEvent) {
@@ -8193,6 +8820,7 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
 
     override func scrollWheel(with event: NSEvent) {
         if routeInputDuringClipboardRead(event) { return }
+        reconcileGhosttyMouseButtons(reason: "scrollWheel")
         guard let surface else {
             // Detached views used by previews and tests have no runtime
             // snapshot. Preserve the bounded first-packet fallback for them.
@@ -8214,6 +8842,7 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
             )
             return
         }
+        _ = rememberGhosttyMouseState(from: event)
         postWheelScroll(requiresAuthoritativeResponse: true)
         lastScrollEventTime = CACurrentMediaTime()
         Self.focusLog("scrollWheel: surface=\(terminalSurface?.id.uuidString ?? "nil") firstResponder=\(String(describing: window?.firstResponder))")
@@ -8305,6 +8934,25 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         if let trackingArea {
             removeTrackingArea(trackingArea)
         }
+        deferredGhosttyMouseRepairTask?.cancel()
+        if let mouseUpEventMonitor {
+            NSEvent.removeMonitor(mouseUpEventMonitor)
+        }
+        if let globalMouseUpEventMonitor {
+            NSEvent.removeMonitor(globalMouseUpEventMonitor)
+        }
+        if let applicationResignActiveObserver {
+            NotificationCenter.default.removeObserver(applicationResignActiveObserver)
+        }
+        if let contextMenuEndObserver {
+            NotificationCenter.default.removeObserver(contextMenuEndObserver)
+        }
+        // Native session release happens in `viewWillMove(toWindow:)` on the
+        // AppKit UI thread. Deinit must remain nonisolated: only cancel tasks,
+        // remove observers, and invalidate the local ledger here.
+        deferredGhosttyMouseRepairTask = nil
+        ghosttyMouseSessionLedger.invalidate()
+        removeMouseUpEventMonitorIfUnused()
         terminalSurface = nil
     }
 
@@ -10818,6 +11466,9 @@ final class GhosttySurfaceScrollView: NSView {
             )
         }
         if !visible {
+            if wasVisible {
+                surfaceView.deferReleaseAllGhosttyMouseButtons(reason: "setVisibleInUI.false")
+            }
             setLinkHoverURL(nil)
             // If we were focused, yield first responder.
             if let window = uiWindow, let fr = window.firstResponder as? NSView,
@@ -10825,6 +11476,7 @@ final class GhosttySurfaceScrollView: NSView {
                 window.makeFirstResponder(nil)
             }
         } else if !wasVisible {
+            surfaceView.deferReconcileGhosttyMouseButtons(reason: "setVisibleInUI.true")
             // Workspace/sidebar selection can make an already-sized terminal visible again
             // without a portal frame delta or a focus handoff. Nudge the Metal layer with
             // the portal refresh path — but on the next main-queue turn: reveals arrive
@@ -10876,9 +11528,15 @@ final class GhosttySurfaceScrollView: NSView {
             )
         }
 #endif
-        if active && !wasActive {
-            scheduleAutomaticFirstResponderApply(reason: "setActive")
-        } else if !active {
+        if active {
+            if !wasActive {
+                surfaceView.deferReconcileGhosttyMouseButtons(reason: "setActive.true")
+                scheduleAutomaticFirstResponderApply(reason: "setActive")
+            }
+        } else {
+            if wasActive {
+                surfaceView.deferReleaseAllGhosttyMouseButtons(reason: "setActive.false")
+            }
             resignOwnedFirstResponderIfNeeded(reason: "setActive(false)")
         }
     }
diff --git a/Sources/TerminalClipboardInputSequencer.swift b/Sources/TerminalClipboardInputSequencer.swift
index 97956817e28e..33987fc9d4f7 100644
--- a/Sources/TerminalClipboardInputSequencer.swift
+++ b/Sources/TerminalClipboardInputSequencer.swift
@@ -199,6 +199,12 @@ final class TerminalClipboardInputSequencer<Event, RequestID: Hashable & Sendabl
         return true
     }
 
+    /// Returns whether a clipboard request is currently holding input for the
+    /// given runtime epoch. Unsequenced reads intentionally return `false`.
+    func hasInputDeferral(for epoch: UInt64 = 0) -> Bool {
+        hasRequestInFlight(for: epoch)
+    }
+
     /// Cancels a request whose native surface lifetime ended. Deferred input
     /// from that epoch is discarded without touching replacement-surface input.
     func cancelRequest(
diff --git a/cmux.xcodeproj/project.pbxproj b/cmux.xcodeproj/project.pbxproj
index 51c6e54a923e..a8c6e0c3d190 100644
--- a/cmux.xcodeproj/project.pbxproj
+++ b/cmux.xcodeproj/project.pbxproj
@@ -1118,6 +1118,8 @@ C0DE71B10000000000000001 /* AppDelegate+AgentChatNotifications.swift in Sources
 		FEED0000000000000000F00F /* FeedTextEditorDebugWindowController.swift in Sources */ = {isa = PBXBuildFile; fileRef = FEED0000000000000000F00E /* FeedTextEditorDebugWindowController.swift */; };
 		D0B1001AA1B2C3D4E5F60001 /* FileDropHintBadgeView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D0B1001BA1B2C3D4E5F60001 /* FileDropHintBadgeView.swift */; };
 		781100017811000178110001 /* FileDropOverlayHitTestPerformanceTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 781100027811000278110002 /* FileDropOverlayHitTestPerformanceTests.swift */; };
+		F0A1100D0000000000000001 /* FileDropOverlayMouseDragButton.swift in Sources */ = {isa = PBXBuildFile; fileRef = F0A1100E0000000000000001 /* FileDropOverlayMouseDragButton.swift */; };
+		F0A1100F0000000000000001 /* FileDropOverlayMouseDragTarget.swift in Sources */ = {isa = PBXBuildFile; fileRef = F0A110100000000000000001 /* FileDropOverlayMouseDragTarget.swift */; };
 		D0B10020A1B2C3D4E5F60001 /* FileDropOverlayView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D0B10021A1B2C3D4E5F60001 /* FileDropOverlayView.swift */; };
 		D0B10022A1B2C3D4E5F60001 /* FileDropOverlayViewHitTesting.swift in Sources */ = {isa = PBXBuildFile; fileRef = D0B10023A1B2C3D4E5F60001 /* FileDropOverlayViewHitTesting.swift */; };
 		D0B10018A1B2C3D4E5F60001 /* FileDropOverlayViewTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D0B10019A1B2C3D4E5F60001 /* FileDropOverlayViewTests.swift */; };
@@ -1239,6 +1241,12 @@ C0DE71B10000000000000001 /* AppDelegate+AgentChatNotifications.swift in Sources
 		E89950010000000000000001 /* GhosttyFlashOverlayView.swift in Sources */ = {isa = PBXBuildFile; fileRef = E89950010000000000000002 /* GhosttyFlashOverlayView.swift */; };
 		048A66B6400AB53182FA4304 /* GhosttyKeyModifiers.swift in Sources */ = {isa = PBXBuildFile; fileRef = 77F5AB36771F1414A95E3330 /* GhosttyKeyModifiers.swift */; };
 		A5001006 /* GhosttyKit.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = A5001016 /* GhosttyKit.xcframework */; };
+		F0A110010000000000000001 /* GhosttyMouseSessionLedger.swift in Sources */ = {isa = PBXBuildFile; fileRef = F0A110020000000000000001 /* GhosttyMouseSessionLedger.swift */; };
+		F0A110050000000000000001 /* GhosttyMouseSessionLedgerButton.swift in Sources */ = {isa = PBXBuildFile; fileRef = F0A110060000000000000001 /* GhosttyMouseSessionLedgerButton.swift */; };
+		F0A110090000000000000001 /* GhosttyMouseSessionLedgerPointerState.swift in Sources */ = {isa = PBXBuildFile; fileRef = F0A1100A0000000000000001 /* GhosttyMouseSessionLedgerPointerState.swift */; };
+		F0A1100B0000000000000001 /* GhosttyMouseSessionLedgerSession.swift in Sources */ = {isa = PBXBuildFile; fileRef = F0A1100C0000000000000001 /* GhosttyMouseSessionLedgerSession.swift */; };
+		F0A110070000000000000001 /* GhosttyMouseSessionLedgerSurfaceIdentity.swift in Sources */ = {isa = PBXBuildFile; fileRef = F0A110080000000000000001 /* GhosttyMouseSessionLedgerSurfaceIdentity.swift */; };
+		F0A110030000000000000001 /* GhosttyMouseSessionLedgerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F0A110040000000000000001 /* GhosttyMouseSessionLedgerTests.swift */; };
 		A11EAF000000000000000000 /* GhosttyNotificationDispatcherTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = A11EAF000000000000000001 /* GhosttyNotificationDispatcherTests.swift */; };
 		D78971000000000000000001 /* GhosttyNotificationScrollRuntimeBridge.swift in Sources */ = {isa = PBXBuildFile; fileRef = D78971000000000000000002 /* GhosttyNotificationScrollRuntimeBridge.swift */; };
 		B88357000000000000000001 /* GhosttyNSView+ClipboardActions.swift in Sources */ = {isa = PBXBuildFile; fileRef = B88357000000000000000002 /* GhosttyNSView+ClipboardActions.swift */; };
@@ -4010,6 +4018,8 @@ C0DE71B10000000000000002 /* AppDelegate+AgentChatNotifications.swift */ = {isa =
 		FEED0000000000000000F00E /* FeedTextEditorDebugWindowController.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = FeedTextEditorDebugWindowController.swift; sourceTree = "<group>"; };
 		D0B1001BA1B2C3D4E5F60001 /* FileDropHintBadgeView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FileDropHintBadgeView.swift; sourceTree = "<group>"; };
 		781100027811000278110002 /* FileDropOverlayHitTestPerformanceTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FileDropOverlayHitTestPerformanceTests.swift; sourceTree = "<group>"; };
+		F0A1100E0000000000000001 /* FileDropOverlayMouseDragButton.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FileDropOverlayMouseDragButton.swift; sourceTree = "<group>"; };
+		F0A110100000000000000001 /* FileDropOverlayMouseDragTarget.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FileDropOverlayMouseDragTarget.swift; sourceTree = "<group>"; };
 		D0B10021A1B2C3D4E5F60001 /* FileDropOverlayView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FileDropOverlayView.swift; sourceTree = "<group>"; };
 		D0B10023A1B2C3D4E5F60001 /* FileDropOverlayViewHitTesting.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FileDropOverlayViewHitTesting.swift; sourceTree = "<group>"; };
 		D0B10019A1B2C3D4E5F60001 /* FileDropOverlayViewTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FileDropOverlayViewTests.swift; sourceTree = "<group>"; };
@@ -4132,6 +4142,12 @@ C0DE71B10000000000000002 /* AppDelegate+AgentChatNotifications.swift */ = {isa =
 		E89950010000000000000002 /* GhosttyFlashOverlayView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GhosttyFlashOverlayView.swift; sourceTree = "<group>"; };
 		77F5AB36771F1414A95E3330 /* GhosttyKeyModifiers.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GhosttyKeyModifiers.swift; sourceTree = "<group>"; };
 		A5001016 /* GhosttyKit.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; path = GhosttyKit.xcframework; sourceTree = "<group>"; };
+		F0A110020000000000000001 /* GhosttyMouseSessionLedger.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GhosttyMouseSessionLedger.swift; sourceTree = "<group>"; };
+		F0A110060000000000000001 /* GhosttyMouseSessionLedgerButton.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GhosttyMouseSessionLedgerButton.swift; sourceTree = "<group>"; };
+		F0A1100A0000000000000001 /* GhosttyMouseSessionLedgerPointerState.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GhosttyMouseSessionLedgerPointerState.swift; sourceTree = "<group>"; };
+		F0A1100C0000000000000001 /* GhosttyMouseSessionLedgerSession.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GhosttyMouseSessionLedgerSession.swift; sourceTree = "<group>"; };
+		F0A110080000000000000001 /* GhosttyMouseSessionLedgerSurfaceIdentity.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GhosttyMouseSessionLedgerSurfaceIdentity.swift; sourceTree = "<group>"; };
+		F0A110040000000000000001 /* GhosttyMouseSessionLedgerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GhosttyMouseSessionLedgerTests.swift; sourceTree = "<group>"; };
 		A11EAF000000000000000001 /* GhosttyNotificationDispatcherTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GhosttyNotificationDispatcherTests.swift; sourceTree = "<group>"; };
 		D78971000000000000000002 /* GhosttyNotificationScrollRuntimeBridge.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GhosttyNotificationScrollRuntimeBridge.swift; sourceTree = "<group>"; };
 		B88357000000000000000002 /* GhosttyNSView+ClipboardActions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "GhosttyNSView+ClipboardActions.swift"; sourceTree = "<group>"; };
@@ -6356,6 +6372,8 @@ B8B056D80000000000000002 /* MobileHostIdentityTests.swift */ = {isa = PBXFileRef
 				A5001F000000000000000002 /* DetachedFolderDragIcon.swift */,
 				B05553C10000000000000002 /* DetachedFolderPathLookupCache.swift */,
 				D0B1001BA1B2C3D4E5F60001 /* FileDropHintBadgeView.swift */,
+				F0A1100E0000000000000001 /* FileDropOverlayMouseDragButton.swift */,
+				F0A110100000000000000001 /* FileDropOverlayMouseDragTarget.swift */,
 				D0B10021A1B2C3D4E5F60001 /* FileDropOverlayView.swift */,
 				D0B10023A1B2C3D4E5F60001 /* FileDropOverlayViewHitTesting.swift */,
 				C0DE35010000000000000002 /* SidebarScrim.swift */,
@@ -6885,6 +6903,11 @@ B8B056D80000000000000002 /* MobileHostIdentityTests.swift */ = {isa = PBXFileRef
 				C40410010000000000000020 /* FileExplorerDoubleClickActionSettings.swift */,
 				C0DEF828300000000000002 /* GhosttyTerminalImmediateHostedStateAction.swift */,
 				E89950010000000000000002 /* GhosttyFlashOverlayView.swift */,
+				F0A110020000000000000001 /* GhosttyMouseSessionLedger.swift */,
+				F0A110060000000000000001 /* GhosttyMouseSessionLedgerButton.swift */,
+				F0A1100A0000000000000001 /* GhosttyMouseSessionLedgerPointerState.swift */,
+				F0A1100C0000000000000001 /* GhosttyMouseSessionLedgerSession.swift */,
+				F0A110080000000000000001 /* GhosttyMouseSessionLedgerSurfaceIdentity.swift */,
 				A5001015 /* GhosttyTerminalView.swift */,
 				9612B0010000000000000001 /* TerminalPortalReconciliation.swift */,
 				E89950040000000000000002 /* KeyboardCopyModeGridMetrics.swift */,
@@ -8479,6 +8502,7 @@ B8B056D80000000000000002 /* MobileHostIdentityTests.swift */ = {isa = PBXFileRef
 				BEE83F8394D90ACACD8E19DD /* WindowAndDragTests.swift */,
 				781100027811000278110002 /* FileDropOverlayHitTestPerformanceTests.swift */,
 				D0B10019A1B2C3D4E5F60001 /* FileDropOverlayViewTests.swift */,
+				F0A110040000000000000001 /* GhosttyMouseSessionLedgerTests.swift */,
 				2907A0042907A0042907A004 /* AppDelegateIssue2907RoutingTests.swift */,
 				875900000000000000000002 /* Issue8759FreezeRegressionTests.swift */,
 				C6711B030000000000000001 /* AppDelegateSurfaceResumeTerminalIdTests.swift */,
@@ -9922,6 +9946,8 @@ B8B056D80000000000000002 /* MobileHostIdentityTests.swift */ = {isa = PBXFileRef
 				FEED0000000000000000F00B /* FeedPreviewWindowController.swift in Sources */,
 				FEED0000000000000000F00F /* FeedTextEditorDebugWindowController.swift in Sources */,
 				D0B1001AA1B2C3D4E5F60001 /* FileDropHintBadgeView.swift in Sources */,
+				F0A1100D0000000000000001 /* FileDropOverlayMouseDragButton.swift in Sources */,
+				F0A1100F0000000000000001 /* FileDropOverlayMouseDragTarget.swift in Sources */,
 				D0B10020A1B2C3D4E5F60001 /* FileDropOverlayView.swift in Sources */,
 				D0B10022A1B2C3D4E5F60001 /* FileDropOverlayViewHitTesting.swift in Sources */,
 				FE5996010000000000000002 /* FileExplorerCellView.swift in Sources */,
@@ -10003,6 +10029,11 @@ B8B056D80000000000000002 /* MobileHostIdentityTests.swift */ = {isa = PBXFileRef
 				468120000000000000000001 /* GhosttyDesktopNotificationRequest.swift in Sources */,
 				E89950010000000000000001 /* GhosttyFlashOverlayView.swift in Sources */,
 				048A66B6400AB53182FA4304 /* GhosttyKeyModifiers.swift in Sources */,
+				F0A110010000000000000001 /* GhosttyMouseSessionLedger.swift in Sources */,
+				F0A110050000000000000001 /* GhosttyMouseSessionLedgerButton.swift in Sources */,
+				F0A110090000000000000001 /* GhosttyMouseSessionLedgerPointerState.swift in Sources */,
+				F0A1100B0000000000000001 /* GhosttyMouseSessionLedgerSession.swift in Sources */,
+				F0A110070000000000000001 /* GhosttyMouseSessionLedgerSurfaceIdentity.swift in Sources */,
 				D78971000000000000000001 /* GhosttyNotificationScrollRuntimeBridge.swift in Sources */,
 				B88357000000000000000001 /* GhosttyNSView+ClipboardActions.swift in Sources */,
 				B88357000000000000000003 /* GhosttyNSView+ClipboardInputSequencing.swift in Sources */,
@@ -11719,6 +11750,7 @@ B8B056D80000000000000002 /* MobileHostIdentityTests.swift */ = {isa = PBXFileRef
 				468130000000000000000001 /* GhosttyDesktopNotificationIngressTests.swift in Sources */,
 				604100010000000000000001 /* GhosttyDrawableSizeRetryTests.swift in Sources */,
 				F9000000A1B2C3D4E5F60718 /* GhosttyEnsureFocusWindowActivationTests.swift in Sources */,
+				F0A110030000000000000001 /* GhosttyMouseSessionLedgerTests.swift in Sources */,
 				A11EAF000000000000000000 /* GhosttyNotificationDispatcherTests.swift in Sources */,
 				BDFCA25C0CE77A299C915E26 /* GhosttyOptionAsAltModsTests.swift in Sources */,
 				3069F1D10000000000000003 /* GhosttyPasteboardFidelityTests.swift in Sources */,
diff --git a/cmuxTests/FileDropOverlayViewTests.swift b/cmuxTests/FileDropOverlayViewTests.swift
index 29424bc54db3..af7a317b5e36 100644
--- a/cmuxTests/FileDropOverlayViewTests.swift
+++ b/cmuxTests/FileDropOverlayViewTests.swift
@@ -72,6 +72,46 @@ struct FileDropOverlayViewTests {
         }
     }
 
+    private final class MouseEventSpyView: NSView {
+        var mouseCalls: [String] = []
+
+        override func mouseDown(with event: NSEvent) {
+            mouseCalls.append("down")
+        }
+
+        override func mouseDragged(with event: NSEvent) {
+            mouseCalls.append("dragged")
+        }
+
+        override func mouseUp(with event: NSEvent) {
+            mouseCalls.append("up")
+        }
+
+        override func rightMouseDown(with event: NSEvent) {
+            mouseCalls.append("rightDown")
+        }
+
+        override func rightMouseDragged(with event: NSEvent) {
+            mouseCalls.append("rightDragged")
+        }
+
+        override func rightMouseUp(with event: NSEvent) {
+            mouseCalls.append("rightUp")
+        }
+
+        override func otherMouseDown(with event: NSEvent) {
+            mouseCalls.append("otherDown\(event.buttonNumber)")
+        }
+
+        override func otherMouseDragged(with event: NSEvent) {
+            mouseCalls.append("otherDragged\(event.buttonNumber)")
+        }
+
+        override func otherMouseUp(with event: NSEvent) {
+            mouseCalls.append("otherUp\(event.buttonNumber)")
+        }
+    }
+
     private final class MockDraggingInfo: NSObject, NSDraggingInfo {
         let draggingDestinationWindow: NSWindow?
         let draggingSourceOperationMask: NSDragOperation
@@ -320,4 +360,161 @@ struct FileDropOverlayViewTests {
             "Rejected text drops should not be recorded as performed or receive a text-route conclude"
         )
     }
+
+    @Test("Forwarded mouse-up stays with the original drag target")
+    func forwardedMouseUpUsesOriginalTargetAfterPhysicalRelease() throws {
+        _ = NSApplication.shared
+
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 420, height: 240),
+            styleMask: [.titled, .closable],
+            backing: .buffered,
+            defer: false
+        )
+        window.isReleasedWhenClosed = false
+        defer {
+            window.orderOut(nil)
+            window.close()
+        }
+
+        let contentView = NSView(frame: NSRect(x: 0, y: 0, width: 420, height: 240))
+        window.contentView = contentView
+        let originalTarget = MouseEventSpyView(frame: NSRect(x: 0, y: 0, width: 210, height: 240))
+        let underCursorTarget = MouseEventSpyView(frame: NSRect(x: 210, y: 0, width: 210, height: 240))
+        contentView.addSubview(originalTarget)
+        contentView.addSubview(underCursorTarget)
+        let overlay = FileDropOverlayView(frame: contentView.bounds)
+        contentView.addSubview(overlay, positioned: .above, relativeTo: nil)
+
+        window.makeKeyAndOrderFront(nil)
+        window.displayIfNeeded()
+        contentView.layoutSubtreeIfNeeded()
+
+        let downLocation = originalTarget.convert(
+            NSPoint(x: originalTarget.bounds.midX, y: originalTarget.bounds.midY),
+            to: nil
+        )
+        let upLocation = underCursorTarget.convert(
+            NSPoint(x: underCursorTarget.bounds.midX, y: underCursorTarget.bounds.midY),
+            to: nil
+        )
+        let down = try #require(Self.mouseEvent(type: .leftMouseDown, location: downLocation, window: window))
+        let up = try #require(Self.mouseEvent(type: .leftMouseUp, location: upLocation, window: window))
+
+        overlay.mouseDown(with: down)
+        overlay.mouseUp(with: up)
+
+        #expect(
+            originalTarget.mouseCalls == ["down", "up"],
+            "AppKit's post-release button mask must not redirect mouse-up away from the original target"
+        )
+        #expect(underCursorTarget.mouseCalls.isEmpty)
+    }
+
+    @Test("Forwarded button captures remain independent during right and middle drags")
+    func forwardedButtonCapturesRemainIndependent() throws {
+        _ = NSApplication.shared
+
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 420, height: 240),
+            styleMask: [.titled, .closable],
+            backing: .buffered,
+            defer: false
+        )
+        window.isReleasedWhenClosed = false
+        defer {
+            window.orderOut(nil)
+            window.close()
+        }
+
+        let contentView = NSView(frame: NSRect(x: 0, y: 0, width: 420, height: 240))
+        window.contentView = contentView
+        let leftTarget = MouseEventSpyView(frame: NSRect(x: 0, y: 0, width: 210, height: 240))
+        let rightTarget = MouseEventSpyView(frame: NSRect(x: 210, y: 0, width: 210, height: 240))
+        contentView.addSubview(leftTarget)
+        contentView.addSubview(rightTarget)
+        let overlay = FileDropOverlayView(frame: contentView.bounds)
+        contentView.addSubview(overlay, positioned: .above, relativeTo: nil)
+
+        window.makeKeyAndOrderFront(nil)
+        window.displayIfNeeded()
+        contentView.layoutSubtreeIfNeeded()
+
+        let leftPoint = leftTarget.convert(
+            NSPoint(x: leftTarget.bounds.midX, y: leftTarget.bounds.midY),
+            to: nil
+        )
+        let rightPoint = rightTarget.convert(
+            NSPoint(x: rightTarget.bounds.midX, y: rightTarget.bounds.midY),
+            to: nil
+        )
+        let leftDown = try #require(Self.mouseEvent(type: .leftMouseDown, location: leftPoint, window: window))
+        let rightDown = try #require(Self.mouseEvent(type: .rightMouseDown, location: rightPoint, window: window))
+        let rightDrag = try #require(Self.mouseEvent(type: .rightMouseDragged, location: leftPoint, window: window))
+        let middleDown = try #require(Self.otherMouseEvent(type: .otherMouseDown, location: leftPoint, window: window, buttonNumber: 2))
+        let middleDrag = try #require(Self.otherMouseEvent(type: .otherMouseDragged, location: rightPoint, window: window, buttonNumber: 2))
+        let leftUp = try #require(Self.mouseEvent(type: .leftMouseUp, location: rightPoint, window: window))
+        let rightUp = try #require(Self.mouseEvent(type: .rightMouseUp, location: leftPoint, window: window))
+        let middleUp = try #require(Self.otherMouseEvent(type: .otherMouseUp, location: rightPoint, window: window, buttonNumber: 2))
+
+        overlay.mouseDown(with: leftDown)
+        overlay.rightMouseDown(with: rightDown)
+        overlay.rightMouseDragged(with: rightDrag)
+        overlay.otherMouseDown(with: middleDown)
+        overlay.otherMouseDragged(with: middleDrag)
+        overlay.mouseUp(with: leftUp)
+        overlay.rightMouseUp(with: rightUp)
+        overlay.otherMouseUp(with: middleUp)
+
+        #expect(leftTarget.mouseCalls == ["down", "otherDown2", "otherDragged2", "up", "otherUp2"])
+        #expect(rightTarget.mouseCalls == ["rightDown", "rightDragged", "rightUp"])
+    }
+
+    private static func mouseEvent(
+        type: NSEvent.EventType,
+        location: NSPoint,
+        window: NSWindow
+    ) -> NSEvent? {
+        NSEvent.mouseEvent(
+            with: type,
+            location: location,
+            modifierFlags: [],
+            timestamp: ProcessInfo.processInfo.systemUptime,
+            windowNumber: window.windowNumber,
+            context: nil,
+            eventNumber: 1,
+            clickCount: 1,
+            pressure: type == .leftMouseUp ? 0 : 1
+        )
+    }
+
+    private static func otherMouseEvent(
+        type: NSEvent.EventType,
+        location: NSPoint,
+        window: NSWindow,
+        buttonNumber: Int
+    ) throws -> NSEvent {
+        let cgEventType: CGEventType
+        switch type {
+        case .otherMouseDown:
+            cgEventType = .otherMouseDown
+        case .otherMouseUp:
+            cgEventType = .otherMouseUp
+        case .otherMouseDragged:
+            cgEventType = .otherMouseDragged
+        default:
+            fatalError("Unsupported event type \(type)")
+        }
+        let mouseButton = try #require(CGMouseButton(rawValue: UInt32(buttonNumber)))
+        let cgEvent = try #require(
+            CGEvent(
+                mouseEventSource: nil,
+                mouseType: cgEventType,
+                mouseCursorPosition: location,
+                mouseButton: mouseButton
+            )
+        )
+        cgEvent.setIntegerValueField(.mouseEventButtonNumber, value: Int64(buttonNumber))
+        return try #require(NSEvent(cgEvent: cgEvent))
+    }
 }
diff --git a/cmuxTests/GhosttyMouseSessionLedgerTests.swift b/cmuxTests/GhosttyMouseSessionLedgerTests.swift
new file mode 100644
index 000000000000..18f2c0a1996a
--- /dev/null
+++ b/cmuxTests/GhosttyMouseSessionLedgerTests.swift
@@ -0,0 +1,80 @@
+import AppKit
+import Testing
+
+#if canImport(cmux_DEV)
+@testable import cmux_DEV
+#elseif canImport(cmux)
+@testable import cmux
+#endif
+
+@MainActor
+@Suite("Ghostty mouse session ledger", .serialized)
+struct GhosttyMouseSessionLedgerTests {
+    @Test("button sessions retain independent generations")
+    func buttonSessionsRetainIndependentGenerations() throws {
+        let ledger = GhosttyMouseSessionLedger()
+        let surface = Self.surfaceIdentity(generation: 4, address: 0x101)
+        ledger.transition(to: surface)
+
+        let left = try #require(ledger.begin(.left, on: surface))
+        let right = try #require(ledger.begin(.right, on: surface))
+        #expect(ledger.activeButtons == [.left, .right])
+        #expect(left.generation != right.generation)
+
+        #expect(ledger.finish(left))
+        #expect(ledger.hasSession(for: .right, on: surface))
+        #expect(!ledger.hasSession(for: .left, on: surface))
+    }
+
+    @Test("runtime replacement invalidates old release tokens")
+    func runtimeReplacementInvalidatesOldReleaseTokens() throws {
+        let ledger = GhosttyMouseSessionLedger()
+        let original = Self.surfaceIdentity(generation: 8, address: 0x202)
+        let replacement = Self.surfaceIdentity(generation: 9, address: 0x202)
+        ledger.transition(to: original)
+        let oldSession = try #require(ledger.begin(.left, on: original))
+
+        #expect(ledger.transition(to: replacement))
+        #expect(ledger.activeButtons.isEmpty)
+        #expect(!ledger.finish(oldSession))
+
+        let newSession = try #require(ledger.begin(.left, on: replacement))
+        #expect(newSession.generation != oldSession.generation)
+        #expect(!ledger.finish(oldSession))
+        #expect(ledger.finish(newSession))
+    }
+
+    @Test("physical reconciliation is limited to non-drag repair candidates")
+    func physicalReconciliationSelectsOnlyReleasedButtons() throws {
+        let ledger = GhosttyMouseSessionLedger()
+        let surface = Self.surfaceIdentity(generation: 12, address: 0x303)
+        ledger.transition(to: surface)
+        let left = try #require(ledger.begin(.left, on: surface))
+        _ = try #require(ledger.begin(.right, on: surface))
+
+        let released = ledger.sessionsNeedingRepair(
+            on: surface,
+            physicalButtons: 1 << 0,
+            forcedSessions: []
+        )
+        #expect(released.map(\.button) == [.right])
+
+        let forced = ledger.sessionsNeedingRepair(
+            on: surface,
+            physicalButtons: 1 << 0,
+            forcedSessions: [left]
+        )
+        #expect(Set(forced.map(\.button)) == [.left, .right])
+    }
+
+    private static func surfaceIdentity(
+        generation: UInt64,
+        address: UInt
+    ) -> GhosttyMouseSessionLedger.SurfaceIdentity {
+        GhosttyMouseSessionLedger.SurfaceIdentity(
+            surfaceID: UUID(),
+            runtimeGeneration: generation,
+            nativeAddress: address
+        )
+    }
+}