FloatingControlBarView.swift

import AppKit
import Combine
import OmiSupport
import OmiTheme
import SwiftUI
import UniformTypeIdentifiers

enum ShortcutHintLayout {
  static func visibleTokens(for keys: [String]) -> [String] {
    keys
  }
}

/// A chat surface replaces the compact notch waveform, so recording must keep
/// its own visible projection while the conversation is open. This is derived
/// entirely from reducer-owned presentation state; it does not create another
/// PTT lifecycle owner.
enum FloatingChatPTTOverlayPolicy {
  static func shouldShow(
    showingAIConversation: Bool,
    isVoiceListening: Bool
  ) -> Bool {
    showingAIConversation && isVoiceListening
  }
}

/// Routes an idle notch click through the main chat's sole window authority.
/// Voice and an already-presented floating conversation own their respective
/// surfaces and must not be displaced by a late notch click.
enum NotchIdleTapRoute {
  static func perform(
    isVoicePresentationActive: Bool,
    isShowingConversation: Bool,
    openMainChat: () -> Void
  ) {
    guard !isVoicePresentationActive, !isShowingConversation else { return }
    openMainChat()
  }
}

enum NotchChromeLayout {
  /// A chat can be restoring or transitioning while the rendered conversation
  /// is already visible. Both states must keep the notch controls pinned;
  /// otherwise the notch controls jump out to the surface edges for
  /// a frame during expansion.
  static func isChatPinned(
    showingAIConversation: Bool,
    hasVisibleConversation: Bool
  ) -> Bool {
    showingAIConversation || hasVisibleConversation
  }

  /// The hover menu and chat surface can grow much wider than the physical
  /// notch. Keep the controls in the notch-width header for the entire
  /// lifecycle so expansion never moves either control away from its
  /// collapsed position.
  static func width(
    chromeWidth: CGFloat,
    expandedWidth: CGFloat,
    switcherProgress: CGFloat,
    isChatPresented: Bool
  ) -> CGFloat {
    // The expanded surface owns the extra width. The header must remain a
    // stable physical-notch anchor whether the row is opening, closing, or
    // transitioning into/restoring chat. Keep the parameters at this seam
    // so tests cover every caller state without duplicating layout policy.
    _ = expandedWidth
    _ = switcherProgress
    _ = isChatPresented
    return chromeWidth
  }
}

/// Main floating control bar SwiftUI view composing all sub-views.
struct FloatingControlBarView: View {
  @EnvironmentObject var state: FloatingControlBarState
  @ObservedObject private var shortcutSettings = ShortcutSettings.shared
  @ObservedObject private var agentPills = AgentPillsManager.shared
  weak var window: NSWindow?
  var onPlayPause: () -> Void
  var onTogglePushToTalk: () -> Void
  var onAskAI: () -> Void
  var onHide: () -> Void
  var onSendQuery: (String) -> Void
  var onCloseAI: () -> Void
  var onEscape: () -> Void
  var onClearVisibleConversation: () -> Void
  var onRate: ((String, Int?, ChatFeedbackReason?) -> Void)?
  var onShareLink: (() async -> String?)?

  @State private var isHovering = false
  @State private var onboardingGlowOn = false
  @State private var notchLogoHovering = false
  @State private var agentSwitcherCollapseWorkItem: DispatchWorkItem?
  /// 0 = hover rows hidden, 1 = hover rows revealed below the fixed header.
  @State private var notchSwitcherProgress: CGFloat = 0
  /// Last reported text-editor height so inputViewHeight can be recomputed
  /// when the pill list changes while the input is open. (Cubic P2.)
  private let agentChatSwitchTransition = Animation.easeOut(duration: 0.10)
  private var isChatChromePinned: Bool {
    NotchChromeLayout.isChatPinned(
      showingAIConversation: state.showingAIConversation,
      hasVisibleConversation: state.hasVisibleConversation
    )
  }
  private var notchHiddenCenterWidth: CGFloat {
    // Without a physical notch there is no dead zone to straddle — keep a
    // small deliberate gap between the lobes instead of the phantom one.
    state.usesNotchIsland
      ? FloatingControlBarWindow.notchHiddenCenterWidth(for: window?.screen ?? NSScreen.main)
      : FloatingControlBarWindow.pillSurfaceCenterGapWidth
  }
  private var notchSideWidth: CGFloat {
    if showingNotchVoiceControl {
      return NotchVoiceControlPresentation.activeSideWidth
    }
    if isChatChromePinned {
      return agentPills.pills.isEmpty
        ? FloatingControlBarWindow.notchCompactSideWidth
        : FloatingControlBarWindow.notchActiveSideWidth
    }
    if showingNotchThinking {
      return FloatingControlBarWindow.notchThinkingSideWidth
    }
    if agentPills.pills.isEmpty && !state.isVoiceListening {
      return FloatingControlBarWindow.notchCompactSideWidth
    }
    return FloatingControlBarWindow.notchActiveSideWidth
  }
  private var notchChromeWidth: CGFloat {
    notchHiddenCenterWidth + notchSideWidth * 2
  }
  private var notchChromeLayoutWidth: CGFloat {
    isChatChromePinned || shouldShowNotchHoverMenu
      ? max(notchChromeWidth, FloatingControlBarWindow.notchExpandedWidth)
      : notchChromeWidth
  }
  /// The surface can morph below it, but chrome always keeps the compact
  /// notch-width header so its controls do not drift.
  private var notchChromeMorphWidth: CGFloat {
    NotchChromeLayout.width(
      chromeWidth: notchChromeWidth,
      expandedWidth: FloatingControlBarWindow.notchExpandedWidth,
      switcherProgress: notchSwitcherProgress,
      isChatPresented: isChatChromePinned
    )
  }
  private var notchSurfaceHorizontalInset: CGFloat {
    state.usesNotchIsland ? FloatingControlBarWindow.notchGlowOutsetX : 0
  }
  private var notchSurfaceBottomInset: CGFloat {
    state.usesNotchIsland ? FloatingControlBarWindow.notchGlowOutsetBottom : 0
  }
  private var notchHoverMenuHeight: CGFloat {
    FloatingControlBarWindow.notchHoverMenuHeight(agentCount: agentPills.pills.count)
  }
  private var notchHoverRowWidth: CGFloat {
    max(
      0,
      min(
        notchChromeLayoutWidth - NotchAgentStackMetrics.listHorizontalInset * 2,
        FloatingControlBarWindow.notchExpandedWidth - NotchAgentStackMetrics.listHorizontalInset * 2
      )
    )
  }
  var body: some View {
    Group {
      if state.usesNotchIsland || state.showingAIConversation || state.isNotchHoverMenuVisible {
        unifiedFloatingSurface
      } else {
        VStack(spacing: state.isShowingNotification && !state.showingAIConversation ? 8 : 0) {
          barChrome

          if let notification = state.currentNotification, !state.showingAIConversation {
            barNotification(notification)
              .floatingBackground(cornerRadius: 18)
              .padding(.horizontal, OmiSpacing.sm)
              .padding(.bottom, OmiSpacing.sm)
              .transition(.move(edge: .top).combined(with: .opacity))
          }
        }
      }
    }
    .frame(
      maxWidth: .infinity,
      maxHeight: .infinity,
      alignment: state.usesNotchIsland || state.showingAIConversation || state.isNotchHoverMenuVisible
        ? .top : .center
    )
    .background(Color.clear)
    .omiAnimation(.spring(response: 0.35, dampingFraction: 0.82), value: state.currentNotification?.id)
    // Placed on the always-mounted root (not inside unifiedFloatingSurface) so
    // the pill→island morph still fires when transitioning out of the idle pill.
    .onChange(of: activeLifecycleKey) { _, _ in
      (window as? FloatingControlBarWindow)?.syncActiveIsland()
    }
  }

  /// Composite key for the active PTT lifecycle — any change drives the
  /// pill ↔ notch-island morph (see FloatingControlBarWindow.syncActiveIsland).
  private var activeLifecycleKey: String {
    "\(state.isVoiceListening)-\(state.isVoiceLocked)-\(state.isThinking)-\(state.isVoiceResponseGlowActive)"
  }

  /// Whether the bar chrome should stretch to fill the window width
  private var barNeedsFullWidth: Bool {
    isHovering || state.isVoiceListening
  }

  private var shouldShowNotchHoverMenu: Bool {
    state.isNotchHoverMenuVisible
      && NotchAgentMenuPresentation.shouldPresent(agentCount: agentPills.pills.count)
  }

  private var showingNotchWaveform: Bool {
    state.voiceProjection.isListening
  }

  /// The trailing notch lobe becomes the visible stop/send action while a
  /// voice turn is capturing. A failure hint keeps its dedicated status
  /// treatment instead of suggesting that a finished turn can be sent.
  private var showingNotchVoiceControl: Bool {
    state.voiceProjection.isListening
  }

  /// The notch "thinking" state: a PTT query is committed and being processed,
  /// with no live listening or open conversation surface. Shows the spinning
  /// Omi mark in the left notch lobe (chat already has its own loading UI).
  private var showingNotchThinking: Bool {
    (state.isThinking || state.isVoiceResponseWaiting)
      && !state.showingAIConversation
      && !state.isVoiceListening
  }

  private var showingPTTStatusBanner: Bool {
    !state.pttHintText.isEmpty
  }

  /// The notch "speaking" state: response audio is playing (or draining), so
  /// the resting ring pulses like a speaker instead of sitting static.
  private var showingNotchSpeaking: Bool {
    state.isVoiceResponseGlowActive && !state.isVoiceListening
  }

  private var unifiedFloatingSurface: some View {
    VStack(spacing: 0) {
      if state.usesNotchIsland || state.showingAIConversation {
        notchChrome
      } else {
        // No camera housing to blend into — the pill surface starts
        // with a slim top inset instead of the notch chrome band.
        Color.clear
          .frame(height: FloatingControlBarWindow.pillSurfaceTopPadding)
      }

      if showingPTTStatusBanner {
        pttStatusBanner
          .frame(height: FloatingControlBarWindow.pttHintRowHeight)
          .padding(.horizontal, OmiSpacing.md)
          .padding(.bottom, OmiSpacing.xs)
          .transition(.opacity)
      }

      if shouldShowNotchHoverMenu {
        if state.usesNotchIsland {
          Color.clear
            .frame(width: notchChromeLayoutWidth, height: notchHoverMenuHeight, alignment: .top)
            .onHover { setAgentSwitcherHovering($0) }
            .transition(.identity)
        } else {
          pillAgentListMenu
        }
      }

      if state.showingAIConversation {
        conversationView
          .padding(.horizontal, OmiSpacing.md)
          .padding(.top, 0)
          .padding(.bottom, FloatingControlBarWindow.notchConversationBottomPadding)
          .transition(.opacity)
      }

      if let notification = state.currentNotification, !state.showingAIConversation {
        barNotification(notification)
          .padding(.horizontal, 10)
          .padding(.bottom, 10)
          .transition(.move(edge: .top).combined(with: .opacity))
      }
    }
    .overlay(alignment: .top) {
      if state.usesNotchIsland && shouldShowNotchHoverMenu {
        ZStack(alignment: .top) {
          NotchAgentMorphField(
            manager: agentPills,
            activePillID: state.activeAgentChatPillID,
            progress: notchSwitcherProgress,
            notchHiddenCenterWidth: notchHiddenCenterWidth,
            notchSideWidth: notchSideWidth,
            notchChromeHeight: notchChromeHeight,
            rowTopOffset: 0,
            onSelect: openAgentInChat
          )
          .frame(width: notchChromeLayoutWidth, height: notchChromeHeight + notchHoverMenuHeight)
          .allowsHitTesting(notchSwitcherProgress > 0.6)

          // Shortcut legend + capture controls, hugging the trailing edge of the
          // expanded surface — the notch's right side, revealed on hover.
          VStack {
            NotchSystemControlsView(progress: notchSwitcherProgress)
              .padding(
                .top,
                notchChromeHeight
                  + FloatingControlBarWindow.notchControlPanelTopOffset(agentCount: agentPills.pills.count)
                  + OmiSpacing.xs
              )
              .padding(.trailing, OmiSpacing.md)
            Spacer(minLength: 0)
          }
          .frame(
            width: notchChromeLayoutWidth,
            height: notchChromeHeight + notchHoverMenuHeight,
            alignment: .topTrailing
          )

          notchAgentLogoHitTarget
            .frame(width: notchChromeLayoutWidth, height: notchChromeHeight)
        }
        .frame(width: notchChromeLayoutWidth, height: notchChromeHeight + notchHoverMenuHeight)
        .onHover { setAgentSwitcherHovering($0) }
      }
    }
    .onAppear { notchSwitcherProgress = shouldShowNotchHoverMenu ? 1 : 0 }
    .padding(.horizontal, notchSurfaceHorizontalInset)
    .padding(.bottom, notchSurfaceBottomInset)
    .background(alignment: .top) {
      GeometryReader { geometry in
        let bottomRadius: CGFloat = state.showingAIConversation || state.currentNotification != nil ? 22 : 18
        let surfaceSize = floatingSurfaceSize(geometry: geometry)
        let surfaceWidth = surfaceSize.width
        let surfaceHeight = surfaceSize.height

        ZStack(alignment: .top) {
          NotchDockShape(
            bottomRadius: bottomRadius,
            topRadius: state.usesNotchIsland ? 0 : 14
          )
          .fill(Color.black)
          .frame(width: surfaceWidth, height: surfaceHeight)

          if state.isVoiceResponseGlowActive {
            NotchResponseGlowView(
              bottomRadius: bottomRadius,
              topRadius: state.usesNotchIsland ? 0 : 14,
              edgeInset: state.usesNotchIsland ? 0 : 3
            )
            .frame(width: surfaceWidth, height: surfaceHeight)
          }

          // Onboarding: a plain white glow on the bar edge so first-run
          // users notice it — no animated sweep. Reuses the voice glow's
          // shape and ramps in 1s after the bar appears. Clears the
          // moment they start typing.
          if state.onboardingBarGlow && state.aiInputText.isEmpty {
            NotchLowerEdgeShape(
              bottomRadius: bottomRadius,
              topRadius: state.usesNotchIsland ? 0 : 14,
              edgeInset: state.usesNotchIsland ? 0 : 3
            )
            .stroke(
              Color.white,
              style: StrokeStyle(lineWidth: 3.2, lineCap: .round, lineJoin: .round)
            )
            .frame(width: surfaceWidth, height: surfaceHeight)
            .shadow(color: Color.white.opacity(0.85), radius: 12)
            .shadow(color: Color.white.opacity(0.5), radius: 22)
            .opacity(onboardingGlowOn ? 1 : 0)
            .allowsHitTesting(false)
            .task {
              // Signal-driven (cancels on disappear) instead of asyncAfter:
              // hold the bar un-glowed for a beat, then ease the glow in.
              onboardingGlowOn = false
              try? await Task.sleep(for: .seconds(1))
              guard !Task.isCancelled else { return }
              OmiMotion.withGated(.easeIn(duration: 0.7)) {
                onboardingGlowOn = true
              }
            }
            .onDisappear { onboardingGlowOn = false }
          }
        }
        .frame(width: geometry.size.width, height: geometry.size.height, alignment: .top)
      }
    }
    .overlay(alignment: .bottomTrailing) {
      if state.showingAIConversation {
        ZStack {
          ResizeHandleView(targetWindow: window)
            .frame(width: 20, height: 20)
          ResizeGripShape()
            .foregroundStyle(.white.opacity(0.3))
            .frame(width: 14, height: 14)
            .allowsHitTesting(false)
        }
        .padding(.trailing, notchSurfaceHorizontalInset + 4)
        .padding(.bottom, notchSurfaceBottomInset + 4)
      }
    }
    .overlay(alignment: .bottom) {
      if FloatingChatPTTOverlayPolicy.shouldShow(
        showingAIConversation: state.showingAIConversation,
        isVoiceListening: state.isVoiceListening
      ) {
        // `conversationView` replaces the normal notch waveform while
        // chat is open. Keep the recording/hint projection visible at
        // the bottom of that same surface instead of hiding PTT state.
        voiceListeningView
          .padding(.horizontal, OmiSpacing.md)
          .frame(height: 42)
          .background(Capsule().fill(Color.white.opacity(0.12)))
          .overlay(Capsule().stroke(Color.white.opacity(0.15), lineWidth: 1))
          .padding(.horizontal, notchSurfaceHorizontalInset + OmiSpacing.md)
          .padding(.bottom, notchSurfaceBottomInset + 8)
          .accessibilityIdentifier("floating_chat_ptt_recording")
          .accessibilityLabel(
            state.pttHintText.isEmpty ? "Recording voice message" : state.pttHintText
          )
          .allowsHitTesting(false)
          .transition(.move(edge: .bottom).combined(with: .opacity))
      }
    }
    .scaleEffect(
      x: max(0.001, state.notchRevealProgress),
      y: max(0.001, state.notchRevealProgress),
      anchor: .top
    )
    .opacity(min(1, max(0, state.notchRevealProgress * 1.4)))
    .contentShape(Rectangle())
    .contextMenu { barContextMenu }
    .onHover(perform: handleBarHover)
    .onChange(of: shouldShowNotchHoverMenu) { _, visible in
      if state.isVoicePresentationActive {
        // A PTT transition replaces the idle hover surface with a separately sized panel. Do not
        // let an in-flight hover spring keep changing the black surface after voice takes over.
        var transaction = Transaction()
        transaction.animation = nil
        withTransaction(transaction) {
          notchSwitcherProgress = 0
        }
        return
      }
      // SwiftUI carries the visible morph. The panel expands before the content
      // and collapses only when this animation reports that it has settled.
      let morphAnim: Animation =
        visible
        ? FloatingControlBarWindow.notchHoverMenuExpandAnimation
        : FloatingControlBarWindow.notchHoverMenuCollapseAnimation
      withAnimation(OmiMotion.gated(morphAnim), completionCriteria: .logicallyComplete) {
        notchSwitcherProgress = visible ? 1 : 0
      } completion: {
        guard !visible, !state.isNotchHoverMenuVisible else { return }
        (window as? FloatingControlBarWindow)?.settleNotchAgentSwitcherCollapse()
      }
    }
    .onChange(of: state.isVoicePresentationActive) { _, active in
      guard active else { return }
      // These view-local values otherwise remain true until pointer exit and can paint stale
      // hover chrome over the voice presentation.
      var transaction = Transaction()
      transaction.animation = nil
      withTransaction(transaction) {
        isHovering = false
        notchLogoHovering = false
        notchSwitcherProgress = 0
      }
    }
    .onChange(of: state.showingAIConversation) { _, isShowing in
      guard state.usesNotchIsland, !isShowing, shouldShowNotchHoverMenu else { return }
      DispatchQueue.main.asyncAfter(deadline: .now() + 0.08) {
        guard shouldShowNotchHoverMenu else { return }
        (window as? FloatingControlBarWindow)?.resizeForAgentSwitcher(visible: true)
      }
    }
    .onChange(of: agentPills.pills.isEmpty) { _, isEmpty in
      if isEmpty {
        state.agentSwitcherPinned = false
        state.agentSwitcherHovering = false
        state.setNotchHoverMenuOpen(false)
        notchLogoHovering = false
        (window as? FloatingControlBarWindow)?.setPillAgentListVisible(false)
      }
    }
    .onDisappear { state.setNotchHoverMenuOpen(false) }
  }

  /// Size of the visible black surface behind the floating content.
  /// Notch hover follows the content morph while AppKit snaps at its boundaries.
  private func floatingSurfaceSize(geometry: GeometryProxy) -> CGSize {
    let notchHoverLifecycle = NotchHoverSurfacePolicy.usesAnimatedHoverSurface(
      usesNotchIsland: state.usesNotchIsland,
      showingAIConversation: state.showingAIConversation,
      isVoicePresentationActive: state.isVoicePresentationActive,
      isShowingNotification: state.isShowingNotification)
    if notchHoverLifecycle {
      let openWidth = max(notchChromeWidth, FloatingControlBarWindow.notchExpandedWidth)
      return CGSize(
        width: notchChromeWidth + (openWidth - notchChromeWidth) * notchSwitcherProgress,
        height: notchChromeHeight + notchHoverMenuHeight * notchSwitcherProgress
      )
    }
    let hasExpandedSurface =
      state.showingAIConversation
      || state.currentNotification != nil
      || shouldShowNotchHoverMenu
      || showingPTTStatusBanner
    guard hasExpandedSurface else {
      return CGSize(width: notchChromeWidth, height: notchChromeHeight)
    }
    return CGSize(
      width: max(notchChromeWidth, geometry.size.width - notchSurfaceHorizontalInset * 2),
      height: max(notchChromeHeight, geometry.size.height - notchSurfaceBottomInset)
    )
  }

  private var notchChrome: some View {
    ZStack {
      HStack(spacing: 0) {
        notchAgentLobe
          .frame(width: notchSideWidth, height: notchChromeHeight)

        Spacer(minLength: notchHiddenCenterWidth)

        notchControlLobe
          .frame(width: notchSideWidth, height: notchChromeHeight)
      }

      Color.clear
        .frame(width: notchHiddenCenterWidth, height: notchChromeHeight)
        .allowsHitTesting(false)
    }
    .frame(height: notchChromeHeight)
    .frame(width: notchChromeMorphWidth)
  }

  private var notchAgentLobe: some View {
    HStack(spacing: 0) {
      ZStack(alignment: .trailing) {
        // One always-mounted identity mark owns idle, PTT, and thinking
        // presentation. The reducer still owns the voice lifecycle; this view
        // only morphs its read-only projection at the mark's existing position.
        NotchAgentPillsRowView(
          manager: agentPills,
          barWindow: window,
          isVoiceListening: showingNotchWaveform,
          isThinking: showingNotchThinking,
          isSpeaking: showingNotchSpeaking,
          isDictating: state.isVoiceDictating,
          isLocked: state.isVoiceLocked
        )
        .scaleEffect(notchLogoHovering ? 1.06 : 1.0)
      }
      .frame(width: notchSideWidth, height: notchChromeHeight, alignment: .trailing)
      .padding(.trailing, OmiSpacing.hairline)
      .contentShape(Rectangle())
      .onHover { hovering in
        guard !state.isVoicePresentationActive else { return }
        setNotchLogoHovering(hovering)
      }
      .onTapGesture {
        guard !state.isVoicePresentationActive else { return }
        openAgentChatsFromNotchLogo()
      }
    }
    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .trailing)
  }

  /// Picks the actionable "Couldn't reach Omi" card for reach errors, else the
  /// normal notification card.
  private enum JITFeedbackPresentation {
    case planned(JITTriggerFeedbackContext)
    case ambient(JITAmbientFeedbackContext)
  }

  @ViewBuilder
  private func barNotification(_ notification: FloatingBarNotification) -> some View {
    if let feedbackContext = notification.jitFeedbackContext {
      jitFeedbackCard(notification, presentation: .planned(feedbackContext))
    } else if let ambientFeedbackContext = notification.jitAmbientFeedbackContext {
      jitFeedbackCard(notification, presentation: .ambient(ambientFeedbackContext))
    } else if notification.assistantId == "reach_error" {
      reachErrorCard(notification)
    } else if notification.assistantId == NotchMoment.receiptAssistantId {
      notchReceiptCard(notification)
    } else if notification.assistantId == NotchMoment.endAssistantId {
      notchEndCard(notification)
    } else if notification.assistantId == MeetingActionItemBannerPolicy.assistantID,
      case .meetingSummaryShare(let conversationID, let recipients)? = notification.action
    {
      MeetingSummaryShareCard(
        notification: notification, conversationID: conversationID, recipients: recipients)
    } else if notification.assistantId == "suggestion" {
      suggestionCard(notification)
    } else if notification.assistantId == IntegrationNudgeCoordinator.assistantID,
      case .connectIntegration(let telemetryID, let triggerID)? = notification.action,
      let entry = IntegrationNudgeCatalog.entry(telemetryID: telemetryID)
    {
      IntegrationNudgeCard(notification: notification, entry: entry, triggerID: triggerID)
    } else if notification.assistantId == FirstRealAppCardCoordinator.assistantID,
      case .askOmiPrefilled(let prompt)? = notification.action
    {
      FirstRealAppCard(notification: notification, prompt: prompt)
    } else if notification.assistantId == ContextReminderCoordinator.assistantID,
      case .contextReminder(let reminderID)? = notification.action
    {
      ContextReminderCard(notification: notification, reminderID: reminderID)
    } else {
      notificationView(notification)
    }
  }

  /// Concrete, explicit-only controls for a planned trigger. Each action is
  /// submitted through the delivery actor; dismissing or ignoring the card
  /// never calls this path.
  private func jitFeedbackCard(
    _ notification: FloatingBarNotification,
    presentation: JITFeedbackPresentation
  ) -> some View {
    VStack(alignment: .leading, spacing: OmiSpacing.sm) {
      Button {
        FloatingControlBarManager.shared.openNotificationAsChat(notification)
      } label: {
        HStack(alignment: .top, spacing: OmiSpacing.md) {
          Image(systemName: "bell.badge.fill")
            .font(.system(size: 18, weight: .semibold))
            .foregroundColor(.white)
            .frame(width: 44, height: 44)
            .background(Color.white.opacity(0.12))
            .clipShape(RoundedRectangle(cornerRadius: 13, style: .continuous))

          VStack(alignment: .leading, spacing: 3) {
            Text(notification.title)
              .scaledFont(size: OmiType.subheading, weight: .semibold)
              .foregroundColor(.white)
              .lineLimit(1)
            Text(notification.message)
              .scaledFont(size: OmiType.body)
              .foregroundColor(.white.opacity(0.78))
              .lineLimit(3)
              .multilineTextAlignment(.leading)
            if InterjectFeature.isEnabled {
              Text(InterjectReplyHint.text(tokens: ShortcutSettings.shared.pttShortcut.displayTokens))
                .scaledFont(size: OmiType.micro, weight: .medium)
                .foregroundColor(.white.opacity(0.45))
                .lineLimit(1)
            }
          }
          Spacer(minLength: 0)
        }
        .contentShape(Rectangle())
      }
      .buttonStyle(.plain)

      HStack(spacing: OmiSpacing.xs) {
        jitFeedbackButton("Useful", systemImage: "hand.thumbsup.fill") {
          submitJITFeedback(.useful, notification: notification, presentation: presentation)
        }
        jitFeedbackButton("Not relevant", systemImage: "hand.thumbsdown.fill") {
          submitJITFeedback(.falsePositive, notification: notification, presentation: presentation)
        }
        if case .planned = presentation {
          jitFeedbackButton("Snooze", systemImage: "zzz") {
            submitJITFeedback(
              .snooze, notification: notification, presentation: presentation,
              snoozedUntil: Date().addingTimeInterval(24 * 60 * 60))
          }
          jitFeedbackButton("Disable", systemImage: "bell.slash.fill") {
            submitJITFeedback(.disable, notification: notification, presentation: presentation)
          }
          jitFeedbackButton("Missed", systemImage: "clock.badge.exclamationmark") {
            submitJITFeedback(.missedOrLate, notification: notification, presentation: presentation)
          }
        }
      }
    }
    .padding(.horizontal, OmiSpacing.lg)
    .padding(.vertical, OmiSpacing.md + 2)
    .overlay(alignment: .topTrailing) {
      Button {
        FloatingControlBarManager.shared.dismissCurrentNotification()
      } label: {
        Image(systemName: "xmark")
          .font(.system(size: 10, weight: .bold))
          .foregroundColor(.white.opacity(0.62))
          .frame(width: 18, height: 18)
          .background(Color.white.opacity(0.08))
          .clipShape(Circle())
      }
      .buttonStyle(.plain)
      .padding(.horizontal, OmiSpacing.md)
      .padding(.vertical, OmiSpacing.md)
      .accessibilityLabel("Dismiss notification")
    }
  }

  private func jitFeedbackButton(
    _ title: String,
    systemImage: String,
    action: @escaping () -> Void
  ) -> some View {
    Button(action: action) {
      Label(title, systemImage: systemImage)
        .scaledFont(size: OmiType.micro, weight: .semibold)
        .foregroundColor(.white.opacity(0.9))
        .padding(.horizontal, OmiSpacing.xs)
        .padding(.vertical, OmiSpacing.xxs)
        .background(Color.white.opacity(0.12))
        .clipShape(Capsule())
    }
    .buttonStyle(.plain)
  }

  private func submitJITFeedback(
    _ action: JITTriggerFeedbackAction,
    notification: FloatingBarNotification,
    presentation: JITFeedbackPresentation,
    snoozedUntil: Date? = nil
  ) {
    let ownerID: String
    switch presentation {
    case .planned(let context): ownerID = context.ownerID
    case .ambient(let context): ownerID = context.ownerID
    }
    guard
      let authorizationSnapshot = RuntimeOwnerIdentity.captureAuthorizationSnapshot(
        expectedOwnerID: ownerID
      )
    else { return }
    let accountGeneration = AccountCutoverControlManager.shared.control.accountGeneration
    let notificationID = notification.id
    Task {
      switch presentation {
      case .planned(let context):
        await FloatingControlBarManager.shared.recordInterjectJITVerdictIfEnabled(
          identity: notification.feedbackIdentity,
          verb: action.interjectVerb)
        await JITTriggerFeedbackActionRouter.record(
          action,
          context: context,
          snoozedUntil: snoozedUntil,
          authorizationSnapshot: authorizationSnapshot)
      case .ambient(let context):
        await JITAmbientFeedbackActionRouter.record(
          action,
          context: context,
          authorizationSnapshot: authorizationSnapshot,
          currentAccountGeneration: accountGeneration,
          presentationCurrent: {
            FloatingControlBarManager.shared.isCurrentNotification(notificationID)
          })
      }
      await MainActor.run {
        guard FloatingControlBarManager.shared.isCurrentNotification(notificationID) else { return }
        FloatingControlBarManager.shared.dismissCurrentNotification()
      }
    }
  }

  /// Live proactive suggestion. Monochrome and quiet by design — this card interrupts
  /// unprompted, so it earns attention with the sentence, not with chrome.
  private func suggestionCard(_ notification: FloatingBarNotification) -> some View {
    Button {
      FloatingControlBarManager.shared.openNotificationAsChat(notification)
    } label: {
      HStack(alignment: .top, spacing: OmiSpacing.md) {
        ZStack {
          RoundedRectangle(cornerRadius: 13, style: .continuous)
            .fill(
              LinearGradient(
                colors: [Color.white.opacity(0.18), Color.white.opacity(0.08)],
                startPoint: .top,
                endPoint: .bottom
              )
            )
            .overlay(
              RoundedRectangle(cornerRadius: 13, style: .continuous)
                .strokeBorder(Color.white.opacity(0.12), lineWidth: 1)
            )
            .frame(width: 44, height: 44)

          Image(systemName: "lightbulb.fill")
            .font(.system(size: 17, weight: .semibold))
            .foregroundColor(.white)
        }

        VStack(alignment: .leading, spacing: 3) {
          Text("Suggested by Omi")
            .scaledFont(size: OmiType.caption, weight: .semibold)
            .foregroundColor(.white.opacity(0.5))
            .lineLimit(1)

          Text(notification.message)
            .scaledFont(size: OmiType.subheading, weight: .medium)
            .foregroundColor(.white)
            .lineLimit(3)
            .multilineTextAlignment(.leading)
            .lineSpacing(1.5)
            .fixedSize(horizontal: false, vertical: true)

          if InterjectFeature.isEnabled {
            Text(InterjectReplyHint.text(tokens: ShortcutSettings.shared.pttShortcut.displayTokens))
              .scaledFont(size: OmiType.micro, weight: .medium)
              .foregroundColor(.white.opacity(0.45))
              .lineLimit(1)
          }
        }

        Spacer(minLength: OmiSpacing.xs)

        // Reserve room so copy never runs under the overlaid dismiss button.
        Color.clear
          .frame(width: 28, height: 20)
      }
      .padding(.horizontal, OmiSpacing.lg)
      .padding(.vertical, OmiSpacing.md + 2)
      .frame(maxWidth: .infinity, alignment: .leading)
      .contentShape(Rectangle())
    }
    .buttonStyle(.plain)
    .overlay(alignment: .topTrailing) {
      Button {
        FloatingControlBarManager.shared.dismissCurrentNotification()
      } label: {
        Image(systemName: "xmark")
          .font(.system(size: 10, weight: .bold))
          .foregroundColor(.white.opacity(0.62))
          .frame(width: 18, height: 18)
          .background(Color.white.opacity(0.08))
          .clipShape(Circle())
      }
      .buttonStyle(.plain)
      .padding(.horizontal, OmiSpacing.md)
      .padding(.vertical, OmiSpacing.md)
      .accessibilityLabel("Dismiss suggestion")
    }
  }

  /// Conversation ends — the USP moment. "N follow-ups ready" + Review / Later.
  private func notchEndCard(_ notification: FloatingBarNotification) -> some View {
    VStack(alignment: .leading, spacing: 2) {
      if !notification.message.isEmpty {
        Text(notification.message)
          .scaledFont(size: 11)
          .foregroundColor(.white.opacity(0.55))
          .lineLimit(1)
      }
      Text(notification.title)
        .scaledFont(size: 13, weight: .semibold)
        .foregroundColor(.white)
        .lineLimit(1)
      HStack(spacing: 7) {
        Button {
          NotchMomentsCoordinator.shared.reviewFollowUps()
          FloatingControlBarManager.shared.dismissCurrentNotification()
        } label: {
          Text("Review")
            .scaledFont(size: 12, weight: .semibold)
            .foregroundColor(.black)
            .padding(.horizontal, 11).padding(.vertical, 4)
            .background(Color.white)
            .clipShape(RoundedRectangle(cornerRadius: 7, style: .continuous))
        }
        .buttonStyle(.plain)
        Button {
          FloatingControlBarManager.shared.dismissCurrentNotification()
        } label: {
          Text("Later").scaledFont(size: 12).foregroundColor(.white.opacity(0.5))
        }
        .buttonStyle(.plain)
      }
      .padding(.top, 4)
    }
    .padding(.horizontal, OmiSpacing.md)
    .padding(.vertical, OmiSpacing.sm)
    .frame(maxWidth: .infinity, alignment: .leading)
  }

  /// Hard reach failure (retries exhausted). Persists until the user picks
  /// Retry (re-runs the query, restarting backoff) or Skip (back to idle).
  private func reachErrorCard(_ notification: FloatingBarNotification) -> some View {
    HStack(alignment: .center, spacing: OmiSpacing.sm) {
      Image(systemName: "exclamationmark.triangle.fill")
        .font(.system(size: 14, weight: .semibold))
        .foregroundColor(.white.opacity(0.9))

      VStack(alignment: .leading, spacing: 1) {
        Text(notification.title)
          .scaledFont(size: OmiType.body, weight: .semibold)
          .foregroundColor(.white)
          .lineLimit(1)
        if !notification.message.isEmpty {
          Text(notification.message)
            .scaledFont(size: 11)
            .foregroundColor(.white.opacity(0.7))
            .lineLimit(1)
        }
      }

      Spacer(minLength: OmiSpacing.sm)

      Button {
        FloatingControlBarManager.shared.retryReachError()
      } label: {
        Text("Retry")
          .scaledFont(size: 12, weight: .semibold)
          .foregroundColor(.white)
          .padding(.horizontal, OmiSpacing.sm)
          .padding(.vertical, OmiSpacing.xxs)
          .background(Color.white.opacity(0.18))
          .clipShape(Capsule())
      }
      .buttonStyle(.plain)

      Button {
        FloatingControlBarManager.shared.dismissReachError()
      } label: {
        Text("Skip")
          .scaledFont(size: 12, weight: .semibold)
          .foregroundColor(.white.opacity(0.6))
          .padding(.horizontal, OmiSpacing.xs)
          .padding(.vertical, OmiSpacing.xxs)
      }
      .buttonStyle(.plain)
    }
    .padding(.horizontal, OmiSpacing.md)
    .padding(.vertical, OmiSpacing.md)
    .frame(maxWidth: .infinity, alignment: .leading)
  }

  private var notchAgentLogoHitTarget: some View {
    GeometryReader { geometry in
      let logoCenterX = NotchAgentStackMetrics.logoCenterX(
        rowWidth: geometry.size.width,
        notchHiddenCenterWidth: notchHiddenCenterWidth,
        notchSideWidth: notchSideWidth
      )

      Color.clear
        .frame(width: 44, height: 44)
        .contentShape(Rectangle())
        .position(x: logoCenterX, y: notchChromeHeight / 2)
        .onHover { setNotchLogoHovering($0) }
        .onTapGesture {
          openAgentChatsFromNotchLogo()
        }
        .accessibilityLabel("Agent chats")
        .accessibilityHint("Open agent chats")
    }
  }

  private var notchControlLobe: some View {
    // Idle-notch clicking opens the main chat. During capture the same lobe
    // becomes the explicit stop/send action, using the existing push-to-talk
    // button facade so the reducer remains the sole lifecycle owner.
    Button {
      if showingNotchVoiceControl {
        onTogglePushToTalk()
      } else {
        openMainChatFromIdleNotch()
      }
    } label: {
      if showingNotchVoiceControl {
        HStack(spacing: OmiSpacing.xxs) {
          Image(systemName: NotchVoiceControlPresentation.iconName(isLocked: state.isVoiceLocked))
            .scaledFont(size: OmiType.micro, weight: .semibold)
          Text(NotchVoiceControlPresentation.title(isLocked: state.isVoiceLocked))
            .scaledFont(size: OmiType.micro, weight: .bold)
        }
        .foregroundColor(state.isVoiceLocked ? .orange : NotchGlass.ink(.w85))
        .padding(.horizontal, OmiSpacing.xs)
        .padding(.vertical, OmiSpacing.xxs)
        .background(
          Capsule().fill(
            state.isVoiceLocked ? Color.orange.opacity(0.18) : NotchGlass.fillHover
          )
        )
        .contentShape(Capsule())
      } else {
        Color.clear
          .contentShape(Rectangle())
      }
    }
    .buttonStyle(.plain)
    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .leading)
    .padding(.leading, OmiSpacing.xs)
    .padding(.trailing, OmiSpacing.md)
    .accessibilityLabel(
      showingNotchVoiceControl
        ? NotchVoiceControlPresentation.accessibilityLabel(isLocked: state.isVoiceLocked)
        : "Open Omi chat"
    )
    .accessibilityValue(
      showingNotchVoiceControl
        ? NotchVoiceControlPresentation.accessibilityValue(isLocked: state.isVoiceLocked)
        : ""
    )
    .accessibilityHint(
      showingNotchVoiceControl
        ? NotchVoiceControlPresentation.accessibilityHint(isLocked: state.isVoiceLocked)
        : "Open the main Omi chat window"
    )
    .help(
      showingNotchVoiceControl
        ? NotchVoiceControlPresentation.accessibilityHint(isLocked: state.isVoiceLocked)
        : "Open the main Omi chat window"
    )
  }

  private var notchChromeHeight: CGFloat {
    FloatingControlBarWindow.notchChromeHeight(for: window?.screen ?? NSScreen.main)
  }

  /// Full-width readable status strip under chrome / pill for too-short PTT
  /// taps and mic errors. Keeps long copy out of the narrow logo/mic slot.
  private var pttStatusBanner: some View {
    PTTStatusBannerContent(hint: state.pttHintText)
  }

  /// Collapsed pill / hover bar chrome. Conversations, notifications-with-
  /// chat, and the agent list all render on `unifiedFloatingSurface` — this
  /// chrome only ever shows the idle pill, hover hints, and voice states.
  private var barChrome: some View {
    VStack(spacing: 0) {
      controlBarView

      if showingPTTStatusBanner {
        pttStatusBanner
          .frame(height: FloatingControlBarWindow.pttHintRowHeight)
          .padding(.horizontal, 10)
          .padding(.bottom, OmiSpacing.xs)
          .transition(.opacity)
      }
    }
    .frame(maxWidth: barNeedsFullWidth || showingPTTStatusBanner ? .infinity : nil, alignment: .top)
    // No .clipped() here: the pill's status/voice glow needs to render
    // outside the chrome bounds (the window grows via glow outsets).
    .background(DraggableAreaView(targetWindow: window))
    .floatingBackground(cornerRadius: barNeedsFullWidth ? 20 : 5)
    .contextMenu {
      barContextMenu
    }
    .onHover(perform: handleBarHover)
  }

  @ViewBuilder
  private var barContextMenu: some View {
    PTTRecoveryMenuItems()
    Button("Hide for 2 hours") {
      FloatingControlBarManager.shared.snooze(
        for: FloatingControlBarManager.snoozeTwoHoursDuration
      )
    }
  }

  private var conversationView: some View {
    ZStack(alignment: .top) {
      if case .agent = state.conversationSurface, let activeAgentChatPill {
        AgentMainChatView(
          pill: activeAgentChatPill,
          manager: agentPills,
          onBackToAgentRows: {
            showAgentListFromConversation()
          },
          onEscape: onEscape
        )
        .id(activeAgentChatPill.id)
        .zIndex(1)
      } else if state.conversationSurface == .mainResponse {
        mainConversationContainer {
          aiResponseView
            .id("response")
        }
        .zIndex(1)
      } else {
        // `.mainInput` has no composer: the notch never takes typed text. The surface still exists
        // for the agent-pills header; the body under it is empty.
        mainConversationContainer {
          Color.clear
            .frame(height: 0)
            .id("input")
        }
        .zIndex(1)
      }
    }
    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
  }

  @ViewBuilder
  private func mainConversationContainer<Content: View>(@ViewBuilder content: () -> Content) -> some View {
    // This is the expanded main-chat header, never the compact/hover row.
    // It cannot depend on pill projection timing: the main transcript can
    // render an accepted spawn receipt one update before the manager does.
    VStack(alignment: .leading, spacing: OmiSpacing.sm) {
      HStack(spacing: OmiSpacing.sm) {
        Button(action: mainConversationBackAction) {
          Image(systemName: "chevron.left")
            .scaledFont(size: OmiType.body, weight: .semibold)
            .foregroundColor(.white.opacity(0.82))
            .frame(width: 36, height: 32)
            .contentShape(Rectangle())
        }
        .buttonStyle(.plain)
        .help(agentPills.pills.isEmpty ? "Close Omi Chat" : "Back to subagents")

        Text("Omi Chat")
          .scaledFont(size: OmiType.body, weight: .bold)
          .foregroundColor(.white)
          .lineLimit(1)

        Spacer(minLength: 0)

        if state.hasVisibleConversation {
          escToClearHint
        }
      }
      .padding(.horizontal, OmiSpacing.md)
      .padding(.top, OmiSpacing.sm)

      content()
    }
  }

  private var activeAgentChatPill: AgentPill? {
    guard let id = state.activeAgentChatPillID else { return nil }
    return agentPills.pills.first { $0.id == id }
  }

  private var escToClearHint: some View {
    HStack(spacing: OmiSpacing.xxs) {
      Text("esc")
        .scaledFont(size: OmiType.caption)
        .foregroundColor(.secondary)
        .frame(width: 30, height: 16)
        .background(Color.white.opacity(0.1))
        .cornerRadius(4)
      Text("to clear")
        .scaledFont(size: OmiType.caption)
        .foregroundColor(.secondary)
    }
  }

  private func setAgentSwitcherHovering(_ hovering: Bool) {
    agentSwitcherCollapseWorkItem?.cancel()
    agentSwitcherCollapseWorkItem = nil

    if hovering {
      (window as? FloatingControlBarWindow)?.openNotchHoverMenuUntilExit()
      return
    }

    let workItem = DispatchWorkItem {
      (window as? FloatingControlBarWindow)?.updateNotchPointerFromGlobalMouse()
      if !shouldShowNotchHoverMenu {
        notchLogoHovering = false
      }
    }
    agentSwitcherCollapseWorkItem = workItem
    DispatchQueue.main.asyncAfter(deadline: .now() + 0.12, execute: workItem)
  }

  private func toggleAgentSwitcherPinned() {
    guard !agentPills.pills.isEmpty else { return }
    agentSwitcherCollapseWorkItem?.cancel()
    agentSwitcherCollapseWorkItem = nil
    state.agentSwitcherPinned.toggle()
    state.agentSwitcherHovering = state.agentSwitcherPinned
  }

  private func setNotchLogoHovering(_ hovering: Bool) {
    guard !state.isVoicePresentationActive || !hovering else {
      notchLogoHovering = false
      return
    }
    OmiMotion.withGated(.spring(response: 0.18, dampingFraction: 0.74)) {
      notchLogoHovering = hovering
    }
    setAgentSwitcherHovering(hovering)
  }

  private func openAgentChatsFromNotchLogo() {
    guard !agentPills.pills.isEmpty else {
      openMainChatFromIdleNotch()
      return
    }
    if state.showingAIConversation {
      showAgentListFromConversation()
      return
    }
    if state.usesNotchIsland {
      toggleAgentSwitcherPinned()
      (window as? FloatingControlBarWindow)?.openNotchHoverMenuUntilExit()
    } else {
      (window as? FloatingControlBarWindow)?
        .setPillAgentListVisible(!state.isNotchHoverMenuVisible)
    }
  }

  private func openAgentInChat(_ pill: AgentPill) {
    openAgentInChat(agentID: pill.id)
  }

  private func openAgentInChat(agentID: UUID, completion: ((Bool) -> Void)? = nil) {
    openAgentInChat(
      ref: AgentTimelineRef(pillId: agentID, sessionId: nil, runId: nil),
      completion: completion
    )
  }

  private func openAgentInChat(ref: AgentTimelineRef, completion: ((Bool) -> Void)? = nil) {
    Task { @MainActor in
      let resolved = await agentPills.resolveAndPresentAgent(
        pillId: ref.pillId,
        sessionId: ref.sessionId,
        runId: ref.runId
      )
      guard resolved else {
        log(
          "FloatingControlBarView: agent open unavailable after hydrate "
            + "pillId=\(ref.pillId?.uuidString ?? "nil") "
            + "sessionId=\(ref.sessionId ?? "nil") "
            + "runId=\(ref.runId ?? "nil")"
        )
        completion?(false)
        return
      }
      guard
        let pill = agentPills.pills.first(where: { pill in
          if let pillId = ref.pillId, pill.id == pillId { return true }
          if let runId = ref.runId, pill.canonicalRunId == runId { return true }
          if let sessionId = ref.sessionId, pill.canonicalSessionId == sessionId { return true }
          return false
        }) ?? ref.pillId.flatMap({ id in agentPills.pills.first(where: { $0.id == id }) })
      else {
        completion?(false)
        return
      }
      if state.conversationSurface == .agent(pill.id) {
        showAgentListFromConversation()
        completion?(true)
        return
      }
      agentPills.markViewed(pillID: pill.id)
      let barWindow = window as? FloatingControlBarWindow
      let wasShowingConversation = state.showingAIConversation
      state.setNotchHoverMenuOpen(false)
      notchLogoHovering = false
      barWindow?.makeKeyAndOrderFront(nil)
      OmiMotion.withGated(agentChatSwitchTransition) {
        state.present(.agent(pill.id))
        state.isAILoading = false
      }
      barWindow?.resizeForActiveAgentChatPublic(pillID: pill.id, animated: !wasShowingConversation)
      completion?(true)
    }
  }

  private func openMainChatFromIdleNotch() {
    NotchIdleTapRoute.perform(
      isVoicePresentationActive: state.isVoicePresentationActive,
      isShowingConversation: state.showingAIConversation,
      openMainChat: {
        AppDelegate.summonWindowTarget()?.openMainAppChat()
      }
    )
  }

  private func showAgentListFromConversation() {
    (window as? FloatingControlBarWindow)?.leaveAgentConversation() ?? onCloseAI()
  }

  private func mainConversationBackAction() {
    guard !agentPills.pills.isEmpty else {
      onCloseAI()
      return
    }
    showAgentListFromConversation()
  }

  private func handleBarHover(_ hovering: Bool) {
    FloatingControlBarManager.shared.interjectBarHoverChanged(hovering)
    if state.usesNotchIsland {
      (window as? FloatingControlBarWindow)?.updateNotchPointerFromGlobalMouse()
      let showsHoverChrome = hovering && !state.isVoicePresentationActive
      OmiMotion.withGated(.easeOut(duration: FloatingControlBarWindow.notchHoverMenuExpandDuration)) {
        isHovering = showsHoverChrome && state.isNotchHoverMenuVisible
      }
      if !hovering || !state.isNotchHoverMenuVisible {
        notchLogoHovering = false
      }
      return
    }

    if !hovering {
      state.requiresHoverReset = false
    }

    let effectiveHover = hovering && !state.requiresHoverReset && isWithinActivationZoneForCurrentMode()
    state.isHoveringBar = effectiveHover

    // With subagents present, hovering the pill unfurls the agent rows —
    // the same surface the notch shows on hover — instead of the legacy
    // expanded bar. Moving the pointer away collapses back to the pill.
    if !agentPills.pills.isEmpty, !state.showingAIConversation {
      let barWindow = window as? FloatingControlBarWindow
      if effectiveHover {
        barWindow?.setPillAgentListVisible(true)
      } else {
        barWindow?.schedulePillAgentListCollapse()
      }
      return
    }

    // Resize window BEFORE updating SwiftUI state on expand so the expanded
    // content never renders in a too-small window. If the resize was
    // skipped (guarded), do NOT show the expanded bar — oversized content
    // in a small window force-grows it with the origin pinned, sliding
    // the pill sideways.
    var didExpand = false
    if effectiveHover {
      didExpand = (window as? FloatingControlBarWindow)?.resizeForHover(expanded: true) ?? false
    }
    let hoverAnimation = Animation.easeOut(duration: FloatingControlBarWindow.notchHoverMenuExpandDuration)
    withAnimation(OmiMotion.gated(hoverAnimation), completionCriteria: .logicallyComplete) {
      isHovering = effectiveHover && didExpand
    } completion: {
      guard state.usesNotchIsland, !effectiveHover, !state.isHoveringBar else { return }
      (window as? FloatingControlBarWindow)?.resizeForHover(expanded: false)
    }
    if !effectiveHover, !state.usesNotchIsland {
      (window as? FloatingControlBarWindow)?.resizeForHover(expanded: false)
    }
  }

  private func isWithinActivationZoneForCurrentMode() -> Bool {
    guard state.usesNotchIsland else { return true }
    guard let window else { return false }
    // Exclude the transparent glow margin from hover activation.
    let hitHeight =
      state.isAgentSwitcherExpanded
      ? max(notchChromeHeight, notchChromeHeight + notchHoverMenuHeight)
      : FloatingControlBarWindow.notchActivationHeight
    let visibleWidth =
      state.isAgentSwitcherExpanded
      ? max(notchChromeWidth, FloatingControlBarWindow.notchExpandedWidth)
      : notchChromeWidth
    let horizontalOutset = max(
      FloatingControlBarWindow.notchGlowOutsetX,
      (window.frame.width - visibleWidth) / 2
    )
    return FloatingControlBarGeometry.notchChromeActivationContains(
      mouseLocation: NSEvent.mouseLocation,
      windowFrame: window.frame,
      chromeHeight: hitHeight,
      horizontalOutset: horizontalOutset
    )
  }

  private func notificationView(_ notification: FloatingBarNotification) -> some View {
    // The entire card opens the chat. A SwiftUI Button only hit-tests its
    // visible content, so the previous layout left the padding and spacer
    // as dead zones — users reported clicks landing "on the box" doing
    // nothing. Wrapping the whole card in a single Button with
    // contentShape(Rectangle()) makes every pixel clickable. The dismiss
    // (X) button sits in an overlay on top so it keeps its own hit region.
    let copy = FloatingControlBarManager.notificationCardCopy(
      title: notification.title,
      message: notification.message,
      kind: notification.kind
    )
    return Button {
      FloatingControlBarManager.shared.openNotificationAsChat(notification)
    } label: {
      HStack(alignment: .top, spacing: OmiSpacing.md) {
        FloatingBarNotificationCardLead(
          copy: copy,
          messageLineLimit: interjectInsightTeaserLimit(notification),
          footer: InterjectFeature.isEnabled
            ? InterjectReplyHint.text(tokens: ShortcutSettings.shared.pttShortcut.displayTokens)
            : nil
        )
        Spacer(minLength: 0)

        // Reserve space so text never runs under the overlaid action buttons.
        // Wider for actionable (task) notifications that also show Execute.
        Color.clear
          .frame(width: notification.assistantId == "task" ? 96 : 40, height: 20)
      }
      .padding(.horizontal, OmiSpacing.lg)
      .padding(.vertical, OmiSpacing.md + 2)
      .frame(maxWidth: .infinity, alignment: .leading)
      .contentShape(Rectangle())
    }
    .buttonStyle(.plain)
    .overlay(alignment: .topTrailing) {
      HStack(spacing: OmiSpacing.xs) {
        // Execute is only meaningful for actionable notifications (tasks).
        // Focus / Insight (tips) / other passive notifications are
        // informational — spawning an agent there made no sense.
        if notification.assistantId == "task" {
          Button {
            let model =
              ShortcutSettings.shared.selectedModel.isEmpty
              ? ModelQoS.Claude.defaultSelection
              : ShortcutSettings.shared.selectedModel
            let query = ProactiveTaskExecute.buildQuery(
              title: notification.title,
              message: notification.message
            )
            _ = AgentPillsManager.shared.spawn(
              query: query,
              model: model,
              originSurface: .floatingBar,
              systemPromptSuffix: ProactiveTaskExecute.systemPromptSuffix
            )
            FloatingControlBarManager.shared.dismissCurrentNotification()
          } label: {
            HStack(spacing: OmiSpacing.xxs) {
              Image(systemName: "sparkles")
                .font(.system(size: 9, weight: .bold))
              Text("Execute")
                .scaledFont(size: OmiType.micro, weight: .semibold)
            }
            .foregroundColor(.white)
            .padding(.horizontal, OmiSpacing.sm)
            .padding(.vertical, OmiSpacing.xxs)
            .background(Color.white.opacity(0.18))
            .clipShape(Capsule())
          }
          .buttonStyle(.plain)
          .help("Spawn an agent to handle this")
        }

        Button {
          FloatingControlBarManager.shared.dismissCurrentNotification()
        } label: {
          Image(systemName: "xmark")
            .font(.system(size: 10, weight: .bold))
            .foregroundColor(.white.opacity(0.62))
            .frame(width: 18, height: 18)
            .background(Color.white.opacity(0.08))
            .clipShape(Circle())
        }
        .buttonStyle(.plain)
      }
      .padding(.horizontal, OmiSpacing.md)
      .padding(.vertical, OmiSpacing.md)
    }
  }

  private var controlBarView: some View {
    let allowsHoverExpansion = isHovering && !state.isVoiceResponseGlowActive
    return Group {
      if !state.pttHintText.isEmpty {
        // Too-short / error copy lives in `pttStatusBanner` below — keep
        // the pill chrome as the idle strip so we don't stack two mics.
        PillStatusObservingView(manager: agentPills) { pills in
          let agentGroup =
            state.isVoiceResponseGlowActive
            ? nil
            : NotchAgentStatusGroup.aggregate(for: pills)
          compactCircleView(agentGroup: agentGroup)
            .modifier(AgentStatusGlow(group: agentGroup))
        }
        .frame(height: 14)
        .padding(.vertical, 5)
        .transition(.opacity)
      } else if state.isVoiceListening {
        voiceListeningView
          .padding(.horizontal, 10)
          .padding(.vertical, 5)
          .frame(height: 42)
          .transition(.opacity)
      } else if allowsHoverExpansion {
        VStack(spacing: 1) {
          compactButton(title: "Open Omi", keys: shortcutSettings.askOmiShortcut.displayTokens) {
            onAskAI()
          }

          HStack(spacing: OmiSpacing.xs) {
            compactLabel("Push to talk", keys: shortcutSettings.pttShortcut.displayTokens)
          }
        }
        .padding(.horizontal, OmiSpacing.xs)
        .padding(.vertical, 3)
        .frame(height: 50)
        .transition(.opacity)
      } else {
        PillStatusObservingView(manager: agentPills) { pills in
          let agentGroup =
            state.isVoiceResponseGlowActive
            ? nil
            : NotchAgentStatusGroup.aggregate(for: pills)
          compactCircleView(agentGroup: agentGroup)
            .modifier(AgentStatusGlow(group: agentGroup))
        }
        .transition(.opacity)
      }
    }
  }

  /// The pill-mode agent list: same rows as the notch hover menu, rendered
  /// directly (no notch morph — there is no logo ring to unfurl from).
  private var pillAgentListMenu: some View {
    PillStatusObservingView(manager: agentPills) { pills in
      VStack(spacing: 0) {
        ForEach(pills.prefix(NotchAgentStackMetrics.maxAgents), id: \.id) { pill in
          Button {
            openAgentInChat(pill)
          } label: {
            NotchAgentListRow(
              title: pill.title,
              status: pill.status,
              activity: ChatContinuityInvariants.agentPreviewText(
                prompt: pill.query,
                output: pill.latestActivity
              ),
              isSelected: pill.id == state.activeAgentChatPillID,
              progress: 1
            )
            .overlay(alignment: .leading) {
              pillRowIdentityMark(pill)
                .padding(.leading, NotchAgentStackMetrics.listRowLeadingPadding)
            }
            .frame(width: notchHoverRowWidth, height: FloatingControlBarWindow.notchAgentListRowHeight)
          }
          .buttonStyle(.plain)
          .help(pill.title)
        }
      }
      .padding(.bottom, FloatingControlBarWindow.notchHoverMenuBottomMargin)
      .frame(width: notchChromeLayoutWidth, alignment: .top)
      .onHover { handleBarHover($0) }
      .transition(.opacity)
    }
  }

  @ViewBuilder
  private func pillRowIdentityMark(_ pill: AgentPill) -> some View {
    let group = NotchAgentStatusGroup(status: pill.status)
    if pill.providerIdentity.rendersProviderMark {
      AgentProviderLogoMark(
        provider: pill.providerIdentity,
        statusColor: group.color,
        size: NotchAgentStackMetrics.listOrbSize + 5
      )
      .shadow(color: group.color.opacity(0.55), radius: 5)
    } else {
      Circle()
        .fill(group.color)
        .frame(width: NotchAgentStackMetrics.listOrbSize, height: NotchAgentStackMetrics.listOrbSize)
        .overlay(
          Circle()
            .strokeBorder(Color.white.opacity(0.42), lineWidth: 0.8)
        )
        .shadow(color: group.color.opacity(0.6), radius: 5)
    }
  }

  /// Minimal thin bar shown when not hovering. The fill is the primary
  /// ambient status channel at this size: voice-response gradient wins,
  /// then the aggregate subagent color, then neutral gray.
  private func compactCircleView(agentGroup: NotchAgentStatusGroup?) -> some View {
    RoundedRectangle(cornerRadius: OmiChrome.stripRadius)
      .fill(compactPillFill(agentGroup: agentGroup))
      .frame(width: 28, height: 6)
      .shadow(
        color: state.isVoiceResponseGlowActive ? Color.white.opacity(0.85) : .clear,
        radius: state.isVoiceResponseGlowActive ? 16 : 0,
        x: 0,
        y: 0
      )
      .shadow(
        color: state.isVoiceResponseGlowActive ? Color.white.opacity(0.45) : .clear,
        radius: state.isVoiceResponseGlowActive ? 28 : 0,
        x: 0,
        y: 0
      )
      .overlay {
        if state.isVoiceResponseGlowActive {
          RoundedRectangle(cornerRadius: OmiChrome.stripRadius)
            .stroke(
              LinearGradient(
                colors: [
                  Color.white.opacity(0.9),
                  Color(red: 0.25, green: 0.75, blue: 1.0),
                  Color.white.opacity(0.7),
                ],
                startPoint: .leading,
                endPoint: .trailing
              ),
              lineWidth: 1.4
            )
            .padding(-2.2)
            .blur(radius: 0.25)
        }
      }
      .omiAnimation(.easeInOut(duration: 0.18), value: state.isVoiceResponseGlowActive)
  }

  private func compactPillFill(agentGroup: NotchAgentStatusGroup?) -> LinearGradient {
    if state.isVoiceResponseGlowActive {
      return LinearGradient(
        colors: [
          Color.white.opacity(0.9),
          Color(red: 0.50, green: 0.75, blue: 1.0),
          Color.white.opacity(0.7),
        ],
        startPoint: .leading,
        endPoint: .trailing
      )
    }
    if let agentGroup {
      return LinearGradient(
        colors: [
          agentGroup.color.opacity(0.85),
          agentGroup.color,
          agentGroup.color.opacity(0.85),
        ],
        startPoint: .leading,
        endPoint: .trailing
      )
    }
    return LinearGradient(
      colors: [Color.white.opacity(0.5), Color.white.opacity(0.5)],
      startPoint: .leading,
      endPoint: .trailing
    )
  }

  private func compactToggle(_ title: String, isOn: Binding<Bool>) -> some View {
    Button(action: { isOn.wrappedValue.toggle() }) {
      HStack(spacing: 3) {
        Text(title)
          .scaledFont(size: OmiType.caption, weight: .medium)
          .foregroundColor(.white)
        RoundedRectangle(cornerRadius: OmiChrome.badgeRadius)
          .fill(isOn.wrappedValue ? Color.white.opacity(0.3) : Color.white.opacity(0.1))
          .frame(width: 26, height: 15)
          .overlay(alignment: isOn.wrappedValue ? .trailing : .leading) {
            Circle()
              .fill(.white)
              .frame(width: 11, height: 11)
              .padding(OmiSpacing.hairline)
          }
          .omiAnimation(.easeInOut(duration: 0.15), value: isOn.wrappedValue)
      }
    }
    .buttonStyle(.plain)
  }

  private func compactButton(title: String, keys: [String], action: @escaping () -> Void) -> some View {
    Button(action: action) {
      compactLabel(title, keys: keys)
    }
    .buttonStyle(.plain)
  }

  private func compactLabel(_ title: String, keys: [String]) -> some View {
    HStack(spacing: 3) {
      Text(title)
        .scaledFont(size: OmiType.caption, weight: .medium)
        .foregroundColor(.white)
      ForEach(keys, id: \.self) { key in
        Text(key)
          .scaledFont(size: 9)
          .foregroundColor(.white)
          .padding(.horizontal, key.count > 1 ? 4 : 0)
          .frame(minWidth: 15, minHeight: 15)
          .background(Color.white.opacity(0.1))
          .cornerRadius(OmiChrome.stripRadius)
      }
    }
  }

  private var voiceListeningView: some View {
    HStack(spacing: 7) {
      if state.pttHintText.isEmpty {
        // Playful realtime mic waveform (replaces the old pulsing red dot)
        VoiceWaveformBars(isActive: state.isVoiceListening)
      }

      Image(systemName: "mic.fill")
        .scaledFont(size: 12, weight: .semibold)
        .foregroundColor(.white)

      if let title = state.interjectReplyingToTitle, InterjectFeature.isEnabled {
        Text(InterjectReplyHint.listeningChip(title: title))
          .scaledFont(size: OmiType.micro, weight: .medium)
          .foregroundColor(.white.opacity(0.72))
          .lineLimit(1)
      }

      // Locked mode is a mode the user has to be able to see at a glance: a bare glyph
      // read as decoration, and gating it on an empty hint hid it for most of the turn.
      // Restores the pre-2b416572c0 badge, always shown while locked.
      if state.isVoiceLocked {
        Text("LOCKED")
          .scaledFont(size: 10, weight: .bold)
          .foregroundColor(.orange)
          .padding(.horizontal, 6)
          .padding(.vertical, 2)
          .background(Color.orange.opacity(0.2))
          .cornerRadius(4)
      }
    }
  }

  private func interjectInsightTeaserLimit(_ notification: FloatingBarNotification) -> Int {
    FloatingControlBarGeometry.interjectInsightTeaserLineLimit(
      kindIsInsight: InterjectFeature.isEnabled && notification.kind == .insight,
      isHovering: isHovering,
      interjectBarHovering: state.interjectBarHovering,
      interjectPTTHoldActive: state.interjectReplyingToTitle != nil
    )
  }

  private var floatingChatProvider: ChatProvider? {
    FloatingControlBarManager.shared.sharedFloatingProvider
  }

  /// The chip's secondary hint names the shortcut actually bound, and is absent
  /// when push-to-talk is off — a hint for a disabled gesture is a wrong hint.
  ///
  /// Every token, not the first: a chord binding (`⌃⌥`, or a modifier plus a
  /// key) renders as several tokens, and naming only the first one tells the
  /// user to hold a key that does not start voice. Joined the way the sibling
  /// hold hint joins them, so the two read the same on the same bar.
  @MainActor static func followUpVoiceHint(settings: ShortcutSettings = ShortcutSettings.shared) -> String? {
    guard settings.pttEnabled else { return nil }
    let shortcut = settings.pttShortcut.displayTokens.joined()
    guard !shortcut.isEmpty else { return nil }
    return "or hold \(shortcut) to ask aloud"
  }

  private var aiResponseView: some View {
    // Re-read derived content when viewport anchors or streamed answer tokens change.
    let _ = state.chatViewport
    let _ = state.answerStreamToken
    let provider = floatingChatProvider
    return AIResponseView(
      isLoading: Binding(
        get: { state.isAILoading },
        set: { state.isAILoading = $0 }
      ),
      currentMessage: state.currentAIMessage(from: provider),
      userInput: state.displayedQuery,
      chatHistory: state.derivedChatHistory(from: provider),
      canClearVisibleConversation: false,
      showsHeader: false,
      onClearVisibleConversation: onClearVisibleConversation,
      onEscape: onEscape,
      onOpenMainApp: {
        (window as? FloatingControlBarWindow)?.closeAIConversation()
        AppDelegate.summonWindowTarget()?.openMainAppChat()
      },
      onRate: onRate,
      onShareLink: onShareLink,
      onOpenAgent: { agentID, completion in
        openAgentInChat(agentID: agentID, completion: completion)
      },
      onOpenAgentRef: { ref, completion in
        openAgentInChat(ref: ref, completion: completion)
      },
      onAskFollowUp: { question in
        AnalyticsManager.shared.questionOriginating(.followUp)
        FloatingControlBarManager.shared.openAIInputWithQuery(question)
      },
      followUpVoiceHint: Self.followUpVoiceHint()
    )
    .transition(
      .asymmetric(
        insertion: .move(edge: .bottom).combined(with: .opacity),
        removal: .move(edge: .bottom).combined(with: .opacity)
      ))
  }

}

private struct NotchDockShape: Shape {
  let bottomRadius: CGFloat
  var topRadius: CGFloat = 0

  func path(in rect: CGRect) -> Path {
    let radius = min(bottomRadius, rect.height / 2)
    // Square top corners blend into a physical notch/bezel; a floating
    // surface on a non-notched display rounds them instead.
    let topR = min(topRadius, rect.height / 2)
    var path = Path()
    path.move(to: CGPoint(x: rect.minX + topR, y: rect.minY))
    path.addLine(to: CGPoint(x: rect.maxX - topR, y: rect.minY))
    path.addQuadCurve(
      to: CGPoint(x: rect.maxX, y: rect.minY + topR),
      control: CGPoint(x: rect.maxX, y: rect.minY)
    )
    path.addLine(to: CGPoint(x: rect.maxX, y: rect.maxY - radius))
    path.addQuadCurve(
      to: CGPoint(x: rect.maxX - radius, y: rect.maxY),
      control: CGPoint(x: rect.maxX, y: rect.maxY)
    )
    path.addLine(to: CGPoint(x: rect.minX + radius, y: rect.maxY))
    path.addQuadCurve(
      to: CGPoint(x: rect.minX, y: rect.maxY - radius),
      control: CGPoint(x: rect.minX, y: rect.maxY)
    )
    path.addLine(to: CGPoint(x: rect.minX, y: rect.minY + topR))
    path.addQuadCurve(
      to: CGPoint(x: rect.minX + topR, y: rect.minY),
      control: CGPoint(x: rect.minX, y: rect.minY)
    )
    path.closeSubpath()
    return path
  }
}

private struct NotchLowerEdgeShape: Shape {
  let bottomRadius: CGFloat
  /// 0 = open lower-edge path (notch mode: the top blends into the bezel).
  /// > 0 = closed full-perimeter ring with rounded top corners (pill mode:
  /// the surface is a floating card, so the glow wraps all the way around).
  var topRadius: CGFloat = 0
  /// Inset from the shape bounds. Pill-mode windows have no glow outsets,
  /// so the ring is drawn slightly inside the surface to avoid clipping.
  var edgeInset: CGFloat = 0

  func path(in rect: CGRect) -> Path {
    let rect = rect.insetBy(dx: edgeInset, dy: edgeInset)
    let radius = min(max(0, bottomRadius - edgeInset), rect.height / 2)
    var path = Path()
    if topRadius > 0 {
      let topR = min(max(0, topRadius - edgeInset), rect.height / 2)
      path.move(to: CGPoint(x: rect.minX + topR, y: rect.minY))
      path.addLine(to: CGPoint(x: rect.maxX - topR, y: rect.minY))
      path.addQuadCurve(
        to: CGPoint(x: rect.maxX, y: rect.minY + topR),
        control: CGPoint(x: rect.maxX, y: rect.minY)
      )
    } else {
      path.move(to: CGPoint(x: rect.maxX, y: rect.minY + 1))
    }
    path.addLine(to: CGPoint(x: rect.maxX, y: rect.maxY - radius))
    path.addQuadCurve(
      to: CGPoint(x: rect.maxX - radius, y: rect.maxY),
      control: CGPoint(x: rect.maxX, y: rect.maxY)
    )
    path.addLine(to: CGPoint(x: rect.minX + radius, y: rect.maxY))
    path.addQuadCurve(
      to: CGPoint(x: rect.minX, y: rect.maxY - radius),
      control: CGPoint(x: rect.minX, y: rect.maxY)
    )
    if topRadius > 0 {
      let topR = min(max(0, topRadius - edgeInset), rect.height / 2)
      path.addLine(to: CGPoint(x: rect.minX, y: rect.minY + topR))
      path.addQuadCurve(
        to: CGPoint(x: rect.minX + topR, y: rect.minY),
        control: CGPoint(x: rect.minX, y: rect.minY)
      )
      path.closeSubpath()
    } else {
      path.addLine(to: CGPoint(x: rect.minX, y: rect.minY + 1))
    }
    return path
  }
}

private struct NotchResponseGlowView: View {
  let bottomRadius: CGFloat
  /// See `NotchLowerEdgeShape`: 0 = notch lower-edge glow, > 0 = pill-mode
  /// full-perimeter ring with this top corner radius.
  var topRadius: CGFloat = 0
  var edgeInset: CGFloat = 0

  var body: some View {
    TimelineView(.periodic(from: .now, by: 1.0 / 24.0)) { timeline in
      let time = timeline.date.timeIntervalSinceReferenceDate
      let phase = time.truncatingRemainder(dividingBy: 2.4) / 2.4
      let sweepStart = UnitPoint(x: -0.35 + phase * 1.7, y: 0.0)
      let sweepEnd = UnitPoint(x: 0.35 + phase * 1.7, y: 1.0)
      let edge = NotchLowerEdgeShape(
        bottomRadius: bottomRadius,
        topRadius: topRadius,
        edgeInset: edgeInset
      )

      ZStack {
        edge
          .stroke(
            LinearGradient(
              colors: [
                Color.white.opacity(1.0),
                Color(red: 0.72, green: 0.88, blue: 1.0).opacity(1.0),
                Color(red: 0.88, green: 0.95, blue: 1.0).opacity(1.0),
                Color.white.opacity(1.0),
              ],
              startPoint: .leading,
              endPoint: .trailing
            ),
            style: StrokeStyle(lineWidth: 3.2, lineCap: .round, lineJoin: .round)
          )

        edge
          .stroke(
            LinearGradient(
              stops: [
                .init(color: .clear, location: 0.0),
                .init(color: Color.white.opacity(0.55), location: 0.28),
                .init(color: Color(red: 0.22, green: 0.88, blue: 1.0).opacity(1.0), location: 0.45),
                .init(color: Color.white.opacity(1.0), location: 0.53),
                .init(color: Color(red: 1.0, green: 0.96, blue: 0.92).opacity(0.95), location: 0.70),
                .init(color: .clear, location: 1.0),
              ],
              startPoint: sweepStart,
              endPoint: sweepEnd
            ),
            style: StrokeStyle(lineWidth: 4.8, lineCap: .round, lineJoin: .round)
          )
      }
    }
    .allowsHitTesting(false)
  }
}

private struct SubagentChatPointer: Shape {
  func path(in rect: CGRect) -> Path {
    var path = Path()
    path.move(to: CGPoint(x: rect.midX, y: rect.minY))
    path.addLine(to: CGPoint(x: rect.maxX, y: rect.maxY))
    path.addLine(to: CGPoint(x: rect.minX, y: rect.maxY))
    path.closeSubpath()
    return path
  }
}

private struct AgentMainChatView: View {
  @EnvironmentObject var state: FloatingControlBarState
  @ObservedObject var pill: AgentPill
  @ObservedObject var manager: AgentPillsManager
  let onBackToAgentRows: () -> Void
  let onEscape: () -> Void

  init(
    pill: AgentPill,
    manager: AgentPillsManager,
    onBackToAgentRows: @escaping () -> Void,
    onEscape: @escaping () -> Void
  ) {
    self.pill = pill
    self.manager = manager
    self.onBackToAgentRows = onBackToAgentRows
    self.onEscape = onEscape
  }

  private var isRunning: Bool {
    guard !hasFinalAssistantOutput else { return false }
    switch pill.status {
    case .queued, .starting, .running:
      return true
    case .done, .stopped, .failed:
      return false
    }
  }

  private var displayedMessages: [ChatMessage] {
    if !pill.conversationMessages.isEmpty {
      return normalizedAgentMessages(pill.conversationMessages)
    }
    var fallback = [ChatMessage(id: "\(pill.id.uuidString)-query", text: pill.query, sender: .user)]
    if let message = pill.aiMessage {
      let text = message.text.trimmingCharacters(in: .whitespacesAndNewlines)
      if !text.isEmpty || !message.contentBlocks.isEmpty {
        fallback.append(message)
      }
    }
    return normalizedAgentMessages(fallback)
  }

  private var hasAssistantTurn: Bool {
    displayedMessages.contains { $0.sender == .ai }
  }

  private var hasFinalAssistantOutput: Bool {
    displayedMessages.contains { message in
      message.sender == .ai
        && !message.isStreaming
        && hasVisibleAssistantContent(message)
    }
  }

  private var activityText: String {
    pill.latestActivity.trimmingCharacters(in: .whitespacesAndNewlines)
  }

  private var scrollContentToken: AnyHashable {
    AnyHashable(
      [
        String(pill.contentRevision),
        pill.latestActivity,
        displayedMessages.map { message in
          [
            message.id,
            message.text,
            String(message.contentBlocks.count),
            String(message.displayResources.count),
            String(message.isStreaming),
          ].joined(separator: "\u{1F}")
        }.joined(separator: "\u{1E}"),
      ].joined(separator: "\u{1D}")
    )
  }

  var body: some View {
    VStack(alignment: .leading, spacing: OmiSpacing.md) {
      header

      ChatScrollContainer(
        bottomAnchorId: "agentBottom",
        contentChangeToken: scrollContentToken,
        scrollPaddingTrailing: 30,
        onContentHeightChange: { height in
          state.reportContentHeight(height, for: .agent(pill.id))
        }
      ) {
        conversationContent
          .id(pill.contentRevision)
      }
      .frame(maxWidth: .infinity, maxHeight: .infinity)

      followUpInput
    }
    .padding()
    .frame(maxWidth: .infinity, maxHeight: .infinity)
    .onAppear {
      manager.markViewed(pillID: pill.id)
    }
    .onExitCommand {
      onEscape()
    }
  }

  private var header: some View {
    HStack(spacing: OmiSpacing.sm) {
      Button(action: onBackToAgentRows) {
        Image(systemName: "chevron.left")
          .scaledFont(size: OmiType.body, weight: .semibold)
          .foregroundColor(.white.opacity(0.82))
          .frame(width: 36, height: 36)
          .contentShape(Rectangle())
      }
      .buttonStyle(.plain)
      .help("Back to chats")

      Text(pill.title)
        .scaledFont(size: OmiType.body, weight: .bold)
        .foregroundColor(.white)
        .lineLimit(1)

      Spacer(minLength: 8)

      statusBadge
    }
  }

  private var statusBadge: some View {
    HStack(spacing: OmiSpacing.xs) {
      Group {
        if displayStatus.isFinished {
          Button {
            manager.dismiss(pillID: pill.id)
            onBackToAgentRows()
          } label: {
            statusBadgeLabel
          }
          .buttonStyle(.plain)
          .help("Dismiss agent")
        } else {
          statusBadgeLabel
        }
      }

      if isRunning {
        stopButton
      }
    }
  }

  private var stopButton: some View {
    Button {
      manager.stop(pillID: pill.id)
    } label: {
      Image(systemName: "stop.fill")
        .scaledFont(size: 8, weight: .bold)
        .foregroundColor(.black.opacity(0.82))
        .frame(width: 22, height: 22)
        .background(pill.status.tintColor)
        .clipShape(Circle())
    }
    .buttonStyle(.plain)
    .accessibilityLabel("Stop subagent")
    .help("Stop subagent")
  }

  private var statusBadgeLabel: some View {
    Text(displayStatus.displayLabel)
      .scaledFont(size: 9, weight: .bold)
      .foregroundColor(statusForeground)
      .padding(.horizontal, OmiSpacing.sm)
      .padding(.vertical, OmiSpacing.xxs)
      .background(displayStatus.tintColor.opacity(statusBackgroundOpacity))
      .clipShape(Capsule())
  }

  private var displayStatus: AgentPill.Status {
    if hasFinalAssistantOutput, !pill.status.isFinished {
      return .done
    }
    return pill.status
  }

  private var statusForeground: Color {
    switch displayStatus {
    case .queued, .starting, .running, .done:
      return .black.opacity(0.86)
    case .stopped:
      return .black.opacity(0.78)
    case .failed:
      return .white
    }
  }

  private var statusBackgroundOpacity: Double {
    switch displayStatus {
    case .queued, .starting, .running, .done, .stopped:
      return 1
    case .failed:
      return 0.75
    }
  }

  @ViewBuilder
  private var conversationContent: some View {
    VStack(alignment: .leading, spacing: 14) {
      ForEach(displayedMessages) { message in
        agentMessageBubble(message)
      }

      if isRunning && !hasAssistantTurn {
        runningActivityView
      }
    }
  }

  private func normalizedAgentMessages(_ messages: [ChatMessage]) -> [ChatMessage] {
    let hasFinalOutput = messages.contains { message in
      message.sender == .ai
        && !message.isStreaming
        && hasVisibleAssistantContent(message)
    }
    guard hasFinalOutput else { return messages }
    return messages.filter { message in
      !(message.sender == .ai
        && message.isStreaming
        && !hasVisibleAssistantContent(message))
    }
  }

  private func hasVisibleAssistantContent(_ message: ChatMessage) -> Bool {
    !message.text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
      || !message.contentBlocks.isEmpty
      || !message.displayResources.isEmpty
  }

  private var runningActivityView: some View {
    VStack(alignment: .leading, spacing: OmiSpacing.sm) {
      TypingIndicator()
        .frame(maxWidth: .infinity, minHeight: 24, alignment: .leading)
      if !activityText.isEmpty {
        Text(activityText)
          .scaledFont(size: 12, weight: .semibold)
          .foregroundColor(.white.opacity(0.62))
          .textSelection(.enabled)
      }
    }
  }

  @ViewBuilder
  private func agentMessageBubble(_ message: ChatMessage) -> some View {
    let trimmed = message.text.trimmingCharacters(in: .whitespacesAndNewlines)
    if message.sender == .user {
      VStack(alignment: .leading, spacing: OmiSpacing.sm) {
        if !trimmed.isEmpty {
          Text(trimmed)
            .scaledFont(size: OmiType.body, weight: .semibold)
            .foregroundColor(.white)
            .textSelection(.enabled)
            .lineLimit(nil)
            .frame(maxWidth: .infinity, alignment: .leading)
        }
        agentResourceStrip(message)
      }
      .padding(.horizontal, OmiSpacing.md)
      .padding(.vertical, 9)
      .background(Color.white.opacity(0.10))
      .clipShape(RoundedRectangle(cornerRadius: 9, style: .continuous))
      .contextMenu {
        Button("Copy") {
          NSPasteboard.general.clearContents()
          NSPasteboard.general.setString(message.copyableText, forType: .string)
        }
      }
    } else if trimmed.isEmpty && message.isStreaming && message.displayResources.isEmpty {
      VStack(alignment: .leading, spacing: OmiSpacing.sm) {
        TypingIndicator()
          .frame(maxWidth: .infinity, minHeight: 24, alignment: .leading)
        if !activityText.isEmpty {
          Text(activityText)
            .scaledFont(size: 12, weight: .semibold)
            .foregroundColor(.white.opacity(0.62))
            .textSelection(.enabled)
        }
      }
    } else {
      VStack(alignment: .leading, spacing: OmiSpacing.sm) {
        agentAssistantContent(message)
        agentResourceStrip(message)
      }
      .padding(.horizontal, OmiSpacing.xxs)
      .contextMenu {
        Button("Copy") {
          NSPasteboard.general.clearContents()
          NSPasteboard.general.setString(message.copyableText, forType: .string)
        }
      }
    }
  }

  @ViewBuilder
  private func agentResourceStrip(_ message: ChatMessage) -> some View {
    if !message.displayResources.isEmpty {
      ChatResourceStrip(
        resources: message.displayResources,
        density: .compact,
        alignment: .leading
      )
      .environment(\.colorScheme, .dark)
      .frame(maxWidth: .infinity, alignment: .leading)
    }
  }

  @ViewBuilder
  private func agentAssistantContent(_ message: ChatMessage) -> some View {
    if !message.contentBlocks.isEmpty {
      VStack(alignment: .leading, spacing: OmiSpacing.sm) {
        ForEach(groupedContentBlocks(for: message)) { group in
          switch group {
          case .text(_, let text):
            if !text.isEmpty {
              OmiMarkdown(text: text, sender: .ai, citations: message.inlineCitationReferences)
                .environment(\.colorScheme, .dark)
                .frame(maxWidth: .infinity, alignment: .leading)
            }
          case .commentary(_, let text):
            TurnCommentaryRow(text: text)
              .environment(\.colorScheme, .dark)
              .frame(maxWidth: .infinity, alignment: .leading)
          case .toolCalls(_, let calls):
            ToolCallsGroup(calls: calls, compact: true)
              .frame(maxWidth: .infinity, alignment: .leading)
          case .thinking(_, let text):
            ThinkingBlock(text: text)
              .frame(maxWidth: .infinity, alignment: .leading)
          case .discoveryCard(_, let title, let summary, let fullText):
            DiscoveryCard(title: title, summary: summary, fullText: fullText)
              .frame(maxWidth: .infinity, alignment: .leading)
          // The notch projects the same journal as the main window, so it
          // renders the same interactable cards. Taps route the one shell and
          // summon the main window (`ChatFirstRichBlockContext.auxiliary`).
          case .questionCard, .taskCard, .goalLink, .captureLink, .conversationLink, .memoryLink:
            if let context = ChatFirstRichBlockContext.floatingSurface {
              ChatFirstRichBlockGroupView(
                group: group,
                messageID: message.id,
                context: context
              )
              .environment(\.colorScheme, .light)
              .frame(maxWidth: .infinity, alignment: .leading)
            }
          // The follow-up chip belongs to the answer surface, not this agent-pill
          // transcript, which has no lane to send the next turn on, and the review
          // card is a rich editor this passive surface does not own.
          case .followUp, .memoryReviewCard:
            EmptyView()
          case .agentSpawn(
            _, let pillId, let sessionId, let runId, let title, let objective, let provider
          ):
            AgentSpawnCard(
              title: title,
              objective: objective,
              provider: provider,
              ref: AgentTimelineRef(pillId: pillId, sessionId: sessionId, runId: runId),
              onOpen: nil
            )
            .frame(maxWidth: .infinity, alignment: .leading)
          case .agentCompletion(
            _, let pillId, let sessionId, let runId, let title, let promptSnippet, let output,
            let status
          ):
            AgentCompletionCard(
              title: title,
              promptSnippet: promptSnippet,
              output: output,
              status: status,
              ref: AgentTimelineRef(pillId: pillId, sessionId: sessionId, runId: runId),
              onOpen: nil
            )
            .frame(maxWidth: .infinity, alignment: .leading)
          }
        }
      }
    } else {
      let trimmed = message.text.trimmingCharacters(in: .whitespacesAndNewlines)
      if !trimmed.isEmpty {
        OmiMarkdown(text: trimmed, sender: .ai, citations: message.inlineCitationReferences)
          .environment(\.fontScale, 0.88)
          .fixedSize(horizontal: false, vertical: true)
          .frame(maxWidth: .infinity, alignment: .leading)
      }
    }
  }

  private func groupedContentBlocks(for message: ChatMessage) -> [ContentBlockGroup] {
    ContentBlockGroup.visibleChatGroups(
      message.contentBlocks,
      isStreaming: message.isStreaming
    )
  }

  private var followUpInput: some View {
    HStack(spacing: OmiSpacing.xs) {
      Button {
        onEscape()
        AppDelegate.summonWindowTarget()?.openMainAppChat()
      } label: {
        HStack(spacing: OmiSpacing.xs) {
          Text("Continue in Omi")
            .scaledFont(size: OmiType.body, weight: .medium)
            .foregroundColor(.white.opacity(0.85))
          Spacer(minLength: 0)
          Image(systemName: "arrow.up.forward.app")
            .scaledFont(size: OmiType.body)
            .foregroundColor(.secondary)
        }
        .padding(.horizontal, 10)
        .padding(.vertical, 7)
        .background(Color.white.opacity(0.10))
        .clipShape(RoundedRectangle(cornerRadius: OmiChrome.elementRadius, style: .continuous))
        .contentShape(Rectangle())
      }
      .buttonStyle(.plain)
      .help("Open the Omi app to steer this agent")
    }
  }
}

/// Re-renders when any individual pill's @Published status changes — the
/// manager only publishes on pill add/remove, so per-pill observers are needed
/// for live status color updates (same pattern as NotchAgentPillsRowView).
private struct PillStatusObservingView<Content: View>: View {
  @ObservedObject var manager: AgentPillsManager
  @ViewBuilder let content: ([AgentPill]) -> Content
  @State private var pillStatusCancellables: [UUID: AnyCancellable] = [:]
  @State private var pillStatusChangeToken = 0

  var body: some View {
    let _ = pillStatusChangeToken
    content(NotchAgentStackMetrics.sortedPills(manager.pills))
      .onAppear { syncPillStatusObservers() }
      .onChange(of: manager.pills.map(\.id)) { _, _ in
        syncPillStatusObservers()
      }
  }

  private func syncPillStatusObservers() {
    let currentIDs = Set(manager.pills.map(\.id))
    pillStatusCancellables = pillStatusCancellables.filter { currentIDs.contains($0.key) }
    for pill in manager.pills where pillStatusCancellables[pill.id] == nil {
      pillStatusCancellables[pill.id] = pill.objectWillChange
        .receive(on: DispatchQueue.main)
        .sink { _ in
          pillStatusChangeToken &+= 1
        }
    }
  }
}

/// Aggregate agent-status glow on the collapsed pill — the pill itself glows
/// in the highest-priority status color (failed > running > queued > done >
/// stopped), breathing while agents are active, mirroring the PTT voice glow.
private struct AgentStatusGlow: ViewModifier {
  let group: NotchAgentStatusGroup?
  @State private var breathing = false

  private var isAnimated: Bool { group == .running || group == .queued }
  private var glowColor: Color { group?.color ?? .clear }

  func body(content: Content) -> some View {
    let pulse = isAnimated && breathing
    content
      .shadow(
        color: group == nil ? .clear : glowColor.opacity(pulse ? 0.95 : 0.6),
        radius: group == nil ? 0 : (pulse ? 15 : 9)
      )
      .shadow(
        color: group == nil ? .clear : glowColor.opacity(pulse ? 0.5 : 0.3),
        radius: group == nil ? 0 : (pulse ? 26 : 16)
      )
      .omiAnimation(
        isAnimated
          ? .easeInOut(duration: 1.15).repeatForever(autoreverses: true)
          : .easeInOut(duration: 0.25),
        value: breathing
      )
      .onAppear { breathing = true }
      .onChange(of: isAnimated) { _, _ in
        // Restart the repeat-forever animation when the aggregate
        // state flips between animated and static groups.
        breathing = false
        DispatchQueue.main.async { breathing = true }
      }
      .accessibilityLabel(group.map { "Subagents: \($0.title)" } ?? "")
  }
}

private struct NotchAgentPillsRowView: View {
  @ObservedObject var manager: AgentPillsManager
  weak var barWindow: NSWindow?
  let isVoiceListening: Bool
  let isThinking: Bool
  let isSpeaking: Bool
  let isDictating: Bool
  let isLocked: Bool
  @State private var pillStatusCancellables: [UUID: AnyCancellable] = [:]
  @State private var pillStatusChangeToken = 0

  private var stackedPills: [AgentPill] {
    NotchAgentStackMetrics.sortedPills(manager.pills)
  }

  var body: some View {
    let _ = pillStatusChangeToken
    NotchVoiceMorphMark(
      dotColors: stackedPills.prefix(NotchAgentStackMetrics.maxAgents).map {
        NotchAgentStatusGroup(status: $0.status).color
      },
      isListening: isVoiceListening,
      isThinking: isThinking,
      isSpeaking: isSpeaking,
      isLocked: isLocked,
      isDictating: isDictating
    )
    // Keep every PTT dot inside the same 21pt identity slot as the resting
    // Omi mark. The slot is frontmost and trails the visible left lobe, so the
    // physical notch/header surface cannot cover or crop the waveform.
    .frame(
      width: NotchVoiceMorphGeometry.markSize.width,
      height: NotchVoiceMorphGeometry.markSize.height
    )
    .zIndex(1)
    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .trailing)
    .accessibilityIdentifier("notch_voice_morph_mark")
    .accessibilityLabel(
      isVoiceListening
        ? NotchVoiceControlPresentation.stateLabel(isLocked: isLocked)
        : "Subagent status"
    )
    .accessibilityHint(
      isVoiceListening
        ? ""
        : "Hover to fan out subagents, click to keep them open"
    )
    .onAppear { syncPillStatusObservers() }
    .onChange(of: manager.pills.map(\.id)) { _, _ in
      syncPillStatusObservers()
    }
  }

  private func syncPillStatusObservers() {
    let currentIDs = Set(manager.pills.map(\.id))
    pillStatusCancellables = pillStatusCancellables.filter { currentIDs.contains($0.key) }
    for pill in manager.pills where pillStatusCancellables[pill.id] == nil {
      pillStatusCancellables[pill.id] = pill.objectWillChange
        .receive(on: DispatchQueue.main)
        .sink { _ in
          pillStatusChangeToken &+= 1
        }
    }
  }
}

@MainActor
private enum NotchAgentStackMetrics {
  static let maxAgents = FloatingControlBarWindow.notchAgentListMaxVisibleAgents
  static let listOrbSize: CGFloat = 11
  static let listHorizontalInset: CGFloat = 12
  static let listRowLeadingPadding: CGFloat = 12
  static let listOrbSlotWidth: CGFloat = 24
  static let logoFrameSize: CGFloat = 21
  static let logoTrailingInset: CGFloat = 2
  static let logoDotDiameterRatio: CGFloat = 0.18
  static let logoRingRadiusRatio: CGFloat = 0.33

  static func sortedPills(_ pills: [AgentPill]) -> [AgentPill] {
    let newestIndex = Dictionary(
      lastWriteWins: pills.enumerated().map {
        ($0.element.id, pills.count - 1 - $0.offset)
      })
    return pills.sorted { lhs, rhs in
      let lhsGroup = NotchAgentStatusGroup(status: lhs.status)
      let rhsGroup = NotchAgentStatusGroup(status: rhs.status)
      if lhsGroup.sortRank != rhsGroup.sortRank {
        return lhsGroup.sortRank < rhsGroup.sortRank
      }
      return (newestIndex[lhs.id] ?? 0) < (newestIndex[rhs.id] ?? 0)
    }
  }

  static func logoCenterX(
    rowWidth: CGFloat,
    notchHiddenCenterWidth: CGFloat,
    notchSideWidth: CGFloat
  ) -> CGFloat {
    let chromeWidth = notchHiddenCenterWidth + notchSideWidth * 2
    let chromeMinX = (rowWidth - chromeWidth) / 2
    return chromeMinX + notchSideWidth - logoTrailingInset - logoFrameSize / 2
  }

  static func logoDotSourceOffset(for index: Int) -> CGSize {
    let angle = Double(index) / Double(maxAgents) * Double.pi * 2 - Double.pi
    let ringRadius = logoFrameSize * logoRingRadiusRatio
    return CGSize(
      width: CGFloat(cos(angle)) * ringRadius,
      height: CGFloat(sin(angle)) * ringRadius
    )
  }

  static func smoothStep(_ value: CGFloat) -> CGFloat {
    let t = min(1, max(0, value))
    return t * t * (3 - 2 * t)
  }

  static func quadraticBezier(from start: CGPoint, control: CGPoint, to end: CGPoint, progress: CGFloat) -> CGPoint {
    let t = smoothStep(progress)
    let inverse = 1 - t
    return CGPoint(
      x: inverse * inverse * start.x + 2 * inverse * t * control.x + t * t * end.x,
      y: inverse * inverse * start.y + 2 * inverse * t * control.y + t * t * end.y
    )
  }

  /// The expanded-row identity mark uses the full orb size. The fixed header
  /// owns the compact Omi ring independently.
  static let logoDotScale: CGFloat = (logoFrameSize * logoDotDiameterRatio) / listOrbSize
}

/// The expanded agent rows live below the fixed notch header. Their status marks
/// fade into their row slots, while the Omi logo remains anchored in the compact
/// header above.
private struct NotchAgentMorphField: View {
  @ObservedObject var manager: AgentPillsManager
  let activePillID: UUID?
  let progress: CGFloat
  let notchHiddenCenterWidth: CGFloat
  let notchSideWidth: CGFloat
  let notchChromeHeight: CGFloat
  let rowTopOffset: CGFloat
  let onSelect: (AgentPill) -> Void
  @State private var pillStatusCancellables: [UUID: AnyCancellable] = [:]
  @State private var pillStatusChangeToken = 0

  private var sortedPills: [AgentPill] {
    let _ = pillStatusChangeToken
    return Array(NotchAgentStackMetrics.sortedPills(manager.pills).prefix(NotchAgentStackMetrics.maxAgents))
  }

  var body: some View {
    GeometryReader { geometry in
      let width = geometry.size.width
      let chromeHeight = notchChromeHeight
      let rowHeight = FloatingControlBarWindow.notchAgentListRowHeight
      let rowSpacing = FloatingControlBarWindow.notchAgentListRowSpacing
      let verticalPadding = FloatingControlBarWindow.notchAgentListVerticalPadding
      let rowWidth = max(
        0,
        min(
          width - NotchAgentStackMetrics.listHorizontalInset * 2,
          FloatingControlBarWindow.notchExpandedWidth - NotchAgentStackMetrics.listHorizontalInset * 2))
      let rowMinX = (width - rowWidth) / 2
      let rowRevealProgress = NotchAgentStackMetrics.smoothStep((progress - 0.38) / 0.62)
      let pills = sortedPills

      ZStack {
        ForEach(Array(pills.enumerated()), id: \.offset) { index, pill in
          let rowMinY = chromeHeight + rowTopOffset + verticalPadding + CGFloat(index) * (rowHeight + rowSpacing)
          let rowCenter = CGPoint(x: width / 2, y: rowMinY + rowHeight / 2)
          let orbCenter = CGPoint(
            x: rowMinX + NotchAgentStackMetrics.listRowLeadingPadding + NotchAgentStackMetrics.listOrbSize / 2,
            y: rowCenter.y
          )
          let group = NotchAgentStatusGroup(status: pill.status)

          Button {
            onSelect(pill)
          } label: {
            NotchAgentListRow(
              title: pill.title,
              status: pill.status,
              activity: ChatContinuityInvariants.agentPreviewText(
                prompt: pill.query,
                output: pill.latestActivity
              ),
              isSelected: pill.id == activePillID,
              progress: rowRevealProgress
            )
            .frame(width: rowWidth, height: rowHeight)
          }
          .buttonStyle(.plain)
          .frame(width: rowWidth, height: rowHeight)
          .opacity(rowRevealProgress)
          .allowsHitTesting(progress > 0.6)
          .position(rowCenter)
          .help(pill.title)

          notchAgentIdentityMark(
            provider: pill.providerIdentity,
            color: group.color,
            isActive: pill.id == activePillID,
            progress: 1
          )
          .opacity(rowRevealProgress)
          .position(orbCenter)
          .allowsHitTesting(false)
        }
      }
      .frame(width: width, height: geometry.size.height, alignment: .top)
    }
    .onAppear { syncPillStatusObservers() }
    .onChange(of: manager.pills.map(\.id)) { _, _ in syncPillStatusObservers() }
  }

  private func syncPillStatusObservers() {
    let currentIDs = Set(manager.pills.map(\.id))
    pillStatusCancellables = pillStatusCancellables.filter { currentIDs.contains($0.key) }
    for pill in manager.pills where pillStatusCancellables[pill.id] == nil {
      pillStatusCancellables[pill.id] = pill.objectWillChange
        .receive(on: DispatchQueue.main)
        .sink { _ in
          pillStatusChangeToken &+= 1
        }
    }
  }

  @ViewBuilder
  private func notchAgentIdentityMark(
    provider: AgentHarnessMode?,
    color: Color,
    isActive: Bool,
    progress: CGFloat
  ) -> some View {
    if provider.rendersProviderMark {
      let scale = NotchAgentStackMetrics.logoDotScale + (1 - NotchAgentStackMetrics.logoDotScale) * progress
      AgentProviderLogoMark(provider: provider, statusColor: color, size: NotchAgentStackMetrics.listOrbSize + 5)
        .shadow(color: color.opacity(0.55), radius: isActive ? 9 : 5)
        .scaleEffect(scale)
        .frame(width: 18, height: 22)
    } else {
      NotchMorphDot(
        color: color,
        isActive: isActive,
        progress: progress
      )
    }
  }
}

/// A single dot that looks like a logo-ring dot at progress 0 (small, no stroke)
/// and a fanned status orb at progress 1 (full size, ringed).
private struct NotchMorphDot: View {
  let color: Color
  let isActive: Bool
  let progress: CGFloat

  var body: some View {
    let scale = NotchAgentStackMetrics.logoDotScale + (1 - NotchAgentStackMetrics.logoDotScale) * progress
    Circle()
      .fill(color)
      .frame(width: NotchAgentStackMetrics.listOrbSize, height: NotchAgentStackMetrics.listOrbSize)
      .overlay(
        Circle()
          .strokeBorder(Color.white.opacity(0.42 * Double(progress)), lineWidth: 0.8)
      )
      .shadow(color: color.opacity(0.6), radius: isActive ? 9 : 5)
      .scaleEffect(scale)
      .frame(width: 18, height: 22)
      .contentShape(Circle())
  }
}

private struct NotchLogoPlaceholderDot: View {
  let progress: CGFloat

  var body: some View {
    Circle()
      .fill(Color.white.opacity(0.96 * Double(1 - progress)))
      .frame(width: NotchAgentStackMetrics.listOrbSize, height: NotchAgentStackMetrics.listOrbSize)
      .scaleEffect(NotchAgentStackMetrics.logoDotScale)
      .frame(width: 18, height: 22)
  }
}

private struct NotchAgentListRow: View {
  let title: String
  let status: AgentPill.Status
  let activity: String
  let isSelected: Bool
  let progress: CGFloat

  var body: some View {
    HStack(spacing: OmiSpacing.sm) {
      // The identity mark (Omi dot or provider logo) is rendered by the
      // traveling `notchAgentIdentityMark` that morphs from the collapsed
      // logo ring and lands on this slot. The row only reserves the space —
      // drawing a logo here too would double it up under the morph mark.
      Color.clear
        .frame(width: NotchAgentStackMetrics.listOrbSlotWidth, height: 18)

      VStack(alignment: .leading, spacing: 1) {
        Text(title)
          .scaledFont(size: 12, weight: .semibold)
          .foregroundStyle(.white.opacity(0.94))
          .lineLimit(1)
          .truncationMode(.tail)

        HStack(spacing: OmiSpacing.xxs) {
          Image(systemName: activityIcon)
            .font(.system(size: 8, weight: .bold))
            .foregroundStyle(statusColor.opacity(0.95))
            .frame(width: 9, height: 9)

          Text(progressSummary)
            .scaledFont(size: 9, weight: .medium)
            .foregroundStyle(.white.opacity(0.52))
            .lineLimit(1)
            .truncationMode(.tail)
        }
      }
      .opacity(progress)

      Spacer(minLength: 0)
    }
    .padding(.leading, NotchAgentStackMetrics.listRowLeadingPadding)
    .padding(.trailing, 10)
    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .leading)
    .background(
      RoundedRectangle(cornerRadius: OmiChrome.elementRadius, style: .continuous)
        .fill(isSelected ? Color.white.opacity(0.12 * Double(progress)) : .clear)
    )
    .overlay(alignment: .bottom) {
      Rectangle()
        .fill(Color.white.opacity(0.11 * Double(progress)))
        .frame(height: 0.6)
    }
    .contentShape(Rectangle())
  }

  private var progressSummary: String {
    let trimmed = activity.trimmingCharacters(in: .whitespacesAndNewlines)
    if trimmed.isEmpty || trimmed == status.displayLabel {
      return status.displayLabel
    }
    if trimmed.lowercased().hasPrefix(status.displayLabel.lowercased()) {
      return trimmed
    }
    return "\(status.displayLabel) — \(trimmed)"
  }

  private var statusColor: Color {
    status.tintColor
  }

  private var activityIcon: String {
    switch status {
    case .queued:
      return "clock"
    case .starting, .running:
      return "sparkles"
    case .done:
      return "checkmark"
    case .stopped:
      return "stop.fill"
    case .failed:
      return "exclamationmark"
    }
  }
}

private enum NotchAgentStatusGroup: String, Identifiable {
  case running
  case queued
  case failed
  case stopped
  case done

  var id: String { rawValue }

  init(status: AgentPill.Status) {
    switch status {
    case .starting, .running:
      self = .running
    case .queued:
      self = .queued
    case .failed:
      self = .failed
    case .stopped:
      self = .stopped
    case .done:
      self = .done
    }
  }

  var title: String {
    switch self {
    case .running: return "Running"
    case .queued: return "Queued"
    case .failed: return "Failed"
    case .stopped: return "Stopped"
    case .done: return "Done"
    }
  }

  var color: Color {
    switch self {
    case .running: return Color(red: 1.0, green: 0.80, blue: 0.40)
    case .queued: return Color(red: 0.20, green: 0.86, blue: 1.0)
    case .failed: return Color(red: 1.0, green: 0.42, blue: 0.42)
    case .stopped: return Color(red: 0.64, green: 0.66, blue: 0.70)
    case .done: return Color(red: 0.27, green: 0.92, blue: 0.46)
    }
  }

  var highlightColor: Color {
    switch self {
    case .running: return Color(red: 1.0, green: 0.62, blue: 0.20)
    case .queued: return Color(red: 0.08, green: 0.52, blue: 1.0)
    case .failed: return Color(red: 1.0, green: 0.46, blue: 0.12)
    case .stopped: return Color(red: 0.42, green: 0.44, blue: 0.48)
    case .done: return Color(red: 0.08, green: 0.78, blue: 0.62)
    }
  }

  var shadowColor: Color {
    switch self {
    case .running: return Color(red: 0.72, green: 0.36, blue: 0.04)
    case .queued: return Color(red: 0.00, green: 0.44, blue: 0.95)
    case .failed: return Color(red: 0.78, green: 0.08, blue: 0.18)
    case .stopped: return Color(red: 0.24, green: 0.25, blue: 0.28)
    case .done: return Color(red: 0.02, green: 0.50, blue: 0.24)
    }
  }

  var sortRank: Int {
    switch self {
    case .running: return 0
    case .queued: return 1
    case .failed: return 2
    case .stopped: return 3
    case .done: return 4
    }
  }

  /// Highest-priority aggregate across all pills, for the collapsed-pill
  /// tint/glow: failure needs the user, activity is ambient. Finished
  /// agents the user has already viewed go quiet — done work should stop
  /// tugging at the eye.
  @MainActor
  static func aggregate(for pills: [AgentPill]) -> NotchAgentStatusGroup? {
    let groups =
      pills
      .filter { !($0.status.isFinished && $0.viewedAt != nil) }
      .map { NotchAgentStatusGroup(status: $0.status) }
    for candidate: NotchAgentStatusGroup in [.failed, .running, .queued, .done, .stopped]
    where groups.contains(candidate) {
      return candidate
    }
    return groups.first
  }

}

private struct NotchAgentStatusOrb: View {
  let group: NotchAgentStatusGroup
  let isActive: Bool
  var size: CGFloat = 16

  var body: some View {
    Circle()
      .fill(group.color)
      .overlay(
        Circle()
          .stroke(Color.white.opacity(isActive ? 0.34 : 0.20), lineWidth: 1)
      )
      .frame(width: size, height: size)
      .frame(width: size + 6, height: size + 6)
  }
}

/// Post-meeting summary share card. Persistent by contract: it is presented
/// with `isPersistent: true`, so the only exits are the user's — Copy link,
/// Send to <participant>, See summary, or the close button. Chrome matches the
/// other proactive cards (suggestion/insight): icon tile + eyebrow + title,
/// with the dismiss circle top-trailing.
private struct MeetingSummaryShareCard: View {
  let notification: FloatingBarNotification
  let conversationID: String
  let recipients: [ConversationShareRecipient]

  private enum Phase: Equatable {
    case idle
    case copying
    case sending
    case done(String)
    case failed(String)
  }

  @State private var phase: Phase = .idle
  @State private var isAddressing = false
  @State private var recipientEmail: String = ""
  @FocusState private var recipientFieldFocused: Bool

  /// Shape-only: the address is the owner's to choose, so this rejects an
  /// obvious typo without pretending to know the mailbox exists.
  private var typedEmailIsSendable: Bool {
    let value = recipientEmail.trimmingCharacters(in: .whitespaces)
    guard !value.contains(" "), let at = value.firstIndex(of: "@"), at != value.startIndex else { return false }
    let domain = value[value.index(after: at)...]
    return !domain.isEmpty && domain.contains(".") && !domain.hasSuffix(".") && !domain.contains("@")
  }

  private var isBusy: Bool { phase == .copying || phase == .sending }

  var body: some View {
    HStack(alignment: .top, spacing: OmiSpacing.md) {
      ZStack {
        RoundedRectangle(cornerRadius: 13, style: .continuous)
          .fill(
            LinearGradient(
              colors: [Color.white.opacity(0.18), Color.white.opacity(0.08)],
              startPoint: .top,
              endPoint: .bottom
            )
          )
          .overlay(
            RoundedRectangle(cornerRadius: 13, style: .continuous)
              .strokeBorder(Color.white.opacity(0.12), lineWidth: 1)
          )
          .frame(width: 44, height: 44)

        Image(systemName: "text.document")
          .font(.system(size: 17, weight: .semibold))
          .foregroundColor(.white)
      }

      VStack(alignment: .leading, spacing: 3) {
        Text(notification.title)
          .scaledFont(size: OmiType.caption, weight: .semibold)
          .foregroundColor(.white.opacity(0.5))
          .lineLimit(1)

        if !notification.message.isEmpty {
          Text(notification.message)
            .scaledFont(size: OmiType.subheading, weight: .medium)
            .foregroundColor(.white)
            .lineLimit(2)
            .multilineTextAlignment(.leading)
            .fixedSize(horizontal: false, vertical: true)
        }

        switch phase {
        case .done(let confirmation):
          Label(confirmation, systemImage: "checkmark")
            .scaledFont(size: 12, weight: .medium)
            .foregroundColor(.white.opacity(0.85))
            .padding(.top, 5)
        case .failed(let message):
          Text(message)
            .scaledFont(size: 11)
            .foregroundColor(.white.opacity(0.7))
            .padding(.top, 2)
          actionRow
        default:
          actionRow
        }
      }

      Spacer(minLength: OmiSpacing.xs)

      // Reserve room so copy never runs under the overlaid dismiss button.
      Color.clear
        .frame(width: 28, height: 20)
    }
    .padding(.horizontal, OmiSpacing.lg)
    .padding(.vertical, OmiSpacing.md + 2)
    .frame(maxWidth: .infinity, alignment: .leading)
    .overlay(alignment: .topTrailing) {
      Button {
        FloatingControlBarManager.shared.dismissCurrentNotification()
      } label: {
        Image(systemName: "xmark")
          .font(.system(size: 10, weight: .bold))
          .foregroundColor(.white.opacity(0.62))
          .frame(width: 18, height: 18)
          .background(Color.white.opacity(0.08))
          .clipShape(Circle())
      }
      .buttonStyle(.plain)
      .padding(.horizontal, OmiSpacing.md)
      .padding(.vertical, OmiSpacing.md)
      .accessibilityLabel("Dismiss meeting summary notification")
    }
    .onReceive(NotificationCenter.default.publisher(for: .meetingSummaryShareBeginAddressing)) { _ in
      beginAddressing()
    }
    .onReceive(NotificationCenter.default.publisher(for: .meetingSummaryShareSubmit)) { note in
      if let address = note.object as? String, !address.isEmpty {
        recipientEmail = address
      }
      isAddressing = true
      sendSummary()
    }
  }

  private var actionRow: some View {
    Group {
      if isAddressing {
        addressRow
      } else {
        HStack(spacing: 9) {
          Button {
            beginAddressing()
          } label: {
            HStack(spacing: 4) {
              Image(systemName: "lock.fill")
                .font(.system(size: 9, weight: .semibold))
              Text("Share")
            }
            .scaledFont(size: 12, weight: .semibold)
            .foregroundColor(.black)
            .padding(.horizontal, 11).padding(.vertical, 4)
            .background(Color.white)
            .clipShape(RoundedRectangle(cornerRadius: 7, style: .continuous))
          }
          .buttonStyle(.plain)
          .disabled(isBusy)
          .help("Email these notes to someone")
          .accessibilityIdentifier("meeting-summary-share-send")

          Button {
            copyLink()
          } label: {
            Group {
              if phase == .copying {
                ProgressView().controlSize(.mini)
              } else {
                Image(systemName: "link")
                  .font(.system(size: 11, weight: .semibold))
              }
            }
            .foregroundColor(.white)
            .frame(width: 26, height: 21)
            .background(Color.white.opacity(0.18))
            .clipShape(RoundedRectangle(cornerRadius: 7, style: .continuous))
          }
          .buttonStyle(.plain)
          .disabled(isBusy)
          .help("Copy the share link")
          .accessibilityIdentifier("meeting-summary-share-copy")

          // Text-style link, deliberately chrome-free beside the two controls.
          Button {
            FloatingControlBarManager.shared.dismissCurrentNotification()
            MeetingSummaryShareActions.openSummary(conversationID: conversationID)
          } label: {
            Text("See summary")
              .scaledFont(size: 12, weight: .medium)
              .foregroundColor(.white.opacity(0.55))
              .underline()
          }
          .buttonStyle(.plain)
          .disabled(isBusy)
          .accessibilityIdentifier("meeting-summary-share-open")
        }
      }
    }
    .padding(.top, 6)
  }

  /// The Share affordance in its open state: one address field and one send.
  private var addressRow: some View {
    HStack(spacing: 7) {
      TextField("name@company.com", text: $recipientEmail)
        .textFieldStyle(.plain)
        .scaledFont(size: 12, weight: .medium)
        .foregroundColor(.white)
        .focused($recipientFieldFocused)
        .onSubmit { sendSummary() }
        .padding(.horizontal, 9).padding(.vertical, 4)
        .background(Color.white.opacity(0.12))
        .clipShape(RoundedRectangle(cornerRadius: 7, style: .continuous))
        .frame(maxWidth: 210)
        .accessibilityIdentifier("meeting-summary-share-email-field")

      Button {
        sendSummary()
      } label: {
        HStack(spacing: 4) {
          if phase == .sending {
            ProgressView().controlSize(.mini)
          }
          Text("Send")
        }
        .scaledFont(size: 12, weight: .semibold)
        .foregroundColor(.black)
        .padding(.horizontal, 11).padding(.vertical, 4)
        .background(Color.white.opacity(typedEmailIsSendable ? 1 : 0.35))
        .clipShape(RoundedRectangle(cornerRadius: 7, style: .continuous))
      }
      .buttonStyle(.plain)
      .disabled(isBusy || !typedEmailIsSendable)
      .accessibilityIdentifier("meeting-summary-share-email-send")

      Button {
        isAddressing = false
        recipientFieldFocused = false
      } label: {
        Text("Cancel")
          .scaledFont(size: 12, weight: .medium)
          .foregroundColor(.white.opacity(0.55))
      }
      .buttonStyle(.plain)
      .disabled(isBusy)
      .accessibilityIdentifier("meeting-summary-share-email-cancel")
    }
  }

  /// Detection now only prefills the field: the owner still confirms or
  /// replaces the address before anything is sent, which is what keeps a
  /// mis-identified participant from being emailed by one click.
  func beginAddressing() {
    guard !isBusy else { return }
    if recipientEmail.isEmpty, let suggested = recipients.first?.email {
      recipientEmail = suggested
    }
    isAddressing = true
    FloatingControlBarManager.shared.focusBarWindowForTextEntry()
    recipientFieldFocused = true
  }

  private func copyLink() {
    guard !isBusy else { return }
    phase = .copying
    Task { @MainActor in
      let feedback = await MeetingSummaryShareActions.copyLink(conversationID: conversationID)
      if feedback == .copied {
        finish(confirmation: "Link copied")
      } else {
        phase = .failed("Couldn't copy the link — try again")
      }
    }
  }

  private func sendSummary() {
    let address = recipientEmail.trimmingCharacters(in: .whitespaces)
    guard !isBusy, typedEmailIsSendable else { return }
    phase = .sending
    recipientFieldFocused = false
    Task { @MainActor in
      do {
        let sent = try await MeetingSummaryShareActions.sendSummary(
          conversationID: conversationID, recipientEmails: [address])
        let label = ConversationShareRecipient(name: nil, email: address).shortLabel
        finish(confirmation: sent.count > 1 ? "Sent to \(label) +\(sent.count - 1)" : "Sent to \(label)")
      } catch {
        isAddressing = true
        phase = .failed("Couldn't send — try again")
      }
    }
  }

  /// Success shows a short confirmation, then the card dismisses itself. The
  /// dismissal goes through the manager so queue advancement and bar re-hide
  /// keep their single owner.
  private func finish(confirmation: String) {
    phase = .done(confirmation)
    Task { @MainActor in
      try? await Task.sleep(nanoseconds: 1_400_000_000)
      FloatingControlBarManager.shared.dismissCurrentNotification()
    }
  }
}