Merge pull request #381 from hicccc77/dev

Dev

.gitignore

@@ -56,11 +56,13 @@ Thumbs.db
 *.aps
 
 wcdb/
+xkey/
+server/
 *info
-概述.md
 chatlab-format.md
 *.bak
 AGENTS.md
 .claude/
 .agents/
-resources/wx_send
+resources/wx_send
+概述.md

README.md

@@ -41,7 +41,28 @@ WeFlow 是一个**完全本地**的微信**实时**聊天记录查看、分析
 - 年度报告与可视化概览
 - 导出聊天记录为 HTML 等格式
 - HTTP API 接口（供开发者集成）
+- 查看完整能力清单：[详细功能](#详细功能清单)
 
+## 快速开始
+
+若你只想使用成品版本，可前往 Release 下载并安装。
+
+## 详细功能清单
+
+当前版本已支持以下能力：
+
+| 功能模块 | 说明 |
+|---------|------|
+| **聊天** | 解密聊天中的图片、视频、实况（仅支持谷歌协议拍摄的实况）；支持**修改**、删除**本地**消息；实时刷新最新消息，无需生成解密中间数据库 |
+| **实时弹窗通知** | 新消息到达时提供桌面弹窗提醒，便于及时查看重要会话，提供黑白名单功能 |
+| **私聊分析** | 统计好友间消息数量；分析消息类型与发送比例；查看消息时段分布等 |
+| **群聊分析** | 查看群成员详细信息；分析群内发言排行、活跃时段和媒体内容 |
+| **年度报告** | 生成按年统计的年度报告，或跨年度的长期历史报告 |
+| **双人报告** | 选择指定好友，基于双方聊天记录生成专属分析报告 |
+| **消息导出** | 将微信聊天记录导出为多种格式：JSON、HTML、TXT、Excel、CSV、PGSQL、ChatLab专属格式等 |
+| **朋友圈** | 解密朋友圈图片、视频、实况；导出朋友圈内容；拦截朋友圈的删除与隐藏操作；突破时间访问限制 |
+| **联系人** | 导出微信好友、群聊、公众号信息；尝试找回曾经的好友（功能尚不完善） |
+| **HTTP API 映射** | 将本地消息能力映射为 HTTP API，便于对接外部系统、自动化脚本与二次开发 |
 
 ## HTTP API
 
@@ -55,13 +76,9 @@ WeFlow 提供本地 HTTP API 服务，支持通过接口查询消息数据，可
 - **访问地址**：`http://127.0.0.1:5031`
 - **支持格式**：原始 JSON 或 [ChatLab](https://chatlab.fun/) 标准格式
 
-📖 完整接口文档：[点击查看](docs/HTTP-API.md)
+完整接口文档：[点击查看](docs/HTTP-API.md)
 
 
-## 快速开始
-
-若你只想使用成品版本，可前往 Release 下载并安装。
-
 ## 面向开发者
 
 如果你想从源码构建或为项目贡献代码，请遵循以下步骤：

docs/HTTP-API.md

@@ -105,7 +105,8 @@ GET http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&keyword=项目进度&l
       "senderUsername": "wxid_sender",
       "mediaType": "image",
       "mediaFileName": "image_123.jpg",
-      "mediaPath": "C:\\Users\\Alice\\Documents\\WeFlow\\api-media\\wxid_xxx\\images\\image_123.jpg"
+      "mediaUrl": "http://127.0.0.1:5031/api/v1/media/wxid_xxx/images/image_123.jpg",
+      "mediaLocalPath": "C:\\Users\\Alice\\Documents\\WeFlow\\api-media\\wxid_xxx\\images\\image_123.jpg"
     }
   ]
 }
@@ -140,7 +141,7 @@ GET http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&keyword=项目进度&l
       "timestamp": 1738713600000,
       "type": 0,
       "content": "消息内容",
-      "mediaPath": "C:\\Users\\Alice\\Documents\\WeFlow\\api-media\\wxid_xxx\\images\\image_123.jpg"
+      "mediaPath": "http://127.0.0.1:5031/api/v1/media/wxid_xxx/images/image_123.jpg"
     }
   ],
   "media": {
@@ -153,7 +154,59 @@ GET http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&keyword=项目进度&l
 
 ---
 
-### 3. 获取会话列表
+### 3. 访问导出媒体文件
+
+通过 HTTP 直接访问已导出的媒体文件（图片、语音、视频、表情）。
+
+**请求**
+```
+GET /api/v1/media/{relativePath}
+```
+
+**路径参数**
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| `relativePath` | string | ✅ | 媒体文件的相对路径，如 `wxid_xxx/images/image_123.jpg` |
+
+**支持的媒体类型**
+
+| 扩展名 | Content-Type |
+|--------|-------------|
+| `.png` | image/png |
+| `.jpg` / `.jpeg` | image/jpeg |
+| `.gif` | image/gif |
+| `.webp` | image/webp |
+| `.wav` | audio/wav |
+| `.mp3` | audio/mpeg |
+| `.mp4` | video/mp4 |
+
+**示例请求**
+```bash
+# 访问导出的图片
+GET http://127.0.0.1:5031/api/v1/media/wxid_xxx/images/image_123.jpg
+
+# 访问导出的语音
+GET http://127.0.0.1:5031/api/v1/media/wxid_xxx/voices/voice_456.wav
+
+# 访问导出的视频
+GET http://127.0.0.1:5031/api/v1/media/wxid_xxx/videos/video_789.mp4
+```
+
+**响应**
+
+成功时直接返回文件内容，`Content-Type` 根据文件扩展名自动设置。
+
+失败时返回：
+```json
+{ "error": "Media not found" }
+```
+
+> 注意：媒体文件需要先通过消息接口的 `media=1` 参数导出后才能访问。
+
+---
+
+### 4. 获取会话列表
 
 获取所有会话列表。
 

electron/preload.ts

@@ -73,6 +73,15 @@ contextBridge.exposeInMainWorld('electronAPI', {
     debug: (data: any) => ipcRenderer.send('log:debug', data)
   },
 
+  diagnostics: {
+    getExportCardLogs: (options?: { limit?: number }) =>
+      ipcRenderer.invoke('diagnostics:getExportCardLogs', options),
+    clearExportCardLogs: () =>
+      ipcRenderer.invoke('diagnostics:clearExportCardLogs'),
+    exportExportCardLogs: (payload: { filePath: string; frontendLogs?: unknown[] }) =>
+      ipcRenderer.invoke('diagnostics:exportExportCardLogs', payload)
+  },
+
   // 窗口控制
   window: {
     minimize: () => ipcRenderer.send('window:minimize'),
@@ -89,7 +98,17 @@ contextBridge.exposeInMainWorld('electronAPI', {
     openImageViewerWindow: (imagePath: string, liveVideoPath?: string) =>
       ipcRenderer.invoke('window:openImageViewerWindow', imagePath, liveVideoPath),
     openChatHistoryWindow: (sessionId: string, messageId: number) =>
-      ipcRenderer.invoke('window:openChatHistoryWindow', sessionId, messageId)
+      ipcRenderer.invoke('window:openChatHistoryWindow', sessionId, messageId),
+    openSessionChatWindow: (
+      sessionId: string,
+      options?: {
+        source?: 'chat' | 'export'
+        initialDisplayName?: string
+        initialAvatarUrl?: string
+        initialContactType?: 'friend' | 'group' | 'official' | 'former_friend' | 'other'
+      }
+    ) =>
+      ipcRenderer.invoke('window:openSessionChatWindow', sessionId, options)
   },
 
   // 数据库路径
@@ -113,7 +132,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
   // 密钥获取
   key: {
     autoGetDbKey: () => ipcRenderer.invoke('key:autoGetDbKey'),
-    autoGetImageKey: (manualDir?: string) => ipcRenderer.invoke('key:autoGetImageKey', manualDir),
+    autoGetImageKey: (manualDir?: string, wxid?: string) => ipcRenderer.invoke('key:autoGetImageKey', manualDir, wxid),
+    scanImageKeyFromMemory: (userDir: string) => ipcRenderer.invoke('key:scanImageKeyFromMemory', userDir),
     onDbKeyStatus: (callback: (payload: { message: string; level: number }) => void) => {
       ipcRenderer.on('key:dbKeyStatus', (_, payload) => callback(payload))
       return () => ipcRenderer.removeAllListeners('key:dbKeyStatus')
@@ -129,8 +149,14 @@ contextBridge.exposeInMainWorld('electronAPI', {
   chat: {
     connect: () => ipcRenderer.invoke('chat:connect'),
     getSessions: () => ipcRenderer.invoke('chat:getSessions'),
-    enrichSessionsContactInfo: (usernames: string[]) =>
-      ipcRenderer.invoke('chat:enrichSessionsContactInfo', usernames),
+    getSessionStatuses: (usernames: string[]) => ipcRenderer.invoke('chat:getSessionStatuses', usernames),
+    getExportTabCounts: () => ipcRenderer.invoke('chat:getExportTabCounts'),
+    getContactTypeCounts: () => ipcRenderer.invoke('chat:getContactTypeCounts'),
+    getSessionMessageCounts: (sessionIds: string[]) => ipcRenderer.invoke('chat:getSessionMessageCounts', sessionIds),
+    enrichSessionsContactInfo: (
+      usernames: string[],
+      options?: { skipDisplayName?: boolean; onlyMissingAvatar?: boolean }
+    ) => ipcRenderer.invoke('chat:enrichSessionsContactInfo', usernames, options),
     getMessages: (sessionId: string, offset?: number, limit?: number, startTime?: number, endTime?: number, ascending?: boolean) =>
       ipcRenderer.invoke('chat:getMessages', sessionId, offset, limit, startTime, endTime, ascending),
     getLatestMessages: (sessionId: string, limit?: number) =>
@@ -148,14 +174,31 @@ contextBridge.exposeInMainWorld('electronAPI', {
     getMyAvatarUrl: () => ipcRenderer.invoke('chat:getMyAvatarUrl'),
     downloadEmoji: (cdnUrl: string, md5?: string) => ipcRenderer.invoke('chat:downloadEmoji', cdnUrl, md5),
     getCachedMessages: (sessionId: string) => ipcRenderer.invoke('chat:getCachedMessages', sessionId),
+    clearCurrentAccountData: (options: { clearCache?: boolean; clearExports?: boolean }) =>
+      ipcRenderer.invoke('chat:clearCurrentAccountData', options),
     close: () => ipcRenderer.invoke('chat:close'),
     getSessionDetail: (sessionId: string) => ipcRenderer.invoke('chat:getSessionDetail', sessionId),
+    getSessionDetailFast: (sessionId: string) => ipcRenderer.invoke('chat:getSessionDetailFast', sessionId),
+    getSessionDetailExtra: (sessionId: string) => ipcRenderer.invoke('chat:getSessionDetailExtra', sessionId),
+    getExportSessionStats: (
+      sessionIds: string[],
+      options?: {
+        includeRelations?: boolean
+        forceRefresh?: boolean
+        allowStaleCache?: boolean
+        preferAccurateSpecialTypes?: boolean
+        cacheOnly?: boolean
+      }
+    ) => ipcRenderer.invoke('chat:getExportSessionStats', sessionIds, options),
+    getGroupMyMessageCountHint: (chatroomId: string) =>
+      ipcRenderer.invoke('chat:getGroupMyMessageCountHint', chatroomId),
     getImageData: (sessionId: string, msgId: string) => ipcRenderer.invoke('chat:getImageData', sessionId, msgId),
     getVoiceData: (sessionId: string, msgId: string, createTime?: number, serverId?: string | number) =>
       ipcRenderer.invoke('chat:getVoiceData', sessionId, msgId, createTime, serverId),
     getAllVoiceMessages: (sessionId: string) => ipcRenderer.invoke('chat:getAllVoiceMessages', sessionId),
     getAllImageMessages: (sessionId: string) => ipcRenderer.invoke('chat:getAllImageMessages', sessionId),
     getMessageDates: (sessionId: string) => ipcRenderer.invoke('chat:getMessageDates', sessionId),
+    getMessageDateCounts: (sessionId: string) => ipcRenderer.invoke('chat:getMessageDateCounts', sessionId),
     resolveVoiceCache: (sessionId: string, msgId: string) => ipcRenderer.invoke('chat:resolveVoiceCache', sessionId, msgId),
     getVoiceTranscript: (sessionId: string, msgId: string, createTime?: number) => ipcRenderer.invoke('chat:getVoiceTranscript', sessionId, msgId, createTime),
     onVoiceTranscriptPartial: (callback: (payload: { msgId: string; text: string }) => void) => {
@@ -226,6 +269,10 @@ contextBridge.exposeInMainWorld('electronAPI', {
   groupAnalytics: {
     getGroupChats: () => ipcRenderer.invoke('groupAnalytics:getGroupChats'),
     getGroupMembers: (chatroomId: string) => ipcRenderer.invoke('groupAnalytics:getGroupMembers', chatroomId),
+    getGroupMembersPanelData: (
+      chatroomId: string,
+      options?: { forceRefresh?: boolean; includeMessageCounts?: boolean }
+    ) => ipcRenderer.invoke('groupAnalytics:getGroupMembersPanelData', chatroomId, options),
     getGroupMessageRanking: (chatroomId: string, limit?: number, startTime?: number, endTime?: number) => ipcRenderer.invoke('groupAnalytics:getGroupMessageRanking', chatroomId, limit, startTime, endTime),
     getGroupActiveHours: (chatroomId: string, startTime?: number, endTime?: number) => ipcRenderer.invoke('groupAnalytics:getGroupActiveHours', chatroomId, startTime, endTime),
     getGroupMediaStats: (chatroomId: string, startTime?: number, endTime?: number) => ipcRenderer.invoke('groupAnalytics:getGroupMediaStats', chatroomId, startTime, endTime),
@@ -237,9 +284,29 @@ contextBridge.exposeInMainWorld('electronAPI', {
   // 年度报告
   annualReport: {
     getAvailableYears: () => ipcRenderer.invoke('annualReport:getAvailableYears'),
+    startAvailableYearsLoad: () => ipcRenderer.invoke('annualReport:startAvailableYearsLoad'),
+    cancelAvailableYearsLoad: (taskId: string) => ipcRenderer.invoke('annualReport:cancelAvailableYearsLoad', taskId),
     generateReport: (year: number) => ipcRenderer.invoke('annualReport:generateReport', year),
     exportImages: (payload: { baseDir: string; folderName: string; images: Array<{ name: string; dataUrl: string }> }) =>
       ipcRenderer.invoke('annualReport:exportImages', payload),
+    onAvailableYearsProgress: (callback: (payload: {
+      taskId: string
+      years?: number[]
+      done: boolean
+      error?: string
+      canceled?: boolean
+      strategy?: 'cache' | 'native' | 'hybrid'
+      phase?: 'cache' | 'native' | 'scan' | 'done'
+      statusText?: string
+      nativeElapsedMs?: number
+      scanElapsedMs?: number
+      totalElapsedMs?: number
+      switched?: boolean
+      nativeTimedOut?: boolean
+    }) => void) => {
+      ipcRenderer.on('annualReport:availableYearsProgress', (_, payload) => callback(payload))
+      return () => ipcRenderer.removeAllListeners('annualReport:availableYearsProgress')
+    },
     onProgress: (callback: (payload: { status: string; progress: number }) => void) => {
       ipcRenderer.on('annualReport:progress', (_, payload) => callback(payload))
       return () => ipcRenderer.removeAllListeners('annualReport:progress')
@@ -264,7 +331,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
       ipcRenderer.invoke('export:exportSession', sessionId, outputPath, options),
     exportContacts: (outputDir: string, options: any) =>
       ipcRenderer.invoke('export:exportContacts', outputDir, options),
-    onProgress: (callback: (payload: { current: number; total: number; currentSession: string; phase: string }) => void) => {
+    onProgress: (callback: (payload: { current: number; total: number; currentSession: string; currentSessionId?: string; phase: string }) => void) => {
       ipcRenderer.on('export:progress', (_, payload) => callback(payload))
       return () => ipcRenderer.removeAllListeners('export:progress')
     }
@@ -286,6 +353,10 @@ contextBridge.exposeInMainWorld('electronAPI', {
     getTimeline: (limit: number, offset: number, usernames?: string[], keyword?: string, startTime?: number, endTime?: number) =>
       ipcRenderer.invoke('sns:getTimeline', limit, offset, usernames, keyword, startTime, endTime),
     getSnsUsernames: () => ipcRenderer.invoke('sns:getSnsUsernames'),
+    getUserPostCounts: () => ipcRenderer.invoke('sns:getUserPostCounts'),
+    getExportStatsFast: () => ipcRenderer.invoke('sns:getExportStatsFast'),
+    getExportStats: () => ipcRenderer.invoke('sns:getExportStats'),
+    getUserPostStats: (username: string) => ipcRenderer.invoke('sns:getUserPostStats', username),
     debugResource: (url: string) => ipcRenderer.invoke('sns:debugResource', url),
     proxyImage: (payload: { url: string; key?: string | number }) => ipcRenderer.invoke('sns:proxyImage', payload),
     downloadImage: (payload: { url: string; key?: string | number }) => ipcRenderer.invoke('sns:downloadImage', payload),
@@ -294,7 +365,20 @@ contextBridge.exposeInMainWorld('electronAPI', {
       ipcRenderer.on('sns:exportProgress', (_, payload) => callback(payload))
       return () => ipcRenderer.removeAllListeners('sns:exportProgress')
     },
-    selectExportDir: () => ipcRenderer.invoke('sns:selectExportDir')
+    selectExportDir: () => ipcRenderer.invoke('sns:selectExportDir'),
+    installBlockDeleteTrigger: () => ipcRenderer.invoke('sns:installBlockDeleteTrigger'),
+    uninstallBlockDeleteTrigger: () => ipcRenderer.invoke('sns:uninstallBlockDeleteTrigger'),
+    checkBlockDeleteTrigger: () => ipcRenderer.invoke('sns:checkBlockDeleteTrigger'),
+    deleteSnsPost: (postId: string) => ipcRenderer.invoke('sns:deleteSnsPost', postId),
+    downloadEmoji: (params: { url: string; encryptUrl?: string; aesKey?: string }) => ipcRenderer.invoke('sns:downloadEmoji', params)
+  },
+
+
+  // 数据收集
+  cloud: {
+    init: () => ipcRenderer.invoke('cloud:init'),
+    recordPage: (pageName: string) => ipcRenderer.invoke('cloud:recordPage', pageName),
+    getLogs: () => ipcRenderer.invoke('cloud:getLogs')
   },
 
   // HTTP API 服务

electron/services/analyticsService.ts

@@ -76,17 +76,13 @@ class AnalyticsService {
     const map: Record<string, string> = {}
     if (usernames.length === 0) return map
 
+    // C++ 层不支持参数绑定，直接内联转义后的字符串值
     const chunkSize = 200
     for (let i = 0; i < usernames.length; i += chunkSize) {
       const chunk = usernames.slice(i, i + chunkSize)
-      // 使用参数化查询防止SQL注入
-      const placeholders = chunk.map(() => '?').join(',')
-      const sql = `
-        SELECT username, alias
-        FROM contact
-        WHERE username IN (${placeholders})
-      `
-      const result = await wcdbService.execQuery('contact', null, sql, chunk)
+      const inList = chunk.map((u) => `'${this.escapeSqlValue(u)}'`).join(',')
+      const sql = `SELECT username, alias FROM contact WHERE username IN (${inList})`
+      const result = await wcdbService.execQuery('contact', null, sql)
       if (!result.success || !result.rows) continue
       for (const row of result.rows as Record<string, any>[]) {
         const username = row.username || ''

electron/services/annualReportService.ts

@@ -85,7 +85,34 @@ export interface AnnualReportData {
   } | null
 }
 
+export interface AvailableYearsLoadProgress {
+  years: number[]
+  strategy: 'cache' | 'native' | 'hybrid'
+  phase: 'cache' | 'native' | 'scan'
+  statusText: string
+  nativeElapsedMs: number
+  scanElapsedMs: number
+  totalElapsedMs: number
+  switched?: boolean
+  nativeTimedOut?: boolean
+}
+
+interface AvailableYearsLoadMeta {
+  strategy: 'cache' | 'native' | 'hybrid'
+  nativeElapsedMs: number
+  scanElapsedMs: number
+  totalElapsedMs: number
+  switched: boolean
+  nativeTimedOut: boolean
+  statusText: string
+}
+
 class AnnualReportService {
+  private readonly availableYearsCacheTtlMs = 10 * 60 * 1000
+  private readonly availableYearsScanConcurrency = 4
+  private readonly availableYearsColumnCache = new Map<string, string>()
+  private readonly availableYearsCache = new Map<string, { years: number[]; updatedAt: number }>()
+
   constructor() {
   }
 
@@ -181,6 +208,234 @@ class AnnualReportService {
     }
   }
 
+  private quoteSqlIdentifier(identifier: string): string {
+    return `"${String(identifier || '').replace(/"/g, '""')}"`
+  }
+
+  private toUnixTimestamp(value: any): number {
+    const n = Number(value)
+    if (!Number.isFinite(n) || n <= 0) return 0
+    // 兼容毫秒级时间戳
+    const seconds = n > 1e12 ? Math.floor(n / 1000) : Math.floor(n)
+    return seconds > 0 ? seconds : 0
+  }
+
+  private addYearsFromRange(years: Set<number>, firstTs: number, lastTs: number): boolean {
+    let changed = false
+    const currentYear = new Date().getFullYear()
+    const minTs = firstTs > 0 ? firstTs : lastTs
+    const maxTs = lastTs > 0 ? lastTs : firstTs
+    if (minTs <= 0 || maxTs <= 0) return changed
+
+    const minYear = new Date(minTs * 1000).getFullYear()
+    const maxYear = new Date(maxTs * 1000).getFullYear()
+    for (let y = minYear; y <= maxYear; y++) {
+      if (y >= 2010 && y <= currentYear && !years.has(y)) {
+        years.add(y)
+        changed = true
+      }
+    }
+    return changed
+  }
+
+  private normalizeAvailableYears(years: Iterable<number>): number[] {
+    return Array.from(new Set(Array.from(years)))
+      .filter((y) => Number.isFinite(y))
+      .map((y) => Math.floor(y))
+      .sort((a, b) => b - a)
+  }
+
+  private async forEachWithConcurrency<T>(
+    items: T[],
+    concurrency: number,
+    handler: (item: T, index: number) => Promise<void>,
+    shouldStop?: () => boolean
+  ): Promise<void> {
+    if (!items.length) return
+    const workerCount = Math.max(1, Math.min(concurrency, items.length))
+    let nextIndex = 0
+    const workers: Promise<void>[] = []
+
+    for (let i = 0; i < workerCount; i++) {
+      workers.push((async () => {
+        while (true) {
+          if (shouldStop?.()) break
+          const current = nextIndex
+          nextIndex += 1
+          if (current >= items.length) break
+          await handler(items[current], current)
+        }
+      })())
+    }
+
+    await Promise.all(workers)
+  }
+
+  private async detectTimeColumn(dbPath: string, tableName: string): Promise<string | null> {
+    const cacheKey = `${dbPath}\u0001${tableName}`
+    if (this.availableYearsColumnCache.has(cacheKey)) {
+      const cached = this.availableYearsColumnCache.get(cacheKey) || ''
+      return cached || null
+    }
+
+    const result = await wcdbService.execQuery('message', dbPath, `PRAGMA table_info(${this.quoteSqlIdentifier(tableName)})`)
+    if (!result.success || !Array.isArray(result.rows) || result.rows.length === 0) {
+      this.availableYearsColumnCache.set(cacheKey, '')
+      return null
+    }
+
+    const candidates = ['create_time', 'createtime', 'msg_create_time', 'msg_time', 'msgtime', 'time']
+    const columns = new Set<string>()
+    for (const row of result.rows as Record<string, any>[]) {
+      const name = String(row.name || row.column_name || row.columnName || '').trim().toLowerCase()
+      if (name) columns.add(name)
+    }
+
+    for (const candidate of candidates) {
+      if (columns.has(candidate)) {
+        this.availableYearsColumnCache.set(cacheKey, candidate)
+        return candidate
+      }
+    }
+
+    this.availableYearsColumnCache.set(cacheKey, '')
+    return null
+  }
+
+  private async getTableTimeRange(dbPath: string, tableName: string): Promise<{ first: number; last: number } | null> {
+    const cacheKey = `${dbPath}\u0001${tableName}`
+    const cachedColumn = this.availableYearsColumnCache.get(cacheKey)
+    const initialColumn = cachedColumn && cachedColumn.length > 0 ? cachedColumn : 'create_time'
+    const tried = new Set<string>()
+
+    const queryByColumn = async (column: string): Promise<{ first: number; last: number } | null> => {
+      const sql = `SELECT MIN(${this.quoteSqlIdentifier(column)}) AS first_ts, MAX(${this.quoteSqlIdentifier(column)}) AS last_ts FROM ${this.quoteSqlIdentifier(tableName)}`
+      const result = await wcdbService.execQuery('message', dbPath, sql)
+      if (!result.success || !Array.isArray(result.rows) || result.rows.length === 0) return null
+      const row = result.rows[0] as Record<string, any>
+      const first = this.toUnixTimestamp(row.first_ts ?? row.firstTs ?? row.min_ts ?? row.minTs)
+      const last = this.toUnixTimestamp(row.last_ts ?? row.lastTs ?? row.max_ts ?? row.maxTs)
+      return { first, last }
+    }
+
+    tried.add(initialColumn)
+    const quick = await queryByColumn(initialColumn)
+    if (quick) {
+      if (!cachedColumn) this.availableYearsColumnCache.set(cacheKey, initialColumn)
+      return quick
+    }
+
+    const detectedColumn = await this.detectTimeColumn(dbPath, tableName)
+    if (!detectedColumn || tried.has(detectedColumn)) {
+      return null
+    }
+
+    return queryByColumn(detectedColumn)
+  }
+
+  private async getAvailableYearsByTableScan(
+    sessionIds: string[],
+    options?: { onProgress?: (years: number[]) => void; shouldCancel?: () => boolean }
+  ): Promise<number[]> {
+    const years = new Set<number>()
+    let lastEmittedSize = 0
+
+    const emitIfChanged = (force = false) => {
+      if (!options?.onProgress) return
+      const next = this.normalizeAvailableYears(years)
+      if (!force && next.length === lastEmittedSize) return
+      options.onProgress(next)
+      lastEmittedSize = next.length
+    }
+
+    const shouldCancel = () => options?.shouldCancel?.() === true
+
+    await this.forEachWithConcurrency(sessionIds, this.availableYearsScanConcurrency, async (sessionId) => {
+      if (shouldCancel()) return
+      const tableStats = await wcdbService.getMessageTableStats(sessionId)
+      if (!tableStats.success || !Array.isArray(tableStats.tables) || tableStats.tables.length === 0) {
+        return
+      }
+
+      for (const table of tableStats.tables as Record<string, any>[]) {
+        if (shouldCancel()) return
+        const tableName = String(table.table_name || table.name || '').trim()
+        const dbPath = String(table.db_path || table.dbPath || '').trim()
+        if (!tableName || !dbPath) continue
+
+        const range = await this.getTableTimeRange(dbPath, tableName)
+        if (!range) continue
+        const changed = this.addYearsFromRange(years, range.first, range.last)
+        if (changed) emitIfChanged()
+      }
+    }, shouldCancel)
+
+    emitIfChanged(true)
+    return this.normalizeAvailableYears(years)
+  }
+
+  private async getAvailableYearsByEdgeScan(
+    sessionIds: string[],
+    options?: { onProgress?: (years: number[]) => void; shouldCancel?: () => boolean }
+  ): Promise<number[]> {
+    const years = new Set<number>()
+    let lastEmittedSize = 0
+    const shouldCancel = () => options?.shouldCancel?.() === true
+
+    const emitIfChanged = (force = false) => {
+      if (!options?.onProgress) return
+      const next = this.normalizeAvailableYears(years)
+      if (!force && next.length === lastEmittedSize) return
+      options.onProgress(next)
+      lastEmittedSize = next.length
+    }
+
+    for (const sessionId of sessionIds) {
+      if (shouldCancel()) break
+      const first = await this.getEdgeMessageTime(sessionId, true)
+      const last = await this.getEdgeMessageTime(sessionId, false)
+      const changed = this.addYearsFromRange(years, first || 0, last || 0)
+      if (changed) emitIfChanged()
+    }
+    emitIfChanged(true)
+    return this.normalizeAvailableYears(years)
+  }
+
+  private buildAvailableYearsCacheKey(dbPath: string, cleanedWxid: string): string {
+    return `${dbPath}\u0001${cleanedWxid}`
+  }
+
+  private getCachedAvailableYears(cacheKey: string): number[] | null {
+    const cached = this.availableYearsCache.get(cacheKey)
+    if (!cached) return null
+    if (Date.now() - cached.updatedAt > this.availableYearsCacheTtlMs) {
+      this.availableYearsCache.delete(cacheKey)
+      return null
+    }
+    return [...cached.years]
+  }
+
+  private setCachedAvailableYears(cacheKey: string, years: number[]): void {
+    const normalized = this.normalizeAvailableYears(years)
+
+    this.availableYearsCache.set(cacheKey, {
+      years: normalized,
+      updatedAt: Date.now()
+    })
+
+    if (this.availableYearsCache.size > 8) {
+      let oldestKey = ''
+      let oldestTime = Number.POSITIVE_INFINITY
+      for (const [key, val] of this.availableYearsCache) {
+        if (val.updatedAt < oldestTime) {
+          oldestTime = val.updatedAt
+          oldestKey = key
+        }
+      }
+      if (oldestKey) this.availableYearsCache.delete(oldestKey)
+    }
+  }
+
   private decodeMessageContent(messageContent: any, compressContent: any): string {
     let content = this.decodeMaybeCompressed(compressContent)
     if (!content || content.length === 0) {
@@ -359,38 +614,226 @@ class AnnualReportService {
     return { sessionId: bestSessionId, days: bestDays, start: bestStart, end: bestEnd }
   }
 
-  async getAvailableYears(params: { dbPath: string; decryptKey: string; wxid: string }): Promise<{ success: boolean; data?: number[]; error?: string }> {
+  async getAvailableYears(params: {
+    dbPath: string
+    decryptKey: string
+    wxid: string
+    onProgress?: (payload: AvailableYearsLoadProgress) => void
+    shouldCancel?: () => boolean
+    nativeTimeoutMs?: number
+  }): Promise<{ success: boolean; data?: number[]; error?: string; meta?: AvailableYearsLoadMeta }> {
     try {
+      const isCancelled = () => params.shouldCancel?.() === true
+      const totalStartedAt = Date.now()
+      let nativeElapsedMs = 0
+      let scanElapsedMs = 0
+      let switched = false
+      let nativeTimedOut = false
+      let latestYears: number[] = []
+
+      const emitProgress = (payload: {
+        years?: number[]
+        strategy: 'cache' | 'native' | 'hybrid'
+        phase: 'cache' | 'native' | 'scan'
+        statusText: string
+        switched?: boolean
+        nativeTimedOut?: boolean
+      }) => {
+        if (!params.onProgress) return
+        if (Array.isArray(payload.years)) latestYears = payload.years
+        params.onProgress({
+          years: latestYears,
+          strategy: payload.strategy,
+          phase: payload.phase,
+          statusText: payload.statusText,
+          nativeElapsedMs,
+          scanElapsedMs,
+          totalElapsedMs: Date.now() - totalStartedAt,
+          switched: payload.switched ?? switched,
+          nativeTimedOut: payload.nativeTimedOut ?? nativeTimedOut
+        })
+      }
+
+      const buildMeta = (
+        strategy: 'cache' | 'native' | 'hybrid',
+        statusText: string
+      ): AvailableYearsLoadMeta => ({
+        strategy,
+        nativeElapsedMs,
+        scanElapsedMs,
+        totalElapsedMs: Date.now() - totalStartedAt,
+        switched,
+        nativeTimedOut,
+        statusText
+      })
+
       const conn = await this.ensureConnectedWithConfig(params.dbPath, params.decryptKey, params.wxid)
-      if (!conn.success || !conn.cleanedWxid) return { success: false, error: conn.error }
-
-      const sessionIds = await this.getPrivateSessions(conn.cleanedWxid)
-      if (sessionIds.length === 0) {
-        return { success: false, error: '未找到消息会话' }
-      }
-
-      const fastYears = await wcdbService.getAvailableYears(sessionIds)
-      if (fastYears.success && fastYears.data) {
-        return { success: true, data: fastYears.data }
-      }
-
-      const years = new Set<number>()
-      for (const sessionId of sessionIds) {
-        const first = await this.getEdgeMessageTime(sessionId, true)
-        const last = await this.getEdgeMessageTime(sessionId, false)
-        if (!first && !last) continue
-
-        const minYear = new Date((first || last || 0) * 1000).getFullYear()
-        const maxYear = new Date((last || first || 0) * 1000).getFullYear()
-        for (let y = minYear; y <= maxYear; y++) {
-          if (y >= 2010 && y <= new Date().getFullYear()) years.add(y)
+      if (!conn.success || !conn.cleanedWxid) return { success: false, error: conn.error, meta: buildMeta('hybrid', '连接数据库失败') }
+      if (isCancelled()) return { success: false, error: '已取消加载年份数据', meta: buildMeta('hybrid', '已取消加载年份数据') }
+      const cacheKey = this.buildAvailableYearsCacheKey(params.dbPath, conn.cleanedWxid)
+      const cached = this.getCachedAvailableYears(cacheKey)
+      if (cached) {
+        latestYears = cached
+        emitProgress({
+          years: cached,
+          strategy: 'cache',
+          phase: 'cache',
+          statusText: '命中缓存，已快速加载年份数据'
+        })
+        return {
+          success: true,
+          data: cached,
+          meta: buildMeta('cache', '命中缓存，已快速加载年份数据')
         }
       }
 
-      const sortedYears = Array.from(years).sort((a, b) => b - a)
-      return { success: true, data: sortedYears }
+      const sessionIds = await this.getPrivateSessions(conn.cleanedWxid)
+      if (sessionIds.length === 0) {
+        return { success: false, error: '未找到消息会话', meta: buildMeta('hybrid', '未找到消息会话') }
+      }
+      if (isCancelled()) return { success: false, error: '已取消加载年份数据', meta: buildMeta('hybrid', '已取消加载年份数据') }
+
+      const nativeTimeoutMs = Math.max(1000, Math.floor(params.nativeTimeoutMs || 5000))
+      const nativeStartedAt = Date.now()
+      let nativeTicker: ReturnType<typeof setInterval> | null = null
+
+      emitProgress({
+        strategy: 'native',
+        phase: 'native',
+        statusText: '正在使用原生快速模式加载年份...'
+      })
+      nativeTicker = setInterval(() => {
+        nativeElapsedMs = Date.now() - nativeStartedAt
+        emitProgress({
+          strategy: 'native',
+          phase: 'native',
+          statusText: '正在使用原生快速模式加载年份...'
+        })
+      }, 120)
+
+      const nativeRace = await Promise.race([
+        wcdbService.getAvailableYears(sessionIds)
+          .then((result) => ({ kind: 'result' as const, result }))
+          .catch((error) => ({ kind: 'error' as const, error: String(error) })),
+        new Promise<{ kind: 'timeout' }>((resolve) => setTimeout(() => resolve({ kind: 'timeout' }), nativeTimeoutMs))
+      ])
+
+      if (nativeTicker) {
+        clearInterval(nativeTicker)
+        nativeTicker = null
+      }
+      nativeElapsedMs = Math.max(nativeElapsedMs, Date.now() - nativeStartedAt)
+
+      if (isCancelled()) return { success: false, error: '已取消加载年份数据', meta: buildMeta('hybrid', '已取消加载年份数据') }
+
+      if (nativeRace.kind === 'result' && nativeRace.result.success && Array.isArray(nativeRace.result.data) && nativeRace.result.data.length > 0) {
+        const years = this.normalizeAvailableYears(nativeRace.result.data)
+        latestYears = years
+        this.setCachedAvailableYears(cacheKey, years)
+        emitProgress({
+          years,
+          strategy: 'native',
+          phase: 'native',
+          statusText: '原生快速模式加载完成'
+        })
+        return {
+          success: true,
+          data: years,
+          meta: buildMeta('native', '原生快速模式加载完成')
+        }
+      }
+
+      switched = true
+      nativeTimedOut = nativeRace.kind === 'timeout'
+      emitProgress({
+        strategy: 'hybrid',
+        phase: 'native',
+        statusText: nativeTimedOut
+          ? '原生快速模式超时，已自动切换到扫表兼容模式...'
+          : '原生快速模式不可用，已自动切换到扫表兼容模式...',
+        switched: true,
+        nativeTimedOut
+      })
+
+      const scanStartedAt = Date.now()
+      let scanTicker: ReturnType<typeof setInterval> | null = null
+      scanTicker = setInterval(() => {
+        scanElapsedMs = Date.now() - scanStartedAt
+        emitProgress({
+          strategy: 'hybrid',
+          phase: 'scan',
+          statusText: nativeTimedOut
+            ? '原生已超时，正在使用扫表兼容模式加载年份...'
+            : '正在使用扫表兼容模式加载年份...',
+          switched: true,
+          nativeTimedOut
+        })
+      }, 120)
+
+      let years = await this.getAvailableYearsByTableScan(sessionIds, {
+        onProgress: (items) => {
+          latestYears = items
+          scanElapsedMs = Date.now() - scanStartedAt
+          emitProgress({
+            years: items,
+            strategy: 'hybrid',
+            phase: 'scan',
+            statusText: nativeTimedOut
+              ? '原生已超时，正在使用扫表兼容模式加载年份...'
+              : '正在使用扫表兼容模式加载年份...',
+            switched: true,
+            nativeTimedOut
+          })
+        },
+        shouldCancel: params.shouldCancel
+      })
+
+      if (isCancelled()) {
+        if (scanTicker) clearInterval(scanTicker)
+        return { success: false, error: '已取消加载年份数据', meta: buildMeta('hybrid', '已取消加载年份数据') }
+      }
+      if (years.length === 0) {
+        years = await this.getAvailableYearsByEdgeScan(sessionIds, {
+          onProgress: (items) => {
+            latestYears = items
+            scanElapsedMs = Date.now() - scanStartedAt
+            emitProgress({
+              years: items,
+              strategy: 'hybrid',
+              phase: 'scan',
+              statusText: '扫表结果为空，正在执行游标兜底扫描...',
+              switched: true,
+              nativeTimedOut
+            })
+          },
+          shouldCancel: params.shouldCancel
+        })
+      }
+      if (scanTicker) {
+        clearInterval(scanTicker)
+        scanTicker = null
+      }
+      scanElapsedMs = Math.max(scanElapsedMs, Date.now() - scanStartedAt)
+
+      if (isCancelled()) return { success: false, error: '已取消加载年份数据', meta: buildMeta('hybrid', '已取消加载年份数据') }
+
+      this.setCachedAvailableYears(cacheKey, years)
+      latestYears = years
+      emitProgress({
+        years,
+        strategy: 'hybrid',
+        phase: 'scan',
+        statusText: '扫表兼容模式加载完成',
+        switched: true,
+        nativeTimedOut
+      })
+      return {
+        success: true,
+        data: years,
+        meta: buildMeta('hybrid', '扫表兼容模式加载完成')
+      }
     } catch (e) {
-      return { success: false, error: String(e) }
+      return { success: false, error: String(e), meta: { strategy: 'hybrid', nativeElapsedMs: 0, scanElapsedMs: 0, totalElapsedMs: 0, switched: false, nativeTimedOut: false, statusText: '加载年度数据失败' } }
     }
   }
 

electron/services/cloudControlService.ts

@@ -0,0 +1,91 @@
+import { app } from 'electron'
+import { wcdbService } from './wcdbService'
+
+interface UsageStats {
+  appVersion: string
+  platform: string
+  deviceId: string
+  timestamp: number
+  online: boolean
+  pages: string[]
+}
+
+class CloudControlService {
+  private deviceId: string = ''
+  private timer: NodeJS.Timeout | null = null
+  private pages: Set<string> = new Set()
+
+  async init() {
+    this.deviceId = this.getDeviceId()
+    await wcdbService.cloudInit(300)
+    await this.reportOnline()
+
+    this.timer = setInterval(() => {
+      this.reportOnline()
+    }, 300000)
+  }
+
+  private getDeviceId(): string {
+    const crypto = require('crypto')
+    const os = require('os')
+    const machineId = os.hostname() + os.platform() + os.arch()
+    return crypto.createHash('md5').update(machineId).digest('hex')
+  }
+
+  private async reportOnline() {
+    const data: UsageStats = {
+      appVersion: app.getVersion(),
+      platform: this.getPlatformVersion(),
+      deviceId: this.deviceId,
+      timestamp: Date.now(),
+      online: true,
+      pages: Array.from(this.pages)
+    }
+
+    await wcdbService.cloudReport(JSON.stringify(data))
+    this.pages.clear()
+  }
+
+  private getPlatformVersion(): string {
+    const os = require('os')
+    const platform = process.platform
+
+    if (platform === 'win32') {
+      const release = os.release()
+      const parts = release.split('.')
+      const major = parseInt(parts[0])
+      const minor = parseInt(parts[1] || '0')
+      const build = parseInt(parts[2] || '0')
+
+      // Windows 11 是 10.0.22000+，且主版本必须是 10.0
+      if (major === 10 && minor === 0 && build >= 22000) {
+        return 'Windows 11'
+      } else if (major === 10) {
+        return 'Windows 10'
+      }
+      return `Windows ${release}`
+    }
+
+    return platform
+  }
+
+  recordPage(pageName: string) {
+    this.pages.add(pageName)
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer)
+      this.timer = null
+    }
+    wcdbService.cloudStop()
+  }
+
+  async getLogs() {
+    return wcdbService.getLogs()
+  }
+}
+
+export const cloudControlService = new CloudControlService()
+
+

electron/services/config.ts

@@ -105,7 +105,7 @@ export class ConfigService {
         whisperDownloadSource: 'tsinghua',
         autoTranscribeVoice: false,
         transcribeLanguages: ['zh'],
-        exportDefaultConcurrency: 2,
+        exportDefaultConcurrency: 4,
         analyticsExcludedUsernames: [],
         authEnabled: false,
         authPassword: '',
@@ -637,6 +637,27 @@ export class ConfigService {
 
   // === 工具方法 ===
 
+  /**
+   * 获取当前 wxid 对应的图片密钥，优先从 wxidConfigs 中取，找不到则回退到全局配置
+   */
+  getImageKeysForCurrentWxid(): { xorKey: unknown; aesKey: string } {
+    const wxid = this.get('myWxid')
+    if (wxid) {
+      const wxidConfigs = this.get('wxidConfigs')
+      const cfg = wxidConfigs?.[wxid]
+      if (cfg && (cfg.imageXorKey !== undefined || cfg.imageAesKey)) {
+        return {
+          xorKey: cfg.imageXorKey ?? this.get('imageXorKey'),
+          aesKey: cfg.imageAesKey ?? this.get('imageAesKey')
+        }
+      }
+    }
+    return {
+      xorKey: this.get('imageXorKey'),
+      aesKey: this.get('imageAesKey')
+    }
+  }
+
   getCacheBasePath(): string {
     return join(app.getPath('userData'), 'cache')
   }
@@ -650,4 +671,4 @@ export class ConfigService {
     this.unlockedKeys.clear()
     this.unlockPassword = null
   }
-}
+}

electron/services/exportCardDiagnosticsService.ts

@@ -0,0 +1,354 @@
+import { mkdir, writeFile } from 'fs/promises'
+import { basename, dirname, extname, join } from 'path'
+
+export type ExportCardDiagSource = 'frontend' | 'main' | 'backend' | 'worker'
+export type ExportCardDiagLevel = 'debug' | 'info' | 'warn' | 'error'
+export type ExportCardDiagStatus = 'running' | 'done' | 'failed' | 'timeout'
+
+export interface ExportCardDiagLogEntry {
+  id: string
+  ts: number
+  source: ExportCardDiagSource
+  level: ExportCardDiagLevel
+  message: string
+  traceId?: string
+  stepId?: string
+  stepName?: string
+  status?: ExportCardDiagStatus
+  durationMs?: number
+  data?: Record<string, unknown>
+}
+
+interface ActiveStepState {
+  key: string
+  traceId: string
+  stepId: string
+  stepName: string
+  source: ExportCardDiagSource
+  startedAt: number
+  lastUpdatedAt: number
+  message?: string
+}
+
+interface StepStartInput {
+  traceId: string
+  stepId: string
+  stepName: string
+  source: ExportCardDiagSource
+  level?: ExportCardDiagLevel
+  message?: string
+  data?: Record<string, unknown>
+}
+
+interface StepEndInput {
+  traceId: string
+  stepId: string
+  stepName: string
+  source: ExportCardDiagSource
+  status?: Extract<ExportCardDiagStatus, 'done' | 'failed' | 'timeout'>
+  level?: ExportCardDiagLevel
+  message?: string
+  data?: Record<string, unknown>
+  durationMs?: number
+}
+
+interface LogInput {
+  ts?: number
+  source: ExportCardDiagSource
+  level?: ExportCardDiagLevel
+  message: string
+  traceId?: string
+  stepId?: string
+  stepName?: string
+  status?: ExportCardDiagStatus
+  durationMs?: number
+  data?: Record<string, unknown>
+}
+
+export interface ExportCardDiagSnapshot {
+  logs: ExportCardDiagLogEntry[]
+  activeSteps: Array<{
+    traceId: string
+    stepId: string
+    stepName: string
+    source: ExportCardDiagSource
+    elapsedMs: number
+    stallMs: number
+    startedAt: number
+    lastUpdatedAt: number
+    message?: string
+  }>
+  summary: {
+    totalLogs: number
+    activeStepCount: number
+    errorCount: number
+    warnCount: number
+    timeoutCount: number
+    lastUpdatedAt: number
+  }
+}
+
+export class ExportCardDiagnosticsService {
+  private readonly maxLogs = 6000
+  private logs: ExportCardDiagLogEntry[] = []
+  private activeSteps = new Map<string, ActiveStepState>()
+  private seq = 0
+
+  private nextId(ts: number): string {
+    this.seq += 1
+    return `export-card-diag-${ts}-${this.seq}`
+  }
+
+  private trimLogs() {
+    if (this.logs.length <= this.maxLogs) return
+    const drop = this.logs.length - this.maxLogs
+    this.logs.splice(0, drop)
+  }
+
+  log(input: LogInput): ExportCardDiagLogEntry {
+    const ts = Number.isFinite(input.ts) ? Math.max(0, Math.floor(input.ts as number)) : Date.now()
+    const entry: ExportCardDiagLogEntry = {
+      id: this.nextId(ts),
+      ts,
+      source: input.source,
+      level: input.level || 'info',
+      message: input.message,
+      traceId: input.traceId,
+      stepId: input.stepId,
+      stepName: input.stepName,
+      status: input.status,
+      durationMs: Number.isFinite(input.durationMs) ? Math.max(0, Math.floor(input.durationMs as number)) : undefined,
+      data: input.data
+    }
+
+    this.logs.push(entry)
+    this.trimLogs()
+
+    if (entry.traceId && entry.stepId && entry.stepName) {
+      const key = `${entry.traceId}::${entry.stepId}`
+      if (entry.status === 'running') {
+        const previous = this.activeSteps.get(key)
+        this.activeSteps.set(key, {
+          key,
+          traceId: entry.traceId,
+          stepId: entry.stepId,
+          stepName: entry.stepName,
+          source: entry.source,
+          startedAt: previous?.startedAt || entry.ts,
+          lastUpdatedAt: entry.ts,
+          message: entry.message
+        })
+      } else if (entry.status === 'done' || entry.status === 'failed' || entry.status === 'timeout') {
+        this.activeSteps.delete(key)
+      }
+    }
+
+    return entry
+  }
+
+  stepStart(input: StepStartInput): ExportCardDiagLogEntry {
+    return this.log({
+      source: input.source,
+      level: input.level || 'info',
+      message: input.message || `${input.stepName} 开始`,
+      traceId: input.traceId,
+      stepId: input.stepId,
+      stepName: input.stepName,
+      status: 'running',
+      data: input.data
+    })
+  }
+
+  stepEnd(input: StepEndInput): ExportCardDiagLogEntry {
+    return this.log({
+      source: input.source,
+      level: input.level || (input.status === 'done' ? 'info' : 'warn'),
+      message: input.message || `${input.stepName} ${input.status === 'done' ? '完成' : '结束'}`,
+      traceId: input.traceId,
+      stepId: input.stepId,
+      stepName: input.stepName,
+      status: input.status || 'done',
+      durationMs: input.durationMs,
+      data: input.data
+    })
+  }
+
+  clear() {
+    this.logs = []
+    this.activeSteps.clear()
+  }
+
+  snapshot(limit = 1200): ExportCardDiagSnapshot {
+    const capped = Number.isFinite(limit) ? Math.max(100, Math.min(5000, Math.floor(limit))) : 1200
+    const logs = this.logs.slice(-capped)
+    const now = Date.now()
+
+    const activeSteps = Array.from(this.activeSteps.values())
+      .map(step => ({
+        traceId: step.traceId,
+        stepId: step.stepId,
+        stepName: step.stepName,
+        source: step.source,
+        startedAt: step.startedAt,
+        lastUpdatedAt: step.lastUpdatedAt,
+        elapsedMs: Math.max(0, now - step.startedAt),
+        stallMs: Math.max(0, now - step.lastUpdatedAt),
+        message: step.message
+      }))
+      .sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt)
+
+    let errorCount = 0
+    let warnCount = 0
+    let timeoutCount = 0
+    for (const item of logs) {
+      if (item.level === 'error') errorCount += 1
+      if (item.level === 'warn') warnCount += 1
+      if (item.status === 'timeout') timeoutCount += 1
+    }
+
+    return {
+      logs,
+      activeSteps,
+      summary: {
+        totalLogs: this.logs.length,
+        activeStepCount: activeSteps.length,
+        errorCount,
+        warnCount,
+        timeoutCount,
+        lastUpdatedAt: logs.length > 0 ? logs[logs.length - 1].ts : 0
+      }
+    }
+  }
+
+  private normalizeExternalLogs(value: unknown[]): ExportCardDiagLogEntry[] {
+    const result: ExportCardDiagLogEntry[] = []
+    for (const item of value) {
+      if (!item || typeof item !== 'object') continue
+      const row = item as Record<string, unknown>
+      const tsRaw = row.ts ?? row.timestamp
+      const tsNum = Number(tsRaw)
+      const ts = Number.isFinite(tsNum) && tsNum > 0 ? Math.floor(tsNum) : Date.now()
+
+      const sourceRaw = String(row.source || 'frontend')
+      const source: ExportCardDiagSource = sourceRaw === 'main' || sourceRaw === 'backend' || sourceRaw === 'worker'
+        ? sourceRaw
+        : 'frontend'
+      const levelRaw = String(row.level || 'info')
+      const level: ExportCardDiagLevel = levelRaw === 'debug' || levelRaw === 'warn' || levelRaw === 'error'
+        ? levelRaw
+        : 'info'
+
+      const statusRaw = String(row.status || '')
+      const status: ExportCardDiagStatus | undefined = statusRaw === 'running' || statusRaw === 'done' || statusRaw === 'failed' || statusRaw === 'timeout'
+        ? statusRaw
+        : undefined
+
+      const durationRaw = Number(row.durationMs)
+      result.push({
+        id: String(row.id || this.nextId(ts)),
+        ts,
+        source,
+        level,
+        message: String(row.message || ''),
+        traceId: typeof row.traceId === 'string' ? row.traceId : undefined,
+        stepId: typeof row.stepId === 'string' ? row.stepId : undefined,
+        stepName: typeof row.stepName === 'string' ? row.stepName : undefined,
+        status,
+        durationMs: Number.isFinite(durationRaw) ? Math.max(0, Math.floor(durationRaw)) : undefined,
+        data: row.data && typeof row.data === 'object' ? row.data as Record<string, unknown> : undefined
+      })
+    }
+    return result
+  }
+
+  private serializeLogEntry(log: ExportCardDiagLogEntry): string {
+    return JSON.stringify(log)
+  }
+
+  private buildSummaryText(logs: ExportCardDiagLogEntry[], activeSteps: ExportCardDiagSnapshot['activeSteps']): string {
+    const total = logs.length
+    let errorCount = 0
+    let warnCount = 0
+    let timeoutCount = 0
+    let frontendCount = 0
+    let backendCount = 0
+    let mainCount = 0
+    let workerCount = 0
+
+    for (const item of logs) {
+      if (item.level === 'error') errorCount += 1
+      if (item.level === 'warn') warnCount += 1
+      if (item.status === 'timeout') timeoutCount += 1
+      if (item.source === 'frontend') frontendCount += 1
+      if (item.source === 'backend') backendCount += 1
+      if (item.source === 'main') mainCount += 1
+      if (item.source === 'worker') workerCount += 1
+    }
+
+    const lines: string[] = []
+    lines.push('WeFlow 导出卡片诊断摘要')
+    lines.push(`生成时间: ${new Date().toLocaleString('zh-CN')}`)
+    lines.push(`日志总数: ${total}`)
+    lines.push(`来源统计: frontend=${frontendCount}, main=${mainCount}, backend=${backendCount}, worker=${workerCount}`)
+    lines.push(`级别统计: warn=${warnCount}, error=${errorCount}, timeout=${timeoutCount}`)
+    lines.push(`当前活跃步骤: ${activeSteps.length}`)
+
+    if (activeSteps.length > 0) {
+      lines.push('')
+      lines.push('活跃步骤:')
+      for (const step of activeSteps.slice(0, 12)) {
+        lines.push(`- [${step.source}] ${step.stepName} trace=${step.traceId} elapsed=${step.elapsedMs}ms stall=${step.stallMs}ms`)
+      }
+    }
+
+    const latestErrors = logs.filter(item => item.level === 'error' || item.status === 'failed' || item.status === 'timeout').slice(-12)
+    if (latestErrors.length > 0) {
+      lines.push('')
+      lines.push('最近异常:')
+      for (const item of latestErrors) {
+        lines.push(`- ${new Date(item.ts).toLocaleTimeString('zh-CN')} [${item.source}] ${item.stepName || item.stepId || 'unknown'} ${item.status || item.level} ${item.message}`)
+      }
+    }
+
+    return lines.join('\n')
+  }
+
+  async exportCombinedLogs(filePath: string, frontendLogs: unknown[] = []): Promise<{
+    success: boolean
+    filePath?: string
+    summaryPath?: string
+    count?: number
+    error?: string
+  }> {
+    try {
+      const normalizedFrontend = this.normalizeExternalLogs(Array.isArray(frontendLogs) ? frontendLogs : [])
+      const merged = [...this.logs, ...normalizedFrontend]
+        .sort((a, b) => (a.ts - b.ts) || a.id.localeCompare(b.id))
+
+      const lines = merged.map(item => this.serializeLogEntry(item)).join('\n')
+      await mkdir(dirname(filePath), { recursive: true })
+      await writeFile(filePath, lines ? `${lines}\n` : '', 'utf8')
+
+      const ext = extname(filePath)
+      const baseName = ext ? basename(filePath, ext) : basename(filePath)
+      const summaryPath = join(dirname(filePath), `${baseName}.txt`)
+      const snapshot = this.snapshot(1500)
+      const summaryText = this.buildSummaryText(merged, snapshot.activeSteps)
+      await writeFile(summaryPath, summaryText, 'utf8')
+
+      return {
+        success: true,
+        filePath,
+        summaryPath,
+        count: merged.length
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: String(error)
+      }
+    }
+  }
+}
+
+export const exportCardDiagnosticsService = new ExportCardDiagnosticsService()

electron/services/exportContentStatsCacheService.ts

@@ -0,0 +1,229 @@
+import { join, dirname } from 'path'
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs'
+import { ConfigService } from './config'
+
+const CACHE_VERSION = 1
+const MAX_SCOPE_ENTRIES = 12
+const MAX_SESSION_ENTRIES_PER_SCOPE = 6000
+
+export interface ExportContentSessionStatsEntry {
+  updatedAt: number
+  hasAny: boolean
+  hasVoice: boolean
+  hasImage: boolean
+  hasVideo: boolean
+  hasEmoji: boolean
+  mediaReady: boolean
+}
+
+export interface ExportContentScopeStatsEntry {
+  updatedAt: number
+  sessions: Record<string, ExportContentSessionStatsEntry>
+}
+
+interface ExportContentStatsStore {
+  version: number
+  scopes: Record<string, ExportContentScopeStatsEntry>
+}
+
+function toNonNegativeInt(value: unknown): number | undefined {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return undefined
+  return Math.max(0, Math.floor(value))
+}
+
+function toBoolean(value: unknown, fallback = false): boolean {
+  if (typeof value === 'boolean') return value
+  return fallback
+}
+
+function normalizeSessionStatsEntry(raw: unknown): ExportContentSessionStatsEntry | null {
+  if (!raw || typeof raw !== 'object') return null
+  const source = raw as Record<string, unknown>
+  const updatedAt = toNonNegativeInt(source.updatedAt)
+  if (updatedAt === undefined) return null
+  return {
+    updatedAt,
+    hasAny: toBoolean(source.hasAny, false),
+    hasVoice: toBoolean(source.hasVoice, false),
+    hasImage: toBoolean(source.hasImage, false),
+    hasVideo: toBoolean(source.hasVideo, false),
+    hasEmoji: toBoolean(source.hasEmoji, false),
+    mediaReady: toBoolean(source.mediaReady, false)
+  }
+}
+
+function normalizeScopeStatsEntry(raw: unknown): ExportContentScopeStatsEntry | null {
+  if (!raw || typeof raw !== 'object') return null
+  const source = raw as Record<string, unknown>
+  const updatedAt = toNonNegativeInt(source.updatedAt)
+  if (updatedAt === undefined) return null
+
+  const sessionsRaw = source.sessions
+  if (!sessionsRaw || typeof sessionsRaw !== 'object') {
+    return {
+      updatedAt,
+      sessions: {}
+    }
+  }
+
+  const sessions: Record<string, ExportContentSessionStatsEntry> = {}
+  for (const [sessionId, entryRaw] of Object.entries(sessionsRaw as Record<string, unknown>)) {
+    const normalized = normalizeSessionStatsEntry(entryRaw)
+    if (!normalized) continue
+    sessions[sessionId] = normalized
+  }
+
+  return {
+    updatedAt,
+    sessions
+  }
+}
+
+function cloneScope(scope: ExportContentScopeStatsEntry): ExportContentScopeStatsEntry {
+  return {
+    updatedAt: scope.updatedAt,
+    sessions: Object.fromEntries(
+      Object.entries(scope.sessions).map(([sessionId, entry]) => [sessionId, { ...entry }])
+    )
+  }
+}
+
+export class ExportContentStatsCacheService {
+  private readonly cacheFilePath: string
+  private store: ExportContentStatsStore = {
+    version: CACHE_VERSION,
+    scopes: {}
+  }
+
+  constructor(cacheBasePath?: string) {
+    const basePath = cacheBasePath && cacheBasePath.trim().length > 0
+      ? cacheBasePath
+      : ConfigService.getInstance().getCacheBasePath()
+    this.cacheFilePath = join(basePath, 'export-content-stats.json')
+    this.ensureCacheDir()
+    this.load()
+  }
+
+  private ensureCacheDir(): void {
+    const dir = dirname(this.cacheFilePath)
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true })
+    }
+  }
+
+  private load(): void {
+    if (!existsSync(this.cacheFilePath)) return
+    try {
+      const raw = readFileSync(this.cacheFilePath, 'utf8')
+      const parsed = JSON.parse(raw) as unknown
+      if (!parsed || typeof parsed !== 'object') {
+        this.store = { version: CACHE_VERSION, scopes: {} }
+        return
+      }
+
+      const payload = parsed as Record<string, unknown>
+      const scopesRaw = payload.scopes
+      if (!scopesRaw || typeof scopesRaw !== 'object') {
+        this.store = { version: CACHE_VERSION, scopes: {} }
+        return
+      }
+
+      const scopes: Record<string, ExportContentScopeStatsEntry> = {}
+      for (const [scopeKey, scopeRaw] of Object.entries(scopesRaw as Record<string, unknown>)) {
+        const normalizedScope = normalizeScopeStatsEntry(scopeRaw)
+        if (!normalizedScope) continue
+        scopes[scopeKey] = normalizedScope
+      }
+
+      this.store = {
+        version: CACHE_VERSION,
+        scopes
+      }
+    } catch (error) {
+      console.error('ExportContentStatsCacheService: 载入缓存失败', error)
+      this.store = { version: CACHE_VERSION, scopes: {} }
+    }
+  }
+
+  getScope(scopeKey: string): ExportContentScopeStatsEntry | undefined {
+    if (!scopeKey) return undefined
+    const rawScope = this.store.scopes[scopeKey]
+    if (!rawScope) return undefined
+    const normalizedScope = normalizeScopeStatsEntry(rawScope)
+    if (!normalizedScope) {
+      delete this.store.scopes[scopeKey]
+      this.persist()
+      return undefined
+    }
+    this.store.scopes[scopeKey] = normalizedScope
+    return cloneScope(normalizedScope)
+  }
+
+  setScope(scopeKey: string, scope: ExportContentScopeStatsEntry): void {
+    if (!scopeKey) return
+    const normalized = normalizeScopeStatsEntry(scope)
+    if (!normalized) return
+    this.store.scopes[scopeKey] = normalized
+    this.trimScope(scopeKey)
+    this.trimScopes()
+    this.persist()
+  }
+
+  deleteSession(scopeKey: string, sessionId: string): void {
+    if (!scopeKey || !sessionId) return
+    const scope = this.store.scopes[scopeKey]
+    if (!scope) return
+    if (!(sessionId in scope.sessions)) return
+    delete scope.sessions[sessionId]
+    if (Object.keys(scope.sessions).length === 0) {
+      delete this.store.scopes[scopeKey]
+    } else {
+      scope.updatedAt = Date.now()
+    }
+    this.persist()
+  }
+
+  clearScope(scopeKey: string): void {
+    if (!scopeKey) return
+    if (!this.store.scopes[scopeKey]) return
+    delete this.store.scopes[scopeKey]
+    this.persist()
+  }
+
+  clearAll(): void {
+    this.store = { version: CACHE_VERSION, scopes: {} }
+    try {
+      rmSync(this.cacheFilePath, { force: true })
+    } catch (error) {
+      console.error('ExportContentStatsCacheService: 清理缓存失败', error)
+    }
+  }
+
+  private trimScope(scopeKey: string): void {
+    const scope = this.store.scopes[scopeKey]
+    if (!scope) return
+
+    const entries = Object.entries(scope.sessions)
+    if (entries.length <= MAX_SESSION_ENTRIES_PER_SCOPE) return
+
+    entries.sort((a, b) => b[1].updatedAt - a[1].updatedAt)
+    scope.sessions = Object.fromEntries(entries.slice(0, MAX_SESSION_ENTRIES_PER_SCOPE))
+  }
+
+  private trimScopes(): void {
+    const scopeEntries = Object.entries(this.store.scopes)
+    if (scopeEntries.length <= MAX_SCOPE_ENTRIES) return
+
+    scopeEntries.sort((a, b) => b[1].updatedAt - a[1].updatedAt)
+    this.store.scopes = Object.fromEntries(scopeEntries.slice(0, MAX_SCOPE_ENTRIES))
+  }
+
+  private persist(): void {
+    try {
+      this.ensureCacheDir()
+      writeFileSync(this.cacheFilePath, JSON.stringify(this.store), 'utf8')
+    } catch (error) {
+      console.error('ExportContentStatsCacheService: 持久化缓存失败', error)
+    }
+  }
+}

electron/services/exportRecordService.ts

@@ -0,0 +1,95 @@
+import { app } from 'electron'
+import fs from 'fs'
+import path from 'path'
+
+export interface ExportRecord {
+  exportTime: number
+  format: string
+  messageCount: number
+  sourceLatestMessageTimestamp?: number
+  outputPath?: string
+}
+
+type RecordStore = Record<string, ExportRecord[]>
+
+class ExportRecordService {
+  private filePath: string | null = null
+  private loaded = false
+  private store: RecordStore = {}
+
+  private resolveFilePath(): string {
+    if (this.filePath) return this.filePath
+    const userDataPath = app.getPath('userData')
+    fs.mkdirSync(userDataPath, { recursive: true })
+    this.filePath = path.join(userDataPath, 'weflow-export-records.json')
+    return this.filePath
+  }
+
+  private ensureLoaded(): void {
+    if (this.loaded) return
+    this.loaded = true
+    const filePath = this.resolveFilePath()
+    try {
+      if (!fs.existsSync(filePath)) return
+      const raw = fs.readFileSync(filePath, 'utf-8')
+      const parsed = JSON.parse(raw)
+      if (parsed && typeof parsed === 'object') {
+        this.store = parsed as RecordStore
+      }
+    } catch {
+      this.store = {}
+    }
+  }
+
+  private persist(): void {
+    try {
+      const filePath = this.resolveFilePath()
+      fs.writeFileSync(filePath, JSON.stringify(this.store), 'utf-8')
+    } catch {
+      // ignore persist errors to avoid blocking export flow
+    }
+  }
+
+  getLatestRecord(sessionId: string, format: string): ExportRecord | null {
+    this.ensureLoaded()
+    const records = this.store[sessionId]
+    if (!records || records.length === 0) return null
+    for (let i = records.length - 1; i >= 0; i--) {
+      const record = records[i]
+      if (record && record.format === format) return record
+    }
+    return null
+  }
+
+  saveRecord(
+    sessionId: string,
+    format: string,
+    messageCount: number,
+    extra?: {
+      sourceLatestMessageTimestamp?: number
+      outputPath?: string
+    }
+  ): void {
+    this.ensureLoaded()
+    const normalizedSessionId = String(sessionId || '').trim()
+    if (!normalizedSessionId) return
+    if (!this.store[normalizedSessionId]) {
+      this.store[normalizedSessionId] = []
+    }
+    const list = this.store[normalizedSessionId]
+    list.push({
+      exportTime: Date.now(),
+      format,
+      messageCount,
+      sourceLatestMessageTimestamp: extra?.sourceLatestMessageTimestamp,
+      outputPath: extra?.outputPath
+    })
+    // keep the latest 30 records per session
+    if (list.length > 30) {
+      this.store[normalizedSessionId] = list.slice(-30)
+    }
+    this.persist()
+  }
+}
+
+export const exportRecordService = new ExportRecordService()

electron/services/groupAnalyticsService.ts

@@ -21,6 +21,12 @@ export interface GroupMember {
   alias?: string
   remark?: string
   groupNickname?: string
+  isOwner?: boolean
+}
+
+export interface GroupMembersPanelEntry extends GroupMember {
+  isFriend: boolean
+  messageCount: number
 }
 
 export interface GroupMessageRank {
@@ -43,8 +49,28 @@ export interface GroupMediaStats {
   total: number
 }
 
+interface GroupMemberContactInfo {
+  remark: string
+  nickName: string
+  alias: string
+  username: string
+  userName: string
+  encryptUsername: string
+  encryptUserName: string
+  localType: number
+}
+
 class GroupAnalyticsService {
   private configService: ConfigService
+  private readonly groupMembersPanelCacheTtlMs = 10 * 60 * 1000
+  private readonly groupMembersPanelMembersTimeoutMs = 12 * 1000
+  private readonly groupMembersPanelFullTimeoutMs = 25 * 1000
+  private readonly groupMembersPanelCache = new Map<string, { updatedAt: number; data: GroupMembersPanelEntry[] }>()
+  private readonly groupMembersPanelInFlight = new Map<
+    string,
+    Promise<{ success: boolean; data?: GroupMembersPanelEntry[]; error?: string; fromCache?: boolean; updatedAt?: number }>
+  >()
+  private readonly friendExcludeNames = new Set(['medianote', 'floatbottle', 'qmessage', 'qqmail', 'fmessage'])
 
   constructor() {
     this.configService = new ConfigService()
@@ -89,6 +115,128 @@ class GroupAnalyticsService {
     return cleaned
   }
 
+  private resolveMemberUsername(
+    candidate: unknown,
+    memberLookup: Map<string, string>
+  ): string | null {
+    if (typeof candidate !== 'string') return null
+    const raw = candidate.trim()
+    if (!raw) return null
+    if (memberLookup.has(raw)) return memberLookup.get(raw) || null
+    const cleaned = this.cleanAccountDirName(raw)
+    if (memberLookup.has(cleaned)) return memberLookup.get(cleaned) || null
+
+    const parts = raw.split(/[,\s;|]+/).filter(Boolean)
+    for (const part of parts) {
+      if (memberLookup.has(part)) return memberLookup.get(part) || null
+      const normalizedPart = this.cleanAccountDirName(part)
+      if (memberLookup.has(normalizedPart)) return memberLookup.get(normalizedPart) || null
+    }
+
+    if ((raw.startsWith('{') || raw.startsWith('[')) && raw.length < 4096) {
+      try {
+        const parsed = JSON.parse(raw)
+        return this.extractOwnerUsername(parsed, memberLookup, 0)
+      } catch {
+        return null
+      }
+    }
+
+    return null
+  }
+
+  private extractOwnerUsername(
+    value: unknown,
+    memberLookup: Map<string, string>,
+    depth: number
+  ): string | null {
+    if (depth > 4 || value == null) return null
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array) return null
+
+    if (typeof value === 'string') {
+      return this.resolveMemberUsername(value, memberLookup)
+    }
+
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const owner = this.extractOwnerUsername(item, memberLookup, depth + 1)
+        if (owner) return owner
+      }
+      return null
+    }
+
+    if (typeof value !== 'object') return null
+    const row = value as Record<string, unknown>
+
+    for (const [key, entry] of Object.entries(row)) {
+      const keyLower = key.toLowerCase()
+      if (!keyLower.includes('owner') && !keyLower.includes('host') && !keyLower.includes('creator')) {
+        continue
+      }
+
+      if (typeof entry === 'boolean') {
+        if (entry && typeof row.username === 'string') {
+          const owner = this.resolveMemberUsername(row.username, memberLookup)
+          if (owner) return owner
+        }
+        continue
+      }
+
+      const owner = this.extractOwnerUsername(entry, memberLookup, depth + 1)
+      if (owner) return owner
+    }
+
+    return null
+  }
+
+  private async detectGroupOwnerUsername(
+    chatroomId: string,
+    members: Array<{ username: string; [key: string]: unknown }>
+  ): Promise<string | undefined> {
+    const memberLookup = new Map<string, string>()
+    for (const member of members) {
+      const username = String(member.username || '').trim()
+      if (!username) continue
+      const cleaned = this.cleanAccountDirName(username)
+      memberLookup.set(username, username)
+      memberLookup.set(cleaned, username)
+    }
+    if (memberLookup.size === 0) return undefined
+
+    const tryResolve = (candidate: unknown): string | undefined => {
+      const owner = this.extractOwnerUsername(candidate, memberLookup, 0)
+      return owner || undefined
+    }
+
+    for (const member of members) {
+      const owner = tryResolve(member)
+      if (owner) return owner
+    }
+
+    try {
+      const groupContact = await wcdbService.getContact(chatroomId)
+      if (groupContact.success && groupContact.contact) {
+        const owner = tryResolve(groupContact.contact)
+        if (owner) return owner
+      }
+    } catch {
+      // ignore
+    }
+
+    try {
+      const escapedChatroomId = chatroomId.replace(/'/g, "''")
+      const roomResult = await wcdbService.execQuery('contact', null, `SELECT * FROM chat_room WHERE username='${escapedChatroomId}' LIMIT 1`)
+      if (roomResult.success && roomResult.rows && roomResult.rows.length > 0) {
+        const owner = tryResolve(roomResult.rows[0])
+        if (owner) return owner
+      }
+    } catch {
+      // ignore
+    }
+
+    return undefined
+  }
+
   private async ensureConnected(): Promise<{ success: boolean; error?: string }> {
     const wxid = this.configService.get('myWxid')
     const dbPath = this.configService.get('dbPath')
@@ -296,6 +444,203 @@ class GroupAnalyticsService {
     return Array.from(set)
   }
 
+  private toNonNegativeInteger(value: unknown): number {
+    const parsed = Number(value)
+    if (!Number.isFinite(parsed)) return 0
+    return Math.max(0, Math.floor(parsed))
+  }
+
+  private pickStringField(row: Record<string, unknown>, keys: string[]): string {
+    for (const key of keys) {
+      const value = row[key]
+      if (value == null) continue
+      const text = String(value).trim()
+      if (text) return text
+    }
+    return ''
+  }
+
+  private pickIntegerField(row: Record<string, unknown>, keys: string[], fallback: number = 0): number {
+    for (const key of keys) {
+      const value = row[key]
+      if (value == null || value === '') continue
+      const parsed = Number(value)
+      if (Number.isFinite(parsed)) return Math.floor(parsed)
+    }
+    return fallback
+  }
+
+  private buildGroupMembersPanelCacheKey(chatroomId: string, includeMessageCounts: boolean): string {
+    const dbPath = String(this.configService.get('dbPath') || '').trim()
+    const wxid = this.cleanAccountDirName(String(this.configService.get('myWxid') || '').trim())
+    const mode = includeMessageCounts ? 'full' : 'members'
+    return `${dbPath}::${wxid}::${chatroomId}::${mode}`
+  }
+
+  private pruneGroupMembersPanelCache(maxEntries: number = 80): void {
+    if (this.groupMembersPanelCache.size <= maxEntries) return
+    const entries = Array.from(this.groupMembersPanelCache.entries())
+      .sort((a, b) => a[1].updatedAt - b[1].updatedAt)
+    const removeCount = this.groupMembersPanelCache.size - maxEntries
+    for (let i = 0; i < removeCount; i += 1) {
+      this.groupMembersPanelCache.delete(entries[i][0])
+    }
+  }
+
+  private async withPromiseTimeout<T>(
+    promise: Promise<T>,
+    timeoutMs: number,
+    timeoutResult: T
+  ): Promise<T> {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      return promise
+    }
+
+    let timeoutTimer: ReturnType<typeof setTimeout> | null = null
+    const timeoutPromise = new Promise<T>((resolve) => {
+      timeoutTimer = setTimeout(() => {
+        resolve(timeoutResult)
+      }, timeoutMs)
+    })
+
+    try {
+      return await Promise.race([promise, timeoutPromise])
+    } finally {
+      if (timeoutTimer) {
+        clearTimeout(timeoutTimer)
+      }
+    }
+  }
+
+  private async buildGroupMemberContactLookup(usernames: string[]): Promise<Map<string, GroupMemberContactInfo>> {
+    const lookup = new Map<string, GroupMemberContactInfo>()
+    const candidates = this.buildIdCandidates(usernames)
+    if (candidates.length === 0) return lookup
+
+    const appendContactsToLookup = (rows: Record<string, unknown>[]) => {
+      for (const row of rows) {
+        const contact: GroupMemberContactInfo = {
+          remark: this.pickStringField(row, ['remark', 'WCDB_CT_remark']),
+          nickName: this.pickStringField(row, ['nick_name', 'nickName', 'WCDB_CT_nick_name']),
+          alias: this.pickStringField(row, ['alias', 'WCDB_CT_alias']),
+          username: this.pickStringField(row, ['username', 'WCDB_CT_username']),
+          userName: this.pickStringField(row, ['user_name', 'userName', 'WCDB_CT_user_name']),
+          encryptUsername: this.pickStringField(row, ['encrypt_username', 'encryptUsername', 'WCDB_CT_encrypt_username']),
+          encryptUserName: this.pickStringField(row, ['encrypt_user_name', 'encryptUserName', 'WCDB_CT_encrypt_user_name']),
+          localType: this.pickIntegerField(row, ['local_type', 'localType', 'WCDB_CT_local_type'], 0)
+        }
+        const lookupKeys = this.buildIdCandidates([
+          contact.username,
+          contact.userName,
+          contact.encryptUsername,
+          contact.encryptUserName,
+          contact.alias
+        ])
+        for (const key of lookupKeys) {
+          const normalized = key.toLowerCase()
+          if (!lookup.has(normalized)) {
+            lookup.set(normalized, contact)
+          }
+        }
+      }
+    }
+
+    const batchSize = 200
+    for (let i = 0; i < candidates.length; i += batchSize) {
+      const batch = candidates.slice(i, i + batchSize)
+      if (batch.length === 0) continue
+
+      const inList = batch.map((username) => `'${username.replace(/'/g, "''")}'`).join(',')
+      const lightweightSql = `
+        SELECT username, user_name, encrypt_username, encrypt_user_name, remark, nick_name, alias, local_type
+        FROM contact
+        WHERE username IN (${inList})
+      `
+      let result = await wcdbService.execQuery('contact', null, lightweightSql)
+      if (!result.success || !result.rows) {
+        // 兼容历史/变体列名，轻查询失败时回退全字段查询，避免好友标识丢失
+        result = await wcdbService.execQuery('contact', null, `SELECT * FROM contact WHERE username IN (${inList})`)
+      }
+      if (!result.success || !result.rows) continue
+      appendContactsToLookup(result.rows as Record<string, unknown>[])
+    }
+    return lookup
+  }
+
+  private resolveContactByCandidates(
+    lookup: Map<string, GroupMemberContactInfo>,
+    candidates: Array<string | undefined | null>
+  ): GroupMemberContactInfo | undefined {
+    const ids = this.buildIdCandidates(candidates)
+    for (const id of ids) {
+      const hit = lookup.get(id.toLowerCase())
+      if (hit) return hit
+    }
+    return undefined
+  }
+
+  private async buildGroupMessageCountLookup(chatroomId: string): Promise<Map<string, number>> {
+    const lookup = new Map<string, number>()
+    const result = await wcdbService.getGroupStats(chatroomId, 0, 0)
+    if (!result.success || !result.data) return lookup
+
+    const sessionData = result.data?.sessions?.[chatroomId]
+    if (!sessionData || !sessionData.senders) return lookup
+
+    const idMap = result.data.idMap || {}
+    for (const [senderId, rawCount] of Object.entries(sessionData.senders as Record<string, number>)) {
+      const username = String(idMap[senderId] || senderId || '').trim()
+      if (!username) continue
+      const count = this.toNonNegativeInteger(rawCount)
+      const keys = this.buildIdCandidates([username])
+      for (const key of keys) {
+        const normalized = key.toLowerCase()
+        const prev = lookup.get(normalized) || 0
+        if (count > prev) {
+          lookup.set(normalized, count)
+        }
+      }
+    }
+    return lookup
+  }
+
+  private resolveMessageCountByCandidates(
+    lookup: Map<string, number>,
+    candidates: Array<string | undefined | null>
+  ): number {
+    let maxCount = 0
+    const ids = this.buildIdCandidates(candidates)
+    for (const id of ids) {
+      const count = lookup.get(id.toLowerCase())
+      if (typeof count === 'number' && count > maxCount) {
+        maxCount = count
+      }
+    }
+    return maxCount
+  }
+
+  private isFriendMember(wxid: string, contact?: GroupMemberContactInfo): boolean {
+    const normalizedWxid = String(wxid || '').trim().toLowerCase()
+    if (!normalizedWxid) return false
+    if (normalizedWxid.includes('@chatroom') || normalizedWxid.startsWith('gh_')) return false
+    if (this.friendExcludeNames.has(normalizedWxid)) return false
+    if (!contact) return false
+    return contact.localType === 1
+  }
+
+  private sortGroupMembersPanelEntries(members: GroupMembersPanelEntry[]): GroupMembersPanelEntry[] {
+    return members.sort((a, b) => {
+      const ownerDiff = Number(Boolean(b.isOwner)) - Number(Boolean(a.isOwner))
+      if (ownerDiff !== 0) return ownerDiff
+
+      const friendDiff = Number(Boolean(b.isFriend)) - Number(Boolean(a.isFriend))
+      if (friendDiff !== 0) return friendDiff
+
+      if (a.messageCount !== b.messageCount) return b.messageCount - a.messageCount
+      return a.displayName.localeCompare(b.displayName, 'zh-Hans-CN')
+    })
+  }
+
   private resolveGroupNicknameByCandidates(groupNicknames: Map<string, string>, candidates: string[]): string {
     const idCandidates = this.buildIdCandidates(candidates)
     if (idCandidates.length === 0) return ''
@@ -483,6 +828,167 @@ class GroupAnalyticsService {
     }
   }
 
+  private async loadGroupMembersPanelDataFresh(
+    chatroomId: string,
+    includeMessageCounts: boolean
+  ): Promise<{ success: boolean; data?: GroupMembersPanelEntry[]; error?: string }> {
+    const membersResult = await wcdbService.getGroupMembers(chatroomId)
+    if (!membersResult.success || !membersResult.members) {
+      return { success: false, error: membersResult.error || '获取群成员失败' }
+    }
+
+    const members = membersResult.members as Array<{
+      username: string
+      avatarUrl?: string
+      originalName?: string
+      [key: string]: unknown
+    }>
+    if (members.length === 0) return { success: true, data: [] }
+
+    const usernames = members
+      .map((member) => String(member.username || '').trim())
+      .filter(Boolean)
+    if (usernames.length === 0) return { success: true, data: [] }
+
+    const displayNamesPromise = wcdbService.getDisplayNames(usernames)
+    const contactLookupPromise = this.buildGroupMemberContactLookup(usernames)
+    const ownerPromise = this.detectGroupOwnerUsername(chatroomId, members)
+    const messageCountLookupPromise = includeMessageCounts
+      ? this.buildGroupMessageCountLookup(chatroomId)
+      : Promise.resolve(new Map<string, number>())
+
+    const [displayNames, contactLookup, ownerUsername, messageCountLookup] = await Promise.all([
+      displayNamesPromise,
+      contactLookupPromise,
+      ownerPromise,
+      messageCountLookupPromise
+    ])
+
+    const nicknameCandidates = this.buildIdCandidates([
+      ...members.map((member) => member.username),
+      ...members.map((member) => member.originalName),
+      ...Array.from(contactLookup.values()).map((contact) => contact?.username),
+      ...Array.from(contactLookup.values()).map((contact) => contact?.userName),
+      ...Array.from(contactLookup.values()).map((contact) => contact?.encryptUsername),
+      ...Array.from(contactLookup.values()).map((contact) => contact?.encryptUserName),
+      ...Array.from(contactLookup.values()).map((contact) => contact?.alias)
+    ])
+    const groupNicknames = await this.getGroupNicknamesForRoom(chatroomId, nicknameCandidates)
+    const myWxid = this.cleanAccountDirName(this.configService.get('myWxid') || '')
+    let myGroupMessageCountHint: number | undefined
+
+    const data: GroupMembersPanelEntry[] = members
+      .map((member) => {
+        const wxid = String(member.username || '').trim()
+        if (!wxid) return null
+
+        const contact = this.resolveContactByCandidates(contactLookup, [wxid, member.originalName])
+        const nickname = contact?.nickName || ''
+        const remark = contact?.remark || ''
+        const alias = contact?.alias || ''
+        const normalizedWxid = this.cleanAccountDirName(wxid)
+        const lookupCandidates = this.buildIdCandidates([
+          wxid,
+          member.originalName as string | undefined,
+          contact?.username,
+          contact?.userName,
+          contact?.encryptUsername,
+          contact?.encryptUserName,
+          alias
+        ])
+        if (normalizedWxid === myWxid) {
+          lookupCandidates.push(myWxid)
+        }
+        const groupNickname = this.resolveGroupNicknameByCandidates(groupNicknames, lookupCandidates)
+        const displayName = displayNames.success && displayNames.map ? (displayNames.map[wxid] || wxid) : wxid
+
+        return {
+          username: wxid,
+          displayName,
+          nickname,
+          alias,
+          remark,
+          groupNickname,
+          avatarUrl: member.avatarUrl,
+          isOwner: Boolean(ownerUsername && ownerUsername === wxid),
+          isFriend: this.isFriendMember(wxid, contact),
+          messageCount: this.resolveMessageCountByCandidates(messageCountLookup, lookupCandidates)
+        }
+      })
+      .filter((member): member is GroupMembersPanelEntry => Boolean(member))
+
+    if (includeMessageCounts && myWxid) {
+      const selfEntry = data.find((member) => this.cleanAccountDirName(member.username) === myWxid)
+      if (selfEntry && Number.isFinite(selfEntry.messageCount)) {
+        myGroupMessageCountHint = Math.max(0, Math.floor(selfEntry.messageCount))
+      }
+    }
+
+    if (includeMessageCounts && Number.isFinite(myGroupMessageCountHint)) {
+      void chatService.setGroupMyMessageCountHint(chatroomId, myGroupMessageCountHint as number)
+    }
+
+    return { success: true, data: this.sortGroupMembersPanelEntries(data) }
+  }
+
+  async getGroupMembersPanelData(
+    chatroomId: string,
+    options?: { forceRefresh?: boolean; includeMessageCounts?: boolean }
+  ): Promise<{ success: boolean; data?: GroupMembersPanelEntry[]; error?: string; fromCache?: boolean; updatedAt?: number }> {
+    try {
+      const normalizedChatroomId = String(chatroomId || '').trim()
+      if (!normalizedChatroomId) return { success: false, error: '群聊ID不能为空' }
+
+      const forceRefresh = Boolean(options?.forceRefresh)
+      const includeMessageCounts = options?.includeMessageCounts !== false
+      const cacheKey = this.buildGroupMembersPanelCacheKey(normalizedChatroomId, includeMessageCounts)
+      const now = Date.now()
+      const cached = this.groupMembersPanelCache.get(cacheKey)
+      if (!forceRefresh && cached && now - cached.updatedAt < this.groupMembersPanelCacheTtlMs) {
+        return { success: true, data: cached.data, fromCache: true, updatedAt: cached.updatedAt }
+      }
+
+      if (!forceRefresh) {
+        const pending = this.groupMembersPanelInFlight.get(cacheKey)
+        if (pending) return pending
+      }
+
+      const requestPromise = (async () => {
+        const conn = await this.ensureConnected()
+        if (!conn.success) return { success: false, error: conn.error }
+
+        const timeoutMs = includeMessageCounts
+          ? this.groupMembersPanelFullTimeoutMs
+          : this.groupMembersPanelMembersTimeoutMs
+        const fresh = await this.withPromiseTimeout(
+          this.loadGroupMembersPanelDataFresh(normalizedChatroomId, includeMessageCounts),
+          timeoutMs,
+          {
+            success: false,
+            error: includeMessageCounts
+              ? '群成员发言统计加载超时，请稍后重试'
+              : '群成员列表加载超时，请稍后重试'
+          }
+        )
+        if (!fresh.success || !fresh.data) {
+          return { success: false, error: fresh.error || '获取群成员面板数据失败' }
+        }
+
+        const updatedAt = Date.now()
+        this.groupMembersPanelCache.set(cacheKey, { updatedAt, data: fresh.data })
+        this.pruneGroupMembersPanelCache()
+        return { success: true, data: fresh.data, fromCache: false, updatedAt }
+      })().finally(() => {
+        this.groupMembersPanelInFlight.delete(cacheKey)
+      })
+
+      this.groupMembersPanelInFlight.set(cacheKey, requestPromise)
+      return await requestPromise
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
   async getGroupMembers(chatroomId: string): Promise<{ success: boolean; data?: GroupMember[]; error?: string }> {
     try {
       const conn = await this.ensureConnected()
@@ -497,6 +1003,7 @@ class GroupAnalyticsService {
         username: string
         avatarUrl?: string
         originalName?: string
+        [key: string]: unknown
       }>
       const usernames = members.map((m) => m.username).filter(Boolean)
 
@@ -543,6 +1050,7 @@ class GroupAnalyticsService {
       const groupNicknames = await this.getGroupNicknamesForRoom(chatroomId, nicknameCandidates)
 
       const myWxid = this.cleanAccountDirName(this.configService.get('myWxid') || '')
+      const ownerUsername = await this.detectGroupOwnerUsername(chatroomId, members)
       const data: GroupMember[] = members.map((m) => {
         const wxid = m.username || ''
         const displayName = displayNames.success && displayNames.map ? (displayNames.map[wxid] || wxid) : wxid
@@ -572,7 +1080,8 @@ class GroupAnalyticsService {
           alias,
           remark,
           groupNickname,
-          avatarUrl: m.avatarUrl
+          avatarUrl: m.avatarUrl,
+          isOwner: Boolean(ownerUsername && ownerUsername === wxid)
         }
       })
 

electron/services/groupMyMessageCountCacheService.ts

@@ -0,0 +1,204 @@
+import { join, dirname } from 'path'
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'fs'
+import { ConfigService } from './config'
+
+const CACHE_VERSION = 1
+const MAX_GROUP_ENTRIES_PER_SCOPE = 3000
+const MAX_SCOPE_ENTRIES = 12
+
+export interface GroupMyMessageCountCacheEntry {
+  updatedAt: number
+  messageCount: number
+}
+
+interface GroupMyMessageCountScopeMap {
+  [chatroomId: string]: GroupMyMessageCountCacheEntry
+}
+
+interface GroupMyMessageCountCacheStore {
+  version: number
+  scopes: Record<string, GroupMyMessageCountScopeMap>
+}
+
+function toNonNegativeInt(value: unknown): number | undefined {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return undefined
+  return Math.max(0, Math.floor(value))
+}
+
+function normalizeEntry(raw: unknown): GroupMyMessageCountCacheEntry | null {
+  if (!raw || typeof raw !== 'object') return null
+  const source = raw as Record<string, unknown>
+  const updatedAt = toNonNegativeInt(source.updatedAt)
+  const messageCount = toNonNegativeInt(source.messageCount)
+  if (updatedAt === undefined || messageCount === undefined) return null
+  return {
+    updatedAt,
+    messageCount
+  }
+}
+
+export class GroupMyMessageCountCacheService {
+  private readonly cacheFilePath: string
+  private store: GroupMyMessageCountCacheStore = {
+    version: CACHE_VERSION,
+    scopes: {}
+  }
+
+  constructor(cacheBasePath?: string) {
+    const basePath = cacheBasePath && cacheBasePath.trim().length > 0
+      ? cacheBasePath
+      : ConfigService.getInstance().getCacheBasePath()
+    this.cacheFilePath = join(basePath, 'group-my-message-counts.json')
+    this.ensureCacheDir()
+    this.load()
+  }
+
+  private ensureCacheDir(): void {
+    const dir = dirname(this.cacheFilePath)
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true })
+    }
+  }
+
+  private load(): void {
+    if (!existsSync(this.cacheFilePath)) return
+    try {
+      const raw = readFileSync(this.cacheFilePath, 'utf8')
+      const parsed = JSON.parse(raw) as unknown
+      if (!parsed || typeof parsed !== 'object') {
+        this.store = { version: CACHE_VERSION, scopes: {} }
+        return
+      }
+
+      const payload = parsed as Record<string, unknown>
+      const scopesRaw = payload.scopes
+      if (!scopesRaw || typeof scopesRaw !== 'object') {
+        this.store = { version: CACHE_VERSION, scopes: {} }
+        return
+      }
+
+      const scopes: Record<string, GroupMyMessageCountScopeMap> = {}
+      for (const [scopeKey, scopeValue] of Object.entries(scopesRaw as Record<string, unknown>)) {
+        if (!scopeValue || typeof scopeValue !== 'object') continue
+        const normalizedScope: GroupMyMessageCountScopeMap = {}
+        for (const [chatroomId, entryRaw] of Object.entries(scopeValue as Record<string, unknown>)) {
+          const entry = normalizeEntry(entryRaw)
+          if (!entry) continue
+          normalizedScope[chatroomId] = entry
+        }
+        if (Object.keys(normalizedScope).length > 0) {
+          scopes[scopeKey] = normalizedScope
+        }
+      }
+
+      this.store = {
+        version: CACHE_VERSION,
+        scopes
+      }
+    } catch (error) {
+      console.error('GroupMyMessageCountCacheService: 载入缓存失败', error)
+      this.store = { version: CACHE_VERSION, scopes: {} }
+    }
+  }
+
+  get(scopeKey: string, chatroomId: string): GroupMyMessageCountCacheEntry | undefined {
+    if (!scopeKey || !chatroomId) return undefined
+    const scope = this.store.scopes[scopeKey]
+    if (!scope) return undefined
+    const entry = normalizeEntry(scope[chatroomId])
+    if (!entry) {
+      delete scope[chatroomId]
+      if (Object.keys(scope).length === 0) {
+        delete this.store.scopes[scopeKey]
+      }
+      this.persist()
+      return undefined
+    }
+    return entry
+  }
+
+  set(scopeKey: string, chatroomId: string, entry: GroupMyMessageCountCacheEntry): void {
+    if (!scopeKey || !chatroomId) return
+    const normalized = normalizeEntry(entry)
+    if (!normalized) return
+
+    if (!this.store.scopes[scopeKey]) {
+      this.store.scopes[scopeKey] = {}
+    }
+
+    const existing = this.store.scopes[scopeKey][chatroomId]
+    if (existing && existing.updatedAt > normalized.updatedAt) {
+      return
+    }
+
+    this.store.scopes[scopeKey][chatroomId] = normalized
+    this.trimScope(scopeKey)
+    this.trimScopes()
+    this.persist()
+  }
+
+  delete(scopeKey: string, chatroomId: string): void {
+    if (!scopeKey || !chatroomId) return
+    const scope = this.store.scopes[scopeKey]
+    if (!scope) return
+    if (!(chatroomId in scope)) return
+    delete scope[chatroomId]
+    if (Object.keys(scope).length === 0) {
+      delete this.store.scopes[scopeKey]
+    }
+    this.persist()
+  }
+
+  clearScope(scopeKey: string): void {
+    if (!scopeKey) return
+    if (!this.store.scopes[scopeKey]) return
+    delete this.store.scopes[scopeKey]
+    this.persist()
+  }
+
+  clearAll(): void {
+    this.store = { version: CACHE_VERSION, scopes: {} }
+    try {
+      rmSync(this.cacheFilePath, { force: true })
+    } catch (error) {
+      console.error('GroupMyMessageCountCacheService: 清理缓存失败', error)
+    }
+  }
+
+  private trimScope(scopeKey: string): void {
+    const scope = this.store.scopes[scopeKey]
+    if (!scope) return
+    const entries = Object.entries(scope)
+    if (entries.length <= MAX_GROUP_ENTRIES_PER_SCOPE) return
+    entries.sort((a, b) => b[1].updatedAt - a[1].updatedAt)
+    const trimmed: GroupMyMessageCountScopeMap = {}
+    for (const [chatroomId, entry] of entries.slice(0, MAX_GROUP_ENTRIES_PER_SCOPE)) {
+      trimmed[chatroomId] = entry
+    }
+    this.store.scopes[scopeKey] = trimmed
+  }
+
+  private trimScopes(): void {
+    const scopeEntries = Object.entries(this.store.scopes)
+    if (scopeEntries.length <= MAX_SCOPE_ENTRIES) return
+    scopeEntries.sort((a, b) => {
+      const aUpdatedAt = Math.max(...Object.values(a[1]).map((entry) => entry.updatedAt), 0)
+      const bUpdatedAt = Math.max(...Object.values(b[1]).map((entry) => entry.updatedAt), 0)
+      return bUpdatedAt - aUpdatedAt
+    })
+
+    const trimmedScopes: Record<string, GroupMyMessageCountScopeMap> = {}
+    for (const [scopeKey, scopeMap] of scopeEntries.slice(0, MAX_SCOPE_ENTRIES)) {
+      trimmedScopes[scopeKey] = scopeMap
+    }
+    this.store.scopes = trimmedScopes
+  }
+
+  private persist(): void {
+    try {
+      writeFileSync(this.cacheFilePath, JSON.stringify(this.store), 'utf8')
+    } catch (error) {
+      console.error('GroupMyMessageCountCacheService: 保存缓存失败', error)
+    }
+  }
+}

electron/services/httpService.ts

@@ -10,6 +10,7 @@ import { chatService, Message } from './chatService'
 import { wcdbService } from './wcdbService'
 import { ConfigService } from './config'
 import { videoService } from './videoService'
+import { imageDecryptService } from './imageDecryptService'
 
 // ChatLab 格式定义
 interface ChatLabHeader {
@@ -69,6 +70,7 @@ interface ApiExportedMedia {
   kind: MediaKind
   fileName: string
   fullPath: string
+  relativePath: string
 }
 
 // ChatLab 消息类型映射
@@ -236,6 +238,8 @@ class HttpService {
         await this.handleSessions(url, res)
       } else if (pathname === '/api/v1/contacts') {
         await this.handleContacts(url, res)
+      } else if (pathname.startsWith('/api/v1/media/')) {
+        this.handleMediaRequest(pathname, res)
       } else {
         this.sendError(res, 404, 'Not Found')
       }
@@ -245,6 +249,40 @@ class HttpService {
     }
   }
 
+  private handleMediaRequest(pathname: string, res: http.ServerResponse): void {
+    const mediaBasePath = this.getApiMediaExportPath()
+    const relativePath = pathname.replace('/api/v1/media/', '')
+    const fullPath = path.join(mediaBasePath, relativePath)
+
+    if (!fs.existsSync(fullPath)) {
+      this.sendError(res, 404, 'Media not found')
+      return
+    }
+
+    const ext = path.extname(fullPath).toLowerCase()
+    const mimeTypes: Record<string, string> = {
+      '.png': 'image/png',
+      '.jpg': 'image/jpeg',
+      '.jpeg': 'image/jpeg',
+      '.gif': 'image/gif',
+      '.webp': 'image/webp',
+      '.wav': 'audio/wav',
+      '.mp3': 'audio/mpeg',
+      '.mp4': 'video/mp4'
+    }
+    const contentType = mimeTypes[ext] || 'application/octet-stream'
+
+    try {
+      const fileBuffer = fs.readFileSync(fullPath)
+      res.setHeader('Content-Type', contentType)
+      res.setHeader('Content-Length', fileBuffer.length)
+      res.writeHead(200)
+      res.end(fileBuffer)
+    } catch (e) {
+      this.sendError(res, 500, 'Failed to read media file')
+    }
+  }
+
   /**
    * 批量获取消息（循环游标直到满足 limit）
    * 绕过 chatService 的单 batch 限制，直接操作 wcdbService 游标
@@ -380,7 +418,7 @@ class HttpService {
     const queryOffset = keyword ? 0 : offset
     const queryLimit = keyword ? 10000 : limit
 
-    const result = await this.fetchMessagesBatch(talker, queryOffset, queryLimit, startTime, endTime, true)
+    const result = await this.fetchMessagesBatch(talker, queryOffset, queryLimit, startTime, endTime, false)
     if (!result.success || !result.messages) {
       this.sendError(res, 500, result.error || 'Failed to get messages')
       return
@@ -576,19 +614,44 @@ class HttpService {
   ): Promise<ApiExportedMedia | null> {
     try {
       if (msg.localType === 3 && options.exportImages) {
-        const result = await chatService.getImageData(talker, String(msg.localId))
-        if (result.success && result.data) {
-          const imageBuffer = Buffer.from(result.data, 'base64')
-          const ext = this.detectImageExt(imageBuffer)
-          const fileBase = this.sanitizeFileName(msg.imageMd5 || msg.imageDatName || `image_${msg.localId}`, `image_${msg.localId}`)
-          const fileName = `${fileBase}${ext}`
-          const targetDir = path.join(sessionDir, 'images')
-          const fullPath = path.join(targetDir, fileName)
-          this.ensureDir(targetDir)
-          if (!fs.existsSync(fullPath)) {
-            fs.writeFileSync(fullPath, imageBuffer)
+        const result = await imageDecryptService.decryptImage({
+          sessionId: talker,
+          imageMd5: msg.imageMd5,
+          imageDatName: msg.imageDatName,
+          force: true
+        })
+        if (result.success && result.localPath) {
+          let imagePath = result.localPath
+          if (imagePath.startsWith('data:')) {
+            const base64Match = imagePath.match(/^data:[^;]+;base64,(.+)$/)
+            if (base64Match) {
+              const imageBuffer = Buffer.from(base64Match[1], 'base64')
+              const ext = this.detectImageExt(imageBuffer)
+              const fileBase = this.sanitizeFileName(msg.imageMd5 || msg.imageDatName || `image_${msg.localId}`, `image_${msg.localId}`)
+              const fileName = `${fileBase}${ext}`
+              const targetDir = path.join(sessionDir, 'images')
+              const fullPath = path.join(targetDir, fileName)
+              this.ensureDir(targetDir)
+              if (!fs.existsSync(fullPath)) {
+                fs.writeFileSync(fullPath, imageBuffer)
+              }
+              const relativePath = `${this.sanitizeFileName(talker, 'session')}/images/${fileName}`
+              return { kind: 'image', fileName, fullPath, relativePath }
+            }
+          } else if (fs.existsSync(imagePath)) {
+            const imageBuffer = fs.readFileSync(imagePath)
+            const ext = this.detectImageExt(imageBuffer)
+            const fileBase = this.sanitizeFileName(msg.imageMd5 || msg.imageDatName || `image_${msg.localId}`, `image_${msg.localId}`)
+            const fileName = `${fileBase}${ext}`
+            const targetDir = path.join(sessionDir, 'images')
+            const fullPath = path.join(targetDir, fileName)
+            this.ensureDir(targetDir)
+            if (!fs.existsSync(fullPath)) {
+              fs.copyFileSync(imagePath, fullPath)
+            }
+            const relativePath = `${this.sanitizeFileName(talker, 'session')}/images/${fileName}`
+            return { kind: 'image', fileName, fullPath, relativePath }
           }
-          return { kind: 'image', fileName, fullPath }
         }
       }
 
@@ -607,7 +670,8 @@ class HttpService {
           if (!fs.existsSync(fullPath)) {
             fs.writeFileSync(fullPath, Buffer.from(result.data, 'base64'))
           }
-          return { kind: 'voice', fileName, fullPath }
+          const relativePath = `${this.sanitizeFileName(talker, 'session')}/voices/${fileName}`
+          return { kind: 'voice', fileName, fullPath, relativePath }
         }
       }
 
@@ -622,7 +686,8 @@ class HttpService {
           if (!fs.existsSync(fullPath)) {
             fs.copyFileSync(info.videoUrl, fullPath)
           }
-          return { kind: 'video', fileName, fullPath }
+          const relativePath = `${this.sanitizeFileName(talker, 'session')}/videos/${fileName}`
+          return { kind: 'video', fileName, fullPath, relativePath }
         }
       }
 
@@ -637,7 +702,8 @@ class HttpService {
           if (!fs.existsSync(fullPath)) {
             fs.copyFileSync(result.localPath, fullPath)
           }
-          return { kind: 'emoji', fileName, fullPath }
+          const relativePath = `${this.sanitizeFileName(talker, 'session')}/emojis/${fileName}`
+          return { kind: 'emoji', fileName, fullPath, relativePath }
         }
       }
     } catch (e) {
@@ -661,7 +727,8 @@ class HttpService {
       parsedContent: msg.parsedContent,
       mediaType: media?.kind,
       mediaFileName: media?.fileName,
-      mediaPath: media?.fullPath
+      mediaUrl: media ? `http://127.0.0.1:${this.port}/api/v1/media/${media.relativePath}` : undefined,
+      mediaLocalPath: media?.fullPath
     }
   }
 
@@ -784,7 +851,7 @@ class HttpService {
         type: this.mapMessageType(msg.localType, msg),
         content: this.getMessageContent(msg),
         platformMessageId: msg.serverId ? String(msg.serverId) : undefined,
-        mediaPath: mediaMap.get(msg.localId)?.fullPath
+        mediaPath: mediaMap.get(msg.localId) ? `http://127.0.0.1:${this.port}/api/v1/media/${mediaMap.get(msg.localId)!.relativePath}` : undefined
       }
     })
 

electron/services/imageDecryptService.ts

@@ -1,4 +1,4 @@
-import { app, BrowserWindow } from 'electron'
+import { app, BrowserWindow } from 'electron'
 import { basename, dirname, extname, join } from 'path'
 import { pathToFileURL } from 'url'
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, appendFileSync } from 'fs'
@@ -11,7 +11,29 @@ import { wcdbService } from './wcdbService'
 // 获取 ffmpeg-static 的路径
 function getStaticFfmpegPath(): string | null {
   try {
-    // 优先处理打包后的路径
+    // 方法1: 直接 require ffmpeg-static
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const ffmpegStatic = require('ffmpeg-static')
+
+    if (typeof ffmpegStatic === 'string') {
+      // 修复：如果路径包含 app.asar（打包后），自动替换为 app.asar.unpacked
+      let fixedPath = ffmpegStatic
+      if (fixedPath.includes('app.asar') && !fixedPath.includes('app.asar.unpacked')) {
+        fixedPath = fixedPath.replace('app.asar', 'app.asar.unpacked')
+      }
+
+      if (existsSync(fixedPath)) {
+        return fixedPath
+      }
+    }
+
+    // 方法2: 手动构建路径（开发环境）
+    const devPath = join(process.cwd(), 'node_modules', 'ffmpeg-static', 'ffmpeg.exe')
+    if (existsSync(devPath)) {
+      return devPath
+    }
+
+    // 方法3: 打包后的路径
     if (app.isPackaged) {
       const resourcesPath = process.resourcesPath
       const packedPath = join(resourcesPath, 'app.asar.unpacked', 'node_modules', 'ffmpeg-static', 'ffmpeg.exe')
@@ -20,20 +42,6 @@ function getStaticFfmpegPath(): string | null {
       }
     }
 
-    // 方法1: 直接 require ffmpeg-static（开发环境）
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const ffmpegStatic = require('ffmpeg-static')
-
-    if (typeof ffmpegStatic === 'string' && existsSync(ffmpegStatic)) {
-      return ffmpegStatic
-    }
-
-    // 方法2: 手动构建路径（开发环境备用）
-    const devPath = join(process.cwd(), 'node_modules', 'ffmpeg-static', 'ffmpeg.exe')
-    if (existsSync(devPath)) {
-      return devPath
-    }
-
     return null
   } catch {
     return null
@@ -45,7 +53,6 @@ type DecryptResult = {
   localPath?: string
   error?: string
   isThumb?: boolean  // 是否是缩略图（没有高清图时返回缩略图）
-  liveVideoPath?: string  // 实况照片的视频路径
 }
 
 type HardlinkState = {
@@ -62,7 +69,6 @@ export class ImageDecryptService {
   private cacheIndexed = false
   private cacheIndexing: Promise<void> | null = null
   private updateFlags = new Map<string, boolean>()
-  private noLiveSet = new Set<string>() // 已确认无 live 视频的图片路径
 
   private logInfo(message: string, meta?: Record<string, unknown>): void {
     if (!this.configService.get('logEnabled')) return
@@ -118,9 +124,8 @@ export class ImageDecryptService {
         } else {
           this.updateFlags.delete(key)
         }
-        const liveVideoPath = isThumb ? undefined : this.checkLiveVideoCache(cached)
         this.emitCacheResolved(payload, key, dataUrl || this.filePathToUrl(cached))
-        return { success: true, localPath: dataUrl || this.filePathToUrl(cached), hasUpdate, liveVideoPath }
+        return { success: true, localPath: dataUrl || this.filePathToUrl(cached), hasUpdate }
       }
       if (cached && !this.isImageFile(cached)) {
         this.resolvedCache.delete(key)
@@ -139,9 +144,8 @@ export class ImageDecryptService {
         } else {
           this.updateFlags.delete(key)
         }
-        const liveVideoPath = isThumb ? undefined : this.checkLiveVideoCache(existing)
         this.emitCacheResolved(payload, key, dataUrl || this.filePathToUrl(existing))
-        return { success: true, localPath: dataUrl || this.filePathToUrl(existing), hasUpdate, liveVideoPath }
+        return { success: true, localPath: dataUrl || this.filePathToUrl(existing), hasUpdate }
       }
     }
     this.logInfo('未找到缓存', { md5: payload.imageMd5, datName: payload.imageDatName })
@@ -155,25 +159,13 @@ export class ImageDecryptService {
       return { success: false, error: '缺少图片标识' }
     }
 
-    if (payload.force) {
-      const hdCached = this.findCachedOutput(cacheKey, true, payload.sessionId)
-      if (hdCached && existsSync(hdCached) && this.isImageFile(hdCached) && !this.isThumbnailPath(hdCached)) {
-        const dataUrl = this.fileToDataUrl(hdCached)
-        const localPath = dataUrl || this.filePathToUrl(hdCached)
-        const liveVideoPath = this.checkLiveVideoCache(hdCached)
-        this.emitCacheResolved(payload, cacheKey, localPath)
-        return { success: true, localPath, isThumb: false, liveVideoPath }
-      }
-    }
-
     if (!payload.force) {
       const cached = this.resolvedCache.get(cacheKey)
       if (cached && existsSync(cached) && this.isImageFile(cached)) {
         const dataUrl = this.fileToDataUrl(cached)
         const localPath = dataUrl || this.filePathToUrl(cached)
-        const liveVideoPath = this.isThumbnailPath(cached) ? undefined : this.checkLiveVideoCache(cached)
         this.emitCacheResolved(payload, cacheKey, localPath)
-        return { success: true, localPath, liveVideoPath }
+        return { success: true, localPath }
       }
       if (cached && !this.isImageFile(cached)) {
         this.resolvedCache.delete(cacheKey)
@@ -251,13 +243,14 @@ export class ImageDecryptService {
           const dataUrl = this.fileToDataUrl(existing)
           const localPath = dataUrl || this.filePathToUrl(existing)
           const isThumb = this.isThumbnailPath(existing)
-          const liveVideoPath = isThumb ? undefined : this.checkLiveVideoCache(existing)
           this.emitCacheResolved(payload, cacheKey, localPath)
-          return { success: true, localPath, isThumb, liveVideoPath }
+          return { success: true, localPath, isThumb }
         }
       }
 
-      const xorKeyRaw = this.configService.get('imageXorKey') as unknown
+      // 优先使用当前 wxid 对应的密钥，找不到则回退到全局配置
+      const imageKeys = this.configService.getImageKeysForCurrentWxid()
+      const xorKeyRaw = imageKeys.xorKey
       // 支持十六进制格式（如 0x53）和十进制格式
       let xorKey: number
       if (typeof xorKeyRaw === 'number') {
@@ -274,7 +267,7 @@ export class ImageDecryptService {
         return { success: false, error: '未配置图片解密密钥' }
       }
 
-      const aesKeyRaw = this.configService.get('imageAesKey')
+      const aesKeyRaw = imageKeys.aesKey
       const aesKey = this.resolveAesKey(aesKeyRaw)
 
       this.logInfo('开始解密DAT文件', { datPath, xorKey, hasAesKey: !!aesKey })
@@ -297,14 +290,14 @@ export class ImageDecryptService {
       await writeFile(outputPath, decrypted)
       this.logInfo('解密成功', { outputPath, size: decrypted.length })
 
-      // 对于 hevc 格式，返回错误提示
       if (finalExt === '.hevc') {
         return {
           success: false,
-          error: '此图片为微信新格式(wxgf)，需要安装 ffmpeg 才能显示',
+          error: '此图片为微信新格式(wxgf)，ffmpeg 转换失败，请检查日志',
           isThumb: this.isThumbnailPath(datPath)
         }
       }
+
       const isThumb = this.isThumbnailPath(datPath)
       this.cacheResolvedPaths(cacheKey, payload.imageMd5, payload.imageDatName, outputPath)
       if (!isThumb) {
@@ -313,15 +306,7 @@ export class ImageDecryptService {
       const dataUrl = this.bufferToDataUrl(decrypted, finalExt)
       const localPath = dataUrl || this.filePathToUrl(outputPath)
       this.emitCacheResolved(payload, cacheKey, localPath)
-
-      // 检测实况照片（Motion Photo）
-      let liveVideoPath: string | undefined
-      if (!isThumb && (finalExt === '.jpg' || finalExt === '.jpeg')) {
-        const videoPath = await this.extractMotionPhotoVideo(outputPath, decrypted)
-        if (videoPath) liveVideoPath = this.filePathToUrl(videoPath)
-      }
-
-      return { success: true, localPath, isThumb, liveVideoPath }
+      return { success: true, localPath, isThumb }
     } catch (e) {
       this.logError('解密失败', e, { md5: payload.imageMd5, datName: payload.imageDatName })
       return { success: false, error: String(e) }
@@ -357,37 +342,23 @@ export class ImageDecryptService {
    * 获取解密后的缓存目录（用于查找 hardlink.db）
    */
   private getDecryptedCacheDir(wxid: string): string | null {
+    const cachePath = this.configService.get('cachePath')
+    if (!cachePath) return null
+
     const cleanedWxid = this.cleanAccountDirName(wxid)
-    const configured = this.configService.get('cachePath')
-    const documentsPath = app.getPath('documents')
-    const baseCandidates = Array.from(new Set([
-      configured || '',
-      join(documentsPath, 'WeFlow'),
-      join(documentsPath, 'WeFlowData'),
-      this.configService.getCacheBasePath()
-    ].filter(Boolean)))
+    const cacheAccountDir = join(cachePath, cleanedWxid)
 
-    for (const base of baseCandidates) {
-      const accountCandidates = Array.from(new Set([
-        join(base, wxid),
-        join(base, cleanedWxid),
-        join(base, 'databases', wxid),
-        join(base, 'databases', cleanedWxid)
-      ]))
-      for (const accountDir of accountCandidates) {
-        if (existsSync(join(accountDir, 'hardlink.db'))) {
-          return accountDir
-        }
-        const hardlinkSubdir = join(accountDir, 'db_storage', 'hardlink')
-        if (existsSync(join(hardlinkSubdir, 'hardlink.db'))) {
-          return hardlinkSubdir
-        }
-      }
-      if (existsSync(join(base, 'hardlink.db'))) {
-        return base
-      }
+    // 检查缓存目录下是否有 hardlink.db
+    if (existsSync(join(cacheAccountDir, 'hardlink.db'))) {
+      return cacheAccountDir
+    }
+    if (existsSync(join(cachePath, 'hardlink.db'))) {
+      return cachePath
+    }
+    const cacheHardlinkDir = join(cacheAccountDir, 'db_storage', 'hardlink')
+    if (existsSync(join(cacheHardlinkDir, 'hardlink.db'))) {
+      return cacheHardlinkDir
     }
-
     return null
   }
 
@@ -396,8 +367,7 @@ export class ImageDecryptService {
       existsSync(join(dirPath, 'hardlink.db')) ||
       existsSync(join(dirPath, 'db_storage')) ||
       existsSync(join(dirPath, 'FileStorage', 'Image')) ||
-      existsSync(join(dirPath, 'FileStorage', 'Image2')) ||
-      existsSync(join(dirPath, 'msg', 'attach'))
+      existsSync(join(dirPath, 'FileStorage', 'Image2'))
     )
   }
 
@@ -421,7 +391,7 @@ export class ImageDecryptService {
 
     const suffixMatch = trimmed.match(/^(.+)_([a-zA-Z0-9]{4})$/)
     const cleaned = suffixMatch ? suffixMatch[1] : trimmed
-    
+
     return cleaned
   }
 
@@ -435,14 +405,35 @@ export class ImageDecryptService {
     const allowThumbnail = options?.allowThumbnail ?? true
     const skipResolvedCache = options?.skipResolvedCache ?? false
     this.logInfo('[ImageDecrypt] resolveDatPath', {
-      accountDir,
       imageMd5,
       imageDatName,
-      sessionId,
       allowThumbnail,
       skipResolvedCache
     })
 
+    if (!skipResolvedCache) {
+      if (imageMd5) {
+        const cached = this.resolvedCache.get(imageMd5)
+        if (cached && existsSync(cached)) return cached
+      }
+      if (imageDatName) {
+        const cached = this.resolvedCache.get(imageDatName)
+        if (cached && existsSync(cached)) return cached
+      }
+    }
+
+    // 1. 通过 MD5 快速定位 (MsgAttach 目录)
+    if (imageMd5) {
+      const res = await this.fastProbabilisticSearch(accountDir, imageMd5, allowThumbnail)
+      if (res) return res
+    }
+
+    // 2. 如果 imageDatName 看起来像 MD5，也尝试快速定位
+    if (!imageMd5 && imageDatName && this.looksLikeMd5(imageDatName)) {
+      const res = await this.fastProbabilisticSearch(accountDir, imageDatName, allowThumbnail)
+      if (res) return res
+    }
+
     // 优先通过 hardlink.db 查询
     if (imageMd5) {
       this.logInfo('[ImageDecrypt] hardlink lookup (md5)', { imageMd5, sessionId })
@@ -463,12 +454,6 @@ export class ImageDecryptService {
           if (imageDatName) this.cacheDatPath(accountDir, imageDatName, hdPath)
           return hdPath
         }
-        const hdInDir = await this.searchDatFileInDir(dirname(hardlinkPath), imageDatName || imageMd5 || '', false)
-        if (hdInDir) {
-          this.cacheDatPath(accountDir, imageMd5, hdInDir)
-          if (imageDatName) this.cacheDatPath(accountDir, imageDatName, hdInDir)
-          return hdInDir
-        }
         // 没找到高清图，返回 null（不进行全局搜索）
         return null
       }
@@ -486,16 +471,9 @@ export class ImageDecryptService {
           // 找到缩略图但要求高清图，尝试同目录查找高清图变体
           const hdPath = this.findHdVariantInSameDir(fallbackPath)
           if (hdPath) {
-            this.cacheDatPath(accountDir, imageMd5, hdPath)
             this.cacheDatPath(accountDir, imageDatName, hdPath)
             return hdPath
           }
-          const hdInDir = await this.searchDatFileInDir(dirname(fallbackPath), imageDatName || imageMd5 || '', false)
-          if (hdInDir) {
-            this.cacheDatPath(accountDir, imageMd5, hdInDir)
-            this.cacheDatPath(accountDir, imageDatName, hdInDir)
-            return hdInDir
-          }
           return null
         }
         this.logInfo('[ImageDecrypt] hardlink miss (datName)', { imageDatName })
@@ -518,17 +496,15 @@ export class ImageDecryptService {
           this.cacheDatPath(accountDir, imageDatName, hdPath)
           return hdPath
         }
-        const hdInDir = await this.searchDatFileInDir(dirname(hardlinkPath), imageDatName || '', false)
-        if (hdInDir) {
-          this.cacheDatPath(accountDir, imageDatName, hdInDir)
-          return hdInDir
-        }
         return null
       }
       this.logInfo('[ImageDecrypt] hardlink miss (datName)', { imageDatName })
     }
 
-    // force 模式下也继续尝试缓存目录/文件系统搜索，避免 hardlink.db 缺行时只能拿到缩略图
+    // 如果要求高清图但 hardlink 没找到，也不要搜索了（搜索太慢）
+    if (!allowThumbnail) {
+      return null
+    }
 
     if (!imageDatName) return null
     if (!skipResolvedCache) {
@@ -538,8 +514,6 @@ export class ImageDecryptService {
         // 缓存的是缩略图，尝试找高清图
         const hdPath = this.findHdVariantInSameDir(cached)
         if (hdPath) return hdPath
-        const hdInDir = await this.searchDatFileInDir(dirname(cached), imageDatName, false)
-        if (hdInDir) return hdInDir
       }
     }
 
@@ -640,9 +614,7 @@ export class ImageDecryptService {
     }).catch(() => { })
   }
 
-  private looksLikeMd5(value: string): boolean {
-    return /^[a-fA-F0-9]{16,32}$/.test(value)
-  }
+
 
   private resolveHardlinkDbPath(accountDir: string): string | null {
     const wxid = this.configService.get('myWxid')
@@ -858,7 +830,7 @@ export class ImageDecryptService {
    * 包含：1. 微信旧版结构 filename.substr(0, 2)/...
    *       2. 微信新版结构 msg/attach/{hash}/{YYYY-MM}/Img/filename
    */
-  private async fastProbabilisticSearch(root: string, datName: string): Promise<string | null> {
+  private async fastProbabilisticSearch(root: string, datName: string, _allowThumbnail?: boolean): Promise<string | null> {
     const { promises: fs } = require('fs')
     const { join } = require('path')
 
@@ -894,7 +866,7 @@ export class ImageDecryptService {
         } catch { }
       }
 
-      // --- 策略 B: 新版 Session 哈希路径猜测 ---
+      // --- 绛栫暐 B: 鏂扮増 Session 鍝堝笇璺緞鐚滄祴 ---
       try {
         const entries = await fs.readdir(root, { withFileTypes: true })
         const sessionDirs = entries
@@ -947,7 +919,7 @@ export class ImageDecryptService {
 
   /**
    * 在同一目录下查找高清图变体
-   * 缩略图: xxx_t.dat -> 高清图: xxx_h.dat 或 xxx.dat
+   * 缩略图 xxx_t.dat -> 高清图 xxx_h.dat 或 xxx.dat
    */
   private findHdVariantInSameDir(thumbPath: string): string | null {
     try {
@@ -1029,55 +1001,6 @@ export class ImageDecryptService {
     })
   }
 
-  private matchesDatName(fileName: string, datName: string): boolean {
-    const lower = fileName.toLowerCase()
-    const base = lower.endsWith('.dat') ? lower.slice(0, -4) : lower
-    const normalizedBase = this.normalizeDatBase(base)
-    const normalizedTarget = this.normalizeDatBase(datName.toLowerCase())
-    if (normalizedBase === normalizedTarget) return true
-    const pattern = new RegExp(`^${datName}(?:[._][a-z])?\\.dat$`, 'i')
-    if (pattern.test(lower)) return true
-    return lower.endsWith('.dat') && lower.includes(datName)
-  }
-
-  private scoreDatName(fileName: string): number {
-    if (fileName.includes('.t.dat') || fileName.includes('_t.dat')) return 1
-    if (fileName.includes('.c.dat') || fileName.includes('_c.dat')) return 1
-    return 2
-  }
-
-  private isThumbnailDat(fileName: string): boolean {
-    return fileName.includes('.t.dat') || fileName.includes('_t.dat')
-  }
-
-  private hasXVariant(baseLower: string): boolean {
-    return /[._][a-z]$/.test(baseLower)
-  }
-
-  private isThumbnailPath(filePath: string): boolean {
-    const lower = basename(filePath).toLowerCase()
-    if (this.isThumbnailDat(lower)) return true
-    const ext = extname(lower)
-    const base = ext ? lower.slice(0, -ext.length) : lower
-    // 支持新命名 _thumb 和旧命名 _t
-    return base.endsWith('_t') || base.endsWith('_thumb')
-  }
-
-  private isHdPath(filePath: string): boolean {
-    const lower = basename(filePath).toLowerCase()
-    const ext = extname(lower)
-    const base = ext ? lower.slice(0, -ext.length) : lower
-    return base.endsWith('_hd') || base.endsWith('_h')
-  }
-
-  private hasImageVariantSuffix(baseLower: string): boolean {
-    return /[._][a-z]$/.test(baseLower)
-  }
-
-  private isLikelyImageDatBase(baseLower: string): boolean {
-    return this.hasImageVariantSuffix(baseLower) || this.looksLikeMd5(baseLower)
-  }
-
   private normalizeDatBase(name: string): string {
     let base = name.toLowerCase()
     if (base.endsWith('.dat') || base.endsWith('.jpg')) {
@@ -1089,27 +1012,16 @@ export class ImageDecryptService {
     return base
   }
 
-  private sanitizeDirName(name: string): string {
-    const trimmed = name.trim()
-    if (!trimmed) return 'unknown'
-    return trimmed.replace(/[<>:"/\\|?*]/g, '_')
+  private hasImageVariantSuffix(baseLower: string): boolean {
+    return /[._][a-z]$/.test(baseLower)
   }
 
-  private resolveTimeDir(datPath: string): string {
-    const parts = datPath.split(/[\\/]+/)
-    for (const part of parts) {
-      if (/^\d{4}-\d{2}$/.test(part)) return part
-    }
-    try {
-      const stat = statSync(datPath)
-      const year = stat.mtime.getFullYear()
-      const month = String(stat.mtime.getMonth() + 1).padStart(2, '0')
-      return `${year}-${month}`
-    } catch {
-      return 'unknown-time'
-    }
+  private isLikelyImageDatBase(baseLower: string): boolean {
+    return this.hasImageVariantSuffix(baseLower) || this.looksLikeMd5(baseLower)
   }
 
+
+
   private findCachedOutput(cacheKey: string, preferHd: boolean = false, sessionId?: string): string | null {
     const allRoots = this.getAllCacheRoots()
     const normalizedKey = this.normalizeDatBase(cacheKey.toLowerCase())
@@ -1344,14 +1256,14 @@ export class ImageDecryptService {
   private async ensureCacheIndexed(): Promise<void> {
     if (this.cacheIndexed) return
     if (this.cacheIndexing) return this.cacheIndexing
-    this.cacheIndexing = new Promise((resolve) => {
+    this.cacheIndexing = (async () => {
       // 扫描所有可能的缓存根目录
       const allRoots = this.getAllCacheRoots()
       this.logInfo('开始索引缓存', { roots: allRoots.length })
 
       for (const root of allRoots) {
         try {
-          this.indexCacheDir(root, 3, 0) // 增加深度到3，支持 sessionId/YYYY-MM 结构
+          this.indexCacheDir(root, 3, 0) // 增加深度到 3，支持 sessionId/YYYY-MM 结构
         } catch (e) {
           this.logError('索引目录失败', e, { root })
         }
@@ -1360,8 +1272,7 @@ export class ImageDecryptService {
       this.logInfo('缓存索引完成', { entries: this.resolvedCache.size })
       this.cacheIndexed = true
       this.cacheIndexing = null
-      resolve()
-    })
+    })()
     return this.cacheIndexing
   }
 
@@ -1564,14 +1475,14 @@ export class ImageDecryptService {
 
   private bytesToInt32(bytes: Buffer): number {
     if (bytes.length !== 4) {
-      throw new Error('需要4个字节')
+      throw new Error('需要 4 个字节')
     }
     return bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24)
   }
 
   asciiKey16(keyString: string): Buffer {
     if (keyString.length < 16) {
-      throw new Error('AES密钥至少需要16个字符')
+      throw new Error('AES密钥至少需要 16 个字符')
     }
     return Buffer.from(keyString, 'ascii').subarray(0, 16)
   }
@@ -1738,76 +1649,6 @@ export class ImageDecryptService {
     return mostCommonKey
   }
 
-  /**
-   * 检查图片对应的 live 视频缓存，返回 file:// URL 或 undefined
-   * 已确认无 live 的路径会被记录，下次直接跳过
-   */
-  private checkLiveVideoCache(imagePath: string): string | undefined {
-    if (this.noLiveSet.has(imagePath)) return undefined
-    const livePath = imagePath.replace(/\.(jpg|jpeg|png)$/i, '_live.mp4')
-    if (existsSync(livePath)) return this.filePathToUrl(livePath)
-    this.noLiveSet.add(imagePath)
-    return undefined
-  }
-
-  /**
-   * 检测并分离 Motion Photo（实况照片）
-   * Google Motion Photo = JPEG + MP4 拼接在一起
-   * 返回视频文件路径，如果不是实况照片则返回 null
-   */
-  private async extractMotionPhotoVideo(imagePath: string, imageBuffer: Buffer): Promise<string | null> {
-    // 只处理 JPEG 文件
-    if (imageBuffer.length < 8) return null
-    if (imageBuffer[0] !== 0xff || imageBuffer[1] !== 0xd8) return null
-
-    // 从末尾向前搜索 MP4 ftyp 原子签名
-    // ftyp 原子结构: [4字节大小][ftyp(66 74 79 70)][品牌...]
-    // 实际起始位置在 ftyp 前4字节（大小字段）
-    const ftypSig = [0x66, 0x74, 0x79, 0x70] // 'ftyp'
-    let videoOffset: number | null = null
-
-    const searchEnd = Math.max(0, imageBuffer.length - 8)
-    for (let i = searchEnd; i > 0; i--) {
-      if (imageBuffer[i] === ftypSig[0] &&
-        imageBuffer[i + 1] === ftypSig[1] &&
-        imageBuffer[i + 2] === ftypSig[2] &&
-        imageBuffer[i + 3] === ftypSig[3]) {
-        // ftyp 前4字节是 box size，实际 MP4 从这里开始
-        videoOffset = i - 4
-        break
-      }
-    }
-
-    // 备用：从 XMP 元数据中读取偏移量
-    if (videoOffset === null || videoOffset <= 0) {
-      try {
-        const text = imageBuffer.toString('latin1')
-        const match = text.match(/MediaDataOffset="(\d+)"/i) || text.match(/MicroVideoOffset="(\d+)"/i)
-        if (match) {
-          const offset = parseInt(match[1], 10)
-          if (offset > 0 && offset < imageBuffer.length) {
-            videoOffset = imageBuffer.length - offset
-          }
-        }
-      } catch { }
-    }
-
-    if (videoOffset === null || videoOffset <= 100) return null
-
-    // 验证视频部分确实以有效 MP4 数据开头
-    const videoStart = imageBuffer[videoOffset + 4] === 0x66 &&
-      imageBuffer[videoOffset + 5] === 0x74 &&
-      imageBuffer[videoOffset + 6] === 0x79 &&
-      imageBuffer[videoOffset + 7] === 0x70
-    if (!videoStart) return null
-
-    // 写出视频文件
-    const videoPath = imagePath.replace(/\.(jpg|jpeg|png)$/i, '_live.mp4')
-    const videoBuffer = imageBuffer.slice(videoOffset)
-    await writeFile(videoPath, videoBuffer)
-    return videoPath
-  }
-
   /**
    * 解包 wxgf 格式
    * wxgf 是微信的图片格式，内部使用 HEVC 编码
@@ -1833,25 +1674,28 @@ export class ImageDecryptService {
 
     // 提取 HEVC NALU 裸流
     const hevcData = this.extractHevcNalu(buffer)
-    if (!hevcData || hevcData.length < 100) {
-      return { data: buffer, isWxgf: true }
-    }
+    // 优先用提取的 NALU 裸流，提取失败则跳过 wxgf 头部直接用原始数据
+    const feedData = (hevcData && hevcData.length >= 100) ? hevcData : buffer.subarray(4)
+    this.logInfo('unwrapWxgf: 准备 ffmpeg 转换', {
+      naluExtracted: !!(hevcData && hevcData.length >= 100),
+      feedSize: feedData.length
+    })
 
     // 尝试用 ffmpeg 转换
     try {
-      const jpgData = await this.convertHevcToJpg(hevcData)
+      const jpgData = await this.convertHevcToJpg(feedData)
       if (jpgData && jpgData.length > 0) {
         return { data: jpgData, isWxgf: false }
       }
-    } catch {
-      // ffmpeg 转换失败
+    } catch (e) {
+      this.logError('unwrapWxgf: ffmpeg 转换失败', e)
     }
 
-    return { data: hevcData, isWxgf: true }
+    return { data: feedData, isWxgf: true }
   }
 
   /**
-   * 从 wxgf 数据中提取 HEVC NALU 裸流
+   * 浠?wxgf 鏁版嵁涓彁鍙?HEVC NALU 瑁告祦
    */
   private extractHevcNalu(buffer: Buffer): Buffer | null {
     const nalUnits: Buffer[] = []
@@ -1914,53 +1758,133 @@ export class ImageDecryptService {
   /**
    * 使用 ffmpeg 将 HEVC 裸流转换为 JPG
    */
-  private convertHevcToJpg(hevcData: Buffer): Promise<Buffer | null> {
+  private async convertHevcToJpg(hevcData: Buffer): Promise<Buffer | null> {
     const ffmpeg = this.getFfmpegPath()
     this.logInfo('ffmpeg 转换开始', { ffmpegPath: ffmpeg, hevcSize: hevcData.length })
 
+    const tmpDir = join(app.getPath('temp'), 'weflow_hevc')
+    if (!existsSync(tmpDir)) mkdirSync(tmpDir, { recursive: true })
+    const ts = Date.now()
+    const tmpInput = join(tmpDir, `hevc_${ts}.hevc`)
+    const tmpOutput = join(tmpDir, `hevc_${ts}.jpg`)
+
+    try {
+      await writeFile(tmpInput, hevcData)
+
+      // 依次尝试: 1) -f hevc 裸流  2) 不指定格式让 ffmpeg 自动检测
+      const attempts: { label: string; inputArgs: string[] }[] = [
+        { label: 'hevc raw', inputArgs: ['-f', 'hevc', '-i', tmpInput] },
+        { label: 'auto detect', inputArgs: ['-i', tmpInput] },
+      ]
+
+      for (const attempt of attempts) {
+        // 清理上一轮的输出
+        try { if (existsSync(tmpOutput)) require('fs').unlinkSync(tmpOutput) } catch {}
+
+        const result = await this.runFfmpegConvert(ffmpeg, attempt.inputArgs, tmpOutput, attempt.label)
+        if (result) return result
+      }
+
+      return null
+    } catch (e) {
+      this.logError('ffmpeg 转换异常', e)
+      return null
+    } finally {
+      try { if (existsSync(tmpInput)) require('fs').unlinkSync(tmpInput) } catch {}
+      try { if (existsSync(tmpOutput)) require('fs').unlinkSync(tmpOutput) } catch {}
+    }
+  }
+
+  private runFfmpegConvert(ffmpeg: string, inputArgs: string[], tmpOutput: string, label: string): Promise<Buffer | null> {
     return new Promise((resolve) => {
       const { spawn } = require('child_process')
-      const chunks: Buffer[] = []
       const errChunks: Buffer[] = []
 
-      const proc = spawn(ffmpeg, [
-        '-hide_banner',
-        '-loglevel', 'error',
-        '-f', 'hevc',
-        '-i', 'pipe:0',
-        '-vframes', '1',
-        '-q:v', '3',
-        '-f', 'mjpeg',
-        'pipe:1'
-      ], {
-        stdio: ['pipe', 'pipe', 'pipe'],
+      const args = [
+        '-hide_banner', '-loglevel', 'error',
+        ...inputArgs,
+        '-vframes', '1', '-q:v', '2', '-f', 'image2', tmpOutput
+      ]
+      this.logInfo(`ffmpeg 尝试 [${label}]`, { args: args.join(' ') })
+
+      const proc = spawn(ffmpeg, args, {
+        stdio: ['ignore', 'ignore', 'pipe'],
         windowsHide: true
       })
 
-      proc.stdout.on('data', (chunk: Buffer) => chunks.push(chunk))
       proc.stderr.on('data', (chunk: Buffer) => errChunks.push(chunk))
 
-      proc.on('close', (code: number) => {
-        if (code === 0 && chunks.length > 0) {
-          this.logInfo('ffmpeg 转换成功', { outputSize: Buffer.concat(chunks).length })
-          resolve(Buffer.concat(chunks))
-        } else {
-          const errMsg = Buffer.concat(errChunks).toString()
-          this.logInfo('ffmpeg 转换失败', { code, error: errMsg })
-          resolve(null)
-        }
-      })
+      const timer = setTimeout(() => {
+        proc.kill('SIGKILL')
+        this.logError(`ffmpeg [${label}] 超时(15s)`)
+        resolve(null)
+      }, 15000)
 
-      proc.on('error', (err: Error) => {
-        this.logInfo('ffmpeg 进程错误', { error: err.message })
+      proc.on('close', (code: number) => {
+        clearTimeout(timer)
+        if (code === 0 && existsSync(tmpOutput)) {
+          try {
+            const jpgBuf = readFileSync(tmpOutput)
+            if (jpgBuf.length > 0) {
+              this.logInfo(`ffmpeg [${label}] 成功`, { outputSize: jpgBuf.length })
+              resolve(jpgBuf)
+              return
+            }
+          } catch (e) {
+            this.logError(`ffmpeg [${label}] 读取输出失败`, e)
+          }
+        }
+        const errMsg = Buffer.concat(errChunks).toString().trim()
+        this.logInfo(`ffmpeg [${label}] 失败`, { code, error: errMsg })
         resolve(null)
       })
 
-      proc.stdin.write(hevcData)
-      proc.stdin.end()
+      proc.on('error', (err: Error) => {
+        clearTimeout(timer)
+        this.logError(`ffmpeg [${label}] 进程错误`, err)
+        resolve(null)
+      })
     })
   }
 
+  private looksLikeMd5(s: string): boolean {
+    return /^[a-f0-9]{32}$/i.test(s)
+  }
+
+  private isThumbnailDat(name: string): boolean {
+    const lower = name.toLowerCase()
+    return lower.includes('_t.dat') || lower.includes('.t.dat') || lower.includes('_thumb.dat')
+  }
+
+  private hasXVariant(base: string): boolean {
+    const lower = base.toLowerCase()
+    return lower.endsWith('_h') || lower.endsWith('_hd') || lower.endsWith('_thumb') || lower.endsWith('_t')
+  }
+
+  private isHdPath(p: string): boolean {
+    return p.toLowerCase().includes('_hd') || p.toLowerCase().includes('_h')
+  }
+
+  private isThumbnailPath(p: string): boolean {
+    const lower = p.toLowerCase()
+    return lower.includes('_thumb') || lower.includes('_t') || lower.includes('.t.')
+  }
+
+  private sanitizeDirName(s: string): string {
+    return s.replace(/[<>:"/\\|?*]/g, '_').trim() || 'unknown'
+  }
+
+  private resolveTimeDir(filePath: string): string {
+    try {
+      const stats = statSync(filePath)
+      const d = new Date(stats.mtime)
+      return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`
+    } catch {
+      const d = new Date()
+      return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`
+    }
+  }
+
   // 保留原有的解密到文件方法（用于兼容）
   async decryptToFile(inputPath: string, outputPath: string, xorKey: number, aesKey?: Buffer): Promise<void> {
     const version = this.getDatVersion(inputPath)
@@ -1973,7 +1897,7 @@ export class ImageDecryptService {
       decrypted = this.decryptDatV4(inputPath, xorKey, key)
     } else {
       if (!aesKey || aesKey.length !== 16) {
-        throw new Error('V4版本需要16字节AES密钥')
+        throw new Error('V4版本需要 16 字节 AES 密钥')
       }
       decrypted = this.decryptDatV4(inputPath, xorKey, aesKey)
     }

electron/services/sessionStatsCacheService.ts

@@ -0,0 +1,293 @@
+import { join, dirname } from 'path'
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'fs'
+import { ConfigService } from './config'
+
+const CACHE_VERSION = 2
+const MAX_SESSION_ENTRIES_PER_SCOPE = 2000
+const MAX_SCOPE_ENTRIES = 12
+
+export interface SessionStatsCacheStats {
+  totalMessages: number
+  voiceMessages: number
+  imageMessages: number
+  videoMessages: number
+  emojiMessages: number
+  transferMessages: number
+  redPacketMessages: number
+  callMessages: number
+  firstTimestamp?: number
+  lastTimestamp?: number
+  privateMutualGroups?: number
+  groupMemberCount?: number
+  groupMyMessages?: number
+  groupActiveSpeakers?: number
+  groupMutualFriends?: number
+}
+
+export interface SessionStatsCacheEntry {
+  updatedAt: number
+  includeRelations: boolean
+  stats: SessionStatsCacheStats
+}
+
+interface SessionStatsScopeMap {
+  [sessionId: string]: SessionStatsCacheEntry
+}
+
+interface SessionStatsCacheStore {
+  version: number
+  scopes: Record<string, SessionStatsScopeMap>
+}
+
+function toNonNegativeInt(value: unknown): number | undefined {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return undefined
+  return Math.max(0, Math.floor(value))
+}
+
+function normalizeStats(raw: unknown): SessionStatsCacheStats | null {
+  if (!raw || typeof raw !== 'object') return null
+  const source = raw as Record<string, unknown>
+
+  const totalMessages = toNonNegativeInt(source.totalMessages)
+  const voiceMessages = toNonNegativeInt(source.voiceMessages)
+  const imageMessages = toNonNegativeInt(source.imageMessages)
+  const videoMessages = toNonNegativeInt(source.videoMessages)
+  const emojiMessages = toNonNegativeInt(source.emojiMessages)
+  const transferMessages = toNonNegativeInt(source.transferMessages)
+  const redPacketMessages = toNonNegativeInt(source.redPacketMessages)
+  const callMessages = toNonNegativeInt(source.callMessages)
+
+  if (
+    totalMessages === undefined ||
+    voiceMessages === undefined ||
+    imageMessages === undefined ||
+    videoMessages === undefined ||
+    emojiMessages === undefined ||
+    transferMessages === undefined ||
+    redPacketMessages === undefined ||
+    callMessages === undefined
+  ) {
+    return null
+  }
+
+  const normalized: SessionStatsCacheStats = {
+    totalMessages,
+    voiceMessages,
+    imageMessages,
+    videoMessages,
+    emojiMessages,
+    transferMessages,
+    redPacketMessages,
+    callMessages
+  }
+
+  const firstTimestamp = toNonNegativeInt(source.firstTimestamp)
+  if (firstTimestamp !== undefined) normalized.firstTimestamp = firstTimestamp
+
+  const lastTimestamp = toNonNegativeInt(source.lastTimestamp)
+  if (lastTimestamp !== undefined) normalized.lastTimestamp = lastTimestamp
+
+  const privateMutualGroups = toNonNegativeInt(source.privateMutualGroups)
+  if (privateMutualGroups !== undefined) normalized.privateMutualGroups = privateMutualGroups
+
+  const groupMemberCount = toNonNegativeInt(source.groupMemberCount)
+  if (groupMemberCount !== undefined) normalized.groupMemberCount = groupMemberCount
+
+  const groupMyMessages = toNonNegativeInt(source.groupMyMessages)
+  if (groupMyMessages !== undefined) normalized.groupMyMessages = groupMyMessages
+
+  const groupActiveSpeakers = toNonNegativeInt(source.groupActiveSpeakers)
+  if (groupActiveSpeakers !== undefined) normalized.groupActiveSpeakers = groupActiveSpeakers
+
+  const groupMutualFriends = toNonNegativeInt(source.groupMutualFriends)
+  if (groupMutualFriends !== undefined) normalized.groupMutualFriends = groupMutualFriends
+
+  return normalized
+}
+
+function normalizeEntry(raw: unknown): SessionStatsCacheEntry | null {
+  if (!raw || typeof raw !== 'object') return null
+  const source = raw as Record<string, unknown>
+  const updatedAt = toNonNegativeInt(source.updatedAt)
+  const includeRelations = typeof source.includeRelations === 'boolean' ? source.includeRelations : false
+  const stats = normalizeStats(source.stats)
+
+  if (updatedAt === undefined || !stats) {
+    return null
+  }
+
+  return {
+    updatedAt,
+    includeRelations,
+    stats
+  }
+}
+
+export class SessionStatsCacheService {
+  private readonly cacheFilePath: string
+  private store: SessionStatsCacheStore = {
+    version: CACHE_VERSION,
+    scopes: {}
+  }
+
+  constructor(cacheBasePath?: string) {
+    const basePath = cacheBasePath && cacheBasePath.trim().length > 0
+      ? cacheBasePath
+      : ConfigService.getInstance().getCacheBasePath()
+    this.cacheFilePath = join(basePath, 'session-stats.json')
+    this.ensureCacheDir()
+    this.load()
+  }
+
+  private ensureCacheDir(): void {
+    const dir = dirname(this.cacheFilePath)
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true })
+    }
+  }
+
+  private load(): void {
+    if (!existsSync(this.cacheFilePath)) return
+    try {
+      const raw = readFileSync(this.cacheFilePath, 'utf8')
+      const parsed = JSON.parse(raw) as unknown
+      if (!parsed || typeof parsed !== 'object') {
+        this.store = { version: CACHE_VERSION, scopes: {} }
+        return
+      }
+
+      const payload = parsed as Record<string, unknown>
+      const version = Number(payload.version)
+      if (!Number.isFinite(version) || version !== CACHE_VERSION) {
+        this.store = { version: CACHE_VERSION, scopes: {} }
+        return
+      }
+      const scopesRaw = payload.scopes
+      if (!scopesRaw || typeof scopesRaw !== 'object') {
+        this.store = { version: CACHE_VERSION, scopes: {} }
+        return
+      }
+
+      const scopes: Record<string, SessionStatsScopeMap> = {}
+      for (const [scopeKey, scopeValue] of Object.entries(scopesRaw as Record<string, unknown>)) {
+        if (!scopeValue || typeof scopeValue !== 'object') continue
+        const normalizedScope: SessionStatsScopeMap = {}
+        for (const [sessionId, entryRaw] of Object.entries(scopeValue as Record<string, unknown>)) {
+          const entry = normalizeEntry(entryRaw)
+          if (!entry) continue
+          normalizedScope[sessionId] = entry
+        }
+        if (Object.keys(normalizedScope).length > 0) {
+          scopes[scopeKey] = normalizedScope
+        }
+      }
+
+      this.store = {
+        version: CACHE_VERSION,
+        scopes
+      }
+    } catch (error) {
+      console.error('SessionStatsCacheService: 载入缓存失败', error)
+      this.store = { version: CACHE_VERSION, scopes: {} }
+    }
+  }
+
+  get(scopeKey: string, sessionId: string): SessionStatsCacheEntry | undefined {
+    if (!scopeKey || !sessionId) return undefined
+    const scope = this.store.scopes[scopeKey]
+    if (!scope) return undefined
+    const entry = normalizeEntry(scope[sessionId])
+    if (!entry) {
+      delete scope[sessionId]
+      if (Object.keys(scope).length === 0) {
+        delete this.store.scopes[scopeKey]
+      }
+      this.persist()
+      return undefined
+    }
+    return entry
+  }
+
+  set(scopeKey: string, sessionId: string, entry: SessionStatsCacheEntry): void {
+    if (!scopeKey || !sessionId) return
+    const normalized = normalizeEntry(entry)
+    if (!normalized) return
+
+    if (!this.store.scopes[scopeKey]) {
+      this.store.scopes[scopeKey] = {}
+    }
+    this.store.scopes[scopeKey][sessionId] = normalized
+
+    this.trimScope(scopeKey)
+    this.trimScopes()
+    this.persist()
+  }
+
+  delete(scopeKey: string, sessionId: string): void {
+    if (!scopeKey || !sessionId) return
+    const scope = this.store.scopes[scopeKey]
+    if (!scope) return
+    if (!(sessionId in scope)) return
+
+    delete scope[sessionId]
+    if (Object.keys(scope).length === 0) {
+      delete this.store.scopes[scopeKey]
+    }
+    this.persist()
+  }
+
+  clearScope(scopeKey: string): void {
+    if (!scopeKey) return
+    if (!this.store.scopes[scopeKey]) return
+    delete this.store.scopes[scopeKey]
+    this.persist()
+  }
+
+  clearAll(): void {
+    this.store = { version: CACHE_VERSION, scopes: {} }
+    try {
+      rmSync(this.cacheFilePath, { force: true })
+    } catch (error) {
+      console.error('SessionStatsCacheService: 清理缓存失败', error)
+    }
+  }
+
+  private trimScope(scopeKey: string): void {
+    const scope = this.store.scopes[scopeKey]
+    if (!scope) return
+    const entries = Object.entries(scope)
+    if (entries.length <= MAX_SESSION_ENTRIES_PER_SCOPE) return
+
+    entries.sort((a, b) => b[1].updatedAt - a[1].updatedAt)
+    const trimmed: SessionStatsScopeMap = {}
+    for (const [sessionId, entry] of entries.slice(0, MAX_SESSION_ENTRIES_PER_SCOPE)) {
+      trimmed[sessionId] = entry
+    }
+    this.store.scopes[scopeKey] = trimmed
+  }
+
+  private trimScopes(): void {
+    const scopeEntries = Object.entries(this.store.scopes)
+    if (scopeEntries.length <= MAX_SCOPE_ENTRIES) return
+
+    scopeEntries.sort((a, b) => {
+      const aUpdatedAt = Math.max(...Object.values(a[1]).map((entry) => entry.updatedAt), 0)
+      const bUpdatedAt = Math.max(...Object.values(b[1]).map((entry) => entry.updatedAt), 0)
+      return bUpdatedAt - aUpdatedAt
+    })
+
+    const trimmedScopes: Record<string, SessionStatsScopeMap> = {}
+    for (const [scopeKey, scopeMap] of scopeEntries.slice(0, MAX_SCOPE_ENTRIES)) {
+      trimmedScopes[scopeKey] = scopeMap
+    }
+    this.store.scopes = trimmedScopes
+  }
+
+  private persist(): void {
+    try {
+      writeFileSync(this.cacheFilePath, JSON.stringify(this.store), 'utf8')
+    } catch (error) {
+      console.error('SessionStatsCacheService: 保存缓存失败', error)
+    }
+  }
+}

electron/services/videoService.ts

@@ -1,5 +1,6 @@
 import { join } from 'path'
-import { existsSync, readdirSync, statSync, readFileSync } from 'fs'
+import { existsSync, readdirSync, statSync, readFileSync, appendFileSync, mkdirSync } from 'fs'
+import { app } from 'electron'
 import { ConfigService } from './config'
 import Database from 'better-sqlite3'
 import { wcdbService } from './wcdbService'
@@ -18,6 +19,16 @@ class VideoService {
         this.configService = new ConfigService()
     }
 
+    private log(message: string, meta?: Record<string, unknown>): void {
+        try {
+            const timestamp = new Date().toISOString()
+            const metaStr = meta ? ` ${JSON.stringify(meta)}` : ''
+            const logDir = join(app.getPath('userData'), 'logs')
+            if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true })
+            appendFileSync(join(logDir, 'wcdb.log'), `[${timestamp}] [VideoService] ${message}${metaStr}\n`, 'utf8')
+        } catch {}
+    }
+
     /**
      * 获取数据库根目录
      */
@@ -69,7 +80,12 @@ class VideoService {
         const wxid = this.getMyWxid()
         const cleanedWxid = this.cleanWxid(wxid)
 
-        if (!wxid) return undefined
+        this.log('queryVideoFileName 开始', { md5, wxid, cleanedWxid, cachePath, dbPath })
+
+        if (!wxid) {
+            this.log('queryVideoFileName: wxid 为空')
+            return undefined
+        }
 
         // 方法1：优先在 cachePath 下查找解密后的 hardlink.db
         if (cachePath) {
@@ -84,20 +100,23 @@ class VideoService {
             for (const p of cacheDbPaths) {
                 if (existsSync(p)) {
                     try {
+                        this.log('尝试缓存 hardlink.db', { path: p })
                         const db = new Database(p, { readonly: true })
                         const row = db.prepare(`
-                            SELECT file_name, md5 FROM video_hardlink_info_v4 
-                            WHERE md5 = ? 
+                            SELECT file_name, md5 FROM video_hardlink_info_v4
+                            WHERE md5 = ?
                             LIMIT 1
                         `).get(md5) as { file_name: string; md5: string } | undefined
                         db.close()
 
                         if (row?.file_name) {
                             const realMd5 = row.file_name.replace(/\.[^.]+$/, '')
+                            this.log('缓存 hardlink.db 命中', { file_name: row.file_name, realMd5 })
                             return realMd5
                         }
+                        this.log('缓存 hardlink.db 未命中', { path: p })
                     } catch (e) {
-                        // 忽略错误
+                        this.log('缓存 hardlink.db 查询失败', { path: p, error: String(e) })
                     }
                 }
             }
@@ -105,7 +124,6 @@ class VideoService {
 
         // 方法2：使用 wcdbService.execQuery 查询加密的 hardlink.db
         if (dbPath) {
-            // 检查 dbPath 是否已经包含 wxid
             const dbPathLower = dbPath.toLowerCase()
             const wxidLower = wxid.toLowerCase()
             const cleanedWxidLower = cleanedWxid.toLowerCase()
@@ -113,10 +131,8 @@ class VideoService {
 
             const encryptedDbPaths: string[] = []
             if (dbPathContainsWxid) {
-                // dbPath 已包含 wxid，不需要再拼接
                 encryptedDbPaths.push(join(dbPath, 'db_storage', 'hardlink', 'hardlink.db'))
             } else {
-                // dbPath 不包含 wxid，需要拼接
                 encryptedDbPaths.push(join(dbPath, wxid, 'db_storage', 'hardlink', 'hardlink.db'))
                 encryptedDbPaths.push(join(dbPath, cleanedWxid, 'db_storage', 'hardlink', 'hardlink.db'))
             }
@@ -124,27 +140,29 @@ class VideoService {
             for (const p of encryptedDbPaths) {
                 if (existsSync(p)) {
                     try {
+                        this.log('尝试加密 hardlink.db', { path: p })
                         const escapedMd5 = md5.replace(/'/g, "''")
-
-                        // 用 md5 字段查询，获取 file_name
                         const sql = `SELECT file_name FROM video_hardlink_info_v4 WHERE md5 = '${escapedMd5}' LIMIT 1`
-
                         const result = await wcdbService.execQuery('media', p, sql)
 
                         if (result.success && result.rows && result.rows.length > 0) {
                             const row = result.rows[0]
                             if (row?.file_name) {
-                                // 提取不带扩展名的文件名作为实际视频 MD5
                                 const realMd5 = String(row.file_name).replace(/\.[^.]+$/, '')
+                                this.log('加密 hardlink.db 命中', { file_name: row.file_name, realMd5 })
                                 return realMd5
                             }
                         }
+                        this.log('加密 hardlink.db 未命中', { path: p, result: JSON.stringify(result).slice(0, 200) })
                     } catch (e) {
-                        // 忽略错误
+                        this.log('加密 hardlink.db 查询失败', { path: p, error: String(e) })
                     }
+                } else {
+                    this.log('加密 hardlink.db 不存在', { path: p })
                 }
             }
         }
+        this.log('queryVideoFileName: 所有方法均未找到', { md5 })
         return undefined
     }
 
@@ -170,12 +188,16 @@ class VideoService {
         const dbPath = this.getDbPath()
         const wxid = this.getMyWxid()
 
+        this.log('getVideoInfo 开始', { videoMd5, dbPath, wxid })
+
         if (!dbPath || !wxid || !videoMd5) {
+            this.log('getVideoInfo: 参数缺失', { dbPath: !!dbPath, wxid: !!wxid, videoMd5: !!videoMd5 })
             return { exists: false }
         }
 
         // 先尝试从数据库查询真正的视频文件名
         const realVideoMd5 = await this.queryVideoFileName(videoMd5) || videoMd5
+        this.log('realVideoMd5', { input: videoMd5, resolved: realVideoMd5, changed: realVideoMd5 !== videoMd5 })
 
         // 检查 dbPath 是否已经包含 wxid，避免重复拼接
         const dbPathLower = dbPath.toLowerCase()
@@ -184,50 +206,89 @@ class VideoService {
 
         let videoBaseDir: string
         if (dbPathLower.includes(wxidLower) || dbPathLower.includes(cleanedWxid.toLowerCase())) {
-            // dbPath 已经包含 wxid，直接使用
             videoBaseDir = join(dbPath, 'msg', 'video')
         } else {
-            // dbPath 不包含 wxid，需要拼接
             videoBaseDir = join(dbPath, wxid, 'msg', 'video')
         }
 
+        this.log('videoBaseDir', { videoBaseDir, exists: existsSync(videoBaseDir) })
+
         if (!existsSync(videoBaseDir)) {
+            this.log('getVideoInfo: videoBaseDir 不存在')
             return { exists: false }
         }
 
         // 遍历年月目录查找视频文件
         try {
             const allDirs = readdirSync(videoBaseDir)
-
-            // 支持多种目录格式: YYYY-MM, YYYYMM, 或其他
             const yearMonthDirs = allDirs
                 .filter(dir => {
                     const dirPath = join(videoBaseDir, dir)
                     return statSync(dirPath).isDirectory()
                 })
-                .sort((a, b) => b.localeCompare(a)) // 从最新的目录开始查找
+                .sort((a, b) => b.localeCompare(a))
+
+            this.log('扫描目录', { dirs: yearMonthDirs })
 
             for (const yearMonth of yearMonthDirs) {
                 const dirPath = join(videoBaseDir, yearMonth)
-
                 const videoPath = join(dirPath, `${realVideoMd5}.mp4`)
-                const coverPath = join(dirPath, `${realVideoMd5}.jpg`)
-                const thumbPath = join(dirPath, `${realVideoMd5}_thumb.jpg`)
 
-                // 检查视频文件是否存在
                 if (existsSync(videoPath)) {
+                    // 封面/缩略图使用不带 _raw 后缀的基础名（自己发的视频文件名带 _raw，但封面不带）
+                    const baseMd5 = realVideoMd5.replace(/_raw$/, '')
+                    const coverPath = join(dirPath, `${baseMd5}.jpg`)
+                    const thumbPath = join(dirPath, `${baseMd5}_thumb.jpg`)
+
+                    // 列出同目录下与该 md5 相关的所有文件，帮助排查封面命名
+                    const allFiles = readdirSync(dirPath)
+                    const relatedFiles = allFiles.filter(f => f.toLowerCase().startsWith(realVideoMd5.slice(0, 8).toLowerCase()))
+                    this.log('找到视频，相关文件列表', {
+                        videoPath,
+                        coverExists: existsSync(coverPath),
+                        thumbExists: existsSync(thumbPath),
+                        relatedFiles,
+                        coverPath,
+                        thumbPath
+                    })
+
                     return {
-                        videoUrl: videoPath,  // 返回文件路径，前端通过 readFile 读取
+                        videoUrl: videoPath,
                         coverUrl: this.fileToDataUrl(coverPath, 'image/jpeg'),
                         thumbUrl: this.fileToDataUrl(thumbPath, 'image/jpeg'),
                         exists: true
                     }
                 }
             }
+
+            // 没找到，列出所有目录里的 mp4 文件帮助排查（最多每目录 10 个）
+            this.log('未找到视频，开始全目录扫描', {
+                lookingForOriginal: `${videoMd5}.mp4`,
+                lookingForResolved: `${realVideoMd5}.mp4`,
+                hardlinkResolved: realVideoMd5 !== videoMd5
+            })
+            for (const yearMonth of yearMonthDirs) {
+                const dirPath = join(videoBaseDir, yearMonth)
+                try {
+                    const allFiles = readdirSync(dirPath)
+                    const mp4Files = allFiles.filter(f => f.endsWith('.mp4')).slice(0, 10)
+                    // 检查原始 md5 是否部分匹配（前8位）
+                    const partialMatch = mp4Files.filter(f => f.toLowerCase().startsWith(videoMd5.slice(0, 8).toLowerCase()))
+                    this.log(`目录 ${yearMonth} 扫描结果`, {
+                        totalFiles: allFiles.length,
+                        mp4Count: allFiles.filter(f => f.endsWith('.mp4')).length,
+                        sampleMp4: mp4Files,
+                        partialMatchByOriginalMd5: partialMatch
+                    })
+                } catch (e) {
+                    this.log(`目录 ${yearMonth} 读取失败`, { error: String(e) })
+                }
+            }
         } catch (e) {
-            // 忽略错误
+            this.log('getVideoInfo 遍历出错', { error: String(e) })
         }
 
+        this.log('getVideoInfo: 未找到视频', { videoMd5, realVideoMd5 })
         return { exists: false }
     }
 
@@ -235,41 +296,59 @@ class VideoService {
      * 根据消息内容解析视频MD5
      */
     parseVideoMd5(content: string): string | undefined {
-
-        // 打印前500字符看看 XML 结构
-
         if (!content) return undefined
 
+        // 打印原始 XML 前 800 字符，帮助排查自己发的视频结构
+        this.log('parseVideoMd5 原始内容', { preview: content.slice(0, 800) })
+
         try {
-            // 提取所有可能的 md5 值进行日志
-            const allMd5s: string[] = []
-            const md5Regex = /(?:md5|rawmd5|newmd5|originsourcemd5)\s*=\s*['"]([a-fA-F0-9]+)['"]/gi
+            // 收集所有 md5 相关属性，方便对比
+            const allMd5Attrs: string[] = []
+            const md5Regex = /(?:md5|rawmd5|newmd5|originsourcemd5)\s*=\s*['"]([a-fA-F0-9]*)['"]/gi
             let match
             while ((match = md5Regex.exec(content)) !== null) {
-                allMd5s.push(`${match[0]}`)
+                allMd5Attrs.push(match[0])
+            }
+            this.log('parseVideoMd5 所有 md5 属性', { attrs: allMd5Attrs })
+
+            // 方法1：从 <videomsg md5="..."> 提取（收到的视频）
+            const videoMsgMd5Match = /<videomsg[^>]*\smd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
+            if (videoMsgMd5Match) {
+                this.log('parseVideoMd5 命中 videomsg md5 属性', { md5: videoMsgMd5Match[1] })
+                return videoMsgMd5Match[1].toLowerCase()
             }
 
-            // 提取 md5（用于查询 hardlink.db）
-            // 注意：不是 rawmd5，rawmd5 是另一个值
-            // 格式: md5="xxx" 或 <md5>xxx</md5>
-
-            // 尝试从videomsg标签中提取md5
-            const videoMsgMatch = /<videomsg[^>]*\smd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
-            if (videoMsgMatch) {
-                return videoMsgMatch[1].toLowerCase()
+            // 方法2：从 <videomsg rawmd5="..."> 提取（自己发的视频，没有 md5 只有 rawmd5）
+            const rawMd5Match = /<videomsg[^>]*\srawmd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
+            if (rawMd5Match) {
+                this.log('parseVideoMd5 命中 videomsg rawmd5 属性（自发视频）', { rawmd5: rawMd5Match[1] })
+                return rawMd5Match[1].toLowerCase()
             }
 
-            const attrMatch = /\smd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
+            // 方法3：任意属性 md5="..."（非 rawmd5/cdnthumbaeskey 等）
+            const attrMatch = /(?<![a-z])md5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
             if (attrMatch) {
+                this.log('parseVideoMd5 命中通用 md5 属性', { md5: attrMatch[1] })
                 return attrMatch[1].toLowerCase()
             }
 
-            const md5Match = /<md5>([a-fA-F0-9]+)<\/md5>/i.exec(content)
-            if (md5Match) {
-                return md5Match[1].toLowerCase()
+            // 方法4：<md5>...</md5> 标签
+            const md5TagMatch = /<md5>([a-fA-F0-9]+)<\/md5>/i.exec(content)
+            if (md5TagMatch) {
+                this.log('parseVideoMd5 命中 md5 标签', { md5: md5TagMatch[1] })
+                return md5TagMatch[1].toLowerCase()
             }
+
+            // 方法5：兜底取 rawmd5 属性（任意位置）
+            const rawMd5Fallback = /\srawmd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
+            if (rawMd5Fallback) {
+                this.log('parseVideoMd5 兜底命中 rawmd5', { rawmd5: rawMd5Fallback[1] })
+                return rawMd5Fallback[1].toLowerCase()
+            }
+
+            this.log('parseVideoMd5 未提取到任何 md5', { contentLength: content.length })
         } catch (e) {
-            console.error('[VideoService] 解析视频MD5失败:', e)
+            this.log('parseVideoMd5 异常', { error: String(e) })
         }
 
         return undefined

electron/services/wcdbCore.ts

@@ -1,8 +1,50 @@
-import { join, dirname, basename } from 'path'
+import { join, dirname, basename } from 'path'
 import { appendFileSync, existsSync, mkdirSync, readdirSync, statSync, readFileSync } from 'fs'
 
 // DLL 初始化错误信息，用于帮助用户诊断问题
 let lastDllInitError: string | null = null
+
+/**
+ * 解析 extra_buffer（protobuf）中的免打扰状态
+ * - field 12 (tag 0x60): 值非0 = 免打扰
+ * 折叠状态通过 contact.flag & 0x10000000 判断
+ */
+function parseExtraBuffer(raw: Buffer | string | null | undefined): { isMuted: boolean } {
+  if (!raw) return { isMuted: false }
+  // execQuery 返回的 BLOB 列是十六进制字符串，需要先解码
+  const buf: Buffer = typeof raw === 'string' ? Buffer.from(raw, 'hex') : raw
+  if (buf.length === 0) return { isMuted: false }
+  let isMuted = false
+  let i = 0
+  const len = buf.length
+
+  const readVarint = (): number => {
+    let result = 0, shift = 0
+    while (i < len) {
+      const b = buf[i++]
+      result |= (b & 0x7f) << shift
+      shift += 7
+      if (!(b & 0x80)) break
+    }
+    return result
+  }
+
+  while (i < len) {
+    const tag = readVarint()
+    const fieldNum = tag >>> 3
+    const wireType = tag & 0x07
+    if (wireType === 0) {
+      const val = readVarint()
+      if (fieldNum === 12 && val !== 0) isMuted = true
+    } else if (wireType === 2) {
+      const sz = readVarint()
+      i += sz
+    } else if (wireType === 5) { i += 4
+    } else if (wireType === 1) { i += 8
+    } else { break }
+  }
+  return { isMuted }
+}
 export function getLastDllInitError(): string | null {
   return lastDllInitError
 }
@@ -41,6 +83,7 @@ export class WcdbCore {
   private wcdbGetMessageTables: any = null
   private wcdbGetMessageMeta: any = null
   private wcdbGetContact: any = null
+  private wcdbGetContactStatus: any = null
   private wcdbGetMessageTableStats: any = null
   private wcdbGetAggregateStats: any = null
   private wcdbGetAvailableYears: any = null
@@ -63,10 +106,17 @@ export class WcdbCore {
   private wcdbGetVoiceData: any = null
   private wcdbGetSnsTimeline: any = null
   private wcdbGetSnsAnnualStats: any = null
+  private wcdbInstallSnsBlockDeleteTrigger: any = null
+  private wcdbUninstallSnsBlockDeleteTrigger: any = null
+  private wcdbCheckSnsBlockDeleteTrigger: any = null
+  private wcdbDeleteSnsPost: any = null
   private wcdbVerifyUser: any = null
   private wcdbStartMonitorPipe: any = null
   private wcdbStopMonitorPipe: any = null
   private wcdbGetMonitorPipeName: any = null
+  private wcdbCloudInit: any = null
+  private wcdbCloudReport: any = null
+  private wcdbCloudStop: any = null
 
   private monitorPipeClient: any = null
   private monitorCallback: ((type: string, json: string) => void) | null = null
@@ -483,6 +533,13 @@ export class WcdbCore {
       // wcdb_status wcdb_get_contact(wcdb_handle handle, const char* username, char** out_json)
       this.wcdbGetContact = this.lib.func('int32 wcdb_get_contact(int64 handle, const char* username, _Out_ void** outJson)')
 
+      // wcdb_status wcdb_get_contact_status(wcdb_handle handle, const char* usernames_json, char** out_json)
+      try {
+        this.wcdbGetContactStatus = this.lib.func('int32 wcdb_get_contact_status(int64 handle, const char* usernamesJson, _Out_ void** outJson)')
+      } catch {
+        this.wcdbGetContactStatus = null
+      }
+
       // wcdb_status wcdb_get_message_table_stats(wcdb_handle handle, const char* session_id, char** out_json)
       this.wcdbGetMessageTableStats = this.lib.func('int32 wcdb_get_message_table_stats(int64 handle, const char* sessionId, _Out_ void** outJson)')
 
@@ -600,6 +657,34 @@ export class WcdbCore {
         this.wcdbGetSnsAnnualStats = null
       }
 
+      // wcdb_status wcdb_install_sns_block_delete_trigger(wcdb_handle handle, char** out_error)
+      try {
+        this.wcdbInstallSnsBlockDeleteTrigger = this.lib.func('int32 wcdb_install_sns_block_delete_trigger(int64 handle, _Out_ void** outError)')
+      } catch {
+        this.wcdbInstallSnsBlockDeleteTrigger = null
+      }
+
+      // wcdb_status wcdb_uninstall_sns_block_delete_trigger(wcdb_handle handle, char** out_error)
+      try {
+        this.wcdbUninstallSnsBlockDeleteTrigger = this.lib.func('int32 wcdb_uninstall_sns_block_delete_trigger(int64 handle, _Out_ void** outError)')
+      } catch {
+        this.wcdbUninstallSnsBlockDeleteTrigger = null
+      }
+
+      // wcdb_status wcdb_check_sns_block_delete_trigger(wcdb_handle handle, int32_t* out_installed)
+      try {
+        this.wcdbCheckSnsBlockDeleteTrigger = this.lib.func('int32 wcdb_check_sns_block_delete_trigger(int64 handle, _Out_ int32* outInstalled)')
+      } catch {
+        this.wcdbCheckSnsBlockDeleteTrigger = null
+      }
+
+      // wcdb_status wcdb_delete_sns_post(wcdb_handle handle, const char* post_id, char** out_error)
+      try {
+        this.wcdbDeleteSnsPost = this.lib.func('int32 wcdb_delete_sns_post(int64 handle, const char* postId, _Out_ void** outError)')
+      } catch {
+        this.wcdbDeleteSnsPost = null
+      }
+
       // Named pipe IPC for monitoring (replaces callback)
       try {
         this.wcdbStartMonitorPipe = this.lib.func('int32 wcdb_start_monitor_pipe()')
@@ -620,6 +705,26 @@ export class WcdbCore {
         this.wcdbVerifyUser = null
       }
 
+      // wcdb_status wcdb_cloud_init(int32_t interval_seconds)
+      try {
+        this.wcdbCloudInit = this.lib.func('int32 wcdb_cloud_init(int32 intervalSeconds)')
+      } catch {
+        this.wcdbCloudInit = null
+      }
+
+      // wcdb_status wcdb_cloud_report(const char* stats_json)
+      try {
+        this.wcdbCloudReport = this.lib.func('int32 wcdb_cloud_report(const char* statsJson)')
+      } catch {
+        this.wcdbCloudReport = null
+      }
+
+      // void wcdb_cloud_stop()
+      try {
+        this.wcdbCloudStop = this.lib.func('void wcdb_cloud_stop()')
+      } catch {
+        this.wcdbCloudStop = null
+      }
 
 
       // 初始化
@@ -1062,6 +1167,40 @@ export class WcdbCore {
     }
   }
 
+  async getMessageCounts(sessionIds: string[]): Promise<{ success: boolean; counts?: Record<string, number>; error?: string }> {
+    if (!this.ensureReady()) {
+      return { success: false, error: 'WCDB 未连接' }
+    }
+
+    const normalizedSessionIds = Array.from(
+      new Set(
+        (sessionIds || [])
+          .map((id) => String(id || '').trim())
+          .filter(Boolean)
+      )
+    )
+    if (normalizedSessionIds.length === 0) {
+      return { success: true, counts: {} }
+    }
+
+    try {
+      const counts: Record<string, number> = {}
+      for (let i = 0; i < normalizedSessionIds.length; i += 1) {
+        const sessionId = normalizedSessionIds[i]
+        const outCount = [0]
+        const result = this.wcdbGetMessageCount(this.handle, sessionId, outCount)
+        counts[sessionId] = result === 0 && Number.isFinite(outCount[0]) ? Math.max(0, Math.floor(outCount[0])) : 0
+
+        if (i > 0 && i % 160 === 0) {
+          await new Promise(resolve => setImmediate(resolve))
+        }
+      }
+      return { success: true, counts }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
   async getDisplayNames(usernames: string[]): Promise<{ success: boolean; map?: Record<string, string>; error?: string }> {
     if (!this.ensureReady()) {
       return { success: false, error: 'WCDB 未连接' }
@@ -1338,6 +1477,36 @@ export class WcdbCore {
     }
   }
 
+  async getContactStatus(usernames: string[]): Promise<{ success: boolean; map?: Record<string, { isFolded: boolean; isMuted: boolean }>; error?: string }> {
+    if (!this.ensureReady()) {
+      return { success: false, error: 'WCDB 未连接' }
+    }
+    try {
+      // 分批查询，避免 SQL 过长（execQuery 不支持参数绑定，直接拼 SQL）
+      const BATCH = 200
+      const map: Record<string, { isFolded: boolean; isMuted: boolean }> = {}
+      for (let i = 0; i < usernames.length; i += BATCH) {
+        const batch = usernames.slice(i, i + BATCH)
+        const inList = batch.map(u => `'${u.replace(/'/g, "''")}'`).join(',')
+        const sql = `SELECT username, flag, extra_buffer FROM contact WHERE username IN (${inList})`
+        const result = await this.execQuery('contact', null, sql)
+        if (!result.success || !result.rows) continue
+        for (const row of result.rows) {
+          const uname: string = row.username
+          // 折叠：flag bit 28 (0x10000000)
+          const flag = parseInt(row.flag ?? '0', 10)
+          const isFolded = (flag & 0x10000000) !== 0
+          // 免打扰：extra_buffer field 12 非0
+          const { isMuted } = parseExtraBuffer(row.extra_buffer)
+          map[uname] = { isFolded, isMuted }
+        }
+      }
+      return { success: true, map }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
   async getAggregateStats(sessionIds: string[], beginTimestamp: number = 0, endTimestamp: number = 0): Promise<{ success: boolean; data?: any; error?: string }> {
     if (!this.ensureReady()) {
       return { success: false, error: 'WCDB 未连接' }
@@ -1729,8 +1898,57 @@ export class WcdbCore {
   }
 
   /**
-   * 验证 Windows Hello
+   * 数据收集初始化
    */
+  async cloudInit(intervalSeconds: number = 600): Promise<{ success: boolean; error?: string }> {
+    if (!this.initialized) {
+      const initOk = await this.initialize()
+      if (!initOk) return { success: false, error: 'WCDB init failed' }
+    }
+    if (!this.wcdbCloudInit) {
+      return { success: false, error: 'Cloud init API not supported by DLL' }
+    }
+    try {
+      const result = this.wcdbCloudInit(intervalSeconds)
+      if (result !== 0) {
+        return { success: false, error: `Cloud init failed: ${result}` }
+      }
+      return { success: true }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
+  async cloudReport(statsJson: string): Promise<{ success: boolean; error?: string }> {
+    if (!this.initialized) {
+      const initOk = await this.initialize()
+      if (!initOk) return { success: false, error: 'WCDB init failed' }
+    }
+    if (!this.wcdbCloudReport) {
+      return { success: false, error: 'Cloud report API not supported by DLL' }
+    }
+    try {
+      const result = this.wcdbCloudReport(statsJson || '')
+      if (result !== 0) {
+        return { success: false, error: `Cloud report failed: ${result}` }
+      }
+      return { success: true }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
+  cloudStop(): { success: boolean; error?: string } {
+    if (!this.wcdbCloudStop) {
+      return { success: false, error: 'Cloud stop API not supported by DLL' }
+    }
+    try {
+      this.wcdbCloudStop()
+      return { success: true }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
   async verifyUser(message: string, hwnd?: string): Promise<{ success: boolean; error?: string }> {
     if (!this.initialized) {
       const initOk = await this.initialize()
@@ -1813,6 +2031,94 @@ export class WcdbCore {
       return { success: false, error: String(e) }
     }
   }
+  /**
+   * 为朋友圈安装删除
+   */
+  async installSnsBlockDeleteTrigger(): Promise<{ success: boolean; alreadyInstalled?: boolean; error?: string }> {
+    if (!this.ensureReady()) return { success: false, error: 'WCDB 未连接' }
+    if (!this.wcdbInstallSnsBlockDeleteTrigger) return { success: false, error: '当前 DLL 版本不支持此功能' }
+    try {
+      const outPtr = [null]
+      const status = this.wcdbInstallSnsBlockDeleteTrigger(this.handle, outPtr)
+      let msg = ''
+      if (outPtr[0]) {
+        try { msg = this.koffi.decode(outPtr[0], 'char', -1) } catch { }
+        try { this.wcdbFreeString(outPtr[0]) } catch { }
+      }
+      if (status === 1) {
+        // DLL 返回 1 表示已安装
+        return { success: true, alreadyInstalled: true }
+      }
+      if (status !== 0) {
+        return { success: false, error: msg || `DLL error ${status}` }
+      }
+      return { success: true, alreadyInstalled: false }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
+  /**
+   * 关闭朋友圈删除拦截
+   */
+  async uninstallSnsBlockDeleteTrigger(): Promise<{ success: boolean; error?: string }> {
+    if (!this.ensureReady()) return { success: false, error: 'WCDB 未连接' }
+    if (!this.wcdbUninstallSnsBlockDeleteTrigger) return { success: false, error: '当前 DLL 版本不支持此功能' }
+    try {
+      const outPtr = [null]
+      const status = this.wcdbUninstallSnsBlockDeleteTrigger(this.handle, outPtr)
+      let msg = ''
+      if (outPtr[0]) {
+        try { msg = this.koffi.decode(outPtr[0], 'char', -1) } catch { }
+        try { this.wcdbFreeString(outPtr[0]) } catch { }
+      }
+      if (status !== 0) {
+        return { success: false, error: msg || `DLL error ${status}` }
+      }
+      return { success: true }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
+  /**
+   * 查询朋友圈删除拦截是否已安装
+   */
+  async checkSnsBlockDeleteTrigger(): Promise<{ success: boolean; installed?: boolean; error?: string }> {
+    if (!this.ensureReady()) return { success: false, error: 'WCDB 未连接' }
+    if (!this.wcdbCheckSnsBlockDeleteTrigger) return { success: false, error: '当前 DLL 版本不支持此功能' }
+    try {
+      const outInstalled = [0]
+      const status = this.wcdbCheckSnsBlockDeleteTrigger(this.handle, outInstalled)
+      if (status !== 0) {
+        return { success: false, error: `DLL error ${status}` }
+      }
+      return { success: true, installed: outInstalled[0] === 1 }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
+  async deleteSnsPost(postId: string): Promise<{ success: boolean; error?: string }> {
+    if (!this.ensureReady()) return { success: false, error: 'WCDB 未连接' }
+    if (!this.wcdbDeleteSnsPost) return { success: false, error: '当前 DLL 版本不支持此功能' }
+    try {
+      const outPtr = [null]
+      const status = this.wcdbDeleteSnsPost(this.handle, postId, outPtr)
+      let msg = ''
+      if (outPtr[0]) {
+        try { msg = this.koffi.decode(outPtr[0], 'char', -1) } catch { }
+        try { this.wcdbFreeString(outPtr[0]) } catch { }
+      }
+      if (status !== 0) {
+        return { success: false, error: msg || `DLL error ${status}` }
+      }
+      return { success: true }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
   async getDualReportStats(sessionId: string, beginTimestamp: number = 0, endTimestamp: number = 0): Promise<{ success: boolean; data?: any; error?: string }> {
     if (!this.ensureReady()) {
       return { success: false, error: 'WCDB 未连接' }
@@ -1893,4 +2199,3 @@ export class WcdbCore {
     })
   }
 }
-

electron/services/wcdbService.ts

@@ -218,6 +218,10 @@ export class WcdbService {
     return this.callWorker('getMessageCount', { sessionId })
   }
 
+  async getMessageCounts(sessionIds: string[]): Promise<{ success: boolean; counts?: Record<string, number>; error?: string }> {
+    return this.callWorker('getMessageCounts', { sessionIds })
+  }
+
   /**
    * 获取联系人昵称
    */
@@ -290,6 +294,13 @@ export class WcdbService {
     return this.callWorker('getContact', { username })
   }
 
+  /**
+   * 批量获取联系人 extra_buffer 状态（isFolded/isMuted）
+   */
+  async getContactStatus(usernames: string[]): Promise<{ success: boolean; map?: Record<string, { isFolded: boolean; isMuted: boolean }>; error?: string }> {
+    return this.callWorker('getContactStatus', { usernames })
+  }
+
   /**
    * 获取聚合统计数据
    */
@@ -416,6 +427,34 @@ export class WcdbService {
     return this.callWorker('getSnsAnnualStats', { beginTimestamp, endTimestamp })
   }
 
+  /**
+   * 安装朋友圈删除拦截
+   */
+  async installSnsBlockDeleteTrigger(): Promise<{ success: boolean; alreadyInstalled?: boolean; error?: string }> {
+    return this.callWorker('installSnsBlockDeleteTrigger')
+  }
+
+  /**
+   * 卸载朋友圈删除拦截
+   */
+  async uninstallSnsBlockDeleteTrigger(): Promise<{ success: boolean; error?: string }> {
+    return this.callWorker('uninstallSnsBlockDeleteTrigger')
+  }
+
+  /**
+   * 查询朋友圈删除拦截是否已安装
+   */
+  async checkSnsBlockDeleteTrigger(): Promise<{ success: boolean; installed?: boolean; error?: string }> {
+    return this.callWorker('checkSnsBlockDeleteTrigger')
+  }
+
+  /**
+   * 从数据库直接删除朋友圈记录
+   */
+  async deleteSnsPost(postId: string): Promise<{ success: boolean; error?: string }> {
+    return this.callWorker('deleteSnsPost', { postId })
+  }
+
   /**
    * 获取 DLL 内部日志
    */
@@ -444,6 +483,27 @@ export class WcdbService {
     return this.callWorker('deleteMessage', { sessionId, localId, createTime, dbPathHint })
   }
 
+  /**
+   * 数据收集：初始化
+   */
+  async cloudInit(intervalSeconds: number): Promise<{ success: boolean; error?: string }> {
+    return this.callWorker('cloudInit', { intervalSeconds })
+  }
+
+  /**
+   * 数据收集：上报数据
+   */
+  async cloudReport(statsJson: string): Promise<{ success: boolean; error?: string }> {
+    return this.callWorker('cloudReport', { statsJson })
+  }
+
+  /**
+   * 数据收集：停止
+   */
+  cloudStop(): Promise<{ success: boolean; error?: string }> {
+    return this.callWorker('cloudStop', {})
+  }
+
 
 
 }

electron/wcdbWorker.ts

@@ -54,6 +54,9 @@ if (parentPort) {
                 case 'getMessageCount':
                     result = await core.getMessageCount(payload.sessionId)
                     break
+                case 'getMessageCounts':
+                    result = await core.getMessageCounts(payload.sessionIds)
+                    break
                 case 'getDisplayNames':
                     result = await core.getDisplayNames(payload.usernames)
                     break
@@ -87,6 +90,9 @@ if (parentPort) {
                 case 'getContact':
                     result = await core.getContact(payload.username)
                     break
+                case 'getContactStatus':
+                    result = await core.getContactStatus(payload.usernames)
+                    break
                 case 'getAggregateStats':
                     result = await core.getAggregateStats(payload.sessionIds, payload.beginTimestamp, payload.endTimestamp)
                     break
@@ -144,6 +150,18 @@ if (parentPort) {
                 case 'getSnsAnnualStats':
                     result = await core.getSnsAnnualStats(payload.beginTimestamp, payload.endTimestamp)
                     break
+                case 'installSnsBlockDeleteTrigger':
+                    result = await core.installSnsBlockDeleteTrigger()
+                    break
+                case 'uninstallSnsBlockDeleteTrigger':
+                    result = await core.uninstallSnsBlockDeleteTrigger()
+                    break
+                case 'checkSnsBlockDeleteTrigger':
+                    result = await core.checkSnsBlockDeleteTrigger()
+                    break
+                case 'deleteSnsPost':
+                    result = await core.deleteSnsPost(payload.postId)
+                    break
                 case 'getLogs':
                     result = await core.getLogs()
                     break
@@ -156,7 +174,15 @@ if (parentPort) {
                 case 'deleteMessage':
                     result = await core.deleteMessage(payload.sessionId, payload.localId, payload.createTime, payload.dbPathHint)
                     break
-
+                case 'cloudInit':
+                    result = await core.cloudInit(payload.intervalSeconds)
+                    break
+                case 'cloudReport':
+                    result = await core.cloudReport(payload.statsJson)
+                    break
+                case 'cloudStop':
+                    result = core.cloudStop()
+                    break
                 default:
                     result = { success: false, error: `Unknown method: ${type}` }
             }

electron/windows/notificationWindow.ts

@@ -5,6 +5,28 @@ import { ConfigService } from '../services/config'
 let notificationWindow: BrowserWindow | null = null
 let closeTimer: NodeJS.Timeout | null = null
 
+export function destroyNotificationWindow() {
+    if (closeTimer) {
+        clearTimeout(closeTimer)
+        closeTimer = null
+    }
+    lastNotificationData = null
+
+    if (!notificationWindow || notificationWindow.isDestroyed()) {
+        notificationWindow = null
+        return
+    }
+
+    const win = notificationWindow
+    notificationWindow = null
+
+    try {
+        win.destroy()
+    } catch (error) {
+        console.warn('[NotificationWindow] Failed to destroy window:', error)
+    }
+}
+
 export function createNotificationWindow() {
     if (notificationWindow && !notificationWindow.isDestroyed()) {
         return notificationWindow

package.json

@@ -13,6 +13,7 @@
     "postinstall": "electron-builder install-app-deps",
     "rebuild": "electron-rebuild",
     "dev": "vite",
+    "typecheck": "tsc --noEmit",
     "build": "tsc && vite build && electron-builder",
     "preview": "vite preview",
     "electron:dev": "vite --mode electron",

public/splash.html

@@ -0,0 +1,249 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>WeFlow</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+
+    html, body {
+      width: 100%; height: 100%;
+      background: transparent;
+      overflow: hidden;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Microsoft YaHei', sans-serif;
+      user-select: none;
+      -webkit-app-region: drag;
+    }
+
+    .splash {
+      width: 100%; height: 100%;
+      border-radius: 20px;
+      display: flex;
+      flex-direction: column;
+    }
+
+    /* 品牌区 */
+    .brand {
+      padding: 48px 52px 0;
+      display: flex;
+      align-items: center;
+      gap: 18px;
+      animation: fadeIn 0.4s ease both;
+    }
+    .logo {
+      width: 56px; height: 56px;
+      border-radius: 14px;
+      flex-shrink: 0;
+    }
+    .app-name {
+      font-size: 22px;
+      font-weight: 700;
+      letter-spacing: 0.3px;
+    }
+    .app-desc {
+      font-size: 12px;
+      margin-top: 5px;
+      opacity: 0.6;
+    }
+
+    .spacer { flex: 1; }
+
+    /* 底部进度区 */
+    .bottom {
+      padding: 0 48px 40px;
+      animation: fadeIn 0.4s ease 0.1s both;
+    }
+
+    /* 进度条轨道 */
+    .progress-track {
+      width: 100%;
+      height: 2px;
+      border-radius: 2px;
+      margin-bottom: 12px;
+      position: relative;
+      overflow: hidden;
+    }
+
+    /* 进度条填充 */
+    .progress-fill {
+      height: 100%;
+      width: 0%;
+      border-radius: 2px;
+      position: relative;
+      transition: width 0.5s cubic-bezier(0.4, 0, 0.2, 1);
+      overflow: hidden;
+    }
+
+    /* 扫光：只在有进度时显示，不循环 */
+    .progress-fill::after {
+      content: '';
+      position: absolute;
+      top: 0; left: 0;
+      width: 100%; height: 100%;
+      background: linear-gradient(90deg, transparent 0%, rgba(255,255,255,0.5) 50%, transparent 100%);
+      animation: sweep 1.2s ease-out forwards;
+      opacity: 0;
+    }
+
+    /* 等待阶段：进度条末端呼吸光点 */
+    .progress-fill.waiting::before {
+      content: '';
+      position: absolute;
+      top: -1px; right: -2px;
+      width: 6px; height: 4px;
+      border-radius: 50%;
+      background: inherit;
+      filter: blur(2px);
+      animation: pulse 1.5s ease-in-out infinite;
+    }
+
+    .bottom-row {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    .progress-text {
+      font-size: 11px;
+      opacity: 0.38;
+    }
+    .version {
+      font-size: 11px;
+      opacity: 0.25;
+    }
+
+    @keyframes fadeIn {
+      from { opacity: 0; transform: translateY(4px); }
+      to   { opacity: 1; transform: translateY(0); }
+    }
+    @keyframes sweep {
+      0%   { opacity: 0; transform: translateX(-100%); }
+      20%  { opacity: 1; }
+      80%  { opacity: 1; }
+      100% { opacity: 0; transform: translateX(100%); }
+    }
+    @keyframes pulse {
+      0%, 100% { opacity: 0.4; transform: scaleX(1); }
+      50%       { opacity: 1;   transform: scaleX(1.8); }
+    }
+  </style>
+</head>
+<body>
+  <div class="splash" id="splash">
+    <div class="brand">
+      <img class="logo" src="./logo.png" alt="WeFlow" />
+      <div class="brand-text">
+        <div class="app-name" id="appName">WeFlow</div>
+        <div class="app-desc" id="appDesc">微信聊天记录管理工具</div>
+      </div>
+    </div>
+
+    <div class="spacer"></div>
+
+    <div class="bottom">
+      <div class="progress-track" id="progressTrack">
+        <div class="progress-fill" id="progressFill"></div>
+      </div>
+      <div class="bottom-row">
+        <div class="progress-text" id="progressText">正在启动...</div>
+        <div class="version" id="versionText"></div>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    var themes = {
+      'cloud-dancer': {
+        light: { primary: '#8B7355', bg: '#F0EEE9', bgEnd: '#E5E1DA', text: '#3d3d3d', desc: '#8B7355' },
+        dark:  { primary: '#C9A86C', bg: '#1a1816', bgEnd: '#252220', text: '#F0EEE9', desc: '#C9A86C' }
+      },
+      'corundum-blue': {
+        light: { primary: '#4A6670', bg: '#E8EEF0', bgEnd: '#D8E4E8', text: '#3d3d3d', desc: '#4A6670' },
+        dark:  { primary: '#6A9AAA', bg: '#141a1c', bgEnd: '#1e2a2e', text: '#E0EEF2', desc: '#6A9AAA' }
+      },
+      'kiwi-green': {
+        light: { primary: '#7A9A5C', bg: '#E8F0E4', bgEnd: '#D8E8D2', text: '#3d3d3d', desc: '#7A9A5C' },
+        dark:  { primary: '#9ABA7C', bg: '#161a14', bgEnd: '#222a1e', text: '#E8F0E4', desc: '#9ABA7C' }
+      },
+      'spicy-red': {
+        light: { primary: '#8B4049', bg: '#F0E8E8', bgEnd: '#E8D8D8', text: '#3d3d3d', desc: '#8B4049' },
+        dark:  { primary: '#C06068', bg: '#1a1416', bgEnd: '#261e20', text: '#F2E8EA', desc: '#C06068' }
+      },
+      'teal-water': {
+        light: { primary: '#5A8A8A', bg: '#E4F0F0', bgEnd: '#D2E8E8', text: '#3d3d3d', desc: '#5A8A8A' },
+        dark:  { primary: '#7ABAAA', bg: '#121a1a', bgEnd: '#1a2626', text: '#E0F2EE', desc: '#7ABAAA' }
+      },
+      'blossom-dream': {
+        light: { primary: '#D4849A', primaryEnd: '#D4849A', bg: '#FCF9FB', bgMid: '#F8F2F8', bgEnd: '#F2F6FB', text: '#2E2633', desc: '#D4849A' },
+        dark:  { primary: '#C670C3', primaryEnd: '#8A60C0', bg: '#120B16', bgMid: '#1A1020', bgEnd: '#0E0B18', text: '#F2EAF4', desc: '#C670C3' }
+      }
+    };
+
+    function applyTheme(themeId, mode) {
+      var t = themes[themeId] || themes['cloud-dancer'];
+      var isDark = mode === 'dark';
+      if (mode === 'system') isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+      var c = isDark ? t.dark : t.light;
+
+      var el = document.getElementById('splash');
+      var fill = document.getElementById('progressFill');
+
+      if (themeId === 'blossom-dream') {
+        if (isDark) {
+          // 深色
+          el.style.background =
+            'radial-gradient(ellipse 60% 50% at 100% 0%, ' + c.primary + '28 0%, transparent 70%), ' +
+            'linear-gradient(150deg, ' + c.bg + ' 0%, ' + c.bgMid + ' 45%, ' + c.bgEnd + ' 100%)';
+        } else {
+          // 浅色
+          el.style.background = 'linear-gradient(150deg, ' + c.bg + ' 0%, ' + c.bgMid + ' 45%, ' + c.bgEnd + ' 100%)';
+        }
+        // 进度条
+        fill.style.background = 'linear-gradient(90deg, ' + c.primary + ' 0%, ' + c.primaryEnd + ' 100%)';
+      } else {
+        if (isDark) {
+          el.style.background =
+            'radial-gradient(ellipse 60% 50% at 100% 0%, ' + c.primary + '22 0%, transparent 70%), ' +
+            'linear-gradient(145deg, ' + c.bg + ' 0%, ' + c.bgEnd + ' 100%)';
+        } else {
+          el.style.background = 'linear-gradient(150deg, ' + c.bg + ' 0%, ' + c.bgEnd + ' 100%)';
+        }
+        fill.style.background = c.primary;
+      }
+
+      document.getElementById('appName').style.color = c.text;
+      document.getElementById('appDesc').style.color = c.desc;
+      document.getElementById('progressText').style.color = c.text;
+      document.getElementById('versionText').style.color = c.text;
+      document.getElementById('progressTrack').style.background = c.primary + (isDark ? '25' : '18');
+    }
+
+    // percent: 实际进度值；waiting: 是否处于等待阶段
+    function updateProgress(percent, text, waiting) {
+      var fill = document.getElementById('progressFill');
+      var label = document.getElementById('progressText');
+
+      if (fill) {
+        fill.style.width = percent + '%';
+        if (waiting) {
+          fill.classList.add('waiting');
+        } else {
+          fill.classList.remove('waiting');
+          // 触发扫光：重置动画
+          fill.style.animation = 'none';
+          fill.offsetHeight;
+          fill.style.animation = '';
+        }
+      }
+      if (label && text) label.textContent = text;
+    }
+
+    function setVersion(ver) {
+      var el = document.getElementById('versionText');
+      if (el) el.textContent = 'v' + ver;
+    }
+
+    applyTheme('cloud-dancer', 'light');
+  </script>
+</body>
+</html>

src/App.scss

@@ -4,6 +4,48 @@
   flex-direction: column;
   background: var(--bg-primary);
   animation: appFadeIn 0.35s ease-out;
+  position: relative;
+  overflow: hidden;
+}
+
+// 繁花如梦：底色层（::before）+ 光晕层（::after）分离，避免 blur 吃掉边缘
+[data-theme="blossom-dream"] .app-container {
+  background: transparent;
+}
+
+// ::before 纯底色，不模糊
+[data-theme="blossom-dream"] .app-container::before {
+  content: '';
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  z-index: -2;
+  background: var(--bg-primary);
+}
+
+// ::after 光晕层，模糊叠加在底色上
+[data-theme="blossom-dream"] .app-container::after {
+  content: '';
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  z-index: -1;
+  background:
+    radial-gradient(ellipse 55% 45% at 15% 20%, var(--blossom-pink) 0%, transparent 70%),
+    radial-gradient(ellipse 50% 40% at 85% 75%, var(--blossom-peach) 0%, transparent 65%),
+    radial-gradient(ellipse 45% 50% at 80% 10%, var(--blossom-blue) 0%, transparent 60%);
+  filter: blur(80px);
+  opacity: 0.75;
+}
+
+// 深色模式光晕更克制
+[data-theme="blossom-dream"][data-mode="dark"] .app-container::after {
+  background:
+    radial-gradient(ellipse 55% 45% at 15% 20%, var(--blossom-pink) 0%, transparent 70%),
+    radial-gradient(ellipse 50% 40% at 85% 75%, var(--blossom-purple) 0%, transparent 65%),
+    radial-gradient(ellipse 45% 50% at 80% 10%, var(--blossom-blue) 0%, transparent 60%);
+  filter: blur(100px);
+  opacity: 0.2;
 }
 
 .window-drag-region {
@@ -27,6 +69,19 @@
   flex: 1;
   overflow: auto;
   padding: 24px;
+  position: relative;
+}
+
+.export-keepalive-page {
+  height: 100%;
+
+  &.hidden {
+    display: none;
+  }
+}
+
+.export-route-anchor {
+  display: none;
 }
 
 @keyframes appFadeIn {

src/App.tsx

@@ -26,6 +26,7 @@ import NotificationWindow from './pages/NotificationWindow'
 import { useAppStore } from './stores/appStore'
 import { themes, useThemeStore, type ThemeId, type ThemeMode } from './stores/themeStore'
 import * as configService from './services/config'
+import * as cloudControl from './services/cloudControl'
 import { Download, X, Shield } from 'lucide-react'
 import './App.scss'
 
@@ -60,7 +61,9 @@ function App() {
   const isOnboardingWindow = location.pathname === '/onboarding-window'
   const isVideoPlayerWindow = location.pathname === '/video-player-window'
   const isChatHistoryWindow = location.pathname.startsWith('/chat-history/')
+  const isStandaloneChatWindow = location.pathname === '/chat-window'
   const isNotificationWindow = location.pathname === '/notification-window'
+  const isExportRoute = location.pathname === '/export'
   const [themeHydrated, setThemeHydrated] = useState(false)
 
   // 锁定状态
@@ -75,6 +78,9 @@ function App() {
   const [agreementChecked, setAgreementChecked] = useState(false)
   const [agreementLoading, setAgreementLoading] = useState(true)
 
+  // 数据收集同意状态
+  const [showAnalyticsConsent, setShowAnalyticsConsent] = useState(false)
+
   useEffect(() => {
     const root = document.documentElement
     const body = document.body
@@ -170,6 +176,14 @@ function App() {
         const agreed = await configService.getAgreementAccepted()
         if (!agreed) {
           setShowAgreement(true)
+        } else {
+          // 协议已同意，检查数据收集同意状态
+          const consent = await configService.getAnalyticsConsent()
+          const denyCount = await configService.getAnalyticsDenyCount()
+          // 如果未设置同意状态且拒绝次数小于2次，显示弹窗
+          if (consent === null && denyCount < 2) {
+            setShowAnalyticsConsent(true)
+          }
         }
       } catch (e) {
         console.error('检查协议状态失败:', e)
@@ -180,16 +194,45 @@ function App() {
     checkAgreement()
   }, [])
 
+  // 初始化数据收集
+  useEffect(() => {
+    cloudControl.initCloudControl()
+  }, [])
+
+  // 记录页面访问
+  useEffect(() => {
+    const path = location.pathname
+    if (path && path !== '/') {
+      cloudControl.recordPage(path)
+    }
+  }, [location.pathname])
+
   const handleAgree = async () => {
     if (!agreementChecked) return
     await configService.setAgreementAccepted(true)
     setShowAgreement(false)
+    // 协议同意后，检查数据收集同意
+    const consent = await configService.getAnalyticsConsent()
+    if (consent === null) {
+      setShowAnalyticsConsent(true)
+    }
   }
 
   const handleDisagree = () => {
     window.electronAPI.window.close()
   }
 
+  const handleAnalyticsAllow = async () => {
+    await configService.setAnalyticsConsent(true)
+    setShowAnalyticsConsent(false)
+  }
+
+  const handleAnalyticsDeny = async () => {
+    const denyCount = await configService.getAnalyticsDenyCount()
+    await configService.setAnalyticsDenyCount(denyCount + 1)
+    setShowAnalyticsConsent(false)
+  }
+
   // 监听启动时的更新通知
   useEffect(() => {
     if (isNotificationWindow) return // Skip updates in notification window
@@ -360,6 +403,26 @@ function App() {
     return <ChatHistoryPage />
   }
 
+  // 独立会话聊天窗口（仅显示聊天内容区域）
+  if (isStandaloneChatWindow) {
+    const params = new URLSearchParams(location.search)
+    const sessionId = params.get('sessionId') || ''
+    const standaloneSource = params.get('source')
+    const standaloneInitialDisplayName = params.get('initialDisplayName')
+    const standaloneInitialAvatarUrl = params.get('initialAvatarUrl')
+    const standaloneInitialContactType = params.get('initialContactType')
+    return (
+      <ChatPage
+        standaloneSessionWindow
+        initialSessionId={sessionId}
+        standaloneSource={standaloneSource}
+        standaloneInitialDisplayName={standaloneInitialDisplayName}
+        standaloneInitialAvatarUrl={standaloneInitialAvatarUrl}
+        standaloneInitialContactType={standaloneInitialContactType}
+      />
+    )
+  }
+
   // 独立通知窗口
   if (isNotificationWindow) {
     return <NotificationWindow />
@@ -439,6 +502,42 @@ function App() {
         </div>
       )}
 
+      {/* 数据收集同意弹窗 */}
+      {showAnalyticsConsent && !agreementLoading && (
+        <div className="agreement-overlay">
+          <div className="agreement-modal">
+            <div className="agreement-header">
+              <Shield size={32} />
+              <h2>使用数据收集说明</h2>
+            </div>
+            <div className="agreement-content">
+              <div className="agreement-text">
+                <p>为了持续改进 WeFlow 并提供更好的用户体验，我们希望收集一些匿名的使用数据。</p>
+
+                <h4>我们会收集什么？</h4>
+                <p>• 功能使用情况（如哪些功能被使用、使用频率）</p>
+                <p>• 应用性能数据（如加载时间、错误日志）</p>
+                <p>• 设备基本信息（如操作系统版本、应用版本）</p>
+
+                <h4>我们不会收集什么？</h4>
+                <p>• 你的聊天记录内容</p>
+                <p>• 个人身份信息</p>
+                <p>• 联系人信息</p>
+                <p>• 任何可以识别你身份的数据</p>
+                <p>• 一切你担心会涉及隐藏的数据</p>
+
+              </div>
+            </div>
+            <div className="agreement-footer">
+              <div className="agreement-actions">
+                <button className="btn btn-secondary" onClick={handleAnalyticsDeny}>不允许</button>
+                <button className="btn btn-primary" onClick={handleAnalyticsAllow}>允许</button>
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+
       {/* 更新提示对话框 */}
       <UpdateDialog
         open={showUpdateDialog}
@@ -454,6 +553,10 @@ function App() {
         <Sidebar />
         <main className="content">
           <RouteGuard>
+            <div className={`export-keepalive-page ${isExportRoute ? 'active' : 'hidden'}`} aria-hidden={!isExportRoute}>
+              <ExportPage />
+            </div>
+
             <Routes>
               <Route path="/" element={<HomePage />} />
               <Route path="/home" element={<HomePage />} />
@@ -468,7 +571,7 @@ function App() {
               <Route path="/dual-report/view" element={<DualReportWindow />} />
 
               <Route path="/settings" element={<SettingsPage />} />
-              <Route path="/export" element={<ExportPage />} />
+              <Route path="/export" element={<div className="export-route-anchor" aria-hidden="true" />} />
               <Route path="/sns" element={<SnsPage />} />
               <Route path="/contacts" element={<ContactsPage />} />
               <Route path="/chat-history/:sessionId/:messageId" element={<ChatHistoryPage />} />

src/components/Export/ExportDateRangeDialog.scss

@@ -0,0 +1,254 @@
+.export-date-range-dialog-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.35);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 16px;
+  z-index: 2400;
+}
+
+.export-date-range-dialog {
+  width: min(480px, calc(100vw - 32px));
+  max-height: calc(100vh - 64px);
+  overflow-y: auto;
+  border-radius: 12px;
+  border: 1px solid var(--border-color);
+  background: var(--bg-secondary-solid, var(--bg-primary));
+  padding: 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.export-date-range-dialog-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+
+  h4 {
+    margin: 0;
+    font-size: 14px;
+    color: var(--text-primary);
+  }
+}
+
+.export-date-range-dialog-close-btn {
+  border: 1px solid var(--border-color);
+  background: var(--bg-secondary);
+  border-radius: 8px;
+  width: 30px;
+  height: 30px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  color: var(--text-secondary);
+}
+
+.export-date-range-preset-list {
+  display: flex;
+  flex-wrap: nowrap;
+  gap: 4px;
+  overflow-x: auto;
+  padding-bottom: 2px;
+
+  &::-webkit-scrollbar {
+    height: 4px;
+  }
+}
+
+.export-date-range-preset-item {
+  flex: 0 0 auto;
+  border: 1px solid var(--border-color);
+  border-radius: 8px;
+  background: var(--bg-secondary);
+  color: var(--text-primary);
+  min-height: 30px;
+  padding: 0 8px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 4px;
+  font-size: 11px;
+  cursor: pointer;
+  white-space: nowrap;
+
+  &.active {
+    border-color: var(--primary);
+    background: rgba(var(--primary-rgb), 0.08);
+    color: var(--primary);
+  }
+}
+
+.export-date-range-mode-banner {
+  border-radius: 8px;
+  padding: 6px 8px;
+  font-size: 11px;
+  line-height: 1.4;
+  border: 1px solid var(--border-color);
+  background: var(--bg-secondary);
+  color: var(--text-secondary);
+
+  &.range {
+    border-color: rgba(var(--primary-rgb), 0.4);
+    background: rgba(var(--primary-rgb), 0.1);
+    color: var(--primary);
+  }
+}
+
+.export-date-range-calendar-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 8px;
+}
+
+.export-date-range-calendar-panel {
+  border: 1px solid var(--border-color);
+  border-radius: 8px;
+  background: var(--bg-secondary);
+  padding: 7px;
+}
+
+.export-date-range-calendar-panel-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  gap: 8px;
+}
+
+.export-date-range-calendar-date-label {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+
+  span {
+    font-size: 11px;
+    color: var(--text-secondary);
+  }
+}
+
+.export-date-range-date-input {
+  width: 100%;
+  min-width: 0;
+  border-radius: 6px;
+  border: 1px solid var(--border-color);
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  height: 24px;
+  padding: 0 7px;
+  font-size: 11px;
+
+  &.invalid {
+    border-color: #e84d4d;
+    box-shadow: 0 0 0 1px rgba(232, 77, 77, 0.2);
+  }
+}
+
+.export-date-range-calendar-nav {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  font-size: 11px;
+  color: var(--text-primary);
+
+  button {
+    width: 20px;
+    height: 20px;
+    border-radius: 5px;
+    border: 1px solid var(--border-color);
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    cursor: pointer;
+    padding: 0;
+    line-height: 1;
+  }
+}
+
+.export-date-range-calendar-weekdays {
+  margin-top: 6px;
+  display: grid;
+  grid-template-columns: repeat(7, 1fr);
+  gap: 2px;
+
+  span {
+    text-align: center;
+    font-size: 10px;
+    color: var(--text-tertiary);
+  }
+}
+
+.export-date-range-calendar-days {
+  margin-top: 4px;
+  display: grid;
+  grid-template-columns: repeat(7, 1fr);
+  gap: 2px;
+}
+
+.export-date-range-calendar-day {
+  border: 1px solid transparent;
+  border-radius: 6px;
+  min-height: 20px;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  font-size: 10px;
+  cursor: pointer;
+  padding: 0;
+
+  &.outside {
+    color: var(--text-quaternary);
+    opacity: 0.75;
+  }
+
+  &.selected {
+    border-color: var(--primary);
+    background: rgba(var(--primary-rgb), 0.14);
+    color: var(--primary);
+    font-weight: 600;
+  }
+}
+
+.export-date-range-dialog-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+.export-date-range-dialog-btn {
+  border-radius: 8px;
+  padding: 7px 12px;
+  font-size: 12px;
+  font-weight: 600;
+  border: 1px solid var(--border-color);
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  cursor: pointer;
+
+  &.primary {
+    border-color: var(--primary);
+    background: var(--primary);
+    color: #fff;
+
+    &:hover {
+      background: var(--primary-hover);
+    }
+  }
+
+  &.secondary {
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+
+    &:hover {
+      border-color: var(--primary);
+      color: var(--primary);
+    }
+  }
+}
+
+@media (max-width: 860px) {
+  .export-date-range-calendar-grid {
+    grid-template-columns: 1fr;
+  }
+}

src/components/Export/ExportDateRangeDialog.tsx

@@ -0,0 +1,340 @@
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { createPortal } from 'react-dom'
+import { Check, X } from 'lucide-react'
+import {
+  EXPORT_DATE_RANGE_PRESETS,
+  WEEKDAY_SHORT_LABELS,
+  addMonths,
+  buildCalendarCells,
+  cloneExportDateRangeSelection,
+  createDateRangeByPreset,
+  createDefaultDateRange,
+  formatCalendarMonthTitle,
+  formatDateInputValue,
+  isSameDay,
+  parseDateInputValue,
+  startOfDay,
+  endOfDay,
+  toMonthStart,
+  type ExportDateRangePreset,
+  type ExportDateRangeSelection
+} from '../../utils/exportDateRange'
+import './ExportDateRangeDialog.scss'
+
+interface ExportDateRangeDialogProps {
+  open: boolean
+  value: ExportDateRangeSelection
+  title?: string
+  onClose: () => void
+  onConfirm: (value: ExportDateRangeSelection) => void
+}
+
+interface ExportDateRangeDialogDraft extends ExportDateRangeSelection {
+  startPanelMonth: Date
+  endPanelMonth: Date
+}
+
+const buildDialogDraft = (value: ExportDateRangeSelection): ExportDateRangeDialogDraft => ({
+  ...cloneExportDateRangeSelection(value),
+  startPanelMonth: toMonthStart(value.dateRange.start),
+  endPanelMonth: toMonthStart(value.dateRange.end)
+})
+
+export function ExportDateRangeDialog({
+  open,
+  value,
+  title = '时间范围设置',
+  onClose,
+  onConfirm
+}: ExportDateRangeDialogProps) {
+  const [draft, setDraft] = useState<ExportDateRangeDialogDraft>(() => buildDialogDraft(value))
+  const [dateInput, setDateInput] = useState({
+    start: formatDateInputValue(value.dateRange.start),
+    end: formatDateInputValue(value.dateRange.end)
+  })
+  const [dateInputError, setDateInputError] = useState({ start: false, end: false })
+
+  useEffect(() => {
+    if (!open) return
+    const nextDraft = buildDialogDraft(value)
+    setDraft(nextDraft)
+    setDateInput({
+      start: formatDateInputValue(nextDraft.dateRange.start),
+      end: formatDateInputValue(nextDraft.dateRange.end)
+    })
+    setDateInputError({ start: false, end: false })
+  }, [open, value])
+
+  useEffect(() => {
+    if (!open) return
+    setDateInput({
+      start: formatDateInputValue(draft.dateRange.start),
+      end: formatDateInputValue(draft.dateRange.end)
+    })
+    setDateInputError({ start: false, end: false })
+  }, [draft.dateRange.end.getTime(), draft.dateRange.start.getTime(), open])
+
+  const applyPreset = useCallback((preset: Exclude<ExportDateRangePreset, 'custom'>) => {
+    if (preset === 'all') {
+      const previewRange = createDefaultDateRange()
+      setDraft(prev => ({
+        ...prev,
+        preset,
+        useAllTime: true,
+        dateRange: previewRange,
+        startPanelMonth: toMonthStart(previewRange.start),
+        endPanelMonth: toMonthStart(previewRange.end)
+      }))
+      return
+    }
+
+    const range = createDateRangeByPreset(preset)
+    setDraft(prev => ({
+      ...prev,
+      preset,
+      useAllTime: false,
+      dateRange: range,
+      startPanelMonth: toMonthStart(range.start),
+      endPanelMonth: toMonthStart(range.end)
+    }))
+  }, [])
+
+  const updateDraftStart = useCallback((targetDate: Date) => {
+    const start = startOfDay(targetDate)
+    setDraft(prev => {
+      const nextEnd = prev.dateRange.end < start ? endOfDay(start) : prev.dateRange.end
+      return {
+        ...prev,
+        preset: 'custom',
+        useAllTime: false,
+        dateRange: {
+          start,
+          end: nextEnd
+        },
+        startPanelMonth: toMonthStart(start),
+        endPanelMonth: toMonthStart(nextEnd)
+      }
+    })
+  }, [])
+
+  const updateDraftEnd = useCallback((targetDate: Date) => {
+    const end = endOfDay(targetDate)
+    setDraft(prev => {
+      const nextStart = prev.useAllTime ? startOfDay(targetDate) : prev.dateRange.start
+      const nextEnd = end < nextStart ? endOfDay(nextStart) : end
+      return {
+        ...prev,
+        preset: 'custom',
+        useAllTime: false,
+        dateRange: {
+          start: nextStart,
+          end: nextEnd
+        },
+        startPanelMonth: toMonthStart(nextStart),
+        endPanelMonth: toMonthStart(nextEnd)
+      }
+    })
+  }, [])
+
+  const commitStartFromInput = useCallback(() => {
+    const parsed = parseDateInputValue(dateInput.start)
+    if (!parsed) {
+      setDateInputError(prev => ({ ...prev, start: true }))
+      return
+    }
+    setDateInputError(prev => ({ ...prev, start: false }))
+    updateDraftStart(parsed)
+  }, [dateInput.start, updateDraftStart])
+
+  const commitEndFromInput = useCallback(() => {
+    const parsed = parseDateInputValue(dateInput.end)
+    if (!parsed) {
+      setDateInputError(prev => ({ ...prev, end: true }))
+      return
+    }
+    setDateInputError(prev => ({ ...prev, end: false }))
+    updateDraftEnd(parsed)
+  }, [dateInput.end, updateDraftEnd])
+
+  const shiftPanelMonth = useCallback((panel: 'start' | 'end', delta: number) => {
+    setDraft(prev => (
+      panel === 'start'
+        ? { ...prev, startPanelMonth: addMonths(prev.startPanelMonth, delta) }
+        : { ...prev, endPanelMonth: addMonths(prev.endPanelMonth, delta) }
+    ))
+  }, [])
+
+  const isRangeModeActive = !draft.useAllTime
+  const modeText = isRangeModeActive
+    ? '当前导出模式：按时间范围导出'
+    : '当前导出模式：全部时间导出（选择下方日期将切换为按时间范围导出）'
+
+  const isPresetActive = useCallback((preset: ExportDateRangePreset): boolean => {
+    if (preset === 'all') return draft.useAllTime
+    return !draft.useAllTime && draft.preset === preset
+  }, [draft])
+
+  const startPanelCells = useMemo(() => buildCalendarCells(draft.startPanelMonth), [draft.startPanelMonth])
+  const endPanelCells = useMemo(() => buildCalendarCells(draft.endPanelMonth), [draft.endPanelMonth])
+
+  if (!open) return null
+
+  return createPortal(
+    <div className="export-date-range-dialog-overlay" onClick={onClose}>
+      <div className="export-date-range-dialog" role="dialog" aria-modal="true" onClick={(event) => event.stopPropagation()}>
+        <div className="export-date-range-dialog-header">
+          <h4>{title}</h4>
+          <button
+            type="button"
+            className="export-date-range-dialog-close-btn"
+            onClick={onClose}
+            aria-label="关闭时间范围设置"
+          >
+            <X size={14} />
+          </button>
+        </div>
+
+        <div className="export-date-range-preset-list">
+          {EXPORT_DATE_RANGE_PRESETS.map((preset) => {
+            const active = isPresetActive(preset.value)
+            return (
+              <button
+                key={preset.value}
+                type="button"
+                className={`export-date-range-preset-item ${active ? 'active' : ''}`}
+                onClick={() => applyPreset(preset.value)}
+              >
+                <span>{preset.label}</span>
+                {active && <Check size={14} />}
+              </button>
+            )
+          })}
+        </div>
+
+        <div className={`export-date-range-mode-banner ${isRangeModeActive ? 'range' : 'all'}`}>
+          {modeText}
+        </div>
+
+        <div className="export-date-range-calendar-grid">
+          <section className="export-date-range-calendar-panel">
+            <div className="export-date-range-calendar-panel-header">
+              <div className="export-date-range-calendar-date-label">
+                <span>起始日期</span>
+                <input
+                  type="text"
+                  className={`export-date-range-date-input ${dateInputError.start ? 'invalid' : ''}`}
+                  value={dateInput.start}
+                  placeholder="YYYY-MM-DD"
+                  onChange={(event) => {
+                    const nextValue = event.target.value
+                    setDateInput(prev => ({ ...prev, start: nextValue }))
+                    if (dateInputError.start) {
+                      setDateInputError(prev => ({ ...prev, start: false }))
+                    }
+                  }}
+                  onKeyDown={(event) => {
+                    if (event.key !== 'Enter') return
+                    event.preventDefault()
+                    commitStartFromInput()
+                  }}
+                  onBlur={commitStartFromInput}
+                />
+              </div>
+              <div className="export-date-range-calendar-nav">
+                <button type="button" onClick={() => shiftPanelMonth('start', -1)} aria-label="上个月">‹</button>
+                <span>{formatCalendarMonthTitle(draft.startPanelMonth)}</span>
+                <button type="button" onClick={() => shiftPanelMonth('start', 1)} aria-label="下个月">›</button>
+              </div>
+            </div>
+            <div className="export-date-range-calendar-weekdays">
+              {WEEKDAY_SHORT_LABELS.map(label => (
+                <span key={`start-weekday-${label}`}>{label}</span>
+              ))}
+            </div>
+            <div className="export-date-range-calendar-days">
+              {startPanelCells.map((cell) => {
+                const selected = !draft.useAllTime && isSameDay(cell.date, draft.dateRange.start)
+                return (
+                  <button
+                    key={`start-${cell.date.getTime()}`}
+                    type="button"
+                    className={`export-date-range-calendar-day ${cell.inCurrentMonth ? '' : 'outside'} ${selected ? 'selected' : ''}`}
+                    onClick={() => updateDraftStart(cell.date)}
+                  >
+                    {cell.date.getDate()}
+                  </button>
+                )
+              })}
+            </div>
+          </section>
+
+          <section className="export-date-range-calendar-panel">
+            <div className="export-date-range-calendar-panel-header">
+              <div className="export-date-range-calendar-date-label">
+                <span>截止日期</span>
+                <input
+                  type="text"
+                  className={`export-date-range-date-input ${dateInputError.end ? 'invalid' : ''}`}
+                  value={dateInput.end}
+                  placeholder="YYYY-MM-DD"
+                  onChange={(event) => {
+                    const nextValue = event.target.value
+                    setDateInput(prev => ({ ...prev, end: nextValue }))
+                    if (dateInputError.end) {
+                      setDateInputError(prev => ({ ...prev, end: false }))
+                    }
+                  }}
+                  onKeyDown={(event) => {
+                    if (event.key !== 'Enter') return
+                    event.preventDefault()
+                    commitEndFromInput()
+                  }}
+                  onBlur={commitEndFromInput}
+                />
+              </div>
+              <div className="export-date-range-calendar-nav">
+                <button type="button" onClick={() => shiftPanelMonth('end', -1)} aria-label="上个月">‹</button>
+                <span>{formatCalendarMonthTitle(draft.endPanelMonth)}</span>
+                <button type="button" onClick={() => shiftPanelMonth('end', 1)} aria-label="下个月">›</button>
+              </div>
+            </div>
+            <div className="export-date-range-calendar-weekdays">
+              {WEEKDAY_SHORT_LABELS.map(label => (
+                <span key={`end-weekday-${label}`}>{label}</span>
+              ))}
+            </div>
+            <div className="export-date-range-calendar-days">
+              {endPanelCells.map((cell) => {
+                const selected = !draft.useAllTime && isSameDay(cell.date, draft.dateRange.end)
+                return (
+                  <button
+                    key={`end-${cell.date.getTime()}`}
+                    type="button"
+                    className={`export-date-range-calendar-day ${cell.inCurrentMonth ? '' : 'outside'} ${selected ? 'selected' : ''}`}
+                    onClick={() => updateDraftEnd(cell.date)}
+                  >
+                    {cell.date.getDate()}
+                  </button>
+                )
+              })}
+            </div>
+          </section>
+        </div>
+
+        <div className="export-date-range-dialog-actions">
+          <button type="button" className="export-date-range-dialog-btn secondary" onClick={onClose}>
+            取消
+          </button>
+          <button
+            type="button"
+            className="export-date-range-dialog-btn primary"
+            onClick={() => onConfirm(cloneExportDateRangeSelection(draft))}
+          >
+            确认
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body
+  )
+}

src/components/Export/ExportDefaultsSettingsForm.scss

@@ -0,0 +1,459 @@
+.export-defaults-settings-form {
+  .form-group {
+    margin-bottom: 20px;
+
+    &:last-child {
+      margin-bottom: 0;
+    }
+  }
+
+  label {
+    display: block;
+    font-size: 14px;
+    font-weight: 500;
+    color: var(--text-primary);
+    margin-bottom: 2px;
+  }
+
+  .form-hint {
+    display: block;
+    font-size: 12px;
+    color: var(--text-tertiary);
+    margin-bottom: 8px;
+  }
+
+  .select-field {
+    position: relative;
+    margin-bottom: 10px;
+  }
+
+  .select-trigger {
+    width: 100%;
+    padding: 10px 16px;
+    border: 1px solid var(--border-color);
+    border-radius: 9999px;
+    font-size: 14px;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    cursor: pointer;
+    transition: all 0.2s;
+
+    &:hover {
+      border-color: var(--text-tertiary);
+    }
+
+    &.open {
+      border-color: var(--primary);
+      box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary) 15%, transparent);
+    }
+  }
+
+  .select-value {
+    flex: 1;
+    min-width: 0;
+    text-align: left;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .select-dropdown {
+    position: absolute;
+    top: calc(100% + 6px);
+    left: 0;
+    right: 0;
+    background: color-mix(in srgb, var(--bg-primary) 85%, var(--bg-secondary));
+    border: 1px solid var(--border-color);
+    border-radius: 12px;
+    padding: 6px;
+    box-shadow: var(--shadow-md);
+    z-index: 120;
+    max-height: 320px;
+    overflow-y: auto;
+    backdrop-filter: blur(14px);
+    -webkit-backdrop-filter: blur(14px);
+  }
+
+  .select-option {
+    width: 100%;
+    text-align: left;
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    padding: 10px 12px;
+    border: none;
+    border-radius: 10px;
+    background: transparent;
+    cursor: pointer;
+    transition: all 0.15s;
+    color: var(--text-primary);
+    font-size: 14px;
+
+    &:hover {
+      background: var(--bg-tertiary);
+    }
+
+    &.active {
+      background: color-mix(in srgb, var(--primary) 12%, transparent);
+      color: var(--primary);
+    }
+  }
+
+  .option-label {
+    font-weight: 500;
+  }
+
+  .option-desc {
+    font-size: 12px;
+    color: var(--text-tertiary);
+  }
+
+  .format-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(156px, 1fr));
+    gap: 6px;
+    width: 100%;
+    margin-bottom: 10px;
+  }
+
+  .format-card {
+    width: 100%;
+    min-height: 0;
+    border: 1px solid var(--border-color);
+    border-radius: 10px;
+    padding: 8px 10px;
+    text-align: left;
+    background: var(--bg-primary);
+    cursor: pointer;
+    display: flex;
+    flex-direction: column;
+    align-items: flex-start;
+    justify-content: flex-start;
+    transition: border-color 0.2s ease, background 0.2s ease;
+
+    &:hover {
+      border-color: var(--text-tertiary);
+    }
+
+    &.active {
+      border-color: var(--primary);
+      background: rgba(var(--primary-rgb), 0.08);
+    }
+  }
+
+  .format-label {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-primary);
+    line-height: 1.35;
+  }
+
+  .format-desc {
+    margin-top: 1px;
+    font-size: 11px;
+    color: var(--text-tertiary);
+    line-height: 1.35;
+  }
+
+  .select-option.active .option-desc {
+    color: var(--primary);
+  }
+
+  .settings-time-range-field {
+    margin-bottom: 10px;
+  }
+
+  .settings-time-range-trigger {
+    width: 100%;
+    padding: 10px 16px;
+    border: 1px solid var(--border-color);
+    border-radius: 9999px;
+    font-size: 14px;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    cursor: pointer;
+    transition: all 0.2s;
+
+    &:hover {
+      border-color: rgba(var(--primary-rgb), 0.45);
+      color: var(--primary);
+    }
+
+    &.open {
+      border-color: var(--primary);
+      box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary) 15%, transparent);
+    }
+  }
+
+  .settings-time-range-value {
+    flex: 1;
+    min-width: 0;
+    text-align: left;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .settings-time-range-arrow {
+    color: var(--text-tertiary);
+    font-weight: 700;
+    line-height: 1;
+  }
+
+  .log-toggle-line {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+    margin-bottom: 10px;
+    padding: 10px 14px;
+    border: 1px solid var(--border-color);
+    border-radius: 14px;
+    background: var(--bg-primary);
+  }
+
+  .media-default-grid {
+    width: 100%;
+    display: flex;
+    align-items: center;
+    flex-wrap: nowrap;
+    gap: 12px;
+    margin-bottom: 10px;
+
+    label {
+      display: inline-flex;
+      align-items: center;
+      gap: 5px;
+      margin-bottom: 0;
+      font-size: 13px;
+      line-height: 1;
+      font-weight: 500;
+      color: var(--text-primary);
+      cursor: pointer;
+      white-space: nowrap;
+    }
+
+    input[type='checkbox'] {
+      margin: 0;
+      accent-color: var(--primary);
+    }
+  }
+
+  .log-status {
+    font-size: 13px;
+    color: var(--text-secondary);
+  }
+
+  .concurrency-inline-options {
+    width: 100%;
+    display: grid;
+    grid-template-columns: repeat(6, minmax(0, 1fr));
+    gap: 6px;
+    margin-bottom: 10px;
+  }
+
+  .concurrency-option {
+    border: 1px solid var(--border-color);
+    border-radius: 10px;
+    min-height: 38px;
+    padding: 0;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    font-size: 14px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: border-color 0.2s ease, background 0.2s ease, color 0.2s ease;
+
+    &:hover {
+      border-color: var(--text-tertiary);
+    }
+
+    &.active {
+      border-color: var(--primary);
+      background: rgba(var(--primary-rgb), 0.08);
+      color: var(--primary);
+    }
+  }
+
+  .switch {
+    position: relative;
+    display: inline-flex;
+    width: 48px;
+    height: 28px;
+    cursor: pointer;
+    flex-shrink: 0;
+  }
+
+  .switch-input {
+    opacity: 0;
+    width: 0;
+    height: 0;
+    position: absolute;
+
+    &:checked + .switch-slider {
+      background: var(--primary);
+    }
+
+    &:checked + .switch-slider::before {
+      transform: translateX(20px);
+    }
+
+    &:focus + .switch-slider {
+      box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary) 18%, transparent);
+    }
+  }
+
+  .switch-slider {
+    position: absolute;
+    inset: 0;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border-color);
+    border-radius: 999px;
+    transition: all 0.2s ease;
+
+    &::before {
+      content: '';
+      position: absolute;
+      width: 20px;
+      height: 20px;
+      left: 3px;
+      top: 3px;
+      border-radius: 50%;
+      background: #fff;
+      box-shadow: 0 1px 3px rgba(0, 0, 0, 0.18);
+      transition: transform 0.2s ease;
+    }
+  }
+
+  &.layout-split {
+    .form-group {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) minmax(280px, 360px);
+      gap: 18px;
+      align-items: center;
+      padding: 14px 0;
+      margin-bottom: 0;
+      border-bottom: 1px solid color-mix(in srgb, var(--border-color) 70%, transparent);
+    }
+
+    .form-group:last-child {
+      border-bottom: none;
+      padding-bottom: 0;
+    }
+
+    .form-group:first-child {
+      padding-top: 0;
+    }
+
+    .form-copy {
+      min-width: 0;
+    }
+
+    .form-control {
+      min-width: 0;
+      display: flex;
+      justify-content: flex-end;
+    }
+
+    .form-hint {
+      margin-bottom: 0;
+      line-height: 1.5;
+    }
+
+    .select-field,
+    .settings-time-range-field {
+      width: 100%;
+      max-width: 360px;
+      margin-bottom: 0;
+    }
+
+    .log-toggle-line {
+      width: 100%;
+      max-width: 360px;
+      margin-bottom: 0;
+    }
+
+    .media-default-grid {
+      max-width: 360px;
+      margin-bottom: 0;
+    }
+
+    .concurrency-inline-options {
+      max-width: 360px;
+      margin-bottom: 0;
+    }
+
+    .format-setting-group {
+      grid-template-columns: 1fr;
+      gap: 10px;
+      align-items: stretch;
+    }
+
+    .format-setting-group .form-control {
+      justify-content: flex-start;
+    }
+
+    .format-grid {
+      max-width: none;
+      grid-template-columns: repeat(3, minmax(0, 1fr));
+      margin-bottom: 0;
+    }
+  }
+}
+
+@media (max-width: 1024px) {
+  .export-defaults-settings-form.layout-split {
+    .media-setting-group {
+      grid-template-columns: 1fr;
+      gap: 10px;
+      align-items: stretch;
+    }
+
+    .media-setting-group .form-control {
+      justify-content: flex-start;
+    }
+
+    .media-default-grid {
+      max-width: none;
+      flex-wrap: wrap;
+    }
+  }
+}
+
+@media (max-width: 760px) {
+  .export-defaults-settings-form.layout-split {
+    .form-group {
+      grid-template-columns: 1fr;
+      gap: 10px;
+    }
+
+    .form-control {
+      justify-content: flex-start;
+    }
+
+    .select-field,
+    .settings-time-range-field,
+    .log-toggle-line,
+    .media-default-grid,
+    .concurrency-inline-options,
+    .format-grid {
+      max-width: none;
+    }
+
+    .media-default-grid {
+      flex-wrap: wrap;
+    }
+
+    .format-grid {
+      grid-template-columns: repeat(auto-fit, minmax(156px, 1fr));
+    }
+  }
+}

src/components/Export/ExportDefaultsSettingsForm.tsx

@@ -0,0 +1,389 @@
+import { useEffect, useMemo, useRef, useState } from 'react'
+import { ChevronDown } from 'lucide-react'
+import * as configService from '../../services/config'
+import { ExportDateRangeDialog } from './ExportDateRangeDialog'
+import {
+  createDefaultExportDateRangeSelection,
+  getExportDateRangeLabel,
+  resolveExportDateRangeConfig,
+  serializeExportDateRangeConfig,
+  type ExportDateRangeSelection
+} from '../../utils/exportDateRange'
+import './ExportDefaultsSettingsForm.scss'
+
+export interface ExportDefaultsSettingsPatch {
+  format?: string
+  avatars?: boolean
+  dateRange?: ExportDateRangeSelection
+  media?: configService.ExportDefaultMediaConfig
+  voiceAsText?: boolean
+  excelCompactColumns?: boolean
+  concurrency?: number
+}
+
+interface ExportDefaultsSettingsFormProps {
+  onNotify?: (text: string, success: boolean) => void
+  onDefaultsChanged?: (patch: ExportDefaultsSettingsPatch) => void
+  layout?: 'stacked' | 'split'
+}
+
+const exportFormatOptions = [
+  { value: 'excel', label: 'Excel', desc: '电子表格，适合统计分析' },
+  { value: 'json', label: 'JSON', desc: '详细格式，包含完整消息信息' },
+  { value: 'html', label: 'HTML', desc: '网页格式，可直接浏览' },
+  { value: 'txt', label: 'TXT', desc: '纯文本，通用格式' },
+  { value: 'arkme-json', label: 'Arkme JSON', desc: '紧凑 JSON，支持 sender 去重与关系统计' },
+  { value: 'chatlab', label: 'ChatLab', desc: '标准格式，支持其他软件导入' },
+  { value: 'chatlab-jsonl', label: 'ChatLab JSONL', desc: '流式格式，适合大量消息' },
+  { value: 'weclone', label: 'WeClone CSV', desc: 'WeClone 兼容字段格式（CSV）' },
+  { value: 'sql', label: 'PostgreSQL', desc: '数据库脚本，便于导入到数据库' }
+] as const
+
+const exportExcelColumnOptions = [
+  { value: 'compact', label: '精简列', desc: '序号、时间、发送者身份、消息类型、内容' },
+  { value: 'full', label: '完整列', desc: '含发送者昵称/微信ID/备注' }
+] as const
+
+const exportConcurrencyOptions = [1, 2, 3, 4, 5, 6] as const
+
+const getOptionLabel = (options: ReadonlyArray<{ value: string; label: string }>, value: string) => {
+  return options.find((option) => option.value === value)?.label ?? value
+}
+
+export function ExportDefaultsSettingsForm({
+  onNotify,
+  onDefaultsChanged,
+  layout = 'stacked'
+}: ExportDefaultsSettingsFormProps) {
+  const [showExportExcelColumnsSelect, setShowExportExcelColumnsSelect] = useState(false)
+  const [isExportDateRangeDialogOpen, setIsExportDateRangeDialogOpen] = useState(false)
+  const exportExcelColumnsDropdownRef = useRef<HTMLDivElement>(null)
+
+  const [exportDefaultFormat, setExportDefaultFormat] = useState('excel')
+  const [exportDefaultAvatars, setExportDefaultAvatars] = useState(true)
+  const [exportDefaultDateRange, setExportDefaultDateRange] = useState<ExportDateRangeSelection>(() => createDefaultExportDateRangeSelection())
+  const [exportDefaultMedia, setExportDefaultMedia] = useState<configService.ExportDefaultMediaConfig>({
+    images: true,
+    videos: true,
+    voices: true,
+    emojis: true
+  })
+  const [exportDefaultVoiceAsText, setExportDefaultVoiceAsText] = useState(false)
+  const [exportDefaultExcelCompactColumns, setExportDefaultExcelCompactColumns] = useState(true)
+  const [exportDefaultConcurrency, setExportDefaultConcurrency] = useState(2)
+
+  useEffect(() => {
+    let cancelled = false
+    void (async () => {
+      const [savedFormat, savedAvatars, savedDateRange, savedMedia, savedVoiceAsText, savedExcelCompactColumns, savedConcurrency] = await Promise.all([
+        configService.getExportDefaultFormat(),
+        configService.getExportDefaultAvatars(),
+        configService.getExportDefaultDateRange(),
+        configService.getExportDefaultMedia(),
+        configService.getExportDefaultVoiceAsText(),
+        configService.getExportDefaultExcelCompactColumns(),
+        configService.getExportDefaultConcurrency()
+      ])
+
+      if (cancelled) return
+
+      setExportDefaultFormat(savedFormat || 'excel')
+      setExportDefaultAvatars(savedAvatars ?? true)
+      setExportDefaultDateRange(resolveExportDateRangeConfig(savedDateRange))
+      setExportDefaultMedia(savedMedia ?? {
+        images: true,
+        videos: true,
+        voices: true,
+        emojis: true
+      })
+      setExportDefaultVoiceAsText(savedVoiceAsText ?? false)
+      setExportDefaultExcelCompactColumns(savedExcelCompactColumns ?? true)
+      setExportDefaultConcurrency(savedConcurrency ?? 2)
+    })()
+
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
+  useEffect(() => {
+    const handleClickOutside = (e: MouseEvent) => {
+      const target = e.target as Node
+      if (showExportExcelColumnsSelect && exportExcelColumnsDropdownRef.current && !exportExcelColumnsDropdownRef.current.contains(target)) {
+        setShowExportExcelColumnsSelect(false)
+      }
+    }
+
+    document.addEventListener('mousedown', handleClickOutside)
+    return () => document.removeEventListener('mousedown', handleClickOutside)
+  }, [showExportExcelColumnsSelect])
+
+  const exportExcelColumnsValue = exportDefaultExcelCompactColumns ? 'compact' : 'full'
+  const exportDateRangeLabel = useMemo(() => getExportDateRangeLabel(exportDefaultDateRange), [exportDefaultDateRange])
+  const exportExcelColumnsLabel = useMemo(() => getOptionLabel(exportExcelColumnOptions, exportExcelColumnsValue), [exportExcelColumnsValue])
+
+  const notify = (text: string, success = true) => {
+    onNotify?.(text, success)
+  }
+
+  return (
+    <div className={`export-defaults-settings-form ${layout === 'split' ? 'layout-split' : 'layout-stacked'}`}>
+      <div className="form-group">
+        <div className="form-copy">
+          <label>导出并发数</label>
+          <span className="form-hint">导出多个会话时的最大并发（1~6）</span>
+        </div>
+        <div className="form-control">
+          <div className="concurrency-inline-options" role="radiogroup" aria-label="导出并发数">
+            {exportConcurrencyOptions.map((option) => (
+              <button
+                key={option}
+                type="button"
+                className={`concurrency-option ${exportDefaultConcurrency === option ? 'active' : ''}`}
+                aria-pressed={exportDefaultConcurrency === option}
+                onClick={async () => {
+                  setExportDefaultConcurrency(option)
+                  await configService.setExportDefaultConcurrency(option)
+                  onDefaultsChanged?.({ concurrency: option })
+                  notify(`已将导出并发数设为 ${option}`, true)
+                }}
+              >
+                {option}
+              </button>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      <div className="form-group format-setting-group">
+        <div className="form-copy">
+          <label>聊天消息默认导出格式</label>
+          <span className="form-hint">导出页面默认选中的格式</span>
+        </div>
+        <div className="form-control">
+          <div className="format-grid">
+            {exportFormatOptions.map((option) => (
+              <button
+                key={option.value}
+                type="button"
+                className={`format-card ${exportDefaultFormat === option.value ? 'active' : ''}`}
+                onClick={async () => {
+                  setExportDefaultFormat(option.value)
+                  await configService.setExportDefaultFormat(option.value)
+                  onDefaultsChanged?.({ format: option.value })
+                  notify('已更新导出格式默认值', true)
+                }}
+              >
+                <span className="format-label">{option.label}</span>
+                <span className="format-desc">{option.desc}</span>
+              </button>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      <div className="form-group">
+        <div className="form-copy">
+          <label>聊天消息导出带头像</label>
+          <span className="form-hint">开启后导出的聊天消息对应的文件中会带头像信息。</span>
+        </div>
+        <div className="form-control">
+          <div className="log-toggle-line">
+            <span className="log-status">{exportDefaultAvatars ? '已开启' : '已关闭'}</span>
+            <label className="switch" htmlFor="shared-export-default-avatars">
+              <input
+                id="shared-export-default-avatars"
+                className="switch-input"
+                type="checkbox"
+                checked={exportDefaultAvatars}
+                onChange={async (e) => {
+                  const enabled = e.target.checked
+                  setExportDefaultAvatars(enabled)
+                  await configService.setExportDefaultAvatars(enabled)
+                  onDefaultsChanged?.({ avatars: enabled })
+                  notify(enabled ? '已开启聊天消息导出带头像' : '已关闭聊天消息导出带头像', true)
+                }}
+              />
+              <span className="switch-slider" />
+            </label>
+          </div>
+        </div>
+      </div>
+
+      <div className="form-group">
+        <div className="form-copy">
+          <label>默认导出时间范围</label>
+          <span className="form-hint">控制导出页面的默认时间选择</span>
+        </div>
+        <div className="form-control">
+          <div className="settings-time-range-field">
+            <button
+              type="button"
+              className={`settings-time-range-trigger ${isExportDateRangeDialogOpen ? 'open' : ''}`}
+              onClick={() => {
+                setShowExportExcelColumnsSelect(false)
+                setIsExportDateRangeDialogOpen(true)
+              }}
+            >
+              <span className="settings-time-range-value">{exportDateRangeLabel}</span>
+              <span className="settings-time-range-arrow">&gt;</span>
+            </button>
+          </div>
+        </div>
+      </div>
+
+      <ExportDateRangeDialog
+        open={isExportDateRangeDialogOpen}
+        value={exportDefaultDateRange}
+        onClose={() => setIsExportDateRangeDialogOpen(false)}
+        onConfirm={async (nextSelection) => {
+          setExportDefaultDateRange(nextSelection)
+          await configService.setExportDefaultDateRange(serializeExportDateRangeConfig(nextSelection))
+          onDefaultsChanged?.({ dateRange: nextSelection })
+          notify('已更新默认导出时间范围', true)
+          setIsExportDateRangeDialogOpen(false)
+        }}
+      />
+
+      <div className="form-group">
+        <div className="form-copy">
+          <label>Excel 列显示</label>
+          <span className="form-hint">控制 Excel 导出的列字段</span>
+        </div>
+        <div className="form-control">
+          <div className="select-field" ref={exportExcelColumnsDropdownRef}>
+            <button
+              type="button"
+              className={`select-trigger ${showExportExcelColumnsSelect ? 'open' : ''}`}
+              onClick={() => {
+                setShowExportExcelColumnsSelect(!showExportExcelColumnsSelect)
+                setIsExportDateRangeDialogOpen(false)
+              }}
+            >
+              <span className="select-value">{exportExcelColumnsLabel}</span>
+              <ChevronDown size={16} />
+            </button>
+            {showExportExcelColumnsSelect && (
+              <div className="select-dropdown">
+                {exportExcelColumnOptions.map((option) => (
+                  <button
+                    key={option.value}
+                    type="button"
+                    className={`select-option ${exportExcelColumnsValue === option.value ? 'active' : ''}`}
+                    onClick={async () => {
+                      const compact = option.value === 'compact'
+                      setExportDefaultExcelCompactColumns(compact)
+                      await configService.setExportDefaultExcelCompactColumns(compact)
+                      onDefaultsChanged?.({ excelCompactColumns: compact })
+                      notify(compact ? '已启用精简列' : '已启用完整列', true)
+                      setShowExportExcelColumnsSelect(false)
+                    }}
+                  >
+                    <span className="option-label">{option.label}</span>
+                    <span className="option-desc">{option.desc}</span>
+                  </button>
+                ))}
+              </div>
+            )}
+          </div>
+        </div>
+      </div>
+
+      <div className="form-group media-setting-group">
+        <div className="form-copy">
+          <label>默认导出媒体内容</label>
+          <span className="form-hint">控制图片、视频、语音、表情包的默认导出开关</span>
+        </div>
+        <div className="form-control">
+          <div className="media-default-grid">
+            <label>
+              <input
+                type="checkbox"
+                checked={exportDefaultMedia.images}
+                onChange={async (e) => {
+                  const next = { ...exportDefaultMedia, images: e.target.checked }
+                  setExportDefaultMedia(next)
+                  await configService.setExportDefaultMedia(next)
+                  onDefaultsChanged?.({ media: next })
+                  notify(`已${e.target.checked ? '开启' : '关闭'}默认导出图片`, true)
+                }}
+              />
+              图片
+            </label>
+            <label>
+              <input
+                type="checkbox"
+                checked={exportDefaultMedia.voices}
+                onChange={async (e) => {
+                  const next = { ...exportDefaultMedia, voices: e.target.checked }
+                  setExportDefaultMedia(next)
+                  await configService.setExportDefaultMedia(next)
+                  onDefaultsChanged?.({ media: next })
+                  notify(`已${e.target.checked ? '开启' : '关闭'}默认导出语音`, true)
+                }}
+              />
+              语音
+            </label>
+            <label>
+              <input
+                type="checkbox"
+                checked={exportDefaultMedia.videos}
+                onChange={async (e) => {
+                  const next = { ...exportDefaultMedia, videos: e.target.checked }
+                  setExportDefaultMedia(next)
+                  await configService.setExportDefaultMedia(next)
+                  onDefaultsChanged?.({ media: next })
+                  notify(`已${e.target.checked ? '开启' : '关闭'}默认导出视频`, true)
+                }}
+              />
+              视频
+            </label>
+            <label>
+              <input
+                type="checkbox"
+                checked={exportDefaultMedia.emojis}
+                onChange={async (e) => {
+                  const next = { ...exportDefaultMedia, emojis: e.target.checked }
+                  setExportDefaultMedia(next)
+                  await configService.setExportDefaultMedia(next)
+                  onDefaultsChanged?.({ media: next })
+                  notify(`已${e.target.checked ? '开启' : '关闭'}默认导出表情包`, true)
+                }}
+              />
+              表情包
+            </label>
+          </div>
+        </div>
+      </div>
+
+      <div className="form-group">
+        <div className="form-copy">
+          <label>默认语音转文字</label>
+          <span className="form-hint">导出时默认将语音转写为文字</span>
+        </div>
+        <div className="form-control">
+          <div className="log-toggle-line">
+            <span className="log-status">{exportDefaultVoiceAsText ? '已开启' : '已关闭'}</span>
+            <label className="switch" htmlFor="shared-export-default-voice-as-text">
+              <input
+                id="shared-export-default-voice-as-text"
+                className="switch-input"
+                type="checkbox"
+                checked={exportDefaultVoiceAsText}
+                onChange={async (e) => {
+                  const enabled = e.target.checked
+                  setExportDefaultVoiceAsText(enabled)
+                  await configService.setExportDefaultVoiceAsText(enabled)
+                  onDefaultsChanged?.({ voiceAsText: enabled })
+                  notify(enabled ? '已开启默认语音转文字' : '已关闭默认语音转文字', true)
+                }}
+              />
+              <span className="switch-slider" />
+            </label>
+          </div>
+        </div>
+      </div>
+
+    </div>
+  )
+}

src/components/GlobalSessionMonitor.tsx

@@ -97,6 +97,10 @@ export function GlobalSessionMonitor() {
             if (!isCurrentSession && (!oldSession || newSession.lastTimestamp > oldSession.lastTimestamp)) {
                 // 这是新消息事件
 
+                // 免打扰、折叠群、折叠入口不弹通知
+                if (newSession.isMuted || newSession.isFolded) continue
+                if (newSession.username.toLowerCase().includes('placeholder_foldgroup')) continue
+
                 // 1. 群聊过滤自己发送的消息
                 if (newSession.username.includes('@chatroom')) {
                     // 如果是自己发的消息，不弹通知
@@ -194,11 +198,12 @@ export function GlobalSessionMonitor() {
                         // 尝试丰富或获取联系人详情
                         const contact = await window.electronAPI.chat.getContact(newSession.username)
                         if (contact) {
-                            if (contact.remark || contact.nickname) {
-                                title = contact.remark || contact.nickname
+                            if (contact.remark || contact.nickName) {
+                                title = contact.remark || contact.nickName
                             }
-                            if (contact.avatarUrl) {
-                                avatarUrl = contact.avatarUrl
+                            const avatarResult = await window.electronAPI.chat.getContactAvatar(newSession.username)
+                            if (avatarResult?.avatarUrl) {
+                                avatarUrl = avatarResult.avatarUrl
                             }
                         } else {
                             // 如果不在缓存/数据库中
@@ -218,8 +223,11 @@ export function GlobalSessionMonitor() {
                             if (title === newSession.username || title.startsWith('wxid_')) {
                                 const retried = await window.electronAPI.chat.getContact(newSession.username)
                                 if (retried) {
-                                    title = retried.remark || retried.nickname || title
-                                    avatarUrl = retried.avatarUrl || avatarUrl
+                                    title = retried.remark || retried.nickName || title
+                                    const retriedAvatar = await window.electronAPI.chat.getContactAvatar(newSession.username)
+                                    if (retriedAvatar?.avatarUrl) {
+                                        avatarUrl = retriedAvatar.avatarUrl
+                                    }
                                 }
                             }
                         }
@@ -253,7 +261,8 @@ export function GlobalSessionMonitor() {
     const handleActiveSessionRefresh = async (sessionId: string) => {
         // 从 ChatPage 复制/调整的逻辑，以保持集中
         const state = useChatStore.getState()
-        const lastMsg = state.messages[state.messages.length - 1]
+        const msgs = state.messages || []
+        const lastMsg = msgs[msgs.length - 1]
         const minTime = lastMsg?.createTime || 0
 
         try {

src/components/JumpToDatePopover.scss

@@ -0,0 +1,166 @@
+.jump-date-popover {
+  position: absolute;
+  top: calc(100% + 10px);
+  right: 0;
+  width: 312px;
+  border-radius: 14px;
+  border: 1px solid var(--border-color);
+  background: none;
+  background-color: var(--bg-secondary-solid, #ffffff) !important;
+  opacity: 1;
+  backdrop-filter: none !important;
+  -webkit-backdrop-filter: none !important;
+  mix-blend-mode: normal;
+  isolation: isolate;
+  box-shadow: 0 16px 40px rgba(0, 0, 0, 0.2);
+  padding: 12px;
+  z-index: 1600;
+}
+
+.jump-date-popover .calendar-nav {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 10px;
+}
+
+.jump-date-popover .current-month {
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.jump-date-popover .nav-btn {
+  width: 28px;
+  height: 28px;
+  border: 1px solid var(--border-color);
+  border-radius: 8px;
+  background: none;
+  background-color: var(--bg-secondary-solid, #ffffff) !important;
+  color: var(--text-secondary);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  transition: all 0.18s ease;
+}
+
+.jump-date-popover .nav-btn:hover {
+  border-color: var(--primary);
+  color: var(--primary);
+  background: var(--bg-hover);
+}
+
+.jump-date-popover .status-line {
+  min-height: 16px;
+  margin-bottom: 6px;
+}
+
+.jump-date-popover .status-item {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  color: var(--text-tertiary);
+  font-size: 11px;
+}
+
+.jump-date-popover .calendar-grid .weekdays {
+  display: grid;
+  grid-template-columns: repeat(7, 1fr);
+  margin-bottom: 6px;
+}
+
+.jump-date-popover .calendar-grid .weekday {
+  text-align: center;
+  font-size: 11px;
+  color: var(--text-tertiary);
+}
+
+.jump-date-popover .calendar-grid .days {
+  display: grid;
+  grid-template-columns: repeat(7, 1fr);
+  grid-template-rows: repeat(6, 36px);
+  gap: 4px;
+}
+
+.jump-date-popover .day-cell {
+  position: relative;
+  border: 1px solid transparent;
+  border-radius: 8px;
+  background: transparent;
+  color: var(--text-primary);
+  cursor: pointer;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 1px;
+  padding: 0;
+  font-size: 13px;
+  transition: all 0.18s ease;
+}
+
+.jump-date-popover .day-cell .day-number {
+  position: relative;
+  z-index: 1;
+  font-size: 12px;
+  line-height: 1;
+  font-weight: 500;
+}
+
+.jump-date-popover .day-cell.empty {
+  cursor: default;
+  background: transparent;
+}
+
+.jump-date-popover .day-cell:not(.empty):not(.no-message):hover {
+  background: var(--bg-hover);
+}
+
+.jump-date-popover .day-cell.today {
+  border-color: var(--primary-light);
+  color: var(--primary);
+}
+
+.jump-date-popover .day-cell.selected {
+  background: var(--primary);
+  color: #fff;
+}
+
+.jump-date-popover .day-cell.no-message {
+  opacity: 0.5;
+  cursor: default;
+}
+
+.jump-date-popover .day-count {
+  position: static;
+  margin-top: 1px;
+  font-size: 13px;
+  line-height: 1;
+  color: #16a34a;
+  font-weight: 700;
+}
+
+.jump-date-popover .day-cell.selected .day-count {
+  color: #86efac;
+}
+
+.jump-date-popover .day-count-loading {
+  position: static;
+  margin-top: 1px;
+  color: #22c55e;
+}
+
+.jump-date-popover .spin {
+  animation: jump-date-spin 1s linear infinite;
+}
+
+@keyframes jump-date-spin {
+  from {
+    transform: rotate(0deg);
+  }
+
+  to {
+    transform: rotate(360deg);
+  }
+}

src/components/JumpToDatePopover.tsx

@@ -0,0 +1,191 @@
+import React, { useEffect, useState } from 'react'
+import { ChevronLeft, ChevronRight, Loader2 } from 'lucide-react'
+import './JumpToDatePopover.scss'
+
+interface JumpToDatePopoverProps {
+  isOpen: boolean
+  onClose: () => void
+  onSelect: (date: Date) => void
+  onMonthChange?: (date: Date) => void
+  className?: string
+  style?: React.CSSProperties
+  currentDate?: Date
+  messageDates?: Set<string>
+  hasLoadedMessageDates?: boolean
+  messageDateCounts?: Record<string, number>
+  loadingDates?: boolean
+  loadingDateCounts?: boolean
+}
+
+const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({
+  isOpen,
+  onClose,
+  onSelect,
+  onMonthChange,
+  className,
+  style,
+  currentDate = new Date(),
+  messageDates,
+  hasLoadedMessageDates = false,
+  messageDateCounts,
+  loadingDates = false,
+  loadingDateCounts = false
+}) => {
+  const [calendarDate, setCalendarDate] = useState<Date>(new Date(currentDate))
+  const [selectedDate, setSelectedDate] = useState<Date>(new Date(currentDate))
+
+  useEffect(() => {
+    if (!isOpen) return
+    const normalized = new Date(currentDate)
+    setCalendarDate(normalized)
+    setSelectedDate(normalized)
+  }, [isOpen, currentDate])
+
+  if (!isOpen) return null
+
+  const getDaysInMonth = (date: Date): number => {
+    const year = date.getFullYear()
+    const month = date.getMonth()
+    return new Date(year, month + 1, 0).getDate()
+  }
+
+  const getFirstDayOfMonth = (date: Date): number => {
+    const year = date.getFullYear()
+    const month = date.getMonth()
+    return new Date(year, month, 1).getDay()
+  }
+
+  const toDateKey = (day: number): string => {
+    const year = calendarDate.getFullYear()
+    const month = calendarDate.getMonth() + 1
+    return `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`
+  }
+
+  const hasMessage = (day: number): boolean => {
+    if (!hasLoadedMessageDates) return true
+    if (!messageDates || messageDates.size === 0) return false
+    return messageDates.has(toDateKey(day))
+  }
+
+  const isToday = (day: number): boolean => {
+    const today = new Date()
+    return day === today.getDate()
+      && calendarDate.getMonth() === today.getMonth()
+      && calendarDate.getFullYear() === today.getFullYear()
+  }
+
+  const isSelected = (day: number): boolean => {
+    return day === selectedDate.getDate()
+      && calendarDate.getMonth() === selectedDate.getMonth()
+      && calendarDate.getFullYear() === selectedDate.getFullYear()
+  }
+
+  const generateCalendar = (): Array<number | null> => {
+    const daysInMonth = getDaysInMonth(calendarDate)
+    const firstDay = getFirstDayOfMonth(calendarDate)
+    const days: Array<number | null> = []
+
+    for (let i = 0; i < firstDay; i++) {
+      days.push(null)
+    }
+    for (let i = 1; i <= daysInMonth; i++) {
+      days.push(i)
+    }
+    return days
+  }
+
+  const handleDateClick = (day: number) => {
+    if (hasLoadedMessageDates && !hasMessage(day)) return
+    const targetDate = new Date(calendarDate.getFullYear(), calendarDate.getMonth(), day)
+    setSelectedDate(targetDate)
+    onSelect(targetDate)
+    onClose()
+  }
+
+  const getDayClassName = (day: number | null): string => {
+    if (day === null) return 'day-cell empty'
+    const classes = ['day-cell']
+    if (isToday(day)) classes.push('today')
+    if (isSelected(day)) classes.push('selected')
+    if (hasLoadedMessageDates && !hasMessage(day)) classes.push('no-message')
+    return classes.join(' ')
+  }
+
+  const weekdays = ['日', '一', '二', '三', '四', '五', '六']
+  const days = generateCalendar()
+  const mergedClassName = ['jump-date-popover', className || ''].join(' ').trim()
+  const updateCalendarDate = (nextDate: Date) => {
+    setCalendarDate(nextDate)
+    onMonthChange?.(nextDate)
+  }
+
+  return (
+    <div className={mergedClassName} style={style} role="dialog" aria-label="跳转日期">
+      <div className="calendar-nav">
+        <button
+          className="nav-btn"
+          onClick={() => updateCalendarDate(new Date(calendarDate.getFullYear(), calendarDate.getMonth() - 1, 1))}
+          aria-label="上一月"
+        >
+          <ChevronLeft size={16} />
+        </button>
+        <span className="current-month">{calendarDate.getFullYear()}年{calendarDate.getMonth() + 1}月</span>
+        <button
+          className="nav-btn"
+          onClick={() => updateCalendarDate(new Date(calendarDate.getFullYear(), calendarDate.getMonth() + 1, 1))}
+          aria-label="下一月"
+        >
+          <ChevronRight size={16} />
+        </button>
+      </div>
+
+      <div className="status-line">
+        {loadingDates && (
+          <span className="status-item">
+            <Loader2 size={12} className="spin" />
+            <span>日期加载中</span>
+          </span>
+        )}
+        {!loadingDates && loadingDateCounts && (
+          <span className="status-item">
+            <Loader2 size={12} className="spin" />
+            <span>条数加载中</span>
+          </span>
+        )}
+      </div>
+
+      <div className="calendar-grid">
+        <div className="weekdays">
+          {weekdays.map(day => (
+            <div key={day} className="weekday">{day}</div>
+          ))}
+        </div>
+        <div className="days">
+          {days.map((day, index) => {
+            if (day === null) return <div key={index} className="day-cell empty" />
+            const dateKey = toDateKey(day)
+            const hasMessageOnDay = hasMessage(day)
+            const count = Number(messageDateCounts?.[dateKey] || 0)
+            const showCount = count > 0
+            const showCountLoading = hasMessageOnDay && loadingDateCounts && !showCount
+            return (
+              <button
+                key={index}
+                className={getDayClassName(day)}
+                onClick={() => handleDateClick(day)}
+                disabled={hasLoadedMessageDates && !hasMessageOnDay}
+                type="button"
+              >
+                <span className="day-number">{day}</span>
+                {showCount && <span className="day-count">{count}</span>}
+                {showCountLoading && <Loader2 size={11} className="day-count-loading spin" />}
+              </button>
+            )
+          })}
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default JumpToDatePopover

src/components/NotificationToast.scss

@@ -7,10 +7,12 @@
     -webkit-backdrop-filter: blur(20px);
     border: 1px solid var(--border-light);
 
-    // 浅色模式下使用不透明背景，避免透明窗口中通知过于透明
+    // 浅色模式下使用完全不透明背景，并禁用毛玻璃效果
     [data-mode="light"] &,
     :not([data-mode]) & {
         background: rgba(255, 255, 255, 1);
+        backdrop-filter: none;
+        -webkit-backdrop-filter: none;
     }
 
     border-radius: 12px;
@@ -46,12 +48,26 @@
         backdrop-filter: none !important;
         -webkit-backdrop-filter: none !important;
 
-        // 确保背景不透明
-        background: var(--bg-secondary, #2c2c2c);
-        color: var(--text-primary, #ffffff);
+        // 独立通知窗口：默认使用浅色模式硬编码值，确保不依赖 <html> 上的主题属性
+        background: #ffffff;
+        color: #3d3d3d;
+        --text-primary: #3d3d3d;
+        --text-secondary: #666666;
+        --text-tertiary: #999999;
+        --border-light: rgba(0, 0, 0, 0.08);
+
+        // 深色模式覆盖
+        [data-mode="dark"] & {
+            background: var(--bg-secondary-solid, #282420);
+            color: var(--text-primary, #F0EEE9);
+            --text-primary: #F0EEE9;
+            --text-secondary: #b3b0aa;
+            --text-tertiary: #807d78;
+            --border-light: rgba(255, 255, 255, 0.1);
+        }
 
         box-shadow: none !important; // NO SHADOW
-        border: 1px solid var(--border-light, rgba(255, 255, 255, 0.1));
+        border: 1px solid var(--border-light);
 
         display: flex;
         padding: 16px;

src/components/Sidebar.scss

@@ -10,6 +10,19 @@
   &.collapsed {
     width: 64px;
 
+    .sidebar-user-card-wrap {
+      margin: 0 8px 8px;
+    }
+
+    .sidebar-user-card {
+      padding: 8px 0;
+      justify-content: center;
+
+      .user-meta {
+        display: none;
+      }
+    }
+
     .nav-menu,
     .sidebar-footer {
       padding: 0 8px;
@@ -27,6 +40,119 @@
   }
 }
 
+.sidebar-user-card-wrap {
+  position: relative;
+  margin: 0 12px 10px;
+}
+
+.sidebar-user-clear-trigger {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: calc(100% + 8px);
+  z-index: 12;
+  border: 1px solid rgba(255, 59, 48, 0.28);
+  border-radius: 10px;
+  background: var(--bg-secondary);
+  color: #d93025;
+  padding: 8px 10px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 12px;
+  font-weight: 600;
+  cursor: pointer;
+  box-shadow: 0 8px 20px rgba(15, 23, 42, 0.12);
+  transition: background 0.2s ease, color 0.2s ease, border-color 0.2s ease;
+
+  &:hover {
+    background: rgba(255, 59, 48, 0.08);
+    border-color: rgba(255, 59, 48, 0.46);
+  }
+}
+
+.sidebar-user-card {
+  width: 100%;
+  padding: 10px;
+  border: 1px solid var(--border-color);
+  border-radius: 12px;
+  background: var(--bg-secondary);
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  min-height: 56px;
+  cursor: pointer;
+  transition: border-color 0.2s ease, background 0.2s ease, box-shadow 0.2s ease;
+
+  &:hover {
+    border-color: rgba(99, 102, 241, 0.32);
+    background: var(--bg-tertiary);
+  }
+
+  &.menu-open {
+    border-color: rgba(99, 102, 241, 0.44);
+    box-shadow: 0 0 0 2px rgba(99, 102, 241, 0.12);
+  }
+
+  .user-avatar {
+    width: 36px;
+    height: 36px;
+    border-radius: 10px;
+    overflow: hidden;
+    background: linear-gradient(135deg, var(--primary), var(--primary-hover));
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+
+    img {
+      width: 100%;
+      height: 100%;
+      object-fit: cover;
+    }
+
+    span {
+      color: var(--on-primary);
+      font-size: 14px;
+      font-weight: 600;
+    }
+  }
+
+  .user-meta {
+    min-width: 0;
+    flex: 1;
+  }
+
+  .user-name {
+    font-size: 13px;
+    color: var(--text-primary);
+    font-weight: 600;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .user-wxid {
+    margin-top: 2px;
+    font-size: 11px;
+    color: var(--text-tertiary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .user-menu-caret {
+    color: var(--text-tertiary);
+    display: inline-flex;
+    transition: transform 0.2s ease, color 0.2s ease;
+
+    &.open {
+      transform: rotate(180deg);
+      color: var(--text-secondary);
+    }
+  }
+}
+
 .nav-menu {
   flex: 1;
   display: flex;
@@ -57,7 +183,7 @@
 
   &.active {
     background: var(--primary);
-    color: white;
+    color: var(--on-primary);
   }
 }
 
@@ -70,11 +196,44 @@
   flex-shrink: 0;
 }
 
+.nav-icon-with-badge {
+  position: relative;
+}
+
 .nav-label {
   font-size: 14px;
   font-weight: 500;
 }
 
+.nav-badge {
+  margin-left: auto;
+  min-width: 20px;
+  height: 20px;
+  border-radius: 999px;
+  padding: 0 6px;
+  background: #ff3b30;
+  color: #ffffff;
+  font-size: 11px;
+  font-weight: 700;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  line-height: 1;
+  box-shadow: 0 0 0 2px rgba(255, 59, 48, 0.18);
+}
+
+.nav-badge.icon-badge {
+  position: absolute;
+  top: -7px;
+  right: -10px;
+  margin-left: 0;
+  min-width: 16px;
+  height: 16px;
+  padding: 0 4px;
+  font-size: 10px;
+  box-shadow: 0 0 0 2px var(--bg-secondary);
+}
+
 .sidebar-footer {
   padding: 0 12px;
   border-top: 1px solid var(--border-color);
@@ -103,4 +262,107 @@
     background: var(--bg-tertiary);
     color: var(--text-primary);
   }
-}
+}
+
+.sidebar-clear-dialog-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(15, 23, 42, 0.3);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1100;
+  padding: 20px;
+}
+
+.sidebar-clear-dialog {
+  width: min(460px, 100%);
+  background: var(--bg-secondary);
+  border: 1px solid var(--border-color);
+  border-radius: 16px;
+  box-shadow: 0 18px 40px rgba(15, 23, 42, 0.24);
+  padding: 18px 18px 16px;
+
+  h3 {
+    margin: 0;
+    font-size: 16px;
+    color: var(--text-primary);
+  }
+
+  p {
+    margin: 10px 0 0;
+    font-size: 13px;
+    line-height: 1.6;
+    color: var(--text-secondary);
+  }
+}
+
+.sidebar-clear-options {
+  margin-top: 14px;
+  display: flex;
+  gap: 14px;
+  flex-wrap: wrap;
+
+  label {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 13px;
+    color: var(--text-primary);
+  }
+}
+
+.sidebar-clear-actions {
+  margin-top: 18px;
+  display: flex;
+  justify-content: flex-end;
+  gap: 10px;
+
+  button {
+    border: 1px solid var(--border-color);
+    border-radius: 10px;
+    padding: 8px 14px;
+    font-size: 13px;
+    cursor: pointer;
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+  }
+
+  button:disabled {
+    cursor: not-allowed;
+    opacity: 0.6;
+  }
+
+  .danger {
+    border-color: #ef4444;
+    background: #ef4444;
+    color: #fff;
+  }
+}
+
+// 繁花如梦主题：侧边栏毛玻璃 + 激活项用主品牌色
+[data-theme="blossom-dream"] .sidebar {
+  background: rgba(255, 255, 255, 0.6);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  border-right: 1px solid rgba(255, 255, 255, 0.4);
+}
+
+[data-theme="blossom-dream"][data-mode="dark"] .sidebar {
+  background: rgba(34, 30, 36, 0.75);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  border-right: 1px solid rgba(255, 255, 255, 0.06);
+}
+
+// 激活项：主品牌色纵向微渐变
+[data-theme="blossom-dream"] .nav-item.active {
+  background: linear-gradient(180deg, #D4849A 0%, #C4748A 100%);
+}
+
+// 深色激活项：用藕粉色，背景深灰底 + 粉色文字/图标（高阶玩法）
+[data-theme="blossom-dream"][data-mode="dark"] .nav-item.active {
+  background: rgba(209, 158, 187, 0.15);
+  color: #D19EBB;
+  border: 1px solid rgba(209, 158, 187, 0.2);
+}

src/components/Sidebar.tsx

@@ -1,23 +1,336 @@
-import { useState, useEffect } from 'react'
-import { NavLink, useLocation } from 'react-router-dom'
-import { Home, MessageSquare, BarChart3, Users, FileText, Database, Settings, ChevronLeft, ChevronRight, Download, Aperture, UserCircle, Lock } from 'lucide-react'
+import { useState, useEffect, useRef } from 'react'
+import { NavLink, useLocation, useNavigate } from 'react-router-dom'
+import { Home, MessageSquare, BarChart3, Users, FileText, Settings, ChevronLeft, ChevronRight, Download, Aperture, UserCircle, Lock, LockOpen, ChevronUp, Trash2 } from 'lucide-react'
 import { useAppStore } from '../stores/appStore'
+import * as configService from '../services/config'
+import { onExportSessionStatus, requestExportSessionStatus } from '../services/exportBridge'
 
 import './Sidebar.scss'
 
+interface SidebarUserProfile {
+  wxid: string
+  displayName: string
+  alias?: string
+  avatarUrl?: string
+}
+
+const SIDEBAR_USER_PROFILE_CACHE_KEY = 'sidebar_user_profile_cache_v1'
+
+interface SidebarUserProfileCache extends SidebarUserProfile {
+  updatedAt: number
+}
+
+const readSidebarUserProfileCache = (): SidebarUserProfile | null => {
+  try {
+    const raw = window.localStorage.getItem(SIDEBAR_USER_PROFILE_CACHE_KEY)
+    if (!raw) return null
+    const parsed = JSON.parse(raw) as SidebarUserProfileCache
+    if (!parsed || typeof parsed !== 'object') return null
+    if (!parsed.wxid || !parsed.displayName) return null
+    return {
+      wxid: parsed.wxid,
+      displayName: parsed.displayName,
+      alias: parsed.alias,
+      avatarUrl: parsed.avatarUrl
+    }
+  } catch {
+    return null
+  }
+}
+
+const writeSidebarUserProfileCache = (profile: SidebarUserProfile): void => {
+  if (!profile.wxid || !profile.displayName) return
+  try {
+    const payload: SidebarUserProfileCache = {
+      ...profile,
+      updatedAt: Date.now()
+    }
+    window.localStorage.setItem(SIDEBAR_USER_PROFILE_CACHE_KEY, JSON.stringify(payload))
+  } catch {
+    // 忽略本地缓存失败，不影响主流程
+  }
+}
+
+const normalizeAccountId = (value?: string | null): string => {
+  const trimmed = String(value || '').trim()
+  if (!trimmed) return ''
+  if (trimmed.toLowerCase().startsWith('wxid_')) {
+    const match = trimmed.match(/^(wxid_[^_]+)/i)
+    return match?.[1] || trimmed
+  }
+  const suffixMatch = trimmed.match(/^(.+)_([a-zA-Z0-9]{4})$/)
+  return suffixMatch ? suffixMatch[1] : trimmed
+}
+
 function Sidebar() {
   const location = useLocation()
+  const navigate = useNavigate()
   const [collapsed, setCollapsed] = useState(false)
   const [authEnabled, setAuthEnabled] = useState(false)
+  const [activeExportTaskCount, setActiveExportTaskCount] = useState(0)
+  const [userProfile, setUserProfile] = useState<SidebarUserProfile>({
+    wxid: '',
+    displayName: '未识别用户'
+  })
+  const [isAccountMenuOpen, setIsAccountMenuOpen] = useState(false)
+  const [showClearAccountDialog, setShowClearAccountDialog] = useState(false)
+  const [shouldClearCacheData, setShouldClearCacheData] = useState(false)
+  const [shouldClearExportData, setShouldClearExportData] = useState(false)
+  const [isClearingAccountData, setIsClearingAccountData] = useState(false)
+  const accountCardWrapRef = useRef<HTMLDivElement | null>(null)
   const setLocked = useAppStore(state => state.setLocked)
 
   useEffect(() => {
     window.electronAPI.auth.verifyEnabled().then(setAuthEnabled)
   }, [])
 
+  useEffect(() => {
+    const handleClickOutside = (event: MouseEvent) => {
+      if (!isAccountMenuOpen) return
+      const target = event.target as Node | null
+      if (accountCardWrapRef.current && target && !accountCardWrapRef.current.contains(target)) {
+        setIsAccountMenuOpen(false)
+      }
+    }
+    document.addEventListener('mousedown', handleClickOutside)
+    return () => document.removeEventListener('mousedown', handleClickOutside)
+  }, [isAccountMenuOpen])
+
+  useEffect(() => {
+    const unsubscribe = onExportSessionStatus((payload) => {
+      const countFromPayload = typeof payload?.activeTaskCount === 'number'
+        ? payload.activeTaskCount
+        : Array.isArray(payload?.inProgressSessionIds)
+          ? payload.inProgressSessionIds.length
+          : 0
+      const normalized = Math.max(0, Math.floor(countFromPayload))
+      setActiveExportTaskCount(normalized)
+    })
+
+    requestExportSessionStatus()
+    const timer = window.setTimeout(() => requestExportSessionStatus(), 120)
+
+    return () => {
+      unsubscribe()
+      window.clearTimeout(timer)
+    }
+  }, [])
+
+  useEffect(() => {
+    const loadCurrentUser = async () => {
+      const patchUserProfile = (patch: Partial<SidebarUserProfile>, expectedWxid?: string) => {
+        setUserProfile(prev => {
+          if (expectedWxid && prev.wxid && prev.wxid !== expectedWxid) {
+            return prev
+          }
+          const next: SidebarUserProfile = {
+            ...prev,
+            ...patch
+          }
+          if (!next.displayName) {
+            next.displayName = next.wxid || '未识别用户'
+          }
+          writeSidebarUserProfileCache(next)
+          return next
+        })
+      }
+
+      try {
+        const wxid = await configService.getMyWxid()
+        const resolvedWxidRaw = String(wxid || '').trim()
+        const cleanedWxid = normalizeAccountId(resolvedWxidRaw)
+        const resolvedWxid = cleanedWxid || resolvedWxidRaw
+        const wxidCandidates = new Set<string>([
+          resolvedWxidRaw.toLowerCase(),
+          resolvedWxid.trim().toLowerCase(),
+          cleanedWxid.trim().toLowerCase()
+        ].filter(Boolean))
+
+        const normalizeName = (value?: string | null): string | undefined => {
+          if (!value) return undefined
+          const trimmed = value.trim()
+          if (!trimmed) return undefined
+          const lowered = trimmed.toLowerCase()
+          if (lowered === 'self') return undefined
+          if (lowered.startsWith('wxid_')) return undefined
+          if (wxidCandidates.has(lowered)) return undefined
+          return trimmed
+        }
+
+        const pickFirstValidName = (...candidates: Array<string | null | undefined>): string | undefined => {
+          for (const candidate of candidates) {
+            const normalized = normalizeName(candidate)
+            if (normalized) return normalized
+          }
+          return undefined
+        }
+
+        const fallbackDisplayName = resolvedWxid || '未识别用户'
+
+        // 第一阶段：先把 wxid/名称打上，保证侧边栏第一时间可见。
+        patchUserProfile({
+          wxid: resolvedWxid,
+          displayName: fallbackDisplayName
+        })
+
+        if (!resolvedWxidRaw && !resolvedWxid) return
+
+        // 第二阶段：后台补齐名称（不会阻塞首屏）。
+        void (async () => {
+          try {
+            let myContact: Awaited<ReturnType<typeof window.electronAPI.chat.getContact>> | null = null
+            for (const candidate of Array.from(new Set([resolvedWxidRaw, resolvedWxid, cleanedWxid].filter(Boolean)))) {
+              const contact = await window.electronAPI.chat.getContact(candidate)
+              if (!contact) continue
+              if (!myContact) myContact = contact
+              if (contact.remark || contact.nickName || contact.alias) {
+                myContact = contact
+                break
+              }
+            }
+            const fromContact = pickFirstValidName(
+              myContact?.remark,
+              myContact?.nickName,
+              myContact?.alias
+            )
+
+            if (fromContact) {
+              patchUserProfile({ displayName: fromContact }, resolvedWxid)
+              // 同步补充微信号（alias）
+              if (myContact?.alias) {
+                patchUserProfile({ alias: myContact.alias }, resolvedWxid)
+              }
+              return
+            }
+
+            const enrichTargets = Array.from(new Set([resolvedWxidRaw, resolvedWxid, cleanedWxid, 'self'].filter(Boolean)))
+            const enrichedResult = await window.electronAPI.chat.enrichSessionsContactInfo(enrichTargets)
+            const enrichedDisplayName = pickFirstValidName(
+              enrichedResult.contacts?.[resolvedWxidRaw]?.displayName,
+              enrichedResult.contacts?.[resolvedWxid]?.displayName,
+              enrichedResult.contacts?.[cleanedWxid]?.displayName,
+              enrichedResult.contacts?.self?.displayName,
+              myContact?.alias
+            )
+            const bestName = enrichedDisplayName
+            if (bestName) {
+              patchUserProfile({ displayName: bestName }, resolvedWxid)
+            }
+            // 降级分支也补充微信号
+            if (myContact?.alias) {
+              patchUserProfile({ alias: myContact.alias }, resolvedWxid)
+            }
+          } catch (nameError) {
+            console.error('加载侧边栏用户昵称失败:', nameError)
+          }
+        })()
+
+        // 第二阶段：后台补齐头像（不会阻塞首屏）。
+        void (async () => {
+          try {
+            const avatarResult = await window.electronAPI.chat.getMyAvatarUrl()
+            if (avatarResult.success && avatarResult.avatarUrl) {
+              patchUserProfile({ avatarUrl: avatarResult.avatarUrl }, resolvedWxid)
+            }
+          } catch (avatarError) {
+            console.error('加载侧边栏用户头像失败:', avatarError)
+          }
+        })()
+      } catch (error) {
+        console.error('加载侧边栏用户信息失败:', error)
+      }
+    }
+
+    const cachedProfile = readSidebarUserProfileCache()
+    if (cachedProfile) {
+      setUserProfile(prev => ({
+        ...prev,
+        ...cachedProfile
+      }))
+    }
+
+    void loadCurrentUser()
+    const onWxidChanged = () => { void loadCurrentUser() }
+    window.addEventListener('wxid-changed', onWxidChanged as EventListener)
+    return () => window.removeEventListener('wxid-changed', onWxidChanged as EventListener)
+  }, [])
+
+  const getAvatarLetter = (name: string): string => {
+    if (!name) return '?'
+    return [...name][0] || '?'
+  }
+
   const isActive = (path: string) => {
     return location.pathname === path || location.pathname.startsWith(`${path}/`)
   }
+  const exportTaskBadge = activeExportTaskCount > 99 ? '99+' : `${activeExportTaskCount}`
+  const canConfirmClear = shouldClearCacheData || shouldClearExportData
+
+  const resetClearDialogState = () => {
+    setShouldClearCacheData(false)
+    setShouldClearExportData(false)
+    setShowClearAccountDialog(false)
+  }
+
+  const openClearAccountDialog = () => {
+    setIsAccountMenuOpen(false)
+    setShouldClearCacheData(false)
+    setShouldClearExportData(false)
+    setShowClearAccountDialog(true)
+  }
+
+  const handleConfirmClearAccountData = async () => {
+    if (!canConfirmClear || isClearingAccountData) return
+    setIsClearingAccountData(true)
+    try {
+      const result = await window.electronAPI.chat.clearCurrentAccountData({
+        clearCache: shouldClearCacheData,
+        clearExports: shouldClearExportData
+      })
+      if (!result.success) {
+        window.alert(result.error || '清理失败，请稍后重试。')
+        return
+      }
+      window.localStorage.removeItem(SIDEBAR_USER_PROFILE_CACHE_KEY)
+      setUserProfile({ wxid: '', displayName: '未识别用户' })
+      window.dispatchEvent(new Event('wxid-changed'))
+
+      const removedPaths = Array.isArray(result.removedPaths) ? result.removedPaths : []
+      const selectedScopes = [
+        shouldClearCacheData ? '缓存数据' : '',
+        shouldClearExportData ? '导出数据' : ''
+      ].filter(Boolean)
+      const detailLines: string[] = [
+        `清理范围：${selectedScopes.join('、') || '未选择'}`,
+        `已清理项目：${removedPaths.length} 项`
+      ]
+      if (removedPaths.length > 0) {
+        detailLines.push('', '清理明细（最多显示 8 项）：')
+        for (const [index, path] of removedPaths.slice(0, 8).entries()) {
+          detailLines.push(`${index + 1}. ${path}`)
+        }
+        if (removedPaths.length > 8) {
+          detailLines.push(`... 其余 ${removedPaths.length - 8} 项已省略`)
+        }
+      }
+      if (result.warning) {
+        detailLines.push('', `注意：${result.warning}`)
+      }
+      const followupHint = shouldClearCacheData
+        ? '若需再次获取数据，请手动登录微信客户端并重新在 WeFlow 完成配置。'
+        : '你可以继续使用当前登录状态，无需重新登录。'
+      window.alert(`账号数据清理完成。\n\n${detailLines.join('\n')}\n\n为保障数据安全，WeFlow 已清除该账号本地缓存/导出相关数据。${followupHint}`)
+      resetClearDialogState()
+      if (shouldClearCacheData) {
+        window.location.reload()
+      }
+    } catch (error) {
+      console.error('清理账号数据失败:', error)
+      window.alert('清理失败，请稍后重试。')
+    } finally {
+      setIsClearingAccountData(false)
+    }
+  }
 
   return (
     <aside className={`sidebar ${collapsed ? 'collapsed' : ''}`}>
@@ -98,24 +411,75 @@ function Sidebar() {
           className={`nav-item ${isActive('/export') ? 'active' : ''}`}
           title={collapsed ? '导出' : undefined}
         >
-          <span className="nav-icon"><Download size={20} /></span>
+          <span className="nav-icon nav-icon-with-badge">
+            <Download size={20} />
+            {collapsed && activeExportTaskCount > 0 && (
+              <span className="nav-badge icon-badge">{exportTaskBadge}</span>
+            )}
+          </span>
           <span className="nav-label">导出</span>
+          {!collapsed && activeExportTaskCount > 0 && (
+            <span className="nav-badge">{exportTaskBadge}</span>
+          )}
         </NavLink>
 
 
       </nav>
 
       <div className="sidebar-footer">
-        {authEnabled && (
-          <button
-            className="nav-item"
-            onClick={() => setLocked(true)}
-            title={collapsed ? '锁定' : undefined}
+        <div className="sidebar-user-card-wrap" ref={accountCardWrapRef}>
+          {isAccountMenuOpen && (
+            <button
+              className="sidebar-user-clear-trigger"
+              onClick={openClearAccountDialog}
+              type="button"
+            >
+              <Trash2 size={14} />
+              <span>清除此账号所有数据</span>
+            </button>
+          )}
+          <div
+            className={`sidebar-user-card ${isAccountMenuOpen ? 'menu-open' : ''}`}
+            title={collapsed ? `${userProfile.displayName}${(userProfile.alias || userProfile.wxid) ? `\n${userProfile.alias || userProfile.wxid}` : ''}` : undefined}
+            onClick={() => setIsAccountMenuOpen(prev => !prev)}
+            role="button"
+            tabIndex={0}
+            onKeyDown={(event) => {
+              if (event.key === 'Enter' || event.key === ' ') {
+                event.preventDefault()
+                setIsAccountMenuOpen(prev => !prev)
+              }
+            }}
           >
-            <span className="nav-icon"><Lock size={20} /></span>
-            <span className="nav-label">锁定</span>
-          </button>
-        )}
+            <div className="user-avatar">
+              {userProfile.avatarUrl ? <img src={userProfile.avatarUrl} alt="" /> : <span>{getAvatarLetter(userProfile.displayName)}</span>}
+            </div>
+            <div className="user-meta">
+              <div className="user-name">{userProfile.displayName}</div>
+              <div className="user-wxid">{userProfile.alias || userProfile.wxid || 'wxid 未识别'}</div>
+            </div>
+            {!collapsed && (
+              <span className={`user-menu-caret ${isAccountMenuOpen ? 'open' : ''}`}>
+                <ChevronUp size={14} />
+              </span>
+            )}
+          </div>
+        </div>
+
+        <button
+          className="nav-item"
+          onClick={() => {
+            if (authEnabled) {
+              setLocked(true)
+              return
+            }
+            navigate('/settings', { state: { initialTab: 'security' } })
+          }}
+          title={collapsed ? (authEnabled ? '锁定' : '未锁定') : undefined}
+        >
+          <span className="nav-icon">{authEnabled ? <Lock size={20} /> : <LockOpen size={20} />}</span>
+          <span className="nav-label">{authEnabled ? '锁定' : '未锁定'}</span>
+        </button>
 
         <NavLink
           to="/settings"
@@ -136,6 +500,49 @@ function Sidebar() {
           {collapsed ? <ChevronRight size={18} /> : <ChevronLeft size={18} />}
         </button>
       </div>
+
+      {showClearAccountDialog && (
+        <div className="sidebar-clear-dialog-overlay" onClick={() => !isClearingAccountData && resetClearDialogState()}>
+          <div className="sidebar-clear-dialog" role="dialog" aria-modal="true" onClick={(event) => event.stopPropagation()}>
+            <h3>清除此账号所有数据</h3>
+            <p>
+              操作后可将该账户在 weflow 下产生的所有缓存文件、导出文件等彻底清除。
+              清除后必须手动登录微信客户端 weflow 才能再次获取，保障你的数据安全。
+            </p>
+            <div className="sidebar-clear-options">
+              <label>
+                <input
+                  type="checkbox"
+                  checked={shouldClearCacheData}
+                  onChange={(event) => setShouldClearCacheData(event.target.checked)}
+                  disabled={isClearingAccountData}
+                />
+                缓存数据
+              </label>
+              <label>
+                <input
+                  type="checkbox"
+                  checked={shouldClearExportData}
+                  onChange={(event) => setShouldClearExportData(event.target.checked)}
+                  disabled={isClearingAccountData}
+                />
+                导出数据
+              </label>
+            </div>
+            <div className="sidebar-clear-actions">
+              <button type="button" onClick={resetClearDialogState} disabled={isClearingAccountData}>取消</button>
+              <button
+                type="button"
+                className="danger"
+                disabled={!canConfirmClear || isClearingAccountData}
+                onClick={handleConfirmClearAccountData}
+              >
+                {isClearingAccountData ? '清除中...' : '确认清除'}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
     </aside>
   )
 }

src/components/Sns/ContactSnsTimelineDialog.scss

@@ -0,0 +1,329 @@
+.contact-sns-dialog-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 1200;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 24px 16px;
+  background: rgba(15, 23, 42, 0.38);
+}
+
+.contact-sns-dialog {
+  width: min(760px, 100%);
+  max-height: min(86vh, 860px);
+  border-radius: 14px;
+  border: 1px solid var(--border-color);
+  background: var(--bg-secondary-solid, #ffffff);
+  box-shadow: 0 22px 46px rgba(0, 0, 0, 0.24);
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+
+  .spin {
+    animation: contactSnsDialogSpin 1s linear infinite;
+  }
+
+  .contact-sns-dialog-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+    padding: 14px 16px;
+    border-bottom: 1px solid var(--border-color);
+  }
+
+  .contact-sns-dialog-header-main {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    min-width: 0;
+  }
+
+  .contact-sns-dialog-avatar {
+    width: 42px;
+    height: 42px;
+    border-radius: 10px;
+    background: linear-gradient(135deg, var(--primary), var(--primary-hover));
+    overflow: hidden;
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+
+    img {
+      width: 100%;
+      height: 100%;
+      object-fit: cover;
+    }
+
+    span {
+      color: #fff;
+      font-size: 14px;
+      font-weight: 600;
+    }
+  }
+
+  .contact-sns-dialog-meta {
+    min-width: 0;
+
+    h4 {
+      margin: 0;
+      font-size: 15px;
+      color: var(--text-primary);
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+  }
+
+  .contact-sns-dialog-username {
+    margin-top: 2px;
+    font-size: 12px;
+    color: var(--text-tertiary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .contact-sns-dialog-stats {
+    margin-top: 4px;
+    font-size: 12px;
+    color: var(--text-secondary);
+  }
+
+  .contact-sns-dialog-header-actions {
+    display: flex;
+    align-items: flex-start;
+    gap: 8px;
+    flex-shrink: 0;
+  }
+
+  .contact-sns-dialog-rank-switch {
+    position: relative;
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+  }
+
+  .contact-sns-dialog-rank-btn {
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+    color: var(--text-secondary);
+    height: 28px;
+    padding: 0 10px;
+    font-size: 12px;
+    line-height: 1;
+    cursor: pointer;
+    white-space: nowrap;
+
+    &:hover {
+      color: var(--text-primary);
+      border-color: color-mix(in srgb, var(--primary) 42%, var(--border-color));
+    }
+
+    &.active {
+      color: var(--primary);
+      border-color: color-mix(in srgb, var(--primary) 52%, var(--border-color));
+      background: color-mix(in srgb, var(--primary) 10%, var(--bg-primary));
+    }
+  }
+
+  .contact-sns-dialog-rank-panel {
+    position: absolute;
+    top: calc(100% + 8px);
+    right: 0;
+    width: 248px;
+    max-height: calc((28px * 15) + 16px);
+    overflow-y: auto;
+    border: 1px solid color-mix(in srgb, var(--primary) 30%, var(--border-color));
+    border-radius: 10px;
+    background: var(--bg-primary);
+    box-shadow: 0 14px 26px rgba(0, 0, 0, 0.18);
+    padding: 8px;
+    z-index: 12;
+  }
+
+  .contact-sns-dialog-rank-empty {
+    font-size: 12px;
+    color: var(--text-tertiary);
+    line-height: 1.5;
+    text-align: center;
+    padding: 6px 0;
+  }
+
+  .contact-sns-dialog-rank-loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 6px;
+    min-height: 28px;
+    padding: 4px 0 8px;
+    font-size: 12px;
+    color: var(--text-secondary);
+    line-height: 1.5;
+  }
+
+  .contact-sns-dialog-rank-row {
+    display: grid;
+    grid-template-columns: 20px minmax(0, 1fr) auto;
+    align-items: center;
+    gap: 8px;
+    min-height: 28px;
+    padding: 0 4px;
+    border-radius: 7px;
+
+    &:hover {
+      background: var(--bg-hover);
+    }
+  }
+
+  .contact-sns-dialog-rank-index {
+    font-size: 12px;
+    color: var(--text-tertiary);
+    text-align: right;
+    font-variant-numeric: tabular-nums;
+  }
+
+  .contact-sns-dialog-rank-name {
+    font-size: 12px;
+    color: var(--text-primary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .contact-sns-dialog-rank-count {
+    font-size: 12px;
+    color: var(--text-secondary);
+    font-variant-numeric: tabular-nums;
+    white-space: nowrap;
+  }
+
+  .contact-sns-dialog-close-btn {
+    border: none;
+    background: transparent;
+    color: var(--text-secondary);
+    width: 28px;
+    height: 28px;
+    border-radius: 7px;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+
+    &:hover {
+      background: var(--bg-hover);
+      color: var(--text-primary);
+    }
+  }
+
+  .contact-sns-dialog-tip {
+    padding: 10px 16px;
+    border-bottom: 1px solid color-mix(in srgb, var(--border-color) 88%, transparent);
+    background: color-mix(in srgb, var(--bg-primary) 78%, var(--bg-secondary));
+    font-size: 12px;
+    line-height: 1.6;
+    color: var(--text-secondary);
+    word-break: break-word;
+  }
+
+  .contact-sns-dialog-body {
+    flex: 1;
+    min-height: 0;
+    overflow-y: auto;
+    padding: 12px 16px 14px;
+  }
+
+  .contact-sns-dialog-posts-list {
+    display: flex;
+    flex-direction: column;
+    gap: 14px;
+  }
+
+  .contact-sns-dialog-posts-list .post-header-actions {
+    display: none;
+  }
+
+  .contact-sns-dialog-status {
+    padding: 20px 12px;
+    text-align: center;
+    font-size: 13px;
+    color: var(--text-secondary);
+
+    &.empty {
+      color: var(--text-tertiary);
+    }
+  }
+
+  .contact-sns-dialog-load-more {
+    display: block;
+    margin: 12px auto 0;
+    border: 1px solid var(--border-color);
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    border-radius: 10px;
+    padding: 9px 18px;
+    font-size: 13px;
+    cursor: pointer;
+
+    &:hover:not(:disabled) {
+      border-color: color-mix(in srgb, var(--primary) 42%, var(--border-color));
+      color: var(--primary);
+    }
+
+    &:disabled {
+      cursor: not-allowed;
+      opacity: 0.72;
+    }
+  }
+}
+
+@media (max-width: 768px) {
+  .contact-sns-dialog-overlay {
+    padding: 12px 8px;
+  }
+
+  .contact-sns-dialog {
+    width: min(100vw - 16px, 760px);
+    max-height: calc(100vh - 24px);
+
+    .contact-sns-dialog-header {
+      padding: 12px;
+    }
+
+    .contact-sns-dialog-header-actions {
+      gap: 6px;
+    }
+
+    .contact-sns-dialog-rank-btn {
+      height: 26px;
+      padding: 0 8px;
+      font-size: 11px;
+    }
+
+    .contact-sns-dialog-rank-panel {
+      width: min(78vw, 232px);
+    }
+
+    .contact-sns-dialog-tip {
+      padding: 10px 12px;
+      line-height: 1.55;
+    }
+
+    .contact-sns-dialog-body {
+      padding: 10px 10px 12px;
+    }
+  }
+}
+
+@keyframes contactSnsDialogSpin {
+  from {
+    transform: rotate(0deg);
+  }
+
+  to {
+    transform: rotate(360deg);
+  }
+}

src/components/Sns/ContactSnsTimelineDialog.tsx

@@ -0,0 +1,593 @@
+import { createPortal } from 'react-dom'
+import { Loader2, X } from 'lucide-react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { SnsPostItem } from './SnsPostItem'
+import type { SnsPost } from '../../types/sns'
+import {
+  type ContactSnsRankItem,
+  type ContactSnsRankMode,
+  type ContactSnsTimelineTarget,
+  getAvatarLetter
+} from './contactSnsTimeline'
+import './ContactSnsTimelineDialog.scss'
+
+const TIMELINE_PAGE_SIZE = 20
+const SNS_RANK_PAGE_SIZE = 50
+const SNS_RANK_DISPLAY_LIMIT = 15
+
+interface ContactSnsRankCacheEntry {
+  likes: ContactSnsRankItem[]
+  comments: ContactSnsRankItem[]
+  totalPosts: number
+}
+
+interface ContactSnsTimelineDialogProps {
+  target: ContactSnsTimelineTarget | null
+  onClose: () => void
+  initialTotalPosts?: number | null
+  initialTotalPostsLoading?: boolean
+  isProtected?: boolean
+  onDeletePost?: (postId: string, username: string) => void
+}
+
+const normalizeTotalPosts = (value?: number | null): number | null => {
+  if (!Number.isFinite(value)) return null
+  return Math.max(0, Math.floor(Number(value)))
+}
+
+const formatYmdDateFromSeconds = (timestamp?: number): string => {
+  if (!timestamp || !Number.isFinite(timestamp)) return '—'
+  const date = new Date(timestamp * 1000)
+  const year = date.getFullYear()
+  const month = `${date.getMonth() + 1}`.padStart(2, '0')
+  const day = `${date.getDate()}`.padStart(2, '0')
+  return `${year}-${month}-${day}`
+}
+
+const buildContactSnsRankings = (posts: SnsPost[]): { likes: ContactSnsRankItem[]; comments: ContactSnsRankItem[] } => {
+  const likeMap = new Map<string, ContactSnsRankItem>()
+  const commentMap = new Map<string, ContactSnsRankItem>()
+
+  for (const post of posts) {
+    const createTime = Number(post?.createTime) || 0
+    const likes = Array.isArray(post?.likes) ? post.likes : []
+    const comments = Array.isArray(post?.comments) ? post.comments : []
+
+    for (const likeNameRaw of likes) {
+      const name = String(likeNameRaw || '').trim() || '未知用户'
+      const current = likeMap.get(name)
+      if (current) {
+        current.count += 1
+        if (createTime > current.latestTime) current.latestTime = createTime
+        continue
+      }
+      likeMap.set(name, { name, count: 1, latestTime: createTime })
+    }
+
+    for (const comment of comments) {
+      const name = String(comment?.nickname || '').trim() || '未知用户'
+      const current = commentMap.get(name)
+      if (current) {
+        current.count += 1
+        if (createTime > current.latestTime) current.latestTime = createTime
+        continue
+      }
+      commentMap.set(name, { name, count: 1, latestTime: createTime })
+    }
+  }
+
+  const sorter = (left: ContactSnsRankItem, right: ContactSnsRankItem): number => {
+    if (right.count !== left.count) return right.count - left.count
+    if (right.latestTime !== left.latestTime) return right.latestTime - left.latestTime
+    return left.name.localeCompare(right.name, 'zh-CN')
+  }
+
+  return {
+    likes: [...likeMap.values()].sort(sorter),
+    comments: [...commentMap.values()].sort(sorter)
+  }
+}
+
+export function ContactSnsTimelineDialog({
+  target,
+  onClose,
+  initialTotalPosts = null,
+  initialTotalPostsLoading = false,
+  isProtected = false,
+  onDeletePost
+}: ContactSnsTimelineDialogProps) {
+  const [timelinePosts, setTimelinePosts] = useState<SnsPost[]>([])
+  const [timelineLoading, setTimelineLoading] = useState(false)
+  const [timelineLoadingMore, setTimelineLoadingMore] = useState(false)
+  const [timelineHasMore, setTimelineHasMore] = useState(false)
+  const [timelineTotalPosts, setTimelineTotalPosts] = useState<number | null>(null)
+  const [timelineStatsLoading, setTimelineStatsLoading] = useState(false)
+  const [rankMode, setRankMode] = useState<ContactSnsRankMode | null>(null)
+  const [likeRankings, setLikeRankings] = useState<ContactSnsRankItem[]>([])
+  const [commentRankings, setCommentRankings] = useState<ContactSnsRankItem[]>([])
+  const [rankLoading, setRankLoading] = useState(false)
+  const [rankError, setRankError] = useState<string | null>(null)
+  const [rankLoadedPosts, setRankLoadedPosts] = useState(0)
+  const [rankTotalPosts, setRankTotalPosts] = useState<number | null>(null)
+
+  const timelinePostsRef = useRef<SnsPost[]>([])
+  const timelineLoadingRef = useRef(false)
+  const timelineRequestTokenRef = useRef(0)
+  const totalPostsRequestTokenRef = useRef(0)
+  const rankRequestTokenRef = useRef(0)
+  const rankLoadingRef = useRef(false)
+  const rankCacheRef = useRef<Record<string, ContactSnsRankCacheEntry>>({})
+
+  const targetUsername = String(target?.username || '').trim()
+  const targetDisplayName = target?.displayName || targetUsername
+  const targetAvatarUrl = target?.avatarUrl
+
+  useEffect(() => {
+    timelinePostsRef.current = timelinePosts
+  }, [timelinePosts])
+
+  const loadTimelinePosts = useCallback(async (nextTarget: ContactSnsTimelineTarget, options?: { reset?: boolean }) => {
+    const reset = Boolean(options?.reset)
+    if (timelineLoadingRef.current) return
+
+    timelineLoadingRef.current = true
+    if (reset) {
+      setTimelineLoading(true)
+      setTimelineLoadingMore(false)
+      setTimelineHasMore(false)
+    } else {
+      setTimelineLoadingMore(true)
+    }
+
+    const requestToken = ++timelineRequestTokenRef.current
+
+    try {
+      let endTime: number | undefined
+      if (!reset && timelinePostsRef.current.length > 0) {
+        endTime = timelinePostsRef.current[timelinePostsRef.current.length - 1].createTime - 1
+      }
+
+      const result = await window.electronAPI.sns.getTimeline(
+        TIMELINE_PAGE_SIZE,
+        0,
+        [nextTarget.username],
+        '',
+        undefined,
+        endTime
+      )
+      if (requestToken !== timelineRequestTokenRef.current) return
+
+      if (!result.success || !Array.isArray(result.timeline)) {
+        if (reset) {
+          setTimelinePosts([])
+          setTimelineHasMore(false)
+        }
+        return
+      }
+
+      const timeline = [...(result.timeline as SnsPost[])].sort((left, right) => right.createTime - left.createTime)
+      if (reset) {
+        setTimelinePosts(timeline)
+        setTimelineHasMore(timeline.length >= TIMELINE_PAGE_SIZE)
+        return
+      }
+
+      const existingIds = new Set(timelinePostsRef.current.map((post) => post.id))
+      const uniqueOlder = timeline.filter((post) => !existingIds.has(post.id))
+      if (uniqueOlder.length > 0) {
+        const merged = [...timelinePostsRef.current, ...uniqueOlder].sort((left, right) => right.createTime - left.createTime)
+        setTimelinePosts(merged)
+      }
+      if (timeline.length < TIMELINE_PAGE_SIZE) {
+        setTimelineHasMore(false)
+      }
+    } catch (error) {
+      console.error('加载联系人朋友圈失败:', error)
+      if (requestToken === timelineRequestTokenRef.current && reset) {
+        setTimelinePosts([])
+        setTimelineHasMore(false)
+      }
+    } finally {
+      if (requestToken === timelineRequestTokenRef.current) {
+        timelineLoadingRef.current = false
+        setTimelineLoading(false)
+        setTimelineLoadingMore(false)
+      }
+    }
+  }, [])
+
+  const loadTimelineTotalPosts = useCallback(async (nextTarget: ContactSnsTimelineTarget) => {
+    const requestToken = ++totalPostsRequestTokenRef.current
+    setTimelineStatsLoading(true)
+
+    try {
+      const result = await window.electronAPI.sns.getUserPostCounts()
+      if (requestToken !== totalPostsRequestTokenRef.current) return
+
+      if (!result.success || !result.counts) {
+        setTimelineTotalPosts(null)
+        setRankTotalPosts(null)
+        return
+      }
+
+      const rawCount = Number(result.counts[nextTarget.username] || 0)
+      const normalized = Number.isFinite(rawCount) ? Math.max(0, Math.floor(rawCount)) : 0
+      setTimelineTotalPosts(normalized)
+      setRankTotalPosts(normalized)
+    } catch (error) {
+      console.error('加载联系人朋友圈条数失败:', error)
+      if (requestToken !== totalPostsRequestTokenRef.current) return
+      setTimelineTotalPosts(null)
+      setRankTotalPosts(null)
+    } finally {
+      if (requestToken === totalPostsRequestTokenRef.current) {
+        setTimelineStatsLoading(false)
+      }
+    }
+  }, [])
+
+  const loadRankings = useCallback(async (nextTarget: ContactSnsTimelineTarget) => {
+    const normalizedUsername = String(nextTarget?.username || '').trim()
+    if (!normalizedUsername || rankLoadingRef.current) return
+
+    const normalizedKnownTotal = normalizeTotalPosts(timelineTotalPosts)
+    const cached = rankCacheRef.current[normalizedUsername]
+
+    if (cached && (normalizedKnownTotal === null || cached.totalPosts === normalizedKnownTotal)) {
+      setLikeRankings(cached.likes)
+      setCommentRankings(cached.comments)
+      setRankLoadedPosts(cached.totalPosts)
+      setRankTotalPosts(cached.totalPosts)
+      setRankError(null)
+      setRankLoading(false)
+      return
+    }
+
+    rankLoadingRef.current = true
+    const requestToken = ++rankRequestTokenRef.current
+    setRankLoading(true)
+    setRankError(null)
+    setRankLoadedPosts(0)
+    setRankTotalPosts(normalizedKnownTotal)
+
+    try {
+      const allPosts: SnsPost[] = []
+      let endTime: number | undefined
+      let hasMore = true
+
+      while (hasMore) {
+        const result = await window.electronAPI.sns.getTimeline(
+          SNS_RANK_PAGE_SIZE,
+          0,
+          [normalizedUsername],
+          '',
+          undefined,
+          endTime
+        )
+        if (requestToken !== rankRequestTokenRef.current) return
+
+        if (!result.success) {
+          throw new Error(result.error || '加载朋友圈排行失败')
+        }
+
+        const pagePosts = Array.isArray(result.timeline)
+          ? [...(result.timeline as SnsPost[])].sort((left, right) => right.createTime - left.createTime)
+          : []
+        if (pagePosts.length === 0) {
+          hasMore = false
+          break
+        }
+
+        allPosts.push(...pagePosts)
+        setRankLoadedPosts(allPosts.length)
+        if (normalizedKnownTotal === null) {
+          setRankTotalPosts(allPosts.length)
+        }
+
+        endTime = pagePosts[pagePosts.length - 1].createTime - 1
+        hasMore = pagePosts.length >= SNS_RANK_PAGE_SIZE
+      }
+
+      if (requestToken !== rankRequestTokenRef.current) return
+
+      const rankings = buildContactSnsRankings(allPosts)
+      const totalPosts = allPosts.length
+      rankCacheRef.current[normalizedUsername] = {
+        likes: rankings.likes,
+        comments: rankings.comments,
+        totalPosts
+      }
+      setLikeRankings(rankings.likes)
+      setCommentRankings(rankings.comments)
+      setRankLoadedPosts(totalPosts)
+      setRankTotalPosts(totalPosts)
+      setRankError(null)
+    } catch (error) {
+      if (requestToken !== rankRequestTokenRef.current) return
+      const message = error instanceof Error ? error.message : String(error)
+      setLikeRankings([])
+      setCommentRankings([])
+      setRankError(message || '加载朋友圈排行失败')
+    } finally {
+      if (requestToken === rankRequestTokenRef.current) {
+        rankLoadingRef.current = false
+        setRankLoading(false)
+      }
+    }
+  }, [timelineTotalPosts])
+
+  useEffect(() => {
+    if (!targetUsername) return
+
+    totalPostsRequestTokenRef.current += 1
+    rankRequestTokenRef.current += 1
+    rankLoadingRef.current = false
+    setRankMode(null)
+    setLikeRankings([])
+    setCommentRankings([])
+    setRankLoading(false)
+    setRankError(null)
+    setRankLoadedPosts(0)
+    setRankTotalPosts(null)
+    setTimelinePosts([])
+    setTimelineTotalPosts(null)
+    setTimelineStatsLoading(false)
+    setTimelineHasMore(false)
+    setTimelineLoadingMore(false)
+    setTimelineLoading(false)
+
+    void loadTimelinePosts({
+      username: targetUsername,
+      displayName: targetDisplayName,
+      avatarUrl: targetAvatarUrl
+    }, { reset: true })
+  }, [loadTimelinePosts, targetAvatarUrl, targetDisplayName, targetUsername])
+
+  useEffect(() => {
+    if (!targetUsername) return
+
+    const normalizedTotal = normalizeTotalPosts(initialTotalPosts)
+    if (normalizedTotal !== null) {
+      setTimelineTotalPosts(normalizedTotal)
+      setRankTotalPosts(normalizedTotal)
+      setTimelineStatsLoading(false)
+      return
+    }
+
+    if (initialTotalPostsLoading) {
+      setTimelineTotalPosts(null)
+      setRankTotalPosts(null)
+      setTimelineStatsLoading(true)
+      return
+    }
+
+    void loadTimelineTotalPosts({
+      username: targetUsername,
+      displayName: targetDisplayName,
+      avatarUrl: targetAvatarUrl
+    })
+  }, [
+    initialTotalPosts,
+    initialTotalPostsLoading,
+    loadTimelineTotalPosts,
+    targetAvatarUrl,
+    targetDisplayName,
+    targetUsername
+  ])
+
+  useEffect(() => {
+    if (timelineTotalPosts === null) return
+    if (timelinePosts.length >= timelineTotalPosts) {
+      setTimelineHasMore(false)
+    }
+  }, [timelinePosts.length, timelineTotalPosts])
+
+  useEffect(() => {
+    if (!rankMode || !targetUsername) return
+    void loadRankings({
+      username: targetUsername,
+      displayName: targetDisplayName,
+      avatarUrl: targetAvatarUrl
+    })
+  }, [loadRankings, rankMode, targetAvatarUrl, targetDisplayName, targetUsername])
+
+  useEffect(() => {
+    if (!targetUsername) return
+    const handleKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        onClose()
+      }
+    }
+    window.addEventListener('keydown', handleKeyDown)
+    return () => window.removeEventListener('keydown', handleKeyDown)
+  }, [onClose, targetUsername])
+
+  const timelineStatsText = useMemo(() => {
+    const loadedCount = timelinePosts.length
+    const loadPart = timelineStatsLoading
+      ? `已加载 ${loadedCount} / 总数统计中...`
+      : timelineTotalPosts === null
+        ? `已加载 ${loadedCount} 条`
+        : `已加载 ${loadedCount} / 共 ${timelineTotalPosts} 条`
+
+    if (timelineLoading && loadedCount === 0) return `${loadPart} ｜ 加载中...`
+    if (loadedCount === 0) return loadPart
+
+    const latest = timelinePosts[0]?.createTime
+    const earliest = timelinePosts[timelinePosts.length - 1]?.createTime
+    return `${loadPart} ｜ ${formatYmdDateFromSeconds(earliest)} ~ ${formatYmdDateFromSeconds(latest)}`
+  }, [timelineLoading, timelinePosts, timelineStatsLoading, timelineTotalPosts])
+
+  const activeRankings = useMemo(() => {
+    if (rankMode === 'likes') return likeRankings
+    if (rankMode === 'comments') return commentRankings
+    return []
+  }, [commentRankings, likeRankings, rankMode])
+
+  const loadMore = useCallback(() => {
+    if (!targetUsername || timelineLoading || timelineLoadingMore || !timelineHasMore) return
+    void loadTimelinePosts({
+      username: targetUsername,
+      displayName: targetDisplayName,
+      avatarUrl: targetAvatarUrl
+    }, { reset: false })
+  }, [
+    loadTimelinePosts,
+    targetAvatarUrl,
+    targetDisplayName,
+    targetUsername,
+    timelineHasMore,
+    timelineLoading,
+    timelineLoadingMore
+  ])
+
+  const handleBodyScroll = useCallback((event: React.UIEvent<HTMLDivElement>) => {
+    const element = event.currentTarget
+    const remaining = element.scrollHeight - element.scrollTop - element.clientHeight
+    if (remaining <= 160) {
+      loadMore()
+    }
+  }, [loadMore])
+
+  const toggleRankMode = useCallback((mode: ContactSnsRankMode) => {
+    setRankMode((previous) => (previous === mode ? null : mode))
+  }, [])
+
+  if (!target) return null
+
+  return createPortal(
+    <div className="contact-sns-dialog-overlay" onClick={onClose}>
+      <div
+        className="contact-sns-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-label="联系人朋友圈"
+        onClick={(event) => event.stopPropagation()}
+      >
+        <div className="contact-sns-dialog-header">
+          <div className="contact-sns-dialog-header-main">
+            <div className="contact-sns-dialog-avatar">
+              {targetAvatarUrl ? (
+                <img src={targetAvatarUrl} alt="" />
+              ) : (
+                <span>{getAvatarLetter(targetDisplayName)}</span>
+              )}
+            </div>
+            <div className="contact-sns-dialog-meta">
+              <h4>{targetDisplayName}</h4>
+              <div className="contact-sns-dialog-username">@{targetUsername}</div>
+              <div className="contact-sns-dialog-stats">{timelineStatsText}</div>
+            </div>
+          </div>
+          <div className="contact-sns-dialog-header-actions">
+            <div className="contact-sns-dialog-rank-switch">
+              <button
+                type="button"
+                className={`contact-sns-dialog-rank-btn ${rankMode === 'likes' ? 'active' : ''}`}
+                onClick={() => toggleRankMode('likes')}
+              >
+                点赞排行
+              </button>
+              <button
+                type="button"
+                className={`contact-sns-dialog-rank-btn ${rankMode === 'comments' ? 'active' : ''}`}
+                onClick={() => toggleRankMode('comments')}
+              >
+                评论排行
+              </button>
+              {rankMode && (
+                <div
+                  className="contact-sns-dialog-rank-panel"
+                  role="region"
+                  aria-label={rankMode === 'likes' ? '点赞排行' : '评论排行'}
+                >
+                  {rankLoading && (
+                    <div className="contact-sns-dialog-rank-loading">
+                      <Loader2 size={12} className="spin" />
+                      <span>
+                        {rankTotalPosts !== null && rankTotalPosts > 0
+                          ? `统计中，已加载 ${rankLoadedPosts} / ${rankTotalPosts} 条`
+                          : `统计中，已加载 ${rankLoadedPosts} 条`}
+                      </span>
+                    </div>
+                  )}
+                  {!rankLoading && rankError ? (
+                    <div className="contact-sns-dialog-rank-empty">{rankError}</div>
+                  ) : !rankLoading && activeRankings.length === 0 ? (
+                    <div className="contact-sns-dialog-rank-empty">
+                      {rankMode === 'likes' ? '暂无点赞数据' : '暂无评论数据'}
+                    </div>
+                  ) : (
+                    activeRankings.slice(0, SNS_RANK_DISPLAY_LIMIT).map((item, index) => (
+                      <div className="contact-sns-dialog-rank-row" key={`${rankMode}-${item.name}`}>
+                        <span className="contact-sns-dialog-rank-index">{index + 1}</span>
+                        <span className="contact-sns-dialog-rank-name" title={item.name}>{item.name}</span>
+                        <span className="contact-sns-dialog-rank-count">
+                          {item.count.toLocaleString('zh-CN')}
+                          {rankMode === 'likes' ? '次' : '条'}
+                        </span>
+                      </div>
+                    ))
+                  )}
+                </div>
+              )}
+            </div>
+            <button className="contact-sns-dialog-close-btn" type="button" onClick={onClose}>
+              <X size={16} />
+            </button>
+          </div>
+        </div>
+
+        <div className="contact-sns-dialog-tip">
+          在微信桌面客户端中打开这个人的朋友圈浏览，可快速把其朋友圈同步到这里。若你在乎这个人，一定要试试～
+        </div>
+
+        <div
+          className="contact-sns-dialog-body"
+          onScroll={handleBodyScroll}
+        >
+          {timelinePosts.length > 0 && (
+            <div className="contact-sns-dialog-posts-list">
+              {timelinePosts.map((post) => (
+                <SnsPostItem
+                  key={post.id}
+                  post={{ ...post, isProtected }}
+                  onPreview={(src, isVideo, liveVideoPath) => {
+                    if (isVideo) {
+                      void window.electronAPI.window.openVideoPlayerWindow(src)
+                    } else {
+                      void window.electronAPI.window.openImageViewerWindow(src, liveVideoPath || undefined)
+                    }
+                  }}
+                  onDebug={() => {}}
+                  onDelete={onDeletePost}
+                  hideAuthorMeta
+                />
+              ))}
+            </div>
+          )}
+
+          {timelineLoading && (
+            <div className="contact-sns-dialog-status">正在加载该联系人的朋友圈...</div>
+          )}
+
+          {!timelineLoading && timelinePosts.length === 0 && (
+            <div className="contact-sns-dialog-status empty">该联系人暂无朋友圈</div>
+          )}
+
+          {!timelineLoading && timelineHasMore && (
+            <button
+              className="contact-sns-dialog-load-more"
+              type="button"
+              onClick={loadMore}
+              disabled={timelineLoadingMore}
+            >
+              {timelineLoadingMore ? '正在加载...' : '加载更多'}
+            </button>
+          )}
+        </div>
+      </div>
+    </div>,
+    document.body
+  )
+}

src/components/Sns/SnsFilterPanel.tsx

@@ -1,67 +1,69 @@
-import React, { useState } from 'react'
-import { Search, Calendar, User, X, Filter, Check } from 'lucide-react'
+import React from 'react'
+import { Search, User, X, Loader2 } from 'lucide-react'
 import { Avatar } from '../Avatar'
-// import JumpToDateDialog from '../JumpToDateDialog' // Assuming this is imported from parent or moved
 
 interface Contact {
     username: string
     displayName: string
     avatarUrl?: string
+    postCount?: number
+    postCountStatus?: 'idle' | 'loading' | 'ready'
+}
+
+interface ContactsCountProgress {
+    resolved: number
+    total: number
+    running: boolean
 }
 
 interface SnsFilterPanelProps {
     searchKeyword: string
     setSearchKeyword: (val: string) => void
-    jumpTargetDate?: Date
-    setJumpTargetDate: (date?: Date) => void
-    onOpenJumpDialog: () => void
-    selectedUsernames: string[]
-    setSelectedUsernames: (val: string[]) => void
+    totalFriendsLabel?: string
     contacts: Contact[]
     contactSearch: string
     setContactSearch: (val: string) => void
     loading?: boolean
+    contactsCountProgress?: ContactsCountProgress
+    onOpenContactTimeline: (contact: Contact) => void
 }
 
 export const SnsFilterPanel: React.FC<SnsFilterPanelProps> = ({
     searchKeyword,
     setSearchKeyword,
-    jumpTargetDate,
-    setJumpTargetDate,
-    onOpenJumpDialog,
-    selectedUsernames,
-    setSelectedUsernames,
+    totalFriendsLabel,
     contacts,
     contactSearch,
     setContactSearch,
-    loading
+    loading,
+    contactsCountProgress,
+    onOpenContactTimeline
 }) => {
-
     const filteredContacts = contacts.filter(c =>
-        c.displayName.toLowerCase().includes(contactSearch.toLowerCase()) ||
+        (c.displayName || '').toLowerCase().includes(contactSearch.toLowerCase()) ||
         c.username.toLowerCase().includes(contactSearch.toLowerCase())
     )
 
-    const toggleUserSelection = (username: string) => {
-        if (selectedUsernames.includes(username)) {
-            setSelectedUsernames(selectedUsernames.filter(u => u !== username))
-        } else {
-            setJumpTargetDate(undefined) // Reset date jump when selecting user
-            setSelectedUsernames([...selectedUsernames, username])
-        }
-    }
-
     const clearFilters = () => {
         setSearchKeyword('')
-        setSelectedUsernames([])
-        setJumpTargetDate(undefined)
+        setContactSearch('')
+    }
+
+    const getEmptyStateText = () => {
+        if (loading && contacts.length === 0) {
+            return '正在加载联系人...'
+        }
+        if (contacts.length === 0) {
+            return '暂无好友或曾经的好友'
+        }
+        return '没有找到联系人'
     }
 
     return (
         <aside className="sns-filter-panel">
             <div className="filter-header">
                 <h3>筛选条件</h3>
-                {(searchKeyword || jumpTargetDate || selectedUsernames.length > 0) && (
+                {(searchKeyword || contactSearch) && (
                     <button className="reset-all-btn" onClick={clearFilters} title="重置所有筛选">
                         <RefreshCw size={14} />
                     </button>
@@ -89,43 +91,13 @@ export const SnsFilterPanel: React.FC<SnsFilterPanelProps> = ({
                         )}
                     </div>
                 </div>
-
-                {/* Date Widget */}
-                <div className="filter-widget date-widget">
-                    <div className="widget-header">
-                        <Calendar size={14} />
-                        <span>时间跳转</span>
-                    </div>
-                    <button
-                        className={`date-picker-trigger ${jumpTargetDate ? 'active' : ''}`}
-                        onClick={onOpenJumpDialog}
-                    >
-                        <span className="date-text">
-                            {jumpTargetDate
-                                ? jumpTargetDate.toLocaleDateString('zh-CN', { year: 'numeric', month: 'long', day: 'numeric' })
-                                : '选择日期...'}
-                        </span>
-                        {jumpTargetDate && (
-                            <div
-                                className="clear-date-btn"
-                                onClick={(e) => {
-                                    e.stopPropagation()
-                                    setJumpTargetDate(undefined)
-                                }}
-                            >
-                                <X size={12} />
-                            </div>
-                        )}
-                    </button>
-                </div>
-
                 {/* Contact Widget */}
                 <div className="filter-widget contact-widget">
                     <div className="widget-header">
                         <User size={14} />
                         <span>联系人</span>
-                        {selectedUsernames.length > 0 && (
-                            <span className="badge">{selectedUsernames.length}</span>
+                        {totalFriendsLabel && (
+                            <span className="widget-header-summary">{totalFriendsLabel}</span>
                         )}
                     </div>
 
@@ -142,19 +114,41 @@ export const SnsFilterPanel: React.FC<SnsFilterPanelProps> = ({
                         )}
                     </div>
 
+                    {contactsCountProgress && contactsCountProgress.total > 0 && (
+                        <div className="contact-count-progress">
+                            {contactsCountProgress.running
+                                ? `朋友圈条数统计中 ${contactsCountProgress.resolved}/${contactsCountProgress.total}`
+                                : `朋友圈条数已统计 ${contactsCountProgress.total}/${contactsCountProgress.total}`}
+                        </div>
+                    )}
+
                     <div className="contact-list-scroll">
-                        {filteredContacts.map(contact => (
+                        {filteredContacts.map(contact => {
+                            const isPostCountReady = contact.postCountStatus === 'ready'
+                            return (
                             <div
                                 key={contact.username}
-                                className={`contact-row ${selectedUsernames.includes(contact.username) ? 'selected' : ''}`}
-                                onClick={() => toggleUserSelection(contact.username)}
+                                className="contact-row"
+                                onClick={() => onOpenContactTimeline(contact)}
                             >
                                 <Avatar src={contact.avatarUrl} name={contact.displayName} size={36} shape="rounded" />
-                                <span className="contact-name">{contact.displayName}</span>
+                                <div className="contact-meta">
+                                    <span className="contact-name">{contact.displayName}</span>
+                                </div>
+                                <div className="contact-post-count-wrap">
+                                    {isPostCountReady ? (
+                                        <span className="contact-post-count">{Math.max(0, Math.floor(Number(contact.postCount || 0)))}条</span>
+                                    ) : (
+                                        <span className="contact-post-count-loading" title="统计中">
+                                            <Loader2 size={13} className="spinning" />
+                                        </span>
+                                    )}
+                                </div>
                             </div>
-                        ))}
+                            )
+                        })}
                         {filteredContacts.length === 0 && (
-                            <div className="empty-state">没有找到联系人</div>
+                            <div className="empty-state">{getEmptyStateText()}</div>
                         )}
                     </div>
                 </div>

src/components/Sns/SnsPostItem.tsx

@@ -1,5 +1,6 @@
-import React, { useState, useMemo } from 'react'
-import { Heart, ChevronRight, ImageIcon, Download, Code, MoreHorizontal, Trash2 } from 'lucide-react'
+import React, { useState, useMemo, useEffect } from 'react'
+import { createPortal } from 'react-dom'
+import { Heart, ChevronRight, ImageIcon, Code, Trash2 } from 'lucide-react'
 import { SnsPost, SnsLinkCardData } from '../../types/sns'
 import { Avatar } from '../Avatar'
 import { SnsMediaGrid } from './SnsMediaGrid'
@@ -178,14 +179,80 @@ const SnsLinkCard = ({ card }: { card: SnsLinkCardData }) => {
     )
 }
 
+// 表情包内存缓存
+const emojiLocalCache = new Map<string, string>()
+
+// 评论表情包组件
+const CommentEmoji: React.FC<{
+    emoji: { url: string; md5: string; width: number; height: number; encryptUrl?: string; aesKey?: string }
+    onPreview?: (src: string) => void
+}> = ({ emoji, onPreview }) => {
+    const cacheKey = emoji.encryptUrl || emoji.url
+    const [localSrc, setLocalSrc] = useState<string>(() => emojiLocalCache.get(cacheKey) || '')
+
+    useEffect(() => {
+        if (!cacheKey) return
+        if (emojiLocalCache.has(cacheKey)) {
+            setLocalSrc(emojiLocalCache.get(cacheKey)!)
+            return
+        }
+        let cancelled = false
+        const load = async () => {
+            try {
+                const res = await window.electronAPI.sns.downloadEmoji({
+                    url: emoji.url,
+                    encryptUrl: emoji.encryptUrl,
+                    aesKey: emoji.aesKey
+                })
+                if (cancelled) return
+                if (res.success && res.localPath) {
+                    const fileUrl = res.localPath.startsWith('file:')
+                        ? res.localPath
+                        : `file://${res.localPath.replace(/\\/g, '/')}`
+                    emojiLocalCache.set(cacheKey, fileUrl)
+                    setLocalSrc(fileUrl)
+                }
+            } catch { /* 静默失败 */ }
+        }
+        load()
+        return () => { cancelled = true }
+    }, [cacheKey])
+
+    if (!localSrc) return null
+
+    return (
+        <img
+            src={localSrc}
+            alt="emoji"
+            className="comment-custom-emoji"
+            draggable={false}
+            onClick={(e) => { e.stopPropagation(); onPreview?.(localSrc) }}
+            style={{
+                width: Math.min(emoji.width || 24, 30),
+                height: Math.min(emoji.height || 24, 30),
+                verticalAlign: 'middle',
+                marginLeft: 2,
+                borderRadius: 4,
+                cursor: onPreview ? 'pointer' : 'default'
+            }}
+        />
+    )
+}
+
 interface SnsPostItemProps {
     post: SnsPost
     onPreview: (src: string, isVideo?: boolean, liveVideoPath?: string) => void
     onDebug: (post: SnsPost) => void
+    onDelete?: (postId: string, username: string) => void
+    onOpenAuthorPosts?: (post: SnsPost) => void
+    hideAuthorMeta?: boolean
 }
 
-export const SnsPostItem: React.FC<SnsPostItemProps> = ({ post, onPreview, onDebug }) => {
+export const SnsPostItem: React.FC<SnsPostItemProps> = ({ post, onPreview, onDebug, onDelete, onOpenAuthorPosts, hideAuthorMeta = false }) => {
     const [mediaDeleted, setMediaDeleted] = useState(false)
+    const [dbDeleted, setDbDeleted] = useState(false)
+    const [deleting, setDeleting] = useState(false)
+    const [showDeleteConfirm, setShowDeleteConfirm] = useState(false)
     const linkCard = buildLinkCardData(post)
     const hasVideoMedia = post.type === 15 || post.media.some((item) => isSnsVideoUrl(item.url))
     const showLinkCard = Boolean(linkCard) && post.media.length <= 1 && !hasVideoMedia
@@ -221,30 +288,84 @@ export const SnsPostItem: React.FC<SnsPostItemProps> = ({ post, onPreview, onDeb
         })
     }
 
+    const handleDeleteClick = (e: React.MouseEvent) => {
+        e.stopPropagation()
+        if (deleting || dbDeleted) return
+        setShowDeleteConfirm(true)
+    }
+
+    const handleDeleteConfirm = async () => {
+        setShowDeleteConfirm(false)
+        setDeleting(true)
+        try {
+            const r = await window.electronAPI.sns.deleteSnsPost(post.tid ?? post.id)
+            if (r.success) {
+                setDbDeleted(true)
+                onDelete?.(post.id, post.username)
+            }
+        } finally {
+            setDeleting(false)
+        }
+    }
+
+    const handleOpenAuthorPosts = (e: React.MouseEvent) => {
+        e.stopPropagation()
+        onOpenAuthorPosts?.(post)
+    }
+
     return (
-        <div className={`sns-post-item ${mediaDeleted ? 'post-deleted' : ''}`}>
-            <div className="post-avatar-col">
-                <Avatar
-                    src={post.avatarUrl}
-                    name={post.nickname}
-                    size={48}
-                    shape="rounded"
-                />
-            </div>
+        <>
+        <div className={`sns-post-item ${(mediaDeleted || dbDeleted) ? 'post-deleted' : ''}`}>
+            {!hideAuthorMeta && (
+                <div className="post-avatar-col">
+                    <button
+                        type="button"
+                        className="author-trigger-btn avatar-trigger"
+                        onClick={handleOpenAuthorPosts}
+                        title="查看该发布者的全部朋友圈"
+                    >
+                        <Avatar
+                            src={post.avatarUrl}
+                            name={post.nickname}
+                            size={48}
+                            shape="rounded"
+                        />
+                    </button>
+                </div>
+            )}
 
             <div className="post-content-col">
                 <div className="post-header-row">
-                    <div className="post-author-info">
-                        <span className="author-name">{decodeHtmlEntities(post.nickname)}</span>
-                        <span className="post-time">{formatTime(post.createTime)}</span>
-                    </div>
+                    {hideAuthorMeta ? (
+                        <span className="post-time post-time-standalone">{formatTime(post.createTime)}</span>
+                    ) : (
+                        <div className="post-author-info">
+                            <button
+                                type="button"
+                                className="author-trigger-btn author-name-trigger"
+                                onClick={handleOpenAuthorPosts}
+                                title="查看该发布者的全部朋友圈"
+                            >
+                                <span className="author-name">{decodeHtmlEntities(post.nickname)}</span>
+                            </button>
+                            <span className="post-time">{formatTime(post.createTime)}</span>
+                        </div>
+                    )}
                     <div className="post-header-actions">
-                        {mediaDeleted && (
+                        {(mediaDeleted || dbDeleted) && (
                             <span className="post-deleted-badge">
                                 <Trash2 size={12} />
                                 <span>已删除</span>
                             </span>
                         )}
+                        <button
+                            className="icon-btn-ghost debug-btn delete-btn"
+                            onClick={handleDeleteClick}
+                            disabled={deleting || dbDeleted}
+                            title="从数据库删除此条记录"
+                        >
+                            <Trash2 size={14} />
+                        </button>
                         <button className="icon-btn-ghost debug-btn" onClick={(e) => {
                             e.stopPropagation();
                             onDebug(post);
@@ -289,7 +410,16 @@ export const SnsPostItem: React.FC<SnsPostItemProps> = ({ post, onPreview, onDeb
                                             </>
                                         )}
                                         <span className="comment-colon">：</span>
-                                        <span className="comment-content">{renderTextWithEmoji(c.content)}</span>
+                                        {c.content && (
+                                            <span className="comment-content">{renderTextWithEmoji(c.content)}</span>
+                                        )}
+                                        {c.emojis && c.emojis.map((emoji, ei) => (
+                                            <CommentEmoji
+                                                key={ei}
+                                                emoji={emoji}
+                                                onPreview={(src) => onPreview(src)}
+                                            />
+                                        ))}
                                     </div>
                                 ))}
                             </div>
@@ -298,5 +428,24 @@ export const SnsPostItem: React.FC<SnsPostItemProps> = ({ post, onPreview, onDeb
                 )}
             </div>
         </div>
+
+        {/* 删除确认弹窗 - 用 Portal 挂到 body，避免父级 transform 影响 fixed 定位 */}
+        {showDeleteConfirm && createPortal(
+            <div className="sns-confirm-overlay" onClick={() => setShowDeleteConfirm(false)}>
+                <div className="sns-confirm-dialog" onClick={(e) => e.stopPropagation()}>
+                    <div className="sns-confirm-icon">
+                        <Trash2 size={22} />
+                    </div>
+                    <div className="sns-confirm-title">删除这条记录？</div>
+                    <div className="sns-confirm-desc">将从本地数据库中永久删除，无法恢复。</div>
+                    <div className="sns-confirm-actions">
+                        <button className="sns-confirm-cancel" onClick={() => setShowDeleteConfirm(false)}>取消</button>
+                        <button className="sns-confirm-ok" onClick={handleDeleteConfirm}>删除</button>
+                    </div>
+                </div>
+            </div>,
+            document.body
+        )}
+        </>
     )
 }

src/components/Sns/contactSnsTimeline.ts

@@ -0,0 +1,26 @@
+export interface ContactSnsTimelineTarget {
+  username: string
+  displayName: string
+  avatarUrl?: string
+}
+
+export interface ContactSnsRankItem {
+  name: string
+  count: number
+  latestTime: number
+}
+
+export type ContactSnsRankMode = 'likes' | 'comments'
+
+export const isSingleContactSession = (sessionId: string): boolean => {
+  const normalized = String(sessionId || '').trim()
+  if (!normalized) return false
+  if (normalized.includes('@chatroom')) return false
+  if (normalized.startsWith('gh_')) return false
+  return true
+}
+
+export const getAvatarLetter = (name: string): string => {
+  if (!name) return '?'
+  return [...name][0] || '?'
+}

src/components/TitleBar.scss

@@ -10,6 +10,12 @@
   gap: 8px;
 }
 
+// 繁花如梦：标题栏毛玻璃
+[data-theme="blossom-dream"] .title-bar {
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+}
+
 .title-logo {
   width: 20px;
   height: 20px;

src/pages/AnnualReportPage.scss

@@ -26,6 +26,48 @@
   margin: 0 0 48px;
 }
 
+.page-desc.load-summary {
+  margin: 0 0 28px;
+}
+
+.page-desc.load-summary.complete {
+  color: var(--text-secondary);
+}
+
+.load-telemetry {
+  width: min(760px, 100%);
+  padding: 12px 14px;
+  margin: 0 0 28px;
+  border-radius: 12px;
+  border: 1px solid color-mix(in srgb, var(--border-color) 80%, transparent);
+  background: color-mix(in srgb, var(--card-bg) 92%, transparent);
+  text-align: left;
+  font-size: 13px;
+  color: var(--text-secondary);
+  line-height: 1.5;
+
+  p {
+    margin: 4px 0;
+  }
+
+  .label {
+    color: var(--text-tertiary);
+  }
+}
+
+.load-telemetry.loading {
+  border-color: color-mix(in srgb, var(--primary) 30%, var(--border-color));
+}
+
+.load-telemetry.complete {
+  border-color: color-mix(in srgb, var(--primary) 40%, var(--border-color));
+}
+
+.load-telemetry.compact {
+  margin: 12px 0 0;
+  width: min(560px, 100%);
+}
+
 .report-sections {
   display: flex;
   flex-direction: column;
@@ -83,6 +125,14 @@
   color: var(--text-tertiary);
 }
 
+.year-grid-with-status {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+  margin-bottom: 24px;
+}
+
 .year-grid {
   display: flex;
   flex-wrap: wrap;
@@ -95,7 +145,39 @@
 .report-section .year-grid {
   justify-content: flex-start;
   max-width: none;
-  margin-bottom: 24px;
+  margin-bottom: 0;
+}
+
+.year-grid-with-status .year-grid {
+  flex: 1;
+}
+
+.year-load-status {
+  display: inline-flex;
+  align-items: center;
+  font-size: 12px;
+  color: var(--text-tertiary);
+  white-space: nowrap;
+  margin-top: 6px;
+  flex-shrink: 0;
+}
+
+.year-load-status.complete {
+  color: color-mix(in srgb, var(--primary) 80%, var(--text-secondary));
+}
+
+.dot-ellipsis {
+  display: inline-block;
+  width: 0;
+  overflow: hidden;
+  vertical-align: bottom;
+  animation: dot-ellipsis 1.2s steps(4, end) infinite;
+}
+
+.year-load-status.complete .dot-ellipsis,
+.page-desc.load-summary.complete .dot-ellipsis {
+  animation: none;
+  width: 0;
 }
 
 .year-card {
@@ -185,3 +267,7 @@
   from { transform: rotate(0deg); }
   to { transform: rotate(360deg); }
 }
+
+@keyframes dot-ellipsis {
+  to { width: 1.4em; }
+}

src/pages/AnnualReportPage.tsx

@@ -4,6 +4,28 @@ import { Calendar, Loader2, Sparkles, Users } from 'lucide-react'
 import './AnnualReportPage.scss'
 
 type YearOption = number | 'all'
+type YearsLoadPayload = {
+  years?: number[]
+  done: boolean
+  error?: string
+  canceled?: boolean
+  strategy?: 'cache' | 'native' | 'hybrid'
+  phase?: 'cache' | 'native' | 'scan' | 'done'
+  statusText?: string
+  nativeElapsedMs?: number
+  scanElapsedMs?: number
+  totalElapsedMs?: number
+  switched?: boolean
+  nativeTimedOut?: boolean
+}
+
+const formatLoadElapsed = (ms: number) => {
+  const totalSeconds = Math.max(0, ms) / 1000
+  if (totalSeconds < 60) return `${totalSeconds.toFixed(1)}s`
+  const minutes = Math.floor(totalSeconds / 60)
+  const seconds = Math.floor(totalSeconds % 60)
+  return `${minutes}m ${String(seconds).padStart(2, '0')}s`
+}
 
 function AnnualReportPage() {
   const navigate = useNavigate()
@@ -11,32 +33,117 @@ function AnnualReportPage() {
   const [selectedYear, setSelectedYear] = useState<YearOption | null>(null)
   const [selectedPairYear, setSelectedPairYear] = useState<YearOption | null>(null)
   const [isLoading, setIsLoading] = useState(true)
+  const [isLoadingMoreYears, setIsLoadingMoreYears] = useState(false)
+  const [hasYearsLoadFinished, setHasYearsLoadFinished] = useState(false)
+  const [loadStrategy, setLoadStrategy] = useState<'cache' | 'native' | 'hybrid'>('native')
+  const [loadPhase, setLoadPhase] = useState<'cache' | 'native' | 'scan' | 'done'>('native')
+  const [loadStatusText, setLoadStatusText] = useState('准备加载年份数据...')
+  const [nativeElapsedMs, setNativeElapsedMs] = useState(0)
+  const [scanElapsedMs, setScanElapsedMs] = useState(0)
+  const [totalElapsedMs, setTotalElapsedMs] = useState(0)
+  const [hasSwitchedStrategy, setHasSwitchedStrategy] = useState(false)
+  const [nativeTimedOut, setNativeTimedOut] = useState(false)
   const [isGenerating, setIsGenerating] = useState(false)
   const [loadError, setLoadError] = useState<string | null>(null)
 
   useEffect(() => {
-    loadAvailableYears()
-  }, [])
+    let disposed = false
+    let taskId = ''
 
-  const loadAvailableYears = async () => {
-    setIsLoading(true)
-    setLoadError(null)
-    try {
-      const result = await window.electronAPI.annualReport.getAvailableYears()
-      if (result.success && result.data && result.data.length > 0) {
-        setAvailableYears(result.data)
-        setSelectedYear((prev) => prev ?? result.data[0])
-        setSelectedPairYear((prev) => prev ?? result.data[0])
-      } else if (!result.success) {
-        setLoadError(result.error || '加载年度数据失败')
+    const applyLoadPayload = (payload: YearsLoadPayload) => {
+      if (payload.strategy) setLoadStrategy(payload.strategy)
+      if (payload.phase) setLoadPhase(payload.phase)
+      if (typeof payload.statusText === 'string' && payload.statusText) setLoadStatusText(payload.statusText)
+      if (typeof payload.nativeElapsedMs === 'number' && Number.isFinite(payload.nativeElapsedMs)) {
+        setNativeElapsedMs(Math.max(0, payload.nativeElapsedMs))
+      }
+      if (typeof payload.scanElapsedMs === 'number' && Number.isFinite(payload.scanElapsedMs)) {
+        setScanElapsedMs(Math.max(0, payload.scanElapsedMs))
+      }
+      if (typeof payload.totalElapsedMs === 'number' && Number.isFinite(payload.totalElapsedMs)) {
+        setTotalElapsedMs(Math.max(0, payload.totalElapsedMs))
+      }
+      if (typeof payload.switched === 'boolean') setHasSwitchedStrategy(payload.switched)
+      if (typeof payload.nativeTimedOut === 'boolean') setNativeTimedOut(payload.nativeTimedOut)
+
+      const years = Array.isArray(payload.years) ? payload.years : []
+      if (years.length > 0) {
+        setAvailableYears(years)
+        setSelectedYear((prev) => {
+          if (prev === 'all') return prev
+          if (typeof prev === 'number' && years.includes(prev)) return prev
+          return years[0]
+        })
+        setSelectedPairYear((prev) => {
+          if (prev === 'all') return prev
+          if (typeof prev === 'number' && years.includes(prev)) return prev
+          return years[0]
+        })
+        setIsLoading(false)
+      }
+
+      if (payload.error && !payload.canceled) {
+        setLoadError(payload.error || '加载年度数据失败')
+      }
+
+      if (payload.done) {
+        setIsLoading(false)
+        setIsLoadingMoreYears(false)
+        setHasYearsLoadFinished(true)
+        setLoadPhase('done')
+      } else {
+        setIsLoadingMoreYears(true)
+        setHasYearsLoadFinished(false)
       }
-    } catch (e) {
-      console.error(e)
-      setLoadError(String(e))
-    } finally {
-      setIsLoading(false)
     }
-  }
+
+    const stopListen = window.electronAPI.annualReport.onAvailableYearsProgress((payload) => {
+      if (disposed) return
+      if (taskId && payload.taskId !== taskId) return
+      if (!taskId) taskId = payload.taskId
+      applyLoadPayload(payload)
+    })
+
+    const startLoad = async () => {
+      setIsLoading(true)
+      setIsLoadingMoreYears(true)
+      setHasYearsLoadFinished(false)
+      setLoadStrategy('native')
+      setLoadPhase('native')
+      setLoadStatusText('准备使用原生快速模式加载年份...')
+      setNativeElapsedMs(0)
+      setScanElapsedMs(0)
+      setTotalElapsedMs(0)
+      setHasSwitchedStrategy(false)
+      setNativeTimedOut(false)
+      setLoadError(null)
+      try {
+        const startResult = await window.electronAPI.annualReport.startAvailableYearsLoad()
+        if (!startResult.success || !startResult.taskId) {
+          setLoadError(startResult.error || '加载年度数据失败')
+          setIsLoading(false)
+          setIsLoadingMoreYears(false)
+          return
+        }
+        taskId = startResult.taskId
+        if (startResult.snapshot) {
+          applyLoadPayload(startResult.snapshot)
+        }
+      } catch (e) {
+        console.error(e)
+        setLoadError(String(e))
+        setIsLoading(false)
+        setIsLoadingMoreYears(false)
+      }
+    }
+
+    void startLoad()
+
+    return () => {
+      disposed = true
+      stopListen()
+    }
+  }, [])
 
   const handleGenerateReport = async () => {
     if (selectedYear === null) return
@@ -57,16 +164,25 @@ function AnnualReportPage() {
     navigate(`/dual-report?year=${yearParam}`)
   }
 
-  if (isLoading) {
+  if (isLoading && availableYears.length === 0) {
     return (
       <div className="annual-report-page">
         <Loader2 size={32} className="spin" style={{ color: 'var(--text-tertiary)' }} />
-        <p style={{ color: 'var(--text-tertiary)', marginTop: 16 }}>正在加载年份数据...</p>
+        <p style={{ color: 'var(--text-tertiary)', marginTop: 16 }}>正在加载年份数据（首批）...</p>
+        <div className="load-telemetry compact">
+          <p><span className="label">加载方式：</span>{getStrategyLabel({ loadStrategy, loadPhase, hasYearsLoadFinished, hasSwitchedStrategy, nativeTimedOut })}</p>
+          <p><span className="label">状态：</span>{loadStatusText || '正在加载年份数据...'}</p>
+          <p>
+            <span className="label">原生耗时：</span>{formatLoadElapsed(nativeElapsedMs)}{nativeTimedOut ? '（超时）' : ''} ｜{' '}
+            <span className="label">扫表耗时：</span>{formatLoadElapsed(scanElapsedMs)} ｜{' '}
+            <span className="label">总耗时：</span>{formatLoadElapsed(totalElapsedMs)}
+          </p>
+        </div>
       </div>
     )
   }
 
-  if (availableYears.length === 0) {
+  if (availableYears.length === 0 && !isLoadingMoreYears) {
     return (
       <div className="annual-report-page">
         <Calendar size={64} style={{ color: 'var(--text-tertiary)', opacity: 0.5 }} />
@@ -87,11 +203,50 @@ function AnnualReportPage() {
     return value === 'all' ? '全部时间' : `${value} 年`
   }
 
+  const loadedYearCount = availableYears.length
+  const isYearStatusComplete = hasYearsLoadFinished
+  const strategyLabel = getStrategyLabel({ loadStrategy, loadPhase, hasYearsLoadFinished, hasSwitchedStrategy, nativeTimedOut })
+  const renderYearLoadStatus = () => (
+    <div className={`year-load-status ${isYearStatusComplete ? 'complete' : 'loading'}`}>
+      {isYearStatusComplete ? (
+        <>全部年份已加载完毕</>
+      ) : (
+        <>
+          更多年份加载中<span className="dot-ellipsis" aria-hidden="true">...</span>
+        </>
+      )}
+    </div>
+  )
+
   return (
     <div className="annual-report-page">
       <Sparkles size={32} className="header-icon" />
       <h1 className="page-title">年度报告</h1>
       <p className="page-desc">选择年份，回顾你在微信里的点点滴滴</p>
+      {loadedYearCount > 0 && (
+        <p className={`page-desc load-summary ${isYearStatusComplete ? 'complete' : 'loading'}`}>
+          {isYearStatusComplete ? (
+            <>已显示 {loadedYearCount} 个年份，年份数据已全部加载完毕。总耗时 {formatLoadElapsed(totalElapsedMs)}</>
+          ) : (
+            <>
+              已显示 {loadedYearCount} 个年份，正在补充更多年份<span className="dot-ellipsis" aria-hidden="true">...</span>
+              （已耗时 {formatLoadElapsed(totalElapsedMs)}）
+            </>
+          )}
+        </p>
+      )}
+      <div className={`load-telemetry ${isYearStatusComplete ? 'complete' : 'loading'}`}>
+        <p><span className="label">加载方式：</span>{strategyLabel}</p>
+        <p>
+          <span className="label">状态：</span>
+          {loadStatusText || (isYearStatusComplete ? '全部年份已加载完毕' : '正在加载年份数据...')}
+        </p>
+        <p>
+          <span className="label">原生耗时：</span>{formatLoadElapsed(nativeElapsedMs)}{nativeTimedOut ? '（超时）' : ''} ｜{' '}
+          <span className="label">扫表耗时：</span>{formatLoadElapsed(scanElapsedMs)} ｜{' '}
+          <span className="label">总耗时：</span>{formatLoadElapsed(totalElapsedMs)}
+        </p>
+      </div>
 
       <div className="report-sections">
         <section className="report-section">
@@ -102,17 +257,20 @@ function AnnualReportPage() {
             </div>
           </div>
 
-          <div className="year-grid">
-            {yearOptions.map(option => (
-              <div
-                key={option}
-                className={`year-card ${option === 'all' ? 'all-time' : ''} ${selectedYear === option ? 'selected' : ''}`}
-                onClick={() => setSelectedYear(option)}
-              >
-                <span className="year-number">{option === 'all' ? '全部' : option}</span>
-                <span className="year-label">{option === 'all' ? '时间' : '年'}</span>
-              </div>
-            ))}
+          <div className="year-grid-with-status">
+            <div className="year-grid">
+              {yearOptions.map(option => (
+                <div
+                  key={option}
+                  className={`year-card ${option === 'all' ? 'all-time' : ''} ${selectedYear === option ? 'selected' : ''}`}
+                  onClick={() => setSelectedYear(option)}
+                >
+                  <span className="year-number">{option === 'all' ? '全部' : option}</span>
+                  <span className="year-label">{option === 'all' ? '时间' : '年'}</span>
+                </div>
+              ))}
+            </div>
+            {renderYearLoadStatus()}
           </div>
 
           <button
@@ -146,17 +304,20 @@ function AnnualReportPage() {
             </div>
           </div>
 
-          <div className="year-grid">
-            {yearOptions.map(option => (
-              <div
-                key={`pair-${option}`}
-                className={`year-card ${option === 'all' ? 'all-time' : ''} ${selectedPairYear === option ? 'selected' : ''}`}
-                onClick={() => setSelectedPairYear(option)}
-              >
-                <span className="year-number">{option === 'all' ? '全部' : option}</span>
-                <span className="year-label">{option === 'all' ? '时间' : '年'}</span>
-              </div>
-            ))}
+          <div className="year-grid-with-status">
+            <div className="year-grid">
+              {yearOptions.map(option => (
+                <div
+                  key={`pair-${option}`}
+                  className={`year-card ${option === 'all' ? 'all-time' : ''} ${selectedPairYear === option ? 'selected' : ''}`}
+                  onClick={() => setSelectedPairYear(option)}
+                >
+                  <span className="year-number">{option === 'all' ? '全部' : option}</span>
+                  <span className="year-label">{option === 'all' ? '时间' : '年'}</span>
+                </div>
+              ))}
+            </div>
+            {renderYearLoadStatus()}
           </div>
 
           <button
@@ -174,4 +335,23 @@ function AnnualReportPage() {
   )
 }
 
+function getStrategyLabel(params: {
+  loadStrategy: 'cache' | 'native' | 'hybrid'
+  loadPhase: 'cache' | 'native' | 'scan' | 'done'
+  hasYearsLoadFinished: boolean
+  hasSwitchedStrategy: boolean
+  nativeTimedOut: boolean
+}): string {
+  const { loadStrategy, loadPhase, hasYearsLoadFinished, hasSwitchedStrategy, nativeTimedOut } = params
+  if (loadStrategy === 'cache') return '缓存模式（快速）'
+  if (hasYearsLoadFinished) {
+    if (loadStrategy === 'native') return '原生快速模式'
+    if (hasSwitchedStrategy || nativeTimedOut) return '混合策略（原生→扫表）'
+    return '扫表兼容模式'
+  }
+  if (loadPhase === 'native') return '原生快速模式（优先）'
+  if (loadPhase === 'scan') return '扫表兼容模式（回退）'
+  return '混合策略'
+}
+
 export default AnnualReportPage

src/pages/ChatPage.scss

@@ -490,6 +490,18 @@
           gap: 8px;
           -webkit-app-region: no-drag;
 
+          .jump-calendar-anchor {
+            position: relative;
+            display: flex;
+            align-items: center;
+            isolation: isolate;
+            z-index: 20;
+
+            .jump-date-popover {
+              z-index: 2600;
+            }
+          }
+
           .icon-btn {
             width: 34px;
             height: 34px;
@@ -534,6 +546,22 @@
         overflow: hidden;
       }
 
+      .export-prepare-hint {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        padding: 8px 24px;
+        font-size: 12px;
+        color: var(--text-secondary);
+        border-bottom: 1px solid var(--border-color);
+        background: var(--bg-tertiary);
+        -webkit-app-region: no-drag;
+
+        .spin {
+          animation: spin 1s linear infinite;
+        }
+      }
+
       .message-list {
         flex: 1;
         background: var(--chat-pattern);
@@ -815,6 +843,24 @@
     min-width: 0;
   }
 
+  .session-sync-indicator {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    padding: 4px 8px;
+    border-radius: 999px;
+    background: var(--bg-primary);
+    color: var(--text-tertiary);
+    font-size: 11px;
+    white-space: nowrap;
+    border: 1px solid var(--border-color);
+    flex-shrink: 0;
+
+    .spin {
+      animation: spin 0.9s linear infinite;
+    }
+  }
+
   .search-box {
     flex: 1;
     display: flex;
@@ -866,6 +912,73 @@
   }
 }
 
+// Header 双 panel 滑动动画
+.session-header-viewport {
+  overflow: hidden;
+  position: relative;
+  display: flex;
+  flex-direction: row;
+  width: 100%;
+
+  .session-header-panel {
+    flex: 0 0 100%;
+    width: 100%;
+    display: flex;
+    align-items: center;
+    padding: 16px 16px 12px;
+    min-height: 56px;
+    transition: transform 0.28s cubic-bezier(0.4, 0, 0.2, 1);
+  }
+
+  .main-header {
+    transform: translateX(0);
+    justify-content: space-between;
+  }
+
+  .folded-header {
+    transform: translateX(0);
+  }
+
+  &.folded {
+    .main-header { transform: translateX(-100%); }
+    .folded-header { transform: translateX(-100%); }
+  }
+}
+
+.folded-view-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+
+  .back-btn {
+    width: 32px;
+    height: 32px;
+    border: none;
+    background: transparent;
+    border-radius: 6px;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--text-secondary);
+    flex-shrink: 0;
+
+    &:hover {
+      background: var(--bg-hover);
+    }
+  }
+
+  .folded-view-title {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--text-primary);
+  }
+}
+
 @keyframes searchExpand {
   from {
     opacity: 0;
@@ -1525,6 +1638,13 @@
     display: flex;
     align-items: center;
     gap: 8px;
+
+    .jump-calendar-anchor {
+      position: relative;
+      display: flex;
+      align-items: center;
+      isolation: isolate;
+    }
   }
 
   .icon-btn {
@@ -1557,6 +1677,10 @@
       opacity: 0.5;
       cursor: not-allowed;
     }
+
+    .spin {
+      animation: spin 1s linear infinite;
+    }
   }
 }
 
@@ -1584,6 +1708,33 @@
     opacity: 0;
     pointer-events: none;
   }
+
+  &.switching .message-list {
+    opacity: 0.42;
+    transform: scale(0.995);
+    filter: saturate(0.72) blur(1px);
+    pointer-events: none;
+  }
+
+  &.switching .loading-overlay {
+    background: rgba(127, 127, 127, 0.18);
+    backdrop-filter: blur(4px);
+  }
+}
+
+.export-prepare-hint {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 8px 20px;
+  font-size: 12px;
+  color: var(--text-secondary);
+  border-bottom: 1px solid var(--border-color);
+  background: var(--bg-tertiary);
+
+  .spin {
+    animation: spin 1s linear infinite;
+  }
 }
 
 .message-list {
@@ -1599,7 +1750,7 @@
   background-color: var(--bg-tertiary);
   position: relative;
   -webkit-app-region: no-drag !important;
-  transition: opacity 240ms ease, transform 240ms ease;
+  transition: opacity 240ms ease, transform 240ms ease, filter 220ms ease;
 
   // 滚动条样式
   &::-webkit-scrollbar {
@@ -1632,6 +1783,30 @@
   z-index: 2;
 }
 
+.standalone-phase-overlay {
+  position: absolute;
+  inset: 0;
+  z-index: 3;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+  background: color-mix(in srgb, var(--bg-tertiary) 82%, transparent);
+  color: var(--text-secondary);
+  font-size: 14px;
+  pointer-events: none;
+
+  .spin {
+    animation: spin 1s linear infinite;
+  }
+
+  small {
+    color: var(--text-tertiary);
+    font-size: 12px;
+  }
+}
+
 .empty-chat-inline {
   display: flex;
   flex-direction: column;
@@ -2243,6 +2418,18 @@
   .quoted-text {
     color: var(--text-secondary);
     white-space: pre-wrap;
+
+    .quoted-type-label {
+      font-style: italic;
+      opacity: 0.8;
+    }
+
+    .quoted-emoji-image {
+      width: 40px;
+      height: 40px;
+      vertical-align: middle;
+      object-fit: contain;
+    }
   }
 }
 
@@ -2583,6 +2770,13 @@
         opacity: 0.7;
       }
     }
+
+    .detail-stats-meta {
+      margin-top: -6px;
+      margin-bottom: 10px;
+      font-size: 12px;
+      color: var(--text-tertiary);
+    }
   }
 
   .detail-item {
@@ -2620,6 +2814,26 @@
       }
     }
 
+    .detail-inline-btn {
+      border: none;
+      background: var(--bg-secondary);
+      color: var(--primary);
+      border-radius: 6px;
+      padding: 4px 8px;
+      font-size: 12px;
+      line-height: 1;
+      cursor: pointer;
+
+      &:disabled {
+        cursor: not-allowed;
+        opacity: 0.7;
+      }
+
+      &:hover:not(:disabled) {
+        background: var(--bg-hover);
+      }
+    }
+
     .copy-btn {
       display: flex;
       align-items: center;
@@ -2657,6 +2871,14 @@
     gap: 8px;
   }
 
+  .detail-table-placeholder {
+    padding: 10px 12px;
+    background: var(--bg-secondary);
+    border-radius: 8px;
+    font-size: 12px;
+    color: var(--text-secondary);
+  }
+
   .table-item {
     display: flex;
     align-items: center;
@@ -2678,6 +2900,188 @@
   }
 }
 
+.group-members-panel {
+  .group-members-toolbar {
+    padding: 12px 16px 10px;
+    border-bottom: 1px solid var(--border-color);
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+  }
+
+  .group-members-count {
+    font-size: 12px;
+    color: var(--text-secondary);
+  }
+
+  .group-members-search {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 10px;
+    background: var(--bg-secondary);
+
+    svg {
+      color: var(--text-tertiary);
+      flex-shrink: 0;
+    }
+
+    input {
+      flex: 1;
+      border: none;
+      outline: none;
+      background: transparent;
+      color: var(--text-primary);
+      font-size: 13px;
+
+      &::placeholder {
+        color: var(--text-tertiary);
+      }
+    }
+  }
+
+  .group-members-status {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 6px 16px;
+    font-size: 12px;
+    color: var(--text-secondary);
+    border-bottom: 1px solid var(--border-color);
+    background: var(--bg-secondary);
+
+    .spin {
+      animation: spin 1s linear infinite;
+    }
+
+    &.warning {
+      color: #b45309;
+      background: color-mix(in srgb, #f59e0b 10%, transparent);
+    }
+  }
+
+  .group-members-list {
+    flex: 1;
+    min-height: 0;
+    overflow-y: auto;
+    padding: 4px 0;
+
+    &::-webkit-scrollbar {
+      width: 4px;
+    }
+
+    &::-webkit-scrollbar-thumb {
+      background: var(--text-tertiary);
+      border-radius: 2px;
+    }
+  }
+
+  .group-member-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    padding: 10px 16px;
+    border-bottom: 1px solid var(--border-color);
+
+    &:last-child {
+      border-bottom: none;
+    }
+  }
+
+  .group-member-main {
+    min-width: 0;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    flex: 1;
+  }
+
+  .group-member-avatar {
+    flex-shrink: 0;
+  }
+
+  .group-member-meta {
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+  }
+
+  .group-member-name-row {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    min-width: 0;
+  }
+
+  .group-member-name {
+    font-size: 13px;
+    color: var(--text-primary);
+    max-width: 100%;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .group-member-id {
+    font-size: 11px;
+    color: var(--text-tertiary);
+    max-width: 100%;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .group-member-badges {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    flex-shrink: 0;
+  }
+
+  .member-flag {
+    width: 18px;
+    height: 18px;
+    border-radius: 9999px;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    border: 1px solid var(--border-color);
+
+    &.owner {
+      color: #f59e0b;
+      background: color-mix(in srgb, #f59e0b 16%, transparent);
+      border-color: color-mix(in srgb, #f59e0b 35%, var(--border-color));
+    }
+
+    &.friend {
+      color: var(--primary);
+      background: color-mix(in srgb, var(--primary) 14%, transparent);
+      border-color: color-mix(in srgb, var(--primary) 35%, var(--border-color));
+    }
+  }
+
+  .group-member-count {
+    flex-shrink: 0;
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-secondary);
+
+    &.loading {
+      color: var(--text-tertiary);
+      font-weight: 500;
+    }
+
+    &.failed {
+      color: #b45309;
+      font-weight: 600;
+    }
+  }
+}
+
 @keyframes slideInRight {
   from {
     opacity: 0;
@@ -2897,7 +3301,6 @@
   display: flex;
   align-items: center;
   gap: 6px;
-  padding: 8px 12px;
   color: var(--text-secondary);
   font-size: 13px;
 
@@ -3253,9 +3656,12 @@
 // 批量转写模态框基础样式（共享样式在 styles/batchTranscribe.scss）
 
 // 批量转写确认对话框
-.batch-confirm-modal {
+.batch-modal-content.batch-confirm-modal {
   width: 480px;
   max-width: 90vw;
+  max-height: none;
+  overflow: visible;
+  overflow-y: visible;
 
   .batch-modal-header {
     display: flex;
@@ -3392,6 +3798,74 @@
           font-weight: 600;
           color: var(--primary-color);
         }
+
+        .batch-concurrency-field {
+          position: relative;
+
+          .batch-concurrency-trigger {
+            display: flex;
+            align-items: center;
+            gap: 6px;
+            padding: 6px 12px;
+            border-radius: 9999px;
+            border: 1px solid var(--border-color);
+            background: var(--bg-primary);
+            color: var(--text-primary);
+            font-size: 13px;
+            cursor: pointer;
+
+            &:hover {
+              border-color: var(--text-tertiary);
+            }
+
+            &.open {
+              border-color: var(--primary);
+            }
+
+            svg {
+              color: var(--text-tertiary);
+              transition: transform 0.2s;
+            }
+
+            &.open svg {
+              transform: rotate(180deg);
+            }
+          }
+
+          .batch-concurrency-dropdown {
+            position: absolute;
+            top: calc(100% + 6px);
+            right: 0;
+            min-width: 180px;
+            background: color-mix(in srgb, var(--bg-primary) 90%, var(--bg-secondary));
+            border: 1px solid var(--border-color);
+            border-radius: 12px;
+            padding: 6px;
+            box-shadow: 0 8px 24px rgba(0, 0, 0, 0.12);
+            z-index: 100;
+          }
+
+          .batch-concurrency-option {
+            width: 100%;
+            text-align: left;
+            padding: 8px 12px;
+            border: none;
+            border-radius: 8px;
+            background: transparent;
+            color: var(--text-primary);
+            font-size: 13px;
+            cursor: pointer;
+
+            &:hover {
+              background: var(--bg-tertiary);
+            }
+
+            &.active {
+              color: var(--primary);
+              font-weight: 500;
+            }
+          }
+        }
       }
     }
 
@@ -3449,7 +3923,7 @@
       &.btn-primary,
       &.batch-transcribe-start-btn {
         background: var(--primary-color);
-        color: white;
+        color: #000;
 
         &:hover {
           opacity: 0.9;
@@ -3852,4 +4326,300 @@
       overflow: hidden;
     }
   }
-}
+}
+
+// 折叠群视图 header
+.folded-view-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 0 4px;
+  width: 100%;
+
+  .back-btn {
+    flex-shrink: 0;
+    color: var(--text-secondary);
+    &:hover {
+      color: var(--text-primary);
+    }
+  }
+
+  .folded-view-title {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 14px;
+    font-weight: 500;
+    color: var(--text-primary);
+  }
+}
+
+// 双 panel 滑动容器
+.session-list-viewport {
+  flex: 1;
+  overflow: hidden;
+  position: relative;
+  display: flex;
+  flex-direction: row;
+  // 两个 panel 并排，宽度各 100%，通过 translateX 切换
+  width: 100%;
+
+  .session-list-panel {
+    flex: 0 0 100%;
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    transition: transform 0.28s cubic-bezier(0.4, 0, 0.2, 1);
+  }
+
+  // 默认：main 在视口内，folded 在右侧外
+  .main-panel {
+    transform: translateX(0);
+  }
+  .folded-panel {
+    transform: translateX(0);
+  }
+
+  // 切换到折叠群视图：两个 panel 同时左移 100%
+  &.folded {
+    .main-panel {
+      transform: translateX(-100%);
+    }
+    .folded-panel {
+      transform: translateX(-100%);
+    }
+  }
+
+  .session-list {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: hidden;
+
+    &::-webkit-scrollbar {
+      width: 8px;
+    }
+    &::-webkit-scrollbar-track {
+      background: transparent;
+    }
+    &::-webkit-scrollbar-thumb {
+      background: rgba(0, 0, 0, 0.2);
+      border-radius: 4px;
+      &:hover {
+        background: rgba(0, 0, 0, 0.3);
+      }
+    }
+  }
+}
+
+// 免打扰标识
+.session-item {
+  &.muted {
+    .session-name {
+      color: var(--text-secondary);
+    }
+  }
+
+  .session-badges {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    flex-shrink: 0;
+
+    .mute-icon {
+      color: var(--text-tertiary, #aaa);
+      opacity: 0.7;
+    }
+
+    .unread-badge.muted {
+      background: var(--text-tertiary, #aaa);
+      box-shadow: none;
+    }
+  }
+}
+
+// 折叠群入口样式
+.session-item.fold-entry {
+  background: var(--card-inner-bg, rgba(0,0,0,0.03));
+
+  .fold-entry-avatar {
+    width: 48px;
+    height: 48px;
+    border-radius: 8px;
+    background: var(--primary-color, #07c160);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+    color: #fff;
+  }
+
+  .session-name {
+    font-weight: 500;
+  }
+}
+// 消息信息弹窗
+.message-info-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.4);
+  backdrop-filter: blur(4px);
+  z-index: 2000;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.message-info-modal {
+  width: 360px;
+  max-width: 90vw;
+  max-height: 80vh;
+  background: var(--card-bg);
+  border: 1px solid var(--border-color);
+  border-radius: 12px;
+  display: flex;
+  flex-direction: column;
+  box-shadow: 0 12px 40px rgba(0, 0, 0, 0.2);
+  overflow: hidden;
+
+  .detail-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 16px;
+    border-bottom: 1px solid var(--border-color);
+
+    h4 {
+      font-size: 15px;
+      font-weight: 600;
+      color: var(--text-primary);
+      margin: 0;
+    }
+
+    .close-btn {
+      background: none;
+      border: none;
+      padding: 4px;
+      cursor: pointer;
+      color: var(--text-secondary);
+      border-radius: 6px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+
+      &:hover {
+        background: var(--bg-hover);
+        color: var(--text-primary);
+      }
+    }
+  }
+
+  .detail-content {
+    flex: 1;
+    overflow-y: auto;
+    padding: 16px;
+
+    &::-webkit-scrollbar { width: 4px; }
+    &::-webkit-scrollbar-thumb { background: var(--text-tertiary); border-radius: 2px; }
+  }
+
+  .detail-section {
+    margin-bottom: 20px;
+    &:last-child { margin-bottom: 0; }
+
+    .section-title {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      font-size: 12px;
+      font-weight: 600;
+      color: var(--text-secondary);
+      margin-bottom: 12px;
+      letter-spacing: 0.5px;
+
+      svg { opacity: 0.7; }
+
+      .copy-btn {
+        margin-left: auto;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        width: 22px;
+        height: 22px;
+        padding: 0;
+        border: none;
+        border-radius: 4px;
+        background: transparent;
+        color: var(--text-tertiary);
+        cursor: pointer;
+        &:hover { background: var(--bg-secondary); color: var(--text-primary); }
+      }
+    }
+  }
+
+  .detail-item {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 0;
+    border-bottom: 1px solid var(--border-color);
+    font-size: 13px;
+
+    &:last-child { border-bottom: none; }
+
+    svg { color: var(--text-tertiary); flex-shrink: 0; }
+
+    .label { color: var(--text-secondary); flex-shrink: 0; }
+
+    .value {
+      flex: 1;
+      text-align: right;
+      color: var(--text-primary);
+      word-break: break-all;
+      user-select: text;
+
+      &.highlight { color: var(--primary); font-weight: 600; }
+      &.mono { font-family: 'Consolas', 'Monaco', monospace; font-size: 12px; }
+    }
+
+    .copy-btn {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      width: 22px;
+      height: 22px;
+      padding: 0;
+      border: none;
+      border-radius: 4px;
+      background: transparent;
+      color: var(--text-tertiary);
+      cursor: pointer;
+      flex-shrink: 0;
+      opacity: 0;
+      transition: opacity 0.15s, color 0.15s, background 0.15s;
+
+      &:hover { background: var(--bg-secondary); color: var(--text-primary); }
+      svg { color: inherit; }
+    }
+
+    &:hover .copy-btn { opacity: 1; }
+  }
+
+  .raw-content-box {
+    background: var(--bg-tertiary);
+    border-radius: 8px;
+    padding: 12px;
+    max-height: 200px;
+    overflow: auto;
+
+    pre {
+      margin: 0;
+      white-space: pre-wrap;
+      word-break: break-all;
+      font-family: 'Consolas', 'Monaco', monospace;
+      font-size: 12px;
+      color: var(--text-primary);
+      user-select: text;
+    }
+  }
+}

src/pages/ContactsPage.scss

@@ -148,6 +148,17 @@
       svg {
         opacity: 0.7;
         transition: transform 0.2s;
+        flex-shrink: 0;
+      }
+
+      .chip-label {
+        min-width: 0;
+      }
+
+      .chip-count {
+        margin-left: auto;
+        text-align: right;
+        font-variant-numeric: tabular-nums;
       }
 
       &:hover {
@@ -177,6 +188,22 @@
     padding: 0 20px 12px;
     font-size: 13px;
     color: var(--text-secondary);
+
+    .contacts-cache-meta {
+      margin-left: 10px;
+      color: var(--text-tertiary);
+      font-size: 12px;
+
+      &.syncing {
+        color: var(--primary);
+      }
+    }
+
+    .avatar-enrich-progress {
+      margin-left: 10px;
+      color: var(--text-tertiary);
+      font-size: 12px;
+    }
   }
 
   .selection-toolbar {
@@ -213,10 +240,103 @@
     }
   }
 
+  .load-issue-state {
+    flex: 1;
+    padding: 14px 14px 18px;
+    overflow-y: auto;
+  }
+
+  .issue-card {
+    border: 1px solid color-mix(in srgb, var(--danger, #ef4444) 45%, var(--border-color));
+    background: color-mix(in srgb, var(--danger, #ef4444) 8%, var(--card-bg));
+    border-radius: 12px;
+    padding: 14px;
+    color: var(--text-primary);
+
+    .issue-title {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      font-size: 14px;
+      font-weight: 600;
+      color: color-mix(in srgb, var(--danger, #ef4444) 85%, var(--text-primary));
+      margin-bottom: 8px;
+    }
+
+    .issue-message {
+      margin: 0 0 8px;
+      font-size: 13px;
+      color: var(--text-secondary);
+      line-height: 1.5;
+    }
+
+    .issue-reason {
+      margin: 0;
+      font-size: 13px;
+      color: var(--text-secondary);
+      line-height: 1.5;
+    }
+
+    .issue-hints {
+      margin: 10px 0 0;
+      padding-left: 18px;
+      font-size: 12px;
+      color: var(--text-tertiary);
+      line-height: 1.6;
+    }
+
+    .issue-actions {
+      margin-top: 12px;
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+    }
+
+    .issue-btn {
+      border: 1px solid var(--border-color);
+      background: var(--bg-secondary);
+      border-radius: 8px;
+      padding: 7px 10px;
+      font-size: 12px;
+      color: var(--text-secondary);
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      cursor: pointer;
+      transition: all 0.2s ease;
+
+      &:hover {
+        color: var(--text-primary);
+        border-color: var(--text-tertiary);
+        background: var(--bg-hover);
+      }
+
+      &.primary {
+        background: color-mix(in srgb, var(--primary) 14%, var(--bg-secondary));
+        border-color: color-mix(in srgb, var(--primary) 42%, var(--border-color));
+        color: var(--primary);
+      }
+    }
+
+    .issue-diagnostics {
+      margin-top: 12px;
+      border-radius: 8px;
+      background: var(--bg-primary);
+      border: 1px dashed var(--border-color);
+      padding: 10px;
+      font-size: 12px;
+      line-height: 1.5;
+      color: var(--text-secondary);
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+  }
+
   .contacts-list {
     flex: 1;
     overflow-y: auto;
     padding: 0 12px 12px;
+    position: relative;
 
     &::-webkit-scrollbar {
       width: 6px;
@@ -229,15 +349,31 @@
     }
   }
 
+  .contacts-list-virtual {
+    position: relative;
+    min-height: 100%;
+  }
+
+  .contact-row {
+    position: absolute;
+    left: 0;
+    right: 0;
+    height: 76px;
+    padding-bottom: 4px;
+    will-change: transform;
+  }
+
   .contact-item {
     display: flex;
     align-items: center;
     gap: 12px;
     padding: 12px;
+    height: 72px;
+    box-sizing: border-box;
     border-radius: 10px;
     transition: all 0.2s;
     cursor: pointer;
-    margin-bottom: 4px;
+    margin-bottom: 0;
 
     &:hover {
       background: var(--bg-hover);
@@ -399,6 +535,28 @@
       word-break: break-all;
       user-select: text;
     }
+
+    .detail-entry-btn {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      margin-left: auto;
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      background: var(--bg-secondary);
+      color: var(--text-primary);
+      padding: 6px 10px;
+      font-size: 12px;
+      line-height: 1;
+      cursor: pointer;
+      transition: border-color 0.2s ease, color 0.2s ease, background 0.2s ease;
+
+      &:hover {
+        color: var(--primary);
+        border-color: color-mix(in srgb, var(--primary) 45%, var(--border-color));
+        background: color-mix(in srgb, var(--primary) 8%, var(--bg-secondary));
+      }
+    }
   }
 
   .goto-chat-btn {

src/pages/DualReportWindow.tsx

@@ -107,7 +107,16 @@ function DualReportWindow() {
       setLoadingStage('完成')
 
       if (result.success && result.data) {
-        setReportData(result.data)
+        const normalizedResponse = result.data.response
+          ? {
+            ...result.data.response,
+            slowest: result.data.response.slowest ?? result.data.response.avg
+          }
+          : undefined
+        setReportData({
+          ...result.data,
+          response: normalizedResponse
+        })
         setIsLoading(false)
       } else {
         setError(result.error || '生成报告失败')

src/pages/GroupAnalyticsPage.tsx

@@ -30,7 +30,7 @@ interface GroupMessageRank {
 }
 
 type AnalysisFunction = 'members' | 'memberExport' | 'ranking' | 'activeHours' | 'mediaStats'
-type MemberExportFormat = 'chatlab' | 'chatlab-jsonl' | 'json' | 'html' | 'txt' | 'excel' | 'weclone'
+type MemberExportFormat = 'chatlab' | 'chatlab-jsonl' | 'json' | 'arkme-json' | 'html' | 'txt' | 'excel' | 'weclone'
 
 interface MemberMessageExportOptions {
   format: MemberExportFormat
@@ -119,6 +119,7 @@ function GroupAnalyticsPage() {
     { value: 'excel', label: 'Excel', desc: '电子表格，适合统计分析' },
     { value: 'txt', label: 'TXT', desc: '纯文本，通用格式' },
     { value: 'json', label: 'JSON', desc: '详细格式，包含完整消息信息' },
+    { value: 'arkme-json', label: 'Arkme JSON', desc: '紧凑 JSON，支持 sender 去重与关系统计' },
     { value: 'chatlab', label: 'ChatLab', desc: '标准格式，支持其他软件导入' },
     { value: 'chatlab-jsonl', label: 'ChatLab JSONL', desc: '流式格式，适合大量消息' },
     { value: 'html', label: 'HTML', desc: '网页格式，可直接浏览' },

src/pages/HomePage.scss

@@ -29,7 +29,7 @@
 .blob-1 {
   width: 400px;
   height: 400px;
-  background: rgba(139, 115, 85, 0.25);
+  background: rgba(var(--primary-rgb), 0.25);
   top: -100px;
   left: -50px;
   animation-duration: 25s;
@@ -38,7 +38,7 @@
 .blob-2 {
   width: 350px;
   height: 350px;
-  background: rgba(139, 115, 85, 0.15);
+  background: rgba(var(--primary-rgb), 0.15);
   bottom: -50px;
   right: -50px;
   animation-duration: 30s;
@@ -74,7 +74,7 @@
   margin: 0 0 16px;
   color: var(--text-primary);
   letter-spacing: -2px;
-  background: linear-gradient(135deg, var(--text-primary) 0%, rgba(139, 115, 85, 0.8) 100%);
+  background: linear-gradient(135deg, var(--primary) 0%, rgba(var(--primary-rgb), 0.6) 100%);
   background-clip: text;
   -webkit-background-clip: text;
   -webkit-text-fill-color: transparent;

src/pages/NotificationWindow.tsx

@@ -1,11 +1,9 @@
 import { useEffect, useState, useRef } from 'react'
 import { NotificationToast, type NotificationData } from '../components/NotificationToast'
-import { useThemeStore } from '../stores/themeStore'
 import '../components/NotificationToast.scss'
 import './NotificationWindow.scss'
 
 export default function NotificationWindow() {
-    const { currentTheme, themeMode } = useThemeStore()
     const [notification, setNotification] = useState<NotificationData | null>(null)
     const [prevNotification, setPrevNotification] = useState<NotificationData | null>(null)
 
@@ -19,12 +17,6 @@ export default function NotificationWindow() {
 
     const notificationRef = useRef<NotificationData | null>(null)
 
-    // 应用主题到通知窗口
-    useEffect(() => {
-        document.documentElement.setAttribute('data-theme', currentTheme)
-        document.documentElement.setAttribute('data-mode', themeMode)
-    }, [currentTheme, themeMode])
-
     useEffect(() => {
         notificationRef.current = notification
     }, [notification])

src/pages/SettingsPage.scss

@@ -348,6 +348,51 @@
     margin-bottom: 10px;
   }
 
+  .settings-time-range-field {
+    margin-bottom: 10px;
+  }
+
+  .settings-time-range-trigger {
+    width: 100%;
+    padding: 10px 16px;
+    border: 1px solid var(--border-color);
+    border-radius: 9999px;
+    font-size: 14px;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    cursor: pointer;
+    transition: all 0.2s;
+
+    &:hover {
+      border-color: rgba(var(--primary-rgb), 0.45);
+      color: var(--primary);
+    }
+
+    &.open {
+      border-color: var(--primary);
+      box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary) 15%, transparent);
+    }
+  }
+
+  .settings-time-range-value {
+    flex: 1;
+    min-width: 0;
+    text-align: left;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .settings-time-range-arrow {
+    color: var(--text-tertiary);
+    font-weight: 700;
+    line-height: 1;
+  }
+
   .select-trigger {
     width: 100%;
     padding: 10px 16px;
@@ -2172,4 +2217,71 @@
     width: 100%;
     margin-top: 12px;
   }
-}
+}
+
+.brute-force-progress {
+  margin-top: 12px;
+  padding: 14px 16px;
+  background: var(--bg-tertiary);
+  border: 1px solid var(--border-color);
+  border-radius: 12px;
+  animation: slideUp 0.3s ease;
+
+  .status-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 10px;
+
+    .status-text {
+      font-size: 13px;
+      color: var(--text-primary);
+      font-weight: 500;
+      margin: 0;
+      // 增加文字呼吸灯效果，表明正在运行
+      animation: pulse 2s ease-in-out infinite;
+    }
+
+    .percent {
+      font-size: 14px;
+      color: var(--primary);
+      font-weight: 700;
+      font-family: var(--font-mono);
+    }
+  }
+
+  .progress-bar-container {
+    width: 100%;
+    height: 8px;
+    background: var(--bg-primary);
+    border-radius: 4px;
+    overflow: hidden;
+    border: 1px solid var(--border-color);
+    box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.05);
+
+    .fill {
+      height: 100%;
+      background: linear-gradient(90deg, var(--primary) 0%, color-mix(in srgb, var(--primary) 60%, white) 100%);
+      border-radius: 4px;
+      transition: width 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+      position: relative;
+
+      // 流光扫过的高亮特效
+      &::after {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background: linear-gradient(
+                        90deg,
+                        transparent,
+                        rgba(255, 255, 255, 0.3),
+                        transparent
+        );
+        animation: progress-shimmer 1.5s infinite linear;
+      }
+    }
+  }
+}

src/pages/SettingsPage.tsx

@@ -1,4 +1,5 @@
 import { useState, useEffect, useRef } from 'react'
+import { useLocation } from 'react-router-dom'
 import { useAppStore } from '../stores/appStore'
 import { useChatStore } from '../stores/chatStore'
 import { useThemeStore, themes } from '../stores/themeStore'
@@ -8,20 +9,19 @@ import * as configService from '../services/config'
 import {
   Eye, EyeOff, FolderSearch, FolderOpen, Search, Copy,
   RotateCcw, Trash2, Plug, Check, Sun, Moon, Monitor,
-  Palette, Database, Download, HardDrive, Info, RefreshCw, ChevronDown, Mic,
+  Palette, Database, HardDrive, Info, RefreshCw, ChevronDown, Download, Mic,
   ShieldCheck, Fingerprint, Lock, KeyRound, Bell, Globe, BarChart2
 } from 'lucide-react'
 import { Avatar } from '../components/Avatar'
 import './SettingsPage.scss'
 
-type SettingsTab = 'appearance' | 'notification' | 'database' | 'models' | 'export' | 'cache' | 'api' | 'security' | 'about' | 'analytics'
+type SettingsTab = 'appearance' | 'notification' | 'database' | 'models' | 'cache' | 'api' | 'security' | 'about' | 'analytics'
 
 const tabs: { id: SettingsTab; label: string; icon: React.ElementType }[] = [
   { id: 'appearance', label: '外观', icon: Palette },
   { id: 'notification', label: '通知', icon: Bell },
   { id: 'database', label: '数据库连接', icon: Database },
   { id: 'models', label: '模型管理', icon: Mic },
-  { id: 'export', label: '导出', icon: Download },
   { id: 'cache', label: '缓存', icon: HardDrive },
   { id: 'api', label: 'API 服务', icon: Globe },
 
@@ -37,6 +37,7 @@ interface WxidOption {
 }
 
 function SettingsPage() {
+  const location = useLocation()
   const {
     isDbConnected,
     setDbConnected,
@@ -73,15 +74,9 @@ function SettingsPage() {
   const [wxid, setWxid] = useState('')
   const [wxidOptions, setWxidOptions] = useState<WxidOption[]>([])
   const [showWxidSelect, setShowWxidSelect] = useState(false)
-  const [showExportFormatSelect, setShowExportFormatSelect] = useState(false)
-  const [showExportDateRangeSelect, setShowExportDateRangeSelect] = useState(false)
-  const [showExportExcelColumnsSelect, setShowExportExcelColumnsSelect] = useState(false)
-  const [showExportConcurrencySelect, setShowExportConcurrencySelect] = useState(false)
-  const exportFormatDropdownRef = useRef<HTMLDivElement>(null)
-  const exportDateRangeDropdownRef = useRef<HTMLDivElement>(null)
-  const exportExcelColumnsDropdownRef = useRef<HTMLDivElement>(null)
-  const exportConcurrencyDropdownRef = useRef<HTMLDivElement>(null)
   const [cachePath, setCachePath] = useState('')
+  const [imageKeyProgress, setImageKeyProgress] = useState(0)
+  const [imageKeyPercent, setImageKeyPercent] = useState<number | null>(null)
 
   const [logEnabled, setLogEnabled] = useState(false)
   const [whisperModelName, setWhisperModelName] = useState('base')
@@ -101,12 +96,6 @@ function SettingsPage() {
 
   const [autoTranscribeVoice, setAutoTranscribeVoice] = useState(false)
   const [transcribeLanguages, setTranscribeLanguages] = useState<string[]>(['zh'])
-  const [exportDefaultFormat, setExportDefaultFormat] = useState('excel')
-  const [exportDefaultDateRange, setExportDefaultDateRange] = useState('today')
-  const [exportDefaultMedia, setExportDefaultMedia] = useState(false)
-  const [exportDefaultVoiceAsText, setExportDefaultVoiceAsText] = useState(false)
-  const [exportDefaultExcelCompactColumns, setExportDefaultExcelCompactColumns] = useState(true)
-  const [exportDefaultConcurrency, setExportDefaultConcurrency] = useState(2)
 
   const [notificationEnabled, setNotificationEnabled] = useState(true)
   const [notificationPosition, setNotificationPosition] = useState<'top-right' | 'top-left' | 'bottom-right' | 'bottom-left'>('top-right')
@@ -119,6 +108,9 @@ function SettingsPage() {
   const [wordCloudExcludeWords, setWordCloudExcludeWords] = useState<string[]>([])
   const [excludeWordsInput, setExcludeWordsInput] = useState('')
 
+  // 数据收集同意状态
+  const [analyticsConsent, setAnalyticsConsent] = useState<boolean>(false)
+
 
 
 
@@ -197,33 +189,38 @@ function SettingsPage() {
     }
   }, [])
 
-  // 点击外部关闭下拉框
   useEffect(() => {
-    const handleClickOutside = (e: MouseEvent) => {
-      const target = e.target as Node
-      if (showExportFormatSelect && exportFormatDropdownRef.current && !exportFormatDropdownRef.current.contains(target)) {
-        setShowExportFormatSelect(false)
-      }
-      if (showExportDateRangeSelect && exportDateRangeDropdownRef.current && !exportDateRangeDropdownRef.current.contains(target)) {
-        setShowExportDateRangeSelect(false)
-      }
-      if (showExportExcelColumnsSelect && exportExcelColumnsDropdownRef.current && !exportExcelColumnsDropdownRef.current.contains(target)) {
-        setShowExportExcelColumnsSelect(false)
-      }
-      if (showExportConcurrencySelect && exportConcurrencyDropdownRef.current && !exportConcurrencyDropdownRef.current.contains(target)) {
-        setShowExportConcurrencySelect(false)
-      }
-    }
-    document.addEventListener('mousedown', handleClickOutside)
-    return () => document.removeEventListener('mousedown', handleClickOutside)
-  }, [showExportFormatSelect, showExportDateRangeSelect, showExportExcelColumnsSelect, showExportConcurrencySelect])
+    const initialTab = (location.state as { initialTab?: SettingsTab } | null)?.initialTab
+    if (!initialTab) return
+    setActiveTab(initialTab)
+  }, [location.state])
 
   useEffect(() => {
     const removeDb = window.electronAPI.key.onDbKeyStatus((payload: { message: string; level: number }) => {
       setDbKeyStatus(payload.message)
     })
-    const removeImage = window.electronAPI.key.onImageKeyStatus((payload: { message: string }) => {
-      setImageKeyStatus(payload.message)
+
+    const removeImage = window.electronAPI.key.onImageKeyStatus((payload: { message: string, percent?: number }) => {
+      let msg = payload.message;
+      let pct = payload.percent;
+
+      // 如果后端没有显式传 percent，则用正则从字符串中提取如 "(12.5%)"
+      if (pct === undefined) {
+        const match = msg.match(/\(([\d.]+)%\)/);
+        if (match) {
+          pct = parseFloat(match[1]);
+          // 将百分比从文本中剥离，让 UI 更清爽
+          msg = msg.replace(/\s*\([\d.]+%\)/, '');
+        }
+      }
+
+      setImageKeyStatus(msg);
+      if (pct !== undefined) {
+        setImageKeyPercent(pct);
+      } else if (msg.includes('启动多核') || msg.includes('定位') || msg.includes('准备')) {
+        // 预热阶段
+        setImageKeyPercent(0);
+      }
     })
     return () => {
       removeDb?.()
@@ -264,13 +261,6 @@ function SettingsPage() {
       const savedWhisperModelDir = await configService.getWhisperModelDir()
       const savedAutoTranscribe = await configService.getAutoTranscribeVoice()
       const savedTranscribeLanguages = await configService.getTranscribeLanguages()
-      const savedExportDefaultFormat = await configService.getExportDefaultFormat()
-      const savedExportDefaultDateRange = await configService.getExportDefaultDateRange()
-      const savedExportDefaultMedia = await configService.getExportDefaultMedia()
-      const savedExportDefaultVoiceAsText = await configService.getExportDefaultVoiceAsText()
-      const savedExportDefaultExcelCompactColumns = await configService.getExportDefaultExcelCompactColumns()
-      const savedExportDefaultConcurrency = await configService.getExportDefaultConcurrency()
-
       const savedNotificationEnabled = await configService.getNotificationEnabled()
       const savedNotificationPosition = await configService.getNotificationPosition()
       const savedNotificationFilterMode = await configService.getNotificationFilterMode()
@@ -305,12 +295,6 @@ function SettingsPage() {
       setLogEnabled(savedLogEnabled)
       setAutoTranscribeVoice(savedAutoTranscribe)
       setTranscribeLanguages(savedTranscribeLanguages)
-      setExportDefaultFormat(savedExportDefaultFormat || 'excel')
-      setExportDefaultDateRange(savedExportDefaultDateRange || 'today')
-      setExportDefaultMedia(savedExportDefaultMedia ?? false)
-      setExportDefaultVoiceAsText(savedExportDefaultVoiceAsText ?? false)
-      setExportDefaultExcelCompactColumns(savedExportDefaultExcelCompactColumns ?? true)
-      setExportDefaultConcurrency(savedExportDefaultConcurrency ?? 2)
 
       setNotificationEnabled(savedNotificationEnabled)
       setNotificationPosition(savedNotificationPosition)
@@ -321,6 +305,9 @@ function SettingsPage() {
       setWordCloudExcludeWords(savedExcludeWords)
       setExcludeWordsInput(savedExcludeWords.join('\n'))
 
+      const savedAnalyticsConsent = await configService.getAnalyticsConsent()
+      setAnalyticsConsent(savedAnalyticsConsent ?? false)
+
       // 如果语言列表为空，保存默认值
       if (!savedTranscribeLanguages || savedTranscribeLanguages.length === 0) {
         const defaultLanguages = ['zh']
@@ -745,40 +732,26 @@ function SettingsPage() {
   }
 
   const handleAutoGetImageKey = async () => {
-    if (isFetchingImageKey) return
-    if (!dbPath) {
-      showMessage('请先选择数据库目录', false)
-      return
-    }
-    setIsFetchingImageKey(true)
-    setImageKeyStatus('正在准备获取图片密钥...')
+    if (isFetchingImageKey) return;
+    if (!dbPath) { showMessage('请先选择数据库目录', false); return; }
+    setIsFetchingImageKey(true);
+    setImageKeyPercent(0)
+    setImageKeyStatus('正在初始化...');
+    setImageKeyProgress(0);
+
     try {
-      const accountPath = wxid ? `${dbPath}/${wxid}` : dbPath
-      const result = await window.electronAPI.key.autoGetImageKey(accountPath)
+      const accountPath = wxid ? `${dbPath}/${wxid}` : dbPath;
+      const result = await window.electronAPI.key.autoGetImageKey(accountPath, wxid)
       if (result.success && result.aesKey) {
-        if (typeof result.xorKey === 'number') {
-          setImageXorKey(`0x${result.xorKey.toString(16).toUpperCase().padStart(2, '0')}`)
-        }
+        if (typeof result.xorKey === 'number') setImageXorKey(`0x${result.xorKey.toString(16).toUpperCase().padStart(2, '0')}`)
         setImageAesKey(result.aesKey)
         setImageKeyStatus('已获取图片密钥')
         showMessage('已自动获取图片密钥', true)
-
-        // Auto-save after fetching keys
-        // We need to use the values directly because state updates are async
         const newXorKey = typeof result.xorKey === 'number' ? result.xorKey : 0
         const newAesKey = result.aesKey
-
         await configService.setImageXorKey(newXorKey)
         await configService.setImageAesKey(newAesKey)
-
-        if (wxid) {
-          await configService.setWxidConfig(wxid, {
-            decryptKey: decryptKey, // use current state as it hasn't changed here
-            imageXorKey: newXorKey,
-            imageAesKey: newAesKey
-          })
-        }
-
+        if (wxid) await configService.setWxidConfig(wxid, { decryptKey, imageXorKey: newXorKey, imageAesKey: newAesKey })
       } else {
         showMessage(result.error || '自动获取图片密钥失败', false)
       }
@@ -789,6 +762,36 @@ function SettingsPage() {
     }
   }
 
+  const handleScanImageKeyFromMemory = async () => {
+    if (isFetchingImageKey) return;
+    if (!dbPath) { showMessage('请先选择数据库目录', false); return; }
+    setIsFetchingImageKey(true);
+    setImageKeyPercent(0)
+    setImageKeyStatus('正在扫描内存...');
+
+    try {
+      const accountPath = wxid ? `${dbPath}/${wxid}` : dbPath;
+      const result = await window.electronAPI.key.scanImageKeyFromMemory(accountPath)
+      if (result.success && result.aesKey) {
+        if (typeof result.xorKey === 'number') setImageXorKey(`0x${result.xorKey.toString(16).toUpperCase().padStart(2, '0')}`)
+        setImageAesKey(result.aesKey)
+        setImageKeyStatus('内存扫描成功，已获取图片密钥')
+        showMessage('内存扫描成功，已获取图片密钥', true)
+        const newXorKey = typeof result.xorKey === 'number' ? result.xorKey : 0
+        const newAesKey = result.aesKey
+        await configService.setImageXorKey(newXorKey)
+        await configService.setImageAesKey(newAesKey)
+        if (wxid) await configService.setWxidConfig(wxid, { decryptKey, imageXorKey: newXorKey, imageAesKey: newAesKey })
+      } else {
+        showMessage(result.error || '内存扫描获取图片密钥失败', false)
+      }
+    } catch (e: any) {
+      showMessage(`内存扫描失败: ${e}`, false)
+    } finally {
+      setIsFetchingImageKey(false)
+    }
+  }
+
 
 
   const handleTestConnection = async () => {
@@ -939,8 +942,20 @@ function SettingsPage() {
       <div className="theme-grid">
         {themes.map((theme) => (
           <div key={theme.id} className={`theme-card ${currentTheme === theme.id ? 'active' : ''}`} onClick={() => setTheme(theme.id)}>
-            <div className="theme-preview" style={{ background: effectiveMode === 'dark' ? 'linear-gradient(135deg, #1a1a1a 0%, #2a2a2a 100%)' : `linear-gradient(135deg, ${theme.bgColor} 0%, ${theme.bgColor}dd 100%)` }}>
-              <div className="theme-accent" style={{ background: theme.primaryColor }} />
+            <div className="theme-preview" style={{
+              background: effectiveMode === 'dark'
+                ? (theme.id === 'blossom-dream' ? 'linear-gradient(150deg, #151316 0%, #1A1620 50%, #131018 100%)'
+                  : theme.id === 'geist' ? 'linear-gradient(135deg, #1a1a1a 0%, #222222 100%)'
+                  : 'linear-gradient(135deg, #1a1a1a 0%, #2a2a2a 100%)')
+                : (theme.id === 'blossom-dream' ? `linear-gradient(150deg, ${theme.bgColor} 0%, #F8F2F8 45%, #F2F6FB 100%)`
+                  : theme.id === 'geist' ? 'linear-gradient(135deg, #ffffff 0%, #f0f0f0 100%)'
+                  : `linear-gradient(135deg, ${theme.bgColor} 0%, ${theme.bgColor}dd 100%)`)
+            }}>
+              <div className="theme-accent" style={{
+                background: theme.accentColor
+                  ? `linear-gradient(135deg, ${theme.primaryColor} 0%, ${theme.accentColor} 100%)`
+                  : theme.primaryColor
+              }} />
             </div>
             <div className="theme-info">
               <span className="theme-name">{theme.name}</span>
@@ -1340,11 +1355,27 @@ function SettingsPage() {
             scheduleConfigSave('keys', () => syncCurrentKeys({ imageAesKey: value, wxid }))
           }}
         />
-        <button className="btn btn-secondary btn-sm" onClick={handleAutoGetImageKey} disabled={isFetchingImageKey}>
-          <Plug size={14} /> {isFetchingImageKey ? '获取中...' : '自动获取图片密钥'}
-        </button>
-        {imageKeyStatus && <div className="form-hint status-text">{imageKeyStatus}</div>}
-        {isFetchingImageKey && <div className="form-hint status-text">正在扫描内存，请稍候...</div>}
+        <div className="form-hint" style={{ color: '#f59e0b', margin: '6px 0' }}>
+          ⚠️ 快速获取方案基于本地缓存计算，可能因账号信息不匹配而不准确。若图片无法解密，请使用「内存扫描」方案。
+        </div>
+        <div style={{ display: 'flex', gap: '8px', marginTop: '4px' }}>
+          <button className="btn btn-secondary btn-sm" onClick={handleAutoGetImageKey} disabled={isFetchingImageKey} title="从本地缓存快速计算（可能不准确）">
+            <Plug size={14} /> {isFetchingImageKey ? '获取中...' : '快速获取（缓存计算）'}
+          </button>
+          <button className="btn btn-primary btn-sm" onClick={handleScanImageKeyFromMemory} disabled={isFetchingImageKey} title="扫描微信进程内存，准确率更高">
+            {isFetchingImageKey ? '扫描中...' : '内存扫描（推荐）'}
+          </button>
+        </div>
+        {isFetchingImageKey ? (
+          <div className="brute-force-progress">
+            <div className="status-header">
+              <span className="status-text">{imageKeyStatus || '正在启动...'}</span>
+            </div>
+          </div>
+        ) : (
+          imageKeyStatus && <div className="form-hint status-text" style={{ marginTop: '8px' }}>{imageKeyStatus}</div>
+        )}
+        <span className="form-hint">内存扫描需要微信正在运行，并在微信中打开 2-3 张图片大图后再点击</span>
       </div>
 
       <div className="form-group">
@@ -1475,258 +1506,6 @@ function SettingsPage() {
     </div>
   )
 
-  const exportFormatOptions = [
-    { value: 'excel', label: 'Excel', desc: '电子表格，适合统计分析' },
-    { value: 'chatlab', label: 'ChatLab', desc: '标准格式，支持其他软件导入' },
-    { value: 'chatlab-jsonl', label: 'ChatLab JSONL', desc: '流式格式，适合大量消息' },
-    { value: 'json', label: 'JSON', desc: '详细格式，包含完整消息信息' },
-    { value: 'html', label: 'HTML', desc: '网页格式，可直接浏览' },
-    { value: 'txt', label: 'TXT', desc: '纯文本，通用格式' },
-    { value: 'weclone', label: 'WeClone CSV', desc: 'WeClone 兼容字段格式（CSV）' },
-    { value: 'sql', label: 'PostgreSQL', desc: '数据库脚本，便于导入到数据库' }
-  ]
-  const exportDateRangeOptions = [
-    { value: 'today', label: '今天' },
-    { value: '7d', label: '最近7天' },
-    { value: '30d', label: '最近30天' },
-    { value: '90d', label: '最近90天' },
-    { value: 'all', label: '全部时间' }
-  ]
-  const exportExcelColumnOptions = [
-    { value: 'compact', label: '精简列', desc: '序号、时间、发送者身份、消息类型、内容' },
-    { value: 'full', label: '完整列', desc: '含发送者昵称/微信ID/备注' }
-  ]
-
-  const exportConcurrencyOptions = [
-    { value: 1, label: '1' },
-    { value: 2, label: '2' },
-    { value: 3, label: '3' },
-    { value: 4, label: '4' },
-    { value: 5, label: '5' },
-    { value: 6, label: '6' }
-  ]
-
-  const getOptionLabel = (options: { value: string; label: string }[], value: string) => {
-    return options.find((option) => option.value === value)?.label ?? value
-  }
-
-  const renderExportTab = () => {
-    const exportExcelColumnsValue = exportDefaultExcelCompactColumns ? 'compact' : 'full'
-    const exportFormatLabel = getOptionLabel(exportFormatOptions, exportDefaultFormat)
-    const exportDateRangeLabel = getOptionLabel(exportDateRangeOptions, exportDefaultDateRange)
-    const exportExcelColumnsLabel = getOptionLabel(exportExcelColumnOptions, exportExcelColumnsValue)
-    const exportConcurrencyLabel = String(exportDefaultConcurrency)
-
-    return (
-      <div className="tab-content">
-        <div className="form-group">
-          <label>默认导出格式</label>
-          <span className="form-hint">导出页面默认选中的格式</span>
-          <div className="select-field" ref={exportFormatDropdownRef}>
-            <button
-              type="button"
-              className={`select-trigger ${showExportFormatSelect ? 'open' : ''}`}
-              onClick={() => {
-                setShowExportFormatSelect(!showExportFormatSelect)
-                setShowExportDateRangeSelect(false)
-                setShowExportExcelColumnsSelect(false)
-                setShowExportConcurrencySelect(false)
-              }}
-            >
-              <span className="select-value">{exportFormatLabel}</span>
-              <ChevronDown size={16} />
-            </button>
-            {showExportFormatSelect && (
-              <div className="select-dropdown">
-                {exportFormatOptions.map((option) => (
-                  <button
-                    key={option.value}
-                    type="button"
-                    className={`select-option ${exportDefaultFormat === option.value ? 'active' : ''}`}
-                    onClick={async () => {
-                      setExportDefaultFormat(option.value)
-                      await configService.setExportDefaultFormat(option.value)
-                      showMessage('已更新导出格式默认值', true)
-                      setShowExportFormatSelect(false)
-                    }}
-                  >
-                    <span className="option-label">{option.label}</span>
-                    {option.desc && <span className="option-desc">{option.desc}</span>}
-                  </button>
-                ))}
-              </div>
-            )}
-          </div>
-        </div>
-
-        <div className="form-group">
-          <label>默认导出时间范围</label>
-          <span className="form-hint">控制导出页面的默认时间选择</span>
-          <div className="select-field" ref={exportDateRangeDropdownRef}>
-            <button
-              type="button"
-              className={`select-trigger ${showExportDateRangeSelect ? 'open' : ''}`}
-              onClick={() => {
-                setShowExportDateRangeSelect(!showExportDateRangeSelect)
-                setShowExportFormatSelect(false)
-                setShowExportExcelColumnsSelect(false)
-                setShowExportConcurrencySelect(false)
-              }}
-            >
-              <span className="select-value">{exportDateRangeLabel}</span>
-              <ChevronDown size={16} />
-            </button>
-            {showExportDateRangeSelect && (
-              <div className="select-dropdown">
-                {exportDateRangeOptions.map((option) => (
-                  <button
-                    key={option.value}
-                    type="button"
-                    className={`select-option ${exportDefaultDateRange === option.value ? 'active' : ''}`}
-                    onClick={async () => {
-                      setExportDefaultDateRange(option.value)
-                      await configService.setExportDefaultDateRange(option.value)
-                      showMessage('已更新默认导出时间范围', true)
-                      setShowExportDateRangeSelect(false)
-                    }}
-                  >
-                    <span className="option-label">{option.label}</span>
-                  </button>
-                ))}
-              </div>
-            )}
-          </div>
-        </div>
-
-        <div className="form-group">
-          <label>默认导出媒体文件</label>
-          <span className="form-hint">控制图片/语音/表情的默认导出开关</span>
-          <div className="log-toggle-line">
-            <span className="log-status">{exportDefaultMedia ? '已开启' : '已关闭'}</span>
-            <label className="switch" htmlFor="export-default-media">
-              <input
-                id="export-default-media"
-                className="switch-input"
-                type="checkbox"
-                checked={exportDefaultMedia}
-                onChange={async (e) => {
-                  const enabled = e.target.checked
-                  setExportDefaultMedia(enabled)
-                  await configService.setExportDefaultMedia(enabled)
-                  showMessage(enabled ? '已开启默认媒体导出' : '已关闭默认媒体导出', true)
-                }}
-              />
-              <span className="switch-slider" />
-            </label>
-          </div>
-        </div>
-
-        <div className="form-group">
-          <label>默认语音转文字</label>
-          <span className="form-hint">导出时默认将语音转写为文字</span>
-          <div className="log-toggle-line">
-            <span className="log-status">{exportDefaultVoiceAsText ? '已开启' : '已关闭'}</span>
-            <label className="switch" htmlFor="export-default-voice-as-text">
-              <input
-                id="export-default-voice-as-text"
-                className="switch-input"
-                type="checkbox"
-                checked={exportDefaultVoiceAsText}
-                onChange={async (e) => {
-                  const enabled = e.target.checked
-                  setExportDefaultVoiceAsText(enabled)
-                  await configService.setExportDefaultVoiceAsText(enabled)
-                  showMessage(enabled ? '已开启默认语音转文字' : '已关闭默认语音转文字', true)
-                }}
-              />
-              <span className="switch-slider" />
-            </label>
-          </div>
-        </div>
-
-        <div className="form-group">
-          <label>Excel 列显示</label>
-          <span className="form-hint">控制 Excel 导出的列字段</span>
-          <div className="select-field" ref={exportExcelColumnsDropdownRef}>
-            <button
-              type="button"
-              className={`select-trigger ${showExportExcelColumnsSelect ? 'open' : ''}`}
-              onClick={() => {
-                setShowExportExcelColumnsSelect(!showExportExcelColumnsSelect)
-                setShowExportFormatSelect(false)
-                setShowExportDateRangeSelect(false)
-                setShowExportConcurrencySelect(false)
-              }}
-            >
-              <span className="select-value">{exportExcelColumnsLabel}</span>
-              <ChevronDown size={16} />
-            </button>
-            {showExportExcelColumnsSelect && (
-              <div className="select-dropdown">
-                {exportExcelColumnOptions.map((option) => (
-                  <button
-                    key={option.value}
-                    type="button"
-                    className={`select-option ${exportExcelColumnsValue === option.value ? 'active' : ''}`}
-                    onClick={async () => {
-                      const compact = option.value === 'compact'
-                      setExportDefaultExcelCompactColumns(compact)
-                      await configService.setExportDefaultExcelCompactColumns(compact)
-                      showMessage(compact ? '已启用精简列' : '已启用完整列', true)
-                      setShowExportExcelColumnsSelect(false)
-                    }}
-                  >
-                    <span className="option-label">{option.label}</span>
-                    {option.desc && <span className="option-desc">{option.desc}</span>}
-                  </button>
-                ))}
-              </div>
-            )}
-          </div>
-        </div>
-
-        <div className="form-group">
-          <label>导出并发数</label>
-          <span className="form-hint">导出多个会话时的最大并发（1~6）</span>
-          <div className="select-field" ref={exportConcurrencyDropdownRef}>
-            <button
-              type="button"
-              className={`select-trigger ${showExportConcurrencySelect ? 'open' : ''}`}
-              onClick={() => {
-                setShowExportConcurrencySelect(!showExportConcurrencySelect)
-                setShowExportFormatSelect(false)
-                setShowExportDateRangeSelect(false)
-                setShowExportExcelColumnsSelect(false)
-              }}
-            >
-              <span className="select-value">{exportConcurrencyLabel}</span>
-              <ChevronDown size={16} />
-            </button>
-            {showExportConcurrencySelect && (
-              <div className="select-dropdown">
-                {exportConcurrencyOptions.map((option) => (
-                  <button
-                    key={option.value}
-                    type="button"
-                    className={`select-option ${exportDefaultConcurrency === option.value ? 'active' : ''}`}
-                    onClick={async () => {
-                      setExportDefaultConcurrency(option.value)
-                      await configService.setExportDefaultConcurrency(option.value)
-                      showMessage(`已将导出并发数设为 ${option.value}`, true)
-                      setShowExportConcurrencySelect(false)
-                    }}
-                  >
-                    <span className="option-label">{option.label}</span>
-                  </button>
-                ))}
-              </div>
-            )}
-          </div>
-        </div>
-
-      </div>
-    )
-  }
   const renderCacheTab = () => (
     <div className="tab-content">
       <p className="section-desc">管理应用缓存数据</p>
@@ -2067,8 +1846,8 @@ function SettingsPage() {
             <label>应用锁状态</label>
             <span className="form-hint">{
               isLockMode ? '已开启' :
-              authEnabled ? '旧版模式 — 请重新设置密码以升级为新模式提高安全性' :
-              '未开启 — 请设置密码以开启'
+                authEnabled ? '旧版模式 — 请重新设置密码以升级为新模式提高安全性' :
+                  '未开启 — 请设置密码以开启'
             }</span>
           </div>
           {authEnabled && !showDisableLockInput && (
@@ -2247,6 +2026,24 @@ function SettingsPage() {
           <a href="#" onClick={(e) => { e.preventDefault(); window.electronAPI.window.openAgreementWindow() }}>用户协议</a>
         </div>
         <p className="copyright">© 2025 WeFlow. All rights reserved.</p>
+
+        <div className="log-toggle-line" style={{ marginTop: '16px', justifyContent: 'center' }}>
+          <span style={{ fontSize: '13px', opacity: 0.7 }}>匿名数据收集</span>
+          <label className="switch">
+            <input
+              type="checkbox"
+              className="switch-input"
+              checked={analyticsConsent}
+              onChange={async (e) => {
+                const consent = e.target.checked
+                setAnalyticsConsent(consent)
+                await configService.setAnalyticsConsent(consent)
+                showMessage(consent ? '已允许数据收集' : '已拒绝数据收集', true)
+              }}
+            />
+            <span className="switch-slider"></span>
+          </label>
+        </div>
       </div>
     </div>
   )
@@ -2305,7 +2102,6 @@ function SettingsPage() {
         {activeTab === 'notification' && renderNotificationTab()}
         {activeTab === 'database' && renderDatabaseTab()}
         {activeTab === 'models' && renderModelsTab()}
-        {activeTab === 'export' && renderExportTab()}
         {activeTab === 'cache' && renderCacheTab()}
         {activeTab === 'api' && renderApiTab()}
         {activeTab === 'analytics' && renderAnalyticsTab()}

src/pages/WelcomePage.scss

@@ -803,3 +803,79 @@
     opacity: 1;
   }
 }
+
+
+.brute-force-progress {
+  margin-top: 16px;
+  padding: 14px 16px;
+  background: var(--bg-tertiary);
+  border: 1px solid var(--border-color);
+  border-radius: 12px;
+  animation: slideUp 0.3s ease;
+
+  .status-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 10px;
+
+    .status-text {
+      font-size: 13px;
+      color: var(--text-primary);
+      font-weight: 500;
+      margin: 0;
+      animation: pulse 2s ease-in-out infinite;
+    }
+
+    .percent {
+      font-size: 14px;
+      color: var(--primary);
+      font-weight: 700;
+      font-family: var(--font-mono);
+    }
+  }
+
+  .progress-bar-container {
+    width: 100%;
+    height: 8px;
+    background: var(--bg-primary);
+    border-radius: 4px;
+    overflow: hidden;
+    border: 1px solid var(--border-color);
+    box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.05);
+
+    .fill {
+      height: 100%;
+      background: linear-gradient(90deg, var(--primary) 0%, color-mix(in srgb, var(--primary) 60%, white) 100%);
+      border-radius: 4px;
+      transition: width 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+      position: relative;
+
+      &::after {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background: linear-gradient(
+                        90deg,
+                        transparent,
+                        rgba(255, 255, 255, 0.3),
+                        transparent
+        );
+        animation: progress-shimmer 1.5s infinite linear;
+      }
+    }
+  }
+}
+
+@keyframes pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.7; }
+}
+
+@keyframes progress-shimmer {
+  0% { transform: translateX(-100%); }
+  100% { transform: translateX(100%); }
+}

src/pages/WelcomePage.tsx

@@ -23,6 +23,18 @@ interface WelcomePageProps {
   standalone?: boolean
 }
 
+const formatDbKeyFailureMessage = (error?: string, logs?: string[]): string => {
+  const base = String(error || '自动获取密钥失败').trim()
+  const tailLogs = Array.isArray(logs)
+    ? logs
+      .map(item => String(item || '').trim())
+      .filter(Boolean)
+      .slice(-6)
+    : []
+  if (tailLogs.length === 0) return base
+  return `${base}；最近状态：${tailLogs.join(' | ')}`
+}
+
 function WelcomePage({ standalone = false }: WelcomePageProps) {
   const navigate = useNavigate()
   const { isDbConnected, setDbConnected, setLoading } = useAppStore()
@@ -48,6 +60,7 @@ function WelcomePage({ standalone = false }: WelcomePageProps) {
   const [dbKeyStatus, setDbKeyStatus] = useState('')
   const [imageKeyStatus, setImageKeyStatus] = useState('')
   const [isManualStartPrompt, setIsManualStartPrompt] = useState(false)
+  const [imageKeyPercent, setImageKeyPercent] = useState<number | null>(null)
 
   // 安全相关 state
   const [enableAuth, setEnableAuth] = useState(false)
@@ -111,8 +124,25 @@ function WelcomePage({ standalone = false }: WelcomePageProps) {
     const removeDb = window.electronAPI.key.onDbKeyStatus((payload: { message: string; level: number }) => {
       setDbKeyStatus(payload.message)
     })
-    const removeImage = window.electronAPI.key.onImageKeyStatus((payload: { message: string }) => {
-      setImageKeyStatus(payload.message)
+    const removeImage = window.electronAPI.key.onImageKeyStatus((payload: { message: string, percent?: number }) => {
+      let msg = payload.message;
+      let pct = payload.percent;
+
+      // 解析文本中的百分比
+      if (pct === undefined) {
+        const match = msg.match(/\(([\d.]+)%\)/);
+        if (match) {
+          pct = parseFloat(match[1]);
+          msg = msg.replace(/\s*\([\d.]+%\)/, '');
+        }
+      }
+
+      setImageKeyStatus(msg);
+      if (pct !== undefined) {
+        setImageKeyPercent(pct);
+      } else if (msg.includes('启动多核') || msg.includes('定位') || msg.includes('准备')) {
+        setImageKeyPercent(0);
+      }
     })
     return () => {
       removeDb?.()
@@ -274,7 +304,10 @@ function WelcomePage({ standalone = false }: WelcomePageProps) {
           setIsManualStartPrompt(true)
           setDbKeyStatus('需要手动启动微信')
         } else {
-          setError(result.error || '自动获取密钥失败')
+          if (result.error?.includes('尚未完成登录')) {
+            setDbKeyStatus('请先在微信完成登录后重试')
+          }
+          setError(formatDbKeyFailureMessage(result.error, result.logs))
         }
       }
     } catch (e) {
@@ -291,21 +324,16 @@ function WelcomePage({ standalone = false }: WelcomePageProps) {
 
   const handleAutoGetImageKey = async () => {
     if (isFetchingImageKey) return
-    if (!dbPath) {
-      setError('请先选择数据库目录')
-      return
-    }
+    if (!dbPath) { setError('请先选择数据库目录'); return }
     setIsFetchingImageKey(true)
     setError('')
+    setImageKeyPercent(0)
     setImageKeyStatus('正在准备获取图片密钥...')
     try {
-      // 拼接完整的账号目录，确保 KeyService 能准确找到模板文件
       const accountPath = wxid ? `${dbPath}/${wxid}` : dbPath
-      const result = await window.electronAPI.key.autoGetImageKey(accountPath)
+      const result = await window.electronAPI.key.autoGetImageKey(accountPath, wxid)
       if (result.success && result.aesKey) {
-        if (typeof result.xorKey === 'number') {
-          setImageXorKey(`0x${result.xorKey.toString(16).toUpperCase().padStart(2, '0')}`)
-        }
+        if (typeof result.xorKey === 'number') setImageXorKey(`0x${result.xorKey.toString(16).toUpperCase().padStart(2, '0')}`)
         setImageAesKey(result.aesKey)
         setImageKeyStatus('已获取图片密钥')
       } else {
@@ -318,6 +346,30 @@ function WelcomePage({ standalone = false }: WelcomePageProps) {
     }
   }
 
+  const handleScanImageKeyFromMemory = async () => {
+    if (isFetchingImageKey) return
+    if (!dbPath) { setError('请先选择数据库目录'); return }
+    setIsFetchingImageKey(true)
+    setError('')
+    setImageKeyPercent(0)
+    setImageKeyStatus('正在扫描内存...')
+    try {
+      const accountPath = wxid ? `${dbPath}/${wxid}` : dbPath
+      const result = await window.electronAPI.key.scanImageKeyFromMemory(accountPath)
+      if (result.success && result.aesKey) {
+        if (typeof result.xorKey === 'number') setImageXorKey(`0x${result.xorKey.toString(16).toUpperCase().padStart(2, '0')}`)
+        setImageAesKey(result.aesKey)
+        setImageKeyStatus('内存扫描成功，已获取图片密钥')
+      } else {
+        setError(result.error || '内存扫描获取图片密钥失败')
+      }
+    } catch (e) {
+      setError(`内存扫描失败: ${e}`)
+    } finally {
+      setIsFetchingImageKey(false)
+    }
+  }
+
   const canGoNext = () => {
     if (currentStep.id === 'intro') return true
     if (currentStep.id === 'db') return Boolean(dbPath)
@@ -728,35 +780,40 @@ function WelcomePage({ standalone = false }: WelcomePageProps) {
 
             {currentStep.id === 'image' && (
               <div className="form-group">
+                <div className="field-hint" style={{ color: '#f59e0b', marginBottom: '12px' }}>
+                  ⚠️ 快速获取方案基于本地缓存计算，可能因账号信息不匹配而不准确。若图片无法解密，请使用下方「内存扫描」方案。
+                </div>
                 <div className="grid-2">
                   <div>
                     <label className="field-label">图片 XOR 密钥</label>
-                    <input
-                      type="text"
-                      className="field-input"
-                      placeholder="0x..."
-                      value={imageXorKey}
-                      onChange={(e) => setImageXorKey(e.target.value)}
-                    />
+                    <input type="text" className="field-input" placeholder="0x..." value={imageXorKey} onChange={(e) => setImageXorKey(e.target.value)} />
                   </div>
                   <div>
                     <label className="field-label">图片 AES 密钥</label>
-                    <input
-                      type="text"
-                      className="field-input"
-                      placeholder="16位密钥"
-                      value={imageAesKey}
-                      onChange={(e) => setImageAesKey(e.target.value)}
-                    />
+                    <input type="text" className="field-input" placeholder="16位密钥" value={imageAesKey} onChange={(e) => setImageAesKey(e.target.value)} />
                   </div>
                 </div>
 
-                <button className="btn btn-secondary btn-block mt-4" onClick={handleAutoGetImageKey} disabled={isFetchingImageKey}>
-                  {isFetchingImageKey ? '扫描中...' : '自动获取图片密钥'}
-                </button>
+                <div style={{ display: 'flex', gap: '8px', marginTop: '16px' }}>
+                  <button className="btn btn-secondary btn-block" onClick={handleAutoGetImageKey} disabled={isFetchingImageKey} title="从本地缓存快速计算（可能不准确）">
+                    {isFetchingImageKey ? '获取中...' : '快速获取（缓存计算）'}
+                  </button>
+                  <button className="btn btn-primary btn-block" onClick={handleScanImageKeyFromMemory} disabled={isFetchingImageKey} title="扫描微信进程内存，准确率更高，需要微信正在运行">
+                    {isFetchingImageKey ? '扫描中...' : '内存扫描（推荐）'}
+                  </button>
+                </div>
 
-                {imageKeyStatus && <div className="status-message">{imageKeyStatus}</div>}
-                <div className="field-hint">请在微信中打开几张图片后再点击获取</div>
+                {isFetchingImageKey ? (
+                  <div className="brute-force-progress">
+                    <div className="status-header">
+                      <span className="status-text">{imageKeyStatus || '正在启动...'}</span>
+                    </div>
+                  </div>
+                ) : (
+                  imageKeyStatus && <div className="status-message" style={{ marginTop: '12px' }}>{imageKeyStatus}</div>
+                )}
+
+                <div className="field-hint" style={{ marginTop: '8px' }}>内存扫描需要微信正在运行，并在微信中打开 2-3 张图片大图后再点击</div>
               </div>
             )}
           </div>

src/services/cloudControl.ts

@@ -0,0 +1,9 @@
+// 数据收集服务前端接口
+
+export async function initCloudControl() {
+  return window.electronAPI.cloud.init()
+}
+
+export function recordPage(pageName: string) {
+  window.electronAPI.cloud.recordPage(pageName)
+}

src/services/config.ts

@@ -1,5 +1,6 @@
 // 配置服务 - 封装 Electron Store
 import { config } from './ipc'
+import type { ExportDefaultDateRangeConfig } from '../utils/exportDateRange'
 
 // 配置键名
 export const CONFIG_KEYS = {
@@ -26,12 +27,27 @@ export const CONFIG_KEYS = {
   AUTO_TRANSCRIBE_VOICE: 'autoTranscribeVoice',
   TRANSCRIBE_LANGUAGES: 'transcribeLanguages',
   EXPORT_DEFAULT_FORMAT: 'exportDefaultFormat',
+  EXPORT_DEFAULT_AVATARS: 'exportDefaultAvatars',
   EXPORT_DEFAULT_DATE_RANGE: 'exportDefaultDateRange',
   EXPORT_DEFAULT_MEDIA: 'exportDefaultMedia',
   EXPORT_DEFAULT_VOICE_AS_TEXT: 'exportDefaultVoiceAsText',
   EXPORT_DEFAULT_EXCEL_COMPACT_COLUMNS: 'exportDefaultExcelCompactColumns',
   EXPORT_DEFAULT_TXT_COLUMNS: 'exportDefaultTxtColumns',
   EXPORT_DEFAULT_CONCURRENCY: 'exportDefaultConcurrency',
+  EXPORT_WRITE_LAYOUT: 'exportWriteLayout',
+  EXPORT_SESSION_NAME_PREFIX_ENABLED: 'exportSessionNamePrefixEnabled',
+  EXPORT_LAST_SESSION_RUN_MAP: 'exportLastSessionRunMap',
+  EXPORT_LAST_CONTENT_RUN_MAP: 'exportLastContentRunMap',
+  EXPORT_SESSION_RECORD_MAP: 'exportSessionRecordMap',
+  EXPORT_LAST_SNS_POST_COUNT: 'exportLastSnsPostCount',
+  EXPORT_SESSION_MESSAGE_COUNT_CACHE_MAP: 'exportSessionMessageCountCacheMap',
+  EXPORT_SESSION_CONTENT_METRIC_CACHE_MAP: 'exportSessionContentMetricCacheMap',
+  EXPORT_SNS_STATS_CACHE_MAP: 'exportSnsStatsCacheMap',
+  EXPORT_SNS_USER_POST_COUNTS_CACHE_MAP: 'exportSnsUserPostCountsCacheMap',
+  SNS_PAGE_CACHE_MAP: 'snsPageCacheMap',
+  CONTACTS_LOAD_TIMEOUT_MS: 'contactsLoadTimeoutMs',
+  CONTACTS_LIST_CACHE_MAP: 'contactsListCacheMap',
+  CONTACTS_AVATAR_CACHE_MAP: 'contactsAvatarCacheMap',
 
   // 安全
   AUTH_ENABLED: 'authEnabled',
@@ -48,7 +64,11 @@ export const CONFIG_KEYS = {
   NOTIFICATION_FILTER_LIST: 'notificationFilterList',
 
   // 词云
-  WORD_CLOUD_EXCLUDE_WORDS: 'wordCloudExcludeWords'
+  WORD_CLOUD_EXCLUDE_WORDS: 'wordCloudExcludeWords',
+
+  // 数据收集
+  ANALYTICS_CONSENT: 'analyticsConsent',
+  ANALYTICS_DENY_COUNT: 'analyticsDenyCount'
 } as const
 
 export interface WxidConfig {
@@ -58,6 +78,20 @@ export interface WxidConfig {
   updatedAt?: number
 }
 
+export interface ExportDefaultMediaConfig {
+  images: boolean
+  videos: boolean
+  voices: boolean
+  emojis: boolean
+}
+
+const DEFAULT_EXPORT_MEDIA_CONFIG: ExportDefaultMediaConfig = {
+  images: true,
+  videos: true,
+  voices: true,
+  emojis: true
+}
+
 // 获取解密密钥
 export async function getDecryptKey(): Promise<string | null> {
   const value = await config.get(CONFIG_KEYS.DECRYPT_KEY)
@@ -316,27 +350,64 @@ export async function setExportDefaultFormat(format: string): Promise<void> {
   await config.set(CONFIG_KEYS.EXPORT_DEFAULT_FORMAT, format)
 }
 
-// 获取导出默认时间范围
-export async function getExportDefaultDateRange(): Promise<string | null> {
-  const value = await config.get(CONFIG_KEYS.EXPORT_DEFAULT_DATE_RANGE)
-  return (value as string) || null
-}
-
-// 设置导出默认时间范围
-export async function setExportDefaultDateRange(range: string): Promise<void> {
-  await config.set(CONFIG_KEYS.EXPORT_DEFAULT_DATE_RANGE, range)
-}
-
-// 获取导出默认媒体设置
-export async function getExportDefaultMedia(): Promise<boolean | null> {
-  const value = await config.get(CONFIG_KEYS.EXPORT_DEFAULT_MEDIA)
+// 获取导出默认头像设置
+export async function getExportDefaultAvatars(): Promise<boolean | null> {
+  const value = await config.get(CONFIG_KEYS.EXPORT_DEFAULT_AVATARS)
   if (typeof value === 'boolean') return value
   return null
 }
 
+// 设置导出默认头像设置
+export async function setExportDefaultAvatars(enabled: boolean): Promise<void> {
+  await config.set(CONFIG_KEYS.EXPORT_DEFAULT_AVATARS, enabled)
+}
+
+// 获取导出默认时间范围
+export async function getExportDefaultDateRange(): Promise<ExportDefaultDateRangeConfig | string | null> {
+  const value = await config.get(CONFIG_KEYS.EXPORT_DEFAULT_DATE_RANGE)
+  if (typeof value === 'string') return value
+  if (value && typeof value === 'object') {
+    return value as ExportDefaultDateRangeConfig
+  }
+  return null
+}
+
+// 设置导出默认时间范围
+export async function setExportDefaultDateRange(range: ExportDefaultDateRangeConfig | string): Promise<void> {
+  await config.set(CONFIG_KEYS.EXPORT_DEFAULT_DATE_RANGE, range)
+}
+
+// 获取导出默认媒体设置
+export async function getExportDefaultMedia(): Promise<ExportDefaultMediaConfig | null> {
+  const value = await config.get(CONFIG_KEYS.EXPORT_DEFAULT_MEDIA)
+  if (typeof value === 'boolean') {
+    return {
+      images: value,
+      videos: value,
+      voices: value,
+      emojis: value
+    }
+  }
+  if (value && typeof value === 'object') {
+    const raw = value as Partial<Record<keyof ExportDefaultMediaConfig, unknown>>
+    return {
+      images: typeof raw.images === 'boolean' ? raw.images : DEFAULT_EXPORT_MEDIA_CONFIG.images,
+      videos: typeof raw.videos === 'boolean' ? raw.videos : DEFAULT_EXPORT_MEDIA_CONFIG.videos,
+      voices: typeof raw.voices === 'boolean' ? raw.voices : DEFAULT_EXPORT_MEDIA_CONFIG.voices,
+      emojis: typeof raw.emojis === 'boolean' ? raw.emojis : DEFAULT_EXPORT_MEDIA_CONFIG.emojis
+    }
+  }
+  return null
+}
+
 // 设置导出默认媒体设置
-export async function setExportDefaultMedia(enabled: boolean): Promise<void> {
-  await config.set(CONFIG_KEYS.EXPORT_DEFAULT_MEDIA, enabled)
+export async function setExportDefaultMedia(media: ExportDefaultMediaConfig): Promise<void> {
+  await config.set(CONFIG_KEYS.EXPORT_DEFAULT_MEDIA, {
+    images: media.images,
+    videos: media.videos,
+    voices: media.voices,
+    emojis: media.emojis
+  })
 }
 
 // 获取导出默认语音转文字
@@ -386,6 +457,651 @@ export async function setExportDefaultConcurrency(concurrency: number): Promise<
   await config.set(CONFIG_KEYS.EXPORT_DEFAULT_CONCURRENCY, concurrency)
 }
 
+export type ExportWriteLayout = 'A' | 'B' | 'C'
+
+export async function getExportWriteLayout(): Promise<ExportWriteLayout> {
+  const value = await config.get(CONFIG_KEYS.EXPORT_WRITE_LAYOUT)
+  if (value === 'A' || value === 'B' || value === 'C') return value
+  return 'B'
+}
+
+export async function setExportWriteLayout(layout: ExportWriteLayout): Promise<void> {
+  await config.set(CONFIG_KEYS.EXPORT_WRITE_LAYOUT, layout)
+}
+
+export async function getExportSessionNamePrefixEnabled(): Promise<boolean> {
+  const value = await config.get(CONFIG_KEYS.EXPORT_SESSION_NAME_PREFIX_ENABLED)
+  if (typeof value === 'boolean') return value
+  return true
+}
+
+export async function setExportSessionNamePrefixEnabled(enabled: boolean): Promise<void> {
+  await config.set(CONFIG_KEYS.EXPORT_SESSION_NAME_PREFIX_ENABLED, enabled)
+}
+
+export async function getExportLastSessionRunMap(): Promise<Record<string, number>> {
+  const value = await config.get(CONFIG_KEYS.EXPORT_LAST_SESSION_RUN_MAP)
+  if (!value || typeof value !== 'object') return {}
+  const entries = Object.entries(value as Record<string, unknown>)
+  const map: Record<string, number> = {}
+  for (const [sessionId, raw] of entries) {
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+      map[sessionId] = raw
+    }
+  }
+  return map
+}
+
+export async function setExportLastSessionRunMap(map: Record<string, number>): Promise<void> {
+  await config.set(CONFIG_KEYS.EXPORT_LAST_SESSION_RUN_MAP, map)
+}
+
+export async function getExportLastContentRunMap(): Promise<Record<string, number>> {
+  const value = await config.get(CONFIG_KEYS.EXPORT_LAST_CONTENT_RUN_MAP)
+  if (!value || typeof value !== 'object') return {}
+  const entries = Object.entries(value as Record<string, unknown>)
+  const map: Record<string, number> = {}
+  for (const [key, raw] of entries) {
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+      map[key] = raw
+    }
+  }
+  return map
+}
+
+export async function setExportLastContentRunMap(map: Record<string, number>): Promise<void> {
+  await config.set(CONFIG_KEYS.EXPORT_LAST_CONTENT_RUN_MAP, map)
+}
+
+export interface ExportSessionRecordEntry {
+  exportTime: number
+  content: string
+  outputDir: string
+}
+
+export async function getExportSessionRecordMap(): Promise<Record<string, ExportSessionRecordEntry[]>> {
+  const value = await config.get(CONFIG_KEYS.EXPORT_SESSION_RECORD_MAP)
+  if (!value || typeof value !== 'object') return {}
+  const map: Record<string, ExportSessionRecordEntry[]> = {}
+  const entries = Object.entries(value as Record<string, unknown>)
+  for (const [sessionId, rawList] of entries) {
+    if (!Array.isArray(rawList)) continue
+    const normalizedList: ExportSessionRecordEntry[] = []
+    for (const rawItem of rawList) {
+      if (!rawItem || typeof rawItem !== 'object') continue
+      const exportTime = Number((rawItem as Record<string, unknown>).exportTime)
+      const content = String((rawItem as Record<string, unknown>).content || '').trim()
+      const outputDir = String((rawItem as Record<string, unknown>).outputDir || '').trim()
+      if (!Number.isFinite(exportTime) || exportTime <= 0) continue
+      if (!content || !outputDir) continue
+      normalizedList.push({
+        exportTime: Math.floor(exportTime),
+        content,
+        outputDir
+      })
+    }
+    if (normalizedList.length > 0) {
+      map[sessionId] = normalizedList
+    }
+  }
+  return map
+}
+
+export async function setExportSessionRecordMap(map: Record<string, ExportSessionRecordEntry[]>): Promise<void> {
+  await config.set(CONFIG_KEYS.EXPORT_SESSION_RECORD_MAP, map)
+}
+
+export async function getExportLastSnsPostCount(): Promise<number> {
+  const value = await config.get(CONFIG_KEYS.EXPORT_LAST_SNS_POST_COUNT)
+  if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
+    return Math.floor(value)
+  }
+  return 0
+}
+
+export async function setExportLastSnsPostCount(count: number): Promise<void> {
+  const normalized = Number.isFinite(count) ? Math.max(0, Math.floor(count)) : 0
+  await config.set(CONFIG_KEYS.EXPORT_LAST_SNS_POST_COUNT, normalized)
+}
+
+export interface ExportSessionMessageCountCacheItem {
+  updatedAt: number
+  counts: Record<string, number>
+}
+
+export interface ExportSessionContentMetricCacheEntry {
+  totalMessages?: number
+  voiceMessages?: number
+  imageMessages?: number
+  videoMessages?: number
+  emojiMessages?: number
+}
+
+export interface ExportSessionContentMetricCacheItem {
+  updatedAt: number
+  metrics: Record<string, ExportSessionContentMetricCacheEntry>
+}
+
+export interface ExportSnsStatsCacheItem {
+  updatedAt: number
+  totalPosts: number
+  totalFriends: number
+}
+
+export interface ExportSnsUserPostCountsCacheItem {
+  updatedAt: number
+  counts: Record<string, number>
+}
+
+export interface SnsPageOverviewCache {
+  totalPosts: number
+  totalFriends: number
+  myPosts: number | null
+  earliestTime: number | null
+  latestTime: number | null
+}
+
+export interface SnsPageCacheItem {
+  updatedAt: number
+  overviewStats: SnsPageOverviewCache
+  posts: unknown[]
+}
+
+export interface ContactsListCacheContact {
+  username: string
+  displayName: string
+  remark?: string
+  nickname?: string
+  type: 'friend' | 'group' | 'official' | 'former_friend' | 'other'
+}
+
+export interface ContactsListCacheItem {
+  updatedAt: number
+  contacts: ContactsListCacheContact[]
+}
+
+export interface ContactsAvatarCacheEntry {
+  avatarUrl: string
+  updatedAt: number
+  checkedAt: number
+}
+
+export interface ContactsAvatarCacheItem {
+  updatedAt: number
+  avatars: Record<string, ContactsAvatarCacheEntry>
+}
+
+export async function getExportSessionMessageCountCache(scopeKey: string): Promise<ExportSessionMessageCountCacheItem | null> {
+  if (!scopeKey) return null
+  const value = await config.get(CONFIG_KEYS.EXPORT_SESSION_MESSAGE_COUNT_CACHE_MAP)
+  if (!value || typeof value !== 'object') return null
+  const rawMap = value as Record<string, unknown>
+  const rawItem = rawMap[scopeKey]
+  if (!rawItem || typeof rawItem !== 'object') return null
+
+  const rawUpdatedAt = (rawItem as Record<string, unknown>).updatedAt
+  const rawCounts = (rawItem as Record<string, unknown>).counts
+  if (!rawCounts || typeof rawCounts !== 'object') return null
+
+  const counts: Record<string, number> = {}
+  for (const [sessionId, countRaw] of Object.entries(rawCounts as Record<string, unknown>)) {
+    if (typeof countRaw === 'number' && Number.isFinite(countRaw) && countRaw >= 0) {
+      counts[sessionId] = Math.floor(countRaw)
+    }
+  }
+
+  return {
+    updatedAt: typeof rawUpdatedAt === 'number' && Number.isFinite(rawUpdatedAt) ? rawUpdatedAt : 0,
+    counts
+  }
+}
+
+export async function setExportSessionMessageCountCache(scopeKey: string, counts: Record<string, number>): Promise<void> {
+  if (!scopeKey) return
+  const current = await config.get(CONFIG_KEYS.EXPORT_SESSION_MESSAGE_COUNT_CACHE_MAP)
+  const map = current && typeof current === 'object'
+    ? { ...(current as Record<string, unknown>) }
+    : {}
+
+  const normalized: Record<string, number> = {}
+  for (const [sessionId, countRaw] of Object.entries(counts || {})) {
+    if (typeof countRaw === 'number' && Number.isFinite(countRaw) && countRaw >= 0) {
+      normalized[sessionId] = Math.floor(countRaw)
+    }
+  }
+
+  map[scopeKey] = {
+    updatedAt: Date.now(),
+    counts: normalized
+  }
+  await config.set(CONFIG_KEYS.EXPORT_SESSION_MESSAGE_COUNT_CACHE_MAP, map)
+}
+
+export async function getExportSessionContentMetricCache(scopeKey: string): Promise<ExportSessionContentMetricCacheItem | null> {
+  if (!scopeKey) return null
+  const value = await config.get(CONFIG_KEYS.EXPORT_SESSION_CONTENT_METRIC_CACHE_MAP)
+  if (!value || typeof value !== 'object') return null
+  const rawMap = value as Record<string, unknown>
+  const rawItem = rawMap[scopeKey]
+  if (!rawItem || typeof rawItem !== 'object') return null
+
+  const rawUpdatedAt = (rawItem as Record<string, unknown>).updatedAt
+  const rawMetrics = (rawItem as Record<string, unknown>).metrics
+  if (!rawMetrics || typeof rawMetrics !== 'object') return null
+
+  const metrics: Record<string, ExportSessionContentMetricCacheEntry> = {}
+  for (const [sessionId, rawMetric] of Object.entries(rawMetrics as Record<string, unknown>)) {
+    if (!rawMetric || typeof rawMetric !== 'object') continue
+    const source = rawMetric as Record<string, unknown>
+    const metric: ExportSessionContentMetricCacheEntry = {}
+    if (typeof source.totalMessages === 'number' && Number.isFinite(source.totalMessages) && source.totalMessages >= 0) {
+      metric.totalMessages = Math.floor(source.totalMessages)
+    }
+    if (typeof source.voiceMessages === 'number' && Number.isFinite(source.voiceMessages) && source.voiceMessages >= 0) {
+      metric.voiceMessages = Math.floor(source.voiceMessages)
+    }
+    if (typeof source.imageMessages === 'number' && Number.isFinite(source.imageMessages) && source.imageMessages >= 0) {
+      metric.imageMessages = Math.floor(source.imageMessages)
+    }
+    if (typeof source.videoMessages === 'number' && Number.isFinite(source.videoMessages) && source.videoMessages >= 0) {
+      metric.videoMessages = Math.floor(source.videoMessages)
+    }
+    if (typeof source.emojiMessages === 'number' && Number.isFinite(source.emojiMessages) && source.emojiMessages >= 0) {
+      metric.emojiMessages = Math.floor(source.emojiMessages)
+    }
+    if (Object.keys(metric).length === 0) continue
+    metrics[sessionId] = metric
+  }
+
+  return {
+    updatedAt: typeof rawUpdatedAt === 'number' && Number.isFinite(rawUpdatedAt) ? rawUpdatedAt : 0,
+    metrics
+  }
+}
+
+export async function setExportSessionContentMetricCache(
+  scopeKey: string,
+  metrics: Record<string, ExportSessionContentMetricCacheEntry>
+): Promise<void> {
+  if (!scopeKey) return
+  const current = await config.get(CONFIG_KEYS.EXPORT_SESSION_CONTENT_METRIC_CACHE_MAP)
+  const map = current && typeof current === 'object'
+    ? { ...(current as Record<string, unknown>) }
+    : {}
+
+  const normalized: Record<string, ExportSessionContentMetricCacheEntry> = {}
+  for (const [sessionId, rawMetric] of Object.entries(metrics || {})) {
+    if (!rawMetric || typeof rawMetric !== 'object') continue
+    const metric: ExportSessionContentMetricCacheEntry = {}
+    if (typeof rawMetric.totalMessages === 'number' && Number.isFinite(rawMetric.totalMessages) && rawMetric.totalMessages >= 0) {
+      metric.totalMessages = Math.floor(rawMetric.totalMessages)
+    }
+    if (typeof rawMetric.voiceMessages === 'number' && Number.isFinite(rawMetric.voiceMessages) && rawMetric.voiceMessages >= 0) {
+      metric.voiceMessages = Math.floor(rawMetric.voiceMessages)
+    }
+    if (typeof rawMetric.imageMessages === 'number' && Number.isFinite(rawMetric.imageMessages) && rawMetric.imageMessages >= 0) {
+      metric.imageMessages = Math.floor(rawMetric.imageMessages)
+    }
+    if (typeof rawMetric.videoMessages === 'number' && Number.isFinite(rawMetric.videoMessages) && rawMetric.videoMessages >= 0) {
+      metric.videoMessages = Math.floor(rawMetric.videoMessages)
+    }
+    if (typeof rawMetric.emojiMessages === 'number' && Number.isFinite(rawMetric.emojiMessages) && rawMetric.emojiMessages >= 0) {
+      metric.emojiMessages = Math.floor(rawMetric.emojiMessages)
+    }
+    if (Object.keys(metric).length === 0) continue
+    normalized[sessionId] = metric
+  }
+
+  map[scopeKey] = {
+    updatedAt: Date.now(),
+    metrics: normalized
+  }
+  await config.set(CONFIG_KEYS.EXPORT_SESSION_CONTENT_METRIC_CACHE_MAP, map)
+}
+
+export async function getExportSnsStatsCache(scopeKey: string): Promise<ExportSnsStatsCacheItem | null> {
+  if (!scopeKey) return null
+  const value = await config.get(CONFIG_KEYS.EXPORT_SNS_STATS_CACHE_MAP)
+  if (!value || typeof value !== 'object') return null
+  const rawMap = value as Record<string, unknown>
+  const rawItem = rawMap[scopeKey]
+  if (!rawItem || typeof rawItem !== 'object') return null
+
+  const raw = rawItem as Record<string, unknown>
+  const totalPosts = typeof raw.totalPosts === 'number' && Number.isFinite(raw.totalPosts) && raw.totalPosts >= 0
+    ? Math.floor(raw.totalPosts)
+    : 0
+  const totalFriends = typeof raw.totalFriends === 'number' && Number.isFinite(raw.totalFriends) && raw.totalFriends >= 0
+    ? Math.floor(raw.totalFriends)
+    : 0
+  const updatedAt = typeof raw.updatedAt === 'number' && Number.isFinite(raw.updatedAt)
+    ? raw.updatedAt
+    : 0
+
+  return { updatedAt, totalPosts, totalFriends }
+}
+
+export async function setExportSnsStatsCache(
+  scopeKey: string,
+  stats: { totalPosts: number; totalFriends: number }
+): Promise<void> {
+  if (!scopeKey) return
+  const current = await config.get(CONFIG_KEYS.EXPORT_SNS_STATS_CACHE_MAP)
+  const map = current && typeof current === 'object'
+    ? { ...(current as Record<string, unknown>) }
+    : {}
+
+  map[scopeKey] = {
+    updatedAt: Date.now(),
+    totalPosts: Number.isFinite(stats.totalPosts) ? Math.max(0, Math.floor(stats.totalPosts)) : 0,
+    totalFriends: Number.isFinite(stats.totalFriends) ? Math.max(0, Math.floor(stats.totalFriends)) : 0
+  }
+
+  await config.set(CONFIG_KEYS.EXPORT_SNS_STATS_CACHE_MAP, map)
+}
+
+export async function getExportSnsUserPostCountsCache(scopeKey: string): Promise<ExportSnsUserPostCountsCacheItem | null> {
+  if (!scopeKey) return null
+  const value = await config.get(CONFIG_KEYS.EXPORT_SNS_USER_POST_COUNTS_CACHE_MAP)
+  if (!value || typeof value !== 'object') return null
+  const rawMap = value as Record<string, unknown>
+  const rawItem = rawMap[scopeKey]
+  if (!rawItem || typeof rawItem !== 'object') return null
+
+  const raw = rawItem as Record<string, unknown>
+  const rawCounts = raw.counts
+  if (!rawCounts || typeof rawCounts !== 'object') return null
+
+  const counts: Record<string, number> = {}
+  for (const [rawUsername, rawCount] of Object.entries(rawCounts as Record<string, unknown>)) {
+    const username = String(rawUsername || '').trim()
+    if (!username) continue
+    const valueNum = Number(rawCount)
+    counts[username] = Number.isFinite(valueNum) ? Math.max(0, Math.floor(valueNum)) : 0
+  }
+
+  const updatedAt = typeof raw.updatedAt === 'number' && Number.isFinite(raw.updatedAt)
+    ? raw.updatedAt
+    : 0
+  return { updatedAt, counts }
+}
+
+export async function setExportSnsUserPostCountsCache(
+  scopeKey: string,
+  counts: Record<string, number>
+): Promise<void> {
+  if (!scopeKey) return
+  const current = await config.get(CONFIG_KEYS.EXPORT_SNS_USER_POST_COUNTS_CACHE_MAP)
+  const map = current && typeof current === 'object'
+    ? { ...(current as Record<string, unknown>) }
+    : {}
+
+  const normalized: Record<string, number> = {}
+  for (const [rawUsername, rawCount] of Object.entries(counts || {})) {
+    const username = String(rawUsername || '').trim()
+    if (!username) continue
+    const valueNum = Number(rawCount)
+    normalized[username] = Number.isFinite(valueNum) ? Math.max(0, Math.floor(valueNum)) : 0
+  }
+
+  map[scopeKey] = {
+    updatedAt: Date.now(),
+    counts: normalized
+  }
+
+  await config.set(CONFIG_KEYS.EXPORT_SNS_USER_POST_COUNTS_CACHE_MAP, map)
+}
+
+export async function getSnsPageCache(scopeKey: string): Promise<SnsPageCacheItem | null> {
+  if (!scopeKey) return null
+  const value = await config.get(CONFIG_KEYS.SNS_PAGE_CACHE_MAP)
+  if (!value || typeof value !== 'object') return null
+  const rawMap = value as Record<string, unknown>
+  const rawItem = rawMap[scopeKey]
+  if (!rawItem || typeof rawItem !== 'object') return null
+
+  const raw = rawItem as Record<string, unknown>
+  const rawOverview = raw.overviewStats
+  const rawPosts = raw.posts
+  if (!rawOverview || typeof rawOverview !== 'object' || !Array.isArray(rawPosts)) return null
+
+  const overviewObj = rawOverview as Record<string, unknown>
+  const normalizeNumber = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) ? Math.floor(v) : 0)
+  const normalizeNullableTimestamp = (v: unknown) => {
+    if (v === null || v === undefined) return null
+    if (typeof v === 'number' && Number.isFinite(v) && v > 0) return Math.floor(v)
+    return null
+  }
+  const normalizeNullableCount = (v: unknown) => {
+    if (v === null || v === undefined) return null
+    if (typeof v === 'number' && Number.isFinite(v) && v >= 0) return Math.floor(v)
+    return null
+  }
+
+  return {
+    updatedAt: typeof raw.updatedAt === 'number' && Number.isFinite(raw.updatedAt) ? raw.updatedAt : 0,
+    overviewStats: {
+      totalPosts: Math.max(0, normalizeNumber(overviewObj.totalPosts)),
+      totalFriends: Math.max(0, normalizeNumber(overviewObj.totalFriends)),
+      myPosts: normalizeNullableCount(overviewObj.myPosts),
+      earliestTime: normalizeNullableTimestamp(overviewObj.earliestTime),
+      latestTime: normalizeNullableTimestamp(overviewObj.latestTime)
+    },
+    posts: rawPosts
+  }
+}
+
+export async function setSnsPageCache(
+  scopeKey: string,
+  payload: { overviewStats: SnsPageOverviewCache; posts: unknown[] }
+): Promise<void> {
+  if (!scopeKey) return
+  const current = await config.get(CONFIG_KEYS.SNS_PAGE_CACHE_MAP)
+  const map = current && typeof current === 'object'
+    ? { ...(current as Record<string, unknown>) }
+    : {}
+
+  const normalizeNumber = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) ? Math.max(0, Math.floor(v)) : 0)
+  const normalizeNullableTimestamp = (v: unknown) => {
+    if (v === null || v === undefined) return null
+    if (typeof v === 'number' && Number.isFinite(v) && v > 0) return Math.floor(v)
+    return null
+  }
+  const normalizeNullableCount = (v: unknown) => {
+    if (v === null || v === undefined) return null
+    if (typeof v === 'number' && Number.isFinite(v) && v >= 0) return Math.floor(v)
+    return null
+  }
+
+  map[scopeKey] = {
+    updatedAt: Date.now(),
+    overviewStats: {
+      totalPosts: normalizeNumber(payload?.overviewStats?.totalPosts),
+      totalFriends: normalizeNumber(payload?.overviewStats?.totalFriends),
+      myPosts: normalizeNullableCount(payload?.overviewStats?.myPosts),
+      earliestTime: normalizeNullableTimestamp(payload?.overviewStats?.earliestTime),
+      latestTime: normalizeNullableTimestamp(payload?.overviewStats?.latestTime)
+    },
+    posts: Array.isArray(payload?.posts) ? payload.posts : []
+  }
+
+  await config.set(CONFIG_KEYS.SNS_PAGE_CACHE_MAP, map)
+}
+
+// 获取通讯录加载超时阈值（毫秒）
+export async function getContactsLoadTimeoutMs(): Promise<number> {
+  const value = await config.get(CONFIG_KEYS.CONTACTS_LOAD_TIMEOUT_MS)
+  if (typeof value === 'number' && Number.isFinite(value) && value >= 1000 && value <= 60000) {
+    return Math.floor(value)
+  }
+  return 3000
+}
+
+// 设置通讯录加载超时阈值（毫秒）
+export async function setContactsLoadTimeoutMs(timeoutMs: number): Promise<void> {
+  const normalized = Number.isFinite(timeoutMs)
+    ? Math.min(60000, Math.max(1000, Math.floor(timeoutMs)))
+    : 3000
+  await config.set(CONFIG_KEYS.CONTACTS_LOAD_TIMEOUT_MS, normalized)
+}
+
+export async function getContactsListCache(scopeKey: string): Promise<ContactsListCacheItem | null> {
+  if (!scopeKey) return null
+  const value = await config.get(CONFIG_KEYS.CONTACTS_LIST_CACHE_MAP)
+  if (!value || typeof value !== 'object') return null
+  const rawMap = value as Record<string, unknown>
+  const rawItem = rawMap[scopeKey]
+  if (!rawItem || typeof rawItem !== 'object') return null
+
+  const rawUpdatedAt = (rawItem as Record<string, unknown>).updatedAt
+  const rawContacts = (rawItem as Record<string, unknown>).contacts
+  if (!Array.isArray(rawContacts)) return null
+
+  const contacts: ContactsListCacheContact[] = []
+  for (const raw of rawContacts) {
+    if (!raw || typeof raw !== 'object') continue
+    const item = raw as Record<string, unknown>
+    const username = typeof item.username === 'string' ? item.username.trim() : ''
+    if (!username) continue
+    const displayName = typeof item.displayName === 'string' ? item.displayName : username
+    const type = typeof item.type === 'string' ? item.type : 'other'
+    contacts.push({
+      username,
+      displayName,
+      remark: typeof item.remark === 'string' ? item.remark : undefined,
+      nickname: typeof item.nickname === 'string' ? item.nickname : undefined,
+      type: (type === 'friend' || type === 'group' || type === 'official' || type === 'former_friend' || type === 'other')
+        ? type
+        : 'other'
+    })
+  }
+
+  return {
+    updatedAt: typeof rawUpdatedAt === 'number' && Number.isFinite(rawUpdatedAt) ? rawUpdatedAt : 0,
+    contacts
+  }
+}
+
+export async function setContactsListCache(scopeKey: string, contacts: ContactsListCacheContact[]): Promise<void> {
+  if (!scopeKey) return
+  const current = await config.get(CONFIG_KEYS.CONTACTS_LIST_CACHE_MAP)
+  const map = current && typeof current === 'object'
+    ? { ...(current as Record<string, unknown>) }
+    : {}
+
+  const normalized: ContactsListCacheContact[] = []
+  for (const contact of contacts || []) {
+    const username = String(contact?.username || '').trim()
+    if (!username) continue
+    const displayName = String(contact?.displayName || username)
+    const type = contact?.type || 'other'
+    if (type !== 'friend' && type !== 'group' && type !== 'official' && type !== 'former_friend' && type !== 'other') {
+      continue
+    }
+    normalized.push({
+      username,
+      displayName,
+      remark: contact?.remark ? String(contact.remark) : undefined,
+      nickname: contact?.nickname ? String(contact.nickname) : undefined,
+      type
+    })
+  }
+
+  map[scopeKey] = {
+    updatedAt: Date.now(),
+    contacts: normalized
+  }
+  await config.set(CONFIG_KEYS.CONTACTS_LIST_CACHE_MAP, map)
+}
+
+export async function getContactsAvatarCache(scopeKey: string): Promise<ContactsAvatarCacheItem | null> {
+  if (!scopeKey) return null
+  const value = await config.get(CONFIG_KEYS.CONTACTS_AVATAR_CACHE_MAP)
+  if (!value || typeof value !== 'object') return null
+  const rawMap = value as Record<string, unknown>
+  const rawItem = rawMap[scopeKey]
+  if (!rawItem || typeof rawItem !== 'object') return null
+
+  const rawUpdatedAt = (rawItem as Record<string, unknown>).updatedAt
+  const rawAvatars = (rawItem as Record<string, unknown>).avatars
+  if (!rawAvatars || typeof rawAvatars !== 'object') return null
+
+  const avatars: Record<string, ContactsAvatarCacheEntry> = {}
+  for (const [rawUsername, rawEntry] of Object.entries(rawAvatars as Record<string, unknown>)) {
+    const username = rawUsername.trim()
+    if (!username) continue
+
+    if (typeof rawEntry === 'string') {
+      const avatarUrl = rawEntry.trim()
+      if (!avatarUrl) continue
+      avatars[username] = {
+        avatarUrl,
+        updatedAt: typeof rawUpdatedAt === 'number' && Number.isFinite(rawUpdatedAt) ? rawUpdatedAt : 0,
+        checkedAt: typeof rawUpdatedAt === 'number' && Number.isFinite(rawUpdatedAt) ? rawUpdatedAt : 0
+      }
+      continue
+    }
+
+    if (!rawEntry || typeof rawEntry !== 'object') continue
+    const entry = rawEntry as Record<string, unknown>
+    const avatarUrl = typeof entry.avatarUrl === 'string' ? entry.avatarUrl.trim() : ''
+    if (!avatarUrl) continue
+    const updatedAt = typeof entry.updatedAt === 'number' && Number.isFinite(entry.updatedAt)
+      ? entry.updatedAt
+      : 0
+    const checkedAt = typeof entry.checkedAt === 'number' && Number.isFinite(entry.checkedAt)
+      ? entry.checkedAt
+      : updatedAt
+
+    avatars[username] = {
+      avatarUrl,
+      updatedAt,
+      checkedAt
+    }
+  }
+
+  return {
+    updatedAt: typeof rawUpdatedAt === 'number' && Number.isFinite(rawUpdatedAt) ? rawUpdatedAt : 0,
+    avatars
+  }
+}
+
+export async function setContactsAvatarCache(
+  scopeKey: string,
+  avatars: Record<string, ContactsAvatarCacheEntry>
+): Promise<void> {
+  if (!scopeKey) return
+  const current = await config.get(CONFIG_KEYS.CONTACTS_AVATAR_CACHE_MAP)
+  const map = current && typeof current === 'object'
+    ? { ...(current as Record<string, unknown>) }
+    : {}
+
+  const normalized: Record<string, ContactsAvatarCacheEntry> = {}
+  for (const [rawUsername, rawEntry] of Object.entries(avatars || {})) {
+    const username = String(rawUsername || '').trim()
+    if (!username || !rawEntry || typeof rawEntry !== 'object') continue
+    const avatarUrl = String(rawEntry.avatarUrl || '').trim()
+    if (!avatarUrl) continue
+    const updatedAt = Number.isFinite(rawEntry.updatedAt)
+      ? Math.max(0, Math.floor(rawEntry.updatedAt))
+      : Date.now()
+    const checkedAt = Number.isFinite(rawEntry.checkedAt)
+      ? Math.max(0, Math.floor(rawEntry.checkedAt))
+      : updatedAt
+    normalized[username] = {
+      avatarUrl,
+      updatedAt,
+      checkedAt
+    }
+  }
+
+  map[scopeKey] = {
+    updatedAt: Date.now(),
+    avatars: normalized
+  }
+  await config.set(CONFIG_KEYS.CONTACTS_AVATAR_CACHE_MAP, map)
+}
+
 // === 安全相关 ===
 
 export async function getAuthEnabled(): Promise<boolean> {
@@ -482,3 +1198,26 @@ export async function getWordCloudExcludeWords(): Promise<string[]> {
 export async function setWordCloudExcludeWords(words: string[]): Promise<void> {
   await config.set(CONFIG_KEYS.WORD_CLOUD_EXCLUDE_WORDS, words)
 }
+
+// 获取数据收集同意状态
+export async function getAnalyticsConsent(): Promise<boolean | null> {
+  const value = await config.get(CONFIG_KEYS.ANALYTICS_CONSENT)
+  if (typeof value === 'boolean') return value
+  return null
+}
+
+// 设置数据收集同意状态
+export async function setAnalyticsConsent(consent: boolean): Promise<void> {
+  await config.set(CONFIG_KEYS.ANALYTICS_CONSENT, consent)
+}
+
+// 获取数据收集拒绝次数
+export async function getAnalyticsDenyCount(): Promise<number> {
+  const value = await config.get(CONFIG_KEYS.ANALYTICS_DENY_COUNT)
+  return typeof value === 'number' ? value : 0
+}
+
+// 设置数据收集拒绝次数
+export async function setAnalyticsDenyCount(count: number): Promise<void> {
+  await config.set(CONFIG_KEYS.ANALYTICS_DENY_COUNT, count)
+}

src/services/exportBridge.ts

@@ -0,0 +1,85 @@
+export interface OpenSingleExportPayload {
+  sessionId: string
+  sessionName?: string
+  requestId?: string
+}
+
+export interface ExportSessionStatusPayload {
+  inProgressSessionIds: string[]
+  activeTaskCount: number
+}
+
+export interface SingleExportDialogStatusPayload {
+  requestId: string
+  status: 'initializing' | 'opened' | 'failed'
+  message?: string
+}
+
+const OPEN_SINGLE_EXPORT_EVENT = 'weflow:open-single-export'
+const EXPORT_SESSION_STATUS_EVENT = 'weflow:export-session-status'
+const EXPORT_SESSION_STATUS_REQUEST_EVENT = 'weflow:export-session-status-request'
+const SINGLE_EXPORT_DIALOG_STATUS_EVENT = 'weflow:single-export-dialog-status'
+
+export const emitOpenSingleExport = (payload: OpenSingleExportPayload) => {
+  window.dispatchEvent(new CustomEvent<OpenSingleExportPayload>(OPEN_SINGLE_EXPORT_EVENT, {
+    detail: payload
+  }))
+}
+
+export const onOpenSingleExport = (
+  listener: (payload: OpenSingleExportPayload) => void
+): (() => void) => {
+  const handler = (event: Event) => {
+    const customEvent = event as CustomEvent<OpenSingleExportPayload>
+    listener(customEvent.detail)
+  }
+
+  window.addEventListener(OPEN_SINGLE_EXPORT_EVENT, handler as EventListener)
+  return () => window.removeEventListener(OPEN_SINGLE_EXPORT_EVENT, handler as EventListener)
+}
+
+export const emitExportSessionStatus = (payload: ExportSessionStatusPayload) => {
+  window.dispatchEvent(new CustomEvent<ExportSessionStatusPayload>(EXPORT_SESSION_STATUS_EVENT, {
+    detail: payload
+  }))
+}
+
+export const onExportSessionStatus = (
+  listener: (payload: ExportSessionStatusPayload) => void
+): (() => void) => {
+  const handler = (event: Event) => {
+    const customEvent = event as CustomEvent<ExportSessionStatusPayload>
+    listener(customEvent.detail)
+  }
+
+  window.addEventListener(EXPORT_SESSION_STATUS_EVENT, handler as EventListener)
+  return () => window.removeEventListener(EXPORT_SESSION_STATUS_EVENT, handler as EventListener)
+}
+
+export const requestExportSessionStatus = () => {
+  window.dispatchEvent(new CustomEvent(EXPORT_SESSION_STATUS_REQUEST_EVENT))
+}
+
+export const onExportSessionStatusRequest = (listener: () => void): (() => void) => {
+  const handler = () => listener()
+  window.addEventListener(EXPORT_SESSION_STATUS_REQUEST_EVENT, handler)
+  return () => window.removeEventListener(EXPORT_SESSION_STATUS_REQUEST_EVENT, handler)
+}
+
+export const emitSingleExportDialogStatus = (payload: SingleExportDialogStatusPayload) => {
+  window.dispatchEvent(new CustomEvent<SingleExportDialogStatusPayload>(SINGLE_EXPORT_DIALOG_STATUS_EVENT, {
+    detail: payload
+  }))
+}
+
+export const onSingleExportDialogStatus = (
+  listener: (payload: SingleExportDialogStatusPayload) => void
+): (() => void) => {
+  const handler = (event: Event) => {
+    const customEvent = event as CustomEvent<SingleExportDialogStatusPayload>
+    listener(customEvent.detail)
+  }
+
+  window.addEventListener(SINGLE_EXPORT_DIALOG_STATUS_EVENT, handler as EventListener)
+  return () => window.removeEventListener(SINGLE_EXPORT_DIALOG_STATUS_EVENT, handler as EventListener)
+}

src/stores/chatStore.ts

@@ -32,7 +32,7 @@ export interface ChatState {
   setConnectionError: (error: string | null) => void
   setSessions: (sessions: ChatSession[]) => void
   setFilteredSessions: (sessions: ChatSession[]) => void
-  setCurrentSession: (sessionId: string | null) => void
+  setCurrentSession: (sessionId: string | null, options?: { preserveMessages?: boolean }) => void
   setLoadingSessions: (loading: boolean) => void
   setMessages: (messages: Message[]) => void
   appendMessages: (messages: Message[], prepend?: boolean) => void
@@ -69,12 +69,12 @@ export const useChatStore = create<ChatState>((set, get) => ({
   setSessions: (sessions) => set({ sessions, filteredSessions: sessions }),
   setFilteredSessions: (sessions) => set({ filteredSessions: sessions }),
 
-  setCurrentSession: (sessionId) => set({
+  setCurrentSession: (sessionId, options) => set((state) => ({
     currentSessionId: sessionId,
-    messages: [],
+    messages: options?.preserveMessages ? state.messages : [],
     hasMoreMessages: true,
     hasMoreLater: false
-  }),
+  })),
 
   setLoadingSessions: (loading) => set({ isLoadingSessions: loading }),
 
@@ -86,15 +86,16 @@ export const useChatStore = create<ChatState>((set, get) => ({
       if (m.localId && m.localId > 0) return `l:${m.localId}`
       return `t:${m.createTime}:${m.sortSeq || 0}:${m.serverId || 0}`
     }
-    const existingKeys = new Set(state.messages.map(getMsgKey))
+    const currentMessages = state.messages || []
+    const existingKeys = new Set(currentMessages.map(getMsgKey))
     const filtered = newMessages.filter(m => !existingKeys.has(getMsgKey(m)))
 
     if (filtered.length === 0) return state
 
     return {
       messages: prepend
-        ? [...filtered, ...state.messages]
-        : [...state.messages, ...filtered]
+        ? [...filtered, ...currentMessages]
+        : [...currentMessages, ...filtered]
     }
   }),
 

src/stores/contactTypeCountsStore.ts

@@ -0,0 +1,115 @@
+import { create } from 'zustand'
+import type { ContactInfo } from '../types/models'
+
+export interface ContactTypeTabCounts {
+  private: number
+  group: number
+  official: number
+  former_friend: number
+}
+
+export interface ContactTypeCardCounts {
+  friends: number
+  groups: number
+  officials: number
+  deletedFriends: number
+}
+
+const emptyTabCounts: ContactTypeTabCounts = {
+  private: 0,
+  group: 0,
+  official: 0,
+  former_friend: 0
+}
+
+let inflightPromise: Promise<ContactTypeTabCounts> | null = null
+
+const normalizeCounts = (counts?: Partial<ContactTypeTabCounts> | null): ContactTypeTabCounts => {
+  return {
+    private: Number.isFinite(counts?.private) ? Math.max(0, Math.floor(Number(counts?.private))) : 0,
+    group: Number.isFinite(counts?.group) ? Math.max(0, Math.floor(Number(counts?.group))) : 0,
+    official: Number.isFinite(counts?.official) ? Math.max(0, Math.floor(Number(counts?.official))) : 0,
+    former_friend: Number.isFinite(counts?.former_friend) ? Math.max(0, Math.floor(Number(counts?.former_friend))) : 0
+  }
+}
+
+export const toContactTypeTabCountsFromContacts = (contacts: ContactInfo[]): ContactTypeTabCounts => {
+  const next = { ...emptyTabCounts }
+  for (const contact of contacts || []) {
+    if (contact.type === 'friend') next.private += 1
+    if (contact.type === 'group') next.group += 1
+    if (contact.type === 'official') next.official += 1
+    if (contact.type === 'former_friend') next.former_friend += 1
+  }
+  return next
+}
+
+export const toContactTypeCardCounts = (counts: ContactTypeTabCounts): ContactTypeCardCounts => {
+  return {
+    friends: counts.private,
+    groups: counts.group,
+    officials: counts.official,
+    deletedFriends: counts.former_friend
+  }
+}
+
+interface ContactTypeCountsState {
+  tabCounts: ContactTypeTabCounts
+  isLoading: boolean
+  isReady: boolean
+  updatedAt: number
+  setTabCounts: (counts: ContactTypeTabCounts) => void
+  syncFromContacts: (contacts: ContactInfo[]) => void
+  ensureLoaded: (options?: { force?: boolean }) => Promise<ContactTypeTabCounts>
+}
+
+export const useContactTypeCountsStore = create<ContactTypeCountsState>((set, get) => ({
+  tabCounts: { ...emptyTabCounts },
+  isLoading: false,
+  isReady: false,
+  updatedAt: 0,
+  setTabCounts: (counts) => {
+    const normalized = normalizeCounts(counts)
+    set({
+      tabCounts: normalized,
+      isReady: true,
+      updatedAt: Date.now()
+    })
+  },
+  syncFromContacts: (contacts) => {
+    const fromContacts = toContactTypeTabCountsFromContacts(contacts || [])
+    get().setTabCounts(fromContacts)
+  },
+  ensureLoaded: async (options) => {
+    if (!options?.force && get().isReady) {
+      return get().tabCounts
+    }
+    if (inflightPromise) {
+      return inflightPromise
+    }
+
+    set({ isLoading: true })
+    inflightPromise = (async () => {
+      try {
+        const result = await window.electronAPI.chat.getContactTypeCounts()
+        if (result?.success && result.counts) {
+          const normalized = normalizeCounts(result.counts)
+          set({
+            tabCounts: normalized,
+            isReady: true,
+            updatedAt: Date.now()
+          })
+          return normalized
+        }
+      } catch (error) {
+        console.error('加载联系人类型计数失败:', error)
+      }
+      return get().tabCounts
+    })().finally(() => {
+      inflightPromise = null
+      set({ isLoading: false })
+    })
+
+    return inflightPromise
+  }
+}))

src/stores/themeStore.ts

@@ -1,7 +1,7 @@
 import { create } from 'zustand'
 import { persist } from 'zustand/middleware'
 
-export type ThemeId = 'cloud-dancer' | 'corundum-blue' | 'kiwi-green' | 'spicy-red' | 'teal-water'
+export type ThemeId = 'cloud-dancer' | 'corundum-blue' | 'kiwi-green' | 'spicy-red' | 'teal-water' | 'blossom-dream' | 'geist'
 export type ThemeMode = 'light' | 'dark' | 'system'
 
 export interface ThemeInfo {
@@ -10,6 +10,8 @@ export interface ThemeInfo {
   description: string
   primaryColor: string
   bgColor: string
+  // 可选副色，用于多彩主题的渐变预览
+  accentColor?: string
 }
 
 export const themes: ThemeInfo[] = [
@@ -20,6 +22,14 @@ export const themes: ThemeInfo[] = [
     primaryColor: '#8B7355',
     bgColor: '#F0EEE9'
   },
+  {
+    id: 'blossom-dream',
+    name: '繁花如梦',
+    description: '晨曦花境 · 夜阑幽梦',
+    primaryColor: '#D4849A',
+    bgColor: '#FCF9FB',
+    accentColor: '#FFBE98'
+  },
   {
     id: 'corundum-blue',
     name: '刚玉蓝',
@@ -47,6 +57,13 @@ export const themes: ThemeInfo[] = [
     description: 'RAL 180 80 10',
     primaryColor: '#5A8A8A',
     bgColor: '#E4F0F0'
+  },
+  {
+    id: 'geist',
+    name: 'Geist',
+    description: 'Vercel · 极简黑白',
+    primaryColor: '#000000',
+    bgColor: '#ffffff'
   }
 ]
 

src/styles/main.scss

@@ -39,6 +39,9 @@
   --card-bg: rgba(255, 255, 255, 0.7);
   --card-inner-bg: #FAFAF7;
   --sent-card-bg: var(--primary);
+
+  // primary 色上方的前景文字色（大多数主题为白色）
+  --on-primary: white;
 }
 
 // ==================== 浅色主题 ====================
@@ -153,6 +156,68 @@
   --sent-card-bg: var(--primary);
 }
 
+// 繁花如梦 - 浅色（晨曦花境）
+[data-theme="blossom-dream"][data-mode="light"],
+[data-theme="blossom-dream"]:not([data-mode]) {
+  // 三色定义（供伪元素光晕使用，饱和度提高以便在底色上可见）
+  --blossom-pink: #F0A0B8;
+  --blossom-peach: #FFB07A;
+  --blossom-blue: #90B8E0;
+
+  // 主品牌色：Pantone 粉晶 Rose Quartz
+  --primary: #D4849A;
+  --primary-rgb: 212, 132, 154;
+  --primary-hover: #C4748A;
+  --primary-light: rgba(212, 132, 154, 0.12);
+
+  // 背景三层：主背景最深（相对），面板次之，卡片最白
+  --bg-primary: #F5EDF2;
+  --bg-secondary: rgba(255, 255, 255, 0.82);
+  --bg-tertiary: rgba(212, 132, 154, 0.06);
+  --bg-hover: rgba(212, 132, 154, 0.09);
+
+  // 文字：提高对比度，主色接近纯黑只带微弱紫调
+  --text-primary: #1E1A22;
+  --text-secondary: #6B5F70;
+  --text-tertiary: #9A8A9E;
+  // 边框：粉色半透明，有存在感但不强硬
+  --border-color: rgba(212, 132, 154, 0.18);
+
+  --bg-gradient: linear-gradient(150deg, #F5EDF2 0%, #F0EAF6 50%, #EAF0F8 100%);
+  --primary-gradient: linear-gradient(135deg, #D4849A 0%, #E8A8B8 100%);
+
+  // 卡片：高不透明度白，与背景形成明显层次
+  --card-bg: rgba(255, 255, 255, 0.88);
+  --card-inner-bg: rgba(255, 255, 255, 0.95);
+
+  --sent-card-bg: var(--primary);
+}
+
+// Geist · 极简黑白 - 浅色
+[data-theme="geist"][data-mode="light"],
+[data-theme="geist"]:not([data-mode]) {
+  --primary: #444444;
+  --primary-rgb: 68, 68, 68;
+  --primary-hover: #333333;
+  --primary-light: rgba(68, 68, 68, 0.08);
+  --bg-primary: #ffffff;
+  --bg-secondary: rgba(250, 250, 250, 0.95);
+  --bg-tertiary: rgba(0, 0, 0, 0.03);
+  --bg-hover: rgba(0, 0, 0, 0.05);
+  --text-primary: #111111;
+  --text-secondary: #666666;
+  --text-tertiary: #999999;
+  --border-color: #eaeaea;
+  --border-radius: 6px;
+  --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.08);
+  --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.12);
+  --bg-gradient: linear-gradient(135deg, #ffffff 0%, #fafafa 100%);
+  --primary-gradient: linear-gradient(135deg, #444444 0%, #666666 100%);
+  --card-bg: rgba(250, 250, 250, 0.95);
+  --card-inner-bg: #f5f5f5;
+  --sent-card-bg: #444444;
+}
+
 // ==================== 深色主题 ====================
 
 // 云上舞白 - 深色
@@ -163,6 +228,7 @@
   --primary-light: rgba(201, 168, 108, 0.15);
   --bg-primary: #1a1816;
   --bg-secondary: rgba(40, 36, 32, 0.9);
+  --bg-secondary-solid: #282420;
   --bg-tertiary: rgba(255, 255, 255, 0.05);
   --bg-hover: rgba(255, 255, 255, 0.08);
   --text-primary: #F0EEE9;
@@ -184,6 +250,7 @@
   --primary-light: rgba(106, 154, 170, 0.15);
   --bg-primary: #141a1c;
   --bg-secondary: rgba(30, 40, 44, 0.9);
+  --bg-secondary-solid: #1e282c;
   --bg-tertiary: rgba(255, 255, 255, 0.05);
   --bg-hover: rgba(255, 255, 255, 0.08);
   --text-primary: #E8EEF0;
@@ -205,6 +272,7 @@
   --primary-light: rgba(154, 186, 124, 0.15);
   --bg-primary: #161a14;
   --bg-secondary: rgba(34, 42, 30, 0.9);
+  --bg-secondary-solid: #222a1e;
   --bg-tertiary: rgba(255, 255, 255, 0.05);
   --bg-hover: rgba(255, 255, 255, 0.08);
   --text-primary: #E8F0E4;
@@ -226,6 +294,7 @@
   --primary-light: rgba(192, 96, 104, 0.15);
   --bg-primary: #1a1416;
   --bg-secondary: rgba(42, 32, 34, 0.9);
+  --bg-secondary-solid: #2a2022;
   --bg-tertiary: rgba(255, 255, 255, 0.05);
   --bg-hover: rgba(255, 255, 255, 0.08);
   --text-primary: #F0E8E8;
@@ -247,6 +316,7 @@
   --primary-light: rgba(122, 186, 170, 0.15);
   --bg-primary: #121a1a;
   --bg-secondary: rgba(28, 42, 42, 0.9);
+  --bg-secondary-solid: #1c2a2a;
   --bg-tertiary: rgba(255, 255, 255, 0.05);
   --bg-hover: rgba(255, 255, 255, 0.08);
   --text-primary: #E4F0F0;
@@ -260,6 +330,70 @@
   --sent-card-bg: var(--primary);
 }
 
+// 繁花如梦 - 深色（夜阑幽梦）
+[data-theme="blossom-dream"][data-mode="dark"] {
+  // 光晕色（供伪元素使用，降低饱和度避免刺眼）
+  --blossom-pink: #C670C3;
+  --blossom-purple: #5F4B8B;
+  --blossom-blue: #3A2A50;
+
+  // 主品牌色：藕粉/烟紫粉，降饱和度不刺眼
+  --primary: #D19EBB;
+  --primary-rgb: 209, 158, 187;
+  --primary-hover: #DDB0C8;
+  --primary-light: rgba(209, 158, 187, 0.15);
+
+  // 背景三层：极深黑灰底（去掉紫薯色），面板略浅，卡片再浅一级
+  --bg-primary: #151316;
+  --bg-secondary: rgba(34, 30, 36, 0.92);
+  --bg-secondary-solid: #221E24;
+  --bg-tertiary: rgba(255, 255, 255, 0.04);
+  --bg-hover: rgba(209, 158, 187, 0.1);
+
+  // 文字
+  --text-primary: #F0EAF4;
+  --text-secondary: #A898AE;
+  --text-tertiary: #6A5870;
+  // 边框：极细白色内发光，剥离层级
+  --border-color: rgba(255, 255, 255, 0.07);
+
+  --bg-gradient: linear-gradient(150deg, #151316 0%, #1A1620 50%, #131018 100%);
+  --primary-gradient: linear-gradient(135deg, #D19EBB 0%, #A878A8 100%);
+
+  // 卡片：比面板更亮一档，用深灰而非紫色
+  --card-bg: rgba(42, 38, 46, 0.92);
+  --card-inner-bg: rgba(52, 48, 56, 0.96);
+
+  --sent-card-bg: var(--primary);
+}
+
+// Geist · 极简黑白 - 深色
+[data-theme="geist"][data-mode="dark"] {
+  --primary: #ededed;
+  --primary-rgb: 237, 237, 237;
+  --primary-hover: #d5d5d5;
+  --primary-light: rgba(237, 237, 237, 0.1);
+  --bg-primary: #1a1a1a;
+  --bg-secondary: rgba(34, 34, 34, 0.95);
+  --bg-secondary-solid: #222222;
+  --bg-tertiary: rgba(255, 255, 255, 0.04);
+  --bg-hover: rgba(255, 255, 255, 0.07);
+  --text-primary: #ededed;
+  --text-secondary: #999999;
+  --text-tertiary: #666666;
+  --border-color: #2e2e2e;
+  --border-radius: 6px;
+  --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.4);
+  --shadow-md: 0 4px 16px rgba(0, 0, 0, 0.5);
+  --bg-gradient: linear-gradient(135deg, #1a1a1a 0%, #222222 100%);
+  --primary-gradient: linear-gradient(135deg, #ededed 0%, #cccccc 100%);
+  --card-bg: rgba(34, 34, 34, 0.95);
+  --card-inner-bg: #2a2a2a;
+  --sent-card-bg: #3a3a3a;
+  // primary 是浅灰色，上方文字需要用深色
+  --on-primary: #111111;
+}
+
 // 重置样式
 * {
   margin: 0;
@@ -316,7 +450,7 @@ body {
 
   &-primary {
     background: var(--primary);
-    color: white;
+    color: var(--on-primary);
 
     &:hover {
       background: var(--primary-hover);

src/types/electron.d.ts

@@ -1,5 +1,12 @@
 import type { ChatSession, Message, Contact, ContactInfo } from './models'
 
+export interface SessionChatWindowOpenOptions {
+  source?: 'chat' | 'export'
+  initialDisplayName?: string
+  initialAvatarUrl?: string
+  initialContactType?: ContactInfo['type']
+}
+
 export interface ElectronAPI {
   window: {
     minimize: () => void
@@ -13,6 +20,7 @@ export interface ElectronAPI {
     resizeToFitVideo: (videoWidth: number, videoHeight: number) => Promise<void>
     openImageViewerWindow: (imagePath: string, liveVideoPath?: string) => Promise<void>
     openChatHistoryWindow: (sessionId: string, messageId: number) => Promise<boolean>
+    openSessionChatWindow: (sessionId: string, options?: SessionChatWindowOpenOptions) => Promise<boolean>
   }
   config: {
     get: (key: string) => Promise<unknown>
@@ -48,9 +56,65 @@ export interface ElectronAPI {
     onDownloadProgress: (callback: (progress: number) => void) => () => void
     onUpdateAvailable: (callback: (info: { version: string; releaseNotes: string }) => void) => () => void
   }
+  notification: {
+    show: (data: { title: string; content: string; avatarUrl?: string; sessionId: string }) => Promise<{ success?: boolean; error?: string } | void>
+    close: () => Promise<void>
+    click: (sessionId: string) => void
+    ready: () => void
+    resize: (width: number, height: number) => void
+    onShow: (callback: (event: any, data: any) => void) => () => void
+  }
   log: {
     getPath: () => Promise<string>
     read: () => Promise<{ success: boolean; content?: string; error?: string }>
+    debug: (data: any) => void
+  }
+  diagnostics: {
+    getExportCardLogs: (options?: { limit?: number }) => Promise<{
+      logs: Array<{
+        id: string
+        ts: number
+        source: 'frontend' | 'main' | 'backend' | 'worker'
+        level: 'debug' | 'info' | 'warn' | 'error'
+        message: string
+        traceId?: string
+        stepId?: string
+        stepName?: string
+        status?: 'running' | 'done' | 'failed' | 'timeout'
+        durationMs?: number
+        data?: Record<string, unknown>
+      }>
+      activeSteps: Array<{
+        traceId: string
+        stepId: string
+        stepName: string
+        source: 'frontend' | 'main' | 'backend' | 'worker'
+        elapsedMs: number
+        stallMs: number
+        startedAt: number
+        lastUpdatedAt: number
+        message?: string
+      }>
+      summary: {
+        totalLogs: number
+        activeStepCount: number
+        errorCount: number
+        warnCount: number
+        timeoutCount: number
+        lastUpdatedAt: number
+      }
+    }>
+    clearExportCardLogs: () => Promise<{ success: boolean }>
+    exportExportCardLogs: (payload: {
+      filePath: string
+      frontendLogs?: unknown[]
+    }) => Promise<{
+      success: boolean
+      filePath?: string
+      summaryPath?: string
+      count?: number
+      error?: string
+    }>
   }
   dbPath: {
     autoDetect: () => Promise<{ success: boolean; path?: string; error?: string }>
@@ -66,14 +130,48 @@ export interface ElectronAPI {
   }
   key: {
     autoGetDbKey: () => Promise<{ success: boolean; key?: string; error?: string; logs?: string[] }>
-    autoGetImageKey: (manualDir?: string) => Promise<{ success: boolean; xorKey?: number; aesKey?: string; error?: string }>
+    autoGetImageKey: (manualDir?: string, wxid?: string) => Promise<{ success: boolean; xorKey?: number; aesKey?: string; error?: string }>
+    scanImageKeyFromMemory: (userDir: string) => Promise<{ success: boolean; xorKey?: number; aesKey?: string; error?: string }>
     onDbKeyStatus: (callback: (payload: { message: string; level: number }) => void) => () => void
     onImageKeyStatus: (callback: (payload: { message: string }) => void) => () => void
   }
   chat: {
     connect: () => Promise<{ success: boolean; error?: string }>
     getSessions: () => Promise<{ success: boolean; sessions?: ChatSession[]; error?: string }>
-    enrichSessionsContactInfo: (usernames: string[]) => Promise<{
+    getSessionStatuses: (usernames: string[]) => Promise<{
+      success: boolean
+      map?: Record<string, { isFolded?: boolean; isMuted?: boolean }>
+      error?: string
+    }>
+    getExportTabCounts: () => Promise<{
+      success: boolean
+      counts?: {
+        private: number
+        group: number
+        official: number
+        former_friend: number
+      }
+      error?: string
+    }>
+    getContactTypeCounts: () => Promise<{
+      success: boolean
+      counts?: {
+        private: number
+        group: number
+        official: number
+        former_friend: number
+      }
+      error?: string
+    }>
+    getSessionMessageCounts: (sessionIds: string[]) => Promise<{
+      success: boolean
+      counts?: Record<string, number>
+      error?: string
+    }>
+    enrichSessionsContactInfo: (
+      usernames: string[],
+      options?: { skipDisplayName?: boolean; onlyMissingAvatar?: boolean }
+    ) => Promise<{
       success: boolean
       contacts?: Record<string, { displayName?: string; avatarUrl?: string }>
       error?: string
@@ -87,6 +185,7 @@ export interface ElectronAPI {
     getLatestMessages: (sessionId: string, limit?: number) => Promise<{
       success: boolean
       messages?: Message[]
+      hasMore?: boolean
       error?: string
     }>
     getNewMessages: (sessionId: string, minTime: number, limit?: number) => Promise<{
@@ -94,6 +193,17 @@ export interface ElectronAPI {
       messages?: Message[]
       error?: string
     }>
+    getCachedMessages: (sessionId: string) => Promise<{
+      success: boolean
+      messages?: Message[]
+      error?: string
+    }>
+    clearCurrentAccountData: (options: { clearCache?: boolean; clearExports?: boolean }) => Promise<{
+      success: boolean
+      removedPaths?: string[]
+      warning?: string
+      error?: string
+    }>
     getContact: (username: string) => Promise<Contact | null>
     getContactAvatar: (username: string) => Promise<{ avatarUrl?: string; displayName?: string } | null>
     updateMessage: (sessionId: string, localId: number, createTime: number, newContent: string) => Promise<{ success: boolean; error?: string }>
@@ -123,6 +233,72 @@ export interface ElectronAPI {
       }
       error?: string
     }>
+    getSessionDetailFast: (sessionId: string) => Promise<{
+      success: boolean
+      detail?: {
+        wxid: string
+        displayName: string
+        remark?: string
+        nickName?: string
+        alias?: string
+        avatarUrl?: string
+        messageCount: number
+      }
+      error?: string
+    }>
+    getSessionDetailExtra: (sessionId: string) => Promise<{
+      success: boolean
+      detail?: {
+        firstMessageTime?: number
+        latestMessageTime?: number
+        messageTables: { dbName: string; tableName: string; count: number }[]
+      }
+      error?: string
+    }>
+    getExportSessionStats: (
+      sessionIds: string[],
+      options?: {
+        includeRelations?: boolean
+        forceRefresh?: boolean
+        allowStaleCache?: boolean
+        preferAccurateSpecialTypes?: boolean
+        cacheOnly?: boolean
+      }
+    ) => Promise<{
+      success: boolean
+      data?: Record<string, {
+        totalMessages: number
+        voiceMessages: number
+        imageMessages: number
+        videoMessages: number
+        emojiMessages: number
+        transferMessages: number
+        redPacketMessages: number
+        callMessages: number
+        firstTimestamp?: number
+        lastTimestamp?: number
+        privateMutualGroups?: number
+        groupMemberCount?: number
+        groupMyMessages?: number
+        groupActiveSpeakers?: number
+        groupMutualFriends?: number
+      }>
+      cache?: Record<string, {
+        updatedAt: number
+        stale: boolean
+        includeRelations: boolean
+        source: 'memory' | 'disk' | 'fresh'
+      }>
+      needsRefresh?: string[]
+      error?: string
+    }>
+    getGroupMyMessageCountHint: (chatroomId: string) => Promise<{
+      success: boolean
+      count?: number
+      updatedAt?: number
+      source?: 'memory' | 'disk'
+      error?: string
+    }>
     getImageData: (sessionId: string, msgId: string) => Promise<{ success: boolean; data?: string; error?: string }>
     getVoiceData: (sessionId: string, msgId: string, createTime?: number, serverId?: string | number) => Promise<{ success: boolean; data?: string; error?: string }>
     getAllVoiceMessages: (sessionId: string) => Promise<{ success: boolean; messages?: Message[]; error?: string }>
@@ -131,6 +307,8 @@ export interface ElectronAPI {
       images?: { imageMd5?: string; imageDatName?: string; createTime?: number }[]
       error?: string
     }>
+    getMessageDates: (sessionId: string) => Promise<{ success: boolean; dates?: string[]; error?: string }>
+    getMessageDateCounts: (sessionId: string) => Promise<{ success: boolean; counts?: Record<string, number>; error?: string }>
     resolveVoiceCache: (sessionId: string, msgId: string) => Promise<{ success: boolean; hasCache: boolean; data?: string }>
     getVoiceTranscript: (sessionId: string, msgId: string, createTime?: number) => Promise<{ success: boolean; transcript?: string; error?: string }>
     onVoiceTranscriptPartial: (callback: (payload: { msgId: string; text: string }) => void) => () => void
@@ -140,7 +318,7 @@ export interface ElectronAPI {
   }
 
   image: {
-    decrypt: (payload: { sessionId?: string; imageMd5?: string; imageDatName?: string; force?: boolean }) => Promise<{ success: boolean; localPath?: string; error?: string }>
+    decrypt: (payload: { sessionId?: string; imageMd5?: string; imageDatName?: string; force?: boolean }) => Promise<{ success: boolean; localPath?: string; liveVideoPath?: string; error?: string }>
     resolveCache: (payload: { sessionId?: string; imageMd5?: string; imageDatName?: string }) => Promise<{ success: boolean; localPath?: string; hasUpdate?: boolean; liveVideoPath?: string; error?: string }>
     preload: (payloads: Array<{ sessionId?: string; imageMd5?: string; imageDatName?: string }>) => Promise<boolean>
     onUpdateAvailable: (callback: (payload: { cacheKey: string; imageMd5?: string; imageDatName?: string }) => void) => () => void
@@ -252,9 +430,31 @@ export interface ElectronAPI {
         alias?: string
         remark?: string
         groupNickname?: string
+        isOwner?: boolean
       }>
       error?: string
     }>
+    getGroupMembersPanelData: (
+      chatroomId: string,
+      options?: { forceRefresh?: boolean; includeMessageCounts?: boolean }
+    ) => Promise<{
+      success: boolean
+      data?: Array<{
+        username: string
+        displayName: string
+        avatarUrl?: string
+        nickname?: string
+        alias?: string
+        remark?: string
+        groupNickname?: string
+        isOwner?: boolean
+        isFriend: boolean
+        messageCount: number
+      }>
+      fromCache?: boolean
+      updatedAt?: number
+      error?: string
+    }>
     getGroupMessageRanking: (chatroomId: string, limit?: number, startTime?: number, endTime?: number) => Promise<{
       success: boolean
       data?: Array<{
@@ -309,6 +509,30 @@ export interface ElectronAPI {
       data?: number[]
       error?: string
     }>
+    startAvailableYearsLoad: () => Promise<{
+      success: boolean
+      taskId?: string
+      reused?: boolean
+      snapshot?: {
+        years?: number[]
+        done: boolean
+        error?: string
+        canceled?: boolean
+        strategy?: 'cache' | 'native' | 'hybrid'
+        phase?: 'cache' | 'native' | 'scan' | 'done'
+        statusText?: string
+        nativeElapsedMs?: number
+        scanElapsedMs?: number
+        totalElapsedMs?: number
+        switched?: boolean
+        nativeTimedOut?: boolean
+      }
+      error?: string
+    }>
+    cancelAvailableYearsLoad: (taskId: string) => Promise<{
+      success: boolean
+      error?: string
+    }>
     generateReport: (year: number) => Promise<{
       success: boolean
       data?: {
@@ -371,6 +595,20 @@ export interface ElectronAPI {
           phrase: string
           count: number
         }>
+        snsStats?: {
+          totalPosts: number
+          typeCounts?: Record<string, number>
+          topLikers: { username: string; displayName: string; avatarUrl?: string; count: number }[]
+          topLiked: { username: string; displayName: string; avatarUrl?: string; count: number }[]
+        }
+        lostFriend: {
+          username: string
+          displayName: string
+          avatarUrl?: string
+          earlyCount: number
+          lateCount: number
+          periodDesc: string
+        } | null
       }
       error?: string
     }>
@@ -379,6 +617,21 @@ export interface ElectronAPI {
       dir?: string
       error?: string
     }>
+    onAvailableYearsProgress: (callback: (payload: {
+      taskId: string
+      years?: number[]
+      done: boolean
+      error?: string
+      canceled?: boolean
+      strategy?: 'cache' | 'native' | 'hybrid'
+      phase?: 'cache' | 'native' | 'scan' | 'done'
+      statusText?: string
+      nativeElapsedMs?: number
+      scanElapsedMs?: number
+      totalElapsedMs?: number
+      switched?: boolean
+      nativeTimedOut?: boolean
+    }) => void) => () => void
     onProgress: (callback: (payload: { status: string; progress: number }) => void) => () => void
   }
   dualReport: {
@@ -426,15 +679,26 @@ export interface ElectronAPI {
           myTopEmojiMd5?: string
           friendTopEmojiMd5?: string
           myTopEmojiUrl?: string
+          friendTopEmojiUrl?: string
+          myTopEmojiCount?: number
+          friendTopEmojiCount?: number
           topPhrases: Array<{ phrase: string; count: number }>
           myExclusivePhrases: Array<{ phrase: string; count: number }>
           friendExclusivePhrases: Array<{ phrase: string; count: number }>
           heatmap?: number[][]
           initiative?: { initiated: number; received: number }
-          response?: { avg: number; fastest: number; count: number }
+          response?: { avg: number; fastest: number; slowest?: number; count: number }
           monthly?: Record<string, number>
           streak?: { days: number; startDate: string; endDate: string }
         }
+        topPhrases: Array<{ phrase: string; count: number }>
+        myExclusivePhrases: Array<{ phrase: string; count: number }>
+        friendExclusivePhrases: Array<{ phrase: string; count: number }>
+        heatmap?: number[][]
+        initiative?: { initiated: number; received: number }
+        response?: { avg: number; fastest: number; slowest?: number; count: number }
+        monthly?: Record<string, number>
+        streak?: { days: number; startDate: string; endDate: string }
       }
       error?: string
     }>
@@ -454,6 +718,9 @@ export interface ElectronAPI {
       success: boolean
       successCount?: number
       failCount?: number
+      pendingSessionIds?: string[]
+      successSessionIds?: string[]
+      failedSessionIds?: string[]
       error?: string
     }>
     exportSession: (sessionId: string, outputPath: string, options: ExportOptions) => Promise<{
@@ -500,26 +767,42 @@ export interface ElectronAPI {
           }
         }>
         likes: Array<string>
-        comments: Array<{ id: string; nickname: string; content: string; refCommentId: string; refNickname?: string }>
+        comments: Array<{ id: string; nickname: string; content: string; refCommentId: string; refNickname?: string; emojis?: Array<{ url: string; md5: string; width: number; height: number; encryptUrl?: string; aesKey?: string }> }>
         rawXml?: string
       }>
       error?: string
     }>
     debugResource: (url: string) => Promise<{ success: boolean; status?: number; headers?: any; error?: string }>
-    proxyImage: (payload: { url: string; key?: string | number }) => Promise<{ success: boolean; dataUrl?: string; error?: string }>
+    proxyImage: (payload: { url: string; key?: string | number }) => Promise<{ success: boolean; dataUrl?: string; videoPath?: string; error?: string }>
     downloadImage: (payload: { url: string; key?: string | number }) => Promise<{ success: boolean; data?: any; contentType?: string; error?: string }>
     exportTimeline: (options: {
       outputDir: string
-      format: 'json' | 'html'
+      format: 'json' | 'html' | 'arkmejson'
       usernames?: string[]
       keyword?: string
-      exportMedia?: boolean
+      exportImages?: boolean
+      exportLivePhotos?: boolean
+      exportVideos?: boolean
       startTime?: number
       endTime?: number
     }) => Promise<{ success: boolean; filePath?: string; postCount?: number; mediaCount?: number; error?: string }>
     onExportProgress: (callback: (payload: { current: number; total: number; status: string }) => void) => () => void
     selectExportDir: () => Promise<{ canceled: boolean; filePath?: string }>
     getSnsUsernames: () => Promise<{ success: boolean; usernames?: string[]; error?: string }>
+    getUserPostCounts: () => Promise<{ success: boolean; counts?: Record<string, number>; error?: string }>
+    getExportStatsFast: () => Promise<{ success: boolean; data?: { totalPosts: number; totalFriends: number; myPosts: number | null }; error?: string }>
+    getExportStats: () => Promise<{ success: boolean; data?: { totalPosts: number; totalFriends: number; myPosts: number | null }; error?: string }>
+    getUserPostStats: (username: string) => Promise<{ success: boolean; data?: { username: string; totalPosts: number }; error?: string }>
+    installBlockDeleteTrigger: () => Promise<{ success: boolean; alreadyInstalled?: boolean; error?: string }>
+    uninstallBlockDeleteTrigger: () => Promise<{ success: boolean; error?: string }>
+    checkBlockDeleteTrigger: () => Promise<{ success: boolean; installed?: boolean; error?: string }>
+    deleteSnsPost: (postId: string) => Promise<{ success: boolean; error?: string }>
+    downloadEmoji: (params: { url: string; encryptUrl?: string; aesKey?: string }) => Promise<{ success: boolean; localPath?: string; error?: string }>
+  }
+  cloud: {
+    init: () => Promise<void>
+    recordPage: (pageName: string) => Promise<void>
+    getLogs: () => Promise<string[]>
   }
   http: {
     start: (port?: number) => Promise<{ success: boolean; port?: number; error?: string }>
@@ -529,7 +812,8 @@ export interface ElectronAPI {
 }
 
 export interface ExportOptions {
-  format: 'chatlab' | 'chatlab-jsonl' | 'json' | 'html' | 'txt' | 'excel' | 'weclone' | 'sql'
+  format: 'chatlab' | 'chatlab-jsonl' | 'json' | 'arkme-json' | 'html' | 'txt' | 'excel' | 'weclone' | 'sql'
+  contentType?: 'text' | 'voice' | 'image' | 'video' | 'emoji'
   dateRange?: { start: number; end: number } | null
   senderUsername?: string
   fileNameSuffix?: string
@@ -543,6 +827,7 @@ export interface ExportOptions {
   excelCompactColumns?: boolean
   txtColumns?: string[]
   sessionLayout?: 'shared' | 'per-session'
+  sessionNameWithTypePrefix?: boolean
   displayNamePreference?: 'group-nickname' | 'remark' | 'nickname'
   exportConcurrency?: number
 }
@@ -551,6 +836,7 @@ export interface ExportProgress {
   current: number
   total: number
   currentSession: string
+  currentSessionId?: string
   phase: 'preparing' | 'exporting' | 'exporting-media' | 'exporting-voice' | 'writing' | 'complete'
   phaseProgress?: number
   phaseTotal?: number

src/types/models.ts

@@ -7,11 +7,14 @@ export interface ChatSession {
   sortTimestamp: number  // 用于排序
   lastTimestamp: number  // 用于显示时间
   lastMsgType: number
+  messageCountHint?: number // 会话总消息数提示（若底层直接可取）
   displayName?: string
   avatarUrl?: string
   lastMsgSender?: string
   lastSenderDisplayName?: string
   selfWxid?: string // Helper field to avoid extra API calls
+  isFolded?: boolean  // 是否已折叠进"折叠的群聊"
+  isMuted?: boolean   // 是否开启免打扰
 }
 
 // 联系人
@@ -31,6 +34,7 @@ export interface ContactInfo {
   displayName: string
   remark?: string
   nickname?: string
+  alias?: string
   avatarUrl?: string
   type: 'friend' | 'group' | 'official' | 'former_friend' | 'other'
 }
@@ -51,6 +55,7 @@ export interface Message {
   imageDatName?: string
   emojiCdnUrl?: string
   emojiMd5?: string
+  emojiLocalPath?: string   // 本地缓存路径（转发表情包无 CDN URL 时使用）
   voiceDurationSeconds?: number
   videoMd5?: string
   // 引用消息

src/types/sns.ts

@@ -16,16 +16,27 @@ export interface SnsMedia {
     livePhoto?: SnsLivePhoto
 }
 
+export interface SnsCommentEmoji {
+    url: string
+    md5: string
+    width: number
+    height: number
+    encryptUrl?: string
+    aesKey?: string
+}
+
 export interface SnsComment {
     id: string
     nickname: string
     content: string
     refCommentId: string
     refNickname?: string
+    emojis?: SnsCommentEmoji[]
 }
 
 export interface SnsPost {
     id: string
+    tid?: string       // 数据库主键（雪花 ID），用于精确删除
     username: string
     nickname: string
     avatarUrl?: string
@@ -38,6 +49,7 @@ export interface SnsPost {
     rawXml?: string
     linkTitle?: string
     linkUrl?: string
+    isProtected?: boolean  // 是否受保护（已安装时标记）
 }
 
 export interface SnsLinkCardData {

src/utils/exportDateRange.ts

@@ -0,0 +1,341 @@
+export type ExportDateRangePreset =
+  | 'all'
+  | 'today'
+  | 'yesterday'
+  | 'last3days'
+  | 'last7days'
+  | 'last30days'
+  | 'last1year'
+  | 'last2years'
+  | 'custom'
+
+export type CalendarCell = { date: Date; inCurrentMonth: boolean }
+
+export interface ExportDateRange {
+  start: Date
+  end: Date
+}
+
+export interface ExportDateRangeSelection {
+  preset: ExportDateRangePreset
+  useAllTime: boolean
+  dateRange: ExportDateRange
+}
+
+export interface ExportDefaultDateRangeConfig {
+  version?: 1
+  preset?: ExportDateRangePreset | string
+  useAllTime?: boolean
+  start?: string | number | Date | null
+  end?: string | number | Date | null
+}
+
+export const EXPORT_DATE_RANGE_PRESETS: Array<{
+  value: Exclude<ExportDateRangePreset, 'custom'>
+  label: string
+}> = [
+  { value: 'all', label: '全部时间' },
+  { value: 'today', label: '今天' },
+  { value: 'yesterday', label: '昨天' },
+  { value: 'last3days', label: '最近3天' },
+  { value: 'last7days', label: '最近一周' },
+  { value: 'last30days', label: '最近30天' },
+  { value: 'last1year', label: '最近一年' }
+]
+
+const PRESET_LABELS: Record<Exclude<ExportDateRangePreset, 'custom'>, string> = {
+  all: '全部时间',
+  today: '今天',
+  yesterday: '昨天',
+  last3days: '最近3天',
+  last7days: '最近一周',
+  last30days: '最近30天',
+  last1year: '最近一年',
+  last2years: '最近两年'
+}
+
+const LEGACY_PRESET_MAP: Record<string, Exclude<ExportDateRangePreset, 'custom'> | 'legacy90days'> = {
+  all: 'all',
+  today: 'today',
+  yesterday: 'yesterday',
+  last3days: 'last3days',
+  last7days: 'last7days',
+  last30days: 'last30days',
+  last1year: 'last1year',
+  last2years: 'last2years',
+  '7d': 'last7days',
+  '30d': 'last30days',
+  '90d': 'legacy90days'
+}
+
+export const WEEKDAY_SHORT_LABELS = ['日', '一', '二', '三', '四', '五', '六']
+
+export const startOfDay = (date: Date): Date => {
+  const next = new Date(date)
+  next.setHours(0, 0, 0, 0)
+  return next
+}
+
+export const endOfDay = (date: Date): Date => {
+  const next = new Date(date)
+  next.setHours(23, 59, 59, 999)
+  return next
+}
+
+export const createDefaultDateRange = (): ExportDateRange => {
+  const now = new Date()
+  return {
+    start: startOfDay(now),
+    end: now
+  }
+}
+
+export const createDateRangeByPreset = (
+  preset: Exclude<ExportDateRangePreset, 'all' | 'custom'>,
+  now = new Date()
+): ExportDateRange => {
+  const end = new Date(now)
+  const baseStart = startOfDay(now)
+
+  if (preset === 'today') {
+    return { start: baseStart, end }
+  }
+
+  if (preset === 'yesterday') {
+    const yesterday = new Date(baseStart)
+    yesterday.setDate(yesterday.getDate() - 1)
+    return {
+      start: yesterday,
+      end: endOfDay(yesterday)
+    }
+  }
+
+  if (preset === 'last1year' || preset === 'last2years') {
+    const yearsBack = preset === 'last1year' ? 1 : 2
+    const start = new Date(baseStart)
+    const expectedMonth = start.getMonth()
+    start.setFullYear(start.getFullYear() - yearsBack)
+    if (start.getMonth() !== expectedMonth) {
+      start.setDate(0)
+    }
+    return { start, end }
+  }
+
+  const daysBack = preset === 'last3days' ? 2 : preset === 'last7days' ? 6 : 29
+  const start = new Date(baseStart)
+  start.setDate(start.getDate() - daysBack)
+  return { start, end }
+}
+
+export const createDateRangeByLastNDays = (days: number, now = new Date()): ExportDateRange => {
+  const end = new Date(now)
+  const start = startOfDay(now)
+  start.setDate(start.getDate() - Math.max(0, days - 1))
+  return { start, end }
+}
+
+export const formatDateInputValue = (date: Date): string => {
+  const y = date.getFullYear()
+  const m = `${date.getMonth() + 1}`.padStart(2, '0')
+  const d = `${date.getDate()}`.padStart(2, '0')
+  return `${y}-${m}-${d}`
+}
+
+export const parseDateInputValue = (raw: string): Date | null => {
+  const text = String(raw || '').trim()
+  const matched = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text)
+  if (!matched) return null
+  const year = Number(matched[1])
+  const month = Number(matched[2])
+  const day = Number(matched[3])
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) return null
+  if (month < 1 || month > 12 || day < 1 || day > 31) return null
+  const parsed = new Date(year, month - 1, day)
+  if (
+    parsed.getFullYear() !== year ||
+    parsed.getMonth() !== month - 1 ||
+    parsed.getDate() !== day
+  ) {
+    return null
+  }
+  return parsed
+}
+
+export const toMonthStart = (date: Date): Date => new Date(date.getFullYear(), date.getMonth(), 1)
+
+export const addMonths = (date: Date, delta: number): Date => {
+  const next = new Date(date)
+  next.setMonth(next.getMonth() + delta)
+  return toMonthStart(next)
+}
+
+export const isSameDay = (left: Date, right: Date): boolean => (
+  left.getFullYear() === right.getFullYear() &&
+  left.getMonth() === right.getMonth() &&
+  left.getDate() === right.getDate()
+)
+
+export const buildCalendarCells = (monthStart: Date): CalendarCell[] => {
+  const firstDay = new Date(monthStart.getFullYear(), monthStart.getMonth(), 1)
+  const startOffset = firstDay.getDay()
+  const gridStart = new Date(firstDay)
+  gridStart.setDate(gridStart.getDate() - startOffset)
+  const cells: CalendarCell[] = []
+  for (let index = 0; index < 42; index += 1) {
+    const current = new Date(gridStart)
+    current.setDate(gridStart.getDate() + index)
+    cells.push({
+      date: current,
+      inCurrentMonth: current.getMonth() === monthStart.getMonth()
+    })
+  }
+  return cells
+}
+
+export const formatCalendarMonthTitle = (date: Date): string => `${date.getFullYear()}年${date.getMonth() + 1}月`
+
+export const cloneExportDateRange = (range: ExportDateRange): ExportDateRange => ({
+  start: new Date(range.start),
+  end: new Date(range.end)
+})
+
+export const cloneExportDateRangeSelection = (selection: ExportDateRangeSelection): ExportDateRangeSelection => ({
+  preset: selection.preset,
+  useAllTime: selection.useAllTime,
+  dateRange: cloneExportDateRange(selection.dateRange)
+})
+
+export const createExportDateRangeSelectionFromPreset = (
+  preset: Exclude<ExportDateRangePreset, 'custom'>,
+  now = new Date()
+): ExportDateRangeSelection => {
+  if (preset === 'all') {
+    return {
+      preset,
+      useAllTime: true,
+      dateRange: createDefaultDateRange()
+    }
+  }
+
+  return {
+    preset,
+    useAllTime: false,
+    dateRange: createDateRangeByPreset(preset, now)
+  }
+}
+
+export const createDefaultExportDateRangeSelection = (): ExportDateRangeSelection => (
+  createExportDateRangeSelectionFromPreset('today')
+)
+
+const parseStoredDate = (value: unknown): Date | null => {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return new Date(value)
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    const parsed = new Date(value)
+    return Number.isNaN(parsed.getTime()) ? null : parsed
+  }
+  if (typeof value === 'string') {
+    const normalized = parseDateInputValue(value)
+    if (normalized) return normalized
+    const parsed = new Date(value)
+    return Number.isNaN(parsed.getTime()) ? null : parsed
+  }
+  return null
+}
+
+const normalizePreset = (raw: unknown): Exclude<ExportDateRangePreset, 'custom'> | 'legacy90days' | null => {
+  if (typeof raw !== 'string') return null
+  const normalized = LEGACY_PRESET_MAP[raw]
+  return normalized ?? null
+}
+
+export const resolveExportDateRangeConfig = (
+  raw: ExportDefaultDateRangeConfig | string | null | undefined,
+  now = new Date()
+): ExportDateRangeSelection => {
+  if (!raw) {
+    return createDefaultExportDateRangeSelection()
+  }
+
+  if (typeof raw === 'string') {
+    const preset = normalizePreset(raw)
+    if (!preset) return createDefaultExportDateRangeSelection()
+    if (preset === 'legacy90days') {
+      return {
+        preset: 'custom',
+        useAllTime: false,
+        dateRange: createDateRangeByLastNDays(90, now)
+      }
+    }
+    return createExportDateRangeSelectionFromPreset(preset, now)
+  }
+
+  const preset = normalizePreset(raw.preset)
+  if (raw.useAllTime || preset === 'all') {
+    return createExportDateRangeSelectionFromPreset('all', now)
+  }
+  if (preset && preset !== 'legacy90days') {
+    return createExportDateRangeSelectionFromPreset(preset, now)
+  }
+
+  if (preset === 'legacy90days') {
+    return {
+      preset: 'custom',
+      useAllTime: false,
+      dateRange: createDateRangeByLastNDays(90, now)
+    }
+  }
+
+  const parsedStart = parseStoredDate(raw.start)
+  const parsedEnd = parseStoredDate(raw.end)
+  if (parsedStart && parsedEnd) {
+    const start = startOfDay(parsedStart)
+    const end = endOfDay(parsedEnd)
+    return {
+      preset: 'custom',
+      useAllTime: false,
+      dateRange: {
+        start,
+        end: end < start ? endOfDay(start) : end
+      }
+    }
+  }
+
+  return createDefaultExportDateRangeSelection()
+}
+
+export const serializeExportDateRangeConfig = (
+  selection: ExportDateRangeSelection
+): ExportDefaultDateRangeConfig => {
+  if (selection.useAllTime) {
+    return {
+      version: 1,
+      preset: 'all',
+      useAllTime: true
+    }
+  }
+
+  if (selection.preset === 'custom') {
+    return {
+      version: 1,
+      preset: 'custom',
+      useAllTime: false,
+      start: formatDateInputValue(selection.dateRange.start),
+      end: formatDateInputValue(selection.dateRange.end)
+    }
+  }
+
+  return {
+    version: 1,
+    preset: selection.preset,
+    useAllTime: false
+  }
+}
+
+export const getExportDateRangeLabel = (selection: ExportDateRangeSelection): string => {
+  if (selection.useAllTime) return PRESET_LABELS.all
+  if (selection.preset !== 'custom') return PRESET_LABELS[selection.preset]
+  return `${formatDateInputValue(selection.dateRange.start)} 至 ${formatDateInputValue(selection.dateRange.end)}`
+}

src/vite-env.d.ts

@@ -1,22 +1 @@
 /// <reference types="vite/client" />
-
-interface Window {
-    electronAPI: {
-        // ... other methods ...
-        auth: {
-            hello: (message?: string) => Promise<{ success: boolean; error?: string }>
-            verifyEnabled: () => Promise<boolean>
-            unlock: (password: string) => Promise<{ success: boolean; error?: string }>
-            enableLock: (password: string) => Promise<{ success: boolean; error?: string }>
-            disableLock: (password: string) => Promise<{ success: boolean; error?: string }>
-            changePassword: (oldPassword: string, newPassword: string) => Promise<{ success: boolean; error?: string }>
-            setHelloSecret: (password: string) => Promise<{ success: boolean }>
-            clearHelloSecret: () => Promise<{ success: boolean }>
-            isLockMode: () => Promise<boolean>
-        }
-        // For brevity, using 'any' for other parts or properly importing types if available.
-        // In a real scenario, you'd likely want to keep the full interface definition consistent with preload.ts
-        // or import a shared type definition.
-        [key: string]: any
-    }
-}