Merge dev into PR 805

2026-05-27 23:26:45 +00:00 · 2026-05-26 18:27:52 +08:00
parent 1b7197cdef 305bdcb629
commit a667201ccf
137 changed files with 26214 additions and 11055 deletions
--- a/.github/scripts/release-utils.sh
+++ b/.github/scripts/release-utils.sh
@@ -58,12 +58,26 @@ wait_for_release_id() {

  local i
  local release_id
+  local release_api_url
  for ((i = 1; i <= attempts; i++)); do
    release_id="$(gh api "repos/$repo/releases/tags/$tag" --jq '.id' 2>/dev/null || true)"
    if [[ "$release_id" =~ ^[0-9]+$ ]]; then
      echo "$release_id"
      return 0
    fi
+
+    release_id="$(gh release view "$tag" --repo "$repo" --json databaseId --jq '.databaseId // empty' 2>/dev/null || true)"
+    if [[ "$release_id" =~ ^[0-9]+$ ]]; then
+      echo "$release_id"
+      return 0
+    fi
+
+    release_api_url="$(gh release view "$tag" --repo "$repo" --json apiUrl --jq '.apiUrl // empty' 2>/dev/null || true)"
+    if [[ "$release_api_url" =~ /releases/([0-9]+)$ ]]; then
+      echo "${BASH_REMATCH[1]}"
+      return 0
+    fi
+
    if [ "$i" -lt "$attempts" ]; then
      echo "Release id for tag '$tag' is not ready yet (attempt $i/$attempts), retrying in ${delay_seconds}s..." >&2
      sleep "$delay_seconds"
@@ -71,6 +85,7 @@ wait_for_release_id() {
  done

  echo "Unable to fetch release id for tag '$tag' after $attempts attempts." >&2
+  gh release view "$tag" --repo "$repo" --json databaseId,id,isDraft,isPrerelease,url 2>/dev/null || true
  gh api "repos/$repo/releases/tags/$tag" --jq '{draft: .draft, prerelease: .prerelease, url: .html_url}' 2>/dev/null || true
  return 1
 }
@@ -87,9 +102,10 @@ settle_release_state() {
  local draft_state
  local prerelease_state
  for ((i = 1; i <= attempts; i++)); do
+    gh release edit "$tag" --repo "$repo" --draft=false --prerelease >/dev/null 2>&1 || true
    gh api --method PATCH "repos/$repo/releases/$release_id" -F draft=false -F prerelease=true >/dev/null 2>&1 || true
-    draft_state="$(gh api "$endpoint" --jq '.draft' 2>/dev/null || echo true)"
-    prerelease_state="$(gh api "$endpoint" --jq '.prerelease' 2>/dev/null || echo false)"
+    draft_state="$(gh api "$endpoint" --jq '.draft' 2>/dev/null || gh release view "$tag" --repo "$repo" --json isDraft --jq '.isDraft' 2>/dev/null || echo true)"
+    prerelease_state="$(gh api "$endpoint" --jq '.prerelease' 2>/dev/null || gh release view "$tag" --repo "$repo" --json isPrerelease --jq '.isPrerelease' 2>/dev/null || echo false)"
    if [ "$draft_state" = "false" ] && [ "$prerelease_state" = "true" ]; then
      return 0
    fi
@@ -100,10 +116,19 @@ settle_release_state() {
  done

  echo "Failed to settle release state for tag '$tag'." >&2
+  gh release view "$tag" --repo "$repo" --json isDraft,isPrerelease,url 2>/dev/null || true
  gh api "$endpoint" --jq '{draft: .draft, prerelease: .prerelease, url: .html_url}' 2>/dev/null || true
  return 1
 }

+print_release_state() {
+  local repo="$1"
+  local tag="$2"
+
+  gh api "repos/$repo/releases/tags/$tag" --jq '{isDraft: .draft, isPrerelease: .prerelease, url: .html_url}' 2>/dev/null \
+    || gh release view "$tag" --repo "$repo" --json isDraft,isPrerelease,url --jq '{isDraft: .isDraft, isPrerelease: .isPrerelease, url: .url}'
+}
+
 wait_for_release_absent() {
  local repo="$1"
  local tag="$2"
--- a/.github/workflows/dev-daily-fixed.yml
+++ b/.github/workflows/dev-daily-fixed.yml
@@ -105,9 +105,13 @@ jobs:
      - name: Package macOS arm64 dev artifacts
        shell: bash
        run: |
+          set -euo pipefail
          export ELECTRON_BUILDER_BINARIES_MIRROR="https://github.com/electron-userland/electron-builder-binaries/releases/download/"
          echo "Using ELECTRON_BUILDER_BINARIES_MIRROR=$ELECTRON_BUILDER_BINARIES_MIRROR"
-          npx electron-builder --mac dmg zip --arm64 --publish never '--config.publish.channel=dev' '--config.artifactName=${productName}-dev-arm64.${ext}'
+          if ! npx electron-builder --mac dmg zip --arm64 --publish never '--config.publish.channel=dev' '--config.artifactName=${productName}-dev-arm64.${ext}'; then
+            echo "::warning::DMG packaging failed (hdiutil instability on runner). Retrying with ZIP only."
+            npx electron-builder --mac zip --arm64 --publish never '--config.publish.channel=dev' '--config.artifactName=${productName}-dev-arm64.${ext}'
+          fi

      - name: Upload macOS arm64 assets to fixed release
        env:
@@ -283,6 +287,12 @@ jobs:
    if: always() && needs.prepare.result == 'success'
    runs-on: ubuntu-latest
    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 1
+
      - name: Update fixed dev release notes
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -314,6 +324,9 @@ jobs:
          WINDOWS_ASSET="$(pick_asset "dev-x64-Setup[.]exe$")"
          WINDOWS_ARM64_ASSET="$(pick_asset "dev-arm64-Setup[.]exe$")"
          MAC_ASSET="$(pick_asset "dev-arm64[.]dmg$")"
+          if [ -z "$MAC_ASSET" ]; then
+            MAC_ASSET="$(pick_asset "dev-arm64[.]zip$")"
+          fi
          LINUX_TAR_ASSET="$(pick_asset "dev-linux[.]tar[.]gz$")"
          LINUX_APPIMAGE_ASSET="$(pick_asset "dev-linux[.]AppImage$")"

@@ -373,4 +386,4 @@ jobs:
          source .github/scripts/release-utils.sh
          RELEASE_REST_ID="$(wait_for_release_id "$REPO" "$TAG" 12 2)"
          settle_release_state "$REPO" "$RELEASE_REST_ID" "$TAG" 12 2
-          gh api "repos/$REPO/releases/tags/$TAG" --jq '{isDraft: .draft, isPrerelease: .prerelease, url: .html_url}'
+          print_release_state "$REPO" "$TAG"
--- a/.github/workflows/preview-nightly-main.yml
+++ b/.github/workflows/preview-nightly-main.yml
@@ -134,9 +134,13 @@ jobs:
          CSC_IDENTITY_AUTO_DISCOVERY: "false"
        shell: bash
        run: |
+          set -euo pipefail
          export ELECTRON_BUILDER_BINARIES_MIRROR="https://github.com/electron-userland/electron-builder-binaries/releases/download/"
          echo "Using ELECTRON_BUILDER_BINARIES_MIRROR=$ELECTRON_BUILDER_BINARIES_MIRROR"
-          npx electron-builder --mac dmg zip --arm64 --publish never '--config.publish.channel=preview' '--config.artifactName=${productName}-preview-arm64.${ext}'
+          if ! npx electron-builder --mac dmg zip --arm64 --publish never '--config.publish.channel=preview' '--config.artifactName=${productName}-preview-arm64.${ext}'; then
+            echo "::warning::DMG packaging failed (hdiutil instability on runner). Retrying with ZIP only."
+            npx electron-builder --mac zip --arm64 --publish never '--config.publish.channel=preview' '--config.artifactName=${productName}-preview-arm64.${ext}'
+          fi

      - name: Upload macOS arm64 assets to fixed preview release
        env:
@@ -324,6 +328,12 @@ jobs:
    if: needs.prepare.outputs.should_build == 'true' && always()
    runs-on: ubuntu-latest
    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 1
+
      - name: Update preview release notes
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -359,6 +369,9 @@ jobs:
          fi
          WINDOWS_ARM64_ASSET="$(pick_asset "arm64.*[.]exe$")"
          MAC_ASSET="$(pick_asset "[.]dmg$")"
+          if [ -z "$MAC_ASSET" ]; then
+            MAC_ASSET="$(pick_asset "[.]zip$")"
+          fi
          LINUX_TAR_ASSET="$(pick_asset "[.]tar[.]gz$")"
          LINUX_APPIMAGE_ASSET="$(pick_asset "[.]AppImage$")"

@@ -416,4 +429,4 @@ jobs:
          source .github/scripts/release-utils.sh
          RELEASE_REST_ID="$(wait_for_release_id "$REPO" "$TAG" 12 2)"
          settle_release_state "$REPO" "$RELEASE_REST_ID" "$TAG" 12 2
-          gh api "repos/$REPO/releases/tags/$TAG" --jq '{isDraft: .draft, isPrerelease: .prerelease, url: .html_url}'
+          print_release_state "$REPO" "$TAG"
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -28,7 +28,23 @@ jobs:
          node-version: 24
          cache: "npm"
      - name: Install Dependencies
-        run: npm install
+        run: npm install --ignore-scripts
+
+      - name: Ensure mac key helpers are executable
+        shell: bash
+        run: |
+          set -euo pipefail
+          for file in \
+            resources/key/macos/universal/xkey_helper \
+            resources/key/macos/universal/image_scan_helper \
+            resources/key/macos/universal/xkey_helper_macos \
+            resources/key/macos/universal/libwx_key.dylib
+          do
+            if [ -f "$file" ]; then
+              chmod +x "$file"
+              ls -l "$file"
+            fi
+          done

      - name: Sync version with tag
        shell: bash
@@ -49,9 +65,13 @@ jobs:
          CSC_IDENTITY_AUTO_DISCOVERY: "false"
        shell: bash
        run: |
+          set -euo pipefail
          export ELECTRON_BUILDER_BINARIES_MIRROR="https://github.com/electron-userland/electron-builder-binaries/releases/download/"
          echo "Using ELECTRON_BUILDER_BINARIES_MIRROR=$ELECTRON_BUILDER_BINARIES_MIRROR"
-          npx electron-builder --mac dmg zip --arm64 --publish always
+          if ! npx electron-builder --mac dmg zip --arm64 --publish always '--config.npmRebuild=false' '--config.publish.owner=${{ github.repository_owner }}' '--config.publish.repo=${{ github.event.repository.name }}'; then
+            echo "::warning::DMG packaging failed (hdiutil instability on runner). Retrying with ZIP only."
+            npx electron-builder --mac zip --arm64 --publish always '--config.npmRebuild=false' '--config.publish.owner=${{ github.repository_owner }}' '--config.publish.repo=${{ github.event.repository.name }}'
+          fi

      - name: Inject minimumVersion into latest yml
        env:
@@ -114,7 +134,7 @@ jobs:
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
-          npx electron-builder --linux --publish always
+          npx electron-builder --linux --publish always '--config.publish.owner=${{ github.repository_owner }}' '--config.publish.repo=${{ github.event.repository.name }}'

      - name: Inject minimumVersion into latest yml
        env:
@@ -167,7 +187,7 @@ jobs:
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
-          npx electron-builder --win nsis --x64 --publish always '--config.artifactName=${productName}-${version}-x64-Setup.${ext}'
+          npx electron-builder --win nsis --x64 --publish always '--config.publish.owner=${{ github.repository_owner }}' '--config.publish.repo=${{ github.event.repository.name }}' '--config.artifactName=${productName}-${version}-x64-Setup.${ext}'

      - name: Inject minimumVersion into latest yml
        env:
@@ -220,7 +240,7 @@ jobs:
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
-          npx electron-builder --win nsis --arm64 --publish always '--config.publish.channel=latest-arm64' '--config.artifactName=${productName}-${version}-arm64-Setup.${ext}'
+          npx electron-builder --win nsis --arm64 --publish always '--config.publish.owner=${{ github.repository_owner }}' '--config.publish.repo=${{ github.event.repository.name }}' '--config.publish.channel=latest-arm64' '--config.artifactName=${productName}-${version}-arm64-Setup.${ext}'

      - name: Inject minimumVersion into latest yml
        env:
@@ -248,6 +268,11 @@ jobs:
      - release-windows-arm64

    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 1
+
      - name: Generate release notes with platform download links
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -274,6 +299,9 @@ jobs:
          fi
          WINDOWS_ARM64_ASSET="$(echo "$ASSETS_JSON" | jq -r '[.assets[].name | select(test("arm64.*\\.exe$"))][0] // ""')"
          MAC_ASSET="$(pick_asset "\\.dmg$")"
+          if [ -z "$MAC_ASSET" ]; then
+            MAC_ASSET="$(pick_asset "arm64\\.zip$")"
+          fi
          LINUX_TAR_ASSET="$(pick_asset "\\.tar\\.gz$")"
          LINUX_APPIMAGE_ASSET="$(pick_asset "\\.AppImage$")"

@@ -315,32 +343,49 @@ jobs:
          retry_cmd 5 3 gh release edit "$TAG" --repo "$REPO" --notes-file release_notes.md

  deploy-aur:
-      runs-on: ubuntu-latest
-      needs: [release-linux] 
-      if: startsWith(github.ref, 'refs/tags/v')
-      steps:
-        - name: Checkout code
-          uses: actions/checkout@v5
-          with:
-            fetch-depth: 0
+    runs-on: ubuntu-latest
+    needs: [release-linux]
+    if: startsWith(github.ref, 'refs/tags/v')
+    steps:
+      - name: Check AUR credentials
+        id: aur-credentials
+        shell: bash
+        env:
+          AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+        run: |
+          if [ -z "${AUR_SSH_PRIVATE_KEY}" ]; then
+            echo "::notice::AUR_SSH_PRIVATE_KEY is not configured; skipping AUR publish."
+            echo "enabled=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "enabled=true" >> "$GITHUB_OUTPUT"
+          fi

-        - name: Update PKGBUILD version
-          run: |
-            NEW_VER=$(echo "${{ github.ref_name }}" | sed 's/^v//')
-            sed -i "s/^pkgver=.*/pkgver=${NEW_VER}/" resources/installer/linux/PKGBUILD
-            sed -i "s/^pkgrel=.*/pkgrel=1/" resources/installer/linux/PKGBUILD
+      - name: Checkout code
+        if: steps.aur-credentials.outputs.enabled == 'true'
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0

-        - name: Publish AUR package
-          uses: KSXGitHub/github-actions-deploy-aur@master
-          with:
-            pkgname: weflow
-            pkgbuild: resources/installer/linux/PKGBUILD
-            updpkgsums: true
-            assets: |
-              resources/installer/linux/weflow.desktop
-              resources/installer/linux/icon.png
+      - name: Update PKGBUILD version
+        if: steps.aur-credentials.outputs.enabled == 'true'
+        run: |
+          NEW_VER=$(echo "${{ github.ref_name }}" | sed 's/^v//')
+          sed -i "s/^pkgver=.*/pkgver=${NEW_VER}/" resources/installer/linux/PKGBUILD
+          sed -i "s/^pkgrel=.*/pkgrel=1/" resources/installer/linux/PKGBUILD

-            ssh_private_key: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
-            commit_username: H3CoF6
-            commit_email: h3cof6@gmail.com
-            ssh_keyscan_types: ed25519
+      - name: Publish AUR package
+        if: steps.aur-credentials.outputs.enabled == 'true'
+        uses: KSXGitHub/github-actions-deploy-aur@master
+        with:
+          pkgname: weflow
+          pkgbuild: resources/installer/linux/PKGBUILD
+          updpkgsums: true
+          assets: |
+            resources/installer/linux/weflow.desktop
+            resources/installer/linux/icon.png
+            resources/installer/linux/.gitignore
+
+          ssh_private_key: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+          commit_username: H3CoF6
+          commit_email: h3cof6@gmail.com
+          ssh_keyscan_types: ed25519
--- a/.github/workflows/security-scan.yml
+++ b/.github/workflows/security-scan.yml
@@ -1,96 +0,0 @@
-name: Security Scan
-
-env:
-  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
-
-on:
-  schedule:
-    - cron: '0 2 * * *'  # 每天 UTC 02:00
-  workflow_dispatch:     # 手动触发
-  pull_request:          # PR 时触发
-    branches: [ main, dev ]
-
-permissions:
-  contents: read
-  security-events: write
-  actions: read
-
-jobs:
-  security-scan:
-    name: Security Scan (${{ matrix.branch }})
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        branch:
-          - main
-
-    steps:
-      - name: Checkout ${{ matrix.branch }}
-        uses: actions/checkout@v5
-        with:
-          ref: ${{ matrix.branch }}
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v5
-        with:
-          node-version: '24'
-          cache: 'npm' # 使用 npm 缓存加速
-
-      - name: Install dependencies
-        run: npm ci --ignore-scripts
-
-      # 1. npm audit - 检查依赖漏洞
-      - name: Dependency vulnerability audit
-        run: npm audit --audit-level=moderate
-        continue-on-error: true
-
-      # 2. CodeQL 静态分析
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
-        with:
-          languages: javascript, typescript
-          queries: security-and-quality
-
-      - name: Autobuild
-        uses: github/codeql-action/autobuild@v3
-
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
-        with:
-          category: '/language:javascript-typescript/branch:${{ matrix.branch }}'
-
-      # 3. 密钥/敏感信息扫描
-      - name: Secret scanning with Gitleaks
-        uses: gitleaks/gitleaks-action@v2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        continue-on-error: true
-
-  # 动态获取所有分支并扫描
-  scan-all-branches:
-    name: Scan additional branches
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v5
-        with:
-          node-version: '24'
-          cache: 'npm'
-
-      - name: Run npm audit on all branches
-        run: |
-          git branch -r | grep -v HEAD | sed 's|origin/||' | tr -d ' ' | while read branch; do
-            echo "===== Auditing branch: $branch ====="
-            git checkout "$branch" 2>/dev/null || continue
-            # 尝试安装并审计
-            npm ci --ignore-scripts --silent 2>/dev/null || npm install --ignore-scripts --silent 2>/dev/null || true
-            npm audit --audit-level=moderate 2>/dev/null || true
-          done
-        continue-on-error: true
--- a/.gitignore
+++ b/.gitignore
@@ -76,5 +76,5 @@ wechat-research-site
 .codex
 weflow-web-offical
 /Wedecrypt
-.codebuddy/
-.DS_Store
+/scripts/syncwcdb.py
+/scripts/syncWedecrypt.py
--- a/README.md
+++ b/README.md
@@ -2,27 +2,33 @@

 WeFlow 是一个**完全本地**的微信**实时**聊天记录查看、分析与导出工具。它可以实时获取你的微信聊天记录并将其导出，还可以根据你的聊天记录为你生成独一无二的分析报告。

+---
+
+**WeFlow** is a fully local tool for viewing, analyzing, and exporting WeChat chat history in real time. It generates unique analysis reports based on your chat history.
+
 <p align="center">
-  <img src="app.png" alt="WeFlow 应用预览" width="90%">
+  <img src="app.jpg" alt="WeFlow 应用预览" width="90%">
 </p>

 <p align="center">
-  <!-- 第一行修复样式 -->
  <a href="https://github.com/hicccc77/WeFlow/stargazers"><img src="https://img.shields.io/github/stars/hicccc77/WeFlow?style=flat&label=Stars&labelColor=1F2937&color=2563EB" alt="Stargazers"></a>
  <a href="https://github.com/hicccc77/WeFlow/network/members"><img src="https://img.shields.io/github/forks/hicccc77/WeFlow?style=flat&label=Forks&labelColor=1F2937&color=7C3AED" alt="Forks"></a>
  <a href="https://github.com/hicccc77/WeFlow/issues"><img src="https://img.shields.io/github/issues/hicccc77/WeFlow?style=flat&label=Issues&labelColor=1F2937&color=D97706" alt="Issues"></a>
  <a href="https://github.com/hicccc77/WeFlow/releases"><img src="https://img.shields.io/github/downloads/hicccc77/WeFlow/total?style=flat&label=Downloads&labelColor=1F2937&color=059669" alt="Downloads"></a>
  <br><br>
-  <!-- 第二行：电报矮一点(22px)，排名高一点(32px)，使用 vertical-align: middle 居中对齐 -->
  <a href="https://t.me/weflow_cc"><img src="https://img.shields.io/badge/Telegram-频道-1D9BF0?style=flat&logo=telegram&logoColor=white&labelColor=1F2937&color=1D9BF0" alt="Telegram Channel" style="height: 22px; vertical-align: middle;"></a>
  <a href="https://www.star-history.com/hicccc77/weflow"><img src="https://api.star-history.com/badge?repo=hicccc77/WeFlow&theme=dark" alt="Star History Rank" style="height: 32px; vertical-align: middle;"></a>
 </p>

 > [!TIP]
 > 如果导出聊天记录后，想深入分析聊天内容可以试试 [ChatLab](https://chatlab.fun/)
+> 
+> If you want to analyze your exported chat content in depth, try [ChatLab](https://chatlab.fun/)

 > [!NOTE]
 > 仅支持微信 **4.0 及以上**版本，确保你的微信版本符合要求
+> 
+> Only supports WeChat **version 4.0 and above**. Please ensure your WeChat version meets the requirements.

 ## 主要功能

@@ -34,6 +40,18 @@ WeFlow 是一个**完全本地**的微信**实时**聊天记录查看、分析
 - HTTP API 接口（供开发者集成）
 - 查看完整能力清单：[详细功能](#详细功能清单)

+---
+
+**Key Features**
+
+- View chat history locally in real-time
+- Preview and decrypt Moments photos, videos, and **Live Photos**
+- Statistical analysis and group chat insights
+- Annual reports and visual overviews
+- Export chat history to HTML and other formats
+- HTTP API (for developer integration)
+- View complete feature list: [Detailed Features](#详细功能清单)
+
 ## 支持平台与设备

 | 平台 | 设备/架构 | 安装包 |
@@ -42,12 +60,30 @@ WeFlow 是一个**完全本地**的微信**实时**聊天记录查看、分析
 | macOS | Apple Silicon（M 系列，arm64） | `.dmg` |
 | Linux | x64 设备（amd64） | `.AppImage`、`.tar.gz` |

+---
+
+**Supported Platforms & Devices**
+
+| Platform | Device/Architecture | Package |
+|----------|---------------------|---------|
+| Windows | Windows 10+, x64 (amd64) | `.exe` |
+| macOS | Apple Silicon (M series, arm64) | `.dmg` |
+| Linux | x64 devices (amd64) | `.AppImage`, `.tar.gz` |
+
 ## 快速开始

 若你只想使用成品版本，可前往 [Releases](https://github.com/hicccc77/WeFlow/releases) 下载并安装。

 > ArchLinux 用户可以选择 `yay -S weflow` 快速安装

+---
+
+**Quick Start**
+
+If you just want to use the pre-compiled application, go to [Releases](https://github.com/hicccc77/WeFlow/releases) to download and install.
+
+> ArchLinux users can quickly install with `yay -S weflow`
+
 ## 详细功能清单

 当前版本已支持以下能力：
@@ -66,6 +102,26 @@ WeFlow 是一个**完全本地**的微信**实时**聊天记录查看、分析
 | **联系人** | 导出微信好友、群聊、公众号信息；尝试找回曾经的好友（功能尚不完善） |
 | **HTTP API 映射** | 将本地消息能力映射为 HTTP API，便于对接外部系统、自动化脚本与二次开发 |

+---
+
+**Detailed Feature List**
+
+The current version supports the following capabilities:
+
+| Feature Module | Description |
+|----------------|-------------|
+| **Chat** | Decrypt images, videos, and Live Photos in chats (only supports Live Photos captured with Google protocol); supports **modifying** and deleting **local** messages; real-time refresh of latest messages without generating decrypted intermediate databases |
+| **Anti-Recall** | Prevent messages sent by others from being recalled |
+| **Real-time Notifications** | Desktop popup notifications when new messages arrive, convenient for timely viewing of important conversations, with blacklist/whitelist functionality |
+| **Private Chat Analysis** | Statistics on message counts between friends; analysis of message types and sending ratios; view message time distribution, etc. |
+| **Group Chat Analysis** | View detailed group member information; analyze group activity rankings, active periods, and media content |
+| **Annual Report** | Generate annual reports by year, or long-term historical reports across years |
+| **Duo Report** | Select a specific friend and generate an exclusive analysis report based on your mutual chat history |
+| **Message Export** | Export WeChat chat history to multiple formats: JSON, HTML, TXT, Excel, CSV, PGSQL, ChatLab proprietary format, etc. |
+| **Moments** | Decrypt Moments photos, videos, and Live Photos; export Moments content; intercept deletion and hiding operations in Moments; bypass time-based access restrictions |
+| **Contacts** | Export WeChat friends, group chats, and official account information; attempt to recover deleted friends (work in progress) |
+| **HTTP API** | Map local message capabilities to HTTP API for easy integration with external systems, automation scripts, and secondary development |
+
 ## HTTP API

 > [!WARNING]
@@ -80,6 +136,20 @@ WeFlow 提供本地 HTTP API 服务，支持通过接口查询消息数据，可

 完整接口文档：[点击查看](docs/HTTP-API.md)

+---
+
+> [!WARNING]
+> This feature is currently in its early stages, and the interface may change. Stay tuned for future updates.
+
+WeFlow provides a local HTTP API service that supports querying message data through interfaces, which can be used for integration with other tools or secondary development.
+
+- **Enable Method**: Settings → API Service → Start Service
+- **Default Port**: 5031
+- **Access Address**: `http://127.0.0.1:5031`
+- **Supported Formats**: Raw JSON or [ChatLab](https://chatlab.fun/) standard format
+
+Complete API documentation: [Click to view](docs/HTTP-API.md)
+
 ## 面向开发者

 如果你想从源码构建或为项目贡献代码，请遵循以下步骤：
@@ -96,17 +166,50 @@ npm install
 npm run dev
 ```

+---
+
+**For Developers**
+
+If you want to build from source or contribute code to the project, please follow these steps:
+
+```bash
+# 1. Clone the project locally
+git clone https://github.com/hicccc77/WeFlow.git
+cd WeFlow
+
+# 2. Install project dependencies
+npm install
+
+# 3. Run the application (development mode)
+npm run dev
+```
+
 ## 致谢

 - [密语 CipherTalk](https://github.com/ILoveBingLu/miyu) 为本项目提供了基础框架
 - [WeChat-Channels-Video-File-Decryption](https://github.com/Evil0ctal/WeChat-Channels-Video-File-Decryption) 提供了视频解密相关的技术参考

+---
+
+**Acknowledgments**
+
+- [CipherTalk](https://github.com/ILoveBingLu/miyu) provided the basic framework for this project
+- [WeChat-Channels-Video-File-Decryption](https://github.com/Evil0ctal/WeChat-Channels-Video-File-Decryption) provided technical references for video decryption
+
 ## 支持我们

 如果 WeFlow 确实帮到了你，可以考虑请我们喝杯咖啡：

 > TRC20 **Address:** `TZCtAw8CaeARWZBfvjidCnTcfnAtf6nvS6`

+---
+
+**Support Us**
+
+If WeFlow has truly helped you, consider buying us a coffee:
+
+> TRC20 **Address:** `TZCtAw8CaeARWZBfvjidCnTcfnAtf6nvS6`
+
 ## Star History

 <a href="https://www.star-history.com/#hicccc77/WeFlow&type=date&legend=top-left">
@@ -123,4 +226,6 @@ npm run dev

 **请负责任地使用本工具，遵守相关法律法规**

+**Please use this tool responsibly and comply with relevant laws and regulations**
+
 </div>
--- a/app.jpg
+++ b/app.jpg
--- a/app.png
+++ b/app.png
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -1,596 +0,0 @@
-# WeFlow 项目蓝图与架构文档
-
-> 版本：对应 `package.json` v4.3.0 · 生成时间：2026-04-17  
-> 适用于开发者、新成员上手、Agent（CodeBuddy 等）自动化协作
-
---
-
-## 1. 项目定位
-
-**WeFlow** 是一个**完全本地**的微信 4.0+ 聊天记录查看、分析与导出的桌面应用。
-
-| 维度 | 说明 |
-|------|------|
-| 产品形态 | Electron 桌面应用（Windows / macOS / Linux） |
-| 核心诉求 | 实时查看 & 解密本地微信数据库、生成聊天分析 / 年度报告 / 双人报告、导出多格式、朋友圈解密 |
-| 数据边界 | 全部本地运行，无云端上传；可选开放本地 HTTP API（端口 5031） |
-| 许可 | 见 `LICENSE` |
-| 版本策略 | electron-updater + GitHub Releases，支持自动更新与差分包 |
-
-### 1.1 关键功能矩阵
-
-| 模块 | 能力概述 | 主要代码落点 |
-|------|---------|-------------|
-| 实时聊天查看 | 消息列表、撤回防护、实时刷新 | [ChatPage.tsx](src/pages/ChatPage.tsx) + [chatService.ts](electron/services/chatService.ts) |
-| 图片/视频/实况解密 | XOR / AES + ffmpeg 转码 | [imageDecryptService.ts](electron/services/imageDecryptService.ts), [videoService.ts](electron/services/videoService.ts) |
-| 私聊/群聊分析 | 统计消息、时段、画像 | [analyticsService.ts](electron/services/analyticsService.ts), [groupAnalyticsService.ts](electron/services/groupAnalyticsService.ts) |
-| 年度 / 双人报告 | 跨年数据生成、可视化 | [annualReportService.ts](electron/services/annualReportService.ts), [dualReportService.ts](electron/services/dualReportService.ts) + 对应 Worker |
-| 导出 | JSON / HTML / TXT / Excel / CSV / ChatLab | [exportService.ts](electron/services/exportService.ts) + [exportWorker.ts](electron/exportWorker.ts) |
-| 朋友圈 | 图片/视频/实况解密、时间突破 | [snsService.ts](electron/services/snsService.ts) + [SnsPage.tsx](src/pages/SnsPage.tsx) |
-| HTTP API | 本地消息 API 服务 | [httpService.ts](electron/services/httpService.ts) + [docs/HTTP-API.md](docs/HTTP-API.md) |
-| 语音转写 | sherpa-onnx ASR + silk-wasm | [voiceTranscribeService.ts](electron/services/voiceTranscribeService.ts) + [transcribeWorker.ts](electron/transcribeWorker.ts) |
-| 通知与防撤回 | 桌面弹窗、黑白名单 | [messagePushService.ts](electron/services/messagePushService.ts), [notificationWindow.ts](electron/windows/notificationWindow.ts) |
-| 应用锁 | Windows Hello / 系统凭据 | [windowsHelloService.ts](electron/services/windowsHelloService.ts) + [LockScreen.tsx](src/components/LockScreen.tsx) |
-
---
-
-## 2. 技术栈总览
-
-### 2.1 运行时 & 构建
-
-| 层 | 技术 | 说明 |
-|----|------|------|
-| Shell | Electron 41 | 主进程 + 渲染进程分离 |
-| 渲染进程 | React 19 + TypeScript 6 | 使用 `react-router-dom@7` 路由 |
-| 构建 | Vite 7 + `vite-plugin-electron` + `vite-plugin-electron-renderer` | 一次构建产出主/渲染/Worker |
-| 样式 | SCSS（`sass`） + 组件局部样式 | 深浅色 + 主题色切换（`data-theme` / `data-mode`） |
-| 打包 | electron-builder 26 | Win `.exe`(NSIS)、macOS `.dmg/.zip`、Linux `AppImage/tar.gz` |
-| 自动更新 | electron-updater + GitHub provider | 差分包关闭，支持强制更新 |
-
-### 2.2 核心依赖
-
-| 类别 | 库 | 用途 |
-|------|----|------|
-| 状态管理 | `zustand` | 轻量全局 store，见 `src/stores/` |
-| UI 图标 | `lucide-react` | 图标系统 |
-| 图表 | `echarts` + `echarts-for-react` | 分析与报告可视化 |
-| 长列表 | `react-virtuoso` | 聊天消息虚拟滚动 |
-| Markdown | `react-markdown` + `remark-gfm` | 报告与富文本 |
-| 数据库 | `wcdb` 原生 + `koffi` FFI | 微信 SQLite/WCDB 加密数据库读取 |
-| 多媒体 | `ffmpeg-static`、`silk-wasm`、`sherpa-onnx-node` | 视频解码、silk 语音、ASR |
-| 中文分词 | `jieba-wasm` | 词云与分析 |
-| 配置 | `electron-store` | JSON 持久化 |
-| 导出 | `exceljs`、`jszip`、`html2canvas` | 多格式产物 |
-| 辅助 | `fzstd`、`wechat-emojis`、`sudo-prompt` | zstd 解压、表情、提权 |
-
---
-
-## 3. 目录蓝图
-
-```
-WeFlow/
-├── electron/                         # 主进程与 Worker（Node.js 环境）
-│   ├── main.ts                       # 主进程入口（≈122KB，IPC 汇聚点）
-│   ├── preload.ts                    # 预加载脚本，暴露 window.electronAPI
-│   ├── preload-env.ts                # 环境预加载（启动前）
-│   ├── annualReportWorker.ts         # 年度报告工作线程
-│   ├── dualReportWorker.ts           # 双人报告工作线程
-│   ├── exportWorker.ts               # 导出工作线程
-│   ├── imageSearchWorker.ts          # 图像检索/遍历工作线程
-│   ├── transcribeWorker.ts           # 语音转写工作线程
-│   ├── wcdbWorker.ts                 # WCDB 读取工作线程
-│   ├── services/                     # 业务服务（按域拆分）
-│   ├── windows/notificationWindow.ts # 独立通知窗口
-│   ├── utils/LRUCache.ts             # 主进程工具
-│   ├── assets/wasm/                  # wasm 资源（jieba、silk 等）
-│   └── types/                        # 原生模块类型声明
-│
-├── src/                              # 渲染进程（React）
-│   ├── main.tsx / App.tsx / App.scss # 入口与根路由
-│   ├── pages/                        # 页面级组件（大文件集中地）
-│   ├── components/                   # 通用/业务组件
-│   │   ├── Export/                   # 导出子组件
-│   │   └── Sns/                      # 朋友圈子组件
-│   ├── services/                     # 渲染层服务（通过 IPC 调用主进程）
-│   ├── stores/                       # Zustand 全局状态
-│   ├── styles/                       # 全局样式与主题
-│   ├── types/                        # 渲染层类型
-│   └── utils/                        # 工具函数
-│
-├── docs/                             # 项目文档（HTTP-API、架构文档等）
-├── resources/                        # 平台资源：icons / runtime / wcdb / key / installer
-├── public/                           # 前端静态资源 + splash
-├── .github/workflows/                # CI：release、nightly、security-scan 等
-├── AGENTS.md                         # Agent 协作规则
-├── README.md                         # 用户说明
-├── package.json                      # 依赖 + electron-builder 配置
-├── vite.config.ts                    # 构建管线（1 主 + 7 Worker + preload）
-├── tsconfig.json / tsconfig.node.json
-├── installer.nsh                     # NSIS 安装脚本
-└── .gitleaks.toml                    # 密钥扫描配置
-```
-
---
-
-## 4. 架构总览
-
-### 4.1 高层架构图
-
-```mermaid
-flowchart TB
-    subgraph User["用户"]
-      U([👤])
-    end
-
-    subgraph Renderer["渲染进程 (Chromium + React 19)"]
-      UI[["Pages / Components"]]
-      Stores[(Zustand Stores)]
-      RSvc["渲染层服务\n(src/services)"]
-      UI <--> Stores
-      UI --> RSvc
-    end
-
-    subgraph Preload["preload.ts\n(contextBridge)"]
-      API["window.electronAPI"]
-    end
-
-    subgraph Main["主进程 (Node.js)"]
-      IPC[["ipcMain\nhandlers (main.ts)"]]
-      subgraph Services["electron/services/*"]
-        Chat[chatService]
-        Export[exportService]
-        Image[imageDecryptService]
-        Sns[snsService]
-        Analytics[analyticsService]
-        GAnalytics[groupAnalyticsService]
-        Annual[annualReportService]
-        Dual[dualReportService]
-        Http[httpService]
-        Key[keyService + Mac/Linux/WindowsHello]
-        Wcdb[wcdbService / wcdbCore]
-        Voice[voiceTranscribeService]
-        Msg[messagePushService]
-        Cfg[config]
-      end
-      subgraph Workers["Utility Workers (vite 独立打包)"]
-        W1[wcdbWorker]
-        W2[exportWorker]
-        W3[annualReportWorker]
-        W4[dualReportWorker]
-        W5[transcribeWorker]
-        W6[imageSearchWorker]
-      end
-      IPC --> Services
-      Services --> Workers
-    end
-
-    subgraph OS["操作系统 & 外部资源"]
-      Fs[(本地文件系统\n微信数据目录)]
-      NativeLibs[(原生库\nkoffi / sherpa-onnx / ffmpeg / wcdb)]
-      Store[(electron-store\nJSON 配置)]
-      HttpClient[(外部 HTTP 客户端\nChatLab / 脚本)]
-      Updater[(GitHub Releases\nelectron-updater)]
-    end
-
-    U --> UI
-    RSvc --> API
-    API <--> IPC
-    Services --> Fs
-    Services --> NativeLibs
-    Services --> Store
-    Http -. 暴露 5031 .-> HttpClient
-    Main -. 自动更新 .-> Updater
-```
-
-### 4.2 进程与线程模型
-
-```mermaid
-flowchart LR
-    Main[[主进程\nelectron/main.ts]]
-    Pre[[Preload\nelectron/preload.ts]]
-    R1[渲染：主窗口\nindex.html + App.tsx]
-    R2[渲染：通知窗口]
-    R3[渲染：视频/图片独立窗口]
-    R4[渲染：聊天记录窗口]
-    R5[渲染：年度/双人报告窗口]
-    W1((wcdbWorker))
-    W2((exportWorker))
-    W3((annualReportWorker))
-    W4((dualReportWorker))
-    W5((transcribeWorker))
-    W6((imageSearchWorker))
-
-    Main --- Pre --- R1
-    Main --- R2
-    Main --- R3
-    Main --- R4
-    Main --- R5
-    Main -. Worker_threads/child_process .-> W1
-    Main -. 同上 .-> W2
-    Main -. 同上 .-> W3
-    Main -. 同上 .-> W4
-    Main -. 同上 .-> W5
-    Main -. 同上 .-> W6
-```
-
-> 关键设计：**CPU 密集或长耗任务全部外包到独立 Worker**，通过 `vite.config.ts` 的多 entry 独立打包。`inlineDynamicImports: true` 保证 worker 单文件产物可 `new Worker(path)` 直接加载。
-
-### 4.3 通信契约（IPC 命名空间）
-
-`electron/main.ts` 中 `ipcMain.handle` / `ipcMain.on` 采用 **前缀:动作** 命名空间，统一走 [preload.ts](electron/preload.ts) 暴露的 `window.electronAPI.<ns>.<method>`：
-
-| 命名空间 | 典型通道 | 所属服务 |
-|---------|---------|---------|
-| `config:*` | `get` / `set` / `clear` | `config.ts` |
-| `dialog:*` | `openFile` / `openDirectory` / `saveFile` | Electron `dialog` |
-| `shell:*` | `openPath` / `openExternal` | Electron `shell` |
-| `app:*` | `getVersion` / `checkForUpdates` / `downloadAndInstall` / `ignoreUpdate` / `getLaunchAtStartupStatus` | 主进程 + updater |
-| `window:*` | `minimize` / `maximize` / `close` / `isMaximized` / `openVideoPlayerWindow` / `openChatHistoryWindow` / `openSessionChatWindow` / `respondCloseConfirm` / `setTitleBarOverlay` | 主窗口管理 |
-| `log:*` / `diagnostics:*` | 日志读取、导出卡片诊断 | 日志系统 |
-| `cloud:*` | `init` / `recordPage` / `getLogs` | `cloudControlService` |
-| `insight:*` | `testConnection` / `getTodayStats` / `triggerTest` / `generateFootprintInsight` | `insightService` |
-| `video:*` | `getVideoInfo` / `parseVideoMd5` | `videoService` |
-| `dbpath:*` | `autoDetect` / `scanWxids` / `scanWxidCandidates` / `getDefault` | `dbPathService` |
-| `wcdb:*` | `testConnection` / `open` / `close` | `wcdbService` |
-| `chat:*` | 会话、消息、联系人等（见 `preload.ts`） | `chatService` |
-| `export:*` | 导出任务、进度、取消 | `exportService` |
-| `sns:*` | 朋友圈列表、解密 | `snsService` |
-| `analytics:*` / `group-analytics:*` | 统计查询 | 对应 Service |
-| `annual-report:*` / `dual-report:*` | 报告生成 | 对应 Service |
-| `voice:*` | 语音转写 | `voiceTranscribeService` |
-| `auth:*` | 应用锁状态 | `keyService*` / `windowsHelloService` |
-| `notification:*` | 新消息通知与跳转 | `messagePushService` + `notificationWindow` |
-
-> 上述仅为骨架，完整 IPC 契约以 [preload.ts](electron/preload.ts) 为唯一来源（≈28KB，包含完整白名单与类型）。
-
---
-
-## 5. 渲染进程结构
-
-### 5.1 路由蓝图
-
-基于 [App.tsx](src/App.tsx) 的实际路由：
-
-```mermaid
-flowchart TB
-    Start((启动)) --> Gate{路由判定}
-    Gate -->|"/agreement-window"| AgreeWin[AgreementPage · 独立窗口]
-    Gate -->|"/onboarding-window"| Welcome[WelcomePage · standalone]
-    Gate -->|"/video-player-window"| VideoWin[VideoWindow]
-    Gate -->|"/image-viewer-window"| ImgWin[ImageWindow]
-    Gate -->|"/chat-history/..."| HistWin[ChatHistoryPage]
-    Gate -->|"/chat-window"| ChatStandalone[ChatPage · standalone]
-    Gate -->|"/notification-window"| NotifWin[NotificationWindow]
-
-    Gate -->|主窗口| Main[[主布局:\nTitleBar + Sidebar + Content]]
-    Main --> Home[/home: HomePage/]
-    Main --> AcctMgmt[/account-management/]
-    Main --> Chat[/chat: ChatPage/]
-    Main --> AnalyticsHub[/analytics: ChatAnalyticsHubPage/]
-    AnalyticsHub --> PrivAnaWel[/analytics/private: Welcome/]
-    AnalyticsHub --> PrivAna[/analytics/private/view/]
-    AnalyticsHub --> GroupAna[/analytics/group/]
-    Main --> Annual[/annual-report + /view/]
-    Main --> Dual[/dual-report + /view/]
-    Main --> Footprint[/footprint/]
-    Main --> Export[/export: ExportPage · keepalive/]
-    Main --> Sns[/sns: SnsPage/]
-    Main --> Biz[/biz: BizPage/]
-    Main --> Contacts[/contacts: ContactsPage/]
-    Main --> Res[/resources: ResourcesPage/]
-
-    Main -. 叠加 .-> Settings[/settings: SettingsPage · 背景路由切换/]
-```
-
-**亮点**：
- **ExportPage 采用 keep-alive 模式**：用 `export-keepalive-page` DOM 容器常驻，仅切换 `active/hidden` class，避免长任务重置。
- **Settings 路由叠加**：通过 `location.state.backgroundLocation` 实现在任意页面上浮设置面板。
- **多独立窗口**：视频、图片、通知、聊天记录、会话聊天、年度/双人报告均有独立 `BrowserWindow`。
-
-### 5.2 Zustand Stores
-
-| Store | 文件 | 职责 |
-|-------|------|------|
-| `useAppStore` | `src/stores/appStore.ts` | 数据库连接状态、更新信息、锁屏 |
-| `useThemeStore` | `src/stores/themeStore.ts` | 主题 ID / 模式（light/dark/system） |
-| `useChatStore` | `src/stores/chatStore.ts` | 当前会话、选中消息 |
-| `useAnalyticsStore` | `src/stores/analyticsStore.ts` | 分析页参数与缓存 |
-| `useImageStore` | `src/stores/imageStore.ts` | 图片解密结果缓存 |
-| `useBatchImageDecryptStore` | `src/stores/batchImageDecryptStore.ts` | 全局批量解密进度 |
-| `useBatchTranscribeStore` | `src/stores/batchTranscribeStore.ts` | 全局批量转写进度 |
-| `useContactTypeCountsStore` | `src/stores/contactTypeCountsStore.ts` | 联系人分类计数缓存 |
-
-### 5.3 渲染层服务
-
-| 文件 | 角色 |
-|------|------|
-| `src/services/ipc.ts` | IPC 桥接基础（与 preload 对齐） |
-| `src/services/config.ts` | 配置封装（73KB，大量常量与 setter/getter） |
-| `src/services/exportBridge.ts` | 导出事件桥（主→渲染进度广播） |
-| `src/services/cloudControl.ts` | 云控 / 统计上报（仅在用户同意后启用） |
-| `src/services/backgroundTaskMonitor.ts` | 后台任务监测（解密、转写、导出） |
-
---
-
-## 6. 主进程服务层（`electron/services/`）
-
-### 6.1 服务地图（按规模分层）
-
-```mermaid
-flowchart LR
-    subgraph Core["核心数据层 (超大)"]
-      ChatService["chatService.ts\n389KB"]
-      WcdbCore["wcdbCore.ts\n177KB"]
-      ExportService["exportService.ts\n343KB"]
-      SnsService["snsService.ts\n105KB"]
-      ImageDecrypt["imageDecryptService.ts\n75KB"]
-      GroupAnalytics["groupAnalyticsService.ts\n74KB"]
-      AnnualReport["annualReportService.ts\n58KB"]
-      KeyMac["keyServiceMac.ts\n51KB"]
-    end
-
-    subgraph Feature["功能层 (中大)"]
-      HttpSvc["httpService.ts\n62KB"]
-      InsightSvc["insightService.ts\n44KB"]
-      KeyService["keyService.ts\n39KB"]
-      Config["config.ts\n30KB"]
-      DualReport["dualReportService.ts\n30KB"]
-      AnalyticsSvc["analyticsService.ts\n24KB"]
-      WcdbService["wcdbService.ts\n24KB"]
-      VideoSvc["videoService.ts\n25KB"]
-      VoiceSvc["voiceTranscribeService.ts\n17KB"]
-      MessagePush["messagePushService.ts\n16KB"]
-      KeyLinux["keyServiceLinux.ts\n16KB"]
-    end
-
-    subgraph Util["工具与缓存 (小)"]
-      DbPath[dbPathService]
-      BizSvc[bizService]
-      Cloud[cloudControlService]
-      Wasm[wasmService]
-      Isaac[isaac64]
-      Avatar[avatarFileCacheService]
-      Contact[contactCacheService]
-      ContactExp[contactExportService]
-      GMsgCnt[groupMyMessageCountCacheService]
-      Session[sessionStatsCacheService]
-      Stats[exportContentStatsCacheService]
-      Rec[exportRecordService]
-      ImgPre[imagePreloadService]
-      MsgCache[messageCacheService]
-      Linux[linuxNotificationService]
-      Hello[windowsHelloService]
-      Styles[exportHtmlStyles]
-      CardDiag[exportCardDiagnosticsService]
-      Region[contactRegionLookupData]
-    end
-
-    ChatService --> WcdbCore
-    ExportService --> ChatService
-    SnsService --> WcdbCore
-    ImageDecrypt --> WcdbCore
-    GroupAnalytics --> ChatService
-    AnnualReport --> ChatService
-    DualReport --> ChatService
-    AnalyticsSvc --> ChatService
-    HttpSvc --> ChatService
-    InsightSvc --> ChatService
-```
-
-### 6.2 关键服务职责
-
-| 服务 | 核心职责 | 特别说明 |
-|------|---------|---------|
-| `chatService` | 会话列表、消息读取、媒体定位、实时刷新 | 超大文件，必须用 `codebase_search` / `view_code_item` 定位后再改 |
-| `wcdbCore` / `wcdbService` | 基于 `koffi` FFI 调用 WCDB 原生库，解密读取微信 SQLite | 跨平台原生库放在 `resources/wcdb/<platform>/` |
-| `keyService*` | 获取微信解密密钥（Win/Mac/Linux） | Mac 51KB：涉及内存扫描；Linux 独立实现；Win 通过 `windowsHelloService` 辅助 |
-| `imageDecryptService` | XOR / AES 解密图片、实况图片 | LRU 缓存 + 批量调度（配合 `batchImageDecryptStore`） |
-| `videoService` | 视频 md5 解析、ffmpeg 转码、生成封面 | 依赖 `ffmpeg-static` + `asarUnpack` |
-| `voiceTranscribeService` | silk→wav→sherpa-onnx ASR | 通过 `transcribeWorker` 异步执行 |
-| `snsService` | 朋友圈解密、导出、时间限制突破 | 单独的 `Sns/` 组件族对应 |
-| `analyticsService` / `groupAnalyticsService` | 私聊/群聊统计分析、排行、时段分布 | 依赖 `jieba-wasm` 分词 |
-| `annualReportService` / `dualReportService` | 年度/双人报告生成 | 将重算任务派给对应 Worker |
-| `exportService` + `exportWorker` | 多格式导出，分任务并发 + 进度广播 | HTML 导出样式来自 [exportHtml.css](electron/services/exportHtml.css) |
-| `httpService` | 本地 HTTP API 服务（默认 5031） | 详见 [docs/HTTP-API.md](docs/HTTP-API.md) |
-| `messagePushService` | 新消息监听 + 通知窗口推送 | 黑白名单、防撤回 |
-| `insightService` | 「我的足迹」洞察 / AI 辅助洞察 | 支持 Footprint 生成 |
-| `config` | 使用 `electron-store` 的 JSON 配置中台 | 多 wxid 配置、密钥、主题、协议同意等 |
-| `cloudControlService` | 开关/页面统计（用户同意后） | 完全本地化的云控模型 |
-
---
-
-## 7. 核心数据流
-
-### 7.1 启动 & 连接数据库流程
-
-```mermaid
-sequenceDiagram
-    participant U as 用户
-    participant App as App.tsx
-    participant Cfg as configService
-    participant IPC as window.electronAPI
-    participant Main as main.ts
-    participant Wcdb as wcdbService + wcdbCore
-
-    U->>App: 打开应用
-    App->>Cfg: getAgreementAccepted
-    alt 未同意
-        App-->>U: 显示协议弹窗
-    else 已同意
-        App->>Cfg: 读取 dbPath / decryptKey / wxid
-        alt 配置完整
-            App->>IPC: chat.connect()
-            IPC->>Main: ipcMain.handle('chat:connect')
-            Main->>Wcdb: open(dbPath, hexKey, wxid)
-            Wcdb-->>Main: 成功/失败
-            Main-->>IPC: { success }
-            IPC-->>App: setDbConnected(true)
-            App->>App: navigate('/home')
-        else 配置缺失
-            App->>App: 引导 WelcomePage
-        end
-    end
-```
-
-### 7.2 聊天消息读取与图片解密
-
-```mermaid
-sequenceDiagram
-    participant UI as ChatPage
-    participant Store as chatStore
-    participant IPC as electronAPI.chat
-    participant Chat as chatService
-    participant WCore as wcdbCore(FFI)
-    participant Img as imageDecryptService
-    participant W as imageSearchWorker
-
-    UI->>IPC: listMessages(sessionId, range)
-    IPC->>Chat: 查询消息
-    Chat->>WCore: SQL via koffi
-    WCore-->>Chat: 原始消息
-    Chat-->>UI: 消息列表（含图片引用）
-    UI->>Store: 写入消息
-    UI->>IPC: decryptImage(md5/hash)
-    IPC->>Img: 解密请求
-    alt 需要遍历目录
-        Img->>W: postMessage(search)
-        W-->>Img: 文件路径
-    end
-    Img-->>IPC: 解密后的路径/blob
-    IPC-->>UI: 图片数据
-```
-
-### 7.3 导出任务生命周期
-
-```mermaid
-stateDiagram-v2
-    [*] --> Queued: 用户点击导出
-    Queued --> Running: exportService 派发
-    Running --> WorkerRun: exportWorker 执行
-    WorkerRun --> Progress: 进度广播（exportBridge）
-    Progress --> WorkerRun
-    WorkerRun --> Success: 成功
-    WorkerRun --> Failed: 异常/取消
-    Success --> [*]
-    Failed --> [*]
-```
-
-**进度通道**：`exportService` → 主进程事件 → `exportBridge.ts` → 渲染层订阅者（`ExportPage`）。
-
---
-
-## 8. 构建与发布
-
-### 8.1 Vite 多入口
-
-[vite.config.ts](vite.config.ts) 声明 **8 个 entry**：
-
-| Entry | 产物 | 说明 |
-|-------|------|------|
-| `electron/main.ts` | `dist-electron/main.js` | 主进程 |
-| `electron/preload.ts` | `dist-electron/preload.js` | 预加载 |
-| `electron/annualReportWorker.ts` | `dist-electron/annualReportWorker.js` | 年度报告 worker |
-| `electron/dualReportWorker.ts` | `dist-electron/dualReportWorker.js` | 双人报告 worker |
-| `electron/imageSearchWorker.ts` | `dist-electron/imageSearchWorker.js` | 图像搜索 worker |
-| `electron/wcdbWorker.ts` | `dist-electron/wcdbWorker.js` | WCDB worker |
-| `electron/transcribeWorker.ts` | `dist-electron/transcribeWorker.js` | 语音转写 worker |
-| `electron/exportWorker.ts` | `dist-electron/exportWorker.js` | 导出 worker |
-
- `react(), renderer()` 插件处理渲染进程；`inlineDynamicImports: true` 确保 worker 单文件。
- `external`：`koffi` / `better-sqlite3` / `sherpa-onnx-node` / `exceljs` / `ffmpeg-static` 不打包进 bundle，asar 外存放。
-
-### 8.2 打包策略（electron-builder）
-
-| 平台 | Target | 关键配置 |
-|------|--------|---------|
-| Windows | `nsis` | `installer.nsh`、多语言安装器、VC++ 运行库随包 |
-| macOS | `dmg` + `zip` | `hardenedRuntime: false`、`entitlements.mac.plist` |
-| Linux | `AppImage` + `tar.gz` | 附带 `resources/linux/install.sh` |
-| `asarUnpack` | `silk-wasm` / `sherpa-onnx-*` / `ffmpeg-static` | 原生/二进制模块不能进 asar |
-| `extraResources` | `resources/**` + `public/icon.*` + `electron/assets/wasm/` | 运行时资源 |
-| `publish` | GitHub `Jasonzhu1207/WeFlow` | 配合 `electron-updater` |
-
-### 8.3 CI 流水线（`.github/workflows/`）
-
-| 文件 | 作用 |
-|------|------|
-| `release.yml` | 发布打包 |
-| `preview-nightly-main.yml` | Nightly 构建 |
-| `dev-daily-fixed.yml` | Dev 日常 |
-| `security-scan.yml` | 安全扫描（含 gitleaks） |
-| `anti-spam.yml` | Issue 反垃圾 |
-| `issue-auto-assign.yml` | Issue 自动分派 |
-
---
-
-## 9. 安全与合规设计
-
-1. **数据本地化**：全部解密、分析、导出均在本地执行，不上传任何聊天内容（协议与隐私弹窗双重同意）。
-2. **密钥保护**：
-   - 微信 key 通过平台特定 `keyService*` 动态获取，不落盘；
-   - 应用锁可选 Windows Hello / 系统凭据；
-   - `.gitleaks.toml` 扫描源码防止密钥入库。
-3. **参数化查询**：所有 SQLite 查询通过 WCDB 参数化接口，避免拼接。
-4. **更新通道**：仅从 GitHub Releases 拉取，支持强制更新（`minimumVersion`）。
-5. **云控与统计**：`cloudControlService` 完全可选，用户可拒绝；默认不采集任何聊天内容。
-6. **IPC 白名单**：`preload.ts` 通过 `contextBridge` 仅暴露有限 API，渲染层无法直接访问 Node。
-
---
-
-## 10. 性能关键点
-
-| 热点 | 设计 |
-|------|------|
-| 消息列表（聊天动辄百万级） | `react-virtuoso` 虚拟滚动 + `chatService` 分页 + `LRUCache` |
-| 图片解密批量（几千张） | `imageDecryptService` + `imageSearchWorker` + 全局进度 store |
-| 年度/双人报告（跨年聚合） | 独立 Worker + 分块流式 + 缓存（`groupMyMessageCountCacheService`、`sessionStatsCacheService` 等） |
-| 导出大体量 HTML/Excel | `exportWorker` + `jszip` 流式写入 + 进度广播 |
-| 主题切换 & 样式 | CSS 变量 + `data-theme` / `data-mode` 根属性切换，无重渲染 |
-| 启动速度 | `splash.html` 早期显示 + 主题预读 + DB 异步连接 |
-
---
-
-## 11. 扩展点（二开指南）
-
-| 场景 | 落点 |
-|------|------|
-| 新增页面 | `src/pages/` 新建 `XxxPage.tsx` + `.scss`，在 [App.tsx](src/App.tsx) 路由和 [Sidebar.tsx](src/components/Sidebar.tsx) 菜单登记 |
-| 新增主进程能力 | `electron/services/` 新建 service，在 `main.ts` 添加 `ipcMain.handle('ns:action', ...)`，在 [preload.ts](electron/preload.ts) 暴露 → 渲染层新增对应 `src/services/` 或直接 `window.electronAPI.ns.action()` 调用 |
-| 新增 Worker | `electron/xxxWorker.ts` 建立，在 [vite.config.ts](vite.config.ts) 添加 entry |
-| 新增导出格式 | 扩展 `exportService` + `exportWorker`，UI 在 `src/components/Export/` 与 `ExportPage.tsx` 挂接 |
-| 新增 HTTP API | `httpService.ts` 注册路由，同步更新 [docs/HTTP-API.md](docs/HTTP-API.md) |
-| 新增主题 | `src/stores/themeStore.ts` 的 themes 列表 + `src/styles/` 主题 SCSS |
-| 新语言支持 | 当前未接入 i18n，需要新增语言时优先引入 `react-i18next`（评估风险） |
-
---
-
-## 12. 已知风险与技术债
-
-| 风险 | 说明 | 缓解建议 |
-|------|------|---------|
-| 超大文件 | `ChatPage.tsx` 397KB、`ExportPage.tsx` 402KB、`chatService.ts` 389KB、`exportService.ts` 343KB、`SettingsPage.tsx` 174KB | 新增内容尽量独立成文件；只在必须时才对这些文件进行精细化 diff，禁止盲目整读 |
-| 原生模块兼容 | `koffi`、`sherpa-onnx-node`、`wcdb` 随平台/Electron 版本变化 | 升级前先 `npm run rebuild` 并跑三端冒烟 |
-| 配置 migrate | `electron-store` schema 无正式迁移框架 | 新字段默认可 Optional；破坏性变更需加版本号判定 |
-| 单一 `preload.ts` | 28KB，IPC 全部集中 | 保持字段分组；考虑按域拆分 preload 模块（需评估 `contextBridge` 成本） |
-| 无自动化测试 | 缺少单元/集成测试 | 新功能按 AGENTS.md "Level 2 TDD" 策略补齐关键分支 |
-
---
-
-## 13. 快速上手路径（推荐）
-
-1. 通读 [README.md](README.md) + 本架构文档
-2. 阅读 [AGENTS.md](AGENTS.md) 了解协作与门禁
-3. 顺序浏览：[App.tsx](src/App.tsx) → [Sidebar.tsx](src/components/Sidebar.tsx) → [preload.ts](electron/preload.ts) → [main.ts](electron/main.ts)（搜索 `ipcMain.handle`）
-4. 按域选择 Service 细读：聊天链路入口从 `chat:connect` / `chat:listSessions` 反查 [chatService.ts](electron/services/chatService.ts)
-5. 运行 `npm install && npm run dev` 启动联调；`npm run typecheck` 验证
-
---
-
-## 14. 参考文档
-
- [README.md](README.md)
- [docs/HTTP-API.md](docs/HTTP-API.md)
- [AGENTS.md](AGENTS.md)
- [vite.config.ts](vite.config.ts)
- [package.json](package.json)
-
--- a/docs/HTTP-API.md
+++ b/docs/HTTP-API.md
@@ -27,8 +27,8 @@ WeFlow 提供本地 HTTP API（已支持GET 和 POST请求），便于外部脚
 - `GET|POST /api/v1/health`
 - `GET|POST /api/v1/push/messages`
 - `GET|POST /api/v1/messages`
- `GET|POST /api/v1/messages/new`
 - `GET|POST /api/v1/sessions`
+- `GET /api/v1/sessions/:id/messages` (ChatLab Pull)
 - `GET|POST /api/v1/contacts`
 - `GET|POST /api/v1/group-members`
 - `GET|POST /api/v1/media/*`
@@ -74,18 +74,19 @@ GET /api/v1/push/messages
 - 需要先在设置页开启 `HTTP API 服务`
 - 同时需要开启 `主动推送`
 - 响应类型为 `text/event-stream`
- 新消息事件名固定为 `message.new`
- 建议接收端按 `messageKey` 去重
+- 事件名包含 `message.new` 和 `message.revoke`
+- 建议接收端按 `event + rawid` 去重

 ### 事件字段

 - `event`
 - `sessionId`
- `messageKey`
+- `rawid`
 - `avatarUrl`
 - `sourceName`
 - `groupName`（仅群聊）
 - `content`
+- `timestamp`（消息时间，秒级 Unix 时间戳）

 ### 示例

@@ -97,7 +98,14 @@ curl -N "http://127.0.0.1:5031/api/v1/push/messages?access_token=YOUR_TOKEN

 ```text
 event: message.new
-data: {"event":"message.new","sessionId":"xxx@chatroom","messageKey":"server:123456:1760000123:1760000123000:321:wxid_member:1","avatarUrl":"https://example.com/group.jpg","sourceName":"李四","groupName":"项目群","content":"[图片]"}
+data: {"event":"message.new","sessionId":"xxx@chatroom","sessionType":"group","rawid":"1234567890123456789","avatarUrl":"https://example.com/group.jpg","sourceName":"李四","groupName":"项目群","content":"[图片]","timestamp":1760000123}
+```
+
+撤回事件示例：
+
+```text
+event: message.revoke
+data: {"event":"message.revoke","sessionId":"wxid_xxx","sessionType":"other","rawid":"1234567890123456789","avatarUrl":"https://example.com/avatar.jpg","sourceName":"张三","content":"对方撤回了一条消息（rawid：1234567890123456789） 内容为“你好”","timestamp":1760000180}
 ```

 ---
@@ -116,21 +124,21 @@ GET /api/v1/messages

 ### 参数

-| 参数 | 类型 | 必填 | 说明 |
-| --- | --- | --- | --- |
-| `talker` | string | 是 | 会话 ID。私聊通常是对方 `wxid`，群聊是 `xxx@chatroom` |
-| `limit` | number | 否 | 返回条数，默认 `100`，范围 `1~10000` |
-| `offset` | number | 否 | 分页偏移，默认 `0` |
-| `start` | string | 否 | 开始时间，支持 `YYYYMMDD` 或时间戳 |
-| `end` | string | 否 | 结束时间，支持 `YYYYMMDD` 或时间戳 |
-| `keyword` | string | 否 | 基于消息显示文本过滤 |
-| `chatlab` | string | 否 | `1/true` 时输出 ChatLab 格式 |
-| `format` | string | 否 | `json` 或 `chatlab` |
-| `media` | string | 否 | `1/true` 时导出媒体并返回媒体地址，兼容别名 `meiti` |
-| `image` | string | 否 | 在 `media=1` 时控制图片导出，兼容别名 `tupian` |
-| `voice` | string | 否 | 在 `media=1` 时控制语音导出，兼容别名 `vioce` |
-| `video` | string | 否 | 在 `media=1` 时控制视频导出 |
-| `emoji` | string | 否 | 在 `media=1` 时控制表情导出 |
+| 参数      | 类型   | 必填 | 说明                                                  |
+| --------- | ------ | ---- | ----------------------------------------------------- |
+| `talker`  | string | 是   | 会话 ID。私聊通常是对方 `wxid`，群聊是 `xxx@chatroom` |
+| `limit`   | number | 否   | 返回条数，默认 `100`，范围 `1~10000`                  |
+| `offset`  | number | 否   | 分页偏移，默认 `0`                                    |
+| `start`   | string | 否   | 开始时间，支持 `YYYYMMDD` 或时间戳                    |
+| `end`     | string | 否   | 结束时间，支持 `YYYYMMDD` 或时间戳                    |
+| `keyword` | string | 否   | 基于消息显示文本过滤                                  |
+| `chatlab` | string | 否   | `1/true` 时输出 ChatLab 格式                          |
+| `format`  | string | 否   | `json` 或 `chatlab`                                   |
+| `media`   | string | 否   | `1/true` 时导出媒体并返回媒体地址，兼容别名 `meiti`   |
+| `image`   | string | 否   | 在 `media=1` 时控制图片导出，兼容别名 `tupian`        |
+| `voice`   | string | 否   | 在 `media=1` 时控制语音导出，兼容别名 `vioce`         |
+| `video`   | string | 否   | 在 `media=1` 时控制视频导出                           |
+| `emoji`   | string | 否   | 在 `media=1` 时控制表情导出                           |

 ### 示例

@@ -165,6 +173,8 @@ curl "http://127.0.0.1:5031/api/v1/messages?talker=xxx@chatroom&media=1&image=1&
 - `content`
 - `rawContent`
 - `parsedContent`
+- `replyToMessageId`（引用回复目标消息的 `serverId`，仅引用消息返回）
+- `quote`（引用消息快照，包含被引用消息的 ID、发送者、内容和类型）
 - `mediaType`
 - `mediaFileName`
 - `mediaUrl`
@@ -176,7 +186,7 @@ curl "http://127.0.0.1:5031/api/v1/messages?talker=xxx@chatroom&media=1&image=1&
 {
  "success": true,
  "talker": "xxx@chatroom",
-  "count": 2,
+  "count": 3,
  "hasMore": true,
  "media": {
    "enabled": true,
@@ -186,7 +196,7 @@ curl "http://127.0.0.1:5031/api/v1/messages?talker=xxx@chatroom&media=1&image=1&
  "messages": [
    {
      "localId": 123,
-      "serverId": "456",
+      "serverId": "6116895530414915131",
      "localType": 1,
      "createTime": 1738713600,
      "isSend": 0,
@@ -195,6 +205,25 @@ curl "http://127.0.0.1:5031/api/v1/messages?talker=xxx@chatroom&media=1&image=1&
      "rawContent": "你好",
      "parsedContent": "你好"
    },
+    {
+      "localId": 125,
+      "serverId": "6116895530414915133",
+      "localType": 244813135921,
+      "createTime": 1738713700,
+      "isSend": 0,
+      "senderUsername": "wxid_member",
+      "content": "收到",
+      "rawContent": "<msg>...</msg>",
+      "parsedContent": "收到",
+      "replyToMessageId": "6116895530414915131",
+      "quote": {
+        "platformMessageId": "6116895530414915131",
+        "sender": "wxid_other",
+        "accountName": "张三",
+        "content": "你好",
+        "type": 0
+      }
+    },
    {
      "localId": 124,
      "localType": 3,
@@ -235,6 +264,7 @@ curl "http://127.0.0.1:5031/api/v1/messages?talker=xxx@chatroom&media=1&image=1&
 - `messages[].type`
 - `messages[].content`
 - `messages[].platformMessageId`
+- `messages[].replyToMessageId`
 - `messages[].mediaPath`

 群聊里 `groupNickname` 会优先来自群成员群昵称；若源数据缺失，则回退为空或展示名。
@@ -253,10 +283,10 @@ GET /api/v1/sessions

 ### 参数

-| 参数 | 类型 | 必填 | 说明 |
-| --- | --- | --- | --- |
-| `keyword` | string | 否 | 匹配 `username` 或 `displayName` |
-| `limit` | number | 否 | 默认 `100` |
+| 参数      | 类型   | 必填 | 说明                             |
+| --------- | ------ | ---- | -------------------------------- |
+| `keyword` | string | 否   | 匹配 `username` 或 `displayName` |
+| `limit`   | number | 否   | 默认 `100`                       |

 ### 响应字段

@@ -288,6 +318,130 @@ GET /api/v1/sessions

 ---

+## 4.1 获取会话列表（ChatLab 格式）
+
+当 `format=chatlab` 时，返回 ChatLab Pull 协议兼容格式，可直接作为 ChatLab 远程数据源。
+
+**请求**
+
+```http
+GET /api/v1/sessions?format=chatlab
+```
+
+### 参数
+
+| 参数      | 类型   | 必填 | 说明                             |
+| --------- | ------ | ---- | -------------------------------- |
+| `format`  | string | 是   | 设为 `chatlab`                   |
+| `keyword` | string | 否   | 匹配 `username` 或 `displayName` |
+| `limit`   | number | 否   | 默认 `100`                       |
+
+### 响应
+
+```json
+{
+  "sessions": [
+    {
+      "id": "xxx@chatroom",
+      "name": "项目群",
+      "platform": "wechat",
+      "type": "group",
+      "messageCount": 58000,
+      "lastMessageAt": 1738713600
+    }
+  ]
+}
+```
+
+| 字段            | 说明                                |
+| --------------- | ----------------------------------- |
+| `id`            | 会话 ID（微信 username）            |
+| `name`          | 会话显示名称                        |
+| `platform`      | 固定 `wechat`                       |
+| `type`          | `group`（群聊）或 `private`（私聊） |
+| `messageCount`  | 消息数量（估算值，可能不精确）      |
+| `lastMessageAt` | 最后消息的秒级 Unix 时间戳          |
+
+---
+
+## 4.2 拉取会话消息（ChatLab Pull）
+
+返回 ChatLab 标准格式的聊天数据，支持增量拉取和分页。
+
+**请求**
+
+```http
+GET /api/v1/sessions/:id/messages
+```
+
+### 参数
+
+| 参数     | 类型   | 必填 | 说明                                     |
+| -------- | ------ | ---- | ---------------------------------------- |
+| `:id`    | string | 是   | 会话 ID（Path 参数）                     |
+| `since`  | number | 否   | 秒级 Unix 时间戳，仅返回此时间之后的消息 |
+| `end`    | number | 否   | 秒级 Unix 时间戳，时间上界               |
+| `limit`  | number | 否   | 单次返回上限，默认且最大 `5000`          |
+| `offset` | number | 否   | 分页偏移，默认 `0`                       |
+
+### 响应
+
+返回 ChatLab 标准 JSON 格式，外加 `sync` 分页块：
+
+```json
+{
+  "chatlab": {
+    "version": "0.0.2",
+    "exportedAt": 1738713600,
+    "generator": "WeFlow"
+  },
+  "meta": {
+    "name": "项目群",
+    "platform": "wechat",
+    "type": "group",
+    "groupId": "xxx@chatroom",
+    "ownerId": "wxid_xxx"
+  },
+  "members": [
+    {
+      "platformId": "wxid_a",
+      "accountName": "张三",
+      "groupNickname": "产品",
+      "avatar": "https://example.com/avatar.jpg"
+    }
+  ],
+  "messages": [
+    {
+      "sender": "wxid_a",
+      "accountName": "张三",
+      "timestamp": 1738713600,
+      "type": 0,
+      "content": "你好",
+      "platformMessageId": "123456"
+    }
+  ],
+  "sync": {
+    "hasMore": true,
+    "nextSince": 1738713600,
+    "nextOffset": 5000,
+    "watermark": 1738714000
+  }
+}
+```
+
+### sync 块
+
+| 字段         | 说明                             |
+| ------------ | -------------------------------- |
+| `hasMore`    | 是否还有更多数据                 |
+| `nextSince`  | 下次请求的 `since` 值            |
+| `nextOffset` | 下次请求的 `offset` 值           |
+| `watermark`  | 本次拉取的时间上界（秒级时间戳） |
+
+**ChatLab 对接方式**：在 ChatLab 设置中添加远程数据源，`baseUrl` 填 `http://127.0.0.1:5031/api/v1`，Token 填 WeFlow 中配置的 API Token。
+
+---
+
 ## 5. 获取联系人列表

 > 当使用 POST 时，请将参数放在 JSON Body 中（Content-Type: application/json）
@@ -300,10 +454,10 @@ GET /api/v1/contacts

 ### 参数

-| 参数 | 类型 | 必填 | 说明 |
-| --- | --- | --- | --- |
-| `keyword` | string | 否 | 匹配 `username`、`nickname`、`remark`、`displayName` |
-| `limit` | number | 否 | 默认 `100` |
+| 参数      | 类型   | 必填 | 说明                                                 |
+| --------- | ------ | ---- | ---------------------------------------------------- |
+| `keyword` | string | 否   | 匹配 `username`、`nickname`、`remark`、`displayName` |
+| `limit`   | number | 否   | 默认 `100`                                           |

 ### 响应字段

@@ -353,12 +507,12 @@ GET /api/v1/group-members

 ### 参数

-| 参数 | 类型 | 必填 | 说明 |
-| --- | --- | --- | --- |
-| `chatroomId` | string | 是 | 群 ID，兼容使用 `talker` 传入 |
-| `includeMessageCounts` | string | 否 | `1/true` 时附带成员发言数 |
-| `withCounts` | string | 否 | `includeMessageCounts` 的别名 |
-| `forceRefresh` | string | 否 | `1/true` 时跳过内存缓存强制刷新 |
+| 参数                   | 类型   | 必填 | 说明                            |
+| ---------------------- | ------ | ---- | ------------------------------- |
+| `chatroomId`           | string | 是   | 群 ID，兼容使用 `talker` 传入   |
+| `includeMessageCounts` | string | 否   | `1/true` 时附带成员发言数       |
+| `withCounts`           | string | 否   | `includeMessageCounts` 的别名   |
+| `forceRefresh`         | string | 否   | `1/true` 时跳过内存缓存强制刷新 |

 ### 响应字段

@@ -443,17 +597,17 @@ GET /api/v1/sns/timeline

 参数：

-| 参数 | 类型 | 必填 | 说明 |
-| --- | --- | --- | --- |
-| `limit` | number | 否 | 返回数量，默认 20，范围 `1~200` |
-| `offset` | number | 否 | 偏移量，默认 0 |
-| `usernames` | string | 否 | 发布者过滤，逗号分隔，如 `wxid_a,wxid_b` |
-| `keyword` | string | 否 | 关键词过滤（正文） |
-| `start` | string | 否 | 开始时间，支持 `YYYYMMDD` 或秒/毫秒时间戳 |
-| `end` | string | 否 | 结束时间，支持 `YYYYMMDD` 或秒/毫秒时间戳 |
-| `media` | number | 否 | 是否返回可直接访问的媒体地址，默认 `1` |
-| `replace` | number | 否 | `media=1` 时，是否用解析地址覆盖 `media.url/thumb`，默认 `1` |
-| `inline` | number | 否 | `media=1` 时，是否内联返回 `data:` URL，默认 `0` |
+| 参数        | 类型   | 必填 | 说明                                                         |
+| ----------- | ------ | ---- | ------------------------------------------------------------ |
+| `limit`     | number | 否   | 返回数量，默认 20，范围 `1~200`                              |
+| `offset`    | number | 否   | 偏移量，默认 0                                               |
+| `usernames` | string | 否   | 发布者过滤，逗号分隔，如 `wxid_a,wxid_b`                     |
+| `keyword`   | string | 否   | 关键词过滤（正文）                                           |
+| `start`     | string | 否   | 开始时间，支持 `YYYYMMDD` 或秒/毫秒时间戳                    |
+| `end`       | string | 否   | 结束时间，支持 `YYYYMMDD` 或秒/毫秒时间戳                    |
+| `media`     | number | 否   | 是否返回可直接访问的媒体地址，默认 `1`                       |
+| `replace`   | number | 否   | `media=1` 时，是否用解析地址覆盖 `media.url/thumb`，默认 `1` |
+| `inline`    | number | 否   | `media=1` 时，是否内联返回 `data:` URL，默认 `0`             |

 示例：

@@ -490,9 +644,9 @@ GET /api/v1/sns/export/stats

 参数：

-| 参数 | 类型 | 必填 | 说明 |
-| --- | --- | --- | --- |
-| `fast` | number | 否 | `1` 使用快速统计（优先缓存） |
+| 参数   | 类型   | 必填 | 说明                         |
+| ------ | ------ | ---- | ---------------------------- |
+| `fast` | number | 否   | `1` 使用快速统计（优先缓存） |

 ### 7.4 朋友圈媒体代理

@@ -502,10 +656,10 @@ GET /api/v1/sns/media/proxy

 参数：

-| 参数 | 类型 | 必填 | 说明 |
-| --- | --- | --- | --- |
-| `url` | string | 是 | 媒体原始 URL |
-| `key` | string/number | 否 | 解密 key（部分资源需要） |
+| 参数  | 类型          | 必填 | 说明                     |
+| ----- | ------------- | ---- | ------------------------ |
+| `url` | string        | 是   | 媒体原始 URL             |
+| `key` | string/number | 否   | 解密 key（部分资源需要） |

 ### 7.5 导出朋友圈

@@ -572,15 +726,15 @@ curl "http://127.0.0.1:5031/api/v1/media/xxx@chatroom/emojis/emoji_300.gif"

 ### 支持的 Content-Type

-| 扩展名 | Content-Type |
-| --- | --- |
-| `.png` | `image/png` |
+| 扩展名           | Content-Type |
+| ---------------- | ------------ |
+| `.png`           | `image/png`  |
 | `.jpg` / `.jpeg` | `image/jpeg` |
-| `.gif` | `image/gif` |
-| `.webp` | `image/webp` |
-| `.wav` | `audio/wav` |
-| `.mp3` | `audio/mpeg` |
-| `.mp4` | `video/mp4` |
+| `.gif`           | `image/gif`  |
+| `.webp`          | `image/webp` |
+| `.wav`           | `audio/wav`  |
+| `.mp3`           | `audio/mpeg` |
+| `.mp4`           | `video/mp4`  |

 常见错误响应：

@@ -626,8 +780,8 @@ headers = {"Authorization": "Bearer YOUR_TOKEN", "Content-Type": "application/js

 # POST 方式获取消息
 messages = requests.post(
-    f"{BASE_URL}/api/v1/messages", 
-    json={"talker": "xxx@chatroom", "limit": 50}, 
+    f"{BASE_URL}/api/v1/messages",
+    json={"talker": "xxx@chatroom", "limit": 50},
    headers=headers
 ).json()

--- a/docs/MAC-KEY-FAQ.md
+++ b/docs/MAC-KEY-FAQ.md
@@ -0,0 +1,54 @@
+# macOS 微信密钥自动获取失败排障指南
+
+如果你在 macOS 系统下，遇到了 WeFlow 自动获取微信数据库密钥失败的问题，这篇指南或许可以帮到你。
+
+### 请立刻停止连续重试
+
+当你看到下面这些报错时，请务必暂停操作，不要再去反复点击获取：
+
+- SCAN_FAILED，通常伴随 No suitable module found 或 Sink pattern not found
+- HOOK_FAILED 或 Native Hook Failed
+- patch_breakpoint_failed
+- thread_get_state_failed
+
+现在的 macOS 系统和微信防护机制非常敏锐。连续的重试动作不仅无法解决问题，反而容易被判定为异常行为，进而触发微信的安全模式或系统级的内存保护。
+
+### 可能的尝试流程
+
+根据大量社区用户的反馈，如果你已经遇到了获取失败的情况，按照下面的步骤顺序操作，通常都能顺利解决问题：
+
+1. **降级微信版本**。找一个经过大家验证、兼容性更好的老版本，目前最推荐先退回到 4.1.7.57 或者 4.1.8.100。
+2. **彻底退出微信**。请使用快捷键 Command + Q 或在活动监视器中结束进程，而不仅仅是关闭窗口。
+3. **重启你的 Mac**。这一步极其关键，必须是真正的重新启动。注销或睡眠唤醒无法清除系统底层的拦截状态。
+4. **重新打开微信**。随便点击几下保持它在最前台，并且确保它是未登录的状态。
+5. **回到 WeFlow**。仅仅尝试一次“自动获取密钥”。
+6. **输入密码并登录**。先在弹窗中输入你的系统密码后，确认页面弹出允许登录了再登录微信
+7. **恢复日常使用**。只要成功拿到了密钥，你就可以放心地把微信更新回你平时爱用的最新版本。
+
+### 常见报错与应对方法
+
+为了方便排查，这里列出了几类最常见的报错及其背后的原因和对策：
+
+**SCAN_FAILED: No suitable module found**
+这意味着微信的内存布局并不标准，或者目标模块没有被命中。你可以先确保微信完整启动并保持在前台。如果还是不行，请直接执行上面提到的“降级、重启电脑、获取、再升级”的完整流程。
+
+**SCAN_FAILED: Sink pattern not found**
+这说明 WeFlow 还没有适配你当前正在使用的微信版本特征。最快的解决办法是直接降级到微信 4.1.7 或 4.1.8.100 版本再试。
+
+**patch_breakpoint_failed 或 thread_get_state_failed**
+这类错误大多是因为调试断点注入或线程状态读取被 macOS 系统的安全机制拦截了。此时继续尝试毫无意义，彻底退出微信并重启电脑再试。
+
+**task_for_pid:5**
+这是进程附加权限被系统拒绝的提示。请确保你使用的是打包好的 WeFlow.app，同时检查系统的签名与调试权限是否已经正确配置。
+
+### 关于推荐版本的补充说明
+
+截至 2026 年 4 月，综合社区的反馈来看，微信 4.1.7 和 4.1.8.100 版本在密钥获取流程中的表现最为稳定，成功率最高。
+
+这并不意味着其他新版本绝对无法获取，只是作为当前的排障参考。未来 WeFlow 也会在后续的更新中逐步适配新版微信的特征，建议大家多留意项目的 Release 动态。
+
+### 最后的几点建议
+
+首次失败后，首要任务是排查原因，切忌盲目地连续点击自动获取。如果你在看到这篇文档前已经失败了好几次，最好的做法是直接清零重来：彻底退出微信，重启电脑，然后再进行下一次尝试。
+
+最后，如果尝试了上述所有方法依然无法解决，请记得保存完整的报错文本，特别是 SCAN_FAILED 或 HOOK_FAILED 后面跟着的英文细节。把这些信息提交到[issue](https://github.com/hicccc77/WeFlow/issues/745)，会大大加快定位和修复兼容性问题的速度。
--- a/electron/exportWorker.ts
+++ b/electron/exportWorker.ts
@@ -1,19 +1,133 @@
 import { parentPort, workerData } from 'worker_threads'
-import type { ExportOptions } from './services/exportService'

 interface ExportWorkerConfig {
-  sessionIds: string[]
-  outputDir: string
-  options: ExportOptions
+  mode?: 'sessions' | 'single' | 'contacts'
+  sessionIds?: string[]
+  sessionId?: string
+  outputDir?: string
+  outputPath?: string
+  options?: any
+  taskId?: string
  dbPath?: string
  decryptKey?: string
  myWxid?: string
+  imageXorKey?: unknown
+  imageAesKey?: string
  resourcesPath?: string
  userDataPath?: string
  logEnabled?: boolean
+  isPackaged?: boolean
 }

 const config = workerData as ExportWorkerConfig
+const controlState = {
+  pauseRequested: false,
+  stopRequested: false
+}
+
+const CREATED_PATH_FLUSH_INTERVAL_MS = 200
+const CREATED_PATH_BATCH_LIMIT = 256
+const PROGRESS_POST_INTERVAL_MS = 180
+let queuedCreatedFiles: string[] = []
+let queuedCreatedDirs: string[] = []
+let createdPathFlushTimer: ReturnType<typeof setTimeout> | null = null
+let pendingProgress: any = null
+let progressPostTimer: ReturnType<typeof setTimeout> | null = null
+let lastProgressPostedAt = 0
+
+function flushCreatedPaths() {
+  if (createdPathFlushTimer) {
+    clearTimeout(createdPathFlushTimer)
+    createdPathFlushTimer = null
+  }
+  const filePaths = queuedCreatedFiles
+  const dirPaths = queuedCreatedDirs
+  queuedCreatedFiles = []
+  queuedCreatedDirs = []
+  if (!parentPort) return
+  if (filePaths.length > 0) {
+    parentPort.postMessage({ type: 'export:createdFiles', filePaths })
+  }
+  if (dirPaths.length > 0) {
+    parentPort.postMessage({ type: 'export:createdDirs', dirPaths })
+  }
+}
+
+function scheduleCreatedPathFlush() {
+  if (createdPathFlushTimer) return
+  createdPathFlushTimer = setTimeout(flushCreatedPaths, CREATED_PATH_FLUSH_INTERVAL_MS)
+}
+
+function queueCreatedFile(filePath: string) {
+  const normalized = String(filePath || '').trim()
+  if (!normalized) return
+  queuedCreatedFiles.push(normalized)
+  if (queuedCreatedFiles.length + queuedCreatedDirs.length >= CREATED_PATH_BATCH_LIMIT) {
+    flushCreatedPaths()
+  } else {
+    scheduleCreatedPathFlush()
+  }
+}
+
+function queueCreatedDir(dirPath: string) {
+  const normalized = String(dirPath || '').trim()
+  if (!normalized) return
+  queuedCreatedDirs.push(normalized)
+  if (queuedCreatedFiles.length + queuedCreatedDirs.length >= CREATED_PATH_BATCH_LIMIT) {
+    flushCreatedPaths()
+  } else {
+    scheduleCreatedPathFlush()
+  }
+}
+
+function flushProgress() {
+  if (!pendingProgress) return
+  if (progressPostTimer) {
+    clearTimeout(progressPostTimer)
+    progressPostTimer = null
+  }
+  parentPort?.postMessage({
+    type: 'export:progress',
+    data: pendingProgress
+  })
+  pendingProgress = null
+  lastProgressPostedAt = Date.now()
+}
+
+function queueProgress(progress: any) {
+  pendingProgress = progress
+  if (progress?.phase === 'complete') {
+    flushProgress()
+    return
+  }
+
+  const now = Date.now()
+  const elapsed = now - lastProgressPostedAt
+  if (elapsed >= PROGRESS_POST_INTERVAL_MS) {
+    flushProgress()
+    return
+  }
+
+  if (progressPostTimer) return
+  progressPostTimer = setTimeout(flushProgress, PROGRESS_POST_INTERVAL_MS - elapsed)
+}
+
+parentPort?.on('message', (message: any) => {
+  if (!message || typeof message.type !== 'string') return
+  if (message.type === 'export:pause') {
+    controlState.pauseRequested = true
+    return
+  }
+  if (message.type === 'export:resume') {
+    controlState.pauseRequested = false
+    return
+  }
+  if (message.type === 'export:cancel') {
+    controlState.stopRequested = true
+    controlState.pauseRequested = false
+  }
+})
+
 process.env.WEFLOW_WORKER = '1'
 if (config.resourcesPath) {
  process.env.WCDB_RESOURCES_PATH = config.resourcesPath
@@ -35,20 +149,63 @@ async function run() {
  exportService.setRuntimeConfig({
    dbPath: config.dbPath,
    decryptKey: config.decryptKey,
-    myWxid: config.myWxid
+    myWxid: config.myWxid,
+    imageXorKey: config.imageXorKey,
+    imageAesKey: config.imageAesKey,
+    resourcesPath: config.resourcesPath,
+    appPath: config.resourcesPath ? require('path').dirname(config.resourcesPath) : __dirname,
+    isPackaged: config.isPackaged
  })

-  const result = await exportService.exportSessions(
-    Array.isArray(config.sessionIds) ? config.sessionIds : [],
-    String(config.outputDir || ''),
-    config.options || { format: 'json' },
-    (progress) => {
-      parentPort?.postMessage({
-        type: 'export:progress',
-        data: progress
-      })
-    }
-  )
+  const onProgress = (progress: any) => queueProgress(progress)
+
+  const taskControl = config.taskId
+    ? {
+        shouldPause: () => controlState.pauseRequested,
+        shouldStop: () => controlState.stopRequested,
+        recordCreatedFile: queueCreatedFile,
+        recordCreatedDir: queueCreatedDir
+      }
+    : undefined
+
+  let result: any
+  if (config.mode === 'contacts') {
+    const [{ contactExportService }, { chatService }] = await Promise.all([
+      import('./services/contactExportService'),
+      import('./services/chatService')
+    ])
+    chatService.setRuntimeConfig({
+      dbPath: config.dbPath,
+      decryptKey: config.decryptKey,
+      myWxid: config.myWxid,
+      resourcesPath: config.resourcesPath,
+      appPath: config.resourcesPath ? require('path').dirname(config.resourcesPath) : __dirname,
+      isPackaged: config.isPackaged
+    })
+    result = await contactExportService.exportContacts(
+      String(config.outputDir || ''),
+      config.options || {}
+    )
+  } else if (config.mode === 'single') {
+    result = await exportService.exportSessionToChatLab(
+      String(config.sessionId || '').trim(),
+      String(config.outputPath || '').trim(),
+      config.options || { format: 'chatlab' },
+      onProgress,
+      taskControl
+    )
+  } else {
+    result = await exportService.exportSessions(
+      Array.isArray(config.sessionIds) ? config.sessionIds : [],
+      String(config.outputDir || ''),
+      config.options || { format: 'json' },
+      onProgress,
+      taskControl
+    )
+  }
+
+  flushProgress()
+  flushCreatedPaths()

  parentPort?.postMessage({
    type: 'export:result',
@@ -57,6 +214,8 @@ async function run() {
 }

 run().catch((error) => {
+  flushProgress()
+  flushCreatedPaths()
  parentPort?.postMessage({
    type: 'export:error',
    error: String(error)
--- a/electron/main.ts
+++ b/electron/main.ts
--- a/electron/preload.ts
+++ b/electron/preload.ts
@@ -13,7 +13,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
  notification: {
    show: (data: any) => ipcRenderer.invoke('notification:show', data),
    close: () => ipcRenderer.invoke('notification:close'),
-    click: (sessionId: string) => ipcRenderer.send('notification-clicked', sessionId),
+    click: (payload: any) => ipcRenderer.send('notification-clicked', payload),
    ready: () => ipcRenderer.send('notification:ready'),
    resize: (width: number, height: number) => ipcRenderer.send('notification:resize', { width, height }),
    onShow: (callback: (event: any, data: any) => void) => {
@@ -24,6 +24,11 @@ contextBridge.exposeInMainWorld('electronAPI', {
      const listener = (_: any, sessionId: string) => callback(sessionId)
      ipcRenderer.on('navigate-to-session', listener)
      return () => ipcRenderer.removeListener('navigate-to-session', listener)
+    },
+    onNavigateToRoute: (callback: (route: string) => void) => {
+      const listener = (_: any, route: string) => callback(route)
+      ipcRenderer.on('navigate-to-route', listener)
+      return () => ipcRenderer.removeListener('navigate-to-route', listener)
    }
  },

@@ -154,6 +159,17 @@ contextBridge.exposeInMainWorld('electronAPI', {

  },

+  backup: {
+    create: (payload: { outputPath: string; options?: { includeImages?: boolean; includeVideos?: boolean; includeFiles?: boolean } }) => ipcRenderer.invoke('backup:create', payload),
+    inspect: (payload: { archivePath: string }) => ipcRenderer.invoke('backup:inspect', payload),
+    restore: (payload: { archivePath: string }) => ipcRenderer.invoke('backup:restore', payload),
+    onProgress: (callback: (progress: any) => void) => {
+      const listener = (_: unknown, progress: any) => callback(progress)
+      ipcRenderer.on('backup:progress', listener)
+      return () => ipcRenderer.removeListener('backup:progress', listener)
+    }
+  },
+
  // 密钥获取
  key: {
    autoGetDbKey: () => ipcRenderer.invoke('key:autoGetDbKey'),
@@ -174,10 +190,12 @@ contextBridge.exposeInMainWorld('electronAPI', {
  chat: {
    connect: () => ipcRenderer.invoke('chat:connect'),
    getSessions: () => ipcRenderer.invoke('chat:getSessions'),
+    markAllSessionsRead: () => ipcRenderer.invoke('chat:markAllSessionsRead'),
+    getAntiRevokeSessions: () => ipcRenderer.invoke('chat:getAntiRevokeSessions'),
    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),
+    getSessionMessageCounts: (sessionIds: string[], options?: { preferHintCache?: boolean; bypassSessionCache?: boolean }) => ipcRenderer.invoke('chat:getSessionMessageCounts', sessionIds, options),
    enrichSessionsContactInfo: (
      usernames: string[],
      options?: { skipDisplayName?: boolean; onlyMissingAvatar?: boolean }
@@ -219,6 +237,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
        allowStaleCache?: boolean
        preferAccurateSpecialTypes?: boolean
        cacheOnly?: boolean
+        beginTimestamp?: number
+        endTimestamp?: number
      }
    ) => ipcRenderer.invoke('chat:getExportSessionStats', sessionIds, options),
    getGroupMyMessageCountHint: (chatroomId: string) =>
@@ -351,7 +371,10 @@ contextBridge.exposeInMainWorld('electronAPI', {
      }) => callback(payload)
      ipcRenderer.on('image:decryptProgress', listener)
      return () => ipcRenderer.removeListener('image:decryptProgress', listener)
-    }
+    },
+    startAutoDownload: (whitelist: string[] | string) => ipcRenderer.invoke('image:startAutoDownload', whitelist),
+    stopAutoDownload: () => ipcRenderer.invoke('image:stopAutoDownload'),
+    getAutoDownloadStatus: () => ipcRenderer.invoke('image:getAutoDownloadStatus')
  },

  // 视频
@@ -360,6 +383,11 @@ contextBridge.exposeInMainWorld('electronAPI', {
    parseVideoMd5: (content: string) => ipcRenderer.invoke('video:parseVideoMd5', content)
  },

+  process: {
+    platform: process.platform,
+    arch: process.arch
+  },
+
  // 数据分析
  analytics: {
    getOverallStatistics: (force?: boolean) => ipcRenderer.invoke('analytics:getOverallStatistics', force),
@@ -412,6 +440,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
    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),
+    captureCurrentWindow: () => ipcRenderer.invoke('annualReport:captureCurrentWindow'),
    onAvailableYearsProgress: (callback: (payload: {
      taskId: string
      years?: number[]
@@ -448,8 +477,14 @@ contextBridge.exposeInMainWorld('electronAPI', {
  export: {
    getExportStats: (sessionIds: string[], options: any) =>
      ipcRenderer.invoke('export:getExportStats', sessionIds, options),
-    exportSessions: (sessionIds: string[], outputDir: string, options: any) =>
-      ipcRenderer.invoke('export:exportSessions', sessionIds, outputDir, options),
+    exportSessions: (sessionIds: string[], outputDir: string, options: any, controlOptions?: { taskId?: string }) =>
+      ipcRenderer.invoke('export:exportSessions', sessionIds, outputDir, options, controlOptions),
+    pauseTask: (taskId: string) =>
+      ipcRenderer.invoke('export:pauseTask', taskId),
+    resumeTask: (taskId: string) =>
+      ipcRenderer.invoke('export:resumeTask', taskId),
+    cancelTask: (taskId: string) =>
+      ipcRenderer.invoke('export:cancelTask', taskId),
    exportSession: (sessionId: string, outputPath: string, options: any) =>
      ipcRenderer.invoke('export:exportSession', sessionId, outputPath, options),
    exportContacts: (outputDir: string, options: any) =>
@@ -543,7 +578,16 @@ contextBridge.exposeInMainWorld('electronAPI', {
  insight: {
    testConnection: () => ipcRenderer.invoke('insight:testConnection'),
    getTodayStats: () => ipcRenderer.invoke('insight:getTodayStats'),
+    listRecords: (filters?: any) => ipcRenderer.invoke('insight:listRecords', filters),
+    getRecord: (id: string) => ipcRenderer.invoke('insight:getRecord', id),
+    markRecordRead: (id: string) => ipcRenderer.invoke('insight:markRecordRead', id),
+    clearRecords: (filters?: any) => ipcRenderer.invoke('insight:clearRecords', filters),
    triggerTest: () => ipcRenderer.invoke('insight:triggerTest'),
+    triggerSessionInsight: (payload: {
+      sessionId: string
+      displayName?: string
+      avatarUrl?: string
+    }) => ipcRenderer.invoke('insight:triggerSessionInsight', payload),
    generateFootprintInsight: (payload: {
      rangeLabel: string
      summary: {
@@ -556,7 +600,37 @@ contextBridge.exposeInMainWorld('electronAPI', {
      }
      privateSegments?: Array<{ displayName?: string; session_id?: string; incoming_count?: number; outgoing_count?: number; message_count?: number; replied?: boolean }>
      mentionGroups?: Array<{ displayName?: string; session_id?: string; count?: number }>
-    }) => ipcRenderer.invoke('insight:generateFootprintInsight', payload)
+    }) => ipcRenderer.invoke('insight:generateFootprintInsight', payload),
+    generateMessageInsight: (payload: {
+      sessionId: string
+      displayName?: string
+      avatarUrl?: string
+      targetLocalId?: number
+      targetCreateTime?: number
+      targetMessageKey?: string
+      targetText: string
+      targetSenderName?: string
+      contextCount?: number
+      forceRefresh?: boolean
+    }) => ipcRenderer.invoke('insight:generateMessageInsight', payload)
+  },
+
+  groupSummary: {
+    listRecords: (filters?: any) => ipcRenderer.invoke('groupSummary:listRecords', filters),
+    getRecord: (id: string) => ipcRenderer.invoke('groupSummary:getRecord', id),
+    triggerManual: (payload: {
+      sessionId: string
+      displayName?: string
+      avatarUrl?: string
+      startTime: number
+      endTime: number
+    }) => ipcRenderer.invoke('groupSummary:triggerManual', payload),
+    triggerDay: (payload: {
+      sessionId: string
+      displayName?: string
+      avatarUrl?: string
+      date: string
+    }) => ipcRenderer.invoke('groupSummary:triggerDay', payload)
  },

  social: {
@@ -564,4 +638,3 @@ contextBridge.exposeInMainWorld('electronAPI', {
    validateWeiboUid: (uid: string) => ipcRenderer.invoke('social:validateWeiboUid', uid)
  }
 })
-
--- a/electron/services/accountDirResolver.ts
+++ b/electron/services/accountDirResolver.ts
@@ -0,0 +1,73 @@
+import { existsSync, readdirSync, statSync } from 'fs'
+import { join } from 'path'
+
+const accountDirCache = new Map<string, string>()
+
+const cleanAccountDirName = (dirName: string): string => {
+  const trimmed = dirName.trim()
+  if (!trimmed) return trimmed
+
+  if (trimmed.toLowerCase().startsWith('wxid_')) {
+    const match = trimmed.match(/^(wxid_[^_]+)/i)
+    if (match) return match[1]
+    return trimmed
+  }
+
+  const suffixMatch = trimmed.match(/^(.+)_([a-zA-Z0-9]{4})$/)
+  if (suffixMatch) return suffixMatch[1]
+
+  return trimmed
+}
+
+const isDirectory = (path: string): boolean => {
+  try {
+    return statSync(path).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+export const resolveAccountDir = (dbPath?: string, wxid?: string): string | null => {
+  if (!dbPath || !wxid) return null
+
+  const cleanedWxid = cleanAccountDirName(wxid)
+  const normalized = dbPath.replace(/[\\/]+$/, '')
+  const cacheKey = `${normalized}|${cleanedWxid.toLowerCase()}`
+
+  const cached = accountDirCache.get(cacheKey)
+  if (cached && existsSync(cached)) return cached
+  if (cached && !existsSync(cached)) {
+    accountDirCache.delete(cacheKey)
+  }
+
+  const lowerWxid = cleanedWxid.toLowerCase()
+  if (!lowerWxid.startsWith('wxid_')) {
+    const direct = join(normalized, cleanedWxid)
+    if (existsSync(direct) && isDirectory(direct)) {
+      accountDirCache.set(cacheKey, direct)
+      return direct
+    }
+  }
+
+  try {
+    const entries = readdirSync(normalized)
+    for (const entry of entries) {
+      const entryPath = join(normalized, entry)
+      if (!isDirectory(entryPath)) continue
+
+      const lowerEntry = entry.toLowerCase()
+      const isExactMatch = lowerEntry === lowerWxid
+      const isSuffixMatch = lowerEntry.startsWith(`${lowerWxid}_`)
+      const shouldMatch = lowerWxid.startsWith('wxid_')
+        ? isSuffixMatch
+        : (isExactMatch || isSuffixMatch)
+
+      if (shouldMatch) {
+        accountDirCache.set(cacheKey, entryPath)
+        return entryPath
+      }
+    }
+  } catch { }
+
+  return null
+}
--- a/electron/services/analyticsService.ts
+++ b/electron/services/analyticsService.ts
@@ -103,8 +103,10 @@ class AnalyticsService {
    if (username === 'filehelper') return false
    if (username.startsWith('gh_')) return false

+    if (username.toLowerCase() === 'weixin') return false
+
    const excludeList = [
-      'weixin', 'qqmail', 'fmessage', 'medianote', 'floatbottle',
+      'qqmail', 'fmessage', 'medianote', 'floatbottle',
      'newsapp', 'brandsessionholder', 'brandservicesessionholder',
      'notifymessage', 'opencustomerservicemsg', 'notification_messages',
      'userexperience_alarm', 'helper_folders', 'placeholder_foldgroup',
@@ -125,13 +127,19 @@ class AnalyticsService {
    const wxid = this.configService.get('myWxid')
    const dbPath = this.configService.get('dbPath')
    const decryptKey = this.configService.get('decryptKey')
+
    if (!wxid) return { success: false, error: '未配置微信ID' }
    if (!dbPath) return { success: false, error: '未配置数据库路径' }
    if (!decryptKey) return { success: false, error: '未配置解密密钥' }

-    const cleanedWxid = this.cleanAccountDirName(wxid)
-    const ok = await wcdbService.open(dbPath, decryptKey, cleanedWxid)
+    const accountDir = this.configService.getAccountDir(dbPath, wxid)
+    if (!accountDir) return { success: false, error: '未找到账号目录' }
+
+    const ok = await wcdbService.open(accountDir, decryptKey)
    if (!ok) return { success: false, error: 'WCDB 打开失败' }
+
+    const cleanedWxid = this.cleanAccountDirName(wxid)
+
    return { success: true, cleanedWxid }
  }

@@ -231,8 +239,7 @@ class AnalyticsService {
  }

  private async computeAggregateByCursor(sessionIds: string[], beginTimestamp = 0, endTimestamp = 0): Promise<any> {
-    const wxid = this.configService.get('myWxid')
-    const cleanedWxid = wxid ? this.cleanAccountDirName(wxid) : ''
+    const cleanedWxid = this.configService.getMyWxidCleaned() || ''

    const aggregate = {
      total: 0,
@@ -269,8 +276,7 @@ class AnalyticsService {
            const myWxidLower = cleanedWxid.toLowerCase()
            isSend = (
              senderLower === myWxidLower ||
-              // 兼容非 wxid 开头的账号（如果文件夹名带后缀，如 custom_backup，而 sender 是 custom）
-              (myWxidLower.startsWith(senderLower + '_'))
+              senderLower.startsWith(myWxidLower + '_')
            )
          }
        }
--- a/electron/services/annualReportService.ts
+++ b/electron/services/annualReportService.ts
@@ -1,5 +1,6 @@
 import { parentPort } from 'worker_threads'
 import { wcdbService } from './wcdbService'
+import { resolveAccountDir } from './accountDirResolver'

 export interface TopContact {
  username: string
@@ -59,6 +60,8 @@ export interface AnnualReportData {
    initiatedChats: number
    receivedChats: number
    initiativeRate: number
+    topInitiatedFriend?: string
+    topInitiatedCount?: number
  } | null
  responseSpeed: {
    avgResponseTime: number
@@ -156,9 +159,13 @@ class AnnualReportService {
    if (!dbPath) return { success: false, error: '未配置数据库路径' }
    if (!decryptKey) return { success: false, error: '未配置解密密钥' }

-    const cleanedWxid = this.cleanAccountDirName(wxid)
-    const ok = await wcdbService.open(dbPath, decryptKey, cleanedWxid)
+    const accountDir = resolveAccountDir(dbPath, wxid)
+    if (!accountDir) return { success: false, error: '未找到账号目录' }
+
+    const ok = await wcdbService.open(accountDir, decryptKey)
    if (!ok) return { success: false, error: 'WCDB 打开失败' }
+
+    const cleanedWxid = this.cleanAccountDirName(wxid)
    return { success: true, cleanedWxid, rawWxid: wxid }
  }

@@ -168,7 +175,7 @@ class AnnualReportService {
    const rows = sessionResult.sessions as Record<string, any>[]

    const excludeList = [
-      'weixin', 'qqmail', 'fmessage', 'medianote', 'floatbottle',
+      'qqmail', 'fmessage', 'medianote', 'floatbottle',
      'newsapp', 'brandsessionholder', 'brandservicesessionholder',
      'notifymessage', 'opencustomerservicemsg', 'notification_messages',
      'userexperience_alarm', 'helper_folders', 'placeholder_foldgroup',
@@ -183,6 +190,7 @@ class AnnualReportService {
        if (username === 'filehelper') return false
        if (username.startsWith('gh_')) return false
        if (username.toLowerCase() === cleanedWxid.toLowerCase()) return false
+        if (username.toLowerCase() === 'weixin') return false

        for (const prefix of excludeList) {
          if (username.startsWith(prefix) || username === prefix) return false
@@ -1190,7 +1198,9 @@ class AnnualReportService {
        topLiked: { username: string; displayName: string; avatarUrl?: string; count: number }[]
      } | undefined

-      const snsStats = await wcdbService.getSnsAnnualStats(actualStartTime, actualEndTime)
+      const snsBeginTime = isAllTime ? 0 : actualStartTime
+      const snsEndTime = isAllTime ? Math.floor(Date.now() / 1000) : actualEndTime
+      const snsStats = await wcdbService.getSnsAnnualStats(snsBeginTime, snsEndTime)

      if (snsStats.success && snsStats.data) {
        const d = snsStats.data
@@ -1217,6 +1227,20 @@ class AnnualReportService {
        }
      }

+      // ALL YEARS 兼容：部分底层实现 begin/end 为 0 时会返回 0，兜底使用导出统计总数。
+      if (isAllTime && (!snsStatsResult || Number(snsStatsResult.totalPosts || 0) <= 0)) {
+        const snsExportStats = await wcdbService.getSnsExportStats(cleanedWxid || rawWxid)
+        if (snsExportStats.success && snsExportStats.data) {
+          const fallbackTotalPosts = Math.max(0, Number(snsExportStats.data.totalPosts || 0))
+          snsStatsResult = {
+            totalPosts: fallbackTotalPosts,
+            typeCounts: snsStatsResult?.typeCounts,
+            topLikers: snsStatsResult?.topLikers || [],
+            topLiked: snsStatsResult?.topLiked || []
+          }
+        }
+      }
+
      this.reportProgress('整理联系人信息...', 85, onProgress)

      const contactIds = Array.from(contactStats.keys())
@@ -1346,16 +1370,27 @@ class AnnualReportService {
      let socialInitiative: AnnualReportData['socialInitiative'] = null
      let totalInitiated = 0
      let totalReceived = 0
-      for (const stats of conversationStarts.values()) {
+      let topInitiatedSessionId = ''
+      let topInitiatedCount = 0
+      for (const [sessionId, stats] of conversationStarts.entries()) {
        totalInitiated += stats.initiated
        totalReceived += stats.received
+        if (stats.initiated > topInitiatedCount) {
+          topInitiatedCount = stats.initiated
+          topInitiatedSessionId = sessionId
+        }
      }
      const totalConversations = totalInitiated + totalReceived
      if (totalConversations > 0) {
+        const topInitiatedInfo = topInitiatedSessionId ? contactInfoMap.get(topInitiatedSessionId) : null
        socialInitiative = {
          initiatedChats: totalInitiated,
          receivedChats: totalReceived,
-          initiativeRate: Math.round((totalInitiated / totalConversations) * 1000) / 10
+          initiativeRate: Math.round((totalInitiated / totalConversations) * 1000) / 10,
+          topInitiatedFriend: topInitiatedCount > 0
+            ? (topInitiatedInfo?.displayName || topInitiatedSessionId)
+            : undefined,
+          topInitiatedCount: topInitiatedCount > 0 ? topInitiatedCount : undefined
        }
      }

--- a/electron/services/backupService.ts
+++ b/electron/services/backupService.ts
--- a/electron/services/bizService.ts
+++ b/electron/services/bizService.ts
@@ -100,7 +100,7 @@ export class BizService {
      const contactInfoMap = enrichment.success && enrichment.contacts ? enrichment.contacts : {}

      const root = this.configService.get('dbPath')
-      const myWxid = this.configService.get('myWxid')
+      const myWxid = this.configService.getMyWxidCleaned()
      const accountWxid = account || myWxid
      if (!root || !accountWxid) return []

--- a/electron/services/chatService.ts
+++ b/electron/services/chatService.ts
--- a/electron/services/config.ts
+++ b/electron/services/config.ts
@@ -1,9 +1,23 @@
 import { join } from 'path'
-import { app, safeStorage } from 'electron'
+import { existsSync, readdirSync, statSync } from 'fs'
 import crypto from 'crypto'
 import Store from 'electron-store'
 import { expandHomePath } from '../utils/pathUtils'

+// 条件导入 electron（Worker 环境中不可用）
+let app: any = null
+let safeStorage: any = null
+const isWorkerThread = process.env.WEFLOW_WORKER === '1'
+if (!isWorkerThread) {
+  try {
+    const electron = require('electron')
+    app = electron.app
+    safeStorage = electron.safeStorage
+  } catch {
+    // Worker 环境中 electron 不可用
+  }
+}
+
 // 加密前缀标记
 const SAFE_PREFIX = 'safe:'  // safeStorage 加密（普通模式）
 const isSafeStorageAvailable = (): boolean => {
@@ -36,6 +50,7 @@ interface ConfigSchema {
  language: string
  logEnabled: boolean
  launchAtStartup?: boolean
+  silentStartup?: boolean
  llmModelPath: string
  whisperModelName: string
  whisperModelDir: string
@@ -57,6 +72,7 @@ interface ConfigSchema {

  // 通知
  notificationEnabled: boolean
+  aiInsightNotificationEnabled: boolean
  notificationPosition: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center'
  notificationFilterMode: 'all' | 'whitelist' | 'blacklist'
  notificationFilterList: string[]
@@ -84,7 +100,15 @@ interface ConfigSchema {
  aiInsightApiModel: string
  aiInsightSilenceDays: number
  aiInsightAllowContext: boolean
+  aiInsightAllowMomentsContext: boolean
+  aiInsightMomentsContextCount: number
+  aiInsightMomentsBindings: Record<string, { enabled: boolean; updatedAt: number }>
  aiInsightAllowSocialContext: boolean
+  aiInsightSocialContextCount: number
+  aiInsightWeiboCookie: string
+  aiInsightWeiboBindings: Record<string, { uid: string; screenName?: string; updatedAt: number }>
+  aiInsightFilterMode: 'whitelist' | 'blacklist'
+  aiInsightFilterList: string[]
  aiInsightWhitelistEnabled: boolean
  aiInsightWhitelist: string[]
  /** 活跃分析冷却时间（分钟），0 表示无冷却 */
@@ -105,8 +129,18 @@ interface ConfigSchema {
  // AI 足迹
  aiFootprintEnabled: boolean
  aiFootprintSystemPrompt: string
+  aiGroupSummaryEnabled: boolean
+  aiGroupSummaryIntervalHours: number
+  aiGroupSummarySystemPrompt: string
+  aiGroupSummaryFilterMode: 'whitelist' | 'blacklist'
+  aiGroupSummaryFilterList: string[]
+  aiMessageInsightEnabled: boolean
+  aiMessageInsightContextCount: number
+  aiMessageInsightSystemPrompt: string
  /** 是否将 AI 见解调试日志输出到桌面 */
  aiInsightDebugLogEnabled: boolean
+  autoDownloadHighRes: boolean
+  autoDownloadWhitelist: string[]
 }

 // 需要 safeStorage 加密的字段（普通模式）
@@ -134,6 +168,9 @@ export class ConfigService {
  private unlockedKeys: Map<string, any> = new Map()
  private unlockPassword: string | null = null

+  // 账号目录缓存
+  private accountDirCache: Map<string, string> = new Map()
+
  static getInstance(): ConfigService {
    if (!ConfigService.instance) {
      ConfigService.instance = new ConfigService()
@@ -161,6 +198,7 @@ export class ConfigService {
      themeId: 'cloud-dancer',
      language: 'zh-CN',
      logEnabled: false,
+      silentStartup: false,
      llmModelPath: '',
      whisperModelName: 'base',
      whisperModelDir: '',
@@ -176,6 +214,7 @@ export class ConfigService {
      ignoredUpdateVersion: '',
      updateChannel: 'auto',
      notificationEnabled: true,
+      aiInsightNotificationEnabled: true,
      notificationPosition: 'top-right',
      notificationFilterMode: 'all',
      notificationFilterList: [],
@@ -194,14 +233,19 @@ export class ConfigService {
      aiModelApiBaseUrl: '',
      aiModelApiKey: '',
      aiModelApiModel: 'gpt-4o-mini',
-      aiModelApiMaxTokens: 200,
+      aiModelApiMaxTokens: 1024,
      aiInsightEnabled: false,
      aiInsightApiBaseUrl: '',
      aiInsightApiKey: '',
      aiInsightApiModel: 'gpt-4o-mini',
      aiInsightSilenceDays: 3,
      aiInsightAllowContext: false,
+      aiInsightAllowMomentsContext: false,
+      aiInsightMomentsContextCount: 5,
+      aiInsightMomentsBindings: {},
      aiInsightAllowSocialContext: false,
+      aiInsightFilterMode: 'whitelist',
+      aiInsightFilterList: [],
      aiInsightWhitelistEnabled: false,
      aiInsightWhitelist: [],
      aiInsightCooldownMinutes: 120,
@@ -216,7 +260,17 @@ export class ConfigService {
      aiInsightWeiboBindings: {},
      aiFootprintEnabled: false,
      aiFootprintSystemPrompt: '',
-      aiInsightDebugLogEnabled: false
+      aiGroupSummaryEnabled: false,
+      aiGroupSummaryIntervalHours: 4,
+      aiGroupSummarySystemPrompt: '',
+      aiGroupSummaryFilterMode: 'whitelist',
+      aiGroupSummaryFilterList: [],
+      aiMessageInsightEnabled: false,
+      aiMessageInsightContextCount: 50,
+      aiMessageInsightSystemPrompt: '',
+      aiInsightDebugLogEnabled: false,
+      autoDownloadHighRes: false,
+      autoDownloadWhitelist: []
    }

    const storeOptions: any = {
@@ -779,6 +833,12 @@ export class ConfigService {
    if (!sharedModel && legacyModel) {
      this.set('aiModelApiModel', legacyModel)
    }
+
+    const groupSummaryFilterMode = String(this.store.get('aiGroupSummaryFilterMode' as any) || '').trim()
+    if (groupSummaryFilterMode === 'blacklist') {
+      this.store.set('aiGroupSummaryFilterList' as any, [] as any)
+      this.store.set('aiGroupSummaryFilterMode' as any, 'whitelist' as any)
+    }
  }

  // === 验证 ===
@@ -799,6 +859,14 @@ export class ConfigService {

  // === 工具方法 ===

+  /**
+   * 获取当前用户 wxid（清洗后，不带后缀）
+   */
+  getMyWxidCleaned(): string {
+    const wxid = this.get('myWxid')
+    return wxid ? this.cleanAccountDirName(wxid) : ''
+  }
+
  /**
   * 获取当前 wxid 对应的图片密钥，优先从 wxidConfigs 中取，找不到则回退到全局配置
   */
@@ -820,6 +888,99 @@ export class ConfigService {
    }
  }

+  /**
+   * 清理账号目录名称（移除后缀）
+   */
+  private cleanAccountDirName(dirName: string): string {
+    const trimmed = dirName.trim()
+    if (!trimmed) return trimmed
+
+    // wxid_ 开头的特殊处理
+    if (trimmed.toLowerCase().startsWith('wxid_')) {
+      const match = trimmed.match(/^(wxid_[^_]+)/i)
+      if (match) return match[1]
+      return trimmed
+    }
+
+    // 移除4位后缀
+    const suffixMatch = trimmed.match(/^(.+)_([a-zA-Z0-9]{4})$/)
+    if (suffixMatch) return suffixMatch[1]
+
+    return trimmed
+  }
+
+  /**
+   * 检查是否是目录
+   */
+  private isDirectory(path: string): boolean {
+    try {
+      return statSync(path).isDirectory()
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * 获取账号目录路径
+   * 统一的账号目录解析方法，所有服务应该使用此方法而不是自己实现
+   *
+   * @param dbPath 数据库根目录（可选，默认从配置读取）
+   * @param wxid 微信ID（可选，默认从配置读取）
+   * @returns 账号目录的完整路径，如果找不到返回 null
+   */
+  getAccountDir(dbPath?: string, wxid?: string): string | null {
+    const actualDbPath = dbPath || this.get('dbPath')
+    const actualWxid = wxid || this.get('myWxid')
+
+    if (!actualDbPath || !actualWxid) return null
+
+    const cleanedWxid = this.cleanAccountDirName(actualWxid)
+    const normalized = actualDbPath.replace(/[\\/]+$/, '')
+    const cacheKey = `${normalized}|${cleanedWxid.toLowerCase()}`
+
+    // 检查缓存
+    const cached = this.accountDirCache.get(cacheKey)
+    if (cached && existsSync(cached)) return cached
+    if (cached && !existsSync(cached)) {
+      this.accountDirCache.delete(cacheKey)
+    }
+
+    // 尝试直接路径（非 wxid_ 开头的账号）
+    const lowerWxid = cleanedWxid.toLowerCase()
+    if (!lowerWxid.startsWith('wxid_')) {
+      const direct = join(normalized, cleanedWxid)
+      if (existsSync(direct) && this.isDirectory(direct)) {
+        this.accountDirCache.set(cacheKey, direct)
+        return direct
+      }
+    }
+
+    // 扫描目录查找匹配的账号目录
+    try {
+      const entries = readdirSync(normalized)
+      for (const entry of entries) {
+        const entryPath = join(normalized, entry)
+        if (!this.isDirectory(entryPath)) continue
+
+        const lowerEntry = entry.toLowerCase()
+        const isExactMatch = lowerEntry === lowerWxid
+        const isSuffixMatch = lowerEntry.startsWith(`${lowerWxid}_`)
+
+        // wxid_ 开头只接受带后缀的目录；其他账号精确匹配或带后缀都可以
+        const shouldMatch = lowerWxid.startsWith('wxid_')
+          ? isSuffixMatch
+          : (isExactMatch || isSuffixMatch)
+
+        if (shouldMatch) {
+          this.accountDirCache.set(cacheKey, entryPath)
+          return entryPath
+        }
+      }
+    } catch { }
+
+    return null
+  }
+
  private getUserDataPath(): string {
    const workerUserDataPath = String(process.env.WEFLOW_USER_DATA_PATH || process.env.WEFLOW_CONFIG_CWD || '').trim()
    if (workerUserDataPath) {
--- a/electron/services/dbPathService.ts
+++ b/electron/services/dbPathService.ts
@@ -160,6 +160,16 @@ export class DbPathService {

          // 检查是否有有效账号目录结构
          if (this.isAccountDir(entryPath)) {
+            // 过滤掉不带后缀的 wxid_ 目录
+            const lowerEntry = entry.toLowerCase()
+            if (lowerEntry.startsWith('wxid_')) {
+              // wxid_ 开头的目录必须带后缀（wxid_xxx_yyyy 格式）
+              const parts = entry.split('_')
+              if (parts.length <= 2) {
+                // wxid_xxx 格式，跳过
+                continue
+              }
+            }
            accounts.push(entry)
          }
        }
@@ -232,6 +242,16 @@ export class DbPathService {
          const lower = entry.toLowerCase()
          if (lower === 'all_users') continue
          if (!entry.includes('_')) continue
+
+          // 过滤掉不带后缀的 wxid_ 目录
+          if (lower.startsWith('wxid_')) {
+            const parts = entry.split('_')
+            if (parts.length <= 2) {
+              // wxid_xxx 格式，跳过
+              continue
+            }
+          }
+
          wxids.push({ wxid: entry, modifiedTime: stat.mtimeMs })
        }
      }
--- a/electron/services/dualReportService.ts
+++ b/electron/services/dualReportService.ts
@@ -1,5 +1,6 @@
 import { parentPort } from 'worker_threads'
 import { wcdbService } from './wcdbService'
+import { resolveAccountDir } from './accountDirResolver'


 export interface DualReportMessage {
@@ -109,9 +110,11 @@ class DualReportService {
    if (!dbPath) return { success: false, error: '未配置数据库路径' }
    if (!decryptKey) return { success: false, error: '未配置解密密钥' }

-    const cleanedWxid = this.cleanAccountDirName(wxid)
-    const ok = await wcdbService.open(dbPath, decryptKey, cleanedWxid)
+    const accountDir = resolveAccountDir(dbPath, wxid)
+    if (!accountDir) return { success: false, error: '无法找到账号目录' }
+    const ok = await wcdbService.open(accountDir, decryptKey)
    if (!ok) return { success: false, error: 'WCDB 打开失败' }
+    const cleanedWxid = this.cleanAccountDirName(wxid)
    return { success: true, cleanedWxid, rawWxid: wxid }
  }

--- a/electron/services/exportService.ts
+++ b/electron/services/exportService.ts
--- a/electron/services/exportTaskControlService.ts
+++ b/electron/services/exportTaskControlService.ts
@@ -0,0 +1,210 @@
+import * as path from 'path'
+import { rm, rmdir } from 'fs/promises'
+
+export type ExportTaskControlState = 'running' | 'pause_requested' | 'cancel_requested'
+
+export interface ExportTaskControlHooks {
+  shouldPause: () => boolean
+  shouldStop: () => boolean
+  recordCreatedFile: (filePath: string) => void
+  recordCreatedDir: (dirPath: string) => void
+}
+
+interface ExportTaskManifest {
+  outputDir: string
+  files: Set<string>
+  dirs: Set<string>
+}
+
+interface ExportTaskControlRecord {
+  state: ExportTaskControlState
+  manifest: ExportTaskManifest
+  createdAt: number
+  updatedAt: number
+}
+
+export interface ExportTaskCleanupResult {
+  success: boolean
+  filesDeleted: number
+  dirsDeleted: number
+  error?: string
+}
+
+class ExportTaskControlService {
+  private tasks = new Map<string, ExportTaskControlRecord>()
+
+  createControl(taskId: string, outputDir: string): ExportTaskControlHooks {
+    this.registerTask(taskId, outputDir)
+    return {
+      shouldPause: () => this.getState(taskId) === 'pause_requested',
+      shouldStop: () => this.getState(taskId) === 'cancel_requested',
+      recordCreatedFile: (filePath: string) => this.recordCreatedFile(taskId, filePath),
+      recordCreatedDir: (dirPath: string) => this.recordCreatedDir(taskId, dirPath)
+    }
+  }
+
+  registerTask(taskId: string, outputDir: string): void {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    if (!normalizedTaskId) return
+
+    const normalizedOutputDir = path.resolve(String(outputDir || '').trim() || '.')
+    const existing = this.tasks.get(normalizedTaskId)
+    if (existing) {
+      existing.state = 'running'
+      existing.updatedAt = Date.now()
+      if (!existing.manifest.outputDir) {
+        existing.manifest.outputDir = normalizedOutputDir
+      }
+      return
+    }
+
+    this.tasks.set(normalizedTaskId, {
+      state: 'running',
+      manifest: {
+        outputDir: normalizedOutputDir,
+        files: new Set<string>(),
+        dirs: new Set<string>()
+      },
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    })
+  }
+
+  pauseTask(taskId: string): boolean {
+    return this.setState(taskId, 'pause_requested')
+  }
+
+  resumeTask(taskId: string): boolean {
+    return this.setState(taskId, 'running')
+  }
+
+  cancelTask(taskId: string): boolean {
+    return this.setState(taskId, 'cancel_requested')
+  }
+
+  getState(taskId: string): ExportTaskControlState | null {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    if (!normalizedTaskId) return null
+    return this.tasks.get(normalizedTaskId)?.state || null
+  }
+
+  releaseTask(taskId: string): void {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    if (!normalizedTaskId) return
+    this.tasks.delete(normalizedTaskId)
+  }
+
+  recordCreatedFile(taskId: string, filePath: string): void {
+    const task = this.getTaskForManifestWrite(taskId, filePath)
+    if (!task) return
+    task.manifest.files.add(path.resolve(filePath))
+    task.updatedAt = Date.now()
+  }
+
+  recordCreatedDir(taskId: string, dirPath: string): void {
+    const task = this.getTaskForManifestWrite(taskId, dirPath)
+    if (!task) return
+    task.manifest.dirs.add(path.resolve(dirPath))
+    task.updatedAt = Date.now()
+  }
+
+  async cleanupTask(taskId: string): Promise<ExportTaskCleanupResult> {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    const task = normalizedTaskId ? this.tasks.get(normalizedTaskId) : undefined
+    if (!task) {
+      return { success: true, filesDeleted: 0, dirsDeleted: 0 }
+    }
+
+    const outputDir = task.manifest.outputDir
+    let filesDeleted = 0
+    let dirsDeleted = 0
+    const errors: string[] = []
+
+    const files = Array.from(task.manifest.files)
+      .filter(filePath => this.isInsideOutputDir(filePath, outputDir))
+      .sort((a, b) => b.length - a.length)
+
+    for (const filePath of files) {
+      try {
+        await rm(filePath, { force: true, recursive: false })
+        filesDeleted++
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException | undefined)?.code
+        if (code !== 'ENOENT') {
+          errors.push(`${filePath}: ${error instanceof Error ? error.message : String(error)}`)
+        }
+      }
+    }
+
+    const dirs = Array.from(task.manifest.dirs)
+      .filter(dirPath => this.isInsideOutputDir(dirPath, outputDir) || this.isSamePath(dirPath, outputDir))
+      .sort((a, b) => b.length - a.length)
+
+    for (const dirPath of dirs) {
+      try {
+        await rmdir(dirPath)
+        dirsDeleted++
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException | undefined)?.code
+        if (code !== 'ENOENT' && code !== 'ENOTEMPTY' && code !== 'EEXIST') {
+          errors.push(`${dirPath}: ${error instanceof Error ? error.message : String(error)}`)
+        }
+      }
+    }
+
+    if (errors.length === 0) {
+      this.releaseTask(normalizedTaskId)
+      return { success: true, filesDeleted, dirsDeleted }
+    }
+
+    return {
+      success: false,
+      filesDeleted,
+      dirsDeleted,
+      error: errors.slice(0, 3).join('; ')
+    }
+  }
+
+  private setState(taskId: string, state: ExportTaskControlState): boolean {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    if (!normalizedTaskId) return false
+    const task = this.tasks.get(normalizedTaskId)
+    if (!task) return false
+    task.state = state
+    task.updatedAt = Date.now()
+    return true
+  }
+
+  private getTaskForManifestWrite(taskId: string, targetPath: string): ExportTaskControlRecord | null {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    if (!normalizedTaskId) return null
+    const task = this.tasks.get(normalizedTaskId)
+    if (!task) return null
+    if (!this.isInsideOutputDir(targetPath, task.manifest.outputDir) && !this.isSamePath(targetPath, task.manifest.outputDir)) {
+      return null
+    }
+    return task
+  }
+
+  private isInsideOutputDir(targetPath: string, outputDir: string): boolean {
+    const resolvedTarget = path.resolve(targetPath)
+    const resolvedOutputDir = path.resolve(outputDir)
+    const relativePath = path.relative(resolvedOutputDir, resolvedTarget)
+    return Boolean(relativePath) && !relativePath.startsWith('..') && !path.isAbsolute(relativePath)
+  }
+
+  private isSamePath(left: string, right: string): boolean {
+    const resolvedLeft = path.resolve(left)
+    const resolvedRight = path.resolve(right)
+    if (process.platform === 'win32') {
+      return resolvedLeft.toLowerCase() === resolvedRight.toLowerCase()
+    }
+    return resolvedLeft === resolvedRight
+  }
+
+  private normalizeTaskId(taskId: string): string {
+    return String(taskId || '').trim()
+  }
+}
+
+export const exportTaskControlService = new ExportTaskControlService()
--- a/electron/services/groupAnalyticsService.ts
+++ b/electron/services/groupAnalyticsService.ts
@@ -251,7 +251,7 @@ class GroupAnalyticsService {
  }

  private async ensureConnected(): Promise<{ success: boolean; error?: string }> {
-    const wxid = this.configService.get('myWxid')
+    const wxid = this.configService.getMyWxidCleaned()
    const dbPath = this.configService.get('dbPath')
    const decryptKey = this.configService.get('decryptKey')
    if (!wxid) return { success: false, error: '未配置微信ID' }
@@ -259,7 +259,9 @@ class GroupAnalyticsService {
    if (!decryptKey) return { success: false, error: '未配置解密密钥' }

    const cleanedWxid = this.cleanAccountDirName(wxid)
-    const ok = await wcdbService.open(dbPath, decryptKey, cleanedWxid)
+    const accountDir = this.configService.getAccountDir(dbPath, wxid)
+    if (!accountDir) return { success: false, error: '无法找到账号目录' }
+    const ok = await wcdbService.open(accountDir, decryptKey)
    if (!ok) return { success: false, error: 'WCDB 打开失败' }
    return { success: true }
  }
@@ -1555,7 +1557,7 @@ class GroupAnalyticsService {
      const phraseCounts = new Map<string, number>()
      const emojiCounts = new Map<string, number>()

-      const myWxid = String(this.configService.get('myWxid') || '').trim()
+      const myWxid = String(this.configService.getMyWxidCleaned() || '').trim()

      try {
        while (true) {
--- a/electron/services/groupSummaryRecordService.ts
+++ b/electron/services/groupSummaryRecordService.ts
@@ -0,0 +1,384 @@
+import { app } from 'electron'
+import fs from 'fs'
+import path from 'path'
+import { createHash, randomUUID } from 'crypto'
+import { ConfigService } from './config'
+
+export type GroupSummaryTriggerType = 'auto' | 'manual'
+
+export interface GroupSummaryTopic {
+  title: string
+  participants: string[]
+  keyPoints: string[]
+  conclusion: string
+}
+
+export interface GroupSummaryLog {
+  endpoint: string
+  model: string
+  temperature: number
+  triggerType: GroupSummaryTriggerType
+  periodStart: number
+  periodEnd: number
+  messageCount: number
+  readableMessageCount: number
+  systemPrompt: string
+  userPrompt: string
+  rawOutput: string
+  finalSummary: string
+  durationMs: number
+  createdAt: number
+  responseFormatJson?: boolean
+  responseFormatFallback?: boolean
+  responseFormatFallbackReason?: string
+  parsedTopics?: GroupSummaryTopic[]
+}
+
+export interface GroupSummaryRecord {
+  id: string
+  accountScope: string
+  createdAt: number
+  sessionId: string
+  displayName: string
+  avatarUrl?: string
+  triggerType: GroupSummaryTriggerType
+  periodStart: number
+  periodEnd: number
+  messageCount: number
+  readableMessageCount: number
+  topics: GroupSummaryTopic[]
+  summaryText: string
+  rawOutput: string
+  log: GroupSummaryLog
+}
+
+export interface GroupSummaryRecordSummary {
+  id: string
+  createdAt: number
+  sessionId: string
+  displayName: string
+  avatarUrl?: string
+  triggerType: GroupSummaryTriggerType
+  periodStart: number
+  periodEnd: number
+  messageCount: number
+  readableMessageCount: number
+  topics: GroupSummaryTopic[]
+  summaryText: string
+}
+
+export interface GroupSummaryRecordFilters {
+  sessionId?: string
+  startTime?: number
+  endTime?: number
+  limit?: number
+  offset?: number
+}
+
+export interface GroupSummaryRecordListResult {
+  success: boolean
+  records: GroupSummaryRecordSummary[]
+  total: number
+  error?: string
+}
+
+interface GroupSummaryIndexRecord extends GroupSummaryRecordSummary {
+  accountScope: string
+  logFile?: string
+}
+
+interface LegacyGroupSummaryRecord extends GroupSummaryIndexRecord {
+  rawOutput?: string
+  log?: GroupSummaryLog
+}
+
+class GroupSummaryRecordService {
+  private readonly maxRecordsPerScope = 2000
+  private filePath: string | null = null
+  private logDir: string | null = null
+  private loaded = false
+  private records: GroupSummaryIndexRecord[] = []
+
+  private resolveUserDataPath(): string {
+    const workerUserDataPath = String(process.env.WEFLOW_USER_DATA_PATH || process.env.WEFLOW_CONFIG_CWD || '').trim()
+    const userDataPath = workerUserDataPath || app?.getPath?.('userData') || process.cwd()
+    fs.mkdirSync(userDataPath, { recursive: true })
+    return userDataPath
+  }
+
+  private resolveFilePath(): string {
+    if (this.filePath) return this.filePath
+    this.filePath = path.join(this.resolveUserDataPath(), 'weflow-group-summary-records.json')
+    return this.filePath
+  }
+
+  private resolveLogDir(): string {
+    if (this.logDir) return this.logDir
+    this.logDir = path.join(this.resolveUserDataPath(), 'weflow-group-summary-logs')
+    fs.mkdirSync(this.logDir, { recursive: true })
+    return this.logDir
+  }
+
+  private normalizeTimestampSeconds(value: unknown): number {
+    const numeric = Number(value || 0)
+    if (!Number.isFinite(numeric) || numeric <= 0) return 0
+    let normalized = Math.floor(numeric)
+    while (normalized > 10000000000) {
+      normalized = Math.floor(normalized / 1000)
+    }
+    return normalized
+  }
+
+  private safeLogFileName(id: string): string {
+    const normalized = String(id || '').replace(/[^a-zA-Z0-9_-]/g, '')
+    return `${normalized || randomUUID()}.json`
+  }
+
+  private writeLogFile(recordId: string, log: GroupSummaryLog, rawOutput: string): string | undefined {
+    try {
+      const fileName = this.safeLogFileName(recordId)
+      const logPath = path.join(this.resolveLogDir(), fileName)
+      fs.writeFileSync(logPath, JSON.stringify({ version: 1, rawOutput, log }, null, 2), 'utf-8')
+      return fileName
+    } catch {
+      return undefined
+    }
+  }
+
+  private readLogFile(fileName?: string): { rawOutput: string; log: GroupSummaryLog } | null {
+    if (!fileName) return null
+    try {
+      const logPath = path.join(this.resolveLogDir(), this.safeLogFileName(fileName.replace(/\.json$/i, '')))
+      if (!fs.existsSync(logPath)) return null
+      const parsed = JSON.parse(fs.readFileSync(logPath, 'utf-8'))
+      const log = parsed?.log
+      if (!log || typeof log !== 'object') return null
+      return {
+        rawOutput: typeof parsed?.rawOutput === 'string' ? parsed.rawOutput : String(log.rawOutput || ''),
+        log: log as GroupSummaryLog
+      }
+    } catch {
+      return null
+    }
+  }
+
+  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)
+      const records = Array.isArray(parsed) ? parsed : parsed?.records
+      if (!Array.isArray(records)) return
+
+      const legacyRecords = records.filter((item) => item && typeof item === 'object') as LegacyGroupSummaryRecord[]
+      const needsMigration = legacyRecords.some((record) => Boolean(record.log || record.rawOutput))
+      if (needsMigration) {
+        this.backupLegacyFile(filePath)
+      }
+
+      this.records = legacyRecords.map((record) => {
+        const id = String(record.id || randomUUID())
+        const logFile = record.log
+          ? this.writeLogFile(id, record.log, String(record.rawOutput || record.log.rawOutput || ''))
+          : record.logFile
+        return {
+          id,
+          accountScope: String(record.accountScope || 'default'),
+          createdAt: Number(record.createdAt || Date.now()),
+          sessionId: String(record.sessionId || ''),
+          displayName: String(record.displayName || record.sessionId || ''),
+          avatarUrl: record.avatarUrl,
+          triggerType: record.triggerType === 'auto' ? 'auto' : 'manual',
+          periodStart: this.normalizeTimestampSeconds(record.periodStart),
+          periodEnd: this.normalizeTimestampSeconds(record.periodEnd),
+          messageCount: Math.max(0, Math.floor(Number(record.messageCount || 0))),
+          readableMessageCount: Math.max(0, Math.floor(Number(record.readableMessageCount || 0))),
+          topics: Array.isArray(record.topics) ? record.topics : [],
+          summaryText: String(record.summaryText || ''),
+          logFile
+        }
+      }).filter((record) => record.sessionId && record.periodStart > 0 && record.periodEnd > record.periodStart)
+
+      if (needsMigration) {
+        this.persist()
+      }
+    } catch {
+      this.records = []
+    }
+  }
+
+  private backupLegacyFile(filePath: string): void {
+    try {
+      const backupPath = `${filePath}.legacy-${Date.now()}.bak`
+      if (!fs.existsSync(backupPath)) {
+        fs.copyFileSync(filePath, backupPath)
+      }
+    } catch {
+      // Backup failure should not block reading existing records.
+    }
+  }
+
+  private persist(): void {
+    try {
+      const filePath = this.resolveFilePath()
+      fs.writeFileSync(filePath, JSON.stringify({ version: 2, records: this.records }, null, 2), 'utf-8')
+    } catch {
+      // Summary generation should not fail because local record persistence failed.
+    }
+  }
+
+  private getCurrentAccountScope(): string {
+    const config = ConfigService.getInstance()
+    const myWxid = String(config.getMyWxidCleaned() || '').trim()
+    if (myWxid) return `wxid:${myWxid}`
+
+    const dbPath = String(config.get('dbPath') || '').trim()
+    if (dbPath) {
+      const hash = createHash('sha1').update(dbPath).digest('hex').slice(0, 16)
+      return `db:${hash}`
+    }
+    return 'default'
+  }
+
+  private toSummary(record: GroupSummaryIndexRecord): GroupSummaryRecordSummary {
+    return {
+      id: record.id,
+      createdAt: record.createdAt,
+      sessionId: record.sessionId,
+      displayName: record.displayName,
+      avatarUrl: record.avatarUrl,
+      triggerType: record.triggerType,
+      periodStart: record.periodStart,
+      periodEnd: record.periodEnd,
+      messageCount: record.messageCount,
+      readableMessageCount: record.readableMessageCount,
+      topics: Array.isArray(record.topics) ? record.topics : [],
+      summaryText: record.summaryText || ''
+    }
+  }
+
+  private getScopedRecords(): GroupSummaryIndexRecord[] {
+    this.ensureLoaded()
+    const scope = this.getCurrentAccountScope()
+    return this.records.filter((record) => record.accountScope === scope)
+  }
+
+  addRecord(input: {
+    sessionId: string
+    displayName: string
+    avatarUrl?: string
+    triggerType: GroupSummaryTriggerType
+    periodStart: number
+    periodEnd: number
+    messageCount: number
+    readableMessageCount: number
+    topics: GroupSummaryTopic[]
+    summaryText: string
+    rawOutput: string
+    log: GroupSummaryLog
+  }): GroupSummaryRecordSummary {
+    this.ensureLoaded()
+    const scope = this.getCurrentAccountScope()
+    const id = randomUUID()
+    const logFile = this.writeLogFile(id, input.log, input.rawOutput)
+    const record: GroupSummaryIndexRecord = {
+      id,
+      accountScope: scope,
+      createdAt: Date.now(),
+      sessionId: input.sessionId,
+      displayName: input.displayName,
+      avatarUrl: input.avatarUrl,
+      triggerType: input.triggerType,
+      periodStart: input.periodStart,
+      periodEnd: input.periodEnd,
+      messageCount: input.messageCount,
+      readableMessageCount: input.readableMessageCount,
+      topics: input.topics,
+      summaryText: input.summaryText,
+      logFile
+    }
+
+    this.records.push(record)
+    const scopedRecords = this.records
+      .filter((item) => item.accountScope === scope)
+      .sort((a, b) => b.createdAt - a.createdAt)
+    const keepIds = new Set(scopedRecords.slice(0, this.maxRecordsPerScope).map((item) => item.id))
+    this.records = this.records.filter((item) => item.accountScope !== scope || keepIds.has(item.id))
+    this.persist()
+    return this.toSummary(record)
+  }
+
+  hasAutoRecord(sessionId: string, periodStart: number, periodEnd: number): boolean {
+    const normalizedSessionId = String(sessionId || '').trim()
+    if (!normalizedSessionId) return false
+    return this.getScopedRecords().some((record) =>
+      record.triggerType === 'auto' &&
+      record.sessionId === normalizedSessionId &&
+      Number(record.periodStart || 0) === periodStart &&
+      Number(record.periodEnd || 0) === periodEnd
+    )
+  }
+
+  listRecords(filters: GroupSummaryRecordFilters = {}): GroupSummaryRecordListResult {
+    try {
+      const sessionId = String(filters.sessionId || '').trim()
+      const startTime = this.normalizeTimestampSeconds(filters.startTime)
+      const endTime = this.normalizeTimestampSeconds(filters.endTime)
+      const offset = Math.max(0, Math.floor(Number(filters.offset || 0)))
+      const limit = Math.min(200, Math.max(1, Math.floor(Number(filters.limit || 100))))
+
+      const filtered = this.getScopedRecords()
+        .filter((record) => {
+          if (sessionId && record.sessionId !== sessionId) return false
+          const periodStart = Number(record.periodStart || 0)
+          const periodEnd = Number(record.periodEnd || 0)
+          if (startTime > 0 && periodEnd < startTime) return false
+          if (endTime > 0 && periodStart > endTime) return false
+          return true
+        })
+        .sort((a, b) => Number(b.periodStart || b.createdAt) - Number(a.periodStart || a.createdAt))
+
+      return {
+        success: true,
+        records: filtered.slice(offset, offset + limit).map((record) => this.toSummary(record)),
+        total: filtered.length
+      }
+    } catch (error) {
+      return { success: false, records: [], total: 0, error: (error as Error).message || String(error) }
+    }
+  }
+
+  getRecord(id: string): { success: boolean; record?: GroupSummaryRecord; error?: string } {
+    this.ensureLoaded()
+    const normalizedId = String(id || '').trim()
+    if (!normalizedId) return { success: false, error: '记录 ID 为空' }
+    const scope = this.getCurrentAccountScope()
+    const record = this.records.find((item) => item.id === normalizedId && item.accountScope === scope)
+    if (!record) return { success: false, error: '未找到该群聊总结记录' }
+
+    const logData = this.readLogFile(record.logFile)
+    if (!logData) return { success: false, error: '未找到该群聊总结日志' }
+
+    return {
+      success: true,
+      record: {
+        ...this.toSummary(record),
+        accountScope: record.accountScope,
+        rawOutput: logData.rawOutput,
+        log: logData.log
+      }
+    }
+  }
+
+  clearRuntimeCache(): void {
+    this.loaded = false
+    this.records = []
+    this.filePath = null
+    this.logDir = null
+  }
+}
+
+export const groupSummaryRecordService = new GroupSummaryRecordService()
--- a/electron/services/groupSummaryService.ts
+++ b/electron/services/groupSummaryService.ts
@@ -0,0 +1,801 @@
+import https from 'https'
+import http from 'http'
+import { URL } from 'url'
+import groupSummaryPrompt from '../../shared/groupSummaryPrompt.json'
+import { ConfigService } from './config'
+import { chatService, type Message } from './chatService'
+import { wcdbService } from './wcdbService'
+import {
+  groupSummaryRecordService,
+  type GroupSummaryLog,
+  type GroupSummaryRecord,
+  type GroupSummaryRecordFilters,
+  type GroupSummaryRecordListResult,
+  type GroupSummaryRecordSummary,
+  type GroupSummaryTopic,
+  type GroupSummaryTriggerType
+} from './groupSummaryRecordService'
+
+const API_TIMEOUT_MS = 90_000
+const API_TEMPERATURE = 0.4
+const MIN_SUMMARY_MESSAGES = 5
+const MAX_MANUAL_RANGE_SECONDS = 48 * 60 * 60
+const MAX_MESSAGES_PER_SUMMARY = 3000
+const SUMMARY_CURSOR_BATCH_SIZE = 360
+const DEFAULT_GROUP_SUMMARY_SYSTEM_PROMPT = String(groupSummaryPrompt.defaultSystemPrompt || '').trim()
+const SUMMARY_CONFIG_KEYS = new Set([
+  'aiGroupSummaryEnabled',
+  'aiGroupSummaryIntervalHours',
+  'aiGroupSummarySystemPrompt',
+  'aiGroupSummaryFilterMode',
+  'aiGroupSummaryFilterList',
+  'aiModelApiBaseUrl',
+  'aiModelApiKey',
+  'aiModelApiModel',
+  'aiInsightApiBaseUrl',
+  'aiInsightApiKey',
+  'aiInsightApiModel',
+  'dbPath',
+  'decryptKey',
+  'myWxid'
+])
+
+interface SharedAiModelConfig {
+  apiBaseUrl: string
+  apiKey: string
+  model: string
+}
+
+interface GroupSummaryTriggerResult {
+  success: boolean
+  message: string
+  recordId?: string
+  record?: GroupSummaryRecordSummary
+  skipped?: boolean
+  skippedReason?: string
+}
+
+interface GroupSummaryDayTriggerResult {
+  success: boolean
+  message: string
+  generated: number
+  skipped: number
+  records: GroupSummaryRecordSummary[]
+}
+
+class ApiRequestError extends Error {
+  statusCode?: number
+  responseBody?: string
+
+  constructor(message: string, statusCode?: number, responseBody?: string) {
+    super(message)
+    this.name = 'ApiRequestError'
+    this.statusCode = statusCode
+    this.responseBody = responseBody
+  }
+}
+
+function buildApiUrl(baseUrl: string, path: string): string {
+  const base = baseUrl.replace(/\/+$/, '')
+  const suffix = path.startsWith('/') ? path : `/${path}`
+  return `${base}${suffix}`
+}
+
+function normalizeSessionIdList(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return Array.from(new Set(value.map((item) => String(item || '').trim()).filter(Boolean)))
+}
+
+function normalizeIntervalHours(value: unknown): number {
+  const allowed = new Set([1, 2, 4, 8, 12, 24])
+  const numeric = Math.floor(Number(value) || 4)
+  return allowed.has(numeric) ? numeric : 4
+}
+
+function getStartOfDaySeconds(date: Date = new Date()): number {
+  const next = new Date(date)
+  next.setHours(0, 0, 0, 0)
+  return Math.floor(next.getTime() / 1000)
+}
+
+function clampText(value: unknown, maxLength: number): string {
+  const text = String(value || '').replace(/\s+/g, ' ').trim()
+  if (text.length <= maxLength) return text
+  return `${text.slice(0, Math.max(0, maxLength - 1))}…`
+}
+
+function stripJsonFence(value: string): string {
+  const text = String(value || '').trim()
+  const fenced = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)
+  if (fenced) return fenced[1].trim()
+  const firstBrace = text.indexOf('{')
+  const lastBrace = text.lastIndexOf('}')
+  if (firstBrace >= 0 && lastBrace > firstBrace) {
+    return text.slice(firstBrace, lastBrace + 1).trim()
+  }
+  return text
+}
+
+function shouldFallbackJsonMode(error: unknown): boolean {
+  const statusCode = (error as ApiRequestError)?.statusCode
+  if (statusCode === 400 || statusCode === 404 || statusCode === 422) return true
+  const text = `${(error as Error)?.message || ''}\n${(error as ApiRequestError)?.responseBody || ''}`.toLowerCase()
+  return text.includes('response_format') || text.includes('json_object') || text.includes('json mode')
+}
+
+function formatTimestamp(createTime: number): string {
+  const ms = createTime > 1_000_000_000_000 ? createTime : createTime * 1000
+  const date = new Date(ms)
+  const year = date.getFullYear()
+  const month = String(date.getMonth() + 1).padStart(2, '0')
+  const day = String(date.getDate()).padStart(2, '0')
+  const hours = String(date.getHours()).padStart(2, '0')
+  const minutes = String(date.getMinutes()).padStart(2, '0')
+  const seconds = String(date.getSeconds()).padStart(2, '0')
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`
+}
+
+function callChatCompletions(
+  apiBaseUrl: string,
+  apiKey: string,
+  model: string,
+  messages: Array<{ role: string; content: string }>,
+  options?: { responseFormatJson?: boolean }
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const endpoint = buildApiUrl(apiBaseUrl, '/chat/completions')
+    let urlObj: URL
+    try {
+      urlObj = new URL(endpoint)
+    } catch {
+      reject(new Error(`无效的 API URL: ${endpoint}`))
+      return
+    }
+
+    const payload: Record<string, unknown> = {
+      model,
+      messages,
+      temperature: API_TEMPERATURE,
+      stream: false
+    }
+    if (options?.responseFormatJson) {
+      payload.response_format = { type: 'json_object' }
+    }
+
+    const body = JSON.stringify(payload)
+    const requestOptions = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+      path: urlObj.pathname + urlObj.search,
+      method: 'POST' as const,
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body).toString(),
+        Authorization: `Bearer ${apiKey}`
+      }
+    }
+
+    const requestFn = urlObj.protocol === 'https:' ? https.request : http.request
+    const req = requestFn(requestOptions, (res) => {
+      let data = ''
+      res.on('data', (chunk) => { data += chunk })
+      res.on('end', () => {
+        try {
+          if (res.statusCode && res.statusCode >= 400) {
+            reject(new ApiRequestError(`API 请求失败 (${res.statusCode}): ${data.slice(0, 200)}`, res.statusCode, data))
+            return
+          }
+          const parsed = JSON.parse(data)
+          const content = parsed?.choices?.[0]?.message?.content
+          if (typeof content === 'string' && content.trim()) {
+            resolve(content.trim())
+          } else {
+            reject(new Error(`API 返回格式异常: ${data.slice(0, 200)}`))
+          }
+        } catch {
+          reject(new Error(`JSON 解析失败: ${data.slice(0, 200)}`))
+        }
+      })
+    })
+
+    req.setTimeout(API_TIMEOUT_MS, () => {
+      req.destroy()
+      reject(new Error('API 请求超时'))
+    })
+    req.on('error', reject)
+    req.write(body)
+    req.end()
+  })
+}
+
+function parseTopics(rawOutput: string): GroupSummaryTopic[] {
+  const parsed = JSON.parse(stripJsonFence(rawOutput)) as unknown
+  if (!parsed || typeof parsed !== 'object') {
+    throw new Error('模型输出格式异常：JSON 根节点不是对象')
+  }
+  const source = parsed as Record<string, unknown>
+  const rawTopics = Array.isArray(source.topics) ? source.topics : []
+  const topics = rawTopics.map((item, index) => {
+    const topic = item && typeof item === 'object' ? item as Record<string, unknown> : {}
+    const participantsRaw = Array.isArray(topic.participants) ? topic.participants : []
+    const keyPointsRaw = Array.isArray(topic.key_points)
+      ? topic.key_points
+      : (Array.isArray(topic.keyPoints) ? topic.keyPoints : [])
+    return {
+      title: clampText(topic.title || `话题 ${index + 1}`, 48) || `话题 ${index + 1}`,
+      participants: participantsRaw.map((value) => clampText(value, 24)).filter(Boolean).slice(0, 12),
+      keyPoints: keyPointsRaw.map((value) => clampText(value, 120)).filter(Boolean).slice(0, 8),
+      conclusion: clampText(topic.conclusion, 180) || '无明确结论'
+    }
+  }).filter((topic) => topic.title || topic.keyPoints.length > 0 || topic.conclusion)
+
+  if (topics.length === 0) {
+    throw new Error('模型输出格式异常：topics 为空')
+  }
+  return topics
+}
+
+function buildSummaryText(topics: GroupSummaryTopic[]): string {
+  return topics.map((topic) => {
+    const participants = topic.participants.length > 0 ? topic.participants.join('、') : '未明确'
+    const keyPoints = topic.keyPoints.length > 0 ? topic.keyPoints.join('；') : '无'
+    return `【${topic.title}】参与者：${participants}。关键/矛盾点：${keyPoints}。结论：${topic.conclusion}`
+  }).join('\n')
+}
+
+function fallbackTopicFromRaw(rawOutput: string): GroupSummaryTopic {
+  return {
+    title: '未归类总结',
+    participants: [],
+    keyPoints: [clampText(rawOutput, 500)],
+    conclusion: '模型未按固定 JSON 格式返回，请查看完整日志。'
+  }
+}
+
+class GroupSummaryService {
+  private config: ConfigService
+  private started = false
+  private scanTimer: NodeJS.Timeout | null = null
+  private processing = false
+  private pendingAutoRun = false
+  private dbConnected = false
+
+  constructor() {
+    this.config = ConfigService.getInstance()
+  }
+
+  start(): void {
+    if (this.started) return
+    this.started = true
+    void this.refreshConfiguration('startup')
+  }
+
+  stop(): void {
+    this.started = false
+    this.clearTimers()
+    this.processing = false
+    this.pendingAutoRun = false
+    this.dbConnected = false
+  }
+
+  async handleConfigChanged(key: string): Promise<void> {
+    const normalizedKey = String(key || '').trim()
+    if (!SUMMARY_CONFIG_KEYS.has(normalizedKey)) return
+    if (normalizedKey === 'aiGroupSummarySystemPrompt') return
+    if (normalizedKey === 'dbPath' || normalizedKey === 'decryptKey' || normalizedKey === 'myWxid') {
+      this.dbConnected = false
+      groupSummaryRecordService.clearRuntimeCache()
+    }
+    await this.refreshConfiguration(`config:${normalizedKey}`)
+  }
+
+  handleConfigCleared(): void {
+    this.clearTimers()
+    this.processing = false
+    this.pendingAutoRun = false
+    this.dbConnected = false
+    groupSummaryRecordService.clearRuntimeCache()
+  }
+
+  listRecords(filters?: GroupSummaryRecordFilters): GroupSummaryRecordListResult {
+    return groupSummaryRecordService.listRecords(filters || {})
+  }
+
+  getRecord(id: string): { success: boolean; record?: GroupSummaryRecord; error?: string } {
+    return groupSummaryRecordService.getRecord(id)
+  }
+
+  async triggerManual(params: {
+    sessionId: string
+    displayName?: string
+    avatarUrl?: string
+    startTime: number
+    endTime: number
+  }): Promise<GroupSummaryTriggerResult> {
+    if (!this.isEnabled()) {
+      return { success: false, message: '请先在设置中开启「AI 群聊总结」' }
+    }
+    const sessionId = String(params?.sessionId || '').trim()
+    if (!sessionId.endsWith('@chatroom')) {
+      return { success: false, message: 'AI 群聊总结仅支持群聊' }
+    }
+    const startTime = this.normalizeTimestampSeconds(params?.startTime)
+    const endTime = this.normalizeTimestampSeconds(params?.endTime)
+    if (startTime <= 0 || endTime <= startTime) {
+      return { success: false, message: '请选择有效的总结时段' }
+    }
+    if (endTime - startTime > MAX_MANUAL_RANGE_SECONDS) {
+      return { success: false, message: '手动总结时段不能超过 48 小时' }
+    }
+
+    const displayName = String(params?.displayName || sessionId).trim() || sessionId
+    const avatarUrl = String(params?.avatarUrl || '').trim() || undefined
+    return this.generateSummaryForPeriod({
+      sessionId,
+      displayName,
+      avatarUrl,
+      periodStart: startTime,
+      periodEnd: endTime,
+      triggerType: 'manual'
+    })
+  }
+
+  async triggerDay(params: {
+    sessionId: string
+    displayName?: string
+    avatarUrl?: string
+    date: string
+  }): Promise<GroupSummaryDayTriggerResult> {
+    if (!this.isEnabled()) {
+      return { success: false, message: '请先在设置中开启「AI 群聊总结」', generated: 0, skipped: 0, records: [] }
+    }
+    const sessionId = String(params?.sessionId || '').trim()
+    if (!sessionId.endsWith('@chatroom')) {
+      return { success: false, message: 'AI 群聊总结仅支持群聊', generated: 0, skipped: 0, records: [] }
+    }
+    const dayRange = this.parseLocalDateDayRange(params?.date)
+    if (!dayRange) {
+      return { success: false, message: '请选择有效日期', generated: 0, skipped: 0, records: [] }
+    }
+    const todayStart = getStartOfDaySeconds(new Date())
+    if (dayRange.start > todayStart) {
+      return { success: false, message: '不能总结未来日期', generated: 0, skipped: 0, records: [] }
+    }
+
+    const now = Math.floor(Date.now() / 1000)
+    const effectiveEnd = dayRange.start === todayStart ? Math.min(dayRange.end, now) : dayRange.end
+    const periods = this.getIntervalPeriods(dayRange.start, effectiveEnd, false)
+    if (periods.length === 0) {
+      return { success: true, message: '当前日期暂无已完成的总结时段', generated: 0, skipped: 0, records: [] }
+    }
+
+    const displayName = String(params?.displayName || sessionId).trim() || sessionId
+    const avatarUrl = String(params?.avatarUrl || '').trim() || undefined
+    return this.generateSummariesForPeriods({
+      sessionId,
+      displayName,
+      avatarUrl,
+      periods,
+      triggerType: 'manual'
+    })
+  }
+
+  private async refreshConfiguration(_reason: string): Promise<void> {
+    if (!this.started) return
+    this.clearTimers()
+    if (!this.isEnabled()) return
+    await this.queueDueAutoSummaries()
+    this.scheduleNextAutoRun()
+  }
+
+  private isEnabled(): boolean {
+    return this.config.get('aiGroupSummaryEnabled') === true
+  }
+
+  private clearTimers(): void {
+    if (this.scanTimer !== null) {
+      clearTimeout(this.scanTimer)
+      this.scanTimer = null
+    }
+  }
+
+  private scheduleNextAutoRun(): void {
+    if (!this.started || !this.isEnabled()) return
+    const intervalHours = normalizeIntervalHours(this.config.get('aiGroupSummaryIntervalHours'))
+    const now = Math.floor(Date.now() / 1000)
+    const dayStart = getStartOfDaySeconds(new Date())
+    const intervalSeconds = intervalHours * 60 * 60
+    const elapsed = Math.max(0, now - dayStart)
+    const nextBoundary = dayStart + (Math.floor(elapsed / intervalSeconds) + 1) * intervalSeconds
+    const delayMs = Math.max(1_000, (nextBoundary - now) * 1000 + 1_000)
+
+    this.scanTimer = setTimeout(async () => {
+      this.scanTimer = null
+      await this.queueDueAutoSummaries()
+      this.scheduleNextAutoRun()
+    }, delayMs)
+  }
+
+  private async ensureConnected(): Promise<boolean> {
+    if (this.dbConnected) return true
+    const result = await chatService.connect()
+    this.dbConnected = result.success === true
+    return this.dbConnected
+  }
+
+  private getSharedAiModelConfig(): SharedAiModelConfig {
+    const apiBaseUrl = String(
+      this.config.get('aiModelApiBaseUrl')
+      || this.config.get('aiInsightApiBaseUrl')
+      || ''
+    ).trim()
+    const apiKey = String(
+      this.config.get('aiModelApiKey')
+      || this.config.get('aiInsightApiKey')
+      || ''
+    ).trim()
+    const model = String(
+      this.config.get('aiModelApiModel')
+      || this.config.get('aiInsightApiModel')
+      || 'gpt-4o-mini'
+    ).trim() || 'gpt-4o-mini'
+    return { apiBaseUrl, apiKey, model }
+  }
+
+  private getAutoScopeSessionIds(): string[] {
+    return normalizeSessionIdList(this.config.get('aiGroupSummaryFilterList'))
+      .filter((sessionId) => sessionId.endsWith('@chatroom'))
+  }
+
+  private normalizeTimestampSeconds(value: unknown): number {
+    const numeric = Number(value || 0)
+    if (!Number.isFinite(numeric) || numeric <= 0) return 0
+    let normalized = Math.floor(numeric)
+    while (normalized > 10000000000) {
+      normalized = Math.floor(normalized / 1000)
+    }
+    return normalized
+  }
+
+  private parseLocalDateDayRange(value: unknown): { start: number; end: number } | null {
+    const text = String(value || '').trim()
+    const match = text.match(/^(\d{4})-(\d{2})-(\d{2})$/)
+    if (!match) return null
+    const year = Number(match[1])
+    const month = Number(match[2])
+    const day = Number(match[3])
+    const start = new Date(year, month - 1, day, 0, 0, 0, 0)
+    if (
+      !Number.isFinite(start.getTime()) ||
+      start.getFullYear() !== year ||
+      start.getMonth() !== month - 1 ||
+      start.getDate() !== day
+    ) {
+      return null
+    }
+    const end = new Date(start)
+    end.setDate(end.getDate() + 1)
+    return {
+      start: Math.floor(start.getTime() / 1000),
+      end: Math.floor(end.getTime() / 1000)
+    }
+  }
+
+  private getIntervalPeriods(startTime: number, endTime: number, includePartial: boolean): Array<{ start: number; end: number }> {
+    const intervalHours = normalizeIntervalHours(this.config.get('aiGroupSummaryIntervalHours'))
+    const intervalSeconds = intervalHours * 60 * 60
+    const periods: Array<{ start: number; end: number }> = []
+    for (let start = startTime; start < endTime; start += intervalSeconds) {
+      const end = Math.min(start + intervalSeconds, endTime)
+      if (!includePartial && end - start < intervalSeconds) continue
+      if (end > start) periods.push({ start, end })
+    }
+    return periods
+  }
+
+  private getCompletedPeriodsToday(): Array<{ start: number; end: number }> {
+    const dayStart = getStartOfDaySeconds(new Date())
+    const now = Math.floor(Date.now() / 1000)
+    return this.getIntervalPeriods(dayStart, now, false)
+  }
+
+  private async queueDueAutoSummaries(): Promise<void> {
+    if (!this.started || !this.isEnabled()) return
+    if (this.processing) {
+      this.pendingAutoRun = true
+      return
+    }
+    this.processing = true
+    try {
+      do {
+        this.pendingAutoRun = false
+        await this.runDueAutoSummariesOnce()
+      } while (this.pendingAutoRun && this.started && this.isEnabled())
+    } finally {
+      this.processing = false
+    }
+  }
+
+  private async runDueAutoSummariesOnce(): Promise<void> {
+    if (!this.started || !this.isEnabled()) return
+    try {
+      const { apiBaseUrl, apiKey } = this.getSharedAiModelConfig()
+      if (!apiBaseUrl || !apiKey) return
+      const scopeSessionIds = this.getAutoScopeSessionIds()
+      if (scopeSessionIds.length === 0) return
+      if (!await this.ensureConnected()) return
+
+      const contacts = (await chatService.enrichSessionsContactInfo(scopeSessionIds).catch(() => null))?.contacts || {}
+
+      const periods = this.getCompletedPeriodsToday()
+      for (const period of periods) {
+        for (const sessionId of scopeSessionIds) {
+          if (!this.started || !this.isEnabled()) return
+          if (!sessionId) continue
+          if (groupSummaryRecordService.hasAutoRecord(sessionId, period.start, period.end)) continue
+          await this.generateSummaryForPeriod({
+            sessionId,
+            displayName: contacts[sessionId]?.displayName || sessionId,
+            avatarUrl: contacts[sessionId]?.avatarUrl,
+            periodStart: period.start,
+            periodEnd: period.end,
+            triggerType: 'auto'
+          })
+        }
+      }
+    } catch (error) {
+      console.warn('[GroupSummaryService] 自动总结失败:', error)
+    }
+  }
+
+  private async readMessagesInPeriod(sessionId: string, startTime: number, endTime: number): Promise<Message[]> {
+    if (!await this.ensureConnected()) {
+      throw new Error('数据库连接失败，请先在“数据库连接”页完成配置')
+    }
+    const cursorResult = await wcdbService.openMessageCursorLite(
+      sessionId,
+      SUMMARY_CURSOR_BATCH_SIZE,
+      true,
+      startTime,
+      endTime
+    )
+    if (!cursorResult.success || !cursorResult.cursor) {
+      throw new Error(cursorResult.error || '打开消息游标失败')
+    }
+
+    const cursor = cursorResult.cursor
+    const messages: Message[] = []
+    try {
+      let hasMore = true
+      while (hasMore && messages.length < MAX_MESSAGES_PER_SUMMARY) {
+        const batch = await wcdbService.fetchMessageBatch(cursor)
+        if (!batch.success) {
+          throw new Error(batch.error || '读取消息失败')
+        }
+        hasMore = batch.hasMore === true
+        const rows = Array.isArray(batch.rows) ? batch.rows as Record<string, any>[] : []
+        if (rows.length === 0) {
+          if (!hasMore) break
+          continue
+        }
+        const mapped = chatService.mapRowsToMessagesForApi(rows, sessionId)
+        for (const message of mapped) {
+          const createTime = Number(message.createTime || 0)
+          if (createTime < startTime || createTime > endTime) continue
+          messages.push(message)
+          if (messages.length >= MAX_MESSAGES_PER_SUMMARY) break
+        }
+      }
+    } finally {
+      await wcdbService.closeMessageCursor(cursor).catch(() => {})
+    }
+
+    return messages.sort((a, b) => {
+      if (a.createTime !== b.createTime) return a.createTime - b.createTime
+      if (a.sortSeq !== b.sortSeq) return a.sortSeq - b.sortSeq
+      return a.localId - b.localId
+    })
+  }
+
+  private normalizeMessageText(message: Message): string {
+    const parsedContent = String(message.parsedContent || '').replace(/\s+/g, ' ').trim()
+    const quotedContent = String(message.quotedContent || '').replace(/\s+/g, ' ').trim()
+    const quotedSender = String(message.quotedSender || '').replace(/\s+/g, ' ').trim()
+    let text = parsedContent
+    if (quotedContent) {
+      const quote = quotedSender ? `${quotedSender}：${quotedContent}` : quotedContent
+      text = text && text !== '[引用消息]' ? `${text} [引用 ${quote}]` : `[引用 ${quote}]`
+    }
+    if (!text) {
+      text = String(message.linkTitle || message.fileName || message.appMsgDesc || '').replace(/\s+/g, ' ').trim()
+    }
+    if (!text) return ''
+    if (/^<\?xml|^<msg\b|^<appmsg\b|^<img\b|^<emoji\b/i.test(text)) return ''
+    return text
+  }
+
+  private async buildTranscript(sessionId: string, messages: Message[]): Promise<{ transcript: string; readableMessages: Message[] }> {
+    const readableMessages = messages.filter((message) => this.normalizeMessageText(message))
+    const senderIds = Array.from(new Set(
+      readableMessages
+        .map((message) => String(message.senderUsername || '').trim())
+        .filter(Boolean)
+    ))
+    const contacts = senderIds.length > 0
+      ? (await chatService.enrichSessionsContactInfo(senderIds).catch(() => null))?.contacts || {}
+      : {}
+    const myWxid = String(this.config.getMyWxidCleaned() || '').trim()
+
+    const lines = readableMessages.map((message) => {
+      const senderUsername = String(message.senderUsername || '').trim()
+      const senderName = message.isSend === 1 || (senderUsername && myWxid && senderUsername === myWxid)
+        ? '我'
+        : (contacts[senderUsername]?.displayName || senderUsername || '未知成员')
+      return `${formatTimestamp(message.createTime)} ${senderName}：${this.normalizeMessageText(message)}`
+    })
+
+    return {
+      transcript: lines.join('\n'),
+      readableMessages
+    }
+  }
+
+  private async generateSummaryForPeriod(params: {
+    sessionId: string
+    displayName: string
+    avatarUrl?: string
+    periodStart: number
+    periodEnd: number
+    triggerType: GroupSummaryTriggerType
+  }): Promise<GroupSummaryTriggerResult> {
+    const { apiBaseUrl, apiKey, model } = this.getSharedAiModelConfig()
+    if (!apiBaseUrl || !apiKey) {
+      return { success: false, message: '请先填写通用 AI 模型配置（API 地址和 Key）' }
+    }
+
+    try {
+      const messages = await this.readMessagesInPeriod(params.sessionId, params.periodStart, params.periodEnd)
+      const { transcript, readableMessages } = await this.buildTranscript(params.sessionId, messages)
+      if (readableMessages.length < MIN_SUMMARY_MESSAGES) {
+        return {
+          success: true,
+          skipped: true,
+          skippedReason: 'message_count_too_low',
+          message: `该时段可总结消息少于 ${MIN_SUMMARY_MESSAGES} 条，已跳过`
+        }
+      }
+
+      const customPrompt = String(this.config.get('aiGroupSummarySystemPrompt') || '').trim()
+      const systemPrompt = customPrompt || DEFAULT_GROUP_SUMMARY_SYSTEM_PROMPT
+      const userPrompt = `群聊：${params.displayName}
+总结时段：${formatTimestamp(params.periodStart)} 至 ${formatTimestamp(params.periodEnd)}
+消息数量：${readableMessages.length}
+
+群聊记录：
+${transcript}
+
+请只输出指定 JSON。`
+      const endpoint = buildApiUrl(apiBaseUrl, '/chat/completions')
+      const requestMessages = [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt }
+      ]
+
+      let rawOutput = ''
+      let responseFormatJson = true
+      let responseFormatFallback = false
+      let responseFormatFallbackReason = ''
+      const startedAt = Date.now()
+      try {
+        rawOutput = await callChatCompletions(apiBaseUrl, apiKey, model, requestMessages, { responseFormatJson: true })
+      } catch (error) {
+        if (!shouldFallbackJsonMode(error)) throw error
+        responseFormatJson = false
+        responseFormatFallback = true
+        responseFormatFallbackReason = (error as Error).message || 'response_format 不受支持'
+        rawOutput = await callChatCompletions(apiBaseUrl, apiKey, model, requestMessages)
+      }
+
+      let topics: GroupSummaryTopic[]
+      let finalSummary: string
+      try {
+        topics = parseTopics(rawOutput)
+        finalSummary = buildSummaryText(topics)
+      } catch {
+        topics = [fallbackTopicFromRaw(rawOutput)]
+        finalSummary = buildSummaryText(topics)
+      }
+
+      const log: GroupSummaryLog = {
+        endpoint,
+        model,
+        temperature: API_TEMPERATURE,
+        triggerType: params.triggerType,
+        periodStart: params.periodStart,
+        periodEnd: params.periodEnd,
+        messageCount: messages.length,
+        readableMessageCount: readableMessages.length,
+        systemPrompt,
+        userPrompt,
+        rawOutput,
+        finalSummary,
+        durationMs: Date.now() - startedAt,
+        createdAt: Date.now(),
+        responseFormatJson,
+        responseFormatFallback,
+        responseFormatFallbackReason,
+        parsedTopics: topics
+      }
+
+      const record = groupSummaryRecordService.addRecord({
+        sessionId: params.sessionId,
+        displayName: params.displayName,
+        avatarUrl: params.avatarUrl,
+        triggerType: params.triggerType,
+        periodStart: params.periodStart,
+        periodEnd: params.periodEnd,
+        messageCount: messages.length,
+        readableMessageCount: readableMessages.length,
+        topics,
+        summaryText: finalSummary,
+        rawOutput,
+        log
+      })
+
+      return { success: true, message: '群聊总结已生成', recordId: record.id, record }
+    } catch (error) {
+      return { success: false, message: `生成失败：${(error as Error).message || String(error)}` }
+    }
+  }
+
+  private async generateSummariesForPeriods(params: {
+    sessionId: string
+    displayName: string
+    avatarUrl?: string
+    periods: Array<{ start: number; end: number }>
+    triggerType: GroupSummaryTriggerType
+  }): Promise<GroupSummaryDayTriggerResult> {
+    const records: GroupSummaryRecordSummary[] = []
+    let skipped = 0
+    let failed = 0
+    let firstError = ''
+
+    for (const period of params.periods) {
+      const result = await this.generateSummaryForPeriod({
+        sessionId: params.sessionId,
+        displayName: params.displayName,
+        avatarUrl: params.avatarUrl,
+        periodStart: period.start,
+        periodEnd: period.end,
+        triggerType: params.triggerType
+      })
+      if (result.success && result.record) {
+        records.push(result.record)
+        continue
+      }
+      if (result.success && result.skipped) {
+        skipped += 1
+        continue
+      }
+      failed += 1
+      if (!firstError) firstError = result.message
+    }
+
+    const generated = records.length
+    const parts = [`生成 ${generated} 段`, `跳过 ${skipped} 段`]
+    if (failed > 0) parts.push(`失败 ${failed} 段`)
+    const message = failed > 0 && generated === 0 && skipped === 0
+      ? (firstError || '群聊总结生成失败')
+      : `群聊总结完成：${parts.join('，')}`
+
+    return {
+      success: generated > 0 || skipped > 0 || failed === 0,
+      message,
+      generated,
+      skipped,
+      records
+    }
+  }
+}
+
+export const groupSummaryService = new GroupSummaryService()
--- a/electron/services/httpService.ts
+++ b/electron/services/httpService.ts
@@ -26,7 +26,7 @@ interface ChatLabHeader {
 interface ChatLabMeta {
  name: string
  platform: string
-  type: 'group' | 'private'
+  type: ApiSessionType
  groupId?: string
  groupAvatar?: string
  ownerId?: string
@@ -52,6 +52,20 @@ interface ChatLabMessage {
  mediaPath?: string
 }

+interface ApiQuoteSnapshot {
+  platformMessageId?: string
+  sender?: string
+  accountName?: string
+  content?: string
+  type?: number
+}
+
+interface ApiQuoteInfo {
+  replyText?: string
+  replyToMessageId?: string
+  quote?: ApiQuoteSnapshot
+}
+
 interface ChatLabData {
  chatlab: ChatLabHeader
  meta: ChatLabMeta
@@ -68,6 +82,7 @@ interface ApiMediaOptions {
 }

 type MediaKind = 'image' | 'voice' | 'video' | 'emoji'
+type ApiSessionType = 'group' | 'private' | 'channel' | 'other'

 interface ApiExportedMedia {
  kind: MediaKind
@@ -76,6 +91,12 @@ interface ApiExportedMedia {
  relativePath: string
 }

+interface MessagePushReplayEvent {
+  id: number
+  body: string
+  createdAt: number
+}
+
 // ChatLab 消息类型映射
 const ChatLabType = {
  TEXT: 0,
@@ -107,8 +128,12 @@ class HttpService {
  private running: boolean = false
  private connections: Set<import('net').Socket> = new Set()
  private messagePushClients: Set<http.ServerResponse> = new Set()
+  private messagePushReplayBuffer: MessagePushReplayEvent[] = []
  private messagePushHeartbeatTimer: ReturnType<typeof setInterval> | null = null
  private connectionMutex: boolean = false
+  private messagePushEventId = 0
+  private readonly messagePushReplayLimit = 1000
+  private readonly messagePushReplayTtlMs = 10 * 60 * 1000

  constructor() {
    this.configService = ConfigService.getInstance()
@@ -178,6 +203,7 @@ class HttpService {
          } catch {}
        }
        this.messagePushClients.clear()
+        this.messagePushReplayBuffer = []
        if (this.messagePushHeartbeatTimer) {
          clearInterval(this.messagePushHeartbeatTimer)
          this.messagePushHeartbeatTimer = null
@@ -232,9 +258,57 @@ class HttpService {
    return `http://${this.host}:${this.port}/api/v1/push/messages`
  }

+  private nextMessagePushEventId(): number {
+    this.messagePushEventId += 1
+    if (!Number.isSafeInteger(this.messagePushEventId) || this.messagePushEventId <= 0) {
+      this.messagePushEventId = 1
+    }
+    return this.messagePushEventId
+  }
+
+  private rememberMessagePushEvent(id: number, body: string): void {
+    this.pruneMessagePushReplayBuffer()
+    this.messagePushReplayBuffer.push({ id, body, createdAt: Date.now() })
+    if (this.messagePushReplayBuffer.length > this.messagePushReplayLimit) {
+      this.messagePushReplayBuffer.splice(0, this.messagePushReplayBuffer.length - this.messagePushReplayLimit)
+    }
+  }
+
+  private pruneMessagePushReplayBuffer(): void {
+    const cutoff = Date.now() - this.messagePushReplayTtlMs
+    while (this.messagePushReplayBuffer.length > 0 && this.messagePushReplayBuffer[0].createdAt < cutoff) {
+      this.messagePushReplayBuffer.shift()
+    }
+  }
+
+  private parseMessagePushLastEventId(req: http.IncomingMessage, url?: URL): number {
+    const queryValue = url?.searchParams.get('lastEventId') || url?.searchParams.get('last_event_id') || ''
+    const headerValue = Array.isArray(req.headers['last-event-id'])
+      ? req.headers['last-event-id'][0]
+      : req.headers['last-event-id']
+    const parsed = Number.parseInt(String(queryValue || headerValue || '0').trim(), 10)
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 0
+  }
+
+  private replayMessagePushEvents(res: http.ServerResponse, lastEventId: number): void {
+    this.pruneMessagePushReplayBuffer()
+    const events = lastEventId > 0
+      ? this.messagePushReplayBuffer.filter((event) => event.id > lastEventId)
+      : this.messagePushReplayBuffer
+
+    for (const event of events) {
+      if (res.writableEnded || res.destroyed) return
+      res.write(event.body)
+    }
+  }
+
  broadcastMessagePush(payload: Record<string, unknown>): void {
-    if (!this.running || this.messagePushClients.size === 0) return
-    const eventBody = `event: message.new\ndata: ${JSON.stringify(payload)}\n\n`
+    if (!this.running) return
+    const eventId = this.nextMessagePushEventId()
+    const eventName = this.getMessagePushEventName(payload)
+    const eventBody = `id: ${eventId}\nevent: ${eventName}\ndata: ${JSON.stringify(payload)}\n\n`
+    this.rememberMessagePushEvent(eventId, eventBody)
+    if (this.messagePushClients.size === 0) return

    for (const client of Array.from(this.messagePushClients)) {
      try {
@@ -250,6 +324,11 @@ class HttpService {
    }
  }

+  private getMessagePushEventName(payload: Record<string, unknown>): string {
+    const eventName = String(payload?.event || '').trim()
+    return /^[a-z0-9._-]+$/i.test(eventName) ? eventName : 'message.new'
+  }
+
  async autoStart(): Promise<void> {
    const enabled = this.configService.get('httpApiEnabled')
    if (enabled) {
@@ -365,11 +444,22 @@ class HttpService {
            if (pathname === '/health' || pathname === '/api/v1/health') {
                this.sendJson(res, { status: 'ok' })
            } else if (pathname === '/api/v1/push/messages') {
-                this.handleMessagePushStream(req, res)
+                this.handleMessagePushStream(req, res, url)
            } else if (pathname === '/api/v1/messages') {
                await this.handleMessages(url, res)
            } else if (pathname === '/api/v1/sessions') {
                await this.handleSessions(url, res)
+            } else if (
+                pathname.startsWith('/api/v1/sessions/') &&
+                pathname.endsWith('/messages')
+            ) {
+                const parts = pathname.split('/')
+                const sessionId = decodeURIComponent(parts[4] || '')
+                if (!sessionId) {
+                    this.sendError(res, 400, 'Missing session ID')
+                } else {
+                    await this.handlePullMessages(sessionId, url, res)
+                }
            } else if (pathname === '/api/v1/contacts') {
                await this.handleContacts(url, res)
            } else if (pathname === '/api/v1/group-members') {
@@ -429,7 +519,7 @@ class HttpService {
    }, 25000)
  }

-  private handleMessagePushStream(req: http.IncomingMessage, res: http.ServerResponse): void {
+  private handleMessagePushStream(req: http.IncomingMessage, res: http.ServerResponse, url: URL): void {
    if (this.configService.get('messagePushEnabled') !== true) {
      this.sendError(res, 403, 'Message push is disabled')
      return
@@ -442,9 +532,10 @@ class HttpService {
      'X-Accel-Buffering': 'no'
    })
    res.flushHeaders?.()
-    res.write(`event: ready\ndata: ${JSON.stringify({ success: true, stream: this.getMessagePushStreamUrl() })}\n\n`)

    this.messagePushClients.add(res)
+    res.write(`event: ready\ndata: ${JSON.stringify({ success: true, stream: this.getMessagePushStreamUrl() })}\n\n`)
+    this.replayMessagePushEvents(res, this.parseMessagePushLastEventId(req, url))

    const cleanup = () => {
      this.messagePushClients.delete(res)
@@ -485,11 +576,20 @@ class HttpService {
    const contentType = mimeTypes[ext] || 'application/octet-stream'

    try {
-      const fileBuffer = fs.readFileSync(fullPath)
+      const stat = fs.statSync(fullPath)
      res.setHeader('Content-Type', contentType)
-      res.setHeader('Content-Length', fileBuffer.length)
+      res.setHeader('Content-Length', stat.size)
      res.writeHead(200)
-      res.end(fileBuffer)
+
+      const stream = fs.createReadStream(fullPath)
+      stream.on('error', () => {
+        if (!res.headersSent) {
+          this.sendError(res, 500, 'Failed to read media file')
+        } else {
+          try { res.destroy() } catch {}
+        }
+      })
+      stream.pipe(res)
    } catch (e) {
      this.sendError(res, 500, 'Failed to read media file')
    }
@@ -505,27 +605,29 @@ class HttpService {
    limit: number,
    startTime: number,
    endTime: number,
-    ascending: boolean
+    ascending: boolean,
+    useLiteMapping: boolean = true
  ): Promise<{ success: boolean; messages?: Message[]; hasMore?: boolean; error?: string }> {
    try {
-      // 使用固定 batch 大小（与 limit 相同或最多 500）来减少循环次数
-      const batchSize = Math.min(limit, 500)
+      // 深分页时放大 batch，避免 offset 很大时出现大量小批次循环。
+      const batchSize = Math.min(2000, Math.max(500, limit))
      const beginTimestamp = startTime > 10000000000 ? Math.floor(startTime / 1000) : startTime
      const endTimestamp = endTime > 10000000000 ? Math.floor(endTime / 1000) : endTime

-      const cursorResult = await wcdbService.openMessageCursor(talker, batchSize, ascending, beginTimestamp, endTimestamp)
+      const cursorResult = await wcdbService.openMessageCursorLite(talker, batchSize, ascending, beginTimestamp, endTimestamp)
      if (!cursorResult.success || !cursorResult.cursor) {
        return { success: false, error: cursorResult.error || '打开消息游标失败' }
      }

      const cursor = cursorResult.cursor
      try {
-        const allRows: Record<string, any>[] = []
+        const collectedRows: Record<string, any>[] = []
        let hasMore = true
        let skipped = 0
+        let reachedLimit = false

        // 循环获取消息，处理 offset 跳过 + limit 累积
-        while (allRows.length < limit && hasMore) {
+        while (collectedRows.length < limit && hasMore) {
          const batch = await wcdbService.fetchMessageBatch(cursor)
          if (!batch.success || !batch.rows || batch.rows.length === 0) {
            hasMore = false
@@ -546,12 +648,20 @@ class HttpService {
            skipped = offset
          }

-          allRows.push(...rows)
+          const remainingCapacity = limit - collectedRows.length
+          if (rows.length > remainingCapacity) {
+            collectedRows.push(...rows.slice(0, remainingCapacity))
+            reachedLimit = true
+            break
+          }
+
+          collectedRows.push(...rows)
        }

-        const trimmedRows = allRows.slice(0, limit)
-        const finalHasMore = hasMore || allRows.length > limit
-        const messages = chatService.mapRowsToMessagesForApi(trimmedRows)
+        const finalHasMore = hasMore || reachedLimit
+        const messages = useLiteMapping
+          ? chatService.mapRowsToMessagesLiteForApi(collectedRows)
+          : chatService.mapRowsToMessagesForApi(collectedRows)
        await this.backfillMissingSenderUsernames(talker, messages)
        return { success: true, messages, hasMore: finalHasMore }
      } finally {
@@ -578,33 +688,71 @@ class HttpService {
    const targets = messages.filter((msg) => !String(msg.senderUsername || '').trim())
    if (targets.length === 0) return

-    const myWxid = (this.configService.get('myWxid') || '').trim()
-    for (const msg of targets) {
-      const localId = Number(msg.localId || 0)
-      if (Number.isFinite(localId) && localId > 0) {
-        try {
-          const detail = await wcdbService.getMessageById(talker, localId)
-          if (detail.success && detail.message) {
-            const hydrated = chatService.mapRowsToMessagesForApi([detail.message])[0]
-            if (hydrated?.senderUsername) {
-              msg.senderUsername = hydrated.senderUsername
-            }
-            if ((msg.isSend === null || msg.isSend === undefined) && hydrated?.isSend !== undefined) {
-              msg.isSend = hydrated.isSend
-            }
-            if (!msg.rawContent && hydrated?.rawContent) {
-              msg.rawContent = hydrated.rawContent
-            }
-          }
-        } catch (error) {
-          console.warn('[HttpService] backfill sender failed:', error)
+    const myWxid = (this.configService.getMyWxidCleaned() || '').trim()
+    const MAX_DETAIL_BACKFILL = 120
+    if (targets.length > MAX_DETAIL_BACKFILL) {
+      for (const msg of targets) {
+        if (!msg.senderUsername && msg.isSend === 1 && myWxid) {
+          msg.senderUsername = myWxid
        }
      }
+      return
+    }

-      if (!msg.senderUsername && msg.isSend === 1 && myWxid) {
-        msg.senderUsername = myWxid
+    const queue = [...targets]
+    const workerCount = Math.max(1, Math.min(6, queue.length))
+    const state = {
+      attempted: 0,
+      hydrated: 0,
+      consecutiveMiss: 0
+    }
+    const MAX_DETAIL_LOOKUPS = 80
+    const MAX_CONSECUTIVE_MISS = 36
+    const runWorker = async (): Promise<void> => {
+      while (queue.length > 0) {
+        if (state.attempted >= MAX_DETAIL_LOOKUPS) break
+        if (state.consecutiveMiss >= MAX_CONSECUTIVE_MISS && state.hydrated <= 0) break
+        const msg = queue.shift()
+        if (!msg) break
+
+        const localId = Number(msg.localId || 0)
+        if (Number.isFinite(localId) && localId > 0) {
+          state.attempted += 1
+          try {
+            const detail = await wcdbService.getMessageById(talker, localId)
+            if (detail.success && detail.message) {
+              const hydrated = chatService.mapRowsToMessagesForApi([detail.message])[0]
+              if (hydrated?.senderUsername) {
+                msg.senderUsername = hydrated.senderUsername
+              }
+              if ((msg.isSend === null || msg.isSend === undefined) && hydrated?.isSend !== undefined) {
+                msg.isSend = hydrated.isSend
+              }
+              if (!msg.rawContent && hydrated?.rawContent) {
+                msg.rawContent = hydrated.rawContent
+              }
+              if (msg.senderUsername) {
+                state.hydrated += 1
+                state.consecutiveMiss = 0
+              } else {
+                state.consecutiveMiss += 1
+              }
+            } else {
+              state.consecutiveMiss += 1
+            }
+          } catch (error) {
+            console.warn('[HttpService] backfill sender failed:', error)
+            state.consecutiveMiss += 1
+          }
+        }
+
+        if (!msg.senderUsername && msg.isSend === 1 && myWxid) {
+          msg.senderUsername = myWxid
+        }
      }
    }
+
+    await Promise.all(Array.from({ length: workerCount }, () => runWorker()))
  }

  private parseBooleanParam(url: URL, keys: string[], defaultValue: boolean = false): boolean {
@@ -648,11 +796,22 @@ class HttpService {
    }
  }

+  private getApiSessionType(username: string): ApiSessionType {
+    const normalized = String(username || '').trim()
+    const lowered = normalized.toLowerCase()
+    if (!normalized) return 'other'
+    if (lowered.endsWith('@chatroom')) return 'group'
+    if (lowered.startsWith('gh_')) return 'channel'
+    if (lowered.includes('@openim')) return 'channel'
+    if (lowered.startsWith('weixin') && lowered !== 'weixin') return 'channel'
+    return 'private'
+  }
+
  private async handleMessages(url: URL, res: http.ServerResponse): Promise<void> {
    const talker = (url.searchParams.get('talker') || '').trim()
    const limit = this.parseIntParam(url.searchParams.get('limit'), 100, 1, 10000)
    const offset = this.parseIntParam(url.searchParams.get('offset'), 0, 0, Number.MAX_SAFE_INTEGER)
-    const keyword = (url.searchParams.get('keyword') || '').trim().toLowerCase()
+    const keyword = (url.searchParams.get('keyword') || '').trim()
    const startParam = url.searchParams.get('start')
    const endParam = url.searchParams.get('end')
    const chatlab = this.parseBooleanParam(url, ['chatlab'], false)
@@ -672,26 +831,41 @@ class HttpService {

    const startTime = this.parseTimeParam(startParam)
    const endTime = this.parseTimeParam(endParam, true)
-    const queryOffset = keyword ? 0 : offset
-    const queryLimit = keyword ? 10000 : limit
-
-    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
-    }
-
-    let messages = result.messages
-    let hasMore = result.hasMore === true
+    let messages: Message[] = []
+    let hasMore = false

    if (keyword) {
-      const filtered = messages.filter((msg) => {
-        const content = (msg.parsedContent || msg.rawContent || '').toLowerCase()
-        return content.includes(keyword)
-      })
-      const endIndex = offset + limit
-      hasMore = filtered.length > endIndex
-      messages = filtered.slice(offset, endIndex)
+      const searchLimit = Math.max(1, limit) + 1
+      const searchResult = await chatService.searchMessages(
+        keyword,
+        talker,
+        searchLimit,
+        offset,
+        startTime,
+        endTime
+      )
+      if (!searchResult.success || !searchResult.messages) {
+        this.sendError(res, 500, searchResult.error || 'Failed to search messages')
+        return
+      }
+      hasMore = searchResult.messages.length > limit
+      messages = hasMore ? searchResult.messages.slice(0, limit) : searchResult.messages
+    } else {
+      const result = await this.fetchMessagesBatch(
+        talker,
+        offset,
+        limit,
+        startTime,
+        endTime,
+        false,
+        !mediaOptions.enabled
+      )
+      if (!result.success || !result.messages) {
+        this.sendError(res, 500, result.error || 'Failed to get messages')
+        return
+      }
+      messages = result.messages
+      hasMore = result.hasMore === true
    }

    const mediaMap = mediaOptions.enabled
@@ -736,6 +910,7 @@ class HttpService {
  private async handleSessions(url: URL, res: http.ServerResponse): Promise<void> {
    const keyword = (url.searchParams.get('keyword') || '').trim()
    const limit = this.parseIntParam(url.searchParams.get('limit'), 100, 1, 10000)
+    const format = (url.searchParams.get('format') || '').trim().toLowerCase()

    try {
      const sessions = await chatService.getSessions()
@@ -753,9 +928,22 @@ class HttpService {
        )
      }

-      // 应用 limit
      const limitedSessions = filteredSessions.slice(0, limit)

+      if (format === 'chatlab') {
+        this.sendJson(res, {
+          sessions: limitedSessions.map(s => ({
+            id: s.username,
+            name: s.displayName || s.username,
+            platform: 'wechat',
+            type: this.getApiSessionType(s.username),
+            messageCount: s.messageCountHint || undefined,
+            lastMessageAt: s.lastTimestamp
+          }))
+        })
+        return
+      }
+
      this.sendJson(res, {
        success: true,
        count: limitedSessions.length,
@@ -763,6 +951,7 @@ class HttpService {
          username: s.username,
          displayName: s.displayName,
          type: s.type,
+          sessionType: this.getApiSessionType(s.username),
          lastTimestamp: s.lastTimestamp,
          unreadCount: s.unreadCount
        }))
@@ -772,6 +961,53 @@ class HttpService {
    }
  }

+  /**
+   * ChatLab Pull: GET /api/v1/sessions/:id/messages?since=&limit=&offset=&end=
+   * 返回 ChatLab 标准格式 + sync 分页块
+   */
+  private async handlePullMessages(sessionId: string, url: URL, res: http.ServerResponse): Promise<void> {
+    const PULL_MAX_LIMIT = 5000
+    const limit = this.parseIntParam(url.searchParams.get('limit'), PULL_MAX_LIMIT, 1, PULL_MAX_LIMIT)
+    const offset = this.parseIntParam(url.searchParams.get('offset'), 0, 0, Number.MAX_SAFE_INTEGER)
+    const sinceParam = url.searchParams.get('since')
+    const endParam = url.searchParams.get('end')
+
+    const startTime = sinceParam ? this.parseTimeParam(sinceParam) : 0
+    const endTime = endParam ? this.parseTimeParam(endParam, true) : 0
+
+    try {
+      const result = await this.fetchMessagesBatch(sessionId, offset, limit, startTime, endTime, true, true)
+      if (!result.success || !result.messages) {
+        this.sendError(res, 500, result.error || 'Failed to get messages')
+        return
+      }
+
+      const messages = result.messages
+      const hasMore = result.hasMore === true
+
+      const displayNames = await this.getDisplayNames([sessionId])
+      const talkerName = displayNames[sessionId] || sessionId
+      const chatLabData = await this.convertToChatLab(messages, sessionId, talkerName)
+
+      const lastTimestamp = messages.length > 0
+        ? messages[messages.length - 1].createTime
+        : undefined
+
+      this.sendJson(res, {
+        ...chatLabData,
+        sync: {
+          hasMore,
+          nextSince: hasMore && lastTimestamp ? lastTimestamp : undefined,
+          nextOffset: hasMore ? offset + messages.length : undefined,
+          watermark: Math.floor(Date.now() / 1000)
+        }
+      })
+    } catch (error) {
+      console.error('[HttpService] handlePullMessages error:', error)
+      this.sendError(res, 500, String(error))
+    }
+  }
+
  /**
   * 处理联系人查询
   * GET /api/v1/contacts?keyword=xxx&limit=100
@@ -1323,7 +1559,7 @@ class HttpService {
          talker,
          String(msg.localId),
          msg.createTime || undefined,
-          msg.serverId || undefined
+          this.getMessageServerId(msg) || undefined
        )
        if (result.success && result.data) {
          const fileName = `voice_${msg.localId}.wav`
@@ -1377,15 +1613,17 @@ class HttpService {
  }

  private toApiMessage(msg: Message, media?: ApiExportedMedia): Record<string, any> {
-    return {
+    const serverId = this.getMessageServerId(msg)
+    const quoteInfo = this.extractApiQuoteInfo(msg)
+    const apiMessage: Record<string, any> = {
      localId: msg.localId,
-      serverId: msg.serverId,
+      serverId: serverId || '0',
      localType: msg.localType,
      createTime: msg.createTime,
      sortSeq: msg.sortSeq,
      isSend: msg.isSend,
      senderUsername: msg.senderUsername,
-      content: this.getMessageContent(msg),
+      content: this.getMessageContent(msg, quoteInfo),
      rawContent: msg.rawContent,
      parsedContent: msg.parsedContent,
      mediaType: media?.kind,
@@ -1393,6 +1631,36 @@ class HttpService {
      mediaUrl: media ? `http://${this.host}:${this.port}/api/v1/media/${media.relativePath}` : undefined,
      mediaLocalPath: media?.fullPath
    }
+
+    if (quoteInfo?.replyToMessageId) {
+      apiMessage.replyToMessageId = quoteInfo.replyToMessageId
+    }
+    if (quoteInfo?.quote && Object.keys(quoteInfo.quote).length > 0) {
+      apiMessage.quote = quoteInfo.quote
+    }
+
+    return apiMessage
+  }
+
+  private getMessageServerId(msg: Message): string {
+    const raw = this.normalizeUnsignedIntToken(msg.serverIdRaw)
+    if (raw && raw !== '0') return raw
+
+    const fallback = this.normalizeUnsignedIntToken(msg.serverId)
+    return fallback && fallback !== '0' ? fallback : ''
+  }
+
+  private normalizeUnsignedIntToken(value: unknown): string {
+    if (value === null || value === undefined) return ''
+    const text = String(value).trim()
+    if (!text) return ''
+    if (/^\d+$/.test(text)) {
+      return text.replace(/^0+(?=\d)/, '')
+    }
+
+    const numeric = Number(value)
+    if (!Number.isFinite(numeric) || numeric <= 0) return ''
+    return String(Math.floor(numeric))
  }

  /**
@@ -1587,7 +1855,7 @@ class HttpService {
    mediaMap: Map<number, ApiExportedMedia> = new Map()
  ): Promise<ChatLabData> {
    const isGroup = talkerId.endsWith('@chatroom')
-    const myWxid = this.configService.get('myWxid') || ''
+    const myWxid = this.configService.getMyWxidCleaned() || ''
    const normalizedMyWxid = this.normalizeAccountId(myWxid).toLowerCase()

    // 收集所有发送者
@@ -1651,17 +1919,22 @@ class HttpService {
    // 转换消息
    const chatLabMessages: ChatLabMessage[] = messages.map(msg => {
      const senderInfo = this.resolveChatLabSenderInfo(msg, talkerId, talkerName, myWxid, isGroup, senderNames, groupNicknamesMap)
+      const quoteInfo = this.extractApiQuoteInfo(msg)

-      return {
+      const chatLabMessage: ChatLabMessage = {
        sender: senderInfo.sender,
        accountName: senderInfo.accountName,
        groupNickname: senderInfo.groupNickname,
        timestamp: msg.createTime,
        type: this.mapMessageType(msg.localType, msg),
-        content: this.getMessageContent(msg),
-        platformMessageId: msg.serverId ? String(msg.serverId) : undefined,
+        content: this.getMessageContent(msg, quoteInfo),
+        platformMessageId: this.getMessageServerId(msg) || undefined,
        mediaPath: mediaMap.get(msg.localId) ? `http://${this.host}:${this.port}/api/v1/media/${mediaMap.get(msg.localId)!.relativePath}` : undefined
      }
+      if (quoteInfo?.replyToMessageId) {
+        chatLabMessage.replyToMessageId = quoteInfo.replyToMessageId
+      }
+      return chatLabMessage
    })

    return {
@@ -1673,7 +1946,7 @@ class HttpService {
      meta: {
        name: talkerName,
        platform: 'wechat',
-        type: isGroup ? 'group' : 'private',
+        type: this.getApiSessionType(talkerId),
        groupId: isGroup ? talkerId : undefined,
        groupAvatar: isGroup ? sessionAvatarInfo?.avatarUrl : undefined,
        ownerId: myWxid || undefined
@@ -1750,7 +2023,7 @@ class HttpService {
  }

  private extractType49Subtype(rawContent: string): string {
-    const content = String(rawContent || '')
+    const content = this.normalizeAppMessageContent(String(rawContent || ''))
    if (!content) return ''

    const appmsgMatch = /<appmsg[\s\S]*?>([\s\S]*?)<\/appmsg>/i.exec(content)
@@ -1804,9 +2077,9 @@ class HttpService {
    }
  }

-  private getType49Content(msg: Message): string {
+  private getType49Content(msg: Message, quoteInfo?: ApiQuoteInfo): string {
    const subtype = this.resolveType49Subtype(msg)
-    const title = msg.linkTitle || msg.fileName || ''
+    const title = msg.linkTitle || msg.fileName || this.extractAppMessageTitle(msg.rawContent) || ''

    switch (subtype) {
      case '5':
@@ -1820,7 +2093,7 @@ class HttpService {
      case '36':
        return title ? `[小程序] ${title}` : '[小程序]'
      case '57':
-        return msg.parsedContent || title || '[引用消息]'
+        return msg.parsedContent || quoteInfo?.replyText || title || '[引用消息]'
      case '2000':
        return title ? `[转账] ${title}` : '[转账]'
      case '2001':
@@ -1835,9 +2108,19 @@ class HttpService {
  /**
   * 获取消息内容
   */
-  private getMessageContent(msg: Message): string | null {
+  private getMessageContent(msg: Message, quoteInfo?: ApiQuoteInfo): string | null {
+    const normalizeTextContent = (value: string | null | undefined): string | null => {
+      const text = String(value || '')
+      if (!text) return null
+      return text.replace(/^[\s]*([a-zA-Z0-9_@-]+):(?!\/\/)(?:\s*(?:\r?\n|<br\s*\/?>)\s*|\s*)/i, '').trim()
+    }
+
    if (msg.localType === 49) {
-      return this.getType49Content(msg)
+      return this.getType49Content(msg, quoteInfo)
+    }
+
+    if (this.isReplyMessage(msg, quoteInfo)) {
+      return msg.parsedContent || quoteInfo?.replyText || this.extractAppMessageTitle(msg.rawContent) || '[引用消息]'
    }

    // 优先使用已解析的内容
@@ -1848,7 +2131,7 @@ class HttpService {
    // 根据类型返回占位符
    switch (msg.localType) {
      case 1:
-        return msg.rawContent || null
+        return normalizeTextContent(msg.parsedContent || msg.rawContent)
      case 3:
        return '[图片]'
      case 34:
@@ -1862,9 +2145,255 @@ class HttpService {
      case 48:
        return '[位置]'
      case 49:
-        return this.getType49Content(msg)
+        return this.getType49Content(msg, quoteInfo)
      default:
-        return msg.rawContent || null
+        return normalizeTextContent(msg.parsedContent || msg.rawContent) || null
+    }
+  }
+
+  private isReplyMessage(msg: Message, quoteInfo?: ApiQuoteInfo): boolean {
+    if (!quoteInfo?.replyToMessageId && !quoteInfo?.quote) return false
+    if (msg.localType === 244813135921) return true
+    if (msg.localType === 49 && this.resolveType49Subtype(msg) === '57') return true
+    return false
+  }
+
+  private extractApiQuoteInfo(msg: Message): ApiQuoteInfo | undefined {
+    const rawContent = String(msg.rawContent || msg.content || '')
+    if (!rawContent || !this.messageMayContainQuote(rawContent)) {
+      return undefined
+    }
+
+    const normalized = this.normalizeAppMessageContent(rawContent)
+    const referMsgXml = this.extractXmlBlock(normalized, 'refermsg')
+    if (!referMsgXml) return undefined
+
+    const replyToMessageId = this.extractReplyToMessageId(referMsgXml)
+    const referTypeRaw = this.extractXmlValue(referMsgXml, 'type')
+    const referContentRaw = this.extractXmlValue(referMsgXml, 'content')
+    const quoteContent = this.resolveQuotedContent(referMsgXml, referTypeRaw, referContentRaw)
+    const sender = this.resolveQuotedSender(referMsgXml)
+    const accountName = this.resolveQuotedAccountName(referMsgXml)
+    const quoteType = this.mapQuotedMessageType(referTypeRaw, referContentRaw)
+
+    const quote: ApiQuoteSnapshot = {}
+    if (replyToMessageId) quote.platformMessageId = replyToMessageId
+    if (sender) quote.sender = sender
+    if (accountName) quote.accountName = accountName
+    if (quoteContent) quote.content = quoteContent
+    if (quoteType !== undefined) quote.type = quoteType
+
+    const replyText = this.extractAppMessageTitle(normalized)
+
+    if (!replyToMessageId && Object.keys(quote).length === 0 && !replyText) {
+      return undefined
+    }
+
+    return {
+      replyText: replyText || undefined,
+      replyToMessageId,
+      quote: Object.keys(quote).length > 0 ? quote : undefined
+    }
+  }
+
+  private messageMayContainQuote(content: string): boolean {
+    return content.includes('<refermsg>') ||
+      content.includes('&lt;refermsg&gt;') ||
+      content.includes('<type>57</type>') ||
+      content.includes('&lt;type&gt;57&lt;/type&gt;')
+  }
+
+  private normalizeAppMessageContent(content: string): string {
+    return this.decodeHtmlEntities(String(content || ''))
+  }
+
+  private decodeHtmlEntities(text: string): string {
+    if (!text) return ''
+    return text
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&amp;/g, '&')
+      .replace(/&quot;/g, '"')
+      .replace(/&#39;/g, "'")
+      .replace(/&apos;/g, "'")
+  }
+
+  private extractXmlBlock(xml: string, tag: string): string {
+    if (!xml || !tag) return ''
+    const match = new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>`, 'i').exec(xml)
+    return match ? match[0] : ''
+  }
+
+  private extractXmlValue(xml: string, tag: string): string {
+    if (!xml || !tag) return ''
+    const match = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'i').exec(xml)
+    if (!match) return ''
+    return this.decodeHtmlEntities(match[1])
+      .replace(/<!\[CDATA\[/g, '')
+      .replace(/\]\]>/g, '')
+      .trim()
+  }
+
+  private extractAppMessageTitle(content: string): string {
+    const normalized = this.normalizeAppMessageContent(content || '')
+    if (!normalized) return ''
+    const appMsgXml = this.extractXmlBlock(normalized, 'appmsg')
+    return this.sanitizeQuotedContent(this.extractXmlValue(appMsgXml || normalized, 'title'))
+  }
+
+  private extractReplyToMessageId(referMsgXml: string): string | undefined {
+    const candidates = [
+      this.extractXmlValue(referMsgXml, 'svrid'),
+      this.extractXmlValue(referMsgXml, 'msgsvrid'),
+      this.extractXmlValue(referMsgXml, 'newmsgid'),
+      this.extractXmlValue(referMsgXml, 'msgid')
+    ]
+
+    for (const candidate of candidates) {
+      const normalized = this.normalizeUnsignedIntToken(candidate)
+      if (normalized && normalized !== '0') return normalized
+    }
+
+    return undefined
+  }
+
+  private resolveQuotedSender(referMsgXml: string): string | undefined {
+    const chatusr = this.extractXmlValue(referMsgXml, 'chatusr')
+    if (chatusr) return chatusr
+
+    const fromusr = this.extractXmlValue(referMsgXml, 'fromusr')
+    if (fromusr && !fromusr.endsWith('@chatroom')) return fromusr
+
+    return undefined
+  }
+
+  private resolveQuotedAccountName(referMsgXml: string): string | undefined {
+    const displayName = this.extractXmlValue(referMsgXml, 'displayname')
+    if (!displayName || this.looksLikeWxid(displayName)) return undefined
+    return displayName
+  }
+
+  private looksLikeWxid(value: string): boolean {
+    const text = String(value || '').trim().toLowerCase()
+    return Boolean(text) && (text.startsWith('wxid_') || /^wx[a-z0-9_-]{4,}$/.test(text))
+  }
+
+  private resolveQuotedContent(referMsgXml: string, referTypeRaw: string, referContentRaw: string): string {
+    const referType = String(referTypeRaw || '').trim()
+    switch (referType) {
+      case '1':
+        return this.extractPreferredQuotedText(referMsgXml)
+      case '3':
+        return '[图片]'
+      case '34':
+        return '[语音]'
+      case '43':
+        return '[视频]'
+      case '47':
+        return '[动画表情]'
+      case '42':
+        return '[名片]'
+      case '48':
+        return '[位置]'
+      case '49': {
+        const innerType = this.extractType49Subtype(referContentRaw)
+        if (innerType === '57') {
+          return this.extractAppMessageTitle(referContentRaw) || '[引用消息]'
+        }
+        if (innerType === '6') return '[文件]'
+        if (innerType === '19') return '[聊天记录]'
+        if (innerType === '33' || innerType === '36') return '[小程序]'
+        return '[链接]'
+      }
+      default:
+        if (!referContentRaw || referContentRaw.includes('wxid_')) return '[消息]'
+        return this.sanitizeQuotedContent(referContentRaw)
+    }
+  }
+
+  private extractPreferredQuotedText(referMsgXml: string): string {
+    const candidateTags = [
+      'selectedcontent',
+      'selectedtext',
+      'selectcontent',
+      'selecttext',
+      'quotecontent',
+      'quotetext',
+      'partcontent',
+      'parttext',
+      'excerpt',
+      'summary',
+      'preview',
+      'content'
+    ]
+
+    for (const tag of candidateTags) {
+      const value = this.sanitizeQuotedContent(this.extractXmlValue(referMsgXml, tag))
+      if (value) return value
+    }
+
+    return ''
+  }
+
+  private sanitizeQuotedContent(content: string): string {
+    if (!content) return ''
+    return String(content || '')
+      .replace(/wxid_[A-Za-z0-9_-]{3,}/g, '')
+      .replace(/^[\s:：\-]+/, '')
+      .replace(/[:：]{2,}/g, ':')
+      .replace(/^[\s:：\-]+/, '')
+      .replace(/\s+/g, ' ')
+      .trim()
+  }
+
+  private mapQuotedMessageType(referTypeRaw: string, referContentRaw: string): number | undefined {
+    const referType = String(referTypeRaw || '').trim()
+    switch (referType) {
+      case '1':
+        return ChatLabType.TEXT
+      case '3':
+        return ChatLabType.IMAGE
+      case '34':
+        return ChatLabType.VOICE
+      case '43':
+        return ChatLabType.VIDEO
+      case '47':
+        return ChatLabType.EMOJI
+      case '48':
+        return ChatLabType.LOCATION
+      case '42':
+        return ChatLabType.CONTACT
+      case '50':
+        return ChatLabType.CALL
+      case '10000':
+        return ChatLabType.SYSTEM
+      case '49':
+        return this.mapQuotedType49MessageType(referContentRaw)
+      default:
+        return undefined
+    }
+  }
+
+  private mapQuotedType49MessageType(content: string): number {
+    const subtype = this.extractType49Subtype(content)
+    switch (subtype) {
+      case '57':
+        return ChatLabType.REPLY
+      case '6':
+        return ChatLabType.FILE
+      case '19':
+        return ChatLabType.FORWARD
+      case '33':
+      case '36':
+        return ChatLabType.SHARE
+      case '2000':
+        return ChatLabType.TRANSFER
+      case '2001':
+        return ChatLabType.RED_PACKET
+      case '5':
+      case '49':
+      default:
+        return ChatLabType.LINK
    }
  }

--- a/electron/services/imageDecryptService.ts
+++ b/electron/services/imageDecryptService.ts
@@ -81,6 +81,7 @@ export class ImageDecryptService {
  private pending = new Map<string, Promise<DecryptResult>>()
  private updateFlags = new Map<string, boolean>()
  private nativeLogged = false
+  private runtimeConfig: { dbPath?: string; myWxid?: string; imageXorKey?: unknown; imageAesKey?: string } | null = null
  private datNameScanMissAt = new Map<string, number>()
  private readonly datNameScanMissTtlMs = 1200
  private readonly accountDirCache = new Map<string, string>()
@@ -99,13 +100,37 @@ export class ImageDecryptService {
    return this.shouldEmitImageEvents(payload)
  }

+  setRuntimeConfig(config: { dbPath?: string; myWxid?: string; imageXorKey?: unknown; imageAesKey?: string } | null): void {
+    this.runtimeConfig = config
+  }
+
+  private getConfiguredDbPath(): string {
+    return String(this.runtimeConfig?.dbPath || this.configService.get('dbPath') || '').trim()
+  }
+
+  private getConfiguredMyWxid(): string {
+    return String(this.runtimeConfig?.myWxid || this.configService.getMyWxidCleaned() || '').trim()
+  }
+
+  private getConfiguredImageKeys(): { xorKey: unknown; aesKey: string } {
+    const runtimeImageXorKey = this.runtimeConfig?.imageXorKey
+    const hasRuntimeXorKey = runtimeImageXorKey !== undefined && runtimeImageXorKey !== null && String(runtimeImageXorKey).trim() !== ''
+    const runtimeAesKey = String(this.runtimeConfig?.imageAesKey || '').trim()
+    if (hasRuntimeXorKey || runtimeAesKey) {
+      const fallback = this.configService.getImageKeysForCurrentWxid()
+      return {
+        xorKey: hasRuntimeXorKey ? runtimeImageXorKey : fallback.xorKey,
+        aesKey: runtimeAesKey || fallback.aesKey
+      }
+    }
+    return this.configService.getImageKeysForCurrentWxid()
+  }
+
  private logInfo(message: string, meta?: Record<string, unknown>): void {
    if (!this.configService.get('logEnabled')) return
    const timestamp = new Date().toISOString()
    const metaStr = meta ? ` ${JSON.stringify(meta)}` : ''
    const logLine = `[${timestamp}] [ImageDecrypt] ${message}${metaStr}\n`
-
-    // 只写入文件，不输出到控制台
    this.writeLog(logLine)
  }

@@ -115,11 +140,7 @@ export class ImageDecryptService {
    const errorStr = error ? ` Error: ${String(error)}` : ''
    const metaStr = meta ? ` ${JSON.stringify(meta)}` : ''
    const logLine = `[${timestamp}] [ImageDecrypt] ERROR: ${message}${errorStr}${metaStr}\n`
-
-    // 同时输出到控制台
    console.error(message, error, meta)
-
-    // 写入日志文件
    this.writeLog(logLine)
  }

@@ -143,7 +164,7 @@ export class ImageDecryptService {
    }
    for (const key of cacheKeys) {
      const cached = this.resolvedCache.get(key)
-      if (cached && existsSync(cached) && this.isImageFile(cached)) {
+      if (cached && existsSync(cached) && this.isUsableImageCacheFile(cached)) {
        const upgraded = !this.isHdPath(cached)
          ? await this.tryPromoteThumbnailCache(payload, key, cached)
          : null
@@ -161,7 +182,7 @@ export class ImageDecryptService {
        this.emitCacheResolved(payload, key, this.resolveEmitPath(finalPath, payload.preferFilePath))
        return { success: true, localPath, hasUpdate }
      }
-      if (cached && !this.isImageFile(cached)) {
+      if (cached && !this.isUsableImageCacheFile(cached)) {
        this.resolvedCache.delete(key)
      }
    }
@@ -219,7 +240,7 @@ export class ImageDecryptService {
    if (payload.force) {
      for (const key of cacheKeys) {
        const cached = this.resolvedCache.get(key)
-        if (cached && existsSync(cached) && this.isImageFile(cached) && this.isHdPath(cached)) {
+        if (cached && existsSync(cached) && this.isUsableImageCacheFile(cached) && this.isHdPath(cached)) {
          this.cacheResolvedPaths(cacheKey, payload.imageMd5, payload.imageDatName, cached)
          this.clearUpdateFlags(cacheKey, payload.imageMd5, payload.imageDatName)
          const localPath = this.resolveLocalPathForPayload(cached, payload.preferFilePath)
@@ -227,7 +248,7 @@ export class ImageDecryptService {
          this.emitDecryptProgress(payload, cacheKey, 'done', 100, 'done')
          return { success: true, localPath }
        }
-        if (cached && !this.isImageFile(cached)) {
+        if (cached && !this.isUsableImageCacheFile(cached)) {
          this.resolvedCache.delete(key)
        }
      }
@@ -236,7 +257,7 @@ export class ImageDecryptService {

    if (!payload.force) {
      const cached = this.resolvedCache.get(cacheKey)
-      if (cached && existsSync(cached) && this.isImageFile(cached)) {
+      if (cached && existsSync(cached) && this.isUsableImageCacheFile(cached)) {
        const upgraded = !this.isHdPath(cached)
          ? await this.tryPromoteThumbnailCache(payload, cacheKey, cached)
          : null
@@ -246,7 +267,7 @@ export class ImageDecryptService {
        this.emitDecryptProgress(payload, cacheKey, 'done', 100, 'done')
        return { success: true, localPath }
      }
-      if (cached && !this.isImageFile(cached)) {
+      if (cached && !this.isUsableImageCacheFile(cached)) {
        this.resolvedCache.delete(cacheKey)
      }
    }
@@ -272,8 +293,8 @@ export class ImageDecryptService {
    )
    if (normalizedList.length === 0) return

-    const wxid = this.configService.get('myWxid')
-    const dbPath = this.configService.get('dbPath')
+    const wxid = this.getConfiguredMyWxid()
+    const dbPath = this.getConfiguredDbPath()
    if (!wxid || !dbPath) return

    const accountDir = this.resolveAccountDir(dbPath, wxid)
@@ -300,8 +321,8 @@ export class ImageDecryptService {
    this.logInfo('开始解密图片', { md5: payload.imageMd5, datName: payload.imageDatName, force: payload.force, hardlinkOnly: payload.hardlinkOnly === true })
    this.emitDecryptProgress(payload, cacheKey, 'locating', 14, 'running')
    try {
-      const wxid = this.configService.get('myWxid')
-      const dbPath = this.configService.get('dbPath')
+      const wxid = this.getConfiguredMyWxid()
+      const dbPath = this.getConfiguredDbPath()
      if (!wxid || !dbPath) {
        this.logError('配置缺失', undefined, { wxid: !!wxid, dbPath: !!dbPath })
        this.emitDecryptProgress(payload, cacheKey, 'failed', 100, 'error', '配置缺失')
@@ -410,7 +431,7 @@ export class ImageDecryptService {
      }

      // 优先使用当前 wxid 对应的密钥，找不到则回退到全局配置
-      const imageKeys = this.configService.getImageKeysForCurrentWxid()
+      const imageKeys = this.getConfiguredImageKeys()
      const xorKeyRaw = imageKeys.xorKey
      // 支持十六进制格式（如 0x53）和十进制格式
      let xorKey: number
@@ -433,7 +454,7 @@ export class ImageDecryptService {
      const aesKeyText = typeof aesKeyRaw === 'string' ? aesKeyRaw.trim() : ''
      const aesKeyForNative = aesKeyText || undefined

-      this.logInfo('开始解密DAT文件(仅Rust原生)', { datPath, xorKey, hasAesKey: Boolean(aesKeyForNative) })
+      this.logInfo('开始解密DAT文件', { datPath, xorKey, hasAesKey: Boolean(aesKeyForNative) })
      this.emitDecryptProgress(payload, cacheKey, 'decrypting', 58, 'running')
      const nativeResult = this.tryDecryptDatWithNative(datPath, xorKey, aesKeyForNative)
      if (!nativeResult) {
@@ -493,50 +514,11 @@ export class ImageDecryptService {
  }

  private resolveAccountDir(dbPath: string, wxid: string): string | null {
-    const cleanedWxid = this.cleanAccountDirName(wxid)
-    const normalized = dbPath.replace(/[\\/]+$/, '')
-    const cacheKey = `${normalized}|${cleanedWxid.toLowerCase()}`
-    const cached = this.accountDirCache.get(cacheKey)
-    if (cached && existsSync(cached)) return cached
-    if (cached && !existsSync(cached)) {
-      this.accountDirCache.delete(cacheKey)
-    }
-
-    const direct = join(normalized, cleanedWxid)
-    if (existsSync(direct)) {
-      this.accountDirCache.set(cacheKey, direct)
-      return direct
-    }
-
-    if (this.isAccountDir(normalized)) {
-      this.accountDirCache.set(cacheKey, normalized)
-      return normalized
-    }
-
-    try {
-      const entries = readdirSync(normalized)
-      const lowerWxid = cleanedWxid.toLowerCase()
-      for (const entry of entries) {
-        const entryPath = join(normalized, entry)
-        if (!this.isDirectory(entryPath)) continue
-        const lowerEntry = entry.toLowerCase()
-        if (lowerEntry === lowerWxid || lowerEntry.startsWith(`${lowerWxid}_`)) {
-          if (this.isAccountDir(entryPath)) {
-            this.accountDirCache.set(cacheKey, entryPath)
-            return entryPath
-          }
-        }
-      }
-    } catch { }
-
-    return null
+    return this.configService.getAccountDir(dbPath, wxid)
  }

  private resolveCurrentAccountDir(): string | null {
-    const wxid = this.configService.get('myWxid')
-    const dbPath = this.configService.get('dbPath')
-    if (!wxid || !dbPath) return null
-    return this.resolveAccountDir(dbPath, wxid)
+    return this.configService.getAccountDir()
  }

  /**
@@ -1239,8 +1221,9 @@ export class ImageDecryptService {
    const decryptKey = this.configService.get('decryptKey')
    const wxid = this.configService.get('myWxid')
    if (!dbPath || !decryptKey || !wxid) return false
-    const cleanedWxid = this.cleanAccountDirName(wxid)
-    return await wcdbService.open(dbPath, decryptKey, cleanedWxid)
+    const accountDir = this.configService.getAccountDir(dbPath, wxid)
+    if (!accountDir) return false
+    return await wcdbService.open(accountDir, decryptKey)
  }

  private getRowValue(row: any, column: string): any {
@@ -1404,7 +1387,8 @@ export class ImageDecryptService {
  private findCachedOutputByDatPath(datPath: string, sessionId?: string, preferHd = false): string | null {
    const candidates = this.buildCacheOutputCandidatesFromDat(datPath, sessionId, preferHd)
    for (const candidate of candidates) {
-      if (existsSync(candidate)) return candidate
+      if (!existsSync(candidate)) continue
+      if (this.isUsableImageCacheFile(candidate)) return candidate
    }
    return null
  }
@@ -1556,7 +1540,117 @@ export class ImageDecryptService {
        })
      }
    }
-    return result
+    if (result) return result
+    const fallback = this.tryDecryptDatWithJs(datPath, xorKey, aesKey)
+    if (fallback) {
+      this.logInfo('JS DAT 解密 fallback 已启用', { datPath, ext: fallback.ext })
+    }
+    return fallback
+  }
+
+  private tryDecryptDatWithJs(
+    datPath: string,
+    xorKey: number,
+    aesKey?: string
+  ): { data: Buffer; ext: string; isWxgf: boolean } | null {
+    try {
+      const encrypted = readFileSync(datPath)
+      const directExt = this.detectImageExtension(encrypted)
+      if (directExt) return { data: encrypted, ext: directExt, isWxgf: false }
+
+      const candidates: Buffer[] = []
+      const aesKeyText = String(aesKey || '').trim()
+      const datVersion = this.getDatVersion(encrypted)
+      if (datVersion === 2 && aesKeyText.length >= 16) {
+        try {
+          candidates.push(this.decryptDatV4WithJs(encrypted, xorKey, Buffer.from(aesKeyText, 'ascii').subarray(0, 16)))
+        } catch { }
+      }
+      if (datVersion !== 2) {
+        candidates.push(this.decryptDatV3WithJs(encrypted, xorKey))
+      }
+
+      for (const candidate of candidates) {
+        const ext = this.detectImageExtension(candidate)
+        if (ext) return { data: candidate, ext, isWxgf: false }
+      }
+    } catch (error) {
+      this.logError('JS DAT 解密 fallback 失败', error, { datPath })
+    }
+    return null
+  }
+
+  private decryptDatV3WithJs(data: Buffer, xorKey: number): Buffer {
+    const output = Buffer.allocUnsafe(data.length)
+    for (let i = 0; i < data.length; i += 1) {
+      output[i] = data[i] ^ xorKey
+    }
+    return output
+  }
+
+  private decryptDatV4WithJs(data: Buffer, xorKey: number, aesKey: Buffer): Buffer {
+    if (data.length < 0x0f) {
+      throw new Error('dat file too small')
+    }
+    const header = data.subarray(0, 0x0f)
+    const payload = data.subarray(0x0f)
+    const aesSize = this.readInt32LeSafe(header, 6)
+    const xorSize = this.readInt32LeSafe(header, 10)
+    const remainder = ((aesSize % 16) + 16) % 16
+    const alignedAesSize = aesSize + (16 - remainder)
+    if (alignedAesSize > payload.length) throw new Error('invalid aes size')
+
+    const aesData = payload.subarray(0, alignedAesSize)
+
+    let plainAes = Buffer.alloc(0)
+    if (aesData.length > 0) {
+      const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, Buffer.alloc(0))
+      decipher.setAutoPadding(false)
+      plainAes = this.strictRemovePkcs7Padding(Buffer.concat([decipher.update(aesData), decipher.final()]))
+    }
+
+    const remaining = payload.subarray(alignedAesSize)
+    if (xorSize < 0 || xorSize > remaining.length) throw new Error('invalid xor size')
+
+    let rawData = Buffer.alloc(0)
+    let decodedXor = Buffer.alloc(0)
+    if (xorSize > 0) {
+      const rawLength = remaining.length - xorSize
+      if (rawLength < 0) throw new Error('invalid raw size')
+      rawData = remaining.subarray(0, rawLength)
+      const xorData = remaining.subarray(rawLength)
+      decodedXor = Buffer.allocUnsafe(xorData.length)
+      for (let i = 0; i < xorData.length; i += 1) {
+        decodedXor[i] = xorData[i] ^ xorKey
+      }
+    } else {
+      rawData = remaining
+    }
+    return Buffer.concat([plainAes, rawData, decodedXor])
+  }
+
+  private getDatVersion(data: Buffer): number {
+    if (data.length < 6) return 0
+    const sigV1 = Buffer.from([0x07, 0x08, 0x56, 0x31, 0x08, 0x07])
+    const sigV2 = Buffer.from([0x07, 0x08, 0x56, 0x32, 0x08, 0x07])
+    if (data.subarray(0, 6).equals(sigV1)) return 1
+    if (data.subarray(0, 6).equals(sigV2)) return 2
+    return 0
+  }
+
+  private readInt32LeSafe(buffer: Buffer, offset: number): number {
+    if (offset < 0 || offset + 4 > buffer.length) throw new Error('invalid int32 offset')
+    return buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24)
+  }
+
+  private strictRemovePkcs7Padding(data: Buffer): Buffer {
+    if (data.length === 0) throw new Error('empty decrypted data')
+    const pad = data[data.length - 1]
+    if (pad <= 0 || pad > 16 || pad > data.length) throw new Error('invalid pkcs7 padding')
+    for (let i = data.length - pad; i < data.length; i += 1) {
+      if (data[i] !== pad) throw new Error('invalid pkcs7 padding')
+    }
+    return data.subarray(0, data.length - pad)
  }

  private detectImageExtension(buffer: Buffer): string | null {
@@ -1630,6 +1724,73 @@ export class ImageDecryptService {
    return ext === '.gif' || ext === '.png' || ext === '.jpg' || ext === '.jpeg' || ext === '.webp'
  }

+  private isUsableImageCacheFile(filePath: string): boolean {
+    if (!this.isImageFile(filePath)) return false
+    if (!existsSync(filePath)) return false
+    if (this.isLikelyCorruptedDecodedImage(filePath)) {
+      this.logInfo('[ImageDecrypt] 跳过疑似损坏缓存文件', { filePath })
+      void rm(filePath, { force: true }).catch(() => { })
+      return false
+    }
+    return true
+  }
+
+  private isLikelyCorruptedDecodedImage(filePath: string): boolean {
+    try {
+      const ext = extname(filePath).toLowerCase()
+      if (ext !== '.jpg' && ext !== '.jpeg') return false
+      const data = readFileSync(filePath)
+      return this.isLikelyCorruptedJpegBuffer(data)
+    } catch {
+      return false
+    }
+  }
+
+  private isLikelyCorruptedJpegBuffer(data: Buffer): boolean {
+    if (data.length < 4096) return false
+    let zeroCount = 0
+    for (let i = 0; i < data.length; i += 1) {
+      if (data[i] === 0x00) zeroCount += 1
+    }
+    const zeroRatio = zeroCount / data.length
+    if (zeroRatio >= 0.985) return true
+
+    const hasLavcTag = data.length >= 24 && data.subarray(0, 24).includes(Buffer.from('Lavc'))
+    if (!hasLavcTag) return false
+
+    // JPEG 扫描段若几乎全是 0，通常表示解码失败但被编码器强行输出。
+    let sosPos = -1
+    for (let i = 2; i < data.length - 1; i += 1) {
+      if (data[i] === 0xff && data[i + 1] === 0xda) {
+        sosPos = i
+        break
+      }
+    }
+    if (sosPos < 0 || sosPos + 4 >= data.length) return zeroRatio >= 0.95
+
+    const sosLength = (data[sosPos + 2] << 8) | data[sosPos + 3]
+    const scanStart = sosPos + 2 + sosLength
+    if (scanStart >= data.length - 2) return zeroRatio >= 0.95
+
+    let eoiPos = -1
+    for (let i = data.length - 2; i >= scanStart; i -= 1) {
+      if (data[i] === 0xff && data[i + 1] === 0xd9) {
+        eoiPos = i
+        break
+      }
+    }
+    if (eoiPos < 0 || eoiPos <= scanStart) return zeroRatio >= 0.95
+
+    const scanData = data.subarray(scanStart, eoiPos)
+    if (scanData.length < 1024) return zeroRatio >= 0.95
+    let scanZeroCount = 0
+    for (let i = 0; i < scanData.length; i += 1) {
+      if (scanData[i] === 0x00) scanZeroCount += 1
+    }
+    const scanZeroRatio = scanZeroCount / scanData.length
+    return scanZeroRatio >= 0.985
+  }
+
  /**
   * 解包 wxgf 格式
   * wxgf 是微信的图片格式，内部使用 HEVC 编码
@@ -1653,41 +1814,96 @@ export class ImageDecryptService {
      }
    }

-    // 提取 HEVC NALU 裸流
-    const hevcData = this.extractHevcNalu(buffer)
-    // 优先用提取的 NALU 裸流，提取失败则跳过 wxgf 头部直接用原始数据
-    const feedData = (hevcData && hevcData.length >= 100) ? hevcData : buffer.subarray(4)
+    const hevcCandidates = this.buildWxgfHevcCandidates(buffer)
    this.logInfo('unwrapWxgf: 准备 ffmpeg 转换', {
-      naluExtracted: !!(hevcData && hevcData.length >= 100),
-      feedSize: feedData.length
+      candidateCount: hevcCandidates.length,
+      candidates: hevcCandidates.map((item) => `${item.name}:${item.data.length}`)
    })

-    // 尝试用 ffmpeg 转换
-    try {
-      const jpgData = await this.convertHevcToJpg(feedData)
-      if (jpgData && jpgData.length > 0) {
+    for (const candidate of hevcCandidates) {
+      try {
+        const jpgData = await this.convertHevcToJpg(candidate.data)
+        if (!jpgData || jpgData.length === 0) continue
        return { data: jpgData, isWxgf: false }
+      } catch (e) {
+        this.logError('unwrapWxgf: 候选流转换失败', e, { candidate: candidate.name })
      }
-    } catch (e) {
-      this.logError('unwrapWxgf: ffmpeg 转换失败', e)
    }

-    return { data: feedData, isWxgf: true }
+    const fallback = hevcCandidates[0]?.data || buffer.subarray(4)
+    return { data: fallback, isWxgf: true }
  }

-  /**
-   * 从 wxgf 数据中提取 HEVC NALU 裸流
-   */
-  private extractHevcNalu(buffer: Buffer): Buffer | null {
+  private buildWxgfHevcCandidates(buffer: Buffer): Array<{ name: string; data: Buffer }> {
+    const units = this.extractHevcNaluUnits(buffer)
+    const candidates: Array<{ name: string; data: Buffer }> = []
+
+    const addCandidate = (name: string, data: Buffer | null | undefined): void => {
+      if (!data || data.length < 100) return
+      if (candidates.some((item) => item.data.equals(data))) return
+      candidates.push({ name, data })
+    }
+
+    // 1) 优先尝试按 VPS(32) 分组后的候选流
+    const vpsStarts: number[] = []
+    for (let i = 0; i < units.length; i += 1) {
+      const unit = units[i]
+      if (!unit || unit.length < 2) continue
+      const type = (unit[0] >> 1) & 0x3f
+      if (type === 32) vpsStarts.push(i)
+    }
+    const groups: Array<{ index: number; data: Buffer; size: number }> = []
+    for (let i = 0; i < vpsStarts.length; i += 1) {
+      const start = vpsStarts[i]
+      const end = i + 1 < vpsStarts.length ? vpsStarts[i + 1] : units.length
+      const groupUnits = units.slice(start, end)
+      if (groupUnits.length === 0) continue
+      let hasVcl = false
+      for (const unit of groupUnits) {
+        if (!unit || unit.length < 2) continue
+        const type = (unit[0] >> 1) & 0x3f
+        if (type === 19 || type === 20 || type === 1) {
+          hasVcl = true
+          break
+        }
+      }
+      if (!hasVcl) continue
+      const merged = this.mergeHevcNaluUnits(groupUnits)
+      groups.push({ index: i, data: merged, size: merged.length })
+    }
+    groups.sort((a, b) => b.size - a.size)
+    for (const group of groups) {
+      addCandidate(`group_${group.index}`, group.data)
+    }
+
+    // 2) 全量扫描提取流
+    addCandidate('scan_all_nalus', this.mergeHevcNaluUnits(units))
+
+    // 3) 兜底：直接跳过 wxgf 头喂 ffmpeg
+    addCandidate('raw_skip4', buffer.subarray(4))
+
+    return candidates
+  }
+
+  private mergeHevcNaluUnits(units: Buffer[]): Buffer {
+    if (!Array.isArray(units) || units.length === 0) return Buffer.alloc(0)
+    const merged: Buffer[] = []
+    for (const unit of units) {
+      if (!unit || unit.length < 2) continue
+      merged.push(Buffer.from([0x00, 0x00, 0x00, 0x01]))
+      merged.push(unit)
+    }
+    return Buffer.concat(merged)
+  }
+
+  private extractHevcNaluUnits(buffer: Buffer): Buffer[] {
    const starts: number[] = []
    let i = 4
-
    while (i < buffer.length - 3) {
      const hasPrefix4 = buffer[i] === 0x00 && buffer[i + 1] === 0x00 &&
        buffer[i + 2] === 0x00 && buffer[i + 3] === 0x01
      const hasPrefix3 = buffer[i] === 0x00 && buffer[i + 1] === 0x00 &&
        buffer[i + 2] === 0x01
-
      if (hasPrefix4 || hasPrefix3) {
        starts.push(i)
        i += hasPrefix4 ? 4 : 3
@@ -1695,10 +1911,11 @@ export class ImageDecryptService {
      }
      i += 1
    }
+    if (starts.length === 0) return []

-    if (starts.length === 0) return null
-
-    const nalUnits: Buffer[] = []
+    const units: Buffer[] = []
+    let keptUnits = 0
+    let droppedUnits = 0
    for (let index = 0; index < starts.length; index += 1) {
      const start = starts[index]
      const end = index + 1 < starts.length ? starts[index + 1] : buffer.length
@@ -1707,12 +1924,29 @@ export class ImageDecryptService {
      const prefixLength = hasPrefix4 ? 4 : 3
      const payloadStart = start + prefixLength
      if (payloadStart >= end) continue
-      nalUnits.push(Buffer.from([0x00, 0x00, 0x00, 0x01]))
-      nalUnits.push(buffer.subarray(payloadStart, end))
+      const payload = buffer.subarray(payloadStart, end)
+      if (payload.length < 2) {
+        droppedUnits += 1
+        continue
+      }
+      if ((payload[0] & 0x80) !== 0) {
+        droppedUnits += 1
+        continue
+      }
+      units.push(payload)
+      keptUnits += 1
    }
+    return units
+  }

-    if (nalUnits.length === 0) return null
-    return Buffer.concat(nalUnits)
+  /**
+   * 从 wxgf 数据中提取 HEVC NALU 裸流
+   */
+  private extractHevcNalu(buffer: Buffer): Buffer | null {
+    const units = this.extractHevcNaluUnits(buffer)
+    if (units.length === 0) return null
+    const merged = this.mergeHevcNaluUnits(units)
+    return merged.length > 0 ? merged : null
  }

  /**
@@ -1747,18 +1981,26 @@ export class ImageDecryptService {
      await writeFile(tmpInput, hevcData)

      // 依次尝试: 1) -f hevc 裸流  2) 不指定格式让 ffmpeg 自动检测
-      const attempts: { label: string; inputArgs: string[] }[] = [
-        { label: 'hevc raw', inputArgs: ['-f', 'hevc', '-i', tmpInput] },
-        { label: 'h265 raw', inputArgs: ['-f', 'h265', '-i', tmpInput] },
-        { label: 'auto detect', inputArgs: ['-i', tmpInput] },
+      const attempts: { label: string; inputArgs: string[]; outputArgs?: string[] }[] = [
+        { label: 'hevc raw frame0', inputArgs: ['-f', 'hevc', '-i', tmpInput] },
+        { label: 'hevc raw frame1', inputArgs: ['-f', 'hevc', '-i', tmpInput], outputArgs: ['-vf', 'select=eq(n\\,1)'] },
+        { label: 'hevc raw frame5', inputArgs: ['-f', 'hevc', '-i', tmpInput], outputArgs: ['-vf', 'select=eq(n\\,5)'] },
+        { label: 'h265 raw frame0', inputArgs: ['-f', 'h265', '-i', tmpInput] },
+        { label: 'h265 raw frame1', inputArgs: ['-f', 'h265', '-i', tmpInput], outputArgs: ['-vf', 'select=eq(n\\,1)'] },
+        { label: 'h265 raw frame5', inputArgs: ['-f', 'h265', '-i', tmpInput], outputArgs: ['-vf', 'select=eq(n\\,5)'] },
+        { label: 'auto detect frame0', inputArgs: ['-i', tmpInput] },
+        { label: 'auto detect frame1', inputArgs: ['-i', tmpInput], outputArgs: ['-vf', 'select=eq(n\\,1)'] },
+        { label: 'auto detect frame5', inputArgs: ['-i', tmpInput], outputArgs: ['-vf', 'select=eq(n\\,5)'] },
      ]

      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
+        const result = await this.runFfmpegConvert(ffmpeg, attempt.inputArgs, tmpOutput, attempt.label, attempt.outputArgs)
+        if (!result) continue
+        if (this.isLikelyCorruptedJpegBuffer(result)) continue
+        return result
      }

      return null
@@ -1771,7 +2013,13 @@ export class ImageDecryptService {
    }
  }

-  private runFfmpegConvert(ffmpeg: string, inputArgs: string[], tmpOutput: string, label: string): Promise<Buffer | null> {
+  private runFfmpegConvert(
+    ffmpeg: string,
+    inputArgs: string[],
+    tmpOutput: string,
+    label: string,
+    outputArgs?: string[]
+  ): Promise<Buffer | null> {
    return new Promise((resolve) => {
      const { spawn } = require('child_process')
      const errChunks: Buffer[] = []
@@ -1780,6 +2028,7 @@ export class ImageDecryptService {
        '-hide_banner', '-loglevel', 'error',
        '-y',
        ...inputArgs,
+        ...(outputArgs || []),
        '-vframes', '1', '-q:v', '2', '-f', 'image2', tmpOutput
      ]
      this.logInfo(`ffmpeg 尝试 [${label}]`, { args: args.join(' ') })
--- a/electron/services/imageDownloadService.ts
+++ b/electron/services/imageDownloadService.ts
@@ -0,0 +1,203 @@
+import { app } from 'electron'
+import { join } from 'path'
+import { existsSync } from 'fs'
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+// import { ConfigService } from './config'
+
+const execFileAsync = promisify(execFile)
+
+export class ImageDownloadService {
+  private static instance: ImageDownloadService
+  private koffi: any = null
+  private lib: any = null
+  private initialized = false
+
+  private initImgHelper: any = null
+  private uninstallImgHelper: any = null
+  private getImgHelperError: any = null
+
+  private currentPid: number | null = null
+  private pollTimer: NodeJS.Timeout | null = null
+  private isHooked = false
+
+  private lastWhitelist: string[] = []
+
+  static getInstance(): ImageDownloadService {
+    if (!ImageDownloadService.instance) {
+      ImageDownloadService.instance = new ImageDownloadService()
+    }
+    return ImageDownloadService.instance
+  }
+
+  private constructor() {
+  }
+
+  private async ensureInitialized(): Promise<boolean> {
+    if (this.initialized) return true
+    if (process.platform !== 'win32' || process.arch !== 'x64') return false
+
+    try {
+      this.koffi = require('koffi')
+      const dllPath = this.getDllPath()
+      if (!existsSync(dllPath)) return false
+
+      this.lib = this.koffi.load(dllPath)
+
+      this.initImgHelper = this.lib.func('bool InitImgHelper(uint32, const char*)')
+      this.uninstallImgHelper = this.lib.func('void UninstallImgHelper()')
+      this.getImgHelperError = this.lib.func('const char* GetImgHelperError()')
+
+      this.initialized = true
+      return true
+    } catch (error) {
+      console.error('[ImageDownloadService] failed to initialize:', error)
+      return false
+    }
+  }
+
+  private getDllPath(): string {
+    const isPackaged = app.isPackaged
+    const candidates: string[] = []
+    
+    if (isPackaged) {
+      candidates.push(join(process.resourcesPath, 'resources', 'image', 'win32', 'x64', 'img_helper.dll'))
+    } else {
+      candidates.push(join(process.cwd(), 'resources', 'image', 'win32', 'x64', 'img_helper.dll'))
+    }
+
+    for (const path of candidates) {
+      if (existsSync(path)) return path
+    }
+    return candidates[0]
+  }
+
+  private async findMainWeChatPid(): Promise<number | null> {
+    try {
+      const script = `
+      Get-CimInstance Win32_Process -Filter "Name = 'Weixin.exe'" | 
+      Select-Object ProcessId, CommandLine | 
+      ConvertTo-Json -Compress
+    `;
+
+      const { stdout } = await execFileAsync('powershell', ['-NoProfile', '-Command', script])
+      if (!stdout || !stdout.trim()) return null
+
+      let processes = JSON.parse(stdout.trim())
+      if (!Array.isArray(processes)) processes = [processes]
+
+      const target = processes
+          .filter((p: any) => p.CommandLine && p.CommandLine.toLowerCase().includes('weixin.exe'))
+          .sort((a: any, b: any) => a.CommandLine.length - b.CommandLine.length)[0]
+
+      return target ? target.ProcessId : null;
+    } catch (e) {
+      return null
+    }
+  }
+
+  async startAutoDownload(whitelist: string[] | string = []): Promise<{ success: boolean; error?: string }> {
+    if (!await this.ensureInitialized()) {
+      return { success: false, error: '核心组件初始化失败' }
+    }
+
+    if (this.isHooked) {
+      await this.unhook()
+    }
+
+    this.lastWhitelist = whitelist
+
+    if (!this.pollTimer) {
+      this.pollTimer = setInterval(() => this.checkAndHook(this.lastWhitelist, false), 30000)
+    }
+
+    return await this.checkAndHook(whitelist, true)
+  }
+
+  async stopAutoDownload() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer)
+      this.pollTimer = null
+    }
+    await this.unhook()
+  }
+
+  private async checkAndHook(whitelist: string[] | string = [], isManualStart = false): Promise<{ success: boolean; error?: string }> {
+    const pid = await this.findMainWeChatPid()
+
+    if (!pid) {
+      if (this.isHooked) {
+        console.log('[ImageDownloadService] WeChat exited, unhooking')
+        await this.unhook()
+      }
+      return { success: true, error: '等待微信启动' }
+    }
+
+    if (this.isHooked && this.currentPid === pid) {
+      return { success: true }
+    }
+
+    if (this.isHooked && this.currentPid !== pid) {
+      console.log('[ImageDownloadService] WeChat PID changed, re-hooking')
+      await this.unhook()
+    }
+
+    console.log(`[ImageDownloadService] attempting to hook PID: ${pid}`)
+    try {
+      let whitelistBuffer: Buffer | null = null;
+      if (typeof whitelist === 'string') {
+        if (whitelist.length > 0) {
+          whitelistBuffer = Buffer.from(whitelist, 'utf8');
+        }
+      } else if (Array.isArray(whitelist) && whitelist.length > 0) {
+        whitelistBuffer = Buffer.from(whitelist.join('\0') + '\0\0', 'utf8');
+      }
+
+      const success = this.initImgHelper(pid, whitelistBuffer)
+
+      if (success) {
+        this.isHooked = true
+        this.currentPid = pid
+        console.log('[ImageDownloadService] hook successful')
+        return { success: true }
+      } else {
+        const err = this.getImgHelperError()
+        console.error(`[ImageDownloadService] hook failed: ${err}`)
+        if (isManualStart && this.pollTimer) {
+          clearInterval(this.pollTimer)
+          this.pollTimer = null
+        }
+        return { success: false, error: err || 'Hook 失败' }
+      }
+    } catch (e: any) {
+      console.error('[ImageDownloadService] InitImgHelper call crashed:', e)
+      if (isManualStart && this.pollTimer) {
+        clearInterval(this.pollTimer)
+        this.pollTimer = null
+      }
+      return { success: false, error: `调用异常: ${e.message || String(e)}` }
+    }
+  }
+
+  private async unhook() {
+    if (this.isHooked && this.uninstallImgHelper) {
+      try {
+        this.uninstallImgHelper()
+      } catch (e) {
+        console.error('[ImageDownloadService] uninstall failed:', e)
+      }
+    }
+    this.isHooked = false
+    this.currentPid = null
+  }
+
+  async getStatus() {
+    return {
+      isHooked: this.isHooked,
+      pid: this.currentPid,
+      supported: process.platform === 'win32' && process.arch === 'x64'
+    }
+  }
+}
+
+export const imageDownloadService = ImageDownloadService.getInstance()
--- a/electron/services/insightRecordService.ts
+++ b/electron/services/insightRecordService.ts
@@ -0,0 +1,380 @@
+import { app } from 'electron'
+import fs from 'fs'
+import path from 'path'
+import { createHash, randomUUID } from 'crypto'
+import { ConfigService } from './config'
+
+export type InsightRecordTriggerReason = 'activity' | 'silence' | 'test' | 'manual' | 'message_analysis'
+export type InsightRecordSourceType = 'insight' | 'message_analysis'
+
+export interface MessageInsightAnalysis {
+  explicitText: string
+  emotion: string
+  intent: string
+  topic: string
+}
+
+export interface MessageInsightTarget {
+  targetLocalId: number
+  targetCreateTime: number
+  targetMessageKey: string
+  targetSenderName: string
+  targetTextPreview: string
+  analysis: MessageInsightAnalysis
+}
+
+export interface InsightRecordLog {
+  endpoint: string
+  model: string
+  maxTokens: number
+  temperature: number
+  triggerReason: InsightRecordTriggerReason
+  allowContext: boolean
+  contextCount: number
+  systemPrompt: string
+  userPrompt: string
+  rawOutput: string
+  finalInsight: string
+  durationMs: number
+  createdAt: number
+  responseFormatJson?: boolean
+  responseFormatFallback?: boolean
+  responseFormatFallbackReason?: string
+  targetMessage?: {
+    localId: number
+    createTime: number
+    messageKey: string
+    senderName: string
+    textPreview: string
+  }
+  contextStats?: {
+    requested: number
+    beforeTarget: number
+    afterTarget: number
+    readError?: string
+  }
+  parsedAnalysis?: MessageInsightAnalysis
+}
+
+export interface InsightRecord {
+  id: string
+  accountScope: string
+  sourceType: InsightRecordSourceType
+  createdAt: number
+  sessionId: string
+  displayName: string
+  avatarUrl?: string
+  triggerReason: InsightRecordTriggerReason
+  insight: string
+  read: boolean
+  messageInsight?: MessageInsightTarget
+  log: InsightRecordLog
+}
+
+export interface InsightRecordSummary {
+  id: string
+  sourceType: InsightRecordSourceType
+  createdAt: number
+  sessionId: string
+  displayName: string
+  avatarUrl?: string
+  triggerReason: InsightRecordTriggerReason
+  insight: string
+  read: boolean
+  messageInsight?: MessageInsightTarget
+}
+
+export interface InsightRecordContactFacet {
+  sessionId: string
+  displayName: string
+  avatarUrl?: string
+  count: number
+}
+
+export interface InsightRecordFilters {
+  keyword?: string
+  sessionId?: string
+  startTime?: number
+  endTime?: number
+  sourceType?: InsightRecordSourceType | 'all'
+  limit?: number
+  offset?: number
+}
+
+export interface InsightRecordListResult {
+  success: boolean
+  records: InsightRecordSummary[]
+  total: number
+  todayCount: number
+  unreadCount: number
+  contacts: InsightRecordContactFacet[]
+  error?: string
+}
+
+class InsightRecordService {
+  private readonly maxRecordsPerScope = 1000
+  private filePath: string | null = null
+  private loaded = false
+  private records: InsightRecord[] = []
+
+  private resolveFilePath(): string {
+    if (this.filePath) return this.filePath
+    const workerUserDataPath = String(process.env.WEFLOW_USER_DATA_PATH || process.env.WEFLOW_CONFIG_CWD || '').trim()
+    const userDataPath = workerUserDataPath || app?.getPath?.('userData') || process.cwd()
+    fs.mkdirSync(userDataPath, { recursive: true })
+    this.filePath = path.join(userDataPath, 'weflow-insight-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 (Array.isArray(parsed)) {
+        this.records = parsed.filter((item) => item && typeof item === 'object') as InsightRecord[]
+      } else if (Array.isArray(parsed?.records)) {
+        this.records = parsed.records.filter((item: unknown) => item && typeof item === 'object') as InsightRecord[]
+      }
+    } catch {
+      this.records = []
+    }
+  }
+
+  private persist(): void {
+    try {
+      const filePath = this.resolveFilePath()
+      fs.writeFileSync(filePath, JSON.stringify({ version: 1, records: this.records }, null, 2), 'utf-8')
+    } catch {
+      // Keep insight generation non-blocking even if local persistence fails.
+    }
+  }
+
+  private getCurrentAccountScope(): string {
+    const config = ConfigService.getInstance()
+    const myWxid = String(config.getMyWxidCleaned() || '').trim()
+    if (myWxid) return `wxid:${myWxid}`
+
+    const dbPath = String(config.get('dbPath') || '').trim()
+    if (dbPath) {
+      const hash = createHash('sha1').update(dbPath).digest('hex').slice(0, 16)
+      return `db:${hash}`
+    }
+    return 'default'
+  }
+
+  private getStartOfToday(): number {
+    const date = new Date()
+    date.setHours(0, 0, 0, 0)
+    return date.getTime()
+  }
+
+  private toSummary(record: InsightRecord): InsightRecordSummary {
+    return {
+      id: record.id,
+      sourceType: record.sourceType || 'insight',
+      createdAt: record.createdAt,
+      sessionId: record.sessionId,
+      displayName: record.displayName,
+      avatarUrl: record.avatarUrl,
+      triggerReason: record.triggerReason,
+      insight: record.insight,
+      read: record.read,
+      messageInsight: record.messageInsight
+    }
+  }
+
+  private getScopedRecords(): InsightRecord[] {
+    this.ensureLoaded()
+    const scope = this.getCurrentAccountScope()
+    return this.records.filter((record) => record.accountScope === scope)
+  }
+
+  addRecord(input: {
+    sessionId: string
+    displayName: string
+    avatarUrl?: string
+    sourceType?: InsightRecordSourceType
+    triggerReason: InsightRecordTriggerReason
+    insight: string
+    messageInsight?: MessageInsightTarget
+    log: InsightRecordLog
+  }): InsightRecord {
+    this.ensureLoaded()
+    const scope = this.getCurrentAccountScope()
+    const now = Date.now()
+    const record: InsightRecord = {
+      id: randomUUID(),
+      accountScope: scope,
+      sourceType: input.sourceType || 'insight',
+      createdAt: now,
+      sessionId: input.sessionId,
+      displayName: input.displayName,
+      avatarUrl: input.avatarUrl,
+      triggerReason: input.triggerReason,
+      insight: input.insight,
+      read: false,
+      messageInsight: input.messageInsight,
+      log: input.log
+    }
+
+    this.records.push(record)
+    const scopedRecords = this.records
+      .filter((item) => item.accountScope === scope)
+      .sort((a, b) => b.createdAt - a.createdAt)
+    const keepIds = new Set(scopedRecords.slice(0, this.maxRecordsPerScope).map((item) => item.id))
+    this.records = this.records.filter((item) => item.accountScope !== scope || keepIds.has(item.id))
+    this.persist()
+    return record
+  }
+
+  listRecords(filters: InsightRecordFilters = {}): InsightRecordListResult {
+    try {
+      const allScoped = this.getScopedRecords()
+      const todayStart = this.getStartOfToday()
+      const contactsMap = new Map<string, InsightRecordContactFacet>()
+      for (const record of allScoped) {
+        const existing = contactsMap.get(record.sessionId)
+        if (existing) {
+          existing.count += 1
+        } else {
+          contactsMap.set(record.sessionId, {
+            sessionId: record.sessionId,
+            displayName: record.displayName,
+            avatarUrl: record.avatarUrl,
+            count: 1
+          })
+        }
+      }
+
+      const keyword = String(filters.keyword || '').trim().toLowerCase()
+      const sessionId = String(filters.sessionId || '').trim()
+      const sourceType = String(filters.sourceType || 'all').trim()
+      const startTime = Number(filters.startTime || 0)
+      const endTime = Number(filters.endTime || 0)
+      const offset = Math.max(0, Math.floor(Number(filters.offset || 0)))
+      const limit = Math.min(200, Math.max(1, Math.floor(Number(filters.limit || 100))))
+
+      const filtered = allScoped
+        .filter((record) => {
+          if (sessionId && record.sessionId !== sessionId) return false
+          const recordSourceType = record.sourceType || 'insight'
+          if (sourceType !== 'all' && sourceType && recordSourceType !== sourceType) return false
+          if (startTime > 0 && record.createdAt < startTime) return false
+          if (endTime > 0 && record.createdAt > endTime) return false
+          if (keyword) {
+            const haystack = [
+              record.displayName,
+              record.sessionId,
+              record.insight,
+              record.messageInsight?.targetSenderName,
+              record.messageInsight?.targetTextPreview,
+              record.messageInsight?.analysis?.explicitText,
+              record.messageInsight?.analysis?.emotion,
+              record.messageInsight?.analysis?.intent,
+              record.messageInsight?.analysis?.topic
+            ].join('\n').toLowerCase()
+            if (!haystack.includes(keyword)) return false
+          }
+          return true
+        })
+        .sort((a, b) => b.createdAt - a.createdAt)
+
+      return {
+        success: true,
+        records: filtered.slice(offset, offset + limit).map((record) => this.toSummary(record)),
+        total: filtered.length,
+        todayCount: allScoped.filter((record) => record.createdAt >= todayStart).length,
+        unreadCount: allScoped.filter((record) => !record.read).length,
+        contacts: Array.from(contactsMap.values()).sort((a, b) => b.count - a.count)
+      }
+    } catch (error) {
+      return {
+        success: false,
+        records: [],
+        total: 0,
+        todayCount: 0,
+        unreadCount: 0,
+        contacts: [],
+        error: (error as Error).message
+      }
+    }
+  }
+
+  getRecord(id: string): { success: boolean; record?: InsightRecord; error?: string } {
+    this.ensureLoaded()
+    const normalizedId = String(id || '').trim()
+    if (!normalizedId) return { success: false, error: '记录 ID 为空' }
+    const scope = this.getCurrentAccountScope()
+    const record = this.records.find((item) => item.id === normalizedId && item.accountScope === scope)
+    if (!record) return { success: false, error: '未找到该见解记录' }
+    return { success: true, record }
+  }
+
+  findLatestMessageAnalysis(input: {
+    sessionId: string
+    targetLocalId?: number
+    targetCreateTime?: number
+    targetMessageKey?: string
+  }): InsightRecord | null {
+    this.ensureLoaded()
+    const scope = this.getCurrentAccountScope()
+    const sessionId = String(input.sessionId || '').trim()
+    if (!sessionId) return null
+    const targetLocalId = Math.floor(Number(input.targetLocalId || 0))
+    const targetCreateTime = Math.floor(Number(input.targetCreateTime || 0))
+    const targetMessageKey = String(input.targetMessageKey || '').trim()
+    const matches = this.records
+      .filter((record) => {
+        if (record.accountScope !== scope) return false
+        if ((record.sourceType || 'insight') !== 'message_analysis') return false
+        if (record.sessionId !== sessionId) return false
+        const target = record.messageInsight
+        if (!target) return false
+        if (targetLocalId > 0 && Number(target.targetLocalId || 0) === targetLocalId) {
+          if (targetCreateTime <= 0 || Number(target.targetCreateTime || 0) === targetCreateTime) return true
+        }
+        if (targetMessageKey && target.targetMessageKey === targetMessageKey) return true
+        return false
+      })
+      .sort((a, b) => b.createdAt - a.createdAt)
+    return matches[0] || null
+  }
+
+  markRecordRead(id: string): { success: boolean; error?: string } {
+    this.ensureLoaded()
+    const normalizedId = String(id || '').trim()
+    const scope = this.getCurrentAccountScope()
+    const record = this.records.find((item) => item.id === normalizedId && item.accountScope === scope)
+    if (!record) return { success: false, error: '未找到该见解记录' }
+    if (!record.read) {
+      record.read = true
+      this.persist()
+    }
+    return { success: true }
+  }
+
+  clearRecords(filters: InsightRecordFilters = {}): { success: boolean; removed: number; error?: string } {
+    this.ensureLoaded()
+    const scope = this.getCurrentAccountScope()
+    const sessionId = String(filters.sessionId || '').trim()
+    const startTime = Number(filters.startTime || 0)
+    const endTime = Number(filters.endTime || 0)
+    let removed = 0
+    this.records = this.records.filter((record) => {
+      if (record.accountScope !== scope) return true
+      if (sessionId && record.sessionId !== sessionId) return true
+      if (startTime > 0 && record.createdAt < startTime) return true
+      if (endTime > 0 && record.createdAt > endTime) return true
+      removed += 1
+      return false
+    })
+    this.persist()
+    return { success: true, removed }
+  }
+}
+
+export const insightRecordService = new InsightRecordService()
--- a/electron/services/insightService.ts
+++ b/electron/services/insightService.ts
@@ -10,18 +10,23 @@
 * 设计原则：
 * - 不引入任何额外 npm 依赖，使用 Node 原生 https 模块调用 OpenAI 兼容 API
 * - 所有失败静默处理，不影响主流程
- * - 当日触发记录（sessionId + 时间列表）随 prompt 一起发送，让模型自行判断是否克制
+ * - 触发频率、冷却与名单过滤均在本地完成，不把调度统计塞进模型 prompt
 */

 import https from 'https'
 import http from 'http'
-import fs from 'fs'
-import path from 'path'
 import { URL } from 'url'
-import { app, Notification } from 'electron'
 import { ConfigService } from './config'
 import { chatService, ChatSession, Message } from './chatService'
+import { snsService } from './snsService'
 import { weiboService } from './social/weiboService'
+import { showNotification } from '../windows/notificationWindow'
+import {
+  insightRecordService,
+  type InsightRecordLog,
+  type InsightRecordTriggerReason,
+  type MessageInsightAnalysis
+} from './insightRecordService'

 // ─── 常量 ────────────────────────────────────────────────────────────────────

@@ -36,10 +41,11 @@ const SILENCE_SCAN_INITIAL_DELAY_MS = 3 * 60 * 1000

 /** 单次 API 请求超时（毫秒） */
 const API_TIMEOUT_MS = 45_000
-const API_MAX_TOKENS_DEFAULT = 200
+const API_MAX_TOKENS_DEFAULT = 1024
 const API_MAX_TOKENS_MIN = 1
-const API_MAX_TOKENS_MAX = 65_535
+const API_MAX_TOKENS_MAX = 2_000_000
 const API_TEMPERATURE = 0.7
+const INSIGHT_NOTIFICATION_AVATAR_URL = './assets/insight/AI_Insight.png'

 /** 沉默天数阈值默认值 */
 const DEFAULT_SILENCE_DAYS = 3
@@ -50,6 +56,11 @@ const INSIGHT_CONFIG_KEYS = new Set([
  'aiModelApiKey',
  'aiModelApiModel',
  'aiModelApiMaxTokens',
+  'aiInsightFilterMode',
+  'aiInsightFilterList',
+  'aiInsightAllowMomentsContext',
+  'aiInsightMomentsContextCount',
+  'aiInsightMomentsBindings',
  'aiInsightAllowSocialContext',
  'aiInsightSocialContextCount',
  'aiInsightWeiboCookie',
@@ -73,64 +84,39 @@ interface SharedAiModelConfig {
  maxTokens: number
 }

+interface SessionInsightTriggerResult {
+  success: boolean
+  message: string
+  recordId?: string
+  insight?: string
+  skipped?: boolean
+  notificationEnabled?: boolean
+}
+
+type InsightFilterMode = 'whitelist' | 'blacklist'
+
+class ApiRequestError extends Error {
+  statusCode?: number
+  responseBody?: string
+
+  constructor(message: string, statusCode?: number, responseBody?: string) {
+    super(message)
+    this.name = 'ApiRequestError'
+    this.statusCode = statusCode
+    this.responseBody = responseBody
+  }
+}
+
 // ─── 日志 ─────────────────────────────────────────────────────────────────────

 type InsightLogLevel = 'INFO' | 'WARN' | 'ERROR'

-let debugLogWriteQueue: Promise<void> = Promise.resolve()
-
-function formatDebugTimestamp(date: Date = new Date()): string {
-  const year = date.getFullYear()
-  const month = String(date.getMonth() + 1).padStart(2, '0')
-  const day = String(date.getDate()).padStart(2, '0')
-  const hours = String(date.getHours()).padStart(2, '0')
-  const minutes = String(date.getMinutes()).padStart(2, '0')
-  const seconds = String(date.getSeconds()).padStart(2, '0')
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`
+function insightDebugLine(_level: InsightLogLevel, _message: string): void {
+  // Desktop debug log export has been replaced by per-insight request logs.
 }

-function getInsightDebugLogFilePath(date: Date = new Date()): string {
-  const year = date.getFullYear()
-  const month = String(date.getMonth() + 1).padStart(2, '0')
-  const day = String(date.getDate()).padStart(2, '0')
-  return path.join(app.getPath('desktop'), `weflow-ai-insight-debug-${year}-${month}-${day}.log`)
-}
-
-function isInsightDebugLogEnabled(): boolean {
-  try {
-    return ConfigService.getInstance().get('aiInsightDebugLogEnabled') === true
-  } catch {
-    return false
-  }
-}
-
-function appendInsightDebugText(text: string): void {
-  if (!isInsightDebugLogEnabled()) return
-
-  let logFilePath = ''
-  try {
-    logFilePath = getInsightDebugLogFilePath()
-  } catch {
-    return
-  }
-
-  debugLogWriteQueue = debugLogWriteQueue
-    .then(() => fs.promises.appendFile(logFilePath, text, 'utf8'))
-    .catch(() => undefined)
-}
-
-function insightDebugLine(level: InsightLogLevel, message: string): void {
-  appendInsightDebugText(`[${formatDebugTimestamp()}] [${level}] ${message}\n`)
-}
-
-function insightDebugSection(level: InsightLogLevel, title: string, payload: unknown): void {
-  const content = typeof payload === 'string'
-    ? payload
-    : JSON.stringify(payload, null, 2)
-
-  appendInsightDebugText(
-    `\n========== [${formatDebugTimestamp()}] [${level}] ${title} ==========\n${content}\n========== END ==========\n`
-  )
+function insightDebugSection(_level: InsightLogLevel, _title: string, _payload: unknown): void {
+  // Desktop debug log export has been replaced by per-insight request logs.
 }

 /**
@@ -196,6 +182,57 @@ function normalizeApiMaxTokens(value: unknown): number {
  return Math.min(API_MAX_TOKENS_MAX, Math.max(API_MAX_TOKENS_MIN, Math.floor(numeric)))
 }

+function normalizeSessionIdList(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return Array.from(new Set(value.map((item) => String(item || '').trim()).filter(Boolean)))
+}
+
+function clampText(value: unknown, maxLength: number): string {
+  const text = String(value || '').replace(/\s+/g, ' ').trim()
+  if (text.length <= maxLength) return text
+  return `${text.slice(0, Math.max(0, maxLength - 1))}…`
+}
+
+function stripJsonFence(value: string): string {
+  const text = String(value || '').trim()
+  const fenced = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)
+  if (fenced) return fenced[1].trim()
+  const firstBrace = text.indexOf('{')
+  const lastBrace = text.lastIndexOf('}')
+  if (firstBrace >= 0 && lastBrace > firstBrace) {
+    return text.slice(firstBrace, lastBrace + 1).trim()
+  }
+  return text
+}
+
+function parseMessageInsightAnalysis(rawOutput: string): MessageInsightAnalysis {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(stripJsonFence(rawOutput))
+  } catch {
+    throw new Error('模型输出格式异常：不是合法 JSON')
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    throw new Error('模型输出格式异常：JSON 根节点不是对象')
+  }
+  const source = parsed as Record<string, unknown>
+  const explicitText = clampText(source.explicit_text ?? source.explicitText, 120)
+  const emotion = clampText(source.emotion, 16)
+  const intent = clampText(source.intent, 20)
+  const topic = clampText(source.topic, 20)
+  if (!explicitText || !emotion || !intent || !topic) {
+    throw new Error('模型输出格式异常：缺少必要字段')
+  }
+  return { explicitText, emotion, intent, topic }
+}
+
+function shouldFallbackJsonMode(error: unknown): boolean {
+  const statusCode = Number((error as ApiRequestError)?.statusCode || 0)
+  if (statusCode === 400 || statusCode === 404 || statusCode === 422) return true
+  const text = `${(error as Error)?.message || ''}\n${(error as ApiRequestError)?.responseBody || ''}`.toLowerCase()
+  return text.includes('response_format') || text.includes('json_object') || text.includes('json mode')
+}
+
 /**
 * 调用 OpenAI 兼容 API（非流式），返回模型第一条消息内容。
 * 使用 Node 原生 https/http 模块，无需任何第三方 SDK。
@@ -206,7 +243,8 @@ function callApi(
  model: string,
  messages: Array<{ role: string; content: string }>,
  timeoutMs: number = API_TIMEOUT_MS,
-  maxTokens: number = API_MAX_TOKENS_DEFAULT
+  maxTokens: number = API_MAX_TOKENS_DEFAULT,
+  options?: { responseFormatJson?: boolean }
 ): Promise<string> {
  return new Promise((resolve, reject) => {
    const endpoint = buildApiUrl(apiBaseUrl, '/chat/completions')
@@ -218,15 +256,19 @@ function callApi(
      return
    }

-    const body = JSON.stringify({
+    const payload: Record<string, unknown> = {
      model,
      messages,
      max_tokens: normalizeApiMaxTokens(maxTokens),
      temperature: API_TEMPERATURE,
      stream: false
-    })
+    }
+    if (options?.responseFormatJson) {
+      payload.response_format = { type: 'json_object' }
+    }
+    const body = JSON.stringify(payload)

-    const options = {
+    const requestOptions = {
      hostname: urlObj.hostname,
      port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
      path: urlObj.pathname + urlObj.search,
@@ -240,11 +282,15 @@ function callApi(

    const isHttps = urlObj.protocol === 'https:'
    const requestFn = isHttps ? https.request : http.request
-    const req = requestFn(options, (res) => {
+    const req = requestFn(requestOptions, (res) => {
      let data = ''
      res.on('data', (chunk) => { data += chunk })
      res.on('end', () => {
        try {
+          if (res.statusCode && res.statusCode >= 400) {
+            reject(new ApiRequestError(`API 请求失败 (${res.statusCode}): ${data.slice(0, 200)}`, res.statusCode, data))
+            return
+          }
          const parsed = JSON.parse(data)
          const content = parsed?.choices?.[0]?.message?.content
          if (typeof content === 'string' && content.trim()) {
@@ -436,7 +482,7 @@ class InsightService {

    try {
      const endpoint = buildApiUrl(apiBaseUrl, '/chat/completions')
-      const requestMessages = [{ role: 'user', content: appendPromptCurrentTime('请回复"连接成功"四个字。') }]
+      const requestMessages = [{ role: 'user', content: '请回复"连接成功"四个字。' }]
      insightDebugSection(
        'INFO',
        'AI 测试连接请求',
@@ -495,22 +541,72 @@ class InsightService {
        return id && !id.endsWith('@chatroom') && !id.toLowerCase().includes('placeholder') && this.isSessionAllowed(id)
      })
      if (!session) {
-        return { success: false, message: '未找到任何私聊会话（若已启用白名单，请检查是否有勾选的私聊）' }
+        return { success: false, message: '未找到任何可触发的私聊会话（请检查黑白名单模式与选择列表）' }
      }
      const sessionId = session.username?.trim() || ''
      const displayName = session.displayName || sessionId
      insightLog('INFO', `测试目标会话：${displayName} (${sessionId})`)
-      await this.generateInsightForSession({
+      const result = await this.generateInsightForSession({
        sessionId,
        displayName,
-        triggerReason: 'activity'
+        triggerReason: 'test'
      })
-      return { success: true, message: `已向「${displayName}」发送测试见解，请查看右下角弹窗` }
+      if (!result.success) {
+        return { success: false, message: result.message }
+      }
+      const notificationEnabled = this.config.get('aiInsightNotificationEnabled') !== false
+      return {
+        success: true,
+        message: notificationEnabled
+          ? `已向「${displayName}」发送测试见解，请查看通知弹窗`
+          : `已生成「${displayName}」的测试见解，AI 见解消息通知当前已关闭`
+      }
    } catch (e) {
      return { success: false, message: `测试失败：${(e as Error).message}` }
    }
  }

+  /**
+   * 手动对指定会话立即触发一次 AI 见解。
+   * 只新增触发入口；实际上下文、朋友圈/微博拼接、prompt 和入库仍走 generateInsightForSession。
+   */
+  async triggerSessionInsight(params: {
+    sessionId: string
+    displayName?: string
+    avatarUrl?: string
+  }): Promise<SessionInsightTriggerResult> {
+    const sessionId = String(params?.sessionId || '').trim()
+    if (!sessionId) {
+      return { success: false, message: '当前会话无效，无法触发 AI 见解' }
+    }
+    if (!this.isEnabled()) {
+      return { success: false, message: '请先在设置中开启「AI 见解」' }
+    }
+
+    const { apiBaseUrl, apiKey } = this.getSharedAiModelConfig()
+    if (!apiBaseUrl || !apiKey) {
+      return { success: false, message: '请先填写通用 AI 模型配置（API 地址和 Key）' }
+    }
+
+    try {
+      const connectResult = await chatService.connect()
+      if (!connectResult.success) {
+        return { success: false, message: '数据库连接失败，请先在"数据库连接"页完成配置' }
+      }
+      this.dbConnected = true
+
+      const displayName = String(params?.displayName || sessionId).trim() || sessionId
+      insightLog('INFO', `手动触发当前会话见解：${displayName} (${sessionId})`)
+      return await this.generateInsightForSession({
+        sessionId,
+        displayName,
+        triggerReason: 'manual'
+      })
+    } catch (error) {
+      return { success: false, message: `触发失败：${(error as Error).message}` }
+    }
+  }
+
  /** 获取今日触发统计（供设置页展示） */
  getTodayStats(): { sessionId: string; count: number; times: string[] }[] {
    this.resetIfNewDay()
@@ -611,7 +707,7 @@ ${topMentionText}
        25_000,
        maxTokens
      )
-      const insight = result.trim().slice(0, 400)
+      const insight = result.trim()
      if (!insight) return { success: false, message: '模型返回为空' }
      return { success: true, message: '生成成功', insight }
    } catch (error) {
@@ -619,6 +715,207 @@ ${topMentionText}
    }
  }

+  async generateMessageInsight(params: {
+    sessionId: string
+    displayName?: string
+    avatarUrl?: string
+    targetLocalId?: number
+    targetCreateTime?: number
+    targetMessageKey?: string
+    targetText: string
+    targetSenderName?: string
+    contextCount?: number
+    forceRefresh?: boolean
+  }): Promise<{ success: boolean; message: string; cached?: boolean; recordId?: string; data?: MessageInsightAnalysis }> {
+    const enabled = this.config.get('aiMessageInsightEnabled') === true
+    if (!enabled) {
+      return { success: false, message: '请先在设置中开启「消息解析」' }
+    }
+
+    const sessionId = String(params?.sessionId || '').trim()
+    const targetText = clampText(params?.targetText || '', 500)
+    const targetCreateTime = Math.floor(Number(params?.targetCreateTime || 0))
+    const targetLocalId = Math.floor(Number(params?.targetLocalId || 0))
+    const targetMessageKey = String(params?.targetMessageKey || '').trim()
+    if (!sessionId || !targetText || targetCreateTime <= 0) {
+      return { success: false, message: '目标消息无效，无法解析' }
+    }
+
+    if (params?.forceRefresh !== true) {
+      const cached = insightRecordService.findLatestMessageAnalysis({
+        sessionId,
+        targetLocalId,
+        targetCreateTime,
+        targetMessageKey
+      })
+      if (cached?.messageInsight?.analysis) {
+        return {
+          success: true,
+          message: '已读取缓存解析',
+          cached: true,
+          recordId: cached.id,
+          data: cached.messageInsight.analysis
+        }
+      }
+    }
+
+    const { apiBaseUrl, apiKey, model, maxTokens } = this.getSharedAiModelConfig()
+    if (!apiBaseUrl || !apiKey) {
+      return { success: false, message: '请先填写通用 AI 模型配置（API 地址和 Key）' }
+    }
+
+    const configuredContextCount = Number(this.config.get('aiMessageInsightContextCount') || 50)
+    const contextCount = Math.max(1, Math.min(200, Math.floor(Number(params?.contextCount || configuredContextCount) || 50)))
+    const displayName = await this.resolveInsightSessionDisplayName(sessionId, String(params?.displayName || sessionId))
+    const targetSenderName = clampText(params?.targetSenderName || displayName, 40) || displayName
+    const targetTextPreview = clampText(targetText, 120)
+    let avatarUrl = String(params?.avatarUrl || '').trim() || undefined
+    if (!avatarUrl) {
+      try {
+        const contact = await chatService.getContactAvatar(sessionId)
+        avatarUrl = String(contact?.avatarUrl || '').trim() || undefined
+      } catch {
+        avatarUrl = undefined
+      }
+    }
+
+    let beforeMessages: Message[] = []
+    let afterMessages: Message[] = []
+    let contextReadError = ''
+    try {
+      const aroundResult = await chatService.getMessagesAround(
+        sessionId,
+        { localId: targetLocalId, createTime: targetCreateTime, messageKey: targetMessageKey },
+        contextCount
+      )
+      if (aroundResult.success) {
+        beforeMessages = aroundResult.before || []
+        afterMessages = aroundResult.after || []
+      } else {
+        contextReadError = aroundResult.error || '读取上下文失败'
+      }
+    } catch (error) {
+      contextReadError = (error as Error).message || String(error)
+    }
+
+    const formatLine = (message: Message) => {
+      const senderName = message.isSend === 1 ? '我' : (message.senderDisplayName || targetSenderName || displayName)
+      return `${this.formatInsightMessageTimestamp(message.createTime)} ${senderName}：${this.formatInsightMessageContent(message)}`
+    }
+    const beforeText = beforeMessages.length > 0 ? beforeMessages.map(formatLine).join('\n') : '无'
+    const afterText = afterMessages.length > 0 ? afterMessages.map(formatLine).join('\n') : '无'
+
+    const DEFAULT_MESSAGE_INSIGHT_PROMPT = `你是一个克制、准确的聊天语义分析助手。你的任务是把用户选中的一句聊天消息做深度解析，帮助用户理解对方未明说的含义。
+
+严格要求：
+1. 必须且只能输出合法的纯 JSON。
+2. 禁止输出解释说明、前言后语，禁止使用 Markdown 或代码块。
+3. 不要编造上下文没有支持的信息；不确定时用谨慎表述。
+4. explicit_text 用自然中文说明这句话可能想表达的真实含义，80字以内。
+5. emotion、intent、topic 必须是短标签。
+
+JSON 输出格式：
+{
+  "explicit_text": "暗示转明示，80字以内",
+  "emotion": "2-6字情绪标签",
+  "intent": "2-8字意图标签",
+  "topic": "2-8字话题标签"
+}`
+    const customPrompt = String(this.config.get('aiMessageInsightSystemPrompt') || '').trim()
+    const systemPrompt = customPrompt || DEFAULT_MESSAGE_INSIGHT_PROMPT
+    const userPromptBase = `会话：${displayName}
+目标发送者：${targetSenderName}
+目标消息时间：${this.formatInsightMessageTimestamp(targetCreateTime)}
+
+目标消息：
+${targetText}
+
+目标消息之前的上下文（${beforeMessages.length} 条）：
+${beforeText}
+
+目标消息之后的上下文（${afterMessages.length} 条）：
+${afterText}
+
+请分析目标消息，只输出指定 JSON。`
+    const userPrompt = appendPromptCurrentTime(userPromptBase)
+    const endpoint = buildApiUrl(apiBaseUrl, '/chat/completions')
+    const requestMessages = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt }
+    ]
+
+    let rawOutput = ''
+    let responseFormatJson = true
+    let responseFormatFallback = false
+    let responseFormatFallbackReason = ''
+    const startedAt = Date.now()
+    try {
+      try {
+        rawOutput = await callApi(apiBaseUrl, apiKey, model, requestMessages, API_TIMEOUT_MS, maxTokens, { responseFormatJson: true })
+      } catch (error) {
+        if (!shouldFallbackJsonMode(error)) throw error
+        responseFormatJson = false
+        responseFormatFallback = true
+        responseFormatFallbackReason = (error as Error).message || 'response_format 不受支持'
+        rawOutput = await callApi(apiBaseUrl, apiKey, model, requestMessages, API_TIMEOUT_MS, maxTokens)
+      }
+      const analysis = parseMessageInsightAnalysis(rawOutput)
+      const finalInsight = analysis.explicitText
+      const log: InsightRecordLog = {
+        endpoint,
+        model,
+        maxTokens,
+        temperature: API_TEMPERATURE,
+        triggerReason: 'message_analysis',
+        allowContext: true,
+        contextCount,
+        systemPrompt,
+        userPrompt,
+        rawOutput,
+        finalInsight,
+        durationMs: Date.now() - startedAt,
+        createdAt: Date.now(),
+        responseFormatJson,
+        responseFormatFallback,
+        responseFormatFallbackReason,
+        targetMessage: {
+          localId: targetLocalId,
+          createTime: targetCreateTime,
+          messageKey: targetMessageKey,
+          senderName: targetSenderName,
+          textPreview: targetTextPreview
+        },
+        contextStats: {
+          requested: contextCount,
+          beforeTarget: beforeMessages.length,
+          afterTarget: afterMessages.length,
+          readError: contextReadError || undefined
+        },
+        parsedAnalysis: analysis
+      }
+      const record = insightRecordService.addRecord({
+        sessionId,
+        displayName,
+        avatarUrl,
+        sourceType: 'message_analysis',
+        triggerReason: 'message_analysis',
+        insight: finalInsight,
+        messageInsight: {
+          targetLocalId,
+          targetCreateTime,
+          targetMessageKey,
+          targetSenderName,
+          targetTextPreview,
+          analysis
+        },
+        log
+      })
+      return { success: true, message: '解析完成', cached: false, recordId: record.id, data: analysis }
+    } catch (error) {
+      return { success: false, message: `解析失败：${(error as Error).message}` }
+    }
+  }
+
  // ── 私有方法 ────────────────────────────────────────────────────────────────

  private isEnabled(): boolean {
@@ -747,14 +1044,23 @@ ${topMentionText}

  /**
   * 判断某个会话是否允许触发见解。
-   * 若白名单未启用，则所有私聊会话均允许；
-   * 若白名单已启用，则只有在白名单中的会话才允许。
+   * white/black 模式二选一：
+   * - whitelist：仅名单内允许
+   * - blacklist：名单内屏蔽，其他允许
   */
+  private getInsightFilterConfig(): { mode: InsightFilterMode; list: string[] } {
+    const modeRaw = String(this.config.get('aiInsightFilterMode') || '').trim().toLowerCase()
+    const mode: InsightFilterMode = modeRaw === 'blacklist' ? 'blacklist' : 'whitelist'
+    const list = normalizeSessionIdList(this.config.get('aiInsightFilterList'))
+    return { mode, list }
+  }
+
  private isSessionAllowed(sessionId: string): boolean {
-    const whitelistEnabled = this.config.get('aiInsightWhitelistEnabled') as boolean
-    if (!whitelistEnabled) return true
-    const whitelist = (this.config.get('aiInsightWhitelist') as string[]) || []
-    return whitelist.includes(sessionId)
+    const normalizedSessionId = String(sessionId || '').trim()
+    if (!normalizedSessionId) return false
+    const { mode, list } = this.getInsightFilterConfig()
+    if (mode === 'whitelist') return list.includes(normalizedSessionId)
+    return !list.includes(normalizedSessionId)
  }

  /**
@@ -805,26 +1111,13 @@ ${topMentionText}
  }

  /**
-   * 记录触发并返回该会话今日所有触发时间（用于组装 prompt）。
+   * 记录成功推送的见解，用于设置页展示今日触发统计。
   */
-  private recordTrigger(sessionId: string): string[] {
+  private recordTrigger(sessionId: string): void {
    this.resetIfNewDay()
    const existing = this.todayTriggers.get(sessionId) ?? { timestamps: [] }
    existing.timestamps.push(Date.now())
    this.todayTriggers.set(sessionId, existing)
-    return existing.timestamps.map(formatTimestamp)
-  }
-
-  /**
-   * 获取今日全局已触发次数（所有会话合计），用于 prompt 中告知模型全局上下文。
-   */
-  private getTodayTotalTriggerCount(): number {
-    this.resetIfNewDay()
-    let total = 0
-    for (const record of this.todayTriggers.values()) {
-      total += record.timestamps.length
-    }
-    return total
  }

  private formatWeiboTimestamp(raw: string): string {
@@ -835,12 +1128,66 @@ ${topMentionText}
    return new Date(parsed).toLocaleString('zh-CN')
  }

+  private formatMomentsTimestamp(raw: unknown): string {
+    const numeric = Number(raw)
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+      return ''
+    }
+    const ms = numeric > 1_000_000_000_000 ? numeric : numeric * 1000
+    return new Date(ms).toLocaleString('zh-CN')
+  }
+
+  private extractMomentReadableText(post: { contentDesc?: unknown; linkTitle?: unknown }): string {
+    const contentDesc = this.normalizeInsightText(String(post.contentDesc || '')).replace(/\s+/g, ' ').trim()
+    if (contentDesc) return contentDesc
+
+    const linkTitle = this.normalizeInsightText(String(post.linkTitle || '')).replace(/\s+/g, ' ').trim()
+    if (linkTitle) return `[链接] ${linkTitle}`
+
+    return ''
+  }
+
+  private async getMomentsContextSection(sessionId: string): Promise<string> {
+    const allowMomentsContext = this.config.get('aiInsightAllowMomentsContext') === true
+    if (!allowMomentsContext) return ''
+
+    const bindings =
+      (this.config.get('aiInsightMomentsBindings') as Record<string, { enabled?: boolean }> | undefined) || {}
+    const isEnabledForSession = bindings[sessionId]?.enabled === true
+    if (!isEnabledForSession) return ''
+
+    const countRaw = Number(this.config.get('aiInsightMomentsContextCount') || 5)
+    const momentsCount = Math.max(1, Math.min(20, Math.floor(countRaw) || 5))
+
+    try {
+      const result = await snsService.getTimeline(momentsCount, 0, [sessionId])
+      const posts = result.success && Array.isArray(result.timeline) ? result.timeline : []
+      if (posts.length === 0) return ''
+
+      const lines = posts
+        .map((post) => {
+          const text = this.extractMomentReadableText(post as { contentDesc?: unknown; linkTitle?: unknown })
+          if (!text) return ''
+          const shortText = text.length > 180 ? `${text.slice(0, 180)}...` : text
+          const time = this.formatMomentsTimestamp((post as { createTime?: unknown }).createTime)
+          return time ? `[朋友圈 ${time}] ${shortText}` : `[朋友圈] ${shortText}`
+        })
+        .filter(Boolean) as string[]
+
+      if (lines.length === 0) return ''
+      insightLog('INFO', `已加载 ${lines.length} 条朋友圈内容 (sessionId=${sessionId})`)
+      return `近期朋友圈内容（最近 ${lines.length} 条）：\n${lines.join('\n')}`
+    } catch (error) {
+      insightLog('WARN', `拉取朋友圈内容失败 (sessionId=${sessionId}): ${(error as Error).message}`)
+      return ''
+    }
+  }
+
  private async getSocialContextSection(sessionId: string): Promise<string> {
    const allowSocialContext = this.config.get('aiInsightAllowSocialContext') === true
    if (!allowSocialContext) return ''

    const rawCookie = String(this.config.get('aiInsightWeiboCookie') || '').trim()
-    const hasCookie = rawCookie.length > 0

    const bindings =
      (this.config.get('aiInsightWeiboBindings') as Record<string, { uid?: string; screenName?: string }> | undefined) || {}
@@ -861,10 +1208,7 @@ ${topMentionText}
        return `[微博 ${time}] ${text}`
      })
      insightLog('INFO', `已加载 ${lines.length} 条微博公开内容 (uid=${uid})`)
-      const riskHint = hasCookie
-        ? ''
-        : '\n提示：未配置微博 Cookie，使用移动端公开接口抓取，可能因平台风控导致获取失败或内容较少。'
-      return `近期公开社交平台内容（来源：微博，最近 ${lines.length} 条）：\n${lines.join('\n')}${riskHint}`
+      return `近期公开社交平台内容（来源：微博，最近 ${lines.length} 条）：\n${lines.join('\n')}`
    } catch (error) {
      insightLog('WARN', `拉取微博公开内容失败 (uid=${uid}): ${(error as Error).message}`)
      return ''
@@ -966,8 +1310,8 @@ ${topMentionText}
   * 1. 会话有真正的新消息（lastTimestamp 比上次见到的更新）
   * 2. 该会话距上次活跃分析已超过冷却期
   *
-   * 白名单启用时：直接使用白名单里的 sessionId，完全跳过 getSessions()。
-   * 白名单未启用时：从缓存拉取全量会话后过滤私聊。
+   * whitelist 模式：直接使用名单里的 sessionId，完全跳过 getSessions()。
+   * blacklist 模式：从缓存拉取会话后过滤名单。
   */
  private async analyzeRecentActivity(): Promise<void> {
    if (!this.isEnabled()) return
@@ -978,12 +1322,11 @@ ${topMentionText}
      const now = Date.now()
      const cooldownMinutes = (this.config.get('aiInsightCooldownMinutes') as number) ?? 120
      const cooldownMs = cooldownMinutes * 60 * 1000
-      const whitelistEnabled = this.config.get('aiInsightWhitelistEnabled') as boolean
-      const whitelist = (this.config.get('aiInsightWhitelist') as string[]) || []
+      const { mode: filterMode, list: filterList } = this.getInsightFilterConfig()

-      // 白名单启用且有勾选项时，直接用白名单 sessionId，无需查数据库全量会话列表。
+      // whitelist 模式且有勾选项时，直接用名单 sessionId，无需查数据库全量会话列表。
      // 通过拉取该会话最新 1 条消息时间戳判断是否真正有新消息，开销极低。
-      if (whitelistEnabled && whitelist.length > 0) {
+      if (filterMode === 'whitelist' && filterList.length > 0) {
        // 确保数据库已连接（首次时连接，之后复用）
        if (!this.dbConnected) {
          const connectResult = await chatService.connect()
@@ -991,8 +1334,8 @@ ${topMentionText}
          this.dbConnected = true
        }

-        for (const sessionId of whitelist) {
-          if (!sessionId || sessionId.endsWith('@chatroom')) continue
+        for (const sessionId of filterList) {
+          if (!sessionId || sessionId.toLowerCase().includes('placeholder')) continue

          // 冷却期检查（先过滤，减少不必要的 DB 查询）
          if (cooldownMs > 0) {
@@ -1029,16 +1372,22 @@ ${topMentionText}
        return
      }

-      // 白名单未启用：需要拉取全量会话列表，从中过滤私聊
+      if (filterMode === 'whitelist' && filterList.length === 0) {
+        insightLog('INFO', '白名单模式且名单为空，跳过活跃分析')
+        return
+      }
+
+      // blacklist 模式：拉取会话缓存后按过滤规则筛选
      const sessions = await this.getSessionsCached()
      if (sessions.length === 0) return

-      const privateSessions = sessions.filter((s) => {
+      const candidateSessions = sessions.filter((s) => {
        const id = s.username?.trim() || ''
-        return id && !id.endsWith('@chatroom') && !id.toLowerCase().includes('placeholder')
+        if (!id || id.toLowerCase().includes('placeholder')) return false
+        return this.isSessionAllowed(id)
      })

-      for (const session of privateSessions.slice(0, 10)) {
+      for (const session of candidateSessions.slice(0, 10)) {
        const sessionId = session.username?.trim() || ''
        if (!sessionId) continue

@@ -1074,31 +1423,34 @@ ${topMentionText}
  private async generateInsightForSession(params: {
    sessionId: string
    displayName: string
-    triggerReason: 'activity' | 'silence'
+    triggerReason: InsightRecordTriggerReason
    silentDays?: number
-  }): Promise<void> {
+  }): Promise<SessionInsightTriggerResult> {
    const { sessionId, displayName, triggerReason, silentDays } = params
-    if (!sessionId) return
-    if (!this.isEnabled()) return
+    if (!sessionId) return { success: false, message: '会话无效，无法生成见解' }
+    if (!this.isEnabled()) return { success: false, message: '请先在设置中开启「AI 见解」' }

    const { apiBaseUrl, apiKey, model, maxTokens } = this.getSharedAiModelConfig()
    const allowContext = this.config.get('aiInsightAllowContext') as boolean
    const contextCount = (this.config.get('aiInsightContextCount') as number) || 40
    const resolvedDisplayName = await this.resolveInsightSessionDisplayName(sessionId, displayName)
+    let resolvedAvatarUrl: string | undefined
+    try {
+      const contact = await chatService.getContactAvatar(sessionId)
+      resolvedAvatarUrl = String(contact?.avatarUrl || '').trim() || undefined
+    } catch {
+      resolvedAvatarUrl = undefined
+    }

    insightLog('INFO', `generateInsightForSession: sessionId=${sessionId}, reason=${triggerReason}, contextCount=${contextCount}, api=${apiBaseUrl ? '已配置' : '未配置'}`)

    if (!apiBaseUrl || !apiKey) {
      insightLog('WARN', 'API 地址或 Key 未配置，跳过见解生成')
-      return
+      return { success: false, message: '请先填写通用 AI 模型配置（API 地址和 Key）' }
    }

    // ── 构建 prompt ────────────────────────────────────────────────────────────

-    // 今日触发统计（让模型具备时间与克制感）
-    const sessionTriggerTimes = this.recordTrigger(sessionId)
-    const totalTodayTriggers = this.getTodayTotalTriggerCount()
-
    let contextSection = ''
    if (allowContext) {
      try {
@@ -1113,6 +1465,7 @@ ${topMentionText}
      }
    }

+    const momentsContextSection = await this.getMomentsContextSection(sessionId)
    const socialContextSection = await this.getSocialContextSection(sessionId)

    // ── 默认 system prompt（稳定内容，有利于 provider 端 prompt cache 命中）────
@@ -1128,25 +1481,12 @@ ${topMentionText}
    const customPrompt = (this.config.get('aiInsightSystemPrompt') as string) || ''
    const systemPrompt = customPrompt.trim() || DEFAULT_SYSTEM_PROMPT

-    // 可变的上下文统计信息放在 user message 里，保持 system prompt 稳定不变
-    // 这样 provider 端（Anthropic/OpenAI）能最大化命中 prompt cache，降低费用
-    const triggerDesc =
-      triggerReason === 'silence'
-        ? `你已经 ${silentDays} 天没有和「${resolvedDisplayName}」聊天了。`
-        : `你最近和「${resolvedDisplayName}」有新的聊天动态。`
-
-    const todayStatsDesc =
-      sessionTriggerTimes.length > 1
-        ? `今天你已经针对「${resolvedDisplayName}」收到过 ${sessionTriggerTimes.length - 1} 条见解（时间：${sessionTriggerTimes.slice(0, -1).join('、')}），请适当克制。`
-        : `今天你还没有针对「${resolvedDisplayName}」发出过见解。`
-
-    const globalStatsDesc = `今天全部联系人合计已触发 ${totalTodayTriggers} 条见解。`
-
    const userPromptBase = [
-      `触发原因：${triggerDesc}`,
-      `时间统计：${todayStatsDesc}`,
-      `全局统计：${globalStatsDesc}`,
+      triggerReason === 'silence' && silentDays
+        ? `已 ${silentDays} 天未联系「${resolvedDisplayName}」。`
+        : '',
      contextSection,
+      momentsContextSection,
      socialContextSection,
      '请给出你的见解（≤80字）：'
    ].filter(Boolean).join('\n\n')
@@ -1166,7 +1506,7 @@ ${topMentionText}
        `接口地址：${endpoint}`,
        `模型：${model}`,
        `Max Tokens：${maxTokens}`,
-        `触发原因：${triggerReason}`,
+        `触发类型：${triggerReason}`,
        `上下文开关：${allowContext ? '开启' : '关闭'}`,
        `上下文条数：${contextCount}`,
        '',
@@ -1179,6 +1519,7 @@ ${topMentionText}
    )

    try {
+      const apiStartedAt = Date.now()
      const result = await callApi(
        apiBaseUrl,
        apiKey,
@@ -1187,6 +1528,7 @@ ${topMentionText}
        API_TIMEOUT_MS,
        maxTokens
      )
+      const apiDurationMs = Date.now() - apiStartedAt

      insightLog('INFO', `API 返回原文: ${result.slice(0, 150)}`)
      insightDebugSection('INFO', `AI 输出原文 ${resolvedDisplayName} (${sessionId})`, result)
@@ -1194,21 +1536,51 @@ ${topMentionText}
      // 模型主动选择跳过
      if (result.trim().toUpperCase() === 'SKIP' || result.trim().startsWith('SKIP')) {
        insightLog('INFO', `模型选择跳过 ${resolvedDisplayName}`)
-        return
+        return { success: true, message: `模型判断「${resolvedDisplayName}」暂无可生成的见解`, skipped: true }
      }
-      if (!this.isEnabled()) return
+      if (!this.isEnabled()) return { success: false, message: 'AI 见解已关闭，生成结果未保存' }

-      const insight = result.slice(0, 120)
+      const insight = result.trim()
      const notifTitle = `见解 · ${resolvedDisplayName}`
+      const recordLog: InsightRecordLog = {
+        endpoint,
+        model,
+        maxTokens,
+        temperature: API_TEMPERATURE,
+        triggerReason,
+        allowContext,
+        contextCount,
+        systemPrompt,
+        userPrompt,
+        rawOutput: result,
+        finalInsight: insight,
+        durationMs: apiDurationMs,
+        createdAt: Date.now()
+      }
+      const record = insightRecordService.addRecord({
+        sessionId,
+        displayName: resolvedDisplayName,
+        avatarUrl: resolvedAvatarUrl,
+        triggerReason,
+        insight,
+        log: recordLog
+      })

-      insightLog('INFO', `推送通知 → ${resolvedDisplayName}: ${insight}`)
+      const insightNotificationEnabled = this.config.get('aiInsightNotificationEnabled') !== false
+      if (insightNotificationEnabled) {
+        insightLog('INFO', `推送通知 → ${resolvedDisplayName}: ${insight}`)

-      // 渠道一：Electron 原生系统通知
-      if (Notification.isSupported()) {
-        const notif = new Notification({ title: notifTitle, body: insight, silent: false })
-        notif.show()
+        // 渠道一：应用内通知窗口。AI 见解使用独立通知开关，不受新消息通知开关和会话过滤影响。
+        await showNotification({
+          title: notifTitle,
+          content: insight,
+          avatarUrl: INSIGHT_NOTIFICATION_AVATAR_URL,
+          sessionId,
+          insightRecordId: record.id,
+          channel: 'ai-insight'
+        })
      } else {
-        insightLog('WARN', '当前系统不支持原生通知')
+        insightLog('INFO', `AI 见解消息通知已关闭，跳过应用通知 → ${resolvedDisplayName}: ${insight}`)
      }

      // 渠道二：Telegram Bot 推送（可选）
@@ -1229,7 +1601,17 @@ ${topMentionText}
        }
      }

-      insightLog('INFO', `已为 ${resolvedDisplayName} 推送见解`)
+      insightLog('INFO', `已完成 ${resolvedDisplayName} 的见解处理`)
+      this.recordTrigger(sessionId)
+      return {
+        success: true,
+        message: insightNotificationEnabled
+          ? `已生成「${resolvedDisplayName}」的 AI 见解，请查看通知弹窗`
+          : `已生成「${resolvedDisplayName}」的 AI 见解，AI 见解消息通知当前已关闭`,
+        recordId: record.id,
+        insight,
+        notificationEnabled: insightNotificationEnabled
+      }
    } catch (e) {
      insightDebugSection(
        'ERROR',
@@ -1237,6 +1619,7 @@ ${topMentionText}
        `错误信息：${(e as Error).message}\n\n堆栈：\n${(e as Error).stack || '[无堆栈]'}`
      )
      insightLog('ERROR', `API 调用失败 (${resolvedDisplayName}): ${(e as Error).message}`)
+      return { success: false, message: `生成失败：${(e as Error).message}` }
    }
  }

--- a/electron/services/keyService.ts
+++ b/electron/services/keyService.ts
@@ -10,6 +10,10 @@ const execFileAsync = promisify(execFile)

 type DbKeyResult = { success: boolean; key?: string; error?: string; logs?: string[] }
 type ImageKeyResult = { success: boolean; xorKey?: number; aesKey?: string; verified?: boolean; error?: string }
+type DbKeyPollResult =
+  | { status: 'success'; key: string; loginRequiredDetected: boolean }
+  | { status: 'process-ended'; loginRequiredDetected: boolean }
+  | { status: 'timeout'; loginRequiredDetected: boolean }

 export class KeyService {
  private readonly isMac = process.platform === 'darwin'
@@ -58,6 +62,7 @@ export class KeyService {
  private readonly HKEY_CURRENT_USER = 0x80000001
  private readonly ERROR_SUCCESS = 0
  private readonly WM_CLOSE = 0x0010
+  private readonly DB_KEY_PROCESS_CHECK_INTERVAL_MS = 1000

  private getDllPath(): string {
    const isPackaged = typeof app !== 'undefined' && app ? app.isPackaged : process.env.NODE_ENV === 'production'
@@ -342,30 +347,169 @@ export class KeyService {
    return null
  }

-  private async findPidByImageName(imageName: string): Promise<number | null> {
+  private async findPidsByImageName(imageName: string): Promise<number[]> {
    try {
      const { stdout } = await execFileAsync('tasklist', ['/FI', `IMAGENAME eq ${imageName}`, '/FO', 'CSV', '/NH'])
      const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+      const pids: number[] = []
      for (const line of lines) {
        if (line.startsWith('INFO:')) continue
        const parts = line.split('","').map((p) => p.replace(/^"|"$/g, ''))
        if (parts[0]?.toLowerCase() === imageName.toLowerCase()) {
          const pid = Number(parts[1])
-          if (!Number.isNaN(pid)) return pid
+          if (!Number.isNaN(pid)) pids.push(pid)
        }
      }
-      return null
+      return pids
    } catch (e) {
-      return null
+      return []
    }
  }

-  private async findWeChatPid(): Promise<number | null> {
-    const names = ['Weixin.exe', 'WeChat.exe']
-    for (const name of names) {
-      const pid = await this.findPidByImageName(name)
+  private async findWeChatPids(): Promise<number[]> {
+    const pids: number[] = []
+    const pushUnique = (pid: number | null | undefined) => {
+      if (!pid || pids.includes(pid)) return
+      pids.push(pid)
+    }
+
+    for (const name of ['Weixin.exe', 'WeChat.exe']) {
+      const found = await this.findPidsByImageName(name)
+      found.forEach(pushUnique)
+    }
+    return pids
+  }
+
+  private async isWeChatPidActive(pid: number): Promise<boolean> {
+    const pids = await this.findWeChatPids()
+    if (pids.includes(pid)) return true
+
+    const fallbackPid = await this.waitForWeChatWindow(250)
+    return fallbackPid === pid
+  }
+
+  private async waitForWeChatPid(timeoutMs: number): Promise<number | null> {
+    const start = Date.now()
+    while (Date.now() - start < timeoutMs) {
+      const pids = await this.findWeChatPids()
+      if (pids.length > 0) return pids[0]
+
+      const fallbackPid = await this.waitForWeChatWindow(250)
+      if (fallbackPid) return fallbackPid
+
+      await new Promise(r => setTimeout(r, 500))
+    }
+    return null
+  }
+
+  private getRemainingMs(deadline: number): number {
+    return Math.max(0, deadline - Date.now())
+  }
+
+  private async pollDbKeyFromHook(
+      pid: number,
+      deadline: number,
+      logs: string[],
+      onStatus?: (message: string, level: number) => void
+  ): Promise<DbKeyPollResult> {
+    const keyBuffer = Buffer.alloc(128)
+    let loginRequiredDetected = false
+    let nextProcessCheckAt = 0
+
+    while (Date.now() < deadline) {
+      const now = Date.now()
+      if (now >= nextProcessCheckAt) {
+        nextProcessCheckAt = now + this.DB_KEY_PROCESS_CHECK_INTERVAL_MS
+        if (!await this.isWeChatPidActive(pid)) {
+          return { status: 'process-ended', loginRequiredDetected }
+        }
+      }
+
+      if (this.pollKeyData(keyBuffer, keyBuffer.length)) {
+        const key = this.decodeUtf8(keyBuffer)
+        if (key.length === 64) {
+          onStatus?.('密钥获取成功', 1)
+          return { status: 'success', key, loginRequiredDetected }
+        }
+      }
+
+      for (let i = 0; i < 5; i++) {
+        const statusBuffer = Buffer.alloc(256)
+        const levelOut = [0]
+        if (!this.getStatusMessage(statusBuffer, statusBuffer.length, levelOut)) break
+        const msg = this.decodeUtf8(statusBuffer)
+        const level = levelOut[0] ?? 0
+        if (msg) {
+          logs.push(msg)
+          if (this.isLoginRelatedText(msg)) {
+            loginRequiredDetected = true
+          }
+          onStatus?.(msg, level)
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, 120))
+    }
+
+    return { status: 'timeout', loginRequiredDetected }
+  }
+
+  private cleanupDbKeyHook(): void {
+    try {
+      this.cleanupHook()
+    } catch { }
+  }
+
+  private buildInitHookError(): string {
+    const error = this.getLastErrorMsg ? this.decodeCString(this.getLastErrorMsg()) : ''
+    if (error) {
+      if (error.includes('0xC0000022') || error.includes('ACCESS_DENIED') || error.includes('打开目标进程失败')) {
+        return '权限不足：无法访问微信进程。\n\n解决方法：\n1. 右键 WeFlow 图标，选择"以管理员身份运行"\n2. 关闭可能拦截的安全软件（如360、火绒等）\n3. 确保微信没有以管理员权限运行'
+      }
+      return error
+    }
+
+    const statusBuffer = Buffer.alloc(256)
+    const levelOut = [0]
+    const status = this.getStatusMessage && this.getStatusMessage(statusBuffer, statusBuffer.length, levelOut)
+        ? this.decodeUtf8(statusBuffer)
+        : ''
+    return status || '初始化失败'
+  }
+
+  private async waitForNextDbKeyPid(deadline: number, onStatus?: (message: string, level: number) => void): Promise<number | null> {
+    while (this.getRemainingMs(deadline) > 0) {
+      onStatus?.('正在查找微信进程...', 0)
+      const pid = await this.waitForWeChatPid(Math.min(this.getRemainingMs(deadline), 30_000))
      if (pid) return pid
    }
+    return null
+  }
+
+  private shouldRetryAfterProcessLost(deadline: number): boolean {
+    return this.getRemainingMs(deadline) > 1000
+  }
+
+  private async delayBeforeRetry(): Promise<void> {
+    await new Promise((resolve) => setTimeout(resolve, 500))
+  }
+
+  private async waitForProcessRestart(deadline: number, onStatus?: (message: string, level: number) => void): Promise<number | null> {
+    if (!this.shouldRetryAfterProcessLost(deadline)) return null
+    onStatus?.('检测到微信已退出，已清理 Hook，等待重新打开微信...', 0)
+    await this.delayBeforeRetry()
+    return this.waitForNextDbKeyPid(deadline, onStatus)
+  }
+
+  private async detectLoginRequiredForLastPid(pid: number | null, loginRequiredDetected: boolean): Promise<boolean> {
+    if (loginRequiredDetected) return true
+    if (!pid) return false
+    if (!await this.isWeChatPidActive(pid)) return false
+    return await this.detectWeChatLoginRequired(pid)
+  }
+
+  private async findWeChatPid(): Promise<number | null> {
+    const pids = await this.findWeChatPids()
+    if (pids.length > 0) return pids[0]
    const fallbackPid = await this.waitForWeChatWindow(5000)
    return fallbackPid ?? null
  }
@@ -373,9 +517,8 @@ export class KeyService {
  private async waitForWeChatExit(timeoutMs = 8000): Promise<boolean> {
    const start = Date.now()
    while (Date.now() - start < timeoutMs) {
-      const weixinPid = await this.findPidByImageName('Weixin.exe')
-      const wechatPid = await this.findPidByImageName('WeChat.exe')
-      if (!weixinPid && !wechatPid) return true
+      const runningPids = await this.findWeChatPids()
+      if (runningPids.length === 0) return true
      await new Promise(r => setTimeout(r, 400))
    }
    return false
@@ -604,7 +747,7 @@ export class KeyService {
    return true
  }

-  // --- DB Key Logic (Unchanged core flow) ---
+  // --- DB Key Logic (core hook/poll flow unchanged) ---

  async autoGetDbKey(
      timeoutMs = 60_000,
@@ -615,74 +758,56 @@ export class KeyService {
    if (!this.ensureKernel32()) return { success: false, error: 'Kernel32 Init Failed' }

    const logs: string[] = []
-
+    const deadline = Date.now() + timeoutMs
    onStatus?.('正在查找微信进程...', 0)
-    const pid = await this.findWeChatPid()
+    let pid = await this.findWeChatPid()
    if (!pid) {
      const err = '未找到微信进程，请先启动微信'
      onStatus?.(err, 2)
      return { success: false, error: err }
    }
+    let lastAttemptLoginRequiredDetected = false

-    onStatus?.(`检测到微信窗口 (PID: ${pid})，正在获取...`, 0)
-    onStatus?.('正在检测微信界面组件...', 0)
-    await this.waitForWeChatWindowComponents(pid, 15000)
+    while (pid && this.getRemainingMs(deadline) > 0) {
+      onStatus?.(`检测到微信窗口 (PID: ${pid})，正在获取...`, 0)
+      onStatus?.('正在检测微信界面组件...', 0)
+      await this.waitForWeChatWindowComponents(pid, Math.min(15000, this.getRemainingMs(deadline)))

-    const ok = this.initHook(pid)
-    if (!ok) {
-      const error = this.getLastErrorMsg ? this.decodeCString(this.getLastErrorMsg()) : ''
-      if (error) {
-        if (error.includes('0xC0000022') || error.includes('ACCESS_DENIED') || error.includes('打开目标进程失败')) {
-          const friendlyError = '权限不足：无法访问微信进程。\n\n解决方法：\n1. 右键 WeFlow 图标，选择"以管理员身份运行"\n2. 关闭可能拦截的安全软件（如360、火绒等）\n3. 确保微信没有以管理员权限运行'
-          return { success: false, error: friendlyError }
-        }
-        return { success: false, error }
+      if (!await this.isWeChatPidActive(pid)) {
+        pid = await this.waitForProcessRestart(deadline, onStatus)
+        continue
      }
-      const statusBuffer = Buffer.alloc(256)
-      const levelOut = [0]
-      const status = this.getStatusMessage && this.getStatusMessage(statusBuffer, statusBuffer.length, levelOut)
-          ? this.decodeUtf8(statusBuffer)
-          : ''
-      return { success: false, error: status || '初始化失败' }
-    }

-    const keyBuffer = Buffer.alloc(128)
-    const start = Date.now()
-    let loginRequiredDetected = false
-
-    try {
-      while (Date.now() - start < timeoutMs) {
-        if (this.pollKeyData(keyBuffer, keyBuffer.length)) {
-          const key = this.decodeUtf8(keyBuffer)
-          if (key.length === 64) {
-            onStatus?.('密钥获取成功', 1)
-            return { success: true, key, logs }
-          }
+      const ok = this.initHook(pid)
+      if (!ok) {
+        if (!await this.isWeChatPidActive(pid)) {
+          this.cleanupDbKeyHook()
+          pid = await this.waitForProcessRestart(deadline, onStatus)
+          continue
        }
-
-        for (let i = 0; i < 5; i++) {
-          const statusBuffer = Buffer.alloc(256)
-          const levelOut = [0]
-          if (!this.getStatusMessage(statusBuffer, statusBuffer.length, levelOut)) break
-          const msg = this.decodeUtf8(statusBuffer)
-          const level = levelOut[0] ?? 0
-          if (msg) {
-            logs.push(msg)
-            if (this.isLoginRelatedText(msg)) {
-              loginRequiredDetected = true
-            }
-            onStatus?.(msg, level)
-          }
-        }
-        await new Promise((resolve) => setTimeout(resolve, 120))
+        return { success: false, error: this.buildInitHookError(), logs }
      }
-    } finally {
+
+      let pollResult: DbKeyPollResult
      try {
-        this.cleanupHook()
-      } catch { }
+        pollResult = await this.pollDbKeyFromHook(pid, deadline, logs, onStatus)
+      } finally {
+        this.cleanupDbKeyHook()
+      }
+
+      lastAttemptLoginRequiredDetected = pollResult.loginRequiredDetected
+      if (pollResult.status === 'success') {
+        return { success: true, key: pollResult.key, logs }
+      }
+      if (pollResult.status === 'process-ended') {
+        lastAttemptLoginRequiredDetected = false
+        pid = await this.waitForProcessRestart(deadline, onStatus)
+        continue
+      }
+      break
    }

-    const loginRequired = loginRequiredDetected || await this.detectWeChatLoginRequired(pid)
+    const loginRequired = await this.detectLoginRequiredForLastPid(pid, lastAttemptLoginRequiredDetected)
    if (loginRequired) {
      return {
        success: false,
--- a/electron/services/keyServiceLinux.ts
+++ b/electron/services/keyServiceLinux.ts
@@ -5,7 +5,7 @@ import { execFile, exec, spawn } from 'child_process'
 import { promisify } from 'util'
 import crypto from 'crypto'
 import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
+const require = createRequire(__filename);

 const execFileAsync = promisify(execFile)
 const execAsync = promisify(exec)
@@ -167,7 +167,7 @@ export class KeyServiceLinux {

      await new Promise(r => setTimeout(r, 2000))

-      return await this.getDbKey(pid, onStatus)
+      return await this.getDbKey(pid, onStatus, timeoutMs)
    } catch (err: any) {
      console.error('[Debug] 自动获取流程彻底崩溃:', err);
      const errMsg = '自动获取微信 PID 失败: ' + err.message
@@ -176,7 +176,7 @@ export class KeyServiceLinux {
    }
  }

-  public async getDbKey(pid: number, onStatus?: (message: string, level: number) => void): Promise<DbKeyResult> {
+  public async getDbKey(pid: number, onStatus?: (message: string, level: number) => void, timeoutMs = 180_000): Promise<DbKeyResult> {
    try {
      const helperPath = this.getHelperPath()

@@ -193,29 +193,63 @@ export class KeyServiceLinux {
      const targetAddr = scanRes.target_addr
      onStatus?.('基址扫描成功，正在请求管理员权限进行内存 Hook...', 0)

-      return await new Promise((resolve) => {
-        const options = { name: 'WeFlow' }
-        const command = `"${helperPath}" db_hook ${pid} ${targetAddr}`
+      if (!this.sudo || typeof this.sudo.exec !== 'function') {
+        const err = 'Linux 授权组件 @vscode/sudo-prompt 未加载，请确认依赖已安装并重新启动 WeFlow'
+        onStatus?.(err, 2)
+        return { success: false, error: err }
+      }

-        this.sudo.exec(command, options, (error, stdout) => {
+      return await new Promise((resolve) => {
+        const options = {
+          name: 'WeFlow',
+          env: {
+            PATH: `${process.env.PATH || ''}:/bin:/usr/bin:/sbin:/usr/sbin:/usr/local/bin`
+          }
+        }
+        const timeoutSec = Math.ceil((timeoutMs + 15_000) / 1000)
+        const command = `timeout -k 5s ${timeoutSec}s "${helperPath}" db_hook ${pid} ${targetAddr} ${timeoutMs}`
+        let settled = false
+        const finish = (result: DbKeyResult) => {
+          if (settled) return
+          settled = true
+          clearTimeout(watchdog)
+          resolve(result)
+        }
+        const watchdog = setTimeout(() => {
+          execAsync(`kill -CONT ${pid}`).catch(() => {})
+          const err = `Hook 等待超时（${Math.round(timeoutMs / 1000)} 秒）。请确认微信登录确认已完成，或重启微信后重试。`
+          onStatus?.(err, 2)
+          finish({ success: false, error: err })
+        }, timeoutMs + 30_000)
+
+        onStatus?.('授权通过后请在手机上确认登录微信，正在等待密钥回调...', 0)
+
+        this.sudo.exec(command, options, (error, stdout, stderr) => {
          execAsync(`kill -CONT ${pid}`).catch(() => {})
          if (error) {
-            onStatus?.('授权失败或被取消', 2)
-            resolve({ success: false, error: `授权失败或被取消: ${error.message}` })
+            const detail = String(stderr || '').trim()
+            const message = detail ? `${error.message}: ${detail}` : error.message
+            onStatus?.('授权失败或 Hook 执行失败', 2)
+            finish({ success: false, error: `授权失败或 Hook 执行失败: ${message}` })
            return
          }
          try {
-            const hookRes = JSON.parse((stdout as string).trim())
+            const output = String(stdout || '').trim()
+            if (!output) {
+              const detail = String(stderr || '').trim()
+              throw new Error(detail ? `Hook 无输出: ${detail}` : 'Hook 无输出')
+            }
+            const hookRes = JSON.parse(output)
            if (hookRes.success) {
              onStatus?.('密钥获取成功', 1)
-              resolve({ success: true, key: hookRes.key })
+              finish({ success: true, key: hookRes.key })
            } else {
              onStatus?.(hookRes.result, 2)
-              resolve({ success: false, error: hookRes.result })
+              finish({ success: false, error: hookRes.result })
            }
-          } catch (e) {
+          } catch (e: any) {
            onStatus?.('解析 Hook 结果失败', 2)
-            resolve({ success: false, error: '解析 Hook 结果失败' })
+            finish({ success: false, error: e?.message || '解析 Hook 结果失败' })
          }
        })
      })
--- a/electron/services/keyServiceMac.ts
+++ b/electron/services/keyServiceMac.ts
@@ -24,6 +24,9 @@ export class KeyServiceMac {
  private machVmReadOverwrite: any = null
  private machPortDeallocate: any = null
  private _needsElevation = false
+  private restrictedFailureCount = 0
+  private restrictedFailureAt = 0
+  private readonly restrictedFailureWindowMs = 8 * 60_000

  private getHelperPath(): string {
    const isPackaged = app.isPackaged
@@ -186,18 +189,25 @@ export class KeyServiceMac {
      }

      if (!parsed.success) {
-        const errorMsg = this.mapDbKeyErrorMessage(parsed.code, parsed.detail)
+        const errorMsg = this.enrichDbKeyErrorMessage(
+          this.mapDbKeyErrorMessage(parsed.code, parsed.detail),
+          parsed.code,
+          parsed.detail
+        )
        onStatus?.(errorMsg, 2)
        return { success: false, error: errorMsg }
      }

+      this.resetRestrictedFailureState()
      onStatus?.('密钥获取成功', 1)
      return { success: true, key: parsed.key }
    } catch (e: any) {
      console.error('[KeyServiceMac] Error:', e)
      console.error('[KeyServiceMac] Stack:', e.stack)
-      onStatus?.('获取失败: ' + e.message, 2)
-      return { success: false, error: e.message }
+      const rawError = `${e?.message || e || ''}`.trim()
+      const resolvedError = this.resolveUnexpectedDbKeyErrorMessage(rawError)
+      onStatus?.(resolvedError, 2)
+      return { success: false, error: resolvedError }
    }
  }

@@ -223,6 +233,149 @@ export class KeyServiceMac {
    return this.parseDbKeyResult(helperResult)
  }

+  private resetRestrictedFailureState(): void {
+    this.restrictedFailureCount = 0
+    this.restrictedFailureAt = 0
+  }
+
+  private markRestrictedFailureAndGetCount(): number {
+    const now = Date.now()
+    if (now - this.restrictedFailureAt > this.restrictedFailureWindowMs) {
+      this.restrictedFailureCount = 0
+    }
+    this.restrictedFailureAt = now
+    this.restrictedFailureCount += 1
+    return this.restrictedFailureCount
+  }
+
+  private isRestrictedEnvironmentFailure(code?: string, detail?: string): boolean {
+    const normalizedCode = String(code || '').toUpperCase()
+    const normalizedDetail = String(detail || '').toLowerCase()
+    if (!normalizedCode && !normalizedDetail) return false
+
+    if (normalizedCode === 'SCAN_FAILED') {
+      return normalizedDetail.includes('sink pattern not found')
+        || normalizedDetail.includes('no suitable module found')
+    }
+
+    if (normalizedCode === 'HOOK_FAILED') {
+      return normalizedDetail.includes('patch_breakpoint_failed')
+        || normalizedDetail.includes('thread_get_state_failed')
+        || normalizedDetail.includes('native hook failed')
+    }
+
+    if (normalizedCode === 'ATTACH_FAILED') {
+      return normalizedDetail.includes('task_for_pid:5')
+        || normalizedDetail.includes('thread_get_state_failed')
+    }
+
+    return normalizedDetail.includes('patch_breakpoint_failed')
+      || normalizedDetail.includes('thread_get_state_failed')
+      || normalizedDetail.includes('sink pattern not found')
+      || normalizedDetail.includes('no suitable module found')
+  }
+
+  private getMacRecoveryHint(isRepeatedFailure: boolean): string {
+    const steps = isRepeatedFailure
+      ? '建议步骤：彻底退出微信 -> 重启电脑（冷启动）-> 降级微信到 4.1.7 -> 仅尝试一次自动获取 -> 成功后再升级微信。'
+      : '建议步骤：降级微信到 4.1.7 -> 重启电脑（冷启动）-> 自动获取密钥 -> 成功后再升级微信。'
+    return `${steps}\n请不要连续重试，以免触发微信安全模式或系统内存保护。`
+  }
+
+  private simplifyDbKeyDetail(detail?: string): string {
+    const raw = String(detail || '')
+      .replace(/^WF_OK::/i, '')
+      .replace(/^WF_ERR::/i, '')
+      .replace(/\r?\n/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim()
+    if (!raw) return ''
+
+    const keys = [
+      'No suitable module found',
+      'Sink pattern not found',
+      'patch_breakpoint_failed',
+      'thread_get_state_failed',
+      'task_for_pid:5',
+      'attach_wait_timeout',
+      'HOOK_TIMEOUT',
+      'FRIDA_TIMEOUT'
+    ]
+    for (const key of keys) {
+      if (raw.includes(key)) return key
+    }
+
+    const stripped = raw
+      .replace(/\[xkey_helper\]/gi, ' ')
+      .replace(/\[debug\]/gi, ' ')
+      .replace(/\[\*\]/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim()
+    if (!stripped) return ''
+    return stripped.length > 140 ? `${stripped.slice(0, 140)}...` : stripped
+  }
+
+  private extractDbKeyErrorFromAnyText(text?: string): { code?: string; detail?: string } {
+    const raw = String(text || '')
+    if (!raw) return {}
+
+    const explicit = raw.match(/ERROR:([A-Z_]+):([^\r\n]*)/)
+    if (explicit) {
+      return {
+        code: explicit[1] || 'UNKNOWN',
+        detail: this.simplifyDbKeyDetail(explicit[2] || '')
+      }
+    }
+
+    if (raw.includes('No suitable module found')) {
+      return { code: 'SCAN_FAILED', detail: 'No suitable module found' }
+    }
+    if (raw.includes('Sink pattern not found')) {
+      return { code: 'SCAN_FAILED', detail: 'Sink pattern not found' }
+    }
+    if (raw.includes('patch_breakpoint_failed')) {
+      return { code: 'HOOK_FAILED', detail: 'patch_breakpoint_failed' }
+    }
+    if (raw.includes('thread_get_state_failed')) {
+      return { code: 'HOOK_FAILED', detail: 'thread_get_state_failed' }
+    }
+    if (raw.includes('task_for_pid:5')) {
+      return { code: 'ATTACH_FAILED', detail: 'task_for_pid:5' }
+    }
+
+    return {}
+  }
+
+  private resolveUnexpectedDbKeyErrorMessage(rawError?: string): string {
+    const text = String(rawError || '').trim()
+    const { code, detail } = this.extractDbKeyErrorFromAnyText(text)
+    if (code) {
+      const mapped = this.mapDbKeyErrorMessage(code, detail)
+      return this.enrichDbKeyErrorMessage(mapped, code, detail)
+    }
+
+    if (text.includes('helper timeout')) {
+      return '获取密钥超时：请保持微信前台并进行一次会话操作后重试。'
+    }
+    if (text.includes('helper returned empty output') || text.includes('invalid json')) {
+      return '获取失败：helper 未返回可识别结果，请彻底退出微信后重启电脑再试。'
+    }
+    if (text.includes('xkey_helper not found')) {
+      return '获取失败：未找到 xkey_helper，请重新安装 WeFlow 后重试。'
+    }
+    return '自动获取密钥失败：环境可能受限或版本暂未适配，请稍后重试。'
+  }
+
+  private enrichDbKeyErrorMessage(baseMessage: string, code?: string, detail?: string): string {
+    if (!this.isRestrictedEnvironmentFailure(code, detail)) return baseMessage
+
+    const failureCount = this.markRestrictedFailureAndGetCount()
+    if (failureCount >= 2) {
+      return `${baseMessage}\n检测到连续失败，疑似已进入受限状态。请先彻底退出微信并重启电脑，再按下方步骤处理。\n${this.getMacRecoveryHint(true)}`
+    }
+    return `${baseMessage}\n${this.getMacRecoveryHint(false)}`
+  }
+
  private async getWeChatPid(): Promise<number> {
    try {
      // 优先使用 pgrep -x 精确匹配进程名
@@ -498,7 +651,12 @@ export class KeyServiceMac {
      const errNum = parts[1] || 'unknown'
      const errMsg = parts[2] || 'unknown'
      const partial = parts.slice(3).join('::')
-      throw new Error(`elevated helper failed: errNum=${errNum}, errMsg=${errMsg}, partial=${partial || '(empty)'}`)
+      if (errNum === '-128' || String(errMsg).includes('User canceled')) {
+        throw new Error('User canceled')
+      }
+      const inferred = this.extractDbKeyErrorFromAnyText(`${errMsg}\n${partial}`)
+      if (inferred.code) return `ERROR:${inferred.code}:${inferred.detail || ''}`
+      throw new Error(`elevated helper failed: errNum=${errNum}, errMsg=${this.simplifyDbKeyDetail(errMsg) || 'unknown'}`)
    }
    const normalizedOutput = joined.startsWith('WF_OK::') ? joined.slice('WF_OK::'.length) : joined

@@ -520,49 +678,57 @@ export class KeyServiceMac {
    // 其次找 result 字段
    const resultPayload = allJson.find(p => typeof p?.result === 'string')
    if (resultPayload) return resultPayload.result
-    throw new Error('elevated helper returned invalid json: ' + lines[lines.length - 1])
+    const inferred = this.extractDbKeyErrorFromAnyText(normalizedOutput)
+    if (inferred.code) return `ERROR:${inferred.code}:${inferred.detail || ''}`
+    throw new Error('elevated helper returned invalid output')
  }

  private mapDbKeyErrorMessage(code?: string, detail?: string): string {
+    const normalizedDetail = this.simplifyDbKeyDetail(detail)
    if (code === 'PROCESS_NOT_FOUND') return '微信进程未运行'
    if (code === 'ATTACH_FAILED') {
      const isDevElectron = process.execPath.includes('/node_modules/electron/')
-      if ((detail || '').includes('task_for_pid:5')) {
+      if (normalizedDetail.includes('task_for_pid:5')) {
        if (isDevElectron) {
          return `无法附加到微信进程（task_for_pid 被拒绝）。当前为开发环境 Electron：${process.execPath}\n建议使用打包后的 WeFlow.app（已携带调试 entitlements）再重试。`
        }
-        return '无法附加到微信进程（task_for_pid 被系统拒绝）。请确认当前运行程序已正确签名并包含调试 entitlements。'
+        return '无法附加到微信进程（task_for_pid 被系统拒绝）。请确认当前运行程序已正确签名并包含调试 entitlements，优先使用打包版 WeFlow.app。'
      }
-      return `无法附加到进程 (${detail || ''})`
+      if (normalizedDetail.includes('thread_get_state_failed')) {
+        return `无法附加到进程：系统拒绝读取线程状态（${normalizedDetail}）。`
+      }
+      return `无法附加到进程 (${normalizedDetail || ''})`
    }
    if (code === 'FRIDA_FAILED') {
-      if ((detail || '').includes('FRIDA_TIMEOUT')) {
+      if (normalizedDetail.includes('FRIDA_TIMEOUT')) {
        return '定位已成功但在等待时间内未捕获到密钥调用。请保持微信前台并进行一次会话/数据库访问后重试。'
      }
-      return `Frida 语义定位失败 (${detail || ''})`
+      return `Frida 语义定位失败 (${normalizedDetail || ''})`
    }
    if (code === 'HOOK_FAILED') {
-      if ((detail || '').includes('HOOK_TIMEOUT')) {
-        return 'Hook 已安装，但在等待时间内未触发目标函数。请保持微信前台并执行一次会话/数据库访问后重试。'
+      if (normalizedDetail.includes('HOOK_TIMEOUT')) {
+        return 'Hook 已安装，但在等待时间内未触发登录流程。请退出微信账号后重新登录，或在未登录状态下直接登录微信，完成一次登录流程后重试。'
      }
-      if ((detail || '').includes('attach_wait_timeout')) {
+      if (normalizedDetail.includes('attach_wait_timeout')) {
        return '附加调试器超时，未能进入 Hook 阶段。请确认微信处于可交互状态并重试。'
      }
-      return `原生 Hook 失败 (${detail || ''})`
+      if (normalizedDetail.includes('patch_breakpoint_failed') || normalizedDetail.includes('thread_get_state_failed')) {
+        return `原生 Hook 失败：检测到系统调试权限或内存保护冲突（${normalizedDetail}）。`
+      }
+      return `原生 Hook 失败 (${normalizedDetail || ''})`
    }
    if (code === 'HOOK_TARGET_ONLY') {
-      return `已定位到目标函数地址（${detail || ''}），但当前原生 C++ 仅完成定位，尚未完成远程 Hook 回调取 key 流程。`
+      return `已定位到目标函数地址（${normalizedDetail || ''}），但当前原生 C++ 仅完成定位，尚未完成远程 Hook 回调取 key 流程。`
    }
    if (code === 'SCAN_FAILED') {
-      const normalizedDetail = (detail || '').trim()
      if (!normalizedDetail) {
        return '内存扫描失败：未匹配到可用特征。可能是当前微信版本更新导致，请升级 WeFlow 后重试。'
      }
      if (normalizedDetail.includes('Sink pattern not found')) {
-        return '内存扫描失败：未匹配到目标函数特征，可使用微信 4.1.8.100 版本尝试。'
+        return '内存扫描失败：未匹配到目标函数特征（Sink pattern not found），当前微信版本可能暂未适配。'
      }
      if (normalizedDetail.includes('No suitable module found')) {
-        return '内存扫描失败：未找到可扫描的微信主模块。请确认微信已完整启动并保持前台，再重试。'
+        return '内存扫描失败：未找到可扫描的微信主模块。请确认微信已完整启动并保持前台；若仍失败，优先尝试微信 4.1.7。'
      }
      return `内存扫描失败：${normalizedDetail}`
    }
--- a/electron/services/linuxNotificationService.ts
+++ b/electron/services/linuxNotificationService.ts
@@ -6,10 +6,13 @@ export interface LinuxNotificationData {
  title: string;
  content: string;
  avatarUrl?: string;
+  channel?: string;
+  insightRecordId?: string;
+  targetRoute?: string;
  expireTimeout?: number;
 }

-type NotificationCallback = (sessionId: string) => void;
+type NotificationCallback = (payload: unknown) => void;

 let notificationCallbacks: NotificationCallback[] = [];
 let notificationCounter = 1;
@@ -31,10 +34,10 @@ function clearNotificationState(notificationId: number): void {
  }
 }

-function triggerNotificationCallback(sessionId: string): void {
+function triggerNotificationCallback(payload: unknown): void {
  for (const callback of notificationCallbacks) {
    try {
-      callback(sessionId);
+      callback(payload);
    } catch (error) {
      console.error("[LinuxNotification] Callback error:", error);
    }
@@ -69,6 +72,15 @@ export async function showLinuxNotification(
    activeNotifications.set(notificationId, notification);

    notification.on("click", () => {
+      if (data.channel === "ai-insight" && data.insightRecordId) {
+        triggerNotificationCallback({
+          sessionId: data.sessionId,
+          channel: data.channel,
+          insightRecordId: data.insightRecordId,
+          targetRoute: data.targetRoute,
+        });
+        return;
+      }
      if (data.sessionId) {
        triggerNotificationCallback(data.sessionId);
      }
--- a/electron/services/messageCacheService.ts
+++ b/electron/services/messageCacheService.ts
@@ -12,6 +12,7 @@ export class MessageCacheService {
  private readonly cacheFilePath: string
  private cache: Record<string, SessionMessageCacheEntry> = {}
  private readonly sessionLimit = 150
+  private readonly maxSessionEntries = 48

  constructor(cacheBasePath?: string) {
    const basePath = cacheBasePath && cacheBasePath.trim().length > 0
@@ -36,6 +37,7 @@ export class MessageCacheService {
      const parsed = JSON.parse(raw)
      if (parsed && typeof parsed === 'object') {
        this.cache = parsed
+        this.pruneSessionEntries()
      }
    } catch (error) {
      console.error('MessageCacheService: 载入缓存失败', error)
@@ -43,6 +45,19 @@ export class MessageCacheService {
    }
  }

+  private pruneSessionEntries(): void {
+    const entries = Object.entries(this.cache || {})
+    if (entries.length <= this.maxSessionEntries) return
+
+    entries.sort((left, right) => {
+      const leftAt = Number(left[1]?.updatedAt || 0)
+      const rightAt = Number(right[1]?.updatedAt || 0)
+      return rightAt - leftAt
+    })
+
+    this.cache = Object.fromEntries(entries.slice(0, this.maxSessionEntries))
+  }
+
  get(sessionId: string): SessionMessageCacheEntry | undefined {
    return this.cache[sessionId]
  }
@@ -56,6 +71,7 @@ export class MessageCacheService {
      updatedAt: Date.now(),
      messages: trimmed
    }
+    this.pruneSessionEntries()
    this.persist()
  }

--- a/electron/services/messagePushService.ts
+++ b/electron/services/messagePushService.ts
--- a/electron/services/nativeImageDecrypt.ts
+++ b/electron/services/nativeImageDecrypt.ts
@@ -6,10 +6,30 @@ type NativeDecryptResult = {
  ext: string
  isWxgf?: boolean
  is_wxgf?: boolean
+  version?: number
+  aesSize?: number
+  aes_size?: number
+  xorSize?: number
+  xor_size?: number
+  rawSize?: number
+  raw_size?: number
+  flag?: number
+}
+
+export type NativeDatMeta = {
+  version?: number
+  aesSize?: number
+  aes_size?: number
+  xorSize?: number
+  xor_size?: number
+  rawSize?: number
+  raw_size?: number
+  flag?: number
 }

 type NativeAddon = {
  decryptDatNative: (inputPath: string, xorKey: number, aesKey?: string) => NativeDecryptResult
+  encryptDatNative?: (inputPath: string, xorKey: number, aesKey?: string, meta?: NativeDatMeta) => Buffer
 }

 let cachedAddon: NativeAddon | null | undefined
@@ -91,7 +111,7 @@ export function decryptDatViaNative(
  inputPath: string,
  xorKey: number,
  aesKey?: string
-): { data: Buffer; ext: string; isWxgf: boolean } | null {
+): { data: Buffer; ext: string; isWxgf: boolean; meta: NativeDatMeta } | null {
  const addon = loadAddon()
  if (!addon) return null

@@ -103,7 +123,31 @@ export function decryptDatViaNative(
      ? result.ext.trim().toLowerCase()
      : ''
    const ext = rawExt ? (rawExt.startsWith('.') ? rawExt : `.${rawExt}`) : ''
-    return { data: result.data, ext, isWxgf }
+    const meta: NativeDatMeta = {
+      version: result.version,
+      aes_size: result.aes_size ?? result.aesSize,
+      xor_size: result.xor_size ?? result.xorSize,
+      raw_size: result.raw_size ?? result.rawSize,
+      flag: result.flag
+    }
+    return { data: result.data, ext, isWxgf, meta }
+  } catch {
+    return null
+  }
+}
+
+export function encryptDatViaNative(
+  inputPath: string,
+  xorKey: number,
+  aesKey?: string,
+  meta?: NativeDatMeta
+): Buffer | null {
+  const addon = loadAddon()
+  if (!addon || typeof addon.encryptDatNative !== 'function') return null
+
+  try {
+    const result = addon.encryptDatNative(inputPath, xorKey, aesKey, meta)
+    return Buffer.isBuffer(result) ? result : null
  } catch {
    return null
  }
--- a/electron/services/snsService.ts
+++ b/electron/services/snsService.ts
@@ -14,6 +14,7 @@ export interface SnsLivePhoto {
    thumb: string
    md5?: string
    token?: string
+    thumbToken?: string
    key?: string
    encIdx?: string
 }
@@ -23,6 +24,7 @@ export interface SnsMedia {
    thumb: string
    md5?: string
    token?: string
+    thumbToken?: string
    key?: string
    encIdx?: string
    livePhoto?: SnsLivePhoto
@@ -126,12 +128,22 @@ const fixSnsUrl = (url: string, token?: string, isVideo: boolean = false) => {

    let fixedUrl = url.replace('http://', 'https://')

-    // 只有非视频（即图片）才需要处理 /150 变 /0
+    // 只有非视频（即图片）才需要处理路径末尾的尺寸标识（/150、/200等）变为 /0
    if (!isVideo) {
-        fixedUrl = fixedUrl.replace(/\/150($|\?)/, '/0$1')
+        const [pathPart, queryPart] = fixedUrl.split('?')
+        const fixedPath = pathPart.replace(/\/(150|200|480)($|\?)/, '/0$2')
+        fixedUrl = queryPart ? `${fixedPath}?${queryPart}` : fixedPath
    }

-    if (!token || fixedUrl.includes('token=')) return fixedUrl
+    // 如果没有提供新token，直接返回
+    if (!token) return fixedUrl
+
+    // 移除已有的token和idx参数
+    const [pathPart, queryPart] = fixedUrl.split('?')
+    if (queryPart) {
+        const params = queryPart.split('&').filter(p => !p.startsWith('token=') && !p.startsWith('idx='))
+        fixedUrl = params.length > 0 ? `${pathPart}?${params.join('&')}` : pathPart
+    }

    // 根据用户要求，视频链接组合方式为: BASE_URL + "?" + "token=" + token + "&idx=1" + 原有参数
    if (isVideo) {
@@ -324,6 +336,9 @@ class SnsService {
    private configService: ConfigService
    private contactCache: ContactCacheService
    private imageCache = new Map<string, string>()
+    private imageCacheMeta = new Map<string, number>()
+    private readonly imageCacheTtlMs = 15 * 60 * 1000
+    private readonly imageCacheMaxEntries = 120
    private exportStatsCache: { totalPosts: number; totalFriends: number; myPosts: number | null; updatedAt: number } | null = null
    private userPostCountsCache: { counts: Record<string, number>; updatedAt: number } | null = null
    private readonly exportStatsCacheTtlMs = 5 * 60 * 1000
@@ -336,6 +351,38 @@ class SnsService {
        this.contactCache = new ContactCacheService(this.configService.get('cachePath') as string)
    }

+    clearMemoryCache(): void {
+        this.imageCache.clear()
+        this.imageCacheMeta.clear()
+    }
+
+    private pruneImageCache(now: number = Date.now()): void {
+        for (const [key, updatedAt] of this.imageCacheMeta.entries()) {
+            if (now - updatedAt > this.imageCacheTtlMs) {
+                this.imageCacheMeta.delete(key)
+                this.imageCache.delete(key)
+            }
+        }
+
+        while (this.imageCache.size > this.imageCacheMaxEntries) {
+            const oldestKey = this.imageCache.keys().next().value as string | undefined
+            if (!oldestKey) break
+            this.imageCache.delete(oldestKey)
+            this.imageCacheMeta.delete(oldestKey)
+        }
+    }
+
+    private rememberImageCache(cacheKey: string, dataUrl: string): void {
+        if (!cacheKey || !dataUrl) return
+        const now = Date.now()
+        if (this.imageCache.has(cacheKey)) {
+            this.imageCache.delete(cacheKey)
+        }
+        this.imageCache.set(cacheKey, dataUrl)
+        this.imageCacheMeta.set(cacheKey, now)
+        this.pruneImageCache(now)
+    }
+
    private toOptionalString(value: unknown): string | undefined {
        if (typeof value !== 'string') return undefined
        const trimmed = value.trim()
@@ -669,6 +716,7 @@ class SnsService {
                    url: urlMatch ? urlMatch[1].trim() : '',
                    thumb: thumbMatch ? thumbMatch[1].trim() : '',
                    token: urlToken || thumbToken,
+                    thumbToken: thumbToken,
                    key: urlKey || thumbKey,
                    md5: urlMd5,
                    encIdx: urlEncIdx || thumbEncIdx
@@ -681,19 +729,24 @@ class SnsService {
                    const lpUrlTag = lx.match(/<url([^>]*)>/i)
                    const lpThumb = lx.match(/<thumb[^>]*>([^<]+)<\/thumb>/i)
                    const lpThumbTag = lx.match(/<thumb([^>]*)>/i)
-                    let lpToken: string | undefined, lpKey: string | undefined, lpEncIdx: string | undefined
+                    let lpUrlToken: string | undefined, lpThumbToken: string | undefined
+                    let lpKey: string | undefined, lpEncIdx: string | undefined
                    if (lpUrlTag?.[1]) {
                        const a = lpUrlTag[1]
-                        lpToken = a.match(/token="([^"]+)"/i)?.[1]
+                        lpUrlToken = a.match(/token="([^"]+)"/i)?.[1]
                        lpKey = a.match(/key="([^"]+)"/i)?.[1]
                        lpEncIdx = a.match(/enc_idx="([^"]+)"/i)?.[1]
                    }
-                    if (!lpToken && lpThumbTag?.[1]) lpToken = lpThumbTag[1].match(/token="([^"]+)"/i)?.[1]
-                    if (!lpKey && lpThumbTag?.[1]) lpKey = lpThumbTag[1].match(/key="([^"]+)"/i)?.[1]
+                    if (lpThumbTag?.[1]) {
+                        const a = lpThumbTag[1]
+                        lpThumbToken = a.match(/token="([^"]+)"/i)?.[1]
+                        if (!lpKey) lpKey = a.match(/key="([^"]+)"/i)?.[1]
+                    }
                    item.livePhoto = {
                        url: lpUrl ? lpUrl[1].trim() : '',
                        thumb: lpThumb ? lpThumb[1].trim() : '',
-                        token: lpToken,
+                        token: lpUrlToken || lpThumbToken,
+                        thumbToken: lpThumbToken,
                        key: lpKey,
                        encIdx: lpEncIdx
                    }
@@ -879,7 +932,7 @@ class SnsService {
        const allowTimelineFallback = options?.allowTimelineFallback ?? true
        const preferCache = options?.preferCache ?? false
        const now = Date.now()
-        const myWxid = this.toOptionalString(this.configService.get('myWxid'))
+        const myWxid = this.toOptionalString(this.configService.getMyWxidCleaned())

        try {
            if (preferCache && this.exportStatsCache && now - this.exportStatsCache.updatedAt <= this.exportStatsCacheTtlMs) {
@@ -1146,16 +1199,18 @@ class SnsService {

            const fixedMedia = (post.media || []).map((m: any) => ({
                url: fixSnsUrl(m.url, m.token, isVideoPost),
-                thumb: fixSnsUrl(m.thumb, m.token, false),
+                thumb: fixSnsUrl(m.thumb, m.thumbToken || m.token, false),
                md5: m.md5,
                token: m.token,
+                thumbToken: m.thumbToken,
                key: isVideoPost ? (videoKey || m.key) : m.key,
                encIdx: m.encIdx || m.enc_idx,
                livePhoto: m.livePhoto ? {
                    ...m.livePhoto,
                    url: fixSnsUrl(m.livePhoto.url, m.livePhoto.token, true),
-                    thumb: fixSnsUrl(m.livePhoto.thumb, m.livePhoto.token, false),
+                    thumb: fixSnsUrl(m.livePhoto.thumb, m.livePhoto.thumbToken || m.livePhoto.token, false),
                    token: m.livePhoto.token,
+                    thumbToken: m.livePhoto.thumbToken,
                    key: videoKey || m.livePhoto.key || m.key,
                    encIdx: m.livePhoto.encIdx || m.livePhoto.enc_idx
                } : undefined
@@ -1239,20 +1294,27 @@ class SnsService {
        if (!url) return { success: false, error: 'url 不能为空' }
        const cacheKey = `${url}|${key ?? ''}`

-        if (this.imageCache.has(cacheKey)) {
-            const cachedDataUrl = this.imageCache.get(cacheKey) || ''
-            const base64Part = cachedDataUrl.split(',')[1] || ''
-            if (base64Part) {
-                try {
-                    const cachedBuf = Buffer.from(base64Part, 'base64')
-                    if (detectImageMime(cachedBuf, '').startsWith('image/')) {
-                        return { success: true, dataUrl: cachedDataUrl }
+        const cachedDataUrl = this.imageCache.get(cacheKey) || ''
+        if (cachedDataUrl) {
+            const cachedAt = this.imageCacheMeta.get(cacheKey) || 0
+            if (cachedAt > 0 && Date.now() - cachedAt <= this.imageCacheTtlMs) {
+                const base64Part = cachedDataUrl.split(',')[1] || ''
+                if (base64Part) {
+                    try {
+                        const cachedBuf = Buffer.from(base64Part, 'base64')
+                        if (detectImageMime(cachedBuf, '').startsWith('image/')) {
+                            this.imageCache.delete(cacheKey)
+                            this.imageCache.set(cacheKey, cachedDataUrl)
+                            this.imageCacheMeta.set(cacheKey, Date.now())
+                            return { success: true, dataUrl: cachedDataUrl }
+                        }
+                    } catch {
+                        // ignore and fall through to refetch
                    }
-                } catch {
-                    // ignore and fall through to refetch
                }
            }
            this.imageCache.delete(cacheKey)
+            this.imageCacheMeta.delete(cacheKey)
        }

        const result = await this.fetchAndDecryptImage(url, key)
@@ -1269,7 +1331,7 @@ class SnsService {
                    return { success: false, error: '无效图片数据（可能密钥不匹配或缓存损坏）' }
                }
                const dataUrl = `data:${result.contentType};base64,${result.data.toString('base64')}`
-                this.imageCache.set(cacheKey, dataUrl)
+                this.rememberImageCache(cacheKey, dataUrl)
                return { success: true, dataUrl }
            }
        }
@@ -1298,6 +1360,8 @@ class SnsService {
    }, progressCallback?: (progress: { current: number; total: number; status: string }) => void, control?: {
        shouldPause?: () => boolean
        shouldStop?: () => boolean
+        recordCreatedFile?: (filePath: string) => void
+        recordCreatedDir?: (dirPath: string) => void
    }): Promise<{ success: boolean; filePath?: string; postCount?: number; mediaCount?: number; paused?: boolean; stopped?: boolean; error?: string }> {
        const { outputDir, format, usernames, keyword, startTime, endTime } = options
        const hasExplicitMediaSelection =
@@ -1319,6 +1383,18 @@ class SnsService {
            if (control?.shouldPause?.()) return 'paused'
            return null
        }
+        const ensureExportDir = (dirPath: string) => {
+            const existed = existsSync(dirPath)
+            if (!existed) {
+                mkdirSync(dirPath, { recursive: true })
+                control?.recordCreatedDir?.(dirPath)
+            }
+        }
+        const recordCreatedFileBeforeWrite = (filePath: string) => {
+            if (!existsSync(filePath)) {
+                control?.recordCreatedFile?.(filePath)
+            }
+        }
        const buildInterruptedResult = (state: 'paused' | 'stopped', postCount: number, mediaCount: number) => (
            state === 'stopped'
                ? { success: true, stopped: true, filePath: '', postCount, mediaCount }
@@ -1327,9 +1403,7 @@ class SnsService {

        try {
            // 确保输出目录存在
-            if (!existsSync(outputDir)) {
-                mkdirSync(outputDir, { recursive: true })
-            }
+            ensureExportDir(outputDir)

            // 1. 分页加载全部帖子
            const allPosts: SnsPost[] = []
@@ -1372,9 +1446,7 @@ class SnsService {
            const mediaDir = join(outputDir, 'media')

            if (shouldExportMedia) {
-                if (!existsSync(mediaDir)) {
-                    mkdirSync(mediaDir, { recursive: true })
-                }
+                ensureExportDir(mediaDir)

                // 收集所有媒体下载任务
                const mediaTasks: Array<{
@@ -1443,6 +1515,7 @@ class SnsService {
                        } else {
                            const result = await this.fetchAndDecryptImage(task.url, task.key)
                            if (result.success && result.data) {
+                                recordCreatedFileBeforeWrite(filePath)
                                await writeFile(filePath, result.data)
                                if (task.kind === 'livephoto') {
                                    if (media.livePhoto) (media.livePhoto as any).localPath = `media/${fileName}`
@@ -1452,6 +1525,7 @@ class SnsService {
                                mediaCount++
                            } else if (result.success && result.cachePath) {
                                const cachedData = await readFile(result.cachePath)
+                                recordCreatedFileBeforeWrite(filePath)
                                await writeFile(filePath, cachedData)
                                if (task.kind === 'livephoto') {
                                    if (media.livePhoto) (media.livePhoto as any).localPath = `media/${fileName}`
@@ -1489,7 +1563,7 @@ class SnsService {
            // 2.5 下载头像
            const avatarMap = new Map<string, string>()
            if (format === 'html') {
-                if (!existsSync(mediaDir)) mkdirSync(mediaDir, { recursive: true })
+                ensureExportDir(mediaDir)
                const uniqueUsers = [...new Map(allPosts.filter(p => p.avatarUrl).map(p => [p.username, p])).values()]
                let avatarDone = 0
                const avatarQueue = [...uniqueUsers]
@@ -1506,6 +1580,7 @@ class SnsService {
                            } else {
                                const result = await this.fetchAndDecryptImage(post.avatarUrl!)
                                if (result.success && result.data) {
+                                    recordCreatedFileBeforeWrite(filePath)
                                    await writeFile(filePath, result.data)
                                    avatarMap.set(post.username, `media/${fileName}`)
                                }
@@ -1560,6 +1635,7 @@ class SnsService {
                        linkUrl: (p as any).linkUrl
                    }))
                }
+                recordCreatedFileBeforeWrite(outputFilePath)
                await writeFile(outputFilePath, JSON.stringify(exportData, null, 2), 'utf-8')
            } else if (format === 'arkmejson') {
                outputFilePath = join(outputDir, `朋友圈导出_${timestamp}.json`)
@@ -1647,11 +1723,13 @@ class SnsService {
                    },
                    posts
                }
+                recordCreatedFileBeforeWrite(outputFilePath)
                await writeFile(outputFilePath, JSON.stringify(exportData, null, 2), 'utf-8')
            } else {
                // HTML 格式
                outputFilePath = join(outputDir, `朋友圈导出_${timestamp}.html`)
                const html = this.generateHtml(allPosts, { usernames, keyword }, avatarMap)
+                recordCreatedFileBeforeWrite(outputFilePath)
                await writeFile(outputFilePath, html, 'utf-8')
            }

@@ -2002,6 +2080,8 @@ window.addEventListener('scroll',function(){document.getElementById('btt').class
                const zlib = require('zlib')
                const urlObj = new URL(url)

+                console.log(`[SnsService] 开始下载图片: url=${url.substring(0, 100)}..., key=${key || 'undefined'}`)
+
                const options = {
                    hostname: urlObj.hostname,
                    path: urlObj.pathname + urlObj.search,
@@ -2016,7 +2096,9 @@ window.addEventListener('scroll',function(){document.getElementById('btt').class
                }

                const req = https.request(options, (res: any) => {
+                    console.log(`[SnsService] CDN 响应: statusCode=${res.statusCode}, x-enc=${res.headers['x-enc']}, content-type=${res.headers['content-type']}`)
                    if (res.statusCode !== 200 && res.statusCode !== 206) {
+                        console.error(`[SnsService] CDN 请求失败: HTTP ${res.statusCode}`)
                        resolve({ success: false, error: `HTTP ${res.statusCode}` })
                        return
                    }
@@ -2036,9 +2118,11 @@ window.addEventListener('scroll',function(){document.getElementById('btt').class

                        let decoded = raw
                        const rawMagicMime = detectImageMime(raw, '')
+                        console.log(`[SnsService] 原始数据: size=${raw.length}, mime=${rawMagicMime}, xEnc=${xEnc}`)

                        // 图片逻辑
                        const shouldDecrypt = (xEnc === '1' || !!key) && key !== undefined && key !== null && String(key).trim().length > 0
+                        console.log(`[SnsService] 解密判断: shouldDecrypt=${shouldDecrypt}, key=${key || 'undefined'}`)
                        if (shouldDecrypt) {
                            try {
                                const keyStr = String(key).trim()
@@ -2054,6 +2138,7 @@ window.addEventListener('scroll',function(){document.getElementById('btt').class
                                    }

                                    const decryptedMagicMime = detectImageMime(decrypted, '')
+                                    console.log(`[SnsService] 解密后: mime=${decryptedMagicMime}`)
                                    if (decryptedMagicMime.startsWith('image/')) {
                                        decoded = decrypted
                                    } else if (!rawMagicMime.startsWith('image/')) {
@@ -2066,7 +2151,9 @@ window.addEventListener('scroll',function(){document.getElementById('btt').class
                        }

                        const decodedMagicMime = detectImageMime(decoded, '')
+                        console.log(`[SnsService] 最终结果: mime=${decodedMagicMime}, isImage=${decodedMagicMime.startsWith('image/')}`)
                        if (!decodedMagicMime.startsWith('image/')) {
+                            console.error(`[SnsService] 图片解密失败: 原始mime=${rawMagicMime}, 解密后mime=${decodedMagicMime}, key=${key}`)
                            resolve({ success: false, error: '图片解密失败：无法识别图片格式' })
                            return
                        }
--- a/electron/services/videoService.ts
+++ b/electron/services/videoService.ts
@@ -96,7 +96,7 @@ class VideoService {
   * 获取当前用户的wxid
   */
  private getMyWxid(): string {
-    return this.configService.get('myWxid') || ''
+    return this.configService.getMyWxidCleaned() || ''
  }

  /**
@@ -131,6 +131,14 @@ class VideoService {
    if (dbPathContainsWxid) {
      return join(dbPath, 'msg', 'video')
    }
+
+    // 使用 ConfigService 的统一账号目录解析
+    const accountDir = this.configService.getAccountDir(dbPath, wxid)
+    if (accountDir) {
+      return join(accountDir, 'msg', 'video')
+    }
+
+    // 回退到原始逻辑
    return join(dbPath, wxid, 'msg', 'video')
  }

@@ -144,6 +152,13 @@ class VideoService {
      return [join(dbPath, 'db_storage', 'hardlink', 'hardlink.db')]
    }

+    // 使用 ConfigService 的统一账号目录解析
+    const accountDir = this.configService.getAccountDir(dbPath, wxid)
+    if (accountDir) {
+      return [join(accountDir, 'db_storage', 'hardlink', 'hardlink.db')]
+    }
+
+    // 回退到原始逻辑
    return [
      join(dbPath, wxid, 'db_storage', 'hardlink', 'hardlink.db'),
      join(dbPath, cleanedWxid, 'db_storage', 'hardlink', 'hardlink.db')
--- a/electron/services/wcdbCore.ts
+++ b/electron/services/wcdbCore.ts
@@ -11,6 +11,19 @@ export function getLastDllInitError(): string | null {
  return lastDllInitError
 }

+function cleanAccountDirName(dirName: string): string {
+  const trimmed = dirName.trim()
+  if (!trimmed) return trimmed
+  if (trimmed.toLowerCase().startsWith('wxid_')) {
+    const match = trimmed.match(/^(wxid_[^_]+)/i)
+    if (match) return match[1]
+    return trimmed
+  }
+  const suffixMatch = trimmed.match(/^(.+)_([a-zA-Z0-9]{4})$/)
+  if (suffixMatch) return suffixMatch[1]
+  return trimmed
+}
+
 export class WcdbCore {
  private resourcesPath: string | null = null
  private userDataPath: string | null = null
@@ -35,8 +48,10 @@ export class WcdbCore {
  private wcdbUpdateMessage: any = null
  private wcdbDeleteMessage: any = null
  private wcdbGetSessions: any = null
+  private wcdbMarkAllSessionsRead: any = null
  private wcdbGetMessages: any = null
  private wcdbGetMessageCount: any = null
+  private wcdbGetMessageByServerId: any = null
  private wcdbGetDisplayNames: any = null
  private wcdbGetAvatarUrls: any = null
  private wcdbGetGroupMemberCount: any = null
@@ -91,6 +106,11 @@ export class WcdbCore {
  private wcdbGetSnsUsernames: any = null
  private wcdbGetSnsExportStats: any = null
  private wcdbGetMessageTableColumns: any = null
+  private wcdbListTables: any = null
+  private wcdbGetTableSchema: any = null
+  private wcdbExportTableSnapshot: any = null
+  private wcdbImportTableSnapshot: any = null
+  private wcdbImportTableSnapshotWithSchema: any = null
  private wcdbGetMessageTableTimeRange: any = null
  private wcdbResolveImageHardlink: any = null
  private wcdbResolveImageHardlinkBatch: any = null
@@ -805,12 +825,22 @@ export class WcdbCore {
      // wcdb_status wcdb_get_sessions(wcdb_handle handle, char** out_json)
      this.wcdbGetSessions = this.lib.func('int32 wcdb_get_sessions(int64 handle, _Out_ void** outJson)')

+      // wcdb_status wcdb_mark_all_sessions_read(wcdb_handle handle, char** out_error)
+      try {
+        this.wcdbMarkAllSessionsRead = this.lib.func('int32 wcdb_mark_all_sessions_read(int64 handle, _Out_ void** outError)')
+      } catch {
+        this.wcdbMarkAllSessionsRead = null
+      }
+
      // wcdb_status wcdb_get_messages(wcdb_handle handle, const char* username, int32_t limit, int32_t offset, char** out_json)
      this.wcdbGetMessages = this.lib.func('int32 wcdb_get_messages(int64 handle, const char* username, int32 limit, int32 offset, _Out_ void** outJson)')

      // wcdb_status wcdb_get_message_count(wcdb_handle handle, const char* username, int32_t* out_count)
      this.wcdbGetMessageCount = this.lib.func('int32 wcdb_get_message_count(int64 handle, const char* username, _Out_ int32* outCount)')

+      // wcdb_status wcdb_get_message_by_svrid(wcdb_handle handle, const char* session_id, const char* svrid, char** out_json)
+      this.wcdbGetMessageByServerId = this.lib.func('int32 wcdb_get_message_by_svrid(int64 handle, const char* sessionId, const char* svrid, _Out_ void** outJson)')
+
      // wcdb_status wcdb_get_display_names(wcdb_handle handle, const char* usernames_json, char** out_json)
      this.wcdbGetDisplayNames = this.lib.func('int32 wcdb_get_display_names(int64 handle, const char* usernamesJson, _Out_ void** outJson)')

@@ -1090,6 +1120,31 @@ export class WcdbCore {
      } catch {
        this.wcdbGetMessageTableColumns = null
      }
+      try {
+        this.wcdbListTables = this.lib.func('int32 wcdb_list_tables(int64 handle, const char* kind, const char* dbPath, _Out_ void** outJson)')
+      } catch {
+        this.wcdbListTables = null
+      }
+      try {
+        this.wcdbGetTableSchema = this.lib.func('int32 wcdb_get_table_schema(int64 handle, const char* kind, const char* dbPath, const char* tableName, _Out_ void** outJson)')
+      } catch {
+        this.wcdbGetTableSchema = null
+      }
+      try {
+        this.wcdbExportTableSnapshot = this.lib.func('int32 wcdb_export_table_snapshot(int64 handle, const char* kind, const char* dbPath, const char* tableName, const char* outputPath, _Out_ void** outJson)')
+      } catch {
+        this.wcdbExportTableSnapshot = null
+      }
+      try {
+        this.wcdbImportTableSnapshot = this.lib.func('int32 wcdb_import_table_snapshot(int64 handle, const char* kind, const char* dbPath, const char* tableName, const char* inputPath, _Out_ void** outJson)')
+      } catch {
+        this.wcdbImportTableSnapshot = null
+      }
+      try {
+        this.wcdbImportTableSnapshotWithSchema = this.lib.func('int32 wcdb_import_table_snapshot_with_schema(int64 handle, const char* kind, const char* dbPath, const char* tableName, const char* inputPath, const char* createTableSql, _Out_ void** outJson)')
+      } catch {
+        this.wcdbImportTableSnapshotWithSchema = null
+      }
      try {
        this.wcdbGetMessageTableTimeRange = this.lib.func('int32 wcdb_get_message_table_time_range(int64 handle, const char* dbPath, const char* tableName, _Out_ void** outJson)')
      } catch {
@@ -1230,13 +1285,12 @@ export class WcdbCore {
  /**
   * 测试数据库连接
   */
-  async testConnection(dbPath: string, hexKey: string, wxid: string): Promise<{ success: boolean; error?: string; sessionCount?: number }> {
+  async testConnection(accountDir: string, hexKey: string): Promise<{ success: boolean; error?: string; sessionCount?: number }> {
    try {
      // 如果当前已经有相同参数的活动连接，直接返回成功
      if (this.handle !== null &&
-        this.currentPath === dbPath &&
-        this.currentKey === hexKey &&
-        this.currentWxid === wxid) {
+        this.currentPath === accountDir &&
+        this.currentKey === hexKey) {
        return { success: true, sessionCount: 0 }
      }

@@ -1254,9 +1308,9 @@ export class WcdbCore {
        }
      }

-      // 构建 db_storage 目录路径
-      const dbStoragePath = this.resolveDbStoragePath(dbPath, wxid)
-      this.writeLog(`testConnection dbPath=${dbPath} wxid=${wxid} dbStorage=${dbStoragePath || 'null'}`)
+      // 直接使用账号目录
+      const dbStoragePath = join(accountDir, 'db_storage')
+      this.writeLog(`testConnection accountDir=${accountDir} dbStorage=${dbStoragePath}`)

      if (!dbStoragePath || !existsSync(dbStoragePath)) {
        return { success: false, error: this.formatInitProtectionError(-3001) }
@@ -1299,9 +1353,9 @@ export class WcdbCore {
      }

      // 恢复测试前的连接（如果之前有活动连接）
-      if (hadActiveConnection && prevPath && prevKey && prevWxid) {
+      if (hadActiveConnection && prevPath && prevKey) {
        try {
-          await this.open(prevPath, prevKey, prevWxid)
+          await this.open(prevPath, prevKey)
        } catch {
          // 恢复失败则保持断开，由调用方处理
        }
@@ -1506,7 +1560,7 @@ export class WcdbCore {
  /**
   * 打开数据库
   */
-  async open(dbPath: string, hexKey: string, wxid: string): Promise<boolean> {
+  async open(accountDir: string, hexKey: string): Promise<boolean> {
    try {
      lastDllInitError = null
      if (!this.initialized) {
@@ -1516,9 +1570,8 @@ export class WcdbCore {

      // 检查是否已经是当前连接的参数，如果是则直接返回成功，实现"始终保持链接"
      if (this.handle !== null &&
-        this.currentPath === dbPath &&
-        this.currentKey === hexKey &&
-        this.currentWxid === wxid) {
+        this.currentPath === accountDir &&
+        this.currentKey === hexKey) {
        return true
      }

@@ -1530,12 +1583,12 @@ export class WcdbCore {
        if (!initOk) return false
      }

-      const dbStoragePath = this.resolveDbStoragePath(dbPath, wxid)
-      this.writeLog(`open dbPath=${dbPath} wxid=${wxid} dbStorage=${dbStoragePath || 'null'}`, true)
+      const dbStoragePath = join(accountDir, 'db_storage')
+      this.writeLog(`open accountDir=${accountDir} dbStorage=${dbStoragePath}`, true)

      if (!dbStoragePath || !existsSync(dbStoragePath)) {
-        console.error('数据库目录不存在:', dbPath)
-        this.writeLog(`open failed: dbStorage not found for ${dbPath}`)
+        console.error('数据库目录不存在:', accountDir)
+        this.writeLog(`open failed: dbStorage not found for ${accountDir}`)
        lastDllInitError = this.formatInitProtectionError(-3001)
        return false
      }
@@ -1566,8 +1619,12 @@ export class WcdbCore {
        return false
      }

+      // 从账号目录路径中提取 wxid（目录名）
+      const rawWxid = basename(accountDir)
+      const wxid = cleanAccountDirName(rawWxid)
+
      this.handle = handle
-      this.currentPath = dbPath
+      this.currentPath = accountDir
      this.currentKey = hexKey
      this.currentWxid = wxid
      this.currentDbStoragePath = dbStoragePath
@@ -1585,7 +1642,7 @@ export class WcdbCore {
      }
      this.writeLog(`open ok handle=${handle}`, true)
      await this.dumpDbStatus('open')
-      await this.runPostOpenDiagnostics(dbPath, dbStoragePath, sessionDbPath, wxid)
+      await this.runPostOpenDiagnostics(accountDir, dbStoragePath, sessionDbPath, wxid)
      return true
    } catch (e) {
      console.error('打开数据库异常:', e)
@@ -1666,6 +1723,39 @@ export class WcdbCore {
    }
  }

+  async markAllSessionsRead(): Promise<{ success: boolean; error?: string }> {
+    if (!this.ensureReady()) {
+      return { success: false, error: 'WCDB 未连接' }
+    }
+    if (!this.wcdbMarkAllSessionsRead) {
+      return { success: false, error: '当前数据服务版本不支持一键已读' }
+    }
+    try {
+      await new Promise(resolve => setImmediate(resolve))
+
+      const outPtr = [null as any]
+      const result = this.wcdbMarkAllSessionsRead(this.handle, outPtr)
+      let message = ''
+      if (outPtr[0]) {
+        try { message = this.koffi.decode(outPtr[0], 'char', -1) } catch { }
+        try { this.wcdbFreeString(outPtr[0]) } catch { }
+      }
+
+      await new Promise(resolve => setImmediate(resolve))
+
+      if (result !== 0) {
+        this.writeLog(`markAllSessionsRead failed: code=${result} error=${message}`)
+        return { success: false, error: message || `一键已读失败: ${result}` }
+      }
+      this.clearMediaStreamSessionCache()
+      this.writeLog('markAllSessionsRead ok')
+      return { success: true }
+    } catch (e) {
+      this.writeLog(`markAllSessionsRead exception: ${String(e)}`)
+      return { success: false, error: String(e) }
+    }
+  }
+
  async getMessages(sessionId: string, limit: number, offset: number): Promise<{ success: boolean; messages?: any[]; error?: string }> {
    if (!this.ensureReady()) {
      return { success: false, error: 'WCDB 未连接' }
@@ -1735,6 +1825,30 @@ export class WcdbCore {
    }
  }

+  async getMessageByServerId(sessionId: string, svrid: string): Promise<{ success: boolean; row?: any; error?: string }> {
+    if (!this.ensureReady()) {
+      return { success: false, error: 'WCDB 未连接' }
+    }
+    try {
+      const outPtr = [null as any]
+      const result = this.wcdbGetMessageByServerId(this.handle, sessionId, svrid, outPtr)
+      if (result !== 0) {
+        return { success: false, error: `查询消息失败: ${result}` }
+      }
+      const jsonStr = this.decodeJsonPtr(outPtr[0])
+      if (!jsonStr) {
+        return { success: true, row: null }
+      }
+      const parsed = JSON.parse(jsonStr)
+      if (!parsed || Object.keys(parsed).length === 0) {
+        return { success: true, row: null }
+      }
+      return { success: true, row: parsed }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
  async getMessageCounts(sessionIds: string[]): Promise<{ success: boolean; counts?: Record<string, number>; error?: string }> {
    if (!this.ensureReady()) {
      return { success: false, error: 'WCDB 未连接' }
@@ -2902,6 +3016,96 @@ export class WcdbCore {
    }
  }

+  async listTables(kind: string, dbPath: string = ''): Promise<{ success: boolean; tables?: string[]; error?: string }> {
+    if (!this.ensureReady()) return { success: false, error: 'WCDB 未连接' }
+    if (!this.wcdbListTables) return { success: false, error: '接口未就绪' }
+    try {
+      const outPtr = [null as any]
+      const result = this.wcdbListTables(this.handle, kind, dbPath || '', outPtr)
+      if (result !== 0 || !outPtr[0]) return { success: false, error: `获取表列表失败: ${result}` }
+      const jsonStr = this.decodeJsonPtr(outPtr[0])
+      if (!jsonStr) return { success: false, error: '解析表列表失败' }
+      const tables = JSON.parse(jsonStr)
+      return { success: true, tables: Array.isArray(tables) ? tables.map((c: any) => String(c || '')).filter(Boolean) : [] }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
+  async getTableSchema(kind: string, dbPath: string, tableName: string): Promise<{ success: boolean; schema?: string; error?: string }> {
+    if (!this.ensureReady()) return { success: false, error: 'WCDB 未连接' }
+    if (!this.wcdbGetTableSchema) return { success: false, error: '接口未就绪' }
+    try {
+      const outPtr = [null as any]
+      const result = this.wcdbGetTableSchema(this.handle, kind, dbPath || '', tableName, outPtr)
+      const jsonStr = outPtr[0] ? this.decodeJsonPtr(outPtr[0]) : ''
+      const data = jsonStr ? JSON.parse(jsonStr) : {}
+      if (result !== 0 || data?.success === false) return { success: false, error: data?.error || `获取表结构失败: ${result}` }
+      return { success: true, schema: String(data?.schema || '') }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
+  async exportTableSnapshot(kind: string, dbPath: string, tableName: string, outputPath: string): Promise<{ success: boolean; rows?: number; columns?: number; error?: string }> {
+    if (!this.ensureReady()) return { success: false, error: 'WCDB 未连接' }
+    if (!this.wcdbExportTableSnapshot) return { success: false, error: '接口未就绪' }
+    try {
+      const outPtr = [null as any]
+      const result = this.wcdbExportTableSnapshot(this.handle, kind, dbPath || '', tableName, outputPath, outPtr)
+      const jsonStr = outPtr[0] ? this.decodeJsonPtr(outPtr[0]) : ''
+      const data = jsonStr ? JSON.parse(jsonStr) : {}
+      if (result !== 0 || data?.success === false) return { success: false, error: data?.error || `导出表快照失败: ${result}` }
+      return { success: true, rows: Number(data?.rows || 0), columns: Number(data?.columns || 0) }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
+  async importTableSnapshot(kind: string, dbPath: string, tableName: string, inputPath: string): Promise<{ success: boolean; rows?: number; inserted?: number; ignored?: number; malformed?: number; columns?: number; error?: string }> {
+    if (!this.ensureReady()) return { success: false, error: 'WCDB 未连接' }
+    if (!this.wcdbImportTableSnapshot) return { success: false, error: '接口未就绪' }
+    try {
+      const outPtr = [null as any]
+      const result = this.wcdbImportTableSnapshot(this.handle, kind, dbPath || '', tableName, inputPath, outPtr)
+      const jsonStr = outPtr[0] ? this.decodeJsonPtr(outPtr[0]) : ''
+      const data = jsonStr ? JSON.parse(jsonStr) : {}
+      if (result !== 0 || data?.success === false) return { success: false, error: data?.error || `导入表快照失败: ${result}` }
+      return {
+        success: true,
+        rows: Number(data?.rows || 0),
+        inserted: Number(data?.inserted || 0),
+        ignored: Number(data?.ignored || 0),
+        malformed: Number(data?.malformed || 0),
+        columns: Number(data?.columns || 0)
+      }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
+  async importTableSnapshotWithSchema(kind: string, dbPath: string, tableName: string, inputPath: string, createTableSql: string): Promise<{ success: boolean; rows?: number; inserted?: number; ignored?: number; malformed?: number; columns?: number; error?: string }> {
+    if (!this.ensureReady()) return { success: false, error: 'WCDB 未连接' }
+    if (!this.wcdbImportTableSnapshotWithSchema) return { success: false, error: '接口未就绪' }
+    try {
+      const outPtr = [null as any]
+      const result = this.wcdbImportTableSnapshotWithSchema(this.handle, kind, dbPath || '', tableName, inputPath, createTableSql || '', outPtr)
+      const jsonStr = outPtr[0] ? this.decodeJsonPtr(outPtr[0]) : ''
+      const data = jsonStr ? JSON.parse(jsonStr) : {}
+      if (result !== 0 || data?.success === false) return { success: false, error: data?.error || `导入表快照失败: ${result}` }
+      return {
+        success: true,
+        rows: Number(data?.rows || 0),
+        inserted: Number(data?.inserted || 0),
+        ignored: Number(data?.ignored || 0),
+        malformed: Number(data?.malformed || 0),
+        columns: Number(data?.columns || 0)
+      }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
  async getMessageTableTimeRange(dbPath: string, tableName: string): Promise<{ success: boolean; data?: any; error?: string }> {
    if (!this.ensureReady()) return { success: false, error: 'WCDB 未连接' }
    if (!this.wcdbGetMessageTableTimeRange) return { success: false, error: '接口未就绪' }
--- a/electron/services/wcdbService.ts
+++ b/electron/services/wcdbService.ts
@@ -25,9 +25,7 @@ export class WcdbService {
  private logEnabled = false
  private monitorListener: ((type: string, json: string) => void) | null = null

-  constructor() {
-    this.initWorker()
-  }
+  constructor() {}

  /**
   * 初始化 Worker 线程
@@ -94,6 +92,9 @@ export class WcdbService {
        this.setPaths(this.resourcesPath, this.userDataPath)
      }
      this.setLogEnabled(this.logEnabled)
+      if (this.monitorListener) {
+        this.callWorker<{ success?: boolean }>('setMonitor').catch(() => { })
+      }

    } catch (e) {
      // Failed to create worker
@@ -153,15 +154,17 @@ export class WcdbService {
  /**
   * 测试数据库连接
   */
-  async testConnection(dbPath: string, hexKey: string, wxid: string): Promise<{ success: boolean; error?: string; sessionCount?: number }> {
-    return this.callWorker('testConnection', { dbPath, hexKey, wxid })
+  async testConnection(accountDir: string, hexKey: string): Promise<{ success: boolean; error?: string; sessionCount?: number }> {
+    return this.callWorker('testConnection', { accountDir, hexKey })
  }

  /**
   * 打开数据库
+   * @param accountDir 账号目录的完整路径
+   * @param hexKey 解密密钥
   */
-  async open(dbPath: string, hexKey: string, wxid: string): Promise<boolean> {
-    return this.callWorker('open', { dbPath, hexKey, wxid })
+  async open(accountDir: string, hexKey: string): Promise<boolean> {
+    return this.callWorker('open', { accountDir, hexKey })
  }

  async getLastInitError(): Promise<string | null> {
@@ -201,6 +204,10 @@ export class WcdbService {
    return this.callWorker('getSessions')
  }

+  async markAllSessionsRead(): Promise<{ success: boolean; error?: string }> {
+    return this.callWorker('markAllSessionsRead')
+  }
+
  /**
   * 获取消息列表
   */
@@ -222,6 +229,13 @@ export class WcdbService {
    return this.callWorker('getMessageCount', { sessionId })
  }

+  /**
+   * 根据 server_id 查询单条消息
+   */
+  async getMessageByServerId(sessionId: string, svrid: string): Promise<{ success: boolean; row?: any; error?: string }> {
+    return this.callWorker('getMessageByServerId', { sessionId, svrid })
+  }
+
  async getMessageCounts(sessionIds: string[]): Promise<{ success: boolean; counts?: Record<string, number>; error?: string }> {
    return this.callWorker('getMessageCounts', { sessionIds })
  }
@@ -368,6 +382,26 @@ export class WcdbService {
    return this.callWorker('getMessageTableColumns', { dbPath, tableName })
  }

+  async listTables(kind: string, dbPath: string = ''): Promise<{ success: boolean; tables?: string[]; error?: string }> {
+    return this.callWorker('listTables', { kind, dbPath })
+  }
+
+  async getTableSchema(kind: string, dbPath: string, tableName: string): Promise<{ success: boolean; schema?: string; error?: string }> {
+    return this.callWorker('getTableSchema', { kind, dbPath, tableName })
+  }
+
+  async exportTableSnapshot(kind: string, dbPath: string, tableName: string, outputPath: string): Promise<{ success: boolean; rows?: number; columns?: number; error?: string }> {
+    return this.callWorker('exportTableSnapshot', { kind, dbPath, tableName, outputPath })
+  }
+
+  async importTableSnapshot(kind: string, dbPath: string, tableName: string, inputPath: string): Promise<{ success: boolean; rows?: number; inserted?: number; ignored?: number; malformed?: number; columns?: number; error?: string }> {
+    return this.callWorker('importTableSnapshot', { kind, dbPath, tableName, inputPath })
+  }
+
+  async importTableSnapshotWithSchema(kind: string, dbPath: string, tableName: string, inputPath: string, createTableSql: string): Promise<{ success: boolean; rows?: number; inserted?: number; ignored?: number; malformed?: number; columns?: number; error?: string }> {
+    return this.callWorker('importTableSnapshotWithSchema', { kind, dbPath, tableName, inputPath, createTableSql })
+  }
+
  async getMessageTableTimeRange(dbPath: string, tableName: string): Promise<{ success: boolean; data?: any; error?: string }> {
    return this.callWorker('getMessageTableTimeRange', { dbPath, tableName })
  }
--- a/electron/wcdbWorker.ts
+++ b/electron/wcdbWorker.ts
@@ -32,10 +32,10 @@ if (parentPort) {
                    break
                    }
                case 'testConnection':
-                    result = await core.testConnection(payload.dbPath, payload.hexKey, payload.wxid)
+                    result = await core.testConnection(payload.accountDir, payload.hexKey)
                    break
                case 'open':
-                    result = await core.open(payload.dbPath, payload.hexKey, payload.wxid)
+                    result = await core.open(payload.accountDir, payload.hexKey)
                    break
                case 'getLastInitError':
                    result = core.getLastInitError()
@@ -50,6 +50,9 @@ if (parentPort) {
                case 'getSessions':
                    result = await core.getSessions()
                    break
+                case 'markAllSessionsRead':
+                    result = await core.markAllSessionsRead()
+                    break
                case 'getMessages':
                    result = await core.getMessages(payload.sessionId, payload.limit, payload.offset)
                    break
@@ -59,6 +62,9 @@ if (parentPort) {
                case 'getMessageCount':
                    result = await core.getMessageCount(payload.sessionId)
                    break
+                case 'getMessageByServerId':
+                    result = await core.getMessageByServerId(payload.sessionId, payload.svrid)
+                    break
                case 'getMessageCounts':
                    result = await core.getMessageCounts(payload.sessionIds)
                    break
@@ -116,6 +122,21 @@ if (parentPort) {
                case 'getMessageTableColumns':
                    result = await core.getMessageTableColumns(payload.dbPath, payload.tableName)
                    break
+                case 'listTables':
+                    result = await core.listTables(payload.kind, payload.dbPath)
+                    break
+                case 'getTableSchema':
+                    result = await core.getTableSchema(payload.kind, payload.dbPath, payload.tableName)
+                    break
+                case 'exportTableSnapshot':
+                    result = await core.exportTableSnapshot(payload.kind, payload.dbPath, payload.tableName, payload.outputPath)
+                    break
+                case 'importTableSnapshot':
+                    result = await core.importTableSnapshot(payload.kind, payload.dbPath, payload.tableName, payload.inputPath)
+                    break
+                case 'importTableSnapshotWithSchema':
+                    result = await core.importTableSnapshotWithSchema(payload.kind, payload.dbPath, payload.tableName, payload.inputPath, payload.createTableSql)
+                    break
                case 'getMessageTableTimeRange':
                    result = await core.getMessageTableTimeRange(payload.dbPath, payload.tableName)
                    break
--- a/electron/windows/notificationWindow.ts
+++ b/electron/windows/notificationWindow.ts
@@ -9,10 +9,10 @@ let linuxNotificationService:
  | null = null;

 // 用于处理通知点击的回调函数（在Linux上用于导航到会话）
-let onNotificationNavigate: ((sessionId: string) => void) | null = null;
+let onNotificationNavigate: ((payload: unknown) => void) | null = null;

 export function setNotificationNavigateHandler(
-  callback: (sessionId: string) => void,
+  callback: (payload: unknown) => void,
 ) {
  onNotificationNavigate = callback;
 }
@@ -109,25 +109,33 @@ export function createNotificationWindow() {
 export async function showNotification(data: any) {
  // 先检查配置
  const config = ConfigService.getInstance();
-  const enabled = await config.get("notificationEnabled");
-  if (enabled === false) return; // 默认为 true
-
-  // 检查会话过滤
-  const filterMode = config.get("notificationFilterMode") || "all";
-  const filterList = config.get("notificationFilterList") || [];
  const sessionId = typeof data.sessionId === "string" ? data.sessionId : "";
-  // 系统通知（如 "WeFlow 准备就绪"）不是聊天消息，不应受会话白/黑名单影响
-  const isSystemNotification = sessionId.startsWith("weflow-");
+  const channel = typeof data.channel === "string" ? data.channel : "";
+  const isAiInsightNotification = channel === "ai-insight";

-  if (!isSystemNotification && filterMode !== "all") {
-    const isInList = sessionId !== "" && filterList.includes(sessionId);
-    if (filterMode === "whitelist" && !isInList) {
-      // 白名单模式：不在列表中则不显示（空列表视为全部拦截）
-      return;
-    }
-    if (filterMode === "blacklist" && isInList) {
-      // 黑名单模式：在列表中则不显示
-      return;
+  if (isAiInsightNotification) {
+    const enabled = await config.get("aiInsightNotificationEnabled");
+    if (enabled === false) return; // 默认为 true
+  } else {
+    const enabled = await config.get("notificationEnabled");
+    if (enabled === false) return; // 默认为 true
+
+    // 检查会话过滤
+    const filterMode = config.get("notificationFilterMode") || "all";
+    const filterList = config.get("notificationFilterList") || [];
+    // 系统通知（如 "WeFlow 准备就绪"）不是聊天消息，不应受会话白/黑名单影响
+    const isSystemNotification = sessionId.startsWith("weflow-");
+
+    if (!isSystemNotification && filterMode !== "all") {
+      const isInList = sessionId !== "" && filterList.includes(sessionId);
+      if (filterMode === "whitelist" && !isInList) {
+        // 白名单模式：不在列表中则不显示（空列表视为全部拦截）
+        return;
+      }
+      if (filterMode === "blacklist" && isInList) {
+        // 黑名单模式：在列表中则不显示
+        return;
+      }
    }
  }

@@ -176,6 +184,9 @@ async function showLinuxNotification(data: any) {
    content: data.content,
    avatarUrl: data.avatarUrl,
    sessionId: data.sessionId,
+    channel: data.channel,
+    insightRecordId: data.insightRecordId,
+    targetRoute: data.targetRoute,
    expireTimeout: 5000,
  };

@@ -249,14 +260,14 @@ export async function registerNotificationHandlers() {
      await linuxNotificationModule.initLinuxNotificationService();

      // 在Linux上注册通知点击回调
-      linuxNotificationModule.onNotificationAction((sessionId: string) => {
+      linuxNotificationModule.onNotificationAction((payload: unknown) => {
        console.log(
          "[NotificationWindow] Linux notification clicked, sessionId:",
-          sessionId,
+          payload,
        );
        // 如果设置了导航处理程序，则使用该处理程序；否则，回退到ipcMain方法。
        if (onNotificationNavigate) {
-          onNotificationNavigate(sessionId);
+          onNotificationNavigate(payload);
        } else {
          // 如果尚未设置处理程序，则通过ipcMain发出事件
          // 正常流程中不应该发生这种情况，因为我们在初始化之前设置了处理程序。
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -13,16 +13,17 @@
  },
  "//": "二改不应改变此处的作者与应用信息",
  "scripts": {
-    "postinstall": "electron-builder install-app-deps",
+    "postinstall": "electron-builder install-app-deps && node scripts/prepare-electron-runtime.cjs",
    "rebuild": "electron-rebuild",
-    "dev": "vite",
+    "dev": "node scripts/prepare-electron-runtime.cjs && vite",
    "typecheck": "tsc --noEmit",
    "build": "tsc && vite build && electron-builder",
    "preview": "vite preview",
-    "electron:dev": "vite --mode electron",
+    "electron:dev": "node scripts/prepare-electron-runtime.cjs && vite --mode electron",
    "electron:build": "npm run build"
  },
  "dependencies": {
+    "@vscode/sudo-prompt": "^9.3.2",
    "echarts": "^6.0.0",
    "echarts-for-react": "^3.0.2",
    "electron-store": "^11.0.2",
@@ -34,16 +35,15 @@
    "jieba-wasm": "^2.2.0",
    "jszip": "^3.10.1",
    "koffi": "^2.9.0",
-    "lucide-react": "^1.7.0",
+    "lucide-react": "^1.8.0",
    "react": "^19.2.3",
    "react-dom": "^19.2.3",
    "react-markdown": "^10.1.0",
    "react-router-dom": "^7.14.0",
-    "react-virtuoso": "^4.18.1",
+    "react-virtuoso": "^4.18.5",
    "remark-gfm": "^4.0.1",
    "sherpa-onnx-node": "^1.10.38",
    "silk-wasm": "^3.7.1",
-    "sudo-prompt": "^9.2.1",
    "wechat-emojis": "^1.0.2",
    "zustand": "^5.0.2"
  },
@@ -51,13 +51,14 @@
    "@electron/rebuild": "^4.0.2",
    "@types/react": "^19.1.0",
    "@types/react-dom": "^19.1.0",
-    "@vitejs/plugin-react": "^4.3.4",
+    "@vitejs/plugin-react": "^6.0.1",
    "electron": "^41.1.1",
    "electron-builder": "^26.8.1",
+    "esbuild": "^0.28.0",
    "sass": "^1.98.0",
    "sharp": "^0.34.5",
-    "typescript": "^6.0.2",
-    "vite": "^7.0.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.10",
    "vite-plugin-electron": "^0.28.8",
    "vite-plugin-electron-renderer": "^0.14.6"
  },
--- a/public/assets/insight/AI_Insight.png
+++ b/public/assets/insight/AI_Insight.png
--- a/public/splash.html
+++ b/public/splash.html
@@ -4,246 +4,478 @@
  <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; }
+  <script>
+    (function initSplashMode() {
+      var params = new URLSearchParams(window.location.search || "");
+      var mode = params.get("themeMode") || params.get("mode") || "system";
+      var themeId = params.get("themeId") || "cloud-dancer";
+      var mq = window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)");
+      var resolved = mode === "dark" || (mode === "system" && mq && mq.matches) ? "dark" : "light";

-    html, body {
-      width: 100%; height: 100%;
-      background: transparent;
+      document.documentElement.setAttribute("data-theme", themeId);
+      document.documentElement.setAttribute("data-theme-mode", mode);
+      document.documentElement.setAttribute("data-mode", resolved);
+    })();
+  </script>
+  <style>
+    :root {
+      --surface-start: #ffffff;
+      --surface-end: #f8f9fc;
+      --accent: #5b6abf;
+      --accent-rgb: 91, 106, 191;
+      --ambient-glow: rgba(91, 106, 191, 0.08);
+      --text: #1a1b1e;
+      --text-muted: #5f6368;
+      --text-faint: #9aa0a6;
+      --border-subtle: rgba(0, 0, 0, 0.05);
+      --loader-track: rgba(0, 0, 0, 0.06);
+      --shadow-window:
+        0 24px 60px rgba(23, 27, 38, 0.10),
+        0 4px 12px rgba(23, 27, 38, 0.04),
+        inset 0 1px 0 rgba(255, 255, 255, 1);
+      --radius-window: 24px;
+      --ease-ambient: cubic-bezier(0.2, 0.8, 0.2, 1);
+      --font: Inter, -apple-system, BlinkMacSystemFont, "Segoe UI", "Microsoft YaHei", sans-serif;
+    }
+
+    [data-mode="dark"] {
+      --surface-start: #14171d;
+      --surface-end: #0b0d10;
+      --accent: #7c8deb;
+      --accent-rgb: 124, 141, 235;
+      --ambient-glow: rgba(124, 141, 235, 0.08);
+      --text: #f0f0f0;
+      --text-muted: #8b92a5;
+      --text-faint: #4e5569;
+      --border-subtle: rgba(255, 255, 255, 0.06);
+      --loader-track: rgba(255, 255, 255, 0.09);
+      --shadow-window:
+        0 24px 80px rgba(0, 0, 0, 0.60),
+        inset 0 1px 0 rgba(255, 255, 255, 0.05);
+      --radius-window: 20px;
+    }
+
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    html,
+    body {
+      width: 100%;
+      height: 100%;
      overflow: hidden;
-      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Microsoft YaHei', sans-serif;
+      background: transparent;
+      color: var(--text);
+      font-family: var(--font);
+      -webkit-font-smoothing: antialiased;
      user-select: none;
+    }
+
+    body {
+      display: grid;
+      place-items: center;
      -webkit-app-region: drag;
    }

-    .splash {
-      width: 100%; height: 100%;
-      border-radius: 20px;
+    .splash-shell {
+      width: 600px;
+      height: 380px;
+      max-width: calc(100vw - 64px);
+      max-height: calc(100vh - 64px);
+      position: relative;
      display: flex;
      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      overflow: hidden;
+      border-radius: var(--radius-window);
+      border: 1px solid var(--border-subtle);
+      background: linear-gradient(145deg, var(--surface-start), var(--surface-end));
+      box-shadow: var(--shadow-window);
+      isolation: isolate;
+      animation: windowAppear 800ms var(--ease-ambient) both;
    }

-    /* 品牌区 */
-    .brand {
-      padding: 48px 52px 0;
+    .splash-shell::before {
+      content: "";
+      position: absolute;
+      width: 200%;
+      height: 200%;
+      left: -50%;
+      top: -50%;
+      background: radial-gradient(circle at 50% 40%, var(--ambient-glow) 0%, transparent 44%);
+      pointer-events: none;
+      z-index: -1;
+    }
+
+    .brand-stage {
+      position: relative;
+      z-index: 2;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      margin-top: -20px;
+      text-align: center;
+      animation: contentIn 560ms var(--ease-ambient) 90ms both;
+    }
+
+    .logo-core {
+      width: 64px;
+      height: 64px;
+      display: grid;
+      place-items: center;
+      margin-bottom: 24px;
+      background: transparent;
+      border: 0;
+    }
+
+    .logo-image {
+      width: 64px;
+      height: 64px;
+      display: block;
+      object-fit: contain;
+      border-radius: 20px;
+      animation: logoBreathe 3200ms ease-in-out infinite alternate;
+    }
+
+    .app-name {
+      font-size: 24px;
+      line-height: 1.18;
+      font-weight: 600;
+      letter-spacing: 0.02em;
+      color: var(--text);
+      margin-bottom: 6px;
+    }
+
+    [data-mode="dark"] .app-name {
+      text-shadow: 0 2px 10px rgba(0, 0, 0, 0.50);
+    }
+
+    .app-desc {
+      font-size: 13px;
+      line-height: 1.5;
+      font-weight: 500;
+      letter-spacing: 0.04em;
+      color: var(--text-muted);
+    }
+
+    [data-mode="dark"] .app-desc {
+      font-weight: 400;
+      letter-spacing: 0.05em;
+    }
+
+    .status-row {
+      position: absolute;
+      left: 32px;
+      right: 32px;
+      bottom: 24px;
+      z-index: 2;
+      display: flex;
+      align-items: flex-end;
+      justify-content: space-between;
+      gap: 18px;
+      color: var(--text-faint);
+      font-size: 11px;
+      line-height: 1.4;
+      font-variant-numeric: tabular-nums;
+      animation: contentIn 560ms var(--ease-ambient) 170ms both;
+    }
+
+    .progress-text-wrap {
+      min-width: 0;
      display: flex;
      align-items: center;
-      gap: 18px;
-      animation: fadeIn 0.4s ease both;
+      gap: 6px;
+      color: var(--text-muted);
+      font-weight: 500;
    }
-    .logo {
-      width: 56px; height: 56px;
-      border-radius: 14px;
+
+    [data-mode="dark"] .progress-text-wrap {
+      color: var(--text-faint);
+      font-weight: 400;
+    }
+
+    .status-dot {
+      width: 4px;
+      height: 4px;
+      flex: 0 0 auto;
+      border-radius: 50%;
+      background: var(--accent);
+      box-shadow: 0 0 6px rgba(var(--accent-rgb), 0.42);
+      animation: dotPulse 1700ms ease-in-out infinite;
+    }
+
+    .progress-text {
+      min-width: 0;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      letter-spacing: 0.02em;
+    }
+
+    .version {
      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;
+      color: var(--text-faint);
+      font-family: "SFMono-Regular", Consolas, "Liberation Mono", monospace;
+      font-size: 10px;
+      letter-spacing: 0;
+      opacity: 0.62;
    }

-    .spacer { flex: 1; }
-
-    /* 底部进度区 */
-    .bottom {
-      padding: 0 48px 40px;
-      animation: fadeIn 0.4s ease 0.1s both;
+    [data-mode="dark"] .version {
+      opacity: 0.50;
    }

-    /* 进度条轨道 */
    .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;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      z-index: 3;
+      height: 3px;
+      background: var(--loader-track);
+      overflow: hidden;
+    }
+
+    [data-mode="dark"] .progress-track {
+      height: 3px;
+    }
+
+    .progress-fill {
+      position: absolute;
+      left: 0;
+      bottom: 0;
+      width: 0%;
+      height: 100%;
+      min-width: 0;
+      border-radius: 0 999px 999px 0;
+      background: var(--accent);
+      box-shadow: 0 0 18px rgba(var(--accent-rgb), 0.34);
+      overflow: hidden;
+      transition: width 440ms var(--ease-ambient);
+    }
+
+    .progress-fill::before {
+      content: "";
+      position: absolute;
+      top: -7px;
+      right: -18px;
+      width: 44px;
+      height: 15px;
+      border-radius: 999px;
+      background: rgba(var(--accent-rgb), 0.34);
+      filter: blur(8px);
      opacity: 0;
    }

-    /* 等待阶段：进度条末端呼吸光点 */
-    .progress-fill.waiting::before {
-      content: '';
+    .progress-fill::after {
+      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;
+      inset: -1px 0;
+      background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.54), transparent);
+      opacity: 0;
+      transform: translateX(-100%);
+      animation: spectralGlide 1200ms ease-out;
    }

-    .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;
+    .progress-fill.waiting::before {
+      opacity: 0.65;
+      animation: leadingGlow 1300ms ease-in-out infinite;
    }

-    @keyframes fadeIn {
-      from { opacity: 0; transform: translateY(4px); }
-      to   { opacity: 1; transform: translateY(0); }
+    @media (prefers-reduced-motion: reduce) {
+      .splash-shell,
+      .brand-stage,
+      .status-row,
+      .logo-image,
+      .status-dot,
+      .progress-fill,
+      .progress-fill::before,
+      .progress-fill::after {
+        animation: none !important;
+        transition: none !important;
+      }
+
+      .progress-fill {
+        left: 0 !important;
+        opacity: 1 !important;
+      }
    }
-    @keyframes sweep {
-      0%   { opacity: 0; transform: translateX(-100%); }
-      20%  { opacity: 1; }
-      80%  { opacity: 1; }
-      100% { opacity: 0; transform: translateX(100%); }
+
+    @keyframes windowAppear {
+      0% {
+        opacity: 0;
+        transform: scale(0.97) translateY(12px);
+      }
+      100% {
+        opacity: 1;
+        transform: scale(1) translateY(0);
+      }
    }
-    @keyframes pulse {
-      0%, 100% { opacity: 0.4; transform: scaleX(1); }
-      50%       { opacity: 1;   transform: scaleX(1.8); }
+
+    @keyframes contentIn {
+      0% {
+        opacity: 0;
+        transform: translateY(8px);
+      }
+      100% {
+        opacity: 1;
+        transform: translateY(0);
+      }
    }
+
+    @keyframes logoBreathe {
+      0% {
+        opacity: 0.94;
+        transform: translateY(0);
+      }
+      100% {
+        opacity: 1;
+        transform: translateY(-3px);
+      }
+    }
+
+    @keyframes dotPulse {
+      0%,
+      100% {
+        opacity: 0.38;
+        transform: scale(0.84);
+      }
+      50% {
+        opacity: 1;
+        transform: scale(1.18);
+      }
+    }
+
+    @keyframes leadingGlow {
+      0%,
+      100% {
+        opacity: 0.38;
+        transform: scaleX(0.78);
+      }
+      50% {
+        opacity: 0.86;
+        transform: scaleX(1.28);
+      }
+    }
+
+    @keyframes spectralGlide {
+      0% {
+        opacity: 0;
+        transform: translateX(-100%);
+      }
+      22%,
+      66% {
+        opacity: 0.58;
+      }
+      100% {
+        opacity: 0;
+        transform: translateX(100%);
+      }
+    }
+
  </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>
+  <main class="splash-shell" id="splash" role="status" aria-live="polite">
+    <section class="brand-stage" aria-label="WeFlow">
+      <div class="logo-core" aria-hidden="true">
+        <img class="logo-image" src="./logo.png" alt="">
      </div>
+
+      <h1 class="app-name">WeFlow</h1>
+      <p class="app-desc">&#24494;&#20449;&#32842;&#22825;&#35760;&#24405;&#31649;&#29702;&#24037;&#20855;</p>
+    </section>
+
+    <div class="status-row">
+      <div class="progress-text-wrap">
+        <div class="status-dot" aria-hidden="true"></div>
+        <div class="progress-text" id="progressText">&#27491;&#22312;&#39044;&#21152;&#36733;&#20250;&#35805;&#36923;&#36753;...</div>
+      </div>
+      <div class="version" id="versionText"></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 class="progress-track" aria-hidden="true">
+      <div class="progress-fill" id="progressFill"></div>
    </div>
-  </div>
+  </main>

  <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' }
-      }
-    };
+    var themeModeQuery = null;
+    var systemModeQuery = null;

-    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');
+    function resolveMode(mode) {
+      if (mode === "dark" || mode === "light") return mode;
+      return window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+    }
+
+    function syncSystemModeListener(mode) {
+      if (!window.matchMedia) return;
+      var nextQuery = window.matchMedia("(prefers-color-scheme: dark)");
+
+      if (systemModeQuery && systemModeQuery !== nextQuery && systemModeQuery.removeEventListener) {
+        systemModeQuery.removeEventListener("change", handleSystemModeChange);
+      }
+
+      systemModeQuery = nextQuery;
+      themeModeQuery = mode;
+
+      if (mode === "system" && nextQuery.addEventListener) {
+        nextQuery.addEventListener("change", handleSystemModeChange);
+      }
+    }
+
+    function handleSystemModeChange() {
+      if (themeModeQuery === "system") {
+        document.documentElement.setAttribute("data-mode", resolveMode("system"));
+      }
+    }
+
+    function applyTheme(themeId, mode) {
+      var safeThemeId = String(themeId || "cloud-dancer");
+      var safeMode = mode === "light" || mode === "dark" || mode === "system" ? mode : "system";
+      var resolvedMode = resolveMode(safeMode);
+
+      document.documentElement.setAttribute("data-theme", safeThemeId);
+      document.documentElement.setAttribute("data-theme-mode", safeMode);
+      document.documentElement.setAttribute("data-mode", resolvedMode);
+      syncSystemModeListener(safeMode);
    }

-    // percent: 实际进度值；waiting: 是否处于等待阶段
    function updateProgress(percent, text, waiting) {
-      var fill = document.getElementById('progressFill');
-      var label = document.getElementById('progressText');
+      var fill = document.getElementById("progressFill");
+      var label = document.getElementById("progressText");
+      var safePercent = Math.max(0, Math.min(100, Number(percent) || 0));

      if (fill) {
-        fill.style.width = percent + '%';
+        fill.style.width = safePercent + "%";
        if (waiting) {
-          fill.classList.add('waiting');
+          fill.classList.add("waiting");
        } else {
-          fill.classList.remove('waiting');
-          // 触发扫光：重置动画
-          fill.style.animation = 'none';
+          fill.classList.remove("waiting");
+          fill.style.animation = "none";
          fill.offsetHeight;
-          fill.style.animation = '';
+          fill.style.animation = "";
        }
      }
+
      if (label && text) label.textContent = text;
    }

-    function setVersion(ver) {
-      var el = document.getElementById('versionText');
-      if (el) el.textContent = 'v' + ver;
+    function setVersion(version) {
+      var el = document.getElementById("versionText");
+      if (!el) return;
+      var text = String(version || "").trim();
+      el.textContent = text ? "v" + text.replace(/^v/i, "") : "";
    }

-    applyTheme('cloud-dancer', 'light');
+    (function bootstrapSplash() {
+      var params = new URLSearchParams(window.location.search || "");
+      applyTheme(params.get("themeId") || "cloud-dancer", params.get("themeMode") || "system");
+      updateProgress(0, "", false);
+    })();
  </script>
 </body>
 </html>
--- a/resources/fonts/annual-report/CormorantGaramond-Var.ttf
+++ b/resources/fonts/annual-report/CormorantGaramond-Var.ttf
--- a/resources/fonts/annual-report/Inter-Var.ttf
+++ b/resources/fonts/annual-report/Inter-Var.ttf
--- a/resources/fonts/annual-report/NotoSerifSC-Var.ttf
+++ b/resources/fonts/annual-report/NotoSerifSC-Var.ttf
--- a/resources/fonts/annual-report/PlayfairDisplay-Var.ttf
+++ b/resources/fonts/annual-report/PlayfairDisplay-Var.ttf
--- a/resources/fonts/annual-report/SpaceMono-Bold.ttf
+++ b/resources/fonts/annual-report/SpaceMono-Bold.ttf
--- a/resources/fonts/annual-report/SpaceMono-Regular.ttf
+++ b/resources/fonts/annual-report/SpaceMono-Regular.ttf
--- a/resources/image/README.md
+++ b/resources/image/README.md
@@ -0,0 +1 @@
+> 目前只适配了x64 win32平台，其它平台同样原理，但是代码还没写（
--- a/resources/image/win32/x64/img_helper.dll
+++ b/resources/image/win32/x64/img_helper.dll
--- a/resources/installer/linux/.gitignore
+++ b/resources/installer/linux/.gitignore
@@ -0,0 +1,6 @@
+*.tar.gz
+*.tar.xz
+*.zip
+src/
+pkg/
+weflow-*/
--- a/resources/key/linux/x64/xkey_helper_linux
+++ b/resources/key/linux/x64/xkey_helper_linux
--- a/resources/wcdb/linux/x64/libwcdb_api.so
+++ b/resources/wcdb/linux/x64/libwcdb_api.so
--- a/resources/wcdb/macos/universal/libwcdb_api.dylib
+++ b/resources/wcdb/macos/universal/libwcdb_api.dylib
--- a/resources/wcdb/win32/arm64/wcdb_api.dll
+++ b/resources/wcdb/win32/arm64/wcdb_api.dll
--- a/resources/wcdb/win32/x64/wcdb_api.dll
+++ b/resources/wcdb/win32/x64/wcdb_api.dll
--- a/resources/wedecrypt/linux/x64/weflow-image-native-linux-x64.node
+++ b/resources/wedecrypt/linux/x64/weflow-image-native-linux-x64.node
--- a/resources/wedecrypt/macos/arm64/weflow-image-native-macos-arm64.node
+++ b/resources/wedecrypt/macos/arm64/weflow-image-native-macos-arm64.node
--- a/resources/wedecrypt/win32/arm64/weflow-image-native-win32-arm64.node
+++ b/resources/wedecrypt/win32/arm64/weflow-image-native-win32-arm64.node
--- a/resources/wedecrypt/win32/x64/weflow-image-native-win32-x64.node
+++ b/resources/wedecrypt/win32/x64/weflow-image-native-win32-x64.node
--- a/scripts/prepare-electron-runtime.cjs
+++ b/scripts/prepare-electron-runtime.cjs
@@ -0,0 +1,57 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const runtimeNames = [
+  'msvcp140.dll',
+  'msvcp140_1.dll',
+  'vcruntime140.dll',
+  'vcruntime140_1.dll',
+];
+
+function copyIfDifferent(sourcePath, targetPath) {
+  const source = fs.statSync(sourcePath);
+  const targetExists = fs.existsSync(targetPath);
+
+  if (targetExists) {
+    const target = fs.statSync(targetPath);
+    if (target.size === source.size && target.mtimeMs >= source.mtimeMs) {
+      return false;
+    }
+  }
+
+  fs.copyFileSync(sourcePath, targetPath);
+  return true;
+}
+
+function main() {
+  if (process.platform !== 'win32') {
+    return;
+  }
+
+  const projectRoot = path.resolve(__dirname, '..');
+  const sourceDir = path.join(projectRoot, 'resources', 'runtime', 'win32');
+  const targetDir = path.join(projectRoot, 'node_modules', 'electron', 'dist');
+
+  if (!fs.existsSync(sourceDir) || !fs.existsSync(targetDir)) {
+    return;
+  }
+
+  let copiedCount = 0;
+
+  for (const name of runtimeNames) {
+    const sourcePath = path.join(sourceDir, name);
+    const targetPath = path.join(targetDir, name);
+    if (!fs.existsSync(sourcePath)) {
+      continue;
+    }
+    if (copyIfDifferent(sourcePath, targetPath)) {
+      copiedCount += 1;
+    }
+  }
+
+  if (copiedCount > 0) {
+    console.log(`[prepare-electron-runtime] synced ${copiedCount} runtime DLL(s) to ${targetDir}`);
+  }
+}
+
+main();
--- a/shared/groupSummaryPrompt.json
+++ b/shared/groupSummaryPrompt.json
@@ -0,0 +1,3 @@
+{
+  "defaultSystemPrompt": "你是一个群聊会议纪要式总结助手。你只根据用户提供的群聊记录总结，不编造记录中没有的信息。\n\n严格要求：\n1. 必须且只能输出合法纯 JSON，禁止 Markdown 和解释说明。\n2. 按话题分类总结，每个话题包含参与者、关键/矛盾点、结论。\n3. 参与者写群成员显示名；不确定参与者时写已有发言人。\n4. 关键/矛盾点必须来自聊天记录，避免泛泛而谈。\n5. 结论要短、具体；没有结论时写“暂无明确结论”。\n\nJSON 输出格式：\n{\n  \"topics\": [\n    {\n      \"title\": \"话题名称\",\n      \"participants\": [\"参与者A\", \"参与者B\"],\n      \"key_points\": [\"关键点或矛盾点\"],\n      \"conclusion\": \"结论\"\n    }\n  ]\n}"
+}
--- a/src/App.scss
+++ b/src/App.scss
@@ -3,56 +3,15 @@
  display: flex;
  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 {
  position: fixed;
  top: 0;
  left: 0;
-  right: 150px; // 预留系统最小化/最大化/关闭按钮区域
+  right: 150px;
  height: 40px;
  -webkit-app-region: drag;
  pointer-events: auto;
@@ -68,8 +27,9 @@
 .content {
  flex: 1;
  overflow: auto;
-  padding: 24px;
+  padding: 24px 32px;
  position: relative;
+  background: var(--bg-primary);
 }

 .export-keepalive-page {
@@ -84,18 +44,7 @@
  display: none;
 }

-@keyframes appFadeIn {
-  from {
-    opacity: 0;
-    transform: translateY(8px);
-  }
-  to {
-    opacity: 1;
-    transform: translateY(0);
-  }
-}
-
-// 更新提示条
+// ---- Update banner ----
 .update-banner {
  display: flex;
  align-items: center;
@@ -107,7 +56,7 @@

  .update-text {
    flex: 1;
-    
+
    strong {
      font-weight: 600;
    }
@@ -124,7 +73,7 @@
    color: white;
    font-size: 13px;
    cursor: pointer;
-    transition: background 0.2s;
+    transition: background 0.15s;

    &:hover {
      background: rgba(255, 255, 255, 0.3);
@@ -143,7 +92,7 @@
    color: white;
    cursor: pointer;
    opacity: 0.7;
-    transition: opacity 0.2s;
+    transition: opacity 0.15s;

    &:hover {
      opacity: 1;
@@ -178,29 +127,31 @@
  }
 }

-// 用户协议弹窗
+// ---- Agreement modal ----
 .agreement-overlay {
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
-  background: rgba(0, 0, 0, 0.6);
+  background: rgba(0, 0, 0, 0.5);
  display: flex;
  align-items: center;
  justify-content: center;
  z-index: 1000;
+  backdrop-filter: blur(4px);
 }

 .agreement-modal {
  width: 520px;
  max-height: 80vh;
  background: var(--bg-primary);
+  border: 1px solid var(--border-color);
  border-radius: 16px;
  overflow: hidden;
  display: flex;
  flex-direction: column;
-  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+  box-shadow: 0 24px 48px rgba(0, 0, 0, 0.2);
 }

 .agreement-header {
@@ -241,8 +192,8 @@
  margin-bottom: 16px;
  padding: 12px 14px;
  border-radius: 10px;
-  border: 1px solid rgba(255, 160, 0, 0.35);
-  background: rgba(255, 160, 0, 0.12);
+  border: 1px solid rgba(245, 158, 11, 0.3);
+  background: rgba(245, 158, 11, 0.08);
  color: var(--text-primary);

  strong {
@@ -291,19 +242,6 @@
    color: var(--text-secondary);
    line-height: 1.6;
  }
-
-  &::-webkit-scrollbar {
-    width: 6px;
-  }
-
-  &::-webkit-scrollbar-track {
-    background: transparent;
-  }
-
-  &::-webkit-scrollbar-thumb {
-    background: var(--border-color);
-    border-radius: 3px;
-  }
 }

 .agreement-footer {
@@ -347,21 +285,21 @@
    border-radius: 8px;
    font-size: 14px;
    cursor: pointer;
-    transition: background 0.2s;
+    transition: background 0.15s;

    &:hover {
-      background: var(--border-color);
+      background: var(--bg-hover);
    }
  }

  .btn-primary {
    background: var(--primary);
-    color: white;
+    color: var(--on-primary);
    border: none;
    border-radius: 8px;
    font-size: 14px;
    cursor: pointer;
-    transition: opacity 0.2s;
+    transition: opacity 0.15s;

    &:disabled {
      opacity: 0.5;
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -27,6 +27,8 @@ import ResourcesPage from './pages/ResourcesPage'
 import ChatHistoryPage from './pages/ChatHistoryPage'
 import NotificationWindow from './pages/NotificationWindow'
 import AccountManagementPage from './pages/AccountManagementPage'
+import BackupPage from './pages/BackupPage'
+import InsightInboxPage from './pages/InsightInboxPage'

 import { useAppStore } from './stores/appStore'
 import { themes, useThemeStore, type ThemeId, type ThemeMode } from './stores/themeStore'
@@ -80,6 +82,8 @@ function App() {
  const isChatHistoryWindow = location.pathname.startsWith('/chat-history/') || location.pathname.startsWith('/chat-history-inline/')
  const isStandaloneChatWindow = location.pathname === '/chat-window'
  const isNotificationWindow = location.pathname === '/notification-window'
+  const isAnnualReportWindow = location.pathname === '/annual-report/view'
+  const isDualReportWindow = location.pathname === '/dual-report/view'
  const isSettingsRoute = location.pathname === '/settings'
  const settingsRouteState = location.state as { backgroundLocation?: Location; initialTab?: unknown } | null
  const routeLocation = isSettingsRoute
@@ -127,7 +131,7 @@ function App() {
    const body = document.body
    const appRoot = document.getElementById('app')

-    if (isOnboardingWindow || isNotificationWindow) {
+    if (isOnboardingWindow || isNotificationWindow || isAnnualReportWindow || isDualReportWindow) {
      root.style.background = 'transparent'
      body.style.background = 'transparent'
      body.style.overflow = 'hidden'
@@ -144,9 +148,9 @@ function App() {
        appRoot.style.overflow = ''
      }
    }
-  }, [isOnboardingWindow])
+  }, [isOnboardingWindow, isNotificationWindow, isAnnualReportWindow, isDualReportWindow])

-  // 应用主题
+  // 应用主题 (accent color + light/dark mode)
  useEffect(() => {
    const mq = window.matchMedia('(prefers-color-scheme: dark)')
    const applyMode = (mode: ThemeMode, systemDark?: boolean) => {
@@ -165,7 +169,7 @@ function App() {
    }
    mq.addEventListener('change', handler)
    return () => mq.removeEventListener('change', handler)
-  }, [currentTheme, themeMode, isOnboardingWindow, isNotificationWindow])
+  }, [currentTheme, themeMode, isOnboardingWindow, isNotificationWindow, isAnnualReportWindow, isDualReportWindow])

  // 读取已保存的主题设置
  useEffect(() => {
@@ -316,6 +320,19 @@ function App() {
    }
  }, [navigate, isNotificationWindow])

+  useEffect(() => {
+    if (isNotificationWindow) return
+
+    const removeListener = window.electronAPI?.notification?.onNavigateToRoute?.((route: string) => {
+      if (!route || !route.startsWith('/')) return
+      navigate(route, { replace: true })
+    })
+
+    return () => {
+      removeListener?.()
+    }
+  }, [navigate, isNotificationWindow])
+
  // 解锁后显示暂存的更新弹窗
  useEffect(() => {
    if (!isLocked && updateInfo?.hasUpdate && !showUpdateDialog && !isDownloading) {
@@ -511,6 +528,16 @@ function App() {
    return <NotificationWindow />
  }

+  // 独立年度报告全屏窗口
+  if (isAnnualReportWindow) {
+    return <AnnualReportWindow />
+  }
+
+  // 独立双人报告全屏窗口
+  if (isDualReportWindow) {
+    return <DualReportWindow />
+  }
+
  // 主窗口 - 完整布局
  const handleCloseSettings = () => {
    const backgroundLocation = settingsRouteState?.backgroundLocation ?? settingsBackgroundRef.current
@@ -690,9 +717,11 @@ function App() {

              <Route path="/export" element={<div className="export-route-anchor" aria-hidden="true" />} />
              <Route path="/sns" element={<SnsPage />} />
+              <Route path="/insight-inbox" element={<InsightInboxPage />} />
              <Route path="/biz" element={<BizPage />} />
              <Route path="/contacts" element={<ContactsPage />} />
              <Route path="/resources" element={<ResourcesPage />} />
+              <Route path="/backup" element={<BackupPage />} />
              <Route path="/chat-history/:sessionId/:messageId" element={<ChatHistoryPage />} />
              <Route path="/chat-history-inline/:payloadId" element={<ChatHistoryPage />} />
            </Routes>
--- a/src/components/Avatar.tsx
+++ b/src/components/Avatar.tsx
@@ -5,6 +5,21 @@ import './Avatar.scss'

 // 全局缓存已成功加载过的头像 URL，用于控制后续是否显示动画
 const loadedAvatarCache = new Set<string>()
+const MAX_LOADED_AVATAR_CACHE_SIZE = 3000
+
+const rememberLoadedAvatar = (src: string): void => {
+    if (!src) return
+    if (loadedAvatarCache.has(src)) {
+        loadedAvatarCache.delete(src)
+    }
+    loadedAvatarCache.add(src)
+
+    while (loadedAvatarCache.size > MAX_LOADED_AVATAR_CACHE_SIZE) {
+        const oldest = loadedAvatarCache.values().next().value as string | undefined
+        if (!oldest) break
+        loadedAvatarCache.delete(oldest)
+    }
+}

 interface AvatarProps {
    src?: string
@@ -123,7 +138,7 @@ export const Avatar = React.memo(function Avatar({
                        onLoad={() => {
                            if (src) {
                                avatarLoadQueue.clearFailed(src)
-                                loadedAvatarCache.add(src)
+                                rememberLoadedAvatar(src)
                            }
                            setImageLoaded(true)
                            setImageError(false)
--- a/src/components/ChatAnalysisHeader.scss
+++ b/src/components/ChatAnalysisHeader.scss
@@ -4,28 +4,29 @@
  align-items: center;
  justify-content: space-between;
  gap: 16px;
-  min-height: 28px;
+  min-height: 32px;
  padding: 4px 0;
  background: transparent;
  border: none;
-  border-radius: 0;
  flex-shrink: 0;
 }

 .chat-analysis-back {
  display: inline-flex;
  align-items: center;
-  gap: 6px;
-  padding: 0;
+  gap: 4px;
+  padding: 4px 8px 4px 4px;
  border: none;
+  border-radius: 6px;
  background: transparent;
-  color: var(--text-secondary);
+  color: var(--text-tertiary);
  cursor: pointer;
-  transition: color 0.2s ease;
+  transition: background 0.15s ease, color 0.15s ease;
  font-size: 13px;
-  font-weight: 600;
+  font-weight: 500;

  &:hover {
+    background: var(--bg-hover);
    color: var(--text-primary);
  }
 }
@@ -33,12 +34,13 @@
 .chat-analysis-breadcrumb {
  display: flex;
  align-items: center;
-  gap: 8px;
+  gap: 4px;
  font-size: 13px;
-  color: var(--text-secondary);
+  color: var(--text-tertiary);

  .chat-analysis-breadcrumb-separator {
-    opacity: 0.6;
+    opacity: 0.5;
+    font-size: 12px;
  }
 }

@@ -49,25 +51,27 @@
 .chat-analysis-current-trigger {
  display: inline-flex;
  align-items: center;
-  gap: 6px;
-  padding: 0;
+  gap: 4px;
+  padding: 4px 8px;
  border: none;
+  border-radius: 6px;
  background: transparent;
-  color: var(--text-secondary);
+  color: var(--text-tertiary);
  cursor: pointer;
  font-size: 13px;
  font-weight: 600;
-  transition: color 0.2s ease;
+  transition: background 0.15s ease, color 0.15s ease;

  .current {
    color: var(--text-primary);
  }

  svg {
-    transition: transform 0.2s ease;
+    transition: transform 0.15s ease;
  }

  &:hover {
+    background: var(--bg-hover);
    color: var(--text-primary);
  }

@@ -78,34 +82,33 @@

 .chat-analysis-menu {
  position: absolute;
-  top: calc(100% + 10px);
+  top: calc(100% + 6px);
  right: 0;
  min-width: 120px;
-  padding: 6px;
-  background: var(--card-bg);
+  padding: 4px;
+  background: var(--bg-secondary-solid, var(--bg-secondary));
  border: 1px solid var(--border-color);
-  border-radius: 12px;
-  box-shadow: 0 12px 28px rgba(0, 0, 0, 0.12);
+  border-radius: 10px;
+  box-shadow: var(--shadow-md);
  z-index: 20;
 }

 .chat-analysis-menu-item {
  width: 100%;
  display: block;
-  padding: 9px 12px;
+  padding: 8px 12px;
  border: none;
-  border-radius: 8px;
+  border-radius: 6px;
  background: transparent;
  color: var(--text-primary);
  text-align: left;
  cursor: pointer;
  font-size: 13px;
  font-weight: 500;
-  transition: background 0.2s ease, color 0.2s ease;
+  transition: background 0.15s ease;

  &:hover {
    background: var(--bg-hover);
-    color: var(--primary);
  }
 }

--- a/src/components/Export/ExportDateRangeDialog.scss
+++ b/src/components/Export/ExportDateRangeDialog.scss
@@ -11,8 +11,7 @@

 .export-date-range-dialog {
  width: min(480px, calc(100vw - 32px));
-  max-height: calc(100vh - 64px);
-  overflow-y: auto;
+  max-height: calc(100vh - 80px);
  border-radius: 16px;
  border: 1px solid var(--border-color);
  background: var(--bg-secondary-solid, var(--bg-primary));
@@ -21,12 +20,14 @@
  flex-direction: column;
  gap: 10px;
  box-shadow: 0 22px 48px rgba(0, 0, 0, 0.16);
+  overflow: hidden;
 }

 .export-date-range-dialog-header {
  display: flex;
  align-items: center;
  justify-content: space-between;
+  flex-shrink: 0;

  h4 {
    margin: 0;
@@ -35,6 +36,26 @@
  }
 }

+.export-date-range-dialog-content {
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow-y: auto;
+  overflow-x: hidden;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding-right: 2px;
+
+  &::-webkit-scrollbar {
+    width: 6px;
+  }
+
+  &::-webkit-scrollbar-thumb {
+    background: var(--border-color);
+    border-radius: 3px;
+  }
+}
+
 .export-date-range-dialog-close-btn {
  border: 1px solid var(--border-color);
  background: var(--bg-secondary);
@@ -439,6 +460,7 @@
  display: flex;
  justify-content: flex-end;
  gap: 8px;
+  flex-shrink: 0;
 }

 .export-date-range-dialog-btn {
--- a/src/components/Export/ExportDateRangeDialog.tsx
+++ b/src/components/Export/ExportDateRangeDialog.tsx
@@ -551,8 +551,13 @@ export function ExportDateRangeDialog({
  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-overlay"
+      onClick={(event) => {
+        event.stopPropagation()
+        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
@@ -565,6 +570,7 @@ export function ExportDateRangeDialog({
          </button>
        </div>

+        <div className="export-date-range-dialog-content">
        <div className="export-date-range-preset-list">
          {EXPORT_DATE_RANGE_PRESETS.map((preset) => {
            const active = isPresetActive(preset.value)
@@ -728,6 +734,7 @@ export function ExportDateRangeDialog({
            })}
          </div>
        </section>
+        </div>

        <div className="export-date-range-dialog-actions">
          <button type="button" className="export-date-range-dialog-btn secondary" onClick={onClose}>
--- a/src/components/Export/ExportDefaultsSettingsForm.scss
+++ b/src/components/Export/ExportDefaultsSettingsForm.scss
@@ -231,7 +231,8 @@
    label {
      display: inline-flex;
      align-items: center;
-      gap: 5px;
+      gap: 6px;
+      position: relative;
      margin-bottom: 0;
      font-size: 13px;
      line-height: 1;
@@ -239,11 +240,55 @@
      color: var(--text-primary);
      cursor: pointer;
      white-space: nowrap;
+      transition: border-color 0.16s ease, background 0.16s ease;
    }

    input[type='checkbox'] {
      margin: 0;
-      accent-color: var(--primary);
+      position: absolute;
+      width: 1px;
+      height: 1px;
+      opacity: 0;
+      pointer-events: none;
+
+      &:checked + .media-default-check {
+        border-color: var(--primary);
+        background: color-mix(in srgb, var(--primary) 88%, #fff);
+      }
+
+      &:checked + .media-default-check::after {
+        opacity: 1;
+        transform: rotate(-45deg) scale(1);
+      }
+
+      &:focus-visible + .media-default-check {
+        box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary) 18%, transparent);
+      }
+    }
+
+    .media-default-check {
+      width: 14px;
+      height: 14px;
+      flex: 0 0 14px;
+      border: 1px solid color-mix(in srgb, var(--border-color) 82%, var(--text-tertiary));
+      border-radius: 4px;
+      background: var(--bg-primary);
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      transition: border-color 0.16s ease, background 0.16s ease, box-shadow 0.16s ease;
+
+      &::after {
+        content: '';
+        width: 7px;
+        height: 4px;
+        border-left: 2px solid #fff;
+        border-bottom: 2px solid #fff;
+        opacity: 0;
+        transform: rotate(-45deg) scale(0.72);
+        transform-origin: center;
+        transition: opacity 0.16s ease, transform 0.16s ease;
+      }
    }
  }

@@ -457,3 +502,184 @@
    }
  }
 }
+
+// UI rebuild polish for the modal variant used by ExportPage.
+.export-defaults-settings-form.layout-split {
+  display: grid;
+  gap: 10px;
+
+  .form-group {
+    grid-template-columns: minmax(176px, 0.82fr) minmax(0, 1.18fr);
+    gap: 12px;
+    align-items: start;
+    padding: 12px;
+    border: none;
+    border-radius: 12px;
+    background: color-mix(in srgb, var(--bg-secondary) 82%, var(--bg-primary));
+  }
+
+  .form-group:first-child,
+  .form-group:last-child {
+    padding: 12px;
+  }
+
+  .form-copy {
+    padding-top: 2px;
+  }
+
+  label {
+    margin-bottom: 3px;
+    line-height: 1.35;
+  }
+
+  .form-hint {
+    line-height: 1.45;
+  }
+
+  .form-control {
+    width: 100%;
+    min-width: 0;
+    justify-content: stretch;
+  }
+
+  .select-field,
+  .settings-time-range-field,
+  .log-toggle-line,
+  .media-default-grid,
+  .concurrency-inline-options {
+    max-width: none;
+    width: 100%;
+  }
+
+  .select-trigger,
+  .settings-time-range-trigger {
+    border-radius: 12px;
+    background: var(--bg-primary);
+    min-height: 42px;
+    padding: 9px 12px;
+  }
+
+  .log-toggle-line {
+    border-radius: 12px;
+    background: var(--bg-primary);
+    min-height: 42px;
+    padding: 8px 12px;
+  }
+
+  .concurrency-inline-options {
+    grid-template-columns: repeat(6, minmax(38px, 1fr));
+    gap: 6px;
+  }
+
+  .concurrency-option {
+    min-width: 0;
+    min-height: 36px;
+    border-radius: 8px;
+  }
+
+  .format-setting-group {
+    grid-template-columns: 1fr;
+    gap: 10px;
+  }
+
+  .format-grid {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    gap: 8px;
+    width: 100%;
+  }
+
+  .format-card {
+    min-height: 68px;
+    padding: 10px 12px;
+    border-radius: 8px;
+    background: var(--bg-primary);
+  }
+
+  .format-label,
+  .format-desc {
+    max-width: 100%;
+    overflow-wrap: anywhere;
+  }
+
+  .media-default-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(78px, 1fr));
+    gap: 8px;
+
+    label {
+      min-height: 34px;
+      padding: 7px 10px;
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      background: var(--bg-primary);
+
+      &:hover {
+        border-color: color-mix(in srgb, var(--primary) 38%, var(--border-color));
+        background: color-mix(in srgb, var(--text-tertiary) 4%, var(--bg-primary));
+      }
+    }
+  }
+}
+
+.select-dropdown-floating {
+  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);
+  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: background 0.15s ease, color 0.15s ease;
+    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);
+  }
+
+  .select-option.active .option-desc {
+    color: var(--primary);
+  }
+}
+
+@media (max-width: 980px) {
+  .export-defaults-settings-form.layout-split {
+    .form-group {
+      grid-template-columns: 1fr;
+      gap: 10px;
+    }
+
+    .format-grid {
+      grid-template-columns: repeat(auto-fit, minmax(156px, 1fr));
+    }
+  }
+}
--- a/src/components/Export/ExportDefaultsSettingsForm.tsx
+++ b/src/components/Export/ExportDefaultsSettingsForm.tsx
@@ -1,4 +1,6 @@
-import { useEffect, useMemo, useRef, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import type { CSSProperties } from 'react'
+import { createPortal } from 'react-dom'
 import { ChevronDown } from 'lucide-react'
 import * as configService from '../../services/config'
 import { ExportDateRangeDialog } from './ExportDateRangeDialog'
@@ -56,6 +58,48 @@ const getOptionLabel = (options: ReadonlyArray<{ value: string; label: string }>
  return options.find((option) => option.value === value)?.label ?? value
 }

+interface SelectDropdownPlacement {
+  left: number
+  width: number
+  maxHeight: number
+  top?: number
+  bottom?: number
+}
+
+const resolveSelectDropdownPlacement = (anchor: HTMLElement | null): SelectDropdownPlacement | null => {
+  if (!anchor || typeof window === 'undefined') return null
+
+  const rect = anchor.getBoundingClientRect()
+  const viewportWidth = window.innerWidth || document.documentElement.clientWidth
+  const viewportHeight = window.innerHeight || document.documentElement.clientHeight
+  const viewportMargin = 12
+  const dropdownGap = 6
+  const minDropdownHeight = 128
+  const availableWidth = Math.max(160, viewportWidth - viewportMargin * 2)
+  const width = Math.min(Math.max(rect.width, 220), availableWidth)
+  const left = Math.max(viewportMargin, Math.min(rect.left, viewportWidth - width - viewportMargin))
+  const spaceBelow = Math.max(0, viewportHeight - rect.bottom - viewportMargin - dropdownGap)
+  const spaceAbove = Math.max(0, rect.top - viewportMargin - dropdownGap)
+  const shouldOpenAbove = spaceBelow < minDropdownHeight && spaceAbove > spaceBelow
+  const availableHeight = shouldOpenAbove ? spaceAbove : spaceBelow
+  const maxHeight = Math.max(96, Math.min(320, availableHeight))
+
+  return shouldOpenAbove
+    ? { left, width, maxHeight, bottom: viewportHeight - rect.top + dropdownGap }
+    : { left, width, maxHeight, top: rect.bottom + dropdownGap }
+}
+
+const getSelectDropdownStyle = (placement: SelectDropdownPlacement): CSSProperties => ({
+  position: 'fixed',
+  top: placement.top,
+  bottom: placement.bottom,
+  left: placement.left,
+  right: 'auto',
+  width: placement.width,
+  maxHeight: placement.maxHeight,
+  zIndex: 9300
+})
+
 export function ExportDefaultsSettingsForm({
  onNotify,
  onDefaultsChanged,
@@ -66,6 +110,10 @@ export function ExportDefaultsSettingsForm({
  const [isExportDateRangeDialogOpen, setIsExportDateRangeDialogOpen] = useState(false)
  const exportExcelColumnsDropdownRef = useRef<HTMLDivElement>(null)
  const exportFileNamingModeDropdownRef = useRef<HTMLDivElement>(null)
+  const exportExcelColumnsMenuRef = useRef<HTMLDivElement>(null)
+  const exportFileNamingModeMenuRef = useRef<HTMLDivElement>(null)
+  const [exportExcelColumnsPlacement, setExportExcelColumnsPlacement] = useState<SelectDropdownPlacement | null>(null)
+  const [exportFileNamingModePlacement, setExportFileNamingModePlacement] = useState<SelectDropdownPlacement | null>(null)

  const [exportDefaultFormat, setExportDefaultFormat] = useState('excel')
  const [exportDefaultAvatars, setExportDefaultAvatars] = useState(true)
@@ -122,10 +170,20 @@ export function ExportDefaultsSettingsForm({
  useEffect(() => {
    const handleClickOutside = (e: MouseEvent) => {
      const target = e.target as Node
-      if (showExportExcelColumnsSelect && exportExcelColumnsDropdownRef.current && !exportExcelColumnsDropdownRef.current.contains(target)) {
+      if (
+        showExportExcelColumnsSelect &&
+        exportExcelColumnsDropdownRef.current &&
+        !exportExcelColumnsDropdownRef.current.contains(target) &&
+        !exportExcelColumnsMenuRef.current?.contains(target)
+      ) {
        setShowExportExcelColumnsSelect(false)
      }
-      if (showExportFileNamingModeSelect && exportFileNamingModeDropdownRef.current && !exportFileNamingModeDropdownRef.current.contains(target)) {
+      if (
+        showExportFileNamingModeSelect &&
+        exportFileNamingModeDropdownRef.current &&
+        !exportFileNamingModeDropdownRef.current.contains(target) &&
+        !exportFileNamingModeMenuRef.current?.contains(target)
+      ) {
        setShowExportFileNamingModeSelect(false)
      }
    }
@@ -134,6 +192,30 @@ export function ExportDefaultsSettingsForm({
    return () => document.removeEventListener('mousedown', handleClickOutside)
  }, [showExportExcelColumnsSelect, showExportFileNamingModeSelect])

+  const updateSelectDropdownPlacements = useCallback(() => {
+    if (showExportExcelColumnsSelect) {
+      setExportExcelColumnsPlacement(resolveSelectDropdownPlacement(exportExcelColumnsDropdownRef.current))
+    }
+    if (showExportFileNamingModeSelect) {
+      setExportFileNamingModePlacement(resolveSelectDropdownPlacement(exportFileNamingModeDropdownRef.current))
+    }
+  }, [showExportExcelColumnsSelect, showExportFileNamingModeSelect])
+
+  useEffect(() => {
+    if (!showExportExcelColumnsSelect) setExportExcelColumnsPlacement(null)
+    if (!showExportFileNamingModeSelect) setExportFileNamingModePlacement(null)
+    if (!showExportExcelColumnsSelect && !showExportFileNamingModeSelect) return
+
+    updateSelectDropdownPlacements()
+    window.addEventListener('resize', updateSelectDropdownPlacements)
+    document.addEventListener('scroll', updateSelectDropdownPlacements, true)
+
+    return () => {
+      window.removeEventListener('resize', updateSelectDropdownPlacements)
+      document.removeEventListener('scroll', updateSelectDropdownPlacements, true)
+    }
+  }, [showExportExcelColumnsSelect, showExportFileNamingModeSelect, updateSelectDropdownPlacements])
+
  const exportExcelColumnsValue = exportDefaultExcelCompactColumns ? 'compact' : 'full'
  const exportDateRangeLabel = useMemo(() => getExportDateRangeLabel(exportDefaultDateRange), [exportDefaultDateRange])
  const exportExcelColumnsLabel = useMemo(() => getOptionLabel(exportExcelColumnOptions, exportExcelColumnsValue), [exportExcelColumnsValue])
@@ -143,6 +225,73 @@ export function ExportDefaultsSettingsForm({
    onNotify?.(text, success)
  }

+  const fileNamingModeDropdown = showExportFileNamingModeSelect && exportFileNamingModePlacement
+    ? createPortal(
+      <div
+        ref={exportFileNamingModeMenuRef}
+        className="select-dropdown select-dropdown-floating"
+        role="listbox"
+        style={getSelectDropdownStyle(exportFileNamingModePlacement)}
+        onClick={(event) => event.stopPropagation()}
+      >
+        {exportFileNamingModeOptions.map((option) => (
+          <button
+            key={option.value}
+            type="button"
+            role="option"
+            aria-selected={exportDefaultFileNamingMode === option.value}
+            className={`select-option ${exportDefaultFileNamingMode === option.value ? 'active' : ''}`}
+            onClick={async () => {
+              setExportDefaultFileNamingMode(option.value)
+              await configService.setExportDefaultFileNamingMode(option.value)
+              onDefaultsChanged?.({ fileNamingMode: option.value })
+              notify('已更新导出文件命名方式', true)
+              setShowExportFileNamingModeSelect(false)
+            }}
+          >
+            <span className="option-label">{option.label}</span>
+            <span className="option-desc">{option.desc}</span>
+          </button>
+        ))}
+      </div>,
+      document.body
+    )
+    : null
+
+  const excelColumnsDropdown = showExportExcelColumnsSelect && exportExcelColumnsPlacement
+    ? createPortal(
+      <div
+        ref={exportExcelColumnsMenuRef}
+        className="select-dropdown select-dropdown-floating"
+        role="listbox"
+        style={getSelectDropdownStyle(exportExcelColumnsPlacement)}
+        onClick={(event) => event.stopPropagation()}
+      >
+        {exportExcelColumnOptions.map((option) => (
+          <button
+            key={option.value}
+            type="button"
+            role="option"
+            aria-selected={exportExcelColumnsValue === option.value}
+            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>,
+      document.body
+    )
+    : null
+
  return (
    <div className={`export-defaults-settings-form ${layout === 'split' ? 'layout-split' : 'layout-stacked'}`}>
      <div className="form-group">
@@ -273,6 +422,8 @@ export function ExportDefaultsSettingsForm({
            <button
              type="button"
              className={`select-trigger ${showExportFileNamingModeSelect ? 'open' : ''}`}
+              aria-haspopup="listbox"
+              aria-expanded={showExportFileNamingModeSelect}
              onClick={() => {
                setShowExportFileNamingModeSelect(!showExportFileNamingModeSelect)
                setShowExportExcelColumnsSelect(false)
@@ -282,27 +433,7 @@ export function ExportDefaultsSettingsForm({
              <span className="select-value">{exportFileNamingModeLabel}</span>
              <ChevronDown size={16} />
            </button>
-            {showExportFileNamingModeSelect && (
-              <div className="select-dropdown">
-                {exportFileNamingModeOptions.map((option) => (
-                  <button
-                    key={option.value}
-                    type="button"
-                    className={`select-option ${exportDefaultFileNamingMode === option.value ? 'active' : ''}`}
-                    onClick={async () => {
-                      setExportDefaultFileNamingMode(option.value)
-                      await configService.setExportDefaultFileNamingMode(option.value)
-                      onDefaultsChanged?.({ fileNamingMode: option.value })
-                      notify('已更新导出文件命名方式', true)
-                      setShowExportFileNamingModeSelect(false)
-                    }}
-                  >
-                    <span className="option-label">{option.label}</span>
-                    <span className="option-desc">{option.desc}</span>
-                  </button>
-                ))}
-              </div>
-            )}
+            {fileNamingModeDropdown}
          </div>
        </div>
      </div>
@@ -317,6 +448,8 @@ export function ExportDefaultsSettingsForm({
            <button
              type="button"
              className={`select-trigger ${showExportExcelColumnsSelect ? 'open' : ''}`}
+              aria-haspopup="listbox"
+              aria-expanded={showExportExcelColumnsSelect}
              onClick={() => {
                setShowExportExcelColumnsSelect(!showExportExcelColumnsSelect)
                setShowExportFileNamingModeSelect(false)
@@ -326,28 +459,7 @@ export function ExportDefaultsSettingsForm({
              <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>
-            )}
+            {excelColumnsDropdown}
          </div>
        </div>
      </div>
@@ -371,7 +483,8 @@ export function ExportDefaultsSettingsForm({
                  notify(`已${e.target.checked ? '开启' : '关闭'}默认导出图片`, true)
                }}
              />
-              图片
+              <span className="media-default-check" aria-hidden="true" />
+              <span>图片</span>
            </label>
            <label>
              <input
@@ -385,7 +498,8 @@ export function ExportDefaultsSettingsForm({
                  notify(`已${e.target.checked ? '开启' : '关闭'}默认导出语音`, true)
                }}
              />
-              语音
+              <span className="media-default-check" aria-hidden="true" />
+              <span>语音</span>
            </label>
            <label>
              <input
@@ -399,7 +513,8 @@ export function ExportDefaultsSettingsForm({
                  notify(`已${e.target.checked ? '开启' : '关闭'}默认导出视频`, true)
                }}
              />
-              视频
+              <span className="media-default-check" aria-hidden="true" />
+              <span>视频</span>
            </label>
            <label>
              <input
@@ -413,7 +528,8 @@ export function ExportDefaultsSettingsForm({
                  notify(`已${e.target.checked ? '开启' : '关闭'}默认导出表情包`, true)
                }}
              />
-              表情包
+              <span className="media-default-check" aria-hidden="true" />
+              <span>表情包</span>
            </label>
            <label>
              <input
@@ -427,7 +543,8 @@ export function ExportDefaultsSettingsForm({
                  notify(`已${e.target.checked ? '开启' : '关闭'}默认导出文件`, true)
                }}
              />
-              文件
+              <span className="media-default-check" aria-hidden="true" />
+              <span>文件</span>
            </label>
          </div>
        </div>
--- a/src/components/GlobalSessionMonitor.tsx
+++ b/src/components/GlobalSessionMonitor.tsx
@@ -22,7 +22,7 @@ export function GlobalSessionMonitor() {
    // 去重辅助函数：获取消息 key
    const getMessageKey = (msg: Message) => {
        if (msg.messageKey) return msg.messageKey
-        return `fallback:${msg.serverId || 0}:${msg.createTime}:${msg.sortSeq || 0}:${msg.localId || 0}:${msg.senderUsername || ''}:${msg.localType || 0}`
+        return `fallback:${msg._db_path || ''}:${msg.serverId || 0}:${msg.createTime}:${msg.sortSeq || 0}:${msg.localId || 0}:${msg.senderUsername || ''}:${msg.localType || 0}`
    }

    // 处理数据库变更
--- a/src/components/JumpToDatePopover.tsx
+++ b/src/components/JumpToDatePopover.tsx
@@ -15,6 +15,7 @@ interface JumpToDatePopoverProps {
  messageDateCounts?: Record<string, number>
  loadingDates?: boolean
  loadingDateCounts?: boolean
+  maxDate?: Date
 }

 const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({
@@ -29,7 +30,8 @@ const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({
  hasLoadedMessageDates = false,
  messageDateCounts,
  loadingDates = false,
-  loadingDateCounts = false
+  loadingDateCounts = false,
+  maxDate
 }) => {
  type CalendarViewMode = 'day' | 'month' | 'year'
  const getYearPageStart = (year: number): number => Math.floor(year / 12) * 12
@@ -73,6 +75,14 @@ const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({
    return messageDates.has(toDateKey(day))
  }

+  const isAfterMaxDate = (day: number): boolean => {
+    if (!maxDate) return false
+    const max = new Date(maxDate)
+    max.setHours(23, 59, 59, 999)
+    const candidate = new Date(calendarDate.getFullYear(), calendarDate.getMonth(), day, 0, 0, 0, 0)
+    return candidate.getTime() > max.getTime()
+  }
+
  const isToday = (day: number): boolean => {
    const today = new Date()
    return day === today.getDate()
@@ -102,6 +112,7 @@ const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({

  const handleDateClick = (day: number) => {
    if (hasLoadedMessageDates && !hasMessage(day)) return
+    if (isAfterMaxDate(day)) return
    const targetDate = new Date(calendarDate.getFullYear(), calendarDate.getMonth(), day)
    setSelectedDate(targetDate)
    onSelect(targetDate)
@@ -113,7 +124,7 @@ const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({
    const classes = ['day-cell']
    if (isToday(day)) classes.push('today')
    if (isSelected(day)) classes.push('selected')
-    if (hasLoadedMessageDates && !hasMessage(day)) classes.push('no-message')
+    if ((hasLoadedMessageDates && !hasMessage(day)) || isAfterMaxDate(day)) classes.push('no-message')
    return classes.join(' ')
  }

@@ -225,6 +236,7 @@ const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({
              if (day === null) return <div key={index} className="day-cell empty" />
              const dateKey = toDateKey(day)
              const hasMessageOnDay = hasMessage(day)
+              const isDisabled = (hasLoadedMessageDates && !hasMessageOnDay) || isAfterMaxDate(day)
              const count = Number(messageDateCounts?.[dateKey] || 0)
              const showCount = count > 0
              const showCountLoading = hasMessageOnDay && loadingDateCounts && !showCount
@@ -233,7 +245,7 @@ const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({
                  key={index}
                  className={getDayClassName(day)}
                  onClick={() => handleDateClick(day)}
-                  disabled={hasLoadedMessageDates && !hasMessageOnDay}
+                  disabled={isDisabled}
                  type="button"
                >
                  <span className="day-number">{day}</span>
--- a/src/components/MessageBubble.tsx
+++ b/src/components/MessageBubble.tsx
@@ -1,36 +0,0 @@
-import React from 'react'
-import { Bot, User } from 'lucide-react'
-
-interface ChatMessage {
-    id: string;
-    role: 'user' | 'ai';
-    content: string;
-    timestamp: number;
-}
-
-interface MessageBubbleProps {
-    message: ChatMessage;
-}
-
-/**
- * 优化后的消息气泡组件
- * 使用 React.memo 避免不必要的重新渲染
- */
-export const MessageBubble = React.memo<MessageBubbleProps>(({ message }) => {
-    return (
-        <div className={`message-row ${message.role}`}>
-            <div className="avatar">
-                {message.role === 'ai' ? <Bot size={24} /> : <User size={24} />}
-            </div>
-            <div className="bubble">
-                <div className="content">{message.content}</div>
-            </div>
-        </div>
-    )
-}, (prevProps, nextProps) => {
-    // 自定义比较函数：只有内容或ID变化时才重新渲染
-    return prevProps.message.content === nextProps.message.content &&
-        prevProps.message.id === nextProps.message.id
-})
-
-MessageBubble.displayName = 'MessageBubble'
--- a/src/components/NotificationToast.tsx
+++ b/src/components/NotificationToast.tsx
@@ -7,6 +7,9 @@ import './NotificationToast.scss'
 export interface NotificationData {
    id: string
    sessionId: string
+    channel?: string
+    insightRecordId?: string
+    targetRoute?: string
    avatarUrl?: string
    title: string
    content: string
@@ -16,7 +19,7 @@ export interface NotificationData {
 interface NotificationToastProps {
    data: NotificationData | null
    onClose: () => void
-    onClick: (sessionId: string) => void
+    onClick: (data: NotificationData) => void
    duration?: number
    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center'
    isStatic?: boolean
@@ -64,7 +67,7 @@ export function NotificationToast({
        setIsVisible(false)
        setTimeout(() => {
            onClose()
-            onClick(currentData.sessionId)
+            onClick(currentData)
        }, 300)
    }

--- a/src/components/RouteGuard.tsx
+++ b/src/components/RouteGuard.tsx
@@ -6,7 +6,7 @@ interface RouteGuardProps {
  children: React.ReactNode
 }

-const PUBLIC_ROUTES = ['/', '/home', '/settings']
+const PUBLIC_ROUTES = ['/', '/home', '/settings', '/account-management']

 function RouteGuard({ children }: RouteGuardProps) {
  const navigate = useNavigate()
--- a/src/components/Sidebar.scss
+++ b/src/components/Sidebar.scss
@@ -1,14 +1,17 @@
+// Redesigned sidebar — premium feel with left accent bar, refined spacing
 .sidebar {
-  width: 220px;
-  background: var(--bg-secondary);
-  border-right: 1px solid var(--border-color);
+  width: var(--sidebar-width, 260px);
+  background: var(--bg-sidebar, var(--bg-secondary));
  display: flex;
  flex-direction: column;
-  padding: 16px 0;
-  transition: width 0.25s ease;
+  padding: 0;
+  transition: width 0.2s cubic-bezier(0.4, 0, 0.2, 1);
+  flex-shrink: 0;
+  overflow: hidden;
+  border-right: 1px solid var(--border-color);

  &.collapsed {
-    width: 64px;
+    width: 68px;

    .sidebar-user-card-wrap {
      margin: 0 8px 8px;
@@ -21,28 +24,166 @@
      .user-meta {
        display: none;
      }
+
+      .user-menu-caret {
+        display: none;
+      }
    }

-    .nav-menu,
-    .sidebar-footer {
+    .nav-menu {
      padding: 0 8px;
    }

+    .sidebar-footer {
+      padding: 0 8px;
+      padding-top: 8px;
+    }
+
    .nav-label {
      display: none;
    }

+    .nav-badge:not(.icon-badge) {
+      display: none;
+    }
+
    .nav-item {
      justify-content: center;
      padding: 10px;
      gap: 0;
+
+      &::before {
+        display: none;
+      }
    }
  }
 }

+// ---- Navigation ----
+.nav-menu {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  padding: 12px 10px;
+  overflow-y: auto;
+  overflow-x: hidden;
+}
+
+.nav-item {
+  position: relative;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 9px 14px;
+  border-radius: 10px;
+  color: var(--text-secondary);
+  text-decoration: none;
+  transition: background 0.15s ease, color 0.15s ease;
+  white-space: nowrap;
+  border: none;
+  background: transparent;
+  cursor: pointer;
+  font-family: inherit;
+  font-size: 14px;
+  margin: 1px 0;
+
+  // Left accent bar for active state
+  &::before {
+    content: '';
+    position: absolute;
+    left: 0;
+    top: 50%;
+    transform: translateY(-50%) scaleY(0);
+    width: 3px;
+    height: 16px;
+    border-radius: 0 2px 2px 0;
+    background: var(--primary);
+    transition: transform 0.2s cubic-bezier(0.4, 0, 0.2, 1);
+  }
+
+  &:hover {
+    background: var(--bg-hover);
+    color: var(--text-primary);
+  }
+
+  &.active {
+    background: var(--bg-hover);
+    color: var(--text-primary);
+    font-weight: 600;
+
+    &::before {
+      transform: translateY(-50%) scaleY(1);
+    }
+
+    .nav-icon {
+      color: var(--primary);
+    }
+  }
+}
+
+.nav-icon {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 20px;
+  flex-shrink: 0;
+  transition: color 0.15s ease;
+}
+
+.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: #ef4444;
+  color: #ffffff;
+  font-size: 11px;
+  font-weight: 700;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  line-height: 1;
+}
+
+.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-sidebar, var(--bg-secondary));
+}
+
+// ---- Footer ----
+.sidebar-footer {
+  padding: 4px 10px;
+  border-top: 1px solid var(--border-color);
+  padding-top: 8px;
+  margin-top: 4px;
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+}
+
+// ---- User card ----
 .sidebar-user-card-wrap {
  position: relative;
-  margin: 0 12px 10px;
+  margin: 0 10px 10px;
  --sidebar-user-menu-width: 172px;
 }

@@ -55,16 +196,16 @@
  z-index: 12;
  border: 1px solid var(--border-color);
  border-radius: 12px;
-  background: var(--bg-secondary-solid, var(--bg-primary));
+  background: var(--bg-secondary-solid, var(--bg-secondary));
  display: flex;
  flex-direction: column;
-  gap: 4px;
-  padding: 6px;
-  box-shadow: 0 8px 20px rgba(15, 23, 42, 0.12);
+  gap: 2px;
+  padding: 4px;
+  box-shadow: var(--shadow-md);
  opacity: 0;
-  transform: translateY(8px) scale(0.95);
+  transform: translateY(6px) scale(0.97);
  pointer-events: none;
-  transition: opacity 0.2s ease, transform 0.2s ease;
+  transition: opacity 0.15s ease, transform 0.15s ease;

  &.open {
    opacity: 1;
@@ -76,10 +217,10 @@
 .sidebar-user-menu-item {
  width: 100%;
  border: none;
-  border-radius: 10px;
+  border-radius: 8px;
  background: transparent;
  color: var(--text-primary);
-  padding: 9px 10px;
+  padding: 8px 10px;
  display: flex;
  align-items: center;
  gap: 8px;
@@ -87,54 +228,53 @@
  font-weight: 500;
  cursor: pointer;
  text-align: left;
-  transition: background 0.2s ease, color 0.2s ease;
+  transition: background 0.15s ease;

  &:hover {
-    background: var(--bg-tertiary);
+    background: var(--bg-hover);
  }

  &.danger {
-    color: #d93025;
+    color: #ef4444;

    &:hover {
-      background: rgba(255, 59, 48, 0.08);
+      background: rgba(239, 68, 68, 0.08);
    }
  }
 }

 .sidebar-user-card {
  width: 100%;
-  padding: 10px;
-  border: 1px solid var(--border-color);
-  border-radius: 12px;
-  background: var(--bg-secondary);
+  padding: 10px 12px;
+  border-radius: 10px;
+  background: transparent;
  display: flex;
  align-items: center;
  gap: 10px;
-  min-height: 56px;
+  min-height: 52px;
  cursor: pointer;
-  transition: border-color 0.2s ease, background 0.2s ease, box-shadow 0.2s ease;
+  border: none;
+  transition: background 0.15s ease;

  &:hover {
-    border-color: rgba(99, 102, 241, 0.32);
-    background: var(--bg-tertiary);
+    background: var(--bg-hover);
  }

  &.menu-open {
-    border-color: rgba(99, 102, 241, 0.44);
-    box-shadow: 0 0 0 2px rgba(99, 102, 241, 0.12);
+    background: var(--bg-hover);
  }

  .user-avatar {
-    width: 36px;
-    height: 36px;
-    border-radius: 10px;
+    width: 34px;
+    height: 34px;
+    border-radius: 50%;
    overflow: hidden;
-    background: linear-gradient(135deg, var(--primary), var(--primary-hover));
+    background: var(--primary);
    display: flex;
    align-items: center;
    justify-content: center;
    flex-shrink: 0;
+    box-shadow: 0 0 0 2px var(--bg-sidebar, var(--bg-secondary));

    img {
      width: 100%;
@@ -144,7 +284,7 @@

    span {
      color: var(--on-primary);
-      font-size: 14px;
+      font-size: 13px;
      font-weight: 600;
    }
  }
@@ -164,7 +304,7 @@
  }

  .user-wxid {
-    margin-top: 2px;
+    margin-top: 1px;
    font-size: 11px;
    color: var(--text-tertiary);
    white-space: nowrap;
@@ -175,129 +315,10 @@
  .user-menu-caret {
    color: var(--text-tertiary);
    display: inline-flex;
-    transition: transform 0.2s ease, color 0.2s ease;
+    transition: transform 0.15s ease;

    &.open {
      transform: rotate(180deg);
-      color: var(--text-secondary);
    }
  }
 }
-
-.nav-menu {
-  flex: 1;
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-  padding: 0 12px;
-}
-
-.nav-item {
-  display: flex;
-  align-items: center;
-  gap: 12px;
-  padding: 10px 12px;
-  border-radius: 9999px;
-  color: var(--text-secondary);
-  text-decoration: none;
-  transition: all 0.2s ease;
-  white-space: nowrap;
-  border: none;
-  background: transparent;
-  cursor: pointer;
-  font-family: inherit;
-
-  &:hover {
-    background: var(--bg-tertiary);
-    color: var(--text-primary);
-  }
-
-  &.active {
-    background: var(--primary);
-    color: var(--on-primary);
-  }
-}
-
-.nav-icon {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 20px;
-  height: 20px;
-  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);
-  padding-top: 12px;
-  margin-top: 8px;
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-}
-
-// 繁花如梦主题：侧边栏毛玻璃 + 激活项用主品牌色
-[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);
-}
--- a/src/components/Sidebar.tsx
+++ b/src/components/Sidebar.tsx
@@ -1,6 +1,6 @@
 import { useState, useEffect, useRef } from 'react'
 import { NavLink, useLocation, useNavigate } from 'react-router-dom'
-import { Home, MessageSquare, BarChart3, FileText, Settings, Download, Aperture, UserCircle, Lock, LockOpen, ChevronUp, FolderClosed, Footprints, Users } from 'lucide-react'
+import { Home, MessageSquare, BarChart3, FileText, Settings, Download, Aperture, UserCircle, Lock, LockOpen, ChevronUp, FolderClosed, Footprints, Users, ArchiveRestore, Sparkles } from 'lucide-react'
 import { useAppStore } from '../stores/appStore'
 import * as configService from '../services/config'
 import { onExportSessionStatus, requestExportSessionStatus } from '../services/exportBridge'
@@ -344,6 +344,15 @@ function Sidebar({ collapsed }: SidebarProps) {
            <span className="nav-label">朋友圈</span>
          </NavLink>

+          <NavLink
+            to="/insight-inbox"
+            className={`nav-item ${isActive('/insight-inbox') ? 'active' : ''}`}
+            title={collapsed ? '灵感信箱' : undefined}
+          >
+            <span className="nav-icon"><Sparkles size={20} /></span>
+            <span className="nav-label">灵感信箱</span>
+          </NavLink>
+
          {/* 通讯录 */}
          <NavLink
            to="/contacts"
@@ -412,6 +421,15 @@ function Sidebar({ collapsed }: SidebarProps) {
            )}
          </NavLink>

+          <NavLink
+            to="/backup"
+            className={`nav-item ${isActive('/backup') ? 'active' : ''}`}
+            title={collapsed ? '数据库备份' : undefined}
+          >
+            <span className="nav-icon"><ArchiveRestore size={20} /></span>
+            <span className="nav-label">数据库备份</span>
+          </NavLink>
+

        </nav>

--- a/src/components/Sns/ContactSnsTimelineDialog.scss
+++ b/src/components/Sns/ContactSnsTimelineDialog.scss
@@ -6,16 +6,16 @@
  align-items: center;
  justify-content: center;
  padding: 24px 16px;
-  background: rgba(15, 23, 42, 0.38);
+  background: rgba(15, 23, 42, 0.28);
 }

 .contact-sns-dialog {
-  width: min(760px, 100%);
-  max-height: min(86vh, 860px);
-  border-radius: 14px;
+  width: min(720px, 100%);
+  max-height: min(84vh, 820px);
+  border-radius: 10px;
  border: 1px solid var(--border-color);
  background: var(--bg-secondary-solid, #ffffff);
-  box-shadow: 0 22px 46px rgba(0, 0, 0, 0.24);
+  box-shadow: 0 18px 34px rgba(0, 0, 0, 0.18);
  display: flex;
  flex-direction: column;
  overflow: hidden;
@@ -29,7 +29,7 @@
    align-items: center;
    justify-content: space-between;
    gap: 10px;
-    padding: 14px 16px;
+    padding: 12px 14px;
    border-bottom: 1px solid var(--border-color);
  }

@@ -41,9 +41,9 @@
  }

  .contact-sns-dialog-avatar {
-    width: 42px;
-    height: 42px;
-    border-radius: 10px;
+    width: 36px;
+    height: 36px;
+    border-radius: 8px;
    background: linear-gradient(135deg, var(--primary), var(--primary-hover));
    overflow: hidden;
    flex-shrink: 0;
@@ -69,7 +69,7 @@

    h4 {
      margin: 0;
-      font-size: 15px;
+      font-size: 14px;
      color: var(--text-primary);
      overflow: hidden;
      text-overflow: ellipsis;
@@ -79,7 +79,7 @@

  .contact-sns-dialog-username {
    margin-top: 2px;
-    font-size: 12px;
+    font-size: 11px;
    color: var(--text-tertiary);
    overflow: hidden;
    text-overflow: ellipsis;
@@ -88,7 +88,7 @@

  .contact-sns-dialog-stats {
    margin-top: 4px;
-    font-size: 12px;
+    font-size: 11px;
    color: var(--text-secondary);
  }

@@ -111,9 +111,9 @@
    border-radius: 8px;
    background: var(--bg-primary);
    color: var(--text-secondary);
-    height: 28px;
-    padding: 0 10px;
-    font-size: 12px;
+    height: 30px;
+    padding: 0 9px;
+    font-size: 11px;
    line-height: 1;
    cursor: pointer;
    white-space: nowrap;
@@ -134,8 +134,8 @@
    position: absolute;
    top: calc(100% + 8px);
    right: 0;
-    width: 248px;
-    max-height: calc((28px * 15) + 16px);
+    width: 228px;
+    max-height: calc((26px * 15) + 16px);
    overflow-y: auto;
    border: 1px solid color-mix(in srgb, var(--primary) 30%, var(--border-color));
    border-radius: 10px;
@@ -220,26 +220,20 @@
  }

  .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;
+    display: none;
  }

  .contact-sns-dialog-body {
    flex: 1;
    min-height: 0;
    overflow-y: auto;
-    padding: 12px 16px 14px;
+    padding: 10px 12px 12px;
  }

  .contact-sns-dialog-posts-list {
    display: flex;
    flex-direction: column;
-    gap: 14px;
+    gap: 10px;
  }

  .contact-sns-dialog-posts-list .post-header-actions {
@@ -247,9 +241,9 @@
  }

  .contact-sns-dialog-status {
-    padding: 20px 12px;
+    padding: 16px 10px;
    text-align: center;
-    font-size: 13px;
+    font-size: 12px;
    color: var(--text-secondary);

    &.empty {
@@ -264,8 +258,8 @@
    background: var(--bg-primary);
    color: var(--text-primary);
    border-radius: 10px;
-    padding: 9px 18px;
-    font-size: 13px;
+    padding: 8px 14px;
+    font-size: 12px;
    cursor: pointer;

    &:hover:not(:disabled) {
@@ -282,15 +276,15 @@

@media (max-width: 768px) {
  .contact-sns-dialog-overlay {
-    padding: 12px 8px;
+    padding: 10px 8px;
  }

  .contact-sns-dialog {
-    width: min(100vw - 16px, 760px);
+    width: min(100vw - 16px, 720px);
    max-height: calc(100vh - 24px);

    .contact-sns-dialog-header {
-      padding: 12px;
+      padding: 10px 12px;
    }

    .contact-sns-dialog-header-actions {
@@ -300,18 +294,13 @@
    .contact-sns-dialog-rank-btn {
      height: 26px;
      padding: 0 8px;
-      font-size: 11px;
+      font-size: 10px;
    }

    .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;
    }
--- a/src/components/Sns/ContactSnsTimelineDialog.tsx
+++ b/src/components/Sns/ContactSnsTimelineDialog.tsx
@@ -538,10 +538,6 @@ export function ContactSnsTimelineDialog({
          </div>
        </div>

-        <div className="contact-sns-dialog-tip">
-          在微信桌面客户端中打开这个人的朋友圈浏览，可快速把其朋友圈同步到这里。若你在乎这个人，一定要试试～
-        </div>
-
        <div
          className="contact-sns-dialog-body"
          onScroll={handleBodyScroll}
--- a/src/components/Sns/SnsFilterPanel.tsx
+++ b/src/components/Sns/SnsFilterPanel.tsx
@@ -1,5 +1,6 @@
 import React from 'react'
 import { Search, User, X, Loader2, CheckSquare, Square, Download } from 'lucide-react'
+import { Virtuoso } from 'react-virtuoso'
 import { Avatar } from '../Avatar'

 interface Contact {
@@ -51,10 +52,14 @@ export const SnsFilterPanel: React.FC<SnsFilterPanelProps> = ({
    onClearSelectedContacts,
    onExportSelectedContacts
 }) => {
-    const filteredContacts = contacts.filter(c =>
-        (c.displayName || '').toLowerCase().includes(contactSearch.toLowerCase()) ||
-        c.username.toLowerCase().includes(contactSearch.toLowerCase())
-    )
+    const filteredContacts = React.useMemo(() => {
+        const keyword = contactSearch.trim().toLowerCase()
+        if (!keyword) return contacts
+        return contacts.filter(c =>
+            (c.displayName || '').toLowerCase().includes(keyword) ||
+            c.username.toLowerCase().includes(keyword)
+        )
+    }, [contacts, contactSearch])
    const selectedContactLookup = React.useMemo(
        () => new Set(selectedContactUsernames),
        [selectedContactUsernames]
@@ -85,10 +90,52 @@ export const SnsFilterPanel: React.FC<SnsFilterPanelProps> = ({
        return '没有找到联系人'
    }

+    const renderContactRow = React.useCallback((_: number, contact: Contact) => {
+        const isPostCountReady = contact.postCountStatus === 'ready'
+        const isSelected = selectedContactLookup.has(contact.username)
+        const isActive = activeContactUsername === contact.username
+
+        return (
+            <div
+                className={`contact-row${isSelected ? ' is-selected' : ''}${isActive ? ' is-active' : ''}`}
+            >
+                <button
+                    type="button"
+                    className={`contact-select-btn${isSelected ? ' checked' : ''}`}
+                    onClick={() => onToggleContactSelected(contact)}
+                    title={isSelected ? `取消选择 ${contact.displayName}` : `选择 ${contact.displayName}`}
+                    aria-pressed={isSelected}
+                >
+                    {isSelected ? <CheckSquare size={14} /> : <Square size={14} />}
+                </button>
+                <button
+                    type="button"
+                    className="contact-main-btn"
+                    onClick={() => onOpenContactTimeline(contact)}
+                    title={`查看 ${contact.displayName} 的朋友圈`}
+                >
+                    <Avatar src={contact.avatarUrl} name={contact.displayName} size={28} shape="rounded" />
+                    <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={12} className="spinning" />
+                            </span>
+                        )}
+                    </div>
+                </button>
+            </div>
+        )
+    }, [activeContactUsername, onOpenContactTimeline, onToggleContactSelected, selectedContactLookup])
+
    return (
        <aside className="sns-filter-panel">
            <div className="filter-header">
-                <h3>筛选条件</h3>
+                <h3>筛选</h3>
                {(searchKeyword || contactSearch) && (
                    <button className="reset-all-btn" onClick={clearFilters} title="重置所有筛选">
                        <RefreshCw size={14} />
@@ -101,12 +148,12 @@ export const SnsFilterPanel: React.FC<SnsFilterPanelProps> = ({
                <div className="filter-widget search-widget">
                    <div className="widget-header">
                        <Search size={14} />
-                        <span>关键词搜索</span>
+                        <span>关键词</span>
                    </div>
                    <div className="input-group">
                        <input
                            type="text"
-                            placeholder="搜索动态内容..."
+                            placeholder="搜索动态"
                            value={searchKeyword}
                            onChange={e => setSearchKeyword(e.target.value)}
                        />
@@ -130,7 +177,7 @@ export const SnsFilterPanel: React.FC<SnsFilterPanelProps> = ({
                    <div className="contact-search-bar">
                        <input
                            type="text"
-                            placeholder="查找好友..."
+                            placeholder="查找联系人"
                            value={contactSearch}
                            onChange={e => setContactSearch(e.target.value)}
                        />
@@ -162,53 +209,17 @@ export const SnsFilterPanel: React.FC<SnsFilterPanelProps> = ({
                        </div>
                    )}

-                    <div className="contact-interaction-hint">
-                        点左侧可多选下载，点右侧可查看单人详情
-                    </div>
-
                    <div className="contact-list-scroll">
-                        {filteredContacts.map(contact => {
-                            const isPostCountReady = contact.postCountStatus === 'ready'
-                            const isSelected = selectedContactLookup.has(contact.username)
-                            const isActive = activeContactUsername === contact.username
-                            return (
-                                <div
-                                    key={contact.username}
-                                    className={`contact-row${isSelected ? ' is-selected' : ''}${isActive ? ' is-active' : ''}`}
-                                >
-                                    <button
-                                        type="button"
-                                        className={`contact-select-btn${isSelected ? ' checked' : ''}`}
-                                        onClick={() => onToggleContactSelected(contact)}
-                                        title={isSelected ? `取消选择 ${contact.displayName}` : `选择 ${contact.displayName}`}
-                                        aria-pressed={isSelected}
-                                    >
-                                        {isSelected ? <CheckSquare size={16} /> : <Square size={16} />}
-                                    </button>
-                                    <button
-                                        type="button"
-                                        className="contact-main-btn"
-                                        onClick={() => onOpenContactTimeline(contact)}
-                                        title={`查看 ${contact.displayName} 的朋友圈`}
-                                    >
-                                        <Avatar src={contact.avatarUrl} name={contact.displayName} size={36} shape="rounded" />
-                                        <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>
-                                    </button>
-                                </div>
-                            )
-                        })}
-                        {filteredContacts.length === 0 && (
+                        {filteredContacts.length > 0 ? (
+                            <Virtuoso
+                                className="contact-list-virtuoso"
+                                data={filteredContacts}
+                                computeItemKey={(_, contact) => contact.username}
+                                fixedItemHeight={40}
+                                itemContent={renderContactRow}
+                                overscan={320}
+                            />
+                        ) : (
                            <div className="empty-state">{getEmptyStateText()}</div>
                        )}
                    </div>
--- a/src/components/Sns/SnsPostItem.tsx
+++ b/src/components/Sns/SnsPostItem.tsx
@@ -493,7 +493,7 @@ export const SnsPostItem: React.FC<SnsPostItemProps> = ({ post, onPreview, onDeb
                        <Avatar
                            src={post.avatarUrl}
                            name={post.nickname}
-                            size={48}
+                            size={36}
                            shape="rounded"
                        />
                    </button>
--- a/src/components/TitleBar.scss
+++ b/src/components/TitleBar.scss
@@ -1,12 +1,11 @@
 .title-bar {
-  height: 41px;
-  background: var(--bg-secondary);
+  height: 48px;
+  background: transparent;
  display: flex;
  align-items: center;
  justify-content: space-between;
  padding-left: 16px;
-  padding-right: 16px;
-  border-bottom: 1px solid var(--border-color);
+  padding-right: 8px;
  -webkit-app-region: drag;
  flex-shrink: 0;
  gap: 8px;
@@ -14,12 +13,6 @@
  z-index: 2101;
 }

-// 繁花如梦：标题栏毛玻璃
-[data-theme="blossom-dream"] .title-bar {
-  backdrop-filter: blur(20px);
-  -webkit-backdrop-filter: blur(20px);
-}
-
 .title-brand {
  display: inline-flex;
  align-items: center;
@@ -33,16 +26,15 @@
 }

 .titles {
-  font-size: 15px;
-  font-weight: 500;
+  font-size: 14px;
+  font-weight: 600;
  color: var(--text-secondary);
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
+  letter-spacing: -0.01em;
 }

 .title-sidebar-toggle {
-  width: 28px;
-  height: 28px;
+  width: 32px;
+  height: 32px;
  padding: 0;
  border: none;
  border-radius: 8px;
@@ -52,11 +44,11 @@
  align-items: center;
  justify-content: center;
  cursor: pointer;
-  transition: background 0.2s ease, color 0.2s ease;
+  transition: background 0.15s ease, color 0.15s ease;
  -webkit-app-region: no-drag;

  &:hover {
-    background: var(--bg-tertiary);
+    background: var(--bg-hover);
    color: var(--text-primary);
  }
 }
@@ -64,26 +56,26 @@
 .title-window-controls {
  display: inline-flex;
  align-items: center;
-  gap: 6px;
+  gap: 2px;
  -webkit-app-region: no-drag;
 }

 .title-window-control-btn {
-  width: 28px;
+  width: 36px;
  height: 28px;
  padding: 0;
  border: none;
-  border-radius: 8px;
+  border-radius: 6px;
  background: transparent;
  color: var(--text-tertiary);
  display: inline-flex;
  align-items: center;
  justify-content: center;
  cursor: pointer;
-  transition: background 0.2s ease, color 0.2s ease;
+  transition: background 0.15s ease, color 0.15s ease;

  &:hover {
-    background: var(--bg-tertiary);
+    background: var(--bg-hover);
    color: var(--text-primary);
  }

@@ -107,14 +99,14 @@
    color: var(--text-secondary);
    cursor: pointer;
    padding: 6px;
-    border-radius: 4px;
+    border-radius: 6px;
    display: flex;
    align-items: center;
    justify-content: center;
-    transition: all 0.2s;
+    transition: all 0.15s;

    &:hover {
-      background: var(--bg-tertiary);
+      background: var(--bg-hover);
      color: var(--text-primary);
    }

@@ -124,8 +116,8 @@
    }

    &.live-play-btn.active {
-      background: rgba(var(--primary-rgb, 76, 132, 255), 0.16);
-      color: var(--primary, #4c84ff);
+      background: var(--primary-light);
+      color: var(--primary);
    }
  }

--- a/src/pages/AccountManagementPage.tsx
+++ b/src/pages/AccountManagementPage.tsx
@@ -46,7 +46,43 @@ type NoticeState =

 const SIDEBAR_USER_PROFILE_CACHE_KEY = 'sidebar_user_profile_cache_v1'
 const ACCOUNT_PROFILES_CACHE_KEY = 'account_profiles_cache_v1'
-const hiddenDeletedAccountIds = new Set<string>()
+
+const HIDDEN_DELETED_ACCOUNT_NORM_IDS_KEY = 'weflow_account_mgmt_hidden_deleted_norm_v1'
+
+const readHiddenDeletedAccountNormIds = (): Set<string> => {
+  try {
+    const raw = window.localStorage.getItem(HIDDEN_DELETED_ACCOUNT_NORM_IDS_KEY)
+    if (!raw) return new Set()
+    const parsed = JSON.parse(raw) as unknown
+    if (!Array.isArray(parsed)) return new Set()
+    return new Set(parsed.filter((x): x is string => typeof x === 'string' && x.length > 0))
+  } catch {
+    return new Set()
+  }
+}
+
+const writeHiddenDeletedAccountNormIds = (ids: Set<string>): void => {
+  try {
+    window.localStorage.setItem(HIDDEN_DELETED_ACCOUNT_NORM_IDS_KEY, JSON.stringify(Array.from(ids)))
+  } catch {
+    
+  }
+}
+
+const addHiddenDeletedAccountNormId = (normalized: string): void => {
+  if (!normalized) return
+  const next = readHiddenDeletedAccountNormIds()
+  next.add(normalized)
+  writeHiddenDeletedAccountNormIds(next)
+}
+
+const removeHiddenDeletedAccountNormId = (normalized: string): void => {
+  if (!normalized) return
+  const next = readHiddenDeletedAccountNormIds()
+  if (!next.delete(normalized)) return
+  writeHiddenDeletedAccountNormIds(next)
+}
+
 const DEFAULT_ACCOUNT_DISPLAY_NAME = '微信用户'

 const normalizeAccountId = (value?: string | null): string => {
@@ -194,12 +230,14 @@ function AccountManagementPage() {
        })
      }

-      // 被“删除配置”操作移除的账号，在当前会话中从列表隐藏；
-      // 若后续再次生成配置，则自动恢复展示。
+      // 被「删除配置」移除的账号：微信目录仍在扫描结果里会出现无配置条目，持久化隐藏避免误导；
+      // 若后续再次保存该账号配置，则自动恢复展示。
+      const hiddenDeletedNormIds = readHiddenDeletedAccountNormIds()
      for (const [normalized, item] of Array.from(merged.entries())) {
-        if (!hiddenDeletedAccountIds.has(normalized)) continue
+        if (!hiddenDeletedNormIds.has(normalized)) continue
        if (item.hasConfig) {
-          hiddenDeletedAccountIds.delete(normalized)
+          hiddenDeletedNormIds.delete(normalized)
+          writeHiddenDeletedAccountNormIds(hiddenDeletedNormIds)
          continue
        }
        merged.delete(normalized)
@@ -362,7 +400,7 @@ function AccountManagementPage() {
          const [nextWxid, nextConfig] = remainingEntries[0]
          await applyWxidConfig(nextWxid, nextConfig || null)
          window.dispatchEvent(new CustomEvent('wxid-changed', { detail: { wxid: nextWxid } }))
-          hiddenDeletedAccountIds.add(normalizedTarget)
+          addHiddenDeletedAccountNormId(normalizedTarget)
          setDeleteUndoState(undoPayload)
          setNotice({ type: 'success', text: `已删除「${targetWxid}」配置，并切换到「${nextWxid}」` })
          await loadAccounts()
@@ -375,14 +413,14 @@ function AccountManagementPage() {
        await configService.setImageAesKey('')
        setDbConnected(false)
        window.dispatchEvent(new CustomEvent('wxid-changed', { detail: { wxid: '' } }))
-        hiddenDeletedAccountIds.add(normalizedTarget)
+        addHiddenDeletedAccountNormId(normalizedTarget)
        setDeleteUndoState(undoPayload)
        setNotice({ type: 'info', text: `已删除「${targetWxid}」配置，当前无可用账号配置，可撤回或添加账号` })
        await loadAccounts()
        return
      }

-      hiddenDeletedAccountIds.add(normalizedTarget)
+      addHiddenDeletedAccountNormId(normalizedTarget)
      setDeleteUndoState(undoPayload)
      setNotice({ type: 'success', text: `已删除账号「${targetWxid}」配置` })
      await loadAccounts()
@@ -406,7 +444,7 @@ function AccountManagementPage() {
        restoredConfigs[key] = configValue || {}
      }
      await configService.setWxidConfigs(restoredConfigs)
-      hiddenDeletedAccountIds.delete(normalizeAccountId(deleteUndoState.targetWxid) || deleteUndoState.targetWxid)
+      removeHiddenDeletedAccountNormId(normalizeAccountId(deleteUndoState.targetWxid) || deleteUndoState.targetWxid)

      const accountProfileCache = readAccountProfilesCache()
      for (const [key, profile] of deleteUndoState.deletedProfileEntries) {
--- a/src/pages/AnalyticsPage.scss
+++ b/src/pages/AnalyticsPage.scss
@@ -10,7 +10,7 @@
  }
 }

-// 加载和错误状态
+// Loading and error states
 .loading-container,
 .error-container {
  display: flex;
@@ -23,7 +23,7 @@
  color: var(--text-secondary);

  .spin {
-    animation: spin 1s linear infinite;
+    animation: analyticsSpin 1s linear infinite;
  }

  p.loading-status {
@@ -33,13 +33,12 @@
  }

  .progress-bar-wrapper {
-    width: 300px;
-    height: 8px;
+    width: 280px;
+    height: 4px;
    background: var(--bg-tertiary);
    border-radius: 999px;
    overflow: hidden;
    position: relative;
-    border: 1px solid var(--border-color);
  }

  .progress-bar-fill {
@@ -47,9 +46,9 @@
    left: 0;
    top: 0;
    height: 100%;
-    background: var(--primary-gradient);
-    transition: width 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-    box-shadow: 0 0 10px rgba(139, 115, 85, 0.3);
+    background: var(--primary);
+    transition: width 0.3s ease;
+    border-radius: 999px;
  }

  .progress-percent {
@@ -65,57 +64,82 @@
  }
 }

-@keyframes spin {
-  from {
-    transform: rotate(0deg);
-  }
+@keyframes analyticsSpin {
+  from { transform: rotate(0deg); }
+  to { transform: rotate(360deg); }
+}

-  to {
-    transform: rotate(360deg);
+// Page scroll content
+.page-scroll {
+  display: flex;
+  flex-direction: column;
+  gap: 24px;
+}
+
+.page-section {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.section-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+
+  h2 {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--text-primary);
+    margin: 0;
  }
 }

-// 统计卡片
+// Stats overview cards
 .stats-overview {
  display: grid;
  grid-template-columns: repeat(4, 1fr);
-  gap: 16px;
-  margin-bottom: 24px;
+  gap: 12px;
 }

 .stat-card {
  display: flex;
  align-items: center;
-  gap: 16px;
-  padding: 20px;
+  gap: 14px;
+  padding: 18px 16px;
  background: var(--card-bg);
  border-radius: 12px;
  border: 1px solid var(--border-color);

  .stat-icon {
-    width: 48px;
-    height: 48px;
+    width: 40px;
+    height: 40px;
    display: flex;
    align-items: center;
    justify-content: center;
    background: var(--primary-light);
-    border-radius: 12px;
+    border-radius: 10px;
    color: var(--primary);
+    flex-shrink: 0;
  }

  .stat-info {
    display: flex;
    flex-direction: column;
-    gap: 4px;
+    gap: 2px;

    .stat-value {
-      font-size: 24px;
-      font-weight: 600;
+      font-size: 22px;
+      font-weight: 700;
      color: var(--text-primary);
+      letter-spacing: -0.5px;
    }

    .stat-label {
-      font-size: 13px;
+      font-size: 12px;
      color: var(--text-tertiary);
    }
  }
@@ -125,23 +149,23 @@
  display: flex;
  align-items: center;
  gap: 8px;
-  padding: 12px 16px;
+  padding: 10px 14px;
  background: var(--bg-tertiary);
  border-radius: 8px;
-  margin-bottom: 24px;
  font-size: 13px;
  color: var(--text-secondary);

  svg {
    color: var(--text-tertiary);
+    flex-shrink: 0;
  }
 }

+// Charts
 .charts-grid {
  display: grid;
  grid-template-columns: repeat(2, 1fr);
-  gap: 16px;
-  margin-bottom: 24px;
+  gap: 12px;
 }

 .chart-card {
@@ -155,30 +179,30 @@
  }

  h3 {
-    font-size: 15px;
-    font-weight: 500;
+    font-size: 14px;
+    font-weight: 600;
    color: var(--text-primary);
-    margin: 0 0 16px;
+    margin: 0 0 12px;
  }
 }

+// Rankings
 .rankings-list {
  display: flex;
  flex-direction: column;
-  gap: 8px;
+  gap: 4px;
 }

 .ranking-item {
  display: flex;
  align-items: center;
  gap: 12px;
-  padding: 12px 16px;
-  background: var(--bg-primary);
+  padding: 10px 14px;
  border-radius: 8px;
-  transition: background 0.2s;
+  transition: background 0.15s ease;

  &:hover {
-    background: var(--bg-tertiary);
+    background: var(--bg-hover);
  }

  .rank {
@@ -196,13 +220,13 @@

    &.top {
      background: var(--primary);
-      color: white;
+      color: var(--on-primary);
    }
  }

  .contact-avatar {
-    width: 40px;
-    height: 40px;
+    width: 36px;
+    height: 36px;
    flex-shrink: 0;
    position: relative;

@@ -228,8 +252,8 @@
      position: absolute;
      right: -4px;
      bottom: -4px;
-      width: 18px;
-      height: 18px;
+      width: 16px;
+      height: 16px;
      display: flex;
      align-items: center;
      justify-content: center;
@@ -239,24 +263,21 @@
      &.medal-1 {
        background: linear-gradient(135deg, #ffd700, #ffb800);
        color: #fff;
-        box-shadow: 0 2px 4px rgba(255, 184, 0, 0.4);
      }

      &.medal-2 {
        background: linear-gradient(135deg, #c0c0c0, #a8a8a8);
        color: #fff;
-        box-shadow: 0 2px 4px rgba(168, 168, 168, 0.4);
      }

      &.medal-3 {
        background: linear-gradient(135deg, #cd7f32, #b87333);
        color: #fff;
-        box-shadow: 0 2px 4px rgba(184, 115, 51, 0.4);
      }

      svg {
-        width: 10px;
-        height: 10px;
+        width: 8px;
+        height: 8px;
      }
    }
  }
@@ -265,7 +286,7 @@
    flex: 1;
    display: flex;
    flex-direction: column;
-    gap: 2px;
+    gap: 1px;
    min-width: 0;

    .contact-name {
@@ -284,14 +305,14 @@
  }

  .message-count {
-    font-size: 14px;
-    font-weight: 500;
+    font-size: 13px;
+    font-weight: 600;
    color: var(--primary);
    flex-shrink: 0;
  }
 }

-// 响应式
+// Responsive
@media (max-width: 1200px) {
  .stats-overview {
    grid-template-columns: repeat(2, 1fr);
@@ -312,11 +333,11 @@
  }
 }

-// 排除好友弹窗
+// Exclude friends modal
 .exclude-modal-overlay {
  position: fixed;
  inset: 0;
-  background: rgba(0, 0, 0, 0.45);
+  background: rgba(0, 0, 0, 0.5);
  display: flex;
  align-items: center;
  justify-content: center;
@@ -325,13 +346,13 @@
 }

 .exclude-modal {
-  width: 560px;
+  width: 520px;
  max-width: calc(100vw - 48px);
-  background: var(--card-bg);
+  background: var(--bg-secondary-solid, var(--bg-secondary));
  border-radius: 16px;
  border: 1px solid var(--border-color);
  padding: 20px;
-  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.2);
+  box-shadow: 0 24px 48px rgba(0, 0, 0, 0.2);

  .exclude-modal-header {
    display: flex;
@@ -342,6 +363,7 @@
    h3 {
      margin: 0;
      font-size: 16px;
+      font-weight: 600;
      color: var(--text-primary);
    }
  }
@@ -349,14 +371,14 @@
  .modal-close {
    width: 32px;
    height: 32px;
-    border-radius: 50%;
+    border-radius: 8px;
    border: none;
-    background: var(--bg-tertiary);
+    background: transparent;
    display: flex;
    align-items: center;
    justify-content: center;
    cursor: pointer;
-    color: var(--text-secondary);
+    color: var(--text-tertiary);
    transition: all 0.15s;

    &:hover {
@@ -370,7 +392,7 @@
    align-items: center;
    gap: 8px;
    padding: 8px 12px;
-    border-radius: 10px;
+    border-radius: 8px;
    border: 1px solid var(--border-color);
    background: var(--bg-primary);
    margin-bottom: 12px;
@@ -399,7 +421,7 @@
  }

  .exclude-modal-body {
-    max-height: 420px;
+    max-height: 380px;
    overflow: auto;
    padding-right: 4px;
  }
@@ -419,7 +441,7 @@
  .exclude-list {
    display: flex;
    flex-direction: column;
-    gap: 6px;
+    gap: 4px;
  }

  .exclude-item {
@@ -427,23 +449,23 @@
    align-items: center;
    gap: 12px;
    padding: 8px 10px;
-    border-radius: 10px;
+    border-radius: 8px;
    cursor: pointer;
    border: 1px solid transparent;
    transition: all 0.15s;
-    background: var(--bg-primary);

    &:hover {
-      background: var(--bg-tertiary);
+      background: var(--bg-hover);
    }

    &.active {
-      border-color: rgba(7, 193, 96, 0.4);
-      background: rgba(7, 193, 96, 0.08);
+      border-color: rgba(16, 163, 127, 0.3);
+      background: rgba(16, 163, 127, 0.06);
    }

    input {
      margin: 0;
+      accent-color: var(--primary);
    }
  }

@@ -455,7 +477,7 @@
    display: flex;
    flex-direction: column;
    min-width: 0;
-    gap: 2px;
+    gap: 1px;
  }

  .exclude-name {
@@ -479,7 +501,7 @@
    display: flex;
    align-items: center;
    justify-content: space-between;
-    margin-top: 16px;
+    margin-top: 14px;
  }

  .exclude-footer-left {
--- a/src/pages/AnalyticsWelcomePage.scss
+++ b/src/pages/AnalyticsWelcomePage.scss
@@ -1,146 +1,116 @@
-.analytics-entry-page {
+.analytics-welcome-shell {
    display: flex;
    flex-direction: column;
    gap: 16px;
    min-height: 100%;
 }

-.analytics-welcome-container {
+.analytics-welcome-body {
    display: flex;
    flex-direction: column;
    flex: 1;
    align-items: center;
    justify-content: center;
    min-height: 0;
-    padding: 40px;
-    background: var(--bg-primary);
+    padding: 40px 24px;
+    animation: welcomeFadeIn 0.4s ease-out;
+}
+
+.analytics-welcome-content {
+    text-align: center;
+    max-width: 480px;
+    width: 100%;
+}
+
+.analytics-welcome-icon {
+    width: 56px;
+    height: 56px;
+    margin: 0 auto 20px;
+    background: var(--primary-light);
+    border-radius: 14px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--primary);
+}
+
+.analytics-welcome-content h1 {
+    font-size: 24px;
+    font-weight: 700;
+    margin: 0 0 10px;
    color: var(--text-primary);
-    animation: fadeIn 0.4s ease-out;
-    overflow-y: auto;
+    letter-spacing: -0.3px;
+}

-    &.analytics-welcome-container--mode {
-        border-radius: 20px;
-        border: 1px solid var(--border-color);
-        background:
-            radial-gradient(circle at top, rgba(7, 193, 96, 0.06), transparent 48%),
-            var(--bg-primary);
+.analytics-welcome-content p {
+    color: var(--text-secondary);
+    margin: 0 0 32px;
+    font-size: 14px;
+    line-height: 1.7;
+}
+
+.analytics-welcome-actions {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 12px;
+}
+
+.analytics-welcome-card {
+    display: flex;
+    align-items: center;
+    gap: 14px;
+    padding: 16px 18px;
+    background: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-radius: 12px;
+    cursor: pointer;
+    text-align: left;
+    color: var(--text-secondary);
+    transition: background 0.15s ease, border-color 0.15s ease;
+
+    &:hover {
+        background: var(--bg-hover);
+        border-color: var(--text-tertiary);
+        color: var(--primary);
    }

-    .welcome-content {
-        text-align: center;
-        max-width: 600px;
-
-        .icon-wrapper {
-            width: 80px;
-            height: 80px;
-            margin: 0 auto 24px;
-            background: rgba(7, 193, 96, 0.1);
-            border-radius: 20px;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            color: #07c160;
-
-            svg {
-                width: 40px;
-                height: 40px;
-            }
-        }
-
-        h1 {
-            font-size: 28px;
-            margin-bottom: 12px;
-            font-weight: 600;
-        }
-
-        p {
-            color: var(--text-secondary);
-            margin-bottom: 40px;
-            font-size: 16px;
-            line-height: 1.6;
-        }
-
-        .action-cards {
-            display: grid;
-            grid-template-columns: 1fr 1fr;
-            gap: 20px;
-            margin-top: 20px;
-
-            button {
-                display: flex;
-                flex-direction: column;
-                align-items: center;
-                padding: 30px 20px;
-                background: var(--bg-secondary);
-                border: 1px solid var(--border-color);
-                border-radius: 12px;
-                cursor: pointer;
-                transition: all 0.2s ease;
-                text-align: center;
-
-                &:hover:not(:disabled) {
-                    transform: translateY(-2px);
-                    border-color: #07c160;
-                    box-shadow: 0 4px 12px rgba(7, 193, 96, 0.1);
-
-                    .card-icon {
-                        color: #07c160;
-                        background: rgba(7, 193, 96, 0.1);
-                    }
-                }
-
-                &:disabled {
-                    opacity: 0.6;
-                    cursor: not-allowed;
-                    filter: grayscale(100%);
-                }
-
-                .card-icon {
-                    width: 50px;
-                    height: 50px;
-                    border-radius: 12px;
-                    background: var(--bg-tertiary);
-                    display: flex;
-                    align-items: center;
-                    justify-content: center;
-                    margin-bottom: 16px;
-                    color: var(--text-secondary);
-                    transition: all 0.2s ease;
-                }
-
-                h3 {
-                    font-size: 18px;
-                    margin-bottom: 8px;
-                    color: var(--text-primary);
-                }
-
-                span {
-                    font-size: 13px;
-                    color: var(--text-tertiary);
-                }
-            }
-        }
+    svg {
+        flex-shrink: 0;
    }
 }

-@media (max-width: 768px) {
-    .analytics-welcome-container {
-        padding: 28px 18px;
+.analytics-welcome-card-text {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+    min-width: 0;
+}

-        .welcome-content {
-            .action-cards {
-                grid-template-columns: 1fr;
-            }
-        }
+.analytics-welcome-card-title {
+    font-size: 14px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.analytics-welcome-card-meta {
+    font-size: 12px;
+    color: var(--text-tertiary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+@media (max-width: 540px) {
+    .analytics-welcome-actions {
+        grid-template-columns: 1fr;
    }
 }

-@keyframes fadeIn {
+@keyframes welcomeFadeIn {
    from {
        opacity: 0;
        transform: translateY(10px);
    }
-
    to {
        opacity: 1;
        transform: translateY(0);
--- a/src/pages/AnalyticsWelcomePage.tsx
+++ b/src/pages/AnalyticsWelcomePage.tsx
@@ -6,12 +6,6 @@ import './AnalyticsWelcomePage.scss'

 function AnalyticsWelcomePage() {
    const navigate = useNavigate()
-    // 检查是否有任何缓存数据加载或基本的存储状态表明它已准备好。
-    // 实际上，如果 store 没有持久化，`isLoaded` 可能会在应用刷新时重置。
-    // 如果用户点击“加载缓存”但缓存为空，AnalyticsPage 的逻辑（loadData 不带 force）将尝试从后端缓存加载。
-    // 如果后端缓存也为空，则会重新计算。
-
-    // 我们也可以检查 `lastLoadTime` 来显示“上次更新：xxx”（如果已持久化）。
    const { lastLoadTime } = useAnalyticsStore()

    const handleLoadCache = () => {
@@ -28,35 +22,37 @@ function AnalyticsWelcomePage() {
    }

    return (
-        <div className="analytics-entry-page">
+        <div className="analytics-welcome-shell">
            <ChatAnalysisHeader currentMode="private" />

-            <div className="analytics-welcome-container analytics-welcome-container--mode">
-                <div className="welcome-content">
-                    <div className="icon-wrapper">
-                        <BarChart2 size={40} />
+            <div className="analytics-welcome-body">
+                <div className="analytics-welcome-content">
+                    <div className="analytics-welcome-icon">
+                        <BarChart2 size={32} />
                    </div>
                    <h1>私聊数据分析</h1>
                    <p>
-                        WeFlow 可以分析你的好友聊天记录，生成详细的统计报表。<br />
-                        你可以选择加载上次的分析结果，或者重新开始一次新的私聊分析。
+                        分析你的好友聊天记录，生成详细统计报表。<br />
+                        选择加载上次结果或开始新分析。
                    </p>

-                    <div className="action-cards">
-                        <button onClick={handleLoadCache}>
-                            <div className="card-icon">
-                                <History size={24} />
+                    <div className="analytics-welcome-actions">
+                        <button className="analytics-welcome-card" onClick={handleLoadCache} type="button">
+                            <History size={20} />
+                            <div className="analytics-welcome-card-text">
+                                <span className="analytics-welcome-card-title">加载缓存</span>
+                                <span className="analytics-welcome-card-meta">
+                                    上次更新: {formatLastTime(lastLoadTime)}
+                                </span>
                            </div>
-                            <h3>加载缓存</h3>
-                            <span>查看上次分析结果<br />(上次更新: {formatLastTime(lastLoadTime)})</span>
                        </button>

-                        <button onClick={handleNewAnalysis}>
-                            <div className="card-icon">
-                                <RefreshCcw size={24} />
+                        <button className="analytics-welcome-card" onClick={handleNewAnalysis} type="button">
+                            <RefreshCcw size={20} />
+                            <div className="analytics-welcome-card-text">
+                                <span className="analytics-welcome-card-title">新的分析</span>
+                                <span className="analytics-welcome-card-meta">重新扫描并计算数据</span>
                            </div>
-                            <h3>新的分析</h3>
-                            <span>重新扫描并计算数据<br />(可能需要几分钟)</span>
                        </button>
                    </div>
                </div>
--- a/src/pages/AnnualReportPage.scss
+++ b/src/pages/AnnualReportPage.scss
@@ -1,4 +1,5 @@
 .annual-report-page {
+  position: relative;
  display: flex;
  flex-direction: column;
  align-items: center;
@@ -6,6 +7,12 @@
  min-height: 100%;
  text-align: center;
  padding: 40px 24px;
+  animation: reportFadeIn 0.35s ease-out;
+}
+
+.annual-report-page.report-route-transitioning > :not(.report-launch-overlay) {
+  animation: report-page-exit 420ms cubic-bezier(0.4, 0, 0.2, 1) both;
+  pointer-events: none;
 }

 .header-icon {
@@ -14,40 +21,43 @@
 }

 .page-title {
-  font-size: 32px;
+  font-size: 28px;
  font-weight: 700;
  color: var(--text-primary);
-  margin: 0 0 12px;
+  margin: 0 0 10px;
+  letter-spacing: -0.5px;
 }

 .page-desc {
  font-size: 15px;
  color: var(--text-secondary);
-  margin: 0 0 48px;
+  margin: 0 0 40px;
+  line-height: 1.7;
 }

 .page-desc.load-summary {
-  margin: 0 0 28px;
+  margin: 0 0 24px;
 }

 .page-desc.load-summary.complete {
  color: var(--text-secondary);
 }

+// ---- Load telemetry ----
 .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);
+  width: min(620px, 100%);
+  padding: 12px 16px;
+  margin: 0 0 24px;
+  border-radius: 10px;
+  border: 1px solid var(--border-color);
+  background: var(--card-bg);
  text-align: left;
  font-size: 13px;
  color: var(--text-secondary);
  line-height: 1.5;

  p {
-    margin: 4px 0;
+    margin: 3px 0;
  }

  .label {
@@ -56,31 +66,32 @@
 }

 .load-telemetry.loading {
-  border-color: color-mix(in srgb, var(--primary) 30%, var(--border-color));
+  border-color: color-mix(in srgb, var(--primary) 25%, var(--border-color));
 }

 .load-telemetry.complete {
-  border-color: color-mix(in srgb, var(--primary) 40%, var(--border-color));
+  border-color: color-mix(in srgb, var(--primary) 35%, var(--border-color));
 }

 .load-telemetry.compact {
  margin: 12px 0 0;
-  width: min(560px, 100%);
+  width: min(500px, 100%);
 }

+// ---- Report sections ----
 .report-sections {
  display: flex;
  flex-direction: column;
-  gap: 32px;
-  width: min(760px, 100%);
+  gap: 20px;
+  width: min(620px, 100%);
 }

 .report-section {
  width: 100%;
  background: var(--card-bg);
  border: 1px solid var(--border-color);
-  border-radius: 20px;
-  padding: 28px;
+  border-radius: 16px;
+  padding: 24px;
  text-align: left;
 }

@@ -89,57 +100,57 @@
  align-items: flex-start;
  justify-content: space-between;
  gap: 16px;
-  margin-bottom: 20px;
+  margin-bottom: 16px;
 }

 .section-title {
  margin: 0;
-  font-size: 20px;
+  font-size: 17px;
  font-weight: 700;
  color: var(--text-primary);
 }

 .section-desc {
-  margin: 8px 0 0;
-  font-size: 14px;
+  margin: 6px 0 0;
+  font-size: 13px;
  color: var(--text-tertiary);
 }

 .section-badge {
  display: inline-flex;
  align-items: center;
-  gap: 6px;
-  padding: 6px 10px;
+  gap: 5px;
+  padding: 4px 10px;
  border-radius: 999px;
-  background: color-mix(in srgb, var(--primary) 12%, transparent);
+  background: var(--primary-light);
  color: var(--primary);
-  border: 1px solid color-mix(in srgb, var(--primary) 30%, transparent);
  font-size: 12px;
  font-weight: 600;
  white-space: nowrap;
 }

 .section-hint {
-  margin: 12px 0 0;
+  margin: 10px 0 0;
  font-size: 12px;
  color: var(--text-tertiary);
 }

+// ---- Year cards ----
 .year-grid-with-status {
  display: flex;
  align-items: flex-start;
  justify-content: space-between;
-  gap: 16px;
-  margin-bottom: 24px;
+  gap: 12px;
+  margin-bottom: 20px;
 }

 .year-grid {
  display: flex;
  flex-wrap: wrap;
-  gap: 16px;
+  gap: 10px;
  justify-content: center;
  max-width: 600px;
-  margin-bottom: 48px;
+  margin-bottom: 40px;
 }

 .report-section .year-grid {
@@ -163,7 +174,7 @@
 }

 .year-load-status.complete {
-  color: color-mix(in srgb, var(--primary) 80%, var(--text-secondary));
+  color: var(--primary);
 }

 .dot-ellipsis {
@@ -181,27 +192,33 @@
 }

 .year-card {
-  width: 120px;
-  height: 100px;
+  width: 88px;
+  height: 64px;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
-  background: var(--card-bg);
-  border: 2px solid var(--border-color);
-  border-radius: 16px;
+  background: transparent;
+  border: 1px solid var(--border-color);
+  border-radius: 10px;
  cursor: pointer;
-  transition: all 0.2s;
+  transition: all 0.15s ease;
+  gap: 2px;

  &:hover {
-    border-color: var(--primary);
-    transform: translateY(-2px);
-    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.1);
+    border-color: var(--text-tertiary);
+    background: var(--bg-hover);
+  }
+
+  &.disabled {
+    pointer-events: none;
+    opacity: 0.6;
  }

  &.selected {
    border-color: var(--primary);
    background: var(--primary-light);
+    box-shadow: 0 0 0 1px var(--primary);

    .year-number {
      color: var(--primary);
@@ -209,60 +226,100 @@
  }

  .year-number {
-    font-size: 32px;
+    font-size: 22px;
    font-weight: 700;
    color: var(--text-primary);
    line-height: 1;
  }

  .year-label {
-    font-size: 14px;
+    font-size: 11px;
    color: var(--text-tertiary);
-    margin-top: 4px;
  }
 }

+// ---- Generate button ----
 .generate-btn {
  display: flex;
  align-items: center;
-  gap: 10px;
-  padding: 16px 40px;
-  background: linear-gradient(135deg, var(--primary) 0%, color-mix(in srgb, var(--primary) 80%, #000) 100%);
+  justify-content: center;
+  gap: 8px;
+  width: 100%;
+  padding: 12px 24px;
+  background: var(--primary);
  border: none;
-  border-radius: 50px;
-  color: #fff;
-  font-size: 16px;
+  border-radius: 10px;
+  color: var(--on-primary);
+  font-size: 15px;
  font-weight: 600;
  cursor: pointer;
-  transition: all 0.2s;
-  box-shadow: 0 4px 16px color-mix(in srgb, var(--primary) 30%, transparent);
+  transition: opacity 0.15s ease;

  &:hover:not(:disabled) {
-    transform: translateY(-2px);
-    box-shadow: 0 8px 24px color-mix(in srgb, var(--primary) 40%, transparent);
-  }
-
-  &:active:not(:disabled) {
-    transform: translateY(0);
+    opacity: 0.9;
  }

  &:disabled {
-    opacity: 0.6;
+    opacity: 0.5;
    cursor: not-allowed;
  }

+  &.is-pending {
+    pointer-events: none;
+  }
+
  &.secondary {
-    background: var(--card-bg);
+    background: var(--bg-tertiary);
    color: var(--text-primary);
    border: 1px solid var(--border-color);
-    box-shadow: none;
+
+    &:hover:not(:disabled) {
+      background: var(--bg-hover);
+      opacity: 1;
+    }
  }
 }

+// ---- Launch overlay ----
+.report-launch-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 999;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: color-mix(in srgb, var(--bg-primary) 80%, transparent);
+  backdrop-filter: blur(8px);
+  animation: report-launch-overlay-in 350ms ease-out both;
+}
+
+.launch-core {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 10px;
+  text-align: center;
+  color: var(--text-primary);
+  animation: report-launch-core-in 350ms cubic-bezier(0.2, 0.8, 0.2, 1) both;
+}
+
+.launch-title {
+  margin: 4px 0 0;
+  font-size: 17px;
+  font-weight: 600;
+}
+
+.launch-subtitle {
+  margin: 0;
+  font-size: 13px;
+  color: var(--text-tertiary);
+}
+
 .spin {
  animation: spin 1s linear infinite;
 }

+// ---- Animations ----
@keyframes spin {
  from { transform: rotate(0deg); }
  to { transform: rotate(360deg); }
@@ -271,3 +328,43 @@
@keyframes dot-ellipsis {
  to { width: 1.4em; }
 }
+
+@keyframes report-page-exit {
+  from {
+    opacity: 1;
+    filter: blur(0);
+    transform: scale(1);
+  }
+  to {
+    opacity: 0;
+    filter: blur(6px);
+    transform: scale(0.985);
+  }
+}
+
+@keyframes report-launch-overlay-in {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+@keyframes report-launch-core-in {
+  from {
+    opacity: 0;
+    transform: translateY(14px) scale(0.97);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
+
+@keyframes reportFadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(8px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
--- a/src/pages/AnnualReportPage.tsx
+++ b/src/pages/AnnualReportPage.tsx
@@ -1,4 +1,4 @@
-import { useState, useEffect } from 'react'
+import { useState, useEffect, useRef } from 'react'
 import { useNavigate } from 'react-router-dom'
 import { Calendar, Loader2, Sparkles, Users } from 'lucide-react'
 import {
@@ -25,6 +25,8 @@ type YearsLoadPayload = {
  nativeTimedOut?: boolean
 }

+const REPORT_LAUNCH_DELAY_MS = 420
+
 const formatLoadElapsed = (ms: number) => {
  const totalSeconds = Math.max(0, ms) / 1000
  if (totalSeconds < 60) return `${totalSeconds.toFixed(1)}s`
@@ -50,7 +52,10 @@ function AnnualReportPage() {
  const [hasSwitchedStrategy, setHasSwitchedStrategy] = useState(false)
  const [nativeTimedOut, setNativeTimedOut] = useState(false)
  const [isGenerating, setIsGenerating] = useState(false)
+  const [isRouteTransitioning, setIsRouteTransitioning] = useState(false)
+  const [launchingYearLabel, setLaunchingYearLabel] = useState('')
  const [loadError, setLoadError] = useState<string | null>(null)
+  const launchTimerRef = useRef<number | null>(null)

  useEffect(() => {
    let disposed = false
@@ -186,21 +191,37 @@ function AnnualReportPage() {
    }
  }, [])

-  const handleGenerateReport = async () => {
-    if (selectedYear === null) return
-    setIsGenerating(true)
-    try {
-      const yearParam = selectedYear === 'all' ? 0 : selectedYear
-      navigate(`/annual-report/view?year=${yearParam}`)
-    } catch (e) {
-      console.error('生成报告失败:', e)
-    } finally {
-      setIsGenerating(false)
+  useEffect(() => {
+    return () => {
+      if (launchTimerRef.current !== null) {
+        window.clearTimeout(launchTimerRef.current)
+      }
    }
+  }, [])
+
+  const handleGenerateReport = () => {
+    if (selectedYear === null || isRouteTransitioning) return
+    const yearParam = selectedYear === 'all' ? 0 : selectedYear
+    const yearLabel = selectedYear === 'all' ? '全部时间' : `${selectedYear}年`
+    setIsGenerating(true)
+    setIsRouteTransitioning(true)
+    setLaunchingYearLabel(yearLabel)
+    if (launchTimerRef.current !== null) {
+      window.clearTimeout(launchTimerRef.current)
+    }
+    launchTimerRef.current = window.setTimeout(() => {
+      try {
+        navigate(`/annual-report/view?year=${yearParam}`)
+      } catch (e) {
+        console.error('生成报告失败:', e)
+        setIsGenerating(false)
+        setIsRouteTransitioning(false)
+      }
+    }, REPORT_LAUNCH_DELAY_MS)
  }

  const handleGenerateDualReport = () => {
-    if (selectedPairYear === null) return
+    if (selectedPairYear === null || isRouteTransitioning) return
    const yearParam = selectedPairYear === 'all' ? 0 : selectedPairYear
    navigate(`/dual-report?year=${yearParam}`)
  }
@@ -251,7 +272,7 @@ function AnnualReportPage() {
  )

  return (
-    <div className="annual-report-page">
+    <div className={`annual-report-page ${isRouteTransitioning ? 'report-route-transitioning' : ''}`}>
      <Sparkles size={32} className="header-icon" />
      <h1 className="page-title">年度报告</h1>
      <p className="page-desc">选择年份，回顾你在微信里的点点滴滴</p>
@@ -270,8 +291,11 @@ function AnnualReportPage() {
              {yearOptions.map(option => (
                <div
                  key={option}
-                  className={`year-card ${option === 'all' ? 'all-time' : ''} ${selectedYear === option ? 'selected' : ''}`}
-                  onClick={() => setSelectedYear(option)}
+                  className={`year-card ${option === 'all' ? 'all-time' : ''} ${selectedYear === option ? 'selected' : ''} ${isRouteTransitioning ? 'disabled' : ''}`}
+                  onClick={() => {
+                    if (isRouteTransitioning) return
+                    setSelectedYear(option)
+                  }}
                >
                  <span className="year-number">{option === 'all' ? '全部' : option}</span>
                  <span className="year-label">{option === 'all' ? '时间' : '年'}</span>
@@ -281,14 +305,14 @@ function AnnualReportPage() {
          </div>

          <button
-            className="generate-btn"
+            className={`generate-btn ${isRouteTransitioning ? 'is-pending' : ''}`}
            onClick={handleGenerateReport}
-            disabled={!selectedYear || isGenerating}
+            disabled={!selectedYear || isGenerating || isRouteTransitioning}
          >
            {isGenerating ? (
              <>
                <Loader2 size={20} className="spin" />
-                <span>正在生成...</span>
+                <span>{isRouteTransitioning ? '正在进入报告...' : '正在生成...'}</span>
              </>
            ) : (
              <>
@@ -316,8 +340,11 @@ function AnnualReportPage() {
              {yearOptions.map(option => (
                <div
                  key={`pair-${option}`}
-                  className={`year-card ${option === 'all' ? 'all-time' : ''} ${selectedPairYear === option ? 'selected' : ''}`}
-                  onClick={() => setSelectedPairYear(option)}
+                  className={`year-card ${option === 'all' ? 'all-time' : ''} ${selectedPairYear === option ? 'selected' : ''} ${isRouteTransitioning ? 'disabled' : ''}`}
+                  onClick={() => {
+                    if (isRouteTransitioning) return
+                    setSelectedPairYear(option)
+                  }}
                >
                  <span className="year-number">{option === 'all' ? '全部' : option}</span>
                  <span className="year-label">{option === 'all' ? '时间' : '年'}</span>
@@ -327,9 +354,9 @@ function AnnualReportPage() {
          </div>

          <button
-            className="generate-btn secondary"
+            className={`generate-btn secondary ${isRouteTransitioning ? 'is-pending' : ''}`}
            onClick={handleGenerateDualReport}
-            disabled={!selectedPairYear}
+            disabled={!selectedPairYear || isRouteTransitioning}
          >
            <Users size={20} />
            <span>选择好友并生成报告</span>
@@ -337,6 +364,16 @@ function AnnualReportPage() {
          <p className="section-hint">从聊天排行中选择好友生成双人报告</p>
        </section>
      </div>
+
+      {isRouteTransitioning && (
+        <div className="report-launch-overlay" role="status" aria-live="polite">
+          <div className="launch-core">
+            <Loader2 size={30} className="spin" />
+            <p className="launch-title">正在进入{launchingYearLabel}年度报告</p>
+            <p className="launch-subtitle">正在整理你的聊天记忆...</p>
+          </div>
+        </div>
+      )}
    </div>
  )
 }
--- a/src/pages/AnnualReportWindow.scss
+++ b/src/pages/AnnualReportWindow.scss
--- a/src/pages/AnnualReportWindow.tsx
+++ b/src/pages/AnnualReportWindow.tsx
--- a/src/pages/BackupPage.scss
+++ b/src/pages/BackupPage.scss
@@ -0,0 +1,298 @@
+.backup-page {
+  height: 100%;
+  overflow: auto;
+  padding: 20px;
+  color: var(--text-primary);
+  background: var(--bg-primary);
+}
+
+.backup-header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+  margin-bottom: 16px;
+
+  h1 {
+    margin: 0;
+    font-size: 22px;
+    font-weight: 650;
+    letter-spacing: 0;
+  }
+
+  p {
+    margin: 6px 0 0;
+    color: var(--text-secondary);
+    font-size: 14px;
+  }
+}
+
+.backup-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
+.resource-options {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+  margin: -6px 0 14px;
+
+  label {
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+    min-height: 34px;
+    padding: 7px 10px;
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 13px;
+    cursor: pointer;
+  }
+
+  input {
+    margin: 0;
+  }
+
+  svg {
+    color: var(--primary);
+  }
+}
+
+.primary-btn,
+.secondary-btn {
+  border: 1px solid var(--border-color);
+  border-radius: 8px;
+  padding: 8px 11px;
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 13px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: background 0.2s ease, border-color 0.2s ease, color 0.2s ease;
+
+  &:disabled {
+    opacity: 0.55;
+    cursor: not-allowed;
+  }
+}
+
+.primary-btn {
+  background: var(--primary);
+  color: var(--on-primary);
+  border-color: var(--primary);
+}
+
+.secondary-btn {
+  background: var(--bg-secondary);
+  color: var(--text-primary);
+
+  &:not(:disabled):hover {
+    background: var(--bg-tertiary);
+  }
+}
+
+.backup-status-band {
+  min-height: 76px;
+  border-top: 1px solid var(--border-color);
+  border-bottom: 1px solid var(--border-color);
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 14px;
+  padding: 12px 0;
+}
+
+.status-icon {
+  width: 36px;
+  height: 36px;
+  border-radius: 8px;
+  background: var(--bg-secondary);
+  color: var(--primary);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+}
+
+.status-body {
+  min-width: 0;
+  flex: 1;
+}
+
+.status-title {
+  font-size: 15px;
+  font-weight: 700;
+  margin-bottom: 4px;
+}
+
+.status-detail {
+  color: var(--text-secondary);
+  font-size: 12px;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.progress-track {
+  margin-top: 10px;
+  height: 5px;
+  background: var(--bg-tertiary);
+  border-radius: 999px;
+  overflow: hidden;
+}
+
+.progress-fill {
+  height: 100%;
+  background: var(--primary);
+  transition: width 0.2s ease;
+}
+
+.backup-summary,
+.restore-result {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 12px;
+  margin-bottom: 14px;
+}
+
+.summary-item,
+.restore-result > div {
+  border: 1px solid var(--border-color);
+  border-radius: 8px;
+  background: var(--bg-secondary);
+  padding: 12px;
+  min-height: 66px;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+
+  svg {
+    color: var(--primary);
+  }
+
+  span {
+    color: var(--text-secondary);
+    font-size: 12px;
+  }
+
+  strong {
+    color: var(--text-primary);
+    font-size: 18px;
+    line-height: 1.1;
+  }
+}
+
+.backup-detail {
+  border-top: 1px solid var(--border-color);
+  padding-top: 14px;
+}
+
+.detail-heading {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 10px;
+
+  h2 {
+    margin: 0;
+    font-size: 17px;
+  }
+
+  span {
+    color: var(--text-secondary);
+    font-size: 12px;
+  }
+}
+
+.detail-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
+  margin-bottom: 12px;
+
+  div {
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    padding: 12px;
+    background: var(--bg-secondary);
+    min-width: 0;
+  }
+
+  span {
+    display: block;
+    color: var(--text-secondary);
+    font-size: 12px;
+    margin-bottom: 5px;
+  }
+
+  strong {
+    display: block;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-size: 14px;
+  }
+}
+
+.db-list {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.db-row {
+  display: grid;
+  grid-template-columns: 110px 80px minmax(0, 1fr);
+  gap: 10px;
+  align-items: center;
+  border-bottom: 1px solid var(--border-color);
+  padding: 8px 0;
+  font-size: 13px;
+
+  span {
+    color: var(--primary);
+    font-weight: 700;
+  }
+
+  strong {
+    font-weight: 600;
+  }
+
+  em {
+    color: var(--text-secondary);
+    font-style: normal;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+}
+
+@media (max-width: 760px) {
+  .backup-header {
+    flex-direction: column;
+  }
+
+  .backup-actions {
+    width: 100%;
+    justify-content: flex-start;
+  }
+
+  .backup-summary,
+  .restore-result,
+  .detail-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .db-row {
+    grid-template-columns: 82px 64px minmax(0, 1fr);
+  }
+}
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`> 目前只适配了x64 win32平台，其它平台同样原理，但是代码还没写（`