feat(sidebar): show inner tabs in workspace hover

Packages/macOS/CmuxNext/Sources/CmuxNextApp/InputVerification/DebugMouse.swift

@@ -38,6 +38,7 @@ enum DebugMouse {
         if params["target"]?.stringValue == "page" {
             return params["action"]?.stringValue == "scroll" ? scrollPage(params, services: services) : clickPage(params, services: services)
         }
+        if params["target"]?.stringValue == "hover-card" { return hoverCard(params, services: services) }
         let windowID = params["window"]?.stringValue
         guard let controller = services.windows.controllers.first(where: { windowID == nil || $0.state.id == windowID }),
               let window = controller.window else { return .object(["error": .string("no window")]) }
@@ -141,6 +142,32 @@ enum DebugMouse {
         ])
     }
 
+    /// A click/move on the actual non-activating card window, through the app's
+    /// event queue and local monitors. x/y start at the card's top-left, without
+    /// the transparent shadow band. This proves its hit test, rather than
+    /// invoking a tab-selection callback directly.
+    private static func hoverCard(_ params: [String: JSONValue], services: AppServices) -> JSONValue {
+        guard let card = services.hoverCards.debugInteractiveCard,
+              let x = params["x"]?.doubleValue, let y = params["y"]?.doubleValue else {
+            return .object(["error": .string("no interactive hover card, or missing x/y")])
+        }
+        let screen = CGPoint(x: card.frame.minX + x, y: card.frame.maxY - y)
+        let base = card.window.convertPoint(fromScreen: screen)
+        let topLeft = InputJournal.topLeftPoint(base, in: card.window, relativeTo: card.window)
+        let action = params["action"]?.stringValue ?? "click"
+        guard ["move", "click"].contains(action) else { return .object(["error": .string("pass action move or click")]) }
+        let types: [NSEvent.EventType] = action == "move" ? [.mouseMoved] : [.leftMouseDown, .leftMouseUp]
+        let events = types.compactMap { mouse($0, at: topLeft, in: card.window, flags: [], clicks: action == "move" ? 0 : 1) }
+        guard events.count == types.count else { return .object(["error": .string("could not synthesize card events")]) }
+        // Keep the coordinator's synthetic screen point authoritative. Walking
+        // tracking areas here would send a row exit before the non-activating
+        // card receives the move, which is unlike the real panel crossing.
+        services.hoverCards.pointerMoved(to: screen)
+        SyntheticInput.register(events)
+        for event in events { NSApp.postEvent(event, atStart: false) }
+        return .object(["posted": .number(Double(events.count)), "target": .string("hover-card")])
+    }
+
     /// Top-left window-local point from `x`,`y` or the center of `pane`.
     private static func point(_ params: [String: JSONValue], controller: WindowController, window: NSWindow) -> NSPoint? {
         if let x = params["x"]?.doubleValue, let y = params["y"]?.doubleValue { return NSPoint(x: x, y: y) }

Packages/macOS/CmuxNext/Sources/CmuxNextDesign/HoverCards/HoverCardCoordinator.swift

@@ -327,7 +327,8 @@ public final class HoverCardCoordinator {
             let panel = panel ?? HoverCardPanel()
             self.panel = panel
             panel.present(body: body.view, anchor: anchor, placement: body.placement, parent: parent,
-                          themeAnchor: body.themeAnchor, sliding: sliding, cornerRadius: body.cornerRadius, applyTheme: body.applyTheme)
+                          themeAnchor: body.themeAnchor, sliding: sliding, interactive: body.interactive,
+                          cornerRadius: body.cornerRadius, applyTheme: body.applyTheme)
             // A hover card whose row's escape slot already holds the pointer (it rested in the
             // sidebar's margin beside the row) goes at once: the slot never shows its row's card.
             if case .shown(let shown) = machine.phase, shown.id == target.id, escapeTarget(at: currentPointer()) == target.id {
@@ -373,6 +374,26 @@ public final class HoverCardCoordinator {
     /// disappears"): the card ignores the mouse, so the window under it would scroll. The card
     /// scrolls its own scroll view (a long timeline) instead, stays, and the event goes no further.
     func handleMonitoredEvent(_ event: NSEvent) -> NSEvent? {
+        if let panel, panel.isInteractive, panel.isShowingCard {
+            let belongsToParent = event.window.map { window in
+                sequence(first: window, next: \.parent).contains { $0 === panel.parent }
+            } ?? false
+            let pointerOnTarget = machine.shownTarget.flatMap { owners[$0.id]?.source?.hoverCardTargetFrame(for: $0.id) }?.contains(currentPointer()) == true
+            let pointerOnCard = panel.cardFrame.contains(currentPointer())
+            if event.type == .keyDown, belongsToParent, (pointerOnTarget || pointerOnCard),
+               let body = panel.body as? any HoverCardInteractiveBody,
+               body.handleHoverCardKeyDown(event) {
+                return nil
+            }
+            let point = event.window.map { $0.convertPoint(toScreen: event.locationInWindow) } ?? currentPointer()
+            if panel.cardFrame.contains(point) {
+                if event.type == .leftMouseDown {
+                    // Let the interactive card's row receive the click. Its
+                    // action dismisses after it focuses the selected tab.
+                    return event
+                }
+            }
+        }
         if event.type == .scrollWheel, let panel, machine.shownTarget != nil, panel.isShowingCard {
             // A real event names the window under the pointer; a synthesized one may name none.
             let point = event.window.map { $0.convertPoint(toScreen: event.locationInWindow) } ?? currentPointer()
@@ -520,6 +541,15 @@ public final class HoverCardCoordinator {
             "card_text": panel.map { $0.isShowingCard ? $0.bodyLines.joined(separator: "\n") : "" } ?? "",
         ]
     }
+
+    #if DEBUG || CMUX_BENCH_HOOKS
+    /// The currently interactive card, for synthetic native input proofs.
+    /// Coordinates are relative to the card, excluding the window's shadow band.
+    public var debugInteractiveCard: (window: NSWindow, frame: CGRect)? {
+        guard let panel, panel.isInteractive, panel.isShowingCard else { return nil }
+        return (panel, panel.cardFrame)
+    }
+    #endif
 }
 
 struct WeakSource {

Packages/macOS/CmuxNext/Sources/CmuxNextDesign/HoverCards/HoverCardSource.swift

@@ -18,20 +18,33 @@ public struct HoverCardBody {
     public var placement: HoverCardPlacement
     public weak var themeAnchor: NSView?
     public var applyTheme: () -> Void
+    /// An interactive body receives mouse events inside the card and may consume
+    /// keyboard navigation before the coordinator dismisses the card.
+    public var interactive: Bool
     /// The card's corner radius; nil is the floating panels' (`HoverCardPanel.cornerRadius`). A card
     /// that hangs from its target with no gap takes the target's shape (a tab's card, the tab's
     /// `Metrics.tabCornerRadius`).
     public var cornerRadius: CGFloat?
-    public init(view: NSView, placement: HoverCardPlacement, themeAnchor: NSView?, cornerRadius: CGFloat? = nil,
+    public init(view: NSView, placement: HoverCardPlacement, themeAnchor: NSView?, interactive: Bool = false,
+                cornerRadius: CGFloat? = nil,
                 applyTheme: @escaping () -> Void) {
         self.view = view
         self.placement = placement
         self.themeAnchor = themeAnchor
+        self.interactive = interactive
         self.cornerRadius = cornerRadius
         self.applyTheme = applyTheme
     }
 }
 
+/// A card body that handles keyboard navigation while the card window remains
+/// non-activating. The coordinator calls this from its local event monitor.
+@MainActor
+public protocol HoverCardInteractiveBody: AnyObject {
+    /// Returns true when the body consumed `event`.
+    func handleHoverCardKeyDown(_ event: NSEvent) -> Bool
+}
+
 /// A card body that can say what it shows, for `debug.hover_cards` (GUI proofs read it).
 @MainActor
 public protocol HoverCardTextReporting {

Packages/macOS/CmuxNext/Sources/CmuxNextDesignTokens/HoverCards/WorkspaceHoverCardOptions.swift

@@ -21,6 +21,9 @@ public nonisolated struct WorkspaceHoverCardOptions: Sendable, Hashable {
     }
 
     public var layout: Layout = .timeline
+    /// When enabled, keep the richer workspace card with prompts, needs-input state and facts.
+    /// The sidebar defaults to the inner-tab preview; this switch preserves the previous card.
+    public var showsRichDetails = false
     /// Running times: the status's and a command's elapsed time, and the stats line.
     public var showsTimings = true
     /// Prompts the person sent, and starts of work, in the history.

Packages/macOS/CmuxNext/Sources/CmuxNextSettings/HoverCardSettings+Options.swift

@@ -5,6 +5,7 @@ extension HoverCardSettings {
     public var workspaceCardOptions: WorkspaceHoverCardOptions {
         var options = WorkspaceHoverCardOptions()
         options.layout = WorkspaceHoverCardOptions.Layout(rawValue: layout.rawValue) ?? .timeline
+        options.showsRichDetails = showsRichDetails
         options.showsTimings = showsTimings
         options.showsPrompts = showsPrompts
         options.showsWaiting = showsWaiting

Packages/macOS/CmuxNext/Sources/CmuxNextSettings/HoverCardSettings.swift

@@ -11,6 +11,8 @@ public nonisolated struct HoverCardSettings: Sendable, Equatable {
     public var delayMilliseconds = HoverCardSettings.delayDefault
     /// The workspace card's design (`sidebar.hoverCards.layout`).
     public var layout = HoverCardSettings.layoutDefault
+    /// Whether to preserve the richer workspace card instead of listing inner tabs.
+    public var showsRichDetails = HoverCardSettings.richDetailsDefault
     /// `sidebar.hoverCards.sections.*`: which parts the workspace card shows.
     public var showsTimings = HoverCardSettings.timingsDefault
     public var showsPrompts = HoverCardSettings.promptsDefault
@@ -40,6 +42,7 @@ public nonisolated struct HoverCardSettings: Sendable, Equatable {
         if let value = reader.bool("enabled") { settings.enabled = value }
         if let value = reader.number("delay", range: delayRange) { settings.delayMilliseconds = value }
         if let value = reader.choice("layout", HoverCardLayoutSetting.self) { settings.layout = value }
+        if let value = reader.bool("richDetails") { settings.showsRichDetails = value }
         if let value = reader.number("maxRows", range: maxRowsRange) { settings.maxRows = value.rounded() }
         diagnostics += reader.diagnostics
         if var sections = ConfigFieldReader(root, at: ["sidebar", "hoverCards", "sections"], diagnostics: &diagnostics) {