diff --git a/.github/workflows/chat-image-quality.yml b/.github/workflows/chat-image-quality.yml
new file mode 100644
index 00000000..aefecf55
--- /dev/null
+++ b/.github/workflows/chat-image-quality.yml
@@ -0,0 +1,62 @@
+name: Chat Image Quality Checks
+
+on:
+  pull_request:
+    paths:
+      - '.github/workflows/chat-image-quality.yml'
+      - 'src/wechat_decrypt_tool/media_helpers.py'
+      - 'src/wechat_decrypt_tool/chat_export_service.py'
+      - 'src/wechat_decrypt_tool/routers/media.py'
+      - 'src/wechat_decrypt_tool/routers/chat*.py'
+      - 'tests/test_chat_image_local_quality.py'
+      - 'tests/test_chat_media_image_cache_upgrade.py'
+      - 'tests/test_media_decrypt_stream_cancel.py'
+      - 'frontend/lib/chat/chat-history.js'
+      - 'frontend/lib/chat/message-normalizer.js'
+      - 'frontend/tests/chat-image-quality.test.js'
+      - 'pyproject.toml'
+      - 'uv.lock'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  images:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-2022, macos-14]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5
+        with:
+          python-version: '3.11'
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        with:
+          node-version: 22
+      - run: python -m pip install uv
+      - run: uv sync --locked
+      # 使用实际编码的 PNG/JPEG/WebP 与 XOR DAT，不需要真实账号、显卡或 CDN。
+      - name: Local image display, export and predecryption regression
+        run: >-
+          uv run --no-sync pytest -q
+          tests/test_chat_image_local_quality.py
+          tests/test_chat_media_image_cache_upgrade.py
+          tests/test_media_decrypt_stream_cancel.py
+          tests/test_chat_media_file_id_scope.py
+          tests/test_chat_media_record_video.py
+          tests/test_chat_large_image_frontend.py
+          tests/test_chat_image_group_info.py
+          tests/test_image_key_verified_store.py
+          tests/test_image_key_resolver.py
+          tests/test_media_emoticon_catalog.py
+          tests/test_media_emoji_download_stream.py
+      - name: Install frontend dependencies
+        working-directory: frontend
+        run: npm ci
+      - name: Image browser cache regression
+        working-directory: frontend
+        run: npx vitest run tests/chat-image-quality.test.js
diff --git a/.github/workflows/qwen-gpu-runtime.yml b/.github/workflows/qwen-gpu-runtime.yml
new file mode 100644
index 00000000..d17489db
--- /dev/null
+++ b/.github/workflows/qwen-gpu-runtime.yml
@@ -0,0 +1,54 @@
+name: Qwen GPU Runtime Checks
+
+on:
+  pull_request:
+    paths:
+      - '.github/workflows/qwen-gpu-runtime.yml'
+      - 'src/wechat_decrypt_tool/qwen_gpu_runtime.py'
+      - 'src/wechat_decrypt_tool/asr_*.py'
+      - 'src/wechat_decrypt_tool/voice_transcription.py'
+      - 'src/wechat_decrypt_tool/routers/chat_media.py'
+      - 'src/wechat_decrypt_tool/resources/qwen_gpu_runtime.json'
+      - 'tests/test_qwen_gpu_runtime.py'
+      - 'tests/test_asr_upgrade.py'
+      - 'tests/test_voice_transcription.py'
+      - 'frontend/components/SettingsDialog.vue'
+      - 'frontend/composables/useApi.js'
+      - 'frontend/tests/voice-model-settings.test.mjs'
+      - 'desktop/scripts/build-backend.cjs'
+      - 'tools/*qwen*.py'
+      - 'pyproject.toml'
+      - 'uv.lock'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  runtime:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-2022, macos-14]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5
+        with:
+          python-version: '3.11'
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        with:
+          node-version: 22
+      - run: python -m pip install uv
+      # 公共 runner 不依赖显卡或 3 GB 的组件下载，验证续传、隔离、取消和发布清单。
+      - run: uv sync --locked --extra voice-transcription
+      - run: >-
+          uv run --no-sync pytest -q
+          tests/test_qwen_gpu_runtime.py
+          tests/test_asr_upgrade.py
+          tests/test_voice_transcription.py
+      - name: External runtime standard library discovery
+        run: uv run --no-sync python tools/qwen_runtime_stdlib.py
+      - name: Voice settings contracts
+        run: node --test frontend/tests/voice-model-settings.test.mjs
diff --git a/desktop/scripts/build-backend.cjs b/desktop/scripts/build-backend.cjs
index a0bb2797..4a0d8c3f 100644
--- a/desktop/scripts/build-backend.cjs
+++ b/desktop/scripts/build-backend.cjs
@@ -655,6 +655,8 @@ function main() {
     "sherpa_onnx",
     "--add-data",
     pyInstallerAddData(path.join(repoRoot, "src/wechat_decrypt_tool/resources/voice_models.json"), "wechat_decrypt_tool/resources"),
+    "--add-data",
+    pyInstallerAddData(path.join(repoRoot, "src/wechat_decrypt_tool/resources/qwen_gpu_runtime.json"), "wechat_decrypt_tool/resources"),
     "--collect-all",
     "watchfiles",
     ...aiPackagingArgs(repoRoot),
@@ -667,6 +669,12 @@ function main() {
   } else {
     args.splice(args.length - 1, 0, "--exclude-module", "torch", "--exclude-module", "transformers");
   }
+  // 下载后的推理库会动态导入标准库，冻结分析无法从排除的 Torch 源码推导这些依赖。
+  if (process.platform === "win32") {
+    const stdlib = spawnSync("uv", ["run", "--no-sync", "python", path.join(repoRoot, "tools/qwen_runtime_stdlib.py")], { cwd: repoRoot, encoding: "utf8", windowsHide: true });
+    if (stdlib.status !== 0) throw new Error(`Qwen runtime standard library discovery failed: ${stdlib.stderr}`);
+    for (const moduleName of JSON.parse(stdlib.stdout)) args.splice(args.length - 1, 0, "--hidden-import", moduleName);
+  }
 
   if (process.platform === "win32") {
     args.splice(
diff --git a/docs/chat-image-quality-2026-10-06.md b/docs/chat-image-quality-2026-10-06.md
new file mode 100644
index 00000000..70756c3a
--- /dev/null
+++ b/docs/chat-image-quality-2026-10-06.md
@@ -0,0 +1,40 @@
+# 本地大图显示、导出与预解密验收
+
+## 原因与修复
+
+`resource` 中已有有效缩略图时，普通图片请求与导出会直接使用该文件；手动“尝试加载大图”则重新寻找、解密并比较本地变体。预解密也按 MD5 跳过已有缓存，使先处理的缩略图阻止后续原图参与比较；并发处理同一 MD5 的文件还可能互相覆盖。这解释了本地原图存在、无需联网却必须逐张手动补图的现象。
+
+2.3.0 的代码已有类似缓存分支，因此这里只确认并修复可复现的缓存问题，不将整个问题归因于某个 2.8.0 提交。
+
+- 默认显示和导出比较实际像素面积，兼容 JPEG、PNG、GIF、WebP，不能只按 `_b`、`_h` 等文件名或文件大小判断；即使 hardlink 指向另一个目录中的缩略图，首次显示也会比较当前会话已有的原图。
+- 缓存修复只查询 hardlink、已解析源文件的同名变体和当前会话的标准附件目录，不调用 CDN 或递归扫描整个账号。
+- 缓存写入采用同一 MD5 的串行比较与原子替换，已有大图不会被缩略图降低分辨率；读取和导出复制也保护换格式时的缓存路径。
+- 保留旧版带序号/额外后缀的文件名与点号变体；当前会话的图片目录使用有界索引，新增文件后自动重建。预解密只跳过已经参与比较且未变化的源文件。状态包含源文件与密钥的摘要、缓存文件状态，不保存明文密钥或原始路径；已有旧缓存第一次仍会重新比较。默认显示也复用该状态，避免反复解密未变化的大图。
+- 图片使用 ETag 重新验证，普通图片和转发图片 URL 更新缓存版本，以避开旧版本仍有效的浏览器缩略图缓存。
+
+## 真实启动与验收
+
+Windows 上使用正式 `desktop/scripts/dev.cjs` 启动 Nuxt、Electron 和 CPU 依赖的源码后端，采用项目配置的官方生产原生组件及原有签名/完整性校验。
+
+从本机真实微信目录复制三组加密 DAT 文件，源文件字节保持不变。隔离验收账号使用测试用联系人和消息数据库，并从真实图片制作 120×120 缓存来复现旧缓存状态；没有把真实聊天数据库、图片、账号标识或密钥提交到仓库。
+
+| 验收入口 | 结果 |
+| --- | --- |
+| 普通图片请求，无 `prefer_live`、`deep_scan`、`fetch_remote` | 三张均恢复为 4032×3024，与本地解密原图 SHA-256 一致 |
+| HTML 完整导出，导出前重置旧缩略图缓存 | 三张均为 4032×3024，与本地原图内容一致 |
+| JSON 完整导出，导出前独立重置旧缓存 | 三张均为 4032×3024，与本地原图内容一致 |
+| 串行预解密 | 六个真实源文件均成功，三个缓存均保留 4032×3024 |
+| SSE 预解密，并发 10 | 六个真实源文件均成功，三个缓存均保留 4032×3024 |
+| 原图未变化时的 ETag 重新验证 | 三张均返回 304 |
+| Electron 聊天页与图片查看器 | 图片正常显示，未点击“尝试加载大图” |
+
+测试未调用 CDN 补图；没有切断 Windows 网络，也未把缺少本地原图的图片恢复作为通过条件。此修复优先使用实际存在的最高分辨率本地文件，不能恢复本机已经缺失的原图。
+
+## 自动化回归
+
+- 图片显示、导出媒体入口、预解密、并发换格式、缓存重新验证、媒体定位和图片密钥：78 项及 8 个子测试通过。
+- 使用官方生产原生组件运行已有完整 HTML、消息图片、转发记录和增量导出回归：29 项及 13 个子测试通过，没有替换导出签名或完整性实现。
+- 完整前端 Vitest：390 项通过，包含普通/转发图片缓存版本回归。
+- PR 中原有 Qwen 组件及转写回归：95 项及 10 个子测试通过。
+
+新增 Windows/macOS 图片 CI，使用实际编码的图片与 XOR DAT 覆盖同样的缓存问题，公共 runner 不需要真实账号或 CDN。
diff --git a/docs/qwen-gpu-runtime-2026-10-05.md b/docs/qwen-gpu-runtime-2026-10-05.md
new file mode 100644
index 00000000..6da08171
--- /dev/null
+++ b/docs/qwen-gpu-runtime-2026-10-05.md
@@ -0,0 +1,56 @@
+# Qwen GPU 组件按需安装与真实验收
+
+## 当前行为
+
+设置中的 Qwen GPU 卡片提供“下载并启用”，已有模型但缺少依赖时提供“安装 GPU 组件并启用”。组件下载、校验、解压、显卡检查、模型检查全部通过后才修改语音模型设置。失败或暂停时保留原选择。
+
+组件安装在应用数据目录的 `voice_runtimes/<版本>/cp311` 等目录，下载缓存独立保留。Windows x64 的 Python 3.11、3.12、3.13 有各自的固定 wheel 清单；下载总量约 2.91 GB（界面按二进制单位显示约 2.71 GB），初次安装预留约 9 GB 可用空间。普通安装包无需预先内置 Torch，也不要求用户安装系统 Python 或 CUDA Toolkit。
+
+后台任务支持暂停、重试和 HTTP 续传。应用重启时，未完成任务显示暂停，用户点击继续才恢复。语音工作进程和 CUDA 检测进程加载外置依赖；主进程不会把组件加入全局导入路径。组件按发布清单校验 SHA-256，解压时拒绝越界路径和符号链接，组件目录拒绝 Windows 目录联接。
+
+接口：
+
+- `POST /api/chat/media/voice/transcription/qwen-gpu/prepare`：准备组件及模型，验证后启用。
+- `POST /api/chat/media/voice/transcription/qwen-gpu/pause`：暂停，保留组件下载缓存。
+- `GET /api/chat/media/voice/transcription/qwen-gpu/status`：读取状态及进度。
+- 原有模型下载接口继续只下载模型，保持已有调用的语义。
+
+模型下载阶段的暂停会取消原模型下载任务，组件 wheel 支持续传；恢复时未完成的模型下载遵循现有模型管理器行为。完成的模型不会因为暂停而删除。
+
+## 真实验收证据
+
+本机 Windows x64、CPython 3.11.3、RTX 4070 SUPER 12 GB、NVIDIA 驱动 596.49。测试使用独立的数据和浏览器目录，没有修改真实账号的转写缓存或语音设置。语音来源为此前验收保留的真实 SILK 子集，未使用合成音频。
+
+| 项目 | 实际结果 |
+| --- | --- |
+| 官方组件下载 | 下载全部 34 个 wheel，总计 2,907,393,190 字节，逐文件 SHA-256 通过；中断后保留的下载继续完成 |
+| 冻结程序加载外置组件 | 排除内置 Torch、Transformers 的冻结程序成功加载下载目录中的 Torch 2.9.1+cu128，执行 CUDA 张量运算并加载 Qwen 模型 |
+| 真实桌面操作 | 在 Electron 应用内看到“模型已下载 · 缺少组件”，点击安装后能读到实际安装任务；点击暂停后任务停止，原模型仍为 CTC |
+| 重启恢复 | 停止并重新启动验收应用，任务仍为暂停；界面显示“继续安装并启用”，继续后完成实际解压、CUDA 检查和模型加载 |
+| 自动启用 | 组件任务返回 done，界面选择 Qwen GPU，设备显示 NVIDIA GPU / RTX 4070 SUPER |
+| 真实语音 | 经真实冻结后端的正式语音 HTTP 接口处理 20 条 SILK，20/20 成功，实际设备 CUDA、精度 BF16 |
+| 缓存复查 | 对每条语音再次请求，20/20 命中缓存，文字与首次结果一致 |
+| 最终构建复查 | 最终代码重新冻结后，重启隔离应用，20/20 持久化缓存通过；另外强制执行 3 条真实 SILK，全部使用 CUDA / BF16 成功 |
+
+20 条音频总长 202.54 秒，强制转写合计 52.95 秒，包括首次模型加载。这是本机该语料单轮耗时，不代表其他硬件或录音的性能保证，也不等于识别准确率测评。
+
+提交 PR 前，又将本次改动迁入最新主分支 `754b49f3`，在独立工作树中安装锁定的 CPU 依赖（不安装内置 Torch / Transformers），通过项目正式 `desktop/scripts/dev.cjs` 启动 Nuxt、Electron 和后端。桌面语音设置实际显示 Qwen GPU 已选和 RTX 4070 SUPER；后端从已下载的外置组件执行第二轮 20 条真实 SILK 转写及 20 次缓存复查，全部通过，强制转写合计 61.68 秒。隔离语料只有转写所需的媒体与最小数据库标记，不用于验收聊天列表。
+
+验收程序和日志保存在 `tmp/qwen-gpu-acceptance/`：`real-api-summary.json`、`real-api.log`、`final-binary-summary.json`、`final-binary.log`、`prepare-result.json`、`frozen-model-check.json`、构建日志及隔离数据。`transcripts.private.json` 保留逐条文字，仅用于本机检查，不进入本说明或 Git。
+
+## 自动化检查与构建
+
+- 后端组件、语音升级及转写相关检查：94 项通过，另有 6 项子测试通过。
+- 前端现有语音设置契约：10 项通过。
+- Nuxt 静态构建通过；本次设置组件机械检测无新增结果。
+- 最新主分支的完整前端 Vitest：29 个文件、388 项测试通过。
+- 项目正式 CPU 后端构建通过，冻结 OpenCC、watchfiles、AI 运行检查通过。
+- 冻结验证中发现并修正了动态标准库导入缺失，以及 `TorchVersion` 经 Pipe 反序列化时要求父进程导入 Torch 的问题。
+
+组件清单由 `tools/generate_qwen_gpu_manifest.py` 根据 `uv.lock` 生成，新增或升级组件时应更新发布版本 ID 并重新进行冻结程序验收。`tools/qwen_runtime_stdlib.py` 保留外置依赖需要的可用标准库，使 CPU 冻结程序也能加载下载后的推理库。
+
+## 未完成或未实际覆盖的项目
+
+正式安装程序未完成签名验收。本机缺少 `WCE_WINDOWS_CLIENT_CERT_THUMBPRINT` 所需的发布签名证书配置，正式 electron-builder 流程在签名阶段失败，没有关闭签名要求或修改验证策略。桌面功能验收使用已生成的未签名应用目录；将正式后端构建产生、且通过现有校验的 native 资源补入测试目录后运行。此目录仅用于本机验收，不作为正式安装包发布。
+
+Python 3.12/3.13 的 wheel 兼容标签和清单已有自动检查，但没有在这些解释器下执行真实模型推理；其他 NVIDIA 显卡、驱动以及无显卡电脑没有做物理换机验收。损坏文件、错误续传位置、路径越界、任务中断及模型下载取消等异常由自动化测试覆盖。
diff --git a/frontend/components/SettingsDialog.vue b/frontend/components/SettingsDialog.vue
index 4737ade8..6ea0ff66 100644
--- a/frontend/components/SettingsDialog.vue
+++ b/frontend/components/SettingsDialog.vue
@@ -364,6 +364,16 @@
 
                     <div class="mt-1.5 line-clamp-2 text-[10px] leading-relaxed text-[var(--app-text-secondary)]">{{ model.description }}</div>
                     <div v-if="!model.runtimeAvailable" class="mt-1.5 text-[11px] leading-relaxed text-[var(--app-text-secondary)]">{{ model.runtimeReason }}</div>
+                    <div v-if="model.runtimeComponent && !model.runtimeComponent.installed && !model.runtimeAvailable" class="mt-1 text-[11px] text-[var(--app-text-muted)]">
+                      运行组件约 {{ formatBytes(model.runtimeComponent.size) }}，下载和解压需约 9 GB 可用空间。
+                    </div>
+                    <div v-if="qwenIsActive(model) || ['paused', 'error'].includes(model.runtimeComponent?.job?.status)" class="mt-2 text-[11px] leading-relaxed" data-qwen-runtime-status>
+                      <p role="status" class="text-[var(--app-text-secondary)]">{{ qwenStageText(model) }}</p>
+                      <p v-if="qwenIsActive(model) && model.runtimeComponent.job.stage !== 'downloading_model'" class="tabular-nums text-[var(--app-text-muted)]">
+                        {{ formatBytes(model.runtimeComponent.job.bytes || 0) }} / {{ formatBytes(model.runtimeComponent.job.total || model.runtimeComponent.size) }}
+                      </p>
+                      <p v-if="model.runtimeComponent.job.error" role="alert" class="break-words text-[var(--danger-color)]">{{ model.runtimeComponent.job.error }}</p>
+                    </div>
                     <div v-if="isVoiceModelDownloading(model)" class="mt-2" data-voice-model-progress>
                       <div class="flex flex-wrap items-center justify-between gap-x-2 gap-y-0.5 text-[10px] leading-relaxed">
                         <span class="text-[var(--app-text-secondary)]">{{ voiceModelDownloadStageText(model) }}</span>
@@ -390,17 +400,32 @@
 
                     <div class="mt-auto flex flex-wrap items-center justify-end gap-1.5 pt-2">
                       <button
-                        v-if="model.downloaded && !model.selected"
+                        v-if="qwenNeedsPreparation(model)"
+                        type="button"
+                        class="voice-setting-focus whitespace-normal rounded-[5px] bg-[var(--app-accent)] px-2 py-1 text-[11px] font-medium text-white transition hover:bg-[var(--app-accent-hover)] disabled:cursor-not-allowed disabled:opacity-40"
+                        :disabled="voiceModelLocked || !model.runtimeComponent.supported || qwenIsActive(model) || isVoiceModelActionBusy(model.id)"
+                        :title="voiceModelLocked ? '模型由启动环境变量固定' : model.runtimeComponent.reason || '安装所需运行组件和模型，检查显卡后启用'"
+                        @click="prepareQwenModel(model)"
+                      >{{ qwenButtonText(model) }}</button>
+                      <button
+                        v-if="qwenIsActive(model)"
+                        type="button"
+                        class="voice-setting-focus rounded-[5px] border border-[var(--app-border)] px-2 py-1 text-[11px] text-[var(--app-text-secondary)] disabled:opacity-50"
+                        :disabled="isVoiceModelActionBusy(model.id)"
+                        @click="pauseQwenModel(model)"
+                      >暂停</button>
+                      <button
+                        v-if="model.downloaded && !model.selected && !qwenNeedsPreparation(model)"
                         type="button"
                         class="voice-setting-focus rounded-[5px] border border-[var(--app-border)] bg-[var(--app-surface-bg)] px-2 py-1 text-[10px] font-medium text-[var(--app-accent)] transition hover:bg-[var(--app-neutral-btn-hover)] disabled:cursor-not-allowed disabled:opacity-50"
-                        :disabled="voiceModelLocked || !model.runtimeAvailable || isVoiceModelActionBusy(model.id)"
+                        :disabled="voiceModelLocked || !model.runtimeAvailable || qwenPreparationActive || isVoiceModelActionBusy(model.id)"
                         :title="voiceModelLocked ? '模型由启动环境变量固定' : !model.runtimeAvailable ? model.runtimeReason : `选择 ${model.name}`"
                         @click="selectVoiceModel(model)"
                       >
                         {{ isVoiceModelActionBusy(model.id, 'select') ? '选择中...' : '选择' }}
                       </button>
                       <button
-                        v-if="!model.downloaded && !isVoiceModelDeletePending(model.id)"
+                        v-if="!model.downloaded && !isVoiceModelDeletePending(model.id) && !qwenNeedsPreparation(model)"
                         type="button"
                         class="voice-setting-focus whitespace-nowrap rounded-[5px] bg-[var(--app-accent)] px-2 py-1 text-[10px] font-medium text-white transition hover:bg-[var(--app-accent-hover)] disabled:cursor-not-allowed disabled:opacity-40"
                         :disabled="voiceDownloadSourceBusy || !model.downloadable || isVoiceModelDownloading(model) || isVoiceModelActionBusy(model.id)"
@@ -413,7 +438,7 @@
                         v-if="canDeleteVoiceModel(model)"
                         type="button"
                         class="voice-setting-focus rounded-[5px] border border-[var(--app-border)] px-2 py-1 text-[10px] text-[var(--danger-color)] transition hover:bg-[var(--app-neutral-btn-hover)] disabled:cursor-not-allowed disabled:opacity-50"
-                        :disabled="isVoiceModelDeletePending(model.id)"
+                        :disabled="isVoiceModelDeletePending(model.id) || qwenIsActive(model)"
                         :title="isVoiceModelDownloading(model) || isVoiceModelActionBusy(model.id, 'download') ? `停止下载并删除 ${model.name}` : `删除本机上的 ${model.name}`"
                         @click="removeVoiceModel(model)"
                       >
@@ -1292,6 +1317,7 @@ const applyVoiceTranscriptionStatus = (status) => {
       recommended: item?.recommended === true,
       runtimeAvailable: item?.runtimeAvailable !== false,
       runtimeReason: String(item?.runtimeReason || '缺少运行组件，请更新应用或选择其他模型。'),
+      runtimeComponent: item?.runtimeComponent || null,
       selected: item?.selected === true || id === voiceModel.value,
       downloaded,
       downloadable: item?.downloadable !== false,
@@ -1318,6 +1344,49 @@ const applyVoiceTranscriptionStatus = (status) => {
 
 const isVoiceModelDownloading = (model) => ['queued', 'running'].includes(String(model?.downloadStatus || '').toLowerCase())
 
+const qwenIsActive = (model) => ['queued', 'running'].includes(model?.runtimeComponent?.job?.status)
+const qwenPreparationActive = computed(() => voiceModels.value.some(qwenIsActive))
+const qwenNeedsPreparation = (model) => !!model?.runtimeComponent && (
+  !model.downloaded || !model.runtimeAvailable || qwenIsActive(model)
+  || ['paused', 'error'].includes(model.runtimeComponent.job?.status)
+)
+const qwenStageText = (model) => {
+  const job = model?.runtimeComponent?.job || {}
+  if (job.stage === 'downloading_model') return `正在下载模型 ${job.modelPercent || 0}%`
+  return ({ preparing: '准备安装', downloading: '正在下载 GPU 组件', retry_wait: '网络中断，正在重试',
+    verifying: '正在校验组件', installing: '正在安装组件', checking_runtime: '正在检查显卡和组件',
+    checking_model: '正在检查模型', paused: '安装已暂停，可继续', error: '安装或启用失败', done: '已启用' })[job.stage] || '等待安装'
+}
+const qwenButtonText = (model) => {
+  if (qwenIsActive(model)) return qwenStageText(model)
+  if (model.runtimeComponent?.job?.status === 'paused') return '继续安装并启用'
+  if (model.runtimeComponent?.job?.status === 'error') return '重试并启用'
+  return model.downloaded ? '安装 GPU 组件并启用' : '下载并启用'
+}
+const updateQwenComponent = (component) => {
+  voiceModels.value = voiceModels.value.map((model) => model.id === 'qwen3-asr-06b-hf'
+    ? { ...model, runtimeComponent: component } : model)
+}
+const prepareQwenModel = async (model) => {
+  if (voiceModelLocked.value || qwenIsActive(model) || isVoiceModelActionBusy(model.id)) return
+  voiceModelAction.value = { id: model.id, type: 'prepare' }
+  voiceModelError.value = ''
+  try {
+    updateQwenComponent(await api.prepareQwenGpu())
+    scheduleVoiceModelDownloadPolling()
+  } catch (e) {
+    voiceModelError.value = e?.message || 'GPU 组件安装无法启动，请重试。'
+  } finally {
+    voiceModelAction.value = { id: '', type: '' }
+  }
+}
+const pauseQwenModel = async (model) => {
+  voiceModelAction.value = { id: model.id, type: 'pause' }
+  try { updateQwenComponent(await api.pauseQwenGpu()) }
+  catch (e) { voiceModelError.value = e?.message || '暂停失败，请重试。' }
+  finally { voiceModelAction.value = { id: '', type: '' } }
+}
+
 const voiceModelDownloadPercent = (model) => normalizeVoiceModelDownloadPercent(model?.downloadPercent)
 
 const voiceModelDownloadStageText = (model) => {
@@ -1355,6 +1424,9 @@ const isVoiceModelActionBusy = (modelId, type = '') => {
 }
 
 const voiceModelStateText = (model) => {
+  if (qwenIsActive(model)) return '准备启用'
+  if (model.runtimeComponent?.job?.status === 'error') return '启用失败'
+  if (!model.runtimeAvailable) return model.downloaded ? '模型已下载 · 缺少组件' : '缺少组件'
   const status = String(model?.downloadStatus || '').toLowerCase()
   if (status === 'queued') return '等待下载'
   if (status === 'running') return `正在下载 ${voiceModelDownloadPercent(model)}%`
@@ -1364,6 +1436,7 @@ const voiceModelStateText = (model) => {
 }
 
 const voiceModelStateClass = (model) => {
+  if (!model.runtimeAvailable || model.runtimeComponent?.job?.status === 'error') return 'text-[var(--app-text-secondary)]'
   const status = String(model?.downloadStatus || '').toLowerCase()
   if (isVoiceModelDownloading(model) || model?.downloaded) return 'text-[var(--app-accent)]'
   if (status === 'error') return 'text-[var(--danger-color)]'
@@ -1418,9 +1491,18 @@ const pollVoiceModelDownloads = async () => {
     && model.downloadJobId
     && !isVoiceModelDeletePending(model.id)
   ))
-  if (!active.length) return
+  if (!active.length && !qwenPreparationActive.value) return
 
   let terminalJobSeen = false
+  if (qwenPreparationActive.value) {
+    try {
+      const component = await api.getQwenGpuStatus()
+      updateQwenComponent(component)
+      terminalJobSeen = !['queued', 'running'].includes(component.job?.status)
+    } catch (e) {
+      voiceModelError.value = e?.message || '读取 GPU 组件安装进度失败，将继续重试。'
+    }
+  }
   await Promise.all(active.map(async (model) => {
     const generation = voiceModelDownloadGeneration(model.id)
     try {
@@ -1452,7 +1534,7 @@ function scheduleVoiceModelDownloadPolling() {
     isVoiceModelDownloading(model)
     && model.downloadJobId
     && !isVoiceModelDeletePending(model.id)
-  ))) return
+  )) && !qwenPreparationActive.value) return
   voiceModelDownloadTimer = setTimeout(async () => {
     voiceModelDownloadTimer = null
     await pollVoiceModelDownloads()
diff --git a/frontend/composables/useApi.js b/frontend/composables/useApi.js
index 67595746..6f836cc7 100644
--- a/frontend/composables/useApi.js
+++ b/frontend/composables/useApi.js
@@ -589,6 +589,10 @@ export const useApi = () => {
     })
   }
 
+  const prepareQwenGpu = async () => await request('/chat/media/voice/transcription/qwen-gpu/prepare', { method: 'POST' })
+  const pauseQwenGpu = async () => await request('/chat/media/voice/transcription/qwen-gpu/pause', { method: 'POST' })
+  const getQwenGpuStatus = async () => await request('/chat/media/voice/transcription/qwen-gpu/status')
+
   const getVoiceTranscriptionModelDownload = async (jobId) => {
     const id = encodeURIComponent(String(jobId || '').trim())
     return await request(`/chat/media/voice/transcription/models/downloads/${id}`)
@@ -1242,6 +1246,9 @@ export const useApi = () => {
     setVoiceTranscriptionDevice,
     setVoiceTranscriptionModel,
     downloadVoiceTranscriptionModel,
+    prepareQwenGpu,
+    pauseQwenGpu,
+    getQwenGpuStatus,
     getVoiceTranscriptionModelDownload,
     deleteVoiceTranscriptionModel,
     transcribeChatVoice,
diff --git a/frontend/lib/chat/chat-history.js b/frontend/lib/chat/chat-history.js
index 813a6eae..5654b662 100644
--- a/frontend/lib/chat/chat-history.js
+++ b/frontend/lib/chat/chat-history.js
@@ -307,7 +307,7 @@ export const createChatHistoryRecordNormalizer = ({ apiBase, getSelectedAccount,
       })()
       if (fileId) {
         previewCandidates.push(
-          `${apiBase}/chat/media/image?account=${account}&file_id=${encodeURIComponent(fileId)}&username=${username}`
+          `${apiBase}/chat/media/image?account=${account}&file_id=${encodeURIComponent(fileId)}&username=${username}&v=local-quality-1`
         )
       }
 
@@ -320,7 +320,7 @@ export const createChatHistoryRecordNormalizer = ({ apiBase, getSelectedAccount,
           srcServerId ? `server_id=${encodeURIComponent(srcServerId)}` : '',
           `username=${username}`
         ].filter(Boolean)
-        previewCandidates.push(`${apiBase}/chat/media/image?${previewParts.join('&')}`)
+        previewCandidates.push(`${apiBase}/chat/media/image?${previewParts.join('&')}&v=local-quality-1`)
       }
 
       output._linkPreviewCandidates = previewCandidates
@@ -416,7 +416,7 @@ export const createChatHistoryRecordNormalizer = ({ apiBase, getSelectedAccount,
         recordAttachKey ? `record_attach=${encodeURIComponent(recordAttachKey)}` : '',
         `username=${username}`
       ].filter(Boolean)
-      output.imageUrl = imageParts.length ? `${apiBase}/chat/media/image?${imageParts.join('&')}` : ''
+      output.imageUrl = imageParts.length ? `${apiBase}/chat/media/image?${imageParts.join('&')}&v=local-quality-1` : ''
       if (!output.content || /^\[.+\]$/.test(String(output.content || '').trim())) output.content = '[图片]'
     }
 
diff --git a/frontend/lib/chat/message-normalizer.js b/frontend/lib/chat/message-normalizer.js
index 79089b0d..7105c24c 100644
--- a/frontend/lib/chat/message-normalizer.js
+++ b/frontend/lib/chat/message-normalizer.js
@@ -46,7 +46,12 @@ const isUsableMediaUrl = (value) => {
 }
 
 const buildAccountMediaUrl = (apiBase, path, parts) => {
-  return `${apiBase}${path}?${parts.filter(Boolean).join('&')}`
+  const query = parts.filter(Boolean)
+  // 让升级后的默认图片请求避开旧版本仍在有效期内的缩略图浏览器缓存。
+  if (path === '/chat/media/image' && !query.some((part) => part.startsWith('v='))) {
+    query.push('v=local-quality-1')
+  }
+  return `${apiBase}${path}?${query.join('&')}`
 }
 
 const isManualLargeImageUrl = (value) => {
diff --git a/frontend/tests/chat-image-quality.test.js b/frontend/tests/chat-image-quality.test.js
new file mode 100644
index 00000000..38d0d7e7
--- /dev/null
+++ b/frontend/tests/chat-image-quality.test.js
@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest'
+import { createChatHistoryRecordNormalizer } from '../lib/chat/chat-history'
+import { createMessageNormalizer } from '../lib/chat/message-normalizer'
+
+describe('聊天图片缓存升级', () => {
+  it('普通图片首次显示也避开旧浏览器缓存，并保留已有媒体刷新版本', () => {
+    let mediaVersion = 0
+    const normalize = createMessageNormalizer({
+      apiBase: 'http://localhost:10392/api',
+      getSelectedAccount: () => 'wxid_test',
+      getSelectedContact: () => ({ username: 'wxid_friend' }),
+      getLocalMediaVersion: () => mediaVersion
+    })
+    const message = { renderType: 'image', imageMd5: 'a'.repeat(32), serverId: '123456789' }
+    let url = new URL(normalize(message).imageUrl)
+    expect(url.searchParams.get('v')).toBe('local-quality-1')
+    expect(url.searchParams.has('fetch_remote')).toBe(false)
+    mediaVersion = 12345
+    url = new URL(normalize(message).imageUrl)
+    expect(url.searchParams.get('v')).toBe('12345')
+  })
+  it('转发图片使用新缓存版本，保留原消息定位参数', () => {
+    const normalize = createChatHistoryRecordNormalizer({
+      apiBase: 'http://localhost:10392/api',
+      getSelectedAccount: () => 'wxid_test',
+      getSelectedContact: () => ({ username: 'wxid_friend' })
+    })
+    const message = normalize({
+      renderType: 'image', fullmd5: 'a'.repeat(32), fromnewmsgid: '123456789',
+      recordIndexPath: '1_2', srcMsgCreateTime: '1791194400'
+    })
+    const url = new URL(message.imageUrl)
+    expect(url.searchParams.get('v')).toBe('local-quality-1')
+    expect(url.searchParams.get('md5')).toBe('a'.repeat(32))
+    expect(url.searchParams.get('server_id')).toBe('123456789')
+    expect(url.searchParams.get('record_index_path')).toBe('1_2')
+    expect(url.searchParams.has('fetch_remote')).toBe(false)
+  })
+})
diff --git a/frontend/tests/voice-model-settings.test.mjs b/frontend/tests/voice-model-settings.test.mjs
index 35579335..1e464155 100644
--- a/frontend/tests/voice-model-settings.test.mjs
+++ b/frontend/tests/voice-model-settings.test.mjs
@@ -36,8 +36,8 @@ test('settings renders model cards and keeps active downloads observable', () =>
 
 test('download-time deletion stays available and supersedes stale download work', () => {
   assert.match(voiceSectionSource, /v-if="canDeleteVoiceModel\(model\)"/)
-  assert.match(voiceSectionSource, /:disabled="isVoiceModelDeletePending\(model\.id\)"/)
-  assert.match(voiceSectionSource, /v-if="!model\.downloaded && !isVoiceModelDeletePending\(model\.id\)"/)
+  assert.match(voiceSectionSource, /:disabled="isVoiceModelDeletePending\(model\.id\) \|\| qwenIsActive\(model\)"/)
+  assert.match(voiceSectionSource, /v-if="!model\.downloaded && !isVoiceModelDeletePending\(model\.id\) && !qwenNeedsPreparation\(model\)"/)
   assert.match(voiceSectionSource, /停止并删除/)
 
   const deleteButtonStart = voiceSectionSource.indexOf('v-if="canDeleteVoiceModel(model)"')
diff --git a/src/wechat_decrypt_tool/asr_models.py b/src/wechat_decrypt_tool/asr_models.py
index 572c4d54..20795d64 100644
--- a/src/wechat_decrypt_tool/asr_models.py
+++ b/src/wechat_decrypt_tool/asr_models.py
@@ -60,6 +60,10 @@ def verify_model_files(path: Path, model: str, checkpoint: Callable[[], None] =
 
 def dependency_status(model: str) -> tuple[bool, str]:
     backend = SPECS.get(model, {}).get("backend", "whisper")
+    if backend == "qwen-hf":
+        from .qwen_gpu_runtime import installed
+        if installed():
+            return True, ""
     packages = {
         "whisper": ("faster_whisper",),
         "zipformer": ("sherpa_onnx", "av", "numpy"),
@@ -73,5 +77,5 @@ def dependency_status(model: str) -> tuple[bool, str]:
     if ready:
         return True, ""
     if backend == "qwen-hf":
-        return False, "当前未安装 Qwen GPU 运行组件，请使用含 Qwen GPU 组件的版本，或选择 CPU 模型 / Turbo。"
+        return False, "缺少 Qwen GPU 运行组件，点击安装并启用；需要 NVIDIA 显卡，也可选择 CPU 模型 / Turbo。"
     return False, "缺少语音识别运行组件，请安装语音转文字可选依赖或更新应用。"
diff --git a/src/wechat_decrypt_tool/asr_worker.py b/src/wechat_decrypt_tool/asr_worker.py
index e8551b85..20f8f77a 100644
--- a/src/wechat_decrypt_tool/asr_worker.py
+++ b/src/wechat_decrypt_tool/asr_worker.py
@@ -23,6 +23,9 @@ def _worker(connection, backend: str, folder: str, threads: int):
                       MKL_NUM_THREADS=str(threads), OPENBLAS_NUM_THREADS=str(threads))
     model = None
     try:
+        if backend == "qwen-hf":
+            from .qwen_gpu_runtime import activate_for_worker
+            activate_for_worker()
         from .asr_backends import audio_chunks, load_backend, read_audio
         import numpy as np
         while connection.poll(120):
@@ -118,6 +121,8 @@ def close(self):
 
 def _torch_probe(connection):
     try:
+        from .qwen_gpu_runtime import activate_for_worker
+        activate_for_worker()
         import torch
         count = torch.cuda.device_count() if torch.cuda.is_available() else 0
         connection.send(dict(available=count > 0, deviceCount=count,
@@ -133,6 +138,69 @@ def _torch_probe(connection):
 _PROBE_CACHE = None
 
 
+def invalidate_qwen_probe():
+    global _PROBE_CACHE
+    with _PROBE_LOCK:
+        _PROBE_CACHE = None
+
+
+def _runtime_probe(connection, root, folder):
+    try:
+        from .qwen_gpu_runtime import activate_for_worker
+        activate_for_worker(root)
+        import torch
+        from transformers import AutoProcessor, AutoModelForMultimodalLM
+        if not torch.cuda.is_available():
+            raise ValueError("GPU 组件已安装，但 NVIDIA 显卡不可用，请检查显卡驱动。")
+        # 实际执行 CUDA 运算，发现驱动或架构不兼容，而非只检查设备列表。
+        value = (torch.ones(4, device="cuda") * 2).sum().item()
+        if value != 8:
+            raise ValueError("GPU 运算检查未通过，请检查显卡驱动。")
+        if folder:
+            os.environ.update(HF_HUB_OFFLINE="1", TRANSFORMERS_OFFLINE="1")
+            from .asr_backends import QwenGpuBackend
+            model = QwenGpuBackend(__import__("pathlib").Path(folder), 2)
+            del model
+        connection.send(dict(available=True, reason="", device=torch.cuda.get_device_name(0),
+                             torchVersion=str(torch.__version__), torchModule=str(torch.__file__), modelLoaded=bool(folder)))
+    except Exception as exc:
+        connection.send(dict(available=False, reason=f"GPU 组件检查失败：{str(exc)[:300]}。请重试或选择 CPU 模型。"))
+    finally:
+        connection.close()
+
+
+def check_qwen_runtime(root=None, folder=None, cancel_event=None):
+    context = multiprocessing.get_context("spawn")
+    parent, child = context.Pipe(duplex=False)
+    process = context.Process(target=_runtime_probe, args=(child, root, folder), daemon=True)
+    result = dict(available=False, reason="GPU 组件检查超时或进程退出，请重试或选择 CPU 模型。")
+    try:
+        process.start()
+        child.close()
+        deadline = time.monotonic() + 180
+        while time.monotonic() < deadline:
+            if cancel_event is not None and cancel_event.is_set():
+                from .qwen_gpu_runtime import Paused
+                raise Paused()
+            if parent.poll(.1):
+                result = parent.recv()
+                break
+            if not process.is_alive():
+                break
+    except (EOFError, OSError, RuntimeError):
+        pass
+    finally:
+        parent.close()
+        child.close()
+        if process.pid is not None:
+            process.join(timeout=1)
+            if process.is_alive():
+                process.terminate()
+                process.join(timeout=2)
+            process.close()
+    return result
+
+
 def probe_qwen_cuda():
     global _PROBE_CACHE
     with _PROBE_LOCK:
diff --git a/src/wechat_decrypt_tool/chat_export_service.py b/src/wechat_decrypt_tool/chat_export_service.py
index e03c3c50..810ab22a 100644
--- a/src/wechat_decrypt_tool/chat_export_service.py
+++ b/src/wechat_decrypt_tool/chat_export_service.py
@@ -79,6 +79,8 @@
     _detect_image_media_type,
     _fallback_search_media_by_file_id,
     _read_and_maybe_decrypt_media,
+    _prefer_local_image_resource,
+    _image_resource_lock,
     _resolve_account_db_storage_dir,
     _resolve_account_wxid_dir,
     _resolve_media_path_for_kind,
@@ -8706,6 +8708,19 @@ def coerce_blob(value: Any) -> bytes:
     return arc, True
 
 
+def _guard_image_materialization(function):
+    @functools.wraps(function)
+    def guarded(*args, **kwargs):
+        md5 = str(kwargs.get("md5") or "")
+        if kwargs.get("kind") == "image" and _is_md5(md5):
+            # 预解密可能同时升级缓存格式，导出复制期间必须保护当前路径。
+            with _image_resource_lock(kwargs["account_dir"], md5):
+                return function(*args, **kwargs)
+        return function(*args, **kwargs)
+    return guarded
+
+
+@_guard_image_materialization
 def _materialize_media(
     *,
     zf: zipfile.ZipFile,
@@ -8915,6 +8930,10 @@ def _materialize_media(
             if index + 1 >= len(parts) or parts[index + 1] != expected:
                 return "", False
 
+    if src and kind == "image":
+        # 导出也要独立修复旧缩略图缓存，不能依赖用户先在聊天页逐张加载大图。
+        src = _prefer_local_image_resource(account_dir, md5, source=src, username=conv_username) or src
+
     if not src:
         if media_index is not None:
             try:
diff --git a/src/wechat_decrypt_tool/media_helpers.py b/src/wechat_decrypt_tool/media_helpers.py
index c19cfe5d..38bfbb7d 100644
--- a/src/wechat_decrypt_tool/media_helpers.py
+++ b/src/wechat_decrypt_tool/media_helpers.py
@@ -3,12 +3,15 @@
 import glob
 import hashlib
 import ipaddress
+import io
 import json
 import mimetypes
 import os
 import re
 import sqlite3
 import struct
+import tempfile
+import threading
 import time
 from dataclasses import dataclass
 from functools import lru_cache
@@ -27,6 +30,239 @@
 
 logger = get_logger(__name__)
 
+# 条带锁限制内存占用，同一资源的比较、写入和预解密状态更新必须串行完成。
+_IMAGE_RESOURCE_LOCKS = tuple(threading.RLock() for _ in range(64))
+
+
+def _image_payload_score(data: bytes, media_type: str = "") -> tuple[int, int]:
+    """按解码后的像素面积比较图片，兼容 JPEG、PNG、GIF 和 WebP。"""
+    try:
+        from PIL import Image
+
+        with Image.open(io.BytesIO(data)) as image:
+            width, height = image.size
+        return int(width) * int(height), len(data)
+    except Exception:
+        # 保留旧数据的启发式读取能力，无法读出尺寸的文件不能压过有效大图。
+        return 0, len(data or b"")
+
+
+def _image_resource_lock(account_dir: Path, md5: str):
+    key = f"{account_dir.resolve()}:{md5.lower()}".encode("utf-8")
+    return _IMAGE_RESOURCE_LOCKS[int.from_bytes(hashlib.sha256(key).digest()[:2], "big") % 64]
+
+
+def _image_file_signature(path: Path) -> list:
+    stat = path.stat()
+    return [path.name, stat.st_size, stat.st_mtime_ns]
+
+
+def _image_source_identity(path: Path, source_key: str) -> str:
+    stat = path.stat()
+    value = f"{path.resolve()}:{stat.st_size}:{stat.st_mtime_ns}:{source_key}"
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def _image_source_state_path(account_dir: Path, md5: str) -> Path:
+    return _get_decrypted_resource_path(account_dir, md5, "sources.json")
+
+
+def _read_image_source_state(account_dir: Path, md5: str, cached: Optional[Path]) -> dict:
+    try:
+        state = json.loads(_image_source_state_path(account_dir, md5).read_text(encoding="utf-8"))
+        if cached and state.get("cache") == _image_file_signature(cached):
+            return state
+    except (OSError, ValueError, TypeError, AttributeError):
+        pass
+    return {"sources": []}
+
+
+def _is_current_image_resource_source(account_dir: Path, md5: str, source: Path, source_key: str) -> bool:
+    """仅跳过已比较过且没有变化的源文件；旧缩略图缓存不能跳过新发现的大图。"""
+    try:
+        with _image_resource_lock(account_dir, md5):
+            cached = _try_find_decrypted_resource(account_dir, md5)
+            state = _read_image_source_state(account_dir, md5, cached)
+            return _image_source_identity(source, source_key) in state.get("sources", [])
+    except OSError:
+        return False
+
+
+def _read_cached_image_resource(account_dir: Path, md5: str) -> tuple[Optional[Path], bytes, str]:
+    """将查找和读取放在同一把锁内，避免并发换格式时旧路径已被清理。"""
+    with _image_resource_lock(account_dir, md5):
+        path = _try_find_decrypted_resource(account_dir, md5)
+        if path is None:
+            return None, b"", "application/octet-stream"
+        try:
+            data = path.read_bytes()
+        except OSError:
+            return None, b"", "application/octet-stream"
+        media_type = _detect_image_media_type(data[:32])
+        valid = media_type.startswith("image/") and _is_probably_valid_image(data, media_type) and len(data) >= 16
+        if not valid and path.suffix.lower() in {".jpg", ".jpeg", ".png", ".gif", ".webp"}:
+            try:
+                path.unlink(missing_ok=True)
+            except OSError:
+                pass
+        return path, data, media_type
+
+
+def _atomic_write_image_file(path: Path, data: bytes) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = None
+    try:
+        with tempfile.NamedTemporaryFile(dir=path.parent, prefix=".image-", suffix=".tmp", delete=False) as stream:
+            temporary = Path(stream.name)
+            stream.write(data)
+        os.replace(temporary, path)
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+
+
+def _save_best_image_resource(
+    account_dir: Path, md5: str, data: bytes, *, source: Optional[Path] = None, source_key: str = ""
+) -> Path:
+    """原子地保存质量最高的缓存，防止并发预解密或后续缩略图请求降低分辨率。"""
+    md5 = str(md5).strip().lower()
+    if not _EMOTICON_MD5_RE.fullmatch(md5):
+        raise ValueError("无效的图片 MD5")
+    media_type = _detect_image_media_type(data[:32])
+    if not media_type.startswith("image/") or not _is_probably_valid_image(data, media_type):
+        raise ValueError("无效的图片内容")
+    with _image_resource_lock(account_dir, md5):
+        existing = _try_find_decrypted_resource(account_dir, md5)
+        state = _read_image_source_state(account_dir, md5, existing)
+        previous_state = json.dumps(state, sort_keys=True)
+        output = _get_decrypted_resource_path(account_dir, md5, _detect_image_extension(data))
+        previous = None
+        if existing:
+            try:
+                previous = existing.read_bytes()
+                previous_type = _detect_image_media_type(previous[:32])
+                if previous_type.startswith("image/") and _is_probably_valid_image(previous, previous_type) and _image_payload_score(previous) >= _image_payload_score(data):
+                    output = existing
+                    data = previous
+            except OSError:
+                pass
+        if output != existing or not existing or data != previous:
+            _atomic_write_image_file(output, data)
+        # 写入完成后再清理旧格式，避免读者看到半写文件或暂时找不到缓存。
+        for ext in ("jpg", "png", "gif", "webp", "dat"):
+            stale = _get_decrypted_resource_path(account_dir, md5, ext)
+            if stale != output:
+                try:
+                    stale.unlink(missing_ok=True)
+                except OSError:
+                    pass
+        if source is not None:
+            identity = _image_source_identity(source, source_key)
+            sources = list(state.get("sources", []))
+            if identity not in sources:
+                sources.append(identity)
+            state["sources"] = sources[-64:]
+        state["cache"] = _image_file_signature(output)
+        if json.dumps(state, sort_keys=True) != previous_state:
+            try:
+                _atomic_write_image_file(_image_source_state_path(account_dir, md5), json.dumps(state).encode("utf-8"))
+            except OSError:
+                # 状态只用于避免重复解密，写入失败不能让已保存的大图不可用。
+                logger.warning("图片质量缓存已保存，但源文件状态未能保存")
+        return output
+
+
+@lru_cache(maxsize=16)
+def _index_image_directory(folder: str, modified_ns: int) -> tuple[dict[str, tuple[str, ...]], bool]:
+    """缓存标准图片目录的文件名索引；目录变化后重建，限制目录数及文件数。"""
+    groups: dict[str, list[str]] = {}
+    truncated = False
+    try:
+        with os.scandir(folder) as entries:
+            for index, entry in enumerate(entries):
+                if index >= 5000:
+                    truncated = True
+                    break
+                path = Path(entry.name)
+                match = re.match(r"(?i)^([0-9a-f]{32})(?:[_.-]|$)", path.stem)
+                if match and path.suffix.lower() in {".dat", ".jpg", ".jpeg", ".png", ".gif", ".webp"} and entry.is_file():
+                    groups.setdefault(match.group(1).lower(), []).append(entry.name)
+    except OSError:
+        pass
+    return {md5: tuple(names) for md5, names in groups.items()}, truncated
+
+
+def _scoped_image_directory_candidates(folder: Path, md5: str) -> list[Path]:
+    try:
+        names, truncated = _index_image_directory(str(folder.resolve()), folder.stat().st_mtime_ns)
+        hits = [folder / name for name in names.get(md5, ())]
+        if truncated:
+            # 极大的单月目录不全部驻留内存，只对当前 MD5 做非递归匹配。
+            hits.extend(
+                path for path in folder.glob(f"{md5}*")
+                if path.suffix.lower() in {".dat", ".jpg", ".jpeg", ".png", ".gif", ".webp"} and path.is_file()
+            )
+        return _order_media_candidates(list(dict.fromkeys(hits)))[:30]
+    except OSError:
+        return []
+
+
+def _prefer_local_image_resource(
+    account_dir: Path, md5: str, *, source: Optional[Path] = None, username: str = ""
+) -> Optional[Path]:
+    """在 hardlink 与当前会话目录内比较本地图片，不联网、不扫描整个账号。"""
+    md5 = str(md5 or "").strip().lower()
+    username = str(username or "").strip()
+    cached = _try_find_decrypted_resource(account_dir, md5) if _EMOTICON_MD5_RE.fullmatch(md5 or "") else None
+    root = _resolve_account_wxid_dir(account_dir)
+    keys = _load_media_keys(account_dir)
+    xor_key = keys.get("xor")
+    source_key = ""
+    if isinstance(xor_key, int) and 0 <= xor_key <= 255:
+        aes_key = str(keys.get("aes") or "").encode("utf-8")[:16]
+        source_key = hashlib.sha256(bytes([xor_key]) + aes_key).hexdigest()
+    live = _resolve_media_path_for_kind(account_dir, "image", md5, username, False, prefer_cache=False) if md5 else None
+    candidates = []
+    for path in (cached, source, live):
+        if path:
+            candidates.extend(_iter_media_source_candidates(path))
+    if root and username and _EMOTICON_MD5_RE.fullmatch(md5 or ""):
+        # 按月使用文件名索引，避免每张缓存图片都递归扫描该会话的所有附件。
+        attach = root / "msg" / "attach" / hashlib.md5(username.encode("utf-8")).hexdigest()
+        if attach.is_dir():
+            folders = [attach / "Img", attach / "img", attach]
+            folders.extend(child / "Img" for child in attach.iterdir() if child.is_dir() and re.fullmatch(r"\d{4}-\d{2}", child.name))
+            for folder in folders:
+                if not folder.is_dir():
+                    continue
+                for path in _scoped_image_directory_candidates(folder, md5):
+                    candidates.extend(_iter_media_source_candidates(path))
+    best_path, best_data, best_score = cached, b"", (-1, -1)
+    for path in dict.fromkeys(candidates):
+        try:
+            if cached and path != cached and source_key and _is_current_image_resource_source(account_dir, md5, path, source_key):
+                # 该原始文件已比较过且缓存未被替换，避免滚动聊天时重复解密数 MB 的 DAT。
+                continue
+            data, media_type = _read_and_maybe_decrypt_media(path, account_dir=account_dir, weixin_root=root)
+            if not media_type.startswith("image/") or not _is_probably_valid_image(data, media_type):
+                continue
+            score = _image_payload_score(data, media_type)
+            if score > best_score:
+                best_path, best_data, best_score = path, data, score
+        except Exception:
+            continue
+    if best_data and _EMOTICON_MD5_RE.fullmatch(md5 or ""):
+        try:
+            return _save_best_image_resource(
+                account_dir, md5, best_data,
+                source=best_path if source_key and best_path != cached else None,
+                source_key=source_key,
+            )
+        except OSError:
+            # 缓存目录不可写时仍可读取或导出本地原图。
+            return best_path
+    return best_path
+
 _MEDIA_INDEX_FILE_EXTS = {
     ".dat",
     ".gif",
@@ -159,7 +395,7 @@ def _normalize_variant_basename(name: str) -> str:
     if not v:
         return ""
     lower = v.lower()
-    for suf in ("_b", "_h", "_c", "_t", ".b", ".h", ".c", ".t"):
+    for suf in ("_thumbnail", ".thumbnail", "_thumb", ".thumb", "_b", "_h", "_c", "_t", ".b", ".h", ".c", ".t"):
         if lower.endswith(suf) and len(lower) > len(suf):
             return lower[: -len(suf)]
     return lower
@@ -239,11 +475,18 @@ def _iter_media_source_candidates(source: Path, *, limit: int = 30) -> list[Path
         except Exception:
             continue
 
+    # 历史缓存也可能按变体命名，必须一起比较，而不能固定先选无后缀的缩略图。
+    for variant in ("", "_b", "_h", "_c", "_t", ".b", ".h", ".c", ".t"):
+        for extension in ("jpg", "jpeg", "png", "gif", "webp"):
+            p = parent / f"{base}{variant}.{extension}"
+            if p.is_file():
+                out.append(p.resolve())
+
     # Add any other local .dat siblings with the same normalized base (limit to avoid explosion).
     try:
         for p in parent.glob(f"{base}*.dat"):
             try:
-                if p.exists() and p.is_file():
+                if p.exists() and p.is_file() and _normalize_variant_basename(p.stem) == base:
                     out.append(p.resolve())
             except Exception:
                 continue
@@ -3614,7 +3857,10 @@ def _collect_all_dat_files(wxid_dir: Path) -> list[tuple[Path, str]]:
                 # 从文件名提取MD5
                 stem = dat_file.stem
                 # 文件名格式可能是: md5.dat, md5_t.dat, md5_h.dat 等
-                md5 = stem.split("_")[0] if "_" in stem else stem
+                md5 = _normalize_variant_basename(stem)
+                if not _EMOTICON_MD5_RE.fullmatch(md5):
+                    # 保留旧版对 MD5_序号/其他后缀的支持，同时识别新增的点号变体。
+                    md5 = stem.split("_", 1)[0]
                 # 验证是否是有效的MD5（32位十六进制）
                 if len(md5) == 32 and all(c in "0123456789abcdefABCDEF" for c in md5):
                     results.append((dat_file, md5.lower()))
@@ -3673,16 +3919,16 @@ def _decrypt_and_save_resource(
                 decrypted = converted
 
         # 检测图片类型
-        ext = _detect_image_extension(decrypted)
         mt = _detect_image_media_type(decrypted[:32])
         if mt == "application/octet-stream":
             # 解密可能失败，跳过
             return False, "解密后非有效图片"
 
         # 保存到resource目录
-        output_path = _get_decrypted_resource_path(account_dir, md5, ext)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        output_path.write_bytes(decrypted)
+        source_key = hashlib.sha256(bytes([xor_key]) + (aes_key or b"")).hexdigest()
+        output_path = _save_best_image_resource(
+            account_dir, md5, decrypted, source=dat_path, source_key=source_key
+        )
 
         return True, str(output_path)
     except Exception as e:
@@ -3843,6 +4089,8 @@ def _resolve_media_path_for_kind(
     md5: str,
     username: Optional[str],
     allow_fallback_scan: bool = True,
+    *,
+    prefer_cache: bool = True,
 ) -> Optional[Path]:
     if not md5:
         return None
@@ -3850,7 +4098,7 @@ def _resolve_media_path_for_kind(
     kind_key = str(kind or "").strip().lower()
 
     # 优先查找解密后的资源目录（图片、表情、视频缩略图）
-    if kind_key in {"image", "emoji", "video_thumb"}:
+    if prefer_cache and kind_key in {"image", "emoji", "video_thumb"}:
         decrypted_path = _try_find_decrypted_resource(account_dir, md5.lower())
         if decrypted_path:
             logger.debug(f"找到解密资源: {decrypted_path}")
diff --git a/src/wechat_decrypt_tool/qwen_gpu_runtime.py b/src/wechat_decrypt_tool/qwen_gpu_runtime.py
new file mode 100644
index 00000000..76f0584e
--- /dev/null
+++ b/src/wechat_decrypt_tool/qwen_gpu_runtime.py
@@ -0,0 +1,305 @@
+"""按需下载 Qwen GPU 组件；只在隔离语音进程中加载，不修改系统 Python。"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import os
+from pathlib import Path
+import platform
+import shutil
+import stat
+import sys
+import threading
+import time
+from urllib.parse import urlparse
+import zipfile
+
+from .app_paths import get_data_dir
+
+MANIFEST_PATH = Path(__file__).parent / "resources/qwen_gpu_runtime.json"
+MODEL_ID = "qwen3-asr-06b-hf"
+_DLL_HANDLES = []
+_MANAGER = None
+_MANAGER_LOCK = threading.Lock()
+logger = logging.getLogger(__name__)
+
+
+def manifest():
+    return json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+
+
+def runtime_root():
+    return get_data_dir() / "voice_runtimes" / manifest()["id"] / f"cp{sys.version_info.major}{sys.version_info.minor}"
+
+
+def runtime_files():
+    return manifest()["variants"].get(f"cp{sys.version_info.major}{sys.version_info.minor}", [])
+
+
+def supported():
+    return sys.platform == "win32" and platform.machine().lower() in {"amd64", "x86_64"} and bool(runtime_files())
+
+
+def installed():
+    root = runtime_root()
+    try:
+        saved = json.loads((root / "installed.json").read_text(encoding="utf-8"))
+        return (saved == dict(id=manifest()["id"], files=runtime_files()) and
+                not root.is_symlink() and (root / "torch/lib/torch_cuda.dll").is_file() and
+                (root / "transformers/__init__.py").is_file())
+    except (OSError, ValueError):
+        return False
+
+
+def activate_for_worker(root=None):
+    """父进程不导入组件；DLL 目录句柄保留到工作进程退出。"""
+    folder = Path(root) if root else runtime_root() if installed() else None
+    if folder is None:
+        return
+    sys.path.insert(0, str(folder))
+    if os.name == "nt":
+        for directory in (folder / "torch/lib", folder / "numpy.libs"):
+            if directory.is_dir():
+                _DLL_HANDLES.append(os.add_dll_directory(str(directory)))
+    # 外置 wheel 的元数据也必须可见，Transformers 会检查其依赖版本。
+    import importlib
+    importlib.invalidate_caches()
+
+
+class Paused(Exception):
+    pass
+
+
+class QwenRuntimeManager:
+    def __init__(self):
+        self.lock = threading.RLock()
+        self.cancelled = threading.Event()
+        self.thread = None
+        self.job_path = get_data_dir() / "voice_runtimes/qwen-job.json"
+        try:
+            self.job = json.loads(self.job_path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            self.job = dict(status="idle", stage="idle", bytes=0, total=0, error="")
+        if self.job.get("status") in {"queued", "running"}:
+            self.job.update(status="paused", stage="paused", error="上次安装已中断，点击继续。")
+
+    def update(self, **values):
+        with self.lock:
+            self.job.update(values, updated=time.time())
+            self.job_path.parent.mkdir(parents=True, exist_ok=True)
+            temporary = self.job_path.with_suffix(".tmp")
+            temporary.write_text(json.dumps(self.job, ensure_ascii=False), encoding="utf-8")
+            temporary.replace(self.job_path)
+
+    def status(self):
+        with self.lock:
+            return dict(installed=installed(), supported=supported(),
+                        size=sum(f["size"] for f in runtime_files()), version=manifest()["id"],
+                        job=dict(self.job), reason="" if supported() else "此组件支持 Windows x64 的 Python 3.11–3.13，请选择 CPU 模型。")
+
+    def start(self):
+        from .runtime_settings import read_effective_voice_transcription_model, read_effective_voice_transcription_device
+        if read_effective_voice_transcription_model()[1] == "env":
+            raise ValueError("语音模型由启动环境变量固定，无法安装并启用其他模型。")
+        device, device_source = read_effective_voice_transcription_device()
+        if device_source == "env" and device != "cuda":
+            raise ValueError("启动环境变量固定为 CPU，无法启用 Qwen GPU，请选择 CPU 模型。")
+        if not supported():
+            raise ValueError(self.status()["reason"])
+        from .local_search.gpu import gpu_devices
+        if not gpu_devices():
+            raise ValueError("未检测到 NVIDIA 显卡，请检查显卡驱动或选择 CPU 模型。")
+        with self.lock:
+            if self.thread and self.thread.is_alive():
+                return self.status()
+            self.cancelled.clear()
+            self.update(status="queued", stage="preparing", error="", bytes=0,
+                        total=sum(f["size"] for f in runtime_files()), modelJobId="")
+            self.thread = threading.Thread(target=self.run, name="qwen-runtime-install", daemon=True)
+            self.thread.start()
+            return self.status()
+
+    def checkpoint(self):
+        if self.cancelled.is_set():
+            raise Paused()
+
+    def pause(self):
+        with self.lock:
+            self.cancelled.set()
+            job_id = self.job.get("modelJobId")
+        if job_id:
+            from .voice_transcription import VOICE_MODEL_DOWNLOAD_MANAGER
+            # 已完成的模型不会删除；暂停时只终止当前尚未完成的模型下载。
+            with VOICE_MODEL_DOWNLOAD_MANAGER._lock:
+                event = VOICE_MODEL_DOWNLOAD_MANAGER._cancel_events.get(job_id)
+                if event:
+                    event.set()
+        return self.status()
+
+    def hash_file(self, path):
+        digest = hashlib.sha256()
+        with path.open("rb") as source:
+            while block := source.read(4 * 1024 * 1024):
+                self.checkpoint()
+                digest.update(block)
+        return digest.hexdigest()
+
+    def download(self, client, item, path, completed):
+        import httpx
+        if urlparse(item["url"]).hostname not in {"files.pythonhosted.org", "download-r2.pytorch.org", "download.pytorch.org"}:
+            raise ValueError("组件下载地址不在固定发布清单中。")
+        for attempt in range(5):
+            self.checkpoint()
+            offset = path.stat().st_size if path.exists() else 0
+            if offset == item["size"]:
+                break
+            if offset > item["size"]:
+                path.unlink()
+                offset = 0
+            try:
+                with client.stream("GET", item["url"], headers={"Range": f"bytes={offset}-"} if offset else {}) as response:
+                    response.raise_for_status()
+                    if response.status_code == 206:
+                        if not response.headers.get("content-range", "").startswith(f"bytes {offset}-"):
+                            raise ValueError("组件下载续传位置不正确，请重试。")
+                    elif offset:
+                        offset = 0
+                    self.update(stage="downloading", file=item["package"], bytes=completed + offset)
+                    last_update = 0.0
+                    with path.open("ab" if offset else "wb") as output:
+                        for block in response.iter_bytes(256 * 1024):
+                            self.checkpoint()
+                            output.write(block)
+                            offset += len(block)
+                            if offset > item["size"]:
+                                raise ValueError("组件下载大小超过清单，请重试。")
+                            if time.monotonic() - last_update > .3:
+                                self.update(bytes=completed + offset)
+                                last_update = time.monotonic()
+                if offset != item["size"]:
+                    raise httpx.ReadError("下载文件不完整")
+                break
+            except httpx.HTTPError:
+                if attempt == 4:
+                    raise ValueError("组件下载失败，检查网络后点击重试；已下载部分会保留。") from None
+                self.update(stage="retry_wait")
+                if self.cancelled.wait(min(15, 2 ** attempt)):
+                    raise Paused()
+        self.update(stage="verifying")
+        if self.hash_file(path) != item["sha256"]:
+            path.unlink(missing_ok=True)
+            raise ValueError("组件校验失败，损坏文件已清除，请重试。")
+
+    def install(self):
+        import httpx
+        root = runtime_root()
+        cache = root.parent / "downloads"
+        cache.mkdir(parents=True, exist_ok=True)
+        stage = root.with_name(root.name + ".staging")
+        # 清理路径必须是此版本下固定的临时目录，且拒绝目录联接。
+        if stage.exists():
+            self.ensure_owned(stage)
+            shutil.rmtree(stage)
+        stage.mkdir()
+        completed = 0
+        with httpx.Client(follow_redirects=True, timeout=30) as client:
+            for item in runtime_files():
+                path = cache / item["name"]
+                self.ensure_owned(path)
+                self.download(client, item, path, completed)
+                self.update(stage="installing", file=item["package"])
+                with zipfile.ZipFile(path) as archive:
+                    for member in archive.infolist():
+                        self.checkpoint()
+                        target = stage / member.filename
+                        if (not target.resolve().is_relative_to(stage.resolve()) or
+                                (member.external_attr >> 16) & 0o170000 == 0o120000):
+                            raise ValueError("组件包含无效文件路径。")
+                        archive.extract(member, stage)
+                completed += item["size"]
+                self.update(bytes=completed)
+        self.checkpoint()
+        self.update(stage="checking_runtime")
+        from .asr_worker import check_qwen_runtime
+        result = check_qwen_runtime(str(stage), cancel_event=self.cancelled)
+        if not result["available"]:
+            raise ValueError(result["reason"])
+        self.checkpoint()
+        (stage / "installed.json").write_text(json.dumps(dict(id=manifest()["id"], files=runtime_files())), encoding="utf-8")
+        if root.exists():
+            self.ensure_owned(root)
+            shutil.rmtree(root)
+        stage.rename(root)
+
+    def ensure_owned(self, path):
+        base = get_data_dir().resolve()
+        if not path.resolve().is_relative_to(base):
+            raise ValueError("组件目录位于应用数据目录之外。")
+        for ancestor in (path, *path.parents):
+            if ancestor == base:
+                break
+            try:
+                reparse = bool(getattr(ancestor.lstat(), "st_file_attributes", 0) & stat.FILE_ATTRIBUTE_REPARSE_POINT)
+            except FileNotFoundError:
+                reparse = False
+            if ancestor.is_symlink() or reparse:
+                raise ValueError("组件目录不能使用符号链接或目录联接。")
+
+    def run(self):
+        try:
+            self.update(status="running")
+            self.ensure_owned(runtime_root())
+            if not installed():
+                needed = sum(f["size"] for f in runtime_files()) * 3
+                get_data_dir().mkdir(parents=True, exist_ok=True)
+                if shutil.disk_usage(get_data_dir()).free < needed:
+                    raise ValueError("磁盘空间不足，组件下载和解压需要约 9 GB 可用空间。")
+                self.install()
+            self.checkpoint()
+            from .voice_transcription import (VOICE_MODEL_DOWNLOAD_MANAGER, inspect_model_readiness,
+                                              set_voice_transcription_model, _managed_voice_model_dir, _legacy_voice_model_dir,
+                                              _model_directory_is_ready)
+            if not inspect_model_readiness(MODEL_ID)["ready"]:
+                model_job = VOICE_MODEL_DOWNLOAD_MANAGER.start(MODEL_ID)
+                self.update(stage="downloading_model", modelJobId=model_job["jobId"])
+                while True:
+                    self.checkpoint()
+                    job = VOICE_MODEL_DOWNLOAD_MANAGER.get(model_job["jobId"])
+                    self.update(modelPercent=job["percent"])
+                    if job["status"] == "done":
+                        break
+                    if job["status"] in {"error", "cancelled"}:
+                        raise ValueError(job["error"] or "模型下载已停止，请重试。")
+                    self.cancelled.wait(.5)
+            self.checkpoint()
+            self.update(stage="checking_model")
+            from .asr_worker import check_qwen_runtime, invalidate_qwen_probe
+            folder = _managed_voice_model_dir(MODEL_ID)
+            if not _model_directory_is_ready(folder, MODEL_ID):
+                folder = _legacy_voice_model_dir(MODEL_ID)
+            result = check_qwen_runtime(folder=str(folder), cancel_event=self.cancelled)
+            if not result["available"]:
+                raise ValueError(result["reason"])
+            # 最后一步才改设置；暂停与启用互斥，失败保留原来的模型。
+            with self.lock:
+                self.checkpoint()
+                invalidate_qwen_probe()
+                set_voice_transcription_model(MODEL_ID)
+                self.update(status="done", stage="done", error="", modelJobId="")
+        except Paused:
+            self.update(status="paused", stage="paused", error="", modelJobId="")
+        except Exception as exc:
+            logger.exception("Qwen GPU 组件准备失败")
+            message = str(exc) if isinstance(exc, ValueError) else getattr(exc, "user_message", "")
+            self.update(status="error", stage="error", error=message or
+                        "GPU 组件安装或加载失败，请重试或选择 CPU 模型。", modelJobId="")
+
+
+def get_qwen_runtime():
+    global _MANAGER
+    with _MANAGER_LOCK:
+        # 测试和用户数据目录变更时，不复用另一个目录的任务。
+        if _MANAGER is None or _MANAGER.job_path.parent != get_data_dir() / "voice_runtimes":
+            _MANAGER = QwenRuntimeManager()
+        return _MANAGER
diff --git a/src/wechat_decrypt_tool/resources/qwen_gpu_runtime.json b/src/wechat_decrypt_tool/resources/qwen_gpu_runtime.json
new file mode 100644
index 00000000..05471ca4
--- /dev/null
+++ b/src/wechat_decrypt_tool/resources/qwen_gpu_runtime.json
@@ -0,0 +1,845 @@
+{
+  "id": "qwen-torch2.9.1-cu128-transformers5.17.0-v1",
+  "platform": "win32",
+  "architecture": "AMD64",
+  "variants": {
+    "cp311": [
+      {
+        "name": "annotated_doc-0.0.5-py3-none-any.whl",
+        "package": "annotated-doc",
+        "version": "0.0.5",
+        "url": "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl",
+        "size": 5302,
+        "sha256": "117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101"
+      },
+      {
+        "name": "anyio-4.14.2-py3-none-any.whl",
+        "package": "anyio",
+        "version": "4.14.2",
+        "url": "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl",
+        "size": 125813,
+        "sha256": "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494"
+      },
+      {
+        "name": "certifi-2025.6.15-py3-none-any.whl",
+        "package": "certifi",
+        "version": "2025.6.15",
+        "url": "https://files.pythonhosted.org/packages/84/ae/320161bd181fc06471eed047ecce67b693fd7515b16d495d8932db763426/certifi-2025.6.15-py3-none-any.whl",
+        "size": 157650,
+        "sha256": "2e0c7ce7cb5d8f8634ca55d2ba7e6ec2689a2fd6537d8dec1296a477a4910057"
+      },
+      {
+        "name": "click-8.5.0-py3-none-any.whl",
+        "package": "click",
+        "version": "8.5.0",
+        "url": "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl",
+        "size": 125251,
+        "sha256": "255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360"
+      },
+      {
+        "name": "colorama-0.4.6-py2.py3-none-any.whl",
+        "package": "colorama",
+        "version": "0.4.6",
+        "url": "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl",
+        "size": 25335,
+        "sha256": "4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"
+      },
+      {
+        "name": "filelock-3.32.3-py3-none-any.whl",
+        "package": "filelock",
+        "version": "3.32.3",
+        "url": "https://files.pythonhosted.org/packages/a7/8e/50f46a9c0ce8d2861a394c1347caae037ea0431d2f67d7feb151cbc4649a/filelock-3.32.3-py3-none-any.whl",
+        "size": 98901,
+        "sha256": "7f0ca4bcc0e181c60dbbd8aa9ab5b120ebb99e4e064e83636340056f833a1f09"
+      },
+      {
+        "name": "fsspec-2026.7.0-py3-none-any.whl",
+        "package": "fsspec",
+        "version": "2026.7.0",
+        "url": "https://files.pythonhosted.org/packages/fd/3c/6a2bf344106328fd04963664a60b9bb6496fc25df8e962fcdc1367285fb9/fsspec-2026.7.0-py3-none-any.whl",
+        "size": 206583,
+        "sha256": "b57ddbafedfaef7018c1ecab32aa200a9d7ca26b77965f64e48b70061249d279"
+      },
+      {
+        "name": "h11-0.16.0-py3-none-any.whl",
+        "package": "h11",
+        "version": "0.16.0",
+        "url": "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl",
+        "size": 37515,
+        "sha256": "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86"
+      },
+      {
+        "name": "hf_xet-1.6.0-cp38-abi3-win_amd64.whl",
+        "package": "hf-xet",
+        "version": "1.6.0",
+        "url": "https://files.pythonhosted.org/packages/98/b7/8c59a66d15205024662f1d66968136f13893f96df1ddc5087e2e281fc95f/hf_xet-1.6.0-cp38-abi3-win_amd64.whl",
+        "size": 4033128,
+        "sha256": "fb4fadde1b2b70bf4c0c14a6dccbe7194b1c28947fefd5bbe3fed9d940676c3b"
+      },
+      {
+        "name": "httpcore-1.0.9-py3-none-any.whl",
+        "package": "httpcore",
+        "version": "1.0.9",
+        "url": "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl",
+        "size": 78784,
+        "sha256": "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55"
+      },
+      {
+        "name": "httpx-0.28.1-py3-none-any.whl",
+        "package": "httpx",
+        "version": "0.28.1",
+        "url": "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl",
+        "size": 73517,
+        "sha256": "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad"
+      },
+      {
+        "name": "huggingface_hub-1.27.0-py3-none-any.whl",
+        "package": "huggingface-hub",
+        "version": "1.27.0",
+        "url": "https://files.pythonhosted.org/packages/de/d8/95b735e183957c1f26d94c52977f09d466d55119cbbc1558ea4975e4c216/huggingface_hub-1.27.0-py3-none-any.whl",
+        "size": 784926,
+        "sha256": "7df6827c2f956c60fbaa64646e979e566db76f619dd0a9729dfb8c5a3eb4f68d"
+      },
+      {
+        "name": "idna-3.19-py3-none-any.whl",
+        "package": "idna",
+        "version": "3.19",
+        "url": "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl",
+        "size": 68550,
+        "sha256": "815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4"
+      },
+      {
+        "name": "jinja2-3.1.6-py3-none-any.whl",
+        "package": "jinja2",
+        "version": "3.1.6",
+        "url": "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl",
+        "size": 134899,
+        "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67"
+      },
+      {
+        "name": "markdown_it_py-4.2.0-py3-none-any.whl",
+        "package": "markdown-it-py",
+        "version": "4.2.0",
+        "url": "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl",
+        "size": 91687,
+        "sha256": "9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a"
+      },
+      {
+        "name": "markupsafe-3.0.3-cp311-cp311-win_amd64.whl",
+        "package": "markupsafe",
+        "version": "3.0.3",
+        "url": "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl",
+        "size": 15077,
+        "sha256": "de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01"
+      },
+      {
+        "name": "mdurl-0.1.2-py3-none-any.whl",
+        "package": "mdurl",
+        "version": "0.1.2",
+        "url": "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl",
+        "size": 9979,
+        "sha256": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"
+      },
+      {
+        "name": "mpmath-1.3.0-py3-none-any.whl",
+        "package": "mpmath",
+        "version": "1.3.0",
+        "url": "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl",
+        "size": 536198,
+        "sha256": "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"
+      },
+      {
+        "name": "networkx-3.6.1-py3-none-any.whl",
+        "package": "networkx",
+        "version": "3.6.1",
+        "url": "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl",
+        "size": 2068504,
+        "sha256": "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762"
+      },
+      {
+        "name": "numpy-2.4.6-cp311-cp311-win_amd64.whl",
+        "package": "numpy",
+        "version": "2.4.6",
+        "url": "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl",
+        "size": 12608406,
+        "sha256": "1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147"
+      },
+      {
+        "name": "packaging-25.0-py3-none-any.whl",
+        "package": "packaging",
+        "version": "25.0",
+        "url": "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl",
+        "size": 66469,
+        "sha256": "29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484"
+      },
+      {
+        "name": "pygments-2.20.0-py3-none-any.whl",
+        "package": "pygments",
+        "version": "2.20.0",
+        "url": "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl",
+        "size": 1231151,
+        "sha256": "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176"
+      },
+      {
+        "name": "PyYAML-6.0.2-cp311-cp311-win_amd64.whl",
+        "package": "pyyaml",
+        "version": "6.0.2",
+        "url": "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl",
+        "size": 161980,
+        "sha256": "e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44"
+      },
+      {
+        "name": "regex-2026.9.3-cp311-cp311-win_amd64.whl",
+        "package": "regex",
+        "version": "2026.9.3",
+        "url": "https://files.pythonhosted.org/packages/e5/da/6a0ac27bacb39aca3452cdd7d1bfc361608ad000cea3e1b0d7dbaa1e2b15/regex-2026.9.3-cp311-cp311-win_amd64.whl",
+        "size": 278007,
+        "sha256": "8c8a63d55cdf3c716225a2f8741a1df7a52b5fa98ac7530165c9cc9b32feabcc"
+      },
+      {
+        "name": "rich-15.0.0-py3-none-any.whl",
+        "package": "rich",
+        "version": "15.0.0",
+        "url": "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl",
+        "size": 310654,
+        "sha256": "33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb"
+      },
+      {
+        "name": "safetensors-0.8.0-cp310-abi3-win_amd64.whl",
+        "package": "safetensors",
+        "version": "0.8.0",
+        "url": "https://files.pythonhosted.org/packages/1b/6d/3fba214c1e5e0f69991677ec3bc17023f0421776975e1de0c682dca475e2/safetensors-0.8.0-cp310-abi3-win_amd64.whl",
+        "size": 355540,
+        "sha256": "096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f"
+      },
+      {
+        "name": "shellingham-1.5.4-py2.py3-none-any.whl",
+        "package": "shellingham",
+        "version": "1.5.4",
+        "url": "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl",
+        "size": 9755,
+        "sha256": "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686"
+      },
+      {
+        "name": "sympy-1.14.0-py3-none-any.whl",
+        "package": "sympy",
+        "version": "1.14.0",
+        "url": "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl",
+        "size": 6299353,
+        "sha256": "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5"
+      },
+      {
+        "name": "tokenizers-0.23.1-cp310-abi3-win_amd64.whl",
+        "package": "tokenizers",
+        "version": "0.23.1",
+        "url": "https://files.pythonhosted.org/packages/97/c9/2553f72aaf65a2797d4229e37fa7fbe38ffbf3e32912d31bdd78b3323e59/tokenizers-0.23.1-cp310-abi3-win_amd64.whl",
+        "size": 2798223,
+        "sha256": "e7bfaf995c1bdbbd21d13539decb6650967013759318627d85daeb7881af16b7"
+      },
+      {
+        "name": "torch-2.9.1+cu128-cp311-cp311-win_amd64.whl",
+        "package": "torch",
+        "version": "2.9.1+cu128",
+        "url": "https://download-r2.pytorch.org/whl/cu128/torch-2.9.1%2Bcu128-cp311-cp311-win_amd64.whl",
+        "size": 2862053760,
+        "sha256": "633005a3700e81b5be0df2a7d3c1d48aced23ed927653797a3bd2b144a3aeeb6"
+      },
+      {
+        "name": "tqdm-4.70.0-py3-none-any.whl",
+        "package": "tqdm",
+        "version": "4.70.0",
+        "url": "https://files.pythonhosted.org/packages/f9/1c/01bfd571a64e7f270e6bab5e33777debe0edc56759233ce84f27dec92d14/tqdm-4.70.0-py3-none-any.whl",
+        "size": 80184,
+        "sha256": "7f585706bfddbdebf89daac705b2dfcc16890130727d3197ca62c732b4310953"
+      },
+      {
+        "name": "transformers-5.17.0-py3-none-any.whl",
+        "package": "transformers",
+        "version": "5.17.0",
+        "url": "https://files.pythonhosted.org/packages/e8/d0/c502b60d684adbd98a8dc7d5bb866842772b816ac4354e4608be240041ae/transformers-5.17.0-py3-none-any.whl",
+        "size": 12295140,
+        "sha256": "78ec1ce21579b38dfb83950a0658cd119f87212a2fcfdff478096ce9d6c03801"
+      },
+      {
+        "name": "typer-0.27.2-py3-none-any.whl",
+        "package": "typer",
+        "version": "0.27.2",
+        "url": "https://files.pythonhosted.org/packages/dc/bf/205d0004930ede8f542fb58f601526fccf4ae7626075ca1e6c4de5d3d652/typer-0.27.2-py3-none-any.whl",
+        "size": 123130,
+        "sha256": "b3a5fc4342d5fc8fda8fc3010b1cf117e9249aab7fae800c2eff62fd3842d97d"
+      },
+      {
+        "name": "typing_extensions-4.14.0-py3-none-any.whl",
+        "package": "typing-extensions",
+        "version": "4.14.0",
+        "url": "https://files.pythonhosted.org/packages/69/e0/552843e0d356fbb5256d21449fa957fa4eff3bbc135a74a691ee70c7c5da/typing_extensions-4.14.0-py3-none-any.whl",
+        "size": 43839,
+        "sha256": "a1514509136dd0b477638fc68d6a91497af5076466ad0fa6c338e44e359944af"
+      }
+    ],
+    "cp312": [
+      {
+        "name": "annotated_doc-0.0.5-py3-none-any.whl",
+        "package": "annotated-doc",
+        "version": "0.0.5",
+        "url": "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl",
+        "size": 5302,
+        "sha256": "117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101"
+      },
+      {
+        "name": "anyio-4.14.2-py3-none-any.whl",
+        "package": "anyio",
+        "version": "4.14.2",
+        "url": "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl",
+        "size": 125813,
+        "sha256": "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494"
+      },
+      {
+        "name": "certifi-2025.6.15-py3-none-any.whl",
+        "package": "certifi",
+        "version": "2025.6.15",
+        "url": "https://files.pythonhosted.org/packages/84/ae/320161bd181fc06471eed047ecce67b693fd7515b16d495d8932db763426/certifi-2025.6.15-py3-none-any.whl",
+        "size": 157650,
+        "sha256": "2e0c7ce7cb5d8f8634ca55d2ba7e6ec2689a2fd6537d8dec1296a477a4910057"
+      },
+      {
+        "name": "click-8.5.0-py3-none-any.whl",
+        "package": "click",
+        "version": "8.5.0",
+        "url": "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl",
+        "size": 125251,
+        "sha256": "255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360"
+      },
+      {
+        "name": "colorama-0.4.6-py2.py3-none-any.whl",
+        "package": "colorama",
+        "version": "0.4.6",
+        "url": "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl",
+        "size": 25335,
+        "sha256": "4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"
+      },
+      {
+        "name": "filelock-3.32.3-py3-none-any.whl",
+        "package": "filelock",
+        "version": "3.32.3",
+        "url": "https://files.pythonhosted.org/packages/a7/8e/50f46a9c0ce8d2861a394c1347caae037ea0431d2f67d7feb151cbc4649a/filelock-3.32.3-py3-none-any.whl",
+        "size": 98901,
+        "sha256": "7f0ca4bcc0e181c60dbbd8aa9ab5b120ebb99e4e064e83636340056f833a1f09"
+      },
+      {
+        "name": "fsspec-2026.7.0-py3-none-any.whl",
+        "package": "fsspec",
+        "version": "2026.7.0",
+        "url": "https://files.pythonhosted.org/packages/fd/3c/6a2bf344106328fd04963664a60b9bb6496fc25df8e962fcdc1367285fb9/fsspec-2026.7.0-py3-none-any.whl",
+        "size": 206583,
+        "sha256": "b57ddbafedfaef7018c1ecab32aa200a9d7ca26b77965f64e48b70061249d279"
+      },
+      {
+        "name": "h11-0.16.0-py3-none-any.whl",
+        "package": "h11",
+        "version": "0.16.0",
+        "url": "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl",
+        "size": 37515,
+        "sha256": "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86"
+      },
+      {
+        "name": "hf_xet-1.6.0-cp38-abi3-win_amd64.whl",
+        "package": "hf-xet",
+        "version": "1.6.0",
+        "url": "https://files.pythonhosted.org/packages/98/b7/8c59a66d15205024662f1d66968136f13893f96df1ddc5087e2e281fc95f/hf_xet-1.6.0-cp38-abi3-win_amd64.whl",
+        "size": 4033128,
+        "sha256": "fb4fadde1b2b70bf4c0c14a6dccbe7194b1c28947fefd5bbe3fed9d940676c3b"
+      },
+      {
+        "name": "httpcore-1.0.9-py3-none-any.whl",
+        "package": "httpcore",
+        "version": "1.0.9",
+        "url": "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl",
+        "size": 78784,
+        "sha256": "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55"
+      },
+      {
+        "name": "httpx-0.28.1-py3-none-any.whl",
+        "package": "httpx",
+        "version": "0.28.1",
+        "url": "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl",
+        "size": 73517,
+        "sha256": "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad"
+      },
+      {
+        "name": "huggingface_hub-1.27.0-py3-none-any.whl",
+        "package": "huggingface-hub",
+        "version": "1.27.0",
+        "url": "https://files.pythonhosted.org/packages/de/d8/95b735e183957c1f26d94c52977f09d466d55119cbbc1558ea4975e4c216/huggingface_hub-1.27.0-py3-none-any.whl",
+        "size": 784926,
+        "sha256": "7df6827c2f956c60fbaa64646e979e566db76f619dd0a9729dfb8c5a3eb4f68d"
+      },
+      {
+        "name": "idna-3.19-py3-none-any.whl",
+        "package": "idna",
+        "version": "3.19",
+        "url": "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl",
+        "size": 68550,
+        "sha256": "815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4"
+      },
+      {
+        "name": "jinja2-3.1.6-py3-none-any.whl",
+        "package": "jinja2",
+        "version": "3.1.6",
+        "url": "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl",
+        "size": 134899,
+        "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67"
+      },
+      {
+        "name": "markdown_it_py-4.2.0-py3-none-any.whl",
+        "package": "markdown-it-py",
+        "version": "4.2.0",
+        "url": "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl",
+        "size": 91687,
+        "sha256": "9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a"
+      },
+      {
+        "name": "markupsafe-3.0.3-cp312-cp312-win_amd64.whl",
+        "package": "markupsafe",
+        "version": "3.0.3",
+        "url": "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl",
+        "size": 15105,
+        "sha256": "26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c"
+      },
+      {
+        "name": "mdurl-0.1.2-py3-none-any.whl",
+        "package": "mdurl",
+        "version": "0.1.2",
+        "url": "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl",
+        "size": 9979,
+        "sha256": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"
+      },
+      {
+        "name": "mpmath-1.3.0-py3-none-any.whl",
+        "package": "mpmath",
+        "version": "1.3.0",
+        "url": "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl",
+        "size": 536198,
+        "sha256": "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"
+      },
+      {
+        "name": "networkx-3.6.1-py3-none-any.whl",
+        "package": "networkx",
+        "version": "3.6.1",
+        "url": "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl",
+        "size": 2068504,
+        "sha256": "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762"
+      },
+      {
+        "name": "numpy-2.5.2-cp312-cp312-win_amd64.whl",
+        "package": "numpy",
+        "version": "2.5.2",
+        "url": "https://files.pythonhosted.org/packages/7f/b9/87fea2769fe1c47c1b5b01d8310772c9d1a85d485de7cf386ef7a3332b02/numpy-2.5.2-cp312-cp312-win_amd64.whl",
+        "size": 12464674,
+        "sha256": "28ac63476ec7651484215ee7fa15a1f78b57c14621f01e392afe17b9a1390ce4"
+      },
+      {
+        "name": "packaging-25.0-py3-none-any.whl",
+        "package": "packaging",
+        "version": "25.0",
+        "url": "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl",
+        "size": 66469,
+        "sha256": "29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484"
+      },
+      {
+        "name": "pygments-2.20.0-py3-none-any.whl",
+        "package": "pygments",
+        "version": "2.20.0",
+        "url": "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl",
+        "size": 1231151,
+        "sha256": "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176"
+      },
+      {
+        "name": "PyYAML-6.0.2-cp312-cp312-win_amd64.whl",
+        "package": "pyyaml",
+        "version": "6.0.2",
+        "url": "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl",
+        "size": 156338,
+        "sha256": "7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8"
+      },
+      {
+        "name": "regex-2026.9.3-cp312-cp312-win_amd64.whl",
+        "package": "regex",
+        "version": "2026.9.3",
+        "url": "https://files.pythonhosted.org/packages/d5/49/4c40cf722d84d60e807a08ef4c3f579216bf97df60c4a1b10be49655d302/regex-2026.9.3-cp312-cp312-win_amd64.whl",
+        "size": 277773,
+        "sha256": "1ba1dbbb93c5c5629c1861763aec5bfa9f05ad24ef450694130e25029ce7bc36"
+      },
+      {
+        "name": "rich-15.0.0-py3-none-any.whl",
+        "package": "rich",
+        "version": "15.0.0",
+        "url": "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl",
+        "size": 310654,
+        "sha256": "33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb"
+      },
+      {
+        "name": "safetensors-0.8.0-cp310-abi3-win_amd64.whl",
+        "package": "safetensors",
+        "version": "0.8.0",
+        "url": "https://files.pythonhosted.org/packages/1b/6d/3fba214c1e5e0f69991677ec3bc17023f0421776975e1de0c682dca475e2/safetensors-0.8.0-cp310-abi3-win_amd64.whl",
+        "size": 355540,
+        "sha256": "096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f"
+      },
+      {
+        "name": "setuptools-80.9.0-py3-none-any.whl",
+        "package": "setuptools",
+        "version": "80.9.0",
+        "url": "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl",
+        "size": 1201486,
+        "sha256": "062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922"
+      },
+      {
+        "name": "shellingham-1.5.4-py2.py3-none-any.whl",
+        "package": "shellingham",
+        "version": "1.5.4",
+        "url": "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl",
+        "size": 9755,
+        "sha256": "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686"
+      },
+      {
+        "name": "sympy-1.14.0-py3-none-any.whl",
+        "package": "sympy",
+        "version": "1.14.0",
+        "url": "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl",
+        "size": 6299353,
+        "sha256": "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5"
+      },
+      {
+        "name": "tokenizers-0.23.1-cp310-abi3-win_amd64.whl",
+        "package": "tokenizers",
+        "version": "0.23.1",
+        "url": "https://files.pythonhosted.org/packages/97/c9/2553f72aaf65a2797d4229e37fa7fbe38ffbf3e32912d31bdd78b3323e59/tokenizers-0.23.1-cp310-abi3-win_amd64.whl",
+        "size": 2798223,
+        "sha256": "e7bfaf995c1bdbbd21d13539decb6650967013759318627d85daeb7881af16b7"
+      },
+      {
+        "name": "torch-2.9.1+cu128-cp312-cp312-win_amd64.whl",
+        "package": "torch",
+        "version": "2.9.1+cu128",
+        "url": "https://download-r2.pytorch.org/whl/cu128/torch-2.9.1%2Bcu128-cp312-cp312-win_amd64.whl",
+        "size": 2862033275,
+        "sha256": "3a01f0b64c10a82d444d9fd06b3e8c567b1158b76b2764b8f51bfd8f535064b0"
+      },
+      {
+        "name": "tqdm-4.70.0-py3-none-any.whl",
+        "package": "tqdm",
+        "version": "4.70.0",
+        "url": "https://files.pythonhosted.org/packages/f9/1c/01bfd571a64e7f270e6bab5e33777debe0edc56759233ce84f27dec92d14/tqdm-4.70.0-py3-none-any.whl",
+        "size": 80184,
+        "sha256": "7f585706bfddbdebf89daac705b2dfcc16890130727d3197ca62c732b4310953"
+      },
+      {
+        "name": "transformers-5.17.0-py3-none-any.whl",
+        "package": "transformers",
+        "version": "5.17.0",
+        "url": "https://files.pythonhosted.org/packages/e8/d0/c502b60d684adbd98a8dc7d5bb866842772b816ac4354e4608be240041ae/transformers-5.17.0-py3-none-any.whl",
+        "size": 12295140,
+        "sha256": "78ec1ce21579b38dfb83950a0658cd119f87212a2fcfdff478096ce9d6c03801"
+      },
+      {
+        "name": "typer-0.27.2-py3-none-any.whl",
+        "package": "typer",
+        "version": "0.27.2",
+        "url": "https://files.pythonhosted.org/packages/dc/bf/205d0004930ede8f542fb58f601526fccf4ae7626075ca1e6c4de5d3d652/typer-0.27.2-py3-none-any.whl",
+        "size": 123130,
+        "sha256": "b3a5fc4342d5fc8fda8fc3010b1cf117e9249aab7fae800c2eff62fd3842d97d"
+      },
+      {
+        "name": "typing_extensions-4.14.0-py3-none-any.whl",
+        "package": "typing-extensions",
+        "version": "4.14.0",
+        "url": "https://files.pythonhosted.org/packages/69/e0/552843e0d356fbb5256d21449fa957fa4eff3bbc135a74a691ee70c7c5da/typing_extensions-4.14.0-py3-none-any.whl",
+        "size": 43839,
+        "sha256": "a1514509136dd0b477638fc68d6a91497af5076466ad0fa6c338e44e359944af"
+      }
+    ],
+    "cp313": [
+      {
+        "name": "annotated_doc-0.0.5-py3-none-any.whl",
+        "package": "annotated-doc",
+        "version": "0.0.5",
+        "url": "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl",
+        "size": 5302,
+        "sha256": "117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101"
+      },
+      {
+        "name": "anyio-4.14.2-py3-none-any.whl",
+        "package": "anyio",
+        "version": "4.14.2",
+        "url": "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl",
+        "size": 125813,
+        "sha256": "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494"
+      },
+      {
+        "name": "certifi-2025.6.15-py3-none-any.whl",
+        "package": "certifi",
+        "version": "2025.6.15",
+        "url": "https://files.pythonhosted.org/packages/84/ae/320161bd181fc06471eed047ecce67b693fd7515b16d495d8932db763426/certifi-2025.6.15-py3-none-any.whl",
+        "size": 157650,
+        "sha256": "2e0c7ce7cb5d8f8634ca55d2ba7e6ec2689a2fd6537d8dec1296a477a4910057"
+      },
+      {
+        "name": "click-8.5.0-py3-none-any.whl",
+        "package": "click",
+        "version": "8.5.0",
+        "url": "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl",
+        "size": 125251,
+        "sha256": "255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360"
+      },
+      {
+        "name": "colorama-0.4.6-py2.py3-none-any.whl",
+        "package": "colorama",
+        "version": "0.4.6",
+        "url": "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl",
+        "size": 25335,
+        "sha256": "4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"
+      },
+      {
+        "name": "filelock-3.32.3-py3-none-any.whl",
+        "package": "filelock",
+        "version": "3.32.3",
+        "url": "https://files.pythonhosted.org/packages/a7/8e/50f46a9c0ce8d2861a394c1347caae037ea0431d2f67d7feb151cbc4649a/filelock-3.32.3-py3-none-any.whl",
+        "size": 98901,
+        "sha256": "7f0ca4bcc0e181c60dbbd8aa9ab5b120ebb99e4e064e83636340056f833a1f09"
+      },
+      {
+        "name": "fsspec-2026.7.0-py3-none-any.whl",
+        "package": "fsspec",
+        "version": "2026.7.0",
+        "url": "https://files.pythonhosted.org/packages/fd/3c/6a2bf344106328fd04963664a60b9bb6496fc25df8e962fcdc1367285fb9/fsspec-2026.7.0-py3-none-any.whl",
+        "size": 206583,
+        "sha256": "b57ddbafedfaef7018c1ecab32aa200a9d7ca26b77965f64e48b70061249d279"
+      },
+      {
+        "name": "h11-0.16.0-py3-none-any.whl",
+        "package": "h11",
+        "version": "0.16.0",
+        "url": "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl",
+        "size": 37515,
+        "sha256": "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86"
+      },
+      {
+        "name": "hf_xet-1.6.0-cp38-abi3-win_amd64.whl",
+        "package": "hf-xet",
+        "version": "1.6.0",
+        "url": "https://files.pythonhosted.org/packages/98/b7/8c59a66d15205024662f1d66968136f13893f96df1ddc5087e2e281fc95f/hf_xet-1.6.0-cp38-abi3-win_amd64.whl",
+        "size": 4033128,
+        "sha256": "fb4fadde1b2b70bf4c0c14a6dccbe7194b1c28947fefd5bbe3fed9d940676c3b"
+      },
+      {
+        "name": "httpcore-1.0.9-py3-none-any.whl",
+        "package": "httpcore",
+        "version": "1.0.9",
+        "url": "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl",
+        "size": 78784,
+        "sha256": "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55"
+      },
+      {
+        "name": "httpx-0.28.1-py3-none-any.whl",
+        "package": "httpx",
+        "version": "0.28.1",
+        "url": "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl",
+        "size": 73517,
+        "sha256": "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad"
+      },
+      {
+        "name": "huggingface_hub-1.27.0-py3-none-any.whl",
+        "package": "huggingface-hub",
+        "version": "1.27.0",
+        "url": "https://files.pythonhosted.org/packages/de/d8/95b735e183957c1f26d94c52977f09d466d55119cbbc1558ea4975e4c216/huggingface_hub-1.27.0-py3-none-any.whl",
+        "size": 784926,
+        "sha256": "7df6827c2f956c60fbaa64646e979e566db76f619dd0a9729dfb8c5a3eb4f68d"
+      },
+      {
+        "name": "idna-3.19-py3-none-any.whl",
+        "package": "idna",
+        "version": "3.19",
+        "url": "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl",
+        "size": 68550,
+        "sha256": "815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4"
+      },
+      {
+        "name": "jinja2-3.1.6-py3-none-any.whl",
+        "package": "jinja2",
+        "version": "3.1.6",
+        "url": "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl",
+        "size": 134899,
+        "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67"
+      },
+      {
+        "name": "markdown_it_py-4.2.0-py3-none-any.whl",
+        "package": "markdown-it-py",
+        "version": "4.2.0",
+        "url": "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl",
+        "size": 91687,
+        "sha256": "9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a"
+      },
+      {
+        "name": "markupsafe-3.0.3-cp313-cp313-win_amd64.whl",
+        "package": "markupsafe",
+        "version": "3.0.3",
+        "url": "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl",
+        "size": 15113,
+        "sha256": "9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5"
+      },
+      {
+        "name": "mdurl-0.1.2-py3-none-any.whl",
+        "package": "mdurl",
+        "version": "0.1.2",
+        "url": "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl",
+        "size": 9979,
+        "sha256": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"
+      },
+      {
+        "name": "mpmath-1.3.0-py3-none-any.whl",
+        "package": "mpmath",
+        "version": "1.3.0",
+        "url": "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl",
+        "size": 536198,
+        "sha256": "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"
+      },
+      {
+        "name": "networkx-3.6.1-py3-none-any.whl",
+        "package": "networkx",
+        "version": "3.6.1",
+        "url": "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl",
+        "size": 2068504,
+        "sha256": "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762"
+      },
+      {
+        "name": "numpy-2.5.2-cp313-cp313-win_amd64.whl",
+        "package": "numpy",
+        "version": "2.5.2",
+        "url": "https://files.pythonhosted.org/packages/15/20/f3489f86d81ea460b2bcdceaed094142ca6579f6be0ec527b781d39afe68/numpy-2.5.2-cp313-cp313-win_amd64.whl",
+        "size": 12460532,
+        "sha256": "85aaccb24182c25df891ad0ec333585967e115269d5f1b17f2c9ae005bc96657"
+      },
+      {
+        "name": "packaging-25.0-py3-none-any.whl",
+        "package": "packaging",
+        "version": "25.0",
+        "url": "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl",
+        "size": 66469,
+        "sha256": "29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484"
+      },
+      {
+        "name": "pygments-2.20.0-py3-none-any.whl",
+        "package": "pygments",
+        "version": "2.20.0",
+        "url": "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl",
+        "size": 1231151,
+        "sha256": "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176"
+      },
+      {
+        "name": "PyYAML-6.0.2-cp313-cp313-win_amd64.whl",
+        "package": "pyyaml",
+        "version": "6.0.2",
+        "url": "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl",
+        "size": 156446,
+        "sha256": "8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563"
+      },
+      {
+        "name": "regex-2026.9.3-cp313-cp313-win_amd64.whl",
+        "package": "regex",
+        "version": "2026.9.3",
+        "url": "https://files.pythonhosted.org/packages/6d/25/6d20a309c2e4b554cc33579dd55b0bb50d0c2ace7ce6f084be2327c330fc/regex-2026.9.3-cp313-cp313-win_amd64.whl",
+        "size": 277741,
+        "sha256": "185c1ae881856208dda05708b6c908aff76878e59c998c8548d365c1bbcaf1bd"
+      },
+      {
+        "name": "rich-15.0.0-py3-none-any.whl",
+        "package": "rich",
+        "version": "15.0.0",
+        "url": "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl",
+        "size": 310654,
+        "sha256": "33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb"
+      },
+      {
+        "name": "safetensors-0.8.0-cp310-abi3-win_amd64.whl",
+        "package": "safetensors",
+        "version": "0.8.0",
+        "url": "https://files.pythonhosted.org/packages/1b/6d/3fba214c1e5e0f69991677ec3bc17023f0421776975e1de0c682dca475e2/safetensors-0.8.0-cp310-abi3-win_amd64.whl",
+        "size": 355540,
+        "sha256": "096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f"
+      },
+      {
+        "name": "setuptools-80.9.0-py3-none-any.whl",
+        "package": "setuptools",
+        "version": "80.9.0",
+        "url": "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl",
+        "size": 1201486,
+        "sha256": "062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922"
+      },
+      {
+        "name": "shellingham-1.5.4-py2.py3-none-any.whl",
+        "package": "shellingham",
+        "version": "1.5.4",
+        "url": "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl",
+        "size": 9755,
+        "sha256": "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686"
+      },
+      {
+        "name": "sympy-1.14.0-py3-none-any.whl",
+        "package": "sympy",
+        "version": "1.14.0",
+        "url": "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl",
+        "size": 6299353,
+        "sha256": "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5"
+      },
+      {
+        "name": "tokenizers-0.23.1-cp310-abi3-win_amd64.whl",
+        "package": "tokenizers",
+        "version": "0.23.1",
+        "url": "https://files.pythonhosted.org/packages/97/c9/2553f72aaf65a2797d4229e37fa7fbe38ffbf3e32912d31bdd78b3323e59/tokenizers-0.23.1-cp310-abi3-win_amd64.whl",
+        "size": 2798223,
+        "sha256": "e7bfaf995c1bdbbd21d13539decb6650967013759318627d85daeb7881af16b7"
+      },
+      {
+        "name": "torch-2.9.1+cu128-cp313-cp313-win_amd64.whl",
+        "package": "torch",
+        "version": "2.9.1+cu128",
+        "url": "https://download-r2.pytorch.org/whl/cu128/torch-2.9.1%2Bcu128-cp313-cp313-win_amd64.whl",
+        "size": 2862036321,
+        "sha256": "ad9183864acdd99fc5143d7ca9d3d2e7ddfc9a9600ff43217825d4e5e9855ccc"
+      },
+      {
+        "name": "tqdm-4.70.0-py3-none-any.whl",
+        "package": "tqdm",
+        "version": "4.70.0",
+        "url": "https://files.pythonhosted.org/packages/f9/1c/01bfd571a64e7f270e6bab5e33777debe0edc56759233ce84f27dec92d14/tqdm-4.70.0-py3-none-any.whl",
+        "size": 80184,
+        "sha256": "7f585706bfddbdebf89daac705b2dfcc16890130727d3197ca62c732b4310953"
+      },
+      {
+        "name": "transformers-5.17.0-py3-none-any.whl",
+        "package": "transformers",
+        "version": "5.17.0",
+        "url": "https://files.pythonhosted.org/packages/e8/d0/c502b60d684adbd98a8dc7d5bb866842772b816ac4354e4608be240041ae/transformers-5.17.0-py3-none-any.whl",
+        "size": 12295140,
+        "sha256": "78ec1ce21579b38dfb83950a0658cd119f87212a2fcfdff478096ce9d6c03801"
+      },
+      {
+        "name": "typer-0.27.2-py3-none-any.whl",
+        "package": "typer",
+        "version": "0.27.2",
+        "url": "https://files.pythonhosted.org/packages/dc/bf/205d0004930ede8f542fb58f601526fccf4ae7626075ca1e6c4de5d3d652/typer-0.27.2-py3-none-any.whl",
+        "size": 123130,
+        "sha256": "b3a5fc4342d5fc8fda8fc3010b1cf117e9249aab7fae800c2eff62fd3842d97d"
+      },
+      {
+        "name": "typing_extensions-4.14.0-py3-none-any.whl",
+        "package": "typing-extensions",
+        "version": "4.14.0",
+        "url": "https://files.pythonhosted.org/packages/69/e0/552843e0d356fbb5256d21449fa957fa4eff3bbc135a74a691ee70c7c5da/typing_extensions-4.14.0-py3-none-any.whl",
+        "size": 43839,
+        "sha256": "a1514509136dd0b477638fc68d6a91497af5076466ad0fa6c338e44e359944af"
+      }
+    ]
+  }
+}
diff --git a/src/wechat_decrypt_tool/routers/chat.py b/src/wechat_decrypt_tool/routers/chat.py
index 3795f965..ece6f29b 100644
--- a/src/wechat_decrypt_tool/routers/chat.py
+++ b/src/wechat_decrypt_tool/routers/chat.py
@@ -4053,12 +4053,12 @@ def _postprocess_full_messages(
                     if md5:
                         m["imageUrl"] = (
                             base_url
-                            + f"/api/chat/media/image?account={quote(account_dir.name)}&md5={quote(md5)}&username={quote(username)}"
+                            + f"/api/chat/media/image?account={quote(account_dir.name)}&md5={quote(md5)}&username={quote(username)}&v=local-quality-1"
                         )
                     elif file_id:
                         m["imageUrl"] = (
                             base_url
-                            + f"/api/chat/media/image?account={quote(account_dir.name)}&file_id={quote(file_id)}&username={quote(username)}"
+                            + f"/api/chat/media/image?account={quote(account_dir.name)}&file_id={quote(file_id)}&username={quote(username)}&v=local-quality-1"
                         )
             elif rt == "emoji":
                 md5 = str(m.get("emojiMd5") or "")
@@ -4141,7 +4141,7 @@ def _postprocess_full_messages(
                         file_id = f"{lid}_{ct}"
                         m["thumbUrl"] = (
                             base_url
-                            + f"/api/chat/media/image?account={quote(account_dir.name)}&file_id={quote(file_id)}&username={quote(username)}"
+                            + f"/api/chat/media/image?account={quote(account_dir.name)}&file_id={quote(file_id)}&username={quote(username)}&v=local-quality-1"
                         )
             elif rt == "voice":
                 if str(m.get("serverId") or ""):
@@ -7449,12 +7449,12 @@ def sort_key(m: dict[str, Any]) -> tuple[int, int, int]:
                     if md5:
                         m["imageUrl"] = (
                             base_url
-                            + f"/api/chat/media/image?account={quote(account_dir.name)}&md5={quote(md5)}&username={quote(username)}"
+                            + f"/api/chat/media/image?account={quote(account_dir.name)}&md5={quote(md5)}&username={quote(username)}&v=local-quality-1"
                         )
                     elif file_id:
                         m["imageUrl"] = (
                             base_url
-                            + f"/api/chat/media/image?account={quote(account_dir.name)}&file_id={quote(file_id)}&username={quote(username)}"
+                            + f"/api/chat/media/image?account={quote(account_dir.name)}&file_id={quote(file_id)}&username={quote(username)}&v=local-quality-1"
                         )
             elif rt == "emoji":
                 md5 = str(m.get("emojiMd5") or "")
@@ -7532,7 +7532,7 @@ def sort_key(m: dict[str, Any]) -> tuple[int, int, int]:
                         file_id = f"{lid}_{ct}"
                         m["thumbUrl"] = (
                             base_url
-                            + f"/api/chat/media/image?account={quote(account_dir.name)}&file_id={quote(file_id)}&username={quote(username)}"
+                            + f"/api/chat/media/image?account={quote(account_dir.name)}&file_id={quote(file_id)}&username={quote(username)}&v=local-quality-1"
                         )
             elif rt == "voice":
                 if str(m.get("serverId") or ""):
diff --git a/src/wechat_decrypt_tool/routers/chat_media.py b/src/wechat_decrypt_tool/routers/chat_media.py
index cc3473ae..46e98492 100644
--- a/src/wechat_decrypt_tool/routers/chat_media.py
+++ b/src/wechat_decrypt_tool/routers/chat_media.py
@@ -51,6 +51,10 @@
     _get_resource_dir,
     _guess_media_type_by_path,
     _is_probably_valid_image,
+    _image_payload_score,
+    _prefer_local_image_resource,
+    _save_best_image_resource,
+    _read_cached_image_resource,
     _iter_emoji_source_candidates,
     _iter_media_source_candidates,
     _order_media_candidates,
@@ -445,6 +449,9 @@ def _build_cached_media_response(request: Optional[Request], data: bytes, media_
     payload = bytes(data or b"")
     etag = f'"{hashlib.sha1(payload).hexdigest()}"'
     cache_control = f"private, max-age={CHAT_MEDIA_BROWSER_CACHE_SECONDS}"
+    if media_type.startswith("image/"):
+        # ETag 保留浏览器缓存，但每次重新显示都验证本地是否已有更高分辨率版本。
+        cache_control = "private, max-age=0, must-revalidate"
     headers = {
         "Cache-Control": cache_control,
         "ETag": etag,
@@ -485,105 +492,12 @@ def _is_probable_large_image_source(path: Path) -> bool:
     return _image_candidate_variant_rank(path) <= 2
 
 
-def _image_candidate_stat(path: Optional[Path]) -> tuple[int, float]:
-    if not path:
-        return 0, 0.0
-    try:
-        st = path.stat()
-        return int(st.st_size), float(st.st_mtime)
-    except Exception:
-        return 0, 0.0
-
-
-def _should_prefer_live_image_candidates(
-    *,
-    cached_path: Optional[Path],
-    live_candidates: list[Path],
-) -> bool:
-    if not live_candidates:
-        return False
-    if not cached_path:
-        return True
-
-    best_live = live_candidates[0]
-    live_rank = _image_candidate_variant_rank(best_live)
-    if live_rank < 2:
-        return True
-
-    cache_size, cache_mtime = _image_candidate_stat(cached_path)
-    live_size, live_mtime = _image_candidate_stat(best_live)
-    if live_rank == 2 and live_size > cache_size:
-        return True
-    if live_rank == 2 and live_size >= cache_size and live_mtime > cache_mtime:
-        return True
-    return False
-
-
-def _detect_image_payload_dimensions(data: bytes, media_type: str) -> tuple[int, int]:
-    payload = bytes(data or b"")
-    mt = str(media_type or "").strip().lower()
-    try:
-        if mt == "image/png" and len(payload) >= 24 and payload.startswith(b"\x89PNG\r\n\x1a\n"):
-            return int.from_bytes(payload[16:20], "big"), int.from_bytes(payload[20:24], "big")
-        if mt == "image/gif" and len(payload) >= 10 and payload.startswith((b"GIF87a", b"GIF89a")):
-            return int.from_bytes(payload[6:8], "little"), int.from_bytes(payload[8:10], "little")
-        if mt == "image/jpeg" and len(payload) >= 4 and payload.startswith(b"\xff\xd8"):
-            i = 2
-            while i < len(payload) - 9:
-                if payload[i] != 0xFF:
-                    i += 1
-                    continue
-                marker = payload[i + 1]
-                i += 2
-                if marker in (0xD8, 0xD9):
-                    continue
-                if i + 2 > len(payload):
-                    break
-                seg_len = int.from_bytes(payload[i : i + 2], "big")
-                if seg_len < 2:
-                    break
-                if 0xC0 <= marker <= 0xCF and marker not in (0xC4, 0xC8, 0xCC):
-                    if i + 7 <= len(payload):
-                        return int.from_bytes(payload[i + 5 : i + 7], "big"), int.from_bytes(payload[i + 3 : i + 5], "big")
-                    break
-                i += seg_len
-    except Exception:
-        return 0, 0
-    return 0, 0
-
-
-def _image_payload_score(data: bytes, media_type: str) -> tuple[int, int]:
-    width, height = _detect_image_payload_dimensions(data, media_type)
-    area = int(width or 0) * int(height or 0)
-    return area, len(data or b"")
-
-
 def _write_cached_chat_image(account_dir: Path, md5: str, data: bytes) -> None:
     md5_norm = str(md5 or "").strip().lower()
     if (not md5_norm) or (not data):
         return
 
-    ext = _detect_image_extension(data)
-    out_path = _get_decrypted_resource_path(account_dir, md5_norm, ext)
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-
-    for stale_ext in ("jpg", "png", "gif", "webp", "dat"):
-        stale_path = _get_decrypted_resource_path(account_dir, md5_norm, stale_ext)
-        if stale_path == out_path:
-            continue
-        try:
-            if stale_path.exists():
-                stale_path.unlink()
-        except Exception:
-            pass
-
-    try:
-        if out_path.exists() and out_path.read_bytes() == data:
-            return
-    except Exception:
-        pass
-
-    out_path.write_bytes(data)
+    _save_best_image_resource(account_dir, md5_norm, data)
 
 
 def _resolve_avatar_remote_url(
@@ -2653,7 +2567,9 @@ async def get_chat_image(
     # md5 模式：优先检查解密资源目录；如果微信目录里已经有更高质量版本，会在后面自动升级。
     if md5:
         cache_started_at = time.perf_counter()
-        decrypted_path = _try_find_decrypted_resource(account_dir, str(md5).lower())
+        decrypted_path, data, media_type = await asyncio.to_thread(
+            _read_cached_image_resource, account_dir, str(md5).lower()
+        )
         trace(
             "decrypted-cache:path-lookup",
             hasPath=bool(decrypted_path),
@@ -2662,8 +2578,6 @@ async def get_chat_image(
         )
         if decrypted_path:
             read_started_at = time.perf_counter()
-            data = decrypted_path.read_bytes()
-            media_type = _detect_image_media_type(data[:32])
             valid_image = bool(
                 media_type != "application/octet-stream"
                 and _is_probably_valid_image(data, media_type)
@@ -2681,12 +2595,6 @@ async def get_chat_image(
                 cached_path = decrypted_path
                 cached_data = data
                 cached_media_type = media_type
-            # Corrupted cached file (e.g. wrong ext / partial data): remove and regenerate from source.
-            elif decrypted_path.suffix.lower() in {".jpg", ".jpeg", ".png", ".gif", ".webp"}:
-                try:
-                    decrypted_path.unlink()
-                except Exception:
-                    pass
     trace(
         "decrypted-cache:checked",
         hasCachedPath=bool(cached_path),
@@ -2694,14 +2602,29 @@ async def get_chat_image(
         cachedMediaType=cached_media_type,
     )
 
-    if cached_path and (not prefer_live) and (not fetch_remote):
-        trace(
-            "response:ready",
-            result="decrypted-cache-hit",
-            mediaType=cached_media_type,
-            bytes=len(cached_data or b""),
+    if md5 and (not prefer_live) and (not fetch_remote) and not (record_attach or record_index_path):
+        # 旧预解密缓存可能只有 120×120；先比较当前会话或 hardlink 指向的本地变体。
+        upgraded = await asyncio.to_thread(
+            _prefer_local_image_resource, account_dir, str(md5), source=cached_path, username=str(username or "")
         )
-        return _build_cached_media_response(request, cached_data, cached_media_type)
+        if upgraded:
+            if upgraded.is_relative_to(_get_resource_dir(account_dir)):
+                _, latest_data, latest_type = await asyncio.to_thread(_read_cached_image_resource, account_dir, str(md5))
+            else:
+                latest_data, latest_type = await asyncio.to_thread(
+                    _read_and_maybe_decrypt_media, upgraded, account_dir=account_dir
+                )
+            if latest_type.startswith("image/") and _is_probably_valid_image(latest_data, latest_type):
+                cached_path = upgraded
+                cached_data, cached_media_type = latest_data, latest_type
+        if cached_path:
+            trace(
+                "response:ready",
+                result="decrypted-cache-hit",
+                mediaType=cached_media_type,
+                bytes=len(cached_data or b""),
+            )
+            return _build_cached_media_response(request, cached_data, cached_media_type)
 
     # 回退：从微信数据目录实时定位并解密
     roots_started_at = time.perf_counter()
@@ -2728,6 +2651,8 @@ async def get_chat_image(
         roots.append(db_storage_dir)
 
     if not roots:
+        if cached_path and not fetch_remote:
+            return _build_cached_media_response(request, cached_data, cached_media_type)
         raise HTTPException(
             status_code=404,
             detail="wxid_dir/db_storage_path not found. Please decrypt with db_storage_path to enable media lookup.",
@@ -3009,10 +2934,7 @@ async def fetch_cdn_original() -> tuple[bytes, str] | None:
             seen_live.add(key)
             live_candidates.append(candidate)
 
-        if _should_prefer_live_image_candidates(cached_path=cached_path, live_candidates=live_candidates):
-            candidates = [*live_candidates, cached_path]
-        else:
-            candidates = [cached_path, *live_candidates]
+        candidates = [cached_path, *live_candidates]
 
     logger.info(f"chat_image: md5={md5} file_id={file_id} candidates={len(candidates)} first={p}")
 
@@ -3077,7 +2999,7 @@ async def fetch_cdn_original() -> tuple[bytes, str] | None:
                 source_key = str(src_path)
             if source_key != cached_candidate_key and _is_probable_large_image_source(src_path):
                 local_large_found = True
-            if prefer_live or fetch_remote:
+            if media_type.startswith("image/"):
                 score = _image_payload_score(data, media_type)
                 if best_score is None or score > best_score:
                     best_score = score
@@ -3088,7 +3010,7 @@ async def fetch_cdn_original() -> tuple[bytes, str] | None:
             chosen = src_path
             break
 
-    if (prefer_live or fetch_remote) and best_chosen is not None:
+    if best_chosen is not None:
         chosen = best_chosen
         data = best_data
         media_type = best_media_type
@@ -3787,6 +3709,27 @@ async def download_chat_voice_transcription_model(model: str, request: Request):
         ) from exc
 
 
+@router.post("/api/chat/media/voice/transcription/qwen-gpu/{action}", summary="安装或暂停 Qwen GPU 组件并启用模型")
+async def prepare_qwen_gpu(action: str, request: Request):
+    _require_local_voice_mutation(request)
+    from ..qwen_gpu_runtime import get_qwen_runtime
+    manager = get_qwen_runtime()
+    try:
+        if action == "prepare":
+            return await asyncio.to_thread(manager.start)
+        if action == "pause":
+            return manager.pause()
+        raise ValueError("不支持的 GPU 组件操作。")
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail={"code": "qwen_runtime_unavailable", "message": str(exc)}) from None
+
+
+@router.get("/api/chat/media/voice/transcription/qwen-gpu/status", summary="查询 Qwen GPU 组件安装进度")
+async def qwen_gpu_status():
+    from ..qwen_gpu_runtime import get_qwen_runtime
+    return get_qwen_runtime().status()
+
+
 @router.get("/api/chat/media/voice/transcription/models/downloads/{job_id}", summary="查询语音模型下载任务")
 async def get_chat_voice_transcription_model_download(job_id: str):
     try:
diff --git a/src/wechat_decrypt_tool/routers/media.py b/src/wechat_decrypt_tool/routers/media.py
index e5a9e38e..a4c6deb0 100644
--- a/src/wechat_decrypt_tool/routers/media.py
+++ b/src/wechat_decrypt_tool/routers/media.py
@@ -1,5 +1,6 @@
 import asyncio
 import concurrent.futures
+import hashlib
 import json
 import time
 from pathlib import Path
@@ -18,6 +19,7 @@
     _detect_image_extension,
     _detect_image_media_type,
     _is_probably_valid_image,
+    _is_current_image_resource_source,
     _get_resource_dir,
     _load_media_keys,
     _resolve_account_dir,
@@ -296,9 +298,9 @@ async def decrypt_all_media(request: MediaDecryptRequest):
     resource_dir.mkdir(parents=True, exist_ok=True)
 
     for dat_path, md5 in dat_files:
-        # 检查是否已解密
-        existing = _try_find_decrypted_resource(account_dir, md5)
-        if existing:
+        # 只有该源文件已经参与质量比较且未变化时才能跳过，旧缓存不代表原图已处理。
+        source_key = hashlib.sha256(bytes([xor_key_int]) + (aes_key16 or b"")).hexdigest()
+        if _is_current_image_resource_source(account_dir, md5, dat_path, source_key):
             skip_count += 1
             continue
 
@@ -546,8 +548,8 @@ def process_one(item_index: int, dat_path: Path, md5: str, worker_id: int) -> di
                 file_name = dat_path.name
                 item_started_at = time.perf_counter()
                 cache_started_at = time.perf_counter()
-                existing = _try_find_decrypted_resource(account_dir, md5)
-                if existing and _is_valid_cached_image(existing):
+                source_key = hashlib.sha256(bytes([xor_key_int]) + (aes_key16 or b"")).hexdigest()
+                if _is_current_image_resource_source(account_dir, md5, dat_path, source_key):
                     return {
                         "item_index": item_index,
                         "worker_id": worker_id,
@@ -559,11 +561,6 @@ def process_one(item_index: int, dat_path: Path, md5: str, worker_id: int) -> di
                         "decrypt_ms": 0.0,
                         "elapsed_ms": round((time.perf_counter() - item_started_at) * 1000, 1),
                     }
-                if existing:
-                    try:
-                        existing.unlink(missing_ok=True)
-                    except Exception:
-                        pass
                 cache_elapsed_ms = round((time.perf_counter() - cache_started_at) * 1000, 1)
 
                 decrypt_started_at = time.perf_counter()
diff --git a/src/wechat_decrypt_tool/voice_transcription.py b/src/wechat_decrypt_tool/voice_transcription.py
index 16698adb..ac88ed58 100644
--- a/src/wechat_decrypt_tool/voice_transcription.py
+++ b/src/wechat_decrypt_tool/voice_transcription.py
@@ -734,7 +734,8 @@ def _public_model_name(value: str) -> str:
     if not raw:
         return ""
     if "/" in raw or "\\" in raw:
-        return Path(raw.rstrip("/\\")).name or "local-model"
+        # 缓存或配置可能来自另一平台，统一分隔符后仅公开模型文件名。
+        return Path(raw.replace("\\", "/").rstrip("/")).name or "local-model"
     return raw
 
 
@@ -969,6 +970,10 @@ def get_voice_model_catalog(*, selected_model: Optional[str] = None) -> list[dic
         job = jobs.get(model_id) or {}
         item = dict(definition)
         runtime_ready, runtime_reason = dependency_status(model_id)
+        qwen_runtime = None
+        if model_id == "qwen3-asr-06b-hf":
+            from .qwen_gpu_runtime import get_qwen_runtime
+            qwen_runtime = get_qwen_runtime().status()
         spec = ASR_MODEL_SPECS.get(model_id, {})
         item.update(
             {
@@ -976,6 +981,7 @@ def get_voice_model_catalog(*, selected_model: Optional[str] = None) -> list[dic
                 "devices": spec.get("devices", ["cpu", "cuda"]),
                 "runtimeAvailable": runtime_ready,
                 "runtimeReason": runtime_reason,
+                "runtimeComponent": qwen_runtime,
                 "selected": model_id == selected,
                 "downloaded": bool(readiness.get("ready")),
                 "downloadable": bool(readiness.get("downloadable")),
diff --git a/tests/test_chat_image_local_quality.py b/tests/test_chat_image_local_quality.py
new file mode 100644
index 00000000..6af84970
--- /dev/null
+++ b/tests/test_chat_image_local_quality.py
@@ -0,0 +1,281 @@
+"""覆盖旧缩略图缓存的显示、离线导出与并发预解密，使用真实编码和 XOR 解密。"""
+
+import importlib
+import io
+import json
+import logging
+import zipfile
+from concurrent.futures import ThreadPoolExecutor
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from PIL import Image
+
+import test_chat_media_image_cache_upgrade as cache_fixtures
+
+
+ACCOUNT = "wxid_test"
+USERNAME = "wxid_friend"
+MD5 = "a" * 32
+
+
+def image_bytes(width, height, format="PNG"):
+    output = io.BytesIO()
+    Image.new("RGB", (width, height), (24, 90, 170)).save(output, format=format)
+    return output.getvalue()
+
+
+def dimensions(data):
+    with Image.open(io.BytesIO(data)) as image:
+        image.load()
+        return image.size
+
+
+@pytest.fixture
+def local_images(tmp_path, monkeypatch):
+    monkeypatch.setenv("WECHAT_TOOL_DATA_DIR", str(tmp_path))
+    helper = cache_fixtures.TestChatMediaImageCacheUpgrade()
+    account = tmp_path / "output" / "databases" / ACCOUNT
+    account.mkdir(parents=True)
+    source = tmp_path / "wxid_source"
+    source.mkdir()
+    helper._seed_contact_db(account / "contact.db", account=ACCOUNT, username=USERNAME)
+    helper._seed_session_db(account / "session.db", username=USERNAME)
+    helper._seed_source_info(account, wxid_dir=source)
+    client = helper._build_client()
+    from wechat_decrypt_tool import media_helpers
+    from wechat_decrypt_tool.routers import chat_media, media
+
+    importlib.reload(media)
+    client.app.include_router(media.router)
+    media_helpers._save_media_keys(account, 0xA5)
+    try:
+        yield helper, account, source, client, media_helpers, chat_media
+    finally:
+        client.close()
+        logging.shutdown()
+
+
+def seed_variant(fixture, suffix, payload, md5=MD5):
+    helper, _, source, *_ = fixture
+    return helper._seed_live_variant(source, username=USERNAME, md5=md5, suffix=suffix, payload=payload)
+
+
+def seed_cache(fixture, payload, md5=MD5):
+    helper, account, *_ = fixture
+    return helper._seed_cached_resource(account, md5=md5, payload=payload)
+
+
+def get_image(fixture, **kwargs):
+    return fixture[3].get("/api/chat/media/image", params={"account": ACCOUNT, "username": USERNAME, "md5": MD5, **kwargs})
+
+
+def test_default_request_chooses_pixels_over_filename_and_bytes(local_images):
+    seed_cache(local_images, image_bytes(120, 120))
+    seed_variant(local_images, "_b", image_bytes(160, 160, "JPEG"))
+    original = image_bytes(800, 600, "WebP")
+    seed_variant(local_images, "_h", original)
+    _, account, _, _, helpers, router = local_images
+    downloader = AsyncMock(side_effect=AssertionError("本地缓存修复不能调用 CDN"))
+    with patch.object(router.cdn_image_service, "download_original_image", downloader), patch.object(
+        helpers, "_fallback_search_media_by_md5", side_effect=AssertionError("不能全账号扫描")
+    ):
+        response = get_image(local_images)
+    assert response.status_code == 200
+    assert response.content == original
+    assert dimensions(response.content) == (800, 600)
+    assert helpers._try_find_decrypted_resource(account, MD5).read_bytes() == original
+    downloader.assert_not_awaited()
+
+
+def test_default_uncached_request_compares_all_decoded_variants(local_images):
+    seed_variant(local_images, "_b", image_bytes(120, 120))
+    seed_variant(local_images, "_h", image_bytes(800, 600))
+    response = get_image(local_images)
+    assert response.status_code == 200
+    assert dimensions(response.content) == (800, 600)
+
+
+@pytest.mark.parametrize("cached", [False, True])
+def test_hardlink_thumbnail_does_not_hide_original_in_chat_attach(local_images, cached):
+    if cached:
+        seed_cache(local_images, image_bytes(120, 120))
+    seed_variant(local_images, "_h", image_bytes(800, 600))
+    thumbnail = local_images[2] / "cache" / "Thumb" / f"{MD5}_t.dat"
+    thumbnail.parent.mkdir(parents=True)
+    thumbnail.write_bytes(image_bytes(120, 120))
+    with patch.object(local_images[4], "_resolve_media_path_from_hardlink", return_value=thumbnail), patch.object(
+        local_images[5], "_resolve_media_path_from_hardlink", return_value=thumbnail
+    ):
+        response = get_image(local_images)
+    assert response.status_code == 200
+    assert dimensions(response.content) == (800, 600)
+
+
+def test_only_cache_still_works_without_source_directory(local_images):
+    original = image_bytes(900, 700)
+    seed_cache(local_images, original)
+    (_, account, source, _, helpers, _) = local_images
+    (account / "_source.json").write_text(json.dumps({"source": "imported", "prefer_decrypted": True}), encoding="utf-8")
+    with patch.object(helpers, "_resolve_account_wxid_dir", return_value=None), patch.object(
+        helpers, "_resolve_account_db_storage_dir", return_value=None
+    ):
+        response = get_image(local_images)
+    assert response.status_code == 200
+    assert response.content == original
+
+
+def test_larger_cache_is_not_downgraded_by_live_variant(local_images):
+    original = image_bytes(900, 700)
+    seed_cache(local_images, original)
+    seed_variant(local_images, "_b", image_bytes(120, 120))
+    seed_variant(local_images, "_h", b"broken encrypted image")
+    assert get_image(local_images).content == original
+    assert get_image(local_images, prefer_live=True).content == original
+
+
+def test_etag_changes_when_original_arrives_after_thumbnail(local_images):
+    seed_cache(local_images, image_bytes(120, 120))
+    first = get_image(local_images)
+    assert first.headers["cache-control"] == "private, max-age=0, must-revalidate"
+    seed_variant(local_images, "_h", image_bytes(800, 600))
+    client = local_images[3]
+    params = {"account": ACCOUNT, "username": USERNAME, "md5": MD5}
+    second = client.get("/api/chat/media/image", params=params, headers={"If-None-Match": first.headers["etag"]})
+    assert second.status_code == 200
+    assert dimensions(second.content) == (800, 600)
+    assert second.headers["etag"] != first.headers["etag"]
+    third = client.get("/api/chat/media/image", params=params, headers={"If-None-Match": second.headers["etag"]})
+    assert third.status_code == 304
+
+
+def test_extra_filename_suffix_and_uppercase_md5_still_find_original(local_images):
+    seed_cache(local_images, image_bytes(120, 120))
+    seed_variant(local_images, "_123_t", image_bytes(120, 120))
+    seed_variant(local_images, "_123_h", image_bytes(800, 600))
+    response = get_image(local_images, md5=MD5.upper())
+    assert response.status_code == 200
+    assert dimensions(response.content) == (800, 600)
+
+
+def test_directory_index_refreshes_when_another_variant_arrives(local_images):
+    seed_cache(local_images, image_bytes(120, 120))
+    seed_variant(local_images, "_123_t", image_bytes(120, 120))
+    assert dimensions(get_image(local_images).content) == (120, 120)
+    seed_variant(local_images, "_123_h", image_bytes(800, 600))
+    assert dimensions(get_image(local_images).content) == (800, 600)
+
+
+def test_predecrypt_keeps_legacy_filename_suffixes_and_dot_variants(local_images):
+    seed_variant(local_images, "_123_t", bytes(byte ^ 0xA5 for byte in image_bytes(120, 120)))
+    seed_variant(local_images, ".h", bytes(byte ^ 0xA5 for byte in image_bytes(800, 600)))
+    response = local_images[3].post("/api/media/decrypt_all", json={"account": ACCOUNT})
+    response.raise_for_status()
+    assert response.json()["total"] == 2
+    assert response.json()["success_count"] == 2
+    path = local_images[4]._try_find_decrypted_resource(local_images[1], MD5)
+    assert dimensions(path.read_bytes()) == (800, 600)
+
+
+@pytest.mark.parametrize("stream", [False, True])
+def test_predecrypt_repairs_valid_thumbnail_then_skips_unchanged_sources(local_images, stream):
+    seed_cache(local_images, image_bytes(120, 120))
+    for suffix, size in [("_t", (120, 120)), ("_b", (160, 160)), ("_h", (800, 600))]:
+        encrypted = bytes(byte ^ 0xA5 for byte in image_bytes(*size))
+        seed_variant(local_images, suffix, encrypted)
+    _, account, _, client, helpers, _ = local_images
+
+    def run():
+        if stream:
+            response = client.get("/api/media/decrypt_all_stream", params={"account": ACCOUNT, "concurrency": 10})
+            response.raise_for_status()
+            events = [json.loads(line[6:]) for line in response.text.splitlines() if line.startswith("data: ")]
+            return events[-1]
+        response = client.post("/api/media/decrypt_all", json={"account": ACCOUNT})
+        response.raise_for_status()
+        return response.json()
+
+    result = run()
+    assert result["fail_count"] == 0
+    assert result["success_count"] == 3
+    cached = helpers._try_find_decrypted_resource(account, MD5)
+    assert dimensions(cached.read_bytes()) == (800, 600)
+    mtime = cached.stat().st_mtime_ns
+    result = run()
+    assert result["skip_count"] == 3
+    assert result["success_count"] == 0
+    assert cached.stat().st_mtime_ns == mtime
+    # 同一路径内容变化后必须重新比较，不能只按 MD5 永久跳过。
+    seed_variant(local_images, "_h", bytes(byte ^ 0xA5 for byte in image_bytes(1000, 800)))
+    result = run()
+    assert result["success_count"] == 1
+    assert dimensions(cached.read_bytes()) == (1000, 800)
+
+
+def test_concurrent_cache_writers_never_replace_original_with_thumbnail(local_images):
+    _, account, _, _, helpers, _ = local_images
+    sizes = [(120, 120), (800, 600), (160, 160), (1000, 800)] * 8
+    with ThreadPoolExecutor(max_workers=10) as executor:
+        list(executor.map(lambda size: helpers._save_best_image_resource(account, MD5, image_bytes(*size)), sizes))
+    assert dimensions(helpers._try_find_decrypted_resource(account, MD5).read_bytes()) == (1000, 800)
+    assert not list((account / "resource").rglob("*.tmp"))
+
+
+def test_repeated_display_does_not_redecrypt_unchanged_original(local_images):
+    seed_cache(local_images, image_bytes(120, 120))
+    path = seed_variant(local_images, "_h", bytes(byte ^ 0xA5 for byte in image_bytes(800, 600)))
+    assert dimensions(get_image(local_images).content) == (800, 600)
+    helpers = local_images[4]
+    with patch.object(helpers, "_read_and_maybe_decrypt_media", wraps=helpers._read_and_maybe_decrypt_media) as decoder:
+        assert dimensions(get_image(local_images).content) == (800, 600)
+    assert not any(call.args[0] == path for call in decoder.call_args_list)
+    seed_variant(local_images, "_h", bytes(byte ^ 0xA5 for byte in image_bytes(1000, 800)))
+    assert dimensions(get_image(local_images).content) == (1000, 800)
+
+
+def test_readers_remain_valid_while_predecrypt_changes_cache_format(local_images):
+    seed_cache(local_images, image_bytes(120, 120))
+    _, account, _, _, helpers, _ = local_images
+
+    def write(size):
+        format = ["PNG", "JPEG", "WebP"][size % 3]
+        return helpers._save_best_image_resource(account, MD5, image_bytes(size, size, format))
+
+    def read(_):
+        response = get_image(local_images)
+        assert response.status_code == 200
+        assert dimensions(response.content)[0] >= 120
+
+    with ThreadPoolExecutor(max_workers=10) as executor:
+        futures = [executor.submit(write, size) for size in range(121, 151)]
+        futures.extend(executor.submit(read, index) for index in range(30))
+        for future in futures:
+            future.result()
+    assert dimensions(helpers._try_find_decrypted_resource(account, MD5).read_bytes()) == (150, 150)
+
+
+def test_export_upgrades_cache_without_any_prior_image_request(local_images):
+    _, account, _, _, helpers, _ = local_images
+    seed_cache(local_images, image_bytes(120, 120))
+    seed_variant(local_images, "_b", image_bytes(160, 160))
+    original = image_bytes(800, 600)
+    seed_variant(local_images, "_h", bytes(byte ^ 0xA5 for byte in original))
+    from wechat_decrypt_tool import chat_export_service as service
+
+    importlib.reload(service)
+    # HTML、JSON 和增量导出共用这个写入入口；原生签名组件由真实启动验收覆盖。
+    archive_path = account / "offline-export.zip"
+    media_index = helpers.MediaPathIndex.build(account_dir=account, usernames=[USERNAME], media_kinds=["image"])
+    with zipfile.ZipFile(archive_path, "w") as archive:
+        result, copied = service._materialize_media(
+            zf=archive, account_dir=account, conv_username=USERNAME, kind="image", md5=MD5, file_id="",
+            media_written={}, suggested_name="", media_index=media_index,
+        )
+        assert copied
+        assert result.startswith("media/images/")
+    with zipfile.ZipFile(archive_path) as archive:
+        names = [name for name in archive.namelist() if name.startswith("media/images/")]
+        assert len(names) == 1
+        assert archive.read(names[0]) == original
+        assert dimensions(archive.read(names[0])) == (800, 600)
+    assert dimensions(helpers._try_find_decrypted_resource(account, MD5).read_bytes()) == (800, 600)
diff --git a/tests/test_chat_media_image_cache_upgrade.py b/tests/test_chat_media_image_cache_upgrade.py
index 7cd16779..32b94fe7 100644
--- a/tests/test_chat_media_image_cache_upgrade.py
+++ b/tests/test_chat_media_image_cache_upgrade.py
@@ -23,7 +23,7 @@
 
 class TestChatMediaImageCacheUpgrade(unittest.TestCase):
     def assert_cacheable_chat_image_response(self, resp) -> None:
-        self.assertEqual(resp.headers.get("cache-control"), "private, max-age=86400")
+        self.assertEqual(resp.headers.get("cache-control"), "private, max-age=0, must-revalidate")
         self.assertTrue(str(resp.headers.get("etag") or "").strip())
 
     def _seed_contact_db(self, path: Path, *, account: str, username: str) -> None:
@@ -157,8 +157,9 @@ def test_live_high_variant_replaces_stale_cached_thumb(self):
             self._seed_session_db(account_dir / "session.db", username=username)
             self._seed_source_info(account_dir, wxid_dir=wxid_dir)
 
-            cached_thumb = b"\xff\xd8\xff\xd9"
-            live_original = b"\xff\xd8\xff\xe0" + (b"\x00" * 48) + b"\xff\xd9"
+            # 使用真正有效的缩略图，避免被损坏缓存分支提前删除而掩盖问题。
+            cached_thumb = self._png_payload(120, 120)
+            live_original = self._png_payload(800, 600)
             cache_path = self._seed_cached_resource(account_dir, md5=md5, payload=cached_thumb)
             self._seed_live_variant(wxid_dir, username=username, md5=md5, suffix="_h", payload=live_original)
 
@@ -174,7 +175,7 @@ def test_live_high_variant_replaces_stale_cached_thumb(self):
                 self.assertEqual(resp.status_code, 200)
                 self.assertEqual(resp.content, live_original)
                 self.assert_cacheable_chat_image_response(resp)
-                self.assertEqual(cache_path.read_bytes(), live_original)
+                self.assertEqual(cache_path.with_suffix(".png").read_bytes(), live_original)
             finally:
                 try:
                     client.close()
@@ -316,7 +317,7 @@ def test_chat_image_supports_etag_revalidation(self):
                 self.assertEqual(second.status_code, 304)
                 self.assertEqual(second.content, b"")
                 self.assertEqual(second.headers.get("etag"), etag)
-                self.assertEqual(second.headers.get("cache-control"), "private, max-age=86400")
+                self.assertEqual(second.headers.get("cache-control"), "private, max-age=0, must-revalidate")
             finally:
                 try:
                     client.close()
diff --git a/tests/test_qwen_gpu_runtime.py b/tests/test_qwen_gpu_runtime.py
new file mode 100644
index 00000000..54b6e9cd
--- /dev/null
+++ b/tests/test_qwen_gpu_runtime.py
@@ -0,0 +1,174 @@
+"""覆盖组件续传、文件校验、暂停恢复及失败时保留模型设置。"""
+import hashlib
+import io
+import json
+from pathlib import Path
+import threading
+import zipfile
+
+import httpx
+import pytest
+
+from wechat_decrypt_tool import qwen_gpu_runtime as runtime
+
+
+@pytest.fixture
+def manager(tmp_path, monkeypatch):
+    monkeypatch.setenv("WECHAT_TOOL_DATA_DIR", str(tmp_path))
+    return runtime.QwenRuntimeManager()
+
+
+def item(data):
+    return dict(name="test.whl", package="test", size=len(data), sha256=hashlib.sha256(data).hexdigest(),
+                url="https://files.pythonhosted.org/test.whl")
+
+
+def test_range_resume_verifies_complete_file(manager, tmp_path):
+    data = b"real-file-content"
+    target = tmp_path / "test.whl"
+    target.write_bytes(data[:5])
+    def handler(request):
+        assert request.headers["range"] == "bytes=5-"
+        return httpx.Response(206, content=data[5:], headers={"content-range": f"bytes 5-{len(data)-1}/{len(data)}"})
+    with httpx.Client(transport=httpx.MockTransport(handler)) as client:
+        manager.download(client, item(data), target, 0)
+    assert target.read_bytes() == data
+
+
+def test_server_ignoring_range_restarts_file(manager, tmp_path):
+    data = b"new-content"
+    target = tmp_path / "test.whl"
+    target.write_bytes(b"new")
+    with httpx.Client(transport=httpx.MockTransport(lambda _: httpx.Response(200, content=data))) as client:
+        manager.download(client, item(data), target, 0)
+    assert target.read_bytes() == data
+
+
+def test_invalid_range_is_rejected(manager, tmp_path):
+    target = tmp_path / "test.whl"
+    target.write_bytes(b"x")
+    with httpx.Client(transport=httpx.MockTransport(lambda _: httpx.Response(206, content=b"x", headers={"content-range": "bytes 0-1/2"}))) as client:
+        with pytest.raises(ValueError, match="续传位置"):
+            manager.download(client, item(b"xx"), target, 0)
+
+
+def test_corrupt_download_is_removed(manager, tmp_path):
+    target = tmp_path / "test.whl"
+    with httpx.Client(transport=httpx.MockTransport(lambda _: httpx.Response(200, content=b"bad"))) as client:
+        with pytest.raises(ValueError, match="校验失败"):
+            manager.download(client, item(b"yes"), target, 0)
+    assert not target.exists()
+
+
+def test_pause_preserves_partial_file(manager, tmp_path):
+    target = tmp_path / "test.whl"
+    target.write_bytes(b"partial")
+    manager.cancelled.set()
+    with httpx.Client() as client, pytest.raises(runtime.Paused):
+        manager.download(client, item(b"partial-data"), target, 0)
+    assert target.read_bytes() == b"partial"
+
+
+def test_restart_requires_explicit_resume(manager):
+    manager.update(status="running", stage="downloading", bytes=123)
+    restarted = runtime.QwenRuntimeManager()
+    assert restarted.status()["job"]["status"] == "paused"
+    assert restarted.status()["job"]["bytes"] == 123
+    assert restarted.thread is None
+
+
+def test_manifest_has_compatible_pinned_windows_wheels():
+    from packaging.tags import compatible_tags, cpython_tags
+    from packaging.utils import parse_wheel_filename
+    for abi, files in runtime.manifest()["variants"].items():
+        minor = int(abi[3:])
+        tags = set(cpython_tags((3, minor), abis=[abi], platforms=["win_amd64"]))
+        tags.update(compatible_tags((3, minor), interpreter=abi, platforms=["win_amd64"]))
+        assert {f["package"] for f in files} >= {"torch", "transformers", "numpy", "tokenizers", "safetensors"}
+        for f in files:
+            assert parse_wheel_filename(f["name"])[3] & tags
+            assert len(f["sha256"]) == 64 and f["size"] > 0
+
+
+def test_archive_escape_is_refused_before_publishing(manager, tmp_path, monkeypatch):
+    payload = io.BytesIO()
+    with zipfile.ZipFile(payload, "w") as archive:
+        archive.writestr("../escaped.txt", "no")
+    data = payload.getvalue()
+    root = tmp_path / "voice_runtimes/version/cp311"
+    monkeypatch.setattr(runtime, "runtime_root", lambda: root)
+    monkeypatch.setattr(runtime, "runtime_files", lambda: [item(data)])
+    def download(client, entry, path, completed):
+        path.write_bytes(data)
+    monkeypatch.setattr(manager, "download", download)
+    with pytest.raises(ValueError, match="文件路径"):
+        manager.install()
+    assert not (root / "installed.json").exists()
+    assert not (root.parent / "escaped.txt").exists()
+
+
+def test_failed_install_keeps_current_model(manager, monkeypatch):
+    from wechat_decrypt_tool import voice_transcription as voice
+    selections = []
+    monkeypatch.setattr(runtime, "installed", lambda: False)
+    monkeypatch.setattr(manager, "install", lambda: (_ for _ in ()).throw(ValueError("检查失败")))
+    monkeypatch.setattr(voice, "set_voice_transcription_model", selections.append)
+    manager.run()
+    assert selections == []
+    assert manager.status()["job"]["status"] == "error"
+
+
+def test_outside_application_directory_is_refused(manager, tmp_path):
+    with pytest.raises(ValueError, match="数据目录之外"):
+        manager.ensure_owned(tmp_path.parent / "outside-runtime")
+
+
+def test_duplicate_start_reuses_active_task(manager, monkeypatch):
+    from wechat_decrypt_tool.local_search import gpu
+    monkeypatch.setattr(runtime, "supported", lambda: True)
+    monkeypatch.setattr(gpu, "gpu_devices", lambda: [dict(name="test")])
+    entered, release = threading.Event(), threading.Event()
+    monkeypatch.setattr(manager, "run", lambda: (entered.set(), release.wait(2)))
+    manager.start()
+    assert entered.wait(1)
+    thread = manager.thread
+    manager.start()
+    assert manager.thread is thread
+    release.set()
+    thread.join(2)
+
+
+def test_cpu_device_locked_rejects_before_download(manager, monkeypatch):
+    monkeypatch.setenv("WECHAT_TOOL_WHISPER_DEVICE", "cpu")
+    with pytest.raises(ValueError, match="固定为 CPU"):
+        manager.start()
+    assert manager.thread is None
+
+
+def test_cancelled_model_download_does_not_hang_or_switch_model(manager, monkeypatch):
+    from wechat_decrypt_tool import voice_transcription as voice
+    monkeypatch.setattr(runtime, "installed", lambda: True)
+    monkeypatch.setattr(voice, "inspect_model_readiness", lambda _: dict(ready=False))
+    monkeypatch.setattr(voice.VOICE_MODEL_DOWNLOAD_MANAGER, "start", lambda _: dict(jobId="cancelled-test"))
+    monkeypatch.setattr(voice.VOICE_MODEL_DOWNLOAD_MANAGER, "get", lambda _: dict(status="cancelled", percent=5, error=""))
+    selections=[]
+    monkeypatch.setattr(voice, "set_voice_transcription_model", selections.append)
+    manager.run()
+    assert manager.status()["job"]["status"] == "error"
+    assert "下载已停止" in manager.status()["job"]["error"]
+    assert selections == []
+
+
+def test_missing_model_is_downloaded_and_checked_before_selection(manager, monkeypatch):
+    from wechat_decrypt_tool import voice_transcription as voice, asr_worker
+    calls=[]
+    monkeypatch.setattr(runtime, "installed", lambda: True)
+    monkeypatch.setattr(voice, "inspect_model_readiness", lambda _: dict(ready=False))
+    monkeypatch.setattr(voice, "_model_directory_is_ready", lambda *args: True)
+    monkeypatch.setattr(voice.VOICE_MODEL_DOWNLOAD_MANAGER, "start", lambda _: (calls.append('download') or dict(jobId='test')))
+    monkeypatch.setattr(voice.VOICE_MODEL_DOWNLOAD_MANAGER, "get", lambda _: dict(status='done', percent=100))
+    monkeypatch.setattr(asr_worker, "check_qwen_runtime", lambda **kwargs: (calls.append('check_model') or dict(available=True)))
+    monkeypatch.setattr(voice, "set_voice_transcription_model", lambda _: calls.append('select'))
+    manager.run()
+    assert calls == ['download', 'check_model', 'select']
+    assert manager.status()['job']['status'] == 'done'
diff --git a/tests/test_voice_transcription.py b/tests/test_voice_transcription.py
index ae6d569b..f1576ecd 100644
--- a/tests/test_voice_transcription.py
+++ b/tests/test_voice_transcription.py
@@ -8,7 +8,7 @@
 import unittest
 import weakref
 from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from types import SimpleNamespace
 from unittest.mock import Mock, patch
 
@@ -787,6 +787,19 @@ def test_public_result_does_not_expose_local_model_path(self):
                 )
         self.assertEqual(result["model"], "faster-whisper-small")
 
+    def test_public_model_name_handles_imported_paths_on_posix(self):
+        # Windows 上也模拟 POSIX 路径语义，避免仅在 macOS CI 才发现泄露。
+        cases = [
+            (r"D:\models\faster-whisper-small", "faster-whisper-small"),
+            ("/models/faster-whisper-small/", "faster-whisper-small"),
+            (r"\\server\models\faster-whisper-small", "faster-whisper-small"),
+            ("qwen3-asr-06b-hf", "qwen3-asr-06b-hf"),
+        ]
+        with patch.object(voice_transcription_module, "Path", PurePosixPath):
+            for value, expected in cases:
+                with self.subTest(value=value):
+                    self.assertEqual(voice_transcription_module._public_model_name(value), expected)
+
     def test_cuda_initialization_failure_falls_back_to_cpu(self):
         with tempfile.TemporaryDirectory() as tmp:
             calls = []
diff --git a/tools/generate_qwen_gpu_manifest.py b/tools/generate_qwen_gpu_manifest.py
new file mode 100644
index 00000000..c51fbaf5
--- /dev/null
+++ b/tools/generate_qwen_gpu_manifest.py
@@ -0,0 +1,62 @@
+"""从项目锁文件生成 Windows Qwen 外置运行组件清单。"""
+import json
+from pathlib import Path
+import tomllib
+from urllib.parse import unquote, urlparse
+
+import httpx
+from packaging.markers import Marker, default_environment
+from packaging.tags import compatible_tags, cpython_tags
+from packaging.utils import parse_wheel_filename
+
+
+def main():
+    root = Path(__file__).resolve().parents[1]
+    packages = tomllib.loads((root / "uv.lock").read_text(encoding="utf-8"))["package"]
+    variants = {}
+    for minor in (11, 12, 13):
+        env = {**default_environment(), "sys_platform": "win32", "platform_system": "Windows",
+               "platform_machine": "AMD64", "python_version": f"3.{minor}",
+               "python_full_version": f"3.{minor}.3"}
+        tags = list(cpython_tags((3, minor), abis=[f"cp3{minor}"], platforms=["win_amd64"]))
+        tags += list(compatible_tags((3, minor), interpreter=f"cp3{minor}", platforms=["win_amd64"]))
+        ranks = {tag: i for i, tag in enumerate(tags)}
+        resolved = {}
+        pending = [{"name": "torch", "version": "2.9.1+cu128"}, {"name": "transformers", "version": "5.17.0"}]
+        while pending:
+            requirement = pending.pop()
+            if requirement.get("marker") and not Marker(requirement["marker"]).evaluate(env):
+                continue
+            name = requirement["name"]
+            if name in resolved:
+                continue
+            candidates = [p for p in packages if p["name"] == name and
+                          (not requirement.get("version") or p["version"] == requirement["version"])]
+            choices = []
+            for package in candidates:
+                for wheel in package.get("wheels", []):
+                    filename = unquote(urlparse(wheel["url"]).path.rsplit("/", 1)[-1])
+                    matching = parse_wheel_filename(filename)[3] & ranks.keys()
+                    if matching:
+                        choices.append((min(ranks[tag] for tag in matching), package, wheel, filename))
+            if not choices:
+                raise ValueError(f"没有兼容 wheel: {name} / cp3{minor}")
+            _, package, wheel, filename = min(choices, key=lambda item: item[0])
+            size = wheel.get("size")
+            if size is None:
+                response = httpx.head(wheel["url"], follow_redirects=True, timeout=60)
+                response.raise_for_status()
+                size = int(response.headers["content-length"])
+            resolved[name] = dict(name=filename, package=name, version=package["version"],
+                                  url=wheel["url"], size=size, sha256=wheel["hash"].removeprefix("sha256:"))
+            pending.extend(package.get("dependencies", []))
+        variants[f"cp3{minor}"] = sorted(resolved.values(), key=lambda f: f["package"])
+        print(f"cp3{minor}: {len(resolved)} wheels, {sum(f['size'] for f in resolved.values())} bytes", flush=True)
+    manifest = dict(id="qwen-torch2.9.1-cu128-transformers5.17.0-v1", platform="win32",
+                    architecture="AMD64", variants=variants)
+    (root / "src/wechat_decrypt_tool/resources/qwen_gpu_runtime.json").write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/qwen_runtime_stdlib.py b/tools/qwen_runtime_stdlib.py
new file mode 100644
index 00000000..19179aa9
--- /dev/null
+++ b/tools/qwen_runtime_stdlib.py
@@ -0,0 +1,14 @@
+"""外置依赖的动态导入无法被冻结分析发现，显式保留 Windows 可用标准库。"""
+import importlib.util
+import json
+import sys
+
+
+def modules():
+    excluded = {"antigravity", "this", "tkinter", "turtle", "turtledemo", "idlelib", "test", "ensurepip", "venv"}
+    return sorted(name for name in sys.stdlib_module_names
+                  if name not in excluded and not name.startswith("_") and importlib.util.find_spec(name) is not None)
+
+
+if __name__ == '__main__':
+    print(json.dumps(modules()))