Fix blank terminal pane when notification fires on another tab

Sources/GhosttyTerminalView.swift

@@ -3058,6 +3058,9 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
 
     func applyWindowBackgroundIfActive() {
         guard let window else { return }
+        // Always maintain the surface-level background to prevent blank panes.
+        // This is safe even when window-level background is skipped (idempotent).
+        applySurfaceBackground()
         let appDelegate = AppDelegate.shared
         let owningManager = tabId.flatMap { appDelegate?.tabManagerFor(tabId: $0) }
         let owningSelectedTabId = owningManager?.selectedTabId
@@ -3070,7 +3073,6 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         ) else {
             return
         }
-        applySurfaceBackground()
         let color = effectiveBackgroundColor()
         if cmuxShouldUseClearWindowBackground(for: color.alphaComponent) {
             window.backgroundColor = cmuxTransparentWindowBaseColor()

Sources/TerminalNotificationStore.swift

@@ -843,7 +843,12 @@ final class TerminalNotificationStore: ObservableObject {
         }
 
         if WorkspaceAutoReorderSettings.isEnabled() {
-            AppDelegate.shared?.tabManager?.moveTabToTop(tabId)
+            // Defer tab reordering to the next run loop iteration to avoid
+            // cascading SwiftUI re-renders (tabs + notifications @Published
+            // changes in the same frame) that can blank the active pane (#914).
+            DispatchQueue.main.async {
+                AppDelegate.shared?.tabManager?.moveTabToTop(tabId)
+            }
         }
 
         let notification = TerminalNotification(

cmuxTests/GhosttyConfigTests.swift

@@ -749,6 +749,122 @@ final class WindowBackgroundSelectionGateTests: XCTestCase {
     }
 }
 
+// MARK: - Issue #914 regression tests
+
+/// Validates that `shouldApplyWindowBackground` returning false does NOT
+/// prevent surface background from being maintained. The fix moves
+/// `applySurfaceBackground()` before the guard so it always runs.
+///
+/// These tests verify the decision logic that was previously the sole
+/// gate for surface background application. When the guard rejects,
+/// the surface background must still be applied (tested via the code
+/// change, not a mock — these tests document the rejection scenarios).
+final class WindowBackgroundSurfaceBackgroundGuaranteeTests: XCTestCase {
+    func testShouldApplyRejectsWhenOwningSelectionDiffersButSurfaceMustStayVisible() {
+        let surfaceTabId = UUID()
+        let differentSelectedTab = UUID()
+
+        // This is the scenario that triggers #914: the owning manager's
+        // selectedTabId temporarily differs from the surface's tabId
+        // (e.g., during notification-triggered tab reorder).
+        let rejected = !GhosttyNSView.shouldApplyWindowBackground(
+            surfaceTabId: surfaceTabId,
+            owningManagerExists: true,
+            owningSelectedTabId: differentSelectedTab,
+            activeSelectedTabId: surfaceTabId
+        )
+        XCTAssertTrue(rejected, "Guard should reject when owning selection differs — this is the #914 trigger condition")
+    }
+
+    func testShouldApplyRejectsWhenActiveSelectionDiffersWithNoOwningManager() {
+        let surfaceTabId = UUID()
+        let differentActiveTab = UUID()
+
+        let rejected = !GhosttyNSView.shouldApplyWindowBackground(
+            surfaceTabId: surfaceTabId,
+            owningManagerExists: false,
+            owningSelectedTabId: nil,
+            activeSelectedTabId: differentActiveTab
+        )
+        XCTAssertTrue(rejected, "Guard should reject when active selection differs — surface background must still be maintained")
+    }
+}
+
+/// Validates that notification-driven tab reorder is deferred to avoid
+/// cascading @Published changes in the same run loop frame (#914).
+///
+/// Uses source-code inspection (same pattern as
+/// `TabManagerNotificationOrderingSourceTests`) to assert that
+/// `moveTabToTop` is wrapped in `DispatchQueue.main.async` inside
+/// `addNotification`. This avoids singleton state pollution from
+/// `TerminalNotificationStore.shared` and provides a meaningful
+/// regression guard — unlike a runtime test, this will fail if the
+/// async wrapper is removed.
+final class NotificationTabReorderDeferralTests: XCTestCase {
+    func testMoveTabToTopIsDeferredInsideAddNotification() throws {
+        let projectRoot = findProjectRoot()
+        let storeURL = projectRoot.appendingPathComponent("Sources/TerminalNotificationStore.swift")
+        let source = try String(contentsOf: storeURL, encoding: .utf8)
+
+        // Locate the addNotification method body.
+        guard let methodStart = source.range(of: "func addNotification(tabId:") else {
+            XCTFail("Failed to locate addNotification(tabId:) in TerminalNotificationStore.swift")
+            return
+        }
+
+        // Find the next top-level `func` after addNotification to bound the search.
+        let searchRange = methodStart.upperBound..<source.endIndex
+        let methodEnd = source.range(of: "\n    func ", range: searchRange)?.lowerBound ?? source.endIndex
+        let methodBody = String(source[methodStart.lowerBound..<methodEnd])
+
+        // The critical invariant: moveTabToTop must be called inside
+        // DispatchQueue.main.async, NOT directly. A synchronous call
+        // causes two @Published mutations in the same run loop frame
+        // (tabs reorder + notifications update), triggering a cascading
+        // SwiftUI re-render that blanks the active pane (#914).
+        XCTAssertTrue(
+            methodBody.contains("DispatchQueue.main.async"),
+            """
+            addNotification must defer moveTabToTop via DispatchQueue.main.async \
+            to prevent cascading @Published changes that blank the active pane (#914).
+            """
+        )
+        XCTAssertTrue(
+            methodBody.contains("moveTabToTop"),
+            "addNotification must call moveTabToTop for auto-reorder behavior."
+        )
+
+        // Verify moveTabToTop appears ONLY inside the async block, not outside it.
+        // Split on DispatchQueue.main.async and check that moveTabToTop doesn't
+        // appear in the portion before the async block within the reorder section.
+        if let reorderStart = methodBody.range(of: "WorkspaceAutoReorderSettings.isEnabled()") {
+            let reorderSection = String(methodBody[reorderStart.lowerBound..<methodBody.endIndex])
+            if let asyncStart = reorderSection.range(of: "DispatchQueue.main.async") {
+                let beforeAsync = String(reorderSection[reorderSection.startIndex..<asyncStart.lowerBound])
+                XCTAssertFalse(
+                    beforeAsync.contains("moveTabToTop"),
+                    """
+                    moveTabToTop must NOT be called synchronously before the \
+                    DispatchQueue.main.async block — it must be inside it (#914).
+                    """
+                )
+            }
+        }
+    }
+
+    private func findProjectRoot() -> URL {
+        var dir = URL(fileURLWithPath: #file).deletingLastPathComponent().deletingLastPathComponent()
+        for _ in 0..<10 {
+            let marker = dir.appendingPathComponent("GhosttyTabs.xcodeproj")
+            if FileManager.default.fileExists(atPath: marker.path) {
+                return dir
+            }
+            dir = dir.deletingLastPathComponent()
+        }
+        return URL(fileURLWithPath: FileManager.default.currentDirectoryPath)
+    }
+}
+
 final class NotificationBurstCoalescerTests: XCTestCase {
     func testSignalsInSameBurstFlushOnce() {
         let coalescer = NotificationBurstCoalescer(delay: 0.01)