feat: bugfix

主要改动: 配置本地开发环境 PostHog 上报到 Cloud\

     1. 修改 npm start 默认行为
       - start → 使用 .env.mock (默认 mock 数据)
       - 添加 start:real → 使用 .env.local (真实后端)
     2. 添加 PostHog 测试脚本
       - 新增 test:tracking → 启用 PostHog debug 模式 + mock 数据
     3. 清理冗余脚本
       - 移除 start:local (冗余,只是调用 npm start)
       - 重命名 install:clean → reinstall (移除自动启动)
       - 添加 dev 快捷命令 (等同于 npm start)
       - 添加 clean 命令 (只清理,不安装)
     4. 优化 NODE_OPTIONS
       - 不在每个命令中重复,通过注释说明可以提取为环境变量
       - 保持 exit 0 在 lint 命令中

.claude/settings.local.json

@@ -11,7 +11,8 @@
       "Bash(npm install)",
       "Bash(npm run start:mock)",
       "Bash(npm install fsevents@latest --save-optional --force)",
-      "Bash(python -m py_compile:*)"
+      "Bash(python -m py_compile:*)",
+      "Bash(ps -p 20502,53360 -o pid,command)"
     ],
     "deny": [],
     "ask": []

.env.development

@@ -1,5 +1,5 @@
 # 开发环境配置（连接真实后端）
-# 使用方式: npm start
+# 使用方式: npm run start:dev
 
 # React 构建优化配置
 GENERATE_SOURCEMAP=false
@@ -18,3 +18,10 @@ REACT_APP_ENABLE_MOCK=false
 
 # 开发环境标识
 REACT_APP_ENV=development
+
+# PostHog 配置（开发环境）
+# 留空 = 仅控制台 debug
+# 填入 Key = 控制台 + PostHog Cloud 双模式
+REACT_APP_POSTHOG_KEY=
+REACT_APP_POSTHOG_HOST=https://app.posthog.com
+REACT_APP_ENABLE_SESSION_RECORDING=false

.env.mock

@@ -35,3 +35,14 @@ REACT_APP_ENABLE_MOCK=true
 
 # Mock 环境标识
 REACT_APP_ENV=mock
+
+# PostHog 配置（Mock 环境）
+# 留空 = 仅控制台 debug
+# 填入 Key = 控制台 + PostHog Cloud 双模式
+REACT_APP_POSTHOG_KEY=phc_xKlRyG69Bx7hgOdFeCeLUvQWvSjw18ZKFgCwCeYezWF
+REACT_APP_POSTHOG_HOST=https://app.posthog.com
+REACT_APP_ENABLE_SESSION_RECORDING=false
+
+# PostHog Debug 模式（Mock 环境永久启用）
+# 在浏览器 Console 中打印详细的事件追踪日志
+REACT_APP_POSTHOG_DEBUG=true

.env.test

@@ -0,0 +1,42 @@
+# ========================================
+# 本地测试环境（前后端都在本地）
+# ========================================
+# 使用方式: npm run start:test
+#
+# 工作原理：
+# 1. concurrently 同时启动前端和后端
+# 2. 前端: localhost:3000
+# 3. 后端: localhost:5001 (python app_2.py)
+# 4. 数据: 本地数据库
+#
+# 适用场景：
+# - 调试后端代码
+# - 性能测试
+# - 离线开发
+# - 数据库调试
+# ========================================
+
+# 环境标识
+REACT_APP_ENV=test
+NODE_ENV=development
+
+# Mock 配置（关闭 MSW）
+REACT_APP_ENABLE_MOCK=false
+
+# 后端 API 地址（本地后端）
+REACT_APP_API_URL=http://localhost:5001
+
+# PostHog 配置（测试环境）
+# 留空 = 仅控制台 debug
+# 填入 Key = 控制台 + PostHog Cloud 双模式
+REACT_APP_POSTHOG_KEY=
+REACT_APP_POSTHOG_HOST=https://app.posthog.com
+REACT_APP_ENABLE_SESSION_RECORDING=false
+
+# React 构建优化配置
+GENERATE_SOURCEMAP=true  # 测试环境保留 sourcemap 便于调试
+SKIP_PREFLIGHT_CHECK=true
+DISABLE_ESLINT_PLUGIN=false  # 测试环境开启 ESLint
+TSC_COMPILE_ON_ERROR=true
+IMAGE_INLINE_SIZE_LIMIT=10000
+NODE_OPTIONS=--max_old_space_size=4096

package.json

@@ -93,9 +93,14 @@
     "uuid": "^9.0.1"
   },
   "scripts": {
-    "start": "NODE_OPTIONS='--openssl-legacy-provider --max_old_space_size=4096' craco start",
-    "start:mock": "NODE_OPTIONS='--openssl-legacy-provider --max_old_space_size=4096' env-cmd -f .env.mock craco start",
+    "prestart": "kill-port 3000",
+    "start": "NODE_OPTIONS='--openssl-legacy-provider --max_old_space_size=4096' env-cmd -f .env.mock craco start",
+    "start:real": "NODE_OPTIONS='--openssl-legacy-provider --max_old_space_size=4096' env-cmd -f .env.local craco start",
     "start:dev": "NODE_OPTIONS='--openssl-legacy-provider --max_old_space_size=4096' env-cmd -f .env.development craco start",
+    "start:test": "concurrently \"python app_2.py\" \"npm run frontend:test\" --names \"backend,frontend\" --prefix-colors \"blue,green\"",
+    "frontend:test": "NODE_OPTIONS='--openssl-legacy-provider --max_old_space_size=4096' env-cmd -f .env.test craco start",
+    "dev": "npm start",
+    "backend": "python app_2.py",
     "build": "NODE_OPTIONS='--openssl-legacy-provider --max_old_space_size=4096' craco build && gulp licenses",
     "build:analyze": "NODE_OPTIONS='--openssl-legacy-provider --max_old_space_size=4096' ANALYZE=true craco build",
     "test": "craco test --env=jsdom",
@@ -105,12 +110,14 @@
     "rollback": "bash scripts/rollback-from-local.sh",
     "lint:check": "eslint . --ext=js,jsx;  exit 0",
     "lint:fix": "eslint . --ext=js,jsx --fix;  exit 0",
-    "install:clean": "rm -rf node_modules/ && rm -rf package-lock.json && npm install && npm start"
+    "clean": "rm -rf node_modules/ package-lock.json",
+    "reinstall": "npm run clean && npm install"
   },
   "devDependencies": {
     "@craco/craco": "^7.1.0",
     "ajv": "^8.17.1",
     "autoprefixer": "^10.4.21",
+    "concurrently": "^8.2.2",
     "env-cmd": "^11.0.0",
     "eslint-config-prettier": "8.3.0",
     "eslint-plugin-prettier": "3.4.0",
@@ -119,6 +126,7 @@
     "imagemin": "^9.0.1",
     "imagemin-mozjpeg": "^10.0.0",
     "imagemin-pngquant": "^10.0.0",
+    "kill-port": "^2.0.1",
     "msw": "^2.11.5",
     "postcss": "^8.5.6",
     "prettier": "2.2.1",

src/components/Navbars/HomeNavbar.js

@@ -51,6 +51,7 @@ import SubscriptionButton from '../Subscription/SubscriptionButton';
 import SubscriptionModal from '../Subscription/SubscriptionModal';
 import { CrownIcon, TooltipContent } from '../Subscription/CrownTooltip';
 import InvestmentCalendar from '../../views/Community/components/InvestmentCalendar';
+import { useNavigationEvents } from '../../hooks/useNavigationEvents';
 
 /** 二级导航栏组件 - 显示当前一级菜单下的所有二级菜单项 */
 const SecondaryNav = ({ showCompletenessAlert }) => {
@@ -61,6 +62,9 @@ const SecondaryNav = ({ showCompletenessAlert }) => {
     // ⚠️ 必须在组件顶层调用所有Hooks（不能在JSX中调用）
     const borderColorValue = useColorModeValue('gray.200', 'gray.600');
 
+    // 🎯 初始化导航埋点Hook
+    const navEvents = useNavigationEvents({ component: 'secondary_nav' });
+
     // 定义二级导航结构
     const secondaryNavConfig = {
         '/community': {
@@ -162,7 +166,11 @@ const SecondaryNav = ({ showCompletenessAlert }) => {
                         ) : (
                             <Button
                                 key={index}
-                                onClick={() => navigate(item.path)}
+                                onClick={() => {
+                                    // 🎯 追踪侧边栏菜单点击
+                                    navEvents.trackSidebarMenuClicked(item.label, item.path, 2, false);
+                                    navigate(item.path);
+                                }}
                                 size="sm"
                                 variant="ghost"
                                 bg={isActive ? 'blue.50' : 'transparent'}
@@ -313,6 +321,9 @@ const NavItems = ({ isAuthenticated, user }) => {
     // ⚠️ 必须在组件顶层调用所有Hooks（不能在JSX中调用）
     const contactTextColor = useColorModeValue('gray.500', 'gray.300');
 
+    // 🎯 初始化导航埋点Hook
+    const navEvents = useNavigationEvents({ component: 'top_nav' });
+
     // 辅助函数：判断导航项是否激活
     const isActive = useCallback((paths) => {
         return paths.some(path => location.pathname.includes(path));
@@ -337,7 +348,11 @@ const NavItems = ({ isAuthenticated, user }) => {
                     </MenuButton>
                     <MenuList minW="260px" p={2}>
                         <MenuItem
-                            onClick={() => navigate('/community')}
+                            onClick={() => {
+                                // 🎯 追踪菜单项点击
+                                navEvents.trackMenuItemClicked('事件中心', 'dropdown', '/community');
+                                navigate('/community');
+                            }}
                             borderRadius="md"
                             bg={location.pathname.includes('/community') ? 'blue.50' : 'transparent'}
                             borderLeft={location.pathname.includes('/community') ? '3px solid' : 'none'}
@@ -353,7 +368,11 @@ const NavItems = ({ isAuthenticated, user }) => {
                             </Flex>
                         </MenuItem>
                         <MenuItem
-                            onClick={() => navigate('/concepts')}
+                            onClick={() => {
+                                // 🎯 追踪菜单项点击
+                                navEvents.trackMenuItemClicked('概念中心', 'dropdown', '/concepts');
+                                navigate('/concepts');
+                            }}
                             borderRadius="md"
                             bg={location.pathname.includes('/concepts') ? 'blue.50' : 'transparent'}
                             borderLeft={location.pathname.includes('/concepts') ? '3px solid' : 'none'}
@@ -489,6 +508,9 @@ export default function HomeNavbar() {
     const brandHover = useColorModeValue('blue.600', 'blue.300');
     const toast = useToast();
 
+    // 🎯 初始化导航埋点Hook
+    const navEvents = useNavigationEvents({ component: 'main_navbar' });
+
     // ⚡ 提取 userId 为独立变量，避免 user 对象引用变化导致无限循环
     const userId = user?.id;
     const prevUserIdRef = React.useRef(userId);
@@ -882,7 +904,11 @@ export default function HomeNavbar() {
                                 color={brandText}
                                 cursor="pointer"
                                 _hover={{ color: brandHover }}
-                                onClick={() => navigate('/home')}
+                                onClick={() => {
+                                    // 🎯 追踪Logo点击
+                                    navEvents.trackLogoClicked();
+                                    navigate('/home');
+                                }}
                                 style={{ minWidth: isMobile ? '100px' : '140px' }}
                                 noOfLines={1}
                             >
@@ -912,7 +938,13 @@ export default function HomeNavbar() {
                             <IconButton
                                 aria-label="切换主题"
                                 icon={colorMode === 'light' ? <MoonIcon /> : <SunIcon />}
-                                onClick={toggleColorMode}
+                                onClick={() => {
+                                    // 🎯 追踪主题切换
+                                    const fromTheme = colorMode;
+                                    const toTheme = colorMode === 'light' ? 'dark' : 'light';
+                                    navEvents.trackThemeChanged(fromTheme, toTheme);
+                                    toggleColorMode();
+                                }}
                                 variant="ghost"
                                 size="sm"
                                 minW={{ base: '36px', md: '40px' }}

src/components/Subscription/SubscriptionContent.js

@@ -33,6 +33,7 @@ import {
 import React, { useState, useEffect } from 'react';
 import { logger } from '../../utils/logger';
 import { useAuth } from '../../contexts/AuthContext';
+import { useSubscriptionEvents } from '../../hooks/useSubscriptionEvents';
 
 // Icons
 import {
@@ -54,6 +55,14 @@ export default function SubscriptionContent() {
   // Auth context
   const { user } = useAuth();
 
+  // 🎯 初始化订阅埋点Hook（传入当前订阅信息）
+  const subscriptionEvents = useSubscriptionEvents({
+    currentSubscription: {
+      plan: user?.subscription_plan || 'free',
+      status: user?.subscription_status || 'none'
+    }
+  });
+
   // Chakra color mode
   const textColor = useColorModeValue('gray.700', 'white');
   const borderColor = useColorModeValue('gray.200', 'gray.600');
@@ -161,6 +170,13 @@ export default function SubscriptionContent() {
       return;
     }
 
+    // 🎯 追踪定价方案选择
+    subscriptionEvents.trackPricingPlanSelected(
+      plan.name,
+      selectedCycle,
+      selectedCycle === 'monthly' ? plan.monthly_price : plan.yearly_price
+    );
+
     setSelectedPlan(plan);
     onPaymentModalOpen();
   };
@@ -170,6 +186,17 @@ export default function SubscriptionContent() {
 
     setLoading(true);
     try {
+      const price = selectedCycle === 'monthly' ? selectedPlan.monthly_price : selectedPlan.yearly_price;
+
+      // 🎯 追踪支付发起
+      subscriptionEvents.trackPaymentInitiated({
+        planName: selectedPlan.name,
+        paymentMethod: 'wechat_pay',
+        amount: price,
+        billingCycle: selectedCycle,
+        orderId: null // Will be set after order creation
+      });
+
       const response = await fetch('/api/payment/create-order', {
         method: 'POST',
         headers: {
@@ -204,6 +231,13 @@ export default function SubscriptionContent() {
         throw new Error('网络错误');
       }
     } catch (error) {
+      // 🎯 追踪支付失败
+      subscriptionEvents.trackPaymentFailed({
+        planName: selectedPlan.name,
+        paymentMethod: 'wechat_pay',
+        amount: selectedCycle === 'monthly' ? selectedPlan.monthly_price : selectedPlan.yearly_price
+      }, error.message);
+
       toast({
         title: '创建订单失败',
         description: error.message,
@@ -251,6 +285,26 @@ export default function SubscriptionContent() {
             setAutoCheckInterval(null);
 
             logger.info('SubscriptionContent', '自动检测到支付成功', { orderId });
+
+            // 🎯 追踪支付成功
+            subscriptionEvents.trackPaymentSuccessful({
+              planName: selectedPlan?.name,
+              paymentMethod: 'wechat_pay',
+              amount: paymentOrder?.amount,
+              billingCycle: selectedCycle,
+              orderId: orderId,
+              transactionId: data.transaction_id
+            });
+
+            // 🎯 追踪订阅创建
+            subscriptionEvents.trackSubscriptionCreated({
+              plan: selectedPlan?.name,
+              billingCycle: selectedCycle,
+              amount: paymentOrder?.amount,
+              startDate: new Date().toISOString(),
+              endDate: null // Will be calculated by backend
+            });
+
             toast({
               title: '支付成功！',
               description: '订阅已激活，正在跳转...',

src/hooks/useDashboardEvents.js

@@ -0,0 +1,325 @@
+// src/hooks/useDashboardEvents.js
+// 个人中心（Dashboard/Center）事件追踪 Hook
+
+import { useCallback, useEffect } from 'react';
+import { usePostHogTrack } from './usePostHogRedux';
+import { RETENTION_EVENTS } from '../lib/constants';
+import { logger } from '../utils/logger';
+
+/**
+ * 个人中心事件追踪 Hook
+ * @param {Object} options - 配置选项
+ * @param {string} options.pageType - 页面类型 ('center' | 'profile' | 'settings')
+ * @param {Function} options.navigate - 路由导航函数
+ * @returns {Object} 事件追踪处理函数集合
+ */
+export const useDashboardEvents = ({ pageType = 'center', navigate } = {}) => {
+  const { track } = usePostHogTrack();
+
+  // 🎯 页面浏览事件 - 页面加载时触发
+  useEffect(() => {
+    const eventMap = {
+      'center': RETENTION_EVENTS.DASHBOARD_CENTER_VIEWED,
+      'profile': RETENTION_EVENTS.PROFILE_PAGE_VIEWED,
+      'settings': RETENTION_EVENTS.SETTINGS_PAGE_VIEWED,
+    };
+
+    const eventName = eventMap[pageType] || RETENTION_EVENTS.DASHBOARD_VIEWED;
+
+    track(eventName, {
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', `📊 Dashboard Page Viewed: ${pageType}`);
+  }, [track, pageType]);
+
+  /**
+   * 追踪功能卡片点击
+   * @param {string} cardName - 卡片名称 ('watchlist' | 'following_events' | 'comments' | 'subscription')
+   * @param {Object} cardData - 卡片数据
+   */
+  const trackFunctionCardClicked = useCallback((cardName, cardData = {}) => {
+    if (!cardName) {
+      logger.warn('useDashboardEvents', 'Card name is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.FUNCTION_CARD_CLICKED, {
+      card_name: cardName,
+      data_count: cardData.count || 0,
+      has_data: Boolean(cardData.count && cardData.count > 0),
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '🎴 Function Card Clicked', {
+      cardName,
+      count: cardData.count,
+    });
+  }, [track]);
+
+  /**
+   * 追踪自选股列表查看
+   * @param {number} stockCount - 自选股数量
+   * @param {boolean} hasRealtime - 是否有实时行情
+   */
+  const trackWatchlistViewed = useCallback((stockCount = 0, hasRealtime = false) => {
+    track('Watchlist Viewed', {
+      stock_count: stockCount,
+      has_realtime: hasRealtime,
+      is_empty: stockCount === 0,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '⭐ Watchlist Viewed', {
+      stockCount,
+      hasRealtime,
+    });
+  }, [track]);
+
+  /**
+   * 追踪自选股点击
+   * @param {Object} stock - 股票对象
+   * @param {string} stock.code - 股票代码
+   * @param {string} stock.name - 股票名称
+   * @param {number} position - 在列表中的位置
+   */
+  const trackWatchlistStockClicked = useCallback((stock, position = 0) => {
+    if (!stock || !stock.code) {
+      logger.warn('useDashboardEvents', 'Stock object is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.STOCK_CLICKED, {
+      stock_code: stock.code,
+      stock_name: stock.name || '',
+      source: 'watchlist',
+      position,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '🎯 Watchlist Stock Clicked', {
+      stockCode: stock.code,
+      position,
+    });
+  }, [track]);
+
+  /**
+   * 追踪自选股添加
+   * @param {Object} stock - 股票对象
+   * @param {string} stock.code - 股票代码
+   * @param {string} stock.name - 股票名称
+   * @param {string} source - 来源 ('search' | 'stock_detail' | 'manual')
+   */
+  const trackWatchlistStockAdded = useCallback((stock, source = 'manual') => {
+    if (!stock || !stock.code) {
+      logger.warn('useDashboardEvents', 'Stock object is required');
+      return;
+    }
+
+    track('Watchlist Stock Added', {
+      stock_code: stock.code,
+      stock_name: stock.name || '',
+      source,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '➕ Watchlist Stock Added', {
+      stockCode: stock.code,
+      source,
+    });
+  }, [track]);
+
+  /**
+   * 追踪自选股移除
+   * @param {Object} stock - 股票对象
+   * @param {string} stock.code - 股票代码
+   * @param {string} stock.name - 股票名称
+   */
+  const trackWatchlistStockRemoved = useCallback((stock) => {
+    if (!stock || !stock.code) {
+      logger.warn('useDashboardEvents', 'Stock object is required');
+      return;
+    }
+
+    track('Watchlist Stock Removed', {
+      stock_code: stock.code,
+      stock_name: stock.name || '',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '➖ Watchlist Stock Removed', {
+      stockCode: stock.code,
+    });
+  }, [track]);
+
+  /**
+   * 追踪关注的事件列表查看
+   * @param {number} eventCount - 关注的事件数量
+   */
+  const trackFollowingEventsViewed = useCallback((eventCount = 0) => {
+    track('Following Events Viewed', {
+      event_count: eventCount,
+      is_empty: eventCount === 0,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '📌 Following Events Viewed', {
+      eventCount,
+    });
+  }, [track]);
+
+  /**
+   * 追踪关注的事件点击
+   * @param {Object} event - 事件对象
+   * @param {number} event.id - 事件ID
+   * @param {string} event.title - 事件标题
+   * @param {number} position - 在列表中的位置
+   */
+  const trackFollowingEventClicked = useCallback((event, position = 0) => {
+    if (!event || !event.id) {
+      logger.warn('useDashboardEvents', 'Event object is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.NEWS_ARTICLE_CLICKED, {
+      news_id: event.id,
+      news_title: event.title || '',
+      source: 'following_events',
+      position,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '📰 Following Event Clicked', {
+      eventId: event.id,
+      position,
+    });
+  }, [track]);
+
+  /**
+   * 追踪事件评论列表查看
+   * @param {number} commentCount - 评论数量
+   */
+  const trackCommentsViewed = useCallback((commentCount = 0) => {
+    track('Event Comments Viewed', {
+      comment_count: commentCount,
+      is_empty: commentCount === 0,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '💬 Comments Viewed', {
+      commentCount,
+    });
+  }, [track]);
+
+  /**
+   * 追踪订阅信息查看
+   * @param {Object} subscription - 订阅信息
+   * @param {string} subscription.plan - 订阅计划 ('free' | 'pro' | 'enterprise')
+   * @param {string} subscription.status - 订阅状态 ('active' | 'expired' | 'cancelled')
+   */
+  const trackSubscriptionViewed = useCallback((subscription = {}) => {
+    track(RETENTION_EVENTS.SUBSCRIPTION_PAGE_VIEWED, {
+      subscription_plan: subscription.plan || 'free',
+      subscription_status: subscription.status || 'unknown',
+      is_paid_user: subscription.plan !== 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '💳 Subscription Viewed', {
+      plan: subscription.plan,
+      status: subscription.status,
+    });
+  }, [track]);
+
+  /**
+   * 追踪升级按钮点击
+   * @param {string} currentPlan - 当前计划
+   * @param {string} targetPlan - 目标计划
+   * @param {string} source - 来源位置
+   */
+  const trackUpgradePlanClicked = useCallback((currentPlan = 'free', targetPlan = 'pro', source = 'dashboard') => {
+    track(RETENTION_EVENTS.UPGRADE_PLAN_CLICKED, {
+      current_plan: currentPlan,
+      target_plan: targetPlan,
+      source,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '⬆️ Upgrade Plan Clicked', {
+      currentPlan,
+      targetPlan,
+      source,
+    });
+  }, [track]);
+
+  /**
+   * 追踪个人资料更新
+   * @param {Array<string>} updatedFields - 更新的字段列表
+   */
+  const trackProfileUpdated = useCallback((updatedFields = []) => {
+    track(RETENTION_EVENTS.PROFILE_UPDATED, {
+      updated_fields: updatedFields,
+      field_count: updatedFields.length,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '✏️ Profile Updated', {
+      updatedFields,
+    });
+  }, [track]);
+
+  /**
+   * 追踪设置更改
+   * @param {string} settingName - 设置名称
+   * @param {any} oldValue - 旧值
+   * @param {any} newValue - 新值
+   */
+  const trackSettingChanged = useCallback((settingName, oldValue, newValue) => {
+    if (!settingName) {
+      logger.warn('useDashboardEvents', 'Setting name is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.SETTINGS_CHANGED, {
+      setting_name: settingName,
+      old_value: String(oldValue),
+      new_value: String(newValue),
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useDashboardEvents', '⚙️ Setting Changed', {
+      settingName,
+      oldValue,
+      newValue,
+    });
+  }, [track]);
+
+  return {
+    // 功能卡片事件
+    trackFunctionCardClicked,
+
+    // 自选股相关事件
+    trackWatchlistViewed,
+    trackWatchlistStockClicked,
+    trackWatchlistStockAdded,
+    trackWatchlistStockRemoved,
+
+    // 关注事件相关
+    trackFollowingEventsViewed,
+    trackFollowingEventClicked,
+
+    // 评论相关
+    trackCommentsViewed,
+
+    // 订阅相关
+    trackSubscriptionViewed,
+    trackUpgradePlanClicked,
+
+    // 个人资料和设置
+    trackProfileUpdated,
+    trackSettingChanged,
+  };
+};
+
+export default useDashboardEvents;

src/hooks/useNavigationEvents.js

@@ -0,0 +1,293 @@
+// src/hooks/useNavigationEvents.js
+// 导航和菜单事件追踪 Hook
+
+import { useCallback } from 'react';
+import { usePostHogTrack } from './usePostHogRedux';
+import { RETENTION_EVENTS } from '../lib/constants';
+import { logger } from '../utils/logger';
+
+/**
+ * 导航事件追踪 Hook
+ * @param {Object} options - 配置选项
+ * @param {string} options.component - 组件名称 ('top_nav' | 'sidebar' | 'breadcrumb' | 'footer')
+ * @returns {Object} 事件追踪处理函数集合
+ */
+export const useNavigationEvents = ({ component = 'navigation' } = {}) => {
+  const { track } = usePostHogTrack();
+
+  /**
+   * 追踪顶部导航点击
+   * @param {string} itemName - 导航项名称
+   * @param {string} path - 导航目标路径
+   * @param {string} category - 导航分类 ('main' | 'user' | 'utility')
+   */
+  const trackTopNavClicked = useCallback((itemName, path = '', category = 'main') => {
+    if (!itemName) {
+      logger.warn('useNavigationEvents', 'trackTopNavClicked: itemName is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.TOP_NAV_CLICKED, {
+      item_name: itemName,
+      path,
+      category,
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '🔝 Top Navigation Clicked', {
+      itemName,
+      path,
+      category,
+    });
+  }, [track, component]);
+
+  /**
+   * 追踪侧边栏菜单点击
+   * @param {string} itemName - 菜单项名称
+   * @param {string} path - 目标路径
+   * @param {number} level - 菜单层级 (1=主菜单, 2=子菜单)
+   * @param {boolean} isExpanded - 是否展开状态
+   */
+  const trackSidebarMenuClicked = useCallback((itemName, path = '', level = 1, isExpanded = false) => {
+    if (!itemName) {
+      logger.warn('useNavigationEvents', 'trackSidebarMenuClicked: itemName is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.SIDEBAR_MENU_CLICKED, {
+      item_name: itemName,
+      path,
+      level,
+      is_expanded: isExpanded,
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '📂 Sidebar Menu Clicked', {
+      itemName,
+      path,
+      level,
+      isExpanded,
+    });
+  }, [track, component]);
+
+  /**
+   * 追踪通用菜单项点击
+   * @param {string} itemName - 菜单项名称
+   * @param {string} menuType - 菜单类型 ('dropdown' | 'context' | 'tab')
+   * @param {string} path - 目标路径
+   */
+  const trackMenuItemClicked = useCallback((itemName, menuType = 'dropdown', path = '') => {
+    if (!itemName) {
+      logger.warn('useNavigationEvents', 'trackMenuItemClicked: itemName is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.MENU_ITEM_CLICKED, {
+      item_name: itemName,
+      menu_type: menuType,
+      path,
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '📋 Menu Item Clicked', {
+      itemName,
+      menuType,
+      path,
+    });
+  }, [track, component]);
+
+  /**
+   * 追踪面包屑导航点击
+   * @param {string} itemName - 面包屑项名称
+   * @param {string} path - 目标路径
+   * @param {number} position - 在面包屑中的位置
+   * @param {number} totalItems - 面包屑总项数
+   */
+  const trackBreadcrumbClicked = useCallback((itemName, path = '', position = 0, totalItems = 0) => {
+    if (!itemName) {
+      logger.warn('useNavigationEvents', 'trackBreadcrumbClicked: itemName is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.BREADCRUMB_CLICKED, {
+      item_name: itemName,
+      path,
+      position,
+      total_items: totalItems,
+      is_last: position === totalItems - 1,
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '🍞 Breadcrumb Clicked', {
+      itemName,
+      position,
+      totalItems,
+    });
+  }, [track, component]);
+
+  /**
+   * 追踪Logo点击（返回首页）
+   */
+  const trackLogoClicked = useCallback(() => {
+    track('Logo Clicked', {
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '🏠 Logo Clicked');
+  }, [track, component]);
+
+  /**
+   * 追踪用户菜单展开
+   * @param {Object} user - 用户对象
+   * @param {number} menuItemCount - 菜单项数量
+   */
+  const trackUserMenuOpened = useCallback((user = {}, menuItemCount = 0) => {
+    track('User Menu Opened', {
+      user_id: user.id || null,
+      menu_item_count: menuItemCount,
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '👤 User Menu Opened', {
+      userId: user.id,
+      menuItemCount,
+    });
+  }, [track, component]);
+
+  /**
+   * 追踪通知中心打开
+   * @param {number} unreadCount - 未读通知数量
+   */
+  const trackNotificationCenterOpened = useCallback((unreadCount = 0) => {
+    track('Notification Center Opened', {
+      unread_count: unreadCount,
+      has_unread: unreadCount > 0,
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '🔔 Notification Center Opened', {
+      unreadCount,
+    });
+  }, [track, component]);
+
+  /**
+   * 追踪语言切换
+   * @param {string} fromLanguage - 原语言
+   * @param {string} toLanguage - 目标语言
+   */
+  const trackLanguageChanged = useCallback((fromLanguage, toLanguage) => {
+    if (!fromLanguage || !toLanguage) {
+      logger.warn('useNavigationEvents', 'trackLanguageChanged: both languages are required');
+      return;
+    }
+
+    track('Language Changed', {
+      from_language: fromLanguage,
+      to_language: toLanguage,
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '🌐 Language Changed', {
+      fromLanguage,
+      toLanguage,
+    });
+  }, [track, component]);
+
+  /**
+   * 追踪主题切换（深色/浅色模式）
+   * @param {string} fromTheme - 原主题
+   * @param {string} toTheme - 目标主题
+   */
+  const trackThemeChanged = useCallback((fromTheme, toTheme) => {
+    if (!fromTheme || !toTheme) {
+      logger.warn('useNavigationEvents', 'trackThemeChanged: both themes are required');
+      return;
+    }
+
+    track('Theme Changed', {
+      from_theme: fromTheme,
+      to_theme: toTheme,
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '🎨 Theme Changed', {
+      fromTheme,
+      toTheme,
+    });
+  }, [track, component]);
+
+  /**
+   * 追踪快捷键使用
+   * @param {string} shortcut - 快捷键组合 (如 'Ctrl+K', 'Cmd+/')
+   * @param {string} action - 触发的动作
+   */
+  const trackShortcutUsed = useCallback((shortcut, action = '') => {
+    if (!shortcut) {
+      logger.warn('useNavigationEvents', 'trackShortcutUsed: shortcut is required');
+      return;
+    }
+
+    track('Keyboard Shortcut Used', {
+      shortcut,
+      action,
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '⌨️ Keyboard Shortcut Used', {
+      shortcut,
+      action,
+    });
+  }, [track, component]);
+
+  /**
+   * 追踪返回按钮点击
+   * @param {string} fromPage - 当前页面
+   * @param {string} toPage - 返回到的页面
+   */
+  const trackBackButtonClicked = useCallback((fromPage = '', toPage = '') => {
+    track('Back Button Clicked', {
+      from_page: fromPage,
+      to_page: toPage,
+      component,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useNavigationEvents', '◀️ Back Button Clicked', {
+      fromPage,
+      toPage,
+    });
+  }, [track, component]);
+
+  return {
+    // 导航点击事件
+    trackTopNavClicked,
+    trackSidebarMenuClicked,
+    trackMenuItemClicked,
+    trackBreadcrumbClicked,
+    trackLogoClicked,
+
+    // 用户交互事件
+    trackUserMenuOpened,
+    trackNotificationCenterOpened,
+
+    // 设置变更事件
+    trackLanguageChanged,
+    trackThemeChanged,
+
+    // 其他交互
+    trackShortcutUsed,
+    trackBackButtonClicked,
+  };
+};
+
+export default useNavigationEvents;

src/hooks/useProfileEvents.js

@@ -0,0 +1,334 @@
+// src/hooks/useProfileEvents.js
+// 个人资料和设置事件追踪 Hook
+
+import { useCallback } from 'react';
+import { usePostHogTrack } from './usePostHogRedux';
+import { RETENTION_EVENTS } from '../lib/constants';
+import { logger } from '../utils/logger';
+
+/**
+ * 个人资料和设置事件追踪 Hook
+ * @param {Object} options - 配置选项
+ * @param {string} options.pageType - 页面类型 ('profile' | 'settings' | 'security')
+ * @returns {Object} 事件追踪处理函数集合
+ */
+export const useProfileEvents = ({ pageType = 'profile' } = {}) => {
+  const { track } = usePostHogTrack();
+
+  /**
+   * 追踪个人资料字段编辑开始
+   * @param {string} fieldName - 字段名称 ('nickname' | 'email' | 'phone' | 'avatar' | 'bio')
+   */
+  const trackProfileFieldEditStarted = useCallback((fieldName) => {
+    if (!fieldName) {
+      logger.warn('useProfileEvents', 'trackProfileFieldEditStarted: fieldName is required');
+      return;
+    }
+
+    track('Profile Field Edit Started', {
+      field_name: fieldName,
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', '✏️ Profile Field Edit Started', {
+      fieldName,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪个人资料更新成功
+   * @param {Array<string>} updatedFields - 更新的字段列表
+   * @param {Object} changes - 变更详情
+   */
+  const trackProfileUpdated = useCallback((updatedFields = [], changes = {}) => {
+    if (!updatedFields || updatedFields.length === 0) {
+      logger.warn('useProfileEvents', 'trackProfileUpdated: updatedFields array is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.PROFILE_UPDATED, {
+      updated_fields: updatedFields,
+      field_count: updatedFields.length,
+      changes: changes,
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', '✅ Profile Updated', {
+      updatedFields,
+      fieldCount: updatedFields.length,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪个人资料更新失败
+   * @param {Array<string>} attemptedFields - 尝试更新的字段
+   * @param {string} errorMessage - 错误信息
+   */
+  const trackProfileUpdateFailed = useCallback((attemptedFields = [], errorMessage = '') => {
+    track('Profile Update Failed', {
+      attempted_fields: attemptedFields,
+      error_message: errorMessage,
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', '❌ Profile Update Failed', {
+      attemptedFields,
+      errorMessage,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪头像上传
+   * @param {string} uploadMethod - 上传方式 ('file_upload' | 'url' | 'camera' | 'default_avatar')
+   * @param {number} fileSize - 文件大小（bytes）
+   */
+  const trackAvatarUploaded = useCallback((uploadMethod = 'file_upload', fileSize = 0) => {
+    track('Avatar Uploaded', {
+      upload_method: uploadMethod,
+      file_size: fileSize,
+      file_size_mb: (fileSize / (1024 * 1024)).toFixed(2),
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', '🖼️ Avatar Uploaded', {
+      uploadMethod,
+      fileSize,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪密码更改
+   * @param {boolean} success - 是否成功
+   * @param {string} errorReason - 失败原因
+   */
+  const trackPasswordChanged = useCallback((success = true, errorReason = '') => {
+    track('Password Changed', {
+      success,
+      error_reason: errorReason || null,
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', success ? '🔒 Password Changed Successfully' : '❌ Password Change Failed', {
+      success,
+      errorReason,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪邮箱验证发起
+   * @param {string} email - 邮箱地址
+   */
+  const trackEmailVerificationSent = useCallback((email = '') => {
+    track('Email Verification Sent', {
+      email_provided: Boolean(email),
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', '📧 Email Verification Sent', {
+      emailProvided: Boolean(email),
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪手机号验证发起
+   * @param {string} phone - 手机号
+   */
+  const trackPhoneVerificationSent = useCallback((phone = '') => {
+    track('Phone Verification Sent', {
+      phone_provided: Boolean(phone),
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', '📱 Phone Verification Sent', {
+      phoneProvided: Boolean(phone),
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪账号绑定（微信、邮箱、手机等）
+   * @param {string} accountType - 账号类型 ('wechat' | 'email' | 'phone')
+   * @param {boolean} success - 是否成功
+   */
+  const trackAccountBound = useCallback((accountType, success = true) => {
+    if (!accountType) {
+      logger.warn('useProfileEvents', 'trackAccountBound: accountType is required');
+      return;
+    }
+
+    track('Account Bound', {
+      account_type: accountType,
+      success,
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', success ? '🔗 Account Bound' : '❌ Account Bind Failed', {
+      accountType,
+      success,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪账号解绑
+   * @param {string} accountType - 账号类型
+   * @param {boolean} success - 是否成功
+   */
+  const trackAccountUnbound = useCallback((accountType, success = true) => {
+    if (!accountType) {
+      logger.warn('useProfileEvents', 'trackAccountUnbound: accountType is required');
+      return;
+    }
+
+    track('Account Unbound', {
+      account_type: accountType,
+      success,
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', success ? '🔓 Account Unbound' : '❌ Account Unbind Failed', {
+      accountType,
+      success,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪设置项更改
+   * @param {string} settingName - 设置名称
+   * @param {any} oldValue - 旧值
+   * @param {any} newValue - 新值
+   * @param {string} category - 设置分类 ('notification' | 'privacy' | 'display' | 'advanced')
+   */
+  const trackSettingChanged = useCallback((settingName, oldValue, newValue, category = 'general') => {
+    if (!settingName) {
+      logger.warn('useProfileEvents', 'trackSettingChanged: settingName is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.SETTINGS_CHANGED, {
+      setting_name: settingName,
+      old_value: String(oldValue),
+      new_value: String(newValue),
+      category,
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', '⚙️ Setting Changed', {
+      settingName,
+      oldValue,
+      newValue,
+      category,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪通知偏好更改
+   * @param {Object} preferences - 通知偏好设置
+   * @param {boolean} preferences.email - 邮件通知
+   * @param {boolean} preferences.push - 推送通知
+   * @param {boolean} preferences.sms - 短信通知
+   */
+  const trackNotificationPreferencesChanged = useCallback((preferences = {}) => {
+    track('Notification Preferences Changed', {
+      email_enabled: preferences.email || false,
+      push_enabled: preferences.push || false,
+      sms_enabled: preferences.sms || false,
+      total_enabled: Object.values(preferences).filter(Boolean).length,
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', '🔔 Notification Preferences Changed', {
+      preferences,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪隐私设置更改
+   * @param {string} privacySetting - 隐私设置名称
+   * @param {boolean} isPublic - 是否公开
+   */
+  const trackPrivacySettingChanged = useCallback((privacySetting, isPublic = false) => {
+    if (!privacySetting) {
+      logger.warn('useProfileEvents', 'trackPrivacySettingChanged: privacySetting is required');
+      return;
+    }
+
+    track('Privacy Setting Changed', {
+      privacy_setting: privacySetting,
+      is_public: isPublic,
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', '🔐 Privacy Setting Changed', {
+      privacySetting,
+      isPublic,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  /**
+   * 追踪账号删除请求
+   * @param {string} reason - 删除原因
+   */
+  const trackAccountDeletionRequested = useCallback((reason = '') => {
+    track('Account Deletion Requested', {
+      reason,
+      has_reason: Boolean(reason),
+      page_type: pageType,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useProfileEvents', '🗑️ Account Deletion Requested', {
+      reason,
+      pageType,
+    });
+  }, [track, pageType]);
+
+  return {
+    // 个人资料编辑
+    trackProfileFieldEditStarted,
+    trackProfileUpdated,
+    trackProfileUpdateFailed,
+    trackAvatarUploaded,
+
+    // 安全和验证
+    trackPasswordChanged,
+    trackEmailVerificationSent,
+    trackPhoneVerificationSent,
+
+    // 账号绑定
+    trackAccountBound,
+    trackAccountUnbound,
+
+    // 设置更改
+    trackSettingChanged,
+    trackNotificationPreferencesChanged,
+    trackPrivacySettingChanged,
+
+    // 账号管理
+    trackAccountDeletionRequested,
+  };
+};
+
+export default useProfileEvents;

src/hooks/useSearchEvents.js

@@ -0,0 +1,244 @@
+// src/hooks/useSearchEvents.js
+// 全局搜索功能事件追踪 Hook
+
+import { useCallback } from 'react';
+import { usePostHogTrack } from './usePostHogRedux';
+import { RETENTION_EVENTS } from '../lib/constants';
+import { logger } from '../utils/logger';
+
+/**
+ * 全局搜索事件追踪 Hook
+ * @param {Object} options - 配置选项
+ * @param {string} options.context - 搜索上下文 ('global' | 'stock' | 'news' | 'concept' | 'simulation')
+ * @returns {Object} 事件追踪处理函数集合
+ */
+export const useSearchEvents = ({ context = 'global' } = {}) => {
+  const { track } = usePostHogTrack();
+
+  /**
+   * 追踪搜索开始（聚焦搜索框）
+   * @param {string} placeholder - 搜索框提示文本
+   */
+  const trackSearchInitiated = useCallback((placeholder = '') => {
+    track(RETENTION_EVENTS.SEARCH_INITIATED, {
+      context,
+      placeholder,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSearchEvents', '🔍 Search Initiated', {
+      context,
+      placeholder,
+    });
+  }, [track, context]);
+
+  /**
+   * 追踪搜索查询提交
+   * @param {string} query - 搜索查询词
+   * @param {number} resultCount - 搜索结果数量
+   * @param {Object} filters - 应用的筛选条件
+   */
+  const trackSearchQuerySubmitted = useCallback((query, resultCount = 0, filters = {}) => {
+    if (!query) {
+      logger.warn('useSearchEvents', 'trackSearchQuerySubmitted: query is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.SEARCH_QUERY_SUBMITTED, {
+      query,
+      query_length: query.length,
+      result_count: resultCount,
+      has_results: resultCount > 0,
+      context,
+      filters: filters,
+      filter_count: Object.keys(filters).length,
+      timestamp: new Date().toISOString(),
+    });
+
+    // 如果没有搜索结果，额外追踪
+    if (resultCount === 0) {
+      track(RETENTION_EVENTS.SEARCH_NO_RESULTS, {
+        query,
+        context,
+        filters,
+        timestamp: new Date().toISOString(),
+      });
+
+      logger.debug('useSearchEvents', '❌ Search No Results', {
+        query,
+        context,
+      });
+    } else {
+      logger.debug('useSearchEvents', '✅ Search Query Submitted', {
+        query,
+        resultCount,
+        context,
+      });
+    }
+  }, [track, context]);
+
+  /**
+   * 追踪搜索结果点击
+   * @param {Object} result - 被点击的搜索结果
+   * @param {string} result.type - 结果类型 ('stock' | 'news' | 'concept' | 'event')
+   * @param {string} result.id - 结果ID
+   * @param {string} result.title - 结果标题
+   * @param {number} position - 在搜索结果中的位置
+   * @param {string} query - 搜索查询词
+   */
+  const trackSearchResultClicked = useCallback((result, position = 0, query = '') => {
+    if (!result || !result.type) {
+      logger.warn('useSearchEvents', 'trackSearchResultClicked: result object with type is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.SEARCH_RESULT_CLICKED, {
+      result_type: result.type,
+      result_id: result.id || result.code || '',
+      result_title: result.title || result.name || '',
+      position,
+      query,
+      context,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSearchEvents', '🎯 Search Result Clicked', {
+      type: result.type,
+      id: result.id || result.code,
+      position,
+      context,
+    });
+  }, [track, context]);
+
+  /**
+   * 追踪搜索筛选应用
+   * @param {Object} filters - 应用的筛选条件
+   * @param {string} filterType - 筛选类型 ('sort' | 'category' | 'date_range' | 'price_range')
+   * @param {any} filterValue - 筛选值
+   */
+  const trackSearchFilterApplied = useCallback((filterType, filterValue, filters = {}) => {
+    if (!filterType) {
+      logger.warn('useSearchEvents', 'trackSearchFilterApplied: filterType is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.SEARCH_FILTER_APPLIED, {
+      filter_type: filterType,
+      filter_value: String(filterValue),
+      all_filters: filters,
+      context,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSearchEvents', '🔍 Search Filter Applied', {
+      filterType,
+      filterValue,
+      context,
+    });
+  }, [track, context]);
+
+  /**
+   * 追踪搜索建议点击（自动完成）
+   * @param {string} suggestion - 被点击的搜索建议
+   * @param {number} position - 在建议列表中的位置
+   * @param {string} source - 建议来源 ('history' | 'popular' | 'related')
+   */
+  const trackSearchSuggestionClicked = useCallback((suggestion, position = 0, source = 'popular') => {
+    if (!suggestion) {
+      logger.warn('useSearchEvents', 'trackSearchSuggestionClicked: suggestion is required');
+      return;
+    }
+
+    track('Search Suggestion Clicked', {
+      suggestion,
+      position,
+      source,
+      context,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSearchEvents', '💡 Search Suggestion Clicked', {
+      suggestion,
+      position,
+      source,
+      context,
+    });
+  }, [track, context]);
+
+  /**
+   * 追踪搜索历史查看
+   * @param {number} historyCount - 历史记录数量
+   */
+  const trackSearchHistoryViewed = useCallback((historyCount = 0) => {
+    track('Search History Viewed', {
+      history_count: historyCount,
+      has_history: historyCount > 0,
+      context,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSearchEvents', '📜 Search History Viewed', {
+      historyCount,
+      context,
+    });
+  }, [track, context]);
+
+  /**
+   * 追踪搜索历史清除
+   */
+  const trackSearchHistoryCleared = useCallback(() => {
+    track('Search History Cleared', {
+      context,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSearchEvents', '🗑️ Search History Cleared', {
+      context,
+    });
+  }, [track, context]);
+
+  /**
+   * 追踪热门搜索词点击
+   * @param {string} keyword - 被点击的热门关键词
+   * @param {number} position - 在列表中的位置
+   * @param {number} heatScore - 热度分数
+   */
+  const trackPopularKeywordClicked = useCallback((keyword, position = 0, heatScore = 0) => {
+    if (!keyword) {
+      logger.warn('useSearchEvents', 'trackPopularKeywordClicked: keyword is required');
+      return;
+    }
+
+    track('Popular Keyword Clicked', {
+      keyword,
+      position,
+      heat_score: heatScore,
+      context,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSearchEvents', '🔥 Popular Keyword Clicked', {
+      keyword,
+      position,
+      context,
+    });
+  }, [track, context]);
+
+  return {
+    // 搜索流程事件
+    trackSearchInitiated,
+    trackSearchQuerySubmitted,
+    trackSearchResultClicked,
+
+    // 筛选和建议
+    trackSearchFilterApplied,
+    trackSearchSuggestionClicked,
+
+    // 历史和热门
+    trackSearchHistoryViewed,
+    trackSearchHistoryCleared,
+    trackPopularKeywordClicked,
+  };
+};
+
+export default useSearchEvents;

src/hooks/useSubscriptionEvents.js

@@ -0,0 +1,394 @@
+// src/hooks/useSubscriptionEvents.js
+// 订阅和支付事件追踪 Hook
+
+import { useCallback } from 'react';
+import { usePostHogTrack } from './usePostHogRedux';
+import { RETENTION_EVENTS, REVENUE_EVENTS } from '../lib/constants';
+import { logger } from '../utils/logger';
+
+/**
+ * 订阅和支付事件追踪 Hook
+ * @param {Object} options - 配置选项
+ * @param {Object} options.currentSubscription - 当前订阅信息
+ * @returns {Object} 事件追踪处理函数集合
+ */
+export const useSubscriptionEvents = ({ currentSubscription = null } = {}) => {
+  const { track } = usePostHogTrack();
+
+  /**
+   * 追踪付费墙展示
+   * @param {string} feature - 被限制的功能名称
+   * @param {string} requiredPlan - 需要的订阅计划
+   * @param {string} triggerLocation - 触发位置
+   */
+  const trackPaywallShown = useCallback((feature, requiredPlan = 'pro', triggerLocation = '') => {
+    if (!feature) {
+      logger.warn('useSubscriptionEvents', 'trackPaywallShown: feature is required');
+      return;
+    }
+
+    track(REVENUE_EVENTS.PAYWALL_SHOWN, {
+      feature,
+      required_plan: requiredPlan,
+      current_plan: currentSubscription?.plan || 'free',
+      trigger_location: triggerLocation,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '🚧 Paywall Shown', {
+      feature,
+      requiredPlan,
+      triggerLocation,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪付费墙关闭
+   * @param {string} feature - 功能名称
+   * @param {string} closeMethod - 关闭方式 ('dismiss' | 'upgrade_clicked' | 'back_button')
+   */
+  const trackPaywallDismissed = useCallback((feature, closeMethod = 'dismiss') => {
+    if (!feature) {
+      logger.warn('useSubscriptionEvents', 'trackPaywallDismissed: feature is required');
+      return;
+    }
+
+    track(REVENUE_EVENTS.PAYWALL_DISMISSED, {
+      feature,
+      close_method: closeMethod,
+      current_plan: currentSubscription?.plan || 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '❌ Paywall Dismissed', {
+      feature,
+      closeMethod,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪升级按钮点击
+   * @param {string} targetPlan - 目标订阅计划
+   * @param {string} source - 来源位置
+   * @param {string} feature - 关联的功能（如果从付费墙点击）
+   */
+  const trackUpgradePlanClicked = useCallback((targetPlan = 'pro', source = '', feature = '') => {
+    track(REVENUE_EVENTS.PAYWALL_UPGRADE_CLICKED, {
+      current_plan: currentSubscription?.plan || 'free',
+      target_plan: targetPlan,
+      source,
+      feature: feature || null,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '⬆️ Upgrade Plan Clicked', {
+      currentPlan: currentSubscription?.plan,
+      targetPlan,
+      source,
+      feature,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪订阅页面查看
+   * @param {string} source - 来源
+   */
+  const trackSubscriptionPageViewed = useCallback((source = '') => {
+    track(RETENTION_EVENTS.SUBSCRIPTION_PAGE_VIEWED, {
+      current_plan: currentSubscription?.plan || 'free',
+      subscription_status: currentSubscription?.status || 'unknown',
+      is_paid_user: currentSubscription?.plan && currentSubscription.plan !== 'free',
+      source,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '💳 Subscription Page Viewed', {
+      currentPlan: currentSubscription?.plan,
+      source,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪定价计划查看
+   * @param {string} planName - 计划名称 ('free' | 'pro' | 'enterprise')
+   * @param {number} price - 价格
+   */
+  const trackPricingPlanViewed = useCallback((planName, price = 0) => {
+    if (!planName) {
+      logger.warn('useSubscriptionEvents', 'trackPricingPlanViewed: planName is required');
+      return;
+    }
+
+    track('Pricing Plan Viewed', {
+      plan_name: planName,
+      price,
+      current_plan: currentSubscription?.plan || 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '👀 Pricing Plan Viewed', {
+      planName,
+      price,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪定价计划选择
+   * @param {string} planName - 选择的计划名称
+   * @param {string} billingCycle - 计费周期 ('monthly' | 'yearly')
+   * @param {number} price - 价格
+   */
+  const trackPricingPlanSelected = useCallback((planName, billingCycle = 'monthly', price = 0) => {
+    if (!planName) {
+      logger.warn('useSubscriptionEvents', 'trackPricingPlanSelected: planName is required');
+      return;
+    }
+
+    track('Pricing Plan Selected', {
+      plan_name: planName,
+      billing_cycle: billingCycle,
+      price,
+      current_plan: currentSubscription?.plan || 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '✅ Pricing Plan Selected', {
+      planName,
+      billingCycle,
+      price,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪支付页面查看
+   * @param {string} planName - 购买的计划
+   * @param {number} amount - 支付金额
+   */
+  const trackPaymentPageViewed = useCallback((planName, amount = 0) => {
+    track(REVENUE_EVENTS.PAYMENT_PAGE_VIEWED, {
+      plan_name: planName,
+      amount,
+      current_plan: currentSubscription?.plan || 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '💰 Payment Page Viewed', {
+      planName,
+      amount,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪支付方式选择
+   * @param {string} paymentMethod - 支付方式 ('wechat_pay' | 'alipay' | 'credit_card')
+   * @param {number} amount - 支付金额
+   */
+  const trackPaymentMethodSelected = useCallback((paymentMethod, amount = 0) => {
+    if (!paymentMethod) {
+      logger.warn('useSubscriptionEvents', 'trackPaymentMethodSelected: paymentMethod is required');
+      return;
+    }
+
+    track(REVENUE_EVENTS.PAYMENT_METHOD_SELECTED, {
+      payment_method: paymentMethod,
+      amount,
+      current_plan: currentSubscription?.plan || 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '💳 Payment Method Selected', {
+      paymentMethod,
+      amount,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪支付发起
+   * @param {Object} paymentInfo - 支付信息
+   * @param {string} paymentInfo.planName - 计划名称
+   * @param {string} paymentInfo.paymentMethod - 支付方式
+   * @param {number} paymentInfo.amount - 金额
+   * @param {string} paymentInfo.billingCycle - 计费周期
+   * @param {string} paymentInfo.orderId - 订单ID
+   */
+  const trackPaymentInitiated = useCallback((paymentInfo = {}) => {
+    track(REVENUE_EVENTS.PAYMENT_INITIATED, {
+      plan_name: paymentInfo.planName,
+      payment_method: paymentInfo.paymentMethod,
+      amount: paymentInfo.amount,
+      billing_cycle: paymentInfo.billingCycle,
+      order_id: paymentInfo.orderId,
+      current_plan: currentSubscription?.plan || 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '🚀 Payment Initiated', {
+      planName: paymentInfo.planName,
+      amount: paymentInfo.amount,
+      paymentMethod: paymentInfo.paymentMethod,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪支付成功
+   * @param {Object} paymentInfo - 支付信息
+   */
+  const trackPaymentSuccessful = useCallback((paymentInfo = {}) => {
+    track(REVENUE_EVENTS.PAYMENT_SUCCESSFUL, {
+      plan_name: paymentInfo.planName,
+      payment_method: paymentInfo.paymentMethod,
+      amount: paymentInfo.amount,
+      billing_cycle: paymentInfo.billingCycle,
+      order_id: paymentInfo.orderId,
+      transaction_id: paymentInfo.transactionId,
+      previous_plan: currentSubscription?.plan || 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '✅ Payment Successful', {
+      planName: paymentInfo.planName,
+      amount: paymentInfo.amount,
+      orderId: paymentInfo.orderId,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪支付失败
+   * @param {Object} paymentInfo - 支付信息
+   * @param {string} errorReason - 失败原因
+   */
+  const trackPaymentFailed = useCallback((paymentInfo = {}, errorReason = '') => {
+    track(REVENUE_EVENTS.PAYMENT_FAILED, {
+      plan_name: paymentInfo.planName,
+      payment_method: paymentInfo.paymentMethod,
+      amount: paymentInfo.amount,
+      error_reason: errorReason,
+      order_id: paymentInfo.orderId,
+      current_plan: currentSubscription?.plan || 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '❌ Payment Failed', {
+      planName: paymentInfo.planName,
+      errorReason,
+      orderId: paymentInfo.orderId,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪订阅创建成功
+   * @param {Object} subscription - 订阅信息
+   */
+  const trackSubscriptionCreated = useCallback((subscription = {}) => {
+    track(REVENUE_EVENTS.SUBSCRIPTION_CREATED, {
+      plan_name: subscription.plan,
+      billing_cycle: subscription.billingCycle,
+      amount: subscription.amount,
+      start_date: subscription.startDate,
+      end_date: subscription.endDate,
+      previous_plan: currentSubscription?.plan || 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '🎉 Subscription Created', {
+      plan: subscription.plan,
+      billingCycle: subscription.billingCycle,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪订阅续费
+   * @param {Object} subscription - 订阅信息
+   */
+  const trackSubscriptionRenewed = useCallback((subscription = {}) => {
+    track(REVENUE_EVENTS.SUBSCRIPTION_RENEWED, {
+      plan_name: subscription.plan,
+      amount: subscription.amount,
+      previous_end_date: subscription.previousEndDate,
+      new_end_date: subscription.newEndDate,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '🔄 Subscription Renewed', {
+      plan: subscription.plan,
+      amount: subscription.amount,
+    });
+  }, [track]);
+
+  /**
+   * 追踪订阅取消
+   * @param {string} reason - 取消原因
+   * @param {boolean} cancelImmediately - 是否立即取消
+   */
+  const trackSubscriptionCancelled = useCallback((reason = '', cancelImmediately = false) => {
+    track(REVENUE_EVENTS.SUBSCRIPTION_CANCELLED, {
+      plan_name: currentSubscription?.plan,
+      reason,
+      has_reason: Boolean(reason),
+      cancel_immediately: cancelImmediately,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', '🚫 Subscription Cancelled', {
+      plan: currentSubscription?.plan,
+      reason,
+      cancelImmediately,
+    });
+  }, [track, currentSubscription]);
+
+  /**
+   * 追踪优惠券应用
+   * @param {string} couponCode - 优惠券代码
+   * @param {number} discountAmount - 折扣金额
+   * @param {boolean} success - 是否成功
+   */
+  const trackCouponApplied = useCallback((couponCode, discountAmount = 0, success = true) => {
+    if (!couponCode) {
+      logger.warn('useSubscriptionEvents', 'trackCouponApplied: couponCode is required');
+      return;
+    }
+
+    track('Coupon Applied', {
+      coupon_code: couponCode,
+      discount_amount: discountAmount,
+      success,
+      current_plan: currentSubscription?.plan || 'free',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useSubscriptionEvents', success ? '🎟️ Coupon Applied' : '❌ Coupon Failed', {
+      couponCode,
+      discountAmount,
+      success,
+    });
+  }, [track, currentSubscription]);
+
+  return {
+    // 付费墙事件
+    trackPaywallShown,
+    trackPaywallDismissed,
+    trackUpgradePlanClicked,
+
+    // 订阅页面事件
+    trackSubscriptionPageViewed,
+    trackPricingPlanViewed,
+    trackPricingPlanSelected,
+
+    // 支付流程事件
+    trackPaymentPageViewed,
+    trackPaymentMethodSelected,
+    trackPaymentInitiated,
+    trackPaymentSuccessful,
+    trackPaymentFailed,
+
+    // 订阅管理事件
+    trackSubscriptionCreated,
+    trackSubscriptionRenewed,
+    trackSubscriptionCancelled,
+
+    // 优惠券事件
+    trackCouponApplied,
+  };
+};
+
+export default useSubscriptionEvents;

src/mocks/browser.js

@@ -19,7 +19,10 @@ export async function startMockServiceWorker() {
 
     try {
         await worker.start({
-            // 不显示未拦截的请求警告（可选）
+            // 🎯 智能穿透模式（关键配置）
+            // 'bypass': 未定义 Mock 的请求自动转发到真实后端
+            // 'warn': 未定义的请求会显示警告（调试用）
+            // 'error': 未定义的请求会抛出错误（严格模式）
             onUnhandledRequest: 'bypass',
 
             // 自定义 Service Worker URL（如果需要）
@@ -27,7 +30,7 @@ export async function startMockServiceWorker() {
                 url: '/mockServiceWorker.js',
             },
 
-            // 静默模式（不在控制台打印启动消息）
+            // 是否在控制台显示启动日志和拦截日志 静默模式（不在控制台打印启动消息）
             quiet: false,
         });
 
@@ -36,11 +39,11 @@ export async function startMockServiceWorker() {
             'color: #4CAF50; font-weight: bold; font-size: 14px;'
         );
         console.log(
-            '%c提示: 所有 API 请求将使用本地 Mock 数据',
+            '%c智能穿透模式：已定义 Mock → 返回假数据 | 未定义 Mock → 转发到 ' + (process.env.REACT_APP_API_URL || '真实后端'),
             'color: #FF9800; font-size: 12px;'
         );
         console.log(
-            '%c要禁用 Mock，请设置 REACT_APP_ENABLE_MOCK=false',
+            '%c查看 src/mocks/handlers/ 目录管理 Mock 接口',
             'color: #2196F3; font-size: 12px;'
         );
     } catch (error) {

src/views/Community/components/SearchBox.js

@@ -2,11 +2,21 @@
 import React from 'react';
 import { Card, Input, Radio, Form, Button } from 'antd';
 import { SearchOutlined } from '@ant-design/icons';
+import { useSearchEvents } from '../../../hooks/useSearchEvents';
 
 const SearchBox = ({ onSearch }) => {
     const [form] = Form.useForm();
 
+    // 🎯 初始化搜索埋点Hook
+    const searchEvents = useSearchEvents({ context: 'community' });
+
     const handleSubmit = (values) => {
+        // 🎯 追踪搜索查询提交（在调用onSearch之前）
+        if (values.q) {
+            searchEvents.trackSearchQuerySubmitted(values.q, 0, {
+                search_type: values.search_type || 'topic'
+            });
+        }
         onSearch(values);
     };
 

src/views/Community/hooks/useCommunityEvents.js

@@ -0,0 +1,281 @@
+// src/views/Community/hooks/useCommunityEvents.js
+// 新闻催化分析页面事件追踪 Hook
+
+import { useCallback, useEffect } from 'react';
+import { usePostHogTrack } from '../../../hooks/usePostHogRedux';
+import { RETENTION_EVENTS } from '../../../lib/constants';
+import { logger } from '../../../utils/logger';
+
+/**
+ * 新闻催化分析（Community）事件追踪 Hook
+ * @param {Object} options - 配置选项
+ * @param {Function} options.navigate - 路由导航函数
+ * @returns {Object} 事件追踪处理函数集合
+ */
+export const useCommunityEvents = ({ navigate } = {}) => {
+  const { track } = usePostHogTrack();
+
+  // 🎯 页面浏览事件 - 页面加载时触发
+  useEffect(() => {
+    track(RETENTION_EVENTS.COMMUNITY_PAGE_VIEWED, {
+      timestamp: new Date().toISOString(),
+    });
+    logger.debug('useCommunityEvents', '📰 Community Page Viewed');
+  }, [track]);
+
+  /**
+   * 追踪新闻列表查看
+   * @param {Object} params - 列表参数
+   * @param {number} params.totalCount - 新闻总数
+   * @param {string} params.sortBy - 排序方式 ('new' | 'hot' | 'returns')
+   * @param {string} params.importance - 重要性筛选 ('all' | 'high' | 'medium' | 'low')
+   * @param {string} params.dateRange - 日期范围
+   * @param {string} params.industryFilter - 行业筛选
+   */
+  const trackNewsListViewed = useCallback((params = {}) => {
+    track(RETENTION_EVENTS.NEWS_LIST_VIEWED, {
+      total_count: params.totalCount || 0,
+      sort_by: params.sortBy || 'new',
+      importance_filter: params.importance || 'all',
+      date_range: params.dateRange || 'all',
+      industry_filter: params.industryFilter || 'all',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useCommunityEvents', '📋 News List Viewed', params);
+  }, [track]);
+
+  /**
+   * 追踪新闻文章点击
+   * @param {Object} news - 新闻对象
+   * @param {number} news.id - 新闻ID
+   * @param {string} news.title - 新闻标题
+   * @param {string} news.importance - 重要性等级
+   * @param {number} position - 在列表中的位置
+   * @param {string} source - 点击来源 ('list' | 'search' | 'recommendation')
+   */
+  const trackNewsArticleClicked = useCallback((news, position = 0, source = 'list') => {
+    if (!news || !news.id) {
+      logger.warn('useCommunityEvents', 'trackNewsArticleClicked: news object is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.NEWS_ARTICLE_CLICKED, {
+      news_id: news.id,
+      news_title: news.title || '',
+      importance: news.importance || 'unknown',
+      position,
+      source,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useCommunityEvents', '🖱️ News Article Clicked', {
+      id: news.id,
+      position,
+      source,
+    });
+  }, [track]);
+
+  /**
+   * 追踪新闻详情打开
+   * @param {Object} news - 新闻对象
+   * @param {number} news.id - 新闻ID
+   * @param {string} news.title - 新闻标题
+   * @param {string} news.importance - 重要性等级
+   * @param {string} viewMode - 查看模式 ('modal' | 'page')
+   */
+  const trackNewsDetailOpened = useCallback((news, viewMode = 'modal') => {
+    if (!news || !news.id) {
+      logger.warn('useCommunityEvents', 'trackNewsDetailOpened: news object is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.NEWS_DETAIL_OPENED, {
+      news_id: news.id,
+      news_title: news.title || '',
+      importance: news.importance || 'unknown',
+      view_mode: viewMode,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useCommunityEvents', '📖 News Detail Opened', {
+      id: news.id,
+      viewMode,
+    });
+  }, [track]);
+
+  /**
+   * 追踪新闻标签页切换
+   * @param {string} tabName - 标签名称 ('related_stocks' | 'related_concepts' | 'timeline')
+   * @param {number} newsId - 新闻ID
+   */
+  const trackNewsTabClicked = useCallback((tabName, newsId = null) => {
+    if (!tabName) {
+      logger.warn('useCommunityEvents', 'trackNewsTabClicked: tabName is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.NEWS_TAB_CLICKED, {
+      tab_name: tabName,
+      news_id: newsId,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useCommunityEvents', '📑 News Tab Clicked', {
+      tabName,
+      newsId,
+    });
+  }, [track]);
+
+  /**
+   * 追踪新闻筛选应用
+   * @param {Object} filters - 筛选条件
+   * @param {string} filters.importance - 重要性筛选
+   * @param {string} filters.dateRange - 日期范围
+   * @param {string} filters.industryClassification - 行业分类
+   * @param {string} filters.industryCode - 行业代码
+   */
+  const trackNewsFilterApplied = useCallback((filters = {}) => {
+    track(RETENTION_EVENTS.NEWS_FILTER_APPLIED, {
+      importance: filters.importance || 'all',
+      date_range: filters.dateRange || 'all',
+      industry_classification: filters.industryClassification || 'all',
+      industry_code: filters.industryCode || 'all',
+      filter_count: Object.keys(filters).filter(key => filters[key] && filters[key] !== 'all').length,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useCommunityEvents', '🔍 News Filter Applied', filters);
+  }, [track]);
+
+  /**
+   * 追踪新闻排序方式变更
+   * @param {string} sortBy - 排序方式 ('new' | 'hot' | 'returns')
+   * @param {string} previousSort - 之前的排序方式
+   */
+  const trackNewsSorted = useCallback((sortBy, previousSort = 'new') => {
+    if (!sortBy) {
+      logger.warn('useCommunityEvents', 'trackNewsSorted: sortBy is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.NEWS_SORTED, {
+      sort_by: sortBy,
+      previous_sort: previousSort,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useCommunityEvents', '🔄 News Sorted', {
+      sortBy,
+      previousSort,
+    });
+  }, [track]);
+
+  /**
+   * 追踪搜索事件（新闻搜索）
+   * @param {string} query - 搜索关键词
+   * @param {number} resultCount - 搜索结果数量
+   */
+  const trackNewsSearched = useCallback((query, resultCount = 0) => {
+    if (!query) return;
+
+    track(RETENTION_EVENTS.SEARCH_QUERY_SUBMITTED, {
+      query,
+      result_count: resultCount,
+      has_results: resultCount > 0,
+      context: 'community_news',
+      timestamp: new Date().toISOString(),
+    });
+
+    // 如果没有搜索结果，额外追踪
+    if (resultCount === 0) {
+      track(RETENTION_EVENTS.SEARCH_NO_RESULTS, {
+        query,
+        context: 'community_news',
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    logger.debug('useCommunityEvents', '🔍 News Searched', {
+      query,
+      resultCount,
+    });
+  }, [track]);
+
+  /**
+   * 追踪相关股票点击（从新闻详情）
+   * @param {Object} stock - 股票对象
+   * @param {string} stock.code - 股票代码
+   * @param {string} stock.name - 股票名称
+   * @param {number} newsId - 关联的新闻ID
+   */
+  const trackRelatedStockClicked = useCallback((stock, newsId = null) => {
+    if (!stock || !stock.code) {
+      logger.warn('useCommunityEvents', 'trackRelatedStockClicked: stock object is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.STOCK_CLICKED, {
+      stock_code: stock.code,
+      stock_name: stock.name || '',
+      source: 'news_related_stocks',
+      news_id: newsId,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useCommunityEvents', '🎯 Related Stock Clicked', {
+      stockCode: stock.code,
+      newsId,
+    });
+  }, [track]);
+
+  /**
+   * 追踪相关概念点击（从新闻详情）
+   * @param {Object} concept - 概念对象
+   * @param {string} concept.code - 概念代码
+   * @param {string} concept.name - 概念名称
+   * @param {number} newsId - 关联的新闻ID
+   */
+  const trackRelatedConceptClicked = useCallback((concept, newsId = null) => {
+    if (!concept || !concept.code) {
+      logger.warn('useCommunityEvents', 'trackRelatedConceptClicked: concept object is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.CONCEPT_CLICKED, {
+      concept_code: concept.code,
+      concept_name: concept.name || '',
+      source: 'news_related_concepts',
+      news_id: newsId,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useCommunityEvents', '🏷️ Related Concept Clicked', {
+      conceptCode: concept.code,
+      newsId,
+    });
+  }, [track]);
+
+  return {
+    // 页面级事件
+    trackNewsListViewed,
+
+    // 新闻交互事件
+    trackNewsArticleClicked,
+    trackNewsDetailOpened,
+    trackNewsTabClicked,
+
+    // 筛选和排序事件
+    trackNewsFilterApplied,
+    trackNewsSorted,
+
+    // 搜索事件
+    trackNewsSearched,
+
+    // 关联内容点击事件
+    trackRelatedStockClicked,
+    trackRelatedConceptClicked,
+  };
+};
+
+export default useCommunityEvents;

src/views/Community/index.js

@@ -17,6 +17,7 @@ import EventModals from './components/EventModals';
 // 导入自定义 Hooks
 import { useEventData } from './hooks/useEventData';
 import { useEventFilters } from './hooks/useEventFilters';
+import { useCommunityEvents } from './hooks/useCommunityEvents';
 
 import { logger } from '../../utils/logger';
 import { useNotification } from '../../contexts/NotificationContext';
@@ -28,7 +29,7 @@ import { RETENTION_EVENTS } from '../../lib/constants';
 const Community = () => {
   const navigate = useNavigate();
   const dispatch = useDispatch();
-  const { track } = usePostHogTrack(); // PostHog 追踪
+  const { track } = usePostHogTrack(); // PostHog 追踪（保留用于兼容）
 
   // Redux状态
   const { popularKeywords, hotEvents } = useSelector(state => state.communityData);
@@ -47,6 +48,9 @@ const Community = () => {
   const [selectedEvent, setSelectedEvent] = useState(null);
   const [selectedEventForStock, setSelectedEventForStock] = useState(null);
 
+  // 🎯 初始化Community埋点Hook
+  const communityEvents = useCommunityEvents({ navigate });
+
   // 自定义 Hooks
   const { filters, updateFilters, handlePageChange, handleEventClick, handleViewDetail } = useEventFilters({
     navigate,
@@ -63,13 +67,26 @@ const Community = () => {
   }, [dispatch]);
 
   // 🎯 PostHog 追踪：页面浏览
+  // useEffect(() => {
+  //   track(RETENTION_EVENTS.COMMUNITY_PAGE_VIEWED, {
+  //     timestamp: new Date().toISOString(),
+  //     has_hot_events: hotEvents && hotEvents.length > 0,
+  //     has_keywords: popularKeywords && popularKeywords.length > 0,
+  //   });
+  // }, [track]); // 只在组件挂载时执行一次
+
+  // 🎯 追踪新闻列表查看（当事件列表加载完成后）
   useEffect(() => {
-    track(RETENTION_EVENTS.COMMUNITY_PAGE_VIEWED, {
-      timestamp: new Date().toISOString(),
-      has_hot_events: hotEvents && hotEvents.length > 0,
-      has_keywords: popularKeywords && popularKeywords.length > 0,
-    });
-  }, [track]); // 只在组件挂载时执行一次
+    if (events && events.length > 0 && !loading) {
+      communityEvents.trackNewsListViewed({
+        totalCount: pagination?.total || events.length,
+        sortBy: filters.sort,
+        importance: filters.importance,
+        dateRange: filters.date_range,
+        industryFilter: filters.industry_code,
+      });
+    }
+  }, [events, loading, pagination, filters, communityEvents]);
 
   // ⚡ 首次访问社区时，延迟显示权限引导
   useEffect(() => {

src/views/Dashboard/Center.js

@@ -2,6 +2,7 @@
 import React, { useEffect, useState, useCallback } from 'react';
 import { logger } from '../../utils/logger';
 import { getApiBase } from '../../utils/apiConfig';
+import { useDashboardEvents } from '../../hooks/useDashboardEvents';
 import {
   Box,
   Flex,
@@ -72,6 +73,12 @@ export default function CenterDashboard() {
   const userId = user?.id;
   const prevUserIdRef = React.useRef(userId);
 
+  // 🎯 初始化Dashboard埋点Hook
+  const dashboardEvents = useDashboardEvents({
+    pageType: 'center',
+    navigate
+  });
+
   // 颜色主题
   const textColor = useColorModeValue('gray.700', 'white');
   const borderColor = useColorModeValue('gray.200', 'gray.600');
@@ -101,14 +108,33 @@ export default function CenterDashboard() {
       const je = await e.json();
       const jc = await c.json();
       if (jw.success) {
-        setWatchlist(Array.isArray(jw.data) ? jw.data : []);
+        const watchlistData = Array.isArray(jw.data) ? jw.data : [];
+        setWatchlist(watchlistData);
+
+        // 🎯 追踪自选股列表查看
+        if (watchlistData.length > 0) {
+          dashboardEvents.trackWatchlistViewed(watchlistData.length, true);
+        }
+
         // 加载实时行情
         if (jw.data && jw.data.length > 0) {
           loadRealtimeQuotes();
         }
       }
-      if (je.success) setFollowingEvents(Array.isArray(je.data) ? je.data : []);
-      if (jc.success) setEventComments(Array.isArray(jc.data) ? jc.data : []);
+      if (je.success) {
+        const eventsData = Array.isArray(je.data) ? je.data : [];
+        setFollowingEvents(eventsData);
+
+        // 🎯 追踪关注的事件列表查看
+        dashboardEvents.trackFollowingEventsViewed(eventsData.length);
+      }
+      if (jc.success) {
+        const commentsData = Array.isArray(jc.data) ? jc.data : [];
+        setEventComments(commentsData);
+
+        // 🎯 追踪评论列表查看
+        dashboardEvents.trackCommentsViewed(commentsData.length);
+      }
     } catch (err) {
       logger.error('Center', 'loadData', err, {
         userId,

src/views/EventDetail/hooks/useEventDetailEvents.js

@@ -0,0 +1,346 @@
+// src/views/EventDetail/hooks/useEventDetailEvents.js
+// 事件详情页面事件追踪 Hook
+
+import { useCallback, useEffect } from 'react';
+import { usePostHogTrack } from '../../../hooks/usePostHogRedux';
+import { RETENTION_EVENTS } from '../../../lib/constants';
+import { logger } from '../../../utils/logger';
+
+/**
+ * 事件详情（EventDetail）事件追踪 Hook
+ * @param {Object} options - 配置选项
+ * @param {Object} options.event - 事件对象
+ * @param {number} options.event.id - 事件ID
+ * @param {string} options.event.title - 事件标题
+ * @param {string} options.event.importance - 重要性等级
+ * @param {Function} options.navigate - 路由导航函数
+ * @returns {Object} 事件追踪处理函数集合
+ */
+export const useEventDetailEvents = ({ event, navigate } = {}) => {
+  const { track } = usePostHogTrack();
+
+  // 🎯 页面浏览事件 - 页面加载时触发
+  useEffect(() => {
+    if (!event || !event.id) {
+      logger.warn('useEventDetailEvents', 'Event object is required for page view tracking');
+      return;
+    }
+
+    track(RETENTION_EVENTS.EVENT_DETAIL_VIEWED, {
+      event_id: event.id,
+      event_title: event.title || '',
+      importance: event.importance || 'unknown',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', '📄 Event Detail Page Viewed', {
+      eventId: event.id,
+    });
+  }, [track, event]);
+
+  /**
+   * 追踪事件分析内容查看
+   * @param {Object} analysisData - 分析数据
+   * @param {string} analysisData.type - 分析类型 ('market_impact' | 'stock_correlation' | 'timeline')
+   * @param {number} analysisData.relatedStockCount - 相关股票数量
+   * @param {number} analysisData.timelineEventCount - 时间线事件数量
+   */
+  const trackEventAnalysisViewed = useCallback((analysisData = {}) => {
+    if (!event || !event.id) {
+      logger.warn('useEventDetailEvents', 'Event object is required for analysis tracking');
+      return;
+    }
+
+    track(RETENTION_EVENTS.EVENT_ANALYSIS_VIEWED, {
+      event_id: event.id,
+      analysis_type: analysisData.type || 'overview',
+      related_stock_count: analysisData.relatedStockCount || 0,
+      timeline_event_count: analysisData.timelineEventCount || 0,
+      has_market_impact: Boolean(analysisData.marketImpact),
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', '📊 Event Analysis Viewed', {
+      eventId: event.id,
+      analysisType: analysisData.type,
+    });
+  }, [track, event]);
+
+  /**
+   * 追踪事件时间线点击
+   * @param {Object} timelineItem - 时间线项目
+   * @param {string} timelineItem.id - 时间线项目ID
+   * @param {string} timelineItem.date - 时间线日期
+   * @param {string} timelineItem.title - 时间线标题
+   * @param {number} position - 在时间线中的位置
+   */
+  const trackEventTimelineClicked = useCallback((timelineItem, position = 0) => {
+    if (!timelineItem || !timelineItem.id) {
+      logger.warn('useEventDetailEvents', 'Timeline item is required');
+      return;
+    }
+
+    if (!event || !event.id) {
+      logger.warn('useEventDetailEvents', 'Event object is required for timeline tracking');
+      return;
+    }
+
+    track(RETENTION_EVENTS.EVENT_TIMELINE_CLICKED, {
+      event_id: event.id,
+      timeline_item_id: timelineItem.id,
+      timeline_date: timelineItem.date || '',
+      timeline_title: timelineItem.title || '',
+      position,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', '⏰ Event Timeline Clicked', {
+      eventId: event.id,
+      timelineItemId: timelineItem.id,
+      position,
+    });
+  }, [track, event]);
+
+  /**
+   * 追踪相关股票点击（从事件详情）
+   * @param {Object} stock - 股票对象
+   * @param {string} stock.code - 股票代码
+   * @param {string} stock.name - 股票名称
+   * @param {number} position - 在列表中的位置
+   */
+  const trackRelatedStockClicked = useCallback((stock, position = 0) => {
+    if (!stock || !stock.code) {
+      logger.warn('useEventDetailEvents', 'Stock object is required');
+      return;
+    }
+
+    if (!event || !event.id) {
+      logger.warn('useEventDetailEvents', 'Event object is required for stock tracking');
+      return;
+    }
+
+    track(RETENTION_EVENTS.STOCK_CLICKED, {
+      stock_code: stock.code,
+      stock_name: stock.name || '',
+      source: 'event_detail_related_stocks',
+      event_id: event.id,
+      position,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', '🎯 Related Stock Clicked', {
+      stockCode: stock.code,
+      eventId: event.id,
+      position,
+    });
+  }, [track, event]);
+
+  /**
+   * 追踪相关概念点击（从事件详情）
+   * @param {Object} concept - 概念对象
+   * @param {string} concept.code - 概念代码
+   * @param {string} concept.name - 概念名称
+   * @param {number} position - 在列表中的位置
+   */
+  const trackRelatedConceptClicked = useCallback((concept, position = 0) => {
+    if (!concept || !concept.code) {
+      logger.warn('useEventDetailEvents', 'Concept object is required');
+      return;
+    }
+
+    if (!event || !event.id) {
+      logger.warn('useEventDetailEvents', 'Event object is required for concept tracking');
+      return;
+    }
+
+    track(RETENTION_EVENTS.CONCEPT_CLICKED, {
+      concept_code: concept.code,
+      concept_name: concept.name || '',
+      source: 'event_detail_related_concepts',
+      event_id: event.id,
+      position,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', '🏷️ Related Concept Clicked', {
+      conceptCode: concept.code,
+      eventId: event.id,
+      position,
+    });
+  }, [track, event]);
+
+  /**
+   * 追踪标签页切换
+   * @param {string} tabName - 标签名称 ('overview' | 'related_stocks' | 'related_concepts' | 'timeline')
+   */
+  const trackTabClicked = useCallback((tabName) => {
+    if (!tabName) {
+      logger.warn('useEventDetailEvents', 'Tab name is required');
+      return;
+    }
+
+    if (!event || !event.id) {
+      logger.warn('useEventDetailEvents', 'Event object is required for tab tracking');
+      return;
+    }
+
+    track(RETENTION_EVENTS.NEWS_TAB_CLICKED, {
+      tab_name: tabName,
+      event_id: event.id,
+      context: 'event_detail',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', '📑 Tab Clicked', {
+      tabName,
+      eventId: event.id,
+    });
+  }, [track, event]);
+
+  /**
+   * 追踪事件收藏/取消收藏
+   * @param {boolean} isFavorited - 是否收藏
+   */
+  const trackEventFavoriteToggled = useCallback((isFavorited) => {
+    if (!event || !event.id) {
+      logger.warn('useEventDetailEvents', 'Event object is required for favorite tracking');
+      return;
+    }
+
+    const eventName = isFavorited ? 'Event Favorited' : 'Event Unfavorited';
+
+    track(eventName, {
+      event_id: event.id,
+      event_title: event.title || '',
+      action: isFavorited ? 'add' : 'remove',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', `${isFavorited ? '⭐' : '☆'} Event Favorite Toggled`, {
+      eventId: event.id,
+      isFavorited,
+    });
+  }, [track, event]);
+
+  /**
+   * 追踪事件分享
+   * @param {string} shareMethod - 分享方式 ('wechat' | 'link' | 'qrcode')
+   */
+  const trackEventShared = useCallback((shareMethod) => {
+    if (!shareMethod) {
+      logger.warn('useEventDetailEvents', 'Share method is required');
+      return;
+    }
+
+    if (!event || !event.id) {
+      logger.warn('useEventDetailEvents', 'Event object is required for share tracking');
+      return;
+    }
+
+    track(RETENTION_EVENTS.CONTENT_SHARED, {
+      content_type: 'event',
+      content_id: event.id,
+      content_title: event.title || '',
+      share_method: shareMethod,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', '📤 Event Shared', {
+      eventId: event.id,
+      shareMethod,
+    });
+  }, [track, event]);
+
+  /**
+   * 追踪评论点赞/取消点赞
+   * @param {string} commentId - 评论ID
+   * @param {boolean} isLiked - 是否点赞
+   */
+  const trackCommentLiked = useCallback((commentId, isLiked) => {
+    if (!commentId) {
+      logger.warn('useEventDetailEvents', 'Comment ID is required');
+      return;
+    }
+
+    track(isLiked ? 'Comment Liked' : 'Comment Unliked', {
+      comment_id: commentId,
+      event_id: event?.id,
+      action: isLiked ? 'like' : 'unlike',
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', `${isLiked ? '❤️' : '🤍'} Comment ${isLiked ? 'Liked' : 'Unliked'}`, {
+      commentId,
+      eventId: event?.id,
+    });
+  }, [track, event]);
+
+  /**
+   * 追踪添加评论
+   * @param {string} commentId - 评论ID
+   * @param {number} contentLength - 评论内容长度
+   */
+  const trackCommentAdded = useCallback((commentId, contentLength = 0) => {
+    if (!event || !event.id) {
+      logger.warn('useEventDetailEvents', 'Event object is required for comment tracking');
+      return;
+    }
+
+    track('Comment Added', {
+      comment_id: commentId,
+      event_id: event.id,
+      content_length: contentLength,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', '💬 Comment Added', {
+      commentId,
+      eventId: event.id,
+      contentLength,
+    });
+  }, [track, event]);
+
+  /**
+   * 追踪删除评论
+   * @param {string} commentId - 评论ID
+   */
+  const trackCommentDeleted = useCallback((commentId) => {
+    if (!commentId) {
+      logger.warn('useEventDetailEvents', 'Comment ID is required');
+      return;
+    }
+
+    track('Comment Deleted', {
+      comment_id: commentId,
+      event_id: event?.id,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useEventDetailEvents', '🗑️ Comment Deleted', {
+      commentId,
+      eventId: event?.id,
+    });
+  }, [track, event]);
+
+  return {
+    // 页面级事件
+    trackEventAnalysisViewed,
+
+    // 交互事件
+    trackEventTimelineClicked,
+    trackRelatedStockClicked,
+    trackRelatedConceptClicked,
+    trackTabClicked,
+
+    // 用户行为事件
+    trackEventFavoriteToggled,
+    trackEventShared,
+
+    // 社交互动事件
+    trackCommentLiked,
+    trackCommentAdded,
+    trackCommentDeleted,
+  };
+};
+
+export default useEventDetailEvents;

src/views/EventDetail/index.js

@@ -75,6 +75,7 @@ import TransmissionChainAnalysis from './components/TransmissionChainAnalysis';
 import { eventService } from '../../services/eventService';
 import { debugEventService } from '../../utils/debugEventService';
 import { logger } from '../../utils/logger';
+import { useEventDetailEvents } from './hooks/useEventDetailEvents';
 
 // 临时调试代码 - 生产环境测试后请删除
 if (typeof window !== 'undefined') {
@@ -110,7 +111,7 @@ const StatCard = ({ icon, label, value, color }) => {
 };
 
 // 帖子组件
-const PostItem = ({ post, onRefresh }) => {
+const PostItem = ({ post, onRefresh, eventEvents }) => {
     const [showComments, setShowComments] = useState(false);
     const [comments, setComments] = useState([]);
     const [newComment, setNewComment] = useState('');
@@ -145,8 +146,14 @@ const PostItem = ({ post, onRefresh }) => {
         try {
             const result = await eventService.likePost(post.id);
             if (result.success) {
-                setLiked(result.liked);
+                const newLikedState = result.liked;
+                setLiked(newLikedState);
                 setLikesCount(result.likes_count);
+
+                // 🎯 追踪评论点赞
+                if (eventEvents && eventEvents.trackCommentLiked) {
+                    eventEvents.trackCommentLiked(post.id, newLikedState);
+                }
             }
         } catch (error) {
             toast({
@@ -166,6 +173,14 @@ const PostItem = ({ post, onRefresh }) => {
             });
 
             if (result.success) {
+                // 🎯 追踪添加评论
+                if (eventEvents && eventEvents.trackCommentAdded) {
+                    eventEvents.trackCommentAdded(
+                        result.data?.id || post.id,
+                        newComment.length
+                    );
+                }
+
                 toast({
                     title: '评论发表成功',
                     status: 'success',
@@ -192,6 +207,11 @@ const PostItem = ({ post, onRefresh }) => {
             try {
                 const result = await eventService.deletePost(post.id);
                 if (result.success) {
+                    // 🎯 追踪删除评论
+                    if (eventEvents && eventEvents.trackCommentDeleted) {
+                        eventEvents.trackCommentDeleted(post.id);
+                    }
+
                     toast({
                         title: '删除成功',
                         status: 'success',
@@ -348,6 +368,15 @@ const EventDetail = () => {
     const [postsLoading, setPostsLoading] = useState(false);
     const [error, setError] = useState(null);
     const [activeTab, setActiveTab] = useState(0);
+
+    // 🎯 初始化事件详情埋点Hook（传入event对象）
+    const eventEvents = useEventDetailEvents({
+      event: eventData ? {
+        id: eventData.id,
+        title: eventData.title,
+        importance: eventData.importance
+      } : null
+    });
     const [newPostContent, setNewPostContent] = useState('');
     const [newPostTitle, setNewPostTitle] = useState('');
     const [submitting, setSubmitting] = useState(false);
@@ -380,9 +409,11 @@ const EventDetail = () => {
             setEventData(eventResponse.data);
 
             // 总是尝试加载相关股票（权限在组件内部检查）
+            let stocksCount = 0;
             try {
                 const stocksResponse = await eventService.getRelatedStocks(actualEventId);
                 setRelatedStocks(stocksResponse.data || []);
+                stocksCount = stocksResponse.data?.length || 0;
             } catch (e) {
                 logger.warn('EventDetail', '加载相关股票失败', { eventId: actualEventId, error: e.message });
                 setRelatedStocks([]);
@@ -399,13 +430,25 @@ const EventDetail = () => {
             }
 
             // 历史事件所有用户都可以访问，但免费用户只看到前2条
+            let timelineCount = 0;
             try {
                 const eventsResponse = await eventService.getHistoricalEvents(actualEventId);
                 setHistoricalEvents(eventsResponse.data || []);
+                timelineCount = eventsResponse.data?.length || 0;
             } catch (e) {
                 logger.warn('EventDetail', '历史事件加载失败', { eventId: actualEventId, error: e.message });
             }
 
+            // 🎯 追踪事件分析内容查看（数据加载完成后）
+            if (eventResponse.data && eventEvents) {
+                eventEvents.trackEventAnalysisViewed({
+                    type: 'overview',
+                    relatedStockCount: stocksCount,
+                    timelineEventCount: timelineCount,
+                    marketImpact: eventResponse.data.market_impact
+                });
+            }
+
         } catch (err) {
             logger.error('EventDetail', 'loadEventData', err, { eventId: actualEventId });
             setError(err.message || '加载事件数据失败');
@@ -800,7 +843,12 @@ const EventDetail = () => {
                                             </VStack>
                                         ) : posts.length > 0 ? (
                                             posts.map((post) => (
-                                                <PostItem key={post.id} post={post} onRefresh={loadPosts} />
+                                                <PostItem
+                                                    key={post.id}
+                                                    post={post}
+                                                    onRefresh={loadPosts}
+                                                    eventEvents={eventEvents}
+                                                />
                                             ))
                                         ) : (
                                             <Box

src/views/Profile/ProfilePage.js

@@ -44,11 +44,15 @@ import {
 import { EditIcon, CheckIcon, CloseIcon, AddIcon } from '@chakra-ui/icons';
 import { useAuth } from '../../contexts/AuthContext';
 import { logger } from '../../utils/logger';
+import { useProfileEvents } from '../../hooks/useProfileEvents';
 
 export default function ProfilePage() {
     const { user, updateUser } = useAuth();
     const [isEditing, setIsEditing] = useState(false);
     const [isLoading, setIsLoading] = useState(false);
+
+    // 🎯 初始化个人资料埋点Hook
+    const profileEvents = useProfileEvents({ pageType: 'profile' });
     const [newTag, setNewTag] = useState('');
     const { isOpen, onOpen, onClose } = useDisclosure();
     const fileInputRef = useRef();
@@ -95,6 +99,12 @@ export default function ProfilePage() {
             updateUser(updatedData);
             setIsEditing(false);
 
+            // 🎯 追踪个人资料更新成功
+            const updatedFields = Object.keys(formData).filter(
+                key => user?.[key] !== formData[key]
+            );
+            profileEvents.trackProfileUpdated(updatedFields, updatedData);
+
             // ✅ 保留关键操作提示
             toast({
                 title: "个人资料更新成功",
@@ -105,6 +115,10 @@ export default function ProfilePage() {
         } catch (error) {
             logger.error('ProfilePage', 'handleSaveProfile', error, { userId: user?.id });
 
+            // 🎯 追踪个人资料更新失败
+            const attemptedFields = Object.keys(formData);
+            profileEvents.trackProfileUpdateFailed(attemptedFields, error.message);
+
             // ✅ 保留错误提示
             toast({
                 title: "更新失败",
@@ -128,6 +142,9 @@ export default function ProfilePage() {
             reader.onload = (e) => {
                 updateUser({ avatar_url: e.target.result });
 
+                // 🎯 追踪头像上传
+                profileEvents.trackAvatarUploaded('file_upload', file.size);
+
                 // ✅ 保留关键操作提示
                 toast({
                     title: "头像更新成功",

src/views/Settings/SettingsPage.js

@@ -59,12 +59,16 @@ import { FaWeixin, FaMobile, FaEnvelope } from 'react-icons/fa';
 import { useAuth } from '../../contexts/AuthContext';
 import { getApiBase } from '../../utils/apiConfig';
 import { logger } from '../../utils/logger';
+import { useProfileEvents } from '../../hooks/useProfileEvents';
 
 export default function SettingsPage() {
     const { user, updateUser, logout } = useAuth();
     const { colorMode, toggleColorMode } = useColorMode();
     const toast = useToast();
 
+    // 🎯 初始化设置页面埋点Hook
+    const profileEvents = useProfileEvents({ pageType: 'settings' });
+
     // 模态框状态
     const { isOpen: isPasswordOpen, onOpen: onPasswordOpen, onClose: onPasswordClose } = useDisclosure();
     const { isOpen: isPhoneOpen, onOpen: onPhoneOpen, onClose: onPhoneClose } = useDisclosure();
@@ -209,9 +213,12 @@ export default function SettingsPage() {
 
             if (response.ok && data.success) {
                 const isFirstSet = passwordStatus.needsFirstTimeSetup;
-                
+
+                // 🎯 追踪密码修改成功
+                profileEvents.trackPasswordChanged(true);
+
                 toast({
-                    title: isFirstSet ? "密码设置成功" : "密码修改成功", 
+                    title: isFirstSet ? "密码设置成功" : "密码修改成功",
                     description: isFirstSet ? "您现在可以使用手机号+密码登录了" : "请重新登录",
                     status: "success",
                     duration: 3000,
@@ -220,7 +227,7 @@ export default function SettingsPage() {
 
                 setPasswordForm({ currentPassword: '', newPassword: '', confirmPassword: '' });
                 onPasswordClose();
-                
+
                 // 刷新密码状态
                 fetchPasswordStatus();
 
@@ -234,6 +241,9 @@ export default function SettingsPage() {
                 throw new Error(data.error || '密码修改失败');
             }
         } catch (error) {
+            // 🎯 追踪密码修改失败
+            profileEvents.trackPasswordChanged(false, error.message);
+
             toast({
                 title: "修改失败",
                 description: error.message,
@@ -364,6 +374,9 @@ export default function SettingsPage() {
                 email_confirmed: data.user.email_confirmed
             });
 
+            // 🎯 追踪邮箱绑定成功
+            profileEvents.trackAccountBound('email', true);
+
             toast({
                 title: "邮箱绑定成功",
                 status: "success",
@@ -374,6 +387,9 @@ export default function SettingsPage() {
             setEmailForm({ email: '', verificationCode: '' });
             onEmailClose();
         } catch (error) {
+            // 🎯 追踪邮箱绑定失败
+            profileEvents.trackAccountBound('email', false);
+
             toast({
                 title: "绑定失败",
                 description: error.message,
@@ -397,6 +413,13 @@ export default function SettingsPage() {
 
             updateUser(notifications);
 
+            // 🎯 追踪通知偏好更改
+            profileEvents.trackNotificationPreferencesChanged({
+                email: notifications.email_notifications,
+                push: notifications.system_updates,
+                sms: notifications.sms_notifications
+            });
+
             // ❌ 移除设置保存成功toast
             logger.info('SettingsPage', '通知设置已保存');
         } catch (error) {

src/views/TradingSimulation/components/AccountOverview.js

@@ -28,7 +28,9 @@ import { FiTrendingUp, FiTrendingDown, FiDollarSign, FiPieChart, FiTarget, FiAct
 import DonutChart from '../../../components/Charts/DonutChart';
 import IconBox from '../../../components/Icons/IconBox';
 
-export default function AccountOverview({ account }) {
+export default function AccountOverview({ account, tradingEvents }) {
+  // tradingEvents 已传递,可用于将来添加的账户重置等功能
+  // 例如: tradingEvents.trackAccountReset(beforeResetData)
   const textColor = useColorModeValue('gray.700', 'white');
   const secondaryColor = useColorModeValue('gray.500', 'gray.400');
   const profitColor = account?.totalProfit >= 0 ? 'green.500' : 'red.500';

src/views/TradingSimulation/components/PositionsList.js

@@ -64,20 +64,38 @@ const calculateChange = (currentPrice, avgPrice) => {
   return { change, changePercent };
 };
 
-export default function PositionsList({ positions, account, onSellStock }) {
+export default function PositionsList({ positions, account, onSellStock, tradingEvents }) {
   const [selectedPosition, setSelectedPosition] = useState(null);
   const [sellQuantity, setSellQuantity] = useState(0);
   const [orderType, setOrderType] = useState('MARKET');
   const [limitPrice, setLimitPrice] = useState('');
   const [isLoading, setIsLoading] = useState(false);
-  
+  const [hasTracked, setHasTracked] = React.useState(false);
+
   const { isOpen, onOpen, onClose } = useDisclosure();
   const toast = useToast();
-  
+
   const cardBg = useColorModeValue('white', 'gray.800');
   const textColor = useColorModeValue('gray.700', 'white');
   const secondaryColor = useColorModeValue('gray.500', 'gray.400');
 
+  // 🎯 追踪持仓查看 - 组件加载时触发一次
+  React.useEffect(() => {
+    if (!hasTracked && positions && positions.length > 0 && tradingEvents && tradingEvents.trackSimulationHoldingsViewed) {
+      const totalMarketValue = positions.reduce((sum, pos) => sum + (pos.marketValue || pos.quantity * pos.currentPrice || 0), 0);
+      const totalCost = positions.reduce((sum, pos) => sum + (pos.totalCost || pos.quantity * pos.avgPrice || 0), 0);
+      const totalProfit = positions.reduce((sum, pos) => sum + (pos.profit || 0), 0);
+
+      tradingEvents.trackSimulationHoldingsViewed({
+        count: positions.length,
+        totalValue: totalMarketValue,
+        totalCost,
+        profitLoss: totalProfit,
+      });
+      setHasTracked(true);
+    }
+  }, [positions, tradingEvents, hasTracked]);
+
   // 格式化货币
   const formatCurrency = (amount) => {
     return new Intl.NumberFormat('zh-CN', {
@@ -102,6 +120,17 @@ export default function PositionsList({ positions, account, onSellStock }) {
     setSelectedPosition(position);
     setSellQuantity(position.availableQuantity); // 默认全部可卖数量
     setLimitPrice(position.currentPrice?.toString() || position.avgPrice.toString());
+
+    // 🎯 追踪卖出按钮点击
+    if (tradingEvents && tradingEvents.trackSellButtonClicked) {
+      tradingEvents.trackSellButtonClicked({
+        stockCode: position.stockCode,
+        stockName: position.stockName,
+        quantity: position.quantity,
+        profitLoss: position.profit || 0,
+      }, 'holdings');
+    }
+
     onOpen();
   };
 
@@ -110,6 +139,8 @@ export default function PositionsList({ positions, account, onSellStock }) {
     if (!selectedPosition || sellQuantity <= 0) return;
 
     setIsLoading(true);
+    const price = orderType === 'LIMIT' ? parseFloat(limitPrice) : selectedPosition.currentPrice || selectedPosition.avgPrice;
+
     try {
       const result = await onSellStock(
         selectedPosition.stockCode,
@@ -126,6 +157,20 @@ export default function PositionsList({ positions, account, onSellStock }) {
           orderType,
           orderId: result.orderId
         });
+
+        // 🎯 追踪卖出成功
+        if (tradingEvents && tradingEvents.trackSimulationOrderPlaced) {
+          tradingEvents.trackSimulationOrderPlaced({
+            stockCode: selectedPosition.stockCode,
+            stockName: selectedPosition.stockName,
+            direction: 'sell',
+            quantity: sellQuantity,
+            price,
+            orderType,
+            success: true,
+          });
+        }
+
         toast({
           title: '卖出成功',
           description: `已卖出 ${selectedPosition.stockName} ${sellQuantity} 股`,
@@ -142,6 +187,21 @@ export default function PositionsList({ positions, account, onSellStock }) {
         quantity: sellQuantity,
         orderType
       });
+
+      // 🎯 追踪卖出失败
+      if (tradingEvents && tradingEvents.trackSimulationOrderPlaced) {
+        tradingEvents.trackSimulationOrderPlaced({
+          stockCode: selectedPosition.stockCode,
+          stockName: selectedPosition.stockName,
+          direction: 'sell',
+          quantity: sellQuantity,
+          price,
+          orderType,
+          success: false,
+          errorMessage: error.message,
+        });
+      }
+
       toast({
         title: '卖出失败',
         description: error.message,

src/views/TradingSimulation/components/TradingHistory.js

@@ -34,18 +34,31 @@ import {
 import { FiSearch, FiFilter, FiClock, FiTrendingUp, FiTrendingDown } from 'react-icons/fi';
 import { logger } from '../../../utils/logger';
 
-export default function TradingHistory({ history, onCancelOrder }) {
+export default function TradingHistory({ history, onCancelOrder, tradingEvents }) {
   const [filterType, setFilterType] = useState('ALL'); // ALL, BUY, SELL
   const [filterStatus, setFilterStatus] = useState('ALL'); // ALL, FILLED, PENDING, CANCELLED
   const [searchTerm, setSearchTerm] = useState('');
   const [sortBy, setSortBy] = useState('createdAt'); // createdAt, stockCode, amount
   const [sortOrder, setSortOrder] = useState('desc'); // desc, asc
-  
+  const [hasTracked, setHasTracked] = React.useState(false);
+
   const toast = useToast();
   const cardBg = useColorModeValue('white', 'gray.800');
   const textColor = useColorModeValue('gray.700', 'white');
   const secondaryColor = useColorModeValue('gray.500', 'gray.400');
 
+  // 🎯 追踪历史记录查看 - 组件加载时触发一次
+  React.useEffect(() => {
+    if (!hasTracked && history && history.length > 0 && tradingEvents && tradingEvents.trackSimulationHistoryViewed) {
+      tradingEvents.trackSimulationHistoryViewed({
+        count: history.length,
+        filterBy: 'all',
+        dateRange: 'all',
+      });
+      setHasTracked(true);
+    }
+  }, [history, tradingEvents, hasTracked]);
+
   // 格式化货币
   const formatCurrency = (amount) => {
     return new Intl.NumberFormat('zh-CN', {

src/views/TradingSimulation/components/TradingPanel.js

@@ -55,7 +55,7 @@ import { FiSearch, FiTrendingUp, FiTrendingDown, FiDollarSign, FiZap, FiTarget }
 // 导入现有的高质量组件
 import IconBox from '../../../components/Icons/IconBox';
 
-export default function TradingPanel({ account, onBuyStock, onSellStock, searchStocks }) {
+export default function TradingPanel({ account, onBuyStock, onSellStock, searchStocks, tradingEvents }) {
   const [activeTab, setActiveTab] = useState(0); // 0: 买入, 1: 卖出
   const [searchTerm, setSearchTerm] = useState('');
   const [selectedStock, setSelectedStock] = useState(null);
@@ -87,7 +87,7 @@ export default function TradingPanel({ account, onBuyStock, onSellStock, searchS
           const results = await searchStocks(searchTerm);
           // 转换为组件需要的格式
           const formattedResults = results.map(stock => [
-            stock.stock_code, 
+            stock.stock_code,
             {
               name: stock.stock_name,
               price: stock.current_price || 0, // 使用后端返回的真实价格
@@ -97,10 +97,20 @@ export default function TradingPanel({ account, onBuyStock, onSellStock, searchS
           ]);
           setFilteredStocks(formattedResults);
           setShowStockList(true);
+
+          // 🎯 追踪股票搜索
+          if (tradingEvents && tradingEvents.trackSimulationStockSearched) {
+            tradingEvents.trackSimulationStockSearched(searchTerm, formattedResults.length);
+          }
         } catch (error) {
           logger.error('TradingPanel', 'handleStockSearch', error, { searchTerm });
           setFilteredStocks([]);
           setShowStockList(false);
+
+          // 🎯 追踪搜索无结果
+          if (tradingEvents && tradingEvents.trackSimulationStockSearched) {
+            tradingEvents.trackSimulationStockSearched(searchTerm, 0);
+          }
         }
       } else {
         setFilteredStocks([]);
@@ -109,7 +119,7 @@ export default function TradingPanel({ account, onBuyStock, onSellStock, searchS
     }, 300); // 300ms 防抖
 
     return () => clearTimeout(searchDebounced);
-  }, [searchTerm, searchStocks]);
+  }, [searchTerm, searchStocks, tradingEvents]);
 
   // 选择股票
   const handleSelectStock = (code, stock) => {
@@ -169,6 +179,9 @@ export default function TradingPanel({ account, onBuyStock, onSellStock, searchS
     if (!validateForm()) return;
 
     setIsLoading(true);
+    const price = orderType === 'LIMIT' ? parseFloat(limitPrice) : selectedStock.price;
+    const direction = activeTab === 0 ? 'buy' : 'sell';
+
     try {
       let result;
       if (activeTab === 0) {
@@ -197,6 +210,19 @@ export default function TradingPanel({ account, onBuyStock, onSellStock, searchS
           orderType
         });
 
+        // 🎯 追踪下单成功
+        if (tradingEvents && tradingEvents.trackSimulationOrderPlaced) {
+          tradingEvents.trackSimulationOrderPlaced({
+            stockCode: selectedStock.code,
+            stockName: selectedStock.name,
+            direction,
+            quantity,
+            price,
+            orderType,
+            success: true,
+          });
+        }
+
         // ✅ 保留交易成功toast（关键用户操作反馈）
         toast({
           title: activeTab === 0 ? '买入成功' : '卖出成功',
@@ -217,6 +243,20 @@ export default function TradingPanel({ account, onBuyStock, onSellStock, searchS
         orderType
       });
 
+      // 🎯 追踪下单失败
+      if (tradingEvents && tradingEvents.trackSimulationOrderPlaced) {
+        tradingEvents.trackSimulationOrderPlaced({
+          stockCode: selectedStock.code,
+          stockName: selectedStock.name,
+          direction,
+          quantity,
+          price,
+          orderType,
+          success: false,
+          errorMessage: error.message,
+        });
+      }
+
       // ✅ 保留交易失败toast（关键用户操作错误反馈）
       toast({
         title: activeTab === 0 ? '买入失败' : '卖出失败',

src/views/TradingSimulation/hooks/useTradingSimulationEvents.js

@@ -0,0 +1,303 @@
+// src/views/TradingSimulation/hooks/useTradingSimulationEvents.js
+// 模拟盘交易事件追踪 Hook
+
+import { useCallback, useEffect } from 'react';
+import { usePostHogTrack } from '../../../hooks/usePostHogRedux';
+import { RETENTION_EVENTS } from '../../../lib/constants';
+import { logger } from '../../../utils/logger';
+
+/**
+ * 模拟盘交易事件追踪 Hook
+ * @param {Object} options - 配置选项
+ * @param {Object} options.portfolio - 账户信息
+ * @param {number} options.portfolio.totalValue - 总资产
+ * @param {number} options.portfolio.availableCash - 可用资金
+ * @param {number} options.portfolio.holdingsCount - 持仓数量
+ * @param {Function} options.navigate - 路由导航函数
+ * @returns {Object} 事件追踪处理函数集合
+ */
+export const useTradingSimulationEvents = ({ portfolio, navigate } = {}) => {
+  const { track } = usePostHogTrack();
+
+  // 🎯 页面浏览事件 - 页面加载时触发
+  useEffect(() => {
+    track(RETENTION_EVENTS.TRADING_SIMULATION_ENTERED, {
+      total_value: portfolio?.totalValue || 0,
+      available_cash: portfolio?.availableCash || 0,
+      holdings_count: portfolio?.holdingsCount || 0,
+      has_holdings: Boolean(portfolio?.holdingsCount && portfolio.holdingsCount > 0),
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useTradingSimulationEvents', '🎮 Trading Simulation Entered', {
+      totalValue: portfolio?.totalValue,
+      holdingsCount: portfolio?.holdingsCount,
+    });
+  }, [track, portfolio]);
+
+  /**
+   * 追踪股票搜索（模拟盘内）
+   * @param {string} query - 搜索关键词
+   * @param {number} resultCount - 搜索结果数量
+   */
+  const trackSimulationStockSearched = useCallback((query, resultCount = 0) => {
+    if (!query) return;
+
+    track(RETENTION_EVENTS.SIMULATION_STOCK_SEARCHED, {
+      query,
+      result_count: resultCount,
+      has_results: resultCount > 0,
+      timestamp: new Date().toISOString(),
+    });
+
+    // 如果没有搜索结果，额外追踪
+    if (resultCount === 0) {
+      track(RETENTION_EVENTS.SEARCH_NO_RESULTS, {
+        query,
+        context: 'trading_simulation',
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    logger.debug('useTradingSimulationEvents', '🔍 Simulation Stock Searched', {
+      query,
+      resultCount,
+    });
+  }, [track]);
+
+  /**
+   * 追踪下单操作
+   * @param {Object} order - 订单信息
+   * @param {string} order.stockCode - 股票代码
+   * @param {string} order.stockName - 股票名称
+   * @param {string} order.direction - 买卖方向 ('buy' | 'sell')
+   * @param {number} order.quantity - 数量
+   * @param {number} order.price - 价格
+   * @param {string} order.orderType - 订单类型 ('market' | 'limit')
+   * @param {boolean} order.success - 是否成功
+   */
+  const trackSimulationOrderPlaced = useCallback((order) => {
+    if (!order || !order.stockCode) {
+      logger.warn('useTradingSimulationEvents', 'Order object is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.SIMULATION_ORDER_PLACED, {
+      stock_code: order.stockCode,
+      stock_name: order.stockName || '',
+      direction: order.direction,
+      quantity: order.quantity,
+      price: order.price,
+      order_type: order.orderType || 'market',
+      order_value: order.quantity * order.price,
+      success: order.success,
+      error_message: order.errorMessage || null,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useTradingSimulationEvents', '📝 Simulation Order Placed', {
+      stockCode: order.stockCode,
+      direction: order.direction,
+      quantity: order.quantity,
+      success: order.success,
+    });
+  }, [track]);
+
+  /**
+   * 追踪持仓查看
+   * @param {Object} holdings - 持仓信息
+   * @param {number} holdings.count - 持仓数量
+   * @param {number} holdings.totalValue - 持仓总市值
+   * @param {number} holdings.totalCost - 持仓总成本
+   * @param {number} holdings.profitLoss - 总盈亏
+   */
+  const trackSimulationHoldingsViewed = useCallback((holdings = {}) => {
+    track(RETENTION_EVENTS.SIMULATION_HOLDINGS_VIEWED, {
+      holdings_count: holdings.count || 0,
+      total_value: holdings.totalValue || 0,
+      total_cost: holdings.totalCost || 0,
+      profit_loss: holdings.profitLoss || 0,
+      profit_loss_percent: holdings.totalCost ? ((holdings.profitLoss / holdings.totalCost) * 100).toFixed(2) : 0,
+      has_profit: holdings.profitLoss > 0,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useTradingSimulationEvents', '💼 Simulation Holdings Viewed', {
+      count: holdings.count,
+      profitLoss: holdings.profitLoss,
+    });
+  }, [track]);
+
+  /**
+   * 追踪持仓股票点击
+   * @param {Object} holding - 持仓对象
+   * @param {string} holding.stockCode - 股票代码
+   * @param {string} holding.stockName - 股票名称
+   * @param {number} holding.profitLoss - 盈亏金额
+   * @param {number} position - 在列表中的位置
+   */
+  const trackHoldingClicked = useCallback((holding, position = 0) => {
+    if (!holding || !holding.stockCode) {
+      logger.warn('useTradingSimulationEvents', 'Holding object is required');
+      return;
+    }
+
+    track(RETENTION_EVENTS.STOCK_CLICKED, {
+      stock_code: holding.stockCode,
+      stock_name: holding.stockName || '',
+      source: 'simulation_holdings',
+      profit_loss: holding.profitLoss || 0,
+      position,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useTradingSimulationEvents', '🎯 Holding Clicked', {
+      stockCode: holding.stockCode,
+      position,
+    });
+  }, [track]);
+
+  /**
+   * 追踪历史交易记录查看
+   * @param {Object} history - 历史记录信息
+   * @param {number} history.count - 交易记录数量
+   * @param {string} history.filterBy - 筛选条件 ('all' | 'buy' | 'sell')
+   * @param {string} history.dateRange - 日期范围
+   */
+  const trackSimulationHistoryViewed = useCallback((history = {}) => {
+    track(RETENTION_EVENTS.SIMULATION_HISTORY_VIEWED, {
+      history_count: history.count || 0,
+      filter_by: history.filterBy || 'all',
+      date_range: history.dateRange || 'all',
+      has_history: Boolean(history.count && history.count > 0),
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useTradingSimulationEvents', '📜 Simulation History Viewed', {
+      count: history.count,
+      filterBy: history.filterBy,
+    });
+  }, [track]);
+
+  /**
+   * 追踪买入按钮点击
+   * @param {Object} stock - 股票对象
+   * @param {string} stock.code - 股票代码
+   * @param {string} stock.name - 股票名称
+   * @param {number} stock.price - 当前价格
+   * @param {string} source - 来源 ('search' | 'holdings' | 'stock_detail')
+   */
+  const trackBuyButtonClicked = useCallback((stock, source = 'search') => {
+    if (!stock || !stock.code) {
+      logger.warn('useTradingSimulationEvents', 'Stock object is required');
+      return;
+    }
+
+    track('Simulation Buy Button Clicked', {
+      stock_code: stock.code,
+      stock_name: stock.name || '',
+      current_price: stock.price || 0,
+      source,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useTradingSimulationEvents', '🟢 Buy Button Clicked', {
+      stockCode: stock.code,
+      source,
+    });
+  }, [track]);
+
+  /**
+   * 追踪卖出按钮点击
+   * @param {Object} holding - 持仓对象
+   * @param {string} holding.stockCode - 股票代码
+   * @param {string} holding.stockName - 股票名称
+   * @param {number} holding.quantity - 持有数量
+   * @param {number} holding.profitLoss - 盈亏金额
+   * @param {string} source - 来源 ('holdings' | 'stock_detail')
+   */
+  const trackSellButtonClicked = useCallback((holding, source = 'holdings') => {
+    if (!holding || !holding.stockCode) {
+      logger.warn('useTradingSimulationEvents', 'Holding object is required');
+      return;
+    }
+
+    track('Simulation Sell Button Clicked', {
+      stock_code: holding.stockCode,
+      stock_name: holding.stockName || '',
+      quantity: holding.quantity || 0,
+      profit_loss: holding.profitLoss || 0,
+      source,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useTradingSimulationEvents', '🔴 Sell Button Clicked', {
+      stockCode: holding.stockCode,
+      source,
+    });
+  }, [track]);
+
+  /**
+   * 追踪账户重置
+   * @param {Object} beforeReset - 重置前的账户信息
+   * @param {number} beforeReset.totalValue - 总资产
+   * @param {number} beforeReset.profitLoss - 总盈亏
+   */
+  const trackAccountReset = useCallback((beforeReset = {}) => {
+    track('Simulation Account Reset', {
+      total_value_before: beforeReset.totalValue || 0,
+      profit_loss_before: beforeReset.profitLoss || 0,
+      holdings_count_before: beforeReset.holdingsCount || 0,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useTradingSimulationEvents', '🔄 Account Reset', {
+      totalValueBefore: beforeReset.totalValue,
+    });
+  }, [track]);
+
+  /**
+   * 追踪标签页切换
+   * @param {string} tabName - 标签名称 ('trading' | 'holdings' | 'history')
+   */
+  const trackTabClicked = useCallback((tabName) => {
+    if (!tabName) {
+      logger.warn('useTradingSimulationEvents', 'Tab name is required');
+      return;
+    }
+
+    track('Simulation Tab Clicked', {
+      tab_name: tabName,
+      timestamp: new Date().toISOString(),
+    });
+
+    logger.debug('useTradingSimulationEvents', '📑 Tab Clicked', {
+      tabName,
+    });
+  }, [track]);
+
+  return {
+    // 搜索事件
+    trackSimulationStockSearched,
+
+    // 交易事件
+    trackSimulationOrderPlaced,
+    trackBuyButtonClicked,
+    trackSellButtonClicked,
+
+    // 持仓事件
+    trackSimulationHoldingsViewed,
+    trackHoldingClicked,
+
+    // 历史记录事件
+    trackSimulationHistoryViewed,
+
+    // 账户管理事件
+    trackAccountReset,
+
+    // UI交互事件
+    trackTabClicked,
+  };
+};
+
+export default useTradingSimulationEvents;

src/views/TradingSimulation/index.js

@@ -49,6 +49,7 @@ import LineChart from '../../components/Charts/LineChart';
 
 // 模拟盘账户管理 Hook
 import { useTradingAccount } from './hooks/useTradingAccount';
+import { useTradingSimulationEvents } from './hooks/useTradingSimulationEvents';
 
 export default function TradingSimulation() {
   // ========== 1. 所有 Hooks 必须放在最顶部，不能有任何条件判断 ==========
@@ -76,6 +77,15 @@ export default function TradingSimulation() {
     getAssetHistory
   } = useTradingAccount();
 
+  // 🎯 初始化模拟盘埋点Hook（传入账户信息）
+  const tradingEvents = useTradingSimulationEvents({
+    portfolio: account ? {
+      totalValue: account.total_assets,
+      availableCash: account.available_cash,
+      holdingsCount: positions?.length || 0
+    } : null
+  });
+
   // 所有的 useColorModeValue 也必须在顶部
   const bgColor = useColorModeValue('gray.50', 'gray.900');
   const cardBg = useColorModeValue('white', 'gray.800');
@@ -271,9 +281,14 @@ export default function TradingSimulation() {
             </Box>
 
             {/* 主要功能区域 - 放在上面 */}
-            <Tabs 
-              index={activeTab} 
-              onChange={setActiveTab}
+            <Tabs
+              index={activeTab}
+              onChange={(index) => {
+                setActiveTab(index);
+                // 🎯 追踪 Tab 切换
+                const tabNames = ['trading', 'holdings', 'history', 'margin'];
+                tradingEvents.trackTabClicked(tabNames[index]);
+              }}
               variant="soft-rounded"
               colorScheme="blue"
               size="lg"
@@ -288,28 +303,31 @@ export default function TradingSimulation() {
               <TabPanels>
                 {/* 交易面板 */}
                 <TabPanel px={0}>
-                  <TradingPanel 
+                  <TradingPanel
                     account={account}
                     onBuyStock={buyStock}
                     onSellStock={sellStock}
                     searchStocks={searchStocks}
+                    tradingEvents={tradingEvents}
                   />
                 </TabPanel>
 
                 {/* 我的持仓 */}
                 <TabPanel px={0}>
-                  <PositionsList 
+                  <PositionsList
                     positions={positions}
                     account={account}
                     onSellStock={sellStock}
+                    tradingEvents={tradingEvents}
                   />
                 </TabPanel>
 
                 {/* 交易历史 */}
                 <TabPanel px={0}>
-                  <TradingHistory 
+                  <TradingHistory
                     history={tradingHistory}
                     onCancelOrder={cancelOrder}
+                    tradingEvents={tradingEvents}
                   />
                 </TabPanel>
 
@@ -331,7 +349,7 @@ export default function TradingSimulation() {
                 <Heading size="lg" mb={4} color={useColorModeValue('gray.700', 'white')}>
                   📊 账户统计分析
                 </Heading>
-                <AccountOverview account={account} />
+                <AccountOverview account={account} tradingEvents={tradingEvents} />
               </Box>
 
               {/* 资产走势图表 - 只在有数据时显示 */}