@@ -28,10 +28,14 @@ import { RETURN_THRESHOLD_MS } from '@/features/assistant/constants';
 import { useRetentionInit } from '@/features/retention/hooks/useRetentionInit';
 import { DiscoveryReveal } from '@/features/retention/components/DiscoveryReveal';
 import '@/stores/useSettingsStore'; // 导入以触发音效设置初始化
+import { startPomodoroScheduler } from '@/features/pomodoro/lib/pomodoroScheduler';
 
 // 启动时预加载所有音效（不阻塞渲染）
 soundPlayer.preloadAll();
 
+// 番茄钟全局计时调度器：tick 驱动与页面生命周期解耦（切页后计时不停摆）
+startPomodoroScheduler();
+
 const queryClient = new QueryClient({
   defaultOptions: {
     queries: {
 
@@ -0,0 +1,64 @@
+/**
+ * 番茄钟全局计时调度器
+ *
+ * @ai-context: tick 驱动与页面生命周期解耦——历史缺陷：计时曾仅由 PomodoroPage
+ * 组件内 setInterval 驱动，而 AppLayout 的路由切换（AnimatePresence mode="wait"）
+ * 会真实卸载旧页面，导致用户切到其他模块时倒计时静默停摆。
+ * 本模块以模块级 store.subscribe 监听 isRunning 翻转，保证任何页面下计时持续推进；
+ * 前台恢复（visibilitychange）时立即 tick 一次，配合 store 内 endAt 墙钟校准
+ * 自愈系统休眠/后台期间累积的计时误差。
+ *
+ * @ai-context: 纯副作用模块（无 React 依赖），由 App 启动时调用一次 startPomodoroScheduler()。
+ * 测试环境不调用本函数，故不会在单测中产生游离 interval。
+ */
+
+import { usePomodoroStore } from '../store/usePomodoroStore';
+
+const TICK_INTERVAL_MS = 1000;
+
+/** 当前活跃的 interval 句柄（null = 计时未运行） */
+let timer: ReturnType<typeof setInterval> | null = null;
+
+/** 幂等守卫：防止重复注册订阅与监听 */
+let initialized = false;
+
+/**
+ * 按 isRunning 同步 interval 生命周期（幂等）
+ *
+ * @ai-context: 每次调用读取最新 store 快照而非闭包值，
+ * 避免订阅回调里的陈旧状态导致 interval 泄漏或重复创建。
+ */
+function syncTimer(): void {
+  const { isRunning } = usePomodoroStore.getState();
+  if (isRunning && timer === null) {
+    timer = setInterval(() => usePomodoroStore.getState().tick(), TICK_INTERVAL_MS);
+  } else if (!isRunning && timer !== null) {
+    clearInterval(timer);
+    timer = null;
+  }
+}
+
+/**
+ * 启动全局计时调度器（应用启动时调用一次，内部幂等）
+ *
+ * @returns void
+ */
+export function startPomodoroScheduler(): void {
+  if (initialized) return;
+  initialized = true;
+
+  // 仅在 isRunning 翻转时同步 interval，避免其他高频状态变化（如 remainingSeconds）触发多余判断
+  usePomodoroStore.subscribe((state, prevState) => {
+    if (state.isRunning !== prevState.isRunning) syncTimer();
+  });
+
+  // 回前台立即校准一次：休眠/后台期间错过的时间由 endAt 墙钟吸附补齐
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'visible') {
+      usePomodoroStore.getState().tick();
+    }
+  });
+
+  // 应用启动时若已有运行中的计时（如热更新后），立即接管
+  syncTimer();
+}
@@ -1,7 +1,7 @@
 /**
  * @ai-context: pomodoro 功能模块页面：PomodoroPage。
  */
-import { useEffect, useRef, useState, useMemo, useCallback } from 'react';
+import { useEffect, useState, useMemo, useCallback } from 'react';
 import { createPortal } from 'react-dom';
 import { AnimatePresence, motion } from 'framer-motion';
 import { Play, Pause, RotateCcw, SkipForward, Clock, Volume2, VolumeX, Focus } from 'lucide-react';
@@ -29,21 +29,19 @@ import type { AudioPreferences } from '@/lib/audio/audioConfig';
 
 const WHITE_NOISE_FADE_MS = 1000;
 const WHITE_NOISE_FADE_OUT_MS = 1500;
-const TIMER_TICK_INTERVAL_MS = 1000;
 
 export default function PomodoroPage() {
   const {
     phase, isRunning, isPaused, remainingSeconds, totalSeconds,
     completedCount, settings, currentGoal, isImmersive,
     activePreset, presets,
     start, pause, resume, reset, skip, setPreset, setCurrentGoal,
-    enterImmersive, exitImmersive, tick, createPreset,
+    enterImmersive, exitImmersive, createPreset,
     showCompletionOverlay, dismissCompletionOverlay, lastSessionActualDuration,
   } = usePomodoroStore(useShallow(s => s));
 
   usePomodoroEffects();
 
-  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const [goalModalOpen, setGoalModalOpen] = useState(false);
   const [rememberGoal, setRememberGoal] = useState(false);
   const [presetEditorOpen, setPresetEditorOpen] = useState(false);
@@ -77,14 +75,8 @@ export default function PomodoroPage() {
     whiteNoisePlayer.setVolume(vol);
   };
 
-  useEffect(() => {
-    if (isRunning) {
-      intervalRef.current = setInterval(() => tick(), TIMER_TICK_INTERVAL_MS);
-    } else {
-      if (intervalRef.current) { clearInterval(intervalRef.current); intervalRef.current = null; }
-    }
-    return () => { if (intervalRef.current) clearInterval(intervalRef.current); };
-  }, [isRunning, tick]);
+  // @ai-context: tick 驱动已上移至全局调度器 pomodoroScheduler.ts（App 启动时注册），
+  // 不再由本页面组件级 setInterval 驱动——切离页面后计时仍持续推进
 
   useEffect(() => {
     if (isRunning || isPaused) {
@@ -141,13 +133,34 @@ export default function PomodoroPage() {
   // 循环标记数据 — 由活动预设的 longBreakInterval 驱动
   const cycleTotal = activePreset?.longBreakInterval ?? settings.longBreakInterval;
 
+  // 双模式过渡排序：沉浸层（portal）与普通视图分属两个独立 AnimatePresence 实例，
+  // mode="wait" 跨实例无效——此前切换时沉浸退场(0.5s)与普通进场(0.3s)同屏叠加
+  // 约 0.6s，表现为组件重复的双曝光残帧。此处用视图状态机显式串行化
+  // “新视图必须等旧视图退场动画完成后才进场”：切换期间仅渲染旧视图退场动画，
+  // onExitComplete 后再迁至目标视图。全部动画参数保留，仅消除叠加。
+  const [view, setView] = useState<'normal' | 'immersive' | 'switching-to-immersive' | 'switching-to-normal'>(
+    () => (isImmersive ? 'immersive' : 'normal'),
+  );
+
+  useEffect(() => {
+    if (isImmersive) {
+      // 'switching-to-normal' → 'immersive'：沉浸退场中用户又重新进入，直接重新挂载
+      setView(v => (v === 'immersive' || v === 'switching-to-immersive')
+        ? v
+        : v === 'switching-to-normal' ? 'immersive' : 'switching-to-immersive');
+    } else {
+      setView(v => (v === 'normal' || v === 'switching-to-normal')
+        ? v
+        : v === 'switching-to-immersive' ? 'normal' : 'switching-to-normal');
+    }
+  }, [isImmersive]);
+
   return (
     <>
-      {/* 沉浸模式 — portal 到 body，AnimatePresence 在 portal 内部管理动效 */}
-      {/* 沉浸模式切换：mode="wait" 确保沉浸模式完全退出后再显示普通模式，避免双视图叠加残帧 */}
+      {/* 沉浸层 — createPortal 挂到 body（z-40 盖住覆盖层）；挂载时机由上方视图状态机门控 */}
       {createPortal(
-        <AnimatePresence mode="wait">
-          {isImmersive && (
+        <AnimatePresence onExitComplete={() => setView(v => (v === 'switching-to-normal' ? 'normal' : v))}>
+          {view === 'immersive' && (
             <motion.div
               key="immersive"
               className="fixed inset-0 z-40 flex flex-col overflow-hidden"
@@ -169,9 +182,9 @@ export default function PomodoroPage() {
         document.body,
       )}
 
-      {/* 普通模式 */}
-      <AnimatePresence mode="popLayout">
-      {!isImmersive && (
+      {/* 普通视图 — 仅在沉浸层退场完成后（或初始即普通模式时）挂载 */}
+      <AnimatePresence mode="popLayout" onExitComplete={() => setView(v => (v === 'switching-to-immersive' ? 'immersive' : v))}>
+        {view === 'normal' && (
         <motion.div
           key="normal"
           className="flex flex-col items-center justify-center min-h-0 flex-1 px-4 py-12 relative"
@@ -358,7 +371,7 @@ export default function PomodoroPage() {
             }}
           />
         </motion.div>
-      )}
+        )}
       </AnimatePresence>
 
       {/* v0.29: 深潜完成庆祝覆盖层 */}
 
@@ -77,6 +77,7 @@ const DEFAULT_STATE = {
   isPaused: false,
   remainingSeconds: 25 * 60,
   totalSeconds: 25 * 60,
+  endAt: null as number | null,
   completedCount: 0,
   mode: 'self_study' as const,
   settings: DEFAULT_SETTINGS,
@@ -130,6 +131,33 @@ describe('Pomodoro Store', () => {
       usePomodoroStore.getState().tick();
       expect(usePomodoroStore.getState().remainingSeconds).toBe(before);
     });
+
+    it('should snap remainingSeconds to endAt wall clock when drift exceeds 1s', () => {
+      // Arrange：模拟休眠唤醒——递减模型认为还剩 500s，但墙钟显示实际只剩 100s
+      usePomodoroStore.setState({
+        isRunning: true,
+        remainingSeconds: 500,
+        endAt: Date.now() + 100 * 1000,
+      });
+
+      // Act
+      usePomodoroStore.getState().tick();
+
+      // Assert：吸附到墙钟值而非继续 -1
+      expect(usePomodoroStore.getState().remainingSeconds).toBe(100);
+    });
+
+    it('should keep -1 rhythm when wall clock drift is within 1s', () => {
+      // Arrange：刚 start，墙钟与递减模型误差 ≤1s，不应跳秒
+      usePomodoroStore.getState().start();
+      const before = usePomodoroStore.getState().remainingSeconds;
+
+      // Act
+      usePomodoroStore.getState().tick();
+
+      // Assert
+      expect(usePomodoroStore.getState().remainingSeconds).toBe(before - 1);
+    });
   });
 
   // ── phase rotation ────────────────────────────────────────
 
@@ -54,6 +54,8 @@ interface PomodoroState {
   isPaused: boolean;
   remainingSeconds: number;
   totalSeconds: number;
+  /** 当前运行阶段的绝对截止时间戳（ms）——墙钟校准源，休眠唤醒/计时漂移后自愈 */
+  endAt: number | null;
   completedCount: number;
   /** @deprecated 兼容层：由 activePreset 派生，下版本移除 */
   mode: Mode;
@@ -197,6 +199,7 @@ export const usePomodoroStore = create<PomodoroState>((set, get) => {
     isPaused: false,
     remainingSeconds: defaultSettings.workDuration * 60,
     totalSeconds: defaultSettings.workDuration * 60,
+    endAt: null,
     completedCount: 0,
     mode: 'self_study',
     settings: defaultSettings,
@@ -254,6 +257,8 @@ export const usePomodoroStore = create<PomodoroState>((set, get) => {
     start: () => {
       set((s) => ({
         isRunning: true, isPaused: false, sessionStartTime: Date.now(),
+        // 墙钟截止点：tick 据此校准，避免 interval 漂移/后台节流累积误差
+        endAt: Date.now() + s.remainingSeconds * 1000,
         lastAction: 'start' as PomodoroAction, lastActionCounter: s.lastActionCounter + 1,
       }));
       soundPlayer.play('pomodoro_start');
@@ -264,6 +269,7 @@ export const usePomodoroStore = create<PomodoroState>((set, get) => {
       set((s) => ({
         mode: 'self_study', phase: 'work',
         remainingSeconds: MINI_DIVE_SECONDS, totalSeconds: MINI_DIVE_SECONDS,
+        endAt: Date.now() + MINI_DIVE_SECONDS * 1000,
         isMiniDive: true, isRunning: true, isPaused: false,
         sessionStartTime: Date.now(), currentGoal: '首潜 · 3 分钟体验',
         lastAction: 'start' as PomodoroAction, lastActionCounter: s.lastActionCounter + 1,
@@ -276,6 +282,7 @@ export const usePomodoroStore = create<PomodoroState>((set, get) => {
       set((s) => ({
         mode: 'self_study', phase: 'work',
         remainingSeconds: COMMIT_DIVE_SECONDS, totalSeconds: COMMIT_DIVE_SECONDS,
+        endAt: Date.now() + COMMIT_DIVE_SECONDS * 1000,
         isMiniDive: true, isRunning: true, isPaused: false,
         sessionStartTime: Date.now(), currentGoal: '就 5 分钟 · 随时可以停',
         lastAction: 'start' as PomodoroAction, lastActionCounter: s.lastActionCounter + 1,
@@ -285,23 +292,25 @@ export const usePomodoroStore = create<PomodoroState>((set, get) => {
 
     pause: () => {
       set((s) => ({
-        isRunning: false, isPaused: true,
+        isRunning: false, isPaused: true, endAt: null,
         lastAction: 'pause' as PomodoroAction, lastActionCounter: s.lastActionCounter + 1,
       }));
       soundPlayer.play('pomodoro_pause');
     },
 
     resume: () => {
       const { sessionStartTime, wasImmersive } = get();
-      set({
+      set((s) => ({
         isRunning: true,
         isPaused: false,
+        // 恢复运行重设墙钟截止点（暂停期间时间不计入）
+        endAt: Date.now() + s.remainingSeconds * 1000,
         // 如果 sessionStartTime 为空（重置后），重新记录
         sessionStartTime: sessionStartTime ?? Date.now(),
         // 若上次是从沉浸模式退出的，自动重新进入沉浸
         isImmersive: wasImmersive ? true : get().isImmersive,
         wasImmersive: false,
-      });
+      }));
     },
 
     reset: () => {
@@ -312,6 +321,7 @@ export const usePomodoroStore = create<PomodoroState>((set, get) => {
         totalSeconds: duration,
         isRunning: false,
         isPaused: false,
+        endAt: null,
         sessionStartTime: null,
         wasImmersive: false,
         isMiniDive: false,
@@ -331,6 +341,7 @@ export const usePomodoroStore = create<PomodoroState>((set, get) => {
         completedCount: newCount,
         isRunning: false,
         isPaused: false,
+        endAt: null,
         isMiniDive: false,
       });
     },
@@ -376,7 +387,7 @@ export const usePomodoroStore = create<PomodoroState>((set, get) => {
         soundPlayer.play('pomodoro_pause');
       }
       set((s) => ({
-        isImmersive: false, wasImmersive: true, isRunning: false, isPaused: true,
+        isImmersive: false, wasImmersive: true, isRunning: false, isPaused: true, endAt: null,
         lastAction: 'exit_immersive' as PomodoroAction, lastActionCounter: s.lastActionCounter + 1,
       }));
     },
@@ -476,6 +487,8 @@ export const usePomodoroStore = create<PomodoroState>((set, get) => {
           completedCount: newCount,
           isRunning: shouldAutoStart,
           isPaused: !shouldAutoStart,
+          // 自动进入下一阶段时重设墙钟截止点；否则清空等待下次 start/resume
+          endAt: shouldAutoStart ? Date.now() + duration * 1000 : null,
           // 迷你潜水仅限一个工作阶段，阶段切换即恢复常规节律
           isMiniDive: false,
           // 切换到新阶段时清空计时，下一个 start/resume 会重新设置
@@ -490,7 +503,16 @@ export const usePomodoroStore = create<PomodoroState>((set, get) => {
           showCompletionOverlay: phase === 'work' ? true : s.showCompletionOverlay,
         }));
       } else {
-        const nextRemaining = remainingSeconds - 1;
+        let nextRemaining = remainingSeconds - 1;
+        // 墙钟校准：系统休眠唤醒/setInterval 漂移后，与 endAt 误差超过 1s 时直接吸附，
+        // 避免递减模型累积误差（误差 ≤1s 时保持 -1 节奏，防止 UI 跳秒）
+        const { endAt } = get();
+        if (endAt != null) {
+          const wallRemaining = Math.max(0, Math.round((endAt - Date.now()) / 1000));
+          if (Math.abs(wallRemaining - nextRemaining) > 1) {
+            nextRemaining = wallRemaining;
+          }
+        }
         // 静默预设跳过预警和滴答音
         if (!isSilent) {
           // 预警（工作阶段）—— 支持自定义时点