@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useLayoutEffect, useRef, useState, type CSSProperties, type PointerEvent } from 'react';
-import { availableMonitors, currentMonitor, getCurrentWindow, primaryMonitor, type Monitor } from '@tauri-apps/api/window';
+import { availableMonitors, currentMonitor, cursorPosition, getAllWindows, getCurrentWindow, primaryMonitor, type Monitor } from '@tauri-apps/api/window';
 import { PhysicalPosition } from '@tauri-apps/api/dpi';
 import { emitTo, listen } from '@tauri-apps/api/event';
 import { isPermissionGranted, requestPermission, sendNotification } from '@tauri-apps/plugin-notification';
@@ -17,6 +17,7 @@ import { createSessionMonitor } from './lib/session-monitor';
 import { needsRefresh } from './lib/widget-refresh';
 import { createWidgetRecovery } from './lib/widget-recovery';
 import { createLatestQueue, physicalPanelBounds, samePhysical, DETAIL_EVENTS, DETAIL_WINDOW, isCurrentDetailInteraction, panelWidthFor, type DetailInteraction, type DetailState, type PhysicalBounds } from './lib/detail-panel';
+import { createDetailPresence, presenceFromPoint } from './lib/detail-presence';
 import { ProviderGauge } from './components/ProviderGauge';
 import { accountTags } from './lib/accounts';
 import { clipSurfaceSafely, measureSurfaceClip } from './lib/surface-clip';
@@ -178,6 +179,24 @@ export function Widget() {
   const refreshAbort = useRef<AbortController | null>(null);
   const closeTimer = useRef<number | undefined>(undefined);
   const openTimer = useRef<number | undefined>(undefined);
+  /**
+   * Native cursor presence (#154): on macOS the DOM can stop delivering
+   * `mouseleave` in transparent non-activating windows, pinning the popup.
+   * While the popup is open we sample the global cursor position against the
+   * native bounds of both windows — platform-independent close guarantee.
+   */
+  const presenceRef = useRef(
+    createDetailPresence({
+      isOpen: () => detailStateRef.current != null,
+      scheduleClose: () => {
+        // Direct close timer: never gated by the DOM-only `detailInsideRef`,
+        // which is exactly what gets stuck on macOS.
+        window.clearTimeout(closeTimer.current);
+        closeTimer.current = window.setTimeout(() => setHovered(null), CLOSE_DELAY);
+      },
+      cancelClose: () => window.clearTimeout(closeTimer.current),
+    }),
+  ).current;
   const shown = useRef(false);
   const drag = useRef<{ sx: number; sy: number; start: PhysicalPosition | null; sf: number; raf: number; pointerId: number; ending: boolean } | null>(null);
   const orbDrag = useRef<{ id: string; x: number; y: number; moved: boolean } | null>(null);
@@ -683,6 +702,48 @@ export function Widget() {
     if (detailInsideRef.current) return;
     closeTimer.current = window.setTimeout(() => setHovered(null), CLOSE_DELAY);
   };
+
+  // Muestreo nativo de presencia (#154): mientras el popup esté abierto, la
+  // posición global del cursor frente a los bounds nativos de ambas ventanas
+  // alimenta el tracker. Falla en silencio (Wayland puede no exponer la
+  // posición): el muestreo degrada, nunca adivina.
+  useEffect(() => {
+    if (!hovered) {
+      presenceRef.reset();
+      return;
+    }
+    let disposed = false;
+    const boundsOf = async (label: string): Promise<PhysicalBounds | null> => {
+      try {
+        const win = (await getAllWindows()).find((w) => w.label === label);
+        if (!win) return null;
+        const [pos, size] = await Promise.all([win.outerPosition(), win.outerSize()]);
+        return { x: pos.x, y: pos.y, w: size.width, h: size.height };
+      } catch {
+        return null;
+      }
+    };
+    const sample = async () => {
+      try {
+        const point = await cursorPosition();
+        const [widget, detail] = await Promise.all([boundsOf('widget'), boundsOf(DETAIL_WINDOW)]);
+        if (disposed) return;
+        const { widget: inWidget, detail: inDetail } = presenceFromPoint(point, widget, detail);
+        // Sincroniza el flag DOM-only por si su `mouseleave` nunca llegó.
+        detailInsideRef.current = inDetail;
+        presenceRef.cursor('widget', inWidget);
+        presenceRef.cursor('detail', inDetail);
+      } catch {
+        // Sin posición de cursor (p. ej. Wayland): no hay conclusión.
+      }
+    };
+    const interval = window.setInterval(() => { void sample(); }, 400);
+    void sample();
+    return () => {
+      disposed = true;
+      window.clearInterval(interval);
+    };
+  }, [hovered, presenceRef]);
   useEffect(() => {
     dragMounted.current = true;
     return () => {
 
@@ -0,0 +1,137 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createDetailPresence, pointInBounds, presenceFromPoint } from './detail-presence';
+
+/**
+ * Deterministic tracker whose close bookkeeping records the ORDER of
+ * schedule/cancel calls. The guarantee under test is about the final state:
+ * after any transition sequence, a pending close exists iff the cursor is
+ * outside both surfaces while the popup is open.
+ */
+function setup(isOpen: () => boolean = () => true) {
+  vi.useFakeTimers();
+  const calls: ('schedule' | 'cancel')[] = [];
+  const scheduleClose = vi.fn(() => calls.push('schedule'));
+  const cancelClose = vi.fn(() => calls.push('cancel'));
+  const tracker = createDetailPresence({ isOpen, scheduleClose, cancelClose });
+  const lastAction = () => calls[calls.length - 1] ?? 'none';
+  return { tracker, scheduleClose, cancelClose, lastAction };
+}
+afterEach(() => vi.useRealTimers());
+
+describe('createDetailPresence', () => {
+  it('escenario #154: popup abierto, el DOM no emite mouseleave y el cursor nativo sale de ambas superficies → queda pendiente de cerrar', () => {
+    const { tracker, lastAction } = setup();
+    tracker.cursor('widget', true);
+    tracker.cursor('widget', false); // sale del widget (tránsito)
+    tracker.cursor('detail', true); // entra al panel
+    tracker.cursor('detail', false); // sale del panel: fuera de ambas
+    expect(lastAction()).toBe('schedule');
+  });
+
+  it('no deja cierre pendiente si el cursor sigue dentro del widget', () => {
+    const { tracker, lastAction } = setup();
+    tracker.cursor('widget', true);
+    tracker.cursor('detail', false);
+    expect(lastAction()).not.toBe('schedule');
+  });
+
+  it('no deja cierre pendiente si el cursor sigue dentro del panel', () => {
+    const { tracker, lastAction } = setup();
+    tracker.cursor('widget', true);
+    tracker.cursor('widget', false);
+    tracker.cursor('detail', true);
+    expect(lastAction()).not.toBe('schedule');
+  });
+
+  it('con el popup cerrado no programa cierre ni toca timers', () => {
+    const { tracker, scheduleClose, cancelClose, lastAction } = setup(() => false);
+    tracker.cursor('widget', true);
+    tracker.cursor('widget', false);
+    tracker.cursor('detail', true);
+    tracker.cursor('detail', false);
+    expect(scheduleClose).not.toHaveBeenCalled();
+    expect(cancelClose).not.toHaveBeenCalled();
+    expect(lastAction()).toBe('none');
+  });
+
+  it('la re-entrada dentro del retardo cancela el cierre programado (tránsito widget→panel y de vuelta)', () => {
+    const { tracker, lastAction } = setup();
+    tracker.cursor('widget', true);
+    tracker.cursor('widget', false);
+    tracker.cursor('detail', true);
+    expect(lastAction()).toBe('cancel');
+    tracker.cursor('detail', false);
+    tracker.cursor('widget', true);
+    expect(lastAction()).toBe('cancel');
+  });
+
+  it('eventos repetidos idénticos son idempotentes (flujo real widget→panel→fuera)', () => {
+    const { tracker, scheduleClose, cancelClose, lastAction } = setup();
+    tracker.cursor('widget', true);
+    tracker.cursor('widget', true); // duplicado: no-op
+    tracker.cursor('widget', false); // tránsito al panel
+    tracker.cursor('widget', false); // duplicado: no-op
+    tracker.cursor('detail', true);
+    tracker.cursor('detail', false); // fuera de ambas: cierre pendiente
+    tracker.cursor('detail', false); // duplicado: no-op
+    expect(scheduleClose).toHaveBeenCalledTimes(2);
+    expect(cancelClose).toHaveBeenCalledTimes(2);
+    expect(lastAction()).toBe('schedule');
+    // Y una re-entrada posterior cancela: sin cierre pendiente.
+    tracker.cursor('widget', true);
+    expect(lastAction()).toBe('cancel');
+  });
+
+  it('isAnyInside refleja la unión de ambas superficies', () => {
+    const { tracker } = setup();
+    expect(tracker.isAnyInside()).toBe(false);
+    tracker.cursor('detail', true);
+    expect(tracker.isAnyInside()).toBe(true);
+    tracker.cursor('detail', false);
+    tracker.cursor('widget', true);
+    expect(tracker.isAnyInside()).toBe(true);
+    tracker.cursor('widget', false);
+    expect(tracker.isAnyInside()).toBe(false);
+  });
+
+  it('reset olvida la presencia (popup cerrado por otra vía)', () => {
+    const { tracker } = setup();
+    tracker.cursor('widget', true);
+    tracker.reset();
+    expect(tracker.isAnyInside()).toBe(false);
+    // Tras reset, la re-notificación del mismo valor vuelve a procesarse.
+    const { tracker: t2, cancelClose } = setup();
+    t2.cursor('widget', true);
+    t2.reset();
+    t2.cursor('widget', true);
+    expect(cancelClose).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('pointInBounds', () => {
+  const b = { x: 100, y: 200, w: 300, h: 150 };
+  it('contiene puntos interiores y en el borde izquierdo/superior', () => {
+    expect(pointInBounds({ x: 250, y: 275 }, b)).toBe(true);
+    expect(pointInBounds({ x: 100, y: 200 }, b)).toBe(true);
+  });
+  it('excluye bordes derecho/inferior y puntos exteriores', () => {
+    expect(pointInBounds({ x: 400, y: 275 }, b)).toBe(false);
+    expect(pointInBounds({ x: 250, y: 350 }, b)).toBe(false);
+    expect(pointInBounds({ x: 99, y: 275 }, b)).toBe(false);
+    expect(pointInBounds({ x: 250, y: 10000 }, b)).toBe(false);
+  });
+});
+
+describe('presenceFromPoint', () => {
+  const widget = { x: 0, y: 0, w: 100, h: 500 };
+  const detail = { x: 100, y: 0, w: 330, h: 260 };
+  it('clasifica el punto por superficie', () => {
+    expect(presenceFromPoint({ x: 50, y: 250 }, widget, detail)).toEqual({ widget: true, detail: false });
+    expect(presenceFromPoint({ x: 200, y: 100 }, widget, detail)).toEqual({ widget: false, detail: true });
+    expect(presenceFromPoint({ x: 1000, y: 1000 }, widget, detail)).toEqual({ widget: false, detail: false });
+  });
+  it('con bounds desconocidos la superficie no se puede afirmar', () => {
+    expect(presenceFromPoint({ x: 50, y: 250 }, widget, null)).toEqual({ widget: true, detail: false });
+    expect(presenceFromPoint({ x: 50, y: 250 }, null, null)).toEqual({ widget: false, detail: false });
+  });
+});
@@ -0,0 +1,80 @@
+/**
+ * Native cursor presence for the hover detail popup (#154).
+ *
+ * The popup's close path must not depend on DOM `mouseleave`: on macOS, a
+ * Webview in a transparent, non-activating window can stop delivering
+ * mouse-moved/exit events, and the popup then stays pinned forever. The
+ * widget forwards tao's reliable window-level `CursorEntered`/`CursorLeft`
+ * (tao emits them from native tracking rects) for the `widget` and `detail`
+ * windows as a `detail-cursor-presence` event, and this tracker turns those
+ * transitions into close scheduling.
+ *
+ * DOM `mouseleave` handlers keep working as before (Windows path); the
+ * native presence is an additional, platform-independent guarantee, so both
+ * sources converge on the same close timer owned by the widget.
+ */
+
+export type PresenceSurface = 'widget' | 'detail';
+
+export interface DetailPresenceHooks {
+  /** Popup currently open (a detail state is showing). */
+  isOpen(): boolean;
+  /** Start (or restart) the close timer. */
+  scheduleClose(): void;
+  /** Cancel a pending close timer. */
+  cancelClose(): void;
+}
+
+export interface DetailPresence {
+  /** Cursor transition for one surface (native or sampled). */
+  cursor(surface: PresenceSurface, inside: boolean): void;
+  /** True while the cursor is over either surface. */
+  isAnyInside(): boolean;
+  /** Forget presence (popup closed by another path). */
+  reset(): void;
+}
+
+export function createDetailPresence(hooks: DetailPresenceHooks): DetailPresence {
+  const inside: Record<PresenceSurface, boolean> = { widget: false, detail: false };
+
+  return {
+    cursor(surface, next) {
+      if (inside[surface] === next) return; // duplicates are no-ops
+      inside[surface] = next;
+      if (next) {
+        // Cursor reached a surface that must keep the popup alive.
+        if (hooks.isOpen()) hooks.cancelClose();
+        return;
+      }
+      if (hooks.isOpen() && !inside.widget && !inside.detail) hooks.scheduleClose();
+    },
+    isAnyInside() {
+      return inside.widget || inside.detail;
+    },
+    reset() {
+      inside.widget = false;
+      inside.detail = false;
+    },
+  };
+}
+
+/** True when a global (physical-pixel) point lies inside native window bounds. */
+export function pointInBounds(p: { x: number; y: number }, b: { x: number; y: number; w: number; h: number }): boolean {
+  return p.x >= b.x && p.x < b.x + b.w && p.y >= b.y && p.y < b.y + b.h;
+}
+
+/**
+ * Native presence of the global cursor over the popup surfaces, from one
+ * sample. A surface with unknown bounds (`null`: query failed, e.g. Wayland)
+ * is left untouched by the caller — sampling degrades, it never guesses.
+ */
+export function presenceFromPoint(
+  point: { x: number; y: number },
+  widget: { x: number; y: number; w: number; h: number } | null,
+  detail: { x: number; y: number; w: number; h: number } | null,
+): { widget: boolean; detail: boolean } {
+  return {
+    widget: !!widget && pointInBounds(point, widget),
+    detail: !!detail && pointInBounds(point, detail),
+  };
+}