@@ -9,6 +9,7 @@ import { act, TestRenderer } from '@/test/renderer';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { OFFLINE_BANNER_HEIGHT } from '@/lib/offline-banner-state';
+import { HEADER_BACK_GUARD_MS } from '@/lib/hooks/header-back';
 import { ICON_TARGET_BOX_CLASS } from '@/lib/a11y/tap-target';
 import { AGENTS_SESSIONS_HREF } from '@/lib/agents-sessions-route';
 import { ScreenHeader, shouldStackHeaderActions } from './screen-header';
@@ -311,6 +312,37 @@ describe('ScreenHeader mounted', () => {
     expect(back.props.accessibilityRole).toBe('button');
   });
 
+  it('dispatches one back for a burst of presses on the same header', () => {
+    // One gesture owns the header's Back: four presses delivered inside the
+    // window have to pop one screen, not four. The window is per header, so the
+    // screen a dispatched back lands on starts a fresh one.
+    vi.useFakeTimers();
+    try {
+      vi.setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
+      routerState.routes = ['tabs', 'security-agent', 'security-agent-settings'];
+      const renderer = renderHeader({ title: 'Settings' });
+
+      const back = findBackPressable(renderer.root);
+      for (let press = 0; press < 4; press += 1) {
+        act(() => {
+          (back.props.onPress as () => void)();
+        });
+      }
+      expect(routerState.back).toHaveBeenCalledTimes(1);
+      expect(routerState.routes).toEqual(['tabs', 'security-agent']);
+
+      // A deliberate press after the window still walks the stack.
+      vi.setSystemTime(new Date(Date.now() + HEADER_BACK_GUARD_MS));
+      act(() => {
+        (back.props.onPress as () => void)();
+      });
+      expect(routerState.back).toHaveBeenCalledTimes(2);
+      expect(routerState.routes).toEqual(['tabs']);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it('pulls the leading controls with a logical start margin the RTL swap cannot mirror', async () => {
     const renderer = renderHeader({ title: 'Sessions', headerRight: 'RIGHT' });
 
 
@@ -9,6 +9,7 @@ import { useTranslation } from 'react-i18next';
 import { Eyebrow } from '@/components/ui/eyebrow';
 import { Text } from '@/components/ui/text';
 import { useOfflineBannerSpace } from '@/components/offline-banner-space';
+import { useHeaderBack } from '@/lib/hooks/use-header-back';
 import { useThemeColors } from '@/lib/hooks/use-theme-colors';
 import { offlineHeaderReservation } from '@/lib/offline-banner-state';
 import { useScreenInsets, useSideInsetStyle } from '@/lib/screen-insets';
@@ -269,13 +270,13 @@ export function ScreenHeader({
   className,
 }: Readonly<ScreenHeaderProps>) {
   const insets = useScreenInsets();
-  const router = useRouter();
   const colors = useThemeColors();
   const { t } = useTranslation();
   const { width: windowWidth } = useWindowDimensions();
   const fontScale = useLiveFontScale();
   const historyCanGoBack = useCanGoBack();
   const canGoBack = showBackButton ?? (historyCanGoBack || backFallback !== undefined);
+  const handleBack = useHeaderBack({ onBack, backFallback, canGoBack: historyCanGoBack });
   const isOfflineBannerVisible = useOfflineBannerSpace();
   // A window too narrow to hold the title beside its actions drops the actions
   // to their own row instead of squeezing the title into a single-letter
@@ -450,18 +451,7 @@ export function ScreenHeader({
   const backControl = canGoBack ? (
     <View className={cn('shrink-0 overflow-hidden rounded-full', !separateHeading && '-ms-4')}>
       <Pressable
-        onPress={() => {
-          if (onBack) {
-            onBack();
-          } else if (backFallback !== undefined && !router.canGoBack()) {
-            // POP_TO keeps the fallback's contract (land on this destination)
-            // while truncating any routes the app left above the destination;
-            // with no history it still creates the destination, as replace did.
-            router.dismissTo(backFallback);
-          } else {
-            router.back();
-          }
-        }}
+        onPress={handleBack}
         accessibilityRole="button"
         accessibilityLabel={resolvedBackIcon === 'close' ? t('common.close') : t('common.goBack')}
         className={cn(ICON_TARGET_BOX_CLASS, 'active:opacity-70')}
 
@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  claimHeaderBack,
+  HEADER_BACK_GUARD_MS,
+  type HeaderBackGuardState,
+  resolveHeaderBack,
+} from './header-back';
+
+const T0 = 1_700_000_000_000;
+
+function freshState(): HeaderBackGuardState {
+  return { lastBackAt: 0 };
+}
+
+describe('claimHeaderBack', () => {
+  it('claims the first press and records when it was accepted', () => {
+    const state = freshState();
+
+    expect(claimHeaderBack(state, T0)).toBe(true);
+    expect(state.lastBackAt).toBe(T0);
+  });
+
+  it('drops a repeat inside the window so one burst dispatches one back', () => {
+    const state = freshState();
+    claimHeaderBack(state, T0);
+
+    expect(claimHeaderBack(state, T0 + 4)).toBe(false);
+    expect(claimHeaderBack(state, T0 + 40)).toBe(false);
+    expect(state.lastBackAt).toBe(T0);
+  });
+
+  it('accepts the press at the end of the window', () => {
+    const state = freshState();
+    claimHeaderBack(state, T0);
+
+    expect(claimHeaderBack(state, T0 + HEADER_BACK_GUARD_MS - 1)).toBe(false);
+    expect(claimHeaderBack(state, T0 + HEADER_BACK_GUARD_MS)).toBe(true);
+  });
+
+  it('opens a new window when the clock steps backwards', () => {
+    const state = freshState();
+    claimHeaderBack(state, T0);
+
+    // A wall clock that stepped back must not hold every press out until the
+    // clock catches up with the recorded time.
+    expect(claimHeaderBack(state, T0 - 3_600_000)).toBe(true);
+    expect(state.lastBackAt).toBe(T0 - 3_600_000);
+  });
+});
+
+describe('resolveHeaderBack', () => {
+  it('runs the screen handler before anything else', () => {
+    expect(resolveHeaderBack({ hasHandler: true, hasFallback: false, canGoBack: false })).toBe(
+      'handler'
+    );
+    expect(resolveHeaderBack({ hasHandler: true, hasFallback: true, canGoBack: true })).toBe(
+      'handler'
+    );
+  });
+
+  it('pops the navigator when it has history', () => {
+    expect(resolveHeaderBack({ hasHandler: false, hasFallback: false, canGoBack: true })).toBe(
+      'history'
+    );
+    expect(resolveHeaderBack({ hasHandler: false, hasFallback: true, canGoBack: true })).toBe(
+      'history'
+    );
+  });
+
+  it('uses the declared fallback when there is no history', () => {
+    expect(resolveHeaderBack({ hasHandler: false, hasFallback: true, canGoBack: false })).toBe(
+      'fallback'
+    );
+  });
+
+  it('does nothing when there is neither history nor a fallback', () => {
+    expect(resolveHeaderBack({ hasHandler: false, hasFallback: false, canGoBack: false })).toBe(
+      'none'
+    );
+  });
+});
@@ -0,0 +1,72 @@
+/**
+ * Burst window for one header Back press.
+ *
+ * Presses that reach a header inside one burst belong to the same gesture, and
+ * each one dispatches its own `router.back()` — expo-router enqueues one
+ * `GO_BACK` per call and the queue drains in order. On the Android emulator a
+ * four-tap burst on the Security Agent settings header delivered two presses to
+ * the same header 4 ms apart, so one gesture popped two screens. The window can
+ * be generous because the screen a dispatched back pops takes its guard with it,
+ * so the next screen's press starts a fresh window.
+ */
+export const HEADER_BACK_GUARD_MS = 500;
+
+/** Mutable guard state. Each header keeps one instance in a ref. */
+export type HeaderBackGuardState = {
+  /** `Date.now()` of the last dispatched back. `0` means none yet. */
+  lastBackAt: number;
+};
+
+/**
+ * Whether `now` is inside the window opened at `lastBackAt`.
+ *
+ * A wall clock can step backwards (NTP correction, a manual change), which
+ * makes the delta negative and would keep every press out for as long as the
+ * step lasts. A negative delta is read as "the clock moved, not a repeat" and
+ * opens a fresh window instead.
+ */
+function insideWindow(lastBackAt: number, now: number): boolean {
+  const elapsed = now - lastBackAt;
+  return elapsed >= 0 && elapsed < HEADER_BACK_GUARD_MS;
+}
+
+/** What a header Back press should run. */
+type HeaderBackDecision = 'handler' | 'history' | 'fallback' | 'none';
+
+/**
+ * Claim the burst window: `true` when this press may dispatch, `false` when it
+ * repeats a dispatch inside the window. The accepted press is recorded before
+ * returning, so a re-entrant call cannot claim the same window twice.
+ */
+export function claimHeaderBack(state: HeaderBackGuardState, now: number): boolean {
+  if (insideWindow(state.lastBackAt, now)) {
+    return false;
+  }
+  state.lastBackAt = now;
+  return true;
+}
+
+/**
+ * Decide what a Back press runs, from the controls the screen declared.
+ *
+ * A screen's own `onBack` owns the press, because it may open a confirmation
+ * instead of popping. Otherwise the navigator pops only when it has somewhere
+ * to pop to: a `router.back()` with no history is handled by
+ * whatever navigator is left (the tab navigator switches to its first tab) or
+ * is unhandled at the root, which is the unwinding past the stack root this
+ * guard exists to stop. A declared `backFallback` is the destination for a
+ * screen reached without history; with neither, the press does nothing.
+ */
+export function resolveHeaderBack(declared: {
+  hasHandler: boolean;
+  hasFallback: boolean;
+  canGoBack: boolean;
+}): HeaderBackDecision {
+  if (declared.hasHandler) {
+    return 'handler';
+  }
+  if (declared.canGoBack) {
+    return 'history';
+  }
+  return declared.hasFallback ? 'fallback' : 'none';
+}
@@ -0,0 +1,129 @@
+import { createElement } from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { act, TestRenderer } from '@/test/renderer';
+
+import { HEADER_BACK_GUARD_MS } from './header-back';
+import { type HeaderBackOptions, useHeaderBack } from './use-header-back';
+
+const router = vi.hoisted(() => ({ back: vi.fn(), dismissTo: vi.fn() }));
+
+vi.mock('expo-router', () => ({ useRouter: () => router }));
+
+const T0 = 1_700_000_000_000;
+
+function Probe({
+  props,
+  press,
+}: Readonly<{ props: HeaderBackOptions; press: { current: () => void } }>) {
+  press.current = useHeaderBack(props);
+  return null;
+}
+
+function mountHook(initial: HeaderBackOptions) {
+  const press: { current: () => void } = { current: () => undefined };
+  const created: { renderer: TestRenderer.ReactTestRenderer | undefined } = { renderer: undefined };
+  act(() => {
+    created.renderer = TestRenderer.create(createElement(Probe, { props: initial, press }));
+  });
+  const renderer = created.renderer;
+  if (!renderer) {
+    throw new Error('renderer was not created');
+  }
+  return {
+    press: () => {
+      act(() => {
+        press.current();
+      });
+    },
+    rerender: (next: HeaderBackOptions) => {
+      act(() => {
+        renderer.update(createElement(Probe, { props: next, press }));
+      });
+    },
+  };
+}
+
+// The hook reads `Date.now()`, so the burst window is driven from the fake clock.
+function advance(ms: number): void {
+  vi.setSystemTime(Date.now() + ms);
+}
+
+beforeEach(() => {
+  router.back.mockClear();
+  router.dismissTo.mockClear();
+  vi.useFakeTimers({ now: T0 });
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe('useHeaderBack', () => {
+  it('pops once for a burst on the same header', () => {
+    const header = mountHook({ canGoBack: true });
+
+    header.press();
+    advance(4);
+    header.press();
+    advance(40);
+    header.press();
+
+    expect(router.back).toHaveBeenCalledTimes(1);
+  });
+
+  it('pops again once the window has passed', () => {
+    const header = mountHook({ canGoBack: true });
+
+    header.press();
+    advance(HEADER_BACK_GUARD_MS);
+    header.press();
+
+    expect(router.back).toHaveBeenCalledTimes(2);
+  });
+
+  it('never pops without history', () => {
+    const header = mountHook({ canGoBack: false });
+
+    header.press();
+    advance(HEADER_BACK_GUARD_MS);
+    header.press();
+
+    expect(router.back).not.toHaveBeenCalled();
+    expect(router.dismissTo).not.toHaveBeenCalled();
+  });
+
+  it('dismisses to the declared fallback when the container has no history', () => {
+    const header = mountHook({ canGoBack: false, backFallback: '/profile' });
+
+    header.press();
+
+    expect(router.back).not.toHaveBeenCalled();
+    expect(router.dismissTo).toHaveBeenCalledWith('/profile');
+  });
+
+  it('runs the screen handler instead of a pop, once per burst', () => {
+    const onBack = vi.fn<() => void>();
+    const header = mountHook({ canGoBack: true, onBack });
+
+    header.press();
+    advance(4);
+    header.press();
+
+    expect(onBack).toHaveBeenCalledTimes(1);
+    expect(router.back).not.toHaveBeenCalled();
+  });
+
+  it('leaves the window unclaimed when the press has nothing to run', () => {
+    const header = mountHook({ canGoBack: false });
+
+    header.press();
+    // The navigator gained history a moment later; the dropped press must not
+    // hold the new one out of the same window.
+    advance(10);
+    header.rerender({ canGoBack: true });
+    header.press();
+
+    expect(router.back).toHaveBeenCalledTimes(1);
+  });
+});