Merge pull request '_tmp_update' (#11) from _tmp_update into dev

- CredentialRepository 快照新增 requestedAccountId，暂存凭据严格按请求账号匹配，
  避免 A 账号刷新期间把暂存凭据误交给默认账号/其他账号
- Dashboard 首页提示与自动签到开关改为卡片样式，开关配色对齐雨晴粉主题
- 默认账号徽标加 maxLines/softWrap 防窄屏换行

.github/workflows/ci.yml

@@ -5,17 +5,20 @@ on:
     branches: [main]
   pull_request:
 
+permissions:
+  contents: read
+
 jobs:
   test:
     name: Unit Tests & Lint
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-java@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4
+      - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3  # v4
         with:
           java-version: '17'
           distribution: 'temurin'
-      - uses: android-actions/setup-android@v3
+      - uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407  # v3
         with:
           packages: 'platforms;android-35 build-tools;35.0.0'
 
@@ -27,7 +30,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4
         with:
           name: unit-test-results
           path: app/build/test-results/testDebugUnitTest/*.xml
@@ -38,7 +41,7 @@ jobs:
 
       - name: Upload lint results
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4
         with:
           name: lint-results
           path: app/build/reports/lint-results-debug.*
@@ -49,12 +52,12 @@ jobs:
     runs-on: ubuntu-latest
     needs: test
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-java@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4
+      - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3  # v4
         with:
           java-version: '17'
           distribution: 'temurin'
-      - uses: android-actions/setup-android@v3
+      - uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407  # v3
         with:
           packages: 'platforms;android-35 build-tools;35.0.0'
 
@@ -65,7 +68,7 @@ jobs:
         run: ./gradlew assembleDebug
 
       - name: Upload Debug APK
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4
         with:
           name: debug-apk
           path: app/build/outputs/apk/debug/app-debug.apk
@@ -76,12 +79,12 @@ jobs:
     runs-on: ubuntu-latest
     needs: test
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-java@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4
+      - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3  # v4
         with:
           java-version: '17'
           distribution: 'temurin'
-      - uses: android-actions/setup-android@v3
+      - uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407  # v3
         with:
           packages: 'platforms;android-35 build-tools;35.0.0'
 
@@ -119,7 +122,7 @@ jobs:
           echo "✅ APK integrity verified: manifest + arsc + res/ all present"
 
       - name: Upload Release APK
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4
         with:
           name: release-apk
           path: app/build/outputs/apk/release/app-release.apk

.github/workflows/release.yml

@@ -10,12 +10,12 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-java@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4
+      - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3  # v4
         with:
           java-version: '17'
           distribution: 'temurin'
-      - uses: android-actions/setup-android@v3
+      - uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407  # v3
         with:
           packages: 'platforms;android-35 build-tools;35.0.0'
       - name: Decode Keystore
@@ -28,10 +28,13 @@ jobs:
         run: |
           chmod +x gradlew
           ./gradlew assembleRelease
+      - name: Cleanup keystore (always run for security)
+        run: rm -f release.jks
+        if: always()
       - name: Rename & Release
         run: |
           cp app/build/outputs/apk/release/app-release.apk "RainyToken-${GITHUB_REF#refs/tags/}.apk"
-      - uses: softprops/action-gh-release@v2
+      - uses: softprops/action-gh-release@3bb12739c298aeb8a4eeaf626c5b8d85266b0e65  # v2
         with:
           name: "🎉 RainyToken ${{ github.ref_name }}"
           files: RainyToken-${{ github.ref_name }}.apk

.gitignore

@@ -7,6 +7,7 @@
 /.idea/workspace.xml
 /.idea/navEditor.xml
 /.idea/assetWizardSettings.xml
+/.idea/
 .DS_Store
 /build
 app/build/
@@ -20,3 +21,5 @@ release.jks
 .kotlin/
 *.jks
 tmp_cc/
+goal.md
+/reference/

AGENTS.md

@@ -1,275 +1,5 @@
-# 雨晴Token — AI 余额查询 APP
+任务开始前必须先读取 taste.md（协作偏好），任务全程遵守其中约定，包括：修改后派发独立 subagent 审计（无阻断问题 + 无影响用户体验问题），修复后用同一个 subagent 复审。
 
-## 项目概述
+未经用户允许禁止提交推送
 
-Android（Jetpack Compose + Kotlin）APP，统一查询 DeepSeek、OpenCode Go、CommandCode Go、Codex / ChatGPT Plus、Ollama Pro 的余额/配额。
-DeepSeek 走 REST API，OpenCode Go 通过 OkHttp 抓取 dashboard HTML 解析 SSR hydration 数据。
-CommandCode Go 走 JSON API 抓取用量数据，Codex / ChatGPT Plus 通过 auth.json 刷新 token 后查询 wham 用量。Ollama Pro 通过 Cookie 抓取 settings 页 HTML 解析用量百分比。APP 名为「雨晴Token」（粉色调品牌），配套桌面小组件。
-
-## 技术栈
-
-- Kotlin 100% · Jetpack Compose + Material 3
-- MVVM + Repository + `RefreshBalanceUseCase`（单一 UseCase，按 ServiceType 分发）
-- Hilt + KSP（DI）
-- Retrofit 2 + OkHttp 4 + Kotlinx Serialization
-- Room（用量数据，indexed on workspaceId+timeCreated）+ DataStore（余额缓存/图表偏好）+ Android Keystore（凭据加密，AES-256 GCM）
-- `minSdk=31`（Android 12+）
-- `material3-window-size-class` — 平板自适应布局
-- WorkManager（计划中）
-
-## 当前实现状态
-
-**服务**：
-- ✅ DeepSeek — REST API `GET /user/balance`，API Key 认证
-- ✅ OpenCode Go — OkHttp 抓 dashboard HTML，解析 `rollingUsage`/`weeklyUsage`/`monthlyUsage`。**一键激活用量**：OCGO 详情页可向 `opencode.ai/zen/go/v1/chat/completions` 发送简短请求（`content:hello`）触发用量统计，API Key 从设置页手动填写（存 `SessionCredential.apiKey`），模型列表从 `models.dev/api.json`（provider=`opencode-go`）动态获取，用户选择持久化到 `SharedPreferences("ocgo_trigger_prefs")`，响应经 `parseChatResponse()` 提取回复文本+用量统计后弹窗展示。
-- ✅ CommandCode Go — JSON API 抓取用量数据，`CommandCodeUsageRepository` 解析（workspaceId = `"commandcode"`）
-- ✅ Codex / ChatGPT Plus — 支持 **OAuth PKCE 登录（无头模式）** 或粘贴完整 auth.json（含 refresh_token），调 `chatgpt.com/backend-api/wham/usage`；token 过期前 60 分钟自动刷新。OpenAI 采用 refresh_token 单次轮换机制，被外部工具使用后旧 token 立即失效，需重新 OAuth 登录或导入新 auth.json。**5h 窗口可能被 OpenAI 临时关闭**（`primary_window` 返回 `null`），UI 保留空 5h 槽位 + 主标签动态化（`extras["primary.label"]`），恢复后自动填回。**一键激活用量**：Codex 详情页可向 `chatgpt.com/backend-api/codex/responses` 发送简短请求（`input:hello`）触发用量统计，模型列表从 `models.dev/api.json` 动态获取（无需认证），用户选择持久化到 `SharedPreferences("codex_trigger_prefs")`，请求需 `stream:true`+`store:false`+`ChatGPT-Account-Id` 头（从 access_token JWT 解析），SSE 响应经 `parseSseResponse()` 提取回复文本+用量统计后弹窗展示。
-- ✅ Ollama Pro — Cookie 认证，OkHttp 抓 `ollama.com/settings` HTML，正则解析 plan/session(5h)/weekly 百分比 + `data-time` 重置时间 + `data-model` 模型级请求次数；无官方 API（ollama/ollama#12532）。**一键激活用量**：Ollama 详情页可向 `ollama.com/v1/chat/completions` 发送简短请求（`content:hello`）触发用量统计，API Key 从设置页手动填写（存 `SessionCredential.apiKey`），模型列表从 `models.dev/api.json`（provider=`ollama-cloud`）动态获取，用户选择持久化到 `SharedPreferences("ollama_trigger_prefs")`，响应经 `parseOllamaChatResponse()` 提取回复文本+用量统计后弹窗展示。
-- ✅ 文案统一：所有服务标签均使用中文（"每周"统一代替 "weekly"/"Weekly"/"weekly"）
-- ❌ OpenCode Zen / 小米 MiMo — 未实现
-
-**用量统计系统**：
-- ✅ `UsageCache`（Room，indexed on workspaceId+timeCreated）— DAO 查询替代全量 JSON 序列化；首次启动自动从旧 DataStore JSON 迁移
-- ✅ `SyncUsageUseCase`（OCGO）/ `SyncCommandCodeUsageUseCase`（CCGO） — 首次全量同步（cursor 翻页）、增量同步（逐页比对本地 ID 集合，按 `getIdsByWorkspace(wid)` 过滤避免跨 workspace 碰撞）
-- ✅ `UsageViewModel` — `loadStatsInternal()` 单次 `getRecords()`→ 内存聚合 Overview/ModelStats/DailyStats，所有重操作包在 `withContext(Dispatchers.Default)` 避免主线程卡顿
-- ✅ `UsageChartViewModel` — 图表粒度（5h/**12h(10min)**/24h/今天/昨天/7天/当月/自定义日/月/范围），模型多选，3 张 Canvas 图表；支持 **UTC+0/UTC+8 时区切换**（桶边界+标签双感知）；自定义日/月/范围保存 `LocalDate` 语义，切换 UTC 偏好时重新计算边界；**自动降级**（5h无数据→12h→7天→当月）
-- ✅ `ChartSettingsStore`（DataStore Preferences + StateFlow）— 持久化 UTC 偏好，`useUtc8Flow` 异步读取（已移除 runBlocking）
-- ✅ `UsageDataViewModel` — 原始记录分页浏览（20条/页），支持时间+模型筛选，页码输入跳转
-- ✅ 全局刷新绑定 — Dashboard 下拉刷新 → `DashboardViewModel.refresh()` → `UsageViewModel.sync()`（增量）
-
-**调试与错误诊断**：
-- ✅ `DebugLog` — 内存 ring buffer（200 条，线程安全），所有 Repository 关键路径（网络请求、Token 刷新、解析错误）均写入日志；设置页提供「调试日志」入口，无需连电脑即可在 APP 内查看 ERROR/WARN/INFO 三级日志。
-- ✅ `RepositoryError.InvalidCredential` 支持自定义 `detail`，Codex `RefreshResult` 密封类明确区分刷新成功/失败原因，错误信息可透传到 Dashboard 卡片与调试日志。
-
-**JsonNull 安全红线**：
-
-> ⚠️ kotlinx.serialization 中 `?.jsonObject` / `?.jsonPrimitive` 对 JSON 显式 `null` 值无效——返回的是 `JsonNull` 对象（非 Kotlin null），扩展函数内部类型检查会抛 `IllegalArgumentException` 导致闪退。
-> **必须用 `as? JsonObject` / `as? JsonPrimitive` 替代**，安全转换能正确处理 `JsonNull`（返回 null）。
-> `parseUsageWindows()` 等解析方法外部必须包 `try/catch` → `RepositoryError.ParseError`，防止 API 响应结构变化导致异常逃逸。
-
-**凭据回显红线**：
-
-> ⚠️ `CredentialEditViewModel.load()` 首次加载已有凭据时，需针对每种 `Credential` 子类显式编写回显分支。
-> 当前覆盖：`ApiKeyCredential`（API Key 输入框）、`SessionCredential`（Cookie 输入框 / `ollamaCookie` 字段 / `apiKey` 字段 → `triggerApiKey`）、`CodexCredential`（auth.json 输入框）。
-> 新增凭据类型（如 OpenCode Zen / MiMo）时必须同步添加对应的 `load()` 回显分支，否则用户保存后看不到已存内容。
-
-**ViewModel 加载机制红线**：
-
-> ⚠️ 三个 ViewModel 的 `init` 块**已移除**，不再自动加载。数据加载由 Composable 层的 `LaunchedEffect(Unit)` 显式触发：
-> - OCGO 页面：`LaunchedEffect(Unit) { viewModel.load() / loadStats() / loadData() }`
-> - CCGO 页面：`LaunchedEffect(Unit) { viewModel.setWorkspace(wid) }`（`setWorkspace` 内部调 `load()`）
-> - CCGO 页面通过 `autoLoad = false` 参数跳过 Screen 内的 `LaunchedEffect` 重复 load
->
-> 原因：`init` 自动加载时 `workspaceIdOverride` 为 null，协程读到 OCGO 凭据，导致 CCGO 页面闪现 OCGO 数据。
-
-**DashboardViewModel 刷新竞态红线**：
-
-> ⚠️ `DashboardViewModel.init` 必须在**同一协程内串行**调用 `loadFromCache()` → `refresh()`，不能拆成两个独立协程。
-> 原因：并行时 `loadFromCache()` 读到的旧缓存快照可能在 `refresh()` 写入新数据后才 `_uiState.update`，导致用量数据闪回旧值（如 Codex 5h 61%→2%）。
-> `refresh()` 内部用 `Mutex.tryLock()` 防并发——下拉刷新与 init 的 refresh 并发时后者直接跳过，避免交错覆盖。
-
-**hiltViewModel key 红线**：
-
-> ⚠️ `hiltViewModel(key = key)` 的 key 在 ViewModelStore 内全局唯一、不区分类型。
-> CCGO 路由中 `UsageChartViewModel` 和 `UsageViewModel` 用相同 key 会导致类型碰撞、加载失败。
-> 当前方案：`chartVm` 用 `"ccgo_chart_$wid"`，`usageVm` 用 `"ccgo_$wid"`（与 Dashboard 首页 `CommandCodeUsageStatsCard` 共享实例）。
-
-**ARM64 Proot Release 构建红线**：
-
-> ⚠️ AGP 9.0 的 `optimizeReleaseResources` 在 ARM64 Proot 下传入 `--resource-path-shortening-map=<path>`（等号形式），ARM64 AAPT2 不接受此语法（只接受空格分隔），exit code=1 但 AGP `invokeAapt()` 只调 `rethrowFailure()` 不调 `assertNormalExitValue()`，失败被静默吞掉。导致 optimized `.ap_` 缺失，`packageRelease` 生成无 `AndroidManifest.xml` / `resources.arsc` / `res/` 的残缺 APK（BUILD SUCCESSFUL 但 APK 不可用）。
->
-> 修复链（不可删除任一环节）：
-> 1. `~/.gradle/gradle.properties`（全局，不提交项目仓库）→ `android.aapt2FromMavenOverride` 指向 `~/.local/lib/android-aapt2-wrapper/aapt2` wrapper 脚本，将 `--resource-path-shortening-map=<path>` 拆分为 `--resource-path-shortening-map` `<path>` 两个独立 argv
-> 2. `app/build.gradle.kts` 中 `guardReleaseResources` 任务：`optimizeReleaseResources` 之后验证 optimized `.ap_` 完整性（manifest + arsc + res/），缺失则复制 linked `.ap_` 作为 fallback；`packageRelease` 依赖此任务
-> 3. `app/build.gradle.kts` 中 `resolutionStrategy` 强制 `aapt2:linux-aarch64` classifier
->
-> CI（GitHub Actions x86_64）不受影响——全局 `~/.gradle/gradle.properties` 不在项目仓库中。Debug 不经过 `optimizeReleaseResources`，无此问题。
-
-**首页布局**：
-
-> Dashboard 使用 `PullToRefreshBox` → `Column` + `verticalScroll`（非 `LazyColumn`）。
-> 页面仅 8 个 item，`LazyColumn` 的 dispose/recompose 会导致用量卡片的 `LaunchedEffect` 反复触发，产生卡顿。
-> 
-> **自适应断点**：容器宽度 > 600dp 时卡片双列（`BoxWithConstraints`），≤600dp 时单列。
-> OCGO / CCGO 服务余额卡底部均提供「查看用量详情」入口，未配置凭据时不显示。
-> 
-> **长按拖拽排序**：基于 Compose 原生 `detectDragGesturesAfterLongPress`，不引入第三方库。
-> 核心设计：拖动中不修改真实布局顺序（手势节点不动），其它卡片用 `displacementFor()` 计算的 `offset` 做视觉让位。
-> 换位判断采用"拖拽卡片中心点命中目标格"模型——累计手指偏移计算拖拽中心在窗口的坐标，
-> 与冻结的格子中心表 `itemCenterById` 比对，进入目标格激活区域（卡片短边的 45%）后才切换 `dragTargetIndex`。
-> 自动滚动时对浮动卡片和格子中心表同步做 `y - consumed` 补偿，防止飞走。
-> 松手后通过 `settleDraggedItem()` 落位并持久化到 SharedPreferences（`dashboard_card_order`）。
-> 
-> 关键状态拆分：
-> - `visualDragOffsetX/Y` —— 视觉跟手偏移，持续累计
-> - `dragStartCenterX/YInWindow` —— 拖动开始时卡片中心在窗口位置，作为偏移基准
-> - `dragFromIndex` / `dragTargetIndex` —— 真实 index 和目标 index，不触发重组
-> - `itemCenterById` —— 拖动中冻结的格子中心坐标表；使用普通 `HashMap`，不要改回 Compose StateMap（滚动/返回动画期间 `onGloballyPositioned` 高频写入会触发重组卡顿）
-> - `displayOrder` —— 真实布局顺序，拖动中不改
-> - `cardOrder`（外层 SharedPreferences）—— 持久化的用户偏好顺序
-
-**图表自适应**：
-
-> `UsageDetailScreen` / `UsageChartScreen` 通过 `BoxWithConstraints` 判断容器宽度 > 700dp 时图表并排（前两张 50/50，第三张独占一行），反之纵向堆叠。阈值 700dp 高于 Dashboard 的 600dp，因为图表卡片需要更多空间。
-
-**页面导航**：
-```
-Compact（手机）：
-  Dashboard → OCGO: UsageDetail（图表） → UsageOverview（总统计）
-                            ↘ UsageData（原始数据）
-            → CCGO: CCGO_USAGE_DETAIL（图表） → CCGO_USAGE_OVERVIEW（总统计）
-                                          ↘ CCGO_USAGE_DATA（原始数据）
-            → Settings → Tips（使用小技巧）
-
-  返回用 guardedPop()（200ms 时间戳围栏，PopGuard 非 State 对象）+ Android predictive back。
-Manifest 开启 `android:enableOnBackInvokedCallback="true"`；`navigation-compose` 保持 2.9.x 以上，使用后续 predictive back 修复。
-Compact 根 `NavHost` 必须显式配置 `enterTransition` / `exitTransition` / `popEnterTransition` / `popExitTransition` 四项：
-前进统一左滑，返回统一右滑，避免只配置 pop 时短时间返回混入默认淡入淡出。
-当前页面背景/渐变层不适合 `scaleOut` 或长透明淡出类返回动画，容易出现透明背景和文字叠影；若要改动画，先处理 destination 的不透明背景层。
-PopGuard 额外检查 previousBackStackEntry != null，且 popBackStack() 返回 false 时 reset 围栏。
-
-Expanded（平板，≥840dp）：
-  ┌─ 左侧 35%: Dashboard（固定） ─┐  ┌─ 右侧 65%: when(pane) 原子切换 ─────┐
-  │                                │  │  ServiceDetail / OCGOUsage / CCGOUsage │
-  │                                │  │  Settings（内嵌 NavHost → Tips）      │
-  └────────────────────────────────┘  └────────────────────────────────────────┘
-  右侧用量详情内部子路由：图表 → 总览 / 原始数据（OCGO/CCGO/Settings 各自用局部 NavHost）
-  面板切换用 when(pane) 分支（同一帧原子重组，零穿透），子路由由局部 NavHost 的 popBackStack() 内置防护。
-```
-
-**桌面小组件（Widget）**：
-- 显示当前选中服务的用量+DeepSeek 余额
-- 支持四服务切换：OCGO / CCGO / Codex / Ollama（右上角 ↻ 按钮旁的切换按钮循环切换）
-- 右上角 ↻ 手动刷新按钮（后台广播 → `WidgetRefreshReceiver` → EntryPoints 获取 `RefreshBalanceUseCase`）
-- 刷新逻辑：只刷新当前选中服务 + DeepSeek，不再串行刷全部服务；25s 超时保护；`isRefreshing` 互斥锁防连续点击
-- 点击刷新后立即更新 Widget 右上角时间为"刷新中..."（`showRefreshing()`），再后台请求网络
-- 进度条颜色按百分比动态变化（<50% 草莓粉 / 50-80% 暖橙 / >80% 玫红）
-- **MIUI Widget 适配**：`miuiWidget` 标识 → 可拖入负一屏；`miui.appwidget.action.APPWIDGET_UPDATE` 曝光刷新（划到即触发，20s 冷却）；`@android:id/background` 根布局 ID（系统统一裁切圆角）
-- **自动刷新**：`onUpdate()` 内缓存为空或超过 5 分钟冷却时自动发送 `WidgetRefreshReceiver` 广播
-- **一键添桌面**：Dashboard 顶部栏 + 按钮 → 二次确认弹窗 → 权限检测（Manifest `INSTALL_SHORTCUT` + MIUI AppOps `android:install_shortcut`）→ `requestPinAppWidget`（有 fallback 到 `ACTION_APPWIDGET_PICK`）
-- 服务切换状态持久化到 SharedPreferences（`widget_auto_refresh` 中的 `display_service` key），切换后立即调用 `notifyDataChanged` 触发 `onUpdate()` 渲染
-
-**小组件点击绑定**：
-
-> `widget_wordmark` + `widget_open_hint`（`>` 箭头）→ 打开 APP；`widget_content` / `widget_switch` / `widget_service_title` → 切换服务广播 `ACTION_SWITCH_SERVICE`；`widget_refresh` → 刷新广播。
-> 切换 requestCode=2，刷新 requestCode=1。左上角 `>` 箭头是可点击进 APP 的视觉提示（ASCII `>` 替代 Unicode `›`，确保全 ROM 兼容）。
-
-**使用小技巧系统**：
-
-> - `AppTips`（`ui/components/AppTips.kt`）集中管理 13 条技巧，每条含 `title` / `hint`（一句话）/ `detail`（详细说明）
-> - Dashboard 卡片上方每次启动随机显示一条 `hint`（`remember { AppTips.randomHint() }`，不自动轮换）
-> - 设置页 `💡 使用小技巧` 卡片 → `TipsScreen` 独立页面（Route `tips`），LazyColumn 逐条展示
-> - 首次进入 Dashboard 显示一次性"长按卡片可拖拽排序"提示横幅，SharedPreferences `dashboard_ui_hints` 的 `drag_hint_shown` 标记
-
-**图表默认 tooltip**：
-
-> `StackedBarChart` / `LineChart` 的 `tooltipBucket` 初始值为 `buckets.lastOrNull()`，进入图表页即可看到最新时段数值详情，暗示图表可交互。
-
-**测试体系**：
-
-- 纯 JVM 单元测试（`testDebugUnitTest`），无 Android 框架依赖，无网络
-- 5 个测试文件，78 个用例：
-  - `OllamaRepositoryTest`（16）— HTML 解析：plan/百分比/时间戳/模型次数/空输入
-  - `OpenCodeGoRepositoryTest`（10）— SSR hydration 解析：三窗口/嵌套/缺失字段
-  - `FormatUtilsTest`（18）— `formatAmount`/`formatResetInSec`/`formatResetForWidget`/`normalizeWindowLabel`
-  - `FormatCodexPrimaryLabelTest`（9）— `formatCodexPrimaryLabel`：null fallback/大小写/未知值
-  - `CodexRepositoryTest`（25）— `durationLabel` 阈值 + `parseUsageWindows` JsonNull 安全 + `parseSseResponse` SSE 解析
-- CodexRepository 中 `parseUsageWindows`/`durationLabel`/`UsageWindow` 为 `internal`（companion object），`parseSseResponse` 为 `internal` 顶层函数——不使用实例状态，便于测试直接调用
-
-**CI workflow（`.github/workflows/ci.yml`）**：
-
-- 触发：push main / 所有 PR
-- 3 个 job 串行（test 通过后才构建）：
-  1. `test`：`testDebugUnitTest` + `lintDebug`，上传 XML 测试报告 + lint 报告 artifact
-  2. `build-debug`：`assembleDebug`，上传 Debug APK artifact
-  3. `build-release`：`assembleRelease` + APK 完整性验证（`AndroidManifest.xml` + `resources.arsc` + `res/`），上传 Release APK artifact
-- Release 签名 fallback：CI 无 `release.jks`，`build.gradle.kts` 仅在 `CI=true` 环境变量下 fallback 到 `~/.android/debug.keystore`；本地构建缺 `release.jks` 时直接 `GradleException` 报错，防止静默生成 debug 签名的 Release APK
-- artifact 保留 14 天
-
-**重大修改 PR 审计红线**：
-
-> ⚠️ 重大修改（构建配置、签名、CI、架构变更、新服务接入）必须通过 PR 提交，不能直接 push main。
-> PR 触发 CI 三 job 全部通过后才可合并：单元测试 + lint + Debug/Release APK 构建验证。
-> Release APK 完整性验证（manifest + arsc + res/）是防止 ARM64 Proot 构建问题再次发生的最后防线。
-
-## RemoteViews 兼容性红线
-
-以下元素在 Widget 布局中**不可用**，会导致「载入出现问题」：
-
-| ❌ 不可用 | ✅ 替代方案 |
-|-----------|------------|
-| `<Space>` | 透明 ProgressBar（`0dp + weight=1`） |
-| `<View>` | ProgressBar 或 TextView |
-| `<ImageView>` + 矢量 drawable | PNG（`drawable-nodpi`）。Widget logo 必须用 `_widget` 后缀 PNG（`ic_opencode_go_logo_widget.png`、`ic_codex_logo_widget.png`）；DeepSeek / Ollama 已有 PNG（`ic_deepseek_logo.png`、`ic_ollama_logo.png`）。Compose 层（`ServiceIcon.kt`）继续用 VectorDrawable XML。 |
-| `<TextView>` `0dp+weight=1` 空串 spacer | ProgressBar spacer |
-| `<TextView>` 固定 dp 宽度 + `gravity` | 仅固定 dp，不加 gravity |
-
-## 关键命令
-
-```bash
-cd /data/user/0/com.ai.assistance.operit/files/workspace/Rainytoken
-export ANDROID_HOME=$HOME/Android
-export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-arm64
-
-./gradlew testDebugUnitTest
-# 78 个单元测试，纯 JVM，无设备依赖
-
-./gradlew assembleDebug
-# Debug APK: app/build/outputs/apk/debug/app-debug.apk
-
-./gradlew assembleRelease
-# Release APK: app/build/outputs/apk/release/app-release.apk
-# ARM64 Proot 需 ~/.gradle/gradle.properties 配置 aapt2FromMavenOverride（见红线）
-# CI x86_64 无需额外配置
-```
-
-## 数据流
-
-```
-DashboardViewModel.refresh()
-  → RefreshBalanceUseCase(service) （retryOnTransientError: Network/5xx 指数退避重试 2 次）
-    → DeepSeekRepository.fetchBalance()    / OpenCodeGoRepository.fetchBalance()
-    → CommandCodeGoRepository.fetchBalance() / CodexRepository.fetchBalance()
-    → OllamaRepository.fetchBalance()
-  → BalanceCache.put(service, result) — put() 在 dataStore.edit {} 互斥锁内做 read-modify-write，避免并发覆盖
-  → OpenCodeGoWidgetProvider.notifyDataChanged(context)
-
-Dashboard 下拉刷新 → usageSyncTrigger++ → UsageViewModel.sync()
-  → OCGO: SyncUsageUseCase.fullSync() / incrementalSync()
-    → OpenCodeUsageRepository.fetchPage(cursor) 逐页抓取
-    → UsageCache.insertAll() → Room DAO insert（IGNORE 策略，去重）
-  → CCGO: SyncCommandCodeUsageUseCase.fullSync() / incrementalSync()
-    → CommandCodeUsageRepository.fetchPage(cursor) 逐页抓取
-  → UsageViewModel.loadStats() → getRecords() → 内存聚合
-
-CCGO 清除按钮（详情页顶栏）：
-  点击 → AlertDialog 警告弹窗 → 3s 倒计时确认
-  → UsageViewModel.clearAndResync()
-    → UsageCache.deleteByWorkspaceId("commandcode")
-    → SyncCommandCodeUsageUseCase.fullSync()
-    → loadStats() → onBack()
-
-Widget 刷新按钮：
-  ↻ → PendingIntent.getBroadcast() → WidgetRefreshReceiver
-    → EntryPoints → RefreshBalanceUseCase(selectedService + DEEPSEEK)
-    → notifyDataChanged()
-
-MIUI 曝光刷新（用户划到负一屏/桌面）：
-  → miui.appwidget.action.APPWIDGET_UPDATE → onReceive() → onUpdate()
-    → 读缓存渲染
-    → 缓存为空/过期? → sendBroadcast(WidgetRefreshReceiver)
-```
-
-## 品牌色
-
-| 用途 | 色值 |
-|------|------|
-| 主品牌草莓粉 | `#FF85A2` |
-| 樱粉背景/点缀 | `#FFD1DC` |
-| 浅粉背景 | `#FFF0F5` |
-| 深暖文字 | `#3D2C35` |
-| 暖灰辅助 | `#8A7A82` |
-| 玫红（>80% 警示） | `#E91E63` |
-| 暖橙（50-80%） | `#FFA726` |
-
-深色模式下文字颜色由 `inkWarm()` / `inkMuted()` composable 自动切换（定义在 `Theme.kt`），静态资源通过 `drawable-night/` / `layout-night/` 适配。
+派发子代理任务（独立审计/探索/通用 subagent）时，prompt 中涉及工作区文件的所有路径必须使用完整绝对路径（以工作区根目录为前缀）。子代理没有工作区附着上下文，相对路径会导致其找不到文件或无法执行。

README.en.md

@@ -0,0 +1,238 @@
+# RainyToken (雨晴Token)
+
+> *"AI Balance & Usage at a Glance"*
+
+[![CI](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/ci.yml/badge.svg)](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/ci.yml)
+[![Release](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/release.yml/badge.svg)](https://github.com/CATMIAOZHI/Rainytoken/actions)
+[![Version](https://img.shields.io/github/v/release/CATMIAOZHI/Rainytoken?color=ff85a2)](https://github.com/CATMIAOZHI/Rainytoken/releases)
+Android app for checking AI balance & usage — unified view of DeepSeek, OpenCode Go, CommandCode, Codex / ChatGPT, and Ollama balances and usage quotas. Pink-toned brand UI, with companion home screen widgets.
+RainyToken (雨晴Token) — AI Balance & Usage Quota Query · the Rainy Family tools.
+
+---
+
+## 📸 Screenshots
+
+<p align="center">
+  <img src="docs/screenshots/dashboard-light.jpg" width="200" alt="Dashboard (light)" />
+  <img src="docs/screenshots/dashboard-dark.jpg" width="200" alt="Dashboard (dark)" />
+  <img src="docs/screenshots/detail.jpg" width="200" alt="Usage charts" />
+  <img src="docs/screenshots/ollama-detail.jpg" width="200" alt="Ollama model call counts" />
+</p>
+
+<p align="center">
+  <em>Dashboard (light) · Dashboard (dark) · Usage charts · Ollama model call counts</em>
+</p>
+
+<p align="center">
+  <img src="docs/screenshots/widget.jpg" width="300" alt="Home screen widget" />
+  <img src="docs/screenshots/ollama-card.jpg" width="200" alt="Ollama card" />
+</p>
+
+<p align="center">
+  <em>Home screen widget · Ollama home card</em>
+</p>
+
+<p align="center">
+  <img src="docs/screenshots/heatmap.jpg" width="200" alt="Token Activity" />
+</p>
+
+<p align="center">
+  <em>Token Activity</em>
+</p>
+
+---
+
+## ✨ Features
+
+| Feature | Description |
+|------|------|
+| 📊 **Dashboard** | DeepSeek balance (¥) + usage/balance cards for each service; OCGO/CCGO cards link directly to usage details; long-press & drag to reorder (persisted); pull-to-refresh globally · tablet-adaptive two-pane layout |
+| 📈 **Usage charts** | 3 Canvas-drawn charts — amount spent / API request count / token consumption (dual data sources: OCGO & CCGO); UTC+0/UTC+8 timezone switching and custom day/month/range; automatic fallback (no data in last 5h → 12h → 7 days → current month); side-by-side on tablets |
+| 🗓️ **Token Activity** | OCGO daily token heatmap (GitHub contribution-graph style): daily / weekly / cumulative views + year switching (last 365 days by default, or a calendar year); personal profile + activity insights (total requests / top 3 request hours) + yearly stats (total / peak / streaks); 6-level pink quantile scale, tap / slide to inspect |
+| 📱 **Tablet adaptation** | Global `BoxWithConstraints` adaptive container width; ≥600dp dual-column cards, ≥700dp side-by-side charts; two-pane 35/65 split (Expanded mode); supports Android 13+ predictive back gestures |
+| 📋 **Detailed data** | Paginated browsing of raw records with time + model filtering; tap to view full fields |
+| 🔍 **Multi-granularity filters** | 5 hours / 12 hours (10-minute buckets) / 24 hours / today / yesterday / last 7 days / last 30 days / current month / custom day · month · range |
+| 🏷️ **Model filtering** | Multi-select / single-select / select all, with dynamic legends that wrap automatically |
+| 📱 **Home screen widget** | Check usage without opening the app; switch between four services (OCGO/CCGO/Codex/Ollama) + DeepSeek balance; top-left corner → open app, tap elsewhere to switch, ↻ to refresh; can be added to the At a Glance screen; auto-refreshes when scrolled into view (MIUI exposure refresh) |
+| 🔄 **Auto sync** | Pull-to-refresh on home auto-syncs usage; auto full sync on startup when no cache; CCGO detail page supports manual clear & re-sync |
+| 🌙 **Dark mode** | Fully adaptive — in-app text/icons/background switch automatically; widget adapts independently with a dark layout |
+| ➕ **One-tap add to home screen** | Tap + inside the app to add the widget directly, no need to browse the system list; double confirmation + permission check |
+| 💡 **Usage tips** | Home page shows a random operation tip (refreshed on each launch); settings page lists all 13 hidden tips |
+| ⚡ **Room database** | Usage records stored in Room (indexed on workspaceId+timeCreated); DAO queries replace full JSON serialization; auto-migration from the legacy DataStore on first launch |
+| 🎀 **Rainy pink theme** | Material Design 3 · Refined Rose primary #C9436C · Blush white background #FDEFF4 |
+| 🔐 **Codex OAuth sign-in** | Headless OAuth PKCE: the app generates an authorization link → sign in in an external browser → paste the callback URL to complete authorization; no manual auth.json export needed |
+| ⚡ **Codex one-tap usage activation** | Codex detail page can send a short request to the ChatGPT API to trigger usage tracking; model list fetched dynamically from models.dev and persisted, with manual refresh; response dialog is copyable |
+| ⚡ **OCGO / Ollama one-tap usage activation** | OCGO detail page can send a request to `opencode.ai/zen/v1`, Ollama detail page to `ollama.com/v1` to trigger usage tracking; API keys are entered manually in settings; model lists fetched dynamically from models.dev |
+| 🐛 **Debug logs** | In-app "Debug Logs" page showing detailed logs of Repository network requests, token refreshes, parse errors, etc.; no computer needed |
+| 🌐 **Multilingual** | Simplified Chinese / 繁體中文 / English interface; one-tap switching in settings (follow system / Simplified / Traditional / English); two-way sync with the system "App languages" page on Android 13+; non-CN/EN system languages fall back to English; home screen app name and widget follow the language |
+
+---
+
+## 📦 Download
+
+Download the latest APK from [Releases](https://github.com/CATMIAOZHI/Rainytoken/releases).
+
+> ⚠️ You need a DeepSeek API Key, OpenCode Go login credentials, CommandCode API Key, Codex (OAuth sign-in or pasted auth.json), or an Ollama Cookie to fetch data.
+
+---
+
+## 🏗️ Architecture
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                           Android App                            │
+│                                                                  │
+│  ┌────────────────────────────────────────────────────────────┐  │
+│  │ Compose UI (3-layer screens)                               │  │
+│  │ Dashboard · Usage Charts · Totals                          │  │
+│  │ Detail · Token Activity · Settings                         │  │
+│  └──────────────────────────────┬─────────────────────────────┘  │
+│                                 │                                │
+│  ┌──────────────────────────────▼─────────────────────────────┐  │
+│  │ ViewModel Layer (MVVM)                                     │  │
+│  │ DashboardVM · UsageVM · UsageChartVM                       │  │
+│  │ · UsageDataVM (Hilt injected)                              │  │
+│  └──────────────────────────────┬─────────────────────────────┘  │
+│                                 │                                │
+│  ┌──────────────────────────────▼─────────────────────────────┐  │
+│  │ UseCase Layer                                              │  │
+│  │ RefreshBalanceUseCase (balance)                            │  │
+│  │ SyncUsageUseCase / SyncCommandCodeUsageUseCase             │  │
+│  └──────────────────────────────┬─────────────────────────────┘  │
+│                                 │                                │
+│  ┌──────────────────────────────▼─────────────────────────────┐  │
+│  │ Repository + Network                                       │  │
+│  │ DeepSeekApi (Retrofit) · OpenCodeGo web scraping           │  │
+│  │ · OpenCodeUsageRepository · CommandCodeUsageRepository     │  │
+│  │ · CodexRepository · OllamaRepository (OkHttp)              │  │
+│  └──────────────────────────────┬─────────────────────────────┘  │
+│                                 │                                │
+│  ┌──────────────────────────────▼─────────────────────────────┐  │
+│  │ Local Storage                                              │  │
+│  │ BalanceCache (DataStore)                                   │  │
+│  │ UsageCache (Room, indexed on workspaceId+timeCreated)      │  │
+│  │ CredentialRepository (Keystore AES-256 GCM)                │  │
+│  └────────────────────────────────────────────────────────────┘  │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 📁 Project Structure
+
+```
+Rainytoken/
+├── app/src/main/java/com/rainy/token/
+│   ├── data/
+│   │   ├── cache/          # BalanceCache (DataStore)
+│   │   ├── local/          # UsageCache (Room), UsageRecordEntity, UsageDao, UsageDatabase, ChartBucket
+│   │   ├── remote/         # DeepSeekApi (Retrofit) + OpenCodeGo scraping + UsageRepository
+│   │   └── repository/     # DeepSeek / OpenCodeGo / CommandCode / Codex / Ollama / Credential repositories
+│   ├── domain/
+│   │   ├── model/          # ServiceBalance, Credential, etc.
+│   │   ├── service/        # ServiceType enum
+│   │   └── usecase/        # RefreshBalanceUseCase / SyncUsageUseCase / SyncCommandCodeUsageUseCase
+│   ├── ui/
+│   │   ├── dashboard/      # DashboardScreen / UsageDetailScreen / UsageOverviewScreen / UsageDataScreen
+│   │   ├── heatmap/        # Token Activity heatmap (HeatmapScreen / HeatmapCanvas / HeatmapViewModel)
+│   │   ├── servicedetail/  # Service detail (ServiceDetailScreen)
+│   │   ├── settings/       # Settings / credential editing (SettingsScreen / CredentialEditScreen)
+│   │   ├── webview/        # Web login / Codex OAuth (WebViewLoginScreen / CodexOAuthScreen)
+│   │   ├── widget/         # Home screen widget (OpenCodeGoWidgetProvider)
+│   │   ├── components/     # ServiceIcon / StatusChip, etc.
+│   │   ├── theme/          # Rainy pink theme (StrawberryPink / InkMuted)
+│   │   └── RainyTokenNavHost.kt  # Navigation routes
+│   └── di/                 # Hilt modules
+├── gradle/libs.versions.toml   # Version Catalog dependency management
+├── build.gradle.kts            # Project-level configuration
+└── settings.gradle.kts         # Project settings
+```
+
+---
+
+## 🛠️ Build
+
+### Option 1: Android Studio (recommended)
+1. Clone the repository: `git clone https://github.com/CATMIAOZHI/Rainytoken.git`
+2. Open the project in Android Studio
+3. Sync Gradle, connect a device, and hit Run ▶️
+
+### Option 2: Command line
+```bash
+# Run unit tests
+./gradlew testDebugUnitTest
+
+# Build a Debug APK
+./gradlew assembleDebug
+# APK output: app/build/outputs/apk/debug/app-debug.apk
+
+# Build a Release APK
+./gradlew assembleRelease
+```
+
+<details>
+<summary>🔧 ARM64 environment notes (optional)</summary>
+
+The project bundles an ARM64 AAPT2 binary, which is enabled automatically in ARM64 environments such as Proot/Termux:
+```bash
+chmod +x ./setup_android_env.sh
+./setup_android_env.sh
+```
+The script configures `$ANDROID_HOME` and uses the project-bundled ARM64 build-tools.
+
+**Extra Release build configuration**: Under ARM64 Proot, AGP 9.0 passes `--resource-path-shortening-map=<path>` (equals-sign syntax) to `optimizeReleaseResources`, which the ARM64 AAPT2 does not accept. Configure the AAPT2 wrapper in `~/.gradle/gradle.properties` (global, not committed to the repository):
+```properties
+android.aapt2FromMavenOverride=/path/to/android-aapt2-wrapper/aapt2
+```
+The wrapper script splits the equals-sign syntax into two separate space-delimited argv entries. The project's `build.gradle.kts` includes a built-in `guardReleaseResources` task as a build safeguard (falls back to the linked `.ap_` automatically when the optimized `.ap_` is missing).
+> On x86_64 environments (GitHub Actions / regular Linux), the official AAPT2 is used automatically — no extra steps required.
+</details>
+
+---
+
+## 📦 Dependency Management
+
+The project manages all dependencies with a Gradle Version Catalog (`gradle/libs.versions.toml`).
+
+| Dependency | Purpose |
+|------|------|
+| `androidx.compose:compose-bom` | Jetpack Compose BOM |
+| `androidx.navigation:navigation-compose` | Page navigation |
+| `com.squareup.retrofit2:retrofit` | DeepSeek REST API |
+| `com.squareup.okhttp3:okhttp` | OpenCode Go web scraping |
+| `org.jetbrains.kotlinx:kotlinx-serialization-json` | JSON serialization |
+| `androidx.room:room-runtime` | Local usage database (Room) |
+| `androidx.datastore:datastore-preferences` | Local caching |
+| `com.google.dagger:hilt-android` | Dependency injection |
+| `com.google.devtools.ksp:symbol-processing-api` | KSP annotation processing |
+
+---
+
+## 🔒 Security
+
+- ✅ API keys / session credentials are stored in the **Android Keystore** (AES-256 GCM encrypted)
+- ✅ Network requests are only sent to the official DeepSeek / OpenCode APIs
+- ✅ `allowBackup=false`: encrypted credentials and usage data are excluded from system backups, preventing undecryptable ciphertext when restoring on a new device
+- ✅ Fixed signing key — every Release can be installed over the previous version
+- ✅ Signing keys and passwords are stored encrypted in GitHub Secrets and decrypted during CI
+
+---
+
+## 🐱 About
+
+RainyToken (雨晴Token) is the 4th member of the "Rainy Family" tools, maintained by [雨晴喵 (Rainy)](https://github.com/CATMIAOZHI), released alongside the [Rainy Family](https://github.com/CATMIAOZHI?tab=repositories):
+
+- [RainyLLM](https://github.com/CATMIAOZHI/RainyLLM) — fully offline Android local LLM inference server (Gemma + OpenAI-compatible API)
+- [RainyScanner](https://github.com/CATMIAOZHI/RainyScanner) — Android QR scanner that neither intercepts nor redirects
+- [Rainy2FA](https://github.com/CATMIAOZHI/Rainy2FA) — fully local · zero network · biometric-protected TOTP authenticator
+- **RainyToken** — AI Balance & Usage Quota Query (this project)
+
+---
+
+## 📄 License
+
+MIT License © 2026 Rainy
+
+---
+
+<p align="center">RainyToken · the Rainy Family tools</p>

README.md

@@ -1,12 +1,12 @@
 # 🌧️ 雨晴Token (RainyToken)
 
-> *"AI 用量，尽在掌握 — AI Balance & Usage at a Glance"* 🐱✨
+> *"AI 用量，尽在掌握 — AI Balance & Usage at a Glance"*
 
 [![CI](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/ci.yml/badge.svg)](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/ci.yml)
 [![Release](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/release.yml/badge.svg)](https://github.com/CATMIAOZHI/Rainytoken/actions)
 [![Version](https://img.shields.io/github/v/release/CATMIAOZHI/Rainytoken?color=ff85a2)](https://github.com/CATMIAOZHI/Rainytoken/releases)
-Android AI 余额与用量查询 APP —— 统一查看 DeepSeek、OpenCode Go、CommandCode Go、Codex / ChatGPT Plus、Ollama Pro 的余额与用量配额。粉色调品牌 UI，配套桌面小组件。
-🐱 雨晴Token — AI Balance & Usage Quota Query | the Rainy Family tools.
+Android AI 余额与用量查询 APP —— 统一查看 DeepSeek、OpenCode Go、CommandCode、Codex / ChatGPT、Ollama 的余额与用量配额。粉色调品牌 UI，配套桌面小组件。
+RainyToken（雨晴Token）— AI Balance & Usage Quota Query · the Rainy Family tools.
 
 ---
 
@@ -16,20 +16,28 @@ Android AI 余额与用量查询 APP —— 统一查看 DeepSeek、OpenCode Go
   <img src="docs/screenshots/dashboard-light.jpg" width="200" alt="仪表盘（亮色）" />
   <img src="docs/screenshots/dashboard-dark.jpg" width="200" alt="仪表盘（深色）" />
   <img src="docs/screenshots/detail.jpg" width="200" alt="用量图表" />
-  <img src="docs/screenshots/ollama-detail.jpg" width="200" alt="Ollama Pro 模型调用次数" />
+  <img src="docs/screenshots/ollama-detail.jpg" width="200" alt="Ollama 模型调用次数" />
 </p>
 
 <p align="center">
-  <em>仪表盘（亮色） · 仪表盘（深色） · 用量图表 · Ollama Pro 模型调用次数</em>
+  <em>仪表盘（亮色） · 仪表盘（深色） · 用量图表 · Ollama 模型调用次数</em>
 </p>
 
 <p align="center">
   <img src="docs/screenshots/widget.jpg" width="300" alt="桌面小组件" />
-  <img src="docs/screenshots/ollama-card.jpg" width="200" alt="Ollama Pro 卡片" />
+  <img src="docs/screenshots/ollama-card.jpg" width="200" alt="Ollama 卡片" />
 </p>
 
 <p align="center">
-  <em>桌面小组件 · Ollama Pro 首页卡片</em>
+  <em>桌面小组件 · Ollama 首页卡片</em>
+</p>
+
+<p align="center">
+  <img src="docs/screenshots/heatmap.jpg" width="200" alt="Token 活动" />
+</p>
+
+<p align="center">
+  <em>Token 活动</em>
 </p>
 
 ---
@@ -40,9 +48,10 @@ Android AI 余额与用量查询 APP —— 统一查看 DeepSeek、OpenCode Go
 |------|------|
 | 📊 **仪表盘** | DeepSeek 余额（¥）+ 各服务用量/余额卡片；OCGO/CCGO 卡片可直达用量详情；长按拖动自由排序（持久化）；下拉全局刷新 · 平板自适应双窗格布局 |
 | 📈 **用量图表** | 3 张 Canvas 手绘图表 — 消耗金额 / API 请求次数 / Token 消耗（OCGO & CCGO 双数据源）；支持 UTC+0/UTC+8 时区切换和自定义日/月/范围；自动降级（近5h无数据→12h→7天→当月）；平板并排展示 |
+| 🗓️ **Token活动** | OCGO每日 Token热力图（GitHub贡献图风格）：每日 /每周 /累计三视图 +年份切换（默认最近 365 天，可切换自然年）；个人资料 +活动洞察（总请求次数 /最多请求时段 Top 3）+年度统计（累计 /峰值 /连续天数）；6 级粉色分位色阶，点击 /滑动查看 |
 | 📱 **平板适配** | 全局 `BoxWithConstraints` 自适应容器宽度；≥600dp 卡片双列，≥700dp 图表并排；双窗格 35/65 左右分栏（Expanded 模式）；支持 Android 13+ 预见性返回手势 |
 | 📋 **详细数据** | 原始记录分页浏览，支持时间 + 模型筛选，点击查看完整字段 |
-| 🔍 **多粒度筛选** | 5小时 / 12小时(10分钟桶) / 24小时 / 今天 / 昨天 / 最近7天 / 当月 / 自定义日·月·范围 |
+| 🔍 **多粒度筛选** | 5小时 / 12小时(10分钟桶) / 24小时 / 今天 / 昨天 / 最近7天 / 最近30天 / 当月 / 自定义日·月·范围 |
 | 🏷️ **模型筛选** | 多选 / 单选 / 全选，动态图例自适应换行 |
 | 📱 **桌面小组件** | 不打开 APP 也能看用量；支持四服务切换（OCGO/CCGO/Codex/Ollama）+ DeepSeek 余额；左上角 > 进 APP、其他区域点切换、↻ 刷新；可拖入负一屏；划到即自动刷新（MIUI 曝光刷新） |
 | 🔄 **自动同步** | 首页下拉自动同步用量；无缓存时启动自动全量同步；CCGO 详情页支持手动清除并重新同步 |
@@ -50,11 +59,12 @@ Android AI 余额与用量查询 APP —— 统一查看 DeepSeek、OpenCode Go
 | ➕ **一键添桌面** | APP 内点 + 直接添加小组件，不用去系统列表翻；二次确认 + 权限检测 |
 | 💡 **使用小技巧** | 首页随机展示一条操作提示（每次启动刷新）；设置页可查看全部 13 条隐藏操作技巧 |
 | ⚡ **Room 数据库** | 用量记录存 Room（indexed on workspaceId+timeCreated），DAO 查询替代全量 JSON 序列化；首次启动自动从旧 DataStore 迁移 |
-| 🎀 **雨晴粉主题** | Material Design 3 · 草莓粉 #FF85A2 · 樱粉 #FFD1DC |
+| 🎀 **雨晴粉主题** | Material Design 3 · 精致玫瑰粉 主色 #C9436C · 粉白背景 #FDEFF4 |
 | 🔐 **Codex OAuth 登录** | 无头模式 OAuth PKCE：APP 生成授权链接 → 外部浏览器登录 → 粘贴回调 URL 完成授权，无需手动导出 auth.json |
 | ⚡ **Codex 一键激活用量** | Codex 详情页可向 ChatGPT API 发送简短请求触发用量统计；模型列表从 models.dev 动态获取并持久化，支持手动刷新；响应弹窗可复制 |
 | ⚡ **OCGO / Ollama 一键激活用量** | OCGO 详情页可向 `opencode.ai/zen/v1` 发送请求，Ollama 详情页可向 `ollama.com/v1` 发送请求触发用量统计；API Key 在设置页手动填写，模型列表从 models.dev 动态获取 |
 | 🐛 **调试日志** | APP 内「调试日志」页面，查看 Repository 网络请求、Token 刷新、解析错误等详细日志，无需连接电脑 |
+| 🌐 **多语言** | 简体中文 / 繁體中文 / English 三语言界面；设置页一键切换（跟随系统 / 简体 / 繁体 / English）；Android 13+ 与系统「应用语言」页双向同步；非中英系统语言自动回退英文；桌面 APP 名称与小组件跟随语言 |
 
 ---
 
@@ -62,7 +72,7 @@ Android AI 余额与用量查询 APP —— 统一查看 DeepSeek、OpenCode Go
 
 前往 [Releases](https://github.com/CATMIAOZHI/Rainytoken/releases) 下载最新 APK。
 
-> ⚠️ 需要配置 DeepSeek API Key、OpenCode Go 登录凭据、CommandCode Go API Key、Codex（OAuth 登录或粘贴 auth.json）或 Ollama Pro Cookie 才能拉取数据。
+> ⚠️ 需要配置 DeepSeek API Key、OpenCode Go 登录凭据、CommandCode API Key、Codex（OAuth 登录或粘贴 auth.json）或 Ollama Cookie 才能拉取数据。
 
 ---
 
@@ -74,7 +84,8 @@ Android AI 余额与用量查询 APP —— 统一查看 DeepSeek、OpenCode Go
 │                                                   │
 │  ┌─────────────────────────────────────────────┐ │
 │  │        Compose UI（3 层页面）                │ │
-│  │  仪表盘 · 用量图表 · 总统计 · 详细数据 · 设置│ │
+│  │  仪表盘 · 用量图表 · 总统计                  │ │
+│  │  详细数据 · Token活动 · 设置                 │ │
 │  └────────────────────┬────────────────────────┘ │
 │                       │                           │
 │  ┌────────────────────▼─────────────────────────┐ │
@@ -122,6 +133,10 @@ Rainytoken/
 │   │   └── usecase/        # RefreshBalanceUseCase / SyncUsageUseCase / SyncCommandCodeUsageUseCase
 │   ├── ui/
 │   │   ├── dashboard/      # DashboardScreen / UsageDetailScreen / UsageOverviewScreen / UsageDataScreen
+│   │   ├── heatmap/        # Token活动热力图（HeatmapScreen / HeatmapCanvas / HeatmapViewModel）
+│   │   ├── servicedetail/  # 服务详情（ServiceDetailScreen）
+│   │   ├── settings/       # 设置 /凭据编辑（SettingsScreen / CredentialEditScreen）
+│   │   ├── webview/        # 网页登录 / Codex OAuth（WebViewLoginScreen / CodexOAuthScreen）
 │   │   ├── widget/         # 桌面小组件（OpenCodeGoWidgetProvider）
 │   │   ├── components/     # ServiceIcon / StatusChip 等
 │   │   ├── theme/          # 雨晴粉主题（StrawberryPink / InkMuted）
@@ -204,14 +219,14 @@ wrapper 脚本将等号形式拆分为空格分隔的两个独立 argv。项目
 
 ## 🐱 关于
 
-RainyToken（雨晴Token）是「雨晴系列」的第 4 个成员，由 [雨晴喵](https://github.com/CATMIAOZHI) 编纂，随 [雨晴系列](https://github.com/CATMIAOZHI?tab=repositories) 发布：
+RainyToken（雨晴Token）是「雨晴系列」的第 4 个成员，由 [雨晴喵](https://github.com/CATMIAOZHI) 开发维护，随 [雨晴系列](https://github.com/CATMIAOZHI?tab=repositories) 发布：
 
 - [RainyLLM](https://github.com/CATMIAOZHI/RainyLLM) — 纯离线 Android 本地 LLM 推理服务器（Gemma + OpenAI 兼容 API）
 - [RainyScanner](https://github.com/CATMIAOZHI/RainyScanner) — 不拦截不跳转的 Android 扫码工具
 - [Rainy2FA](https://github.com/CATMIAOZHI/Rainy2FA) — 纯本地 · 零联网 · 生物识别保护的 TOTP 验证器
 - **RainyToken** — AI 余额与用量查询 APP | AI Balance & Usage Quota Query（本项目）
 
-> 🎀 Made with love by 雨晴喵 — 守护主人的每一分算力预算 💖
+> 守护每一分 AI 算力预算 💖
 
 ---
 
@@ -221,4 +236,4 @@ MIT License © 2026 Rainy
 
 ---
 
-<p align="center">💖 Made with love by 雨晴喵</p>
+<p align="center">RainyToken · the Rainy Family tools</p>

app/build.gradle.kts

@@ -16,8 +16,8 @@ android {
         applicationId = "com.rainy.token"
         minSdk = 31
         targetSdk = 35
-        versionCode = 7
-        versionName = "1.5.2"
+        versionCode = 14
+        versionName = "1.6.4"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {
@@ -32,9 +32,18 @@ android {
             val keystoreFile = rootProject.file("release.jks")
             if (keystoreFile.exists()) {
                 storeFile = keystoreFile
-                storePassword = System.getenv("KEYSTORE_PASSWORD") ?: "RainyToken2026!"
-                keyAlias = System.getenv("KEYSTORE_ALIAS") ?: "rainy"
-                keyPassword = System.getenv("KEY_PASSWORD") ?: "RainyToken2026!"
+                // 凭据必须通过环境变量注入；缺失或为空时直接报错，不提供任何隐式 fallback
+                // 注意：GitHub Actions 中未设置的 secret 会被替换为空字符串（非 null），
+                // 因此用 takeIf { isNotBlank() } 同时防御 null 和空字符串
+                storePassword = System.getenv("KEYSTORE_PASSWORD")
+                    ?.takeIf { it.isNotBlank() }
+                    ?: throw GradleException("KEYSTORE_PASSWORD env var not set or empty — cannot sign release")
+                keyAlias = System.getenv("KEYSTORE_ALIAS")
+                    ?.takeIf { it.isNotBlank() }
+                    ?: throw GradleException("KEYSTORE_ALIAS env var not set or empty — cannot sign release")
+                keyPassword = System.getenv("KEY_PASSWORD")
+                    ?.takeIf { it.isNotBlank() }
+                    ?: throw GradleException("KEY_PASSWORD env var not set or empty — cannot sign release")
             } else {
                 // 仅在 CI 环境中 fallback 到 debug keystore（用于编译/资源完整性验证）
                 // 本地构建缺少 release.jks 时直接报错，避免静默生成 debug 签名的 Release APK
@@ -75,6 +84,11 @@ android {
     }
     buildFeatures {
         compose = true
+        buildConfig = true
+    }
+    androidResources {
+        // Android 13+ 应用级语言设置：根据 values-* 目录自动生成 locales_config
+        generateLocaleConfig = true
     }
     packaging {
         resources {
@@ -176,6 +190,7 @@ dependencies {
 
     // Core
     implementation(libs.androidx.core.ktx)
+    implementation(libs.androidsvg)
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.lifecycle.runtime.compose)
     implementation(libs.androidx.lifecycle.viewmodel.compose)

app/src/main/AndroidManifest.xml

@@ -4,6 +4,7 @@
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="com.android.launcher.permission.INSTALL_SHORTCUT" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
 
     <application
         android:name=".RainyTokenApplication"
@@ -33,6 +34,15 @@
             android:name=".ui.widget.WidgetRefreshReceiver"
             android:exported="false" />
 
+        <!-- 每日自动签到：零点闹钟广播 + 开机后排程（Hilt 经 EntryPoint 注入，无 @AndroidEntryPoint） -->
+        <receiver
+            android:name=".ui.dashboard.autocheckin.AutoCheckinReceiver"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
+
         <!-- OpenCode Go 小组件（MIUI Widget） -->
         <receiver
             android:name=".ui.widget.OpenCodeGoWidgetProvider"
@@ -66,6 +76,16 @@
             android:name="miuiWidgetVersion"
             android:value="1" />
 
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
+
     </application>
 
 </manifest>

app/src/main/java/com/rainy/token/MainActivity.kt

@@ -1,5 +1,6 @@
 package com.rainy.token
 
+import android.content.Context
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
@@ -14,12 +15,17 @@ import dagger.hilt.android.AndroidEntryPoint
  *
  * 布局策略：
  *  - 外层只套 RainyTokenTheme（统一品牌色 + 字体）
- *  - 再套 RainyBackground（樱粉渐变背景，全局共享）
+ *  - 再套 RainyBackground（精致粉调渐变背景，全局共享）
  *  - NavHost 在背景之上，每个页面自己用 Scaffold 处理 TopAppBar 和 padding
  *  - **不**在外层再套 Scaffold —— 避免双 Scaffold 嵌套的 padding 计算混乱
  */
 @AndroidEntryPoint
 class MainActivity : ComponentActivity() {
+    override fun attachBaseContext(newBase: Context) {
+        // 应用内语言偏好在此层生效：recreate() 后资源按所选语言重新解析
+        super.attachBaseContext(com.rainy.token.util.LocaleManager.wrapContext(newBase))
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()

app/src/main/java/com/rainy/token/RainyTokenApplication.kt

@@ -12,6 +12,12 @@ import dagger.hilt.android.HiltAndroidApp
  */
 @HiltAndroidApp
 class RainyTokenApplication : Application() {
+    override fun attachBaseContext(base: Context) {
+        // 应用内语言偏好（跟随系统 / 中文 / English）在 Application 层生效，
+        // 保证 appContext 与系统级回调（如小组件）之外的代码都使用所选语言。
+        super.attachBaseContext(com.rainy.token.util.LocaleManager.wrapContext(base))
+    }
+
     override fun onCreate() {
         super.onCreate()
         appContext = applicationContext

app/src/main/java/com/rainy/token/data/cache/BalanceCache.kt

@@ -21,7 +21,11 @@ import kotlinx.serialization.json.Json
  *
  * 计划 7.1：断网时 UI 仍可展示 stale 数据。DataStore 文件名 `balance_cache`。
  *
- * 存储结构：JSON 序列化的 `Map<ServiceType, CachedBalance>`。
+ * 存储结构：
+ *  - `balance_cache_v3`：JSON 序列化的 `Map<ServiceType, CachedBalance>`，供单账号服务
+ *    （以及多账号服务的默认账号镜像，兼容旧读取路径）。
+ *  - `balance_cache_accounts_v1`：JSON 序列化的 `Map<String, CachedBalance>`，复合键
+ *    `"{service.storageKey}:{accountId}"`，存放多账号服务每个账号的独立缓存。
  */
 class BalanceCache(
     private val dataStore: DataStore<Preferences>,
@@ -31,6 +35,9 @@ class BalanceCache(
     // v3: 2026-07 统一 Codex amount 为 usedPct（之前是 remainingPct），旧缓存失效
     private val cacheKey = stringPreferencesKey("balance_cache_v3")
 
+    // v1: 2026-10 多账号服务按账号独立缓存
+    private val accountsCacheKey = stringPreferencesKey("balance_cache_accounts_v1")
+
     suspend fun getAll(): Map<ServiceType, CachedBalance> {
         val raw = dataStore.data.map { it[cacheKey] }.first() ?: return emptyMap()
         return decode(raw)
@@ -38,18 +45,46 @@ class BalanceCache(
 
     suspend fun get(service: ServiceType): CachedBalance? = getAll()[service]
 
-    suspend fun put(service: ServiceType, balance: ServiceBalance) {
+    /** 读取缓存：无 [accountId] 时读旧按服务缓存；指定账号时读账号分片缓存。 */
+    suspend fun get(service: ServiceType, accountId: String?): CachedBalance? =
+        if (accountId.isNullOrBlank()) {
+            getAll()[service]
+        } else {
+            getAllAccounts()[accountKey(service, accountId)]
+        }
+
+    /** 所有按账号分片的缓存，复合键 `"{service.storageKey}:{accountId}"`。 */
+    suspend fun getAllAccounts(): Map<String, CachedBalance> {
+        val raw = dataStore.data.map { it[accountsCacheKey] }.first() ?: return emptyMap()
+        return decodeAccounts(raw)
+    }
+
+    /** 读取指定账号的缓存（不含默认账号的旧镜像回退，由调用方处理）。 */
+    suspend fun getAccountCached(service: ServiceType, accountId: String): CachedBalance? =
+        getAllAccounts()[accountKey(service, accountId)]
+
+    /**
+     * 写入余额缓存。
+     *
+     * - [accountId] 为 null：写入旧的按服务缓存（单账号服务 / 多账号默认账号镜像）。
+     * - [accountId] 非 null：写入按账号缓存。
+     * 在 [RefreshWriteSession] 上下文中一律只暂存，由会话提交时按快照账号路由。
+     */
+    suspend fun put(
+        service: ServiceType,
+        balance: ServiceBalance,
+        accountId: String? = null
+    ) {
         currentCoroutineContext()[RefreshWriteSession]?.let { session ->
             session.stageBalance(service, balance)
             return
         }
-        putCached(
-            service = service,
-            cachedBalance = CachedBalance(
-                balance = balance,
-                fetchedAt = System.currentTimeMillis()
-            )
-        )
+        val cached = CachedBalance(balance = balance, fetchedAt = System.currentTimeMillis())
+        if (accountId.isNullOrBlank()) {
+            putCached(service, cached)
+        } else {
+            putAccountCached(service, accountId, cached)
+        }
     }
 
     /** 恢复一份已有缓存并保留原 fetchedAt；仅供凭据测试安全回滚使用。 */
@@ -61,8 +96,58 @@ class BalanceCache(
         }
     }
 
-    /** 删除单个服务缓存。凭据新增、替换或删除时由 CredentialRepository 调用。 */
+    /** 以账号复合键写入缓存（保留原 fetchedAt）。 */
+    internal suspend fun putAccountCached(
+        service: ServiceType,
+        accountId: String,
+        cachedBalance: CachedBalance
+    ) {
+        val key = accountKey(service, accountId)
+        dataStore.edit { prefs ->
+            val updated = decodeAccounts(prefs[accountsCacheKey]).toMutableMap()
+            updated[key] = cachedBalance
+            prefs[accountsCacheKey] = encodeAccounts(updated)
+        }
+    }
+
+    /** 删除单个服务的旧结构缓存。凭据新增、替换或删除时由 CredentialRepository 调用。 */
     suspend fun remove(service: ServiceType) {
+        dataStore.edit { prefs ->
+            var changed = false
+            val current = decode(prefs[cacheKey])
+            if (service in current) {
+                val updated = current.toMutableMap()
+                updated.remove(service)
+                if (updated.isEmpty()) {
+                    prefs.remove(cacheKey)
+                } else {
+                    prefs[cacheKey] = encode(updated)
+                }
+                changed = true
+            }
+            // 顺带清理该服务全部账号缓存（多账号服务删除整个服务时）
+            val accounts = decodeAccounts(prefs[accountsCacheKey])
+            val prefix = service.storageKey + ":"
+            val kept = accounts.filterKeys { !it.startsWith(prefix) }
+            if (kept.size != accounts.size) {
+                if (kept.isEmpty()) {
+                    prefs.remove(accountsCacheKey)
+                } else {
+                    prefs[accountsCacheKey] = encodeAccounts(kept)
+                }
+                changed = true
+            }
+            if (!changed) return@edit
+        }
+    }
+
+    /**
+     * 仅删除旧结构镜像缓存（[balance_cache_v3] 中该服务的条目），不动账号分片缓存。
+     *
+     * 多账号服务切换/删除默认账号时调用：旧镜像属于旧默认账号，若不清除，新默认账号
+     * 在尚无独立分片缓存时会回退读到旧默认账号的余额（缓存串号）。
+     */
+    suspend fun removeLegacy(service: ServiceType) {
         dataStore.edit { prefs ->
             val current = decode(prefs[cacheKey])
             if (service !in current) return@edit
@@ -76,10 +161,32 @@ class BalanceCache(
         }
     }
 
-    suspend fun clear() {
-        dataStore.edit { it.remove(cacheKey) }
+    /** 删除单个账号的缓存（默认账号的旧结构镜像由调用方另行清理）。 */
+    suspend fun removeAccount(service: ServiceType, accountId: String) {
+        val key = accountKey(service, accountId)
+        dataStore.edit { prefs ->
+            val current = decodeAccounts(prefs[accountsCacheKey])
+            if (key !in current) return@edit
+            val updated = current.toMutableMap()
+            updated.remove(key)
+            if (updated.isEmpty()) {
+                prefs.remove(accountsCacheKey)
+            } else {
+                prefs[accountsCacheKey] = encodeAccounts(updated)
+            }
+        }
     }
 
+    suspend fun clear() {
+        dataStore.edit {
+            it.remove(cacheKey)
+            it.remove(accountsCacheKey)
+        }
+    }
+
+    private fun accountKey(service: ServiceType, accountId: String) =
+        "${service.storageKey}:$accountId"
+
     private fun decode(raw: String?): Map<ServiceType, CachedBalance> {
         if (raw == null) return emptyMap()
         return runCatching {
@@ -96,6 +203,22 @@ class BalanceCache(
             value
         )
 
+    private fun decodeAccounts(raw: String?): Map<String, CachedBalance> {
+        if (raw == null) return emptyMap()
+        return runCatching {
+            json.decodeFromString(
+                MapSerializer(String.serializer(), CachedBalance.serializer()),
+                raw
+            )
+        }.getOrDefault(emptyMap())
+    }
+
+    private fun encodeAccounts(value: Map<String, CachedBalance>): String =
+        json.encodeToString(
+            MapSerializer(String.serializer(), CachedBalance.serializer()),
+            value
+        )
+
     companion object {
         val DefaultJson = Json {
             ignoreUnknownKeys = true
@@ -113,4 +236,4 @@ data class CachedBalance(
 /** 顶层 DataStore 委托。文件名对应计划 7.1。 */
 val Context.balanceCacheDataStore: DataStore<Preferences> by preferencesDataStore(
     name = "balance_cache"
-)
+)

app/src/main/java/com/rainy/token/data/local/ChartBucket.kt

@@ -1,5 +1,7 @@
 package com.rainy.token.data.local
 
+import androidx.annotation.StringRes
+import com.rainy.token.R
 import java.time.Instant
 import java.time.ZoneOffset
 
@@ -25,18 +27,19 @@ data class ModelBucket(
     val outputTokens: Long
 )
 
-/** 时间粒度 */
-enum class ChartGranularity(val label: String) {
-    LAST_5H_HOURLY("最近5小时"),
-    LAST_12H_10MIN("最近12小时"),
-    LAST_24H_HOURLY("最近24小时"),
-    TODAY_HOURLY("今天"),
-    YESTERDAY_HOURLY("昨天"),
-    LAST_7D_DAILY("最近7天"),
-    THIS_MONTH_DAILY("当月"),
-    CUSTOM_DAY_HOURLY("自定义日"),
-    CUSTOM_MONTH_DAILY("自定义月"),
-    CUSTOM_RANGE_DAILY("自定义日期")
+/** 时间粒度（label 用字符串资源 ID，UI 层按当前语言解析） */
+enum class ChartGranularity(@StringRes val labelRes: Int) {
+    LAST_5H_HOURLY(R.string.time_last_5h),
+    LAST_12H_10MIN(R.string.time_last_12h),
+    LAST_24H_HOURLY(R.string.time_last_24h),
+    TODAY_HOURLY(R.string.time_today),
+    YESTERDAY_HOURLY(R.string.time_yesterday),
+    LAST_7D_DAILY(R.string.time_last_7d),
+    LAST_30D_DAILY(R.string.time_last_30d),
+    THIS_MONTH_DAILY(R.string.time_this_month),
+    CUSTOM_DAY_HOURLY(R.string.time_custom_day),
+    CUSTOM_MONTH_DAILY(R.string.time_custom_month),
+    CUSTOM_RANGE_DAILY(R.string.time_custom_range)
 }
 
 /** 聚合工具 */

app/src/main/java/com/rainy/token/data/repository/CheckinStatusStore.kt

@@ -0,0 +1,141 @@
+package com.rainy.token.data.repository
+
+import android.content.Context
+import com.rainy.token.domain.service.ServiceType
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.time.LocalDate
+import javax.inject.Inject
+import javax.inject.Singleton
+import org.json.JSONObject
+
+/**
+ * 每日签到状态的统一本地记录（SharedPreferences "checkin_status"）。
+ *
+ * 一条记录包含：
+ *  - checkinDate：签到日期（本地时区 yyyy-MM-dd）
+ *  - status：签到结果状态（SUCCESS/ALREADY/FAILED/RETRYABLE/DEVICE_BLOCKED）
+ *  - checkinId：签到 id（服务端未提供时为空；新签到成功时生成本地 UUID 便于追溯）
+ *  - credits：签到获得数量
+ *  - updatedAt：本地记录更新时间戳
+ *
+ * 「今日已签到」的判定 = checkinDate == 今天 && status ∈ {SUCCESS, ALREADY}。
+ * 因此 FAILED/RETRYABLE/DEVICE_BLOCKED 的记录不会挡住当天重试：标识位和时间
+ * 对不上时，重开 App 会再次唤起签到流程。
+ */
+@Singleton
+class CheckinStatusStore @Inject constructor(
+    @ApplicationContext private val context: Context
+) {
+
+    private fun prefs() =
+        context.getSharedPreferences("checkin_status", Context.MODE_PRIVATE)
+
+    /** 该服务今日是否已「成功」签到（本地时区 yyyy-MM-dd 比对）。 */
+    fun isCheckedToday(service: ServiceType, accountId: String? = null): Boolean {
+        val record = lastRecord(service, accountId) ?: return false
+        return record.checkinDate == LocalDate.now().toString() &&
+            (record.status == STATUS_SUCCESS || record.status == STATUS_ALREADY)
+    }
+
+    /** 最近一次签到记录（含失败记录），无记录返回 null。 */
+    fun lastRecord(service: ServiceType, accountId: String? = null): CheckinRecord? {
+        val raw = prefs().getString(recordKey(service, accountId), null)
+        if (raw != null) {
+            return runCatching {
+                val obj = JSONObject(raw)
+                val id = if (obj.isNull(KEY_ID)) null else obj.optString(KEY_ID).takeIf { it.isNotBlank() }
+                CheckinRecord(
+                    service = service.storageKey,
+                    accountId = accountId,
+                    checkinDate = obj.optString(KEY_DATE),
+                    status = obj.optString(KEY_STATUS),
+                    checkinId = id,
+                    credits = obj.optLong(KEY_CREDITS),
+                    updatedAt = obj.optLong(KEY_UPDATED_AT)
+                )
+            }.getOrNull()
+        }
+        // 旧版 date-only 记录迁移：没有 JSON 记录时回退读旧键
+        val legacyDate = legacyDate(service, accountId) ?: return null
+        return CheckinRecord(
+            service = service.storageKey,
+            accountId = accountId,
+            checkinDate = legacyDate,
+            status = STATUS_SUCCESS,
+            checkinId = null,
+            credits = 0,
+            updatedAt = 0
+        )
+    }
+
+    /** 最近一次成功签到日期（yyyy-MM-dd），无记录返回 null。 */
+    fun lastCheckinDate(service: ServiceType, accountId: String? = null): String? =
+        lastRecord(service, accountId)
+            ?.takeIf { it.status == STATUS_SUCCESS || it.status == STATUS_ALREADY }
+            ?.checkinDate
+
+    /** 记录一条签到结果（成功或失败都会落库，便于当天重试/统计）。 */
+    fun record(
+        service: ServiceType,
+        accountId: String? = null,
+        status: String,
+        checkinId: String? = null,
+        credits: Long = 0,
+        updatedAt: Long = System.currentTimeMillis()
+    ) {
+        val obj = JSONObject()
+        obj.put(KEY_DATE, LocalDate.now().toString())
+        obj.put(KEY_STATUS, status)
+        obj.put(KEY_ID, checkinId ?: JSONObject.NULL)
+        obj.put(KEY_CREDITS, credits)
+        obj.put(KEY_UPDATED_AT, updatedAt)
+        prefs().edit().putString(recordKey(service, accountId), obj.toString()).apply()
+    }
+
+    /** 旧版「已成功签到」快捷写入（服务端确认已签/手动已签场景）。 */
+    fun markChecked(service: ServiceType, accountId: String? = null) {
+        record(service, accountId, STATUS_ALREADY)
+    }
+
+    private fun recordKey(service: ServiceType, accountId: String?): String =
+        "checkin_record_${service.storageKey}" + if (accountId.isNullOrBlank()) "" else ":$accountId"
+
+    private fun legacyDate(service: ServiceType, accountId: String?): String? {
+        val p = prefs()
+        val scopedKey = "last_checkin_${service.storageKey}" + if (accountId.isNullOrBlank()) "" else ":$accountId"
+        val scoped = p.getString(scopedKey, null)
+        if (scoped != null) return scoped
+        // 仅旧版迁移来的 “default” 账号回退读旧版单账号键（其他账号没有旧记录，不能共用），
+        // 避免升级当日重复签到请求
+        return if (accountId == CredentialRepository.LEGACY_DEFAULT_ACCOUNT_ID) {
+            p.getString("last_checkin_${service.storageKey}", null)
+        } else {
+            null
+        }
+    }
+
+    /** 单条签到记录。 */
+    data class CheckinRecord(
+        val service: String,
+        val accountId: String?,
+        val checkinDate: String,
+        val status: String,
+        val checkinId: String?,
+        val credits: Long,
+        val updatedAt: Long
+    )
+
+    companion object {
+        const val STATUS_SUCCESS = "SUCCESS"
+        const val STATUS_ALREADY = "ALREADY"
+        const val STATUS_FAILED = "FAILED"
+        const val STATUS_RETRYABLE = "RETRYABLE"
+        const val STATUS_DEVICE_BLOCKED = "DEVICE_BLOCKED"
+
+        private const val KEY_DATE = "date"
+        private const val KEY_STATUS = "status"
+        private const val KEY_ID = "id"
+        private const val KEY_CREDITS = "credits"
+        private const val KEY_UPDATED_AT = "updated_at"
+    }
+}

app/src/main/java/com/rainy/token/data/repository/CodexOAuthHelper.kt

@@ -15,7 +15,7 @@ import java.security.MessageDigest
 import java.security.SecureRandom
 
 /**
- * Codex / ChatGPT Plus OAuth PKCE 辅助工具。
+ * Codex / ChatGPT OAuth PKCE 辅助工具。
  *
  * 参考：7shi/codex-oauth 的 Python 实现，移植到 Kotlin/Android。
  * 流程：

app/src/main/java/com/rainy/token/data/repository/CodexRepository.kt

@@ -3,6 +3,7 @@ package com.rainy.token.data.repository
 import com.rainy.token.data.cache.BalanceCache
 import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.model.ServiceBalance
+import com.rainy.token.domain.model.TriggerSummary
 import com.rainy.token.domain.service.ServiceConfigProvider
 import com.rainy.token.domain.service.ServiceType
 import kotlinx.coroutines.Dispatchers
@@ -33,6 +34,16 @@ class CodexRepository(
 ) {
     private val json = Json { ignoreUnknownKeys = true }
 
+    /** 用量窗口来源分组：CODEX = 普通 Codex 限额，SPARK = GPT-5.3-Codex-Spark 独立限额 */
+    internal enum class WindowGroup { CODEX, SPARK }
+
+    internal data class UsageWindow(
+        val label: String,
+        val remainingPct: Int,
+        val resetAt: Long?,
+        val group: WindowGroup = WindowGroup.CODEX
+    )
+
     companion object {
         private const val WHAM_USAGE = "https://chatgpt.com/backend-api/wham/usage"
         private const val RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses"
@@ -42,27 +53,49 @@ class CodexRepository(
         private const val REFRESH_BUFFER_MS = 60L * 60 * 1000
         private const val TAG = "Codex"
 
-        internal data class UsageWindow(val label: String, val remainingPct: Int, val resetAt: Long?)
-
         internal fun parseUsageWindows(data: JsonObject): List<UsageWindow> {
             val result = mutableListOf<UsageWindow>()
-            fun addWindows(rl: JsonObject?) {
+            fun addWindows(rl: JsonObject?, group: WindowGroup) {
                 if (rl == null) return
                 for (key in listOf("primary_window", "secondary_window")) {
                     val w = rl[key] as? JsonObject ?: continue
                     val usedPct = (w["used_percent"] as? JsonPrimitive)?.floatOrNull ?: continue
                     val remaining = (100 - usedPct).toInt().coerceIn(0, 100)
-                    result.add(UsageWindow(durationLabel((w["limit_window_seconds"] as? JsonPrimitive)?.longOrNull), remaining, (w["reset_at"] as? JsonPrimitive)?.longOrNull?.times(1000L)))
+                    result.add(UsageWindow(durationLabel((w["limit_window_seconds"] as? JsonPrimitive)?.longOrNull), remaining, (w["reset_at"] as? JsonPrimitive)?.longOrNull?.times(1000L), group))
                 }
             }
-            addWindows(data["rate_limit"] as? JsonObject)
+            // 顶层 rate_limit 始终属于普通 Codex 限额
+            addWindows(data["rate_limit"] as? JsonObject, WindowGroup.CODEX)
+            // additional_rate_limits 每项可携带 limit_name，含 "spark" 的归入 Spark 独立限额组
             (data["additional_rate_limits"] as? kotlinx.serialization.json.JsonArray)?.forEach { item ->
-                if (item is JsonObject) addWindows(item["rate_limit"] as? JsonObject)
+                if (item is JsonObject) {
+                    val name = (item["limit_name"] as? JsonPrimitive)?.contentOrNull.orEmpty()
+                    val group = if (name.contains("spark", ignoreCase = true)) WindowGroup.SPARK else WindowGroup.CODEX
+                    addWindows(item["rate_limit"] as? JsonObject, group)
+                }
             }
             return result
         }
 
-        internal fun durationLabel(seconds: Long?): String = when { seconds == null -> "Usage"; seconds / 60.0 >= 10079 -> "每周"; seconds / 60.0 >= 1439 -> "${(seconds / 86400).toInt()}d"; seconds / 60.0 >= 60 -> "${(seconds / 3600).toInt()}h"; else -> "${maxOf(1, (seconds / 60).toInt())}m" }
+        /**
+         * 选择主余额窗口：
+         * 优先普通 Codex 组的 5h 窗口（与旧逻辑一致）；
+         * 普通组没有 5h 时取普通组第一个（如仅 weekly 的 prolite 账号）；
+         * 普通组为空才 fallback 到任意第一个（避免 Spark 5h 抢走主余额）。
+         */
+        internal fun selectPrimaryWindow(windows: List<UsageWindow>): UsageWindow =
+            windows.firstOrNull { it.group == WindowGroup.CODEX && it.label.contains("h") }
+                ?: windows.firstOrNull { it.group == WindowGroup.CODEX }
+                ?: windows.first()
+
+        /** 窗口时长 → 中性标识（weekly/monthly/usage/数字标签），由 UI 层按语言本地化 */
+        internal fun durationLabel(seconds: Long?): String = when {
+            seconds == null -> "usage"
+            seconds / 60.0 >= 10079 -> "weekly"
+            seconds / 60.0 >= 1439 -> "${(seconds / 86400).toInt()}d"
+            seconds / 60.0 >= 60 -> "${(seconds / 3600).toInt()}h"
+            else -> "${maxOf(1, (seconds / 60).toInt())}m"
+        }
     }
 
     suspend fun fetchBalance(): Result<ServiceBalance> = withContext(Dispatchers.IO) {
@@ -114,17 +147,18 @@ class CodexRepository(
             parseUsageWindows(usageResult)
         } catch (e: Exception) {
             DebugLog.e(TAG, "解析 Codex 用量失败: ${e::class.simpleName}: ${e.message}")
-            return@withContext Result.failure(RepositoryError.ParseError("Codex 用量响应格式异常: ${e.message ?: e::class.simpleName}"))
+            return@withContext Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "Codex 用量响应格式异常: ${e.message ?: e::class.simpleName}"))
         }
-        if (windows.isEmpty()) return@withContext Result.failure(RepositoryError.ParseError("未找到 Codex 用量窗口数据"))
+        if (windows.isEmpty()) return@withContext Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.NO_WINDOWS, "未找到 Codex 用量窗口数据"))
 
         val config = ServiceConfigProvider.get(ServiceType.CODEX)
-        val primary = windows.firstOrNull { it.label.contains("h") } ?: windows.first()
+        val primary = selectPrimaryWindow(windows)
         val extras = buildMap {
             windows.forEachIndexed { i, w ->
                 put("window_$i.label", w.label)
                 put("window_$i.remainingPct", w.remainingPct.toString())
                 put("window_$i.resetAt", w.resetAt?.toString() ?: "")
+                put("window_$i.group", w.group.name)
             }
             put("primary.label", primary.label)
             (usageResult["plan_type"] as? JsonPrimitive)?.contentOrNull?.let { put("plan", it) }
@@ -154,16 +188,16 @@ class CodexRepository(
                     DebugLog.e(TAG, "fetchModels: HTTP ${resp.code}")
                     return@withContext Result.failure(RepositoryError.ServerError(resp.code))
                 }
-                val root = json.parseToJsonElement(resp.body?.string() ?: throw RepositoryError.ParseError("响应体为空")) as? JsonObject
-                    ?: throw RepositoryError.ParseError("响应根节点不是 JSON 对象")
+                val root = json.parseToJsonElement(resp.body?.string() ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.EMPTY_BODY, "响应体为空")) as? JsonObject
+                    ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.NOT_JSON_OBJECT, "响应根节点不是 JSON 对象")
                 // 结构: { "openai": { "models": { "gpt-5.6": {...}, ... } } }
                 val openaiProvider = root["openai"] as? JsonObject
                 val modelsObj = openaiProvider?.get("models") as? JsonObject
                 modelsObj?.keys?.toList()?.sorted()
-                    ?: throw RepositoryError.ParseError("未找到 OpenAI 模型列表")
+                    ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.NO_MODELS, "未找到 OpenAI 模型列表")
             }
             if (models.isEmpty()) {
-                return@withContext Result.failure(RepositoryError.ParseError("模型列表为空"))
+                return@withContext Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.MODELS_EMPTY, "模型列表为空"))
             }
             DebugLog.i(TAG, "fetchModels: 获取到 ${models.size} 个模型")
             Result.success(models)
@@ -203,7 +237,7 @@ class CodexRepository(
      * @param model 用户选择的模型 slug
      * @return Result.success(响应体原文) — 供 UI 展示
      */
-    suspend fun triggerUsage(model: String): Result<String> = withContext(Dispatchers.IO) {
+    suspend fun triggerUsage(model: String): Result<TriggerSummary> = withContext(Dispatchers.IO) {
         val credential = credentialRepository.get(ServiceType.CODEX)
             ?: return@withContext Result.failure(RepositoryError.InvalidCredential("未找到 Codex 凭据"))
         if (credential !is Credential.CodexCredential)
@@ -239,10 +273,10 @@ class CodexRepository(
                                     DebugLog.i(TAG, "triggerUsage retry: HTTP ${resp2.code}, body=${body2.take(500)}")
                                     if (!resp2.isSuccessful) {
                                         DebugLog.e(TAG, "triggerUsage retry failed: HTTP ${resp2.code}")
-                                        return@use Result.failure<String>(
+                                        return@use Result.failure<TriggerSummary>(
                                             TriggerError(
                                                 "HTTP ${resp2.code}",
-                                                body2.ifBlank { "无响应体" }
+                                                body2.ifBlank { "" }
                                             )
                                         )
                                     }
@@ -251,12 +285,12 @@ class CodexRepository(
                             }
                             is RefreshResult.Failure -> {
                                 DebugLog.e(TAG, "triggerUsage: 二次刷新失败: ${r.reason}")
-                                return@use Result.failure(TriggerError("token 刷新失败: ${r.reason}", ""))
+                                return@use Result.failure(TriggerError("token 刷新失败: ${r.reason}", "", TriggerErrorReason.TOKEN_REFRESH))
                             }
                         }
                     } else {
-                        return@use Result.failure<String>(
-                            TriggerError("HTTP ${resp.code}", bodyStr.ifBlank { "无响应体" })
+                        return@use Result.failure<TriggerSummary>(
+                            TriggerError("HTTP ${resp.code}", bodyStr.ifBlank { "" })
                         )
                     }
                 } else {
@@ -385,22 +419,28 @@ class CodexRepository(
                 DebugLog.e(TAG, "fetchJson failed: HTTP ${it.code} ${it.message} url=$url")
                 throw if (it.code in listOf(401, 403)) RepositoryError.InvalidCredential("HTTP ${it.code}") else RepositoryError.ServerError(it.code)
             }
-            return (json.parseToJsonElement(it.body?.string() ?: throw RepositoryError.ParseError("响应体为空")) as? JsonObject)
-                ?: throw RepositoryError.ParseError("响应根节点不是 JSON 对象")
+            return (json.parseToJsonElement(it.body?.string() ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.EMPTY_BODY, "响应体为空")) as? JsonObject)
+                ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.NOT_JSON_OBJECT, "响应根节点不是 JSON 对象")
         }
     }
 
     @Serializable data class OAuthRefreshResponse(@kotlinx.serialization.SerialName("access_token") val accessToken: String, @kotlinx.serialization.SerialName("refresh_token") val refreshToken: String? = null, @kotlinx.serialization.SerialName("expires_in") val expiresIn: Long = 3600, @kotlinx.serialization.SerialName("token_type") val tokenType: String? = null)
 }
 
+/** TriggerError 的结构化原因（UI 层据此映射本地化文案；null = HTTP 错误，summary 为 ASCII 可直显） */
+enum class TriggerErrorReason {
+    /** token 刷新失败（summary 中为中文用户提示，不直接透传 UI） */
+    TOKEN_REFRESH
+}
+
 /** 携带完整响应体的错误类，供 UI 展示服务端返回的详细信息 */
-class TriggerError(val summary: String, val responseBody: String) : Exception(summary)
+class TriggerError(val summary: String, val responseBody: String, val reason: TriggerErrorReason? = null) : Exception(summary)
 
 /**
  * 将 SSE 流响应解析为简洁的文本摘要。
  * 提取：模型回复文本、用量统计（input/output tokens）。
  */
-internal fun parseSseResponse(sseText: String, model: String): String {
+internal fun parseSseResponse(sseText: String, model: String): TriggerSummary {
     val sseJson = Json { ignoreUnknownKeys = true }
     val outputText = StringBuilder()
     var inputTokens: String? = null
@@ -429,16 +469,11 @@ internal fun parseSseResponse(sseText: String, model: String): String {
         } catch (_: Exception) { }
     }
 
-    val sb = StringBuilder()
-    sb.appendLine("✓ 激活成功")
-    sb.appendLine("模型: $model")
-    if (responseId != null) sb.appendLine("Response ID: $responseId")
-    sb.appendLine()
-    sb.appendLine("回复:")
-    sb.appendLine(outputText.ifEmpty { "(空)" })
-    if (inputTokens != null || outputTokens != null) {
-        sb.appendLine()
-        sb.appendLine("用量: input=$inputTokens output=$outputTokens tokens")
-    }
-    return sb.toString().trim()
+    return TriggerSummary(
+        model = model,
+        reply = outputText.toString(),
+        inputTokens = inputTokens,
+        outputTokens = outputTokens,
+        responseId = responseId
+    )
 }

app/src/main/java/com/rainy/token/data/repository/CommandCodeGoRepository.kt

@@ -19,7 +19,7 @@ import java.io.IOException
 import javax.inject.Singleton
 
 /**
- * CommandCode Go 余额仓库。
+ * CommandCode 余额仓库。
  *
  * 调 JSON API 获取月度配额余额 + 用量窗口信息：
  *   GET https://api.commandcode.ai/alpha/billing/credits
@@ -65,7 +65,7 @@ class CommandCodeGoRepository(
 
         // 从订阅信息拿计划名称，查 plan catalog 拿总量
         val monthlyTotal = subResult.getOrNull()?.let { sub ->
-            PLANS[sub.planId.lowercase()]
+            planMonthlyQuota(sub.planId)
         }
         val billingPeriodEndMillis = subResult.getOrNull()?.let { parseIsoToEpoch(it.currentPeriodEnd) }
 
@@ -187,24 +187,35 @@ class CommandCodeGoRepository(
         } catch (_: Exception) { null }
     }
 
-    private fun planDisplayName(planId: String): String =
-        PLAN_NAMES[planId.lowercase()] ?: planId
-
     companion object {
+        /** 计划 → 月度额度（美元）。2026-08 起官网新计划体系：
+         *  Go $1 → $10、GOAT $10 → $70、Pro $20 → $80、Max 10× $100 → $150、Max 20× $200 → $300。
+         *  旧值 individual-go=10 与 individual-goat=70 并存（goat 是当前主流计划）。
+         */
         private val PLANS = mapOf(
             "individual-go" to 10.0,
-            "individual-pro" to 30.0,
+            "individual-goat" to 70.0,
+            "individual-pro" to 80.0,
             "individual-max" to 150.0,
             "individual-ultra" to 300.0
         )
 
         private val PLAN_NAMES = mapOf(
             "individual-go" to "Go",
+            "individual-goat" to "GOAT",
             "individual-pro" to "Pro",
             "individual-max" to "Max",
             "individual-ultra" to "Ultra"
         )
 
+        /** 按 planId 查月度额度（美元）；未知计划返回 null（调用方安全降级）。 */
+        internal fun planMonthlyQuota(planId: String?): Double? =
+            planId?.lowercase()?.let { PLANS[it] }
+
+        /** 按 planId 查展示名；未知计划原样返回。 */
+        internal fun planDisplayName(planId: String?): String =
+            planId?.lowercase()?.let { PLAN_NAMES[it] } ?: planId ?: ""
+
         /** API 返回的是 epoch millis，转为距现在的剩余秒数 */
         private fun epochToRemainingSec(epochMillis: Long): Long =
             maxOf(0L, (epochMillis - System.currentTimeMillis()) / 1000)

app/src/main/java/com/rainy/token/data/repository/CommandCodeUsageRepository.kt

@@ -7,6 +7,7 @@ import com.rainy.token.domain.service.ServiceType
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonNull
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.jsonArray
 import kotlinx.serialization.json.jsonObject
@@ -21,7 +22,7 @@ import java.util.TimeZone
 import javax.inject.Singleton
 
 /**
- * CommandCode Go 用量记录仓库。
+ * CommandCode 用量记录仓库。
  *
  * 调 JSON API 分页抓取 usage 记录：
  *   GET https://api.commandcode.ai/internal/usage?limit=50
@@ -35,7 +36,6 @@ class CommandCodeUsageRepository(
     private val okHttpClient: OkHttpClient,
     private val credentialRepository: CredentialRepository
 ) {
-    private val json = Json { ignoreUnknownKeys = true }
     private val apiBase = "https://api.commandcode.ai"
 
     companion object {
@@ -44,6 +44,121 @@ class CommandCodeUsageRepository(
         const val COST_DENOM = 100_000_000L
         /** CCGO 用量数据在 UsageCache 中的 workspaceId 区分键 */
         const val CCGO_WORKSPACE_ID = "commandcode"
+
+        private val json = Json { ignoreUnknownKeys = true }
+
+        // ===== 纯解析逻辑（无网络依赖，可直接单测）=====
+
+        /**
+         * 解析 JSON 响应。
+         *
+         * 后端 2026-08 起改为新格式：
+         *   - 顶层新增 nextCursor / limit / periodBasis / window；
+         *     分页游标由服务端 nextCursor 直接给出（缺失时回退按末条自编码，兼容旧格式）。
+         *   - 每条记录新增 durationTotal / status / message / type / mode；
+         *     tokensTotal / creditsTotal 已移除。
+         *   - meta 新增 totalCost / inputCost / outputCost / cacheCost / traceId；
+         *     provider / cacheReadInputTokens 已移除。
+         */
+        internal fun parseUsageResponse(body: String): Pair<List<UsageRecord>, String?> {
+            val root = json.parseToJsonElement(body).jsonObject
+            val usages = root["usages"]?.jsonArray ?: return emptyList<UsageRecord>() to null
+
+            val records = usages.mapNotNull { elem ->
+                parseUsageObject(elem.jsonObject)
+            }
+
+            // 新格式：优先用服务端游标；缺失或显式 null 时回退按末条自编码（兼容旧格式）
+            // 注意：JSON null 的 jsonPrimitive.content 是字符串 "null"，必须用 is JsonNull 拦截，
+            // 否则会把 "null" 当游标传给服务端（被忽略→返回第一页），导致 fullSync 死循环。
+            val serverCursor = root["nextCursor"]?.takeIf { it !is JsonNull }
+                ?.jsonPrimitive?.content?.takeIf { it.isNotEmpty() }
+            val nextCursor = serverCursor ?: if (records.size >= PAGE_SIZE) {
+                val last = records.last()
+                encodeCursor(last.id, last.timeCreated)
+            } else null
+
+            return records to nextCursor
+        }
+
+        /**
+         * 解析单条 usage 对象。
+         *
+         * cost 来源：新格式 meta.totalCost（美元数值）；旧格式顶层 creditsTotal（兼容）。
+         * provider：新格式已移除，缺失时为空字符串；旧格式 meta.provider 兼容读取。
+         * cacheReadInputTokens：新格式已移除，缺失时按 0（tokensIn 不再拆分缓存命中）。
+         */
+        internal fun parseUsageObject(obj: JsonObject): UsageRecord? {
+            val id = obj["id"]?.jsonPrimitive?.content ?: return null
+            val createdAt = obj["createdAt"]?.jsonPrimitive?.content ?: return null
+            val timeCreated = parseIsoDate(createdAt) ?: return null
+
+            val tokensIn = obj["tokensIn"]?.jsonPrimitive?.content?.toLongOrNull() ?: 0L
+            val tokensOut = obj["tokensOut"]?.jsonPrimitive?.content?.toLongOrNull() ?: 0L
+
+            val meta = obj["meta"]?.jsonObject
+            val creditsTotal = meta?.get("totalCost")?.jsonPrimitive?.content?.toDoubleOrNull()
+                ?: obj["creditsTotal"]?.jsonPrimitive?.content?.toDoubleOrNull()
+                ?: 0.0
+            val cost = (creditsTotal * COST_DENOM).toLong()
+
+            val model = meta?.get("model")?.jsonPrimitive?.content ?: ""
+            val provider = meta?.get("provider")?.jsonPrimitive?.content ?: ""
+            val cacheReadInputTokens = meta?.get("cacheReadInputTokens")?.jsonPrimitive?.content?.toLongOrNull() ?: 0L
+
+            // CCGO 的 tokensIn 是总输入（缓存命中 + 未命中），按 OCGO 惯例拆分为 inputTokens（未命中）和 cacheReadTokens（命中）
+            // 新格式无缓存 token 数时无法拆分，inputTokens 直接取 tokensIn
+            val inputMissTokens = (tokensIn - cacheReadInputTokens).coerceAtLeast(0)
+
+            return UsageRecord(
+                id = id,
+                workspaceId = CCGO_WORKSPACE_ID,
+                timeCreated = timeCreated,
+                timeUpdated = timeCreated,
+                model = model,
+                provider = provider,
+                inputTokens = inputMissTokens,
+                outputTokens = tokensOut,
+                reasoningTokens = 0L,
+                cacheReadTokens = cacheReadInputTokens,
+                cacheWrite5mTokens = 0L,
+                cacheWrite1hTokens = 0L,
+                cost = cost,
+                keyId = "",
+                sessionId = "",
+                enrichmentPlan = ""
+            )
+        }
+
+        private fun parseIsoDate(iso: String): Long? {
+            // 处理末尾 Z 和时区偏移
+            val normalized = iso
+                .replace("Z", "X")
+                .replace(Regex("""[+-]\d{2}:\d{2}$"""), "X")
+            return try {
+                // SimpleDateFormat 非线程安全，每次创建新实例
+                val sdf = java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'X'", Locale.US).apply {
+                    timeZone = TimeZone.getTimeZone("UTC")
+                }
+                sdf.parse(normalized)?.time
+                    ?: run {
+                        val sdf2 = java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'X'", Locale.US).apply {
+                            timeZone = TimeZone.getTimeZone("UTC")
+                        }
+                        sdf2.parse(normalized)?.time
+                    }
+            } catch (_: Exception) { null }
+        }
+
+        /** 从记录信息编码为 base64 cursor */
+        private fun encodeCursor(id: String, timeCreated: Long): String {
+            val sdf = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US).apply {
+                timeZone = TimeZone.getTimeZone("UTC")
+            }
+            val createdAt = sdf.format(java.util.Date(timeCreated))
+            val cursorJson = """{"createdAt":"$createdAt","id":"$id"}"""
+            return Base64.getUrlEncoder().withoutPadding().encodeToString(cursorJson.toByteArray())
+        }
     }
 
     private suspend fun getCookieHeader(): String {
@@ -106,102 +221,11 @@ class CommandCodeUsageRepository(
                 }
 
                 if (body == null) return@withContext Result.failure(
-                    RepositoryError.ParseError("响应体为空")
+                    RepositoryError.ParseError(RepositoryError.ParseErrorReason.EMPTY_BODY, "响应体为空")
                 )
 
                 val records = parseUsageResponse(body)
                 Result.success(records)
             }
         }
-
-    /**
-     * 解析 JSON 响应。
-     */
-    private fun parseUsageResponse(body: String): Pair<List<UsageRecord>, String?> {
-        val root = json.parseToJsonElement(body).jsonObject
-        val usages = root["usages"]?.jsonArray ?: return emptyList<UsageRecord>() to null
-
-        val records = usages.mapNotNull { elem ->
-            val obj = elem.jsonObject
-            parseUsageObject(obj)
-        }
-
-        // 从最后一条记录计算下一页 cursor
-        val nextCursor = if (records.size >= PAGE_SIZE) {
-            val last = records.last()
-            encodeCursor(last.id, last.timeCreated)
-        } else null
-
-        return records to nextCursor
-    }
-
-    private fun parseUsageObject(obj: JsonObject): UsageRecord? {
-        val id = obj["id"]?.jsonPrimitive?.content ?: return null
-        val createdAt = obj["createdAt"]?.jsonPrimitive?.content ?: return null
-        val timeCreated = parseIsoDate(createdAt) ?: return null
-
-        val tokensIn = obj["tokensIn"]?.jsonPrimitive?.content?.toLongOrNull() ?: 0L
-        val tokensOut = obj["tokensOut"]?.jsonPrimitive?.content?.toLongOrNull() ?: 0L
-        val tokensTotal = obj["tokensTotal"]?.jsonPrimitive?.content?.toLongOrNull() ?: 0L
-
-        val creditsTotal = obj["creditsTotal"]?.jsonPrimitive?.content?.toDoubleOrNull() ?: 0.0
-        val cost = (creditsTotal * COST_DENOM).toLong()
-
-        val meta = obj["meta"]?.jsonObject
-        val model = meta?.get("model")?.jsonPrimitive?.content ?: ""
-        val provider = meta?.get("provider")?.jsonPrimitive?.content ?: ""
-        val cacheReadInputTokens = meta?.get("cacheReadInputTokens")?.jsonPrimitive?.content?.toLongOrNull() ?: 0L
-
-        // CCGO 的 tokensIn 是总输入（缓存命中 + 未命中），按 OCGO 惯例拆分为 inputTokens（未命中）和 cacheReadTokens（命中）
-        val inputMissTokens = (tokensIn - cacheReadInputTokens).coerceAtLeast(0)
-
-        return UsageRecord(
-            id = id,
-            workspaceId = CCGO_WORKSPACE_ID,
-            timeCreated = timeCreated,
-            timeUpdated = timeCreated,
-            model = model,
-            provider = provider,
-            inputTokens = inputMissTokens,
-            outputTokens = tokensOut,
-            reasoningTokens = 0L,
-            cacheReadTokens = cacheReadInputTokens,
-            cacheWrite5mTokens = 0L,
-            cacheWrite1hTokens = 0L,
-            cost = cost,
-            keyId = "",
-            sessionId = "",
-            enrichmentPlan = ""
-        )
-    }
-
-    private fun parseIsoDate(iso: String): Long? {
-        // 处理末尾 Z 和时区偏移
-        val normalized = iso
-            .replace("Z", "X")
-            .replace(Regex("""[+-]\d{2}:\d{2}$"""), "X")
-        return try {
-            // SimpleDateFormat 非线程安全，每次创建新实例
-            val sdf = java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'X'", Locale.US).apply {
-                timeZone = TimeZone.getTimeZone("UTC")
-            }
-            sdf.parse(normalized)?.time
-                ?: run {
-                    val sdf2 = java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'X'", Locale.US).apply {
-                        timeZone = TimeZone.getTimeZone("UTC")
-                    }
-                    sdf2.parse(normalized)?.time
-                }
-        } catch (_: Exception) { null }
-    }
-
-    /** 从记录信息编码为 base64 cursor */
-    private fun encodeCursor(id: String, timeCreated: Long): String {
-        val sdf = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US).apply {
-            timeZone = TimeZone.getTimeZone("UTC")
-        }
-        val createdAt = sdf.format(java.util.Date(timeCreated))
-        val cursorJson = """{"createdAt":"$createdAt","id":"$id"}"""
-        return Base64.getUrlEncoder().withoutPadding().encodeToString(cursorJson.toByteArray())
-    }
 }

app/src/main/java/com/rainy/token/data/repository/CredentialRepository.kt

@@ -3,11 +3,14 @@ package com.rainy.token.data.repository
 import com.rainy.token.data.cache.BalanceCache
 import com.rainy.token.data.cache.CachedBalance
 import com.rainy.token.data.local.SecureStorage
+import com.rainy.token.domain.model.AccountStore
 import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.model.CredentialStatus
+import com.rainy.token.domain.model.ServiceAccountInfo
 import com.rainy.token.domain.service.ServiceConfigProvider
 import com.rainy.token.domain.service.ServiceType
 import java.security.MessageDigest
+import java.util.UUID
 import javax.inject.Inject
 import javax.inject.Singleton
 import kotlinx.coroutines.currentCoroutineContext
@@ -19,6 +22,12 @@ import kotlinx.coroutines.sync.withLock
  *
  * 所有凭据变更都经过 [mutationMutex] 串行化，并维护进程内 revision。网络刷新先取得
  * [CredentialSnapshot]；请求结束后只有快照仍为当前版本时，暂存的凭据与余额才会提交。
+ *
+ * 多账号服务（Trae / WorkBuddy）：
+ *  - 账号元数据（[ServiceAccountInfo]）存 `accounts_{storageKey}`（加密 DataStore）；
+ *  - 每个账号的凭据独立存 `credential_{storageKey}_{accountId}`；
+ *  - 旧版本单凭据存 `credential_{storageKey}`，首次读取时自动迁移为默认账号
+ *    （固定 id = [LEGACY_DEFAULT_ACCOUNT_ID]），旧键保留作为兼容回退。
  */
 @Singleton
 class CredentialRepository @Inject constructor(
@@ -29,7 +38,11 @@ class CredentialRepository @Inject constructor(
     internal data class CredentialSnapshot(
         val credential: Credential,
         val revision: Long,
-        val fingerprint: String
+        val fingerprint: String,
+        /** 快照所属账号；单账号服务为 null。 */
+        val accountId: String? = null,
+        /** 创建快照时调用方请求的账号 ID（多账号服务可能是 null=默认账号），用于会话内精确匹配。 */
+        val requestedAccountId: String? = accountId
     ) {
         val service: ServiceType get() = credential.service
     }
@@ -37,7 +50,19 @@ class CredentialRepository @Inject constructor(
     internal data class LocalState(
         val status: CredentialStatus,
         val fingerprint: String?,
-        val cachedBalance: CachedBalance?
+        val cachedBalance: CachedBalance?,
+        /** 当前凭据对象（首页卡片可能需要读取如 Sub2API 站点 Logo 等附加字段）。 */
+        val credential: Credential? = null
+    )
+
+    /** 按账号展开的本地状态（多账号服务一个账号一条；单账号服务一条 [account]=null）。 */
+    data class AccountLocalState(
+        val service: ServiceType,
+        val account: ServiceAccountInfo?,
+        val status: CredentialStatus,
+        val fingerprint: String?,
+        val cachedBalance: CachedBalance?,
+        val credential: Credential?
     )
 
     private data class CacheRollbackEntry(
@@ -47,69 +72,232 @@ class CredentialRepository @Inject constructor(
     )
 
     private val mutationMutex = Mutex()
-    private val revisions = mutableMapOf<ServiceType, Long>()
-    private val cacheRollbackEntries = mutableMapOf<ServiceType, CacheRollbackEntry>()
+    private val revisions = mutableMapOf<String, Long>()
+    private val cacheRollbackEntries = mutableMapOf<String, CacheRollbackEntry>()
 
-    private fun keyFor(service: ServiceType): String = "credential_${service.storageKey}"
+    private fun accountDocKeyFor(service: ServiceType): String = "accounts_${service.storageKey}"
 
-    suspend fun save(credential: Credential) {
+    /** 凭据存储键：单账号（或兼容回退）为 `credential_{storageKey}`。 */
+    private fun keyFor(service: ServiceType, accountId: String?): String =
+        if (accountId.isNullOrBlank()) {
+            "credential_${service.storageKey}"
+        } else {
+            "credential_${service.storageKey}_$accountId"
+        }
+
+    private fun accountCacheKey(service: ServiceType, accountId: String): String =
+        "${service.storageKey}:$accountId"
+
+    private fun revisionKey(service: ServiceType, accountId: String?): String =
+        "${service.storageKey}:${accountId ?: ""}"
+
+    // ─────────────────────────────────────────────
+    // 公开 API（多账号 + 单账号统一入口）
+    // ─────────────────────────────────────────────
+
+    /** 列出某服务的账号（多账号服务；单账号服务恒为空列表）。 */
+    suspend fun accountsFor(service: ServiceType): List<ServiceAccountInfo> =
+        mutationMutex.withLock { readAccountsUnlocked(service) }
+
+    /** 当前默认账号；无账号返回 null。 */
+    suspend fun getDefaultAccount(service: ServiceType): ServiceAccountInfo? =
+        mutationMutex.withLock { resolveAccountUnlocked(service, null) }
+
+    /**
+     * 新建账号（不写入凭据）。返回新账号；非多账号服务返回 null。
+     * 首个账号自动设为默认账号，label 为空时 UI 按“账号 N”兜底显示。
+     */
+    suspend fun createAccount(service: ServiceType, label: String? = null): ServiceAccountInfo? =
+        mutationMutex.withLock {
+            if (!ServiceType.isMultiAccount(service)) return@withLock null
+            createAccountUnlocked(service, label)
+        }
+
+    /** 设置默认账号（账号不存在时忽略）。切换默认账号时清除旧结构镜像缓存，避免新默认账号读到旧默认账号的余额。 */
+    suspend fun setDefaultAccount(service: ServiceType, accountId: String) {
+        mutationMutex.withLock {
+            val accounts = readAccountsUnlocked(service)
+            if (accounts.none { it.id == accountId }) return@withLock
+            val previousDefault = accounts.firstOrNull { it.isDefault } ?: accounts.firstOrNull()
+            putAccountsUnlocked(
+                service,
+                accounts.map { it.copy(isDefault = it.id == accountId) }
+            )
+            if (previousDefault?.id != accountId) {
+                balanceCache.removeLegacy(service)
+            }
+        }
+    }
+
+    /** 重命名账号（空白 label 视为清除自定义名称）。 */
+    suspend fun renameAccount(service: ServiceType, accountId: String, label: String) {
+        mutationMutex.withLock {
+            val accounts = readAccountsUnlocked(service)
+            putAccountsUnlocked(
+                service,
+                accounts.map {
+                    if (it.id == accountId) it.copy(label = label.takeIf { l -> l.isNotBlank() }) else it
+                }
+            )
+        }
+    }
+
+    /**
+     * 删除单个账号：删除该账号凭据 + 独立缓存；若删除的是默认账号则提升第一个
+     * 剩余账号为默认；最后一个账号删除后整个服务回到未配置状态。
+     */
+    suspend fun removeAccount(service: ServiceType, accountId: String) {
+        mutationMutex.withLock {
+            if (!ServiceType.isMultiAccount(service)) return@withLock
+            val accounts = readAccountsUnlocked(service)
+            val removed = accounts.firstOrNull { it.id == accountId } ?: return@withLock
+            val remaining = accounts.filterNot { it.id == accountId }
+
+            bumpRevision(service, accountId)
+            cacheRollbackEntries.remove(accountCacheKey(service, accountId))
+            balanceCache.removeAccount(service, accountId)
+            secureStorage.remove(keyFor(service, accountId))
+
+            if (remaining.isEmpty()) {
+                secureStorage.remove(accountDocKeyFor(service))
+                secureStorage.remove(keyFor(service, null))
+                balanceCache.remove(service)
+                clearRollbacksFor(service)
+            } else {
+                var fixed = remaining
+                if (fixed.none { it.isDefault }) {
+                    val first = fixed.first()
+                    fixed = fixed.map { if (it.id == first.id) it.copy(isDefault = true) else it }
+                }
+                putAccountsUnlocked(service, fixed)
+                // 删除的是默认账号时，旧结构镜像缓存属于被删账号，必须只清镜像（保留其余账号的独立分片缓存，
+                // 避免全部账号缓存被误清导致都要重新联网拉取）
+                if (removed.isDefault) {
+                    balanceCache.removeLegacy(service)
+                }
+            }
+        }
+    }
+
+    /**
+     * 保存凭据。
+     *
+     * - 多账号服务：[accountId] 为 null 时**总是新建账号**（导航层保证 null 只来自
+     *   「添加账号」流程），首个新建账号自动成为默认账号；显式 [accountId] 覆盖对应账号。
+     *   返回实际写入的账号 ID（用于新建账号后继续编辑）。
+     * - 单账号服务：忽略 [accountId]，行为与旧版一致，返回空串。
+     * - 在 [RefreshWriteSession] 上下文中只暂存，返回快照账号 ID。
+     */
+    suspend fun save(credential: Credential, accountId: String? = null): String {
         currentCoroutineContext()[RefreshWriteSession]?.let { session ->
             session.stageCredential(credential)
-            return
+            return session.snapshot.accountId ?: ""
         }
 
         mutationMutex.withLock {
             val service = credential.service
-            val current = getUnlocked(service)
+            val effectiveId = if (ServiceType.isMultiAccount(service)) {
+                if (accountId.isNullOrBlank()) {
+                    // 多账号服务的 null accountId = “新建账号”模式（导航层保证），总是新建，
+                    // 避免覆盖默认账号；首个账号自动成为默认账号。
+                    createAccountUnlocked(service, null).id
+                } else {
+                    resolveAccountUnlocked(service, accountId)?.id
+                        ?: createAccountUnlocked(service, null).id
+                }
+            } else {
+                null
+            }
+            val key = revisionKey(service, effectiveId)
+            val current = getUnlocked(service, effectiveId)
             val currentIdentity = cacheIdentityFingerprint(current)
             val newIdentity = cacheIdentityFingerprint(credential)
             val cacheIdentityChanged = currentIdentity != newIdentity
 
-            bumpRevision(service)
+            bumpRevision(service, effectiveId)
             if (cacheIdentityChanged) {
-                cacheRollbackEntries[service] = CacheRollbackEntry(
+                cacheRollbackEntries[key] = CacheRollbackEntry(
                     testedFingerprint = credentialFingerprint(credential)!!,
                     previousIdentity = currentIdentity,
-                    cachedBalance = if (current != null) balanceCache.get(service) else null
+                    cachedBalance = if (current != null) {
+                        accountCacheFor(service, effectiveId)
+                    } else {
+                        null
+                    }
                 )
-                balanceCache.remove(service)
+                removeCacheFor(service, effectiveId)
             } else {
-                cacheRollbackEntries.remove(service)
+                cacheRollbackEntries.remove(key)
             }
-            putUnlocked(credential)
+            putUnlocked(credential, effectiveId)
+            return effectiveId ?: ""
         }
     }
 
-    suspend fun get(service: ServiceType): Credential? {
+    suspend fun get(service: ServiceType, accountId: String? = null): Credential? {
         currentCoroutineContext()[RefreshWriteSession]?.let { session ->
             if (session.snapshot.service == service) {
-                return session.credentialForRead()
+                val matches = if (ServiceType.isMultiAccount(service)) {
+                    val requested = accountId?.takeIf { it.isNotBlank() }
+                    // 只允许读取与快照同一账号的暂存凭据；null=默认账号也要看快照当初请求的是不是默认账号，
+                    // 避免 A 账号刷新期间把 A 的暂存凭据误交给默认账号（B）的读请求。
+                    requested == session.snapshot.requestedAccountId
+                } else {
+                    true
+                }
+                if (matches) return session.credentialForRead()
             }
         }
-        return mutationMutex.withLock { getUnlocked(service) }
+        return mutationMutex.withLock { getUnlocked(service, accountId) }
     }
 
-    internal suspend fun readLocalState(service: ServiceType): LocalState =
+    internal suspend fun readLocalState(
+        service: ServiceType,
+        accountId: String? = null
+    ): LocalState =
         mutationMutex.withLock {
-            val credential = getUnlocked(service)
-            localStateOf(service, credential, balanceCache.get(service))
+            val credential = getUnlocked(service, accountId)
+            localStateOf(service, credential, accountCacheFor(service, accountId))
         }
 
+    /** 全部服务的按账号本地状态（保留单账号服务旧语义，多账号展开一条/账号）。 */
+    suspend fun readAccountStates(): List<AccountLocalState> =
+        mutationMutex.withLock { readAccountStatesUnlocked() }
+
     internal suspend fun readLocalStates(): Map<ServiceType, LocalState> =
         mutationMutex.withLock {
-            val cached = balanceCache.getAll()
+            val accountStates = readAccountStatesUnlocked()
+            val legacyCached = balanceCache.getAll()
             ServiceType.entries.associateWith { service ->
-                val credential = getUnlocked(service)
-                localStateOf(service, credential, cached[service])
+                // 默认账号优先（多账号服务中自动签到/小组件使用的账号）
+                val entry = accountStates
+                    .filter { it.service == service }
+                    .minByOrNull { if (it.account?.isDefault == true) 0 else 1 }
+                if (entry != null) {
+                    localStateOf(service, entry.credential, entry.cachedBalance)
+                } else {
+                    val credential = readLegacyCredentialUnlocked(service)
+                    localStateOf(service, credential, legacyCached[service])
+                }
             }
         }
 
     suspend fun remove(service: ServiceType) {
         mutationMutex.withLock {
-            bumpRevision(service)
-            cacheRollbackEntries.remove(service)
+            val accounts = if (ServiceType.isMultiAccount(service)) {
+                readAccountsUnlocked(service)
+            } else {
+                emptyList()
+            }
+            clearRollbacksFor(service)
+            bumpRevision(service, null)
+            accounts.forEach { account ->
+                bumpRevision(service, account.id)
+                secureStorage.remove(keyFor(service, account.id))
+            }
+            secureStorage.remove(keyFor(service, null))
+            secureStorage.remove(accountDocKeyFor(service))
             balanceCache.remove(service)
-            secureStorage.remove(keyFor(service))
         }
     }
 
@@ -122,12 +310,13 @@ class CredentialRepository @Inject constructor(
         previous: Credential?
     ): Boolean = mutationMutex.withLock {
         val service = testedSnapshot.service
-        val current = getUnlocked(service) ?: return@withLock false
+        val accountId = testedSnapshot.accountId
+        val current = getUnlocked(service, accountId) ?: return@withLock false
         if (
             !snapshotMatches(
                 snapshotRevision = testedSnapshot.revision,
                 snapshotFingerprint = testedSnapshot.fingerprint,
-                currentRevision = revisionFor(service),
+                currentRevision = revisionFor(service, accountId),
                 currentFingerprint = credentialFingerprint(current)
             )
         ) return@withLock false
@@ -135,35 +324,54 @@ class CredentialRepository @Inject constructor(
         val currentIdentity = cacheIdentityFingerprint(current)
         val previousIdentity = cacheIdentityFingerprint(previous)
         val identityChanged = currentIdentity != previousIdentity
-        val rollbackEntry = cacheRollbackEntries[service]?.takeIf {
+        val rollbackEntry = cacheRollbackEntries[revisionKey(service, accountId)]?.takeIf {
             it.testedFingerprint == testedSnapshot.fingerprint &&
                 it.previousIdentity == previousIdentity
         }
 
-        bumpRevision(service)
+        bumpRevision(service, accountId)
         if (identityChanged) {
-            balanceCache.remove(service)
+            removeCacheFor(service, accountId)
         }
         if (previous == null) {
-            secureStorage.remove(keyFor(service))
+            secureStorage.remove(keyFor(service, accountId))
         } else {
             require(previous.service == service) { "回滚凭据服务不匹配" }
-            putUnlocked(previous)
+            putUnlocked(previous, accountId)
         }
         if (identityChanged) {
-            rollbackEntry?.cachedBalance?.let { balanceCache.putCached(service, it) }
+            rollbackEntry?.cachedBalance?.let {
+                if (accountId.isNullOrBlank()) {
+                    balanceCache.putCached(service, it)
+                } else {
+                    balanceCache.putAccountCached(service, accountId, it)
+                    if (resolveAccountUnlocked(service, null)?.id == accountId) {
+                        balanceCache.putCached(service, it)
+                    }
+                }
+            }
         }
-        cacheRollbackEntries.remove(service)
+        cacheRollbackEntries.remove(revisionKey(service, accountId))
         true
     }
 
-    internal suspend fun snapshot(service: ServiceType): CredentialSnapshot? =
+    internal suspend fun snapshot(
+        service: ServiceType,
+        accountId: String? = null
+    ): CredentialSnapshot? =
         mutationMutex.withLock {
-            val credential = getUnlocked(service) ?: return@withLock null
+            val resolvedId = if (ServiceType.isMultiAccount(service)) {
+                resolveAccountUnlocked(service, accountId)?.id
+            } else {
+                null
+            }
+            val credential = getUnlocked(service, resolvedId) ?: return@withLock null
             CredentialSnapshot(
                 credential = credential,
-                revision = revisionFor(service),
-                fingerprint = credentialFingerprint(credential)!!
+                revision = revisionFor(service, resolvedId),
+                fingerprint = credentialFingerprint(credential)!!,
+                accountId = resolvedId,
+                requestedAccountId = accountId?.takeIf { it.isNotBlank() }
             )
         }
 
@@ -183,11 +391,11 @@ class CredentialRepository @Inject constructor(
         val hasPendingWrites = pendingCredential != null || pendingBalance != null
 
         val snapshot = session.snapshot
-        val current = getUnlocked(snapshot.service) ?: return@withLock false
+        val service = snapshot.service
+        val accountId = snapshot.accountId
+        val current = getUnlocked(service, accountId) ?: return@withLock false
         val currentFingerprint = credentialFingerprint(current)
 
-        // 一键激活等只读会话不应被同凭据刷新造成的 revision 变化误伤；但凭据真正
-        // 替换/删除后，旧账户的成功响应和失败信息都必须丢弃。
         if (!hasPendingWrites) {
             return@withLock currentFingerprint == snapshot.fingerprint
         }
@@ -195,7 +403,7 @@ class CredentialRepository @Inject constructor(
         val snapshotStillCurrent = snapshotMatches(
             snapshotRevision = snapshot.revision,
             snapshotFingerprint = snapshot.fingerprint,
-            currentRevision = revisionFor(snapshot.service),
+            currentRevision = revisionFor(service, accountId),
             currentFingerprint = currentFingerprint
         )
         val canMergeRotatedCredential = pendingCredential != null &&
@@ -211,22 +419,33 @@ class CredentialRepository @Inject constructor(
             cacheIdentityFingerprint(current) != cacheIdentityFingerprint(finalCredential) &&
                 !sameLineage
 
-        bumpRevision(snapshot.service)
+        bumpRevision(service, accountId)
         if (cacheIdentityChanged) {
-            balanceCache.remove(snapshot.service)
+            removeCacheFor(service, accountId)
         }
         if (pendingCredential != null) {
-            putUnlocked(pendingCredential)
+            putUnlocked(pendingCredential, accountId)
         }
         if (pendingBalance != null) {
-            balanceCache.put(snapshot.service, pendingBalance)
-            cacheRollbackEntries.remove(snapshot.service)
+            val cached = CachedBalance(balance = pendingBalance, fetchedAt = System.currentTimeMillis())
+            if (accountId.isNullOrBlank()) {
+                balanceCache.putCached(service, cached)
+            } else {
+                balanceCache.putAccountCached(service, accountId, cached)
+                if (resolveAccountUnlocked(service, null)?.id == accountId) {
+                    balanceCache.putCached(service, cached)
+                }
+            }
+            cacheRollbackEntries.remove(revisionKey(service, accountId))
         }
         true
     }
 
-    suspend fun statusFor(service: ServiceType): CredentialStatus {
-        val credential = get(service) ?: return CredentialStatus(
+    suspend fun statusFor(
+        service: ServiceType,
+        accountId: String? = null
+    ): CredentialStatus {
+        val credential = get(service, accountId) ?: return CredentialStatus(
             service = service,
             state = CredentialStatus.State.NOT_CONFIGURED,
             lastVerifiedAt = 0L
@@ -244,6 +463,74 @@ class CredentialRepository @Inject constructor(
     suspend fun statusForAll(): List<CredentialStatus> =
         ServiceConfigProvider.all().map { statusFor(it.type) }
 
+    // ─────────────────────────────────────────────
+    // 实现细节
+    // ─────────────────────────────────────────────
+
+    private suspend fun readAccountStatesUnlocked(): List<AccountLocalState> {
+        val cached = balanceCache.getAllAccounts()
+        val legacyCached = balanceCache.getAll()
+        return ServiceType.entries.flatMap { service ->
+            if (ServiceType.isMultiAccount(service)) {
+                val accounts = readAccountsUnlocked(service)
+                if (accounts.isEmpty()) {
+                    val legacy = readLegacyCredentialUnlocked(service)
+                    if (legacy == null) {
+                        emptyList()
+                    } else {
+                        listOf(accountLocalStateOf(service, null, legacy, legacyCached[service]))
+                    }
+                } else {
+                    accounts.map { account ->
+                        val credential = getUnlocked(service, account.id)
+                        val cache = cached[accountCacheKey(service, account.id)]
+                            ?: if (account.isDefault) legacyCached[service] else null
+                        accountLocalStateOf(service, account, credential, cache)
+                    }
+                }
+            } else {
+                val credential = readLegacyCredentialUnlocked(service)
+                if (credential == null) {
+                    emptyList()
+                } else {
+                    listOf(accountLocalStateOf(service, null, credential, legacyCached[service]))
+                }
+            }
+        }
+    }
+
+    private fun accountLocalStateOf(
+        service: ServiceType,
+        account: ServiceAccountInfo?,
+        credential: Credential?,
+        cached: CachedBalance?
+    ): AccountLocalState {
+        val status = if (credential == null) {
+            CredentialStatus(
+                service = service,
+                state = CredentialStatus.State.NOT_CONFIGURED,
+                lastVerifiedAt = 0L
+            )
+        } else {
+            CredentialStatus(
+                service = service,
+                state = determineCredentialState(
+                    credential.lastVerifiedAt,
+                    System.currentTimeMillis()
+                ),
+                lastVerifiedAt = credential.lastVerifiedAt
+            )
+        }
+        return AccountLocalState(
+            service = service,
+            account = account,
+            status = status,
+            fingerprint = credentialFingerprint(credential),
+            cachedBalance = cached,
+            credential = credential
+        )
+    }
+
     private fun localStateOf(
         service: ServiceType,
         credential: Credential?,
@@ -268,31 +555,167 @@ class CredentialRepository @Inject constructor(
         return LocalState(
             status = status,
             fingerprint = credentialFingerprint(credential),
-            cachedBalance = cached
+            cachedBalance = cached,
+            credential = credential
         )
     }
 
-    private suspend fun putUnlocked(credential: Credential) {
+    /** 读取账号元数据；多账号服务且文档不存在时尝试从旧单凭据迁移。 */
+    private suspend fun readAccountsUnlocked(service: ServiceType): List<ServiceAccountInfo> {
+        if (!ServiceType.isMultiAccount(service)) return emptyList()
+        val stored = secureStorage.get(accountDocKeyFor(service), AccountStore.serializer())
+            ?: return migrateLegacyUnlocked(service)
+        return stored.accounts
+    }
+
+    /** 旧版本单凭据迁移为默认账号（幂等，失败重试安全）。 */
+    private suspend fun migrateLegacyUnlocked(service: ServiceType): List<ServiceAccountInfo> {
+        val legacy = readLegacyCredentialUnlocked(service) ?: return emptyList()
+        val account = ServiceAccountInfo(
+            id = LEGACY_DEFAULT_ACCOUNT_ID,
+            label = null,
+            isDefault = true,
+            createdAt = System.currentTimeMillis()
+        )
+        // 先复制凭据、再写账号文档；半途失败时下次读到旧键会重新迁移
+        secureStorage.put(keyFor(service, account.id), legacy, Credential.serializer())
+        putAccountsUnlocked(service, listOf(account))
+        return listOf(account)
+    }
+
+    private suspend fun putAccountsUnlocked(
+        service: ServiceType,
+        accounts: List<ServiceAccountInfo>
+    ) {
         secureStorage.put(
-            key = keyFor(credential.service),
+            key = accountDocKeyFor(service),
+            value = AccountStore(service = service, accounts = accounts),
+            serializer = AccountStore.serializer()
+        )
+    }
+
+    private suspend fun createAccountUnlocked(
+        service: ServiceType,
+        label: String?
+    ): ServiceAccountInfo {
+        val accounts = readAccountsUnlocked(service).toMutableList()
+        val account = ServiceAccountInfo(
+            id = "acct_" + UUID.randomUUID().toString().replace("-", "").take(12),
+            label = label?.takeIf { it.isNotBlank() },
+            isDefault = accounts.isEmpty(),
+            createdAt = System.currentTimeMillis()
+        )
+        accounts += account
+        putAccountsUnlocked(service, accounts)
+        return account
+    }
+
+    /** 解析目标账号：显式 ID → 默认账号（无显式时）。 */
+    private suspend fun resolveAccountUnlocked(
+        service: ServiceType,
+        accountId: String?
+    ): ServiceAccountInfo? {
+        if (!ServiceType.isMultiAccount(service)) return null
+        val accounts = readAccountsUnlocked(service)
+        if (accounts.isEmpty()) return null
+        val id = accountId?.takeIf { it.isNotBlank() }
+        return if (id != null) {
+            accounts.firstOrNull { it.id == id }
+        } else {
+            accounts.firstOrNull { it.isDefault } ?: accounts.first()
+        }
+    }
+
+    private suspend fun accountsDocExistsUnlocked(service: ServiceType): Boolean =
+        secureStorage.get(accountDocKeyFor(service), AccountStore.serializer()) != null
+
+    /** 读取旧结构单凭据（多账号服务的旧版本数据 / 单账号服务的标准凭据）。 */
+    private suspend fun readLegacyCredentialUnlocked(service: ServiceType): Credential? =
+        secureStorage.get(keyFor(service, null), Credential.serializer())
+
+    /**
+     * 按账号读取凭据：
+     *  - 多账号服务：解析账号后读独立键；无账号文档时回退旧键；
+     *  - 单账号服务：恒读旧键。
+     */
+    private suspend fun getUnlocked(
+        service: ServiceType,
+        accountId: String? = null
+    ): Credential? {
+        if (ServiceType.isMultiAccount(service)) {
+            val resolved = resolveAccountUnlocked(service, accountId)
+            if (resolved != null) {
+                return secureStorage.get(keyFor(service, resolved.id), Credential.serializer())
+            }
+            return if (accountId.isNullOrBlank() && !accountsDocExistsUnlocked(service)) {
+                readLegacyCredentialUnlocked(service)
+            } else {
+                null
+            }
+        }
+        return readLegacyCredentialUnlocked(service)
+    }
+
+    private suspend fun putUnlocked(credential: Credential, accountId: String?) {
+        secureStorage.put(
+            key = keyFor(credential.service, accountId),
             value = credential,
             serializer = Credential.serializer()
         )
     }
 
-    private suspend fun getUnlocked(service: ServiceType): Credential? =
-        secureStorage.get(
-            key = keyFor(service),
-            serializer = Credential.serializer()
-        )
+    /** 按账号读缓存：优先账号分片，默认账号回退旧结构镜像。 */
+    private suspend fun accountCacheFor(
+        service: ServiceType,
+        accountId: String?
+    ): CachedBalance? {
+        if (!ServiceType.isMultiAccount(service)) return balanceCache.get(service)
+        val id = accountId?.takeIf { it.isNotBlank() }
+        return if (id != null) {
+            balanceCache.getAccountCached(service, id)
+                ?: if (resolveAccountUnlocked(service, null)?.id == id) balanceCache.get(service) else null
+        } else {
+            resolveAccountUnlocked(service, null)?.let { account ->
+                balanceCache.getAccountCached(service, account.id) ?: balanceCache.get(service)
+            }
+        }
+    }
 
-    private fun revisionFor(service: ServiceType): Long = revisions[service] ?: 0L
+    /** 删除某账号（或单账号服务）关联的余额缓存；默认账号会一并清理旧结构镜像。 */
+    private suspend fun removeCacheFor(service: ServiceType, accountId: String?) {
+        if (ServiceType.isMultiAccount(service)) {
+            if (accountId.isNullOrBlank()) {
+                balanceCache.removeLegacy(service)
+            } else {
+                balanceCache.removeAccount(service, accountId)
+                if (resolveAccountUnlocked(service, null)?.id == accountId) {
+                    // 默认账号被替换：旧结构镜像属于旧默认账号，只清镜像，保留其余账号分片缓存
+                    balanceCache.removeLegacy(service)
+                }
+            }
+        } else {
+            balanceCache.remove(service)
+        }
+    }
 
-    private fun bumpRevision(service: ServiceType) {
-        revisions[service] = revisionFor(service) + 1L
+    private fun clearRollbacksFor(service: ServiceType) {
+        val prefix = service.storageKey + ":"
+        cacheRollbackEntries.keys
+            .filter { it == service.storageKey || it.startsWith(prefix) }
+            .forEach { cacheRollbackEntries.remove(it) }
+    }
+
+    private fun revisionFor(service: ServiceType, accountId: String?): Long =
+        revisions[revisionKey(service, accountId)] ?: 0L
+
+    private fun bumpRevision(service: ServiceType, accountId: String?) {
+        revisions[revisionKey(service, accountId)] = revisionFor(service, accountId) + 1L
     }
 
     companion object {
+        /** 旧单凭据迁移为默认账号时使用的固定账号 ID。 */
+        const val LEGACY_DEFAULT_ACCOUNT_ID = "default"
+
         internal fun determineCredentialState(
             lastVerifiedAt: Long,
             now: Long
@@ -350,6 +773,23 @@ class CredentialRepository @Inject constructor(
                             field("refreshToken", credential.refreshToken)
                         }
                     }
+                    is Credential.TraeCredential -> {
+                        field("type", "trae")
+                        field("jwt", credential.jwt)
+                        field("region", credential.region)
+                    }
+                    is Credential.WorkBuddyCredential -> {
+                        // WorkBuddy 无公开稳定账户 ID；access/refresh token 会话内会轮换，
+                        // 若把 token 纳入身份，每次轮换都会误清余额缓存。这里用固定身份：
+                        // 余额缓存归属同一账号（换账号场景由下一次成功刷新直接覆盖）。
+                        field("type", "workbuddy")
+                        field("identity", "account")
+                    }
+                    is Credential.Sub2ApiCredential -> {
+                        field("type", "sub2api")
+                        field("baseUrl", credential.baseUrl)
+                        field("email", credential.email)
+                    }
                 }
             }
             return sha256(material)
@@ -396,11 +836,33 @@ class CredentialRepository @Inject constructor(
                         field("refreshToken", credential.refreshToken)
                         field("accountId", credential.accountId)
                     }
+                    is Credential.TraeCredential -> {
+                        field("type", "trae")
+                        field("jwt", credential.jwt)
+                        field("region", credential.region)
+                    }
+                    is Credential.WorkBuddyCredential -> {
+                        field("type", "workbuddy")
+                        field("accessToken", credential.accessToken)
+                        field("refreshToken", credential.refreshToken)
+                        field("expiresAt", credential.expiresAt.toString())
+                    }
+                    is Credential.Sub2ApiCredential -> {
+                        field("type", "sub2api")
+                        field("baseUrl", credential.baseUrl)
+                        field("email", credential.email)
+                        field("password", credential.password)
+                        field("apiKey", credential.apiKey)
+                    }
                 }
             }
             return sha256(material)
         }
 
+        /** 账号存储键（与 BalanceCache 的复合键格式一致，供测试断言）。 */
+        internal fun accountCacheKeyFor(service: ServiceType, accountId: String): String =
+            "${service.storageKey}:$accountId"
+
         private fun List<com.rainy.token.domain.model.CookieEntry>.sortedForFingerprint() =
             sortedWith(
                 compareBy(
@@ -437,4 +899,4 @@ class CredentialRepository @Inject constructor(
             return String(chars)
         }
     }
-}
+}

app/src/main/java/com/rainy/token/data/repository/OllamaRepository.kt

@@ -4,6 +4,7 @@ import com.rainy.token.data.cache.BalanceCache
 import com.rainy.token.data.debug.DebugLog
 import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.model.ServiceBalance
+import com.rainy.token.domain.model.TriggerSummary
 import com.rainy.token.domain.service.ServiceType
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
@@ -22,7 +23,7 @@ import java.util.TimeZone
 import javax.inject.Singleton
 
 /**
- * Ollama Pro Cloud 用量仓库。
+ * Ollama Cloud 用量仓库。
  *
  * Ollama 没有公开的 Usage API（见 ollama/ollama#12532），
  * 本 Repository 通过 OkHttp 搓 Cookie 请求 https://ollama.com/settings，
@@ -107,7 +108,7 @@ class OllamaRepository(
             if (sessionPct == null && weeklyPct == null) return null
 
             return ParsedUsage(
-                plan = plan ?: "Unknown",
+                plan = plan.orEmpty(),  // 空串由 UI 层兜底显示 "—"，避免英文 "Unknown" 出现在中文 UI
                 sessionPercent = sessionPct ?: 0f,
                 weeklyPercent = weeklyPct ?: 0f,
                 sessionResetAt = sessionResetAt,
@@ -177,13 +178,14 @@ class OllamaRepository(
             }
 
             val html = resp.body?.string() ?: return@withContext Result.failure(
-                RepositoryError.ParseError("响应体为空")
+                RepositoryError.ParseError(RepositoryError.ParseErrorReason.EMPTY_BODY, "响应体为空")
             )
 
             val parsed = parseUsage(html)
             if (parsed == null) {
                 return@withContext Result.failure(
                     RepositoryError.ParseError(
+                        RepositoryError.ParseErrorReason.NO_WINDOWS,
                         "解析失败：未找到 Ollama Cloud 用量数据。HTML=${html.length} 字节。Cookie 可能已过期。"
                     )
                 )
@@ -240,15 +242,15 @@ class OllamaRepository(
                     DebugLog.e(TAG, "fetchModels: HTTP ${resp.code}")
                     return@withContext Result.failure(RepositoryError.ServerError(resp.code))
                 }
-                val root = json.parseToJsonElement(resp.body?.string() ?: throw RepositoryError.ParseError("响应体为空")) as? JsonObject
-                    ?: throw RepositoryError.ParseError("响应根节点不是 JSON 对象")
+                val root = json.parseToJsonElement(resp.body?.string() ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.EMPTY_BODY, "响应体为空")) as? JsonObject
+                    ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.NOT_JSON_OBJECT, "响应根节点不是 JSON 对象")
                 val provider = root["ollama-cloud"] as? JsonObject
                 val modelsObj = provider?.get("models") as? JsonObject
                 modelsObj?.keys?.toList()?.sorted()
-                    ?: throw RepositoryError.ParseError("未找到 Ollama Cloud 模型列表")
+                    ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.NO_MODELS, "未找到 Ollama Cloud 模型列表")
             }
             if (models.isEmpty()) {
-                return@withContext Result.failure(RepositoryError.ParseError("模型列表为空"))
+                return@withContext Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.MODELS_EMPTY, "模型列表为空"))
             }
             DebugLog.i(TAG, "fetchModels: 获取到 ${models.size} 个模型")
             Result.success(models)
@@ -268,7 +270,7 @@ class OllamaRepository(
      * @param model 用户选择的模型 slug
      * @return Result.success(响应摘要文本) — 供 UI 展示
      */
-    suspend fun triggerUsage(model: String): Result<String> = withContext(Dispatchers.IO) {
+    suspend fun triggerUsage(model: String): Result<TriggerSummary> = withContext(Dispatchers.IO) {
         val credential = credentialRepository.get(ServiceType.OLLAMA)
             ?: return@withContext Result.failure(RepositoryError.InvalidCredential("未找到 Ollama 凭据"))
         if (credential !is Credential.SessionCredential)
@@ -296,8 +298,8 @@ class OllamaRepository(
                 val bodyStr = resp.body?.string() ?: ""
                 DebugLog.i(TAG, "triggerUsage: HTTP ${resp.code}, body=${bodyStr.take(500)}")
                 if (!resp.isSuccessful) {
-                    return@withContext Result.failure<String>(
-                        TriggerError("HTTP ${resp.code}", bodyStr.ifBlank { "无响应体" })
+                    return@withContext Result.failure<TriggerSummary>(
+                        TriggerError("HTTP ${resp.code}", bodyStr.ifBlank { "" })
                     )
                 }
                 DebugLog.i(TAG, "triggerUsage: 请求成功，模型=$model")
@@ -317,7 +319,7 @@ class OllamaRepository(
 /**
  * 解析 Ollama Cloud chat completions 响应，提取回复文本和用量统计。
  */
-internal fun parseOllamaChatResponse(responseBody: String, model: String): String {
+internal fun parseOllamaChatResponse(responseBody: String, model: String): TriggerSummary {
     val json = Json { ignoreUnknownKeys = true }
     return try {
         val root = json.parseToJsonElement(responseBody) as? JsonObject
@@ -330,18 +332,14 @@ internal fun parseOllamaChatResponse(responseBody: String, model: String): Strin
         val completionTokens = (usage?.get("completion_tokens") as? JsonPrimitive)?.contentOrNull
         val totalTokens = (usage?.get("total_tokens") as? JsonPrimitive)?.contentOrNull
 
-        val sb = StringBuilder()
-        sb.appendLine("✓ 激活成功")
-        sb.appendLine("模型: $model")
-        sb.appendLine()
-        sb.appendLine("回复:")
-        sb.appendLine(content?.ifEmpty { "(空)" } ?: "(无回复内容)")
-        if (promptTokens != null || completionTokens != null) {
-            sb.appendLine()
-            sb.appendLine("用量: prompt=$promptTokens completion=$completionTokens total=$totalTokens tokens")
-        }
-        sb.toString().trim()
+        TriggerSummary(
+            model = model,
+            reply = content,
+            inputTokens = promptTokens,
+            outputTokens = completionTokens,
+            totalTokens = totalTokens
+        )
     } catch (_: Exception) {
-        "✓ 激活成功\n模型: $model\n\n(响应解析失败，但请求已发出)"
+        TriggerSummary(model = model, reply = null, parseFailed = true)
     }
 }

app/src/main/java/com/rainy/token/data/repository/OpenCodeGoRepository.kt

@@ -4,10 +4,16 @@ import com.rainy.token.data.cache.BalanceCache
 import com.rainy.token.data.debug.DebugLog
 import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.model.ServiceBalance
+import com.rainy.token.domain.model.TriggerSummary
 import com.rainy.token.domain.service.ServiceConfigProvider
 import com.rainy.token.domain.service.ServiceType
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.withContext
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
@@ -20,6 +26,7 @@ import okhttp3.Request
 import okhttp3.RequestBody.Companion.toRequestBody
 import java.io.IOException
 import java.net.URLEncoder
+import java.util.concurrent.TimeUnit
 import javax.inject.Singleton
 
 /**
@@ -85,13 +92,14 @@ class OpenCodeGoRepository(
             }
 
             val html = resp.body?.string() ?: return@withContext Result.failure(
-                RepositoryError.ParseError("响应体为空")
+                RepositoryError.ParseError(RepositoryError.ParseErrorReason.EMPTY_BODY, "响应体为空")
             )
 
             val windows = parseWindows(html)
             if (windows.isEmpty()) {
                 return@withContext Result.failure(
                     RepositoryError.ParseError(
+                        RepositoryError.ParseErrorReason.NO_WINDOWS,
                         "解析失败：未找到任何 OpenCode Go 配额窗口。HTML=${html.length} 字节。"
                     )
                 )
@@ -102,21 +110,29 @@ class OpenCodeGoRepository(
             val config = ServiceConfigProvider.get(ServiceType.OPENCODE_GO)
 
             // 把 3 个窗口的用量百分比 + 重置时间全部塞进 extras（详情页按窗口渲染）
+            // usage/limit 为页面新增的用量与限额字段（单位以服务端定义为准，保留供详情页展示，UI 兼容缺失场景）
             val extras = buildMap {
                 windows["rollingUsage"]?.let { w ->
                     put("rolling.pct", w.usagePercent.toString())
                     put("rolling.resetInSec", w.resetInSec.toString())
+                    w.usage?.let { put("rolling.usage", it.toString()) }
+                    w.limit?.let { put("rolling.limit", it.toString()) }
                 }
                 windows["weeklyUsage"]?.let { w ->
                     put("weekly.pct", w.usagePercent.toString())
                     put("weekly.resetInSec", w.resetInSec.toString())
+                    w.usage?.let { put("weekly.usage", it.toString()) }
+                    w.limit?.let { put("weekly.limit", it.toString()) }
                 }
                 windows["monthlyUsage"]?.let { w ->
                     put("monthly.pct", w.usagePercent.toString())
                     put("monthly.resetInSec", w.resetInSec.toString())
+                    w.usage?.let { put("monthly.usage", it.toString()) }
+                    w.limit?.let { put("monthly.limit", it.toString()) }
                 }
             }
 
+            // 主窗口数据先落缓存并返回（关键路径只依赖 HTML 解析一次请求）
             val balance = ServiceBalance(
                 service = ServiceType.OPENCODE_GO,
                 amount = primary.usagePercent.toDouble(),
@@ -127,11 +143,22 @@ class OpenCodeGoRepository(
                 nextResetAt = System.currentTimeMillis() + primary.resetInSec * 1000L,
                 extras = extras
             )
-
             balanceCache.put(ServiceType.OPENCODE_GO, balance)
             credentialRepository.save(credential.copy(lastVerifiedAt = System.currentTimeMillis()))
 
-            Result.success(balance)
+            // 模型级用量作为增量增强：并行拉取 + 短超时，失败/超时不影响主窗口数据与缓存
+            val modelUsage = fetchModelWindows(workspaceId, authCookie)
+            if (modelUsage.isEmpty()) {
+                return@withContext Result.success(balance)
+            }
+            val enriched = balance.copy(
+                extras = buildMap {
+                    putAll(extras)
+                    modelUsage.forEach { (window, usage) -> put("$window.models", json.encodeToString(usage)) }
+                }
+            )
+            balanceCache.put(ServiceType.OPENCODE_GO, enriched)
+            Result.success(enriched)
         }
     }
 
@@ -150,15 +177,15 @@ class OpenCodeGoRepository(
                     DebugLog.e(TAG, "fetchModels: HTTP ${resp.code}")
                     return@withContext Result.failure(RepositoryError.ServerError(resp.code))
                 }
-                val root = json.parseToJsonElement(resp.body?.string() ?: throw RepositoryError.ParseError("响应体为空")) as? JsonObject
-                    ?: throw RepositoryError.ParseError("响应根节点不是 JSON 对象")
+                val root = json.parseToJsonElement(resp.body?.string() ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.EMPTY_BODY, "响应体为空")) as? JsonObject
+                    ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.NOT_JSON_OBJECT, "响应根节点不是 JSON 对象")
                 val provider = root["opencode-go"] as? JsonObject
                 val modelsObj = provider?.get("models") as? JsonObject
                 modelsObj?.keys?.toList()?.sorted()
-                    ?: throw RepositoryError.ParseError("未找到 OpenCode Go 模型列表")
+                    ?: throw RepositoryError.ParseError(RepositoryError.ParseErrorReason.NO_MODELS, "未找到 OpenCode Go 模型列表")
             }
             if (models.isEmpty()) {
-                return@withContext Result.failure(RepositoryError.ParseError("模型列表为空"))
+                return@withContext Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.MODELS_EMPTY, "模型列表为空"))
             }
             DebugLog.i(TAG, "fetchModels: 获取到 ${models.size} 个模型")
             Result.success(models)
@@ -178,7 +205,7 @@ class OpenCodeGoRepository(
      * @param model 用户选择的模型 slug
      * @return Result.success(响应摘要文本) — 供 UI 展示
      */
-    suspend fun triggerUsage(model: String): Result<String> = withContext(Dispatchers.IO) {
+    suspend fun triggerUsage(model: String): Result<TriggerSummary> = withContext(Dispatchers.IO) {
         val credential = credentialRepository.get(ServiceType.OPENCODE_GO)
             ?: return@withContext Result.failure(RepositoryError.InvalidCredential("未找到 OpenCode Go 凭据"))
         if (credential !is Credential.SessionCredential)
@@ -206,8 +233,8 @@ class OpenCodeGoRepository(
                 val bodyStr = resp.body?.string() ?: ""
                 DebugLog.i(TAG, "triggerUsage: HTTP ${resp.code}, body=${bodyStr.take(500)}")
                 if (!resp.isSuccessful) {
-                    return@withContext Result.failure<String>(
-                        TriggerError("HTTP ${resp.code}", bodyStr.ifBlank { "无响应体" })
+                    return@withContext Result.failure<TriggerSummary>(
+                        TriggerError("HTTP ${resp.code}", bodyStr.ifBlank { "" })
                     )
                 }
                 DebugLog.i(TAG, "triggerUsage: 请求成功，模型=$model")
@@ -226,6 +253,12 @@ class OpenCodeGoRepository(
         private const val TAG = "OCGO"
         private const val MODELS_API = "https://models.dev/api.json"
         private const val CHAT_API = "https://opencode.ai/zen/go/v1/chat/completions"
+        /** _server 端点：模型级用量接口（f:31 + 窗口参数，需 x-server-id / x-server-instance 头） */
+        private const val SERVER_ENDPOINT = "https://opencode.ai/_server"
+        /** 窗口模型用量的 server function id（与请求头 x-server-id 一致，取自网页端实测） */
+        private const val MODEL_USAGE_SERVER_ID = "ba154d05c4028a885b8c753f9def7e45d87eb982e65fa8b14254cbe636168914"
+        /** 模型级用量单请求超时（毫秒）：只影响增强数据，避免拖慢主窗口刷新 */
+        private const val MODEL_REQUEST_TIMEOUT_MS = 5_000L
         private val SCRAPED_FIELDS = listOf("rollingUsage", "weeklyUsage", "monthlyUsage")
 
         /**
@@ -255,10 +288,14 @@ class OpenCodeGoRepository(
                 val braceEnd = findMatchingBrace(html, braceStart) ?: continue
                 val body = html.substring(braceStart, braceEnd + 1)
 
-                val pct = extractNumberAfterKey(body, "usagePercent")?.toIntOrNull()
+                val pct = extractNumberAfterKey(body, "usagePercent")?.toFloatOrNull()
                 val reset = extractNumberAfterKey(body, "resetInSec")?.toLongOrNull()
+                // usage/limit 是页面新增的用量与限额字段（单位以服务端定义为准，缺失不影响窗口识别）
+                // exactKey=true：避免 "usage" 误命中 "usagePercent" 前缀
+                val usage = extractNumberAfterKey(body, "usage", exactKey = true)?.toLongOrNull()
+                val limit = extractNumberAfterKey(body, "limit", exactKey = true)?.toLongOrNull()
                 if (pct != null && reset != null) {
-                    result[field] = ScrapedWindow(pct, reset)
+                    result[field] = ScrapedWindow(pct, reset, usage, limit)
                 }
             }
 
@@ -286,9 +323,23 @@ class OpenCodeGoRepository(
         /**
          * 在 body 字符串中找 "key:" 后面紧跟的数字（含可选小数）。返回数字字符串，未找到返回 null。
          * 跳过 status 字符串值（"ok" 之类）。
+         *
+         * @param exactKey 为 true 时要求 key 后紧跟 ':'（精确字段匹配），
+         *                 避免 "usage" 误命中 "usagePercent" 这类前缀字段。
          */
-        private fun extractNumberAfterKey(body: String, key: String): String? {
-            val keyIdx = body.indexOf(key)
+        private fun extractNumberAfterKey(body: String, key: String, exactKey: Boolean = false): String? {
+            val keyIdx = if (exactKey) {
+                // 精确匹配：key 后必须紧跟 ':'（如 "usage:"），不能是 "usagePercent"
+                var idx = body.indexOf(key)
+                while (idx >= 0) {
+                    val after = idx + key.length
+                    if (after < body.length && body[after] == ':') break
+                    idx = body.indexOf(key, idx + 1)
+                }
+                idx
+            } else {
+                body.indexOf(key)
+            }
             if (keyIdx < 0) return null
             var i = keyIdx + key.length
             // 跳过 ":" 后面所有非数字、非负号、非小数点字符
@@ -311,14 +362,183 @@ class OpenCodeGoRepository(
             return body.substring(start, i).ifEmpty { null }
         }
 
-        internal data class ScrapedWindow(val usagePercent: Int, val resetInSec: Long)
+        internal data class ScrapedWindow(
+            val usagePercent: Float,
+            val resetInSec: Long,
+            val usage: Long? = null,
+            val limit: Long? = null
+        )
+
+        /**
+         * 解析 _server 返回的模型级用量 flight 响应。
+         *
+         * 实际响应形如：
+         * ```
+         * ;0x000003bc;((self.$R=self.$R||{})["server-fn:2"]=[],($R=>$R[0]={
+         *   usage:1889462439,limit:6000000000,usagePercent:31.5,
+         *   rows:$R[1]=[$R[2]={model:"deepseek-v4-flash",name:"DeepSeek V4 Flash",
+         *                     cost:1002607535,quotaCost:2005215070,multiplier:2,
+         *                     estimated:!0,contributionPercent:30.5},...]
+         * })($R["server-fn:2"]))
+         * ```
+         *
+         * 返回窗口模型用量（usage/limit/usagePercent + 每模型行），解析失败返回 null。
+         * cost/quotaCost 单位为 1e-8 美元（cost × 10⁻⁸ = 美元）。
+         */
+        internal fun parseModelRows(flight: String): WindowModelUsage? {
+            // 定位 "$R[0]={" 数据块（窗口模型用量的固定 hydration 格式）
+            val rootIdx = flight.indexOf("\$R[0]={")
+            if (rootIdx < 0) return null
+            val braceStart = rootIdx + "\$R[0]=".length
+            val braceEnd = findMatchingBrace(flight, braceStart) ?: return null
+            val body = flight.substring(braceStart, braceEnd + 1)
+
+            val usage = extractNumberAfterKey(body, "usage", exactKey = true)?.toLongOrNull()
+            val limit = extractNumberAfterKey(body, "limit", exactKey = true)?.toLongOrNull()
+            val usagePercent = extractNumberAfterKey(body, "usagePercent")?.toFloatOrNull()
+
+            return WindowModelUsage(
+                usage = usage,
+                limit = limit,
+                usagePercent = usagePercent,
+                rows = extractModelRows(body)
+            )
+        }
+
+        /** 从外层对象 body 中提取所有 {model:"..."} 模型行对象。 */
+        private fun extractModelRows(body: String): List<ModelUsageRow> {
+            val rows = mutableListOf<ModelUsageRow>()
+            var idx = body.indexOf("{model:")
+            while (idx >= 0) {
+                val braceEnd = findMatchingBrace(body, idx) ?: break
+                val obj = body.substring(idx, braceEnd + 1)
+                val model = extractQuoted(obj, "model") ?: ""
+                val name = extractQuoted(obj, "name") ?: ""
+                val cost = extractNumberAfterKey(obj, "cost")?.toLongOrNull() ?: 0L
+                val quotaCost = extractNumberAfterKey(obj, "quotaCost")?.toLongOrNull() ?: 0L
+                val multiplier = extractNumberAfterKey(obj, "multiplier")?.toDoubleOrNull() ?: 1.0
+                val estimated = obj.contains("estimated:!0")
+                val contributionPercent = extractNumberAfterKey(obj, "contributionPercent")?.toDoubleOrNull() ?: 0.0
+                rows += ModelUsageRow(
+                    model = model,
+                    name = name,
+                    cost = cost,
+                    quotaCost = quotaCost,
+                    multiplier = multiplier,
+                    estimated = estimated,
+                    contributionPercent = contributionPercent
+                )
+                idx = body.indexOf("{model:", braceEnd + 1)
+            }
+            return rows
+        }
+
+        /** 提取 "key:" 后面紧跟的 "..." 引号字符串值。 */
+        private fun extractQuoted(body: String, key: String): String? {
+            val keyIdx = body.indexOf("$key:\"")
+            if (keyIdx < 0) return null
+            val start = keyIdx + key.length + 2
+            val end = body.indexOf('"', start)
+            if (end < 0) return null
+            return body.substring(start, end)
+        }
+
+        /**
+         * 窗口配额（1e-8 美元整数）：窗口 limit（token 数）÷ multiplier。
+         * 与网页端各窗口"配额"列口径一致（实测：5h=12 亿÷2=$6、周=30 亿÷2=$15、月=60 亿÷2=$30；hy3 月=60 亿÷0.125=$480）。
+         * multiplier 缺失或非正时安全降级为月度基础 $60（与网页默认一致）。
+         */
+        internal fun windowQuotaRaw(windowLimit: Long, multiplier: Double): Long {
+            if (multiplier <= 0.0) return 60L * 100_000_000L
+            return (windowLimit.toDouble() / multiplier).toLong()
+        }
+    }
+
+    /**
+     * 拉取三个窗口（rolling/weekly/monthly）的模型级用量。
+     * 并行发起 + 每个请求独立短超时（MODEL_REQUEST_TIMEOUT_MS），
+     * 任一窗口失败不影响其他窗口；整体失败返回空 Map（主窗口数据不受影响）。
+     */
+    private suspend fun fetchModelWindows(workspaceId: String, authCookie: String): Map<String, WindowModelUsage> =
+        coroutineScope {
+            listOf("rolling", "weekly", "monthly").map { window ->
+                async {
+                    try {
+                        requestModelWindow(workspaceId, authCookie, window)?.let { parseModelRows(it) }
+                    } catch (e: Exception) {
+                        DebugLog.e(TAG, "fetchModelWindows($window) 异常: ${e.message}")
+                        null
+                    }
+                }
+            }.awaitAll().let { results ->
+                listOf("rolling", "weekly", "monthly").zip(results).mapNotNull { (window, usage) ->
+                    usage?.let { window to it }
+                }.toMap()
+            }
+        }
+
+    /** 请求 _server 的窗口模型用量接口，返回 flight 文本；HTTP 失败/超时返回 null。 */
+    private fun requestModelWindow(workspaceId: String, authCookie: String, window: String): String? {
+        val args = """{"t":{"t":9,"i":0,"l":2,"a":[{"t":1,"s":"$workspaceId"},{"t":1,"s":"$window"}],"o":0},"f":31,"m":[]}"""
+        val url = "$SERVER_ENDPOINT?id=$MODEL_USAGE_SERVER_ID&args=${URLEncoder.encode(args, "UTF-8")}"
+        val request = Request.Builder()
+            .url(url)
+            .header("Accept", "*/*")
+            .header("Cookie", "auth=$authCookie")
+            .header("x-server-id", MODEL_USAGE_SERVER_ID)
+            .header("x-server-instance", "server-fn:2")
+            .header("Referer", "https://opencode.ai/workspace/$workspaceId/go")
+            .header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/152.0.0.0 Safari/537.36")
+            .get().build()
+        val call = okHttpClient.newCall(request)
+        call.timeout().timeout(MODEL_REQUEST_TIMEOUT_MS, TimeUnit.MILLISECONDS)
+        return try {
+            call.execute().use { resp ->
+                if (!resp.isSuccessful) {
+                    DebugLog.e(TAG, "requestModelWindow($window): HTTP ${resp.code}")
+                    null
+                } else {
+                    resp.body?.string()
+                }
+            }
+        } catch (e: IOException) {
+            DebugLog.e(TAG, "requestModelWindow($window) 网络异常: ${e.message}")
+            null
+        } catch (e: Throwable) {
+            DebugLog.e(TAG, "requestModelWindow($window) 异常: ${e.message}")
+            null
+        }
     }
 }
 
+/**
+ * 窗口模型级用量（_server 接口 payload）。
+ * cost/quotaCost 单位为 1e-8 美元；multiplier 为计费倍率（quotaCost = cost × multiplier）。
+ */
+@Serializable
+internal data class WindowModelUsage(
+    val usage: Long? = null,
+    val limit: Long? = null,
+    val usagePercent: Float? = null,
+    val rows: List<ModelUsageRow> = emptyList()
+)
+
+/** 单模型用量行。contributionPercent 为该模型占窗口用量的百分比（如 30.5 = 30.5%）。 */
+@Serializable
+internal data class ModelUsageRow(
+    val model: String = "",
+    val name: String = "",
+    val cost: Long = 0L,
+    val quotaCost: Long = 0L,
+    val multiplier: Double = 1.0,
+    val estimated: Boolean = false,
+    val contributionPercent: Double = 0.0
+)
+
 /**
  * 解析 OpenAI 兼容的 chat completions 响应，提取回复文本和用量统计。
  */
-internal fun parseChatResponse(responseBody: String, model: String): String {
+internal fun parseChatResponse(responseBody: String, model: String): TriggerSummary {
     val json = Json { ignoreUnknownKeys = true }
     return try {
         val root = json.parseToJsonElement(responseBody) as? JsonObject
@@ -331,18 +551,14 @@ internal fun parseChatResponse(responseBody: String, model: String): String {
         val completionTokens = (usage?.get("completion_tokens") as? JsonPrimitive)?.contentOrNull
         val totalTokens = (usage?.get("total_tokens") as? JsonPrimitive)?.contentOrNull
 
-        val sb = StringBuilder()
-        sb.appendLine("✓ 激活成功")
-        sb.appendLine("模型: $model")
-        sb.appendLine()
-        sb.appendLine("回复:")
-        sb.appendLine(content?.ifEmpty { "(空)" } ?: "(无回复内容)")
-        if (promptTokens != null || completionTokens != null) {
-            sb.appendLine()
-            sb.appendLine("用量: prompt=$promptTokens completion=$completionTokens total=$totalTokens tokens")
-        }
-        sb.toString().trim()
+        TriggerSummary(
+            model = model,
+            reply = content,
+            inputTokens = promptTokens,
+            outputTokens = completionTokens,
+            totalTokens = totalTokens
+        )
     } catch (_: Exception) {
-        "✓ 激活成功\n模型: $model\n\n(响应解析失败，但请求已发出)"
+        TriggerSummary(model = model, reply = null, parseFailed = true)
     }
 }

app/src/main/java/com/rainy/token/data/repository/OpenCodeUsageRepository.kt

@@ -88,7 +88,7 @@ class OpenCodeUsageRepository(
             }
 
             val body = resp.body?.string() ?: return@withContext Result.failure(
-                RepositoryError.ParseError("响应体为空")
+                RepositoryError.ParseError(RepositoryError.ParseErrorReason.EMPTY_BODY, "响应体为空")
             )
 
             val records = parseUsageRecords(body)

app/src/main/java/com/rainy/token/data/repository/RefreshWriteSession.kt

@@ -19,6 +19,9 @@ internal class RefreshWriteSession(
 
     companion object Key : CoroutineContext.Key<RefreshWriteSession>
 
+    /** 快照对应的账号 ID；单账号服务为 null。 */
+    val accountId: String? get() = snapshot.accountId
+
     private val stateLock = Any()
     private var pendingCredential: Credential? = null
     private var pendingBalance: ServiceBalance? = null
@@ -72,4 +75,7 @@ private fun Credential.withLastVerifiedAt(value: Long): Credential = when (this)
     is Credential.ApiKeyCredential -> copy(lastVerifiedAt = value)
     is Credential.SessionCredential -> copy(lastVerifiedAt = value)
     is Credential.CodexCredential -> copy(lastVerifiedAt = value)
+    is Credential.TraeCredential -> copy(lastVerifiedAt = value)
+    is Credential.WorkBuddyCredential -> copy(lastVerifiedAt = value)
+    is Credential.Sub2ApiCredential -> copy(lastVerifiedAt = value)
 }

app/src/main/java/com/rainy/token/data/repository/RepositoryError.kt

@@ -9,6 +9,9 @@ sealed class RepositoryError(message: String, cause: Throwable? = null) : Except
     class InvalidCredential(detail: String? = null, cause: Throwable? = null) :
         RepositoryError("凭据无效" + (detail?.let { ": $it" } ?: ""), cause)
 
+    /** 服务端 CheckLogin 确认登录态已失效（未登录或 JWT 过期），需重新登录 */
+    class SessionExpired : RepositoryError("登录已过期，请重新登录")
+
     /** 请求期间凭据被保存、替换或删除；旧结果已安全丢弃。 */
     class CredentialChanged : RepositoryError("凭据已变更，本次请求结果已丢弃")
 
@@ -23,9 +26,25 @@ sealed class RepositoryError(message: String, cause: Throwable? = null) : Except
     class ServerError(val code: Int, cause: Throwable? = null) :
         RepositoryError("服务端异常 (HTTP $code)", cause)
 
-    /** 解析失败（HTML 解析结果为空 / JSON 反序列化失败） */
-    class ParseError(message: String, cause: Throwable? = null) :
-        RepositoryError("解析失败: $message", cause)
+    /** 解析失败的具体原因（结构化错误码，UI 层据此映射本地化文案，detail 仅作日志/调试） */
+    enum class ParseErrorReason {
+        /** 响应体为空 */
+        EMPTY_BODY,
+        /** 响应根节点不是 JSON 对象 */
+        NOT_JSON_OBJECT,
+        /** 未找到用量窗口数据 */
+        NO_WINDOWS,
+        /** 未找到模型列表 */
+        NO_MODELS,
+        /** 模型列表为空 */
+        MODELS_EMPTY,
+        /** 响应格式异常（detail 含异常信息，仅供日志） */
+        MALFORMED_RESPONSE
+    }
+
+    /** 解析失败（HTML 解析结果为空 / JSON 反序列化失败），detail 为具体原因（日志用，不直接透传 UI） */
+    class ParseError(val reason: ParseErrorReason, val detail: String, cause: Throwable? = null) :
+        RepositoryError("解析失败: $detail", cause)
 
     /** 未知错误 */
     class Unknown(cause: Throwable? = null) : RepositoryError(

app/src/main/java/com/rainy/token/data/repository/TraeRepository.kt

@@ -0,0 +1,738 @@
+package com.rainy.token.data.repository
+
+import com.rainy.token.data.cache.BalanceCache
+import com.rainy.token.data.debug.DebugLog
+import com.rainy.token.domain.model.Credential
+import com.rainy.token.domain.model.ServiceBalance
+import com.rainy.token.domain.service.ServiceType
+import java.io.IOException
+import javax.inject.Singleton
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.longOrNull
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+
+/**
+ * Trae（CN / Intl）余额仓库。
+ *
+ * 认证：官方 IDE/Web 用的 `Authorization: Cloud-IDE-JWT <jwt>`（RS256，~14 天）。区域只决定域名：
+ * - CN  ：POST https://api.trae.cn/trae/api/v2/pay/ide_user_ent_usage
+ * - INTL：POST https://grow-normal.trae.ai/trae/api/v1/pay/ide_user_ent_usage
+ * 2026-09 用真实登录态实测（api.trae.cn）：**仅带 Authorization + Content-Type 即成功**，
+ * X-User-Region / X-Device-Id 均非必需（官方 Web 不带），故不再发送，避免设备绑定误伤。
+ *
+ * 真实响应（实测结构）：
+ * ```json
+ * {
+ *   "is_credits_billing": true,
+ *   "usage_summary": {"consumed_amount":3341.17,"consumption_ratio":0.613,"total_amount":5450},
+ *   "user_entitlement_pack_list": [ {
+ *      "display_desc":"签到奖励",
+ *      "entitlement_base_info":{"quota":{"credits_limit":150}, ...},
+ *      "usage":{"credits_amount":142.18}, ...
+ *   } ]
+ * }
+ * ```
+ * 余额权威口径 = `usage_summary.total_amount - consumed_amount`（>=0）；usage_summary 缺失时
+ * 才退回包级求和（credits_limit - credits_amount，限流/无限包不计）。字段名防御式扫描。
+ */
+@Singleton
+class TraeRepository constructor(
+    private val okHttpClient: OkHttpClient,
+    private val credentialRepository: CredentialRepository,
+    private val balanceCache: BalanceCache
+) {
+
+    private val json = Json { ignoreUnknownKeys = true }
+
+    suspend fun fetchBalance(accountId: String? = null): Result<ServiceBalance> = withContext(Dispatchers.IO) {
+        val credential = credentialRepository.get(ServiceType.TRAE, accountId)
+            ?: return@withContext Result.failure(RepositoryError.InvalidCredential())
+        if (credential !is Credential.TraeCredential || credential.jwt.isBlank()) {
+            return@withContext Result.failure(RepositoryError.InvalidCredential())
+        }
+
+        val regionKey = credential.region.uppercase().takeIf { it == "INTL" } ?: "CN"
+        val url = when (regionKey) {
+            "INTL" -> "https://grow-normal.trae.ai/trae/api/v1/pay/ide_user_ent_usage"
+            else -> "https://api.trae.cn/trae/api/v2/pay/ide_user_ent_usage"
+        }
+        val request = Request.Builder()
+            .url(url)
+            .addHeader("Authorization", "Cloud-IDE-JWT ${credential.jwt.trim()}")
+            .addHeader("Content-Type", "application/json")
+            .post("{}".toRequestBody("application/json".toMediaType()))
+            .build()
+
+        val body = try {
+            okHttpClient.newCall(request).execute().use { resp ->
+                val text = resp.body?.string().orEmpty()
+                DebugLog.i(TAG, "fetchBalance: http=${resp.code} body=${text.take(300)}")
+                if (!resp.isSuccessful) {
+                    return@withContext Result.failure(
+                        if (resp.code == 401 || resp.code == 403) {
+                            authErrorFor(credential.jwt.trim())
+                        } else {
+                            mapHttpError(resp.code)
+                        }
+                    )
+                }
+                text
+            }
+        } catch (e: IOException) {
+            return@withContext Result.failure(RepositoryError.Network(e))
+        } catch (e: Throwable) {
+            return@withContext Result.failure(RepositoryError.Unknown(e))
+        }
+
+        val parsed = runCatching { parseBody(body) }
+            .getOrElse { e ->
+                return@withContext Result.failure(
+                    RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "trae 解析失败: ${e.message}")
+                )
+            }
+
+        val balance = ServiceBalance(
+            service = ServiceType.TRAE,
+            amount = parsed.amount,
+            unit = "Credits",
+            totalQuota = parsed.totalQuota,
+            extras = parsed.extras
+        )
+        balanceCache.put(ServiceType.TRAE, balance, accountId)
+        credentialRepository.save(credential.copy(lastVerifiedAt = System.currentTimeMillis()), accountId)
+        Result.success(balance)
+    }
+
+    /** 解析：usage_summary 权威优先；缺失时回退权益包求和。字段缺失跳过，不抛异常。 */
+    private fun parseBody(body: String): ParsedTraeUsage {
+        val root = json.parseToJsonElement(body).jsonObject
+        val extras = linkedMapOf<String, String>()
+
+        root["is_credits_billing"]?.jsonPrimitive?.contentOrNull?.let { extras["is_credits_billing"] = it }
+        root["is_dollar_usage_billing"]?.jsonPrimitive?.contentOrNull?.let { extras["is_dollar_usage_billing"] = it }
+        root["is_pay_freshman"]?.jsonPrimitive?.contentOrNull?.let { extras["is_new_user"] = it }
+
+        // 1) 权威汇总
+        val summary = root["usage_summary"]?.jsonObject
+        val total = summary?.numberOr("total_amount")
+        val consumed = summary?.numberOr("consumed_amount")
+        summary?.let { s ->
+            s.numberOr("consumed_amount")?.let { extras["consumed_credits"] = trimNum(it) }
+            s.numberOr("consumption_ratio")?.let { extras["consumption_ratio"] = trimNum(it) }
+            s.numberOr("total_amount")?.let { extras["total_credits"] = trimNum(it) }
+        }
+
+        // 2) 权益包明细（前若干条 + 计数），同时累计兜底求和
+        // 用固定前缀键 entitlement.$i.* 输出，供 TraePacksCard 拆开渲染（每包的
+        // 总额/已用/剩余）。旧「中文名.limit/.used」键形式存在歧义且被
+        // GenericExtrasCard 的过滤规则吞掉，导致权益明细从未展示（2026-10 用户反馈）。
+        var fallbackSum = 0.0
+        var generalSum = 0.0   // available_endpoint=0：通用积分（TraeCode/TraeWork 均可用）
+        var workSum = 0.0      // available_endpoint=1：Work 专属积分（仅 TraeWork 可用）
+        var packShown = 0
+        var packCount = 0
+        val packs = root["user_entitlement_pack_list"]?.jsonArray
+        packs?.forEachIndexed { index, packEl ->
+            val pack = packEl.jsonObject
+            val base = pack["entitlement_base_info"]?.jsonObject
+            val quota = base?.get("quota")?.jsonObject
+            val name = pack.getString("display_desc")
+                ?: pack.getString("group_name")
+                ?: base?.getString("name")
+                ?: base?.get("product_extra")?.jsonObject
+                    ?.get("package_extra")?.jsonObject?.getString("package_name")
+                ?: "pack[$index]"
+            val limit = quota?.getNumber("credits_limit")?.toLong()
+            val used = pack.getNumber("usage", "credits_amount")
+                ?: base?.get("usage")?.jsonObject?.get("credits_amount")?.safeDouble()
+            // available_endpoint 是通用 / Work 专属的唯一判别位（实测 2026-09 对照官方用量页：
+            // 0=通用积分，TraeCode/TraeWork 均可用；1=Work 专属，仅 TraeWork）。缺失按 0（通用）。
+            val isWork = (base?.get("available_endpoint")?.safeDouble() ?: 0.0) >= 1.0
+            val endpointKey = if (isWork) "1" else "0"
+            packCount++
+            when {
+                limit == null -> { /* 结构变化：跳过 */ }
+                limit < 0 -> {
+                    extras["entitlement.$index.name"] = name
+                    extras["entitlement.$index.unlimited"] = "true"
+                    extras["entitlement.$index.endpoint"] = endpointKey
+                }
+                else -> {
+                    val remaining = (limit - (used ?: 0.0)).coerceAtLeast(0.0)
+                    fallbackSum += remaining
+                    if (isWork) workSum += remaining else generalSum += remaining
+                    if (packShown < 8) {
+                        extras["entitlement.$index.name"] = name
+                        extras["entitlement.$index.limit"] = limit.toString()
+                        extras["entitlement.$index.used"] = used?.let { trimNum(it) } ?: "0"
+                        extras["entitlement.$index.remaining"] = trimNum(remaining)
+                        extras["entitlement.$index.endpoint"] = endpointKey
+                        packShown++
+                    }
+                }
+            }
+        }
+        if (packCount > 0) {
+            extras["pack_count"] = packCount.toString()
+            extras["general_credits"] = trimNum(generalSum)
+            extras["work_credits"] = trimNum(workSum)
+        }
+
+        // 3) 金额：汇总优先，缺省回退包级
+        val amount = if (total != null && consumed != null) {
+            (total - consumed).coerceAtLeast(0.0)
+        } else fallbackSum
+        val totalQuota = total?.takeIf { it >= 0 }
+
+        return ParsedTraeUsage(amount = amount, totalQuota = totalQuota, extras = extras)
+    }
+
+    private fun JsonObject.getString(key: String): String? = this[key]?.jsonPrimitive?.contentOrNull
+
+    private fun JsonElement.safeDouble(): Double? =
+        runCatching { jsonPrimitive.content.toDoubleOrNull() }.getOrNull()
+
+    /** 按路径逐层取数：如 getNumber("usage","credits_amount") 取 this.usage.credits_amount。 */
+    private fun JsonObject.getNumber(vararg keys: String): Double? {
+        if (keys.isEmpty()) return null
+        var node: JsonObject? = this
+        for (i in keys.indices) {
+            val el = node?.get(keys[i]) ?: return null
+            if (i == keys.lastIndex) return el.safeDouble()
+            node = runCatching { el.jsonObject }.getOrNull()
+        }
+        return null
+    }
+
+    /** 平铺多候选数值扫描。 */
+    private fun JsonObject.numberOr(vararg keys: String): Double? {
+        for (key in keys) {
+            this[key]?.let { el ->
+                (el as? JsonPrimitive)?.doubleOrNull?.let { return it }
+                (el as? JsonPrimitive)?.contentOrNull?.toDoubleOrNull()?.let { return it }
+            }
+        }
+        return null
+    }
+
+    // ---------- 每日签到（checkin_credits）----------
+
+    /**
+     * 轻量查询「今日是否已签到」（只读，不发起 claim）。
+     *
+     * 供详情页进入时预取状态用：先查本地记录（credential.lastCheckinDate /
+     * [CheckinStatusStore]），未命中再调 status 接口（服务端权威，跨设备已签也能识别）。
+     * 返回 true=今日已签；false=未签/活动未开放；失败=网络/协议异常（调用方按未知处理）。
+     */
+    suspend fun fetchCheckinStatus(accountId: String? = null): Result<Boolean> = withContext(Dispatchers.IO) {
+        val credential = credentialRepository.get(ServiceType.TRAE, accountId)
+            ?: return@withContext Result.failure(RepositoryError.InvalidCredential())
+        if (credential !is Credential.TraeCredential || credential.jwt.isBlank()) {
+            return@withContext Result.failure(RepositoryError.InvalidCredential())
+        }
+        if (credential.region.uppercase() == "INTL") {
+            // INTL 区签到接口未实测，status 同样不可用
+            return@withContext Result.success(false)
+        }
+        val jwt = credential.jwt.trim()
+        if (credential.lastCheckinDate == java.time.LocalDate.now().toString()) {
+            return@withContext Result.success(true)
+        }
+        val deviceId = credential.checkinDeviceId?.trim()?.takeIf { it.isNotEmpty() }
+            ?: ACCOUNT_BOUND_DEVICE_ID
+        val body = checkinRequest(jwt, deviceId, "bound", CHECKIN_STATUS_PATH)
+        body.fold(
+            onSuccess = { text ->
+                val info = parseStatus(text).getOrNull()
+                Result.success(info?.checkedIn == true)
+            },
+            onFailure = { Result.failure(it) }
+        )
+    }
+
+    /** 签到动作语义结果（UI 层据此本地化，不直接展示 Repository 中文串）。 */
+    enum class CheckinOutcome {
+        /** 签到成功 */
+        SUCCESS,
+        /** 今日已签到（账号级，幂等） */
+        ALREADY,
+        /** 设备级拦截（提示而非报错） */
+        DEVICE_BLOCKED,
+        /** 服务端临时限流（如「参与用户太多，请稍后重试」）：提示而非报错，可稍后重试 */
+        RETRYABLE,
+        /** INTL 区签到接口未实测，暂不支持 */
+        INTL_UNSUPPORTED,
+        /** 其他失败（服务端给了原因/错误码） */
+        FAILED
+    }
+
+    /** 签到结果（来源：trae-check 实测字段与语义）。 */
+    data class CheckinResult(
+        val success: Boolean,
+        /** 今日已签（账号级，非设备拦截） */
+        val alreadyChecked: Boolean,
+        val points: Long,
+        /** 服务端原始提示文案（仅作 [outcome] 之外的补充透传） */
+        val message: String,
+        /** 动作语义结果：UI 按此本地化，不依赖 [message] 语言 */
+        val outcome: CheckinOutcome,
+        /** 服务端错误码（outcome=FAILED 时可能有；-1 表示未提供） */
+        val code: Long = -1L
+    )
+
+    /**
+     * 执行 Trae 每日签到（CN 区），流程对齐社区实测工具（trae-daily-checkin /
+     * trae-checkin-helper 逆向口径）：
+     * 1. POST /trae/api/v2/ug/checkin_credits/status（body {}）查状态：
+     *    - enable=false → 签到功能暂未开放（中性提示，非错误）
+     *    - checked_in=true → 今日已签（幂等短路，不重复 claim）
+     * 2. POST /trae/api/v2/ug/checkin_credits/claim（body {}）执行签到：
+     *    code 0/200 成功；code 10001 或文案含「已签到/already」=已签。
+     * 头：Cloud-IDE-JWT <jwt> + x-device-id（登录会话绑定的 App 持久化设备 ID；
+     * 不可用 userJwt.ClientID——固定客户端标识，所有用户相同，会被按设备风控拒绝）。
+     * INTL 区签到接口未实测，暂不支持（返回明确提示）。
+     */
+    suspend fun checkIn(accountId: String? = null): Result<CheckinResult> = withContext(Dispatchers.IO) {
+        val credential = credentialRepository.get(ServiceType.TRAE, accountId)
+            ?: return@withContext Result.failure(RepositoryError.InvalidCredential())
+        if (credential !is Credential.TraeCredential || credential.jwt.isBlank()) {
+            return@withContext Result.failure(RepositoryError.InvalidCredential())
+        }
+        val regionKey = credential.region.uppercase().takeIf { it == "INTL" } ?: "CN"
+        if (regionKey == "INTL") {
+            return@withContext Result.success(
+                CheckinResult(
+                    success = false,
+                    alreadyChecked = false,
+                    points = 0,
+                    message = "",
+                    outcome = CheckinOutcome.INTL_UNSUPPORTED
+                )
+            )
+        }
+        val jwt = credential.jwt.trim()
+        // 本地签到状态短路：今天已成功签到则不再发起任何网络请求（防重复签到/重复 claim）
+        val today = java.time.LocalDate.now().toString()
+        if (credential.lastCheckinDate == today) {
+            DebugLog.i(TAG, "checkin: 本地已记录今日签到，短路跳过网络请求")
+            return@withContext Result.success(
+                CheckinResult(
+                    success = true,
+                    alreadyChecked = true,
+                    points = 0,
+                    message = "",
+                    outcome = CheckinOutcome.ALREADY
+                )
+            )
+        }
+        // 签到设备（x-device-id）：必须使用账号绑定的官方客户端设备——服务端按设备
+        // 做签到风控/去重，App 自生成的随机设备 ID 会稳定触发 9074「参与用户太多」。
+        // 实测（2026-09-13）：改用 PC 客户端真实 did 后 claim 成功。优先级：
+        // 用户设置页填写的 did（换设备后可自行更新）＞ 内置默认（同账号客户端 did）。
+        val deviceId = credential.checkinDeviceId?.trim()?.takeIf { it.isNotEmpty() }
+            ?: ACCOUNT_BOUND_DEVICE_ID
+        val deviceSrc = "bound"
+        // Step 1：先查签到状态（enable 活动开关 + checked_in 防重复短路，
+        // 对齐 trae-checkin-helper 实测口径：enable/checked_in 必须是布尔才算协议正常）
+        val statusBody = checkinRequest(jwt, deviceId, deviceSrc, CHECKIN_STATUS_PATH)
+        if (statusBody.isFailure) {
+            return@withContext Result.failure(
+                statusBody.exceptionOrNull() ?: RepositoryError.Unknown()
+            )
+        }
+        // status 解析失败（协议异常/被风控设备无状态可读）记录日志后继续走 claim 兜底
+        val statusParsed = parseStatus(statusBody.getOrThrow())
+        if (statusParsed.isFailure) {
+            DebugLog.w(
+                TAG,
+                "checkin: status 解析失败，走 claim 兜底: ${statusParsed.exceptionOrNull()?.message}"
+            )
+        }
+        statusParsed.getOrNull()?.let { status ->
+            when {
+                status.enable == false -> {
+                    // 签到活动未开放/间歇期：中性提示，非错误（enable=false 属正常现象）
+                    credentialRepository.save(
+                        credential.copy(lastVerifiedAt = System.currentTimeMillis()),
+                        accountId
+                    )
+                    return@withContext Result.success(
+                        CheckinResult(
+                            success = false,
+                            alreadyChecked = false,
+                            points = 0,
+                            message = status.message.ifBlank { "签到功能暂未开放，请稍后再试" },
+                            outcome = CheckinOutcome.RETRYABLE
+                        )
+                    )
+                }
+                status.checkedIn == true -> {
+                    // 今日已签：幂等短路，不再发起 claim；落本地签到日期防重复
+                    credentialRepository.save(
+                        credential.copy(
+                            lastVerifiedAt = System.currentTimeMillis(),
+                            lastCheckinDate = today
+                        ),
+                        accountId
+                    )
+                    return@withContext Result.success(
+                        CheckinResult(
+                            success = true,
+                            alreadyChecked = true,
+                            points = status.credits?.toLong() ?: 0L,
+                            message = "",
+                            outcome = CheckinOutcome.ALREADY
+                        )
+                    )
+                }
+            }
+        }
+        // status 解析失败（协议变化等情况）继续走 claim——claim 的 code 判定仍权威
+
+        // Step 2：执行签到。claim body 按官方契约探测（对齐 cpa-multi-plugins v0.12.41/43：
+        // 09-04 上游收紧活动校验后，body 必须与 token 谱系匹配；官方契约空 {} 实测到账，
+        // SOLO/TraeWork 官方同款 req_source=2，TraeCode 用 req_source=1；9074 时顺次换 body）。
+        val claimBodies = listOf("{}", """{"req_source":2}""", """{"req_source":1}""")
+        var claimResult: Result<CheckinResult>? = null
+        for (body in claimBodies) {
+            val cl = checkinRequest(jwt, deviceId, deviceSrc, CHECKIN_CLAIM_PATH, body)
+            if (cl.isFailure) {
+                claimResult = Result.failure(
+                    cl.exceptionOrNull() ?: RepositoryError.Unknown()
+                )
+                break
+            }
+            val parsed = parseCheckin(cl.getOrThrow())
+            claimResult = parsed
+            // 9074 已解析为 RETRYABLE；换 body 再试，其它语义（成功/已签/设备拦截/硬错误）直接定稿
+            if (parsed.getOrNull()?.outcome != CheckinOutcome.RETRYABLE) break
+        }
+        val parsed = claimResult
+            ?: return@withContext Result.failure(RepositoryError.Unknown())
+        // 仅「凭据被服务端接受」时才算已验证：SUCCESS/ALREADY/DEVICE_BLOCKED/RETRYABLE 都说明
+        // JWT 有效（401/403 已在 checkinRequest 提前失败）；FAILED（含 HTTP 400 业务失败）不标记，
+        // 避免把无效凭据误标为已验证。SUCCESS/ALREADY 同时落本地签到日期（防当日重复签到）。
+        val outcome = parsed.getOrNull()?.outcome
+        if (outcome != null && outcome != CheckinOutcome.FAILED) {
+            val checkedToday =
+                outcome == CheckinOutcome.SUCCESS || outcome == CheckinOutcome.ALREADY
+            credentialRepository.save(
+                credential.copy(
+                    lastVerifiedAt = System.currentTimeMillis(),
+                    lastCheckinDate = if (checkedToday) today else credential.lastCheckinDate
+                ),
+                accountId
+            )
+        }
+        parsed
+    }
+
+    /**
+     * 签到系 POST（status/claim），请求头逐头对齐 cpa-multi-plugins v0.12.45
+     * 抓包指纹（2026-09-03 成功签到请求复刻，用户账号实测：旧头多日 9074，
+     * 新头当日 claim code=0）：
+     *  - UA 必须是 VSCode 插件进程身份 "VSCode 1.107.1 (TRAE SOLO CN)"——签到走
+     *    VSCode 插件进程，与 IDE 主进程 Trae/0.1.x / web 均不同，混用身份 = 风控画像对不上；
+     *  - X-User-Region / X-Request-Id / X-TT-Trace-Id / Package-Type / App-Version
+     *    等均随真实客户端；Authorization: Cloud-IDE-JWT <jwt>；X-Device-Id 为签到设备。
+     * body 固定 `{}`（官方口径，加任何业务参数都会导致业务失败）。
+     * 401/403 → [RepositoryError.InvalidCredential]；其它非 200/400 → [mapHttpError]；
+     * 400 或 2xx → 返回 body 交给业务解析（400 也可能是已签/设备拦截）。
+     */
+    private fun checkinRequest(
+        jwt: String,
+        deviceId: String,
+        deviceSrc: String,
+        path: String,
+        bodyJson: String = "{}"
+    ): Result<String> {
+        val requestId = java.util.UUID.randomUUID().toString()
+        val request = Request.Builder()
+            .url("https://api.trae.cn" + path)
+            .addHeader("Content-Type", "application/json")
+            .addHeader("Accept", "*/*")
+            .addHeader("User-Agent", "VSCode 1.107.1 (TRAE SOLO CN)")
+            .addHeader("Authorization", "Cloud-IDE-JWT " + jwt)
+            .addHeader("X-User-Region", "CN")
+            .addHeader("Accept-Language", "zh-CN")
+            .addHeader("Package-Type", "stable_cn")
+            .addHeader("X-Lgw-Req-Sdk-Type", "3")
+            .addHeader("X-Market-Client-Id", "VSCode 1.107.1")
+            .addHeader("X-Device-Brand", "83DG")
+            .addHeader("X-Device-Type", "windows")
+            .addHeader("X-OS-Version", "Windows 11 Pro")
+            .addHeader("App-Version", "0.1.61")
+            .addHeader("X-Request-Id", requestId)
+            .addHeader("X-TT-Trace-Id", ttTraceId(requestId))
+            .addHeader("X-Device-Id", deviceId)
+            .addHeader("Sec-Fetch-Dest", "empty")
+            .addHeader("Sec-Fetch-Mode", "no-cors")
+            .addHeader("Sec-Fetch-Site", "none")
+            .post(bodyJson.toRequestBody("application/json".toMediaType()))
+            .build()
+        return try {
+            okHttpClient.newCall(request).execute().use { resp ->
+                val text = resp.body?.string().orEmpty()
+                // 本地调试日志：HTTP 码、路径与 deviceId 来源（bound=服务端绑定/real=持久化/fallback=伪ID）。
+                // 不记录 Authorization 与 deviceId 明文（敏感）。
+                DebugLog.i(
+                    TAG,
+                    "checkin: path=$path body=$bodyJson device=$deviceSrc http=${resp.code} body=${text.take(200)}"
+                )
+                when {
+                    resp.code == 401 || resp.code == 403 ->
+                        Result.failure(authErrorFor(jwt))
+                    !resp.isSuccessful && resp.code != 400 ->
+                        Result.failure(mapHttpError(resp.code))
+                    else -> Result.success(text)
+                }
+            }
+        } catch (e: IOException) {
+            Result.failure(RepositoryError.Network(e))
+        } catch (e: Throwable) {
+            Result.failure(RepositoryError.Unknown(e))
+        }
+    }
+
+    /** 生成抓包格式 tt-trace-id：00-<32hex>-<16hex>-01，16hex 取自请求 ID。 */
+    private fun ttTraceId(requestId: String): String {
+        val bytes = ByteArray(16)
+        java.security.SecureRandom().nextBytes(bytes)
+        val hex32 = bytes.joinToString("") { "%02x".format(it) }
+        return "00-$hex32-${requestId.replace("-", "").take(16)}-01"
+    }
+
+    private fun mapHttpError(code: Int): RepositoryError = when (code) {
+        401, 403 -> RepositoryError.InvalidCredential()
+        429 -> RepositoryError.RateLimited()
+        in 500..599 -> RepositoryError.ServerError(code)
+        else -> RepositoryError.Unknown()
+    }
+
+    /**
+     * 401/403 时用官方 CheckLogin 鉴别真实原因（服务端权威，非启发式猜测）：
+     * - IsLogin=false 或 ExpiredAt 已过 → [RepositoryError.SessionExpired]（提示重新登录）
+     * - 其它情况（含 CheckLogin 自身失败）→ [RepositoryError.InvalidCredential]（保持原语义）
+     */
+    private fun authErrorFor(jwt: String): RepositoryError {
+        val state = runCatching {
+            val request = Request.Builder()
+                .url("https://api.trae.cn/cloudide/api/v3/trae/CheckLogin")
+                .addHeader("Content-Type", "application/json")
+                .addHeader("Accept", "application/json")
+                .addHeader("User-Agent", "Trae/0.1.43")
+                .addHeader("X-Cloudide-Token", jwt)
+                .post("""{"IDEVersion":"0.1.43"}""".toRequestBody("application/json".toMediaType()))
+                .build()
+            okHttpClient.newCall(request).execute().use { resp ->
+                if (!resp.isSuccessful) return@runCatching null
+                parseCheckLogin(resp.body?.string().orEmpty())
+            }
+        }.getOrNull()
+        val expired = state != null &&
+            (state.isLogin == false || (state.expiredAt in 1 until System.currentTimeMillis()))
+        return if (expired) RepositoryError.SessionExpired() else RepositoryError.InvalidCredential()
+    }
+
+    /** CheckLogin 结果：isLogin 为服务端权威登录态；expiredAt 为 JWT 过期时间戳（ms）。 */
+    internal data class CheckLoginState(val isLogin: Boolean?, val expiredAt: Long?)
+
+    /** 解析 CheckLogin 响应（Result.IsLogin / Result.ExpiredAt），协议异常返回 null。 */
+    internal fun parseCheckLogin(body: String): CheckLoginState? = runCatching {
+        val root = parseJson.parseToJsonElement(body).jsonObject
+        val result = root["Result"] as? JsonObject ?: return null
+        CheckLoginState(
+            isLogin = (result["IsLogin"] as? JsonPrimitive)?.booleanOrNull,
+            expiredAt = (result["ExpiredAt"] as? JsonPrimitive)?.longOrNull
+        )
+    }.getOrNull()
+
+    /**
+     * 数值转简短显示串（去掉多余的 0 与小数点）。
+     * 注意不能用 v.toString().trimEnd('0','.')：trimEnd 会连续剥离集合内任意字符，
+     * "50.0" 会被剪成 "5"、"100.0" 剪成 "1"（余额/签到金额会显示错一位）。
+     */
+    private fun trimNum(v: Double): String =
+        java.math.BigDecimal.valueOf(v).stripTrailingZeros().toPlainString()
+
+    private data class ParsedTraeUsage(
+        val amount: Double,
+        val totalQuota: Double?,
+        val extras: Map<String, String>
+    )
+
+    companion object {
+        const val TAG = "Trae"
+
+        /** 官方客户端固定 ClientID（所有用户相同，不可作 x-device-id，会被按设备风控拒绝）。 */
+        const val TRAE_CLIENT_ID = "en1oxy7wnw8j9n"
+
+        /**
+         * 账号绑定的官方 PC 客户端设备 ID（x-device-id）。
+         * 实测根因（2026-09-13）：签到 claim 的 9074「当前参与用户太多」是服务端设备
+         * 风控——App 自生成设备 ID 必被拒，改用官方客户端真实 did 后 claim 成功。
+         * 来源：客户端请求日志（api.trae.com.cn icube config/query did=…）。
+         * ⚠️ 账号级：换账号或官方端重置设备标识后需更新此值。
+         */
+        const val ACCOUNT_BOUND_DEVICE_ID = "895482260673817"
+
+        /** 解析专用 Json（companion 内独立持有，使 parseCheckin 可静态调用/单测）。 */
+        private val parseJson = Json { ignoreUnknownKeys = true }
+
+        /**
+         * 解析 claim 响应（code/message/points 多候选）。
+         *
+         * 语义判定（实测口径）：
+         * - code 0/200 → SUCCESS；code 1001 或文案含「已签到/already/claimed」→ ALREADY；
+         * - 文案含「设备/device/machine」→ DEVICE_BLOCKED（设备级拦截，优先级高于 already，避免误报已签）；
+         * - 其余 → FAILED 并回传 code。
+         *
+         * 放在 companion 内以便单测直接调用（不依赖 OkHttp/凭据）。
+         */
+        internal fun parseCheckin(body: String): Result<CheckinResult> = runCatching {
+            val root = parseJson.parseToJsonElement(body).jsonObject
+            // data 可能为 null/非对象（如 {"code":0}），安全转换后退回根层
+            val data = root["data"] as? JsonObject ?: root
+            val code = data.numberOr("code")?.toLong() ?: root.numberOr("code")?.toLong() ?: -1L
+            val msg = data.scalarOr("message", "msg") ?: root.scalarOr("message", "msg") ?: ""
+            // points 与 credit 双候选（社区实测：claim 成功响应可能用 credit 字段）
+            val points = (data.numberOr("points", "credit")
+                ?: root.numberOr("points", "credit"))?.toLong() ?: 0L
+
+            val succeeded = code == 0L || code == 200L
+            val lowerMsg = msg.lowercase()
+            val deviceBlock = msg.contains("设备") || lowerMsg.contains("device") || lowerMsg.contains("machine")
+            // 权威口径幂等兜底码是 10001（trae-checkin-helper 逆向）；历史实现用 1001，
+            // 两者都认，避免把已签误判为 FAILED 硬错误。
+            val already = (code == 1001L || code == 10001L) || (!deviceBlock && (
+                msg.contains("已签到") || msg.contains("已经签到") || msg.contains("明日再来") ||
+                    msg.contains("今日已完成") || msg.contains("已领取") ||
+                    lowerMsg.contains("already") || lowerMsg.contains("checked") || lowerMsg.contains("claimed")
+                ))
+            // 服务端临时限流/排队（账号、设备或活动人数限制）：提示可稍后重试，不算硬错误。
+            val retryable = !already && !deviceBlock && (
+                msg.contains("参与") || msg.contains("稍后重试") || msg.contains("火爆") ||
+                    msg.contains("繁忙") || msg.contains("限流") || msg.contains("排队") ||
+                    lowerMsg.contains("too many") || lowerMsg.contains("retry") || lowerMsg.contains("busy") ||
+                    lowerMsg.contains("popular") || lowerMsg.contains("later")
+                )
+
+            DebugLog.i(
+                TAG,
+                "checkIn 解析: code=$code msg=$msg points=$points -> " +
+                    when {
+                        succeeded -> "SUCCESS"
+                        already -> "ALREADY"
+                        deviceBlock -> "DEVICE_BLOCKED"
+                        retryable -> "RETRYABLE"
+                        else -> "FAILED"
+                    }
+            )
+
+            when {
+                succeeded -> Result.success(
+                    CheckinResult(
+                        success = true,
+                        alreadyChecked = false,
+                        points = points.takeIf { it > 0 } ?: 200L,
+                        message = msg,
+                        outcome = CheckinOutcome.SUCCESS
+                    )
+                )
+                already -> Result.success(
+                    CheckinResult(true, true, 0L, msg, CheckinOutcome.ALREADY)
+                )
+                deviceBlock -> Result.success(
+                    CheckinResult(false, false, 0L, msg, CheckinOutcome.DEVICE_BLOCKED)
+                )
+                retryable -> Result.success(
+                    CheckinResult(false, false, 0L, msg, CheckinOutcome.RETRYABLE)
+                )
+                else -> Result.success(
+                    CheckinResult(false, false, 0L, msg, CheckinOutcome.FAILED, code)
+                )
+            }
+        }.getOrElse { Result.failure(RepositoryError.Unknown(it)) }
+
+        /** 官方签到接口路径（trae-checkin-helper 逆向口径）。 */
+        const val CHECKIN_STATUS_PATH = "/trae/api/v2/ug/checkin_credits/status"
+        const val CHECKIN_CLAIM_PATH = "/trae/api/v2/ug/checkin_credits/claim"
+
+        /** status 接口解析结果（字段缺失为 null；enable/checked_in 以布尔为权威）。 */
+        internal data class TraeStatusInfo(
+            val enable: Boolean?,
+            val checkedIn: Boolean?,
+            val credits: Double?,
+            val message: String
+        )
+
+        /**
+         * 解析 status 响应（对齐 trae-checkin-helper 实测口径）：
+         * 响应为平铺结构（code/enable/checked_in/credits 同层），个别版本包一层 data，兼容两种；
+         * 业务码非 0/200 或 enable/checked_in 非布尔 → 解析失败（调用方继续走 claim 兜底）。
+         */
+        internal fun parseStatus(body: String): Result<TraeStatusInfo> = runCatching {
+            val root = parseJson.parseToJsonElement(body).jsonObject
+            val data = root["data"] as? JsonObject ?: root
+            val code = data.numberOr("code")?.toLong()
+                ?: root.numberOr("code")?.toLong()
+            if (code != null && code != 0L && code != 200L) {
+                error("status 业务失败 code=$code")
+            }
+            val enable = data.boolOr("enable") ?: root.boolOr("enable")
+            val checkedIn = data.boolOr("checked_in") ?: root.boolOr("checked_in")
+            if (enable == null || checkedIn == null) {
+                error("status 响应缺 enable/checked_in（协议可能已变更）")
+            }
+            TraeStatusInfo(
+                enable = enable,
+                checkedIn = checkedIn,
+                credits = data.numberOr("credits") ?: root.numberOr("credits"),
+                message = data.scalarOr("message", "msg")
+                    ?: root.scalarOr("message", "msg") ?: ""
+            )
+        }
+
+        /** 布尔字段解析（兼容原生 JSON boolean 与 "true"/"false" 字符串，非布尔返回 null）。 */
+        private fun JsonObject.boolOr(key: String): Boolean? {
+            val prim = this[key] as? JsonPrimitive ?: return null
+            return when (prim.content.lowercase()) {
+                "true" -> true
+                "false" -> false
+                else -> null
+            }
+        }
+
+        private fun JsonObject.scalarOr(vararg keys: String): String? {
+            for (key in keys) {
+                this[key]?.jsonPrimitive?.contentOrNull?.takeIf { it.isNotBlank() }?.let { return it }
+            }
+            return null
+        }
+
+        /** 平铺多候选数值扫描。 */
+        private fun JsonObject.numberOr(vararg keys: String): Double? {
+            for (key in keys) {
+                this[key]?.let { el ->
+                    (el as? JsonPrimitive)?.doubleOrNull?.let { return it }
+                    (el as? JsonPrimitive)?.contentOrNull?.toDoubleOrNull()?.let { return it }
+                }
+            }
+            return null
+        }
+    }
+}

app/src/main/java/com/rainy/token/data/repository/UpdateRepository.kt

@@ -0,0 +1,112 @@
+package com.rainy.token.data.repository
+
+import android.content.Context
+import com.rainy.token.BuildConfig
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.io.File
+import java.io.IOException
+import javax.inject.Inject
+import javax.inject.Singleton
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import okhttp3.OkHttpClient
+import okhttp3.Request
+
+/**
+ * 应用更新仓库：从 Gitea 仓库的 update.json 读取版本清单，
+ * 下载 APK 到应用缓存目录供 FileProvider 安装。
+ */
+@Singleton
+class UpdateRepository @Inject constructor(
+    private val okHttpClient: OkHttpClient,
+    @ApplicationContext context: Context
+) {
+    private val appContext = context.applicationContext
+    private val json = Json { ignoreUnknownKeys = true }
+
+    /** 检查是否有新版本。null = 已是最新；非空 = 远端有更新。 */
+    suspend fun checkForUpdate(): Result<UpdateInfo?> = withContext(Dispatchers.IO) {
+        try {
+            val request = Request.Builder()
+                .url(UPDATE_MANIFEST_URL)
+                .get()
+                .build()
+            val text = okHttpClient.newCall(request).execute().use { resp ->
+                if (!resp.isSuccessful) {
+                    return@withContext Result.failure(IOException("HTTP " + resp.code))
+                }
+                resp.body?.string().orEmpty()
+            }
+            val manifest = json.decodeFromString<UpdateManifest>(text)
+            val hasUpdate = manifest.versionCode > BuildConfig.VERSION_CODE
+            Result.success(if (hasUpdate) {
+                UpdateInfo(
+                    versionCode = manifest.versionCode,
+                    versionName = manifest.versionName,
+                    apkUrl = manifest.apkUrl,
+                    notes = manifest.notes
+                )
+            } else {
+                null
+            })
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
+    }
+
+    /** 下载 APK 到缓存目录。onProgress 回调下载字节数/总字节数（total 可能为 -1）。 */
+    suspend fun downloadApk(
+        info: UpdateInfo,
+        onProgress: (downloaded: Long, total: Long) -> Unit
+    ): Result<File> = withContext(Dispatchers.IO) {
+        try {
+            val dir = File(appContext.cacheDir, "apk_downloads").apply { mkdirs() }
+            val file = File(dir, "rainytoken-" + info.versionName + ".apk")
+            val request = Request.Builder().url(info.apkUrl).get().build()
+            okHttpClient.newCall(request).execute().use { resp ->
+                if (!resp.isSuccessful) {
+                    return@withContext Result.failure(IOException("HTTP " + resp.code))
+                }
+                val body = resp.body ?: return@withContext Result.failure(IOException("empty body"))
+                val total = body.contentLength()
+                file.outputStream().buffered().use { output ->
+                    body.byteStream().use { input ->
+                        val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+                        var downloaded = 0L
+                        var read: Int
+                        while (input.read(buffer).also { read = it } != -1) {
+                            output.write(buffer, 0, read)
+                            downloaded += read
+                            onProgress(downloaded, total)
+                        }
+                    }
+                }
+            }
+            Result.success(file)
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
+    }
+
+    @Serializable
+    data class UpdateManifest(
+        val versionCode: Int,
+        val versionName: String,
+        val apkUrl: String,
+        val notes: String = ""
+    )
+
+    data class UpdateInfo(
+        val versionCode: Int,
+        val versionName: String,
+        val apkUrl: String,
+        val notes: String
+    )
+
+    companion object {
+        const val UPDATE_MANIFEST_URL =
+            "http://124.222.97.212:8443/maya/Rainytoken/raw/branch/dev/update.json"
+    }
+}

app/src/main/java/com/rainy/token/data/repository/WebViewSessionSaver.kt

@@ -1,6 +1,7 @@
 package com.rainy.token.data.repository
 
 import android.webkit.CookieManager
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
 import com.rainy.token.domain.model.CookieEntry
 import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.service.ServiceType
@@ -21,10 +22,16 @@ class WebViewSessionSaver @Inject constructor(
     private val credentialRepository: CredentialRepository
 ) {
 
+    /** Sub2API 面板登录保存结果：凭据 + 实际写入的账号 ID（新建账号时返回新 ID）。 */
+    data class SavedSub2PanelSession(
+        val credential: Credential.Sub2ApiCredential,
+        val accountId: String
+    )
+
     /**
      * 提取并保存 Cookie 列表。返回保存后的凭据。
      */
-    fun saveFromCookieManager(
+    suspend fun saveFromCookieManager(
         service: ServiceType,
         url: String,
         token: String? = null,
@@ -41,13 +48,97 @@ class WebViewSessionSaver @Inject constructor(
             expiresAt = expiresAt,
             lastVerifiedAt = System.currentTimeMillis()
         )
-        // 用 runBlocking 写凭据 —— 调用方在 Composable 中，可以接受
-        kotlinx.coroutines.runBlocking {
-            credentialRepository.save(session)
-        }
+        // 挂起写凭据：调用方在 viewModelScope 中，避免在主线程做 Keystore 加解密 + DataStore 写盘
+        credentialRepository.save(session)
         return session
     }
 
+    /**
+     * 面板登录成功后自动写入 Sub2API 凭据。
+     *
+     * 面板把登录态放在 localStorage.auth_token（JWT），所以 WebView 登录完成后
+     * 注入 JS 读取该键，连同站点基址一起落库，用户无需再手工粘贴。
+     *
+     * @param baseUrl 面板基址（登录页所在 origin，自动补 https 前缀）
+     * @param authToken localStorage.auth_token 的值；为空表示没抓到，返回 null 不覆盖旧凭据
+     * @param siteIcon  站点 Logo（可选，登录页 favicon/og:image）
+     * @param email     登录邮箱（可选，仅用于展示与回退登录）
+     * @param accountId 目标账号（多账号服务；null=默认账号/新建账号）
+     */
+    suspend fun saveSub2ApiPanelSession(
+        baseUrl: String,
+        authToken: String,
+        siteIcon: String? = null,
+        email: String? = null,
+        accountId: String? = null
+    ): SavedSub2PanelSession? {
+        val token = authToken.trim()
+        if (token.isEmpty()) return null
+        val base = normalizeBaseUrl(baseUrl) ?: return null
+        val existing = credentialRepository.get(ServiceType.SUB2API, accountId) as? Credential.Sub2ApiCredential
+        val credential = Credential.Sub2ApiCredential(
+            service = ServiceType.SUB2API,
+            baseUrl = base,
+            email = email?.takeIf { it.isNotBlank() } ?: existing?.email.orEmpty(),
+            password = existing?.password.orEmpty(),
+            apiKey = existing?.apiKey,
+            authToken = token,
+            siteIcon = siteIcon?.takeIf { it.isNotBlank() } ?: existing?.siteIcon,
+            lastVerifiedAt = System.currentTimeMillis()
+        )
+        // 返回实际写入的账号 ID：新建账号 / 默认账号统一回填，避免 UI 停留在「新建」空表单
+        val effectiveId = credentialRepository.save(credential, accountId)
+        return SavedSub2PanelSession(credential = credential, accountId = effectiveId)
+    }
+
+    /**
+     * OpenCode Go 应用内登录成功后自动落库。
+     *
+     * WebView 里完成 GitHub/Google OAuth 后落到 dashboard，登录态表现为
+     * `auth` cookie + URL 中的 workspaceId——正是 [OpenCodeGoRepository] 需要的
+     * 两个凭据字段，用户不再需要手动开 DevTools 抄 cookie。
+     *
+     * @param authCookie    dashboard 的 `auth` cookie 值（CookieManager 抓取）
+     * @param workspaceId   dashboard URL `/workspace/{id}/go` 中的 id
+     */
+    suspend fun saveOpenCodeGoSession(
+        authCookie: String,
+        workspaceId: String
+    ): Credential.SessionCredential? {
+        val auth = authCookie.trim()
+        val ws = workspaceId.trim()
+        if (auth.isEmpty() || ws.isEmpty()) return null
+        // 与手动保存一致：基于既有凭据合并，保留 cookies/token/apiKey 等字段不丢
+        val existing = credentialRepository.get(ServiceType.OPENCODE_GO) as? Credential.SessionCredential
+        val session = (existing ?: Credential.SessionCredential(service = ServiceType.OPENCODE_GO)).copy(
+            authCookie = auth,
+            workspaceId = ws,
+            lastVerifiedAt = System.currentTimeMillis()
+        )
+        credentialRepository.save(session)
+        return session
+    }
+
+    /**
+     * 归一化面板基址：补 scheme、去尾斜杠，只保留 scheme://host[:port]。
+     *
+     * 用 [okhttp3.HttpUrl] 真正解析而不是字符串长度判断——否则 "not a url" 这类垃圾
+     * 会被拼成 "https://not a url" 通过校验并落库，后续拼请求 URL 时 OkHttp 直接抛异常。
+     */
+    private fun normalizeBaseUrl(raw: String): String? {
+        val trimmed = raw.trim()
+        if (trimmed.isEmpty()) return null
+        val withScheme = if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+            trimmed
+        } else {
+            "https://" + trimmed
+        }
+        val parsed = withScheme.toHttpUrlOrNull() ?: return null
+        // 只保留 origin，丢掉 path/query（面板基址就是 origin）
+        return parsed.newBuilder().encodedPath("/").query(null).fragment(null).build()
+            .toString().trimEnd('/')
+    }
+
     /**
      * 把 `name1=value1; name2=value2` 解析为 [CookieEntry] 列表。
      * 完整属性（domain/path/expires/secure/httpOnly）暂不可用，因为 Android CookieManager

app/src/main/java/com/rainy/token/data/repository/WorkBuddyRepository.kt

@@ -0,0 +1,745 @@
+package com.rainy.token.data.repository
+
+import com.rainy.token.data.cache.BalanceCache
+import com.rainy.token.data.debug.DebugLog
+import com.rainy.token.domain.model.Credential
+import com.rainy.token.domain.model.ServiceBalance
+import com.rainy.token.domain.service.ServiceType
+import java.io.IOException
+import javax.inject.Singleton
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.longOrNull
+import kotlinx.serialization.json.put
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+
+/**
+ * 腾讯 WorkBuddy 余额仓库。
+ *
+ * 认证：`Authorization: Bearer <accessToken>`；accessToken 过期时用 refreshToken 轮换一次并重试
+ * （同 Codex 语义）：POST https://copilot.tencent.com/v2/plugin/auth/token/refresh（X-Refresh-Token 头）。
+ *
+ * 资源余额（2026-09 用真实登录态在官网个人中心实测，workbuddy.cn）：
+ * - 主端点：POST https://www.workbuddy.cn/billing/meter/get-user-resource-summary  body `{}`
+ *   真实响应：{"code":0,"data":{"Packages":[{"PackageCode":"TCACA_...","CycleTotalCapacity":"7826",
+ *   "CycleRemainCapacity":"2671.96","CycleUsedCapacity":"5154.04","CycleFrozenCapacity":"0",
+ *   "CapacityUnit":"credits"}, ...], "IsPaidUser":false}}
+ * - 兜底：POST https://www.codebuddy.cn/v2/billing/meter/get-user-resource（官方 CLI 插件模型，
+ *   ProductCode p_tcaca / Status 0,3），汇总 Packages/Accounts[] 同族字段。
+ * 余额 = 各包 CycleRemainCapacity 之和；单位取 CapacityUnit（credits）。
+ * 字段名随官方迭代可能变化，解析保持防御式（多候选扫描）。
+ */
+@Singleton
+class WorkBuddyRepository constructor(
+    private val okHttpClient: OkHttpClient,
+    private val credentialRepository: CredentialRepository,
+    private val balanceCache: BalanceCache
+) {
+
+    private val json = Json { ignoreUnknownKeys = true }
+
+    private val jsonMedia = "application/json".toMediaType()
+
+    private val codebuddyBody = buildJsonObject {
+        put("PageNumber", 1)
+        put("PageSize", 100)
+        put("ProductCode", "p_tcaca")
+        put("Status", buildJsonArray { add(JsonPrimitive(0)); add(JsonPrimitive(3)) })
+        put("Channel", "P")
+        put("Unsubmitted", false)
+        put("Unit", "")
+        put("QueryResourceId", buildJsonArray { })
+    }.toString()
+
+    suspend fun fetchBalance(accountId: String? = null): Result<ServiceBalance> = withContext(Dispatchers.IO) {
+        val credential = credentialRepository.get(ServiceType.WORKBUDDY, accountId)
+            ?: return@withContext Result.failure(RepositoryError.InvalidCredential())
+        if (credential !is Credential.WorkBuddyCredential) {
+            return@withContext Result.failure(RepositoryError.InvalidCredential())
+        }
+
+        var access = credential.accessToken
+        var refresh = credential.refreshToken
+        // hostMode 0 = workbuddy.cn summary（实测主路径）；1 = codebuddy.cn 兜底
+        var hostMode = 0
+        var attempts = 0
+        var lastBody = ""
+        while (attempts < 3) {
+            attempts++
+            val request = if (hostMode == 0) summaryRequest(access) else codebuddyRequest(access)
+            val resp = try {
+                okHttpClient.newCall(request).execute()
+            } catch (e: IOException) {
+                return@withContext Result.failure(RepositoryError.Network(e))
+            } catch (e: Throwable) {
+                return@withContext Result.failure(RepositoryError.Unknown(e))
+            }
+            val code = resp.code
+            val body = runCatching { resp.body?.string().orEmpty() }.getOrDefault("")
+            resp.close()
+
+            if (code in 200..299) {
+                lastBody = body
+                break
+            }
+            when (code) {
+                404 -> {
+                    if (hostMode == 0) { hostMode = 1; continue }
+                    return@withContext Result.failure(mapHttpError(code, body))
+                }
+                401, 403 -> {
+                    val refreshed = tryRefesh(refresh) ?: return@withContext Result.failure(
+                        RepositoryError.InvalidCredential()
+                    )
+                    // 暂存轮换后的凭据，随本次成功提交（RefreshWriteSession 机制）
+                    credentialRepository.save(
+                        credential.copy(
+                            accessToken = refreshed.accessToken,
+                            refreshToken = refreshed.refreshToken,
+                            expiresAt = if (refreshed.expiresIn > 0) {
+                                System.currentTimeMillis() + refreshed.expiresIn * 1000
+                            } else {
+                                credential.expiresAt.coerceAtLeast(System.currentTimeMillis())
+                            }
+                        ),
+                        accountId
+                    )
+                    access = refreshed.accessToken
+                    refresh = refreshed.refreshToken
+                    continue
+                }
+                else -> return@withContext Result.failure(mapHttpError(code, body))
+            }
+        }
+
+        if (lastBody.isBlank()) {
+            return@withContext Result.failure(
+                RepositoryError.ParseError(RepositoryError.ParseErrorReason.EMPTY_BODY, "workbuddy 响应为空")
+            )
+        }
+        val parsed = runCatching { parseResource(lastBody) }.getOrElse { e ->
+            return@withContext Result.failure(
+                RepositoryError.ParseError(
+                    RepositoryError.ParseErrorReason.MALFORMED_RESPONSE,
+                    "workbuddy 资源解析失败: ${e.message}"
+                )
+            )
+        }
+
+        // 细粒度账户明细（官网个人中心同源数据）：每个资源包的已用/总量/剩余/到期时间。
+        // 独立请求，失败仅降级（保留 summary 的简化 extras），不影响余额主流程。
+        val detailExtras = runCatching { fetchResourceDetailExtras(access) }.getOrNull()
+        val mergedExtras = if (detailExtras != null) {
+            parsed.extras + detailExtras
+        } else {
+            parsed.extras
+        }
+
+        val balance = ServiceBalance(
+            service = ServiceType.WORKBUDDY,
+            amount = parsed.amount,
+            unit = parsed.unit ?: "Credits",
+            monthlySpent = parsed.used.takeIf { it > 0 },
+            totalQuota = parsed.size.takeIf { it > 0 },
+            isAvailable = parsed.amount > 0 || parsed.size > 0,
+            extras = mergedExtras
+        )
+        balanceCache.put(ServiceType.WORKBUDDY, balance, accountId)
+        credentialRepository.save(credential.copy(lastVerifiedAt = System.currentTimeMillis()), accountId)
+        Result.success(balance)
+    }
+
+    /**
+     * 拉取细粒度账户明细并转成 extras 增量（[KEY_DETAIL_RAW] / [KEY_PLAN_CODE]）。
+     * 请求失败或解析失败返回 null（调用方降级到 summary 的简化 extras）。
+     */
+    private fun fetchResourceDetailExtras(accessToken: String): Map<String, String>? {
+        val request = Request.Builder()
+            .url("https://www.codebuddy.cn/v2/billing/meter/get-user-resource")
+            .addHeader("Authorization", "Bearer $accessToken")
+            .addHeader("Accept", "application/json")
+            .addHeader("Content-Type", "application/json")
+            .post(codebuddyBody.toRequestBody(jsonMedia))
+            .build()
+        val body = try {
+            okHttpClient.newCall(request).execute().use { resp ->
+                if (!resp.isSuccessful) return null
+                resp.body?.string().orEmpty()
+            }
+        } catch (_: Throwable) {
+            return null
+        }
+        if (body.isBlank()) return null
+        return parseResourceDetail(body)
+    }
+
+    /** workbuddy.cn 官网个人中心实测端点（2026-09 确认 200）。 */
+    private fun summaryRequest(accessToken: String): Request =
+        Request.Builder()
+            .url("https://www.workbuddy.cn/billing/meter/get-user-resource-summary")
+            .addHeader("Authorization", "Bearer $accessToken")
+            .addHeader("Content-Type", "application/json")
+            .post("{}".toRequestBody(jsonMedia))
+            .build()
+
+    /** codebuddy.cn 官方 CLI 插件模型（桌面/CLI accessToken 兜底）。 */
+    private fun codebuddyRequest(accessToken: String): Request =
+        Request.Builder()
+            .url("https://www.codebuddy.cn/v2/billing/meter/get-user-resource")
+            .addHeader("Authorization", "Bearer $accessToken")
+            .addHeader("Content-Type", "application/json")
+            .post(codebuddyBody.toRequestBody(jsonMedia))
+            .build()
+
+    /**
+     * refresh_token 单次轮换：POST token/refresh（X-Refresh-Token 头）。
+     * 只读取并返回新凭据；轮换后的提交交给主流程的 save（同一成功才落库）。
+     */
+    private fun tryRefesh(refreshToken: String): RefreshedWorkBuddy? {
+        val request = Request.Builder()
+            .url("https://copilot.tencent.com/v2/plugin/auth/token/refresh")
+            .addHeader("X-Refresh-Token", refreshToken)
+            .post("{}".toRequestBody(jsonMedia))
+            .build()
+        return try {
+            okHttpClient.newCall(request).execute().use { resp ->
+                if (!resp.isSuccessful) return@use null
+                val text = resp.body?.string().orEmpty()
+                val obj = json.parseToJsonElement(text).jsonObject
+                val access = obj.readToken("access_token", "accessToken")
+                    ?: obj["data"]?.jsonObject?.readToken("access_token", "accessToken")
+                    ?: return@use null
+                val refresh = obj.readToken("refresh_token", "refreshToken")
+                    ?: obj["data"]?.jsonObject?.readToken("refresh_token", "refreshToken")
+                    ?: refreshToken
+                val expiresIn = obj["expires_in"]?.jsonPrimitive?.longOrNull ?: 0L
+                RefreshedWorkBuddy(access, refresh, expiresIn)
+            }
+        } catch (_: Throwable) {
+            null
+        }
+    }
+
+    private fun JsonObject.readToken(vararg keys: String): String? {
+        for (key in keys) {
+            this[key]?.jsonPrimitive?.contentOrNull?.takeIf { it.isNotBlank() }?.let { return it }
+        }
+        return null
+    }
+
+    /**
+ * 解析 codebuddy.cn `/v2/billing/meter/get-user-resource` 的细粒度账户明细。
+ *
+ * 响应：`data.Response.Data.Accounts[]`，每个账户是一个独立资源包，字段含
+ * PackageCode / PackageName / CycleCapacityRemainPrecise / CycleCapacityUsedPrecise /
+ * CycleCapacitySizePrecise / CycleStartTime / CycleEndTime / Status / ExpiredTime。
+ *
+ * 按 PackageCode 分组：n==1 且非运营裂变包 → 套餐积分；其余（n>1 的裂变包）→ 平台奖励积分。
+ * 返回 extras 增量（键见 [KEY_DETAIL_RAW]）+ 是否解析成功。失败时调用方保留 summary 的 extras。
+ */
+private fun parseResourceDetail(body: String): Map<String, String>? {
+    val root = runCatching { json.parseToJsonElement(body).jsonObject }.getOrNull() ?: return null
+    val data = root["data"]?.jsonObject?.let { d ->
+        (d["Response"] as? JsonObject)?.let { r -> (r["Data"] as? JsonObject) ?: d } ?: d
+    } ?: root
+    val accounts = data["Accounts"]?.jsonArray ?: return null
+    val list = accounts.mapNotNull { it.jsonObject.takeIf { o -> o.isNotEmpty() } }
+    if (list.isEmpty()) return null
+
+    val out = linkedMapOf<String, String>()
+    val detail = buildJsonArray {
+        for (a in list) {
+            val code = a.scalar("PackageCode") ?: continue
+            val name = a.scalar("PackageName") ?: code
+            val remain = a.scalar("CycleCapacityRemainPrecise")
+                ?: a.number("CycleCapacityRemain", "CapacityRemainPrecise", "CapacityRemain")?.let { trimNum(it) }
+                ?: continue
+            val used = a.scalar("CycleCapacityUsedPrecise")
+                ?: a.number("CycleCapacityUsed", "CapacityUsedPrecise", "CapacityUsed")?.let { trimNum(it) }
+                ?: "0"
+            val total = a.scalar("CycleCapacitySizePrecise")
+                ?: a.number("CycleCapacitySize", "CapacitySizePrecise", "CapacitySize")?.let { trimNum(it) }
+                ?: "0"
+            val cycleEnd = a.scalar("CycleEndTime")?.takeIf { it.isNotBlank() }
+            val expiredAt = a.scalar("ExpiredTime")?.takeIf { it.isNotBlank() }
+            val status = a.number("Status")?.toInt()
+            add(buildJsonObject {
+                put("code", JsonPrimitive(code))
+                put("name", JsonPrimitive(name))
+                put("remain", JsonPrimitive(remain))
+                put("used", JsonPrimitive(used))
+                put("total", JsonPrimitive(total))
+                put("cycleEnd", JsonPrimitive(cycleEnd ?: ""))
+                put("expiredAt", JsonPrimitive(expiredAt ?: ""))
+                put("status", JsonPrimitive(status ?: -1))
+            })
+        }
+    }
+    if (detail.isEmpty()) return null
+    out[KEY_DETAIL_RAW] = detail.toString()
+
+    // 分组：每个 PackageCode 的账户数 + 包名
+    val groups = list.groupBy { it.scalar("PackageCode").orEmpty() }
+        .filterKeys { it.isNotBlank() }
+    // 套餐候选：账户数最少且不是「裂变/奖励」字样的包；奖励池：账户数多或名字带裂变/奖励
+    val planCode = groups.entries
+        .filter { (_, v) -> v.size == 1 }
+        .filter { (k, _) -> list.firstOrNull { it.scalar("PackageCode") == k }
+            ?.scalar("PackageName")?.let { n -> !n.contains("裂变") && !n.contains("奖励") } == true }
+        .minByOrNull { it.key }?.key
+    if (planCode != null) out[KEY_PLAN_CODE] = planCode
+    return out
+}
+
+/** 解析 Packages/Accounts：CycleRemain/Used/TotalCapacity（多候选）。无任何包/数据时抛异常。 */
+    private fun parseResource(body: String): ParsedWorkBuddy {
+        val root = json.parseToJsonElement(body).jsonObject
+        val data = root["data"]?.jsonObject ?: root
+        val packages = data["Packages"]?.jsonArray ?: data["Accounts"]?.jsonArray ?: root["Packages"]?.jsonArray
+        val list = packages?.mapNotNull { it.jsonObject.takeIf { o -> o.isNotEmpty() } } ?: emptyList()
+        if (list.isEmpty()) {
+            throw IllegalArgumentException("workbuddy 响应无 Packages/Accounts 数据")
+        }
+
+        var amount = 0.0
+        var used = 0.0
+        var size = 0.0
+        var frozen = 0.0
+        var unitRaw: String? = null
+        val extras = linkedMapOf<String, String>()
+        // 结构化包明细（名称/编码/已用/总量/剩余/到期/周期重置），详情页按官方语义分组展示。
+        // 键名带 raw 以复用通用卡的「技术键过滤」，不被用量页/通用明细卡当普通键展示。
+        val detail = buildJsonArray {
+            for (item in list.take(20)) {
+                val remain = item.number("CycleRemainCapacity", "CycleCapacityRemain", "Remain", "balance") ?: 0.0
+                val u = item.number("CycleUsedCapacity", "CycleCapacityUsed", "Used") ?: 0.0
+                val s = item.number("CycleTotalCapacity", "CycleCapacitySize", "Size", "Total") ?: 0.0
+                val f = item.number("CycleFrozenCapacity", "Frozen") ?: 0.0
+                amount += remain
+                used += u
+                size += s
+                frozen += f
+                unitRaw = unitRaw ?: item.scalar("CapacityUnit", "unit", "currency", "Unit")
+                val name = item.scalar("ProductName", "PackageCode", "ResourceName", "name", "ResourceId")
+                if (!name.isNullOrBlank() && extras.size < 3) {
+                    extras[name] = "${trimNum(remain)} ${normalizeUnit(unitRaw) ?: "Credits"}"
+                }
+                add(buildJsonObject {
+                    put("name", JsonPrimitive(name ?: ""))
+                    put("code", JsonPrimitive(item.scalar("PackageCode", "ResourceCode", "Code") ?: ""))
+                    put("remain", JsonPrimitive(trimNum(remain)))
+                    put("used", JsonPrimitive(trimNum(u)))
+                    put("total", JsonPrimitive(trimNum(s)))
+                    put(
+                        "expireAt",
+                        JsonPrimitive(
+                            item.timeField("ExpireTime", "ExpireAt", "ExpiredAt", "InvalidTime", "ExpireDate") ?: ""
+                        )
+                    )
+                    put(
+                        "cycleReset",
+                        JsonPrimitive(
+                            item.timeField("NextResetTime", "CycleResetTime", "NextCycleTime", "ResetTime", "ResetAt") ?: ""
+                        )
+                    )
+                })
+            }
+        }
+        if (list.size > 0) extras["packages"] = list.size.toString()
+        if (frozen > 0) extras["frozen"] = trimNum(frozen)
+        extras["wb_detail_raw"] = detail.toString()
+        data["IsPaidUser"]?.jsonPrimitive?.contentOrNull?.let { extras["is_paid_user"] = it }
+        data["SubscriptionPackageCode"]?.jsonPrimitive?.contentOrNull?.takeIf { it.isNotBlank() }
+            ?.let {
+                extras["subscription"] = "true"
+                // 订阅套餐的包编码：详情页据此把该包归入「套餐积分」区，其余归「平台奖励积分」
+                extras["subscription_code"] = it
+            }
+
+        return ParsedWorkBuddy(
+            amount = amount,
+            used = used,
+            size = size,
+            unit = normalizeUnit(unitRaw),
+            extras = extras
+        )
+    }
+
+    /** 官方字段 credits → 展示单位 Credits；其它原样透传。 */
+    private fun normalizeUnit(raw: String?): String? {
+        if (raw.isNullOrBlank()) return null
+        return if (raw.equals("credits", ignoreCase = true)) "Credits" else raw
+    }
+
+    /**
+     * 数值转简短显示串（去掉多余的 0 与小数点）。
+     * 注意不能用 v.toString().trimEnd('0','.')：trimEnd 会连续剥离集合内任意字符，
+     * "50.0" 会被剪成 "5"、"100.0" 剪成 "1"（余额/签到金额会显示错一位）。
+     */
+    private fun trimNum(v: Double): String =
+        java.math.BigDecimal.valueOf(v).stripTrailingZeros().toPlainString()
+
+    private fun JsonObject.number(vararg keys: String): Double? {
+        for (key in keys) {
+            this[key]?.jsonPrimitive?.doubleOrNull?.let { return it }
+            this[key]?.jsonPrimitive?.contentOrNull?.toDoubleOrNull()?.let { return it }
+        }
+        return null
+    }
+
+    private fun JsonObject.scalar(vararg keys: String): String? {
+        for (key in keys) {
+            this[key]?.jsonPrimitive?.contentOrNull?.takeIf { it.isNotBlank() }?.let { return it }
+        }
+        return null
+    }
+
+    /**
+     * 时间字段读取：兼容字符串日期（原样返回）与秒/毫秒时间戳（格式化为本地 yyyy-MM-dd HH:mm:ss）。
+     * 找不到或解析失败返回 null（展示层隐藏该行）。
+     */
+    private fun JsonObject.timeField(vararg keys: String): String? {
+        for (key in keys) {
+            val prim = this[key]?.jsonPrimitive ?: continue
+            val text = prim.contentOrNull?.takeIf { it.isNotBlank() } ?: continue
+            prim.doubleOrNull?.takeIf { it > 0 }?.let { epoch ->
+                val millis = if (epoch > 1e12) epoch.toLong() else (epoch * 1000).toLong()
+                return runCatching {
+                    java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss", java.util.Locale.getDefault())
+                        .format(java.util.Date(millis))
+                }.getOrNull()
+            }
+            // 纯字符串日期（如 "2026-10-01 16:32:41"）直接返回
+            return text
+        }
+        return null
+    }
+
+    // ---------- 每日签到（Buddy 加油站 / codebuddy.cn）----------
+
+    /** 签到动作语义结果（UI 层据此本地化，不直接展示 Repository 中文串）。 */
+    enum class CheckinOutcome {
+        /** 查询模式：只读状态，无动作结果 */
+        QUERY,
+        /** 签到成功 */
+        SUCCESS,
+        /** 今日已签到（幂等） */
+        ALREADY,
+        /** 签到失败（服务端给了原因，见 message） */
+        FAILED
+    }
+
+    /**
+     * 签到状态摘要（来源：cpa-multi-plugins workbuddy 插件实测字段）。
+     * active=活动进行中；todayCheckedIn=今日已签；streakDays=连签；daily/todayCredit=每日/今日积分。
+     */
+    data class CheckinStatus(
+        val active: Boolean,
+        val todayCheckedIn: Boolean,
+        val streakDays: Long,
+        val dailyCredit: Long,
+        val todayCredit: Long,
+        val activityName: String,
+        /** 服务端原始提示文案（可能是中文/英文；仅作 [outcome] 之外的补充透传） */
+        val message: String = "",
+        /** 动作语义结果：UI 按此本地化，不依赖 [message] 语言 */
+        val outcome: CheckinOutcome = CheckinOutcome.QUERY
+    )
+
+    /** 查询今日签到状态。uid 未知时省略 X-User-Id 头（源码确认该头可选）。 */
+    suspend fun fetchCheckinStatus(accountId: String? = null): Result<CheckinStatus> = withContext(Dispatchers.IO) {
+        val credential = credentialRepository.get(ServiceType.WORKBUDDY, accountId)
+            ?: return@withContext Result.failure(RepositoryError.InvalidCredential())
+        if (credential !is Credential.WorkBuddyCredential) {
+            return@withContext Result.failure(RepositoryError.InvalidCredential())
+        }
+        // 两条候选路径 fallback（cpa-plugin 实测：activity-status 优先，旧路径 checkin-status 兜底）
+        // 共享轮换状态：前一条路径轮换出的新 token 会用于下一条，且失败也先落库。
+        val body = authedPostFirstSuccessful(
+            credential,
+            accountId,
+            "/v2/billing/meter/checkin-activity-status",
+            "/v2/billing/meter/checkin-status"
+        ) ?: return@withContext Result.failure(RepositoryError.Unknown())
+        runCatching { parseCheckin(body) }.fold(
+            onSuccess = { Result.success(it) },
+            onFailure = {
+                Result.failure(
+                    RepositoryError.ParseError(
+                        RepositoryError.ParseErrorReason.MALFORMED_RESPONSE,
+                        "workbuddy checkin status 解析失败: " + it.message
+                    )
+                )
+            }
+        )
+    }
+
+    /**
+     * 执行今日签到（幂等：code=0 成功 / code=10001 已签，两种都算成功；源码确认 HTTP 400 也可能是已签）。
+     * 成功/已签后刷新一次状态并附带 message 提示。
+     */
+    suspend fun checkIn(accountId: String? = null): Result<CheckinStatus> = withContext(Dispatchers.IO) {
+        val credential = credentialRepository.get(ServiceType.WORKBUDDY, accountId)
+            ?: return@withContext Result.failure(RepositoryError.InvalidCredential())
+        if (credential !is Credential.WorkBuddyCredential) {
+            return@withContext Result.failure(RepositoryError.InvalidCredential())
+        }
+        val body = when (val r = authedPost(credential, "/v2/billing/meter/daily-checkin")) {
+            is AuthedPostResult.Ok -> {
+                persistCheckinOutcome(credential, accountId, r.rotatedCredential)
+                r.body
+            }
+            is AuthedPostResult.Failed -> {
+                // 即便签到请求失败，也必须先落库轮换出的新 token，否则账号卡在死 token 上；
+                // 但未发生轮换（纯网络失败）时不写入——避免把失败请求误标为「刚验证通过」。
+                if (r.rotatedCredential != null) {
+                    persistCheckinOutcome(credential, accountId, r.rotatedCredential)
+                }
+                // HTTP 400 也可能是业务失败且 body 携带签到语义（如已签），透传交给下方解析。
+                if (r.body.isBlank()) {
+                    return@withContext Result.failure(RepositoryError.Unknown())
+                }
+                r.body
+            }
+        }
+        // 签到响应为官方 envelope：{"code":0,"msg":"...","data":{...}}，code/msg 在根层，
+        // data 为可选明细。必须根层优先 + data 层兜底——否则 data 存在时根层 code 被漏读
+        // 成 -1，导致「实际签到成功却显示失败」（2026-10 实测回归）。
+        // 整体包 runCatching 兜底非法 JSON/"data":null 等边界，避免强转异常冒泡。
+        val code = runCatching {
+            val r = json.parseToJsonElement(body).jsonObject
+            r.scalar("code", "Code")?.toLongOrNull()
+                ?: (r["data"] as? JsonObject)?.scalar("code", "Code")?.toLongOrNull()
+        }.getOrNull() ?: -1L
+        val msg = runCatching {
+            val r = json.parseToJsonElement(body).jsonObject
+            r.scalar("msg", "message", "Message")
+                ?: (r["data"] as? JsonObject)?.scalar("msg", "message", "Message")
+        }.getOrNull().orEmpty()
+        val status = fetchCheckinStatus(accountId).getOrNull()
+        // 已签到语义与上游 cpa-multi-plugins 对齐：code=10001 或文案含「已签/今日/already」。
+        val lowerMsg = msg.lowercase()
+        val already = code == 10001L || msg.contains("已签") || msg.contains("已经签到") ||
+            msg.contains("今日") || lowerMsg.contains("already") || lowerMsg.contains("checked") ||
+            lowerMsg.contains("claimed")
+        val statusInfo = if (status != null) " checked=${status.todayCheckedIn}/streak=${status.streakDays}" else ""
+        DebugLog.i(
+            TAG,
+            "checkIn 判定: code=$code msg=$msg already=$already statusOk=${status != null}$statusInfo"
+        )
+        when {
+            code == 0L -> Result.success(
+                (status ?: CheckinStatus(true, true, 1, 0, 0, "")).copy(
+                    outcome = CheckinOutcome.SUCCESS
+                )
+            )
+            already -> Result.success(
+                (status ?: CheckinStatus(true, true, 0, 0, 0, "")).copy(
+                    outcome = CheckinOutcome.ALREADY
+                )
+            )
+            else -> {
+                if (status != null) {
+                    Result.success(status.copy(message = msg, outcome = CheckinOutcome.FAILED))
+                } else {
+                    Result.failure(RepositoryError.Unknown())
+                }
+            }
+        }
+    }
+
+    /**
+     * [authedPost] 的结果。
+     *
+     * [rotatedCredential] 一旦非空，表示服务端已作废旧 accessToken（新的 access/refresh
+     * 已轮换），调用方**必须**先落库再决定后续动作——即使本次请求最终失败，也不能丢弃它，
+     * 否则旧 refreshToken 单次消费后失效，账号会卡在死 token 上（永久 401）。
+     */
+    private sealed interface AuthedPostResult {
+        val rotatedCredential: Credential.WorkBuddyCredential?
+
+        /** 请求成功（2xx），[body] 为响应体。 */
+        data class Ok(
+            val body: String,
+            override val rotatedCredential: Credential.WorkBuddyCredential?
+        ) : AuthedPostResult
+
+        /** 请求失败，但过程中发生过 token 轮换（新凭据必须落库）。[body] 携带业务失败响应体
+         * （如 HTTP 400 也返回签到语义），可能为空。 */
+        data class Failed(
+            override val rotatedCredential: Credential.WorkBuddyCredential?,
+            val body: String = ""
+        ) : AuthedPostResult
+    }
+
+    /**
+     * 带自动 refresh 一次的 POST（Bearer）。
+     * 失败时若已发生轮换，会以 [AuthedPostResult.Failed] 回传新凭据（不丢轮换结果）。
+     */
+    private fun authedPost(credential: Credential.WorkBuddyCredential, path: String): AuthedPostResult {
+        var access = credential.accessToken
+        var refresh = credential.refreshToken
+        var rotated: Credential.WorkBuddyCredential? = null
+        repeat(2) { attempt ->
+            val request = Request.Builder()
+                .url("https://www.codebuddy.cn" + path)
+                .addHeader("Authorization", "Bearer " + access)
+                .addHeader("Accept", "application/json")
+                .addHeader("Content-Type", "application/json")
+                .post("{}".toRequestBody(jsonMedia))
+                .build()
+            val resp = try {
+                okHttpClient.newCall(request).execute()
+            } catch (e: Throwable) {
+                DebugLog.w(TAG, "authedPost 异常: path=$path err=${e::class.simpleName}: ${e.message}")
+                return AuthedPostResult.Failed(rotated)
+            }
+            val code = resp.code
+            val body = runCatching { resp.body?.string().orEmpty() }.getOrDefault("")
+            resp.close()
+            // 本地调试日志：记录请求路径/HTTP 码/响应摘要，不记录 Authorization（敏感）。
+            DebugLog.i(TAG, "authedPost: path=$path attempt=$attempt http=$code body=${body.take(200)}")
+            when {
+                code in 200..299 -> return AuthedPostResult.Ok(body, rotated)
+                (code == 401 || code == 403) && attempt == 0 -> {
+                    val refreshed = tryRefesh(refresh) ?: return AuthedPostResult.Failed(rotated)
+                    val expiresAt = if (refreshed.expiresIn > 0) {
+                        System.currentTimeMillis() + refreshed.expiresIn * 1000
+                    } else {
+                        credential.expiresAt.coerceAtLeast(System.currentTimeMillis())
+                    }
+                    rotated = credential.copy(
+                        accessToken = refreshed.accessToken,
+                        refreshToken = refreshed.refreshToken,
+                        expiresAt = expiresAt
+                    )
+                    access = refreshed.accessToken
+                    refresh = refreshed.refreshToken
+                }
+                else -> return AuthedPostResult.Failed(rotated, body)
+            }
+        }
+        return AuthedPostResult.Failed(rotated)
+    }
+
+    /**
+     * 候选路径 fallback 专用：依次尝试各路径，但**同一次查询内共享轮换状态**——
+     * 若前一条路径已轮换 token，后续路径必须用新 accessToken 请求，并把轮换结果
+     * 落库后再返回，避免旧 token 重试直接失败。
+     */
+    private suspend fun authedPostFirstSuccessful(
+        credential: Credential.WorkBuddyCredential,
+        accountId: String?,
+        vararg paths: String
+    ): String? {
+        var current = credential
+        for (path in paths) {
+            when (val r = authedPost(current, path)) {
+                is AuthedPostResult.Ok -> {
+                    persistCheckinOutcome(credential, accountId, r.rotatedCredential)
+                    return r.body
+                }
+                is AuthedPostResult.Failed -> {
+                    // 即便本路径失败，也要先把轮换出的新 token 落库并继续用新 token 试下一条
+                    if (r.rotatedCredential != null) {
+                        persistCheckinOutcome(credential, accountId, r.rotatedCredential)
+                        current = r.rotatedCredential
+                    }
+                }
+            }
+        }
+        return null
+    }
+
+    /**
+     * 落库本次签到/状态查询产出：轮换后的 token（若有）+ lastVerifiedAt。
+     * 与 [fetchBalance] 同款语义——一次成功请求即视为凭据已验证。
+     */
+    private suspend fun persistCheckinOutcome(
+        credential: Credential.WorkBuddyCredential,
+        accountId: String?,
+        rotated: Credential.WorkBuddyCredential?
+    ) {
+        val base = rotated ?: credential
+        credentialRepository.save(base.copy(lastVerifiedAt = System.currentTimeMillis()), accountId)
+    }
+
+    private fun mapHttpError(code: Int, body: String): RepositoryError = when (code) {
+        401, 403 -> RepositoryError.InvalidCredential()
+        429 -> RepositoryError.RateLimited()
+        423 -> RepositoryError.ServerError(code)
+        in 500..599 -> RepositoryError.ServerError(code)
+        else -> RepositoryError.Unknown()
+    }
+
+    private data class RefreshedWorkBuddy(
+        val accessToken: String,
+        val refreshToken: String,
+        val expiresIn: Long
+    )
+
+    private data class ParsedWorkBuddy(
+        val amount: Double,
+        val used: Double,
+        val size: Double,
+        val unit: String?,
+        val extras: Map<String, String>
+    )
+
+    companion object {
+        const val TAG = "WorkBuddy"
+
+        /** extras 键：细粒度账户明细 JSON（结构见 [parseResourceDetail]），详情页消费。 */
+        const val KEY_DETAIL_RAW = "wb_detail_raw"
+
+        /** extras 键：套餐积分的 PackageCode（详情页据此区分套餐 vs 奖励积分）。 */
+        const val KEY_PLAN_CODE = "wb_plan_code"
+
+        /** 解析专用 Json（companion 内独立持有，使 parseCheckin 可静态调用/单测）。 */
+        private val parseJson = Json { ignoreUnknownKeys = true }
+
+        /**
+         * 解析 checkin 响应（data 平铺或 data 包裹，防御式多候选）。
+         * 放在 companion 内以便单测直接调用（不依赖 OkHttp/凭据）。
+         */
+        internal fun parseCheckin(body: String): CheckinStatus {
+            val root = parseJson.parseToJsonElement(body).jsonObject
+            val obj = root["data"]?.jsonObject ?: root
+            return CheckinStatus(
+                active = obj.scalar("active", "Active")?.toBoolean() ?: true,
+                todayCheckedIn = obj.scalar("today_checked_in", "todayCheckedIn")?.toBoolean() ?: false,
+                streakDays = obj.longOr("streak_days", "streakDays") ?: 0,
+                dailyCredit = obj.longOr("daily_credit", "dailyCredit") ?: 0,
+                todayCredit = obj.longOr("today_credit", "todayCredit") ?: 0,
+                activityName = obj.scalar("activity_name", "activityName", "theme_name") ?: ""
+            )
+        }
+
+        private fun JsonObject.scalar(vararg keys: String): String? {
+            for (key in keys) {
+                this[key]?.jsonPrimitive?.contentOrNull?.takeIf { it.isNotBlank() }?.let { return it }
+            }
+            return null
+        }
+
+        private fun JsonObject.longOr(vararg keys: String): Long? {
+            for (key in keys) {
+                this[key]?.jsonPrimitive?.contentOrNull?.toLongOrNull()?.let { return it }
+            }
+            return null
+        }
+    }
+}

app/src/main/java/com/rainy/token/di/NetworkModule.kt

@@ -17,6 +17,10 @@ import com.rainy.token.data.repository.CommandCodeUsageRepository
 import com.rainy.token.data.repository.OpenCodeGoRepository
 import com.rainy.token.data.repository.OpenCodeUsageRepository
 import com.rainy.token.data.repository.OllamaRepository
+import com.rainy.token.data.repository.Sub2ApiRepository
+import com.rainy.token.data.repository.TraeRepository
+import com.rainy.token.data.repository.UpdateRepository
+import com.rainy.token.data.repository.WorkBuddyRepository
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -122,7 +126,7 @@ object NetworkModule {
     ): OpenCodeGoRepository = OpenCodeGoRepository(okHttpClient, credentialRepository, balanceCache)
 
     /**
-     * CommandCode Go 用量仓库。
+     * CommandCode 用量仓库。
      */
     @Provides
     @Singleton
@@ -132,7 +136,7 @@ object NetworkModule {
     ): CommandCodeUsageRepository = CommandCodeUsageRepository(okHttpClient, credentialRepository)
 
     /**
-     * CommandCode Go 仓库：API Key 认证，调 JSON API。
+     * CommandCode 仓库：API Key 认证，调 JSON API。
      */
     @Provides
     @Singleton
@@ -155,7 +159,7 @@ object NetworkModule {
     ): DeepSeekRepository = DeepSeekRepository(deepSeekApi, credentialRepository, balanceCache)
 
     /**
-     * Codex / ChatGPT Plus 额度仓库：用 OkHttp 调 chatgpt.com 后台 API。
+     * Codex / ChatGPT 额度仓库：用 OkHttp 调 chatgpt.com 后台 API。
      */
     @Provides
     @Singleton
@@ -166,7 +170,7 @@ object NetworkModule {
     ): CodexRepository = CodexRepository(okHttpClient, credentialRepository, balanceCache)
 
     /**
-     * Ollama Pro Cloud 用量仓库：Cookie 认证 + OkHttp 抓 settings HTML 解析。
+     * Ollama Cloud 用量仓库：Cookie 认证 + OkHttp 抓 settings HTML 解析。
      */
     @Provides
     @Singleton
@@ -176,6 +180,49 @@ object NetworkModule {
         balanceCache: BalanceCache
     ): OllamaRepository = OllamaRepository(okHttpClient, credentialRepository, balanceCache)
 
+    /**
+     * Trae 仓库：Cloud-IDE-JWT 认证 + REST。
+     */
+    @Provides
+    @Singleton
+    fun provideTraeRepository(
+        okHttpClient: OkHttpClient,
+        credentialRepository: CredentialRepository,
+        balanceCache: BalanceCache
+    ): TraeRepository = TraeRepository(okHttpClient, credentialRepository, balanceCache)
+
+    /**
+     * WorkBuddy 仓库：OAuth Bearer + get-user-resource。
+     */
+    @Provides
+    @Singleton
+    fun provideWorkBuddyRepository(
+        okHttpClient: OkHttpClient,
+        credentialRepository: CredentialRepository,
+        balanceCache: BalanceCache
+    ): WorkBuddyRepository = WorkBuddyRepository(okHttpClient, credentialRepository, balanceCache)
+
+    /**
+     * Sub2API 仓库：自托管实例（凭据里的 baseUrl）+ 管理面板 API。
+     */
+    /**
+     * 更新仓库：读取 Gitea 上的 update.json 并下载 APK。
+     */
+    @Provides
+    @Singleton
+    fun provideUpdateRepository(
+        okHttpClient: OkHttpClient,
+        @ApplicationContext context: Context
+    ): UpdateRepository = UpdateRepository(okHttpClient, context)
+
+    @Provides
+    @Singleton
+    fun provideSub2ApiRepository(
+        okHttpClient: OkHttpClient,
+        credentialRepository: CredentialRepository,
+        balanceCache: BalanceCache
+    ): Sub2ApiRepository = Sub2ApiRepository(okHttpClient, credentialRepository, balanceCache)
+
     /** 余额缓存 DataStore（计划 7.1） */
     @Provides
     @Singleton

app/src/main/java/com/rainy/token/domain/model/Credential.kt

@@ -8,7 +8,7 @@ import kotlinx.serialization.Serializable
  *
  * - [ApiKeyCredential] 用于 DeepSeek（API Key 形式）
  * - [SessionCredential] 用于 OpenCode Zen/Go（用户登录 dashboard 后粘贴的值）
- * - [CodexCredential] 用于 Codex / ChatGPT Plus（完整 OAuth 凭据，含自动刷新）
+ * - [CodexCredential] 用于 Codex / ChatGPT（完整 OAuth 凭据，含自动刷新）
  */
 @Serializable
 sealed class Credential {
@@ -41,15 +41,15 @@ sealed class Credential {
         val authCookie: String? = null,
         /** OpenCode Go 专用：workspace ID */
         val workspaceId: String? = null,
-        /** Ollama Pro 专用：完整的 Cookie 字符串（用户从浏览器 DevTools 复制） */
+        /** Ollama 专用：完整的 Cookie 字符串（用户从浏览器 DevTools 复制） */
         val ollamaCookie: String? = null,
-        /** OpenCode Go / Ollama Pro 专用：API Key，用于一键激活用量 */
+        /** OpenCode Go / Ollama 专用：API Key，用于一键激活用量 */
         val apiKey: String? = null,
         override val lastVerifiedAt: Long = 0L
     ) : Credential()
 
     /**
-     * 用于 Codex / ChatGPT Plus：完整 OAuth 凭据，支持自动刷新。
+     * 用于 Codex / ChatGPT：完整 OAuth 凭据，支持自动刷新。
      * 用户从 auth.json 粘贴整个 tokens 对象。
      */
     @Serializable
@@ -62,6 +62,83 @@ sealed class Credential {
         val expiresAt: Long,
         override val lastVerifiedAt: Long = 0L
     ) : Credential()
+
+    /**
+     * 用于 Trae（CN/Intl）：官方 IDE 扩展使用的 Cloud-IDE-JWT。
+     * 单个 JWT（~14 天 RS256），配 [region] 决定域名与请求头。
+     *
+     * [deviceId] 为本 App 持久化生成的每机唯一设备 ID（与登录授权 URL 中
+     * device_id 一致，即 OAuth 会话绑定的设备）。Trae claim 签到接口按 x-device-id
+     * 做设备级每日去重/风控，必须用与登录会话一致的设备 ID；不可用 userJwt.ClientID
+     * （那是固定客户端标识，所有用户相同，会被服务端按设备风控拒绝）。
+     * [userId] 为 OAuth 用户 ID（回调 userInfo），签到按 trae-check 口径拼
+     * `${deviceId}-${userId}`。旧凭据无这些字段时退回由 JWT 派生的稳定伪 ID。
+     */
+    @Serializable
+    data class TraeCredential(
+        override val service: ServiceType,
+        /** `Authorization: Cloud-IDE-JWT <jwt>` 的 JWT 值 */
+        val jwt: String,
+        /** 区域："CN"（api.trae.cn）/ "INTL"（grow-normal.trae.ai） */
+        val region: String = "CN",
+        /** 登录会话绑定的设备 ID（App 持久化每机唯一），null=旧凭据未保存 */
+        val deviceId: String? = null,
+        /** OAuth 用户 ID（回调 userInfo.userId），null=旧凭据未保存 */
+        val userId: String? = null,
+        /** 最近一次成功签到日期（yyyy-MM-dd，本地时区）；当天命中则本地短路，不重复发起签到请求 */
+        val lastCheckinDate: String? = null,
+        /**
+         * 用户在设置页手动填写的签到设备 ID（官方客户端绑定的 did）。
+         * 服务端按设备风控签到（9074 根因），官方客户端真实 did 才能通过；
+         * null/空白 = 使用内置默认（ACCOUNT_BOUND_DEVICE_ID）。
+         * 获取路径见设置页提示（客户端日志 main.log 搜索 did=）。
+         */
+        val checkinDeviceId: String? = null,
+        override val lastVerifiedAt: Long = 0L
+    ) : Credential()
+
+    /**
+     * 用于腾讯 WorkBuddy（AI 办公 Agent，积分与 CodeBuddy 同体系）。
+     * 复用 Codex 的 OAuth Bearer 模式：accessToken + refreshToken（单次轮换）。
+     */
+    @Serializable
+    data class WorkBuddyCredential(
+        override val service: ServiceType,
+        val accessToken: String,
+        val refreshToken: String,
+        /** 过期时间（epoch millis），0=未知 */
+        val expiresAt: Long = 0L,
+        override val lastVerifiedAt: Long = 0L
+    ) : Credential()
+
+    /**
+     * 用于 Sub2API（自建 mid 层/聚合面板，任意用户填自己的实例地址）。
+     * 走【用户级】查询：普通用户填实例分配给他的 sk- API Key 即可查余额，无需管理员。
+     * 实测（xxcsn.site）：GET {base}/v1/usage + Authorization: Bearer <apiKey>
+     * 返回 remaining/balance/unit/usage.total.cost/model_stats 等。
+     * 无 API Key 时可用面板邮箱+密码登录换取 Bearer token 作为备选。
+     */
+    @Serializable
+    data class Sub2ApiCredential(
+        override val service: ServiceType,
+        /** 自托管实例基址，如 https://api.example.com（自动去尾斜杠） */
+        val baseUrl: String,
+        /** 面板登录邮箱（无 API Key 的备选认证） */
+        val email: String,
+        /** 面板登录密码（无 API Key 的备选认证） */
+        val password: String,
+        /** 用户级 API Key（sk-…），存在时优先于 email/password 认证 */
+        val apiKey: String? = null,
+        /**
+         * 面板登录 Token（App 内 WebView 登录后自动从 localStorage.auth_token 提取）。
+         * 存在时走【面板模式】：全账号 usage/stats + dashboard/models + snapshot-v2
+         * （数据与网页「使用记录」页一致，actual_cost 口径）。
+         */
+        val authToken: String? = null,
+        /** 站点 Logo URL（登录/探测时抓取；主页卡片显示，替换内置图标）。 */
+        val siteIcon: String? = null,
+        override val lastVerifiedAt: Long = 0L
+    ) : Credential()
 }
 
 /**

app/src/main/java/com/rainy/token/domain/model/ServiceAccount.kt

@@ -0,0 +1,32 @@
+package com.rainy.token.domain.model
+
+import com.rainy.token.domain.service.ServiceType
+import kotlinx.serialization.Serializable
+
+/**
+ * 单个服务的账号元信息（多账号服务专用，如 Trae / WorkBuddy）。
+ *
+ * 凭据本身按 [id] 独立加密存储，这里只保存展示与排序所需的元数据：
+ * - [id]：稳定账号标识（迁移出的首个账号固定为 "default"；新建账号为随机 ID）
+ * - [label]：用户可见名称；null/空白时 UI 按“账号 N”兜底显示
+ * - [isDefault]：是否为默认账号（小组件 / 每日自动签到仅作用于默认账号）
+ */
+@Serializable
+data class ServiceAccountInfo(
+    val id: String,
+    val label: String? = null,
+    val isDefault: Boolean = false,
+    val createdAt: Long = 0L
+)
+
+/**
+ * 单个服务的账号元数据集合，经 [com.rainy.token.data.local.SecureStorage] 加密持久化，
+ * 存储键为 `accounts_{service.storageKey}`。
+ *
+ * 单账号服务不使用本结构，仍沿用旧的单凭据存储键。
+ */
+@Serializable
+data class AccountStore(
+    val service: ServiceType,
+    val accounts: List<ServiceAccountInfo> = emptyList()
+)

app/src/main/java/com/rainy/token/domain/model/ServiceBalance.kt

@@ -22,5 +22,7 @@ data class ServiceBalance(
     /** 配额周期下次重置时间（订阅型服务，epoch millis） */
     val nextResetAt: Long? = null,
     /** 服务特定的附加信息（如 Zen 充值 $20 起，Go 5h 配额） */
-    val extras: Map<String, String> = emptyMap()
+    val extras: Map<String, String> = emptyMap(),
+    /** Sub2API 专有：网关 /v1/usage 返回的结构化用量明细（模型统计 + 每日明细）。其他服务为 null。 */
+    val sub2UsageDetail: Sub2UsageDetail? = null
 )

app/src/main/java/com/rainy/token/domain/model/Sub2UsageDetail.kt

@@ -0,0 +1,39 @@
+package com.rainy.token.domain.model
+
+import kotlinx.serialization.Serializable
+
+/**
+ * Sub2API 网关 /v1/usage 返回的结构化用量明细。
+ *
+ * 不同网关版本字段名/是否返回都不同，因此全部字段防御式解析：
+ * - [modelStats]：按模型聚合的统计（原来只取前 3 个塞进 extras 字符串，现全量结构化）
+ * - [dailyUsage]：按日聚合的明细（date 形如 "2026-09-04"，时区由请求的 timezone 参数决定）
+ */
+@Serializable
+data class Sub2UsageDetail(
+    val modelStats: List<Sub2ModelStat> = emptyList(),
+    val dailyUsage: List<Sub2DailyUsage> = emptyList()
+) {
+    val isEmpty: Boolean get() = modelStats.isEmpty() && dailyUsage.isEmpty()
+    val isNotEmpty: Boolean get() = !isEmpty
+}
+
+/** 按模型聚合的用量统计。字段名来自官方前端 /v1/usage model_stats[]。 */
+@Serializable
+data class Sub2ModelStat(
+    val model: String,
+    val requests: Long = 0,
+    val inputTokens: Long = 0,
+    val outputTokens: Long = 0,
+    val totalTokens: Long = 0,
+    val cost: Double = 0.0
+)
+
+/** 按日聚合的用量明细。 */
+@Serializable
+data class Sub2DailyUsage(
+    val date: String,
+    val requests: Long = 0,
+    val totalTokens: Long = 0,
+    val cost: Double = 0.0
+)

app/src/main/java/com/rainy/token/domain/model/TriggerSummary.kt

@@ -0,0 +1,24 @@
+package com.rainy.token.domain.model
+
+/**
+ * 一键激活用量的结构化响应摘要。
+ *
+ * Repository 只负责从响应中提取数据，不拼接展示文案；
+ * UI 层按当前语言环境用 stringResource 组装本地化文本。
+ */
+data class TriggerSummary(
+    /** 发起请求时使用的模型 */
+    val model: String,
+    /** 模型回复文本；null 表示响应中不存在回复内容 */
+    val reply: String?,
+    /** 输入 token 数（OCGO/Ollama 为 prompt_tokens，Codex 为 input_tokens） */
+    val inputTokens: String? = null,
+    /** 输出 token 数（OCGO/Ollama 为 completion_tokens，Codex 为 output_tokens） */
+    val outputTokens: String? = null,
+    /** 总 token 数（OCGO/Ollama 的 total_tokens；Codex 无此字段） */
+    val totalTokens: String? = null,
+    /** Codex 响应 ID */
+    val responseId: String? = null,
+    /** 响应解析失败，但请求已成功发出 */
+    val parseFailed: Boolean = false
+)

app/src/main/java/com/rainy/token/domain/service/ServiceConfigProvider.kt

@@ -10,6 +10,9 @@ enum class FetchMethod {
     /** WebView 登录后抓取 HTML/内部 JSON API */
     WEBVIEW_SCRAPER,
 
+    /** 用户自托管实例的 REST API（地址在凭据里，如 Sub2API） */
+    SELF_HOSTED_REST,
+
     /** 完全手动输入（已降级） */
     MANUAL
 }
@@ -24,6 +27,8 @@ data class ServiceConfig(
     val loginUrl: String,
     /** 余额/配额的展示单位（如 "¥" / "$" / "Credits" / "requests"） */
     val displayUnit: String,
+    /** 外部操作页 URL（如 DeepSeek 充值页），App 内 WebView 打开，可空 */
+    val externalUrl: String? = null,
     /** 触发降级的连续失败次数阈值（计划 5.4 / 6.3） */
     val degradationFailureThreshold: Int = 3,
     /** Cookie 有效期 < 该值则触发降级（小时） */
@@ -40,7 +45,9 @@ object ServiceConfigProvider {
             type = ServiceType.DEEPSEEK,
             method = FetchMethod.REST_API,
             loginUrl = "", // REST 模式不需要登录 URL
-            displayUnit = "¥"
+            displayUnit = "¥",
+            // App 内 WebView 打开的官方充值页
+            externalUrl = "https://platform.deepseek.com/top_up"
         ),
         ServiceType.OPENCODE_GO to ServiceConfig(
             type = ServiceType.OPENCODE_GO,
@@ -66,6 +73,29 @@ object ServiceConfigProvider {
             method = FetchMethod.WEBVIEW_SCRAPER,
             loginUrl = "https://ollama.com/settings",
             displayUnit = "%"
+        ),
+        ServiceType.TRAE to ServiceConfig(
+            type = ServiceType.TRAE,
+            method = FetchMethod.REST_API,
+            loginUrl = "",
+            displayUnit = "Credits",
+            // 官网定价页（docs.trae.cn 订阅管理：购买会员套餐/增购积分入口）
+            externalUrl = "https://www.trae.cn/pricing"
+        ),
+        ServiceType.WORKBUDDY to ServiceConfig(
+            type = ServiceType.WORKBUDDY,
+            method = FetchMethod.REST_API,
+            loginUrl = "",
+            displayUnit = "Credits",
+            // 官网订阅定价页
+            externalUrl = "https://www.workbuddy.cn/pricing/"
+        ),
+        ServiceType.SUB2API to ServiceConfig(
+            type = ServiceType.SUB2API,
+            // 地址在用户填写的凭据里，按自托管实例调用
+            method = FetchMethod.SELF_HOSTED_REST,
+            loginUrl = "",
+            displayUnit = "$"
         )
     )
 

app/src/main/java/com/rainy/token/domain/service/ServiceType.kt

@@ -15,13 +15,27 @@ enum class ServiceType(
     val storageKey: String
 ) {
     OPENCODE_GO("OpenCode Go", "opencode_go"),
-    COMMANDCODE_GO("CommandCode Go", "commandcode_go"),
+    COMMANDCODE_GO("CommandCode", "commandcode_go"),
     DEEPSEEK("DeepSeek", "deepseek"),
     CODEX("Codex / ChatGPT", "codex"),
-    OLLAMA("Ollama Pro", "ollama");
+    OLLAMA("Ollama", "ollama"),
+    TRAE("Trae", "trae"),
+    WORKBUDDY("WorkBuddy", "workbuddy"),
+    SUB2API("Sub2API", "sub2api");
 
     companion object {
         fun fromStorageKey(key: String): ServiceType? =
             entries.firstOrNull { it.storageKey == key }
+
+        /** 支持多账号的服务（Trae / WorkBuddy / Sub2API 已启用，见需求范围）。 */
+        val MULTI_ACCOUNT_SERVICES: Set<ServiceType> = setOf(
+            ServiceType.TRAE,
+            ServiceType.WORKBUDDY,
+            ServiceType.SUB2API
+        )
+
+        /** 该服务是否启用多账号。 */
+        fun isMultiAccount(service: ServiceType): Boolean =
+            service in MULTI_ACCOUNT_SERVICES
     }
 }

app/src/main/java/com/rainy/token/domain/usecase/RefreshBalanceUseCase.kt

@@ -3,13 +3,18 @@ package com.rainy.token.domain.usecase
 import com.rainy.token.data.repository.CodexRepository
 import com.rainy.token.data.repository.CommandCodeGoRepository
 import com.rainy.token.data.repository.CredentialRepository
+import com.rainy.token.data.repository.CheckinStatusStore
 import com.rainy.token.data.repository.DeepSeekRepository
 import com.rainy.token.data.repository.OllamaRepository
 import com.rainy.token.data.repository.OpenCodeGoRepository
 import com.rainy.token.data.repository.RefreshWriteSession
 import com.rainy.token.data.repository.RepositoryError
+import com.rainy.token.data.repository.Sub2ApiRepository
+import com.rainy.token.data.repository.TraeRepository
+import com.rainy.token.data.repository.WorkBuddyRepository
 import com.rainy.token.data.repository.retryOnTransientError
 import com.rainy.token.domain.model.ServiceBalance
+import com.rainy.token.domain.model.TriggerSummary
 import com.rainy.token.domain.service.ServiceType
 import javax.inject.Inject
 import javax.inject.Provider
@@ -25,14 +30,21 @@ import kotlinx.coroutines.withContext
  */
 class RefreshBalanceUseCase @Inject constructor(
     private val credentialRepository: CredentialRepository,
+    private val checkinStatusStore: com.rainy.token.data.repository.CheckinStatusStore,
     private val deepSeekRepositoryProvider: Provider<DeepSeekRepository>,
     private val openCodeGoRepositoryProvider: Provider<OpenCodeGoRepository>,
     private val commandCodeGoRepositoryProvider: Provider<CommandCodeGoRepository>,
     private val codexRepositoryProvider: Provider<CodexRepository>,
-    private val ollamaRepositoryProvider: Provider<OllamaRepository>
+    private val ollamaRepositoryProvider: Provider<OllamaRepository>,
+    private val traeRepositoryProvider: Provider<TraeRepository>,
+    private val workBuddyRepositoryProvider: Provider<WorkBuddyRepository>,
+    private val sub2ApiRepositoryProvider: Provider<Sub2ApiRepository>
 ) {
-    suspend operator fun invoke(service: ServiceType): Result<ServiceBalance> =
-        withCredentialSession(service) {
+    suspend operator fun invoke(
+        service: ServiceType,
+        accountId: String? = null
+    ): Result<ServiceBalance> =
+        withCredentialSession(service, accountId) {
             when (service) {
                 ServiceType.DEEPSEEK -> retryOnTransientError {
                     deepSeekRepositoryProvider.get().fetchBalance()
@@ -49,13 +61,22 @@ class RefreshBalanceUseCase @Inject constructor(
                 ServiceType.OLLAMA -> retryOnTransientError {
                     ollamaRepositoryProvider.get().fetchBalance()
                 }
+                ServiceType.TRAE -> retryOnTransientError {
+                    traeRepositoryProvider.get().fetchBalance(accountId)
+                }
+                ServiceType.WORKBUDDY -> retryOnTransientError {
+                    workBuddyRepositoryProvider.get().fetchBalance(accountId)
+                }
+                ServiceType.SUB2API -> retryOnTransientError {
+                    sub2ApiRepositoryProvider.get().fetchBalance(accountId)
+                }
             }
         }
 
     suspend fun fetchCodexModels(): Result<List<String>> =
         codexRepositoryProvider.get().fetchModels()
 
-    suspend fun triggerCodexUsage(model: String): Result<String> =
+    suspend fun triggerCodexUsage(model: String): Result<TriggerSummary> =
         withCredentialSession(ServiceType.CODEX) {
             codexRepositoryProvider.get().triggerUsage(model)
         }
@@ -63,7 +84,7 @@ class RefreshBalanceUseCase @Inject constructor(
     suspend fun fetchOpenCodeGoModels(): Result<List<String>> =
         openCodeGoRepositoryProvider.get().fetchModels()
 
-    suspend fun triggerOpenCodeGoUsage(model: String): Result<String> =
+    suspend fun triggerOpenCodeGoUsage(model: String): Result<TriggerSummary> =
         withCredentialSession(ServiceType.OPENCODE_GO) {
             openCodeGoRepositoryProvider.get().triggerUsage(model)
         }
@@ -71,16 +92,91 @@ class RefreshBalanceUseCase @Inject constructor(
     suspend fun fetchOllamaModels(): Result<List<String>> =
         ollamaRepositoryProvider.get().fetchModels()
 
-    suspend fun triggerOllamaUsage(model: String): Result<String> =
+    suspend fun triggerOllamaUsage(model: String): Result<TriggerSummary> =
         withCredentialSession(ServiceType.OLLAMA) {
             ollamaRepositoryProvider.get().triggerUsage(model)
         }
 
+    /**
+     * 执行每日签到（TRAE / WORKBUDDY），返回各自的语义结果类型。
+     *
+     * 必须走 [withCredentialSession]：签到会触发 OAuth 轮换（WorkBuddy 401/403 时刷新
+     * access/refresh），轮换结果需按凭据快照校验后提交，避免并发改凭据被旧快照覆盖；
+     * 同时会话内重试才能读到已轮换的新 token（否则旧 refreshToken 单次消费后直接失效）。
+     */
+    suspend fun checkInWorkBuddy(accountId: String? = null): Result<WorkBuddyRepository.CheckinStatus> =
+        withCredentialSession(ServiceType.WORKBUDDY, accountId) {
+            workBuddyRepositoryProvider.get().checkIn(accountId).also { result ->
+                result.getOrNull()?.let { s ->
+                    val isChecked = s.outcome == WorkBuddyRepository.CheckinOutcome.SUCCESS ||
+                        s.outcome == WorkBuddyRepository.CheckinOutcome.ALREADY ||
+                        s.outcome == WorkBuddyRepository.CheckinOutcome.QUERY
+                    if (isChecked) {
+                        checkinStatusStore.record(
+                            service = ServiceType.WORKBUDDY,
+                            accountId = accountId,
+                            status = if (s.outcome == WorkBuddyRepository.CheckinOutcome.QUERY) {
+                                CheckinStatusStore.STATUS_ALREADY
+                            } else {
+                                s.outcome.name
+                            },
+                            checkinId = if (s.outcome == WorkBuddyRepository.CheckinOutcome.SUCCESS) {
+                                java.util.UUID.randomUUID().toString()
+                            } else {
+                                null
+                            },
+                            credits = if (s.outcome == WorkBuddyRepository.CheckinOutcome.SUCCESS) {
+                                s.todayCredit.takeIf { it > 0 } ?: s.dailyCredit
+                            } else {
+                                0
+                            }
+                        )
+                    }
+                }
+            }
+        }
+
+    suspend fun checkInTrae(accountId: String? = null): Result<TraeRepository.CheckinResult> =
+        withCredentialSession(ServiceType.TRAE, accountId) {
+            traeRepositoryProvider.get().checkIn(accountId).also { result ->
+                result.getOrNull()?.let { r ->
+                    if (r.outcome == TraeRepository.CheckinOutcome.SUCCESS ||
+                        r.outcome == TraeRepository.CheckinOutcome.ALREADY
+                    ) {
+                        checkinStatusStore.record(
+                            service = ServiceType.TRAE,
+                            accountId = accountId,
+                            status = r.outcome.name,
+                            checkinId = if (r.outcome == TraeRepository.CheckinOutcome.SUCCESS) {
+                                java.util.UUID.randomUUID().toString()
+                            } else {
+                                null
+                            },
+                            credits = if (r.outcome == TraeRepository.CheckinOutcome.SUCCESS) r.points else 0
+                        )
+                    }
+                }
+            }
+        }
+
+    /** 查询今日签到状态（仅 WORKBUDDY 有该接口）。走会话以保证状态查询的凭据写入不覆盖并发编辑。 */
+    suspend fun fetchCheckinStatus(accountId: String? = null): Result<WorkBuddyRepository.CheckinStatus> =
+        withCredentialSession(ServiceType.WORKBUDDY, accountId) {
+            workBuddyRepositoryProvider.get().fetchCheckinStatus(accountId)
+        }
+
+    /** TRAE 今日签到状态（只读 status 接口，供详情页进入时预取「已签到」展示）。 */
+    suspend fun fetchTraeCheckinStatus(accountId: String? = null): Result<Boolean> =
+        withCredentialSession(ServiceType.TRAE, accountId) {
+            traeRepositoryProvider.get().fetchCheckinStatus(accountId)
+        }
+
     private suspend fun <T> withCredentialSession(
         service: ServiceType,
+        accountId: String? = null,
         block: suspend () -> Result<T>
     ): Result<T> {
-        val snapshot = credentialRepository.snapshot(service)
+        val snapshot = credentialRepository.snapshot(service, accountId)
             ?: return Result.failure(RepositoryError.InvalidCredential())
         val session = RefreshWriteSession(snapshot)
 

app/src/main/java/com/rainy/token/domain/usecase/SyncCommandCodeUsageUseCase.kt

@@ -6,7 +6,7 @@ import javax.inject.Inject
 import javax.inject.Provider
 
 /**
- * CommandCode Go 用量同步 UseCase。
+ * CommandCode 用量同步 UseCase。
  *
  * 游标协议：每页返回 (记录列表, 下一页游标)。
  * - cursor=null → 最新页
@@ -23,12 +23,18 @@ class SyncCommandCodeUsageUseCase @Inject constructor(
     private val usageRepoProvider: Provider<CommandCodeUsageRepository>,
     private val cacheProvider: Provider<UsageCache>
 ) {
+    /** 防御性页数上限：正常窗口（1 天 ≤ 数十页）远不会触及，防止游标异常导致死循环 */
+    private companion object {
+        const val MAX_PAGES = 500
+    }
+
     suspend fun fullSync(): Result<SyncResult> {
         val repo = usageRepoProvider.get()
         val cache = cacheProvider.get()
         var cursor: String? = null
         var totalInserted = 0
         val errors = mutableListOf<String>()
+        var pages = 0
 
         while (true) {
             val pageResult = repo.fetchPage(cursor)
@@ -38,6 +44,7 @@ class SyncCommandCodeUsageUseCase @Inject constructor(
             }
             val (records, nextCursor) = pageResult.getOrThrow()
             if (records.isEmpty()) break
+            if (nextCursor == cursor) break // 游标未前进，防死循环
 
             val before = cache.count()
             cache.insertAll(records)
@@ -45,6 +52,7 @@ class SyncCommandCodeUsageUseCase @Inject constructor(
 
             if (records.size < CommandCodeUsageRepository.PAGE_SIZE) break
             cursor = nextCursor
+            if (++pages >= MAX_PAGES) break // 防御性上限，正常窗口不会触及
         }
 
         return if (errors.isEmpty()) Result.success(SyncResult(inserted = totalInserted))
@@ -56,6 +64,7 @@ class SyncCommandCodeUsageUseCase @Inject constructor(
         val cache = cacheProvider.get()
         var cursor: String? = null
         var totalInserted = 0
+        var pages = 0
 
         while (true) {
             val pageResult = repo.fetchPage(cursor)
@@ -63,6 +72,7 @@ class SyncCommandCodeUsageUseCase @Inject constructor(
 
             val (records, nextCursor) = pageResult.getOrThrow()
             if (records.isEmpty()) break
+            if (nextCursor == cursor) break // 游标未前进，防死循环
 
             // 按 workspace 过滤本地已有 ID，避免跨 workspace 碰撞
             val workspaceId = records.firstOrNull()?.workspaceId ?: CommandCodeUsageRepository.CCGO_WORKSPACE_ID
@@ -76,6 +86,7 @@ class SyncCommandCodeUsageUseCase @Inject constructor(
 
             if (records.size < CommandCodeUsageRepository.PAGE_SIZE) break
             cursor = nextCursor
+            if (++pages >= MAX_PAGES) break // 防御性上限
         }
 
         return Result.success(SyncResult(inserted = totalInserted))

app/src/main/java/com/rainy/token/ui/RainyTokenNavHost.kt

@@ -18,12 +18,15 @@ import androidx.compose.material3.VerticalDivider
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
@@ -33,7 +36,9 @@ import androidx.navigation.compose.composable
 import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
 import androidx.navigation.navArgument
+import com.rainy.token.R
 import com.rainy.token.data.repository.CommandCodeUsageRepository
+import com.rainy.token.domain.service.ServiceConfigProvider
 import com.rainy.token.domain.service.ServiceType
 import com.rainy.token.ui.components.rememberWindowSizeClass
 import com.rainy.token.ui.components.DebugLogScreen
@@ -46,13 +51,19 @@ import com.rainy.token.ui.dashboard.UsageDataViewModel
 import com.rainy.token.ui.dashboard.UsageDetailScreen
 import com.rainy.token.ui.dashboard.UsageOverviewScreen
 import com.rainy.token.ui.dashboard.UsageViewModel
+import com.rainy.token.ui.heatmap.HeatmapScreen
+import com.rainy.token.ui.account.ApiManagementScreen
 import com.rainy.token.ui.servicedetail.ServiceDetailScreen
+import com.rainy.token.ui.settings.AccountManagementScreen
 import com.rainy.token.ui.settings.CredentialEditScreen
+import com.rainy.token.ui.settings.CredentialEditViewModel
 import com.rainy.token.ui.settings.SettingsScreen
 import com.rainy.token.ui.theme.inkMuted
 import com.rainy.token.ui.theme.StrawberryPink
 import com.rainy.token.ui.webview.CodexOAuthScreen
 import com.rainy.token.ui.webview.WebViewLoginScreen
+import com.rainy.token.ui.webview.WebViewPageScreen
+import android.net.Uri
 
 /**
  * 应用导航图。
@@ -66,21 +77,43 @@ import com.rainy.token.ui.webview.WebViewLoginScreen
 object Routes {
     const val DASHBOARD = "dashboard"
     const val SETTINGS = "settings"
+    const val API_MANAGEMENT = "api_management"
     const val TIPS = "tips"
     const val DEBUG_LOG = "debug_log"
     const val CODEX_OAUTH = "codex_oauth"
-    const val CREDENTIAL_EDIT = "credential_edit/{type}"
-    fun credentialEdit(type: ServiceType) = "credential_edit/${type.name}"
-    const val WEBVIEW_LOGIN = "webview_login/{type}"
-    fun webviewLogin(type: ServiceType) = "webview_login/${type.name}"
-    const val SERVICE_DETAIL = "service/{type}"
-    fun serviceDetail(type: ServiceType) = "service/${type.name}"
+    const val CREDENTIAL_EDIT = "credential_edit/{type}?account={account}"
+    fun credentialEdit(type: ServiceType, accountId: String? = null): String =
+        if (accountId.isNullOrBlank()) {
+            "credential_edit/${type.name}"
+        } else {
+            "credential_edit/${type.name}?account=${Uri.encode(accountId)}"
+        }
+    const val ACCOUNTS = "accounts/{type}"
+    fun accounts(type: ServiceType) = "accounts/${type.name}"
+    const val WEBVIEW_LOGIN = "webview_login/{type}?account={account}"
+    fun webviewLogin(type: ServiceType, accountId: String? = null): String =
+        if (accountId.isNullOrBlank()) {
+            "webview_login/${type.name}"
+        } else {
+            "webview_login/${type.name}?account=${Uri.encode(accountId)}"
+        }
+    const val WEBVIEW_PAGE = "webview_page?url={url}&title={title}"
+    fun webviewPage(url: String, title: String) =
+        "webview_page?url=${Uri.encode(url)}&title=${Uri.encode(title)}"
+    const val SERVICE_DETAIL = "service/{type}?account={account}"
+    fun serviceDetail(type: ServiceType, accountId: String? = null): String =
+        if (accountId.isNullOrBlank()) {
+            "service/${type.name}"
+        } else {
+            "service/${type.name}?account=${Uri.encode(accountId)}"
+        }
     const val USAGE_DETAIL = "usage_detail"
     const val USAGE_OVERVIEW = "usage_overview"
     const val USAGE_DATA = "usage_data"
     const val CCGO_USAGE_DETAIL = "ccgo_usage_detail"
     const val CCGO_USAGE_OVERVIEW = "ccgo_usage_overview"
     const val CCGO_USAGE_DATA = "ccgo_usage_data"
+    const val HEATMAP = "heatmap"
 }
 
 private fun parseServiceType(typeName: String?): ServiceType =
@@ -88,12 +121,20 @@ private fun parseServiceType(typeName: String?): ServiceType =
         ServiceType.fromStorageKey(it) ?: runCatching { ServiceType.valueOf(it) }.getOrNull()
     } ?: ServiceType.DEEPSEEK
 
+/** 凭据入口：多账号服务先进账号管理页，其余直达凭据编辑页。 */
+private fun credentialEntry(type: ServiceType): String =
+    if (ServiceType.isMultiAccount(type)) Routes.accounts(type) else Routes.credentialEdit(type)
+
 private sealed class DetailPane {
     object Empty : DetailPane()
-    data class ServiceDetail(val type: ServiceType) : DetailPane()
+    data class ServiceDetail(val type: ServiceType, val accountId: String? = null) : DetailPane()
     object OCGOUsage : DetailPane()
     object CCGOUsage : DetailPane()
     object Settings : DetailPane()
+    object ApiManagement : DetailPane()
+    object Heatmap : DetailPane()
+    /** 通用外部页面（充值/订阅页），App 内 WebView 打开。 */
+    data class WebPage(val url: String, val title: String) : DetailPane()
 }
 
 @Composable
@@ -185,11 +226,33 @@ private fun CompactNavHost() {
         }
     ) {
         composable(Routes.DASHBOARD) {
+            val rechargeLabel = stringResource(R.string.action_recharge)
             DashboardScreen(
                 onOpenSettings = { navController.navigate(Routes.SETTINGS) },
-                onOpenService = { type -> navController.navigate(Routes.serviceDetail(type)) },
+                onOpenApiManagement = { navController.navigate(Routes.API_MANAGEMENT) },
+                onOpenService = { type, accountId ->
+                    navController.navigate(Routes.serviceDetail(type, accountId))
+                },
                 onOpenUsageDetail = { navController.navigate(Routes.USAGE_DETAIL) },
-                onOpenCcgoUsageDetail = { navController.navigate(Routes.CCGO_USAGE_DETAIL) }
+                onOpenCcgoUsageDetail = { navController.navigate(Routes.CCGO_USAGE_DETAIL) },
+                onOpenHeatmap = { navController.navigate(Routes.HEATMAP) },
+                onOpenRecharge = { type ->
+                    ServiceConfigProvider.get(type).externalUrl?.let { url ->
+                        navController.navigate(Routes.webviewPage(url, rechargeLabel))
+                    }
+                }
+            )
+        }
+        composable(Routes.API_MANAGEMENT) {
+            val rechargeLabel = stringResource(R.string.action_recharge)
+            ApiManagementScreen(
+                onBack = guardedPop,
+                onConfigure = { type -> navController.navigate(credentialEntry(type)) },
+                onRecharge = { type ->
+                    ServiceConfigProvider.get(type).externalUrl?.let { url ->
+                        navController.navigate(Routes.webviewPage(url, rechargeLabel))
+                    }
+                }
             )
         }
         composable(Routes.USAGE_DETAIL) {
@@ -248,11 +311,22 @@ private fun CompactNavHost() {
         composable(Routes.SETTINGS) {
             SettingsScreen(
                 onBack = guardedPop,
-                onEditCredential = { type -> navController.navigate(Routes.credentialEdit(type)) },
+                onEditCredential = { type -> navController.navigate(credentialEntry(type)) },
+                onManageAccounts = { type -> navController.navigate(Routes.accounts(type)) },
                 onOpenTips = { navController.navigate(Routes.TIPS) },
                 onOpenDebugLog = { navController.navigate(Routes.DEBUG_LOG) }
             )
         }
+        composable(Routes.ACCOUNTS) { backStackEntry ->
+            val type = parseServiceType(backStackEntry.arguments?.getString("type"))
+            AccountManagementScreen(
+                service = type,
+                onBack = guardedPop,
+                onEditAccount = { svc, accountId ->
+                    navController.navigate(Routes.credentialEdit(svc, accountId))
+                }
+            )
+        }
         composable(Routes.TIPS) {
             TipsScreen(onBack = guardedPop)
         }
@@ -267,40 +341,104 @@ private fun CompactNavHost() {
         }
         composable(
             route = Routes.CREDENTIAL_EDIT,
-            arguments = listOf(navArgument("type") { type = NavType.StringType })
+            arguments = listOf(
+                navArgument("type") { type = NavType.StringType },
+                navArgument("account") {
+                    type = NavType.StringType
+                    nullable = true
+                    defaultValue = null
+                }
+            )
         ) { backStackEntry ->
             val type = parseServiceType(backStackEntry.arguments?.getString("type"))
+            val accountId = backStackEntry.arguments?.getString("account")
             CredentialEditScreen(
                 service = type,
+                accountId = accountId,
                 onBack = guardedPop,
-                onStartWebViewLogin = { service -> navController.navigate(Routes.webviewLogin(service)) },
+                onStartWebViewLogin = { svc, acc -> navController.navigate(Routes.webviewLogin(svc, acc)) },
                 onWebViewLoginSuccess = { },
                 onStartCodexOAuth = { navController.navigate(Routes.CODEX_OAUTH) }
             )
         }
         composable(
             route = Routes.WEBVIEW_LOGIN,
-            arguments = listOf(navArgument("type") { type = NavType.StringType })
+            arguments = listOf(
+                navArgument("type") { type = NavType.StringType },
+                navArgument("account") {
+                    type = NavType.StringType
+                    nullable = true
+                    defaultValue = null
+                }
+            )
         ) { backStackEntry ->
             val type = parseServiceType(backStackEntry.arguments?.getString("type"))
+            val accountId = backStackEntry.arguments?.getString("account")
             WebViewLoginScreen(
                 service = type,
+                accountId = accountId,
                 onBack = guardedPop,
-                onLoginSucceeded = { guardedPop() }
+                onLoginSucceeded = { _, effectiveId ->
+                    // 把实际写入的账号 ID 回传给上一层（凭据编辑页），新建账号模式用于回填
+                    if (!effectiveId.isNullOrBlank()) {
+                        navController.previousBackStackEntry?.savedStateHandle?.set(
+                            CredentialEditViewModel.KEY_LOGIN_ACCOUNT_ID, effectiveId
+                        )
+                    }
+                    // 登录成功后返回上一层（详情页或凭据编辑页），由 ON_RESUME 刷新内容
+                    if (!navController.popBackStack(Routes.SERVICE_DETAIL, inclusive = false)) {
+                        guardedPop()
+                    }
+                }
             )
         }
         composable(
             route = Routes.SERVICE_DETAIL,
-            arguments = listOf(navArgument("type") { type = NavType.StringType })
+            arguments = listOf(
+                navArgument("type") { type = NavType.StringType },
+                navArgument("account") {
+                    type = NavType.StringType
+                    nullable = true
+                    defaultValue = null
+                }
+            )
         ) { backStackEntry ->
             val type = parseServiceType(backStackEntry.arguments?.getString("type"))
+            val accountId = backStackEntry.arguments?.getString("account")
+            val rechargeLabel = stringResource(R.string.action_recharge)
             ServiceDetailScreen(
                 service = type,
+                accountId = accountId,
                 onBack = guardedPop,
-                onConfigureCredential = { svc -> navController.navigate(Routes.credentialEdit(svc)) },
-                onStartWebViewLogin = { svc -> navController.navigate(Routes.webviewLogin(svc)) }
+                onSwitchAccount = { svc, acc ->
+                    // 切换账号时替换当前详情页（避免同路由栈堆积）
+                    navController.navigate(Routes.serviceDetail(svc, acc)) {
+                        popUpTo(Routes.SERVICE_DETAIL) { inclusive = true }
+                    }
+                },
+                onConfigureCredential = { svc -> navController.navigate(credentialEntry(svc)) },
+                onStartWebViewLogin = { svc, acc -> navController.navigate(Routes.webviewLogin(svc, acc)) },
+                onOpenRecharge = { svc ->
+                    ServiceConfigProvider.get(svc).externalUrl?.let { url ->
+                        navController.navigate(Routes.webviewPage(url, rechargeLabel))
+                    }
+                }
             )
         }
+        composable(
+            route = Routes.WEBVIEW_PAGE,
+            arguments = listOf(
+                navArgument("url") { type = NavType.StringType },
+                navArgument("title") { type = NavType.StringType }
+            )
+        ) { backStackEntry ->
+            val url = backStackEntry.arguments?.getString("url").orEmpty()
+            val title = backStackEntry.arguments?.getString("title").orEmpty()
+            WebViewPageScreen(url = url, title = title, onBack = guardedPop)
+        }
+        composable(Routes.HEATMAP) {
+            HeatmapScreen(onBack = guardedPop)
+        }
     }
 }
 
@@ -323,6 +461,8 @@ private fun ExpandedLayout() {
         prevPane = detailPane
     }
 
+    val rechargeLabel = stringResource(R.string.action_recharge)
+
     Row(modifier = Modifier.fillMaxSize()) {
         Box(
             modifier = Modifier
@@ -331,9 +471,18 @@ private fun ExpandedLayout() {
         ) {
             DashboardScreen(
                 onOpenSettings = { detailPane = DetailPane.Settings },
-                onOpenService = { type -> detailPane = DetailPane.ServiceDetail(type) },
+                onOpenApiManagement = { detailPane = DetailPane.ApiManagement },
+                onOpenService = { type, accountId ->
+                    detailPane = DetailPane.ServiceDetail(type, accountId)
+                },
                 onOpenUsageDetail = { detailPane = DetailPane.OCGOUsage },
                 onOpenCcgoUsageDetail = { detailPane = DetailPane.CCGOUsage },
+                onOpenHeatmap = { detailPane = DetailPane.Heatmap },
+                onOpenRecharge = { type ->
+                    ServiceConfigProvider.get(type).externalUrl?.let { url ->
+                        detailPane = DetailPane.WebPage(url = url, title = rechargeLabel)
+                    }
+                },
                 viewModel = dashboardVm
             )
         }
@@ -352,6 +501,9 @@ private fun ExpandedLayout() {
             ExpandedDetailPane(
                 pane = detailPane,
                 onClose = { detailPane = DetailPane.Empty },
+                onSwitchAccount = { svc, acc ->
+                    detailPane = DetailPane.ServiceDetail(svc, acc)
+                },
                 onCredentialEditClosed = { dashboardVm.reloadLocalState() }
             )
         }
@@ -362,24 +514,58 @@ private fun ExpandedLayout() {
 private fun ExpandedDetailPane(
     pane: DetailPane,
     onClose: () -> Unit,
+    onSwitchAccount: (ServiceType, String?) -> Unit = { _, _ -> },
     onCredentialEditClosed: () -> Unit = {}
 ) {
     when (pane) {
         is DetailPane.Empty -> {
             Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
                 Column(horizontalAlignment = Alignment.CenterHorizontally) {
-                    Text("👈 选择服务查看详情", style = MaterialTheme.typography.titleMedium, color = inkMuted())
-                    Text("点击左侧卡片即可", style = MaterialTheme.typography.bodySmall, color = inkMuted())
+                    Text(stringResource(R.string.nav_empty_title), style = MaterialTheme.typography.titleMedium, color = inkMuted())
+                    Text(stringResource(R.string.nav_empty_subtitle), style = MaterialTheme.typography.bodySmall, color = inkMuted())
                 }
             }
         }
         is DetailPane.ServiceDetail -> {
-            ServiceDetailScreen(
-                service = pane.type,
-                onBack = onClose,
-                onConfigureCredential = { onClose() },
-                onStartWebViewLogin = { }
-            )
+            // key(pane.type + accountId)：切换服务/账号时重建嵌套导航栈，避免停留在上一个页面
+            key("${pane.type.name}:${pane.accountId.orEmpty()}") {
+                val navController = rememberNavController()
+            NavHost(
+                navController = navController,
+                startDestination = "detail",
+                popExitTransition = { ExitTransition.None }
+            ) {
+                composable("detail") {
+                    val rechargeLabel = LocalContext.current.getString(R.string.action_recharge)
+                    ServiceDetailScreen(
+                        service = pane.type,
+                        accountId = pane.accountId,
+                        onBack = onClose,
+                        onSwitchAccount = onSwitchAccount,
+                        onConfigureCredential = { onClose() },
+                        onStartWebViewLogin = { _, _ -> },
+                        onOpenRecharge = { svc ->
+                            ServiceConfigProvider.get(svc).externalUrl?.let { url ->
+                                navController.navigate(Routes.webviewPage(url, rechargeLabel))
+                            }
+                        }
+                    )
+                }
+                composable(
+                    route = Routes.WEBVIEW_PAGE,
+                    arguments = listOf(
+                        navArgument("url") { type = NavType.StringType },
+                        navArgument("title") { type = NavType.StringType }
+                    )
+                ) { entry ->
+                    WebViewPageScreen(
+                        url = entry.arguments?.getString("url").orEmpty(),
+                        title = entry.arguments?.getString("title").orEmpty(),
+                        onBack = { navController.popBackStack() }
+                    )
+                }
+                }
+            }
         }
         is DetailPane.OCGOUsage -> {
             val navController = rememberNavController()
@@ -440,6 +626,127 @@ private fun ExpandedDetailPane(
                 }
             }
         }
+        is DetailPane.Heatmap -> {
+            HeatmapScreen(onBack = onClose)
+        }
+        is DetailPane.WebPage -> {
+            WebViewPageScreen(
+                url = pane.url,
+                title = pane.title,
+                onBack = onClose
+            )
+        }
+        is DetailPane.ApiManagement -> {
+            val apiNavController = rememberNavController()
+            // 从凭据编辑/WebView 返回到 api_mgmt_main 时刷新 Dashboard 凭据状态
+            val routeStack by apiNavController.currentBackStackEntryAsState()
+            val currentRoute = routeStack?.destination?.route
+            var prevRoute by remember { mutableStateOf("api_mgmt_main") }
+            LaunchedEffect(currentRoute) {
+                if (prevRoute != currentRoute && currentRoute == "api_mgmt_main") {
+                    onCredentialEditClosed()
+                }
+                prevRoute = currentRoute ?: "api_mgmt_main"
+            }
+            NavHost(
+                navController = apiNavController,
+                startDestination = "api_mgmt_main",
+                popExitTransition = { ExitTransition.None }
+            ) {
+                composable("api_mgmt_main") {
+                    val rechargeLabel = LocalContext.current.getString(R.string.action_recharge)
+                    ApiManagementScreen(
+                        onBack = onClose,
+                        onConfigure = { type -> apiNavController.navigate(credentialEntry(type)) },
+                        onRecharge = { type ->
+                            ServiceConfigProvider.get(type).externalUrl?.let { url ->
+                                apiNavController.navigate(Routes.webviewPage(url, rechargeLabel))
+                            }
+                        }
+                    )
+                }
+                composable(Routes.ACCOUNTS) { entry ->
+                    val type = parseServiceType(entry.arguments?.getString("type"))
+                    AccountManagementScreen(
+                        service = type,
+                        onBack = { apiNavController.popBackStack() },
+                        onEditAccount = { svc, accountId ->
+                            apiNavController.navigate(Routes.credentialEdit(svc, accountId))
+                        }
+                    )
+                }
+                composable(
+                    route = Routes.CREDENTIAL_EDIT,
+                    arguments = listOf(
+                        navArgument("type") { type = NavType.StringType },
+                        navArgument("account") {
+                            type = NavType.StringType
+                            nullable = true
+                            defaultValue = null
+                        }
+                    )
+                ) { entry ->
+                    val type = parseServiceType(entry.arguments?.getString("type"))
+                    val accountId = entry.arguments?.getString("account")
+                    CredentialEditScreen(
+                        service = type,
+                        accountId = accountId,
+                        onBack = { apiNavController.popBackStack() },
+                        onStartWebViewLogin = { svc, acc ->
+                            apiNavController.navigate(Routes.webviewLogin(svc, acc))
+                        },
+                        onWebViewLoginSuccess = { },
+                        onStartCodexOAuth = { apiNavController.navigate(Routes.CODEX_OAUTH) }
+                    )
+                }
+                composable(
+                    route = Routes.WEBVIEW_LOGIN,
+                    arguments = listOf(
+                        navArgument("type") { type = NavType.StringType },
+                        navArgument("account") {
+                            type = NavType.StringType
+                            nullable = true
+                            defaultValue = null
+                        }
+                    )
+                ) { entry ->
+                    val type = parseServiceType(entry.arguments?.getString("type"))
+                    val accountId = entry.arguments?.getString("account")
+                    WebViewLoginScreen(
+                        service = type,
+                        accountId = accountId,
+                        onBack = { apiNavController.popBackStack() },
+                        onLoginSucceeded = { _, effectiveId ->
+                            if (!effectiveId.isNullOrBlank()) {
+                                apiNavController.previousBackStackEntry?.savedStateHandle?.set(
+                                    CredentialEditViewModel.KEY_LOGIN_ACCOUNT_ID, effectiveId
+                                )
+                            }
+                            apiNavController.popBackStack()
+                        }
+                    )
+                }
+                composable(Routes.CODEX_OAUTH) {
+                    CodexOAuthScreen(
+                        onBack = { apiNavController.popBackStack() },
+                        onSuccess = { apiNavController.popBackStack() }
+                    )
+                }
+                composable(
+                    route = Routes.WEBVIEW_PAGE,
+                    arguments = listOf(
+                        navArgument("url") { type = NavType.StringType },
+                        navArgument("title") { type = NavType.StringType }
+                    )
+                ) { entry ->
+                    WebViewPageScreen(
+                        url = entry.arguments?.getString("url").orEmpty(),
+                        title = entry.arguments?.getString("title").orEmpty(),
+                        onBack = { apiNavController.popBackStack() }
+                    )
+                }
+            }
+        }
         is DetailPane.Settings -> {
             val settingsNavController = rememberNavController()
             // 监听嵌套 NavHost 路由变化：当从凭据编辑页/WebView 返回 settings_main 时
@@ -462,12 +769,25 @@ private fun ExpandedDetailPane(
                     SettingsScreen(
                         onBack = onClose,
                         onEditCredential = { type ->
-                            settingsNavController.navigate(Routes.credentialEdit(type))
+                            settingsNavController.navigate(credentialEntry(type))
+                        },
+                        onManageAccounts = { type ->
+                            settingsNavController.navigate(Routes.accounts(type))
                         },
                         onOpenTips = { settingsNavController.navigate("tips") },
                         onOpenDebugLog = { settingsNavController.navigate("debug_log") }
                     )
                 }
+                composable(Routes.ACCOUNTS) { entry ->
+                    val type = parseServiceType(entry.arguments?.getString("type"))
+                    AccountManagementScreen(
+                        service = type,
+                        onBack = { settingsNavController.popBackStack() },
+                        onEditAccount = { svc, accountId ->
+                            settingsNavController.navigate(Routes.credentialEdit(svc, accountId))
+                        }
+                    )
+                }
                 composable("tips") {
                     TipsScreen(onBack = { settingsNavController.popBackStack() })
                 }
@@ -482,14 +802,23 @@ private fun ExpandedDetailPane(
                 }
                 composable(
                     route = Routes.CREDENTIAL_EDIT,
-                    arguments = listOf(navArgument("type") { type = NavType.StringType })
+                    arguments = listOf(
+                        navArgument("type") { type = NavType.StringType },
+                        navArgument("account") {
+                            type = NavType.StringType
+                            nullable = true
+                            defaultValue = null
+                        }
+                    )
                 ) { entry ->
                     val type = parseServiceType(entry.arguments?.getString("type"))
+                    val accountId = entry.arguments?.getString("account")
                     CredentialEditScreen(
                         service = type,
+                        accountId = accountId,
                         onBack = { settingsNavController.popBackStack() },
-                        onStartWebViewLogin = { svc ->
-                            settingsNavController.navigate(Routes.webviewLogin(svc))
+                        onStartWebViewLogin = { svc, acc ->
+                            settingsNavController.navigate(Routes.webviewLogin(svc, acc))
                         },
                         onWebViewLoginSuccess = { },
                         onStartCodexOAuth = { settingsNavController.navigate(Routes.CODEX_OAUTH) }
@@ -497,13 +826,29 @@ private fun ExpandedDetailPane(
                 }
                 composable(
                     route = Routes.WEBVIEW_LOGIN,
-                    arguments = listOf(navArgument("type") { type = NavType.StringType })
+                    arguments = listOf(
+                        navArgument("type") { type = NavType.StringType },
+                        navArgument("account") {
+                            type = NavType.StringType
+                            nullable = true
+                            defaultValue = null
+                        }
+                    )
                 ) { entry ->
                     val type = parseServiceType(entry.arguments?.getString("type"))
+                    val accountId = entry.arguments?.getString("account")
                     WebViewLoginScreen(
                         service = type,
+                        accountId = accountId,
                         onBack = { settingsNavController.popBackStack() },
-                        onLoginSucceeded = { settingsNavController.popBackStack() }
+                        onLoginSucceeded = { _, effectiveId ->
+                            if (!effectiveId.isNullOrBlank()) {
+                                settingsNavController.previousBackStackEntry?.savedStateHandle?.set(
+                                    CredentialEditViewModel.KEY_LOGIN_ACCOUNT_ID, effectiveId
+                                )
+                            }
+                            settingsNavController.popBackStack()
+                        }
                     )
                 }
             }

app/src/main/java/com/rainy/token/ui/account/ApiManagementScreen.kt

@@ -0,0 +1,442 @@
+package com.rainy.token.ui.account
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.ArrowBack
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Snackbar
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
+import com.rainy.token.domain.model.CredentialStatus
+import com.rainy.token.domain.service.ServiceConfigProvider
+import com.rainy.token.domain.service.ServiceType
+import com.rainy.token.ui.components.ServiceIcon
+import com.rainy.token.ui.components.formatAmount
+import com.rainy.token.ui.components.resolve
+import com.rainy.token.ui.theme.StrawberryPink
+import com.rainy.token.ui.theme.StatusGreen
+import com.rainy.token.ui.theme.StatusOrange
+import com.rainy.token.ui.theme.inkMuted
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+/**
+ * API 管理页（记事本式）。
+ *
+ * 心智模型像记事本：正文只有「已添加」的服务条目，右上角 **+** 从剩余服务里选一个
+ * 添加（进入对应配置流程）；未配置的服务不占卡片。条目点击即编辑，行内提供
+ * 测试连接 / 删除（需确认），有官方充值/订阅页的服务额外给入口。
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun ApiManagementScreen(
+    onBack: () -> Unit,
+    onConfigure: (ServiceType) -> Unit,
+    onRecharge: (ServiceType) -> Unit,
+    viewModel: ApiManagementViewModel = hiltViewModel()
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val message by viewModel.message.collectAsStateWithLifecycle()
+    val testing by viewModel.testing.collectAsStateWithLifecycle()
+    val snackbarHostState = remember { SnackbarHostState() }
+    val context = LocalContext.current
+    var pendingDelete by remember { mutableStateOf<ServiceType?>(null) }
+    var showAddPicker by remember { mutableStateOf(false) }
+
+    LaunchedEffect(message) {
+        message?.let {
+            snackbarHostState.showSnackbar(it.resolve(context))
+            viewModel.clearMessage()
+        }
+    }
+
+    // 从凭据编辑页/WebView/充值页返回时刷新列表（新增/编辑/删除即时可见，覆盖 Compact 与 Expanded）
+    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
+        viewModel.load()
+    }
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(R.string.api_mgmt_title)) },
+                navigationIcon = {
+                    IconButton(onClick = onBack) {
+                        Icon(
+                            Icons.Filled.ArrowBack,
+                            contentDescription = stringResource(R.string.action_back)
+                        )
+                    }
+                },
+                actions = {
+                    IconButton(onClick = { showAddPicker = true }) {
+                        Icon(
+                            imageVector = Icons.Filled.Add,
+                            contentDescription = stringResource(R.string.api_mgmt_add),
+                            tint = StrawberryPink
+                        )
+                    }
+                }
+            )
+        },
+        snackbarHost = { SnackbarHost(snackbarHostState) { data -> Snackbar(snackbarData = data) } }
+    ) { innerPadding ->
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(innerPadding),
+            contentPadding = PaddingValues(16.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp)
+        ) {
+            if (uiState.rows.isEmpty()) {
+                item { EmptyNotesHint(onAdd = { showAddPicker = true }) }
+            }
+            items(uiState.rows, key = { it.service.storageKey }) { row ->
+                ApiRowCard(
+                    row = row,
+                    testing = row.service in testing,
+                    onEdit = { onConfigure(row.service) },
+                    onTest = { viewModel.test(row.service) },
+                    onDelete = { pendingDelete = row.service },
+                    onRecharge = { onRecharge(row.service) }
+                )
+            }
+        }
+    }
+
+    if (showAddPicker) {
+        AddServicePickerDialog(
+            addable = uiState.addable,
+            onPick = { service ->
+                showAddPicker = false
+                onConfigure(service)
+            },
+            onDismiss = { showAddPicker = false }
+        )
+    }
+
+    pendingDelete?.let { service ->
+        AlertDialog(
+            onDismissRequest = { pendingDelete = null },
+            title = { Text(stringResource(R.string.api_mgmt_delete_title)) },
+            text = {
+                Text(stringResource(R.string.api_mgmt_delete_body, service.displayName))
+            },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        viewModel.delete(service)
+                        pendingDelete = null
+                    }
+                ) {
+                    Text(stringResource(R.string.action_delete), color = MaterialTheme.colorScheme.error)
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { pendingDelete = null }) {
+                    Text(stringResource(R.string.action_cancel))
+                }
+            }
+        )
+    }
+}
+
+/** 空态引导：还没有添加任何条目时展示，给出「+ 添加」动作。 */
+@Composable
+private fun EmptyNotesHint(onAdd: () -> Unit) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(20.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(24.dp),
+            horizontalAlignment = Alignment.CenterHorizontally
+        ) {
+            Text(
+                text = stringResource(R.string.api_mgmt_empty_title),
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.SemiBold
+            )
+            Spacer(modifier = Modifier.height(4.dp))
+            Text(
+                text = stringResource(R.string.api_mgmt_empty_body),
+                style = MaterialTheme.typography.bodySmall,
+                color = inkMuted()
+            )
+            Spacer(modifier = Modifier.height(12.dp))
+            Button(
+                onClick = onAdd,
+                colors = ButtonDefaults.buttonColors(
+                    containerColor = StrawberryPink,
+                    contentColor = Color.White
+                )
+            ) {
+                Icon(imageVector = Icons.Filled.Add, contentDescription = null, modifier = Modifier.size(18.dp))
+                Spacer(modifier = Modifier.width(4.dp))
+                Text(stringResource(R.string.api_mgmt_add))
+            }
+        }
+    }
+}
+
+/** 「+ 添加」服务选择弹窗：列出尚未添加的服务，点选即进入配置流程。 */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun AddServicePickerDialog(
+    addable: List<ServiceType>,
+    onPick: (ServiceType) -> Unit,
+    onDismiss: () -> Unit
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.api_mgmt_add_picker_title)) },
+        text = {
+            if (addable.isEmpty()) {
+                Text(
+                    text = stringResource(R.string.api_mgmt_all_added),
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = inkMuted()
+                )
+            } else {
+                LazyColumn(
+                    modifier = Modifier.heightIn(max = 320.dp),
+                    verticalArrangement = Arrangement.spacedBy(4.dp)
+                ) {
+                    items(addable, key = { it.storageKey }) { service ->
+                        Row(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .clip(RoundedCornerShape(12.dp))
+                                .clickable { onPick(service) }
+                                .padding(vertical = 8.dp, horizontal = 4.dp),
+                            verticalAlignment = Alignment.CenterVertically
+                        ) {
+                            ServiceIcon(service = service, size = 36)
+                            Spacer(modifier = Modifier.width(12.dp))
+                            Column(modifier = Modifier.weight(1f)) {
+                                Text(
+                                    text = service.displayName,
+                                    style = MaterialTheme.typography.bodyLarge
+                                )
+                                Text(
+                                    text = stringResource(serviceDescriptionRes(service)),
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = inkMuted()
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onDismiss) {
+                Text(stringResource(R.string.action_cancel))
+            }
+        }
+    )
+}
+
+/** 添加弹窗里的服务一句话说明（与首页卡片副标题同源，保持口径一致）。 */
+@Composable
+private fun serviceDescriptionRes(service: ServiceType): Int = when (service) {
+    ServiceType.DEEPSEEK -> R.string.service_desc_deepseek
+    ServiceType.OPENCODE_GO -> R.string.service_desc_opencode_go
+    ServiceType.COMMANDCODE_GO -> R.string.service_desc_commandcode_go
+    ServiceType.CODEX -> R.string.service_desc_codex
+    ServiceType.OLLAMA -> R.string.service_desc_ollama
+    ServiceType.TRAE -> R.string.service_desc_trae
+    ServiceType.WORKBUDDY -> R.string.service_desc_workbuddy
+    ServiceType.SUB2API -> R.string.service_desc_sub2api
+}
+
+/** 已添加条目卡：整卡点击进编辑，行内给测试 / 删除，有官方充值页的服务附充值按钮。 */
+@Composable
+private fun ApiRowCard(
+    row: ApiRowUi,
+    testing: Boolean,
+    onEdit: () -> Unit,
+    onTest: () -> Unit,
+    onDelete: () -> Unit,
+    onRecharge: () -> Unit
+) {
+    // 有官方充值/订阅页的服务（ServiceConfig.externalUrl）才展示充值入口
+    val rechargeUrl = remember(row.service) {
+        runCatching { ServiceConfigProvider.get(row.service).externalUrl }.getOrNull()
+    }
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable { onEdit() },
+        shape = RoundedCornerShape(20.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+    ) {
+        Column(modifier = Modifier.padding(16.dp)) {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                ServiceIcon(service = row.service, size = 44)
+                Spacer(modifier = Modifier.width(12.dp))
+                Column(modifier = Modifier.weight(1f)) {
+                    Text(
+                        text = row.service.displayName,
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.SemiBold
+                    )
+                    Text(
+                        text = if (row.isMultiAccountRow) {
+                            stringResource(R.string.api_mgmt_accounts_subtitle, row.accountCount)
+                        } else {
+                            row.maskedCredential ?: stringResource(R.string.api_mgmt_unconfigured)
+                        },
+                        style = MaterialTheme.typography.bodySmall,
+                        color = inkMuted()
+                    )
+                }
+                Spacer(modifier = Modifier.width(8.dp))
+                StatusDot(state = row.state)
+            }
+
+            Spacer(modifier = Modifier.height(10.dp))
+
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                // 最后验证时间 / 缓存余额
+                Column(modifier = Modifier.weight(1f)) {
+                    Text(
+                        text = stringResource(R.string.api_mgmt_last_verified, formatVerified(row.lastVerifiedAt)),
+                        style = MaterialTheme.typography.labelSmall,
+                        color = inkMuted()
+                    )
+                    row.cachedBalance?.let { cached ->
+                        Spacer(modifier = Modifier.height(2.dp))
+                        Text(
+                            text = stringResource(
+                                R.string.api_mgmt_cached_balance,
+                                formatAmount(cached.balance.amount),
+                                cached.balance.unit
+                            ),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurface
+                        )
+                    }
+                }
+                Spacer(modifier = Modifier.width(8.dp))
+                // 测试连接（进行中转圈）+ 删除；多账号服务行内不提供（避免只对默认账号操作 / 误删全部账号）
+                if (!row.isMultiAccountRow) {
+                    if (testing) {
+                        CircularProgressIndicator(
+                            modifier = Modifier.size(20.dp),
+                            color = StrawberryPink,
+                            strokeWidth = 2.dp
+                        )
+                    } else {
+                        TextButton(onClick = onTest) {
+                            Text(
+                                stringResource(R.string.api_mgmt_test),
+                                maxLines = 1,
+                                overflow = TextOverflow.Ellipsis
+                            )
+                        }
+                    }
+                    IconButton(onClick = onDelete) {
+                        Icon(
+                            imageVector = Icons.Filled.Delete,
+                            contentDescription = stringResource(R.string.action_delete),
+                            tint = MaterialTheme.colorScheme.error
+                        )
+                    }
+                }
+                if (rechargeUrl != null) {
+                    TextButton(onClick = onRecharge) {
+                        Text(
+                            stringResource(R.string.action_recharge),
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun StatusDot(state: CredentialStatus.State) {
+    val color = when (state) {
+        CredentialStatus.State.OK -> StatusGreen
+        CredentialStatus.State.WARNING -> StatusOrange
+        CredentialStatus.State.EXPIRED -> MaterialTheme.colorScheme.error
+        CredentialStatus.State.NOT_CONFIGURED -> inkMuted().copy(alpha = 0.5f)
+    }
+    Box(
+        modifier = Modifier
+            .size(10.dp)
+            .clip(RoundedCornerShape(50))
+            .background(color = color)
+    )
+}
+
+private fun formatVerified(ts: Long): String {
+    if (ts <= 0L) return "—"
+    return runCatching {
+        SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.getDefault()).format(Date(ts))
+    }.getOrDefault("—")
+}

app/src/main/java/com/rainy/token/ui/account/ApiManagementViewModel.kt

@@ -0,0 +1,174 @@
+package com.rainy.token.ui.account
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.rainy.token.data.cache.CachedBalance
+import com.rainy.token.data.repository.CredentialRepository
+import com.rainy.token.data.repository.RepositoryError
+import com.rainy.token.domain.model.Credential
+import com.rainy.token.domain.model.CredentialStatus
+import com.rainy.token.domain.service.ServiceType
+import com.rainy.token.domain.usecase.RefreshBalanceUseCase
+import com.rainy.token.ui.components.UiText
+import com.rainy.token.ui.components.formatAmount
+import com.rainy.token.R
+import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+/**
+ * API 管理页 ViewModel（记事本式）。
+ *
+ * 列表只展示「已添加」的凭据条目（Key 掩码、最后验证、缓存余额），
+ * 未配置的服务不占位；右上角 + 从 [addable] 里选服务新增。
+ * 提供测试连接 / 删除操作，编辑走既有 credential_edit 页面。
+ */
+@HiltViewModel
+class ApiManagementViewModel @Inject constructor(
+    private val credentialRepository: CredentialRepository,
+    private val refreshBalanceUseCase: RefreshBalanceUseCase
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow(ApiManagementUiState())
+    val uiState: StateFlow<ApiManagementUiState> = _uiState.asStateFlow()
+
+    private val _message = MutableStateFlow<UiText?>(null)
+    val message: StateFlow<UiText?> = _message
+
+    /** 正在测试连接的服务集合（支持并发多测，各自独立转圈）。 */
+    private val _testing = MutableStateFlow<Set<ServiceType>>(emptySet())
+    val testing: StateFlow<Set<ServiceType>> = _testing
+
+    init {
+        load()
+    }
+
+    fun load() {
+        viewModelScope.launch {
+            val states = credentialRepository.readLocalStates()
+            val all = ServiceType.entries.map { type ->
+                val local = states.getValue(type)
+                val cred = credentialRepository.get(type)
+                ApiRowUi(
+                    service = type,
+                    state = local.status.state,
+                    lastVerifiedAt = local.status.lastVerifiedAt,
+                    cachedBalance = local.cachedBalance,
+                    maskedCredential = maskCredential(cred),
+                    accountCount = if (ServiceType.isMultiAccount(type)) {
+                        credentialRepository.accountsFor(type).size
+                    } else {
+                        0
+                    }
+                )
+            }
+            _uiState.update {
+                it.copy(
+                    // 记事本式：列表只放已添加的条目，未配置的服务收进「+」选择列表
+                    rows = all.filter { row -> row.isConfigured },
+                    addable = all.filterNot { row -> row.isConfigured }.map { row -> row.service }
+                )
+            }
+        }
+    }
+
+    fun delete(service: ServiceType) {
+        viewModelScope.launch {
+            credentialRepository.remove(service)
+            _message.value = UiText.Resource(R.string.msg_credential_deleted)
+            load()
+        }
+    }
+
+    /**
+     * 测试连接：拉一次余额并回应用户；成功/失败只透传摘要（本地化），不改动凭据之外的东西。
+     */
+    fun test(service: ServiceType) {
+        _testing.update { it + service }
+        viewModelScope.launch {
+            val text: UiText = refreshBalanceUseCase(service).fold(
+                onSuccess = { bal ->
+                    UiText.Resource(
+                        R.string.api_mgmt_test_success,
+                        listOf(service.displayName, formatAmount(bal.amount), bal.unit)
+                    )
+                },
+                onFailure = { err ->
+                    // errorSummary 返回 UiText，resolve 会把嵌套 UiText 参数扁平化本地化
+                    UiText.Resource(
+                        R.string.api_mgmt_test_fail,
+                        listOf(service.displayName, errorSummary(err))
+                    )
+                }
+            )
+            _testing.update { it - service }
+            _message.value = text
+            load()
+        }
+    }
+
+    fun clearMessage() {
+        _message.value = null
+    }
+
+    /** 把凭据的核心值打成掩码（前1后1/中间星号）；无凭据返回 null。 */
+    private fun maskCredential(credential: Credential?): String? = when (credential) {
+        null -> null
+        is Credential.ApiKeyCredential -> mask(credential.key)
+        is Credential.SessionCredential -> {
+            credential.apiKey?.let { mask(it) }
+                ?: credential.token?.let { mask(it) }
+                ?: credential.authCookie?.let { mask(it) }
+                ?: credential.cookies.firstOrNull()?.let { mask("${it.name}=${it.value}") }
+                ?: credential.ollamaCookie?.take(8)?.let { mask(it) }
+        }
+        is Credential.CodexCredential -> mask(credential.accessToken)
+        is Credential.TraeCredential -> mask(credential.jwt)
+        is Credential.WorkBuddyCredential -> mask(credential.accessToken)
+        // Sub2API：显示实例基址作为身份标识（非机密），便于区分多个自托管实例；
+        // 真正的机密（password/apiKey）不做掩码展示。
+        is Credential.Sub2ApiCredential -> credential.baseUrl
+    }
+
+    private fun mask(value: String): String {
+        if (value.length <= 8) return "••••"
+        return "${value.take(4)}••••${value.takeLast(4)}"
+    }
+
+    private fun errorSummary(error: Throwable?): UiText = when (error) {
+        is RepositoryError.SessionExpired -> UiText.Resource(R.string.error_credential_session_expired)
+        is RepositoryError.InvalidCredential -> UiText.Resource(R.string.api_mgmt_err_invalid)
+        is RepositoryError.CredentialChanged -> UiText.Resource(R.string.api_mgmt_err_changed)
+        is RepositoryError.RateLimited -> UiText.Resource(R.string.api_mgmt_err_ratelimited)
+        is RepositoryError.Network -> UiText.Resource(R.string.api_mgmt_err_network)
+        is RepositoryError.ServerError -> UiText.Resource(R.string.api_mgmt_err_server, listOf(error.code))
+        is RepositoryError.ParseError -> UiText.Resource(R.string.api_mgmt_err_parse)
+        else -> UiText.Resource(R.string.common_unknown)
+    }
+}
+
+data class ApiRowUi(
+    val service: ServiceType,
+    val state: CredentialStatus.State,
+    val lastVerifiedAt: Long,
+    val cachedBalance: CachedBalance?,
+    val maskedCredential: String?,
+    /** 多账号服务的账号个数；单账号服务为 0。 */
+    val accountCount: Int = 0
+) {
+    val isConfigured: Boolean get() = state != CredentialStatus.State.NOT_CONFIGURED
+
+    /** 多账号服务且已有账号：行内不提供单服务的测试/删除，引导去账号管理页。 */
+    val isMultiAccountRow: Boolean get() = ServiceType.isMultiAccount(service) && accountCount > 0
+}
+
+data class ApiManagementUiState(
+    /** 已添加的凭据条目（记事本正文）。 */
+    val rows: List<ApiRowUi> = emptyList(),
+    /** 尚未添加的服务（右上角 + 的可选列表）。 */
+    val addable: List<ServiceType> = emptyList()
+)

app/src/main/java/com/rainy/token/ui/components/AppTips.kt

@@ -28,44 +28,50 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
+import androidx.annotation.StringRes
+import com.rainy.token.R
 import com.rainy.token.ui.theme.InkMuted
 import com.rainy.token.ui.theme.StrawberryPink
 
 /**
  * APP 使用小技巧列表。
  * Dashboard 卡片上方随机展示一条，设置页可查看全部。
+ *
+ * 文案全部改为字符串资源 ID（@StringRes），由 UI 层按当前语言环境解析，
+ * 保证英文系统下自动显示英文翻译。
  */
 object AppTips {
 
     data class Tip(
-        val title: String,
-        val hint: String,
-        val detail: String
+        @StringRes val titleRes: Int,
+        @StringRes val hintRes: Int,
+        @StringRes val detailRes: Int
     )
 
     val tips: List<Tip> = listOf(
-        Tip("长按卡片拖拽排序", "长按首页卡片可以拖拽排序", "在首页长按任意服务卡片即可拖拽到想要的位置，排序会自动保存。"),
-        Tip("小组件点左上角进 APP", "小组件左上角标识可打开 APP", "桌面小组件左上角 RainyToken › 标识可以点击打开应用，其它区域点击切换服务。"),
-        Tip("图表点击查看详情", "点击图表柱子可查看时段详情", "在用量图表上点击或滑动手指，可查看对应时段的详细数值。"),
-        Tip("图表标题可点击", "点击图表标题弹出按模型明细", "图表卡片标题（如「消耗金额」）点击后会弹出按模型拆分的明细。"),
-        Tip("切换图表时区", "用量详情页可切换 UTC+0 / UTC+8", "用量详情页顶部可切换 UTC+0 / UTC+8，图表标签会跟随切换。"),
-        Tip("CCGO 清除并重新同步", "CCGO 详情页可清除缓存重新同步", "CCGO 用量详情页右上角「清除」可删除本地缓存并重新拉取全部数据。"),
-        Tip("查看用量详情", "服务卡片底部可进入用量图表", "有凭据的服务卡片底部会出现「查看用量详情」入口，点击进入图表统计。"),
-        Tip("原始数据浏览", "用量详情页右上角可查看原始记录", "用量详情页右上角「详细数据」可查看每条原始调用记录，支持分页跳转。"),
-        Tip("下拉刷新联动用量", "下拉刷新会同步余额和用量", "首页下拉刷新不仅刷新余额，还会自动同步 OCGO / CCGO 用量记录。"),
-        Tip("凭据获取教程", "凭据页底部有获取教程", "凭据编辑页底部的「如何获取」按钮有针对每个服务的详细操作步骤。"),
-        Tip("剪贴板自动导入", "Codex 支持从剪贴板一键导入", "Codex 凭据页支持「从剪贴板自动导入」，粘贴 auth.json 后一键填入。"),
-        Tip("详细数据页码跳转", "原始数据页可输入页码直跳", "原始数据页底部可输入页码直接跳转，数据量大时不必逐页翻。"),
-        Tip("小组件自动刷新", "划到小组件会自动刷新余额", "桌面小组件划到负一屏时会自动刷新余额，也可手动点 ↻ 按钮刷新。"),
+        Tip(R.string.tip_1_title, R.string.tip_1_hint, R.string.tip_1_detail),
+        Tip(R.string.tip_2_title, R.string.tip_2_hint, R.string.tip_2_detail),
+        Tip(R.string.tip_3_title, R.string.tip_3_hint, R.string.tip_3_detail),
+        Tip(R.string.tip_4_title, R.string.tip_4_hint, R.string.tip_4_detail),
+        Tip(R.string.tip_5_title, R.string.tip_5_hint, R.string.tip_5_detail),
+        Tip(R.string.tip_6_title, R.string.tip_6_hint, R.string.tip_6_detail),
+        Tip(R.string.tip_7_title, R.string.tip_7_hint, R.string.tip_7_detail),
+        Tip(R.string.tip_8_title, R.string.tip_8_hint, R.string.tip_8_detail),
+        Tip(R.string.tip_9_title, R.string.tip_9_hint, R.string.tip_9_detail),
+        Tip(R.string.tip_10_title, R.string.tip_10_hint, R.string.tip_10_detail),
+        Tip(R.string.tip_11_title, R.string.tip_11_hint, R.string.tip_11_detail),
+        Tip(R.string.tip_12_title, R.string.tip_12_hint, R.string.tip_12_detail),
+        Tip(R.string.tip_13_title, R.string.tip_13_hint, R.string.tip_13_detail),
     )
 
-    /** 首页轮换用的一句话文案。 */
-    val shortHints: List<String> = tips.map { it.hint }
+    /** 首页轮换用的一句话文案（资源 ID 形式）。 */
+    val shortHintRes: List<Int> = tips.map { it.hintRes }
 
-    /** 随机取一条短文案。 */
-    fun randomHint(): String = shortHints.random()
+    /** 随机取一条短文案的资源 ID。 */
+    fun randomHintRes(): Int = shortHintRes.random()
 }
 
 @OptIn(ExperimentalMaterial3Api::class)
@@ -77,7 +83,7 @@ fun TipsScreen(onBack: () -> Unit) {
             TopAppBar(
                 title = {
                     Text(
-                        "使用小技巧",
+                        stringResource(R.string.title_tips),
                         style = MaterialTheme.typography.titleLarge,
                         fontWeight = FontWeight.Bold
                     )
@@ -86,7 +92,7 @@ fun TipsScreen(onBack: () -> Unit) {
                     IconButton(onClick = onBack) {
                         Icon(
                             Icons.Filled.ArrowBack,
-                            contentDescription = "返回",
+                            contentDescription = stringResource(R.string.action_back),
                             tint = StrawberryPink
                         )
                     }
@@ -123,14 +129,14 @@ fun TipsScreen(onBack: () -> Unit) {
                             )
                             Spacer(modifier = Modifier.width(8.dp))
                             Text(
-                                text = tip.title,
+                                text = stringResource(tip.titleRes),
                                 style = MaterialTheme.typography.titleMedium,
                                 fontWeight = FontWeight.SemiBold
                             )
                         }
                         Spacer(modifier = Modifier.height(6.dp))
                         Text(
-                            text = tip.detail,
+                            text = stringResource(tip.detailRes),
                             style = MaterialTheme.typography.bodyMedium,
                             color = InkMuted
                         )

app/src/main/java/com/rainy/token/ui/components/DebugLogScreen.kt

@@ -31,12 +31,16 @@ import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
 import com.rainy.token.data.debug.DebugLog
 import com.rainy.token.ui.theme.InkMuted
+import com.rainy.token.ui.theme.StatusOrange
+import com.rainy.token.ui.theme.StatusRed
 import com.rainy.token.ui.theme.StrawberryPink
 
 @OptIn(ExperimentalMaterial3Api::class)
@@ -50,7 +54,7 @@ fun DebugLogScreen(onBack: () -> Unit) {
             TopAppBar(
                 title = {
                     Text(
-                        "调试日志",
+                        stringResource(R.string.title_debug_log),
                         style = MaterialTheme.typography.titleLarge,
                         fontWeight = FontWeight.SemiBold
                     )
@@ -59,14 +63,14 @@ fun DebugLogScreen(onBack: () -> Unit) {
                     IconButton(onClick = onBack) {
                         Icon(
                             Icons.Filled.ArrowBack,
-                            contentDescription = "返回",
+                            contentDescription = stringResource(R.string.action_back),
                             tint = StrawberryPink
                         )
                     }
                 },
                 actions = {
                     TextButton(onClick = { DebugLog.clear() }) {
-                        Text("清空", color = StrawberryPink)
+                        Text(stringResource(R.string.action_clear), color = StrawberryPink)
                     }
                 },
                 colors = TopAppBarDefaults.topAppBarColors(
@@ -83,7 +87,7 @@ fun DebugLogScreen(onBack: () -> Unit) {
                 contentAlignment = Alignment.Center
             ) {
                 Text(
-                    "暂无日志记录\n刷新 Codex 用量后这里会出现调试信息",
+                    stringResource(R.string.debug_log_empty),
                     style = MaterialTheme.typography.bodyMedium,
                     color = InkMuted,
                     modifier = Modifier.padding(32.dp)
@@ -101,8 +105,8 @@ fun DebugLogScreen(onBack: () -> Unit) {
                 items(entries, key = { it.timestamp.toString() + it.tag + it.message }) { entry ->
                     val levelColor = when (entry.level) {
                         DebugLog.Level.INFO -> InkMuted
-                        DebugLog.Level.WARN -> Color(0xFFFFA726)
-                        DebugLog.Level.ERROR -> Color(0xFFE91E63)
+                        DebugLog.Level.WARN -> StatusOrange
+                        DebugLog.Level.ERROR -> StatusRed
                     }
                     Card(
                         modifier = Modifier.fillMaxWidth(),

app/src/main/java/com/rainy/token/ui/components/FormatUtils.kt

@@ -6,42 +6,79 @@ import java.util.Locale
  * 共享格式化工具函数。
  *
  * 从 DashboardScreen / ServiceDetailScreen / WidgetProvider 提取，消除三处重复。
+ *
+ * 本地化策略：函数保持纯 JVM（不依赖 Context / Resources，可被单元测试直接调用），
+ * 本地化标签通过 [DurationText] / 字符串参数注入。调用方（Compose / Widget）用
+ * `context.getString(...)` 取得当前语言标签后传入；测试继续使用默认中文标签。
  */
 
-/** 格式化金额：整数无小数点，带小数保留 2 位 */
+/** 时长标签（用于 "X 天 Y 小时" 这类拼接）。 */
+data class DurationText(
+    val day: String,
+    val hour: String,
+    val minute: String,
+    /** 无有效时长时展示的占位符 */
+    val dash: String = "—"
+)
+
+/** 默认中文标签（保持与原实现输出完全一致，供单元测试与兜底使用）。 */
+val ChineseDurationText = DurationText(day = "天", hour = "小时", minute = "分")
+
+/** 格式化金额：整数无小数点，带小数保留 2 位（金额数值格式固定 Locale.US，避免小数点歧义） */
 fun formatAmount(value: Double): String {
     return if (value % 1.0 == 0.0) value.toInt().toString()
     else String.format(Locale.US, "%.2f", value)
 }
 
 /** 格式化重置倒计时（秒 → "X 天 Y 小时" / "X 小时 Y 分" / "Y 分"），无效返回 "—" */
-fun formatResetInSec(sec: Long): String {
-    if (sec <= 0) return "—"
+fun formatResetInSec(sec: Long, text: DurationText = ChineseDurationText): String {
+    if (sec <= 0) return text.dash
     val days = sec / 86400
     val hours = (sec % 86400) / 3600
     val minutes = (sec % 3600) / 60
     return when {
-        days > 0 -> "$days 天 $hours 小时"
-        hours > 0 -> "$hours 小时 $minutes 分"
-        else -> "$minutes 分"
+        days > 0 -> "$days ${text.day} $hours ${text.hour}"
+        hours > 0 -> "$hours ${text.hour} $minutes ${text.minute}"
+        else -> "$minutes ${text.minute}"
     }
 }
 
 /** Widget 版本：逻辑相同但空值返回空串（非 "—"），适配 RemoteViews 布局 */
-fun formatResetForWidget(sec: Long): String {
+fun formatResetForWidget(sec: Long, text: DurationText = ChineseDurationText): String {
     if (sec <= 0) return ""
     val days = sec / 86400
     val hours = (sec % 86400) / 3600
     val minutes = (sec % 3600) / 60
     return when {
-        days > 0 -> "$days 天 $hours 小时"
-        hours > 0 -> "$hours 小时 $minutes 分"
-        else -> "$minutes 分"
+        days > 0 -> "$days ${text.day} $hours ${text.hour}"
+        hours > 0 -> "$hours ${text.hour} $minutes ${text.minute}"
+        else -> "$minutes ${text.minute}"
     }
 }
 
-/** 标准化窗口标签：weekly → 每周，其他原样返回 */
-fun normalizeWindowLabel(label: String): String = when (label.lowercase()) {
-    "weekly" -> "每周"
+/** 标准化窗口标签：weekly/每周 → 每周标签，monthly/每月 → 每月标签，usage/用量 → 用量标签，其他原样返回 */
+fun normalizeWindowLabel(
+    label: String,
+    weeklyLabel: String = "Weekly",
+    monthlyLabel: String = "Monthly",
+    usageLabel: String = "Usage"
+): String = when (label.lowercase()) {
+    "weekly", "每周" -> weeklyLabel
+    "monthly", "每月" -> monthlyLabel
+    "usage", "用量" -> usageLabel
     else -> label
+}
+
+/**
+ * 判断窗口标签是否为 5h 窗口（与语言无关）：
+ * - 匹配英文缩写（5h/5H）
+ * - 匹配本地化标签（如 "5小时"/"5 小时"/"5小時"）
+ * - 兼容历史中文数据（含 "5" 且含 "小时"）
+ */
+fun isFiveHourLabel(label: String, fiveHourLabel: String, fiveHourShort: String): Boolean {
+    val normalized = label.trim()
+    return normalized.equals(fiveHourShort, ignoreCase = true) ||
+        normalized == fiveHourLabel ||
+        (normalized.contains("5") && normalized.contains("小时")) ||
+        (normalized.contains("5") && normalized.contains("小時"))
 }

app/src/main/java/com/rainy/token/ui/components/RainyBackground.kt

@@ -13,10 +13,10 @@ import com.rainy.token.ui.theme.DarkSurface
 import androidx.compose.foundation.isSystemInDarkTheme
 
 /**
- * 雨晴风格全局背景。
+ * 雨晴风格全局背景（精致粉调）。
  *
- * Light 模式：樱粉渐变（#FFF0F5 → #FFD1DC，从左上到右下）
- * Dark 模式：暖深渐变（#1F1419 → #2A1F25）
+ * Light 模式：低饱和粉白渐变（#FFF9FB → #FDEFF4，从左上到右下）
+ * Dark 模式：暖深渐变（#1A1417 → #251C21）
  *
  * 放在 Scaffold 容器层，所有页面共享同一层渐变。
  */

app/src/main/java/com/rainy/token/ui/components/ServiceIcon.kt

@@ -13,8 +13,10 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.compose.material3.Text
 import com.rainy.token.R
 import com.rainy.token.domain.service.ServiceType
 
@@ -42,7 +44,7 @@ fun ServiceIcon(
                 modifier = modifier
                     .size(size.dp)
                     .clip(RoundedCornerShape(8.dp))
-                    .background(if (isSystemInDarkTheme()) Color(0xFF352329) else Color.White),
+                    .background(if (isSystemInDarkTheme()) Color(0xFF32262C) else Color.White),
                 contentAlignment = Alignment.Center
             ) {
                 Image(
@@ -57,12 +59,12 @@ fun ServiceIcon(
                 modifier = modifier
                     .size(size.dp)
                     .clip(RoundedCornerShape(8.dp))
-                    .background(if (isSystemInDarkTheme()) Color(0xFF352329) else Color.White),
+                    .background(if (isSystemInDarkTheme()) Color(0xFF32262C) else Color.White),
                 contentAlignment = Alignment.Center
             ) {
                 Image(
                     painter = painterResource(id = R.drawable.ic_opencode_go_logo),
-                    contentDescription = "CommandCode Go",
+                    contentDescription = "CommandCode",
                     modifier = Modifier.size((size * 0.85).dp, ((size * 0.85f * 30f / 54f)).dp)
                 )
             }
@@ -112,10 +114,75 @@ fun ServiceIcon(
             ) {
                 Image(
                     painter = painterResource(id = R.drawable.ic_ollama_logo),
-                    contentDescription = "Ollama Pro",
+                    contentDescription = "Ollama",
                     modifier = Modifier.fillMaxSize()
                 )
             }
         }
+        ServiceType.TRAE -> {
+            Box(
+                modifier = modifier
+                    .size(size.dp)
+                    .clip(RoundedCornerShape(8.dp))
+                    .background(if (isSystemInDarkTheme()) Color(0xFF20242E) else Color.White),
+                contentAlignment = Alignment.Center
+            ) {
+                Image(
+                    painter = painterResource(id = R.drawable.ic_trae_logo),
+                    contentDescription = "Trae",
+                    modifier = Modifier.fillMaxSize()
+                )
+            }
+        }
+        ServiceType.WORKBUDDY -> {
+            Box(
+                modifier = modifier
+                    .size(size.dp)
+                    .clip(RoundedCornerShape(8.dp))
+                    .background(Color.White),
+                contentAlignment = Alignment.Center
+            ) {
+                Image(
+                    painter = painterResource(id = R.drawable.ic_workbuddy_logo),
+                    contentDescription = "WorkBuddy",
+                    modifier = Modifier.fillMaxSize()
+                )
+            }
+        }
+        ServiceType.SUB2API -> {
+            LetterIcon(
+                letter = "S",
+                background = Color(0xFF6C5CE7),
+                modifier = modifier,
+                size = size
+            )
+        }
+    }
+}
+
+/**
+ * 品牌色字母占位图标。正式 logo（Trae / WorkBuddy / Sub2API）落地后
+ * 在此替换为 drawable 分支（同 DeepSeek 模式）。
+ */
+@Composable
+private fun LetterIcon(
+    letter: String,
+    background: Color,
+    modifier: Modifier,
+    size: Int
+) {
+    Box(
+        modifier = modifier
+            .size(size.dp)
+            .clip(RoundedCornerShape(10.dp))
+            .background(background),
+        contentAlignment = Alignment.Center
+    ) {
+        Text(
+            text = letter,
+            color = Color.White,
+            fontSize = (size * 0.5f).sp,
+            fontWeight = FontWeight.Bold
+        )
     }
 }

app/src/main/java/com/rainy/token/ui/components/SiteIcon.kt

@@ -0,0 +1,65 @@
+package com.rainy.token.ui.components
+
+import android.graphics.BitmapFactory
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.produceState
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.painter.BitmapPainter
+import androidx.compose.ui.unit.Dp
+import com.caverock.androidsvg.SVG
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+import okhttp3.Request
+
+/**
+ * 轻量站点图标加载（OkHttp 拉取，无三方图片库）。
+ * 支持 PNG/JPEG/WebP（BitmapFactory）与 SVG（androidsvg 渲染）；失败静默不渲染。
+ * 用于 Sub2API 凭据页站点预览与主页卡片 Logo。
+ */
+@Composable
+fun SiteIcon(url: String, size: Dp) {
+    val icon by produceState<ImageBitmap?>(initialValue = null, url) {
+        // 网络 + SVG 解码放到 IO 线程：produceState 默认在 UI 调度器执行，
+        // 直接在生产者里阻塞请求会造成主页卡片掉帧 / StrictMode 告警。
+        value = withContext(Dispatchers.IO) {
+            runCatching {
+                if (!url.startsWith("http")) return@runCatching null
+                val resp = OkHttpClient.Builder()
+                    .build()
+                    .newCall(Request.Builder().url(url).build())
+                    .execute()
+                resp.use {
+                    val bytes = it.body?.bytes() ?: return@runCatching null
+                    decodeIcon(bytes)
+                }
+            }.getOrNull()
+        }
+    }
+    val bitmap = icon ?: return
+    Image(
+        painter = BitmapPainter(bitmap),
+        contentDescription = null,
+        modifier = Modifier.size(size)
+    )
+}
+
+/** 位图解码：先按 PNG/JPEG 解，失败再按 SVG 渲染（BitmapFactory 不支持 SVG）。 */
+private fun decodeIcon(bytes: ByteArray): ImageBitmap? {
+    val raster = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+    if (raster != null) return raster.asImageBitmap()
+    return runCatching {
+        val svg = SVG.getFromString(String(bytes, Charsets.UTF_8))
+        val w = svg.documentWidth.toInt().coerceIn(16, 1024)
+        val h = svg.documentHeight.toInt().coerceIn(16, 1024)
+        val bmp = android.graphics.Bitmap.createBitmap(w, h, android.graphics.Bitmap.Config.ARGB_8888)
+        val c = android.graphics.Canvas(bmp)
+        svg.renderToCanvas(c)
+        bmp.asImageBitmap()
+    }.getOrNull()
+}

app/src/main/java/com/rainy/token/ui/components/StatusChip.kt

@@ -1,6 +1,7 @@
 package com.rainy.token.ui.components
 
 import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
@@ -9,6 +10,7 @@ import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.annotation.StringRes
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
@@ -16,6 +18,7 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.rainy.token.ui.theme.StatusBlue
 import com.rainy.token.ui.theme.StatusGreen
@@ -33,7 +36,7 @@ import com.rainy.token.ui.theme.StatusRed
 enum class StatusLevel { OK, WARNING, ERROR, INFO }
 
 data class StatusStyle(
-    val label: String,
+    @StringRes val labelRes: Int,
     val level: StatusLevel
 )
 
@@ -42,11 +45,14 @@ fun StatusChip(
     style: StatusStyle,
     modifier: Modifier = Modifier
 ) {
+    // 暗色模式下胶囊底色是状态色 12% alpha 叠加暗色卡片，
+    // 深色文字几乎不可读，故暗色使用同色系亮色文字。
+    val dark = isSystemInDarkTheme()
     val (dotColor, textColor) = when (style.level) {
-        StatusLevel.OK -> StatusGreen to Color(0xFF1B5E20)
-        StatusLevel.WARNING -> StatusOrange to Color(0xFF8A4A00)
-        StatusLevel.ERROR -> StatusRed to Color(0xFF8B0033)
-        StatusLevel.INFO -> StatusBlue to Color(0xFF0D47A1)
+        StatusLevel.OK -> StatusGreen to if (dark) Color(0xFF9CE8BC) else Color(0xFF1B5E20)
+        StatusLevel.WARNING -> StatusOrange to if (dark) Color(0xFFFFDBA6) else Color(0xFF8A4A00)
+        StatusLevel.ERROR -> StatusRed to if (dark) Color(0xFFFFB6CA) else Color(0xFF8A1F40)
+        StatusLevel.INFO -> StatusBlue to if (dark) Color(0xFFAED7FF) else Color(0xFF0D47A1)
     }
     val bgColor = dotColor.copy(alpha = 0.12f)
     Row(
@@ -64,7 +70,7 @@ fun StatusChip(
         )
         Spacer(modifier = Modifier.width(6.dp))
         Text(
-            text = style.label,
+            text = stringResource(style.labelRes),
             style = MaterialTheme.typography.labelSmall,
             color = textColor
         )

app/src/main/java/com/rainy/token/ui/components/UiText.kt

@@ -0,0 +1,44 @@
+package com.rainy.token.ui.components
+
+import android.content.Context
+import androidx.annotation.StringRes
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+
+/**
+ * 可本地化的文本抽象。
+ *
+ * ViewModel / Repository 层不直接持有本地化字符串，而是返回 [UiText]：
+ * - [Resource]：引用字符串资源（可带格式化参数），由 UI 层按当前语言环境解析
+ * - [Dynamic]：服务端返回的动态文本（未知内容，无法预翻译），原样透传
+ *
+ * 调试日志保持使用原始 [Throwable.message]（Repository 中文消息仅用于排查，不用于 UI 展示）。
+ */
+sealed interface UiText {
+
+    data class Resource(
+        @StringRes val resId: Int,
+        val args: List<Any> = emptyList()
+    ) : UiText
+
+    data class Dynamic(val value: String) : UiText
+}
+
+/** 在非 Composable 上下文（协程/回调/事件）中把 [UiText] 解析为字符串（嵌套 [UiText] 参数会递归扁平化）。 */
+fun UiText.resolve(context: Context): String = when (this) {
+    is UiText.Resource -> {
+        val flatArgs = args.map { arg -> if (arg is UiText) arg.resolve(context) else arg }
+        context.getString(resId, *flatArgs.toTypedArray())
+    }
+    is UiText.Dynamic -> value
+}
+
+/** 在 Composable 上下文中把 [UiText] 解析为当前语言环境的字符串（嵌套 [UiText] 参数会递归扁平化）。 */
+@Composable
+fun UiText.asString(): String = when (this) {
+    is UiText.Resource -> {
+        val flatArgs = args.map { arg -> if (arg is UiText) arg.asString() else arg }
+        stringResource(resId, *flatArgs.toTypedArray())
+    }
+    is UiText.Dynamic -> value
+}

app/src/main/java/com/rainy/token/ui/dashboard/CommandCodeUsageStatsCard.kt

@@ -24,17 +24,20 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
+import com.rainy.token.ui.components.asString
 import com.rainy.token.data.local.OverviewStats
 import com.rainy.token.ui.theme.InkMuted
 import com.rainy.token.ui.theme.StrawberryPink
 import java.util.Locale
 
 /**
- * CommandCode Go 用量统计主卡片 —— 风格与 UsageStatsCard（OCGO）完全一致。
+ * CommandCode 用量统计主卡片 —— 风格与 UsageStatsCard（OCGO）完全一致。
  * 仅展示核心指标：输入 Token（含 Cache）、输出 Token、总花费，
  * 外加同步按钮和"查看详情"入口。详细统计在 CCGO 专属详情页。
  */
@@ -68,12 +71,12 @@ fun CommandCodeUsageStatsCard(
             Row(verticalAlignment = Alignment.CenterVertically) {
                 Column(modifier = Modifier.weight(1f)) {
                     Text(
-                        text = "CommandCode 用量",
+                        text = stringResource(R.string.usage_title_commandcode),
                         style = MaterialTheme.typography.titleMedium,
                         fontWeight = FontWeight.SemiBold
                     )
                     Text(
-                        text = if (uiState.recordCount > 0) "${uiState.recordCount} 条记录" else "点击同步",
+                        text = if (uiState.recordCount > 0) stringResource(R.string.usage_record_count, uiState.recordCount) else stringResource(R.string.usage_click_to_sync),
                         style = MaterialTheme.typography.bodySmall,
                         color = InkMuted
                     )
@@ -88,7 +91,7 @@ fun CommandCodeUsageStatsCard(
                     IconButton(onClick = { viewModel.sync() }) {
                         Icon(
                             imageVector = Icons.Filled.Refresh,
-                            contentDescription = "同步用量数据",
+                            contentDescription = stringResource(R.string.action_sync_usage),
                             tint = StrawberryPink
                         )
                     }
@@ -101,13 +104,13 @@ fun CommandCodeUsageStatsCard(
 
                 // 输入 Token = input + cacheRead
                 val inputTotal = overview.inputTokens + overview.cacheReadTokens
-                MetricRow("输入 Token", formatTokenCount(inputTotal))
+                MetricRow(stringResource(R.string.usage_input_tokens), formatTokenCount(inputTotal))
 
                 // 缓存子行
                 if (overview.cacheReadTokens > 0 || overview.cacheWriteTokens > 0) {
                     val parts = mutableListOf<String>()
-                    if (overview.cacheReadTokens > 0) parts.add("缓存读取 ${formatTokenCount(overview.cacheReadTokens)}")
-                    if (overview.cacheWriteTokens > 0) parts.add("缓存写入 ${formatTokenCount(overview.cacheWriteTokens)}")
+                    if (overview.cacheReadTokens > 0) parts.add(stringResource(R.string.usage_cache_read, formatTokenCount(overview.cacheReadTokens)))
+                    if (overview.cacheWriteTokens > 0) parts.add(stringResource(R.string.usage_cache_write, formatTokenCount(overview.cacheWriteTokens)))
                     Text(
                         text = parts.joinToString(" · "),
                         style = MaterialTheme.typography.bodySmall,
@@ -120,8 +123,8 @@ fun CommandCodeUsageStatsCard(
 
                 // 输出 Token + 总花费 同一排
                 Row(Modifier.fillMaxWidth()) {
-                    MetricRow("输出 Token", formatTokenCount(overview.outputTokens), Modifier.weight(1f))
-                    MetricRow("总花费", "$${String.format(Locale.US, "%.4f", overview.totalCost / 100_000_000.0)}", Modifier.weight(1f))
+                    MetricRow(stringResource(R.string.usage_output_tokens), formatTokenCount(overview.outputTokens), Modifier.weight(1f))
+                    MetricRow(stringResource(R.string.usage_total_cost), "$${String.format(Locale.US, "%.4f", overview.totalCost / 100_000_000.0)}", Modifier.weight(1f))
                 }
             }
 
@@ -129,7 +132,7 @@ fun CommandCodeUsageStatsCard(
             if (uiState.overview == null && !uiState.syncing) {
                 Spacer(modifier = Modifier.height(8.dp))
                 Text(
-                    text = if (uiState.loading) "加载中…" else "暂无数据，点击 🔄 同步",
+                    text = if (uiState.loading) stringResource(R.string.common_loading) else stringResource(R.string.usage_no_data_sync),
                     style = MaterialTheme.typography.bodyMedium,
                     color = InkMuted
                 )
@@ -139,7 +142,7 @@ fun CommandCodeUsageStatsCard(
             if (uiState.overview != null) {
                 Spacer(modifier = Modifier.height(8.dp))
                 TextButton(onClick = onOpenDetail) {
-                    Text("查看详情", color = StrawberryPink)
+                    Text(stringResource(R.string.action_view_detail), color = StrawberryPink)
                     Spacer(modifier = Modifier.width(2.dp))
                     Icon(
                         imageVector = Icons.Filled.KeyboardArrowRight,
@@ -154,7 +157,7 @@ fun CommandCodeUsageStatsCard(
             if (uiState.lastSyncResult > 0) {
                 Spacer(modifier = Modifier.height(4.dp))
                 Text(
-                    text = "✓ 新增 ${uiState.lastSyncResult} 条",
+                    text = stringResource(R.string.usage_new_records, uiState.lastSyncResult),
                     style = MaterialTheme.typography.bodySmall,
                     color = StrawberryPink
                 )
@@ -162,12 +165,22 @@ fun CommandCodeUsageStatsCard(
             uiState.lastSyncError?.let { err ->
                 Spacer(modifier = Modifier.height(4.dp))
                 Text(
-                    text = "✗ $err",
+                    text = "✗ ${err.asString()}",
                     style = MaterialTheme.typography.bodySmall,
                     color = MaterialTheme.colorScheme.error
                 )
             }
 
+            // ─── 刷新时间（与其余服务卡片底部一致） ───
+            if (uiState.lastSyncAt > 0) {
+                Spacer(modifier = Modifier.height(4.dp))
+                Text(
+                    text = usageUpdatedAtText(uiState.lastSyncAt),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = InkMuted
+                )
+            }
+
         }
     }
 }

app/src/main/java/com/rainy/token/ui/dashboard/DashboardScreen.kt

@@ -19,21 +19,27 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
+import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.DateRange
 import androidx.compose.material.icons.filled.KeyboardArrowRight
+import androidx.compose.material.icons.filled.Lock
 import androidx.compose.material.icons.filled.Refresh
 import androidx.compose.material.icons.filled.Settings
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.TextButton
+import androidx.compose.material3.Switch
+import androidx.compose.material3.SwitchDefaults
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.CircularProgressIndicator
@@ -42,6 +48,7 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
@@ -67,7 +74,9 @@ import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.layout.positionInWindow
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.zIndex
@@ -77,15 +86,24 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.LifecycleEventEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.data.repository.CredentialRepository
+import com.rainy.token.BuildConfig
+import com.rainy.token.R
 import com.rainy.token.domain.model.CredentialStatus
 import com.rainy.token.domain.model.ServiceBalance
+import com.rainy.token.domain.service.ServiceConfigProvider
 import com.rainy.token.domain.service.ServiceType
 import com.rainy.token.ui.components.ServiceIcon
+import com.rainy.token.ui.components.SiteIcon
 import com.rainy.token.ui.components.StatusChip
 import com.rainy.token.ui.components.StatusLevel
 import com.rainy.token.ui.components.StatusStyle
 import com.rainy.token.ui.components.AppTips
+import com.rainy.token.ui.components.asString
+import com.rainy.token.ui.dashboard.autocheckin.AutoCheckinManager
 import com.rainy.token.ui.theme.inkMuted
+import com.rainy.token.ui.theme.PureWhite
+import com.rainy.token.ui.theme.inkWarm
 import com.rainy.token.ui.theme.StrawberryPink
 import android.app.AppOpsManager
 import android.appwidget.AppWidgetManager
@@ -115,19 +133,32 @@ import java.util.Locale
 @Composable
 fun DashboardScreen(
     onOpenSettings: () -> Unit,
-    onOpenService: (ServiceType) -> Unit,
+    onOpenApiManagement: () -> Unit,
+    onOpenService: (ServiceType, String?) -> Unit,
     onOpenUsageDetail: () -> Unit,
     onOpenCcgoUsageDetail: () -> Unit = {},
+    onOpenHeatmap: () -> Unit = {},
+    onOpenRecharge: (ServiceType) -> Unit = {},
     viewModel: DashboardViewModel = hiltViewModel()
 ) {
-    // 从设置页返回时重新读取本地凭据状态 + 缓存（不自动发起网络请求）
+    // 从设置页返回时重新读取本地凭据状态 + 缓存；若有已配置但无余额缓存的
+    // 新账号（刚登录/导入），ViewModel 会自动拉一次余额让卡片立刻有数据
     LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
         viewModel.reloadLocalState()
     }
 
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    // 自动签到汇报（每日首次打开 App 签到后弹一次）
+    val autoCheckinReport by viewModel.autoCheckinReport.collectAsStateWithLifecycle()
+    // Sub2API 面板管理弹窗数据源
+    val panelKeysState by viewModel.panelKeysState.collectAsStateWithLifecycle()
+    val panelGroups by viewModel.panelGroups.collectAsStateWithLifecycle()
+    val panelActionMessage by viewModel.panelActionMessage.collectAsStateWithLifecycle()
+    val recentlyCreatedKey by viewModel.recentlyCreatedKey.collectAsStateWithLifecycle()
     val context = LocalContext.current
     var showAddWidgetConfirm by remember { mutableStateOf(false) }
+    // 首页 Sub2API 卡片「面板管理」弹窗开关（内嵌与详情页同一个面板管理组件）
+    var showSub2PanelManagement by remember { mutableStateOf(false) }
     // 一次性"长按拖拽排序"提示
     var showDragHint by remember { mutableStateOf(false) }
     LaunchedEffect(Unit) {
@@ -143,8 +174,14 @@ fun DashboardScreen(
             ?.split(',')
             ?.filter { it.isNotBlank() }
             .orEmpty()
+        // 兼容历史排序 id：
+        //  - 最早的格式 "service:{storageKey}"（单账号服务）→ "{storageKey}:"
+        //  - 迁移后旧格式 "{storageKey}:" / "{storageKey}:default" 以及任意 "{storageKey}:{账号id}"
+        //    （多账号服务）→ 服务组 id "group:{storageKey}"（叠放卡组）
+        //  - 其余（用量卡/热力图卡等）原样保留
+        val migrated = saved.mapNotNull { id -> migrateOrderId(id) }.distinct()
         cardOrder.clear()
-        cardOrder.addAll(saved)
+        cardOrder.addAll(migrated)
     }
 
     // 全局刷新触发器——每次 dashboard 刷新完成后 +1，UsageStatsCard 据此同步用量数据
@@ -161,8 +198,8 @@ fun DashboardScreen(
     if (showAddWidgetConfirm) {
         AlertDialog(
             onDismissRequest = { showAddWidgetConfirm = false },
-            title = { Text("添加桌面小组件？") },
-            text = { Text("确认后会请求桌面启动器添加雨晴Token小组件。部分系统仍会弹出系统确认窗口。") },
+            title = { Text(stringResource(R.string.dialog_add_widget_title)) },
+            text = { Text(stringResource(R.string.dialog_add_widget_body)) },
             confirmButton = {
                 TextButton(
                     onClick = {
@@ -170,12 +207,51 @@ fun DashboardScreen(
                         requestRainyTokenWidgetPin(context)
                     }
                 ) {
-                    Text("确认添加", color = StrawberryPink)
+                    Text(stringResource(R.string.action_confirm_add), color = StrawberryPink)
                 }
             },
             dismissButton = {
                 TextButton(onClick = { showAddWidgetConfirm = false }) {
-                    Text("取消")
+                    Text(stringResource(R.string.action_cancel))
+                }
+            }
+        )
+    }
+
+    // 每日自动签到结果汇报：「xx 已签到，积分增加 x」/ 已签 / 失败原因
+    if (autoCheckinReport != null) {
+        AlertDialog(
+            onDismissRequest = viewModel::consumeAutoCheckinReport,
+            title = { Text(stringResource(R.string.auto_checkin_dialog_title)) },
+            text = {
+                Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                    autoCheckinReport!!.forEach { r ->
+                        val serviceName = r.accountLabel?.let {
+                            r.service.displayName + " · " + it
+                        } ?: r.service.displayName
+                        Text(
+                            text = when {
+                                r.failed && r.message.isNotBlank() ->
+                                    stringResource(R.string.auto_checkin_line_failed, serviceName, r.message)
+                                r.failed ->
+                                    stringResource(R.string.auto_checkin_line_failed_generic, serviceName)
+                                r.newlyCheckedIn && r.creditsGained > 0 ->
+                                    stringResource(R.string.auto_checkin_line_gained, serviceName, r.creditsGained)
+                                // 今日确实已签（成功或服务端回报已签）→ 「今日已签到」
+                                r.checkedInToday ->
+                                    stringResource(R.string.auto_checkin_line_already, serviceName)
+                                // 其余（静默跳过等）不出现在汇报里，兜底走失败提示
+                                else ->
+                                    stringResource(R.string.auto_checkin_line_failed_generic, serviceName)
+                            },
+                            style = MaterialTheme.typography.bodyMedium
+                        )
+                    }
+                }
+            },
+            confirmButton = {
+                TextButton(onClick = viewModel::consumeAutoCheckinReport) {
+                    Text(stringResource(R.string.action_confirm), color = StrawberryPink)
                 }
             }
         )
@@ -193,7 +269,7 @@ fun DashboardScreen(
                             fontWeight = FontWeight.Bold
                         )
                         Text(
-                            text = "AI 余额一览",
+                            text = stringResource(R.string.dashboard_subtitle),
                             style = MaterialTheme.typography.bodySmall,
                             color = inkMuted()
                         )
@@ -203,7 +279,7 @@ fun DashboardScreen(
                     IconButton(onClick = { showAddWidgetConfirm = true }) {
                         Icon(
                             imageVector = Icons.Filled.Add,
-                            contentDescription = "添加小组件到桌面",
+                            contentDescription = stringResource(R.string.action_add_widget),
                             tint = StrawberryPink
                         )
                     }
@@ -213,14 +289,21 @@ fun DashboardScreen(
                     ) {
                         Icon(
                             imageVector = Icons.Filled.Refresh,
-                            contentDescription = "刷新",
+                            contentDescription = stringResource(R.string.action_refresh),
+                            tint = StrawberryPink
+                        )
+                    }
+                    IconButton(onClick = onOpenApiManagement) {
+                        Icon(
+                            imageVector = Icons.Filled.Lock,
+                            contentDescription = stringResource(R.string.api_mgmt_title),
                             tint = StrawberryPink
                         )
                     }
                     IconButton(onClick = onOpenSettings) {
                         Icon(
                             imageVector = Icons.Filled.Settings,
-                            contentDescription = "设置",
+                            contentDescription = stringResource(R.string.action_settings),
                             tint = StrawberryPink
                         )
                     }
@@ -238,7 +321,8 @@ fun DashboardScreen(
                 .fillMaxSize()
                 .padding(innerPadding)
         ) {
-            if (uiState.cards.isEmpty()) {
+            // 仅初始加载时显示转圈；加载完即使没有已配置服务也渲染（展示用量卡片 + 空态引导）
+            if (uiState.loading) {
                 Box(
                     modifier = Modifier.fillMaxSize(),
                     contentAlignment = Alignment.Center
@@ -262,20 +346,62 @@ fun DashboardScreen(
                             .padding(contentPadding),
                         verticalArrangement = Arrangement.spacedBy(12.dp)
                     ) {
-                        // 随机小技巧提示（每次启动随机一条）
-                        val tipText = remember { AppTips.randomHint() }
-                        Text(
-                            text = "💡 $tipText",
-                            style = MaterialTheme.typography.bodySmall,
-                            color = inkMuted(),
-                            modifier = Modifier.padding(horizontal = 4.dp)
-                        )
+                        // 随机小技巧提示（每次启动随机一条）+ 最右侧自动签到开关
+                        val tipTextRes = remember { AppTips.randomHintRes() }
+                        val autoCheckinEnabled by viewModel.autoCheckinEnabled.collectAsStateWithLifecycle()
+                        Card(
+                            modifier = Modifier.fillMaxWidth(),
+                            shape = RoundedCornerShape(16.dp),
+                            colors = CardDefaults.cardColors(
+                                containerColor = MaterialTheme.colorScheme.surface
+                            ),
+                            elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+                        ) {
+                            Row(
+                                verticalAlignment = Alignment.CenterVertically,
+                                modifier = Modifier.padding(horizontal = 14.dp, vertical = 10.dp)
+                            ) {
+                                Text(
+                                    text = "💡 " + stringResource(tipTextRes),
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = inkMuted(),
+                                    modifier = Modifier.weight(1f)
+                                )
+                                Spacer(modifier = Modifier.width(8.dp))
+                                Text(
+                                    text = stringResource(R.string.auto_checkin_switch_label),
+                                    style = MaterialTheme.typography.labelMedium,
+                                    color = inkWarm(),
+                                    fontWeight = FontWeight.SemiBold
+                                )
+                                Spacer(modifier = Modifier.width(2.dp))
+                                Switch(
+                                    checked = autoCheckinEnabled,
+                                    onCheckedChange = viewModel::setAutoCheckinEnabled,
+                                    colors = SwitchDefaults.colors(
+                                        checkedThumbColor = PureWhite,
+                                        checkedTrackColor = StrawberryPink,
+                                        checkedBorderColor = StrawberryPink,
+                                        uncheckedThumbColor = MaterialTheme.colorScheme.onSurfaceVariant,
+                                        uncheckedTrackColor = MaterialTheme.colorScheme.surfaceVariant,
+                                        uncheckedBorderColor = MaterialTheme.colorScheme.onSurfaceVariant
+                                    )
+                                )
+                            }
+                        }
                         val items = rememberDashboardItems(
                             cards = uiState.cards,
                             order = cardOrder,
+                            onOpenSettings = onOpenSettings,
                             onOpenUsageDetail = onOpenUsageDetail,
                             onOpenCcgoUsageDetail = onOpenCcgoUsageDetail,
                             onOpenService = onOpenService,
+                            onOpenHeatmap = onOpenHeatmap,
+                            onOpenSub2PanelManagement = { accountId ->
+                                viewModel.openSub2Panel(accountId)
+                                showSub2PanelManagement = true
+                            },
+                            onOpenRecharge = onOpenRecharge,
                             refreshTrigger = usageSyncTrigger
                         )
                         DraggableDashboardCards(
@@ -314,13 +440,13 @@ fun DashboardScreen(
                                     verticalAlignment = Alignment.CenterVertically
                                 ) {
                                     Text(
-                                        text = "💡 长按卡片可拖拽排序",
+                                        text = stringResource(R.string.dashboard_drag_hint),
                                         style = MaterialTheme.typography.bodySmall,
                                         color = StrawberryPink,
                                         modifier = Modifier.weight(1f)
                                     )
                                     Text(
-                                        text = "知道了",
+                                        text = stringResource(R.string.action_got_it),
                                         style = MaterialTheme.typography.bodySmall,
                                         color = StrawberryPink,
                                         fontWeight = FontWeight.SemiBold
@@ -335,6 +461,70 @@ fun DashboardScreen(
             }
         }
     }
+
+    // Sub2API 面板管理弹窗
+    // 滚动说明：AlertDialog 的 text 槽是固定高度且**不自带滚动容器**，内容超过上限会被直接裁掉
+    // （表现为「打开后滚不动、下面的 Key 看不到」）。这里给 text 槽加 verticalScroll + 高度上限，
+    // 让整个面板管理内容（Key 列表/新建/分组/兑换）可以正常上下滚动。
+    if (showSub2PanelManagement) {
+        val scrollState = rememberScrollState()
+        val maxDialogHeight = (LocalConfiguration.current.screenHeightDp * 0.72f).dp
+        // 面板弹窗按当前选中的账号取余额：默认账号 accountId=null，多账号为具体 ID；
+        // 找不到匹配卡（如刚新建账号尚无余额）时回退到第一张 Sub2API 卡，避免显示空。
+        val panelAccountId by viewModel.sub2PanelAccountId.collectAsStateWithLifecycle()
+        val panelBalanceCard = uiState.cards.firstOrNull {
+                it.service == ServiceType.SUB2API && it.accountId == panelAccountId
+            } ?: uiState.cards.firstOrNull { it.service == ServiceType.SUB2API }
+        AlertDialog(
+            onDismissRequest = { showSub2PanelManagement = false },
+            // 标题与刷新按钮同一行：刷新重新拉取 Key 列表与分组
+            title = {
+                Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
+                    Text(
+                        text = stringResource(R.string.sub2_panel_manage_title),
+                        fontWeight = FontWeight.Bold,
+                        modifier = Modifier.weight(1f)
+                    )
+                    IconButton(onClick = { viewModel.loadPanelKeys(); viewModel.loadPanelGroups() }) {
+                        Icon(
+                            imageVector = Icons.Filled.Refresh,
+                            contentDescription = stringResource(R.string.action_refresh)
+                        )
+                    }
+                }
+            },
+            text = {
+                Box(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .heightIn(max = maxDialogHeight)
+                        .verticalScroll(scrollState)
+                ) {
+                    com.rainy.token.ui.servicedetail.Sub2ApiPanelManagement(
+                        balance = panelBalanceCard?.cachedBalance?.balance,
+                        keysState = panelKeysState,
+                        groups = panelGroups,
+                        actionMessage = panelActionMessage,
+                        createdKey = recentlyCreatedKey,
+                        onLoadKeys = { viewModel.loadPanelKeys() },
+                        onLoadGroups = { viewModel.loadPanelGroups() },
+                        onCreateKey = viewModel::createPanelKey,
+                        onSwitchGroup = viewModel::switchPanelGroup,
+                        onDeleteKey = viewModel::deletePanelKey,
+                        onRedeem = viewModel::redeemPanelCode,
+                        onConsumeMessage = viewModel::consumePanelActionMessage,
+                        onConsumeCreatedKey = viewModel::consumeRecentlyCreatedKey,
+                        showHeader = false
+                    )
+                }
+            },
+            confirmButton = {
+                TextButton(onClick = { showSub2PanelManagement = false }) {
+                    Text(stringResource(R.string.action_close))
+                }
+            }
+        )
+    }
 }
 
 private const val DASHBOARD_ORDER_PREFS = "dashboard_card_order"
@@ -342,6 +532,7 @@ private const val DASHBOARD_ORDER_KEY = "order"
 private const val USAGE_OCGO_CARD_ID = "usage:opencode_go"
 private const val USAGE_CCGO_CARD_ID = "usage:commandcode_go"
 private const val DASHBOARD_CARD_SPACING_DP = 12
+private const val HEATMAP_CARD_ID = "heatmap"
 
 private data class DashboardHomeItem(
     val id: String,
@@ -352,37 +543,128 @@ private data class DashboardHomeItem(
 private fun rememberDashboardItems(
     cards: List<DashboardCardUi>,
     order: List<String>,
+    onOpenSettings: () -> Unit,
     onOpenUsageDetail: () -> Unit,
     onOpenCcgoUsageDetail: () -> Unit,
-    onOpenService: (ServiceType) -> Unit,
+    onOpenService: (ServiceType, String?) -> Unit,
+    onOpenHeatmap: () -> Unit,
+    onOpenSub2PanelManagement: (String?) -> Unit,
+    onOpenRecharge: (ServiceType) -> Unit,
     refreshTrigger: Int
 ): List<DashboardHomeItem> {
     val defaultItems = buildList {
-        add(DashboardHomeItem(USAGE_OCGO_CARD_ID) {
-            UsageStatsCard(onOpenDetail = onOpenUsageDetail, refreshTrigger = refreshTrigger)
-        })
-        add(DashboardHomeItem(USAGE_CCGO_CARD_ID) {
-            CommandCodeUsageStatsCard(onOpenDetail = onOpenCcgoUsageDetail, refreshTrigger = refreshTrigger)
-        })
+        // 未配置任何服务时的引导卡片（首页仅显示已配置的服务）
+        if (cards.isEmpty()) {
+            add(DashboardHomeItem("empty_hint") {
+                EmptyServicesHintCard(onOpenSettings = onOpenSettings)
+            })
+        }
+        // 用量卡与热力图卡只在对应服务已配置时出现：
+        // 未配置 OCGO/CCGO 时不应展示它们的用量卡（此前无条件添加，导致未配置也占位）。
+        val configuredServices = cards.map { it.service }.toSet()
+        val ocgoConfigured = ServiceType.OPENCODE_GO in configuredServices
+        val ccgoConfigured = ServiceType.COMMANDCODE_GO in configuredServices
+        if (ocgoConfigured) {
+            add(DashboardHomeItem(USAGE_OCGO_CARD_ID) {
+                UsageStatsCard(onOpenDetail = onOpenUsageDetail, onOpenHeatmap = onOpenHeatmap, refreshTrigger = refreshTrigger)
+            })
+        }
+        if (ccgoConfigured) {
+            add(DashboardHomeItem(USAGE_CCGO_CARD_ID) {
+                CommandCodeUsageStatsCard(onOpenDetail = onOpenCcgoUsageDetail, refreshTrigger = refreshTrigger)
+            })
+        }
+        // 热力图统计的是 OCGO 数据，未配置 OCGO 时同样不展示
+        if (ocgoConfigured) {
+            add(DashboardHomeItem(HEATMAP_CARD_ID) {
+                HeatmapEntryCard(onOpenHeatmap = onOpenHeatmap)
+            })
+        }
+        // 服务卡片：每个账号一张普通卡（同服务多账号即多张连续卡片，不叠放）
         cards.forEach { card ->
-            add(DashboardHomeItem("service:${card.service.storageKey}") {
+            // 多账号卡片用“账号 N”兜底显示名（同服务内默认账号在前，按展示顺序编号）
+            add(DashboardHomeItem(card.key) {
                 DashboardCard(
                     card = card,
-                    onClick = { onOpenService(card.service) },
+                    accountLabel = if (card.accountId != null) {
+                        card.accountLabel?.takeIf { it.isNotBlank() }
+                            ?: stringResource(R.string.account_fallback_name, accountOrdinal(cards, card))
+                    } else {
+                        null
+                    },
+                    onClick = { onOpenService(card.service, card.accountId) },
                     onOpenUsageDetail = when (card.service) {
                         ServiceType.OPENCODE_GO -> onOpenUsageDetail
                         ServiceType.COMMANDCODE_GO -> onOpenCcgoUsageDetail
                         else -> null
-                    }
+                    },
+                    // Token 活动热力图入口仅 OCGO 服务卡片显示（数据只统计 OCGO）
+                    onOpenHeatmap = if (card.service == ServiceType.OPENCODE_GO) onOpenHeatmap else null,
+                    // Sub2API 面板管理快捷入口（首页弹窗）：绑定当前卡片所属账号
+                    onOpenPanelManagement = if (card.service == ServiceType.SUB2API) {
+                        { accountId -> onOpenSub2PanelManagement(accountId ?: card.accountId) }
+                    } else {
+                        null
+                    },
+                    // 充值/订阅入口：有官方 externalUrl 的服务（DeepSeek/Trae/WorkBuddy）在卡片上直开
+                    onOpenRecharge = if (ServiceConfigProvider.get(card.service).externalUrl != null) {
+                        { onOpenRecharge(card.service) }
+                    } else {
+                        null
+                    },
                 )
             })
         }
     }
     val itemById = defaultItems.associateBy { it.id }
-    val ordered = order.mapNotNull { itemById[it] }
+    val ordered = order.mapNotNull { id ->
+        // 回退兼容：叠放实验期间保存过 "group:{storageKey}" 排序 id 的用户，
+        // 旧 id 映射为当前该服务第一张账号卡 key，避免升级回退后卡片掉尾
+        if (id.startsWith("group:")) {
+            val serviceKey = id.removePrefix("group:")
+            defaultItems.firstOrNull { it.id.startsWith("$serviceKey:") && it.id != id }?.id ?: id
+        } else {
+            id
+        }
+    }.mapNotNull { itemById[it] }
     return ordered + defaultItems.filterNot { item -> ordered.any { it.id == item.id } }
 }
 
+@Composable
+/** 同服务内账号序号（1 起，用于“账号 N”兜底显示）。 */
+private fun accountOrdinal(cards: List<DashboardCardUi>, card: DashboardCardUi): Int {
+    var idx = 1
+    for (c in cards) {
+        if (c.key == card.key) break
+        if (c.service == card.service) idx++
+    }
+    return idx
+}
+
+/** 历史排序 id → 当前 id。返回 null 表示该 id 无法对应任何卡片（忽略）。 */
+private fun migrateOrderId(id: String): String? {
+    // 最早格式："service:{storageKey}"
+    val servicePrefix = Regex("""^service:([^/:]+)$""").find(id)?.groupValues?.get(1)
+    if (servicePrefix != null) {
+        val svc = ServiceType.entries.firstOrNull { it.storageKey == servicePrefix } ?: return null
+        return if (ServiceType.isMultiAccount(svc)) {
+            "${svc.storageKey}:${CredentialRepository.LEGACY_DEFAULT_ACCOUNT_ID}"
+        } else {
+            "${svc.storageKey}:"
+        }
+    }
+    // 旧默认账号 key：多账号服务 "{key}:" → "{key}:default"（其余账号 key 原样保留）
+    val sep = id.indexOf(':')
+    if (sep > 0) {
+        val key = id.substring(0, sep)
+        val svc = ServiceType.entries.firstOrNull { it.storageKey == key } ?: return id
+        if (ServiceType.isMultiAccount(svc) && id.endsWith(":")) {
+            return "$key:${CredentialRepository.LEGACY_DEFAULT_ACCOUNT_ID}"
+        }
+    }
+    return id
+}
+
 @Composable
 private fun DraggableDashboardCards(
     items: List<DashboardHomeItem>,
@@ -618,7 +900,15 @@ private fun DraggableDashboardCards(
 }
 
 @Composable
-private fun DashboardCard(card: DashboardCardUi, onClick: () -> Unit, onOpenUsageDetail: (() -> Unit)? = null) {
+private fun DashboardCard(
+    card: DashboardCardUi,
+    accountLabel: String? = null,
+    onClick: () -> Unit,
+    onOpenUsageDetail: (() -> Unit)? = null,
+    onOpenHeatmap: (() -> Unit)? = null,
+    onOpenPanelManagement: ((String?) -> Unit)? = null,
+    onOpenRecharge: (() -> Unit)? = null,
+) {
     Card(
         modifier = Modifier
             .fillMaxWidth()
@@ -630,20 +920,68 @@ private fun DashboardCard(card: DashboardCardUi, onClick: () -> Unit, onOpenUsag
         Column(modifier = Modifier.padding(16.dp)) {
             // ─── 顶部：图标 + 名称 + 状态 chip ───
             Row(verticalAlignment = Alignment.CenterVertically) {
-                ServiceIcon(service = card.service, size = 44)
+                if (card.service == ServiceType.SUB2API && card.siteIcon != null) {
+                    // Sub2API 面板登录后用站点真实 Logo 替换内置图标
+                    SiteIcon(url = card.siteIcon, size = 44.dp)
+                } else {
+                    ServiceIcon(service = card.service, size = 44)
+                }
                 Spacer(modifier = Modifier.width(12.dp))
                 Column(modifier = Modifier.weight(1f)) {
+                    Row(verticalAlignment = Alignment.CenterVertically) {
+                        Text(
+                            text = card.service.displayName,
+                            style = MaterialTheme.typography.titleMedium,
+                            fontWeight = FontWeight.SemiBold
+                        )
+                        // 多账号：默认账号在卡片标题旁标「默认」
+                        if (card.accountId != null && card.isDefaultAccount) {
+                            Spacer(modifier = Modifier.width(6.dp))
+                            Text(
+                                text = stringResource(R.string.account_default_badge),
+                                style = MaterialTheme.typography.labelSmall,
+                                color = StrawberryPink,
+                                maxLines = 1,
+                                softWrap = false,
+                                modifier = Modifier
+                                    .clip(RoundedCornerShape(8.dp))
+                                    .background(StrawberryPink.copy(alpha = 0.12f))
+                                    .padding(horizontal = 6.dp, vertical = 1.dp)
+                            )
+                        }
+                    }
                     Text(
-                        text = card.service.displayName,
-                        style = MaterialTheme.typography.titleMedium,
-                        fontWeight = FontWeight.SemiBold
-                    )
-                    Text(
-                        text = secondaryLine(card),
+                        // Sub2API 显示登录方式；Trae/WorkBuddy 显示「账号 N · 订阅状态」；
+                        // 其余服务用固定描述
+                        text = when (card.service) {
+                            ServiceType.SUB2API -> sub2AuthModeText(card)
+                            ServiceType.TRAE, ServiceType.WORKBUDDY -> {
+                                val sub = subscriptionLine(card) ?: stringResource(secondaryLineRes(card))
+                                if (card.accountId != null && accountLabel != null) {
+                                    "$accountLabel · $sub"
+                                } else {
+                                    sub
+                                }
+                            }
+                            else -> stringResource(secondaryLineRes(card))
+                        },
                         style = MaterialTheme.typography.bodySmall,
                         color = inkMuted()
                     )
                 }
+                // 今日已签到角标（Trae/WorkBuddy）：让用户在首页即知签到状态，不用点进详情
+                if (card.checkedInToday) {
+                    Spacer(modifier = Modifier.width(8.dp))
+                    Text(
+                        text = stringResource(R.string.checkin_badge_today),
+                        style = MaterialTheme.typography.labelSmall,
+                        color = StrawberryPink,
+                        modifier = Modifier
+                            .clip(RoundedCornerShape(8.dp))
+                            .background(StrawberryPink.copy(alpha = 0.12f))
+                            .padding(horizontal = 6.dp, vertical = 2.dp)
+                    )
+                }
                 StatusChip(style = card.statusBadgeStyle())
             }
 
@@ -652,31 +990,204 @@ private fun DashboardCard(card: DashboardCardUi, onClick: () -> Unit, onOpenUsag
             // ─── 主体：服务特定的主信息 ───
             BalanceMainArea(card)
 
-            // 用量服务卡片底部：用量详情入口（仅当有凭证时显示）
+            // 用量服务卡片底部：用量详情入口 + Token 活动快捷入口（仅当有凭证时显示）
             if (onOpenUsageDetail != null && card.credentialState != com.rainy.token.domain.model.CredentialStatus.State.NOT_CONFIGURED) {
                 Spacer(modifier = Modifier.height(8.dp))
-                TextButton(onClick = onOpenUsageDetail) {
-                    Text("查看用量详情", color = StrawberryPink)
-                    Spacer(modifier = Modifier.width(2.dp))
-                    Icon(
-                        imageVector = Icons.Filled.KeyboardArrowRight,
-                        contentDescription = null,
-                        tint = StrawberryPink,
-                        modifier = Modifier.padding(top = 1.dp)
-                    )
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    TextButton(onClick = onOpenUsageDetail) {
+                        Text(
+                            stringResource(R.string.action_view_usage_detail),
+                            color = StrawberryPink,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis,
+                        )
+                        Spacer(modifier = Modifier.width(2.dp))
+                        Icon(
+                            imageVector = Icons.Filled.KeyboardArrowRight,
+                            contentDescription = null,
+                            tint = StrawberryPink,
+                            modifier = Modifier.padding(top = 1.dp)
+                        )
+                    }
+                    // 弹性间距：窄屏/英文长文案时优先压缩间距，避免按钮折行变形
+                    Spacer(modifier = Modifier.weight(1f))
+                    if (onOpenHeatmap != null) {
+                        // OCGO Token 活动热力图快捷入口（与"查看用量详情"并列，右对齐）
+                        TextButton(onClick = onOpenHeatmap) {
+                            Text(
+                                stringResource(R.string.heatmap_quick_entry),
+                                color = StrawberryPink,
+                                maxLines = 1,
+                                overflow = TextOverflow.Ellipsis,
+                            )
+                            Spacer(modifier = Modifier.width(2.dp))
+                            Icon(
+                                imageVector = Icons.Filled.KeyboardArrowRight,
+                                contentDescription = null,
+                                tint = StrawberryPink,
+                                modifier = Modifier.padding(top = 1.dp)
+                            )
+                        }
+                    }
                 }
             }
 
-            // ─── 底部：更新时间 / 错误信息 ───
+            // ─── 底部：左侧更新时间/错误信息，右侧「面板管理 / 充值订阅」入口（同一行、右对齐）───
             Spacer(modifier = Modifier.height(12.dp))
-            Text(
-                text = footerText(card),
-                style = MaterialTheme.typography.bodySmall,
-                color = if (card.lastFetchError != null)
-                    MaterialTheme.colorScheme.error
-                else
-                    inkMuted()
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(
+                    text = footerText(card).asString(),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = if (card.lastFetchError != null)
+                        MaterialTheme.colorScheme.error
+                    else
+                        inkMuted(),
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    // 占据全部剩余宽度，把右侧按钮顶到卡片最右边。
+                    // 注意不能再用一个 Spacer(weight) 平分剩余空间——那样按钮只会到中间。
+                    modifier = Modifier.weight(1f)
+                )
+                if (card.service == ServiceType.SUB2API &&
+                    card.credentialState != CredentialStatus.State.NOT_CONFIGURED &&
+                    onOpenPanelManagement != null
+                ) {
+                    // 清零内边距让文字贴到卡片右内缘。
+                    // 注意：Material3 的最小尺寸挂在 TextButton 内层节点上，外层 modifier 传
+                    // defaultMinSize(0) 压不下去（实测为 no-op），这里不再写无用约束。
+                    TextButton(
+                        onClick = { onOpenPanelManagement?.invoke(card.accountId) },
+                        contentPadding = PaddingValues(0.dp)
+                    ) {
+                        Text(
+                            stringResource(R.string.sub2_panel_manage_title),
+                            color = StrawberryPink,
+                            style = MaterialTheme.typography.bodySmall,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
+                        )
+                        Spacer(modifier = Modifier.width(2.dp))
+                        Icon(
+                            imageVector = Icons.Filled.KeyboardArrowRight,
+                            contentDescription = null,
+                            tint = StrawberryPink,
+                            // 图标盒即箭头可视范围；不用 offset 微调（offset 只改放置不改测量，
+                            // 会让右移的那几 dp 落在按钮命中区之外造成误触）。
+                            modifier = Modifier.size(14.dp)
+                        )
+                    }
+                }
+                // 充值/订阅入口（DeepSeek/Trae/WorkBuddy 等有官方 externalUrl 的服务）：
+                // 与「面板管理」同款式同位置，点开 App 内 WebView 到官方充值/订阅页
+                if (onOpenRecharge != null &&
+                    card.credentialState != CredentialStatus.State.NOT_CONFIGURED
+                ) {
+                    TextButton(
+                        onClick = onOpenRecharge,
+                        contentPadding = PaddingValues(0.dp),
+                        modifier = Modifier.padding(start = 8.dp)
+                    ) {
+                        Text(
+                            stringResource(R.string.action_subscribe_recharge),
+                            color = StrawberryPink,
+                            style = MaterialTheme.typography.bodySmall,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
+                        )
+                        Spacer(modifier = Modifier.width(2.dp))
+                        Icon(
+                            imageVector = Icons.Filled.KeyboardArrowRight,
+                            contentDescription = null,
+                            tint = StrawberryPink,
+                            modifier = Modifier.size(14.dp)
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Token 活动热力图入口卡片。
+ * 白底圆角，左侧日历图标，中间标题，右侧箭头，点击跳转热力图页面。
+ */
+@Composable
+private fun HeatmapEntryCard(onOpenHeatmap: () -> Unit) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable { onOpenHeatmap() },
+        shape = RoundedCornerShape(20.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Icon(
+                imageVector = Icons.Filled.DateRange,
+                contentDescription = null,
+                tint = StrawberryPink,
+                modifier = Modifier.size(44.dp)
             )
+            Spacer(modifier = Modifier.width(12.dp))
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = stringResource(R.string.heatmap_entry),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.SemiBold
+                )
+                Text(
+                    text = stringResource(R.string.heatmap_entry_subtitle),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = inkMuted()
+                )
+            }
+            Icon(
+                imageVector = Icons.Filled.KeyboardArrowRight,
+                contentDescription = null,
+                tint = StrawberryPink
+            )
+        }
+    }
+}
+
+/**
+ * 空态引导卡：首页仅显示已配置的服务，当一个都没配置时给出引导。
+ */
+@Composable
+private fun EmptyServicesHintCard(onOpenSettings: () -> Unit) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(20.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            horizontalAlignment = Alignment.CenterHorizontally
+        ) {
+            Text(
+                text = stringResource(R.string.dashboard_empty_title),
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.SemiBold
+            )
+            Spacer(modifier = Modifier.height(4.dp))
+            Text(
+                text = stringResource(R.string.dashboard_empty_subtitle),
+                style = MaterialTheme.typography.bodySmall,
+                color = inkMuted()
+            )
+            Spacer(modifier = Modifier.height(12.dp))
+            OutlinedButton(onClick = onOpenSettings) {
+                Text(stringResource(R.string.dashboard_empty_go_settings))
+            }
         }
     }
 }
@@ -694,13 +1205,13 @@ private fun DashboardFooter() {
         horizontalAlignment = Alignment.CenterHorizontally
     ) {
         Text(
-            text = "RainyToken · v1.0",
+            text = stringResource(R.string.dashboard_footer_version, BuildConfig.VERSION_NAME),
             style = MaterialTheme.typography.bodySmall,
             color = inkMuted()
         )
         Spacer(modifier = Modifier.height(4.dp))
         Text(
-            text = "本地加密存储，不上传任何数据",
+            text = stringResource(R.string.dashboard_footer_privacy),
             style = MaterialTheme.typography.bodySmall,
             color = inkMuted()
         )
@@ -726,14 +1237,14 @@ private fun requestRainyTokenWidgetPin(context: Context) {
     val appWidgetManager = AppWidgetManager.getInstance(context)
     val component = ComponentName(context, OpenCodeGoWidgetProvider::class.java)
     if (!canInstallLauncherShortcut(context)) {
-        Toast.makeText(context, "桌面快捷方式权限已被拒绝，请在系统设置中允许后重试", Toast.LENGTH_LONG).show()
+        Toast.makeText(context, context.getString(R.string.toast_shortcut_permission_denied), Toast.LENGTH_LONG).show()
         return
     }
 
     if (appWidgetManager.isRequestPinAppWidgetSupported) {
         val requested = appWidgetManager.requestPinAppWidget(component, null, null)
         if (!requested) {
-            Toast.makeText(context, "桌面未接受添加请求，请检查启动器权限", Toast.LENGTH_LONG).show()
+            Toast.makeText(context, context.getString(R.string.toast_add_rejected), Toast.LENGTH_LONG).show()
         }
         return
     }
@@ -745,6 +1256,6 @@ private fun requestRainyTokenWidgetPin(context: Context) {
     if (canOpenPicker) {
         context.startActivity(pickerIntent)
     } else {
-        Toast.makeText(context, "当前桌面不支持应用内添加，请在桌面长按 → 小组件 → 查找雨晴Token", Toast.LENGTH_LONG).show()
+        Toast.makeText(context, context.getString(R.string.toast_picker_unsupported), Toast.LENGTH_LONG).show()
     }
 }

app/src/main/java/com/rainy/token/ui/dashboard/DashboardViewModel.kt

@@ -7,13 +7,18 @@ import com.rainy.token.data.cache.CachedBalance
 import com.rainy.token.data.repository.CredentialRepository
 import com.rainy.token.data.repository.RepositoryError
 import com.rainy.token.domain.model.CredentialStatus
+import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.model.ServiceBalance
 import com.rainy.token.domain.service.ServiceType
 import com.rainy.token.domain.usecase.RefreshBalanceUseCase
+import com.rainy.token.R
+import com.rainy.token.ui.components.UiText
+import com.rainy.token.ui.dashboard.autocheckin.CHECKIN_SERVICES
 import com.rainy.token.ui.widget.OpenCodeGoWidgetProvider
 import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
@@ -36,10 +41,13 @@ import kotlinx.coroutines.sync.Mutex
 class DashboardViewModel @Inject constructor(
     private val credentialRepository: CredentialRepository,
     private val refreshBalanceUseCase: RefreshBalanceUseCase,
-    @param:ApplicationContext private val appContext: Context
+    private val checkinStatusStore: com.rainy.token.data.repository.CheckinStatusStore,
+    private val autoCheckinManager: com.rainy.token.ui.dashboard.autocheckin.AutoCheckinManager,
+    @param:ApplicationContext private val appContext: Context,
+    private val sub2ApiRepository: com.rainy.token.data.repository.Sub2ApiRepository
 ) : ViewModel() {
 
-    private val _uiState = MutableStateFlow(DashboardUiState())
+    private val _uiState = MutableStateFlow(DashboardUiState(loading = true))
     val uiState: StateFlow<DashboardUiState> = _uiState.asStateFlow()
 
     /** 防止并发 refresh() 调用交错覆盖 UI。 */
@@ -47,94 +55,152 @@ class DashboardViewModel @Inject constructor(
 
     init {
         viewModelScope.launch {
-            // 1) 先从缓存快速填充 UI（断网时也能看旧数据）
+            // 1) 先从缓存快速填充 UI（不阻塞首帧，断网时也能看旧数据）
             loadFromCache()
-            // 2) 再发起网络刷新——此时 UI 已有缓存兜底，不会闪回旧值
+            // 2) 每日自动签到：必须先于 refresh() 串行完成。两者并发会对同一服务取
+            // 相同凭据快照，后提交者因快照过期被丢弃（CredentialChanged），而签到
+            // 在服务端已成功、角标也已落库 → 弹窗报「凭据」错误但积分实际到账，
+            // 展示自相矛盾。串行后签到先落库，refresh 再拉到含新积分的余额。
+            // 用 try/catch 而非 runCatching：后者会吞掉 CancellationException，
+            // 导致 ViewModel 销毁取消后协程仍继续往下跑。
+            // 2.5) 打开 App 时把零点后台闹钟重排到下次零点（开机/升级/后台被杀后的兜底）
+            autoCheckinManager.refreshSchedule()
+            try {
+                autoCheckinManager.runDailyIfDue()
+            } catch (cancelled: CancellationException) {
+                throw cancelled
+            } catch (_: Exception) {
+                // 签到失败不阻塞余额刷新
+            }
+            // 3) 发起网络刷新——此时 UI 已有缓存兜底，不会闪回旧值
             refresh()
+            // 4) 同步签到状态到本地记录并重建角标（跨设备/旧版本签过的也能显示）
+            syncCheckinStatus()
         }
     }
 
     /**
-     * 重新读取本地凭据状态 + 余额缓存，不发起网络请求。
+     * 首页自己查询签到状态（不依赖进详情页触发）：
+     * 本地无当日记录的账号问一次服务端 status，已签的回写 [CheckinStatusStore] 后重建卡片角标。
+     */
+    private suspend fun syncCheckinStatus() {
+        val accountStates = credentialRepository.readAccountStates()
+        val toQuery = accountStates.filter { entry ->
+            entry.service in CHECKIN_SERVICES &&
+                entry.credential != null &&
+                !checkinStatusStore.isCheckedToday(entry.service, entry.account?.id)
+        }
+        if (toQuery.isEmpty()) return
+        val newlyChecked = toQuery.filter { entry ->
+            runCatching {
+                when (entry.service) {
+                    ServiceType.TRAE ->
+                        refreshBalanceUseCase.fetchTraeCheckinStatus(entry.account?.id).getOrNull() == true
+                    ServiceType.WORKBUDDY ->
+                        refreshBalanceUseCase.fetchCheckinStatus(entry.account?.id).getOrNull()?.todayCheckedIn == true
+                    else -> false
+                }
+            }.getOrDefault(false)
+        }
+        if (newlyChecked.isEmpty()) return
+        newlyChecked.forEach { checkinStatusStore.markChecked(it.service, it.account?.id) }
+        // 用最新记录更新卡片角标：按 store 真值重算（已有记录的账号不被误清）
+        _uiState.update { state ->
+            state.copy(cards = state.cards.map { card ->
+                card.copy(
+                    checkedInToday = card.service in CHECKIN_SERVICES &&
+                        checkinStatusStore.isCheckedToday(card.service, card.accountId)
+                )
+            })
+        }
+    }
+
+    /** 自动签到结果（非 null 时首页弹「xx 已签到」汇报弹窗；关闭后置 null）。 */
+    val autoCheckinReport: StateFlow<List<com.rainy.token.ui.dashboard.autocheckin.AutoCheckinManager.ServiceResult>?> =
+        autoCheckinManager.report
+
+    /** 自动签到开关状态（首页顶部提示行右侧 Switch）。 */
+    private val _autoCheckinEnabled = MutableStateFlow(autoCheckinManager.enabled)
+    val autoCheckinEnabled: StateFlow<Boolean> = _autoCheckinEnabled.asStateFlow()
+
+    fun setAutoCheckinEnabled(value: Boolean) {
+        autoCheckinManager.enabled = value
+        _autoCheckinEnabled.value = value
+    }
+
+    fun consumeAutoCheckinReport() = autoCheckinManager.consumeReport()
+
+    /**
+     * 重新读取本地凭据状态 + 余额缓存，不自动发起网络请求（除非发现已配置
+     * 但没有余额缓存的"新账号"，此时拉一次余额让首页立刻有数据，不用等进详情页）。
      *
      * 卡片记录不含明文密钥的 SHA-256 指纹。更新时始终基于 _uiState 的最新卡片：
-     * - 凭据变化时采用已清理过的当前账户缓存；
-     * - 凭据未变时按 fetchedAt 采用更新缓存，支持 Widget 后台刷新结果回显；
+     * - 以当前已配置服务（configuredTypes）为准重建，新增服务即时出现、删除服务即时消失；
+     * - 仍存在的服务复用旧卡片做增量合并：
+     *   - 凭据变化时采用已清理过的当前账户缓存；
+     *   - 凭据未变时按 fetchedAt 采用更新缓存，支持 Widget 后台刷新结果回显；
      * - 不修改 refreshing，旧缓存快照也不能回滚新数据。
      */
     fun reloadLocalState() {
         viewModelScope.launch {
-            val localStates = credentialRepository.readLocalStates()
+            val accountStates = credentialRepository.readAccountStates()
             _uiState.update { state ->
-                state.copy(
-                    cards = state.cards.map { card ->
-                        val local = localStates.getValue(card.service)
-                        val credentialChanged = local.fingerprint != card.credentialFingerprint
-                        val cacheAdvanced = !credentialChanged && isNewer(
-                            candidate = local.cachedBalance,
-                            current = card.cachedBalance
-                        )
-                        card.copy(
-                            credentialState = local.status.state,
-                            credentialFingerprint = local.fingerprint,
-                            cachedBalance = if (credentialChanged) {
-                                local.cachedBalance
-                            } else {
-                                newerOf(card.cachedBalance, local.cachedBalance)
-                            },
-                            // 凭据变化或出现更新的成功缓存时，旧错误已不再代表当前数据。
-                            lastFetchError = if (credentialChanged || cacheAdvanced) {
-                                null
-                            } else {
-                                card.lastFetchError
-                            }
-                        )
-                    }
-                )
+                state.copy(cards = rebuildCardsPreservingOrder(state, accountStates))
             }
+            // 登录/导入后刚出现的账号还没有余额缓存：立即拉一次，首页即刻看到
+            // 余额与角标，不用等用户点进详情页才触发刷新（刷新内部有 Mutex 防并发）。
+            val hasFreshAccountWithoutCache = accountStates.any { entry ->
+                entry.status.state != CredentialStatus.State.NOT_CONFIGURED &&
+                    entry.cachedBalance == null
+            }
+            if (hasFreshAccountWithoutCache) refresh()
         }
     }
 
     /** 从本地缓存快速填充一次（不阻塞）。挂起函数，供调用方控制执行顺序。 */
     private suspend fun loadFromCache() {
-        val localStates = credentialRepository.readLocalStates()
-        val cards = ServiceType.entries.map { type ->
-            buildCard(localStates.getValue(type), lastFetchError = null)
+        val accountStates = credentialRepository.readAccountStates()
+        val entries = orderAccountEntries(accountStates)
+        val cards = entries.map { entry ->
+            buildCard(entry, lastFetchError = null)
         }
         _uiState.update { it.copy(loading = false, refreshing = false, cards = cards) }
     }
 
-    /** 拉取所有服务最新余额，更新缓存。失败的服务保留旧数据并把错误信息带上。 */
+    /** 拉取所有已配置账号的最新余额，更新缓存。失败保留旧数据并把错误信息带上。 */
     fun refresh() {
         viewModelScope.launch {
             // Mutex 防并发：如果已有 refresh 在跑，后来的直接跳过
             if (!refreshMutex.tryLock()) return@launch
             try {
                 _uiState.update { it.copy(refreshing = true) }
-                val results: Map<ServiceType, Result<ServiceBalance>?> = coroutineScope {
-                    ServiceType.entries.map { type ->
+                val results: Map<AccountKey, Result<ServiceBalance>?> = coroutineScope {
+                    val entries = orderAccountEntries(credentialRepository.readAccountStates())
+                    entries.map { entry ->
                         async {
-                            val status = credentialRepository.statusFor(type)
-                            if (status.state == CredentialStatus.State.NOT_CONFIGURED) {
-                                type to null // 未配置的服务不拉
-                            } else {
-                                type to refreshBalanceUseCase(type)
-                            }
+                            val key = AccountKey(entry.service, entry.account?.id)
+                            val result: Result<ServiceBalance>? =
+                                if (entry.status.state == CredentialStatus.State.NOT_CONFIGURED) {
+                                    null // 未配置的账号不拉
+                                } else {
+                                    refreshBalanceUseCase(entry.service, entry.account?.id)
+                                }
+                            key to result
                         }
-                    }.awaitAll().toMap()
+                    }.awaitAll().associateBy({ it.first }, { it.second })
                 }
-                val localStates = credentialRepository.readLocalStates()
-                val cards = ServiceType.entries.map { type ->
-                    val result = results[type]
-                    val error = result?.exceptionOrNull()
-                    val errMsg = error
+                val accountStates = credentialRepository.readAccountStates()
+                val cards = orderAccountEntries(accountStates).map { entry ->
+                    val key = AccountKey(entry.service, entry.account?.id)
+                    val error = results[key]?.exceptionOrNull()
+                    val errorUi = error
                         ?.takeUnless { it is RepositoryError.CredentialChanged }
-                        ?.message
-                    buildCard(localStates.getValue(type), lastFetchError = errMsg)
+                        ?.let { errorToUiText(it) }
+                    buildCard(entry, lastFetchError = errorUi)
                 }
                 _uiState.update { it.copy(refreshing = false, cards = cards) }
                 // 刷新成功后更新桌面小组件
-                if (results[ServiceType.OPENCODE_GO]?.isSuccess == true) {
+                if (results[AccountKey(ServiceType.OPENCODE_GO, null)]?.isSuccess == true) {
                     OpenCodeGoWidgetProvider.notifyDataChanged(appContext)
                 }
             } finally {
@@ -143,15 +209,85 @@ class DashboardViewModel @Inject constructor(
         }
     }
 
+    /**
+     * 基于最新账号状态重建卡片列表，尽量保留旧顺序：
+     *  - 同一服务内默认账号在前，其余按账号创建顺序；
+     *  - 新增账号追加到同服务现有卡片之后；服务整体顺序沿用旧顺序，新服务按枚举追加。
+     */
+    private fun rebuildCardsPreservingOrder(
+        state: DashboardUiState,
+        accountStates: List<CredentialRepository.AccountLocalState>
+    ): List<DashboardCardUi> {
+        val entries = orderAccountEntries(accountStates)
+        val previousByKey = state.cards.associateBy { it.key }
+        return entries.mapIndexed { _, entry ->
+            val key = entry.service.storageKey + ":" + entry.account?.id.orEmpty()
+            val previous = previousByKey[key]
+            if (previous == null) {
+                buildCard(entry, lastFetchError = null)
+            } else {
+                val credentialChanged = entry.fingerprint != previous.credentialFingerprint
+                val cacheAdvanced = !credentialChanged && isNewer(
+                    candidate = entry.cachedBalance,
+                    current = previous.cachedBalance
+                )
+                previous.copy(
+                    credentialState = entry.status.state,
+                    credentialFingerprint = entry.fingerprint,
+                    cachedBalance = if (credentialChanged) {
+                        entry.cachedBalance
+                    } else {
+                        newerOf(previous.cachedBalance, entry.cachedBalance)
+                    },
+                    lastFetchError = if (credentialChanged || cacheAdvanced) {
+                        null
+                    } else {
+                        previous.lastFetchError
+                    },
+                    // 账号默认状态在设置页改动后返回时也要同步
+                    isDefaultAccount = entry.account?.isDefault == true,
+                    // 签到角标每次 resume 重算：详情页手动签到后返回首页要立刻看到 ✓
+                    checkedInToday = entry.service in CHECKIN_SERVICES &&
+                        checkinStatusStore.isCheckedToday(entry.service, entry.account?.id)
+                )
+            }
+        }
+    }
+
+    /** 账号条目排序：服务按旧顺序/枚举，服务内默认账号优先、其余按存储顺序。 */
+    private fun orderAccountEntries(
+        accountStates: List<CredentialRepository.AccountLocalState>
+    ): List<CredentialRepository.AccountLocalState> {
+        val existingOrder = _uiState.value.cards
+            .mapIndexed { index, card -> card.service to index }
+            .toMap()
+        return accountStates.sortedWith(
+            compareBy(
+                { existingOrder[it.service] ?: Int.MAX_VALUE },
+                { it.service.ordinal },
+                { if (it.account?.isDefault == true) 0 else 1 },
+                { it.account?.createdAt ?: 0L }
+            )
+        )
+    }
+
     private fun buildCard(
-        local: CredentialRepository.LocalState,
-        lastFetchError: String?
+        local: CredentialRepository.AccountLocalState,
+        lastFetchError: UiText?
     ): DashboardCardUi = DashboardCardUi(
-        service = local.status.service,
+        service = local.service,
+        accountId = local.account?.id,
+        accountLabel = local.account?.label,
+        accountIndex = 0, // 展示兜底名称时由 UI 根据同服务卡片顺序计算
+        isDefaultAccount = local.account?.isDefault == true,
         credentialState = local.status.state,
         credentialFingerprint = local.fingerprint,
         cachedBalance = local.cachedBalance,
-        lastFetchError = lastFetchError
+        lastFetchError = lastFetchError,
+        siteIcon = (local.credential as? Credential.Sub2ApiCredential)?.siteIcon,
+        // 可签到服务（Trae/WorkBuddy）各账号的今日签到角标；其它服务恒 false 不显示
+        checkedInToday = local.service in CHECKIN_SERVICES &&
+            checkinStatusStore.isCheckedToday(local.service, local.account?.id)
     )
 
     private fun newerOf(
@@ -168,6 +304,140 @@ class DashboardViewModel @Inject constructor(
         candidate: CachedBalance?,
         current: CachedBalance?
     ): Boolean = candidate != null && (current == null || candidate.fetchedAt > current.fetchedAt)
+
+    // ---------- Sub2API 面板管理（Key 列表/新建/分组/兑换） ----------
+
+    /** Key 列表状态。 */
+    private val _panelKeysState = MutableStateFlow<com.rainy.token.ui.servicedetail.PanelKeysState>(
+        com.rainy.token.ui.servicedetail.PanelKeysState.Idle
+    )
+    val panelKeysState: StateFlow<com.rainy.token.ui.servicedetail.PanelKeysState> = _panelKeysState.asStateFlow()
+
+    /** 可用分组（新建 Key / 切分组下拉）。 */
+    private val _panelGroups = MutableStateFlow<List<com.rainy.token.data.repository.Sub2ApiRepository.PanelGroup>>(emptyList())
+    val panelGroups: StateFlow<List<com.rainy.token.data.repository.Sub2ApiRepository.PanelGroup>> = _panelGroups.asStateFlow()
+
+    /** 一次性操作结果消息（新建/切组/兑换）。 */
+    private val _panelActionMessage = MutableStateFlow<String?>(null)
+    val panelActionMessage: StateFlow<String?> = _panelActionMessage.asStateFlow()
+
+    fun consumePanelActionMessage() { _panelActionMessage.value = null }
+
+    /** 首页面板弹窗当前管理的 Sub2API 账号（null=默认账号）。 */
+    private val _sub2PanelAccountId = MutableStateFlow<String?>(null)
+    val sub2PanelAccountId: StateFlow<String?> = _sub2PanelAccountId.asStateFlow()
+
+    /** 打开首页面板弹窗并绑定目标账号，同时重置为未加载状态。 */
+    fun openSub2Panel(accountId: String?) {
+        _sub2PanelAccountId.value = accountId
+        _panelKeysState.value = com.rainy.token.ui.servicedetail.PanelKeysState.Idle
+        _panelGroups.value = emptyList()
+        _panelGroupsAccountId = null
+        _panelActionMessage.value = null
+        _recentlyCreatedKey.value = null
+    }
+
+    /** 最近一次新建成功的明文 Key（弹窗立即复制用；查看后清除）。 */
+    private val _recentlyCreatedKey = MutableStateFlow<String?>(null)
+    val recentlyCreatedKey: StateFlow<String?> = _recentlyCreatedKey.asStateFlow()
+
+    fun consumeRecentlyCreatedKey() { _recentlyCreatedKey.value = null }
+
+    /** 刷新面板 Key 列表（仅 SUB2API 且有面板 Token）。 */
+    fun loadPanelKeys() {
+        viewModelScope.launch {
+            if (_panelKeysState.value is com.rainy.token.ui.servicedetail.PanelKeysState.Loading) return@launch
+            _panelKeysState.value = com.rainy.token.ui.servicedetail.PanelKeysState.Loading
+            sub2ApiRepository.fetchPanelKeys(_sub2PanelAccountId.value).fold(
+                onSuccess = { list ->
+                    _panelKeysState.value = com.rainy.token.ui.servicedetail.PanelKeysState.Success(list)
+                },
+                onFailure = { e ->
+                    _panelKeysState.value = com.rainy.token.ui.servicedetail.PanelKeysState.Error(e.message ?: "加载 Key 列表失败")
+                }
+            )
+        }
+    }
+
+    /** 面板分组缓存所属账号（防止切换账号后仍显示上一个账号的分组）。 */
+    private var _panelGroupsAccountId: String? = null
+
+    /** 加载可用分组；同一账号加载过一次则跳过，切换账号后强制重拉。 */
+    fun loadPanelGroups() {
+        viewModelScope.launch {
+            val accountId = _sub2PanelAccountId.value
+            if (_panelGroupsAccountId == accountId && _panelGroups.value.isNotEmpty()) return@launch
+            sub2ApiRepository.fetchPanelGroups(accountId).fold(
+                onSuccess = {
+                    _panelGroups.value = it
+                    _panelGroupsAccountId = accountId
+                },
+                onFailure = {
+                    // 分组加载失败不阻塞主流程（新建 Key 时可不选分组）
+                }
+            )
+        }
+    }
+
+    /** 新建 API Key：成功后展示掩码消息并刷新列表。 */
+    fun createPanelKey(name: String, groupId: Long?) {
+        viewModelScope.launch {
+            sub2ApiRepository.createPanelKey(name, groupId, _sub2PanelAccountId.value).fold(
+                onSuccess = { key ->
+                    _recentlyCreatedKey.value = key
+                    _panelActionMessage.value = "已创建 Key：" + maskPanelKey(key) + "（请在弹出的窗口复制完整 Key）"
+                    loadPanelKeys()
+                },
+                onFailure = { e -> _panelActionMessage.value = "创建失败：" + (e.message ?: "") }
+            )
+        }
+    }
+
+    /** 切换 Key 所属分组：成功后刷新列表。 */
+    fun switchPanelGroup(keyId: Long, groupId: Long) {
+        viewModelScope.launch {
+            sub2ApiRepository.updatePanelKey(keyId, groupId, accountId = _sub2PanelAccountId.value).fold(
+                onSuccess = {
+                    _panelActionMessage.value = "分组已切换"
+                    loadPanelKeys()
+                },
+                onFailure = { e -> _panelActionMessage.value = "切换失败：" + (e.message ?: "") }
+            )
+        }
+    }
+
+    /** 删除 Key：成功后刷新列表。 */
+    fun deletePanelKey(keyId: Long) {
+        viewModelScope.launch {
+            sub2ApiRepository.deletePanelKey(keyId, _sub2PanelAccountId.value).fold(
+                onSuccess = {
+                    _panelActionMessage.value = "已删除 Key"
+                    loadPanelKeys()
+                },
+                onFailure = { e -> _panelActionMessage.value = "删除失败：" + (e.message ?: "") }
+            )
+        }
+    }
+
+    /** 兑换卡密：成功后刷新余额与 Key 列表。 */
+    fun redeemPanelCode(code: String) {
+        viewModelScope.launch {
+            sub2ApiRepository.redeemPanelCode(code, _sub2PanelAccountId.value).fold(
+                onSuccess = { msg ->
+                    _panelActionMessage.value = msg
+                    refreshBalanceUseCase(ServiceType.SUB2API, _sub2PanelAccountId.value)
+                    loadPanelKeys()
+                },
+                onFailure = { e -> _panelActionMessage.value = "兑换失败：" + (e.message ?: "") }
+            )
+        }
+    }
+
+    /** 面板 API Key 展示用掩码：只留前 8 + 后 4 位，避免页面显示过长。 */
+    private fun maskPanelKey(key: String): String = when {
+        key.length <= 16 -> key
+        else -> key.take(8) + "…" + key.takeLast(4)
+    }
 }
 
 data class DashboardUiState(
@@ -178,19 +448,63 @@ data class DashboardUiState(
 
 data class DashboardCardUi(
     val service: ServiceType,
+    /** 账号 ID（多账号服务）；null=单账号服务。 */
+    val accountId: String? = null,
+    /** 账号自定义名称（可能为 null，UI 按“账号 N”兜底）。 */
+    val accountLabel: String? = null,
+    /** 同服务内的账号序号（0 起，用于兜底名称；由 UI 层计算后回写展示）。 */
+    val accountIndex: Int = 0,
+    /** 是否为默认账号（多账号服务）。 */
+    val isDefaultAccount: Boolean = false,
     val credentialState: CredentialStatus.State,
     val credentialFingerprint: String?,
     val cachedBalance: CachedBalance?,
-    val lastFetchError: String?
+    val lastFetchError: UiText?,
+    /** 站点 Logo URL（Sub2API 面板登录后抓取；非空时主页卡片用它替换内置图标）。 */
+    val siteIcon: String? = null,
+    /** 今日已签到角标（仅可签到服务有值，见 [CHECKIN_SERVICES]）。 */
+    val checkedInToday: Boolean = false
 ) {
     /** 余额展示主数字。优先取缓存，错误时也展示（不隐藏，让用户看到旧值 + 红点提示）。 */
     val displayBalance: ServiceBalance? get() = cachedBalance?.balance
 
-    /** 卡片顶部状态徽章。 */
-    val statusBadge: String get() = when {
-        credentialState == CredentialStatus.State.NOT_CONFIGURED -> "未配置"
-        lastFetchError != null -> "刷新失败"
-        cachedBalance == null -> "未获取"
-        else -> "正常"
-    }
+    /** 卡片唯一键：`{storageKey}:{accountId}`，单账号服务为 `{storageKey}:`。 */
+    val key: String get() = "${service.storageKey}:${accountId.orEmpty()}"
+}
+
+/** 内部请求/结果键：账号粒度（多账号服务逐账号拉取）。 */
+private data class AccountKey(
+    val service: ServiceType,
+    val accountId: String? = null
+)
+
+/** 把 Repository 错误映射为本地化文案（ParseError 按 reason 映射资源，detail 仅作日志，不流向 UI）。 */
+private fun errorToUiText(error: Throwable): UiText = when (error) {
+    is RepositoryError.SessionExpired ->
+        UiText.Resource(R.string.error_credential_session_expired)
+    is RepositoryError.InvalidCredential ->
+        UiText.Resource(R.string.error_credential_invalid_reconfigure)
+    is RepositoryError.RateLimited -> UiText.Resource(
+        R.string.error_rate_limited_retry,
+        listOf(
+            error.retryAfterSeconds?.let {
+                UiText.Resource(R.string.error_rate_limited_retry_suffix, listOf(it))
+            } ?: ""
+        )
+    )
+    is RepositoryError.Network -> UiText.Resource(R.string.error_network_check)
+    is RepositoryError.ServerError ->
+        UiText.Resource(R.string.error_server_http, listOf(error.code))
+    is RepositoryError.ParseError -> when (error.reason) {
+        RepositoryError.ParseErrorReason.EMPTY_BODY -> UiText.Resource(R.string.error_parse_empty_body)
+        RepositoryError.ParseErrorReason.NOT_JSON_OBJECT -> UiText.Resource(R.string.error_parse_not_json)
+        RepositoryError.ParseErrorReason.NO_WINDOWS -> UiText.Resource(R.string.error_parse_no_windows)
+        RepositoryError.ParseErrorReason.NO_MODELS -> UiText.Resource(R.string.error_parse_no_models)
+        RepositoryError.ParseErrorReason.MODELS_EMPTY -> UiText.Resource(R.string.error_parse_models_empty)
+        RepositoryError.ParseErrorReason.MALFORMED_RESPONSE -> UiText.Resource(R.string.error_parse_malformed)
+    }
+    // Unknown 的 message 以硬编码中文"未知错误"开头，不能透传 UI，统一映射本地化文案
+    is RepositoryError.Unknown -> UiText.Resource(R.string.common_unknown)
+    else -> error.message?.let { UiText.Dynamic(it) }
+        ?: UiText.Resource(R.string.common_unknown)
 }

app/src/main/java/com/rainy/token/ui/dashboard/DateRangePickerDialog.kt

@@ -0,0 +1,79 @@
+package com.rainy.token.ui.dashboard
+
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.DatePickerDialog
+import androidx.compose.material3.DateRangePicker
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.rememberDateRangePickerState
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.rainy.token.R
+import java.time.Instant
+import java.time.LocalDate
+import java.time.ZoneOffset
+
+/**
+ * 日期范围选择弹窗 —— 单弹窗内一次选出起止日期（连续高亮）。
+ *
+ * - 状态通过 "if (show) Dialog(...)" 条件组合创建：每次打开都会用最新预填值重新初始化；
+ * - 预填毫秒一律按 UTC 零点解释（与项目既有 UTC 语义一致）；
+ * - 两端日期齐备前，确认按钮保持禁用（M3 范围选择：同一天点两次 = 单日区间）。
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+internal fun DateRangePickerDialog(
+    title: String,
+    initialStart: LocalDate?,
+    initialEnd: LocalDate?,
+    onConfirm: (LocalDate, LocalDate) -> Unit,
+    onDismiss: () -> Unit
+) {
+    // 预填数据 sanitize：无起点时忽略终点；终点早于起点时忽略终点
+    val sanitizedEnd = initialEnd?.takeIf { initialStart != null && !it.isBefore(initialStart) }
+    val state = rememberDateRangePickerState(
+        initialSelectedStartDateMillis = initialStart?.toUtcMillis(),
+        initialSelectedEndDateMillis = sanitizedEnd?.toUtcMillis()
+    )
+    DatePickerDialog(
+        onDismissRequest = onDismiss,
+        confirmButton = {
+            val complete = state.selectedStartDateMillis != null && state.selectedEndDateMillis != null
+            TextButton(
+                onClick = {
+                    val startMillis = state.selectedStartDateMillis
+                    val endMillis = state.selectedEndDateMillis
+                    if (startMillis != null && endMillis != null) {
+                        onConfirm(startMillis.toUtcLocalDate(), endMillis.toUtcLocalDate())
+                    }
+                },
+                enabled = complete
+            ) {
+                Text(stringResource(R.string.action_confirm))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text(stringResource(R.string.action_cancel))
+            }
+        }
+    ) {
+        DateRangePicker(
+            state = state,
+            modifier = Modifier.fillMaxWidth().height(500.dp).padding(16.dp),
+            title = { Text(title) },
+            showModeToggle = false
+        )
+    }
+}
+
+private fun LocalDate.toUtcMillis(): Long =
+    atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
+
+private fun Long.toUtcLocalDate(): LocalDate =
+    Instant.ofEpochMilli(this).atOffset(ZoneOffset.UTC).toLocalDate()

app/src/main/java/com/rainy/token/ui/dashboard/ServiceBalanceCards.kt

@@ -1,6 +1,7 @@
 package com.rainy.token.ui.dashboard
 
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
@@ -8,30 +9,43 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.background
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.StrokeCap
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.res.stringResource
+import androidx.annotation.StringRes
+import com.rainy.token.R
 import com.rainy.token.domain.model.CredentialStatus
 import com.rainy.token.domain.model.ServiceBalance
+import com.rainy.token.domain.model.Sub2DailyUsage
+import com.rainy.token.domain.model.Sub2UsageDetail
+import java.time.LocalDate
 import com.rainy.token.domain.service.ServiceType
 import com.rainy.token.ui.components.StatusStyle
 import com.rainy.token.ui.components.StatusLevel
+import com.rainy.token.ui.components.DurationText
+import com.rainy.token.ui.components.UiText
 import com.rainy.token.ui.components.formatAmount
 import com.rainy.token.ui.components.formatResetInSec
+import com.rainy.token.ui.components.isFiveHourLabel
 import com.rainy.token.ui.components.normalizeWindowLabel
 import com.rainy.token.ui.theme.StrawberryPink
 import com.rainy.token.ui.theme.StatusOrange
 import com.rainy.token.ui.theme.inkMuted
 import java.text.SimpleDateFormat
 import java.util.Date
+import kotlin.math.roundToInt
 import java.util.Locale
 
 // ── Service-specific balance Composables ──
@@ -47,7 +61,7 @@ internal fun BalanceMainArea(card: DashboardCardUi) {
                 color = inkMuted()
             )
             Text(
-                text = "点击配置凭据",
+                text = stringResource(R.string.service_click_to_configure),
                 style = MaterialTheme.typography.bodySmall,
                 color = inkMuted()
             )
@@ -59,7 +73,7 @@ internal fun BalanceMainArea(card: DashboardCardUi) {
                 color = inkMuted()
             )
             Text(
-                text = "下拉刷新",
+                text = stringResource(R.string.service_pull_to_refresh),
                 style = MaterialTheme.typography.bodySmall,
                 color = inkMuted()
             )
@@ -84,6 +98,12 @@ internal fun BalanceMainArea(card: DashboardCardUi) {
             Spacer(modifier = Modifier.height(12.dp))
             OllamaUsageWindows(balance)
         }
+        card.service == ServiceType.SUB2API -> {
+            Sub2ApiBalanceWithUsage(balance)
+        }
+        card.service == ServiceType.TRAE -> {
+            TraeSplitMainBalance(balance)
+        }
         else -> {
             Row(verticalAlignment = Alignment.Bottom) {
                 Text(
@@ -102,14 +122,14 @@ internal fun BalanceMainArea(card: DashboardCardUi) {
             }
             if (!balance.isAvailable) {
                 Text(
-                    text = "服务当前不可用",
+                    text = stringResource(R.string.service_unavailable),
                     style = MaterialTheme.typography.bodySmall,
                     color = MaterialTheme.colorScheme.error
                 )
             }
             balance.monthlySpent?.let { spent ->
                 Text(
-                    text = "本月已用 ${formatAmount(spent)}${balance.unit}",
+                    text = stringResource(R.string.service_monthly_used, formatAmount(spent), balance.unit),
                     style = MaterialTheme.typography.bodySmall,
                     color = inkMuted()
                 )
@@ -118,6 +138,73 @@ internal fun BalanceMainArea(card: DashboardCardUi) {
     }
 }
 
+/**
+ * Trae 首页卡片主区：不显示总积分，分开显示「通用积分」（TraeCode/TraeWork 均可用）
+ * 与「Work 专属积分」（仅 TraeWork），取 extras 中 general_credits/work_credits 小计
+ * （与详情页 TraePacksCard 同口径）。旧缓存缺小计键时回退总积分展示，刷新后恢复。
+ */
+@Composable
+private fun TraeSplitMainBalance(balance: ServiceBalance) {
+    val extras = balance.extras
+    val general = extras?.get("general_credits")?.toDoubleOrNull()
+    val work = extras?.get("work_credits")?.toDoubleOrNull()
+    if (general == null && work == null) {
+        // 旧缓存无小计键：回退原总积分展示
+        Row(verticalAlignment = Alignment.Bottom) {
+            Text(
+                text = formatAmount(balance.amount),
+                style = MaterialTheme.typography.displayMedium,
+                fontWeight = FontWeight.Bold,
+                color = MaterialTheme.colorScheme.onSurface
+            )
+            Spacer(modifier = Modifier.width(4.dp))
+            Text(
+                text = balance.unit,
+                style = MaterialTheme.typography.titleMedium,
+                color = inkMuted(),
+                modifier = Modifier.padding(bottom = 6.dp)
+            )
+        }
+        return
+    }
+    val generalTitle = stringResource(R.string.trae_general_credits_title)
+    val workTitle = stringResource(R.string.trae_work_credits_title)
+    TraeSplitLine(generalTitle, general)
+    Spacer(modifier = Modifier.height(6.dp))
+    TraeSplitLine(workTitle, work)
+}
+
+/** 首页 Trae 分区一行：左侧分区名，右侧小计 + 单位。 */
+@Composable
+private fun TraeSplitLine(label: String, value: Double?) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        verticalAlignment = Alignment.Bottom,
+        horizontalArrangement = Arrangement.SpaceBetween
+    ) {
+        Text(
+            text = label,
+            style = MaterialTheme.typography.titleMedium,
+            color = inkMuted()
+        )
+        Row(verticalAlignment = Alignment.Bottom) {
+            Text(
+                text = value?.let { formatAmount(it) } ?: "—",
+                style = MaterialTheme.typography.headlineSmall,
+                fontWeight = FontWeight.Bold,
+                color = MaterialTheme.colorScheme.onSurface
+            )
+            Spacer(modifier = Modifier.width(4.dp))
+            Text(
+                text = "Credits",
+                style = MaterialTheme.typography.titleMedium,
+                color = inkMuted(),
+                modifier = Modifier.padding(bottom = 2.dp)
+            )
+        }
+    }
+}
+
 @Composable
 internal fun OpenCodeGoMainBalance(balance: ServiceBalance) {
     Row(verticalAlignment = Alignment.Bottom) {
@@ -136,7 +223,7 @@ internal fun OpenCodeGoMainBalance(balance: ServiceBalance) {
         )
         Spacer(modifier = Modifier.width(8.dp))
         Text(
-            text = "5h 用量",
+            text = stringResource(R.string.window_5h_usage),
             style = MaterialTheme.typography.titleMedium,
             color = inkMuted(),
             modifier = Modifier.padding(bottom = 6.dp)
@@ -147,9 +234,9 @@ internal fun OpenCodeGoMainBalance(balance: ServiceBalance) {
 @Composable
 internal fun OpenCodeGoUsageWindows(balance: ServiceBalance) {
     val windows = listOf(
-        Triple("5 小时", balance.extras["rolling.pct"]?.toIntOrNull(), balance.extras["rolling.resetInSec"]?.toLongOrNull()),
-        Triple("本周",   balance.extras["weekly.pct"]?.toIntOrNull(),   balance.extras["weekly.resetInSec"]?.toLongOrNull()),
-        Triple("本月",   balance.extras["monthly.pct"]?.toIntOrNull(),  balance.extras["monthly.resetInSec"]?.toLongOrNull())
+        Triple(stringResource(R.string.window_5h), balance.extras["rolling.pct"]?.toFloatOrNull()?.roundToInt(), balance.extras["rolling.resetInSec"]?.toLongOrNull()),
+        Triple(stringResource(R.string.window_weekly),   balance.extras["weekly.pct"]?.toFloatOrNull()?.roundToInt(),   balance.extras["weekly.resetInSec"]?.toLongOrNull()),
+        Triple(stringResource(R.string.window_monthly),   balance.extras["monthly.pct"]?.toFloatOrNull()?.roundToInt(),  balance.extras["monthly.resetInSec"]?.toLongOrNull())
     )
     Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
         windows.forEach { (label, pct, resetSec) ->
@@ -181,7 +268,7 @@ internal fun CommandCodeGoMainBalance(balance: ServiceBalance) {
         )
         Spacer(modifier = Modifier.width(8.dp))
         Text(
-            text = "剩余",
+            text = stringResource(R.string.service_remaining),
             style = MaterialTheme.typography.titleMedium,
             color = inkMuted(),
             modifier = Modifier.padding(bottom = 6.dp)
@@ -189,7 +276,7 @@ internal fun CommandCodeGoMainBalance(balance: ServiceBalance) {
         if (total != null && total > 0) {
             val used = total - balance.amount
             Text(
-                text = " · 已用 ${formatAmount(used)} / 共 ${formatAmount(total)}",
+                text = stringResource(R.string.service_used_total, formatAmount(used), formatAmount(total)),
                 style = MaterialTheme.typography.bodySmall,
                 color = inkMuted(),
                 modifier = Modifier.padding(bottom = 6.dp)
@@ -206,9 +293,9 @@ internal fun CommandCodeGoUsageWindows(balance: ServiceBalance) {
         return ((used / cap) * 100).toInt().coerceIn(0, 100)
     }
     val windows = listOf(
-        Triple("5 小时", calcPct(extras["fiveHour.used"]?.toDoubleOrNull(), extras["fiveHour.cap"]?.toDoubleOrNull()), extras["fiveHour.resetInSec"]?.toLongOrNull()),
-        Triple("本周",   calcPct(extras["weekly.used"]?.toDoubleOrNull(), extras["weekly.cap"]?.toDoubleOrNull()),   extras["weekly.resetInSec"]?.toLongOrNull()),
-        Triple("本月",   calcPct(balance.monthlySpent, balance.totalQuota), extras["monthly.resetInSec"]?.toLongOrNull())
+        Triple(stringResource(R.string.window_5h), calcPct(extras["fiveHour.used"]?.toDoubleOrNull(), extras["fiveHour.cap"]?.toDoubleOrNull()), extras["fiveHour.resetInSec"]?.toLongOrNull()),
+        Triple(stringResource(R.string.window_weekly),   calcPct(extras["weekly.used"]?.toDoubleOrNull(), extras["weekly.cap"]?.toDoubleOrNull()),   extras["weekly.resetInSec"]?.toLongOrNull()),
+        Triple(stringResource(R.string.window_monthly),   calcPct(balance.monthlySpent, balance.totalQuota), extras["monthly.resetInSec"]?.toLongOrNull())
     )
     Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
         windows.forEach { (label, pct, resetSec) ->
@@ -223,10 +310,15 @@ internal fun CommandCodeGoUsageWindows(balance: ServiceBalance) {
 
 @Composable
 internal fun CodexMainBalance(balance: ServiceBalance) {
-    val plan = balance.extras["plan"]?.let {
+    val plan = balance.extras["plan"]?.takeIf { it.isNotBlank() }?.let {
         when (it) { "plus" -> "Plus"; "pro" -> "Pro"; "free" -> "Free"; else -> it.replaceFirstChar { c -> c.uppercaseChar() } }
     } ?: "—"
-    val primaryLabel = formatCodexPrimaryLabel(balance.extras["primary.label"])
+    val primaryLabel = formatCodexPrimaryLabel(
+        balance.extras["primary.label"],
+        weeklyLabel = stringResource(R.string.window_every_week),
+        monthlyLabel = stringResource(R.string.window_every_month),
+        usageLabel = stringResource(R.string.window_usage)
+    )
     Row(verticalAlignment = Alignment.Bottom) {
         Text(
             text = formatAmount(balance.amount),
@@ -243,14 +335,14 @@ internal fun CodexMainBalance(balance: ServiceBalance) {
         )
         Spacer(modifier = Modifier.width(8.dp))
         Text(
-            text = "$primaryLabel 已用",
+            text = stringResource(R.string.service_used_label, primaryLabel),
             style = MaterialTheme.typography.titleMedium,
             color = inkMuted(),
             modifier = Modifier.padding(bottom = 6.dp)
         )
         Spacer(modifier = Modifier.width(8.dp))
         Text(
-            text = "· $plan",
+            text = stringResource(R.string.service_plan_suffix, plan),
             style = MaterialTheme.typography.bodySmall,
             color = inkMuted(),
             modifier = Modifier.padding(bottom = 6.dp)
@@ -258,14 +350,22 @@ internal fun CodexMainBalance(balance: ServiceBalance) {
     }
 }
 
-/** 把 Codex API 返回的 primary label 转成中文短标签 */
-internal fun formatCodexPrimaryLabel(raw: String?): String = when (raw?.lowercase()) {
+/**
+ * 把 Codex API 返回的 primary label 转成本地化短标签。
+ * 默认中文标签保持测试兼容；UI 调用方传入 stringResource 结果。
+ */
+internal fun formatCodexPrimaryLabel(
+    raw: String?,
+    weeklyLabel: String = "Weekly",
+    monthlyLabel: String = "Monthly",
+    usageLabel: String = "Usage"
+): String = when (raw?.lowercase()) {
     "5h" -> "5h"
-    "7d", "每周" -> "每周"
-    "30d", "每月" -> "每月"
-    "usage" -> "用量"
+    "7d", "weekly", "每周", weeklyLabel -> weeklyLabel
+    "30d", "monthly", "每月", monthlyLabel -> monthlyLabel
+    "usage" -> usageLabel
     null -> "5h"
-    else -> raw
+    else -> raw ?: "5h"
 }
 
 @Composable
@@ -276,39 +376,72 @@ internal fun CodexUsageWindows(balance: ServiceBalance) {
         .distinct()
         .maxOrNull()?.plus(1) ?: 0
 
+    val weeklyLabel = stringResource(R.string.window_every_week)
+    val monthlyLabel = stringResource(R.string.window_every_month)
+    val usageLabel = stringResource(R.string.window_usage)
+    val sparkTitle = stringResource(R.string.window_spark)
+
+    data class UiWindow(val label: String, val isSpark: Boolean, val remainingPct: Int?, val resetAt: Long?)
+
     val windows = (0 until windowCount).map { i ->
-        val label = normalizeWindowLabel(extras["window_$i.label"] ?: "Usage")
-        val remainingPct = extras["window_$i.remainingPct"]?.toIntOrNull()
-        val resetAt = extras["window_$i.resetAt"]?.toLongOrNull()?.takeIf { it > 0 }
-        Triple(label, remainingPct, resetAt)
+        val rawLabel = extras["window_$i.label"] ?: "usage"
+        val label = normalizeWindowLabel(
+            rawLabel,
+            weeklyLabel = weeklyLabel,
+            monthlyLabel = monthlyLabel,
+            usageLabel = usageLabel
+        )
+        UiWindow(
+            label = label,
+            isSpark = extras["window_$i.group"] == "SPARK",
+            remainingPct = extras["window_$i.remainingPct"]?.toIntOrNull(),
+            resetAt = extras["window_$i.resetAt"]?.toLongOrNull()?.takeIf { it > 0 }
+        )
     }
 
-    // 判断是否有 5h 窗口（用于保留空槽位）
-    val has5h = windows.any { it.first.contains("5") && it.first.contains("小时") }
+    // 主模型（普通 Codex）窗口独占全部进度行；Spark 独立限额是次要通道，只留一行小字摘要
+    val mainWindows = windows.filter { !it.isSpark }
+    val sparkWindows = windows.filter { it.isSpark }
+
+    // 判断是否有 5h 窗口（与语言无关：匹配 "5h"/"5H" 或本地化标签，仅看主模型窗口）
+    val fiveHourLabel = stringResource(R.string.window_5h)
+    val has5h = mainWindows.any { isFiveHourLabel(it.label, fiveHourLabel, stringResource(R.string.window_5h_short)) }
 
     Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
         if (windows.isEmpty()) {
-            CompactUsageRowEmpty(label = "Usage", resetInSec = null)
+            CompactUsageRowEmpty(label = stringResource(R.string.usage_window_title_plain), resetInSec = null)
         } else {
             // 如果没有 5h 窗口，在顶部插入一个空的 5h 槽位（保留位置，等恢复后自动填充）
             if (!has5h) {
-                CompactUsageRowEmpty(label = "5 小时", resetInSec = null)
+                CompactUsageRowEmpty(label = fiveHourLabel, resetInSec = null)
             }
-            windows.forEach { (label, remainingPct, resetAt) ->
-                if (remainingPct != null) {
-                    val usedPct = (100 - remainingPct).coerceIn(0, 100)
-                    CompactUsageRow(label = label, pct = usedPct, resetInSec = resetAt?.let { (it - System.currentTimeMillis()) / 1000 }?.takeIf { it > 0 })
+            mainWindows.forEach { w ->
+                val resetSec = w.resetAt?.let { (it - System.currentTimeMillis()) / 1000 }?.takeIf { it > 0 }
+                if (w.remainingPct != null) {
+                    CompactUsageRow(label = w.label, pct = (100 - w.remainingPct).coerceIn(0, 100), resetInSec = resetSec)
                 } else {
-                    CompactUsageRowEmpty(label = label, resetInSec = resetAt?.let { (it - System.currentTimeMillis()) / 1000 }?.takeIf { it > 0 })
+                    CompactUsageRowEmpty(label = w.label, resetInSec = resetSec)
                 }
             }
+            // Spark 次要限额：单行摘要，不与主模型争夺视觉焦点
+            if (sparkWindows.isNotEmpty()) {
+                val summary = sparkWindows.joinToString(" · ") { w ->
+                    val used = w.remainingPct?.let { (100 - it).coerceIn(0, 100) }
+                    if (used != null) "${w.label} $used%" else "${w.label} —"
+                }
+                Text(
+                    text = "$sparkTitle · $summary",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = inkMuted()
+                )
+            }
         }
     }
 }
 
 @Composable
 internal fun OllamaMainBalance(balance: ServiceBalance) {
-    val plan = balance.extras["plan"]?.let {
+    val plan = balance.extras["plan"]?.takeIf { it.isNotBlank() }?.let {
         when (it.lowercase()) { "pro" -> "Pro"; "max" -> "Max"; "free" -> "Free"; else -> it }
     } ?: "—"
     Row(verticalAlignment = Alignment.Bottom) {
@@ -327,14 +460,14 @@ internal fun OllamaMainBalance(balance: ServiceBalance) {
         )
         Spacer(modifier = Modifier.width(8.dp))
         Text(
-            text = "5h 已用",
+            text = stringResource(R.string.service_5h_used),
             style = MaterialTheme.typography.titleMedium,
             color = inkMuted(),
             modifier = Modifier.padding(bottom = 6.dp)
         )
         Spacer(modifier = Modifier.width(8.dp))
         Text(
-            text = "· $plan",
+            text = stringResource(R.string.service_plan_suffix, plan),
             style = MaterialTheme.typography.bodySmall,
             color = inkMuted(),
             modifier = Modifier.padding(bottom = 6.dp)
@@ -349,25 +482,26 @@ internal fun OllamaUsageWindows(balance: ServiceBalance) {
     val weeklyPct = extras["weekly.pct"]?.toFloatOrNull()
     val sessionResetAt = extras["session.resetAt"]?.toLongOrNull()
     val weeklyResetAt = extras["weekly.resetAt"]?.toLongOrNull()
+    val weeklyLabel = stringResource(R.string.window_every_week)
 
     Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
         if (sessionPct != null) {
             CompactUsageRow(
-                label = "5h",
+                label = stringResource(R.string.window_5h_short),
                 pct = sessionPct.toInt().coerceIn(0, 100),
                 resetInSec = sessionResetAt?.let { (it - System.currentTimeMillis()) / 1000 }?.takeIf { it > 0 }
             )
         } else {
-            CompactUsageRowEmpty(label = "5h", resetInSec = null)
+            CompactUsageRowEmpty(label = stringResource(R.string.window_5h_short), resetInSec = null)
         }
         if (weeklyPct != null) {
             CompactUsageRow(
-                label = "每周",
+                label = weeklyLabel,
                 pct = weeklyPct.toInt().coerceIn(0, 100),
                 resetInSec = weeklyResetAt?.let { (it - System.currentTimeMillis()) / 1000 }?.takeIf { it > 0 }
             )
         } else {
-            CompactUsageRowEmpty(label = "每周", resetInSec = null)
+            CompactUsageRowEmpty(label = weeklyLabel, resetInSec = null)
         }
     }
 }
@@ -376,6 +510,7 @@ internal fun OllamaUsageWindows(balance: ServiceBalance) {
 
 @Composable
 internal fun CompactUsageRowEmpty(label: String, resetInSec: Long?) {
+    val durationText = rememberDurationText()
     Column {
         Row(
             modifier = Modifier.fillMaxWidth(),
@@ -407,7 +542,7 @@ internal fun CompactUsageRowEmpty(label: String, resetInSec: Long?) {
         if (resetInSec != null && resetInSec > 0) {
             Spacer(modifier = Modifier.height(2.dp))
             Text(
-                text = "${formatResetInSec(resetInSec)}后重置",
+                text = stringResource(R.string.service_reset_in, formatResetInSec(resetInSec, durationText)),
                 style = MaterialTheme.typography.bodySmall,
                 color = inkMuted()
             )
@@ -417,6 +552,7 @@ internal fun CompactUsageRowEmpty(label: String, resetInSec: Long?) {
 
 @Composable
 internal fun CompactUsageRow(label: String, pct: Int, resetInSec: Long?) {
+    val durationText = rememberDurationText()
     val pctValue = pct.coerceIn(0, 100).toFloat()
     Column {
         Row(
@@ -458,7 +594,7 @@ internal fun CompactUsageRow(label: String, pct: Int, resetInSec: Long?) {
         if (resetInSec != null && resetInSec > 0) {
             Spacer(modifier = Modifier.height(2.dp))
             Text(
-                text = "${formatResetInSec(resetInSec)}后重置",
+                text = stringResource(R.string.service_reset_in, formatResetInSec(resetInSec, durationText)),
                 style = MaterialTheme.typography.bodySmall,
                 color = inkMuted()
             )
@@ -466,45 +602,293 @@ internal fun CompactUsageRow(label: String, pct: Int, resetInSec: Long?) {
     }
 }
 
+/** 当前语言环境的时长标签（"天 / 小时 / 分"）。 */
+@Composable
+private fun rememberDurationText(): DurationText = DurationText(
+    day = stringResource(R.string.format_day),
+    hour = stringResource(R.string.format_hour),
+    minute = stringResource(R.string.format_minute)
+)
+
 // ── Dashboard utility functions ──
 
 internal fun DashboardCardUi.statusBadgeStyle(): StatusStyle = when {
     credentialState == CredentialStatus.State.NOT_CONFIGURED ->
-        StatusStyle("未配置", StatusLevel.WARNING)
+        StatusStyle(R.string.status_not_configured, StatusLevel.WARNING)
     lastFetchError != null ->
-        StatusStyle("刷新失败", StatusLevel.ERROR)
+        StatusStyle(R.string.status_refresh_failed, StatusLevel.ERROR)
     credentialState == CredentialStatus.State.EXPIRED ->
-        StatusStyle("已过期", StatusLevel.ERROR)
+        StatusStyle(R.string.status_expired, StatusLevel.ERROR)
     credentialState == CredentialStatus.State.WARNING ->
-        StatusStyle("需重登", StatusLevel.WARNING)
+        StatusStyle(R.string.status_relogin, StatusLevel.WARNING)
     cachedBalance == null ->
-        StatusStyle("待获取", StatusLevel.INFO)
+        StatusStyle(R.string.status_waiting, StatusLevel.INFO)
     else ->
-        StatusStyle("正常", StatusLevel.OK)
+        StatusStyle(R.string.status_normal, StatusLevel.OK)
 }
 
-internal fun secondaryLine(card: DashboardCardUi): String = when (card.service) {
-    ServiceType.DEEPSEEK -> "REST API · ¥"
-    ServiceType.OPENCODE_GO -> "WebView 抓取 · 5h 配额"
-    ServiceType.COMMANDCODE_GO -> "JSON API · $"
-    ServiceType.CODEX -> "ChatGPT Plus · Codex 额度"
-    ServiceType.OLLAMA -> "Cookie 抓取 · Cloud 配额"
-}
-
-internal fun footerText(card: DashboardCardUi): String {
-    if (card.lastFetchError != null) {
-        val msg = card.lastFetchError.take(60)
-        return "⚠ $msg${if (card.lastFetchError.length > 60) "…" else ""}"
+/**
+ * Sub2API 副标题：显示登录方式（邮箱登录 / API 登录），而不是笼统的「自托管面板 · 用户级 sk- Key 余额」。
+ * 依据 UsageDetail/余额 extras 里的 auth_mode（由 Repository 写入）：
+ *   panel  = 面板 Token（邮箱/账号登录面板）
+ *   apikey = 仅配置了 sk- API Key
+ * 无数据时回退到通用描述。
+ */
+@Composable
+internal fun sub2AuthModeText(card: DashboardCardUi): String {
+    val balance = card.displayBalance
+    val mode = balance?.extras?.get("auth_mode")
+    return when (mode) {
+        "panel" -> stringResource(R.string.sub2_auth_panel)
+        "apikey" -> stringResource(R.string.sub2_auth_apikey)
+        else -> stringResource(R.string.service_desc_sub2api)
     }
-    val fetchedAt = card.cachedBalance?.fetchedAt ?: return "从未获取"
+}
+
+/**
+ * Trae / WorkBuddy 卡片副标题：显示订阅状态（不再展示登录方式）。
+ *
+ * 取自 extras 的订阅字段（付费用户 / 订阅中），与详情页「账户信息」区同一数据源。
+ * 无缓存余额或字段缺失时返回 null，调用方回落到 [secondaryLineRes] 的通用描述。
+ */
+@Composable
+internal fun subscriptionLine(card: DashboardCardUi): String? {
+    // 仅 Trae / WorkBuddy 使用本函数；其余服务回落通用描述
+    if (card.service != ServiceType.TRAE && card.service != ServiceType.WORKBUDDY) return null
+    val extras = card.displayBalance?.extras ?: return null
+
+    // WorkBuddy：订阅 / 付费状态
+    if ("is_paid_user" in extras || "subscription" in extras) {
+        val isPaid = extras["is_paid_user"] == "true"
+        val isSubscribed = extras["subscription"] == "true"
+        return when {
+            isSubscribed -> stringResource(R.string.extra_value_subscription_active)
+            isPaid -> stringResource(R.string.extra_value_paid_user)
+            else -> stringResource(R.string.extra_value_free_user)
+        }
+    }
+
+    // Trae：计费模式（积分计费 / 美元计费），无则不显示
+    val billing = when {
+        extras["is_credits_billing"] == "true" -> stringResource(R.string.extra_value_billing_credits)
+        extras["is_dollar_usage_billing"] == "true" -> stringResource(R.string.extra_value_billing_dollar)
+        else -> null
+    }
+    if (billing != null) {
+        return stringResource(R.string.extra_label_billing_mode_desc, billing)
+    }
+
+    // 字段完全缺失时返回 null，回落通用描述
+    return null
+}
+
+/** 服务副标题（资源 ID，由 UI 层解析）。 */
+@StringRes
+internal fun secondaryLineRes(card: DashboardCardUi): Int = when (card.service) {
+    ServiceType.DEEPSEEK -> R.string.service_desc_deepseek
+    ServiceType.OPENCODE_GO -> R.string.service_desc_opencode_go
+    ServiceType.COMMANDCODE_GO -> R.string.service_desc_commandcode_go
+    ServiceType.CODEX -> R.string.service_desc_codex
+    ServiceType.OLLAMA -> R.string.service_desc_ollama
+    ServiceType.TRAE -> R.string.service_desc_trae
+    ServiceType.WORKBUDDY -> R.string.service_desc_workbuddy
+    ServiceType.SUB2API -> R.string.service_desc_sub2api
+}
+
+/**
+ * 底部更新时间/错误文案（UiText 形式，UI 层按当前语言解析）。
+ * 错误信息由 ViewModel 按 RepositoryError 类型映射为本地化资源。
+ */
+
+/** 截断 UiText 到最长 60 字符（仅对 Dynamic 原始文本生效；Resource 长度由资源控制）。 */
+private fun truncateUiText(text: UiText): UiText = when (text) {
+    is UiText.Dynamic -> UiText.Dynamic(text.value.take(60) + if (text.value.length > 60) "…" else "")
+    else -> text
+}
+
+internal fun footerText(card: DashboardCardUi): UiText {
+    val error = card.lastFetchError
+    if (error != null) {
+        // 截断保护：错误信息最长展示 60 字符（以 UiText 形式保留，UI 层按当前语言解析）
+        return UiText.Resource(R.string.dashboard_error_prefix, listOf(truncateUiText(error)))
+    }
+    val fetchedAt = card.cachedBalance?.fetchedAt
+        ?: return UiText.Resource(R.string.footer_never_fetched)
     val sdf = SimpleDateFormat("MM-dd HH:mm", Locale.getDefault())
     val now = System.currentTimeMillis()
     val diffMin = (now - fetchedAt) / 60_000
     val timeStr = sdf.format(Date(fetchedAt))
     return when {
-        diffMin < 1 -> "刚刚更新"
-        diffMin < 60 -> "$diffMin 分钟前更新"
-        diffMin < 1440 -> "${diffMin / 60} 小时前更新"
-        else -> "$timeStr 更新"
+        diffMin < 1 -> UiText.Resource(R.string.footer_just_updated)
+        diffMin < 60 -> UiText.Resource(R.string.footer_minutes_ago, listOf(diffMin))
+        diffMin < 1440 -> UiText.Resource(R.string.footer_hours_ago, listOf(diffMin / 60))
+        else -> UiText.Resource(R.string.footer_updated_at, listOf(timeStr))
     }
-}
+}
+
+/**
+ * 用量卡片（OCGO / CCGO）底部刷新时间文案，规则与 [footerText] 完全一致：
+ * <1 分钟"刚刚更新"、<1 小时"X 分钟前"、<24 小时"X 小时前"、更早显示 "MM-dd HH:mm 更新"。
+ */
+@Composable
+internal fun usageUpdatedAtText(updatedAt: Long): String {
+    val now = System.currentTimeMillis()
+    val diffMin = (now - updatedAt) / 60_000
+    val sdf = SimpleDateFormat("MM-dd HH:mm", Locale.getDefault())
+    return when {
+        diffMin < 1 -> stringResource(R.string.footer_just_updated)
+        diffMin < 60 -> stringResource(R.string.footer_minutes_ago, diffMin)
+        diffMin < 1440 -> stringResource(R.string.footer_hours_ago, diffMin / 60)
+        else -> stringResource(R.string.footer_updated_at, sdf.format(Date(updatedAt)))
+    }
+}
+// ── Sub2API 首页卡片：余额 + 日/周/月/本月 用量汇总 ──
+
+/**
+ * 首页 Sub2API 卡主体。
+ *
+ * 布局：
+ *   ① 余额区——「余额」小标签 + 大号数字 + 单位（带品牌色圆点的左侧强调条）
+ *   ② 用量区——「今日 / 近7天」两块等宽磁贴，每块显示 请求次数 与 Token 数
+ *
+ * 磁贴等宽 + 两行固定结构，保证 360dp 窄屏不换行、不同周期数值长度不一会错位。
+ */
+@Composable
+internal fun Sub2ApiBalanceWithUsage(balance: ServiceBalance) {
+    Column(modifier = Modifier.fillMaxWidth()) {
+        Sub2ApiBalanceHero(balance)
+        Spacer(modifier = Modifier.height(10.dp))
+        Sub2ApiUsageTiles(balance)
+    }
+}
+
+/** 余额区：小标签 + 大数字 + 单位。 */
+@Composable
+internal fun Sub2ApiMainBalance(balance: ServiceBalance, modifier: Modifier = Modifier) {
+    Sub2ApiBalanceHero(balance, modifier)
+}
+
+@Composable
+private fun Sub2ApiBalanceHero(balance: ServiceBalance, modifier: Modifier = Modifier) {
+    // 「余额 357.06 USD」单行排列：小标签 + 大数字 + 单位
+    Row(verticalAlignment = Alignment.Bottom, modifier = modifier.fillMaxWidth()) {
+        Text(
+            text = stringResource(R.string.sub2_balance_label),
+            style = MaterialTheme.typography.labelMedium,
+            color = inkMuted(),
+            modifier = Modifier.padding(bottom = 6.dp),
+            maxLines = 1
+        )
+        Spacer(modifier = Modifier.width(8.dp))
+        Text(
+            text = formatAmount(balance.amount),
+            style = MaterialTheme.typography.displaySmall,
+            fontWeight = FontWeight.Bold,
+            color = MaterialTheme.colorScheme.onSurface,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis
+        )
+        Spacer(modifier = Modifier.width(6.dp))
+        Text(
+            text = balance.unit,
+            style = MaterialTheme.typography.titleSmall,
+            color = inkMuted(),
+            modifier = Modifier.padding(bottom = 4.dp),
+            maxLines = 1
+        )
+    }
+}
+
+/** 用量区：今日 / 近7天 两块等宽磁贴。 */
+@Composable
+private fun Sub2ApiUsageTiles(balance: ServiceBalance) {
+    val detail = balance.sub2UsageDetail
+    val windows = remember(detail) { buildSub2SummaryWindows(detail) }
+    if (windows.isEmpty()) {
+        Text(
+            text = stringResource(R.string.sub2_home_no_usage),
+            style = MaterialTheme.typography.bodySmall,
+            color = inkMuted()
+        )
+        return
+    }
+    Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+        windows.forEach { w ->
+            Column(
+                modifier = Modifier
+                    .weight(1f)
+                    .clip(RoundedCornerShape(14.dp))
+                    .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f))
+                    .padding(horizontal = 12.dp, vertical = 10.dp),
+                verticalArrangement = Arrangement.Center
+            ) {
+                // 第一行：周期名 + 消耗金额
+                Row(verticalAlignment = Alignment.Bottom) {
+                    Text(
+                        text = stringResource(w.labelRes),
+                        style = MaterialTheme.typography.labelSmall,
+                        color = inkMuted(),
+                        maxLines = 1
+                    )
+                    Spacer(modifier = Modifier.weight(1f))
+                    Text(
+                        text = stringResource(R.string.sub2_home_spend, w.cost),
+                        style = MaterialTheme.typography.labelSmall,
+                        color = inkMuted(),
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis
+                    )
+                }
+                Spacer(modifier = Modifier.height(3.dp))
+                Text(
+                    text = w.tokens,
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.SemiBold,
+                    color = MaterialTheme.colorScheme.onSurface,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis
+                )
+            }
+        }
+    }
+}
+
+/** 聚合 dailyUsage 计算各窗口汇总行文案；无数据返回空列表。 */
+private fun buildSub2SummaryWindows(detail: Sub2UsageDetail?): List<Sub2WindowSummary> {
+    val days = detail?.dailyUsage.orEmpty()
+    if (days.isEmpty()) return emptyList()
+    val today = LocalDate.now()
+    fun sum(from: LocalDate): Triple<Long, Long, Double> {
+        var req = 0L; var tok = 0L; var cost = 0.0
+        for (d in days) {
+            val date = runCatching { LocalDate.parse(d.date) }.getOrNull() ?: continue
+            if (!date.isBefore(from) && !date.isAfter(today)) {
+                req += d.requests; tok += d.totalTokens; cost += d.cost
+            }
+        }
+        return Triple(req, tok, cost)
+    }
+    // 首页仅显示 日/周 两个周期（近30天/本月 明细在详情页时间窗口里查看）
+    val windows = listOf(R.string.sub2_window_today to today, R.string.sub2_window_7d to today.minusDays(6))
+    return windows.map { (labelRes, from) ->
+        val (req, tok, cost) = sum(from)
+        val tokens = when {
+            tok >= 1_000_000_000 -> (tok / 1_000_000_000.0).formatLocale("%.1fB")
+            tok >= 1_000_000 -> (tok / 1_000_000.0).formatLocale("%.1fM")
+            tok >= 1_000 -> (tok / 1_000.0).formatLocale("%.1fK")
+            else -> tok.toString()
+        }
+        Sub2WindowSummary(labelRes = labelRes, requests = req, cost = cost, tokens = tokens)
+    }
+}
+
+/** 首页周期汇总（今日 / 近7天）。 */
+private data class Sub2WindowSummary(
+    @androidx.annotation.StringRes val labelRes: Int,
+    val requests: Long,
+    val cost: Double,
+    val tokens: String
+)
+
+private fun Double.formatLocale(pattern: String): String =
+    String.format(java.util.Locale.getDefault(), pattern, this)

app/src/main/java/com/rainy/token/ui/dashboard/UsageChartScreen.kt

@@ -53,12 +53,15 @@ import androidx.compose.ui.graphics.drawscope.DrawScope
 import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.graphics.nativeCanvas
 import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
 import com.rainy.token.data.local.ChartBucket
 import com.rainy.token.data.local.ChartGranularity
 import com.rainy.token.ui.theme.InkMuted
@@ -73,7 +76,7 @@ import java.util.Locale
 // 图表用色板（每个模型一个颜色，12 色 Material Design 500 色阶，足够区分 12 个模型）
 internal val modelColors = listOf(
     Color(0xFFF44336), // Red
-    Color(0xFFE91E63), // Pink
+    Color(0xFFC9436C), // Pink（玫瑰主色）
     Color(0xFF9C27B0), // Purple
     Color(0xFF673AB7), // Deep Purple
     Color(0xFF3F51B5), // Indigo
@@ -86,11 +89,11 @@ internal val modelColors = listOf(
     Color(0xFF607D8B)  // Blue Grey
 )
 
-// Token 堆叠色板：命中缓存（浅粉·顶）、未命中输入（粉·中）、输出（深粉·底）
+// Token 堆叠色板：命中缓存（浅樱粉·顶）、未命中输入（玫瑰粉·中）、输出（深玫瑰·底）
 internal val tokenColors = listOf(
-    Color(0xFFFFD1DC), // cache hit — 浅粉（上面）
-    Color(0xFFFF85A2), // cache miss input — 粉色（中间）
-    Color(0xFFE91E63)  // output — 深粉（下面）
+    Color(0xFFFFE3EC), // cache hit — 浅樱粉（上面）
+    Color(0xFFFFA3BC), // cache miss input — 玫瑰粉（中间）
+    Color(0xFFC9436C)  // output — 深玫瑰（主色，下面）
 )
 
 @OptIn(ExperimentalMaterial3Api::class)
@@ -100,6 +103,7 @@ fun UsageChartScreen(
     viewModel: UsageChartViewModel = hiltViewModel()
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
+    val context = LocalContext.current
     var granularityExpanded by remember { mutableStateOf(false) }
     var modelExpanded by remember { mutableStateOf(false) }
     var showCustomDayPicker by remember { mutableStateOf(false) }
@@ -115,9 +119,9 @@ fun UsageChartScreen(
         containerColor = Color.Transparent,
         topBar = {
             TopAppBar(
-                title = { Text("统计图表") },
+                title = { Text(stringResource(R.string.title_chart)) },
                 navigationIcon = {
-                    IconButton(onClick = onBack) { Icon(Icons.Filled.ArrowBack, "返回") }
+                    IconButton(onClick = onBack) { Icon(Icons.Filled.ArrowBack, stringResource(R.string.action_back)) }
                 },
                 colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Transparent)
             )
@@ -125,7 +129,7 @@ fun UsageChartScreen(
     ) { innerPadding ->
         if (state.loading) {
             Box(Modifier.fillMaxSize().padding(innerPadding), contentAlignment = Alignment.Center) {
-                Text("加载中…", color = InkMuted)
+                Text(stringResource(R.string.common_loading), color = InkMuted)
             }
         } else {
             BoxWithConstraints(modifier = Modifier.fillMaxSize().padding(innerPadding)) {
@@ -146,13 +150,13 @@ fun UsageChartScreen(
                         // 粒度下拉
                         Box {
                             TextButton(onClick = { granularityExpanded = true }) {
-                                Text(state.granularity.label, color = StrawberryPink)
+                                Text(stringResource(state.granularity.labelRes), color = StrawberryPink)
                                 Icon(Icons.Filled.ArrowDropDown, null, tint = StrawberryPink)
                             }
                             DropdownMenu(granularityExpanded, { granularityExpanded = false }) {
                                 ChartGranularity.entries.forEach { g ->
                                     DropdownMenuItem(
-                                        text = { Text(g.label) },
+                                        text = { Text(stringResource(g.labelRes)) },
                                         onClick = {
                                             granularityExpanded = false
                                             when (g) {
@@ -169,15 +173,15 @@ fun UsageChartScreen(
                         Spacer(Modifier.weight(1f))
                         // 模型多选下拉
                         Box {
-                            val modelLabel = if (state.selectedModels.isEmpty()) "全部模型"
-                            else "${state.selectedModels.size} 个模型"
+                            val modelLabel = if (state.selectedModels.isEmpty()) stringResource(R.string.common_all_models)
+                            else stringResource(R.string.model_count, state.selectedModels.size)
                             TextButton(onClick = { modelExpanded = true }) {
                                 Text(modelLabel, color = StrawberryPink, style = MaterialTheme.typography.bodySmall)
                                 Icon(Icons.Filled.ArrowDropDown, null, tint = StrawberryPink)
                             }
                             DropdownMenu(modelExpanded, { modelExpanded = false }) {
                                 DropdownMenuItem(
-                                    text = { Text("全部模型", fontWeight = FontWeight.Bold) },
+                                    text = { Text(stringResource(R.string.common_all_models), fontWeight = FontWeight.Bold) },
                                     onClick = { modelExpanded = false; viewModel.selectAllModels() }
                                 )
                                 state.allModels.forEach { model ->
@@ -210,7 +214,7 @@ fun UsageChartScreen(
                             horizontalArrangement = Arrangement.spacedBy(12.dp)
                         ) {
                             Box(modifier = Modifier.weight(1f)) {
-                                ChartCard("消耗金额 (USD)", "$${String.format(Locale.US, "%.4f", costTotal)}", { showCostDetail = true }) {
+                                ChartCard(stringResource(R.string.chart_cost), "$${String.format(Locale.US, "%.4f", costTotal)}", { showCostDetail = true }) {
                                     StackedBarChart(
                                         buckets = state.buckets,
                                         valueSelector = { it.totalCost.toDouble() / 100_000_000.0 },
@@ -235,12 +239,12 @@ fun UsageChartScreen(
                                 }
                             }
                             Box(modifier = Modifier.weight(1f)) {
-                                ChartCard("API 请求次数", "${reqTotal}次", { showReqDetail = true }) {
+                                ChartCard(stringResource(R.string.chart_requests), stringResource(R.string.count_times, reqTotal), { showReqDetail = true }) {
                                     LineChart(
                                         buckets = state.buckets,
                                         valueSelector = { it.totalRequests.toFloat() },
                                         lineColor = StrawberryPink,
-                                        formatValue = { "${it.toInt()}次" },
+                                        formatValue = { context.getString(R.string.count_times, it.toInt()) },
                                         granularity = state.granularity,
                                         useUtc8 = state.useUtc8
                                     )
@@ -251,7 +255,7 @@ fun UsageChartScreen(
                     // 第三张图表独立一行
                     item {
                         val tokTotal = state.buckets.sumOf { it.cacheHitTokens + it.inputTokens + it.outputTokens }
-                        ChartCard("Token 消耗", formatTokenComma(tokTotal), { showTokenDetail = true }) {
+                        ChartCard(stringResource(R.string.chart_tokens), formatTokenComma(tokTotal), { showTokenDetail = true }) {
                             StackedBarChart(
                                 buckets = state.buckets,
                                 valueSelector = { (it.cacheHitTokens + it.inputTokens + it.outputTokens).toDouble() },
@@ -262,7 +266,7 @@ fun UsageChartScreen(
                                         bucket.cacheHitTokens.toDouble() to tokenColors[0]
                                     )
                                 },
-                                stackLabels = { listOf("输出", "输入(未命中)", "命中缓存") },
+                                stackLabels = { listOf(context.getString(R.string.chart_stack_output), context.getString(R.string.chart_stack_input), context.getString(R.string.chart_stack_cache)) },
                                 formatValue = { formatTokenComma(it.toLong()) },
                                 granularity = state.granularity,
                                 tooltipReversed = true,
@@ -271,9 +275,9 @@ fun UsageChartScreen(
                         }
                         ChartLegend(
                             items = listOf(
-                                "输入(未命中)" to tokenColors[1],
-                                "命中缓存" to tokenColors[0],
-                                "输出" to tokenColors[2]
+                                stringResource(R.string.chart_stack_input) to tokenColors[1],
+                                stringResource(R.string.chart_stack_cache) to tokenColors[0],
+                                stringResource(R.string.chart_stack_output) to tokenColors[2]
                             )
                         )
                     }
@@ -283,7 +287,7 @@ fun UsageChartScreen(
                         val models = state.selectedModels.ifEmpty { state.allModels.toSet() }
                         val costTotal = state.buckets.sumOf { it.totalCost.toDouble() / 100_000_000.0 }
                         ChartCard(
-                            title = "消耗金额 (USD)",
+                            title = stringResource(R.string.chart_cost),
                             summary = "$${String.format(Locale.US, "%.4f", costTotal)}",
                             onSummaryClick = { showCostDetail = true }
                         ) {
@@ -314,15 +318,15 @@ fun UsageChartScreen(
                     item {
                         val reqTotal = state.buckets.sumOf { it.totalRequests }
                         ChartCard(
-                            title = "API 请求次数",
-                            summary = "${reqTotal}次",
+                            title = stringResource(R.string.chart_requests),
+                            summary = stringResource(R.string.count_times, reqTotal),
                             onSummaryClick = { showReqDetail = true }
                         ) {
                             LineChart(
                                 buckets = state.buckets,
                                 valueSelector = { it.totalRequests.toFloat() },
                                 lineColor = StrawberryPink,
-                                formatValue = { "${it.toInt()}次" },
+                                formatValue = { context.getString(R.string.count_times, it.toInt()) },
                                 granularity = state.granularity,
                                 useUtc8 = state.useUtc8
                             )
@@ -332,7 +336,7 @@ fun UsageChartScreen(
                     item {
                         val tokTotal = state.buckets.sumOf { it.cacheHitTokens + it.inputTokens + it.outputTokens }
                         ChartCard(
-                            title = "Token 消耗",
+                            title = stringResource(R.string.chart_tokens),
                             summary = formatTokenComma(tokTotal),
                             onSummaryClick = { showTokenDetail = true }
                         ) {
@@ -346,7 +350,7 @@ fun UsageChartScreen(
                                         bucket.cacheHitTokens.toDouble() to tokenColors[0]
                                     )
                                 },
-                                stackLabels = { listOf("输出", "输入(未命中)", "命中缓存") },
+                                stackLabels = { listOf(context.getString(R.string.chart_stack_output), context.getString(R.string.chart_stack_input), context.getString(R.string.chart_stack_cache)) },
                                 formatValue = { formatTokenComma(it.toLong()) },
                                 granularity = state.granularity,
                                 tooltipReversed = true,
@@ -355,9 +359,9 @@ fun UsageChartScreen(
                         }
                         ChartLegend(
                             items = listOf(
-                                "输入(未命中)" to tokenColors[1],
-                                "命中缓存" to tokenColors[0],
-                                "输出" to tokenColors[2]
+                                stringResource(R.string.chart_stack_input) to tokenColors[1],
+                                stringResource(R.string.chart_stack_cache) to tokenColors[0],
+                                stringResource(R.string.chart_stack_output) to tokenColors[2]
                             )
                         )
                     }
@@ -371,7 +375,7 @@ fun UsageChartScreen(
         // ─── 自定义日期选择器 ───
         if (showCustomDayPicker) {
             DateTimePickerDialog(
-                title = "选择日期",
+                title = stringResource(R.string.date_select_day),
                 onConfirm = { ms ->
                     viewModel.setCustomDay(ms.toUtcLocalDate())
                     showCustomDayPicker = false
@@ -381,7 +385,7 @@ fun UsageChartScreen(
         }
         if (showCustomMonthPicker) {
             DateTimePickerDialog(
-                title = "选择月份（任意一天）",
+                title = stringResource(R.string.date_select_month),
                 onConfirm = { ms ->
                     viewModel.setCustomMonth(ms.toUtcLocalDate())
                     showCustomMonthPicker = false
@@ -391,7 +395,7 @@ fun UsageChartScreen(
         }
         if (showCustomRangeStart) {
             DateTimePickerDialog(
-                title = "开始日期",
+                title = stringResource(R.string.date_pick_start),
                 onConfirm = { ms ->
                     customRangeStartDate = ms.toUtcLocalDate()
                     showCustomRangeStart = false
@@ -402,7 +406,7 @@ fun UsageChartScreen(
         }
         if (showCustomRangeEnd) {
             DateTimePickerDialog(
-                title = "结束日期",
+                title = stringResource(R.string.date_pick_end),
                 onConfirm = { ms ->
                     val startDate = customRangeStartDate ?: return@DateTimePickerDialog
                     val endDate = ms.toUtcLocalDate()
@@ -420,7 +424,7 @@ fun UsageChartScreen(
         if (showCostDetail) {
             AlertDialog(
                 onDismissRequest = { showCostDetail = false },
-                title = { Text("消费明细", fontWeight = FontWeight.Bold) },
+                title = { Text(stringResource(R.string.chart_detail_cost), fontWeight = FontWeight.Bold) },
                 text = {
                     Column {
                         models.forEach { model ->
@@ -435,13 +439,13 @@ fun UsageChartScreen(
                         }
                     }
                 },
-                confirmButton = { TextButton(onClick = { showCostDetail = false }) { Text("关闭") } }
+                confirmButton = { TextButton(onClick = { showCostDetail = false }) { Text(stringResource(R.string.action_close)) } }
             )
         }
         if (showReqDetail) {
             AlertDialog(
                 onDismissRequest = { showReqDetail = false },
-                title = { Text("调用次数明细", fontWeight = FontWeight.Bold) },
+                title = { Text(stringResource(R.string.chart_detail_requests), fontWeight = FontWeight.Bold) },
                 text = {
                     Column {
                         models.forEach { model ->
@@ -449,13 +453,13 @@ fun UsageChartScreen(
                             if (total > 0) {
                                 Row(Modifier.fillMaxWidth().padding(vertical = 2.dp), horizontalArrangement = Arrangement.SpaceBetween) {
                                     Text(model, style = MaterialTheme.typography.bodySmall)
-                                    Text("${total}次", color = StrawberryPink, style = MaterialTheme.typography.bodySmall)
+                                    Text(stringResource(R.string.count_times, total), color = StrawberryPink, style = MaterialTheme.typography.bodySmall)
                                 }
                             }
                         }
                     }
                 },
-                confirmButton = { TextButton(onClick = { showReqDetail = false }) { Text("关闭") } }
+                confirmButton = { TextButton(onClick = { showReqDetail = false }) { Text(stringResource(R.string.action_close)) } }
             )
         }
         if (showTokenDetail) {
@@ -464,24 +468,24 @@ fun UsageChartScreen(
             val outTotal = state.buckets.sumOf { it.outputTokens }
             AlertDialog(
                 onDismissRequest = { showTokenDetail = false },
-                title = { Text("Token 明细", fontWeight = FontWeight.Bold) },
+                title = { Text(stringResource(R.string.chart_detail_tokens), fontWeight = FontWeight.Bold) },
                 text = {
                     Column {
                         Row(Modifier.fillMaxWidth().padding(vertical = 2.dp), horizontalArrangement = Arrangement.SpaceBetween) {
-                            Text("命中缓存", style = MaterialTheme.typography.bodySmall)
+                            Text(stringResource(R.string.chart_stack_cache), style = MaterialTheme.typography.bodySmall)
                             Text(formatTokenComma(hitTotal), color = StrawberryPink, style = MaterialTheme.typography.bodySmall)
                         }
                         Row(Modifier.fillMaxWidth().padding(vertical = 2.dp), horizontalArrangement = Arrangement.SpaceBetween) {
-                            Text("输入(未命中)", style = MaterialTheme.typography.bodySmall)
+                            Text(stringResource(R.string.chart_stack_input), style = MaterialTheme.typography.bodySmall)
                             Text(formatTokenComma(missTotal), color = StrawberryPink, style = MaterialTheme.typography.bodySmall)
                         }
                         Row(Modifier.fillMaxWidth().padding(vertical = 2.dp), horizontalArrangement = Arrangement.SpaceBetween) {
-                            Text("输出", style = MaterialTheme.typography.bodySmall)
+                            Text(stringResource(R.string.chart_stack_output), style = MaterialTheme.typography.bodySmall)
                             Text(formatTokenComma(outTotal), color = StrawberryPink, style = MaterialTheme.typography.bodySmall)
                         }
                     }
                 },
-                confirmButton = { TextButton(onClick = { showTokenDetail = false }) { Text("关闭") } }
+                confirmButton = { TextButton(onClick = { showTokenDetail = false }) { Text(stringResource(R.string.action_close)) } }
             )
         }
     }
@@ -544,10 +548,11 @@ internal fun StackedBarChart(
     useUtc8: Boolean = false
 ) {
     if (buckets.isEmpty()) {
-        Text("暂无数据", color = InkMuted, style = MaterialTheme.typography.bodySmall)
+        Text(stringResource(R.string.common_no_data), color = InkMuted, style = MaterialTheme.typography.bodySmall)
         return
     }
-    var tooltipBucket by remember { mutableStateOf(buckets.lastOrNull()) }
+    // key = buckets：切换时间范围/筛选后重置 tooltip，避免残留旧数据
+    var tooltipBucket by remember(buckets) { mutableStateOf(buckets.lastOrNull()) }
     val density = LocalDensity.current
     val d = density.density
     val barCount = buckets.size
@@ -639,7 +644,7 @@ internal fun StackedBarChart(
                 ) {
                     Column(Modifier.padding(8.dp)) {
                         Text(formatChartTime(bucket.ts, granularity, 0, 1, useUtc8).first, style = MaterialTheme.typography.labelSmall, fontWeight = FontWeight.Bold)
-                        Text("合计: ${formatValue(total)}", style = MaterialTheme.typography.bodySmall, color = StrawberryPink)
+                        Text(stringResource(R.string.chart_total_label, formatValue(total)), style = MaterialTheme.typography.bodySmall, color = StrawberryPink)
                         val labels = stackLabels(bucket)
                         val items = stackSelector(bucket).withIndex()
                         val display = if (tooltipReversed) items.toList().reversed() else items.toList()
@@ -674,10 +679,11 @@ internal fun LineChart(
     useUtc8: Boolean = false
 ) {
     if (buckets.isEmpty()) {
-        Text("暂无数据", color = InkMuted, style = MaterialTheme.typography.bodySmall)
+        Text(stringResource(R.string.common_no_data), color = InkMuted, style = MaterialTheme.typography.bodySmall)
         return
     }
-    var tooltipBucket by remember { mutableStateOf(buckets.lastOrNull()) }
+    // key = buckets：切换时间范围/筛选后重置 tooltip，避免残留旧数据
+    var tooltipBucket by remember(buckets) { mutableStateOf(buckets.lastOrNull()) }
     val density = LocalDensity.current
     val d = density.density
     val barCount = buckets.size
@@ -809,6 +815,7 @@ ChartGranularity.YESTERDAY_HOURLY,
 ChartGranularity.CUSTOM_DAY_HOURLY ->
 index == 0 || index == total - 1  // 只显示首尾小时
 ChartGranularity.LAST_7D_DAILY,
+ChartGranularity.LAST_30D_DAILY,
 ChartGranularity.THIS_MONTH_DAILY,
 ChartGranularity.CUSTOM_MONTH_DAILY,
 ChartGranularity.CUSTOM_RANGE_DAILY ->

app/src/main/java/com/rainy/token/ui/dashboard/UsageChartViewModel.kt

@@ -120,6 +120,7 @@ class UsageChartViewModel @Inject constructor(
                     ChartAggregator.aggregateHourly(filtered, offsetHours)
                 ChartGranularity.THIS_MONTH_DAILY,
                 ChartGranularity.LAST_7D_DAILY,
+                ChartGranularity.LAST_30D_DAILY,
                 ChartGranularity.CUSTOM_MONTH_DAILY,
                 ChartGranularity.CUSTOM_RANGE_DAILY ->
                     ChartAggregator.aggregateDaily(filtered, offsetHours)
@@ -152,30 +153,35 @@ class UsageChartViewModel @Inject constructor(
             // 降级后或用户手动选择 → 关闭降级，正常显示
             allowFallback = false
 
+            // 图例数据源：只保留当前显示范围内实际出现过的模型
+            val rangeModels = result.flatMap { it.byModel.keys }.distinct().sorted()
+
             _state.update {
                 it.copy(
                     buckets = result,
                     allModels = allModels,
+                    rangeModels = rangeModels,
                     loading = false
                 )
             }
         }
     }
     fun setCustomDay(date: LocalDate) {
-        _state.update { it.copy(granularity = ChartGranularity.CUSTOM_DAY_HOURLY) }
+        _state.update { it.copy(granularity = ChartGranularity.CUSTOM_DAY_HOURLY, customDay = date) }
         _customDay = date
         load()
     }
 
     fun setCustomMonth(monthDate: LocalDate) {
-        _state.update { it.copy(granularity = ChartGranularity.CUSTOM_MONTH_DAILY) }
-        _customMonth = monthDate.withDayOfMonth(1)
+        val month = monthDate.withDayOfMonth(1)
+        _state.update { it.copy(granularity = ChartGranularity.CUSTOM_MONTH_DAILY, customMonth = month) }
+        _customMonth = month
         load()
     }
 
     fun setCustomRange(fromDate: LocalDate, toDate: LocalDate) {
         if (toDate.isBefore(fromDate)) return
-        _state.update { it.copy(granularity = ChartGranularity.CUSTOM_RANGE_DAILY) }
+        _state.update { it.copy(granularity = ChartGranularity.CUSTOM_RANGE_DAILY, customRange = fromDate to toDate) }
         _customRange = fromDate to toDate
         load()
     }
@@ -196,6 +202,7 @@ class UsageChartViewModel @Inject constructor(
             ChartGranularity.TODAY_HOURLY -> todayMidnight to todayMidnight + 86400_000L - 1
             ChartGranularity.YESTERDAY_HOURLY -> todayMidnight - 86400_000L to todayMidnight - 1
             ChartGranularity.LAST_7D_DAILY -> todayMidnight - 6 * 86400_000L to todayMidnight + 86400_000L - 1
+            ChartGranularity.LAST_30D_DAILY -> todayMidnight - 29 * 86400_000L to todayMidnight + 86400_000L - 1
             ChartGranularity.CUSTOM_DAY_HOURLY -> dayRange(_customDay ?: today, zoneOffset)
             ChartGranularity.THIS_MONTH_DAILY -> monthRange(today.withDayOfMonth(1), zoneOffset)
             ChartGranularity.CUSTOM_MONTH_DAILY -> {
@@ -260,6 +267,12 @@ data class ChartUiState(
     val loading: Boolean = true,
     val granularity: ChartGranularity = ChartGranularity.LAST_5H_HOURLY,
     val allModels: List<String> = emptyList(),
+    /** 当前显示范围内实际出现过的模型（图例只显示这些） */
+    val rangeModels: List<String> = emptyList(),
+    /** 自定义选择的回显值（选择器打开时预填用） */
+    val customDay: LocalDate? = null,
+    val customMonth: LocalDate? = null,
+    val customRange: Pair<LocalDate, LocalDate>? = null,
     val selectedModels: Set<String> = emptySet(), // empty = all
     val buckets: List<ChartBucket> = emptyList(),
     val useUtc8: Boolean = false,

app/src/main/java/com/rainy/token/ui/dashboard/UsageDataScreen.kt

@@ -46,17 +46,20 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
 import com.rainy.token.data.local.UsageRecord
 import com.rainy.token.ui.theme.inkMuted
 import com.rainy.token.ui.theme.StrawberryPink
 import java.text.SimpleDateFormat
 import java.time.Instant
+import java.time.LocalDate
 import java.time.ZoneOffset
 import java.util.Date
 import java.util.Locale
@@ -80,10 +83,7 @@ fun UsageDataScreen(
 
     var timeMenuExpanded by remember { mutableStateOf(false) }
     var modelMenuExpanded by remember { mutableStateOf(false) }
-    var showStartPicker by remember { mutableStateOf(false) }
-    var showEndPicker by remember { mutableStateOf(false) }
-    var customStartMs by remember { mutableStateOf(0L) }
-    var customEndMs by remember { mutableStateOf(0L) }
+    var showRangePicker by remember { mutableStateOf(false) }
     var showCustomDayPicker by remember { mutableStateOf(false) }
     var showCustomMonthPicker by remember { mutableStateOf(false) }
     var rawRecord by remember { mutableStateOf<UsageRecord?>(null) }
@@ -93,8 +93,8 @@ fun UsageDataScreen(
         containerColor = Color.Transparent,
         topBar = {
             TopAppBar(
-                title = { Text("详细数据") },
-                navigationIcon = { IconButton(onClick = onBack) { Icon(Icons.Filled.ArrowBack, "返回") } },
+                title = { Text(stringResource(R.string.title_raw_data)) },
+                navigationIcon = { IconButton(onClick = onBack) { Icon(Icons.Filled.ArrowBack, stringResource(R.string.action_back)) } },
                 colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Transparent)
             )
         }
@@ -105,7 +105,7 @@ fun UsageDataScreen(
                 // 时间筛选
                 Box {
                     TextButton(onClick = { timeMenuExpanded = true }) {
-                        Text(state.timeFilter.label, color = StrawberryPink, fontWeight = FontWeight.SemiBold, fontSize = 13.sp)
+                        Text(stringResource(state.timeFilter.labelRes), color = StrawberryPink, fontWeight = FontWeight.SemiBold, fontSize = 13.sp)
                         Icon(Icons.Filled.ArrowDropDown, null, tint = StrawberryPink)
                     }
                     DropdownMenu(timeMenuExpanded, { timeMenuExpanded = false }) {
@@ -114,18 +114,18 @@ fun UsageDataScreen(
                             TimeFilter.Today, TimeFilter.Yesterday,
                             TimeFilter.Last7Days, TimeFilter.Last30Days, TimeFilter.ThisMonth
                         ).forEach { f ->
-                            DropdownMenuItem(text = { Text(f.label) }, onClick = {
+                            DropdownMenuItem(text = { Text(stringResource(f.labelRes)) }, onClick = {
                                 timeMenuExpanded = false; viewModel.setTimeFilter(f)
                             })
                         }
-                        DropdownMenuItem(text = { Text("自定义天") }, onClick = {
+                        DropdownMenuItem(text = { Text(stringResource(R.string.time_custom_day)) }, onClick = {
                             timeMenuExpanded = false; showCustomDayPicker = true
                         })
-                        DropdownMenuItem(text = { Text("自定义月") }, onClick = {
+                        DropdownMenuItem(text = { Text(stringResource(R.string.time_custom_month)) }, onClick = {
                             timeMenuExpanded = false; showCustomMonthPicker = true
                         })
-                        DropdownMenuItem(text = { Text("自定义时间") }, onClick = {
-                            timeMenuExpanded = false; viewModel.setTimeFilter(TimeFilter.Custom(0L, 0L))
+                        DropdownMenuItem(text = { Text(stringResource(R.string.time_custom_range)) }, onClick = {
+                            timeMenuExpanded = false; showRangePicker = true
                         })
                     }
                 }
@@ -133,13 +133,13 @@ fun UsageDataScreen(
                 Spacer(Modifier.weight(1f))
                 // 模型筛选
                 Box {
-                    val label = if (state.selectedModels.isEmpty()) "全部模型" else "${state.selectedModels.size} 个"
+                    val label = if (state.selectedModels.isEmpty()) stringResource(R.string.common_all_models) else stringResource(R.string.model_count_short, state.selectedModels.size)
                     TextButton(onClick = { modelMenuExpanded = true }) {
                         Text(label, color = StrawberryPink, fontSize = 13.sp)
                         Icon(Icons.Filled.ArrowDropDown, null, tint = StrawberryPink)
                     }
                     DropdownMenu(modelMenuExpanded, { modelMenuExpanded = false }) {
-                        DropdownMenuItem(text = { Text("全部模型", fontWeight = FontWeight.Bold) },
+                        DropdownMenuItem(text = { Text(stringResource(R.string.common_all_models), fontWeight = FontWeight.Bold) },
                             onClick = { modelMenuExpanded = false; viewModel.selectAllModels() })
                         state.allModels.forEach { m ->
                             DropdownMenuItem(text = {
@@ -153,17 +153,14 @@ fun UsageDataScreen(
                 }
             }
 
-            // 自定义时间范围
-            if (state.timeFilter is TimeFilter.Custom && (state.timeFilter as TimeFilter.Custom).from == 0L) {
-                CustomTimeRangeRow(customStartMs, customEndMs,
-                    { showStartPicker = true }, { showEndPicker = true },
-                    { viewModel.setTimeFilter(TimeFilter.Custom(customStartMs, customEndMs)) })
-                Text("所有时间按 UTC+0 计算", style = MaterialTheme.typography.bodySmall, color = inkMuted())
+            // 自定义时间范围：确认选择后显示 UTC 说明
+            if (state.timeFilter is TimeFilter.Custom) {
+                Text(stringResource(R.string.usage_utc0_note), style = MaterialTheme.typography.bodySmall, color = inkMuted())
             }
 
             // ─── 记录数 + 分页 ───
             Row(Modifier.fillMaxWidth().padding(vertical = 4.dp), Arrangement.SpaceBetween, Alignment.CenterVertically) {
-                Text("${state.totalRecords} 条记录", style = MaterialTheme.typography.bodySmall, color = inkMuted())
+                Text(stringResource(R.string.usage_record_count, state.totalRecords), style = MaterialTheme.typography.bodySmall, color = inkMuted())
                 if (state.totalPages > 1) {
                     Row(verticalAlignment = Alignment.CenterVertically) {
                         TextButton(onClick = { viewModel.prevPage() }, enabled = state.currentPage > 1) {
@@ -188,7 +185,7 @@ fun UsageDataScreen(
                             val p = pageInput.toIntOrNull()
                             if (p != null) { viewModel.goToPage(p); pageInput = "" }
                         }) {
-                            Text("跳转", color = StrawberryPink, fontSize = 12.sp)
+                            Text(stringResource(R.string.action_jump), color = StrawberryPink, fontSize = 12.sp)
                         }
                     }
                 }
@@ -198,22 +195,22 @@ fun UsageDataScreen(
             Card(Modifier.fillMaxWidth(), RoundedCornerShape(topStart = 12.dp, topEnd = 12.dp),
                 CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface)) {
                 Row(Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 8.dp)) {
-                    HeaderCell("时间", Modifier.weight(1.5f), false)
-                    HeaderCell("模型", Modifier.weight(1.8f), false)
-                    HeaderCell("输入(缓存)", Modifier.weight(1.5f), false)
-                    HeaderCell("输出", Modifier.weight(1.2f), false)
-                    HeaderCell("成本", Modifier.weight(1.0f), false)
+                    HeaderCell(stringResource(R.string.header_time), Modifier.weight(1.5f), false)
+                    HeaderCell(stringResource(R.string.header_model), Modifier.weight(1.8f), false)
+                    HeaderCell(stringResource(R.string.header_input_cache), Modifier.weight(1.5f), false)
+                    HeaderCell(stringResource(R.string.header_output), Modifier.weight(1.2f), false)
+                    HeaderCell(stringResource(R.string.header_cost), Modifier.weight(1.0f), false)
                 }
             }
 
             // ─── 记录列表 ───
             if (state.loading) {
                 Box(Modifier.fillMaxWidth().height(200.dp), contentAlignment = Alignment.Center) {
-                    Text("加载中…", color = inkMuted())
+                    Text(stringResource(R.string.common_loading), color = inkMuted())
                 }
             } else if (state.records.isEmpty()) {
                 Box(Modifier.fillMaxWidth().height(200.dp), contentAlignment = Alignment.Center) {
-                    Text("暂无数据", color = inkMuted())
+                    Text(stringResource(R.string.common_no_data), color = inkMuted())
                 }
             } else {
                 LazyColumn(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(1.dp)) {
@@ -226,45 +223,68 @@ fun UsageDataScreen(
         }
 
         // 日期选择器
-        if (showCustomDayPicker) DateTimePickerDialog("选择日期", { ms ->
-            val utc = ZoneOffset.UTC; val ds = Instant.ofEpochMilli(ms).atOffset(utc).toLocalDate().atStartOfDay(utc).toInstant().toEpochMilli()
-            viewModel.setTimeFilter(TimeFilter.Custom(ds, ds + 86400_000L - 1)); showCustomDayPicker = false
-        }, { showCustomDayPicker = false })
-        if (showCustomMonthPicker) DateTimePickerDialog("选择月份（任意一天）", { ms ->
-            val utc = ZoneOffset.UTC; val ld = Instant.ofEpochMilli(ms).atOffset(utc).toLocalDate()
-            val msStart = ld.withDayOfMonth(1).atStartOfDay(utc).toInstant().toEpochMilli()
-            val msEnd = ld.withDayOfMonth(ld.lengthOfMonth()).plusDays(1).atStartOfDay(utc).toInstant().toEpochMilli() - 1
-            viewModel.setTimeFilter(TimeFilter.Custom(msStart, msEnd)); showCustomMonthPicker = false
-        }, { showCustomMonthPicker = false })
-        if (showStartPicker) DateTimePickerDialog("开始时间", { customStartMs = it; showStartPicker = false }, { showStartPicker = false })
-        if (showEndPicker) DateTimePickerDialog("结束时间", { ms ->
-            viewModel.setTimeFilter(TimeFilter.Custom(customStartMs, ms)); showEndPicker = false
-        }, { showEndPicker = false })
+        if (showCustomDayPicker) DateOnlyPickerDialog(
+            title = stringResource(R.string.date_select_day),
+            initialDate = (state.timeFilter as? TimeFilter.Custom)?.from?.takeIf { it > 0 }?.toUtcLocalDate(),
+            onConfirm = { date ->
+                val ds = date.toUtcStartOfDayMillis()
+                viewModel.setTimeFilter(TimeFilter.Custom(ds, ds + 86400_000L - 1))
+                showCustomDayPicker = false
+            },
+            onDismiss = { showCustomDayPicker = false }
+        )
+        if (showCustomMonthPicker) DateOnlyPickerDialog(
+            title = stringResource(R.string.date_select_month),
+            initialDate = (state.timeFilter as? TimeFilter.Custom)?.from?.takeIf { it > 0 }?.toUtcLocalDate(),
+            onConfirm = { date ->
+                val utc = ZoneOffset.UTC
+                val msStart = date.withDayOfMonth(1).atStartOfDay(utc).toInstant().toEpochMilli()
+                val msEnd = date.withDayOfMonth(date.lengthOfMonth()).plusDays(1).atStartOfDay(utc).toInstant().toEpochMilli() - 1
+                viewModel.setTimeFilter(TimeFilter.Custom(msStart, msEnd))
+                showCustomMonthPicker = false
+            },
+            onDismiss = { showCustomMonthPicker = false }
+        )
+        if (showRangePicker) {
+            val current = state.timeFilter as? TimeFilter.Custom
+            DateRangePickerDialog(
+                title = stringResource(R.string.date_pick_range),
+                initialStart = current?.from?.takeIf { it > 0 }?.toUtcLocalDate(),
+                initialEnd = current?.to?.takeIf { current.from > 0 }?.toUtcLocalDate(),
+                onConfirm = { from, to ->
+                    val fromMs = from.toUtcStartOfDayMillis()
+                    val toMs = to.toUtcStartOfDayMillis()
+                    viewModel.setTimeFilter(TimeFilter.Custom(fromMs, toMs + 86400_000L - 1))
+                    showRangePicker = false
+                },
+                onDismiss = { showRangePicker = false }
+            )
+        }
 
         // 原始数据弹窗
         rawRecord?.let { record ->
             AlertDialog(
                 onDismissRequest = { rawRecord = null },
-                title = { Text("原始数据", fontWeight = FontWeight.Bold) },
+                title = { Text(stringResource(R.string.raw_record_title), fontWeight = FontWeight.Bold) },
                 text = {
                     Column(Modifier.horizontalScroll(rememberScrollState())) {
                         RawField("ID", record.id)
-                        RawField("时间", formatUtcTime(record.timeCreated))
-                        RawField("模型", record.model)
+                        RawField(stringResource(R.string.header_time), formatUtcTime(record.timeCreated))
+                        RawField(stringResource(R.string.header_model), record.model)
                         RawField("Provider", record.provider)
-                        RawField("输入 Token", "%,d".format(Locale.US, record.inputTokens))
-                        RawField("输出 Token", "%,d".format(Locale.US, record.outputTokens))
-                        RawField("推理 Token", "%,d".format(Locale.US, record.reasoningTokens))
-                        RawField("缓存读取", "%,d".format(Locale.US, record.cacheReadTokens))
-                        RawField("缓存写入(5m)", "%,d".format(Locale.US, record.cacheWrite5mTokens))
-                        RawField("缓存写入(1h)", "%,d".format(Locale.US, record.cacheWrite1hTokens))
-                        RawField("成本(USD)", "$${String.format(Locale.US, "%.6f", record.costUsd)}")
-                        RawField("成本(Raw)", "${record.cost}")
+                        RawField(stringResource(R.string.usage_input_tokens), "%,d".format(Locale.US, record.inputTokens))
+                        RawField(stringResource(R.string.usage_output_tokens), "%,d".format(Locale.US, record.outputTokens))
+                        RawField(stringResource(R.string.usage_reasoning_tokens), "%,d".format(Locale.US, record.reasoningTokens))
+                        RawField(stringResource(R.string.stat_cache_read), "%,d".format(Locale.US, record.cacheReadTokens))
+                        RawField(stringResource(R.string.stat_cache_write_5m), "%,d".format(Locale.US, record.cacheWrite5mTokens))
+                        RawField(stringResource(R.string.stat_cache_write_1h), "%,d".format(Locale.US, record.cacheWrite1hTokens))
+                        RawField(stringResource(R.string.raw_cost_usd), "$${String.format(Locale.US, "%.6f", record.costUsd)}")
+                        RawField(stringResource(R.string.raw_cost_raw), "${record.cost}")
                         RawField("KeyId", record.keyId)
                         RawField("SessionId", record.sessionId)
                     }
                 },
-                confirmButton = { TextButton(onClick = { rawRecord = null }) { Text("关闭") } }
+                confirmButton = { TextButton(onClick = { rawRecord = null }) { Text(stringResource(R.string.action_close)) } }
             )
         }
     }
@@ -311,6 +331,12 @@ private fun RawField(label: String, value: String) {
     }
 }
 
+private fun Long.toUtcLocalDate(): LocalDate =
+    Instant.ofEpochMilli(this).atOffset(ZoneOffset.UTC).toLocalDate()
+
+private fun LocalDate.toUtcStartOfDayMillis(): Long =
+    atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
+
 private fun formatInputWithCache(record: UsageRecord): String {
     val input = record.inputTokens + record.cacheReadTokens
     val cache = record.cacheReadTokens

app/src/main/java/com/rainy/token/ui/dashboard/UsageDetailScreen.kt

@@ -50,11 +50,15 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
 import com.rainy.token.data.local.ChartGranularity
 import com.rainy.token.ui.theme.InkMuted
 import com.rainy.token.ui.theme.StrawberryPink
@@ -80,6 +84,7 @@ fun UsageDetailScreen(
     clearViewModel: UsageViewModel? = null  // non-null = CCGO, 显示清除按钮
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
+    val context = LocalContext.current
 
     // OCGO 首次加载（CCGO 由 NavHost 的 setWorkspace 触发，不重复 load）
     LaunchedEffect(Unit) {
@@ -92,9 +97,7 @@ fun UsageDetailScreen(
     var modelExpanded by remember { mutableStateOf(false) }
     var showCustomDayPicker by remember { mutableStateOf(false) }
     var showCustomMonthPicker by remember { mutableStateOf(false) }
-    var showCustomRangeStart by remember { mutableStateOf(false) }
-    var showCustomRangeEnd by remember { mutableStateOf(false) }
-    var customRangeStartDate by remember { mutableStateOf<LocalDate?>(null) }
+    var showCustomRangePicker by remember { mutableStateOf(false) }
     var showCostDetail by remember { mutableStateOf(false) }
     var showReqDetail by remember { mutableStateOf(false) }
     var showTokenDetail by remember { mutableStateOf(false) }
@@ -106,16 +109,32 @@ fun UsageDetailScreen(
         snackbarHost = { SnackbarHost(snackbarHostState) },
         topBar = {
             TopAppBar(
-                title = { Text("用量详情") },
-                navigationIcon = { IconButton(onClick = onBack) { Icon(Icons.Filled.ArrowBack, "返回") } },
+                title = {
+                    val serviceLabel = if (clearViewModel == null) "OCGO" else "CommandCode"
+                    Column {
+                        Text(
+                            stringResource(R.string.title_usage_detail),
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
+                        )
+                        Text(
+                            serviceLabel,
+                            style = MaterialTheme.typography.bodySmall,
+                            color = InkMuted,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
+                        )
+                    }
+                },
+                navigationIcon = { IconButton(onClick = onBack) { Icon(Icons.Filled.ArrowBack, stringResource(R.string.action_back)) } },
                 actions = {
                     if (clearViewModel != null) {
                         TextButton(onClick = { showClearDialog = true }) {
-                            Text("清除", color = MaterialTheme.colorScheme.error, fontWeight = FontWeight.SemiBold, fontSize = 13.sp)
+                            Text(stringResource(R.string.action_clear), color = MaterialTheme.colorScheme.error, fontWeight = FontWeight.SemiBold, fontSize = 13.sp)
                         }
                     }
                     TextButton(onClick = onOpenData) {
-                        Text("详细数据", color = StrawberryPink, fontWeight = FontWeight.SemiBold, fontSize = 13.sp)
+                        Text(stringResource(R.string.action_view_raw_data), color = StrawberryPink, fontWeight = FontWeight.SemiBold, fontSize = 13.sp)
                     }
                 },
                 colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Transparent)
@@ -124,7 +143,7 @@ fun UsageDetailScreen(
     ) { innerPadding ->
         if (state.loading) {
             Box(Modifier.fillMaxSize().padding(innerPadding), contentAlignment = Alignment.Center) {
-                Text("加载中…", color = InkMuted)
+                Text(stringResource(R.string.common_loading), color = InkMuted)
             }
         } else {
             BoxWithConstraints(modifier = Modifier.fillMaxSize().padding(innerPadding)) {
@@ -139,17 +158,17 @@ fun UsageDetailScreen(
                         Row(Modifier.fillMaxWidth(), Arrangement.spacedBy(8.dp), Alignment.CenterVertically) {
                             Box {
                                 TextButton(onClick = { granularityExpanded = true }) {
-                                    Text(state.granularity.label, color = StrawberryPink)
+                                    Text(stringResource(state.granularity.labelRes), color = StrawberryPink)
                                     Icon(Icons.Filled.ArrowDropDown, null, tint = StrawberryPink)
                                 }
                                 DropdownMenu(granularityExpanded, { granularityExpanded = false }) {
                                     ChartGranularity.entries.forEach { g ->
-                                        DropdownMenuItem(text = { Text(g.label) }, onClick = {
+                                        DropdownMenuItem(text = { Text(stringResource(g.labelRes)) }, onClick = {
                                             granularityExpanded = false
                                             when (g) {
                                                 ChartGranularity.CUSTOM_DAY_HOURLY -> showCustomDayPicker = true
                                                 ChartGranularity.CUSTOM_MONTH_DAILY -> showCustomMonthPicker = true
-                                                ChartGranularity.CUSTOM_RANGE_DAILY -> showCustomRangeStart = true
+                                                ChartGranularity.CUSTOM_RANGE_DAILY -> showCustomRangePicker = true
                                                 else -> viewModel.setGranularity(g)
                                             }
                                         })
@@ -160,7 +179,7 @@ fun UsageDetailScreen(
                                 viewModel.toggleUtc8()
                                 scope.launch {
                                     snackbarHostState.showSnackbar(
-                                        if (state.useUtc8) "已切换到 UTC+8，图表按北京时间显示" else "已切换到 UTC+0，图表按世界协调时显示",
+                                        if (state.useUtc8) context.getString(R.string.msg_utc8_on) else context.getString(R.string.msg_utc0_on),
                                         duration = SnackbarDuration.Short
                                     )
                                 }
@@ -172,7 +191,7 @@ fun UsageDetailScreen(
                                     fontWeight = if (state.useUtc8) FontWeight.SemiBold else FontWeight.Normal
                                 )
                                 Text(
-                                    " 点击切换",
+                                    stringResource(R.string.usage_click_to_switch),
                                     style = MaterialTheme.typography.bodySmall,
                                     color = InkMuted.copy(alpha = 0.5f),
                                     fontWeight = FontWeight.Normal
@@ -180,14 +199,14 @@ fun UsageDetailScreen(
                             }
                             Spacer(Modifier.weight(1f))
                             Box {
-                                val label = if (state.selectedModels.isEmpty()) "全部模型" else "${state.selectedModels.size} 个模型"
+                                val label = if (state.selectedModels.isEmpty()) stringResource(R.string.common_all_models) else stringResource(R.string.model_count, state.selectedModels.size)
                                 TextButton(onClick = { modelExpanded = true }) {
                                     Text(label, color = StrawberryPink, style = MaterialTheme.typography.bodySmall)
                                     Icon(Icons.Filled.ArrowDropDown, null, tint = StrawberryPink)
                                 }
                                 DropdownMenu(modelExpanded, { modelExpanded = false }) {
                                     DropdownMenuItem(
-                                        text = { Text("全部模型", fontWeight = FontWeight.Bold) },
+                                        text = { Text(stringResource(R.string.common_all_models), fontWeight = FontWeight.Bold) },
                                         onClick = { modelExpanded = false; viewModel.selectAllModels() })
                                     state.allModels.forEach { model ->
                                         DropdownMenuItem(text = {
@@ -205,7 +224,7 @@ fun UsageDetailScreen(
                     if (wideEnough) {
                         // 面板够宽：前两张图表并排
                         item {
-                            val models = state.selectedModels.ifEmpty { state.allModels.toSet() }
+                            val models = state.rangeModels
                             val costTotal = state.buckets.sumOf { it.totalCost.toDouble() / 100_000_000.0 }
                             val reqTotal = state.buckets.sumOf { it.totalRequests }
                             Row(
@@ -213,7 +232,7 @@ fun UsageDetailScreen(
                                 horizontalArrangement = Arrangement.spacedBy(12.dp)
                             ) {
                                 Box(modifier = Modifier.weight(1f)) {
-                                    ChartCard("消耗金额 (USD)", "$${String.format(Locale.US, "%.4f", costTotal)}", { showCostDetail = true }) {
+                                    ChartCard(stringResource(R.string.chart_cost), "$${String.format(Locale.US, "%.4f", costTotal)}", { showCostDetail = true }) {
                                         StackedBarChart(state.buckets,
                                             { it.totalCost.toDouble() / 100_000_000.0 },
                                             { bucket -> models.mapIndexedNotNull { idx, m -> val v = bucket.byModel[m]?.cost ?: return@mapIndexedNotNull null; v.toDouble() / 100_000_000.0 to modelColors[idx % modelColors.size] } },
@@ -228,33 +247,33 @@ fun UsageDetailScreen(
                                     }
                                 }
                                 Box(modifier = Modifier.weight(1f)) {
-                                    ChartCard("API 请求次数", "${reqTotal}次", { showReqDetail = true }) {
-                                        LineChart(state.buckets, { it.totalRequests.toFloat() }, StrawberryPink, { "${it.toInt()}次" }, state.granularity, useUtc8 = state.useUtc8)
+                                    ChartCard(stringResource(R.string.chart_requests), stringResource(R.string.count_times, reqTotal), { showReqDetail = true }) {
+                                        LineChart(state.buckets, { it.totalRequests.toFloat() }, StrawberryPink, { context.getString(R.string.count_times, it.toInt()) }, state.granularity, useUtc8 = state.useUtc8)
                                     }
                                 }
                             }
                         }
                         item {
                             val tokTotal = state.buckets.sumOf { it.cacheHitTokens + it.inputTokens + it.outputTokens }
-                            ChartCard("Token 消耗", formatTokenComma(tokTotal), { showTokenDetail = true }) {
+                            ChartCard(stringResource(R.string.chart_tokens), formatTokenComma(tokTotal), { showTokenDetail = true }) {
                                 StackedBarChart(state.buckets,
                                     { (it.cacheHitTokens + it.inputTokens + it.outputTokens).toDouble() },
                                     { bucket -> listOfNotNull(bucket.outputTokens.toDouble() to tokenColors[2], bucket.inputTokens.toDouble() to tokenColors[1], bucket.cacheHitTokens.toDouble() to tokenColors[0]) },
-                                    { listOf("输出", "输入(未命中)", "命中缓存") },
+                                    { listOf(context.getString(R.string.chart_stack_output), context.getString(R.string.chart_stack_input), context.getString(R.string.chart_stack_cache)) },
                                     formatValue = { formatTokenComma(it.toLong()) },
                                     granularity = state.granularity,
                                     tooltipReversed = true,
                                     useUtc8 = state.useUtc8
                                 )
                             }
-                            ChartLegend(listOf("输入(未命中)" to tokenColors[1], "命中缓存" to tokenColors[0], "输出" to tokenColors[2]))
+                            ChartLegend(listOf(stringResource(R.string.chart_stack_input) to tokenColors[1], stringResource(R.string.chart_stack_cache) to tokenColors[0], stringResource(R.string.chart_stack_output) to tokenColors[2]))
                         }
                     } else {
                         // 窄面板：三张图表纵向堆叠
                         item {
-                            val models = state.selectedModels.ifEmpty { state.allModels.toSet() }
+                            val models = state.rangeModels
                             val costTotal = state.buckets.sumOf { it.totalCost.toDouble() / 100_000_000.0 }
-                            ChartCard("消耗金额 (USD)", "$${String.format(Locale.US, "%.4f", costTotal)}", { showCostDetail = true }) {
+                            ChartCard(stringResource(R.string.chart_cost), "$${String.format(Locale.US, "%.4f", costTotal)}", { showCostDetail = true }) {
                                 StackedBarChart(state.buckets,
                                     { it.totalCost.toDouble() / 100_000_000.0 },
                                     { bucket -> models.mapIndexedNotNull { idx, m -> val v = bucket.byModel[m]?.cost ?: return@mapIndexedNotNull null; v.toDouble() / 100_000_000.0 to modelColors[idx % modelColors.size] } },
@@ -270,29 +289,29 @@ fun UsageDetailScreen(
                         }
                         item {
                             val reqTotal = state.buckets.sumOf { it.totalRequests }
-                            ChartCard("API 请求次数", "${reqTotal}次", { showReqDetail = true }) {
-                                LineChart(state.buckets, { it.totalRequests.toFloat() }, StrawberryPink, { "${it.toInt()}次" }, state.granularity, useUtc8 = state.useUtc8)
+                            ChartCard(stringResource(R.string.chart_requests), stringResource(R.string.count_times, reqTotal), { showReqDetail = true }) {
+                                LineChart(state.buckets, { it.totalRequests.toFloat() }, StrawberryPink, { context.getString(R.string.count_times, it.toInt()) }, state.granularity, useUtc8 = state.useUtc8)
                             }
                         }
                         item {
                             val tokTotal = state.buckets.sumOf { it.cacheHitTokens + it.inputTokens + it.outputTokens }
-                            ChartCard("Token 消耗", formatTokenComma(tokTotal), { showTokenDetail = true }) {
+                            ChartCard(stringResource(R.string.chart_tokens), formatTokenComma(tokTotal), { showTokenDetail = true }) {
                                 StackedBarChart(state.buckets,
                                     { (it.cacheHitTokens + it.inputTokens + it.outputTokens).toDouble() },
                                     { bucket -> listOfNotNull(bucket.outputTokens.toDouble() to tokenColors[2], bucket.inputTokens.toDouble() to tokenColors[1], bucket.cacheHitTokens.toDouble() to tokenColors[0]) },
-                                    { listOf("输出", "输入(未命中)", "命中缓存") },
+                                    { listOf(context.getString(R.string.chart_stack_output), context.getString(R.string.chart_stack_input), context.getString(R.string.chart_stack_cache)) },
                                     formatValue = { formatTokenComma(it.toLong()) },
                                     granularity = state.granularity,
                                     tooltipReversed = true,
                                     useUtc8 = state.useUtc8
                                 )
                             }
-                            ChartLegend(listOf("输入(未命中)" to tokenColors[1], "命中缓存" to tokenColors[0], "输出" to tokenColors[2]))
+                            ChartLegend(listOf(stringResource(R.string.chart_stack_input) to tokenColors[1], stringResource(R.string.chart_stack_cache) to tokenColors[0], stringResource(R.string.chart_stack_output) to tokenColors[2]))
                         }
                     }
                     item {
                         TextButton(onClick = onOpenOverview, modifier = Modifier.fillMaxWidth()) {
-                            Text("📋 总统计", color = StrawberryPink, fontWeight = FontWeight.Bold)
+                            Text("📋 " + stringResource(R.string.title_overview), color = StrawberryPink, fontWeight = FontWeight.Bold)
                         }
                     }
                     item { Spacer(Modifier.height(32.dp)) }
@@ -300,55 +319,59 @@ fun UsageDetailScreen(
             }
         }
         // 自定义日期选择器
-        if (showCustomDayPicker) DateOnlyPickerDialog("选择日期", { date ->
-            viewModel.setCustomDay(date)
-            showCustomDayPicker = false
-        }, { showCustomDayPicker = false })
-        if (showCustomMonthPicker) DateOnlyPickerDialog("选择月份（任意一天）", { date ->
-            viewModel.setCustomMonth(date)
-            showCustomMonthPicker = false
-        }, { showCustomMonthPicker = false })
-        if (showCustomRangeStart) DateOnlyPickerDialog("开始日期", { date ->
-            customRangeStartDate = date
-            showCustomRangeStart = false
-            showCustomRangeEnd = true
-        }, { showCustomRangeStart = false })
-        if (showCustomRangeEnd) {
-            val startDate = customRangeStartDate
-            DateOnlyPickerDialog(
-                title = "结束日期",
-                onConfirm = { endDate ->
-                    if (startDate != null && !endDate.isBefore(startDate)) {
-                        viewModel.setCustomRange(startDate, endDate)
-                        showCustomRangeEnd = false
-                    }
+        if (showCustomDayPicker) DateOnlyPickerDialog(
+            title = stringResource(R.string.date_select_day),
+            initialDate = state.customDay,
+            onConfirm = { date ->
+                viewModel.setCustomDay(date)
+                showCustomDayPicker = false
+            },
+            onDismiss = { showCustomDayPicker = false }
+        )
+        if (showCustomMonthPicker) DateOnlyPickerDialog(
+            title = stringResource(R.string.date_select_month),
+            initialDate = state.customMonth,
+            onConfirm = { date ->
+                viewModel.setCustomMonth(date)
+                showCustomMonthPicker = false
+            },
+            onDismiss = { showCustomMonthPicker = false }
+        )
+        if (showCustomRangePicker) {
+            val currentRange = state.customRange
+            DateRangePickerDialog(
+                title = stringResource(R.string.date_pick_range),
+                initialStart = currentRange?.first,
+                initialEnd = currentRange?.second,
+                onConfirm = { from, to ->
+                    viewModel.setCustomRange(from, to)
+                    showCustomRangePicker = false
                 },
-                onDismiss = { showCustomRangeEnd = false },
-                minDate = startDate
+                onDismiss = { showCustomRangePicker = false }
             )
         }
-        val models = state.selectedModels.ifEmpty { state.allModels.toSet() }
-        if (showCostDetail) ChartDetailDialog("消费明细", { showCostDetail = false }) {
+        val models = state.rangeModels
+        if (showCostDetail) ChartDetailDialog(stringResource(R.string.chart_detail_cost), { showCostDetail = false }) {
             models.forEach { model -> val t = state.buckets.sumOf { it.byModel[model]?.cost ?:0L }; if (t>0) DetailRow(model, "$${String.format(Locale.US, "%.4f", t/100_000_000.0)}") }
         }
-        if (showReqDetail) ChartDetailDialog("调用次数明细", { showReqDetail = false }) {
-            models.forEach { model -> val t = state.buckets.sumOf { it.byModel[model]?.requests ?:0 }; if (t>0) DetailRow(model, "${t}次") }
+        if (showReqDetail) ChartDetailDialog(stringResource(R.string.chart_detail_requests), { showReqDetail = false }) {
+            models.forEach { model -> val t = state.buckets.sumOf { it.byModel[model]?.requests ?: 0 }; if (t>0) DetailRow(model, stringResource(R.string.count_times, t)) }
         }
-        if (showTokenDetail) ChartDetailDialog("Token 明细", { showTokenDetail = false }) {
-            DetailRow("命中缓存", formatTokenComma(state.buckets.sumOf { it.cacheHitTokens }))
-            DetailRow("输入(未命中)", formatTokenComma(state.buckets.sumOf { it.inputTokens }))
-            DetailRow("输出", formatTokenComma(state.buckets.sumOf { it.outputTokens }))
+        if (showTokenDetail) ChartDetailDialog(stringResource(R.string.chart_detail_tokens), { showTokenDetail = false }) {
+            DetailRow(stringResource(R.string.chart_stack_cache), formatTokenComma(state.buckets.sumOf { it.cacheHitTokens }))
+            DetailRow(stringResource(R.string.chart_stack_input), formatTokenComma(state.buckets.sumOf { it.inputTokens }))
+            DetailRow(stringResource(R.string.chart_stack_output), formatTokenComma(state.buckets.sumOf { it.outputTokens }))
         }
         if (showClearDialog && clearViewModel != null) {
             val cd = clearCountdown
             androidx.compose.material3.AlertDialog(
                 onDismissRequest = { showClearDialog = false; clearCountdown = 0 },
-                title = { Text("⚠️ 清除数据", fontWeight = FontWeight.Bold) },
+                title = { Text("⚠️ " + stringResource(R.string.dialog_clear_title), fontWeight = FontWeight.Bold) },
                 text = {
                     Column {
-                        Text("此操作将清除所有 CommandCode 用量本地缓存并重新同步，需要几秒钟完成。")
+                        Text(stringResource(R.string.dialog_clear_body))
                         Spacer(Modifier.height(12.dp))
-                        Text("是否继续？", fontWeight = FontWeight.SemiBold)
+                        Text(stringResource(R.string.dialog_clear_confirm_question), fontWeight = FontWeight.SemiBold)
                     }
                 },
                 confirmButton = {
@@ -362,14 +385,14 @@ fun UsageDetailScreen(
                         enabled = cd == 0
                     ) {
                         Text(
-                            if (cd > 0) "确认（${cd}s）" else "确认清除",
+                            if (cd > 0) stringResource(R.string.action_confirm_countdown, cd) else stringResource(R.string.action_confirm_clear),
                             color = if (cd == 0) MaterialTheme.colorScheme.error else InkMuted
                         )
                     }
                 },
                 dismissButton = {
                     TextButton(onClick = { showClearDialog = false; clearCountdown = 0 }) {
-                        Text("取消")
+                        Text(stringResource(R.string.action_cancel))
                     }
                 }
             )
@@ -391,7 +414,7 @@ private fun ChartDetailDialog(title: String, onDismiss: () -> Unit, content: @Co
         onDismissRequest = onDismiss,
         title = { Text(title, fontWeight = FontWeight.Bold) },
         text = { androidx.compose.foundation.layout.Column { content() } },
-        confirmButton = { TextButton(onClick = onDismiss) { Text("关闭") } })
+        confirmButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.action_close)) } })
 }
 @Composable private fun DetailRow(label: String, value: String) {
     Row(Modifier.fillMaxWidth().padding(vertical = 2.dp), Arrangement.SpaceBetween) {
@@ -421,14 +444,14 @@ internal fun CustomTimeRangeRow(
         ) {
             TextButton(onClick = onPickStart, modifier = Modifier.weight(1f)) {
                 Text(
-                    text = if (startMs > 0) "从 ${fmt.format(Date(startMs))}" else "开始时间",
+                    text = if (startMs > 0) stringResource(R.string.range_from, fmt.format(Date(startMs))) else stringResource(R.string.date_start),
                     style = MaterialTheme.typography.bodySmall,
                     color = if (startMs > 0) StrawberryPink else InkMuted
                 )
             }
             TextButton(onClick = onPickEnd, modifier = Modifier.weight(1f)) {
                 Text(
-                    text = if (endMs > 0) "至 ${fmt.format(Date(endMs))}" else "结束时间",
+                    text = if (endMs > 0) stringResource(R.string.range_to, fmt.format(Date(endMs))) else stringResource(R.string.date_end),
                     style = MaterialTheme.typography.bodySmall,
                     color = if (endMs > 0) StrawberryPink else InkMuted
                 )
@@ -436,7 +459,7 @@ internal fun CustomTimeRangeRow(
         }
         if (startMs > 0 && endMs > 0) {
             TextButton(onClick = onApply) {
-                Text("应用自定义范围", color = StrawberryPink, fontWeight = FontWeight.Bold)
+                Text(stringResource(R.string.action_apply_custom_range), color = StrawberryPink, fontWeight = FontWeight.Bold)
             }
         }
     }
@@ -444,8 +467,9 @@ internal fun CustomTimeRangeRow(
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
-private fun DateOnlyPickerDialog(
+internal fun DateOnlyPickerDialog(
     title: String,
+    initialDate: LocalDate? = null,
     onConfirm: (LocalDate) -> Unit,
     onDismiss: () -> Unit,
     minDate: LocalDate? = null
@@ -459,7 +483,10 @@ private fun DateOnlyPickerDialog(
             }
         }
     }
-    val dateState = rememberDatePickerState(selectableDates = selectableDates)
+    val dateState = rememberDatePickerState(
+        initialSelectedDateMillis = initialDate?.atStartOfDay(utc)?.toInstant()?.toEpochMilli(),
+        selectableDates = selectableDates
+    )
 
     DatePickerDialog(
         onDismissRequest = onDismiss,
@@ -471,10 +498,10 @@ private fun DateOnlyPickerDialog(
                 },
                 enabled = dateState.selectedDateMillis != null
             ) {
-                Text("确定")
+                Text(stringResource(R.string.action_confirm))
             }
         },
-        dismissButton = { TextButton(onClick = onDismiss) { Text("取消") } }
+        dismissButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.action_cancel)) } }
     ) {
         Column {
             Text(
@@ -485,13 +512,13 @@ private fun DateOnlyPickerDialog(
             )
             if (minDate != null) {
                 Text(
-                    text = "结束日期不能早于开始日期 ${minDate.formatDateLabel()}",
+                    text = stringResource(R.string.date_end_before_start, minDate.formatDateLabel()),
                     modifier = Modifier.padding(start = 24.dp, top = 8.dp, end = 24.dp),
                     style = MaterialTheme.typography.bodySmall,
                     color = InkMuted
                 )
             }
-            DatePicker(state = dateState)
+            DatePicker(state = dateState, title = {})
         }
     }
 }
@@ -525,20 +552,20 @@ internal fun DateTimePickerDialog(
                     onConfirm(epochMs)
                 }
             }) {
-                Text("确定")
+                Text(stringResource(R.string.action_confirm))
             }
         },
-        dismissButton = { TextButton(onClick = onDismiss) { Text("取消") } }
+        dismissButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.action_cancel)) } }
     ) {
         Column {
             DatePicker(state = dateState)
             Spacer(modifier = Modifier.height(8.dp))
             Text(
-                text = "时间 ${
-                    String.format("%02d", timeState.hour)
-                }:${
+                text = stringResource(
+                    R.string.time_hm,
+                    String.format("%02d", timeState.hour),
                     String.format("%02d", timeState.minute)
-                }",
+                ),
                 modifier = Modifier.padding(horizontal = 24.dp),
                 style = MaterialTheme.typography.titleMedium
             )

app/src/main/java/com/rainy/token/ui/dashboard/UsageOverviewScreen.kt

@@ -40,15 +40,21 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
 import com.rainy.token.data.local.ModelStats
 import com.rainy.token.data.local.OverviewStats
 import com.rainy.token.ui.theme.inkMuted
 import com.rainy.token.ui.theme.StrawberryPink
 import java.text.SimpleDateFormat
+import java.time.Instant
+import java.time.LocalDate
+import java.time.ZoneOffset
 import java.util.Date
 import java.util.Locale
 
@@ -71,18 +77,15 @@ fun UsageOverviewScreen(
 
     var menuExpanded by remember { mutableStateOf(false) }
     var modelMenuExpanded by remember { mutableStateOf(false) }
-    var showStartPicker by remember { mutableStateOf(false) }
-    var showEndPicker by remember { mutableStateOf(false) }
-    var customStartMs by remember { mutableStateOf(0L) }
-    var customEndMs by remember { mutableStateOf(0L) }
+    var showRangePicker by remember { mutableStateOf(false) }
 
     Scaffold(
         containerColor = Color.Transparent,
         topBar = {
             TopAppBar(
-                title = { Text("总统计") },
+                title = { Text(stringResource(R.string.title_overview)) },
                 navigationIcon = {
-                    IconButton(onClick = onBack) { Icon(Icons.Filled.ArrowBack, "返回") }
+                    IconButton(onClick = onBack) { Icon(Icons.Filled.ArrowBack, stringResource(R.string.action_back)) }
                 },
                 colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Transparent)
             )
@@ -96,7 +99,7 @@ fun UsageOverviewScreen(
             item {
                 Row(verticalAlignment = Alignment.CenterVertically) {
                     TextButton(onClick = { menuExpanded = true }) {
-                        Text(uiState.timeFilter.label, color = StrawberryPink, fontWeight = FontWeight.SemiBold)
+                        Text(stringResource(uiState.timeFilter.labelRes), color = StrawberryPink, fontWeight = FontWeight.SemiBold)
                         Icon(Icons.Filled.ArrowDropDown, null, tint = StrawberryPink)
                     }
                     Text("UTC+0", style = MaterialTheme.typography.bodySmall, color = inkMuted(), modifier = Modifier.padding(start = 4.dp))
@@ -106,23 +109,20 @@ fun UsageOverviewScreen(
                             TimeFilter.Last7Days, TimeFilter.Last30Days, TimeFilter.ThisMonth
                         ).forEach { filter ->
                             DropdownMenuItem(
-                                text = { Text(filter.label) },
+                                text = { Text(stringResource(filter.labelRes)) },
                                 onClick = { menuExpanded = false; viewModel.setTimeFilter(filter) }
                             )
                         }
                         DropdownMenuItem(
-                            text = { Text("自定义") },
-                            onClick = { menuExpanded = false; viewModel.setTimeFilter(TimeFilter.Custom(0L, 0L)) }
+                            text = { Text(stringResource(R.string.time_custom)) },
+                            onClick = { menuExpanded = false; showRangePicker = true }
                         )
                     }
                 }
             }
             if (uiState.timeFilter is TimeFilter.Custom) {
                 item {
-                    CustomTimeRangeRow(customStartMs, customEndMs,
-                        { showStartPicker = true }, { showEndPicker = true },
-                        { viewModel.setTimeFilter(TimeFilter.Custom(customStartMs, customEndMs)) })
-                    Text("所有时间按 UTC+0 计算", style = MaterialTheme.typography.bodySmall, color = inkMuted())
+                    Text(stringResource(R.string.usage_utc0_note), style = MaterialTheme.typography.bodySmall, color = inkMuted())
                 }
             }
             // 总览
@@ -134,7 +134,7 @@ fun UsageOverviewScreen(
             }
             // 按模型
             if (uiState.modelStats.isNotEmpty()) {
-                item { SectionHeader("按模型统计") }
+                item { SectionHeader(stringResource(R.string.section_by_model)) }
                 items(uiState.modelStats, key = { it.model }) { ModelDetailRow(it) }
             }
             // 按天
@@ -144,14 +144,14 @@ fun UsageOverviewScreen(
                 val shown = uiState.dailyStats.drop(startIdx).take(DAILY_PAGE_SIZE)
                 item {
                     Row(verticalAlignment = Alignment.CenterVertically) {
-                        SectionHeader("按天统计（UTC+0）"); Spacer(Modifier.weight(1f))
+                        SectionHeader(stringResource(R.string.section_by_day)); Spacer(Modifier.weight(1f))
                         Box {
                             TextButton(onClick = { modelMenuExpanded = true }) {
-                                Text(uiState.modelFilter ?: "全部模型", color = StrawberryPink, style = MaterialTheme.typography.bodySmall)
+                                Text(uiState.modelFilter ?: stringResource(R.string.common_all_models), color = StrawberryPink, style = MaterialTheme.typography.bodySmall)
                                 Icon(Icons.Filled.ArrowDropDown, null, tint = StrawberryPink)
                             }
                             DropdownMenu(modelMenuExpanded, { modelMenuExpanded = false }) {
-                                DropdownMenuItem(text = { Text("全部模型", fontWeight = FontWeight.Bold) },
+                                DropdownMenuItem(text = { Text(stringResource(R.string.common_all_models), fontWeight = FontWeight.Bold) },
                                     onClick = { modelMenuExpanded = false; viewModel.setModelFilter(null) })
                                 uiState.modelStats.forEach { stat ->
                                     DropdownMenuItem(text = { Text(stat.model) },
@@ -166,18 +166,31 @@ fun UsageOverviewScreen(
                     item {
                         Row(Modifier.fillMaxWidth(), Arrangement.SpaceBetween, Alignment.CenterVertically) {
                             TextButton(onClick = { viewModel.prevDailyPage() }, enabled = uiState.dailyPage > 1) {
-                                Text("◀ 上一页", color = StrawberryPink, style = MaterialTheme.typography.bodySmall) }
+                                Text(stringResource(R.string.action_prev_page), color = StrawberryPink, style = MaterialTheme.typography.bodySmall) }
                             Text("${uiState.dailyPage} / $totalPages", style = MaterialTheme.typography.bodySmall, color = inkMuted())
                             TextButton(onClick = { viewModel.nextDailyPage() }, enabled = uiState.dailyPage < totalPages) {
-                                Text("下一页 ▶", color = StrawberryPink, style = MaterialTheme.typography.bodySmall) }
+                                Text(stringResource(R.string.action_next_page), color = StrawberryPink, style = MaterialTheme.typography.bodySmall) }
                         }
                     }
                 }
             }
             item { Spacer(Modifier.height(24.dp)) }
         }
-        if (showStartPicker) DateTimePickerDialog("开始时间", { customStartMs = it; showStartPicker = false }, { showStartPicker = false })
-        if (showEndPicker) DateTimePickerDialog("结束时间", { customEndMs = it; showEndPicker = false }, { showEndPicker = false })
+        if (showRangePicker) {
+            val current = uiState.timeFilter as? TimeFilter.Custom
+            DateRangePickerDialog(
+                title = stringResource(R.string.date_pick_range),
+                initialStart = current?.from?.takeIf { it > 0 }?.toUtcLocalDate(),
+                initialEnd = current?.to?.takeIf { current.from > 0 }?.toUtcLocalDate(),
+                onConfirm = { from, to ->
+                    val fromMs = from.toUtcStartOfDayMillis()
+                    val toMs = to.toUtcStartOfDayMillis()
+                    viewModel.setTimeFilter(TimeFilter.Custom(fromMs, toMs + 86400_000L - 1))
+                    showRangePicker = false
+                },
+                onDismiss = { showRangePicker = false }
+            )
+        }
     }
 }
 
@@ -193,24 +206,24 @@ fun UsageOverviewScreen(
                     horizontalArrangement = Arrangement.spacedBy(16.dp),
                     verticalArrangement = Arrangement.spacedBy(12.dp)
                 ) {
-                    StatItem("输入 Token", formatTokenCount(inputTotal))
-                    StatItem("输出 Token", formatTokenCount(overview.outputTokens))
-                    StatItem("推理 Token", formatTokenCount(overview.reasoningTokens))
-                    StatItem("总计", formatTokenCount(overview.totalTokens))
-                    StatItem("总花费", "$${String.format(Locale.US, "%.4f", overview.totalCost / 100_000_000.0)}")
-                    StatItem("记录数", "${overview.totalCount}")
+                    StatItem(stringResource(R.string.usage_input_tokens), formatTokenCount(inputTotal))
+                    StatItem(stringResource(R.string.usage_output_tokens), formatTokenCount(overview.outputTokens))
+                    StatItem(stringResource(R.string.usage_reasoning_tokens), formatTokenCount(overview.reasoningTokens))
+                    StatItem(stringResource(R.string.usage_total), formatTokenCount(overview.totalTokens))
+                    StatItem(stringResource(R.string.usage_total_cost), "$${String.format(Locale.US, "%.4f", overview.totalCost / 100_000_000.0)}")
+                    StatItem(stringResource(R.string.usage_records), "${overview.totalCount}")
                 }
             } else {
                 Row(Modifier.fillMaxWidth(), Arrangement.SpaceEvenly) {
-                    StatItem("输入 Token", formatTokenCount(inputTotal))
-                    StatItem("输出 Token", formatTokenCount(overview.outputTokens))
-                    StatItem("推理 Token", formatTokenCount(overview.reasoningTokens))
+                    StatItem(stringResource(R.string.usage_input_tokens), formatTokenCount(inputTotal))
+                    StatItem(stringResource(R.string.usage_output_tokens), formatTokenCount(overview.outputTokens))
+                    StatItem(stringResource(R.string.usage_reasoning_tokens), formatTokenCount(overview.reasoningTokens))
                 }
                 Spacer(Modifier.height(12.dp))
                 Row(Modifier.fillMaxWidth(), Arrangement.SpaceEvenly) {
-                    StatItem("总计", formatTokenCount(overview.totalTokens))
-                    StatItem("总花费", "$${String.format(Locale.US, "%.4f", overview.totalCost / 100_000_000.0)}")
-                    StatItem("记录数", "${overview.totalCount}")
+                    StatItem(stringResource(R.string.usage_total), formatTokenCount(overview.totalTokens))
+                    StatItem(stringResource(R.string.usage_total_cost), "$${String.format(Locale.US, "%.4f", overview.totalCost / 100_000_000.0)}")
+                    StatItem(stringResource(R.string.usage_records), "${overview.totalCount}")
                 }
             }
         }
@@ -220,15 +233,15 @@ fun UsageOverviewScreen(
 @Composable private fun CacheBreakdownCard(overview: OverviewStats) {
     Card(Modifier.fillMaxWidth(), RoundedCornerShape(20.dp), CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface)) {
         Column(Modifier.padding(16.dp)) {
-            Text("缓存 Token 细分", style = MaterialTheme.typography.labelMedium, color = inkMuted())
+            Text(stringResource(R.string.usage_cache_breakdown), style = MaterialTheme.typography.labelMedium, color = inkMuted())
             Spacer(Modifier.height(8.dp))
             Row(Modifier.fillMaxWidth(), Arrangement.SpaceEvenly) {
-                StatItem("缓存读取", formatTokenCount(overview.cacheReadTokens))
-                StatItem("缓存写入", formatTokenCount(overview.cacheWriteTokens))
+                StatItem(stringResource(R.string.stat_cache_read), formatTokenCount(overview.cacheReadTokens))
+                StatItem(stringResource(R.string.stat_cache_write), formatTokenCount(overview.cacheWriteTokens))
             }
             if (overview.cacheReadTokens > 0) {
                 Spacer(Modifier.height(4.dp))
-                Text("※ 缓存读取已计入「输入 Token」", style = MaterialTheme.typography.bodySmall, color = inkMuted())
+                Text(stringResource(R.string.usage_cache_read_note), style = MaterialTheme.typography.bodySmall, color = inkMuted())
             }
         }
     }
@@ -243,7 +256,7 @@ fun UsageOverviewScreen(
         Row(Modifier.fillMaxWidth().padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
             Column(Modifier.weight(1f)) {
                 Text(stat.model, style = MaterialTheme.typography.bodyMedium, fontWeight = FontWeight.Medium)
-                Text("${stat.count} 次调用", style = MaterialTheme.typography.bodySmall, color = inkMuted())
+                Text(stringResource(R.string.usage_calls, stat.count), style = MaterialTheme.typography.bodySmall, color = inkMuted())
             }
             Column(horizontalAlignment = Alignment.End) {
                 Text(formatTokenCount(stat.totalTokens), style = MaterialTheme.typography.bodyMedium, fontWeight = FontWeight.Bold, color = StrawberryPink)
@@ -254,13 +267,18 @@ fun UsageOverviewScreen(
 }
 
 @Composable private fun DailyDetailRow(day: com.rainy.token.data.local.DailyStats) {
-    val utcFmt = remember { SimpleDateFormat("MM月dd日 EEEE", Locale.CHINA).apply { timeZone = java.util.TimeZone.getTimeZone("UTC") } }
+    val datePattern = stringResource(R.string.date_format_md)
+    // 从当前资源 configuration 取 locale（跟随应用内语言切换），
+    // 不能依赖 Locale.getDefault()：LocaleManager 只覆写 activity Configuration，不改变 JVM 默认 locale
+    val configuration = LocalConfiguration.current
+    val activeLocale = remember(configuration) { configuration.locales[0] }
+    val utcFmt = remember(datePattern, activeLocale) { SimpleDateFormat(datePattern, activeLocale).apply { timeZone = java.util.TimeZone.getTimeZone("UTC") } }
     Card(Modifier.fillMaxWidth(), RoundedCornerShape(12.dp), CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface)) {
         Row(Modifier.fillMaxWidth().padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
             Text(utcFmt.format(Date(day.dayTs)), style = MaterialTheme.typography.bodyMedium, fontWeight = FontWeight.Medium, modifier = Modifier.weight(1f))
             Column(horizontalAlignment = Alignment.End) {
                 Text(formatTokenCount(day.totalTokens), style = MaterialTheme.typography.bodyMedium, fontWeight = FontWeight.Bold, color = StrawberryPink)
-                Text("${day.count} 次 · $${String.format(Locale.US, "%.4f", day.totalCost / 100_000_000.0)}", style = MaterialTheme.typography.bodySmall, color = inkMuted())
+                Text(stringResource(R.string.daily_count_cost, day.count, String.format(Locale.US, "%.4f", day.totalCost / 100_000_000.0)), style = MaterialTheme.typography.bodySmall, color = inkMuted())
             }
         }
     }
@@ -273,6 +291,12 @@ fun UsageOverviewScreen(
     }
 }
 
+private fun Long.toUtcLocalDate(): LocalDate =
+    Instant.ofEpochMilli(this).atOffset(ZoneOffset.UTC).toLocalDate()
+
+private fun LocalDate.toUtcStartOfDayMillis(): Long =
+    atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
+
 private fun formatTokenCount(tokens: Long): String = when {
     tokens >= 1_000_000 -> "${"%.1f".format(Locale.US, tokens / 1_000_000.0)}M"
     tokens >= 1_000 -> "${"%.1f".format(Locale.US, tokens / 1_000.0)}K"

app/src/main/java/com/rainy/token/ui/dashboard/UsageStatsCard.kt

@@ -24,11 +24,15 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
 import com.rainy.token.data.local.OverviewStats
+import com.rainy.token.ui.components.asString
 import com.rainy.token.ui.theme.InkMuted
 import com.rainy.token.ui.theme.StrawberryPink
 import java.util.Locale
@@ -41,6 +45,7 @@ import java.util.Locale
 @Composable
 fun UsageStatsCard(
     onOpenDetail: () -> Unit,
+    onOpenHeatmap: () -> Unit = {},
     refreshTrigger: Int = 0,
     viewModel: UsageViewModel = hiltViewModel()
 ) {
@@ -67,12 +72,12 @@ fun UsageStatsCard(
             Row(verticalAlignment = Alignment.CenterVertically) {
                 Column(modifier = Modifier.weight(1f)) {
                     Text(
-                        text = "OpenCode 用量",
+                        text = stringResource(R.string.usage_title_opencode),
                         style = MaterialTheme.typography.titleMedium,
                         fontWeight = FontWeight.SemiBold
                     )
                     Text(
-                        text = if (uiState.recordCount > 0) "${uiState.recordCount} 条记录" else "点击同步",
+                        text = if (uiState.recordCount > 0) stringResource(R.string.usage_record_count, uiState.recordCount) else stringResource(R.string.usage_click_to_sync),
                         style = MaterialTheme.typography.bodySmall,
                         color = InkMuted
                     )
@@ -87,7 +92,7 @@ fun UsageStatsCard(
                     IconButton(onClick = { viewModel.sync() }) {
                         Icon(
                             imageVector = Icons.Filled.Refresh,
-                            contentDescription = "同步用量数据",
+                            contentDescription = stringResource(R.string.action_sync_usage),
                             tint = StrawberryPink
                         )
                     }
@@ -100,13 +105,13 @@ fun UsageStatsCard(
 
                 // 输入 Token = input + cacheRead
                 val inputTotal = overview.inputTokens + overview.cacheReadTokens
-                MetricRow("输入 Token", formatTokenCount(inputTotal))
+                MetricRow(stringResource(R.string.usage_input_tokens), formatTokenCount(inputTotal))
 
                 // 缓存子行
                 if (overview.cacheReadTokens > 0 || overview.cacheWriteTokens > 0) {
                     val parts = mutableListOf<String>()
-                    if (overview.cacheReadTokens > 0) parts.add("缓存读取 ${formatTokenCount(overview.cacheReadTokens)}")
-                    if (overview.cacheWriteTokens > 0) parts.add("缓存写入 ${formatTokenCount(overview.cacheWriteTokens)}")
+                    if (overview.cacheReadTokens > 0) parts.add(stringResource(R.string.usage_cache_read, formatTokenCount(overview.cacheReadTokens)))
+                    if (overview.cacheWriteTokens > 0) parts.add(stringResource(R.string.usage_cache_write, formatTokenCount(overview.cacheWriteTokens)))
                     Text(
                         text = parts.joinToString(" · "),
                         style = MaterialTheme.typography.bodySmall,
@@ -119,8 +124,8 @@ fun UsageStatsCard(
 
                 // 输出 Token + 总花费 同一排
                 Row(Modifier.fillMaxWidth()) {
-                    MetricRow("输出 Token", formatTokenCount(overview.outputTokens), Modifier.weight(1f))
-                    MetricRow("总花费", "$${String.format(Locale.US, "%.4f", overview.totalCost / 100_000_000.0)}", Modifier.weight(1f))
+                    MetricRow(stringResource(R.string.usage_output_tokens), formatTokenCount(overview.outputTokens), Modifier.weight(1f))
+                    MetricRow(stringResource(R.string.usage_total_cost), "$${String.format(Locale.US, "%.4f", overview.totalCost / 100_000_000.0)}", Modifier.weight(1f))
                 }
             }
 
@@ -128,24 +133,49 @@ fun UsageStatsCard(
             if (uiState.overview == null && !uiState.syncing) {
                 Spacer(modifier = Modifier.height(8.dp))
                 Text(
-                    text = if (uiState.loading) "加载中…" else "暂无数据，点击 🔄 同步",
+                    text = if (uiState.loading) stringResource(R.string.common_loading) else stringResource(R.string.usage_no_data_sync),
                     style = MaterialTheme.typography.bodyMedium,
                     color = InkMuted
                 )
             }
 
-            // ─── 查看详情 ───
+            // ─── 查看详情 + Token 活动快捷入口 ───
             if (uiState.overview != null) {
                 Spacer(modifier = Modifier.height(8.dp))
-                TextButton(onClick = onOpenDetail) {
-                    Text("查看详情", color = StrawberryPink)
-                    Spacer(modifier = Modifier.width(2.dp))
-                    Icon(
-                        imageVector = Icons.Filled.KeyboardArrowRight,
-                        contentDescription = null,
-                        tint = StrawberryPink,
-                        modifier = Modifier.padding(top = 1.dp)
-                    )
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    TextButton(onClick = onOpenDetail) {
+                        Text(
+                            stringResource(R.string.action_view_detail),
+                            color = StrawberryPink,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis,
+                        )
+                        Spacer(modifier = Modifier.width(2.dp))
+                        Icon(
+                            imageVector = Icons.Filled.KeyboardArrowRight,
+                            contentDescription = null,
+                            tint = StrawberryPink,
+                            modifier = Modifier.padding(top = 1.dp)
+                        )
+                    }
+                    // 弹性间距：窄屏/英文长文案时优先压缩间距，避免按钮折行变形
+                    Spacer(modifier = Modifier.weight(1f))
+                    // OCGO Token 活动热力图快捷入口（与"查看详情"并列，右对齐）
+                    TextButton(onClick = onOpenHeatmap) {
+                        Text(
+                            stringResource(R.string.heatmap_quick_entry),
+                            color = StrawberryPink,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis,
+                        )
+                        Spacer(modifier = Modifier.width(2.dp))
+                        Icon(
+                            imageVector = Icons.Filled.KeyboardArrowRight,
+                            contentDescription = null,
+                            tint = StrawberryPink,
+                            modifier = Modifier.padding(top = 1.dp)
+                        )
+                    }
                 }
             }
 
@@ -153,7 +183,7 @@ fun UsageStatsCard(
             if (uiState.lastSyncResult > 0) {
                 Spacer(modifier = Modifier.height(4.dp))
                 Text(
-                    text = "✓ 新增 ${uiState.lastSyncResult} 条",
+                    text = stringResource(R.string.usage_new_records, uiState.lastSyncResult),
                     style = MaterialTheme.typography.bodySmall,
                     color = StrawberryPink
                 )
@@ -161,11 +191,21 @@ fun UsageStatsCard(
             uiState.lastSyncError?.let { err ->
                 Spacer(modifier = Modifier.height(4.dp))
                 Text(
-                    text = "✗ $err",
+                    text = "✗ ${err.asString()}",
                     style = MaterialTheme.typography.bodySmall,
                     color = MaterialTheme.colorScheme.error
                 )
             }
+
+            // ─── 刷新时间（与其余服务卡片底部一致） ───
+            if (uiState.lastSyncAt > 0) {
+                Spacer(modifier = Modifier.height(4.dp))
+                Text(
+                    text = usageUpdatedAtText(uiState.lastSyncAt),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = InkMuted
+                )
+            }
         }
     }
 }

app/src/main/java/com/rainy/token/ui/dashboard/UsageViewModel.kt

@@ -1,16 +1,21 @@
 package com.rainy.token.ui.dashboard
 
+import androidx.annotation.StringRes
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.rainy.token.R
 import com.rainy.token.data.local.OverviewStats
 import com.rainy.token.data.local.ModelStats
 import com.rainy.token.data.local.DailyStats
 import com.rainy.token.data.local.UsageCache
 import com.rainy.token.data.repository.CredentialRepository
+import com.rainy.token.data.repository.RepositoryError
 import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.service.ServiceType
 import com.rainy.token.domain.usecase.SyncCommandCodeUsageUseCase
+import com.rainy.token.domain.usecase.SyncError
 import com.rainy.token.domain.usecase.SyncUsageUseCase
+import com.rainy.token.ui.components.UiText
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -26,17 +31,17 @@ import javax.inject.Provider
 
 internal const val DAILY_PAGE_SIZE = 5
 
-/** 时间筛选条件 */
-sealed class TimeFilter(val label: String) {
-    data object All : TimeFilter("全部")
-    data object Last5h : TimeFilter("最近5小时")
-    data object Last24h : TimeFilter("最近24小时")
-    data object Today : TimeFilter("今天")
-    data object Yesterday : TimeFilter("昨天")
-    data object Last7Days : TimeFilter("最近7天")
-    data object Last30Days : TimeFilter("最近30天")
-    data object ThisMonth : TimeFilter("当月")
-    data class Custom(val from: Long, val to: Long) : TimeFilter("自定义")
+/** 时间筛选条件（label 用字符串资源 ID，UI 层按当前语言解析） */
+sealed class TimeFilter(@StringRes val labelRes: Int) {
+    data object All : TimeFilter(R.string.time_all)
+    data object Last5h : TimeFilter(R.string.time_last_5h)
+    data object Last24h : TimeFilter(R.string.time_last_24h)
+    data object Today : TimeFilter(R.string.time_today)
+    data object Yesterday : TimeFilter(R.string.time_yesterday)
+    data object Last7Days : TimeFilter(R.string.time_last_7d)
+    data object Last30Days : TimeFilter(R.string.time_last_30d)
+    data object ThisMonth : TimeFilter(R.string.time_this_month)
+    data class Custom(val from: Long, val to: Long) : TimeFilter(R.string.time_custom)
 
     /** 计算筛选的起止 epoch 毫秒（from 含，to 含）。
      *  返回 Pair(null, null) 表示不限制。 */
@@ -83,6 +88,22 @@ class UsageViewModel @Inject constructor(
     private var workspaceIdOverride: String? = null
     private var loadGeneration = 0  // 递增：过时的 loadStatsInternal 结果自动丢弃
 
+    /** 用量同步时间持久化（按 workspace 区分 OCGO / CCGO），重启后卡片仍能显示刷新时间。 */
+    private fun syncAtPrefs(): android.content.SharedPreferences =
+        com.rainy.token.RainyTokenApplication.appContext.getSharedPreferences(
+            "usage_sync_at",
+            android.content.Context.MODE_PRIVATE
+        )
+
+    private fun syncAtKey(wid: String): String = "sync_at_$wid"
+
+    private fun loadLastSyncAt(wid: String): Long =
+        syncAtPrefs().getLong(syncAtKey(wid), 0L)
+
+    private fun saveLastSyncAt(wid: String, ts: Long) {
+        syncAtPrefs().edit().putLong(syncAtKey(wid), ts).apply()
+    }
+
     /** 覆盖 workspaceId，用于 CCGO 等非 OCGO 服务。必须在 loadStats() 前调用。 */
     fun setWorkspace(wid: String) {
         workspaceIdOverride = wid
@@ -153,7 +174,8 @@ class UsageViewModel @Inject constructor(
                 dailyStats = dailyStats,
                 recordCount = totalCount,
                 loading = false,
-                dailyPage = 1
+                dailyPage = 1,
+                lastSyncAt = loadLastSyncAt(wid)
             )
         }
     }
@@ -184,6 +206,7 @@ class UsageViewModel @Inject constructor(
     fun sync() {
         viewModelScope.launch {
             _uiState.update { it.copy(syncing = true) }
+            val wid = workspaceIdOverride ?: workspaceId()
             val result = withContext(Dispatchers.Default) {
                 val cache = cacheProvider.get()
                 if (workspaceIdOverride == com.rainy.token.data.repository.CommandCodeUsageRepository.CCGO_WORKSPACE_ID) {
@@ -196,12 +219,15 @@ class UsageViewModel @Inject constructor(
                     if (count == 0) useCase.fullSync() else useCase.incrementalSync()
                 }
             }
+            val syncedAt = System.currentTimeMillis()
+            if (result.isSuccess && wid != null) saveLastSyncAt(wid, syncedAt)
             result.onSuccess { loadStats() }
             _uiState.update {
                 it.copy(
                     syncing = false,
                     lastSyncResult = result.getOrNull()?.inserted ?: 0,
-                    lastSyncError = result.exceptionOrNull()?.message
+                    lastSyncError = result.exceptionOrNull()?.let { syncErrorToUiText(it) },
+                    lastSyncAt = if (result.isSuccess && wid != null) syncedAt else it.lastSyncAt
                 )
             }
         }
@@ -217,12 +243,15 @@ class UsageViewModel @Inject constructor(
             invalidateData()
             val useCase = syncCommandCodeUseCaseProvider.get()
             val result = useCase.fullSync()
+            val syncedAt = System.currentTimeMillis()
+            if (result.isSuccess) saveLastSyncAt(wid, syncedAt)
             result.onSuccess { loadStats() }
             _uiState.update {
                 it.copy(
                     syncing = false,
                     lastSyncResult = result.getOrNull()?.inserted ?: 0,
-                    lastSyncError = result.exceptionOrNull()?.message
+                    lastSyncError = result.exceptionOrNull()?.let { syncErrorToUiText(it) },
+                    lastSyncAt = if (result.isSuccess) syncedAt else it.lastSyncAt
                 )
             }
         }
@@ -241,7 +270,8 @@ data class UsageUiState(
     val dailyStats: List<DailyStats> = emptyList(),
     val recordCount: Int = 0,
     val lastSyncResult: Int = 0,
-    val lastSyncError: String? = null,
+    val lastSyncError: UiText? = null,
+    val lastSyncAt: Long = 0,  // 最近一次成功同步的 epoch ms（0 = 从未同步）
     val timeFilter: TimeFilter = TimeFilter.All,
     val dailyPage: Int = 1,
     val modelFilter: String? = null  // null = 全部模型
@@ -253,4 +283,37 @@ private data class LoadResult(
     val modelStats: List<ModelStats>,
     val dailyStats: List<DailyStats>,
     val totalCount: Int
-)
+)
+
+/** 把同步错误映射为本地化文案：SyncError / RepositoryError 全部走资源，不透传中文 message。 */
+private fun syncErrorToUiText(error: Throwable): UiText = when (error) {
+    is SyncError.PartialSync ->
+        UiText.Resource(R.string.sync_partial, listOf(error.inserted, error.errors.size))
+    is RepositoryError.SessionExpired ->
+        UiText.Resource(R.string.error_credential_session_expired)
+    is RepositoryError.InvalidCredential ->
+        UiText.Resource(R.string.error_credential_invalid_reconfigure)
+    is RepositoryError.CredentialChanged ->
+        UiText.Resource(R.string.error_credential_changed_reload)
+    is RepositoryError.RateLimited -> UiText.Resource(
+        R.string.error_rate_limited_retry,
+        listOf(
+            error.retryAfterSeconds?.let {
+                UiText.Resource(R.string.error_rate_limited_retry_suffix, listOf(it))
+            } ?: ""
+        )
+    )
+    is RepositoryError.Network -> UiText.Resource(R.string.error_network_check)
+    is RepositoryError.ServerError ->
+        UiText.Resource(R.string.error_server_http, listOf(error.code))
+    is RepositoryError.ParseError -> when (error.reason) {
+        RepositoryError.ParseErrorReason.EMPTY_BODY -> UiText.Resource(R.string.error_parse_empty_body)
+        RepositoryError.ParseErrorReason.NOT_JSON_OBJECT -> UiText.Resource(R.string.error_parse_not_json)
+        RepositoryError.ParseErrorReason.NO_WINDOWS -> UiText.Resource(R.string.error_parse_no_windows)
+        RepositoryError.ParseErrorReason.NO_MODELS -> UiText.Resource(R.string.error_parse_no_models)
+        RepositoryError.ParseErrorReason.MODELS_EMPTY -> UiText.Resource(R.string.error_parse_models_empty)
+        RepositoryError.ParseErrorReason.MALFORMED_RESPONSE -> UiText.Resource(R.string.error_parse_malformed)
+    }
+    is RepositoryError.Unknown -> UiText.Resource(R.string.common_unknown)
+    else -> UiText.Resource(R.string.common_unknown)
+}

app/src/main/java/com/rainy/token/ui/dashboard/autocheckin/AutoCheckinEntryPoint.kt

@@ -0,0 +1,16 @@
+package com.rainy.token.ui.dashboard.autocheckin
+
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+/**
+ * 后台广播（自动签到闹钟 / 开机重排）获取 Hilt 单例的入口。
+ * 与 ui.widget.WidgetRefreshEntryPoint 同一模式：广播接收器不依赖
+ * @AndroidEntryPoint，通过 EntryPointAccessors 拿 SingletonComponent 里的依赖。
+ */
+@EntryPoint
+@InstallIn(SingletonComponent::class)
+interface AutoCheckinEntryPoint {
+    fun autoCheckinManager(): AutoCheckinManager
+}

app/src/main/java/com/rainy/token/ui/dashboard/autocheckin/AutoCheckinManager.kt

@@ -0,0 +1,296 @@
+package com.rainy.token.ui.dashboard.autocheckin
+
+import android.app.AlarmManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import com.rainy.token.data.repository.CheckinStatusStore
+import com.rainy.token.data.repository.CredentialRepository
+import com.rainy.token.data.repository.RepositoryError
+import com.rainy.token.data.repository.TraeRepository
+import com.rainy.token.data.repository.WorkBuddyRepository
+import com.rainy.token.domain.model.CredentialStatus
+import com.rainy.token.domain.model.ServiceAccountInfo
+import com.rainy.token.domain.service.ServiceType
+import com.rainy.token.domain.usecase.RefreshBalanceUseCase
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.time.ZonedDateTime
+import javax.inject.Inject
+import javax.inject.Singleton
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * 每日自动签到编排器（小组件开关控制启用）。
+ *
+ * 行为契约（用户需求 2026-09-13 / 多账号版 2026-10 / 零点后台版 2026-11）：
+ *  - 开启后，每天零点后由 AlarmManager 自动触发（[AutoCheckinReceiver]），
+ *    为所有「已配置凭据」的可签服务的【全部账号】各签一次；
+ *  - 兜底：每天首次打开 App（DashboardViewModel）也会补签一次（错过闹钟/被杀进程场景）；
+ *  - 当日每账号只签一次：本地有「今日已成功签到」记录的账号直接跳过（手动签过也算）；
+ *    失败/限流/设备拦截等非成功记录不占位，下次打开 App 会再次唤起签到流程；
+ *  - 结果汇报：签完把每个账号的结果暴露为 [report]，首页据此弹「xx 已签到，积分增加 xx」；
+ *  - 开关持久化在 SharedPreferences "auto_checkin"（小组件与 App 内共用同一份）。
+ *
+ * 仅负责编排与记录，不做 UI：签到复用 RefreshBalanceUseCase（带凭据快照会话）。
+ *
+ * 调度说明：使用框架自带的 AlarmManager（非精确 setAndAllowWhileIdle）实现「每日零点后
+ * 后台签到」，零新增依赖；重启设备后闹钟由 BOOT_COMPLETED 广播重排。国产 ROM（如 vivo/
+ * iQOO）可能因电池优化延迟或抑制该闹钟，届时由「首次打开 App」兜底补签。
+ */
+@Singleton
+class AutoCheckinManager @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val refreshBalanceUseCase: RefreshBalanceUseCase,
+    private val credentialRepository: CredentialRepository,
+    private val checkinStatusStore: CheckinStatusStore
+) {
+
+    /** 单个账号的自动签到结果（UI 层本地化展示）。 */
+    data class ServiceResult(
+        val service: ServiceType,
+        /** 该账号的自定义名称；null=单账号服务/未命名的默认账号。 */
+        val accountLabel: String? = null,
+        /** true=本次签到成功（新签到账）；false=已签/失败/跳过 */
+        val newlyCheckedIn: Boolean,
+        /** 今日已签（成功或本来已签），弹窗「已签到」行的判定依据 */
+        val checkedInToday: Boolean,
+        /** 本次新增积分（仅 SUCCESS 时有值；ALREADY/失败为 0） */
+        val creditsGained: Long,
+        /** 失败/提示原因（服务端原文，仅 failed 时非空） */
+        val message: String,
+        val failed: Boolean
+    )
+
+    /**
+     * 自动签到汇总结果。null=没有可展示的内容（未开启/无候选账号/全部账号已签或静默跳过）。
+     * 弹窗消费后由 [consumeReport] 置 null。
+     */
+    private val _report = MutableStateFlow<List<ServiceResult>?>(null)
+    val report: StateFlow<List<ServiceResult>?> = _report.asStateFlow()
+
+    /** 防同日并发重复签到：闹钟广播（IO 线程）与 Dashboard init（viewModelScope）可能同时进入。 */
+    private val runMutex = Mutex()
+
+    private fun prefs() =
+        context.getSharedPreferences("auto_checkin", Context.MODE_PRIVATE)
+
+    /** 自动签到开关（小组件 CheckBox 与 App 内共用）。开关变更时同步排/撤零点闹钟。 */
+    var enabled: Boolean
+        get() = prefs().getBoolean(KEY_ENABLED, false)
+        set(value) {
+            prefs().edit().putBoolean(KEY_ENABLED, value).apply()
+            refreshSchedule()
+        }
+
+    /**
+     * 每日签到执行入口（后台闹钟与首次打开 App 共用）：
+     * 开启时 → 为已配置凭据的可签服务中【今日尚未成功签到】的账号各签一次。
+     * 返回 true 表示本次实际执行了签到（无论结果）。
+     */
+    suspend fun runDailyIfDue(): Boolean = runMutex.withLock {
+        if (!enabled) return false
+        // 不再使用全局 lastRunDate 占位：只有真正「今日签到成功」的账号才跳过，
+        // 失败/限流/设备拦截等不会消费当天机会，重开 App 可再次唤起签到流程。
+        val results = mutableListOf<ServiceResult>()
+        for (service in CHECKIN_SERVICES) {
+            // 多账号服务遍历全部账号；无账号文档时 getDefaultAccount 同样返回 null，
+            // 候选为空 = 不签，与旧版「只签默认账号」的边界行为一致，不会误签旧凭据
+            val accounts = credentialRepository.accountsFor(service)
+            val candidates = accounts.ifEmpty {
+                listOfNotNull(credentialRepository.getDefaultAccount(service))
+            }
+            for (account in candidates) {
+                if (credentialRepository.statusFor(service, account.id).state ==
+                    CredentialStatus.State.NOT_CONFIGURED
+                ) {
+                    continue
+                }
+                // 今日已有成功签到记录（手动签过也算）→ 跳过，不再发网络请求
+                if (checkinStatusStore.isCheckedToday(service, account.id)) continue
+                // runOne 返回 null = 无需汇报（如 INTL 不支持签到），不弹误导性条目
+                runOne(service, account)?.let { results += it }
+            }
+        }
+        if (results.isNotEmpty()) {
+            _report.value = results
+        }
+        return true
+    }
+
+    /**
+     * 注册/取消每日零点后台闹钟（非精确 setAndAllowWhileIdle，零点后几分钟内触发）。
+     * 设备重启后闹钟丢失，由 BOOT_COMPLETED 广播再次调用本方法重排。
+     */
+    fun refreshSchedule() {
+        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+        val intent = Intent(context, AutoCheckinReceiver::class.java)
+            .setAction(ACTION_DAILY_CHECKIN)
+        val pendingIntent = PendingIntent.getBroadcast(
+            context,
+            0,
+            intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+        if (!enabled) {
+            alarmManager.cancel(pendingIntent)
+            return
+        }
+        alarmManager.setAndAllowWhileIdle(
+            AlarmManager.RTC_WAKEUP,
+            nextRunTimeMillis(),
+            pendingIntent
+        )
+    }
+
+    /** 下一次零点（00:05，本地时区）的运行时间戳。 */
+    private fun nextRunTimeMillis(): Long {
+        val now = ZonedDateTime.now()
+        var next = now.toLocalDate().atTime(CHECKIN_HOUR, CHECKIN_MINUTE).atZone(now.zone)
+        if (!next.isAfter(now)) next = next.plusDays(1)
+        return next.toInstant().toEpochMilli()
+    }
+
+    /**
+     * 返回 null 表示该账号无需出现在汇报弹窗里（如 INTL 不支持签到、静默跳过）。
+     */
+    private suspend fun runOne(
+        service: ServiceType,
+        account: ServiceAccountInfo
+    ): ServiceResult? {
+        val label = account.label?.takeIf { it.isNotBlank() }
+        return when (service) {
+            ServiceType.TRAE -> refreshBalanceUseCase.checkInTrae(account.id).fold(
+                onSuccess = { r ->
+                    when (r.outcome) {
+                        TraeRepository.CheckinOutcome.SUCCESS -> ServiceResult(
+                            service = service,
+                            accountLabel = label,
+                            newlyCheckedIn = true,
+                            checkedInToday = true,
+                            creditsGained = r.points,
+                            message = "",
+                            failed = false
+                        )
+                        TraeRepository.CheckinOutcome.ALREADY ->
+                            ServiceResult(service, label, false, true, 0, "", false)
+                        // INTL 不支持签到：静默跳过，不进弹窗（避免误报「已签到」）
+                        TraeRepository.CheckinOutcome.INTL_UNSUPPORTED -> null
+                        TraeRepository.CheckinOutcome.DEVICE_BLOCKED -> {
+                            recordFailure(service, account.id, CheckinStatusStore.STATUS_DEVICE_BLOCKED)
+                            ServiceResult(service, label, false, false, 0, r.message, failed = true)
+                        }
+                        TraeRepository.CheckinOutcome.RETRYABLE -> {
+                            recordFailure(service, account.id, CheckinStatusStore.STATUS_RETRYABLE)
+                            ServiceResult(service, label, false, false, 0, r.message, failed = true)
+                        }
+                        TraeRepository.CheckinOutcome.FAILED -> {
+                            recordFailure(service, account.id, CheckinStatusStore.STATUS_FAILED)
+                            ServiceResult(service, label, false, false, 0, r.message, failed = true)
+                        }
+                    }
+                },
+                onFailure = { e ->
+                    recordFailure(service, account.id, CheckinStatusStore.STATUS_FAILED)
+                    failureResult(service, label, account.id, e)
+                }
+            )
+            ServiceType.WORKBUDDY -> refreshBalanceUseCase.checkInWorkBuddy(account.id).fold(
+                onSuccess = { s ->
+                    when (s.outcome) {
+                        WorkBuddyRepository.CheckinOutcome.SUCCESS -> ServiceResult(
+                            service = service,
+                            accountLabel = label,
+                            newlyCheckedIn = true,
+                            checkedInToday = true,
+                            creditsGained = (s.todayCredit.takeIf { it > 0 } ?: s.dailyCredit),
+                            message = "",
+                            failed = false
+                        )
+                        WorkBuddyRepository.CheckinOutcome.ALREADY ->
+                            ServiceResult(service, label, false, true, 0, "", false)
+                        WorkBuddyRepository.CheckinOutcome.QUERY ->
+                            ServiceResult(service, label, false, true, 0, "", false)
+                        WorkBuddyRepository.CheckinOutcome.FAILED -> {
+                            recordFailure(service, account.id, CheckinStatusStore.STATUS_FAILED)
+                            ServiceResult(service, label, false, false, 0, s.message, failed = true)
+                        }
+                    }
+                },
+                onFailure = { e ->
+                    recordFailure(service, account.id, CheckinStatusStore.STATUS_FAILED)
+                    failureResult(service, label, account.id, e)
+                }
+            )
+            // CHECKIN_SERVICES 只含上述两者；穷尽兜底（未来加服务忘了实现时安全返回失败）
+            else -> null
+        }
+    }
+
+    /**
+     * 签到请求失败的汇报结果。
+     *
+     * 竞态兜底：签到请求在服务端已成功（[RefreshBalanceUseCase.checkInTrae] 的 also 块
+     * 已写 CheckinStatusStore 成功记录），但与并发余额刷新争抢凭据快照导致结果被 [RepositoryError.CredentialChanged]
+     * 丢弃时——若本地记录确认今日已签，按「今日已签到」汇报，而不是报「凭据」错误
+     * （用户会看到积分实际到账却提示失败的矛盾）。
+     */
+    private fun failureResult(
+        service: ServiceType,
+        accountLabel: String?,
+        accountId: String,
+        error: Throwable
+    ): ServiceResult =
+        if (error is RepositoryError.CredentialChanged &&
+            checkinStatusStore.isCheckedToday(service, accountId)
+        ) {
+            ServiceResult(service, accountLabel, false, true, 0, "", false)
+        } else {
+            ServiceResult(
+                service,
+                accountLabel,
+                false,
+                false,
+                0,
+                error.message.orEmpty(),
+                failed = true
+            )
+        }
+
+    /**
+     * 落一条非成功签到记录（仅当今天还没有成功记录时写入）。
+     * 失败/限流/设备拦截不消费当天签到机会，重开 App 仍会重试；
+     * 但若在一次 CredentialChanged 竞态中服务端实际已成功，保留成功记录不被覆盖。
+     */
+    private fun recordFailure(
+        service: ServiceType,
+        accountId: String,
+        status: String
+    ) {
+        if (!checkinStatusStore.isCheckedToday(service, accountId)) {
+            checkinStatusStore.record(service, accountId, status)
+        }
+    }
+
+    /** 弹窗关闭时调用，清除汇报状态（下次执行前不再重复弹）。 */
+    fun consumeReport() {
+        _report.value = null
+    }
+
+    companion object {
+        const val KEY_ENABLED = "enabled"
+
+        /** 每日自动签到闹钟的广播 action（供 [AutoCheckinReceiver] 分发）。 */
+        const val ACTION_DAILY_CHECKIN = "com.rainy.token.action.DAILY_AUTO_CHECKIN"
+
+        /** 每日签到目标时间：零点后 5 分钟（避开日切边界），本地时区。 */
+        const val CHECKIN_HOUR = 0
+        const val CHECKIN_MINUTE = 5
+    }
+}
+
+/** 支持每日签到的服务（DashboardViewModel 与自动签到共用的唯一来源，避免两处漂移）。 */
+internal val CHECKIN_SERVICES = listOf(ServiceType.TRAE, ServiceType.WORKBUDDY)

app/src/main/java/com/rainy/token/ui/dashboard/autocheckin/AutoCheckinReceiver.kt

@@ -0,0 +1,60 @@
+package com.rainy.token.ui.dashboard.autocheckin
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import dagger.hilt.android.EntryPointAccessors
+import kotlin.coroutines.cancellation.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+/**
+ * 每日自动签到后台触发点。
+ *
+ * 两种入口共用同一个接收器：
+ *  - [AutoCheckinManager.ACTION_DAILY_CHECKIN]：AlarmManager 每日零点后发出的闹钟广播，
+ *    到点就为该服务的全部已配置账号签到；
+ *  - ACTION_BOOT_COMPLETED：设备重启后闹钟会被系统清空，这里只负责重新排程，不抢签。
+ *
+ * 通过 EntryPointAccessors 获取 Hilt 单例，不依赖 @AndroidEntryPoint。
+ */
+class AutoCheckinReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val action = intent.action
+        val appContext = context.applicationContext
+        val pendingResult = goAsync()
+
+        CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
+            try {
+                val manager = EntryPointAccessors.fromApplication(
+                    appContext, AutoCheckinEntryPoint::class.java
+                ).autoCheckinManager()
+
+                when (action) {
+                    AutoCheckinManager.ACTION_DAILY_CHECKIN -> {
+                        // 到点签到（关闭时 runDailyIfDue 自身会短路返回）；
+                        // 无论本次签到是否抛异常，都必须把一次性闹钟重排到明天
+                        try {
+                            manager.runDailyIfDue()
+                        } finally {
+                            manager.refreshSchedule()
+                        }
+                    }
+                    Intent.ACTION_BOOT_COMPLETED -> {
+                        // 重启后闹钟丢失，重新排程（今天是否签到由首次打开 App 兜底）
+                        manager.refreshSchedule()
+                    }
+                }
+            } catch (cancelled: CancellationException) {
+                throw cancelled
+            } catch (_: Exception) {
+                // 后台静默：签到/排程失败不阻塞下次闹钟，等下次打开 App 再补救
+            } finally {
+                pendingResult.finish()
+            }
+        }
+    }
+}

app/src/main/java/com/rainy/token/ui/heatmap/HeatmapCanvas.kt

@@ -0,0 +1,748 @@
+package com.rainy.token.ui.heatmap
+
+import android.graphics.Paint
+import android.os.SystemClock
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.drawscope.drawIntoCanvas
+import androidx.compose.ui.graphics.nativeCanvas
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.positionInWindow
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.round
+import androidx.compose.ui.unit.sp
+import com.rainy.token.R
+import com.rainy.token.ui.theme.inkMuted
+import java.time.Instant
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+import kotlin.math.abs
+import kotlin.math.roundToInt
+import kotlinx.coroutines.flow.first
+
+// ── 热力图颜色 ──────────────────────────────────────────────
+
+/** 亮色模式 6 级玫瑰粉梯度（精致粉调，最高级与主色一致） */
+private val LightHeatmapColors = listOf(
+    Color(0xFFF3E9EE), // Level 0: 极浅暖灰
+    Color(0xFFFFE3EC), // Level 1: 浅樱粉
+    Color(0xFFFFC9D9), // Level 2: 浅玫瑰柔
+    Color(0xFFFFA3BC), // Level 3: 玫瑰粉
+    Color(0xFFF27E9F), // Level 4: 玫瑰粉深
+    Color(0xFFC9436C), // Level 5: 深玫瑰（主色）
+)
+
+/** 暗色模式 6 级玫瑰粉梯度 */
+private val DarkHeatmapColors = listOf(
+    Color(0xFF3A2B33), // Level 0: 暖深灰
+    Color(0xFF4A3239), // Level 1
+    Color(0xFF643D4A), // Level 2
+    Color(0xFF855062), // Level 3
+    Color(0xFFA9627A), // Level 4
+    Color(0xFFE07C9A), // Level 5
+)
+
+/** 月份名称资源（按月索引 1~12，locale-aware） */
+private val monthNameRes = intArrayOf(
+    R.string.month_1, R.string.month_2, R.string.month_3, R.string.month_4,
+    R.string.month_5, R.string.month_6, R.string.month_7, R.string.month_8,
+    R.string.month_9, R.string.month_10, R.string.month_11, R.string.month_12,
+)
+
+// ── 格式化辅助函数（HeatmapScreen 浮层与滑动查看读数条共用）──
+
+/** 是否为繁体中文 locale（数字单位用 萬/億） */
+private fun isTraditionalChinese(locale: Locale): Boolean =
+    locale.language == "zh" &&
+        (locale.country == "TW" || locale.country == "HK" || locale.country == "MO")
+
+/**
+ * 将 Token 数按数量级格式化（locale-aware）：
+ * - 中文（zh）：亿级 1.9亿 / 万级 11.2万（繁体用 萬/億）
+ * - 其他语言：≥1e9 → 1.9B，≥1e6 → 11.2M，≥1e3 → 16.8K，否则原数字
+ *
+ * 注意：中文万级先舍入到一位小数再判断是否升亿（如 99999999 → "1.0亿"，而非 "10000.0万"）。
+ */
+internal fun formatTokenChinese(tokens: Long, locale: Locale = Locale.getDefault()): String {
+    if (locale.language != "zh") {
+        return when {
+            tokens >= 1_000_000_000L -> "${"%.1f".format(tokens / 1_000_000_000.0)}B"
+            tokens >= 1_000_000L -> "${"%.1f".format(tokens / 1_000_000.0)}M"
+            tokens >= 1_000L -> "${"%.1f".format(tokens / 1_000.0)}K"
+            else -> "$tokens"
+        }
+    }
+    val wan = if (isTraditionalChinese(locale)) "萬" else "万"
+    val yi = if (isTraditionalChinese(locale)) "億" else "亿"
+    return when {
+        tokens >= 1_0000_0000 -> {
+            val v = tokens / 1_0000_0000.0
+            if (v >= 100) "${v.roundToInt()}$yi"
+            else "${"%.1f".format(v)}$yi"
+        }
+        tokens >= 1_0000 -> {
+            val v = tokens / 1_0000.0
+            // 先舍入到一位小数，避免 "99999999 → 10000.0万"
+            val rounded = (v * 10).roundToInt() / 10.0
+            if (rounded >= 10000) {
+                // 万级溢出升亿：9999.99万 → 1.0亿
+                val v2 = rounded / 10000.0
+                if (v2 >= 100) "${v2.roundToInt()}$yi"
+                else "${"%.1f".format(v2)}$yi"
+            } else {
+                "${"%.1f".format(v)}$wan"  // 始终保留一位小数
+            }
+        }
+        else -> "$tokens"
+    }
+}
+
+/**
+ * 将时间戳格式化为日期文本（locale-aware），按与数据分桶一致的时区：
+ * - 中文（zh）："7月9日"，跨年前缀 "2024年7月9日"
+ * - 其他语言：按 locale 的 "MMM d"，跨年 "MMM d, yyyy"（如 "Jul 9, 2024"）
+ *
+ * 日浮层传 [currentYear]（查看往年时带年份前缀）；周浮层两端传 [selectedYear]，
+ * 使跨年周（如 12月28日-次年1月3日）的结束日带年份前缀，避免范围倒挂。
+ */
+internal fun formatDateChinese(ts: Long, useUtc8: Boolean, yearContext: Int, locale: Locale = Locale.getDefault()): String {
+    val zone = if (useUtc8) ZoneOffset.ofHours(8) else ZoneOffset.UTC
+    val date = Instant.ofEpochMilli(ts).atOffset(zone).toLocalDate()
+    return if (locale.language == "zh") {
+        val yearPrefix = if (date.year != yearContext) "${date.year}年" else ""
+        "$yearPrefix${date.monthValue}月${date.dayOfMonth}日"
+    } else {
+        val fmt = if (date.year != yearContext) "MMM d, yyyy" else "MMM d"
+        DateTimeFormatter.ofPattern(fmt, locale).format(date)
+    }
+}
+
+/**
+ * 将周数据格式化为范围文本："12月28日-12月31日"（不含"使用了X token"，
+ * 句子由调用方用 stringResource 按语言拼接）。
+ *
+ * - 末周只显示到该周落在所选窗口内的有效日期（[dataEndTs]，数据最后一天），
+ *   避免出现未绘制的未来/次年空位日期；数据同源，不依赖实时时钟
+ * - 首列跨年（start 在上一年）时，end 与 start 不同年 → end 强制带年份前缀，避免范围倒挂
+ * - [RECENT_YEAR]（最近 365 天窗口）时按周自身年份判断：start 不带前缀，
+ *   end 仅在与 start 跨年时带前缀（窗口可能跨年，如 "1月5日-2026年1月3日"）
+ */
+internal fun formatWeekRangeText(
+    week: HeatmapWeekData,
+    useUtc8: Boolean,
+    selectedYear: Int,
+    dataEndTs: Long?,
+    locale: Locale = Locale.getDefault(),
+): String {
+    val zone = if (useUtc8) ZoneOffset.ofHours(8) else ZoneOffset.UTC
+    val startDate = Instant.ofEpochMilli(week.weekStartTs).atOffset(zone).toLocalDate()
+    // 最近模式按周自身年份判断前缀；年份模式用所选年作上下文（与既有行为一致）
+    val startContext = if (selectedYear == RECENT_YEAR) startDate.year else selectedYear
+    val start = formatDateChinese(week.weekStartTs, useUtc8, startContext, locale)
+    val endTs = minOf(week.weekStartTs + 6L * 86_400_000L, dataEndTs ?: (week.weekStartTs + 6L * 86_400_000L))
+    if (locale.language == "zh") {
+        val endDate = Instant.ofEpochMilli(endTs).atOffset(zone).toLocalDate()
+        val end = if (endDate.year != startDate.year) {
+            "${endDate.year}年${endDate.monthValue}月${endDate.dayOfMonth}日"
+        } else {
+            formatDateChinese(endTs, useUtc8, startContext, locale)
+        }
+        return "$start-$end"
+    }
+    // 非中文：end 用 start 的年份作上下文（同 startDate.year 时无前缀；跨年时带年份）
+    return "$start-${formatDateChinese(endTs, useUtc8, startContext, locale)}"
+}
+
+// ── 辅助类型与函数 ──────────────────────────────────────────
+
+/**
+ * 水平拖动手势的仲裁模式：
+ * - VIEW：慢速横向拖动 → 滑动查看模式（显示手指所在天的信息，图表锁定不滚动）
+ * - SCROLL：快速横向拖动或纵向拖动 → 放行给 scrollable 正常滚动
+ */
+private enum class DragMode { VIEW, SCROLL }
+
+/** 慢速/快速拖动分界速度（dp/s，密度无关；低于=查看拖动，高于=滚动拖动） */
+private const val VIEW_SPEED_DP_PER_S = 150f
+
+/** 月份标签 */
+private data class MonthLabel(
+    val weekIndex: Int,
+    val label: String,
+)
+
+/** 从时间戳获取星期几 (0=Sunday, 6=Saturday)，按指定时区 */
+private fun dayOfWeekFromTs(ts: Long, zone: ZoneOffset): Int {
+    val dayOfWeek = Instant.ofEpochMilli(ts).atOffset(zone).dayOfWeek.value
+    return dayOfWeek % 7 // Sunday=7 → 0
+}
+
+/** 从时间戳获取月份 (0=January)，按指定时区 */
+private fun monthFromTs(ts: Long, zone: ZoneOffset): Int {
+    return Instant.ofEpochMilli(ts).atOffset(zone).monthValue - 1
+}
+
+/**
+ * 将每日数据按周分组（参考 react-activity-calendar 的 groupByWeeks 逻辑）。
+ * 周起始日为周日（weekStart = 0）。
+ * 返回 List<List<HeatmapDayData?>>，外层为周，内层为星期 0-6，null 表示空位。
+ */
+private fun groupByWeeks(dailyData: List<HeatmapDayData>, zone: ZoneOffset): List<List<HeatmapDayData?>> {
+    if (dailyData.isEmpty()) return emptyList()
+
+    val firstDow = dayOfWeekFromTs(dailyData[0].dayTs, zone)
+
+    // 左侧填充空位，使第一周从周日开始
+    val padded = ArrayList<HeatmapDayData?>(firstDow + dailyData.size)
+    repeat(firstDow) { padded.add(null) }
+    padded.addAll(dailyData)
+
+    val numWeeks = (padded.size + 6) / 7
+    return (0 until numWeeks).map { w ->
+        (0 until 7).map { d ->
+            val idx = w * 7 + d
+            if (idx < padded.size) padded[idx] else null
+        }
+    }
+}
+
+/** 从按周分组的每日数据计算月份标签（[monthNames] 为当前 locale 的月份名，索引 0~11） */
+private fun getMonthLabels(
+    weeks: List<List<HeatmapDayData?>>,
+    zone: ZoneOffset,
+    monthNames: List<String>,
+): List<MonthLabel> {
+    if (weeks.isEmpty()) return emptyList()
+
+    val rawLabels = mutableListOf<MonthLabel>()
+    var prevMonth = -1
+
+    for (weekIndex in weeks.indices) {
+        val firstDay = weeks[weekIndex].firstOrNull { it != null } ?: continue
+        val month = monthFromTs(firstDay.dayTs, zone)
+
+        if (weekIndex == 0 || month != prevMonth) {
+            rawLabels.add(MonthLabel(weekIndex, monthNames[month]))
+            prevMonth = month
+        }
+    }
+
+    return filterMonthLabels(rawLabels, weeks.size)
+}
+
+/**
+ * 过滤月份标签：跳过间距不足的标签（参考 react-activity-calendar 的 label.ts）。
+ * - 第一个标签：若与第二个标签间距 < minWeeks，跳过
+ * - 最后一个标签：若剩余周数 < minWeeks，跳过
+ */
+private fun filterMonthLabels(rawLabels: List<MonthLabel>, totalWeeks: Int): List<MonthLabel> {
+    val minWeeks = 3
+    return rawLabels.filterIndexed { index, label ->
+        when {
+            index == 0 -> {
+                rawLabels.getOrNull(1)?.let { it.weekIndex - label.weekIndex >= minWeeks } ?: false
+            }
+            index == rawLabels.lastIndex -> {
+                totalWeeks - label.weekIndex >= minWeeks
+            }
+            else -> true
+        }
+    }
+}
+
+// ── HeatmapCanvas Composable ───────────────────────────────
+
+/**
+ * Token 活动热力图 Canvas 绘制组件。
+ *
+ * 支持三种视图：
+ * - [HeatmapViewMode.DAILY]：约 53 列 × 7 行（列数按年浮动 52~54），每日 Token 使用
+ * - [HeatmapViewMode.WEEKLY]：约 53 列 × 7 行，**离散柱状图**——列=自然周，
+ *   整列 7 格全部绘制：底部 barHeight 格 = 该周等级颜色（0 用量周 1 格、非零周 2~7 格
+ *   按 token 排名比例），其余格 = Level 0 浅色（空白格不隐藏，网格完整）；
+ *   选中周整列加主题色描边强调；列内格子不表示日期
+ * - [HeatmapViewMode.CUMULATIVE]：约 53 列 × 7 行，累计 Token
+ *
+ * 三种视图列数与网格尺寸一致（约 52~54 列 × 7 行），切换视图时布局保持一致。
+ *
+ * 使用 Compose Canvas 绘制圆角矩形格子，底部显示中文月份标签，
+ * 支持水平滚动和格子点击。
+ *
+ * @param state UI 状态，包含数据与视图模式
+ * @param modifier 布局修饰符
+ * @param selectedWeek 当前选中的周（每周视图绘制强调边框用，null=未选中）
+ * @param onDayClick 每日/累计视图格子点击回调
+ * @param onWeekClick 每周视图格子点击回调
+ */
+@Composable
+fun HeatmapCanvas(
+    state: HeatmapUiState,
+    modifier: Modifier = Modifier,
+    noDataText: String = "",
+    lessText: String = "",
+    moreText: String = "",
+    accessibilityDesc: String = "",
+    selectedWeek: HeatmapWeekData? = null,
+    onDayClick: (HeatmapDayData, IntOffset) -> Unit = { _, _ -> },
+    onWeekClick: (HeatmapWeekData, IntOffset) -> Unit = { _, _ -> },
+) {
+    val darkTheme = isSystemInDarkTheme()
+    val colors = if (darkTheme) DarkHeatmapColors else LightHeatmapColors
+    val mutedColor = inkMuted()
+    val density = LocalDensity.current
+    // 应用内语言（LocaleManager 只覆写配置、不改变 Locale.getDefault()，故从配置取；
+    // 与 UsageOverviewScreen 的 date_format_md 同一做法）
+    val activeLocale = LocalConfiguration.current.locales[0]
+    // 与全局图表设置一致的时区（分桶与显示口径统一）
+    val zone = if (state.useUtc8) ZoneOffset.ofHours(8) else ZoneOffset.UTC
+
+    // 格子参数
+    val blockSize = 11.dp
+    val gap = 3.dp
+    val cornerRadius = 3.dp
+
+    // 预计算 px 值（供 Canvas 绘制和点击检测共用）
+    val blockSizePx = with(density) { blockSize.toPx() }
+    val gapPx = with(density) { gap.toPx() }
+    val cellStepPx = blockSizePx + gapPx
+    val cornerRadiusPx = with(density) { cornerRadius.toPx() }
+
+    val isWeekly = state.viewMode == HeatmapViewMode.WEEKLY
+
+    // 选中周强调样式（主题主色描边，明暗模式均可见）
+    val selectionColor = MaterialTheme.colorScheme.primary
+    val selectionStrokePx = with(density) { 1.5.dp.toPx() }
+
+    // 滑动查看指示器（三种视图）：慢速拖动或长按时"所见即所得"——手指所在格子高亮预览，
+    // 底部读数条显示该格数据（每日/累计=当天，每周=该周）；抬起后保留最后预览，切换视图/年份时清除
+    var indicatorDay by remember { mutableStateOf<HeatmapDayData?>(null) }
+    var indicatorWeek by remember { mutableStateOf<HeatmapWeekData?>(null) }
+    var indicatorCol by remember { mutableStateOf(-1) }
+    var indicatorRow by remember { mutableStateOf(-1) }
+
+    // Canvas 在窗口中的位置（浮层锚点定位用）
+    var canvasWindowPos by remember { mutableStateOf(IntOffset.Zero) }
+
+    // 构建网格数据（每日/累计视图用于绘制与点击；每周视图仅用于列数与月份标签，
+    // 柱状图绘制/点击直接基于 weeklyData）
+    val gridWeeks = remember(state.dailyData, state.cumulativeData, state.viewMode, zone) {
+        when (state.viewMode) {
+            HeatmapViewMode.DAILY, HeatmapViewMode.WEEKLY -> groupByWeeks(state.dailyData, zone)
+            HeatmapViewMode.CUMULATIVE -> groupByWeeks(state.cumulativeData, zone)
+        }
+    }
+
+    // 月份标签（三种视图共用同一计算，位置与每日视图完全一致；月份名按当前 locale）
+    val monthNames = List(12) { stringResource(monthNameRes[it]) }
+    val monthLabels = remember(gridWeeks, zone, monthNames) {
+        getMonthLabels(gridWeeks, zone, monthNames)
+    }
+
+    val cols = gridWeeks.size
+    val rows = 7
+
+    // 加载中或无数据
+    if (state.loading || cols == 0) {
+        Box(
+            modifier = modifier
+                .fillMaxWidth()
+                .height(if (state.loading) 200.dp else 120.dp),
+            contentAlignment = Alignment.Center,
+        ) {
+            if (state.loading) {
+                CircularProgressIndicator(color = MaterialTheme.colorScheme.primary)
+            } else {
+                Text(noDataText.ifEmpty { "No data" }, color = mutedColor, fontSize = 14.sp)
+            }
+        }
+        return
+    }
+
+    // Canvas 尺寸计算
+    val canvasWidthDp = (blockSize + gap) * cols - gap
+    val gridHeightDp = (blockSize + gap) * rows - gap
+    val monthLabelHeightDp = 20.dp
+    val totalHeightDp = gridHeightDp + monthLabelHeightDp
+
+    val gridHeightPx = with(density) { gridHeightDp.toPx() }
+    val labelGapPx = with(density) { 4.dp.toPx() }
+
+    // 月份标签画笔
+    val monthLabelPaint = remember(mutedColor, density) {
+        Paint().apply {
+            textSize = with(density) { 12.sp.toPx() }
+            color = mutedColor.toArgb()
+            isAntiAlias = true
+        }
+    }
+
+    // 横向滚动状态（图例固定在外层，不随热力图滚动）
+    val scrollState = rememberScrollState()
+
+    // 打开页面 / 切换视图 / 切换年份时，横向滚动自动定位到最右（最新数据），并清除滑动查看指示器
+    LaunchedEffect(cols, state.viewMode, state.selectedYear) {
+        indicatorDay = null
+        indicatorWeek = null
+        indicatorCol = -1
+        indicatorRow = -1
+        snapshotFlow { scrollState.maxValue }.first { it > 0 }
+        scrollState.scrollTo(scrollState.maxValue)
+    }
+
+    Column(modifier = modifier) {
+        // ── 热力图网格 + 月份标签（可横向滚动）──
+        Column(
+            modifier = Modifier
+                .horizontalScroll(scrollState)
+                .semantics { contentDescription = accessibilityDesc.ifEmpty {
+                    if (isWeekly) "Token activity heatmap, ${state.weeklyData.size} weeks"
+                    else "Token activity heatmap, ${state.dailyData.size} days"
+                } },
+        ) {
+            Canvas(
+                modifier = Modifier
+                    .size(canvasWidthDp, totalHeightDp)
+                    .onGloballyPositioned { canvasWindowPos = it.positionInWindow().round() }
+                    // 手势仲裁（与点击共存）：慢速横向拖动/长按=滑动查看（锁定图表、指示器跟手），
+                    // 快速横向拖动或纵向拖动=放行给 scrollable 正常滚动；三种视图均启用。
+                    // ⚠️ 必须声明在下方 detectTapGestures 之前：仲裁先收到 Main pass 事件，
+                    // VIEW 模式先 consume 可阻止 tap 误触发（顺序承重，勿调换）
+                    .pointerInput(state, cellStepPx, blockSizePx, gridWeeks, state.viewMode) {
+                        // 慢速/快速分界：密度无关（dp/s），保证不同设备手感一致
+                        val viewSpeedThresholdPxPerMs = with(density) { VIEW_SPEED_DP_PER_S.dp.toPx() } / 1000f
+                        // 指示器更新：手指所在列/行的格子（所见即所得）。
+                        // change.position 已是滚动内容内的本地坐标（与 detectTapGestures 命中一致），
+                        // 不能再加 scrollState.value，否则滚动后列索引整体偏右
+                        fun updateIndicator(pos: Offset) {
+                            val col = (pos.x / cellStepPx).toInt().coerceIn(0, cols - 1)
+                            val row = (pos.y / cellStepPx).toInt().coerceIn(0, rows - 1)
+                            if (isWeekly) {
+                                // 每周视图：整列=同一周（柱状图），读数条显示该周范围与总量
+                                val week = state.weeklyData.getOrNull(col)
+                                if (week != null) {
+                                    indicatorDay = null
+                                    indicatorWeek = week
+                                    indicatorCol = col
+                                    indicatorRow = row
+                                } else {
+                                    indicatorDay = null
+                                    indicatorWeek = null
+                                    indicatorCol = -1
+                                    indicatorRow = -1
+                                }
+                            } else {
+                                // 每日/累计视图：格子=一天（累计视图 tokens 为累计值）
+                                val cell = gridWeeks.getOrNull(col)?.getOrNull(row)
+                                if (cell != null) {
+                                    indicatorWeek = null
+                                    indicatorDay = cell
+                                    indicatorCol = col
+                                    indicatorRow = row
+                                } else {
+                                    indicatorWeek = null
+                                    indicatorDay = null
+                                    indicatorCol = -1
+                                    indicatorRow = -1
+                                }
+                            }
+                        }
+                        awaitEachGesture {
+                            val down = awaitFirstDown(requireUnconsumed = false)
+                            // 模式判定（本次手势内锁定）：
+                            // - 按住不动/慢速横向拖动 → VIEW：指示器跟手、消费事件锁定图表滚动
+                            // - 快速横向拖动或纵向主导 → SCROLL：不消费，放行给 scrollable 正常滚动
+                            var mode: DragMode? = null
+                            var lastPos = down.position
+                            var lastTime = SystemClock.uptimeMillis()
+                            var totalDx = 0f
+                            var totalDy = 0f
+                            val slop = viewConfiguration.touchSlop
+                            val downTime = lastTime
+                            // 长按阈值：按住不动（含微移未超 slop）超过系统长按时长 → 直接进入查看模式。
+                            // 静止时系统不一定派发 move 事件，故用 withTimeoutOrNull 做超时心跳，不依赖事件频率。
+                            // ⚠️ 此符号解析为 AwaitPointerEventScope 的框架成员（非 kotlinx 协程版），
+                            // 勿补 import kotlinx.coroutines.withTimeoutOrNull（会被接口成员遮蔽且语义不同）
+                            val longPressMs = viewConfiguration.longPressTimeoutMillis
+
+                            // 阶段一：模式判定。位移超 slop 按帧速度判 VIEW/SCROLL；提前抬起 = 点击放行给 tap；
+                            // 长按超时（手指未动）→ VIEW
+                            while (mode == null) {
+                                val remaining = longPressMs - (SystemClock.uptimeMillis() - downTime)
+                                val event = if (remaining > 0) {
+                                    withTimeoutOrNull(remaining) { awaitPointerEvent() }
+                                } else {
+                                    null
+                                }
+                                if (event == null) {
+                                    // 长按成立：按住不动（或微移 < slop）→ 查看模式
+                                    mode = DragMode.VIEW
+                                    break
+                                }
+                                val change = event.changes.firstOrNull { it.id == down.id } ?: break
+                                if (!change.pressed) break // 快速抬起 = 点击，交给 detectTapGestures
+                                val cur = change.position
+                                val now = SystemClock.uptimeMillis()
+                                // 帧瞬时速度：停顿后快甩的帧速度大 → 判为滚动；慢速拖动各帧速度都小 → 判为查看
+                                val dxFrame = cur.x - lastPos.x
+                                val dyFrame = cur.y - lastPos.y
+                                val dtFrame = (now - lastTime).coerceAtLeast(1L)
+                                val speedX = abs(dxFrame) / dtFrame
+                                lastPos = cur
+                                lastTime = now
+                                totalDx += dxFrame
+                                totalDy += dyFrame
+                                // 首次超过触摸阈值时判定模式（本次手势内锁定）：
+                                // 横向主导且慢速 → VIEW（查看）；否则 → SCROLL（滚动）
+                                if (abs(totalDx) > slop || abs(totalDy) > slop) {
+                                    mode = if (abs(totalDx) > abs(totalDy) && speedX < viewSpeedThresholdPxPerMs) {
+                                        DragMode.VIEW
+                                    } else {
+                                        DragMode.SCROLL
+                                    }
+                                    if (mode == DragMode.VIEW) {
+                                        // 判决事件立即消费：否则同帧（Main pass leaf→root）会漏到父 scrollable，
+                                        // 其越过自身 slop 先滚一帧（约 0~4px 抖动）后才被 phase2 消费取消
+                                        change.consume()
+                                    }
+                                }
+                            }
+
+                            if (mode == DragMode.VIEW) {
+                                // 进入查看模式立即用最后已知位置更新指示器（长按超时瞬间就要显示，不等下一个事件）
+                                updateIndicator(lastPos)
+                                while (true) {
+                                    val event = awaitPointerEvent()
+                                    val change = event.changes.firstOrNull { it.id == down.id } ?: break
+                                    // 先消费再判抬起：up 若不消费会漏到 detectTapGestures 误触发 onTap 浮层
+                                    // （waitForUpOrCancellation 对 consumed up 返回 null → tap 取消），
+                                    // 与慢拖路径行为保持一致
+                                    updateIndicator(change.position)
+                                    change.consume() // 消费事件锁定图表滚动
+                                    if (!change.pressed) break // 抬起：保留最后预览的格子
+                                }
+                            } else if (mode == DragMode.SCROLL) {
+                                // 滚动模式：清除上次预览的指示器，避免滚动后残留过期信息；
+                                // 不消费事件，scrollable 正常滚动（含惯性）
+                                indicatorDay = null
+                                indicatorWeek = null
+                                indicatorCol = -1
+                                indicatorRow = -1
+                            }
+                        }
+                    }
+                    .pointerInput(state, cellStepPx, blockSizePx, gridWeeks) {
+                    detectTapGestures(onTap = { offset ->
+                        // 点击时清除滑动查看残留的预览（抬起后保留的指示器），避免与浮层同时显示
+                        indicatorDay = null
+                        indicatorWeek = null
+                        indicatorCol = -1
+                        indicatorRow = -1
+                        // 点击落在格子间隙内时不触发（Minor：命中精度）
+                        if (offset.x % cellStepPx >= blockSizePx || offset.y % cellStepPx >= blockSizePx) {
+                            return@detectTapGestures
+                        }
+                        val col = (offset.x / cellStepPx).toInt()
+                        val row = (offset.y / cellStepPx).toInt()
+                        if (col < 0 || col >= gridWeeks.size || row < 0 || row >= rows) {
+                            return@detectTapGestures
+                        }
+                        val cellCenterX = (col * cellStepPx + blockSizePx / 2f).roundToInt()
+                        val cellCenterY = (row * cellStepPx + blockSizePx / 2f).roundToInt()
+                        val anchor = IntOffset(canvasWindowPos.x + cellCenterX, canvasWindowPos.y + cellCenterY)
+
+                        if (isWeekly) {
+                            // 每周视图（柱状图）：该列任意格子都对应同一周 → 点击触发该周浮层；
+                            // 0 用量周也有 1 格 Level 0 浅色格，同样可点击（显示「使用了0token」）
+                            val weekData = state.weeklyData.getOrNull(col) ?: return@detectTapGestures
+                            onWeekClick(weekData, anchor)
+                        } else {
+                            // 每日/累计视图：点击 (col, row) 对应格子（空位不可点）
+                            val cell = gridWeeks[col][row] ?: return@detectTapGestures
+                            onDayClick(cell, anchor)
+                        }
+                    })
+                },
+        ) {
+            // 绘制格子：
+            // - 每日/累计：7 行网格按天等级绘制，null 空位不绘制
+            // - 每周：离散柱状图——列=自然周，整列 7 格全部绘制：
+            //   底部 barHeight 格 = 该周等级颜色（柱：0 用量周 1 格 Level 0、非零周 2~7 格），
+            //   其余格 = Level 0 浅色（空白格不隐藏，网格完整）；
+            //   选中周整列加主题色描边强调
+            if (isWeekly) {
+                state.weeklyData.forEachIndexed { weekIndex, weekData ->
+                    val level = weekData.level.coerceIn(0, 5)
+                    val barHeight = weekData.barHeight.coerceIn(1, 7)
+                    val isSelected = weekData == selectedWeek
+                    val x = weekIndex * cellStepPx
+                    for (row in 0 until rows) {
+                        val inBar = row >= rows - barHeight
+                        val y = row * cellStepPx
+                        drawRoundRect(
+                            color = if (inBar) colors[level] else colors[0],
+                            topLeft = Offset(x, y),
+                            size = Size(blockSizePx, blockSizePx),
+                            cornerRadius = CornerRadius(cornerRadiusPx, cornerRadiusPx),
+                        )
+                        if (isSelected) {
+                            drawRoundRect(
+                                color = selectionColor,
+                                topLeft = Offset(x, y),
+                                size = Size(blockSizePx, blockSizePx),
+                                cornerRadius = CornerRadius(cornerRadiusPx, cornerRadiusPx),
+                                style = Stroke(width = selectionStrokePx),
+                            )
+                        }
+                    }
+                }
+            } else {
+                gridWeeks.forEachIndexed { weekIndex, week ->
+                    week.forEachIndexed { dayIndex, dayData ->
+                        if (dayData == null) return@forEachIndexed
+                        val x = weekIndex * cellStepPx
+                        val y = dayIndex * cellStepPx
+                        drawRoundRect(
+                            color = colors[dayData.level.coerceIn(0, 5)],
+                            topLeft = Offset(x, y),
+                            size = Size(blockSizePx, blockSizePx),
+                            cornerRadius = CornerRadius(cornerRadiusPx, cornerRadiusPx),
+                        )
+                    }
+                }
+            }
+
+            // 绘制月份标签（底部）
+            drawIntoCanvas { canvas ->
+                val nativeCanvas = canvas.nativeCanvas
+                // labelY = 网格底部 + 间距 + 文字基线偏移
+                val labelY = gridHeightPx + labelGapPx - monthLabelPaint.ascent()
+                monthLabels.forEach { label ->
+                    val x = label.weekIndex * cellStepPx
+                    nativeCanvas.drawText(label.label, x, labelY, monthLabelPaint)
+                }
+            }
+
+            // 预览格子高亮（三种视图，所见即所得）：手指所在格子加主题色边框。
+            // 防御性校验：指示器指向的格子数据仍存在（防未来"同一年份数据刷新"后残留过期高亮）
+            val indicatorValid = when {
+                indicatorWeek != null -> state.weeklyData.getOrNull(indicatorCol) != null
+                indicatorDay != null -> gridWeeks.getOrNull(indicatorCol)?.getOrNull(indicatorRow) != null
+                else -> false
+            }
+            if (indicatorValid &&
+                indicatorCol in 0 until cols && indicatorRow in 0 until rows
+            ) {
+                drawRoundRect(
+                    color = selectionColor,
+                    topLeft = Offset(indicatorCol * cellStepPx, indicatorRow * cellStepPx),
+                    size = Size(blockSizePx, blockSizePx),
+                    cornerRadius = CornerRadius(cornerRadiusPx, cornerRadiusPx),
+                    style = Stroke(width = selectionStrokePx * 1.5f),
+                )
+            }
+            }
+        }
+
+        // 滑动查看读数条（三种视图）：显示手指所在格子的数据（每日/累计=当天，每周=该周范围），
+        // 抬起后保留；固定高度占位，避免出现/消失导致图例上下跳动
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(20.dp),
+            contentAlignment = Alignment.CenterStart,
+        ) {
+            val d = indicatorDay
+            val w = indicatorWeek
+            val text = when {
+                d != null -> stringResource(
+                    R.string.heatmap_day_used,
+                    formatDateChinese(d.dayTs, state.useUtc8, state.currentYear, activeLocale),
+                    formatTokenChinese(d.tokens, activeLocale),
+                )
+                w != null -> stringResource(
+                    R.string.heatmap_week_used,
+                    formatWeekRangeText(w, state.useUtc8, state.selectedYear, state.dailyData.lastOrNull()?.dayTs, activeLocale),
+                    formatTokenChinese(w.tokens, activeLocale),
+                )
+                else -> null
+            }
+            if (text != null) {
+                Text(
+                    text = text,
+                    fontSize = 12.sp,
+                    color = mutedColor,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                )
+            }
+        }
+
+        Spacer(Modifier.height(8.dp))
+
+        // ── 颜色图例（右下角，固定不随热力图横向滚动）──
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            horizontalArrangement = Arrangement.End,
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Text(lessText.ifEmpty { "Less" }, color = mutedColor, fontSize = 12.sp)
+            Spacer(Modifier.width(4.dp))
+            for (level in 0..5) {
+                Box(
+                    modifier = Modifier
+                        .size(blockSize)
+                        .background(colors[level], RoundedCornerShape(cornerRadius)),
+                )
+                if (level < 5) {
+                    Spacer(Modifier.width(gap))
+                }
+            }
+            Spacer(Modifier.width(4.dp))
+            Text(moreText.ifEmpty { "More" }, color = mutedColor, fontSize = 12.sp)
+        }
+    }
+}

app/src/main/java/com/rainy/token/ui/heatmap/HeatmapScreen.kt

@@ -0,0 +1,808 @@
+package com.rainy.token.ui.heatmap
+
+import android.content.Context
+import android.graphics.BitmapFactory
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material.icons.filled.Person
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.selected
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.window.Popup
+import androidx.compose.ui.window.PopupProperties
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
+import com.rainy.token.ui.theme.inkMuted
+import java.io.File
+import kotlin.math.roundToInt
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/**
+ * Token 活动热力图页面。
+ *
+ * Scaffold + TopAppBar 布局，包含视图切换器（每日/每周/累计）和 HeatmapCanvas。
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun HeatmapScreen(
+    onBack: () -> Unit,
+    viewModel: HeatmapViewModel = hiltViewModel()
+) {
+    val state by viewModel.uiState.collectAsStateWithLifecycle()
+    // 应用内语言（LocaleManager 只覆写配置、不改变 Locale.getDefault()，故从配置取）
+    val activeLocale = LocalConfiguration.current.locales[0]
+
+    // ── 浮层状态 ──
+    var selectedDay: HeatmapDayData? by remember { mutableStateOf(null) }
+    var selectedWeek: HeatmapWeekData? by remember { mutableStateOf(null) }
+    // 浮层锚点：被点击格子中心在窗口中的位置
+    var popupAnchor by remember { mutableStateOf<IntOffset?>(null) }
+    // 浮层自身尺寸（用于锚点偏移计算）
+    var popupSize by remember { mutableStateOf(IntSize.Zero) }
+    val density = LocalDensity.current
+
+    // ── i18n 字符串 ──
+    val noDataText = stringResource(R.string.heatmap_no_data)
+    val lessText = stringResource(R.string.heatmap_legend_less)
+    val moreText = stringResource(R.string.heatmap_legend_more)
+
+    // ── 年份选择器状态 ──
+    var yearMenuExpanded by remember { mutableStateOf(false) }
+    val selectYearDesc = stringResource(R.string.heatmap_select_year)
+
+    // ── 个人资料状态（昵称/邮箱/头像路径，SharedPreferences 持久化）──
+    val context = LocalContext.current
+    val profilePrefs = remember { context.getSharedPreferences(PROFILE_PREFS, Context.MODE_PRIVATE) }
+    var nickname by remember { mutableStateOf("") }
+    var email by remember { mutableStateOf("") }
+    var avatarPath by remember { mutableStateOf<String?>(null) }
+    // 换头像后路径不变（固定文件名），用版本号强制触发头像重载
+    var avatarVersion by remember { mutableStateOf(0) }
+    var showProfileEdit by remember { mutableStateOf(false) }
+    var avatarMenuVisible by remember { mutableStateOf(false) }
+    LaunchedEffect(Unit) {
+        nickname = profilePrefs.getString(KEY_NICKNAME, "").orEmpty()
+        email = profilePrefs.getString(KEY_EMAIL, "").orEmpty()
+        avatarPath = profilePrefs.getString(KEY_AVATAR_PATH, null)
+    }
+    // 系统相册选图 → 复制到应用私有目录（content URI 授权是临时的，必须保存持久化副本）
+    // 复制在 IO 线程执行（相册原图可达数 MB，避免阻塞主线程）；
+    // 先写临时文件再 rename 覆盖，失败时不破坏已有头像
+    val scope = rememberCoroutineScope()
+    val avatarPicker = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri ->
+        if (uri == null) return@rememberLauncherForActivityResult
+        scope.launch {
+            runCatching {
+                withContext(Dispatchers.IO) {
+                    val target = File(context.filesDir, AVATAR_FILE_NAME)
+                    val tmp = File(context.filesDir, AVATAR_FILE_NAME + ".tmp")
+                    val input = context.contentResolver.openInputStream(uri)
+                        ?: error("cannot open picked image")
+                    input.use { i -> tmp.outputStream().use { o -> i.copyTo(o) } }
+                    if (!tmp.renameTo(target)) {
+                        tmp.delete()
+                        error("cannot persist avatar")
+                    }
+                    target.absolutePath
+                }
+            }.onSuccess { path ->
+                avatarPath = path
+                avatarVersion++ // 路径相同（固定文件名），必须递增版本号触发头像重载
+                profilePrefs.edit().putString(KEY_AVATAR_PATH, path).apply()
+            }.onFailure { tmp ->
+                File(context.filesDir, AVATAR_FILE_NAME + ".tmp").delete()
+            }
+        }
+    }
+
+    LaunchedEffect(Unit) {
+        viewModel.load()
+    }
+
+    Scaffold(
+        containerColor = Color.Transparent,
+        topBar = {
+            TopAppBar(
+                title = {
+                    Row(verticalAlignment = Alignment.CenterVertically) {
+                        Text(stringResource(R.string.heatmap_title))
+                        if (state.availableYears.isNotEmpty()) {
+                            Spacer(Modifier.width(12.dp))
+                            // 年份下拉选择器：默认"最近 365 天"（置顶），下方为具体年份
+                            val selectRangeLabel = if (state.selectedYear == RECENT_YEAR) {
+                                stringResource(R.string.heatmap_select_recent)
+                            } else {
+                                "${state.selectedYear}"
+                            }
+                            Text(
+                                text = "$selectRangeLabel ▾",
+                                style = MaterialTheme.typography.bodyMedium,
+                                fontWeight = FontWeight.Medium,
+                                color = MaterialTheme.colorScheme.onSurface,
+                                maxLines = 1,
+                                overflow = TextOverflow.Ellipsis,
+                                modifier = Modifier
+                                    .clip(RoundedCornerShape(6.dp))
+                                    .clickable { yearMenuExpanded = true }
+                                    .padding(horizontal = 6.dp, vertical = 4.dp)
+                                    .semantics { contentDescription = "$selectYearDesc: $selectRangeLabel" }
+                            )
+                            DropdownMenu(
+                                expanded = yearMenuExpanded,
+                                onDismissRequest = { yearMenuExpanded = false }
+                            ) {
+                                // "最近 365 天"（默认选项，与具体年份区分：置顶 + 分隔线）
+                                DropdownMenuItem(
+                                    text = { Text(stringResource(R.string.heatmap_select_recent)) },
+                                    trailingIcon = {
+                                        if (state.selectedYear == RECENT_YEAR) {
+                                            Icon(
+                                                Icons.Filled.Check,
+                                                contentDescription = null,
+                                                modifier = Modifier.size(18.dp).semantics { selected = true },
+                                            )
+                                        }
+                                    },
+                                    onClick = {
+                                        yearMenuExpanded = false
+                                        viewModel.setYear(RECENT_YEAR)
+                                        // 切换范围时关闭浮层
+                                        selectedDay = null
+                                        selectedWeek = null
+                                        popupAnchor = null
+                                    }
+                                )
+                                HorizontalDivider()
+                                state.availableYears.sortedDescending().forEach { year ->
+                                    DropdownMenuItem(
+                                        text = { Text("$year") },
+                                        trailingIcon = {
+                                            if (state.selectedYear == year) {
+                                                Icon(
+                                                    Icons.Filled.Check,
+                                                    contentDescription = null,
+                                                    modifier = Modifier.size(18.dp).semantics { selected = true },
+                                                )
+                                            }
+                                        },
+                                        onClick = {
+                                            yearMenuExpanded = false
+                                            viewModel.setYear(year)
+                                            // 切换年份时关闭浮层
+                                            selectedDay = null
+                                            selectedWeek = null
+                                            popupAnchor = null
+                                        }
+                                    )
+                                }
+                            }
+                        }
+                    }
+                },
+                navigationIcon = {
+                    IconButton(onClick = onBack) {
+                        Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = stringResource(R.string.action_back))
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Transparent)
+            )
+        }
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(innerPadding)
+                .verticalScroll(rememberScrollState())
+                .padding(horizontal = 16.dp, vertical = 8.dp)
+        ) {
+            // ── 个人资料卡片（页面最顶部：自定义头像 + 昵称/邮箱）──
+            ProfileCard(
+                nickname = nickname,
+                email = email,
+                avatarPath = avatarPath,
+                avatarVersion = avatarVersion,
+                onEdit = { showProfileEdit = true },
+                onAvatarClick = { avatarMenuVisible = true },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(bottom = 12.dp),
+            )
+
+            // ── 活动洞察卡片（个人资料下方：总请求次数 + 最多请求时段 Top3）──
+            InsightsCard(
+                totalRequests = state.insights.totalRequests,
+                topHours = state.insights.topHours,
+                loading = state.loading,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(bottom = 12.dp),
+            )
+
+            // ── 视图切换器 ──
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(16.dp),
+                modifier = Modifier.padding(start = 4.dp, end = 4.dp, bottom = 12.dp)
+            ) {
+                HeatmapViewMode.entries.forEach { mode ->
+                    val label = when (mode) {
+                        HeatmapViewMode.DAILY -> stringResource(R.string.heatmap_view_daily)
+                        HeatmapViewMode.WEEKLY -> stringResource(R.string.heatmap_view_weekly)
+                        HeatmapViewMode.CUMULATIVE -> stringResource(R.string.heatmap_view_cumulative)
+                    }
+                    val isSelected = state.viewMode == mode
+                    Text(
+                        text = label,
+                        style = MaterialTheme.typography.bodyMedium,
+                        fontWeight = if (isSelected) FontWeight.Medium else FontWeight.Normal,
+                        color = if (isSelected) MaterialTheme.colorScheme.onSurface else inkMuted(),
+                        modifier = Modifier.clickable {
+                            viewModel.setViewMode(mode)
+                            // 切换视图时关闭浮层
+                            selectedDay = null
+                            selectedWeek = null
+                            popupAnchor = null
+                        }
+                    )
+                }
+            }
+
+            // ── 年度统计（按所选年份，切换年份跟随变化）──
+            // loading 期间显示占位，避免全 0 造成"无数据"假象
+            val dash = "–"
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(bottom = 12.dp),
+                verticalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    StatItem(
+                        label = stringResource(R.string.heatmap_stats_total),
+                        value = if (state.loading) dash else formatTokenChinese(state.stats.totalTokens, activeLocale),
+                        modifier = Modifier.weight(1f),
+                    )
+                    StatItem(
+                        label = stringResource(R.string.heatmap_stats_peak),
+                        value = if (state.loading) dash else formatTokenChinese(state.stats.peakTokens, activeLocale),
+                        modifier = Modifier.weight(1f),
+                    )
+                }
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    StatItem(
+                        label = stringResource(R.string.heatmap_stats_current_streak),
+                        value = if (state.loading) {
+                            dash
+                        } else {
+                            pluralStringResource(R.plurals.heatmap_stats_days, state.stats.currentStreak, state.stats.currentStreak)
+                        },
+                        modifier = Modifier.weight(1f),
+                    )
+                    StatItem(
+                        label = stringResource(R.string.heatmap_stats_max_streak),
+                        value = if (state.loading) {
+                            dash
+                        } else {
+                            pluralStringResource(R.plurals.heatmap_stats_days, state.stats.maxStreak, state.stats.maxStreak)
+                        },
+                        modifier = Modifier.weight(1f),
+                    )
+                }
+            }
+
+            // ── 热力图 Canvas（带 Crossfade 淡入淡出动画）──
+            Crossfade(
+                targetState = state.viewMode,
+                animationSpec = tween(150),
+                label = "heatmap_view"
+            ) { mode ->
+                // 用 mode 参数构造视图快照：过渡期间新旧两个分支渲染各自模式，
+                // 否则两者都读最新 viewMode，动画会变成空操作
+                // 无障碍描述也在分支内按 mode 计算，避免淡出分支播报错误的模式
+                val desc = if (mode == HeatmapViewMode.WEEKLY) {
+                    stringResource(R.string.heatmap_accessibility_desc_weekly, state.weeklyData.size)
+                } else {
+                    stringResource(R.string.heatmap_accessibility_desc, state.dailyData.size)
+                }
+                HeatmapCanvas(
+                    state = state.copy(viewMode = mode),
+                    noDataText = noDataText,
+                    lessText = lessText,
+                    moreText = moreText,
+                    accessibilityDesc = desc,
+                    selectedWeek = selectedWeek,
+                    onDayClick = { dayData, anchor ->
+                        // 再次点击同一格子则关闭浮层（0 token 的天也可点击查看）
+                        if (selectedDay == dayData) {
+                            selectedDay = null
+                            popupAnchor = null
+                        } else {
+                            selectedDay = dayData
+                            selectedWeek = null
+                            popupAnchor = anchor
+                        }
+                    },
+                    onWeekClick = { weekData, anchor ->
+                        if (selectedWeek == weekData) {
+                            selectedWeek = null
+                            popupAnchor = null
+                        } else {
+                            selectedWeek = weekData
+                            selectedDay = null
+                            popupAnchor = anchor
+                        }
+                    }
+                )
+            }
+
+            Spacer(modifier = Modifier.height(32.dp))
+        }
+    }
+
+    // ── 个人资料编辑对话框（昵称/邮箱均可完全自定义，留空=清除）──
+    if (showProfileEdit) {
+        var editNickname by remember { mutableStateOf(nickname) }
+        var editEmail by remember { mutableStateOf(email) }
+        ProfileEditDialog(
+            nickname = editNickname,
+            email = editEmail,
+            onNicknameChange = { editNickname = it },
+            onEmailChange = { editEmail = it },
+            onSave = {
+                nickname = editNickname
+                email = editEmail
+                profilePrefs.edit()
+                    .putString(KEY_NICKNAME, editNickname)
+                    .putString(KEY_EMAIL, editEmail)
+                    .apply()
+                showProfileEdit = false
+            },
+            onDismiss = { showProfileEdit = false },
+        )
+    }
+
+    // ── 头像操作对话框（更换/移除）──
+    if (avatarMenuVisible) {
+        AlertDialog(
+            onDismissRequest = { avatarMenuVisible = false },
+            title = { Text(stringResource(R.string.heatmap_profile_avatar_change)) },
+            text = {
+                Column {
+                    TextButton(onClick = {
+                        avatarMenuVisible = false
+                        avatarPicker.launch("image/*")
+                    }) {
+                        Text(stringResource(R.string.heatmap_profile_avatar_pick))
+                    }
+                    if (avatarPath != null) {
+                        TextButton(onClick = {
+                            avatarMenuVisible = false
+                            avatarPath?.let { runCatching { File(it).delete() } }
+                            avatarPath = null
+                            profilePrefs.edit().remove(KEY_AVATAR_PATH).apply()
+                        }) {
+                            Text(stringResource(R.string.heatmap_profile_avatar_remove))
+                        }
+                    }
+                }
+            },
+            confirmButton = {},
+            dismissButton = {
+                TextButton(onClick = { avatarMenuVisible = false }) {
+                    Text(stringResource(R.string.heatmap_profile_cancel))
+                }
+            },
+        )
+    }
+
+    // ── 浮层 Popup（锚定到被点击格子的中心位置）──
+    val day = selectedDay
+    val week = selectedWeek
+    val anchor = popupAnchor
+    if (day != null || week != null) {
+        val useUtc8 = state.useUtc8
+        val popupText = when {
+            day != null -> stringResource(
+                R.string.heatmap_day_used,
+                formatDateChinese(day.dayTs, useUtc8, state.currentYear, activeLocale),
+                formatTokenChinese(day.tokens, activeLocale),
+            )
+            week != null -> stringResource(
+                R.string.heatmap_week_used,
+                formatWeekRangeText(week, useUtc8, state.selectedYear, state.dailyData.lastOrNull()?.dayTs, activeLocale),
+                formatTokenChinese(week.tokens, activeLocale),
+            )
+            else -> ""
+        }
+        // 浮层相对锚点的偏移：水平居中、优先显示在格子上方 8dp 处；
+        // 上方空间不足时翻转到下方；x/y 均 clamp 在窗口内
+        val gapPx = with(density) { 8.dp.toPx() }.roundToInt()
+        val edgePaddingPx = with(density) { 8.dp.toPx() }.roundToInt()
+        val configuration = LocalConfiguration.current
+        val windowWidthPx = with(density) { configuration.screenWidthDp.dp.toPx() }.roundToInt()
+        val windowHeightPx = with(density) { configuration.screenHeightDp.dp.toPx() }.roundToInt()
+        val maxX = (windowWidthPx - popupSize.width - edgePaddingPx).coerceAtLeast(edgePaddingPx)
+        val maxY = (windowHeightPx - popupSize.height - edgePaddingPx).coerceAtLeast(edgePaddingPx)
+        val popupOffset = if (anchor != null) {
+            val x = (anchor.x - popupSize.width / 2).coerceIn(edgePaddingPx, maxX)
+            val y = if (anchor.y - popupSize.height - gapPx >= edgePaddingPx) {
+                // 上方放得下：显示在格子上方
+                (anchor.y - popupSize.height - gapPx).coerceIn(edgePaddingPx, maxY)
+            } else {
+                // 上方放不下：翻转到格子下方
+                (anchor.y + gapPx).coerceIn(edgePaddingPx, maxY)
+            }
+            IntOffset(x, y)
+        } else {
+            IntOffset.Zero
+        }
+        Popup(
+            alignment = Alignment.TopStart,
+            offset = popupOffset,
+            onDismissRequest = {
+                selectedDay = null
+                selectedWeek = null
+                popupAnchor = null
+            },
+            // 不拦截图表交互：浮层不获取焦点，点击/滑动直接作用于图表，
+            // 点击其他格子即切换浮层，再次点击同一格子关闭
+            properties = PopupProperties(focusable = false)
+        ) {
+            Surface(
+                shape = androidx.compose.foundation.shape.RoundedCornerShape(12.dp),
+                tonalElevation = 3.dp,
+                shadowElevation = 6.dp,
+                modifier = Modifier
+                    .padding(horizontal = 8.dp)
+                    .onGloballyPositioned { popupSize = it.size }
+            ) {
+                Text(
+                    text = popupText,
+                    fontSize = 14.sp,
+                    modifier = Modifier.padding(12.dp)
+                )
+            }
+        }
+    }
+}
+
+// ── 年度统计卡片（累计/峰值/当前连续/最长连续）──
+@Composable
+private fun StatItem(
+    label: String,
+    value: String,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier
+            .clip(RoundedCornerShape(10.dp))
+            .background(MaterialTheme.colorScheme.surfaceVariant)
+            .padding(horizontal = 10.dp, vertical = 8.dp),
+    ) {
+        Text(
+            text = value,
+            style = MaterialTheme.typography.bodyMedium,
+            fontWeight = FontWeight.SemiBold,
+            color = MaterialTheme.colorScheme.onSurface,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+        Spacer(Modifier.height(2.dp))
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodySmall,
+            color = inkMuted(),
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+    }
+}
+
+// ── 个人资料卡片（页面最顶部：自定义头像 + 昵称/邮箱）──
+@Composable
+private fun ProfileCard(
+    nickname: String,
+    email: String,
+    avatarPath: String?,
+    avatarVersion: Int,
+    onEdit: () -> Unit,
+    onAvatarClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val emptyText = stringResource(R.string.heatmap_profile_empty)
+    Surface(
+        modifier = modifier,
+        shape = RoundedCornerShape(14.dp),
+        color = MaterialTheme.colorScheme.surfaceVariant,
+    ) {
+        Column(Modifier.padding(14.dp)) {
+            Text(
+                text = stringResource(R.string.heatmap_profile_title),
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.SemiBold,
+                color = MaterialTheme.colorScheme.onSurface,
+            )
+            Spacer(Modifier.height(10.dp))
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                ProfileAvatar(
+                    avatarPath = avatarPath,
+                    avatarVersion = avatarVersion,
+                    nickname = nickname,
+                    onClick = onAvatarClick,
+                )
+                Spacer(Modifier.width(12.dp))
+                Column(Modifier.weight(1f)) {
+                    Text(
+                        text = nickname.ifBlank { emptyText },
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.SemiBold,
+                        color = MaterialTheme.colorScheme.onSurface,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                    )
+                    Spacer(Modifier.height(2.dp))
+                    Text(
+                        text = email.ifBlank { emptyText },
+                        style = MaterialTheme.typography.bodySmall,
+                        color = inkMuted(),
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                    )
+                }
+                IconButton(onClick = onEdit) {
+                    Icon(Icons.Filled.Edit, contentDescription = stringResource(R.string.heatmap_profile_edit))
+                }
+            }
+        }
+    }
+}
+
+// ── 自定义头像（圆形裁剪；未设置时显示昵称首字符占位）──
+@Composable
+private fun ProfileAvatar(
+    avatarPath: String?,
+    avatarVersion: Int,
+    nickname: String,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    // 本地文件解码在 IO 线程；key=(路径,版本号)：换头像后路径不变，靠版本号触发重载
+    // 先读尺寸再降采样解码（头像仅 56dp 显示，全尺寸解码相册大图会 OOM）
+    val avatar by produceState<ImageBitmap?>(initialValue = null, avatarPath, avatarVersion) {
+        value = avatarPath?.let { path ->
+            withContext(Dispatchers.IO) {
+                runCatching {
+                    val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+                    BitmapFactory.decodeFile(path, bounds)
+                    var sample = 1
+                    while (bounds.outWidth / sample > 512 || bounds.outHeight / sample > 512) sample *= 2
+                    val opts = BitmapFactory.Options().apply { inSampleSize = sample }
+                    BitmapFactory.decodeFile(path, opts)?.asImageBitmap()
+                }.getOrNull()
+            }
+        }
+    }
+    val avatarDesc = stringResource(R.string.heatmap_profile_avatar_change)
+    Box(
+        modifier = modifier
+            .size(56.dp)
+            .clip(CircleShape)
+            .background(MaterialTheme.colorScheme.surface)
+            .clickable(onClick = onClick)
+            .semantics { contentDescription = avatarDesc },
+        contentAlignment = Alignment.Center,
+    ) {
+        val bmp = avatar
+        if (bmp != null) {
+            Image(
+                bitmap = bmp,
+                contentDescription = null,
+                modifier = Modifier.fillMaxSize(),
+                contentScale = ContentScale.Crop,
+            )
+        } else {
+            // 按 code point 取首字符，避免 emoji（代理对）被截成半个字符显示乱码
+            val trimmed = nickname.trim()
+            val initial = if (trimmed.isEmpty()) null else String(Character.toChars(trimmed.codePointAt(0)))
+            if (initial != null) {
+                Text(
+                    text = initial,
+                    style = MaterialTheme.typography.titleLarge,
+                    fontWeight = FontWeight.SemiBold,
+                    color = inkMuted(),
+                )
+            } else {
+                Icon(Icons.Filled.Person, contentDescription = null, tint = inkMuted())
+            }
+        }
+    }
+}
+
+// ── 个人资料编辑对话框（昵称/邮箱均可完全自定义）──
+@Composable
+private fun ProfileEditDialog(
+    nickname: String,
+    email: String,
+    onNicknameChange: (String) -> Unit,
+    onEmailChange: (String) -> Unit,
+    onSave: () -> Unit,
+    onDismiss: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.heatmap_profile_dialog_title)) },
+        text = {
+            Column {
+                OutlinedTextField(
+                    value = nickname,
+                    onValueChange = onNicknameChange,
+                    label = { Text(stringResource(R.string.heatmap_profile_nickname)) },
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+                Spacer(Modifier.height(8.dp))
+                OutlinedTextField(
+                    value = email,
+                    onValueChange = onEmailChange,
+                    label = { Text(stringResource(R.string.heatmap_profile_email)) },
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onSave) { Text(stringResource(R.string.heatmap_profile_save)) }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.heatmap_profile_cancel)) }
+        },
+    )
+}
+
+// ── 活动洞察卡片（总请求次数 + 最多请求时段 Top3，全量历史口径）──
+@Composable
+private fun InsightsCard(
+    totalRequests: Int,
+    topHours: List<Int>,
+    loading: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    val dash = "–"
+    Surface(
+        modifier = modifier,
+        shape = RoundedCornerShape(14.dp),
+        color = MaterialTheme.colorScheme.surfaceVariant,
+    ) {
+        Column(Modifier.padding(14.dp)) {
+            Text(
+                text = stringResource(R.string.heatmap_insights_title),
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.SemiBold,
+                color = MaterialTheme.colorScheme.onSurface,
+            )
+            Spacer(Modifier.height(8.dp))
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(
+                    text = stringResource(R.string.heatmap_insights_requests),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = inkMuted(),
+                    modifier = Modifier.weight(1f),
+                )
+                Text(
+                    text = if (loading) {
+                        dash
+                    } else {
+                        pluralStringResource(R.plurals.heatmap_insights_request_count, totalRequests, totalRequests)
+                    },
+                    style = MaterialTheme.typography.bodyMedium,
+                    fontWeight = FontWeight.SemiBold,
+                    color = MaterialTheme.colorScheme.onSurface,
+                )
+            }
+            Spacer(Modifier.height(6.dp))
+            Text(
+                text = stringResource(R.string.heatmap_insights_peak_hours),
+                style = MaterialTheme.typography.bodySmall,
+                color = inkMuted(),
+            )
+            Spacer(Modifier.height(6.dp))
+            // 固定 3 个时段槽位，不足的显示占位，避免布局跳动
+            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                repeat(3) { i ->
+                    val hour = topHours.getOrNull(i)
+                    Text(
+                        text = if (loading || hour == null) {
+                            dash
+                        } else {
+                            stringResource(R.string.heatmap_insight_hour_range, hour, hour + 1)
+                        },
+                        style = MaterialTheme.typography.bodySmall,
+                        fontWeight = FontWeight.Medium,
+                        color = MaterialTheme.colorScheme.onSurface,
+                        modifier = Modifier
+                            .clip(RoundedCornerShape(8.dp))
+                            .background(MaterialTheme.colorScheme.surface)
+                            .padding(horizontal = 8.dp, vertical = 4.dp),
+                    )
+                }
+            }
+        }
+    }
+}
+
+// ── 个人资料持久化 ──
+private const val PROFILE_PREFS = "heatmap_profile"
+private const val KEY_NICKNAME = "nickname"
+private const val KEY_EMAIL = "email"
+private const val KEY_AVATAR_PATH = "avatar_path"
+private const val AVATAR_FILE_NAME = "heatmap_avatar.jpg"

app/src/main/java/com/rainy/token/ui/heatmap/HeatmapViewModel.kt

@@ -0,0 +1,593 @@
+package com.rainy.token.ui.heatmap
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.rainy.token.data.local.ChartSettingsStore
+import com.rainy.token.data.local.UsageCache
+import com.rainy.token.data.local.UsageRecord
+import com.rainy.token.data.repository.CredentialRepository
+import com.rainy.token.domain.model.Credential
+import com.rainy.token.domain.service.ServiceType
+import dagger.hilt.android.lifecycle.HiltViewModel
+import java.time.Instant
+import java.time.ZoneOffset
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.util.concurrent.ConcurrentHashMap
+import javax.inject.Inject
+import javax.inject.Provider
+
+// ── 公共数据类 ──────────────────────────────────────────────
+
+/** 热力图视图模式 */
+enum class HeatmapViewMode { DAILY, WEEKLY, CUMULATIVE }
+
+/** 年份选择器中的"最近"窗口（最近 365 天）sentinel：selectedYear == RECENT_YEAR 表示最近模式 */
+internal const val RECENT_YEAR = -1
+
+/** 每日 / 累计视图的单格数据 */
+data class HeatmapDayData(
+    val dayTs: Long,   // UTC 日期时间戳（即天分桶的时间戳）
+    val tokens: Long,  // 当天 token 数（DAILY）或累计 token 数（CUMULATIVE）
+    val level: Int,    // 0-5 颜色等级
+)
+
+/** 每周视图的单格数据 */
+data class HeatmapWeekData(
+    val weekStartTs: Long, // 该周起始日时间戳
+    val tokens: Long,      // 该周 7 天累计 token 数
+    val level: Int,        // 0-5 颜色等级
+    val barHeight: Int,    // 柱状图高度（格数）：0 用量周=1（Level 0 浅色格，可见可点），非零周=2~7（按 token 排名比例）
+)
+
+/** 年度统计指标（按所选年份的每日数据计算，切换年份跟随变化） */
+data class HeatmapStats(
+    val totalTokens: Long = 0L, // 累计 token 数（当年全部天之和）
+    val peakTokens: Long = 0L,  // 峰值 token 数（单日最大；当年无数据=0）
+    val currentStreak: Int = 0, // 当前连续天数（从最后一天往前数连续 >0 的天数；末尾为 0 的天跳过，从最后一个非零天往前数）
+    val maxStreak: Int = 0,     // 最长连续天数（当年内连续 >0 的最大天数）
+)
+
+/**
+ * 活动洞察（基于全部历史记录，不随年份切换变化）。
+ *
+ * - totalRequests：总请求次数（= 记录条数，一条 UsageRecord 即一次请求）
+ * - topHours：请求最多的时段（按小时 0-23），降序取前 3；
+ *   并列时小时数小的优先；不足 3 个时列表较短
+ */
+data class HeatmapInsights(
+    val totalRequests: Int = 0,
+    val topHours: List<Int> = emptyList(),
+)
+
+/** UI 状态 */
+data class HeatmapUiState(
+    val loading: Boolean = true,
+    val viewMode: HeatmapViewMode = HeatmapViewMode.DAILY,
+    val selectedYear: Int = 0,  // 当前选中范围：0=尚未加载，RECENT_YEAR(-1)=最近365天，>0=具体年份
+    val currentYear: Int = 0,   // 今年（浮层日期判断是否显示年份用）
+    val availableYears: List<Int> = emptyList(),  // 可选年份（最早数据年份..今年，降序展示）
+    val dailyData: List<HeatmapDayData> = emptyList(),
+    val weeklyData: List<HeatmapWeekData> = emptyList(),
+    val cumulativeData: List<HeatmapDayData> = emptyList(),
+    val colorLevels: IntArray = IntArray(6),  // [0, p25, p50, p75, p95, max]
+    val stats: HeatmapStats = HeatmapStats(), // 年度统计（累计/峰值/当前连续/最长连续）
+    val insights: HeatmapInsights = HeatmapInsights(), // 活动洞察（全量记录：总请求次数 + 最多请求时段 Top3）
+    val useUtc8: Boolean = false,  // 与全局图表设置一致：true=UTC+8 分桶，false=UTC
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is HeatmapUiState) return false
+        return loading == other.loading &&
+            viewMode == other.viewMode &&
+            selectedYear == other.selectedYear &&
+            currentYear == other.currentYear &&
+            availableYears == other.availableYears &&
+            dailyData == other.dailyData &&
+            weeklyData == other.weeklyData &&
+            cumulativeData == other.cumulativeData &&
+            colorLevels.contentEquals(other.colorLevels) &&
+            stats == other.stats &&
+            insights == other.insights &&
+            useUtc8 == other.useUtc8
+    }
+
+    override fun hashCode(): Int {
+        var result = loading.hashCode()
+        result = 31 * result + viewMode.hashCode()
+        result = 31 * result + selectedYear
+        result = 31 * result + currentYear
+        result = 31 * result + availableYears.hashCode()
+        result = 31 * result + dailyData.hashCode()
+        result = 31 * result + weeklyData.hashCode()
+        result = 31 * result + cumulativeData.hashCode()
+        result = 31 * result + colorLevels.contentHashCode()
+        result = 31 * result + stats.hashCode()
+        result = 31 * result + insights.hashCode()
+        result = 31 * result + useUtc8.hashCode()
+        return result
+    }
+}
+
+/**
+ * 分位阈值与颜色等级映射。
+ *
+ * thresholds[0..5] 存 Long 阈值：
+ * - Level 0: value == 0
+ * - Level 1: 0 < value ≤ P25
+ * - Level 2: P25 < value ≤ P50
+ * - Level 3: P50 < value ≤ P75
+ * - Level 4: P75 < value ≤ P95
+ * - Level 5: value > P95
+ *
+ * 边界情况（非零天数 < 2 或所有非零值相同）时，所有非零值设为 Level 3。
+ */
+internal data class QuantileLevels(val thresholds: LongArray) {
+    fun getColorLevel(value: Long): Int {
+        if (value <= 0L) return 0
+        for (level in 1..5) {
+            if (value <= thresholds[level]) return level
+        }
+        return 5
+    }
+
+    fun toIntArray(): IntArray = IntArray(6) { idx ->
+        val v = thresholds[idx]
+        if (v > Int.MAX_VALUE) Int.MAX_VALUE else v.toInt()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is QuantileLevels) return false
+        return thresholds.contentEquals(other.thresholds)
+    }
+
+    override fun hashCode(): Int = thresholds.contentHashCode()
+}
+
+// ── ViewModel ──────────────────────────────────────────────
+
+@HiltViewModel
+class HeatmapViewModel @Inject constructor(
+    private val cacheProvider: Provider<UsageCache>,
+    private val credentialRepository: CredentialRepository,
+    private val chartSettingsStore: ChartSettingsStore,
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow(HeatmapUiState())
+    val uiState: StateFlow<HeatmapUiState> = _uiState.asStateFlow()
+
+    private var loaded = false
+    // 全量记录缓存（仅在 load 时拉取一次，切换年份/视图时复用）
+    private var records: List<UsageRecord> = emptyList()
+    private var useUtc8 = false
+    // 按年缓存三视图计算结果，切换年份不必重复计算（跨线程读写，用并发容器）
+    private val yearResults = ConcurrentHashMap<Int, AllViewsResult>()
+    // 最近一次请求的年份（防止快速连续切换时旧协程后完成覆盖新选择）
+    private var latestRequestedYear = 0
+
+    /**
+     * Composable 层在 LaunchedEffect 中调用一次即可。
+     * 首次加载拉取全量记录并计算默认年份（今年）的三视图数据。
+     */
+    fun load() {
+        if (loaded) return
+        loaded = true
+        viewModelScope.launch { loadInternal() }
+    }
+
+    /** 切换视图模式（仅改 State，不重新加载数据） */
+    fun setViewMode(mode: HeatmapViewMode) {
+        val result = yearResults[_uiState.value.selectedYear]
+        val levels = result?.let {
+            when (mode) {
+                HeatmapViewMode.DAILY -> it.dailyLevels
+                HeatmapViewMode.WEEKLY -> it.weeklyLevels
+                HeatmapViewMode.CUMULATIVE -> it.cumulativeLevels
+            }
+        }
+        _uiState.update { it.copy(viewMode = mode, colorLevels = levels?.toIntArray() ?: it.colorLevels) }
+    }
+
+    /** 切换窗口范围（年份或最近365天）：用缓存的记录按所选范围重新聚合三视图 */
+    fun setYear(year: Int) {
+        // guard 用 latestRequestedYear（最后一次请求意图）而非已提交的 selectedYear：
+        // 避免"在途切换未提交时重复点击导致最后一次意图被丢弃"的竞态
+        if (year == latestRequestedYear || records.isEmpty()) return
+        latestRequestedYear = year
+        viewModelScope.launch {
+            val cached = yearResults[year]
+            // 最近 365 天窗口以计算时刻的 todayTs 为锚：页面跨天常驻时缓存已过期（窗口末日在昨天），需重算
+            val stale = cached != null && year == RECENT_YEAR && cached.dailyData.lastOrNull()?.dayTs != todayTsOf()
+            val result = if (cached == null || stale) {
+                withContext(Dispatchers.Default) {
+                    computeAllViews(records, useUtc8, year).also { yearResults[year] = it }
+                }
+            } else {
+                cached
+            }
+            // 期间用户又切了别的范围：丢弃过期结果，避免旧协程覆盖新选择
+            if (year != latestRequestedYear) return@launch
+            val mode = _uiState.value.viewMode
+            val levels = when (mode) {
+                HeatmapViewMode.DAILY -> result.dailyLevels
+                HeatmapViewMode.WEEKLY -> result.weeklyLevels
+                HeatmapViewMode.CUMULATIVE -> result.cumulativeLevels
+            }
+            _uiState.update {
+                it.copy(
+                    selectedYear = year,
+                    dailyData = result.dailyData,
+                    weeklyData = result.weeklyData,
+                    cumulativeData = result.cumulativeData,
+                    colorLevels = levels.toIntArray(),
+                    stats = computeStats(result.dailyData),
+                )
+            }
+        }
+    }
+
+    /** 当前时区下的今天自然日零点（缓存新鲜度校验用） */
+    private fun todayTsOf(): Long {
+        val zone = if (useUtc8) ZoneOffset.ofHours(8) else ZoneOffset.UTC
+        return startOfDayTs(System.currentTimeMillis(), zone)
+    }
+
+    // ── 内部逻辑 ────────────────────────────────────────────
+
+    private suspend fun workspaceId(): String? {
+        val c = credentialRepository.get(ServiceType.OPENCODE_GO)
+        return (c as? Credential.SessionCredential)?.workspaceId?.takeIf { it.isNotBlank() }
+    }
+
+    private suspend fun loadInternal() {
+        try {
+            val wid = workspaceId() ?: run {
+                _uiState.update { it.copy(loading = false) }
+                return
+            }
+            val cache = cacheProvider.get()
+            // 与全局图表设置一致：读取 UTC+8 / UTC 分桶偏好
+            useUtc8 = chartSettingsStore.useUtc8Flow.first()
+
+            // 拉取全量记录 + 计算可选年份（在 IO 线程，避免主线程遍历大列表）
+            val zone = if (useUtc8) ZoneOffset.ofHours(8) else ZoneOffset.UTC
+            val currentYear = Instant.now().atOffset(zone).year
+            val (fetched, availableYears) = withContext(Dispatchers.Default) {
+                val all = cache.getRecords(wid)
+                all to computeAvailableYears(all, zone, currentYear)
+            }
+            records = fetched
+            latestRequestedYear = RECENT_YEAR
+
+            // 活动洞察基于全量历史记录（不随年份变化），在后台线程计算（万级记录仅数 ms）
+            val insights = withContext(Dispatchers.Default) { computeInsights(fetched, useUtc8) }
+
+            // 所有重操作放在 Dispatchers.Default 上；默认窗口 = 最近 365 天（RECENT_YEAR）
+            val result = withContext(Dispatchers.Default) {
+                computeAllViews(fetched, useUtc8, RECENT_YEAR).also { yearResults[RECENT_YEAR] = it }
+            }
+
+            // 重操作完成后按当前视图模式写入对应的分位阈值（加载期间可能已切换视图）
+            val mode = _uiState.value.viewMode
+            val levels = when (mode) {
+                HeatmapViewMode.DAILY -> result.dailyLevels
+                HeatmapViewMode.WEEKLY -> result.weeklyLevels
+                HeatmapViewMode.CUMULATIVE -> result.cumulativeLevels
+            }
+            _uiState.update {
+                it.copy(
+                    loading = false,
+                    selectedYear = RECENT_YEAR,
+                    currentYear = currentYear,
+                    availableYears = availableYears,
+                    useUtc8 = useUtc8,
+                    dailyData = result.dailyData,
+                    weeklyData = result.weeklyData,
+                    cumulativeData = result.cumulativeData,
+                    colorLevels = levels.toIntArray(),
+                    stats = computeStats(result.dailyData),
+                    insights = insights,
+                )
+            }
+        } catch (e: Exception) {
+            _uiState.update { it.copy(loading = false) }
+        }
+    }
+
+    /** 可选年份列表：最早有数据的年份 ～ 今年；无数据时只有今年 */
+    private fun computeAvailableYears(records: List<UsageRecord>, zone: ZoneOffset, currentYear: Int): List<Int> {
+        val minYear = records.minOfOrNull { Instant.ofEpochMilli(it.timeCreated).atOffset(zone).year }
+            ?: currentYear
+        return (minYear..currentYear).toList()
+    }
+
+    // ── 聚合计算 ────────────────────────────────────────────
+
+    companion object {
+        private const val DAY_MS = 86_400_000L
+
+        /**
+         * 按指定窗口从全部记录计算三种视图数据 + 颜色等级阈值。
+         *
+         * 窗口类型由 [year] 决定：
+         * - [RECENT_YEAR]（-1）：最近 365 天（今天往前 364 天 ～ 今天，含今天共 365 天），默认窗口
+         * - 今年（year == 当前自然年）：1月1日 ～ 今天
+         * - 往年：1月1日 ～ 12月31日（完整自然年）
+         * - 周视图：周日对齐，第一列为窗口首日所在周（可能含窗口前空位），
+         *   最后一列为结束日所在周（最近/今年=今天所在周；往年可能跨到次年 1 月初），
+         *   列数按窗口浮动（约 52~54 列），不丢数据
+         * - 三种视图的分位数均按所选窗口独立计算（颜色随窗口数据变化是预期行为）
+         *
+         * @param useUtc8 true=按 UTC+8 零点分桶（与全局图表设置一致），false=按 UTC 零点分桶
+         * @param year 目标自然年，或 [RECENT_YEAR] 表示最近 365 天
+         */
+        internal fun computeAllViews(records: List<UsageRecord>, useUtc8: Boolean = false, year: Int): AllViewsResult {
+            val zone = if (useUtc8) ZoneOffset.ofHours(8) else ZoneOffset.UTC
+            val now = System.currentTimeMillis()
+            val todayTs = startOfDayTs(now, zone)
+            val currentYear = Instant.ofEpochMilli(now).atOffset(zone).year
+            val isCurrentYear = year == currentYear
+            val isRecent = year == RECENT_YEAR
+
+            // 1. 窗口边界（该时区下的自然日零点）
+            val windowStartTs = if (isRecent) {
+                todayTs - 364 * DAY_MS
+            } else {
+                Instant.parse("${year}-01-01T00:00:00Z")
+                    .atOffset(zone).toLocalDate().atStartOfDay(zone).toInstant().toEpochMilli()
+            }
+            val windowEndTs = if (isRecent || isCurrentYear) {
+                todayTs
+            } else {
+                Instant.parse("${year}-12-31T00:00:00Z")
+                    .atOffset(zone).toLocalDate().atStartOfDay(zone).toInstant().toEpochMilli()
+            }
+            val totalDays = ((windowEndTs - windowStartTs) / DAY_MS).toInt() + 1
+
+            // 2. 按天分桶聚合 token 数（按所选时区的自然日零点切日）
+            val dayTokenMap = HashMap<Long, Long>()
+            for (r in records) {
+                val dayTs = startOfDayTs(r.timeCreated, zone)
+                if (dayTs < windowStartTs || dayTs > windowEndTs) continue
+                val tokens = r.inputTokens + r.cacheReadTokens + r.reasoningTokens + r.outputTokens
+                dayTokenMap.merge(dayTs, tokens, Long::plus)
+            }
+
+            // 3. 构建完整的每日数据列表（窗口首日 ～ 结束日）
+            val dailyRaw = ArrayList<HeatmapDayData>(totalDays)
+            for (i in 0 until totalDays) {
+                val ts = windowStartTs + i * DAY_MS
+                val tokens = dayTokenMap[ts] ?: 0L
+                dailyRaw.add(HeatmapDayData(dayTs = ts, tokens = tokens, level = 0))
+            }
+
+            // 4. 计算每日视图颜色等级
+            val dailyLevels = computeQuantileLevels(dailyRaw.map { it.tokens })
+            val dailyData = dailyRaw.map { it.copy(level = dailyLevels.getColorLevel(it.tokens)) }
+
+            // 5. 每周视图：周日对齐，第一列=窗口首日所在周，最后一列=结束日所在周
+            val firstWeekStart = startOfWeekTs(windowStartTs, zone)
+            val lastWeekStart = startOfWeekTs(windowEndTs, zone)
+            val (weeklyData, weeklyLevels) = buildWeeklyData(dailyRaw, firstWeekStart, lastWeekStart)
+
+            // 6. 累计视图：从窗口首日到结束日的累计总和
+            var cumulativeSum = 0L
+            val cumulativeRaw = ArrayList<HeatmapDayData>(totalDays)
+            for (d in dailyRaw) {
+                cumulativeSum += d.tokens
+                cumulativeRaw.add(HeatmapDayData(dayTs = d.dayTs, tokens = cumulativeSum, level = 0))
+            }
+            val cumulativeLevels = computeQuantileLevels(cumulativeRaw.map { it.tokens })
+            val cumulativeData = cumulativeRaw.map { it.copy(level = cumulativeLevels.getColorLevel(it.tokens)) }
+
+            // 保存三种视图各自的分位阈值，供切换视图时更新图例
+            return AllViewsResult(dailyData, weeklyData, cumulativeData, dailyLevels, weeklyLevels, cumulativeLevels)
+        }
+
+        /**
+         * 构建每周视图数据：周日对齐，从 firstWeekStart 到 lastWeekStart（含）每周一列。
+         *
+         * 每列聚合该周落在 [yearStartTs, yearEndTs] 范围内的天数（dailyRaw 只含年内天数，
+         * 首列跨前一年 12 月的部分、末列跨次年 1 月初的部分天然不计入），
+         * 周总量决定该列统一的热度等级；渲染层（HeatmapCanvas）按 barHeight
+         * 从底部向上绘制柱状图（0 用量周=1 格浅色，非零周=2~7 格）。
+         */
+        private fun buildWeeklyData(
+            dailyRaw: List<HeatmapDayData>,
+            firstWeekStart: Long,
+            lastWeekStart: Long,
+        ): Pair<List<HeatmapWeekData>, QuantileLevels> {
+            val numWeeks = ((lastWeekStart - firstWeekStart) / (7L * DAY_MS)).toInt() + 1
+            val weeks = ArrayList<HeatmapWeekData>(numWeeks)
+
+            for (w in 0 until numWeeks) {
+                val ws = firstWeekStart + w * 7L * DAY_MS
+                val we = ws + 7L * DAY_MS
+                var weekTokens = 0L
+                for (d in dailyRaw) {
+                    if (d.dayTs >= ws && d.dayTs < we) weekTokens += d.tokens
+                }
+                weeks.add(HeatmapWeekData(
+                    weekStartTs = ws,
+                    tokens = weekTokens,
+                    level = 0,
+                    barHeight = 1,
+                ))
+            }
+
+            // 颜色等级：6 级分位数（供颜色与图例使用）
+            val weekLevels = computeQuantileLevels(weeks.map { it.tokens })
+            // 柱高：非零周按 token 去重排序的排名比例映射 2~7 格（排名不同高度必不同），
+            // 0 用量周固定 1 格（Level 0 浅色，可见可点击）
+            val barHeights = computeBarHeights(weeks.map { it.tokens })
+            return weeks.mapIndexed { i, w ->
+                w.copy(level = weekLevels.getColorLevel(w.tokens), barHeight = barHeights[i])
+            } to weekLevels
+        }
+
+        /**
+         * 计算每周视图的柱状图高度（格数）。
+         *
+         * - 0 用量周：1 格（Level 0 浅色格，作为「空白周」的可见标记，不隐藏）
+         * - 非零周：按 token 值去重排序，排名比例映射到 2~7 格：
+         *   height = 2 + rankIndex * 5 / (uniqueCount - 1)（rankIndex 0-based）
+         *   唯一非零值只有 1 个时该周为 7 格（满柱）
+         *
+         * 用排名比例而非分位档，保证不同量级的周（如 3.7亿 vs 10.7亿）高度不同。
+         */
+        private fun computeBarHeights(tokens: List<Long>): IntArray {
+            val uniqueNonZero = tokens.filter { it > 0L }.distinct().sorted()
+            val n = uniqueNonZero.size
+            return IntArray(tokens.size) { i ->
+                val t = tokens[i]
+                when {
+                    t <= 0L -> 1
+                    n == 1 -> 7
+                    else -> 2 + uniqueNonZero.indexOf(t) * 5 / (n - 1)
+                }
+            }
+        }
+
+        /**
+         * 计算年度统计指标（基于所选年份的完整日序列，dailyRaw 含 0 token 的天）。
+         *
+         * - totalTokens：全部天之和
+         * - peakTokens：单日最大 token（当年无数据=0）
+         * - currentStreak：从最后一天往前数连续 >0 的天数；结尾为 0 的天（如当天尚未产生 token）跳过，
+         *   从最后一个非零天往前数（全部为 0 则=0）
+         * - maxStreak：当年内连续 >0 的最大天数
+         */
+        internal fun computeStats(dailyData: List<HeatmapDayData>): HeatmapStats {
+            var total = 0L
+            var peak = 0L
+            var maxStreak = 0
+            var run = 0
+            for (d in dailyData) {
+                total += d.tokens
+                if (d.tokens > peak) peak = d.tokens
+                if (d.tokens > 0L) run++ else run = 0
+                if (run > maxStreak) maxStreak = run
+            }
+            // 当前连续天数：最后一天即使为 0（当天尚未产生 token）也计入连续——跳过结尾的 0，
+            // 从最后一个非零天往前数连续 >0 的天数；全部为 0 时=0
+            var currentStreak = 0
+            var i = dailyData.size - 1
+            while (i >= 0 && dailyData[i].tokens == 0L) i--
+            while (i >= 0 && dailyData[i].tokens > 0L) {
+                currentStreak++
+                i--
+            }
+            return HeatmapStats(total, peak, currentStreak, maxStreak)
+        }
+
+        /**
+         * 计算活动洞察（基于全部历史记录，不随年份变化）。
+         *
+         * - totalRequests：总请求次数 = 记录条数（一条 UsageRecord 即一次请求）
+         * - topHours：请求最多的时段（按小时 0-23），降序取前 3；
+         *   并列时小时数小的优先；不足 3 个时列表较短；无数据时为空列表
+         *
+         * 小时按 useUtc8 对应的时区（UTC+8 / UTC）计算，与热力图分桶口径一致。
+         */
+        internal fun computeInsights(records: List<UsageRecord>, useUtc8: Boolean = false): HeatmapInsights {
+            if (records.isEmpty()) return HeatmapInsights()
+            val offsetMs = if (useUtc8) 8 * 3_600_000L else 0L
+            val hourCounts = IntArray(24)
+            for (r in records) {
+                // 纯算术取小时（避免逐条分配 Instant/OffsetDateTime）：
+                // (时间戳 + 时区偏移) 对一天取余 → 所在小时（ts 恒为正，无负数取模问题）
+                val hour = (((r.timeCreated + offsetMs) % 86_400_000L) / 3_600_000L).toInt()
+                hourCounts[hour]++
+            }
+            val topHours = hourCounts.indices
+                .sortedWith(compareByDescending<Int> { hourCounts[it] }.thenBy { it })
+                .filter { hourCounts[it] > 0 }
+                .take(3)
+            return HeatmapInsights(totalRequests = records.size, topHours = topHours)
+        }
+
+        /** 返回时间戳在指定时区下的自然日零点（epoch 毫秒） */
+        private fun startOfDayTs(ts: Long, zone: ZoneOffset): Long {
+            return Instant.ofEpochMilli(ts).atOffset(zone).toLocalDate().atStartOfDay(zone).toInstant().toEpochMilli()
+        }
+
+        /** 返回时间戳在指定时区下所在周的周日零点（0=Sunday） */
+        private fun startOfWeekTs(ts: Long, zone: ZoneOffset): Long {
+            val dow = dayOfWeekFromTs(ts, zone)
+            return startOfDayTs(ts, zone) - dow * DAY_MS
+        }
+
+        /** 时间戳在指定时区下的星期几 (0=Sunday, 6=Saturday) */
+        private fun dayOfWeekFromTs(ts: Long, zone: ZoneOffset): Int {
+            val dow = Instant.ofEpochMilli(ts).atOffset(zone).dayOfWeek.value
+            return dow % 7 // Sunday=7 → 0
+        }
+
+        // ── 分位数颜色等级计算 ──────────────────────────────
+
+        /**
+         * 使用 nearest-rank 分位数法计算 P25/P50/P75/P95 阈值。
+         *
+         * 边界情况：
+         * - 非零天数 < 2 → 全部设为 Level 3
+         * - 所有非零值相同 → 全部设为 Level 3
+         *
+         * 返回 [QuantileLevels]，内部 thresholds 为 LongArray(6)：
+         * index 0 = 0（Level 0），index 1-5 分别存 P25/P50/P75/P95/MaxValue。
+         */
+        internal fun computeQuantileLevels(values: List<Long>): QuantileLevels {
+            // 收集所有非零值
+            val nonZero = values.filter { it > 0L }
+
+            // 边界：非零值 < 2 或全部相同 → 全部设为 Level 3
+            if (nonZero.size < 2 || nonZero.toSet().size == 1) {
+                // thresholds[3] = Long.MAX_VALUE 使得 0 < value ≤ MAX → Level 3
+                val t = LongArray(6)
+                t[3] = Long.MAX_VALUE
+                return QuantileLevels(t)
+            }
+
+            val sorted = nonZero.sorted()
+            val n = sorted.size
+
+            val p25 = nearestRank(sorted, n, 0.25)
+            val p50 = nearestRank(sorted, n, 0.50)
+            val p75 = nearestRank(sorted, n, 0.75)
+            val p95 = nearestRank(sorted, n, 0.95)
+
+            // LongArray(6): [0, p25, p50, p75, p95, MaxValue]
+            val thresholds = LongArray(6)
+            thresholds[0] = 0L
+            thresholds[1] = p25
+            thresholds[2] = p50
+            thresholds[3] = p75
+            thresholds[4] = p95
+            thresholds[5] = Long.MAX_VALUE
+            return QuantileLevels(thresholds)
+        }
+
+        private fun nearestRank(sorted: List<Long>, n: Int, percentile: Double): Long {
+            val rank = (Math.ceil(n * percentile).toInt() - 1).coerceIn(0, n - 1)
+            return sorted[rank]
+        }
+    }
+}
+
+// ── 辅助类型 ──────────────────────────────────────────────
+
+/** computeAllViews 返回值 */
+internal data class AllViewsResult(
+    val dailyData: List<HeatmapDayData>,
+    val weeklyData: List<HeatmapWeekData>,
+    val cumulativeData: List<HeatmapDayData>,
+    val dailyLevels: QuantileLevels,
+    val weeklyLevels: QuantileLevels,
+    val cumulativeLevels: QuantileLevels,
+)

app/src/main/java/com/rainy/token/ui/servicedetail/ServiceDetailViewModel.kt

@@ -7,13 +7,21 @@ import com.rainy.token.data.cache.CachedBalance
 import com.rainy.token.data.debug.DebugLog
 import com.rainy.token.data.repository.CredentialRepository
 import com.rainy.token.data.repository.RepositoryError
+import com.rainy.token.data.repository.TraeRepository
+import com.rainy.token.data.repository.WorkBuddyRepository
 import com.rainy.token.data.repository.TriggerError
+import com.rainy.token.data.repository.TriggerErrorReason
 import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.model.CredentialStatus
 import com.rainy.token.domain.model.ServiceBalance
+import com.rainy.token.domain.model.Sub2DailyUsage
+import com.rainy.token.domain.model.TriggerSummary
+import com.rainy.token.R
 import com.rainy.token.domain.service.ServiceType
 import com.rainy.token.domain.usecase.RefreshBalanceUseCase
+import com.rainy.token.ui.components.UiText
 import dagger.hilt.android.lifecycle.HiltViewModel
+import java.time.LocalDate
 import javax.inject.Inject
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -26,10 +34,21 @@ import kotlinx.coroutines.launch
 class ServiceDetailViewModel @Inject constructor(
     private val credentialRepository: CredentialRepository,
     private val balanceCache: BalanceCache,
-    private val refreshBalanceUseCase: RefreshBalanceUseCase
+    private val refreshBalanceUseCase: RefreshBalanceUseCase,
+    private val checkinStatusStore: com.rainy.token.data.repository.CheckinStatusStore,
+    private val sub2ApiRepository: com.rainy.token.data.repository.Sub2ApiRepository
 ) : ViewModel() {
 
     private val _serviceType = MutableStateFlow<ServiceType?>(null)
+    val serviceType: StateFlow<ServiceType?> = _serviceType.asStateFlow()
+
+    /** 当前选中的账号 ID（多账号服务；null=默认账号，单账号服务恒为 null）。 */
+    private val _accountId = MutableStateFlow<String?>(null)
+
+    /** 多账号服务的账号列表（用于详情页账号切换）。 */
+    private val _accounts = MutableStateFlow<List<com.rainy.token.domain.model.ServiceAccountInfo>>(emptyList())
+    val accounts: StateFlow<List<com.rainy.token.domain.model.ServiceAccountInfo>> = _accounts.asStateFlow()
+
     private val _uiState = MutableStateFlow(ServiceDetailUiState())
     val uiState: StateFlow<ServiceDetailUiState> = _uiState.asStateFlow()
 
@@ -45,6 +64,298 @@ class ServiceDetailViewModel @Inject constructor(
     private val _modelsLoading = MutableStateFlow(false)
     val modelsLoading: StateFlow<Boolean> = _modelsLoading.asStateFlow()
 
+    /** 每日签到状态（WorkBuddy / Trae 详情页用）。 */
+    private val _checkinState = MutableStateFlow<CheckinState>(CheckinState.Idle)
+    val checkinState: StateFlow<CheckinState> = _checkinState.asStateFlow()
+
+    /**
+     * 进入详情页时预取的「今日签到信息」（WorkBuddy）。
+     * null=未知/未加载；用于展示「今日已签到（连签 N 天）」并禁用按钮，避免重复点击。
+     */
+    private val _checkinInfo = MutableStateFlow<CheckinInfo?>(null)
+    val checkinInfo: StateFlow<CheckinInfo?> = _checkinInfo.asStateFlow()
+
+    /** 今日签到信息摘要（仅字段已确认的才填）。 */
+    data class CheckinInfo(val todayCheckedIn: Boolean, val streakDays: Long)
+
+    /** 进入详情页时预取「今日签到信息」：WORKBUDDY 走状态接口；TRAE 本地记录 + status 接口。 */
+    private fun preloadCheckinInfo(service: ServiceType, accountId: String?) {
+        _checkinInfo.value = null
+        val generation = serviceGeneration
+        when (service) {
+            ServiceType.WORKBUDDY -> viewModelScope.launch {
+                // 走 RefreshBalanceUseCase 会话：状态查询也会触发 OAuth 轮换，需按快照校验提交
+                val status = refreshBalanceUseCase.fetchCheckinStatus(accountId).getOrNull() ?: return@launch
+                if (generation != serviceGeneration || _serviceType.value != service) return@launch
+                _checkinInfo.value = CheckinInfo(
+                    todayCheckedIn = status.todayCheckedIn,
+                    streakDays = status.streakDays
+                )
+            }
+            ServiceType.TRAE -> {
+                // 先看统一签到记录（零网络秒回），未命中再查服务端 status（跨设备已签也能识别）
+                if (checkinStatusStore.isCheckedToday(service, accountId)) {
+                    _checkinInfo.value = CheckinInfo(todayCheckedIn = true, streakDays = 0)
+                    return
+                }
+                viewModelScope.launch {
+                    val checked = refreshBalanceUseCase.fetchTraeCheckinStatus(accountId).getOrNull()
+                        ?: return@launch
+                    if (generation != serviceGeneration || _serviceType.value != service) return@launch
+                    if (checked) {
+                        checkinStatusStore.markChecked(service, accountId)
+                        _checkinInfo.value = CheckinInfo(todayCheckedIn = true, streakDays = 0)
+                    }
+                }
+            }
+            else -> Unit
+        }
+    }
+
+    /** 触发每日签到：仅 WORKBUDDY / TRAE 有效；结果按语义本地化（不直接显示 Repository 中文串）。 */
+    fun checkin() {
+        val service = _serviceType.value ?: return
+        val accountId = _accountId.value
+        if (service != ServiceType.WORKBUDDY && service != ServiceType.TRAE) return
+        if (_checkinState.value is CheckinState.Loading) return
+        _checkinState.value = CheckinState.Loading
+        val generation = serviceGeneration
+        viewModelScope.launch {
+            val result = when (service) {
+                ServiceType.WORKBUDDY -> refreshBalanceUseCase.checkInWorkBuddy(accountId).fold(
+                    onSuccess = { s ->
+                        when (s.outcome) {
+                            WorkBuddyRepository.CheckinOutcome.ALREADY ->
+                                // 已签时带上连签天数（接口已回传，别浪费）
+                                CheckinState.Done(
+                                    if (s.streakDays > 0) {
+                                        UiText.Resource(R.string.checkin_already_streak, listOf(s.streakDays))
+                                    } else {
+                                        UiText.Resource(R.string.checkin_already)
+                                    }
+                                )
+                            WorkBuddyRepository.CheckinOutcome.SUCCESS -> {
+                                val credits = s.todayCredit.takeIf { it > 0 } ?: s.dailyCredit
+                                CheckinState.Done(
+                                    if (credits > 0) {
+                                        UiText.Resource(R.string.checkin_wb_success_credits, listOf(credits))
+                                    } else {
+                                        UiText.Resource(R.string.checkin_success)
+                                    }
+                                )
+                            }
+                            WorkBuddyRepository.CheckinOutcome.FAILED ->
+                                // 失败原因优先透传服务端原文（多为官方中文提示），缺省用通用失败文案
+                                CheckinState.Error(
+                                    if (s.message.isNotBlank()) UiText.Dynamic(s.message)
+                                    else UiText.Resource(R.string.checkin_failed)
+                                )
+                            // QUERY 不该出现在签到动作结果里，兜底为通用成功
+                            WorkBuddyRepository.CheckinOutcome.QUERY ->
+                                CheckinState.Done(UiText.Resource(R.string.checkin_success))
+                        }
+                    },
+                    // RepositoryError.message 是硬编码中文，必须走 errorMessage() 本地化映射
+                    onFailure = { e -> CheckinState.Error(errorMessage(e)) }
+                )
+                ServiceType.TRAE -> refreshBalanceUseCase.checkInTrae(accountId).fold(
+                    onSuccess = { r ->
+                        when (r.outcome) {
+                            TraeRepository.CheckinOutcome.SUCCESS ->
+                                CheckinState.Done(UiText.Resource(R.string.checkin_success))
+                            TraeRepository.CheckinOutcome.ALREADY ->
+                                CheckinState.Done(UiText.Resource(R.string.checkin_already))
+                            // 设备级拦截不是「账号已签」：用 Notice 展示，按钮保持可点（用户可换网/稍后重试）
+                            TraeRepository.CheckinOutcome.DEVICE_BLOCKED ->
+                                CheckinState.Notice(UiText.Resource(R.string.checkin_trae_device_blocked))
+                            // 服务端临时限流（参与用户太多等）：提示而非错误，稍后可重试
+                            TraeRepository.CheckinOutcome.RETRYABLE ->
+                                CheckinState.Notice(
+                                    if (r.message.isNotBlank()) UiText.Dynamic(r.message)
+                                    else UiText.Resource(R.string.checkin_trae_retry_later)
+                                )
+                            TraeRepository.CheckinOutcome.INTL_UNSUPPORTED ->
+                                CheckinState.Error(
+                                    UiText.Resource(R.string.checkin_trae_intl),
+                                    showDeviceHint = false
+                                )
+                            TraeRepository.CheckinOutcome.FAILED -> CheckinState.Error(
+                                // 服务端原始原因优先；缺省用带 code 的失败文案
+                                if (r.message.isNotBlank()) {
+                                    UiText.Dynamic(r.message)
+                                } else if (r.code >= 0) {
+                                    UiText.Resource(R.string.checkin_trae_failed_code, listOf(r.code))
+                                } else {
+                                    UiText.Resource(R.string.checkin_failed)
+                                }
+                            )
+                        }
+                    },
+                    onFailure = { e -> CheckinState.Error(errorMessage(e)) }
+                )
+                else -> CheckinState.Error(UiText.Resource(R.string.checkin_unsupported))
+            }
+            if (generation == serviceGeneration) {
+                _checkinState.value = result
+                // 签到成功后刷新「今日已签到/连签」摘要，让按钮态即时更新
+                if (result is CheckinState.Done) preloadCheckinInfo(service, accountId)
+            }
+        }
+    }
+
+    // ---------- Sub2API 面板管理（Key 列表/新建/分组/兑换/低余额） ----------
+
+    /** Key 列表状态。 */
+    private val _panelKeysState = MutableStateFlow<PanelKeysState>(PanelKeysState.Idle)
+    val panelKeysState: StateFlow<PanelKeysState> = _panelKeysState.asStateFlow()
+
+    /** 管理操作的一次性结果消息（新建/切组/兑换/复制）。 */
+    private val _panelActionMessage = MutableStateFlow<String?>(null)
+    val panelActionMessage: StateFlow<String?> = _panelActionMessage.asStateFlow()
+
+    fun consumePanelActionMessage() { _panelActionMessage.value = null }
+
+    /** 可用分组（新建 Key / 切分组下拉）。 */
+    private val _panelGroups = MutableStateFlow<List<com.rainy.token.data.repository.Sub2ApiRepository.PanelGroup>>(emptyList())
+    val panelGroups: StateFlow<List<com.rainy.token.data.repository.Sub2ApiRepository.PanelGroup>> = _panelGroups.asStateFlow()
+
+    /** 按所选时间窗口拉取的分模型统计（「全部」窗口直接用明细里的全量 model_stats）。 */
+    private val _panelWindowStats = MutableStateFlow<PanelWindowStatsState>(PanelWindowStatsState.Idle)
+    val panelWindowStats: StateFlow<PanelWindowStatsState> = _panelWindowStats.asStateFlow()
+
+    /** 窗口统计请求代次：快速切换窗口时只接受最后一次请求的结果，避免旧窗口数据覆盖新窗口。 */
+    private var panelWindowStatsGeneration = 0
+
+    fun loadPanelWindowModelStats(from: LocalDate, to: LocalDate) {
+        val generation = ++panelWindowStatsGeneration
+        _panelWindowStats.value = PanelWindowStatsState.Loading
+        viewModelScope.launch {
+            val result = sub2ApiRepository.fetchWindowModelStats(from, to, _accountId.value)
+            // 过时结果（用户已切换到别的窗口）直接丢弃，不写状态
+            if (generation != panelWindowStatsGeneration) return@launch
+            result.fold(
+                onSuccess = { r -> _panelWindowStats.value = PanelWindowStatsState.Success(r.stats, r.allTime) },
+                onFailure = { e ->
+                    _panelWindowStats.value = PanelWindowStatsState.Error(e.message ?: "加载模型统计失败")
+                }
+            )
+        }
+    }
+
+    fun loadPanelGroups() {
+        viewModelScope.launch {
+            if (_panelGroups.value.isNotEmpty()) return@launch
+            sub2ApiRepository.fetchPanelGroups(_accountId.value).onSuccess { _panelGroups.value = it }
+        }
+    }
+
+    /** 「今天」按小时趋势（面板 snapshot-v2?granularity=hour）。 */
+    private val _hourlyTrend = MutableStateFlow<List<Sub2DailyUsage>>(emptyList())
+    val hourlyTrend: StateFlow<List<Sub2DailyUsage>> = _hourlyTrend.asStateFlow()
+
+    private var hourlyTrendGeneration = 0
+
+    fun loadHourlyTrend(date: LocalDate) {
+        val generation = ++hourlyTrendGeneration
+        viewModelScope.launch {
+            val result = sub2ApiRepository.fetchHourlyTrend(date, _accountId.value)
+            if (generation != hourlyTrendGeneration) return@launch
+            _hourlyTrend.value = result.getOrDefault(emptyList())
+        }
+    }
+
+    /** 「按 Key」用量状态（面板使用记录口径，按当前时间周期）。 */
+    private val _panelKeyStats = MutableStateFlow<PanelKeyStatsState>(PanelKeyStatsState.Idle)
+    val panelKeyStats: StateFlow<PanelKeyStatsState> = _panelKeyStats.asStateFlow()
+
+    private var panelKeyStatsGeneration = 0
+
+    /** 按所选周期拉取「按 Key」用量。 */
+    fun loadPanelKeyStats(from: LocalDate, to: LocalDate) {
+        val generation = ++panelKeyStatsGeneration
+        _panelKeyStats.value = PanelKeyStatsState.Loading
+        viewModelScope.launch {
+            val result = sub2ApiRepository.fetchKeyUsageStats(from, to, _accountId.value)
+            if (generation != panelKeyStatsGeneration) return@launch
+            result.fold(
+                onSuccess = { list ->
+                    _panelKeyStats.value = PanelKeyStatsState.Success(
+                        list.map {
+                            PanelKeyStatsState.KeyStat(
+                                keyId = it.keyId, name = it.name, groupName = it.groupName,
+                                requests = it.requests, totalTokens = it.totalTokens,
+                                cost = it.cost, unused = it.unused
+                            )
+                        }
+                    )
+                },
+                onFailure = { e -> _panelKeyStats.value = PanelKeyStatsState.Error(e.message ?: "加载按 Key 用量失败") }
+            )
+        }
+    }
+
+    /** 刷新面板 Key 列表（仅 SUB2API 且有面板 Token）。 */
+    fun loadPanelKeys() {
+        viewModelScope.launch {
+            if (_panelKeysState.value is PanelKeysState.Loading) return@launch
+            _panelKeysState.value = PanelKeysState.Loading
+            sub2ApiRepository.fetchPanelKeys(_accountId.value).fold(
+                onSuccess = { list -> _panelKeysState.value = PanelKeysState.Success(list) },
+                onFailure = { e -> _panelKeysState.value = PanelKeysState.Error(e.message ?: "加载 Key 列表失败") }
+            )
+        }
+    }
+
+    /** 最近一次新建成功的明文 Key（弹窗立即复制用；查看后清除）。 */
+    private val _recentlyCreatedKey = MutableStateFlow<String?>(null)
+    val recentlyCreatedKey: StateFlow<String?> = _recentlyCreatedKey.asStateFlow()
+
+    fun consumeRecentlyCreatedKey() { _recentlyCreatedKey.value = null }
+
+    fun createPanelKey(name: String, groupId: Long?) {
+        viewModelScope.launch {
+            sub2ApiRepository.createPanelKey(name, groupId, _accountId.value).fold(
+                onSuccess = { key ->
+                    _recentlyCreatedKey.value = key
+                    _panelActionMessage.value = "已创建 Key：" + maskPanelKey(key) + "（请在弹出的窗口复制完整 Key）"
+                    loadPanelKeys()
+                },
+                onFailure = { e -> _panelActionMessage.value = "创建失败：" + (e.message ?: "") }
+            )
+        }
+    }
+
+    fun switchPanelGroup(keyId: Long, groupId: Long) {
+        viewModelScope.launch {
+            sub2ApiRepository.updatePanelKey(keyId, groupId, accountId = _accountId.value).fold(
+                onSuccess = {
+                    _panelActionMessage.value = "分组已切换"
+                    loadPanelKeys()
+                },
+                onFailure = { e -> _panelActionMessage.value = "切换失败：" + (e.message ?: "") }
+            )
+        }
+    }
+
+    fun redeemPanelCode(code: String) {
+        viewModelScope.launch {
+            sub2ApiRepository.redeemPanelCode(code, _accountId.value).fold(
+                onSuccess = { msg ->
+                    _panelActionMessage.value = msg
+                    refreshBalanceUseCase(ServiceType.SUB2API, _accountId.value)
+                    loadPanelKeys()
+                },
+                onFailure = { e -> _panelActionMessage.value = "兑换失败：" + (e.message ?: "") }
+            )
+        }
+    }
+
+    /** 面板 API Key 展示用掩码：只留前 8 + 后 4 位，避免页面显示过长。 */
+    private fun maskPanelKey(key: String): String = when {
+        key.length <= 16 -> key
+        else -> key.take(8) + "…" + key.takeLast(4)
+    }
+
     /** 当前凭据的不可逆 SHA-256 指纹。 */
     private var currentCredentialFingerprint: String? = null
 
@@ -61,6 +372,9 @@ class ServiceDetailViewModel @Inject constructor(
         private const val OCGO_PREFS = "ocgo_trigger_prefs"
         private const val OLLAMA_PREFS = "ollama_trigger_prefs"
 
+        /** 缓存新鲜度阈值：fetchedAt 距今 ≤5 分钟视为最新数据，不再标记为"缓存"。 */
+        private const val CACHE_FRESH_THRESHOLD_MS = 5 * 60_000L
+
         internal fun credentialFingerprint(credential: Credential?): String? =
             CredentialRepository.credentialFingerprint(credential)
 
@@ -85,34 +399,55 @@ class ServiceDetailViewModel @Inject constructor(
         else -> CODEX_PREFS
     }
 
-    fun bind(service: ServiceType) {
-        if (_serviceType.value == service) return
+    fun bind(service: ServiceType, accountId: String? = null) {
+        val effectiveAccountId = accountId?.takeIf { it.isNotBlank() }
+        if (_serviceType.value == service && _accountId.value == effectiveAccountId) return
 
         serviceGeneration++
         refreshGeneration++
         _serviceType.value = service
+        _accountId.value = effectiveAccountId
+        _accounts.value = emptyList()
         currentCredentialFingerprint = null
         _models.value = emptyList()
         _selectedModel.value = null
         _modelsLoading.value = false
         _triggerState.value = TriggerState.Idle
+        // 切换服务/账号时重置签到状态，避免上一服务/账号的 Done/Error 残留（按钮态/文案串台）
+        _checkinState.value = CheckinState.Idle
 
         if (service == ServiceType.CODEX || service == ServiceType.OPENCODE_GO || service == ServiceType.OLLAMA) {
             loadSelectedModel(service)?.let { _selectedModel.value = it }
             loadModelsCache(service).takeIf { it.isNotEmpty() }?.let { _models.value = it }
         }
+        loadAccounts(service)
+        preloadCheckinInfo(service, effectiveAccountId)
         loadFromCache()
     }
 
+    /** 加载多账号服务的账号列表（账号管理页返回后可再次调用刷新）。 */
+    fun loadAccounts(service: ServiceType) {
+        val serviceGen = serviceGeneration
+        viewModelScope.launch {
+            val accounts = credentialRepository.accountsFor(service)
+            if (serviceGen == serviceGeneration && _serviceType.value == service) {
+                _accounts.value = accounts
+            }
+        }
+    }
+
     /**
      * 返回页面时同步凭据和缓存。凭据未变时保留错误/Loading，但按 fetchedAt 采用
      * Widget 或其他入口写入的更新缓存；凭据新增或替换时废弃旧状态并重新刷新。
      */
     fun reloadCredentialState() {
         val type = _serviceType.value ?: return
+        val accountId = _accountId.value
         val serviceGen = serviceGeneration
+        // 账号列表可能因账号管理页新增/删除/设默认而变化，一并刷新
+        loadAccounts(type)
         viewModelScope.launch {
-            val local = credentialRepository.readLocalState(type)
+            val local = credentialRepository.readLocalState(type, accountId)
             val newFingerprint = local.fingerprint
             val change = classifyCredentialChange(currentCredentialFingerprint, newFingerprint)
             val newHasCredential = local.status.state != CredentialStatus.State.NOT_CONFIGURED
@@ -150,7 +485,7 @@ class ServiceDetailViewModel @Inject constructor(
                             cached = local.cachedBalance,
                             state = State.Error(
                                 local.cachedBalance?.balance,
-                                "凭据未配置",
+                                UiText.Resource(R.string.error_credential_not_configured),
                                 RepositoryError.InvalidCredential()
                             )
                         )
@@ -162,10 +497,11 @@ class ServiceDetailViewModel @Inject constructor(
 
     fun refresh() {
         val type = _serviceType.value ?: return
+        val accountId = _accountId.value
         val serviceGen = serviceGeneration
         val gen = ++refreshGeneration
         viewModelScope.launch {
-            val requestFingerprint = credentialRepository.readLocalState(type).fingerprint
+            val requestFingerprint = credentialRepository.readLocalState(type, accountId).fingerprint
             if (isStaleRequest(type, serviceGen, gen)) return@launch
             _uiState.update { it.copy(state = State.Loading) }
 
@@ -186,10 +522,10 @@ class ServiceDetailViewModel @Inject constructor(
                 return@launch
             }
 
-            val result = refreshBalanceUseCase(type)
+            val result = refreshBalanceUseCase(type, accountId)
             if (isStaleRequest(type, serviceGen, gen)) return@launch
 
-            val local = credentialRepository.readLocalState(type)
+            val local = credentialRepository.readLocalState(type, accountId)
             if (isStaleRequest(type, serviceGen, gen)) return@launch
             val fingerprintChanged = local.fingerprint != requestFingerprint
 
@@ -303,7 +639,10 @@ class ServiceDetailViewModel @Inject constructor(
         val service = _serviceType.value ?: return
         val serviceGen = serviceGeneration
         val model = _selectedModel.value ?: run {
-            _triggerState.value = TriggerState.Error("请先选择模型", null)
+            _triggerState.value = TriggerState.Error(
+                UiText.Resource(R.string.error_select_model_first),
+                null
+            )
             return
         }
         viewModelScope.launch {
@@ -319,39 +658,49 @@ class ServiceDetailViewModel @Inject constructor(
             if (serviceGen != serviceGeneration || _serviceType.value != service) return@launch
 
             result
-                .onSuccess { responseBody ->
-                    _triggerState.value = TriggerState.Success(responseBody)
+                .onSuccess { summary ->
+                    _triggerState.value = TriggerState.Success(summary)
                     kotlinx.coroutines.delay(2000)
                     if (serviceGen == serviceGeneration && _serviceType.value == service) {
                         refresh()
                     }
                 }
                 .onFailure { error ->
-                    val message: String
+                    val message: UiText
                     val responseBody: String?
                     when (error) {
                         is TriggerError -> {
-                            message = error.summary
+                            // reason 结构化：token 刷新失败显示本地化文案（summary 中文提示只进日志）；
+                            // 其余（HTTP 错误）summary 为 ASCII 可直接展示
+                            message = if (error.reason == TriggerErrorReason.TOKEN_REFRESH) {
+                                UiText.Resource(R.string.error_token_refresh_generic)
+                            } else {
+                                UiText.Dynamic(error.summary)
+                            }
                             responseBody = error.responseBody.ifBlank { null }
                         }
 
                         is RepositoryError.InvalidCredential -> {
-                            message = error.message ?: "凭据无效，请重新登录"
+                            message = UiText.Resource(R.string.error_credential_invalid_relogin)
                             responseBody = null
                         }
 
                         is RepositoryError.CredentialChanged -> {
-                            message = "凭据已变更，请重新操作"
+                            message = UiText.Resource(R.string.error_credential_changed_retry)
                             responseBody = null
                         }
 
                         is RepositoryError.Network -> {
-                            message = "网络异常"
+                            message = UiText.Resource(R.string.error_network_generic)
                             responseBody = null
                         }
 
                         else -> {
-                            message = error.message ?: "未知错误"
+                            message = if ((error as? RepositoryError.Unknown)?.cause is IllegalArgumentException) {
+                                UiText.Resource(R.string.error_trigger_not_supported)
+                            } else {
+                                errorMessage(error)
+                            }
                             responseBody = null
                         }
                     }
@@ -366,6 +715,7 @@ class ServiceDetailViewModel @Inject constructor(
 
     fun saveManualBalance(amount: Double) {
         val type = _serviceType.value ?: return
+        val accountId = _accountId.value
         val serviceGen = serviceGeneration
         viewModelScope.launch {
             val config = com.rainy.token.domain.service.ServiceConfigProvider.get(type)
@@ -375,8 +725,8 @@ class ServiceDetailViewModel @Inject constructor(
                 unit = config.displayUnit,
                 isAvailable = true
             )
-            balanceCache.put(type, balance)
-            val cached = balanceCache.get(type)
+            balanceCache.put(type, balance, accountId)
+            val cached = balanceCache.get(type, accountId)
             if (serviceGen == serviceGeneration && _serviceType.value == type) {
                 _uiState.update {
                     it.copy(
@@ -390,8 +740,9 @@ class ServiceDetailViewModel @Inject constructor(
 
     fun markVerified() {
         val type = _serviceType.value ?: return
+        val accountId = _accountId.value
         viewModelScope.launch {
-            val credential = credentialRepository.get(type) ?: return@launch
+            val credential = credentialRepository.get(type, accountId) ?: return@launch
             val updated = when (credential) {
                 is Credential.ApiKeyCredential ->
                     credential.copy(lastVerifiedAt = System.currentTimeMillis())
@@ -399,17 +750,24 @@ class ServiceDetailViewModel @Inject constructor(
                     credential.copy(lastVerifiedAt = System.currentTimeMillis())
                 is Credential.CodexCredential ->
                     credential.copy(lastVerifiedAt = System.currentTimeMillis())
+                is Credential.TraeCredential ->
+                    credential.copy(lastVerifiedAt = System.currentTimeMillis())
+                is Credential.WorkBuddyCredential ->
+                    credential.copy(lastVerifiedAt = System.currentTimeMillis())
+                is Credential.Sub2ApiCredential ->
+                    credential.copy(lastVerifiedAt = System.currentTimeMillis())
             }
-            credentialRepository.save(updated)
+            credentialRepository.save(updated, accountId)
             loadFromCache()
         }
     }
 
     private fun loadFromCache() {
         val type = _serviceType.value ?: return
+        val accountId = _accountId.value
         val serviceGen = serviceGeneration
         viewModelScope.launch {
-            val local = credentialRepository.readLocalState(type)
+            val local = credentialRepository.readLocalState(type, accountId)
             val status = local.status
             val cached = local.cachedBalance
             val config = com.rainy.token.domain.service.ServiceConfigProvider.get(type)
@@ -418,13 +776,25 @@ class ServiceDetailViewModel @Inject constructor(
                 isManual && cached != null -> State.Stale(cached.balance, cached.fetchedAt)
                 isManual -> State.ManualModeHint
                 status.state == CredentialStatus.State.NOT_CONFIGURED ->
-                    State.Error(null, "凭据未配置", RepositoryError.InvalidCredential())
-                cached != null && status.state == CredentialStatus.State.OK ->
-                    State.Stale(cached.balance, cached.fetchedAt)
+                    State.Error(
+                        null,
+                        UiText.Resource(R.string.error_credential_not_configured),
+                        RepositoryError.InvalidCredential()
+                    )
+                // OK 与 WARNING 都视为「凭据可用」：WARNING 仅是提示建议重新验证（如面板登录较久），
+                // 凭据仍有效，不应误报为「未配置或已过期」——否则能正常刷新余额却显示错误。
+                cached != null && (status.state == CredentialStatus.State.OK ||
+                    status.state == CredentialStatus.State.WARNING) ->
+                    // 缓存新鲜（≤5 分钟）时视为最新数据直接展示，避免"刚刷新完进详情却显示缓存"的困惑
+                    if (isCacheFresh(cached.fetchedAt)) {
+                        State.Fresh(cached.balance)
+                    } else {
+                        State.Stale(cached.balance, cached.fetchedAt)
+                    }
                 cached != null ->
                     State.Error(
                         cached.balance,
-                        "凭据未配置或已过期",
+                        UiText.Resource(R.string.error_credential_not_configured_expired),
                         RepositoryError.InvalidCredential()
                     )
                 else -> State.Loading
@@ -439,7 +809,11 @@ class ServiceDetailViewModel @Inject constructor(
                     state = newState
                 )
             }
-            if (!isManual && status.state != CredentialStatus.State.NOT_CONFIGURED && cached == null) {
+            // 无缓存或缓存已过期（>5 分钟）时自动刷新一次；
+            // 缓存新鲜时直接展示，避免每次进详情页都发网络请求
+            if (!isManual && status.state != CredentialStatus.State.NOT_CONFIGURED &&
+                (cached == null || !isCacheFresh(cached.fetchedAt))
+            ) {
                 refresh()
             }
         }
@@ -455,7 +829,7 @@ class ServiceDetailViewModel @Inject constructor(
         val mergedState: State = when {
             !hasCredential -> State.Error(
                 mergedCache?.balance,
-                "凭据未配置",
+                UiText.Resource(R.string.error_credential_not_configured),
                 RepositoryError.InvalidCredential()
             )
             current.state is State.Loading -> current.state
@@ -465,10 +839,19 @@ class ServiceDetailViewModel @Inject constructor(
             cacheAdvanced && current.state is State.Fresh ->
                 State.Fresh(mergedCache!!.balance)
             cacheAdvanced && current.state is State.Stale ->
-                State.Stale(mergedCache!!.balance, mergedCache.fetchedAt)
+                if (isCacheFresh(mergedCache!!.fetchedAt)) {
+                    State.Fresh(mergedCache.balance)
+                } else {
+                    State.Stale(mergedCache.balance, mergedCache.fetchedAt)
+                }
             current.state is State.Fresh -> current.state
             current.state is State.Stale -> current.state
-            mergedCache != null -> State.Stale(mergedCache.balance, mergedCache.fetchedAt)
+            mergedCache != null ->
+                if (isCacheFresh(mergedCache.fetchedAt)) {
+                    State.Fresh(mergedCache.balance)
+                } else {
+                    State.Stale(mergedCache.balance, mergedCache.fetchedAt)
+                }
             else -> current.state
         }
         return current.copy(
@@ -493,20 +876,45 @@ class ServiceDetailViewModel @Inject constructor(
         current: CachedBalance?
     ): Boolean = candidate != null && (current == null || candidate.fetchedAt > current.fetchedAt)
 
+    /** 缓存是否仍算"最新"：fetchedAt 距今 ≤5 分钟（与 Dashboard 底部"刚刚更新"感知一致）。 */
+    private fun isCacheFresh(fetchedAt: Long): Boolean =
+        System.currentTimeMillis() - fetchedAt <= CACHE_FRESH_THRESHOLD_MS
+
     private fun isStaleRequest(type: ServiceType, serviceGen: Int, refreshGen: Int): Boolean =
         refreshGen != refreshGeneration ||
             serviceGen != serviceGeneration ||
             _serviceType.value != type
 
-    private fun errorMessage(error: Throwable): String = when (error) {
-        is RepositoryError.InvalidCredential -> "凭据无效，请在设置中重新配置"
-        is RepositoryError.CredentialChanged -> "凭据已变更，正在重新加载"
-        is RepositoryError.RateLimited ->
-            "请求过于频繁${error.retryAfterSeconds?.let { "，请 ${it} 秒后重试" } ?: ""}"
-        is RepositoryError.Network -> "网络异常，请检查网络"
-        is RepositoryError.ServerError -> "服务端异常 (HTTP ${error.code})"
-        is RepositoryError.ParseError -> "数据解析失败: ${error.message}"
-        else -> error.message ?: "未知错误"
+    private fun errorMessage(error: Throwable): UiText = when (error) {
+        is RepositoryError.SessionExpired ->
+            UiText.Resource(R.string.error_credential_session_expired)
+        is RepositoryError.InvalidCredential ->
+            UiText.Resource(R.string.error_credential_invalid_reconfigure)
+        is RepositoryError.CredentialChanged ->
+            UiText.Resource(R.string.error_credential_changed_reload)
+        is RepositoryError.RateLimited -> UiText.Resource(
+            R.string.error_rate_limited_retry,
+            listOf(
+                error.retryAfterSeconds?.let {
+                    UiText.Resource(R.string.error_rate_limited_retry_suffix, listOf(it))
+                } ?: ""
+            )
+        )
+        is RepositoryError.Network -> UiText.Resource(R.string.error_network_check)
+        is RepositoryError.ServerError ->
+            UiText.Resource(R.string.error_server_http, listOf(error.code))
+        is RepositoryError.ParseError -> when (error.reason) {
+            RepositoryError.ParseErrorReason.EMPTY_BODY -> UiText.Resource(R.string.error_parse_empty_body)
+            RepositoryError.ParseErrorReason.NOT_JSON_OBJECT -> UiText.Resource(R.string.error_parse_not_json)
+            RepositoryError.ParseErrorReason.NO_WINDOWS -> UiText.Resource(R.string.error_parse_no_windows)
+            RepositoryError.ParseErrorReason.NO_MODELS -> UiText.Resource(R.string.error_parse_no_models)
+            RepositoryError.ParseErrorReason.MODELS_EMPTY -> UiText.Resource(R.string.error_parse_models_empty)
+            RepositoryError.ParseErrorReason.MALFORMED_RESPONSE -> UiText.Resource(R.string.error_parse_malformed)
+        }
+        // Unknown 的 message 以硬编码中文"未知错误"开头，不能透传 UI，统一映射本地化文案
+        is RepositoryError.Unknown -> UiText.Resource(R.string.common_unknown)
+        else -> error.message?.let { UiText.Dynamic(it) }
+            ?: UiText.Resource(R.string.common_unknown)
     }
 
     private fun prefs(service: ServiceType): android.content.SharedPreferences =
@@ -533,13 +941,65 @@ class ServiceDetailViewModel @Inject constructor(
             ?: emptyList()
 }
 
+/** 每日签到 UI 状态。 */
+/** 每日签到 UI 状态。消息用 [UiText] 承载，由 UI 层按当前 Locale 解析（支持多语言）。 */
+sealed class CheckinState {
+    data object Idle : CheckinState()
+    data object Loading : CheckinState()
+    data class Done(val message: UiText) : CheckinState()
+
+    /**
+     * @param showDeviceHint INTL 区接口不支持与设备无关，false 时不追加「设备 ID 获取路径」提示。
+     */
+    data class Error(val message: UiText, val showDeviceHint: Boolean = true) : CheckinState()
+
+    /**
+     * 提示态（非错误、也非完成）：例如 Trae 设备级拦截「该设备今日签到次数已达上限」。
+     * 与 [Done] 的区别是**不置灰按钮**——账号本身尚未签到，换网络/稍后可重试。
+     */
+    data class Notice(val message: UiText) : CheckinState()
+}
+
+/** Sub2API 面板 Key 列表状态。 */
+sealed class PanelKeysState {
+    data object Idle : PanelKeysState()
+    data object Loading : PanelKeysState()
+    data class Success(val keys: List<com.rainy.token.data.repository.Sub2ApiRepository.PanelApiKey>) : PanelKeysState()
+    data class Error(val message: String) : PanelKeysState()
+}
+
+/** Sub2API 按所选时间窗口拉取的分模型统计状态。 */
+sealed class PanelWindowStatsState {
+    data object Idle : PanelWindowStatsState()
+    data object Loading : PanelWindowStatsState()
+    /** @param allTime 数据为历史累计口径（下游接口无法按窗口过滤），UI 需显式标注 */
+    data class Success(
+        val stats: List<com.rainy.token.domain.model.Sub2ModelStat>,
+        val allTime: Boolean = false
+    ) : PanelWindowStatsState()
+    data class Error(val message: String) : PanelWindowStatsState()
+}
+
+/** Sub2API「按 Key」用量状态（按当前时间周期查询面板使用记录）。 */
+sealed class PanelKeyStatsState {
+    data object Idle : PanelKeyStatsState()
+    data object Loading : PanelKeyStatsState()
+    data class Success(val stats: List<KeyStat>) : PanelKeyStatsState()
+    data class Error(val message: String) : PanelKeyStatsState()
+
+    data class KeyStat(
+        val keyId: Long, val name: String, val groupName: String?,
+        val requests: Long, val totalTokens: Long, val cost: Double, val unused: Boolean
+    )
+}
+
 sealed class State {
     data object Loading : State()
     data class Fresh(val data: ServiceBalance) : State()
     data class Stale(val data: ServiceBalance, val lastFetchedAt: Long) : State()
     data class Error(
         val cached: ServiceBalance?,
-        val message: String,
+        val message: UiText,
         val error: Throwable
     ) : State()
     data object ManualModeHint : State()
@@ -554,6 +1014,6 @@ data class ServiceDetailUiState(
 sealed class TriggerState {
     data object Idle : TriggerState()
     data object Loading : TriggerState()
-    data class Success(val responseBody: String) : TriggerState()
-    data class Error(val message: String, val responseBody: String?) : TriggerState()
+    data class Success(val summary: TriggerSummary) : TriggerState()
+    data class Error(val message: UiText, val responseBody: String?) : TriggerState()
 }

app/src/main/java/com/rainy/token/ui/servicedetail/Sub2ApiPanelManagement.kt

@@ -0,0 +1,503 @@
+package com.rainy.token.ui.servicedetail
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.widget.Toast
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.selection.SelectionContainer
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.rainy.token.R
+import com.rainy.token.data.repository.Sub2ApiRepository
+import com.rainy.token.domain.model.ServiceBalance
+import com.rainy.token.ui.theme.inkMuted
+import java.util.Locale
+
+/**
+ * Sub2API 面板管理卡：Key 列表 / 新建 / 分组 / 兑换 / 低余额提醒。
+ *
+ * 首页 Sub2API 卡片与 Sub2API 详情页共用（有面板 Token 时才能加载；
+ * API Key 模式只读余额，进入后提示先登录面板）。
+ *
+ * 交互细节：
+ *  - Key 列表只展示掩码（sk-…后缀），完整 Key 通过「复制」按钮复制并 Toast 反馈；
+ *  - 新建 Key 成功后弹窗展示完整 Key，避免把明文直接铺在长消息里；
+ *  - 兑换/切换分组等操作结果以 Toast + 行内文案双重反馈。
+ */
+@Composable
+internal fun Sub2ApiPanelManagement(
+    balance: ServiceBalance?,
+    keysState: PanelKeysState,
+    groups: List<Sub2ApiRepository.PanelGroup>,
+    actionMessage: String?,
+    createdKey: String? = null,
+    onLoadKeys: () -> Unit,
+    onLoadGroups: () -> Unit,
+    onCreateKey: (String, Long?) -> Unit,
+    onSwitchGroup: (Long, Long) -> Unit,
+    onDeleteKey: (Long) -> Unit,
+    onRedeem: (String) -> Unit,
+    onConsumeMessage: () -> Unit,
+    onConsumeCreatedKey: () -> Unit = {},
+    /** 弹窗场景由 AlertDialog 的 title 槽展示标题，可关闭内部标题避免重复 */
+    showHeader: Boolean = true
+) {
+    val context = LocalContext.current
+    var showCreate by remember { mutableStateOf(false) }
+    var showRedeem by remember { mutableStateOf(false) }
+    var switchForKeyId by remember { mutableStateOf<Long?>(null) }
+    // 待删除的 Key：先弹确认框（删除不可逆，避免列表里误触）
+    var deleteForKeyId by remember { mutableStateOf<Long?>(null) }
+
+    val groupMap = remember(groups) { groups.associateBy { it.id } }
+    val copiedToast = stringResource(R.string.sub2_panel_copied)
+
+    // 进入卡片即自动拉取一次 Key 列表与分组（Idle 态），省掉一次手动点击
+    LaunchedEffect(Unit) {
+        if (keysState is PanelKeysState.Idle) {
+            onLoadKeys()
+            onLoadGroups()
+        }
+    }
+
+    // 最近一次操作结果：用于行内保留展示（Toast 消费后消息会被置空，这里留一份快照）
+    var lastResult by remember { mutableStateOf<String?>(null) }
+
+    // 操作结果（新建/兑换/切组）用 Toast 提醒：避免结果消息藏在长页面里看不见。
+    // 消费后再置空，保证下一次「同样的结果」（如连续两次切换分组成功）仍能再次提示。
+    LaunchedEffect(actionMessage) {
+        val msg = actionMessage ?: return@LaunchedEffect
+        lastResult = msg
+        Toast.makeText(context, msg, Toast.LENGTH_LONG).show()
+        onConsumeMessage()
+    }
+
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.4f))
+    ) {
+        Column(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
+            if (showHeader) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    Text(
+                        text = stringResource(R.string.sub2_panel_manage_title),
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.Bold
+                    )
+                    Spacer(modifier = Modifier.weight(1f))
+                    IconButton(onClick = { onLoadKeys(); onLoadGroups() }) {
+                        Icon(Icons.Filled.Refresh, contentDescription = stringResource(R.string.action_refresh))
+                    }
+                }
+            }
+            // showHeader=false 时不渲染任何标题/刷新行：
+            // 弹窗场景由调用方把标题与刷新按钮放在同一行（见 DashboardScreen 的 title 槽），
+            // 这里再放一行会让刷新按钮掉到标题下面，视觉上多出一条空行。
+
+            (actionMessage ?: lastResult)?.let { msg ->
+                Spacer(modifier = Modifier.height(8.dp))
+                Text(
+                    text = msg.take(160) + if (msg.length > 160) "…" else "",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = if (msg.startsWith("已创建") || msg.startsWith("分组已") || msg.startsWith("兑换成功"))
+                        MaterialTheme.colorScheme.primary
+                    else
+                        MaterialTheme.colorScheme.error
+                )
+            }
+
+            val amount = balance?.amount ?: 0.0
+            if (amount > 0.0 && amount < 5.0) {
+                Spacer(modifier = Modifier.height(10.dp))
+                Text(
+                    text = stringResource(
+                        R.string.sub2_panel_low_balance,
+                        String.format(Locale.getDefault(), "%.2f", amount)
+                    ),
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.error,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .clip(RoundedCornerShape(10.dp))
+                        .background(MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.35f))
+                        .padding(horizontal = 10.dp, vertical = 8.dp)
+                )
+            }
+
+            Spacer(modifier = Modifier.height(12.dp))
+
+            // 主要操作（新建 Key / 兑换卡密）固定在列表上方：
+            // Key 数量多时列表很长，放在底部会被埋在滚动区尽头，不易发现。
+            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                Button(onClick = { onLoadGroups(); showCreate = true }, modifier = Modifier.weight(1f)) {
+                    Text(stringResource(R.string.sub2_panel_create))
+                }
+                OutlinedButton(onClick = { showRedeem = true }, modifier = Modifier.weight(1f)) {
+                    Text(stringResource(R.string.sub2_panel_redeem))
+                }
+            }
+
+            Spacer(modifier = Modifier.height(12.dp))
+
+            Text(
+                text = stringResource(R.string.sub2_panel_keys_header),
+                style = MaterialTheme.typography.labelLarge,
+                color = inkMuted()
+            )
+            Spacer(modifier = Modifier.height(4.dp))
+
+            when (keysState) {
+                is PanelKeysState.Idle -> {
+                    OutlinedButton(onClick = onLoadKeys, modifier = Modifier.fillMaxWidth()) {
+                        Text(stringResource(R.string.sub2_panel_load_keys))
+                    }
+                }
+                is PanelKeysState.Loading -> {
+                    Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.padding(vertical = 8.dp)) {
+                        CircularProgressIndicator(modifier = Modifier.size(18.dp), strokeWidth = 2.dp)
+                        Spacer(modifier = Modifier.width(8.dp))
+                        Text(stringResource(R.string.common_loading), style = MaterialTheme.typography.bodySmall, color = inkMuted())
+                    }
+                }
+                is PanelKeysState.Error -> {
+                    Column {
+                        Text(keysState.message, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.error)
+                        TextButton(onClick = onLoadKeys) { Text(stringResource(R.string.action_retry)) }
+                    }
+                }
+                is PanelKeysState.Success -> {
+                    if (keysState.keys.isEmpty()) {
+                        Text(stringResource(R.string.sub2_panel_no_keys), style = MaterialTheme.typography.bodySmall, color = inkMuted())
+                    } else {
+                        keysState.keys.forEach { key ->
+                            Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp)) {
+                                Column(modifier = Modifier.weight(1f)) {
+                                    Text(
+                                        text = stringResource(R.string.sub2_panel_key_id, key.name, key.id),
+                                        style = MaterialTheme.typography.bodyMedium,
+                                        fontWeight = FontWeight.SemiBold,
+                                        maxLines = 1,
+                                        overflow = TextOverflow.Ellipsis
+                                    )
+                                    // API Key 只显示掩码，避免页面展示过长明文
+                                    Text(
+                                        text = buildString {
+                                            append(maskKey(key.key))
+                                            append(" · ")
+                                            append(
+                                                key.groupId?.let { groupMap[it]?.name }
+                                                    ?: stringResource(R.string.sub2_panel_default_group)
+                                            )
+                                            append(" · ")
+                                            append(key.status)
+                                            append(" · ")
+                                            append(
+                                                key.lastUsedAt?.let { stringResource(R.string.sub2_panel_last_used, it.take(10)) }
+                                                    ?: stringResource(R.string.sub2_panel_never_used)
+                                            )
+                                        },
+                                        style = MaterialTheme.typography.labelSmall,
+                                        color = inkMuted(),
+                                        maxLines = 1,
+                                        overflow = TextOverflow.Ellipsis
+                                    )
+                                }
+                                // 三个操作紧凑排布（用户反馈「间隔有点宽」）。
+                                // 注意：Material3 的 TextButton 会把 58dp 最小宽度与内边距加在
+                                // 其内层节点上，外层传 defaultMinSize(0)/contentPadding(0) 压不下去
+                                //（实测按钮可点区仍有 232px），所以这里直接用可点击 Text。
+                                Row(
+                                    verticalAlignment = Alignment.CenterVertically,
+                                    horizontalArrangement = Arrangement.spacedBy(10.dp)
+                                ) {
+                                    Text(
+                                        text = stringResource(R.string.action_copy),
+                                        style = MaterialTheme.typography.labelSmall,
+                                        color = MaterialTheme.colorScheme.primary,
+                                        modifier = Modifier
+                                            .clip(RoundedCornerShape(4.dp))
+                                            .clickable { copyToClipboard(context, key.key, copiedToast) }
+                                            .padding(horizontal = 2.dp, vertical = 4.dp)
+                                    )
+                                    if (groups.isNotEmpty()) {
+                                        Text(
+                                            text = stringResource(R.string.sub2_panel_group_column),
+                                            style = MaterialTheme.typography.labelSmall,
+                                            color = MaterialTheme.colorScheme.primary,
+                                            modifier = Modifier
+                                                .clip(RoundedCornerShape(4.dp))
+                                                .clickable { switchForKeyId = key.id }
+                                                .padding(horizontal = 2.dp, vertical = 4.dp)
+                                        )
+                                    }
+                                    // 删除：用图标而非文字，避免一行挤下三个按钮在窄屏折行
+                                    Icon(
+                                        imageVector = Icons.Filled.Delete,
+                                        contentDescription = stringResource(R.string.action_delete),
+                                        tint = MaterialTheme.colorScheme.error,
+                                        modifier = Modifier
+                                            .clip(RoundedCornerShape(4.dp))
+                                            .clickable { deleteForKeyId = key.id }
+                                            .padding(2.dp)
+                                            .size(18.dp)
+                                    )
+                                }
+                            }
+                            HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.4f))
+                        }
+                    }
+                }
+            }
+
+        }
+    }
+
+    // 删除确认弹窗：删除不可逆，二次确认后才发请求
+    deleteForKeyId?.let { keyId ->
+        val targetName = (keysState as? PanelKeysState.Success)
+            ?.keys?.firstOrNull { it.id == keyId }?.name
+        AlertDialog(
+            onDismissRequest = { deleteForKeyId = null },
+            title = { Text(stringResource(R.string.sub2_panel_delete_confirm_title), fontWeight = FontWeight.Bold) },
+            text = {
+                Text(
+                    stringResource(
+                        R.string.sub2_panel_delete_confirm_body,
+                        targetName ?: ("#" + keyId)
+                    )
+                )
+            },
+            confirmButton = {
+                Button(
+                    onClick = {
+                        onDeleteKey(keyId)
+                        deleteForKeyId = null
+                    },
+                    colors = ButtonDefaults.buttonColors(
+                        containerColor = MaterialTheme.colorScheme.error,
+                        contentColor = MaterialTheme.colorScheme.onError
+                    )
+                ) { Text(stringResource(R.string.action_delete)) }
+            },
+            dismissButton = {
+                TextButton(onClick = { deleteForKeyId = null }) { Text(stringResource(R.string.action_cancel)) }
+            }
+        )
+    }
+
+    // 新建 Key 弹窗
+    if (showCreate) {
+        var name by remember { mutableStateOf("") }
+        var groupId by remember { mutableStateOf<Long?>(null) }
+        AlertDialog(
+            onDismissRequest = { showCreate = false },
+            title = { Text(stringResource(R.string.sub2_panel_create_title), fontWeight = FontWeight.Bold) },
+            text = {
+                Column {
+                    OutlinedTextField(
+                        value = name,
+                        onValueChange = { name = it },
+                        label = { Text(stringResource(R.string.sub2_panel_key_name)) },
+                        singleLine = true,
+                        modifier = Modifier.fillMaxWidth()
+                    )
+                    Spacer(modifier = Modifier.height(10.dp))
+                    Text(
+                        text = stringResource(R.string.sub2_panel_group_optional),
+                        style = MaterialTheme.typography.labelMedium,
+                        color = inkMuted()
+                    )
+                    Spacer(modifier = Modifier.height(2.dp))
+                    if (groups.isEmpty()) {
+                        Text(
+                            text = stringResource(R.string.sub2_panel_no_groups),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = inkMuted()
+                        )
+                    } else {
+                        groups.forEach { g ->
+                            Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
+                                Text(
+                                    text = g.name + (if (g.rateMultiplier != 1.0) "（x" + String.format(Locale.getDefault(), "%.2f", g.rateMultiplier) + "）" else ""),
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = if (groupId == g.id) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurface,
+                                    modifier = Modifier.weight(1f)
+                                )
+                                TextButton(onClick = { groupId = if (groupId == g.id) null else g.id }) {
+                                    Text(
+                                        text = if (groupId == g.id) stringResource(R.string.action_cancel) else stringResource(R.string.sub2_panel_group_column),
+                                        style = MaterialTheme.typography.labelSmall
+                                    )
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            confirmButton = {
+                Button(
+                    onClick = { onCreateKey(name.trim(), groupId); showCreate = false },
+                    enabled = name.isNotBlank()
+                ) { Text(stringResource(R.string.sub2_panel_create)) }
+            },
+            dismissButton = {
+                TextButton(onClick = { showCreate = false }) { Text(stringResource(R.string.action_cancel)) }
+            }
+        )
+    }
+
+    // 新建成功：弹窗展示完整 Key，方便一次性复制（避免明文铺在长消息里）
+    createdKey?.let { key ->
+        AlertDialog(
+            onDismissRequest = onConsumeCreatedKey,
+            title = { Text(stringResource(R.string.sub2_panel_create_success_title), fontWeight = FontWeight.Bold) },
+            text = {
+                Column {
+                    Text(
+                        text = stringResource(R.string.sub2_panel_create_success_hint),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = inkMuted()
+                    )
+                    Spacer(modifier = Modifier.height(8.dp))
+                    SelectionContainer {
+                        Text(
+                            text = key,
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurface,
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .clip(RoundedCornerShape(8.dp))
+                                .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f))
+                                .padding(10.dp)
+                        )
+                    }
+                }
+            },
+            confirmButton = {
+                Button(onClick = { copyToClipboard(context, key, copiedToast); onConsumeCreatedKey() }) {
+                    Text(stringResource(R.string.sub2_panel_copy_and_close))
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = onConsumeCreatedKey) { Text(stringResource(R.string.action_close)) }
+            }
+        )
+    }
+
+    // 兑换弹窗
+    if (showRedeem) {
+        var code by remember { mutableStateOf("") }
+        AlertDialog(
+            onDismissRequest = { showRedeem = false },
+            title = { Text(stringResource(R.string.sub2_panel_redeem), fontWeight = FontWeight.Bold) },
+            text = {
+                OutlinedTextField(
+                    value = code,
+                    onValueChange = { code = it },
+                    label = { Text(stringResource(R.string.sub2_panel_redeem_code_label)) },
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth()
+                )
+            },
+            confirmButton = {
+                Button(
+                    onClick = { onRedeem(code.trim()); showRedeem = false },
+                    enabled = code.isNotBlank() && code.length >= 6
+                ) { Text(stringResource(R.string.sub2_panel_redeem)) }
+            },
+            dismissButton = {
+                TextButton(onClick = { showRedeem = false }) { Text(stringResource(R.string.action_cancel)) }
+            }
+        )
+    }
+
+    // 切换分组弹窗
+    switchForKeyId?.let { keyId ->
+        AlertDialog(
+            onDismissRequest = { switchForKeyId = null },
+            title = { Text(stringResource(R.string.sub2_panel_switch_group), fontWeight = FontWeight.Bold) },
+            text = {
+                Column {
+                    if (groups.isEmpty()) {
+                        Text(
+                            text = stringResource(R.string.sub2_panel_no_groups),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = inkMuted()
+                        )
+                    } else {
+                        groups.forEach { g ->
+                            TextButton(onClick = { onSwitchGroup(keyId, g.id); switchForKeyId = null }) {
+                                Text(
+                                    text = g.name + (if (g.rateMultiplier != 1.0) "（x" + String.format(Locale.getDefault(), "%.2f", g.rateMultiplier) + "）" else ""),
+                                    color = MaterialTheme.colorScheme.onSurface
+                                )
+                            }
+                        }
+                    }
+                }
+            },
+            confirmButton = {},
+            dismissButton = {
+                TextButton(onClick = { switchForKeyId = null }) { Text(stringResource(R.string.action_cancel)) }
+            }
+        )
+    }
+}
+
+/**
+ * API Key 展示掩码：与面板网页保持一致的观感（sk-xxxx...yyyy）。
+ * 列表接口虽然返回完整 key（实测 67 字符），但页面上不该铺满明文，
+ * 复制按钮复制的仍是完整值（见 copyToClipboard(context, key.key, …)）。
+ */
+private fun maskKey(key: String): String = when {
+    key.length <= 12 -> key
+    else -> key.take(7) + "..." + key.takeLast(4)
+}
+
+/** 复制到剪贴板并 Toast 反馈（用户感知「复制按钮」有效）。 */
+private fun copyToClipboard(context: Context, text: String, toast: String) {
+    val cm = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+    cm.setPrimaryClip(ClipData.newPlainText("API Key", text))
+    Toast.makeText(context, toast, Toast.LENGTH_SHORT).show()
+}

app/src/main/java/com/rainy/token/ui/servicedetail/Sub2ApiUsageCard.kt

@@ -0,0 +1,713 @@
+package com.rainy.token.ui.servicedetail
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.defaultMinSize
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.FilterChipDefaults
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.rainy.token.R
+import com.rainy.token.domain.model.Sub2DailyUsage
+import com.rainy.token.domain.model.Sub2ModelStat
+import com.rainy.token.domain.model.Sub2UsageDetail
+import com.rainy.token.ui.theme.inkMuted
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+
+/**
+ * Sub2API 用量明细卡（替代原来的 GenericExtrasCard）。
+ *
+ * 数据来自 [Sub2UsageDetail]（网关 /v1/usage 的 model_stats + daily_usage）。
+ * 提供：
+ * 1. 时间窗口筛选（今天 / 近7天 / 近30天 / 近90天 / 全部）——按日期对 daily_usage 切片；
+ * 2. 模型筛选（全部 / 指定模型）——选中模型或切换时间窗口时，分模型统计按所选周期
+ *    重新向网关拉取（model_stats 受 start_date/end_date 控制），不再只显示全时间累计；
+ * 3. 窗口内汇总（请求数 / Tokens / 花费）+ 每日花费柱状图（高度封顶）+ 每日明细列表。
+ *
+ * @param windowStatsState 非「全部」窗口下的分模型统计异步状态（由 ViewModel 拉取）。
+ * @param onLoadWindowModelStats 按窗口日期范围拉取分模型统计的回调；null 时跳过（旧用法）。
+ *
+ * 兼容：detail 为空（旧缓存/网关未返回明细）时回退到 [GenericExtrasCard]。
+ */
+@Composable
+internal fun Sub2ApiUsageCard(
+    state: State,
+    windowStatsState: PanelWindowStatsState = PanelWindowStatsState.Idle,
+    onLoadWindowModelStats: ((from: LocalDate, to: LocalDate) -> Unit)? = null,
+    /** 「今天」窗口的按小时趋势；非空时用小时柱替代按天柱（按天只有一根柱没有信息量）。 */
+    hourlyTrend: List<Sub2DailyUsage> = emptyList(),
+    onLoadHourlyTrend: ((LocalDate) -> Unit)? = null,
+    /** 「按 Key」tab 的数据状态（按当前时间周期查询面板使用记录）。 */
+    keyStatsState: PanelKeyStatsState = PanelKeyStatsState.Idle,
+    onLoadKeyStats: ((from: LocalDate, to: LocalDate) -> Unit)? = null
+) {
+    val balance = when (state) {
+        is State.Fresh -> state.data
+        is State.Stale -> state.data
+        is State.Error -> state.cached
+        else -> null
+    } ?: return
+    val detail = balance.sub2UsageDetail
+    if (detail == null || detail.isEmpty) {
+        // 无结构化明细：回退旧通用卡（旧缓存/网关未返回 model_stats/daily_usage）
+        GenericExtrasCard(state)
+        return
+    }
+
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(20.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+    ) {
+        Column(modifier = Modifier.padding(20.dp)) {
+            Text(
+                text = stringResource(R.string.sub2_usage_title),
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.SemiBold
+            )
+            Spacer(modifier = Modifier.height(4.dp))
+            Text(
+                text = stringResource(R.string.sub2_usage_subtitle),
+                style = MaterialTheme.typography.bodySmall,
+                color = inkMuted()
+            )
+            Spacer(modifier = Modifier.height(12.dp))
+
+            // 默认选中「今天」（用户反馈：进入详情页应直接看当天用量）
+            var window by remember { mutableStateOf(Sub2Window.TODAY) }
+            // key=detail：刷新后模型列表变化时重置选中态，避免「每日区隐藏+无模型说明」的悬空状态
+            var selectedModel by remember(detail) { mutableStateOf<String?>(null) }
+            // 明细分区 tab：按模型 / 按 Key
+            var detailTab by remember { mutableStateOf(DetailTab.MODEL) }
+
+            // ── 时间窗口选择 ──
+            LazyRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                items(Sub2Window.entries) { w ->
+                    FilterChip(
+                        selected = window == w,
+                        onClick = { window = w },
+                        label = { Text(stringResource(w.labelRes)) },
+                        colors = FilterChipDefaults.filterChipColors(
+                            selectedContainerColor = MaterialTheme.colorScheme.primary,
+                            selectedLabelColor = MaterialTheme.colorScheme.onPrimary
+                        )
+                    )
+                }
+            }
+
+            val days = remember(detail, window) { window.slice(detail.dailyUsage) }
+            val rangeLabel = remember(days) { formatRange(days) }
+
+            // 「今天」改为按小时展示：只有一根按天柱子看不出分布，故拉当天小时趋势
+            LaunchedEffect(window) {
+                if (window == Sub2Window.TODAY) {
+                    val (from, _) = window.range()
+                    onLoadHourlyTrend?.invoke(from)
+                }
+            }
+            // 小时数据只在「今天」窗口且拿到 ≥2 个小时桶时才用。
+            // 实测面板可能把整天聚合成单个 "00:00" 桶（时区/活动量原因），
+            // 此时按小时展示两端刻度都是 00:00，反而不如按天清楚，故回退按天。
+            val useHourly = window == Sub2Window.TODAY && hourlyTrend.size >= 2
+            val chartSeries = if (useHourly) hourlyTrend else days
+
+            // 非「全部」窗口：按所选时间周期向网关拉取分模型统计（model_stats 受 start_date/end_date 控制）
+            LaunchedEffect(window) {
+                if (onLoadWindowModelStats != null && window != Sub2Window.ALL) {
+                    val (from, to) = window.range()
+                    onLoadWindowModelStats(from, to)
+                }
+            }
+
+            // 「按 Key」tab 打开或切换时间周期时，按当前周期拉取按 Key 用量
+            LaunchedEffect(window, detailTab) {
+                if (onLoadKeyStats != null && detailTab == DetailTab.KEY) {
+                    val (from, to) = window.range()
+                    onLoadKeyStats(from, to)
+                }
+            }
+            if (rangeLabel != null) {
+                Spacer(modifier = Modifier.height(8.dp))
+                Text(
+                    text = rangeLabel,
+                    style = MaterialTheme.typography.labelMedium,
+                    color = inkMuted()
+                )
+            }
+
+            // 窗口分模型统计：「全部」用网关返回的全量 model_stats，其余按当前周期拉取结果
+            // Key 模式下后端口径为「历史累计」时 allTime=true，下面的小标题会如实标注，避免被误读为周期数据
+            // 「全部」窗口本身就用网关全量 model_stats，不需要再挂「累计」后缀；只在按周期拉取时才可能命中累计口径
+            val windowStatsAllTime = window != Sub2Window.ALL &&
+                (windowStatsState as? PanelWindowStatsState.Success)?.allTime == true
+            val windowModelStats = if (window == Sub2Window.ALL) detail.modelStats
+            else (windowStatsState as? PanelWindowStatsState.Success)?.stats.orEmpty()
+
+            // 切换窗口后若原选中模型在当前周期没有数据，自动取消选中，避免「无模型说明 + 日图隐藏」的悬空态
+            LaunchedEffect(window, windowModelStats) {
+                val model = selectedModel
+                if (model != null && windowModelStats.isNotEmpty() &&
+                    windowModelStats.none { it.model == model }
+                ) {
+                    selectedModel = null
+                }
+            }
+
+            // 选中模型 → 汇总/列表均切换为该模型在当前周期内的累计；每日块隐藏（无模型维度，避免误导）
+            val selectedStat = remember(detail, selectedModel, windowModelStats) {
+                windowModelStats.firstOrNull { it.model == selectedModel }
+            }
+
+            if (selectedStat != null) {
+                Spacer(modifier = Modifier.height(12.dp))
+                Text(
+                    text = stringResource(R.string.sub2_model_sel_summary, selectedStat.model),
+                    style = MaterialTheme.typography.labelMedium,
+                    color = inkMuted()
+                )
+            }
+
+            // ── 汇总三格 ──
+            if (days.isNotEmpty() || selectedStat != null) {
+                Spacer(modifier = Modifier.height(10.dp))
+                val sumRequests = selectedStat?.requests ?: days.sumOf { it.requests }
+                val sumTokens = selectedStat?.totalTokens ?: days.sumOf { it.totalTokens }
+                val sumCost = selectedStat?.cost ?: days.sumOf { it.cost }
+                Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+                    StatCell(
+                        label = stringResource(R.string.sub2_stat_requests),
+                        value = compactNum(sumRequests),
+                        modifier = Modifier.weight(1f)
+                    )
+                    StatCell(
+                        label = stringResource(R.string.sub2_stat_tokens),
+                        value = compactNum(sumTokens),
+                        modifier = Modifier.weight(1f)
+                    )
+                    StatCell(
+                        label = stringResource(R.string.sub2_stat_cost),
+                        value = formatCost(sumCost),
+                        modifier = Modifier.weight(1f)
+                    )
+                }
+            }
+
+            // ── 趋势区域：按天（或「今天」按小时）展示 ──
+            // 说明：daily_usage 是账户整体、无模型维度，因此选中单个模型时这张图仍然是
+            // 「账户整体趋势」——加一行标注说明口径，而不是像以前那样整块隐藏
+            //（隐藏会让用户以为柱状图坏了）。
+            run {
+                val isHourly = useHourly
+                if (chartSeries.isEmpty()) {
+                    Spacer(modifier = Modifier.height(12.dp))
+                    Text(
+                        text = stringResource(R.string.sub2_no_daily),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = inkMuted()
+                    )
+                } else {
+                    Spacer(modifier = Modifier.height(14.dp))
+                    if (selectedModel != null) {
+                        // 选中模型时明确标注：趋势图仍是账户整体口径，避免误读为该模型趋势
+                        Text(
+                            text = stringResource(R.string.sub2_trend_account_scope),
+                            style = MaterialTheme.typography.labelSmall,
+                            color = inkMuted()
+                        )
+                        Spacer(modifier = Modifier.height(6.dp))
+                    }
+                    DailyCostBars(chartSeries)
+                    Spacer(modifier = Modifier.height(4.dp))
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.SpaceBetween
+                    ) {
+                        Text(
+                            text = shortDate(chartSeries.first().date),
+                            style = MaterialTheme.typography.labelSmall,
+                            color = inkMuted()
+                        )
+                        Text(
+                            text = shortDate(chartSeries.last().date),
+                            style = MaterialTheme.typography.labelSmall,
+                            color = inkMuted()
+                        )
+                    }
+
+                    // 每日/每小时明细列表
+                    Spacer(modifier = Modifier.height(12.dp))
+                    Text(
+                        text = stringResource(R.string.sub2_daily_header),
+                        style = MaterialTheme.typography.labelLarge,
+                        color = inkMuted()
+                    )
+                    Spacer(modifier = Modifier.height(6.dp))
+                    if (isHourly) {
+                        // 「今天」按小时：倒序展示每小时明细
+                        chartSeries.reversed().forEachIndexed { index, hour ->
+                            DailyRow(hour)
+                            if (index != chartSeries.lastIndex) {
+                                HorizontalDivider(
+                                    modifier = Modifier.padding(vertical = 2.dp),
+                                    color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.4f)
+                                )
+                            }
+                        }
+                    } else {
+                        days.reversed().forEachIndexed { index, day ->
+                            DailyRow(day)
+                            if (index != days.lastIndex) {
+                                HorizontalDivider(
+                                    modifier = Modifier.padding(vertical = 2.dp),
+                                    color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.4f)
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+
+            // ── 明细分区：「按模型 / 按 Key」两个 tab（数据都随所选时间周期变化）──
+            val statsLoading = window != Sub2Window.ALL &&
+                (windowStatsState is PanelWindowStatsState.Idle || windowStatsState is PanelWindowStatsState.Loading)
+            val statsError = (windowStatsState as? PanelWindowStatsState.Error)?.message
+
+            if (detail.modelStats.isNotEmpty() || window != Sub2Window.ALL) {
+                Spacer(modifier = Modifier.height(16.dp))
+                HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f))
+                Spacer(modifier = Modifier.height(10.dp))
+
+                // tab 切换：按模型 / 按 Key（纯文字 tab，非按钮）
+                Row(horizontalArrangement = Arrangement.spacedBy(20.dp)) {
+                    Text(
+                        text = stringResource(R.string.sub2_tab_by_model),
+                        style = MaterialTheme.typography.labelLarge,
+                        fontWeight = if (detailTab == DetailTab.MODEL) FontWeight.SemiBold else FontWeight.Normal,
+                        color = if (detailTab == DetailTab.MODEL) MaterialTheme.colorScheme.primary else inkMuted(),
+                        modifier = Modifier.clickable { detailTab = DetailTab.MODEL }
+                    )
+                    Text(
+                        text = stringResource(R.string.sub2_tab_by_key),
+                        style = MaterialTheme.typography.labelLarge,
+                        fontWeight = if (detailTab == DetailTab.KEY) FontWeight.SemiBold else FontWeight.Normal,
+                        color = if (detailTab == DetailTab.KEY) MaterialTheme.colorScheme.primary else inkMuted(),
+                        modifier = Modifier.clickable { detailTab = DetailTab.KEY }
+                    )
+                }
+                Spacer(modifier = Modifier.height(12.dp))
+
+                if (detailTab == DetailTab.KEY) {
+                    KeyUsageSection(keyStatsState)
+                } else {
+                    // 模型筛选 chips（按当前周期内有数据的模型；「全部」时用网关全量）
+                    LazyRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                        item {
+                            FilterChip(
+                                selected = selectedModel == null,
+                                onClick = { selectedModel = null },
+                                label = { Text(stringResource(R.string.sub2_model_all)) },
+                                colors = FilterChipDefaults.filterChipColors(
+                                    selectedContainerColor = MaterialTheme.colorScheme.primary,
+                                    selectedLabelColor = MaterialTheme.colorScheme.onPrimary
+                                )
+                            )
+                        }
+                        items(windowModelStats) { stat ->
+                            FilterChip(
+                                selected = selectedModel == stat.model,
+                                onClick = { selectedModel = stat.model },
+                                label = { Text(stat.model) }
+                            )
+                        }
+                    }
+                    Spacer(modifier = Modifier.height(8.dp))
+
+                    when {
+                        statsLoading -> Text(
+                            text = stringResource(R.string.common_loading),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = inkMuted()
+                        )
+                        statsError != null -> Text(
+                            text = "✗ " + statsError,
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.error
+                        )
+                        windowModelStats.isEmpty() -> Text(
+                            text = stringResource(R.string.sub2_no_model_data),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = inkMuted()
+                        )
+                        else -> {
+                            val shown = windowModelStats.filter { selectedModel == null || it.model == selectedModel }
+                            shown.forEachIndexed { index, stat ->
+                                ModelRow(stat, highlighted = selectedModel == stat.model)
+                                if (index != shown.lastIndex) {
+                                    HorizontalDivider(
+                                        modifier = Modifier.padding(vertical = 2.dp),
+                                        color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.4f)
+                                    )
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/** 明细分区 tab：按模型 / 按 Key。 */
+private enum class DetailTab { MODEL, KEY }
+
+/** 按 Key 用量区域：加载中/错误/空态/列表。 */
+@Composable
+private fun KeyUsageSection(state: PanelKeyStatsState) {
+    when (state) {
+        is PanelKeyStatsState.Idle,
+        is PanelKeyStatsState.Loading -> Text(
+            text = stringResource(R.string.common_loading),
+            style = MaterialTheme.typography.bodySmall,
+            color = inkMuted()
+        )
+        is PanelKeyStatsState.Error -> Text(
+            text = "✗ " + state.message,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.error
+        )
+        is PanelKeyStatsState.Success -> {
+            if (state.stats.isEmpty()) {
+                Text(
+                    text = stringResource(R.string.sub2_no_key_data),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = inkMuted()
+                )
+            } else {
+                state.stats.forEachIndexed { index, stat ->
+                    KeyUsageRow(stat)
+                    if (index != state.stats.lastIndex) {
+                        HorizontalDivider(
+                            modifier = Modifier.padding(vertical = 2.dp),
+                            color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.4f)
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+/** Key 一行：名称（+分组） + 请求/tokens + cost；未使用的 Key 灰显。 */
+@Composable
+private fun KeyUsageRow(stat: PanelKeyStatsState.KeyStat) {
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(vertical = 8.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Column(modifier = Modifier.weight(1f)) {
+            Text(
+                text = stat.name.ifBlank { "#" + stat.keyId },
+                style = MaterialTheme.typography.bodyMedium,
+                fontWeight = FontWeight.Medium,
+                color = if (stat.unused) inkMuted() else MaterialTheme.colorScheme.onSurface,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis
+            )
+            Spacer(modifier = Modifier.height(2.dp))
+            Text(
+                text = buildString {
+                    stat.groupName?.takeIf { it.isNotBlank() }?.let { append(it).append(" · ") }
+                    if (stat.unused) append(stringResource(R.string.sub2_key_unused))
+                    else append(
+                        stringResource(
+                            R.string.sub2_model_meta,
+                            compactNum(stat.requests),
+                            compactNum(stat.totalTokens)
+                        )
+                    )
+                },
+                style = MaterialTheme.typography.bodySmall,
+                color = inkMuted(),
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis
+            )
+        }
+        Text(
+            text = if (stat.unused) "-" else formatCost(stat.cost),
+            style = MaterialTheme.typography.titleMedium,
+            fontWeight = FontWeight.SemiBold,
+            color = if (stat.unused) inkMuted() else MaterialTheme.colorScheme.onSurface
+        )
+    }
+}
+
+/** 时间窗口：按日期切片（近 N 天 = 今天及之前 N-1 天），不再按行数。 */
+private enum class Sub2Window(val labelRes: Int) {
+    TODAY(R.string.sub2_window_today),
+    DAYS_7(R.string.sub2_window_7d),
+    DAYS_30(R.string.sub2_window_30d),
+    DAYS_90(R.string.sub2_window_90d),
+    ALL(R.string.sub2_window_all);
+
+    fun slice(all: List<Sub2DailyUsage>): List<Sub2DailyUsage> {
+        val today = LocalDate.now()
+        val startDay = when (this) {
+            TODAY -> today
+            DAYS_7 -> today.minusDays(6)
+            DAYS_30 -> today.minusDays(29)
+            DAYS_90 -> today.minusDays(89)
+            ALL -> all.firstOrNull()?.let { runCatching { LocalDate.parse(it.date) }.getOrNull() } ?: today
+        }
+        // 按日期补零：网关只返回有用量的天（实测确认），filter 会日期跳空，
+        // 逐日补齐 cost=0 空行保证柱状图/列表连续。ALL 从最早数据日补到今天。
+        val byDate = all.associateBy { it.date }
+        val out = mutableListOf<Sub2DailyUsage>()
+        var d = startDay
+        while (!d.isAfter(today)) {
+            val key = d.toString()
+            out.add(byDate[key] ?: Sub2DailyUsage(date = key, requests = 0, totalTokens = 0, cost = 0.0))
+            d = d.plusDays(1)
+        }
+        return out
+    }
+
+    /** 窗口对应日期范围 [start, end]（end 恒为今天；「全部」与主页一致取近 90 天）。 */
+    fun range(): Pair<LocalDate, LocalDate> {
+        val today = LocalDate.now()
+        return when (this) {
+            TODAY -> today to today
+            DAYS_7 -> today.minusDays(6) to today
+            DAYS_30 -> today.minusDays(29) to today
+            DAYS_90 -> today.minusDays(89) to today
+            ALL -> today.minusDays(89) to today
+        }
+    }
+}
+
+@Composable
+private fun StatCell(label: String, value: String, modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier
+            .clip(RoundedCornerShape(12.dp))
+            .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f))
+            .padding(horizontal = 10.dp, vertical = 10.dp)
+    ) {
+        Text(
+            text = label,
+            style = MaterialTheme.typography.labelSmall,
+            color = inkMuted()
+        )
+        Spacer(modifier = Modifier.height(2.dp))
+        Text(
+            text = value,
+            style = MaterialTheme.typography.titleMedium,
+            fontWeight = FontWeight.SemiBold,
+            maxLines = 1
+        )
+    }
+}
+
+/** 每日花费迷你柱状图：按窗口内每天的 cost 等比画柱（全零/无数据时显示空态文案）。 */
+@Composable
+private fun DailyCostBars(days: List<Sub2DailyUsage>) {
+    val maxCost = days.maxOfOrNull { it.cost }?.takeIf { it > 0 }
+    if (maxCost == null) {
+        // 全零或全空：空态提示（避免空白灰框）
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(88.dp)
+                .clip(RoundedCornerShape(12.dp))
+                .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.4f)),
+            contentAlignment = Alignment.Center
+        ) {
+            Text(
+                text = stringResource(R.string.sub2_no_cost),
+                style = MaterialTheme.typography.bodySmall,
+                color = inkMuted()
+            )
+        }
+        return
+    }
+    // 长周期（如近90天）柱数多：收窄柱间距避免 3dp×N 间距溢出屏幕导致柱子消失/错乱
+    val barSpacing = when (days.size) {
+        in 0..15 -> 3.dp
+        in 16..44 -> 2.dp
+        else -> 1.dp
+    }
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .height(88.dp)
+            .clip(RoundedCornerShape(12.dp))
+            .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.4f))
+            .padding(horizontal = 6.dp, vertical = 10.dp),
+        verticalAlignment = Alignment.Bottom,
+        horizontalArrangement = Arrangement.spacedBy(barSpacing)
+    ) {
+        days.forEach { day ->
+            // 每日用量栏高度限制（0.95 最高），避免个别峰值日把柱子顶满、图形失真；
+            // 零消耗日给 0.02f 最小占位，保证日期刻度对齐
+            val fraction = ((day.cost / maxCost).toFloat()).coerceIn(0.02f, 0.95f)
+            Column(
+                modifier = Modifier
+                    .weight(1f)
+                    .fillMaxHeight(),
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.Bottom
+            ) {
+                Box(
+                    modifier = Modifier
+                        .fillMaxWidth(0.6f)
+                        .fillMaxHeight(fraction)
+                        .clip(RoundedCornerShape(topStart = 4.dp, topEnd = 4.dp))
+                        .background(
+                            Brush.verticalGradient(
+                                listOf(
+                                    MaterialTheme.colorScheme.primary,
+                                    MaterialTheme.colorScheme.primaryContainer
+                                )
+                            )
+                        )
+                )
+            }
+        }
+    }
+}
+
+/** 每日一行：日期（MM-dd）+ 请求数 + tokens + cost。 */
+@Composable
+private fun DailyRow(day: Sub2DailyUsage) {
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(vertical = 6.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Text(
+            text = shortDate(day.date),
+            style = MaterialTheme.typography.bodyMedium,
+            fontWeight = FontWeight.Medium,
+            modifier = Modifier.weight(1.2f)
+        )
+        Text(
+            text = compactNum(day.requests),
+            style = MaterialTheme.typography.bodySmall,
+            color = inkMuted(),
+            modifier = Modifier.weight(1f),
+            textAlign = TextAlign.Center
+        )
+        Text(
+            text = compactNum(day.totalTokens),
+            style = MaterialTheme.typography.bodySmall,
+            color = inkMuted(),
+            modifier = Modifier.weight(1f),
+            textAlign = TextAlign.Center
+        )
+        Text(
+            text = formatCost(day.cost),
+            style = MaterialTheme.typography.bodyMedium,
+            fontWeight = FontWeight.SemiBold,
+            modifier = Modifier.weight(0.8f),
+            textAlign = TextAlign.End
+        )
+    }
+}
+
+/** 模型一行：名称 + 请求/tokens + cost；选中模型时加粗高亮。 */
+@Composable
+private fun ModelRow(stat: Sub2ModelStat, highlighted: Boolean = false) {
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(vertical = 8.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Column(modifier = Modifier.weight(1f)) {
+            Text(
+                text = stat.model,
+                style = MaterialTheme.typography.bodyMedium,
+                fontWeight = if (highlighted) FontWeight.Bold else FontWeight.Medium,
+                color = if (highlighted) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurface,
+                maxLines = 1
+            )
+            Spacer(modifier = Modifier.height(2.dp))
+            Text(
+                text = stringResource(
+                    R.string.sub2_model_meta,
+                    compactNum(stat.requests),
+                    compactNum(stat.totalTokens)
+                ),
+                style = MaterialTheme.typography.bodySmall,
+                color = inkMuted()
+            )
+        }
+        Text(
+            text = formatCost(stat.cost),
+            style = MaterialTheme.typography.titleMedium,
+            fontWeight = FontWeight.SemiBold,
+            color = if (highlighted) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurface
+        )
+    }
+}
+
+/** "MM-dd" 短日期；"HH:00" 小时刻度原样返回；解析失败原样返回。 */
+private fun shortDate(iso: String): String {
+    // 小时桶（"14:00"）不是日期，直接展示，别走 LocalDate.parse
+    if (iso.length == 5 && iso[2] == ':') return iso
+    return runCatching {
+        LocalDate.parse(iso).format(DateTimeFormatter.ofPattern("MM-dd", Locale.US))
+    }.getOrDefault(iso)
+}
+
+/** 窗口起止标签：近 N 天 → "09-01 ~ 09-30"，今天 → 只显示一天，全部 → null。 */
+private fun formatRange(days: List<Sub2DailyUsage>): String? {
+    if (days.isEmpty()) return null
+    val first = days.first().date
+    val last = days.last().date
+    return if (first == last) shortDate(first) else shortDate(first) + " ~ " + shortDate(last)
+}
+
+/** 花费金额统一 "$x.xx"（0 显示 $0.00，钱不显示占位符）。 */
+private fun formatCost(v: Double): String = "$" + String.format(Locale.US, "%.2f", v)
+
+/** 1000 → "1.0K"，1000000 → "1.0M"，0 → "-"。 */
+private fun compactNum(v: Long): String = when {
+    v <= 0 -> "-"
+    v >= 1_000_000 -> String.format(Locale.US, "%.1fM", v / 1_000_000.0)
+    v >= 1_000 -> String.format(Locale.US, "%.1fK", v / 1_000.0)
+    else -> v.toString()
+}

app/src/main/java/com/rainy/token/ui/settings/AccountManagementScreen.kt

@@ -0,0 +1,342 @@
+package com.rainy.token.ui.settings
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ArrowBack
+import androidx.compose.material.icons.filled.MoreVert
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Snackbar
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
+import com.rainy.token.domain.model.ServiceAccountInfo
+import com.rainy.token.domain.service.ServiceType
+import com.rainy.token.ui.components.ServiceIcon
+import com.rainy.token.ui.components.resolve
+import com.rainy.token.ui.theme.InkMuted
+import com.rainy.token.ui.theme.StrawberryPink
+
+/**
+ * 账号管理页（Trae / WorkBuddy 多账号）。
+ *
+ *  - 列出该服务全部账号（默认账号带角标）；
+ *  - 行内菜单：设为默认 / 重命名 / 删除；
+ *  - 「添加账号」导航到凭据编辑器（新建模式）。
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AccountManagementScreen(
+    service: ServiceType,
+    onBack: () -> Unit,
+    onEditAccount: (ServiceType, String?) -> Unit,
+    viewModel: AccountManagementViewModel = hiltViewModel()
+) {
+    // 重新进入页面（从凭据编辑页保存/删除后返回）时刷新账号列表
+    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
+        viewModel.refresh()
+    }
+    LaunchedEffect(service) { viewModel.bind(service) }
+
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val context = LocalContext.current
+    val snackbarHostState = remember { SnackbarHostState() }
+
+    // 行菜单：记录哪个账号的菜单展开
+    var menuAccountId by remember { mutableStateOf<String?>(null) }
+    // 重命名对话框
+    var renamingAccount by remember { mutableStateOf<ServiceAccountInfo?>(null) }
+    var renameInput by remember { mutableStateOf("") }
+    // 删除确认对话框
+    var deletingAccount by remember { mutableStateOf<ServiceAccountInfo?>(null) }
+
+    LaunchedEffect(uiState.message) {
+        uiState.message?.let { msg ->
+            snackbarHostState.showSnackbar(msg.resolve(context))
+            viewModel.consumeMessage()
+        }
+    }
+
+    Scaffold(
+        containerColor = Color.Transparent,
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(R.string.account_manager_title, service.displayName)) },
+                navigationIcon = {
+                    IconButton(onClick = onBack) {
+                        Icon(Icons.Filled.ArrowBack, contentDescription = stringResource(R.string.action_back))
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Transparent)
+            )
+        },
+        snackbarHost = { SnackbarHost(snackbarHostState) { data -> Snackbar(snackbarData = data) } }
+    ) { innerPadding ->
+        if (uiState.loading && uiState.accounts.isEmpty()) {
+            Box(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(innerPadding),
+                contentAlignment = Alignment.Center
+            ) {
+                CircularProgressIndicator(color = StrawberryPink)
+            }
+        } else {
+            LazyColumn(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(innerPadding),
+                contentPadding = PaddingValues(16.dp),
+                verticalArrangement = Arrangement.spacedBy(12.dp)
+            ) {
+                if (uiState.accounts.isEmpty()) {
+                    item {
+                        Card(
+                            modifier = Modifier.fillMaxWidth(),
+                            shape = RoundedCornerShape(20.dp),
+                            colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+                            elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+                        ) {
+                            Text(
+                                text = stringResource(R.string.account_empty_hint),
+                                style = MaterialTheme.typography.bodyMedium,
+                                color = InkMuted,
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .padding(20.dp),
+                                textAlign = androidx.compose.ui.text.style.TextAlign.Center
+                            )
+                        }
+                    }
+                }
+                items(uiState.accounts, key = { it.id }) { account ->
+                    val ordinal = accountOrdinal(uiState.accounts, account)
+                    AccountRow(
+                        account = account,
+                        displayName = account.label?.takeIf { it.isNotBlank() }
+                            ?: stringResource(R.string.account_fallback_name, ordinal),
+                        menuExpanded = menuAccountId == account.id,
+                        onMenuToggle = {
+                            menuAccountId = if (menuAccountId == account.id) null else account.id
+                        },
+                        onMenuDismiss = { menuAccountId = null },
+                        onEdit = { onEditAccount(service, account.id) },
+                        onSetDefault = {
+                            menuAccountId = null
+                            viewModel.setDefault(account.id)
+                        },
+                        onRename = {
+                            menuAccountId = null
+                            renamingAccount = account
+                            renameInput = account.label.orEmpty()
+                        },
+                        onDelete = {
+                            menuAccountId = null
+                            deletingAccount = account
+                        }
+                    )
+                }
+                item {
+                    Button(
+                        onClick = { onEditAccount(service, null) },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .height(46.dp),
+                        shape = RoundedCornerShape(14.dp),
+                        colors = androidx.compose.material3.ButtonDefaults.buttonColors(
+                            containerColor = StrawberryPink,
+                            contentColor = Color.White
+                        )
+                    ) {
+                        Text(stringResource(R.string.account_add))
+                    }
+                }
+            }
+        }
+    }
+
+    // 重命名对话框
+    renamingAccount?.let { account ->
+        AlertDialog(
+            onDismissRequest = { renamingAccount = null },
+            title = { Text(stringResource(R.string.account_rename_dialog_title)) },
+            text = {
+                OutlinedTextField(
+                    value = renameInput,
+                    onValueChange = { renameInput = it },
+                    label = { Text(stringResource(R.string.account_name_label)) },
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth()
+                )
+            },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        viewModel.rename(account.id, renameInput)
+                        renamingAccount = null
+                    }
+                ) {
+                    Text(stringResource(R.string.action_confirm), color = StrawberryPink)
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { renamingAccount = null }) {
+                    Text(stringResource(R.string.action_cancel))
+                }
+            }
+        )
+    }
+
+    // 删除确认对话框
+    deletingAccount?.let { account ->
+        AlertDialog(
+            onDismissRequest = { deletingAccount = null },
+            title = { Text(stringResource(R.string.account_delete_title)) },
+            text = { Text(stringResource(R.string.account_delete_confirm)) },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        viewModel.delete(account.id)
+                        deletingAccount = null
+                    }
+                ) {
+                    Text(stringResource(R.string.action_delete_confirmed), color = StrawberryPink)
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { deletingAccount = null }) {
+                    Text(stringResource(R.string.action_cancel))
+                }
+            }
+        )
+    }
+}
+
+@Composable
+private fun AccountRow(
+    account: ServiceAccountInfo,
+    displayName: String,
+    menuExpanded: Boolean,
+    onMenuToggle: () -> Unit,
+    onMenuDismiss: () -> Unit,
+    onEdit: () -> Unit,
+    onSetDefault: () -> Unit,
+    onRename: () -> Unit,
+    onDelete: () -> Unit
+) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable { onEdit() },
+        shape = RoundedCornerShape(20.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+    ) {
+        Row(
+            modifier = Modifier.padding(start = 16.dp, top = 12.dp, bottom = 12.dp, end = 4.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Box(modifier = Modifier.weight(1f)) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    Text(
+                        text = displayName,
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.SemiBold
+                    )
+                    if (account.isDefault) {
+                        Spacer(modifier = Modifier.width(8.dp))
+                        Text(
+                            text = stringResource(R.string.account_default_badge),
+                            style = MaterialTheme.typography.labelSmall,
+                            color = StrawberryPink,
+                            maxLines = 1,
+                            softWrap = false,
+                            modifier = Modifier
+                                .padding(horizontal = 6.dp, vertical = 2.dp)
+                                .background(
+                                    color = StrawberryPink.copy(alpha = 0.12f),
+                                    shape = RoundedCornerShape(8.dp)
+                                )
+                        )
+                    }
+                }
+            }
+            Box {
+                IconButton(onClick = onMenuToggle) {
+                    Icon(
+                        imageVector = Icons.Filled.MoreVert,
+                        contentDescription = stringResource(R.string.account_actions),
+                        tint = InkMuted
+                    )
+                }
+                DropdownMenu(expanded = menuExpanded, onDismissRequest = onMenuDismiss) {
+                    if (!account.isDefault) {
+                        DropdownMenuItem(
+                            text = { Text(stringResource(R.string.account_set_default)) },
+                            onClick = onSetDefault
+                        )
+                    }
+                    DropdownMenuItem(
+                        text = { Text(stringResource(R.string.account_rename)) },
+                        onClick = onRename
+                    )
+                    DropdownMenuItem(
+                        text = { Text(stringResource(R.string.account_delete_title)) },
+                        onClick = onDelete
+                    )
+                }
+            }
+        }
+    }
+}
+
+/** 同服务内账号序号（1 起，用于“账号 N”兜底显示）。 */
+private fun accountOrdinal(accounts: List<ServiceAccountInfo>, account: ServiceAccountInfo): Int =
+    accounts.indexOf(account) + 1

app/src/main/java/com/rainy/token/ui/settings/AccountManagementViewModel.kt

@@ -0,0 +1,97 @@
+package com.rainy.token.ui.settings
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.rainy.token.R
+import com.rainy.token.data.repository.CredentialRepository
+import com.rainy.token.domain.model.ServiceAccountInfo
+import com.rainy.token.domain.service.ServiceType
+import com.rainy.token.ui.components.UiText
+import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+/**
+ * 账号管理页 ViewModel（Trae / WorkBuddy 多账号）。
+ *
+ * 「添加账号」由页面回调导航到凭据编辑器（新建模式），首个账号保存时自动设为默认；
+ * 本页负责列出现有账号、设默认、重命名、删除。
+ */
+@HiltViewModel
+class AccountManagementViewModel @Inject constructor(
+    private val credentialRepository: CredentialRepository
+) : ViewModel() {
+
+    private val _service = MutableStateFlow<ServiceType?>(null)
+    val service: StateFlow<ServiceType?> = _service.asStateFlow()
+
+    private val _uiState = MutableStateFlow(AccountManagementUiState())
+    val uiState: StateFlow<AccountManagementUiState> = _uiState.asStateFlow()
+
+    private var loadGeneration = 0
+
+    fun bind(service: ServiceType) {
+        if (_service.value == service) return
+        _service.value = service
+        refresh()
+    }
+
+    fun refresh() {
+        val type = _service.value ?: return
+        val generation = ++loadGeneration
+        viewModelScope.launch {
+            _uiState.update { it.copy(loading = true) }
+            val accounts = credentialRepository.accountsFor(type)
+            if (generation != loadGeneration) return@launch
+            _uiState.update {
+                it.copy(
+                    loading = false,
+                    accounts = accounts,
+                    // 账号列表可能为空（用户刚删光），保持消息残留会误导，这里清掉
+                    message = if (accounts.isEmpty()) null else it.message
+                )
+            }
+        }
+    }
+
+    fun setDefault(accountId: String) {
+        val type = _service.value ?: return
+        viewModelScope.launch {
+            credentialRepository.setDefaultAccount(type, accountId)
+            _uiState.update { it.copy(message = UiText.Resource(R.string.msg_account_default_set)) }
+            refresh()
+        }
+    }
+
+    fun rename(accountId: String, label: String) {
+        val type = _service.value ?: return
+        viewModelScope.launch {
+            credentialRepository.renameAccount(type, accountId, label.trim())
+            _uiState.update { it.copy(message = UiText.Resource(R.string.msg_account_renamed)) }
+            refresh()
+        }
+    }
+
+    fun delete(accountId: String) {
+        val type = _service.value ?: return
+        viewModelScope.launch {
+            credentialRepository.removeAccount(type, accountId)
+            _uiState.update { it.copy(message = UiText.Resource(R.string.msg_account_deleted)) }
+            refresh()
+        }
+    }
+
+    fun consumeMessage() {
+        _uiState.update { it.copy(message = null) }
+    }
+}
+
+data class AccountManagementUiState(
+    val loading: Boolean = false,
+    val accounts: List<ServiceAccountInfo> = emptyList(),
+    val message: UiText? = null
+)

app/src/main/java/com/rainy/token/ui/settings/CredentialEditViewModel.kt

@@ -4,20 +4,25 @@ import android.content.ClipboardManager
 import android.content.Context
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.rainy.token.R
 import com.rainy.token.data.repository.CredentialRepository
 import com.rainy.token.data.repository.RepositoryError
+import com.rainy.token.data.repository.Sub2ApiRepository
 import com.rainy.token.domain.model.CookieEntry
 import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.service.FetchMethod
 import com.rainy.token.domain.service.ServiceConfigProvider
 import com.rainy.token.domain.service.ServiceType
 import com.rainy.token.domain.usecase.RefreshBalanceUseCase
+import com.rainy.token.ui.components.UiText
 import dagger.hilt.android.lifecycle.HiltViewModel
 import javax.inject.Inject
 import javax.inject.Provider
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.serialization.json.Json
@@ -34,33 +39,59 @@ import kotlinx.serialization.json.jsonPrimitive
 @HiltViewModel
 class CredentialEditViewModel @Inject constructor(
     private val credentialRepository: CredentialRepository,
-    private val refreshBalanceUseCaseProvider: Provider<RefreshBalanceUseCase>
+    private val refreshBalanceUseCaseProvider: Provider<RefreshBalanceUseCase>,
+    private val sub2ApiRepository: Sub2ApiRepository,
+    private val savedStateHandle: androidx.lifecycle.SavedStateHandle
 ) : ViewModel() {
 
+    /** Sub2 站点信息探测（baseUrl 输入 debounce 后触发）。 */
+    private var sub2SiteJob: Job? = null
+    private var sub2SiteGeneration: Int = 0
+
     private val _uiState = MutableStateFlow(CredentialEditUiState())
     val uiState: StateFlow<CredentialEditUiState> = _uiState.asStateFlow()
 
     private var serviceType: ServiceType? = null
 
-    fun bind(service: ServiceType) {
-        if (serviceType == service) return
+    /** 当前编辑的账号 ID（多账号服务）；null=新建账号/单账号服务。 */
+    private var accountId: String? = null
+
+    fun bind(service: ServiceType, accountId: String? = null) {
+        val effectiveAccountId = accountId?.takeIf { it.isNotBlank() }
+        if (serviceType == service && this.accountId == effectiveAccountId) return
         serviceType = service
+        this.accountId = effectiveAccountId
         val config = ServiceConfigProvider.get(service)
         val isApiKey = config.method == FetchMethod.REST_API
         _uiState.update {
             it.copy(
                 service = service,
                 isApiKeyService = isApiKey,
-                loginUrl = config.loginUrl
+                loginUrl = config.loginUrl,
+                accountId = effectiveAccountId,
+                accountLabel = null,
+                accountIndex = 0
             )
         }
         load()
+        refreshAccountInfo()
     }
 
     private fun load() {
         val type = serviceType ?: return
+        // WebView 登录成功回调会把实际写入的账号 ID 通过 savedStateHandle 回传：
+        // 新建账号模式（accountId=null）登录后要切换到“编辑该新账号”模式，避免再次保存时误建第二个账号
+        savedStateHandle.get<String>(KEY_LOGIN_ACCOUNT_ID)?.let { pendingId ->
+            savedStateHandle[KEY_LOGIN_ACCOUNT_ID] = null
+            if (accountId.isNullOrBlank() && !pendingId.isBlank()) {
+                accountId = pendingId
+                _uiState.update { it.copy(accountId = pendingId) }
+            }
+        }
         viewModelScope.launch {
-            val existing = credentialRepository.get(type)
+            // 多账号服务 + null accountId = “新建账号”模式：表单必须留空（不能预填默认账号凭据）
+            val isNewAccount = ServiceType.isMultiAccount(type) && accountId.isNullOrBlank()
+            val existing = if (isNewAccount) null else credentialRepository.get(type, accountId)
             _uiState.update {
                 it.copy(
                     apiKey = when (existing) {
@@ -90,9 +121,31 @@ class CredentialEditViewModel @Inject constructor(
                     } else "",
                     ollamaCookie = (existing as? Credential.SessionCredential)?.ollamaCookie.orEmpty(),
                     triggerApiKey = (existing as? Credential.SessionCredential)?.apiKey.orEmpty(),
+                    traeJwt = (existing as? Credential.TraeCredential)?.jwt.orEmpty(),
+                    traeRegion = (existing as? Credential.TraeCredential)?.region ?: "CN",
+                    traeCheckinDeviceId = (existing as? Credential.TraeCredential)?.checkinDeviceId.orEmpty(),
+                    workBuddyAccess = (existing as? Credential.WorkBuddyCredential)?.accessToken.orEmpty(),
+                    workBuddyRefresh = (existing as? Credential.WorkBuddyCredential)?.refreshToken.orEmpty(),
+                    sub2BaseUrl = (existing as? Credential.Sub2ApiCredential)?.baseUrl.orEmpty(),
+                    sub2SiteIcon = (existing as? Credential.Sub2ApiCredential)?.siteIcon,
+                    sub2Email = (existing as? Credential.Sub2ApiCredential)?.email.orEmpty(),
+                    sub2Password = (existing as? Credential.Sub2ApiCredential)?.password.orEmpty(),
+                    sub2ApiKey = (existing as? Credential.Sub2ApiCredential)?.apiKey.orEmpty(),
+                    sub2LoginMode = when {
+                        // 有面板 Token：账号密码模式优先（面板登录是主力）
+                        !((existing as? Credential.Sub2ApiCredential)?.authToken).isNullOrBlank() -> "account"
+                        // 仅存过 API Key：保持 API Key 模式
+                        !((existing as? Credential.Sub2ApiCredential)?.apiKey).isNullOrBlank() -> "apikey"
+                        else -> "account"
+                    },
                     hasExisting = existing != null
                 )
             }
+            // 已有 baseUrl：补跑一次站点识别（load 不经过输入框，探测不会自动触发）
+            val base = (existing as? Credential.Sub2ApiCredential)?.baseUrl
+            if (!base.isNullOrBlank()) {
+                updateSub2BaseUrl(base)
+            }
         }
     }
 
@@ -117,7 +170,7 @@ class CredentialEditViewModel @Inject constructor(
         val current = _uiState.value
         val trimmedKey = current.apiKey.trim()
         if (trimmedKey.isBlank()) {
-            _uiState.update { it.copy(message = "API Key 不能为空") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_api_key_empty)) }
             return
         }
         viewModelScope.launch {
@@ -131,7 +184,7 @@ class CredentialEditViewModel @Inject constructor(
             _uiState.update {
                 it.copy(
                     apiKey = trimmedKey,
-                    message = "已保存",
+                    message = UiText.Resource(R.string.msg_saved),
                     hasExisting = true
                 )
             }
@@ -142,7 +195,7 @@ class CredentialEditViewModel @Inject constructor(
     private suspend fun testAndRollback(
         type: ServiceType,
         saveAndPrep: suspend () -> Pair<Credential?, suspend () -> Result<com.rainy.token.domain.model.ServiceBalance>>,
-        formatSuccess: (com.rainy.token.domain.model.ServiceBalance) -> String,
+        formatSuccess: (com.rainy.token.domain.model.ServiceBalance) -> UiText,
         rollbackOnFailure: Boolean
     ) {
         val (previous, testBlock) = saveAndPrep()
@@ -158,23 +211,47 @@ class CredentialEditViewModel @Inject constructor(
                 false
             }
             val err = result.exceptionOrNull()
-            val reason = when (err) {
-                is RepositoryError.InvalidCredential -> "服务拒绝该凭据 (401/403)"
-                is RepositoryError.CredentialChanged -> "测试期间凭据已变更"
-                is RepositoryError.RateLimited -> "请求过于频繁 (429)"
-                is RepositoryError.ServerError -> "服务端错误 (${err.code})"
-                is RepositoryError.Network -> "网络错误：${err.cause?.message ?: "未知"}"
-                else -> err?.message ?: "未知错误"
+            val reason: UiText = when (err) {
+                is RepositoryError.SessionExpired ->
+                    UiText.Resource(R.string.error_credential_session_expired)
+                is RepositoryError.InvalidCredential ->
+                    UiText.Resource(R.string.error_credential_rejected)
+                is RepositoryError.CredentialChanged ->
+                    UiText.Resource(R.string.error_credential_changed_test)
+                is RepositoryError.RateLimited ->
+                    UiText.Resource(R.string.error_rate_limited)
+                is RepositoryError.ServerError ->
+                    UiText.Resource(R.string.error_server, listOf(err.code))
+                is RepositoryError.Network ->
+                    UiText.Resource(
+                        R.string.error_network,
+                        listOf(
+                            err.cause?.message?.let { UiText.Dynamic(it) }
+                                ?: UiText.Resource(R.string.common_unknown)
+                        )
+                    )
+                is RepositoryError.ParseError -> when (err.reason) {
+                    RepositoryError.ParseErrorReason.EMPTY_BODY -> UiText.Resource(R.string.error_parse_empty_body)
+                    RepositoryError.ParseErrorReason.NOT_JSON_OBJECT -> UiText.Resource(R.string.error_parse_not_json)
+                    RepositoryError.ParseErrorReason.NO_WINDOWS -> UiText.Resource(R.string.error_parse_no_windows)
+                    RepositoryError.ParseErrorReason.NO_MODELS -> UiText.Resource(R.string.error_parse_no_models)
+                    RepositoryError.ParseErrorReason.MODELS_EMPTY -> UiText.Resource(R.string.error_parse_models_empty)
+                    RepositoryError.ParseErrorReason.MALFORMED_RESPONSE -> UiText.Resource(R.string.error_parse_malformed)
+                }
+                // Unknown 的 message 以硬编码中文"未知错误"开头，不能透传 UI，统一映射本地化文案
+                is RepositoryError.Unknown -> UiText.Resource(R.string.common_unknown)
+                else -> err?.message?.let { UiText.Dynamic(it) }
+                    ?: UiText.Resource(R.string.common_unknown)
             }
             val hasExisting = credentialRepository.get(type) != null
-            val rollbackNote = when {
+            val rollbackNote: Any = when {
                 !rollbackOnFailure -> ""
-                rolledBack -> "，已恢复原凭据"
-                else -> "，检测到凭据已变化，未执行回滚"
+                rolledBack -> UiText.Resource(R.string.error_rollback_done)
+                else -> UiText.Resource(R.string.error_rollback_skipped)
             }
             _uiState.update {
                 it.copy(
-                    message = "测试失败。$reason$rollbackNote",
+                    message = UiText.Resource(R.string.error_test_failed, listOf(reason, rollbackNote)),
                     hasExisting = hasExisting
                 )
             }
@@ -184,13 +261,13 @@ class CredentialEditViewModel @Inject constructor(
     fun testAndSaveApiKey() {
         val type = serviceType ?: return
         if (type != ServiceType.DEEPSEEK && type != ServiceType.COMMANDCODE_GO && type != ServiceType.CODEX) {
-            _uiState.update { it.copy(message = "暂不支持测试此服务") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_test_not_supported)) }
             return
         }
         val current = _uiState.value
         val trimmedKey = current.apiKey.trim()
         if (trimmedKey.isBlank()) {
-            _uiState.update { it.copy(message = "API Key 不能为空") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_api_key_empty)) }
             return
         }
         viewModelScope.launch {
@@ -205,30 +282,251 @@ class CredentialEditViewModel @Inject constructor(
             testAndRollback(
                 type = type,
                 saveAndPrep = { existing to { refreshBalanceUseCaseProvider.get().invoke(type) } },
-                formatSuccess = { bal -> "连接成功！余额: ${bal.amount} ${bal.unit}" },
+                formatSuccess = { bal ->
+                    UiText.Resource(
+                        R.string.msg_connect_success_balance,
+                        listOf(bal.amount.toString(), bal.unit)
+                    )
+                },
                 rollbackOnFailure = false
             )
         }
     }
 
+    // ---------- Trae ----------
+
+    fun updateTraeJwt(value: String) {
+        _uiState.update { it.copy(traeJwt = value) }
+    }
+
+    fun updateTraeRegion(value: String) {
+        _uiState.update { it.copy(traeRegion = value) }
+    }
+
+    fun updateTraeCheckinDeviceId(value: String) {
+        _uiState.update { it.copy(traeCheckinDeviceId = value) }
+    }
+
+    fun saveTraeCredential() {
+        val type = serviceType ?: return
+        val current = _uiState.value
+        val jwt = current.traeJwt.trim()
+        if (jwt.isBlank()) {
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_api_key_empty)) }
+            return
+        }
+        viewModelScope.launch {
+            // 新建账号模式（多账号服务 + null accountId）不继承默认账号的元数据（lastVerifiedAt 等）
+            val isNewAccount = ServiceType.isMultiAccount(type) && accountId.isNullOrBlank()
+            val existing = if (isNewAccount) {
+                null
+            } else {
+                credentialRepository.get(type, accountId) as? Credential.TraeCredential
+            }
+            val effectiveId = credentialRepository.save(
+                (existing ?: Credential.TraeCredential(service = type, jwt = jwt, region = "CN")).copy(
+                    jwt = jwt,
+                    region = if (current.traeRegion.uppercase() == "INTL") "INTL" else "CN",
+                    // 换账号（JWT 变化）时清空本地签到短路标记，避免新账号被误判「今日已签到」
+                    lastCheckinDate = if (existing != null && existing.jwt == jwt) existing.lastCheckinDate else null,
+                    // 签到设备 ID：留空 = 用内置默认；填写 = 优先（换设备后自查 did 更新）
+                    checkinDeviceId = current.traeCheckinDeviceId.trim().ifBlank { null },
+                    lastVerifiedAt = existing?.lastVerifiedAt ?: 0L
+                ),
+                accountId
+            )
+            accountId = effectiveId.ifBlank { accountId }
+            _uiState.update {
+                it.copy(hasExisting = true, message = UiText.Resource(R.string.msg_credentials_saved))
+            }
+            refreshAccountInfo()
+        }
+    }
+
+    // ---------- WorkBuddy ----------
+
+    fun updateWorkBuddyAccess(value: String) {
+        _uiState.update { it.copy(workBuddyAccess = value) }
+    }
+
+    fun updateWorkBuddyRefresh(value: String) {
+        _uiState.update { it.copy(workBuddyRefresh = value) }
+    }
+
+    fun saveWorkBuddyCredential() {
+        val type = serviceType ?: return
+        val current = _uiState.value
+        val access = current.workBuddyAccess.trim()
+        val refresh = current.workBuddyRefresh.trim()
+        if (access.isBlank() || refresh.isBlank()) {
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_workbuddy_tokens_required)) }
+            return
+        }
+        viewModelScope.launch {
+            // 新建账号模式（多账号服务 + null accountId）不继承默认账号的元数据
+            val isNewAccount = ServiceType.isMultiAccount(type) && accountId.isNullOrBlank()
+            val existing = if (isNewAccount) {
+                null
+            } else {
+                credentialRepository.get(type, accountId) as? Credential.WorkBuddyCredential
+            }
+            val effectiveId = credentialRepository.save(
+                (existing ?: Credential.WorkBuddyCredential(service = type, accessToken = access, refreshToken = refresh))
+                    .copy(
+                        accessToken = access,
+                        refreshToken = refresh,
+                        expiresAt = existing?.expiresAt ?: 0L,
+                        lastVerifiedAt = existing?.lastVerifiedAt ?: 0L
+                    ),
+                accountId
+            )
+            accountId = effectiveId.ifBlank { accountId }
+            _uiState.update {
+                it.copy(hasExisting = true, message = UiText.Resource(R.string.msg_credentials_saved))
+            }
+            refreshAccountInfo()
+        }
+    }
+
+    // ---------- Sub2API ----------
+
+    fun updateSub2BaseUrl(value: String) {
+        _uiState.update { it.copy(sub2BaseUrl = value, sub2SiteName = null, sub2SiteIcon = null) }
+        sub2SiteJob?.cancel()
+        val generation = ++sub2SiteGeneration
+        sub2SiteJob = viewModelScope.launch {
+            delay(600)
+            val base = value.trim()
+            if (base.isBlank() || generation != sub2SiteGeneration) return@launch
+            _uiState.update { it.copy(sub2SiteLoading = true) }
+            val info = sub2ApiRepository.fetchSiteInfo(base)
+            if (generation != sub2SiteGeneration) return@launch
+            _uiState.update {
+                it.copy(
+                    sub2SiteLoading = false,
+                    sub2SiteName = info?.name?.takeIf { n -> n.isNotBlank() },
+                    sub2SiteIcon = info?.iconUrl
+                )
+            }
+        }
+    }
+
+    /** 面板账号一键登录：邮箱+密码 → POST /api/v1/auth/login → 面板 Token（存为 authToken 走面板模式）。 */
+    fun loginPanelOneClick() {
+        val current = _uiState.value
+        val base = current.sub2BaseUrl.trim()
+        val email = current.sub2Email.trim()
+        val password = current.sub2Password.trim()
+        if (base.isBlank() || email.isBlank() || password.isBlank()) {
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_sub2_required)) }
+            return
+        }
+        if (current.sub2LoggingIn) return
+        _uiState.update { it.copy(sub2LoggingIn = true) }
+        viewModelScope.launch {
+            sub2ApiRepository.loginPanel(base, email, password, current.sub2Totp.trim()).fold(
+                onSuccess = { token -> onPanelTokenAcquired(token) },
+                onFailure = { e ->
+                    _uiState.update {
+                        it.copy(message = UiText.Dynamic(e.message ?: "登录失败，请检查邮箱/密码"))
+                    }
+                }
+            )
+            _uiState.update { it.copy(sub2LoggingIn = false) }
+        }
+    }
+
+    fun updateSub2Email(value: String) {
+        _uiState.update { it.copy(sub2Email = value) }
+    }
+
+    fun updateSub2Password(value: String) {
+        _uiState.update { it.copy(sub2Password = value) }
+    }
+
+    fun updateSub2ApiKey(value: String) {
+        _uiState.update { it.copy(sub2ApiKey = value) }
+    }
+
+    fun updateSub2LoginMode(mode: String) {
+        _uiState.update { it.copy(sub2LoginMode = mode) }
+    }
+
+    fun updateSub2Totp(value: String) {
+        _uiState.update { it.copy(sub2Totp = value) }
+    }
+
+    /** WebView 网页登录成功：写入本次待保存的面板 Token（保存时并入 authToken）。 */
+    fun onPanelTokenAcquired(token: String) {
+        _uiState.update { it.copy(sub2PanelToken = token, message = UiText.Resource(R.string.sub2_panel_login_done)) }
+    }
+
+    fun saveSub2ApiCredential() {
+        val type = serviceType ?: return
+        val current = _uiState.value
+        val base = current.sub2BaseUrl.trim()
+        val apiKey = current.sub2ApiKey.trim()
+        val email = current.sub2Email.trim()
+        val password = current.sub2Password.trim()
+        viewModelScope.launch {
+            // 新建账号模式（多账号服务 + null accountId）不继承默认账号的元数据
+            val isNewAccount = ServiceType.isMultiAccount(type) && accountId.isNullOrBlank()
+            val existing = if (isNewAccount) {
+                null
+            } else {
+                credentialRepository.get(type, accountId) as? Credential.Sub2ApiCredential
+            }
+            // 面板 Token（本次 WebView 获取或既有）也算有效认证
+            val panelToken = current.sub2PanelToken ?: existing?.authToken
+            // 实例地址必填；认证需 API Key /（邮箱+密码）/ 面板 Token 之一
+            if (base.isBlank() || (apiKey.isBlank() && (email.isBlank() || password.isBlank()) && panelToken == null)) {
+                _uiState.update { it.copy(message = UiText.Resource(R.string.error_sub2_required)) }
+                return@launch
+            }
+            val effectiveId = credentialRepository.save(
+                (existing ?: Credential.Sub2ApiCredential(service = type, baseUrl = base, email = email, password = password))
+                    .copy(
+                        baseUrl = base,
+                        email = email,
+                        password = password,
+                        apiKey = apiKey,
+                        authToken = panelToken,
+                        siteIcon = current.sub2SiteIcon ?: existing?.siteIcon,
+                        lastVerifiedAt = existing?.lastVerifiedAt ?: 0L
+                    ),
+                accountId
+            )
+            accountId = effectiveId.ifBlank { accountId }
+            _uiState.update {
+                it.copy(hasExisting = true, sub2PanelToken = null, message = UiText.Resource(R.string.msg_credentials_saved))
+            }
+        }
+    }
+
     /** 把 API Key 缩成 'sk-a***xyz' 这种形式，前 4 后 4，中间用 *** 代替。 */
-    private fun maskedKeyPreview(key: String): String {
-        if (key.length <= 8) return "*** (长度 ${key.length}) ***"
+    private fun maskedKeyPreview(key: String): UiText {
+        if (key.length <= 8) {
+            return UiText.Resource(R.string.msg_key_length, listOf(key.length))
+        }
         val head = key.take(4)
         val tail = key.takeLast(4)
-        return "$head***$tail (长度 ${key.length})"
+        return UiText.Resource(R.string.msg_key_masked, listOf(head, tail, key.length))
     }
 
     fun saveOpenCodeGoSession() {
         val type = serviceType ?: return
         val current = _uiState.value
         if (current.authCookie.isBlank() || current.workspaceId.isBlank()) {
-            _uiState.update { it.copy(message = "auth cookie 和 workspaceId 都需要填写") }
+            _uiState.update {
+                it.copy(message = UiText.Resource(R.string.error_auth_cookie_workspace))
+            }
             return
         }
         viewModelScope.launch {
             doSaveOpenCodeGo(current.workspaceId.trim(), current.authCookie.trim())
-            _uiState.update { it.copy(message = "已保存凭据", hasExisting = true) }
+            _uiState.update {
+                it.copy(message = UiText.Resource(R.string.msg_credentials_saved), hasExisting = true)
+            }
         }
     }
 
@@ -236,7 +534,9 @@ class CredentialEditViewModel @Inject constructor(
         val type = serviceType ?: return
         val current = _uiState.value
         if (current.authCookie.isBlank() || current.workspaceId.isBlank()) {
-            _uiState.update { it.copy(message = "auth cookie 和 workspaceId 都需要填写") }
+            _uiState.update {
+                it.copy(message = UiText.Resource(R.string.error_auth_cookie_workspace))
+            }
             return
         }
         viewModelScope.launch {
@@ -245,7 +545,7 @@ class CredentialEditViewModel @Inject constructor(
             testAndRollback(
                 type = type,
                 saveAndPrep = { previous to { refreshBalanceUseCaseProvider.get().invoke(type) } },
-                formatSuccess = { "连接成功，凭据已保存" },
+                formatSuccess = { UiText.Resource(R.string.msg_connect_success_saved) },
                 rollbackOnFailure = true
             )
         }
@@ -269,12 +569,12 @@ class CredentialEditViewModel @Inject constructor(
         val type = serviceType ?: return
         val current = _uiState.value
         if (current.cookieInput.isBlank()) {
-            _uiState.update { it.copy(message = "Cookie 不能为空") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_cookie_empty)) }
             return
         }
         val cookies = parseCookieString(current.cookieInput)
         if (cookies.isEmpty()) {
-            _uiState.update { it.copy(message = "Cookie 格式错误，应为 name1=value1; name2=value2") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_cookie_format)) }
             return
         }
         viewModelScope.launch {
@@ -289,7 +589,7 @@ class CredentialEditViewModel @Inject constructor(
             credentialRepository.save(updated)
             _uiState.update {
                 it.copy(
-                    message = "已保存 ${cookies.size} 个 Cookie",
+                    message = UiText.Resource(R.string.msg_cookies_saved, listOf(cookies.size)),
                     hasExisting = true,
                     cookieCount = cookies.size
                 )
@@ -306,7 +606,7 @@ class CredentialEditViewModel @Inject constructor(
         val current = _uiState.value
         val text = current.codexAuthJson.trim()
         if (text.isBlank()) {
-            _uiState.update { it.copy(message = "请粘贴 auth.json 内容") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_auth_json_empty)) }
             return
         }
         viewModelScope.launch {
@@ -324,7 +624,9 @@ class CredentialEditViewModel @Inject constructor(
                     ?: System.currentTimeMillis() + 10L * 24 * 3600 * 1000
 
                 if (accessToken.isNullOrBlank() || refreshToken.isNullOrBlank()) {
-                    _uiState.update { it.copy(message = "auth.json 缺少 access_token 或 refresh_token") }
+                    _uiState.update {
+                        it.copy(message = UiText.Resource(R.string.error_auth_json_missing_tokens))
+                    }
                     return@launch
                 }
 
@@ -339,12 +641,22 @@ class CredentialEditViewModel @Inject constructor(
                 credentialRepository.save(newCred)
                 _uiState.update {
                     it.copy(
-                        message = "已保存 Codex 凭据，token 到期后会自动刷新",
+                        message = UiText.Resource(R.string.msg_codex_saved),
                         hasExisting = true
                     )
                 }
             } catch (e: Exception) {
-                _uiState.update { it.copy(message = "解析失败：${e.message ?: "JSON 格式错误"}") }
+                _uiState.update {
+                    it.copy(
+                        message = UiText.Resource(
+                            R.string.error_auth_json_parse,
+                            listOf(
+                                e.message?.let { UiText.Dynamic(it) }
+                                    ?: UiText.Resource(R.string.error_json_format)
+                            )
+                        )
+                    )
+                }
             }
         }
     }
@@ -354,7 +666,7 @@ class CredentialEditViewModel @Inject constructor(
         val current = _uiState.value
         val trimmedKey = current.apiKey.trim()
         if (trimmedKey.isBlank()) {
-            _uiState.update { it.copy(message = "API Key 不能为空") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_api_key_empty)) }
             return
         }
         val cookies = if (current.cookieInput.isNotBlank()) {
@@ -378,7 +690,7 @@ class CredentialEditViewModel @Inject constructor(
             _uiState.update {
                 it.copy(
                     apiKey = trimmedKey,
-                    message = "已保存凭据",
+                    message = UiText.Resource(R.string.msg_credentials_saved),
                     hasExisting = true,
                     cookieCount = cookies.size
                 )
@@ -391,7 +703,7 @@ class CredentialEditViewModel @Inject constructor(
         val current = _uiState.value
         val trimmedKey = current.apiKey.trim()
         if (trimmedKey.isBlank()) {
-            _uiState.update { it.copy(message = "API Key 不能为空") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_api_key_empty)) }
             return
         }
         viewModelScope.launch {
@@ -416,7 +728,10 @@ class CredentialEditViewModel @Inject constructor(
                 type = type,
                 saveAndPrep = { existing to { refreshBalanceUseCaseProvider.get().invoke(type) } },
                 formatSuccess = { bal ->
-                    "连接成功！余额: \$${String.format(java.util.Locale.US, "%.2f", bal.amount)}"
+                    UiText.Resource(
+                        R.string.msg_connect_success_dollar,
+                        listOf(String.format(java.util.Locale.US, "%.2f", bal.amount))
+                    )
                 },
                 rollbackOnFailure = false
             )
@@ -448,7 +763,7 @@ class CredentialEditViewModel @Inject constructor(
             _uiState.update {
                 it.copy(
                     triggerApiKey = trimmedKey,
-                    message = "API Key 已保存",
+                    message = UiText.Resource(R.string.msg_api_key_saved),
                     hasExisting = true
                 )
             }
@@ -459,12 +774,14 @@ class CredentialEditViewModel @Inject constructor(
         val type = serviceType ?: return
         val current = _uiState.value
         if (current.ollamaCookie.isBlank()) {
-            _uiState.update { it.copy(message = "Cookie 不能为空") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_cookie_empty)) }
             return
         }
         viewModelScope.launch {
             doSaveOllama(current.ollamaCookie.trim())
-            _uiState.update { it.copy(message = "已保存凭据", hasExisting = true) }
+            _uiState.update {
+                it.copy(message = UiText.Resource(R.string.msg_credentials_saved), hasExisting = true)
+            }
         }
     }
 
@@ -472,7 +789,7 @@ class CredentialEditViewModel @Inject constructor(
         val type = serviceType ?: return
         val current = _uiState.value
         if (current.ollamaCookie.isBlank()) {
-            _uiState.update { it.copy(message = "Cookie 不能为空") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_cookie_empty)) }
             return
         }
         viewModelScope.launch {
@@ -482,7 +799,10 @@ class CredentialEditViewModel @Inject constructor(
                 type = type,
                 saveAndPrep = { previous to { refreshBalanceUseCaseProvider.get().invoke(type) } },
                 formatSuccess = { bal ->
-                    "连接成功！Session: ${bal.amount}% · ${bal.extras["plan"] ?: "—"}"
+                    UiText.Resource(
+                        R.string.msg_connect_success_session,
+                        listOf(bal.amount.toString(), bal.extras["plan"]?.takeIf { it.isNotBlank() } ?: "—")
+                    )
                 },
                 rollbackOnFailure = true
             )
@@ -504,19 +824,57 @@ class CredentialEditViewModel @Inject constructor(
 
     fun deleteCredential() {
         val type = serviceType ?: return
+        val targetAccountId = accountId
         viewModelScope.launch {
-            credentialRepository.remove(type)
+            if (ServiceType.isMultiAccount(type) && !targetAccountId.isNullOrBlank()) {
+                credentialRepository.removeAccount(type, targetAccountId)
+            } else {
+                credentialRepository.remove(type)
+            }
+            accountId = null
             _uiState.update {
                 it.copy(
-                    message = "凭据已删除",
+                    accountId = null,
+                    accountLabel = null,
+                    accountIndex = 0,
+                    message = UiText.Resource(R.string.msg_credential_deleted),
                     hasExisting = false,
                     apiKey = "",
                     cookieInput = "",
                     authCookie = "",
                     workspaceId = "",
                     cookieCount = 0,
+                    codexAuthJson = "",
                     ollamaCookie = "",
-                    triggerApiKey = ""
+                    triggerApiKey = "",
+                    traeJwt = "",
+                    traeRegion = "CN",
+                    traeCheckinDeviceId = "",
+                    workBuddyAccess = "",
+                    workBuddyRefresh = "",
+                    sub2BaseUrl = "",
+                    sub2Email = "",
+                    sub2Password = "",
+                    sub2ApiKey = ""
+                )
+            }
+        }
+    }
+
+    /** 多账号服务：按当前账号 ID 刷新展示用的账号名与序号。 */
+    private fun refreshAccountInfo() {
+        val type = serviceType ?: return
+        val aid = accountId ?: return
+        viewModelScope.launch {
+            val accounts = credentialRepository.accountsFor(type)
+            val index = accounts.indexOfFirst { it.id == aid }
+            if (index < 0) return@launch
+            val account = accounts[index]
+            _uiState.update {
+                it.copy(
+                    accountId = aid,
+                    accountLabel = account.label?.takeIf { l -> l.isNotBlank() },
+                    accountIndex = index + 1
                 )
             }
         }
@@ -526,11 +884,22 @@ class CredentialEditViewModel @Inject constructor(
         _uiState.update { it.copy(message = null) }
     }
 
+    /** 从 WebView 登录页返回后重载表单与账号信息（当前凭据可能已被登录流程改写）。 */
+    fun reload() {
+        load()
+        refreshAccountInfo()
+    }
+
+    companion object {
+        /** WebView 登录页通过 previousBackStackEntry.savedStateHandle 回传实际写入的账号 ID。 */
+        const val KEY_LOGIN_ACCOUNT_ID = "login_account_id"
+    }
+
     fun importFromClipboard(context: Context) {
         val cm = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return
         val text = cm.primaryClip?.getItemAt(0)?.text?.toString()
         if (text.isNullOrBlank()) {
-            _uiState.update { it.copy(message = "剪贴板为空") }
+            _uiState.update { it.copy(message = UiText.Resource(R.string.error_clipboard_empty)) }
             return
         }
         val ws = extractWorkspaceId(text)
@@ -543,13 +912,13 @@ class CredentialEditViewModel @Inject constructor(
         }
         when {
             ws != null && auth != null ->
-                _uiState.update { it.copy(message = "已识别 workspaceId 和 auth cookie") }
+                _uiState.update { it.copy(message = UiText.Resource(R.string.msg_clipboard_ws_auth)) }
             ws != null ->
-                _uiState.update { it.copy(message = "已识别 workspaceId，请再粘贴 auth cookie") }
+                _uiState.update { it.copy(message = UiText.Resource(R.string.msg_clipboard_ws_only)) }
             auth != null ->
-                _uiState.update { it.copy(message = "已识别 auth cookie，请再粘贴 workspaceId") }
+                _uiState.update { it.copy(message = UiText.Resource(R.string.msg_clipboard_auth_only)) }
             else ->
-                _uiState.update { it.copy(message = "未识别到有效凭据") }
+                _uiState.update { it.copy(message = UiText.Resource(R.string.error_clipboard_none)) }
         }
     }
 
@@ -582,6 +951,12 @@ class CredentialEditViewModel @Inject constructor(
 
 data class CredentialEditUiState(
     val service: ServiceType? = null,
+    /** 当前编辑的账号 ID（多账号服务）；null=新建账号/单账号服务。 */
+    val accountId: String? = null,
+    /** 账号自定义名称（可能为 null，UI 按“账号 N”兜底）。 */
+    val accountLabel: String? = null,
+    /** 同服务内账号序号（1 起，兜底名称用）。 */
+    val accountIndex: Int = 0,
     val isApiKeyService: Boolean = false,
     val loginUrl: String = "",
     val apiKey: String = "",
@@ -594,5 +969,30 @@ data class CredentialEditUiState(
     val ollamaCookie: String = "",
     /** OCGO / Ollama 的一键激活用量 API Key */
     val triggerApiKey: String = "",
-    val message: String? = null
+    /** Trae：Cloud-IDE-JWT + 区域 */
+    val traeJwt: String = "",
+    val traeRegion: String = "CN",
+    /** Trae 签到设备 ID（官方客户端绑定 did；留空用内置默认） */
+    val traeCheckinDeviceId: String = "",
+    /** WorkBuddy：OAuth tokens */
+    val workBuddyAccess: String = "",
+    val workBuddyRefresh: String = "",
+    /** Sub2API：自托管实例连接 */
+    val sub2BaseUrl: String = "",
+    val sub2Email: String = "",
+    val sub2Password: String = "",
+    val sub2ApiKey: String = "",
+    /** Sub2API：WebView/一键登录新获取的面板 Token（保存时并入 authToken） */
+    val sub2PanelToken: String? = null,
+    /** Sub2API：baseUrl 输入后自动探测的站点名称/图标（确认地址填对） */
+    val sub2SiteName: String? = null,
+    val sub2SiteIcon: String? = null,
+    val sub2SiteLoading: Boolean = false,
+    /** Sub2API：一键登录进行中 */
+    val sub2LoggingIn: Boolean = false,
+    /** Sub2API：登录方式（默认账号密码优先；仅存 apiKey 时切 API Key） */
+    val sub2LoginMode: String = "account",
+    /** Sub2API：二次验证码（选填） */
+    val sub2Totp: String = "",
+    val message: UiText? = null
 )

app/src/main/java/com/rainy/token/ui/settings/SettingsScreen.kt

@@ -1,5 +1,7 @@
 package com.rainy.token.ui.settings
 
+import android.app.Activity
+import android.os.Build
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -17,6 +19,7 @@ import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.ArrowBack
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.CircularProgressIndicator
@@ -26,13 +29,19 @@ import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
@@ -45,9 +54,16 @@ import com.rainy.token.ui.components.ServiceIcon
 import com.rainy.token.ui.components.StatusChip
 import com.rainy.token.ui.components.StatusLevel
 import com.rainy.token.ui.components.StatusStyle
+import android.content.Intent
+import android.net.Uri
+import android.provider.Settings
+import androidx.compose.material3.Button
+import androidx.compose.material3.LinearProgressIndicator
+import com.rainy.token.R
 import com.rainy.token.ui.components.AppTips
 import com.rainy.token.ui.theme.InkMuted
 import com.rainy.token.ui.theme.StrawberryPink
+import com.rainy.token.util.LocaleManager
 
 /**
  * 设置页（雨晴风格重做版）。
@@ -62,6 +78,7 @@ import com.rainy.token.ui.theme.StrawberryPink
 fun SettingsScreen(
     onBack: () -> Unit,
     onEditCredential: (ServiceType) -> Unit,
+    onManageAccounts: (ServiceType) -> Unit = {},
     onOpenTips: () -> Unit = {},
     onOpenDebugLog: () -> Unit = {},
     viewModel: SettingsViewModel = hiltViewModel()
@@ -72,6 +89,7 @@ fun SettingsScreen(
     }
 
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    var showLanguageDialog by remember { mutableStateOf(false) }
 
     Scaffold(
         containerColor = Color.Transparent,
@@ -79,7 +97,7 @@ fun SettingsScreen(
             TopAppBar(
                 title = {
                     Text(
-                        "设置",
+                        stringResource(R.string.title_settings),
                         style = MaterialTheme.typography.titleLarge,
                         fontWeight = FontWeight.SemiBold
                     )
@@ -88,7 +106,7 @@ fun SettingsScreen(
                     IconButton(onClick = onBack) {
                         Icon(
                             Icons.Filled.ArrowBack,
-                            contentDescription = "返回",
+                            contentDescription = stringResource(R.string.action_back),
                             tint = StrawberryPink
                         )
                     }
@@ -118,25 +136,38 @@ fun SettingsScreen(
             ) {
                 item {
                     Text(
-                        text = "凭据管理",
+                        text = stringResource(R.string.title_credentials),
                         style = MaterialTheme.typography.titleMedium,
                         fontWeight = FontWeight.SemiBold,
                         color = InkMuted,
                         modifier = Modifier.padding(start = 4.dp, bottom = 4.dp)
                     )
                 }
-                items(uiState.credentialStatuses, key = { it.service.name }) { status ->
+                items(uiState.credentialStatuses, key = { it.status.service.name }) { line ->
                     CredentialStatusCard(
-                        status = status,
-                        onClick = { onEditCredential(status.service) }
+                        status = line.status,
+                        accountCount = line.accountCount,
+                        onClick = {
+                            if (ServiceType.isMultiAccount(line.status.service)) {
+                                onManageAccounts(line.status.service)
+                            } else {
+                                onEditCredential(line.status.service)
+                            }
+                        }
                     )
                 }
+                item {
+                    LanguageCard(onClick = { showLanguageDialog = true })
+                }
                 item {
                     TipsCard(onClick = { onOpenTips() })
                 }
                 item {
                     DebugLogCard(onClick = { onOpenDebugLog() })
                 }
+                item {
+                    UpdateCard()
+                }
                 item {
                     Spacer(modifier = Modifier.padding(top = 8.dp))
                     AboutCard()
@@ -144,10 +175,113 @@ fun SettingsScreen(
             }
         }
     }
+
+    if (showLanguageDialog) {
+        LanguageDialog(onDismiss = { showLanguageDialog = false })
+    }
 }
 
 @Composable
-private fun CredentialStatusCard(status: CredentialStatus, onClick: () -> Unit) {
+private fun LanguageCard(onClick: () -> Unit) {
+    val context = LocalContext.current
+    val current = LocaleManager.getLocaleCode(context)
+    val labelRes = when (current) {
+        "zh" -> R.string.app_locale_zh
+        "zh-Hant" -> R.string.app_locale_zh_hant
+        "en" -> R.string.app_locale_en
+        else -> R.string.app_locale_follow_system
+    }
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable { onClick() },
+        shape = RoundedCornerShape(20.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Text(
+                text = "🌐",
+                style = MaterialTheme.typography.titleLarge
+            )
+            Spacer(modifier = Modifier.width(12.dp))
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = stringResource(R.string.title_language),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.SemiBold
+                )
+                Text(
+                    text = stringResource(labelRes),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = InkMuted,
+                    modifier = Modifier.padding(top = 2.dp)
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun LanguageDialog(onDismiss: () -> Unit) {
+    val context = LocalContext.current
+    val current = LocaleManager.getLocaleCode(context)
+    val options: List<Pair<String?, Int>> = listOf(
+        null to R.string.app_locale_follow_system,
+        "zh" to R.string.app_locale_zh,
+        "zh-Hant" to R.string.app_locale_zh_hant,
+        "en" to R.string.app_locale_en
+    )
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.dialog_language_title)) },
+        text = {
+            Column {
+                options.forEach { (code, labelRes) ->
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .clickable {
+                                LocaleManager.saveLocale(context, code)
+                                onDismiss()
+                                // Android 13+：framework 设置语言后系统自动重建 Activity；
+                                // 旧系统才需要手动 recreate 让资源按新语言重新解析
+                                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+                                    (context as? Activity)?.recreate()
+                                }
+                            }
+                            .padding(vertical = 12.dp),
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Text(
+                            text = stringResource(labelRes),
+                            style = MaterialTheme.typography.bodyMedium,
+                            modifier = Modifier.weight(1f)
+                        )
+                        if (current == code) {
+                            Text("✓", color = StrawberryPink, style = MaterialTheme.typography.bodyMedium)
+                        }
+                    }
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onDismiss) {
+                Text(stringResource(R.string.action_cancel))
+            }
+        }
+    )
+}
+
+@Composable
+private fun CredentialStatusCard(
+    status: CredentialStatus,
+    accountCount: Int = 0,
+    onClick: () -> Unit
+) {
     Card(
         modifier = Modifier
             .fillMaxWidth()
@@ -169,7 +303,11 @@ private fun CredentialStatusCard(status: CredentialStatus, onClick: () -> Unit)
                     fontWeight = FontWeight.SemiBold
                 )
                 Text(
-                    text = stateLabel(status.state),
+                    text = if (accountCount > 0) {
+                        stringResource(R.string.account_count_line, stateLabel(status.state), accountCount)
+                    } else {
+                        stateLabel(status.state)
+                    },
                     style = MaterialTheme.typography.bodySmall,
                     color = InkMuted,
                     modifier = Modifier.padding(top = 2.dp)
@@ -180,6 +318,142 @@ private fun CredentialStatusCard(status: CredentialStatus, onClick: () -> Unit)
     }
 }
 
+@Composable
+private fun UpdateCard(
+    viewModel: UpdateViewModel = hiltViewModel()
+) {
+    val state by viewModel.uiState.collectAsStateWithLifecycle()
+    val context = LocalContext.current
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(20.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+        elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
+    ) {
+        Column(modifier = Modifier.padding(20.dp)) {
+            Text(
+                text = stringResource(R.string.title_update),
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.SemiBold
+            )
+            Spacer(modifier = Modifier.padding(top = 8.dp))
+            Text(
+                text = stringResource(
+                    R.string.update_current_version,
+                    state.currentVersionName,
+                    state.currentVersionCode
+                ),
+                style = MaterialTheme.typography.bodyMedium,
+                color = InkMuted
+            )
+            Spacer(modifier = Modifier.padding(top = 12.dp))
+            when (val phase = state.phase) {
+                is UpdateViewModel.Phase.Idle -> Unit
+                is UpdateViewModel.Phase.Checking -> {
+                    Row(verticalAlignment = Alignment.CenterVertically) {
+                        CircularProgressIndicator(
+                            modifier = Modifier.width(18.dp).height(18.dp),
+                            color = StrawberryPink,
+                            strokeWidth = 2.dp
+                        )
+                        Spacer(modifier = Modifier.width(8.dp))
+                        Text(
+                            text = stringResource(R.string.update_checking),
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = InkMuted
+                        )
+                    }
+                }
+                is UpdateViewModel.Phase.Latest -> {
+                    Text(
+                        text = stringResource(R.string.update_latest),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = InkMuted
+                    )
+                    Spacer(modifier = Modifier.padding(top = 8.dp))
+                    TextButton(onClick = { viewModel.checkForUpdate() }) {
+                        Text(stringResource(R.string.update_check))
+                    }
+                }
+                is UpdateViewModel.Phase.Available -> {
+                    Text(
+                        text = stringResource(R.string.update_available, phase.info.versionName),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = StrawberryPink,
+                        fontWeight = FontWeight.SemiBold
+                    )
+                    if (phase.info.notes.isNotBlank()) {
+                        Spacer(modifier = Modifier.padding(top = 4.dp))
+                        Text(
+                            text = phase.info.notes,
+                            style = MaterialTheme.typography.bodySmall,
+                            color = InkMuted
+                        )
+                    }
+                    Spacer(modifier = Modifier.padding(top = 12.dp))
+                    Button(onClick = { viewModel.downloadAndInstall(phase.info) }) {
+                        Text(stringResource(R.string.update_download))
+                    }
+                }
+                is UpdateViewModel.Phase.Downloading -> {
+                    LinearProgressIndicator(
+                        progress = { phase.progress },
+                        modifier = Modifier.fillMaxWidth()
+                    )
+                    Spacer(modifier = Modifier.padding(top = 4.dp))
+                    Text(
+                        text = stringResource(
+                            R.string.update_downloading,
+                            (phase.progress * 100).toInt()
+                        ),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = InkMuted
+                    )
+                }
+                is UpdateViewModel.Phase.Ready -> {
+                    Text(
+                        text = stringResource(R.string.update_download_finished),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = InkMuted
+                    )
+                    Spacer(modifier = Modifier.padding(top = 8.dp))
+                    Button(onClick = { viewModel.install(phase.file) }) {
+                        Text(stringResource(R.string.update_install))
+                    }
+                }
+                is UpdateViewModel.Phase.NeedInstallPermission -> {
+                    Text(
+                        text = stringResource(R.string.update_install_permission_tip),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.error
+                    )
+                    Spacer(modifier = Modifier.padding(top = 8.dp))
+                    Button(onClick = {
+                        val intent = Intent(
+                            Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES,
+                            Uri.parse("package:" + context.packageName)
+                        )
+                        runCatching { context.startActivity(intent) }
+                    }) {
+                        Text(stringResource(R.string.update_enable_permission))
+                    }
+                }
+                is UpdateViewModel.Phase.Error -> {
+                    Text(
+                        text = stringResource(R.string.update_failed, phase.message),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.error
+                    )
+                    Spacer(modifier = Modifier.padding(top = 8.dp))
+                    TextButton(onClick = { viewModel.checkForUpdate() }) {
+                        Text(stringResource(R.string.update_check))
+                    }
+                }
+            }
+        }
+    }
+}
+
 @Composable
 private fun AboutCard() {
     Card(
@@ -190,13 +464,13 @@ private fun AboutCard() {
     ) {
         Column(modifier = Modifier.padding(20.dp)) {
             Text(
-                text = "关于 RainyToken",
+                text = stringResource(R.string.title_about),
                 style = MaterialTheme.typography.titleMedium,
                 fontWeight = FontWeight.SemiBold
             )
             Spacer(modifier = Modifier.padding(top = 8.dp))
             Text(
-                text = "统一查询 AI 余额的小工具。\n本地加密存储凭据，不上传任何数据。",
+                text = stringResource(R.string.about_description),
                 style = MaterialTheme.typography.bodyMedium,
                 color = InkMuted
             )
@@ -204,18 +478,19 @@ private fun AboutCard() {
     }
 }
 
+@Composable
 private fun stateLabel(state: CredentialStatus.State): String = when (state) {
-    CredentialStatus.State.NOT_CONFIGURED -> "未配置 · 点击添加"
-    CredentialStatus.State.OK -> "已配置 · 凭据有效"
-    CredentialStatus.State.EXPIRED -> "已过期 · 点击重新配置"
-    CredentialStatus.State.WARNING -> "需要重新验证"
+    CredentialStatus.State.NOT_CONFIGURED -> stringResource(R.string.status_not_configured_add)
+    CredentialStatus.State.OK -> stringResource(R.string.status_ok_valid)
+    CredentialStatus.State.EXPIRED -> stringResource(R.string.status_expired_reconfigure)
+    CredentialStatus.State.WARNING -> stringResource(R.string.status_need_reverify)
 }
 
 private fun stateToChip(state: CredentialStatus.State): StatusStyle = when (state) {
-    CredentialStatus.State.NOT_CONFIGURED -> StatusStyle("未配置", StatusLevel.WARNING)
-    CredentialStatus.State.OK -> StatusStyle("已配置", StatusLevel.OK)
-    CredentialStatus.State.EXPIRED -> StatusStyle("已过期", StatusLevel.ERROR)
-    CredentialStatus.State.WARNING -> StatusStyle("需重登", StatusLevel.WARNING)
+    CredentialStatus.State.NOT_CONFIGURED -> StatusStyle(R.string.status_not_configured, StatusLevel.WARNING)
+    CredentialStatus.State.OK -> StatusStyle(R.string.status_configured, StatusLevel.OK)
+    CredentialStatus.State.EXPIRED -> StatusStyle(R.string.status_expired, StatusLevel.ERROR)
+    CredentialStatus.State.WARNING -> StatusStyle(R.string.status_relogin, StatusLevel.WARNING)
 }
 
 @Composable
@@ -239,13 +514,13 @@ private fun TipsCard(onClick: () -> Unit) {
             Spacer(modifier = Modifier.width(12.dp))
             Column(modifier = Modifier.weight(1f)) {
                 Text(
-                    text = "使用小技巧",
+                    text = stringResource(R.string.title_tips),
                     style = MaterialTheme.typography.titleMedium,
                     fontWeight = FontWeight.SemiBold,
                     color = StrawberryPink
                 )
                 Text(
-                    text = "查看全部 ${AppTips.tips.size} 条隐藏操作",
+                    text = stringResource(R.string.tips_view_all, AppTips.tips.size),
                     style = MaterialTheme.typography.bodySmall,
                     color = InkMuted,
                     modifier = Modifier.padding(top = 2.dp)
@@ -276,13 +551,13 @@ private fun DebugLogCard(onClick: () -> Unit) {
             Spacer(modifier = Modifier.width(12.dp))
             Column(modifier = Modifier.weight(1f)) {
                 Text(
-                    text = "调试日志",
+                    text = stringResource(R.string.title_debug_log),
                     style = MaterialTheme.typography.titleMedium,
                     fontWeight = FontWeight.SemiBold,
                     color = InkMuted
                 )
                 Text(
-                    text = "查看 token 刷新、网络请求等调试记录",
+                    text = stringResource(R.string.debug_log_desc),
                     style = MaterialTheme.typography.bodySmall,
                     color = InkMuted,
                     modifier = Modifier.padding(top = 2.dp)

app/src/main/java/com/rainy/token/ui/settings/SettingsViewModel.kt

@@ -4,6 +4,7 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.rainy.token.data.repository.CredentialRepository
 import com.rainy.token.domain.model.CredentialStatus
+import com.rainy.token.domain.service.ServiceType
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -32,8 +33,16 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch {
             _uiState.update { it.copy(loading = true) }
             val statuses = credentialRepository.statusForAll()
+            val lines = statuses.map { status ->
+                val accountCount = if (ServiceType.isMultiAccount(status.service)) {
+                    credentialRepository.accountsFor(status.service).size
+                } else {
+                    0
+                }
+                CredentialStatusLine(status = status, accountCount = accountCount)
+            }
             _uiState.update {
-                it.copy(loading = false, credentialStatuses = statuses)
+                it.copy(loading = false, credentialStatuses = lines)
             }
         }
     }
@@ -41,5 +50,11 @@ class SettingsViewModel @Inject constructor(
 
 data class SettingsUiState(
     val loading: Boolean = false,
-    val credentialStatuses: List<CredentialStatus> = emptyList()
+    val credentialStatuses: List<CredentialStatusLine> = emptyList()
+)
+
+/** 凭据状态行：单账号服务 [accountCount]=0；多账号服务为账号数（0 表示尚未配置）。 */
+data class CredentialStatusLine(
+    val status: CredentialStatus,
+    val accountCount: Int = 0
 )

app/src/main/java/com/rainy/token/ui/settings/UpdateViewModel.kt

@@ -0,0 +1,98 @@
+package com.rainy.token.ui.settings
+
+import android.content.Context
+import android.content.Intent
+import androidx.core.content.FileProvider
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.rainy.token.BuildConfig
+import com.rainy.token.data.repository.UpdateRepository
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.io.File
+import javax.inject.Inject
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+/** 设置页更新模块：检查更新 → 下载 APK → 拉起系统安装器。 */
+@HiltViewModel
+class UpdateViewModel @Inject constructor(
+    private val updateRepository: UpdateRepository,
+    @ApplicationContext private val context: Context
+) : ViewModel() {
+
+    sealed interface Phase {
+        object Idle : Phase
+        object Checking : Phase
+        object Latest : Phase
+        data class Available(val info: UpdateRepository.UpdateInfo) : Phase
+        data class Downloading(val progress: Float) : Phase
+        data class Ready(val file: File) : Phase
+        object NeedInstallPermission : Phase
+        data class Error(val message: String) : Phase
+    }
+
+    data class UiState(
+        val phase: Phase = Phase.Idle,
+        val currentVersionName: String = BuildConfig.VERSION_NAME,
+        val currentVersionCode: Int = BuildConfig.VERSION_CODE
+    )
+
+    private val _uiState = MutableStateFlow(UiState())
+    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
+
+    init {
+        checkForUpdate()
+    }
+
+    fun checkForUpdate() {
+        _uiState.update { it.copy(phase = Phase.Checking) }
+        viewModelScope.launch {
+            updateRepository.checkForUpdate().fold(
+                onSuccess = { info ->
+                    _uiState.update {
+                        it.copy(phase = if (info == null) Phase.Latest else Phase.Available(info))
+                    }
+                },
+                onFailure = { e ->
+                    _uiState.update { it.copy(phase = Phase.Error(e.message ?: "unknown")) }
+                }
+            )
+        }
+    }
+
+    fun downloadAndInstall(info: UpdateRepository.UpdateInfo) {
+        _uiState.update { it.copy(phase = Phase.Downloading(0f)) }
+        viewModelScope.launch {
+            updateRepository.downloadApk(info) { downloaded, total ->
+                val progress = if (total > 0) downloaded.toFloat() / total else 0f
+                _uiState.update { it.copy(phase = Phase.Downloading(progress)) }
+            }.fold(
+                onSuccess = { file -> install(file) },
+                onFailure = { e ->
+                    _uiState.update { it.copy(phase = Phase.Error(e.message ?: "unknown")) }
+                }
+            )
+        }
+    }
+
+    fun install(file: File) {
+        if (context.packageManager.canRequestPackageInstalls()) {
+            _uiState.update { it.copy(phase = Phase.Ready(file)) }
+            val authority = context.packageName + ".fileprovider"
+            val uri = FileProvider.getUriForFile(context, authority, file)
+            val intent = Intent(Intent.ACTION_VIEW).apply {
+                setDataAndType(uri, "application/vnd.android.package-archive")
+                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_ACTIVITY_NEW_TASK)
+            }
+            runCatching { context.startActivity(intent) }.onFailure { e ->
+                _uiState.update { it.copy(phase = Phase.Error(e.message ?: "cannot start installer")) }
+            }
+        } else {
+            _uiState.update { it.copy(phase = Phase.NeedInstallPermission) }
+        }
+    }
+}

app/src/main/java/com/rainy/token/ui/theme/Color.kt

@@ -3,40 +3,41 @@ package com.rainy.token.ui.theme
 import androidx.compose.ui.graphics.Color
 
 /**
- * 雨晴风格配色（RainyStyle Palette）。
+ * 雨晴风格配色（RainyStyle Palette）— 精致粉调。
  *
- * 视觉基调：元气樱粉 / 草莓粉主调，搭配纯白卡片与暖灰文本。
+ * 视觉基调：低饱和樱粉白背景 + 纯白卡片 + 深玫瑰主色点缀，
+ * 通过克制用色与留白呈现精致感，保留"雨晴粉"品牌识别度。
  * 状态色：草绿（正常）、暖橙（注意）、玫红（异常）。
  *
- * 背景使用樱粉渐变（#FFF0F5 → #FFD1DC），主元素采用草莓粉
- * （#FF85A2 / #FF6B8E），与白色形成层次。
+ * 背景使用柔和粉白渐变（#FFF9FB → #FDEFF4），主元素采用深玫瑰
+ * （#C9436C / #B3305B），与白色形成优雅层次。
  */
 
 // ─── 品牌主色 ───
-val CherryPinkLight = Color(0xFFFFF0F5)   // 樱粉浅（背景起始）
-val CherryPinkDeep = Color(0xFFFFD1DC)    // 樱粉深（背景结束）
-val StrawberryPink = Color(0xFFFF85A2)    // 草莓粉（主色 / 强调）
-val StrawberryPinkDark = Color(0xFFFF6B8E)// 草莓粉深（按下态 / 主按钮）
-val StrawberryPinkSoft = Color(0xFFFFB3C6)// 草莓粉柔（hover / 副按钮）
+val CherryPinkLight = Color(0xFFFFF9FB)   // 粉白（背景起始）
+val CherryPinkDeep = Color(0xFFFDEFF4)    // 浅樱粉（背景结束）
+val StrawberryPink = Color(0xFFC9436C)    // 深玫瑰（主色 / 强调，白底对比度 ≥ 4.5:1）
+val StrawberryPinkDark = Color(0xFFB3305B)// 深玫瑰按下态（主按钮）
+val StrawberryPinkSoft = Color(0xFFFFC9D8)// 浅玫瑰柔（容器 / 选中背景）
 
 // ─── 中性色 ───
 val PureWhite = Color(0xFFFFFFFF)
-val SnowWhite = Color(0xFFFAF6F8)         // 卡片次级背景
-val InkWarm = Color(0xFF3D2C35)           // 暖黑（主文本）
-val InkMuted = Color(0xFF7A6B72)          // 暖灰（次要文本）
-val InkOutline = Color(0xFFD9CFD3)        // 暖灰（分隔线 / 描边）
+val SnowWhite = Color(0xFFFAF5F7)         // 卡片次级背景
+val InkWarm = Color(0xFF3A2B31)           // 暖黑（主文本）
+val InkMuted = Color(0xFF7A6870)          // 暖灰（次要文本，白底 ≥ 4.5:1）
+val InkOutline = Color(0xFFE8DCE1)        // 暖灰（分隔线 / 描边）
 
 // ─── 状态色 ───
-val StatusGreen = Color(0xFF66BB6A)       // 正常
+val StatusGreen = Color(0xFF4CAF50)       // 正常
 val StatusOrange = Color(0xFFFFA726)      // 注意 / 需重登
-val StatusRed = Color(0xFFE91E63)         // 错误 / 异常
+val StatusRed = Color(0xFFD64A6E)         // 错误 / 异常（玫红，与粉调统一）
 val StatusBlue = Color(0xFF64B5F6)        // 信息（Stale 缓存）
 
 // ─── 暗色模式 ───
-val DarkBackground = Color(0xFF1F1419)    // 暖深背景
-val DarkSurface = Color(0xFF2A1F25)       // 卡片
-val DarkOnSurface = Color(0xFFEFE0E5)     // 卡片文本
-val DarkPrimary = Color(0xFFFFB3C6)       // 暗色下主色更亮
-val DarkInkWarm = Color(0xFFEFE0E5)       // 暗色下暖黑→浅粉白
-val DarkInkMuted = Color(0xFFC9B8BE)      // 暗色下暖灰→浅灰粉
-val DarkInkOutline = Color(0xFF4D3A42)    // 暗色下描边
+val DarkBackground = Color(0xFF1A1417)    // 暖深背景
+val DarkSurface = Color(0xFF251C21)       // 卡片
+val DarkOnSurface = Color(0xFFF2E6EB)     // 卡片文本
+val DarkPrimary = Color(0xFFFFA9BF)       // 暗色下主色更亮
+val DarkInkWarm = Color(0xFFF2E6EB)       // 暗色下暖黑→浅粉白
+val DarkInkMuted = Color(0xFFCBB8C0)      // 暗色下暖灰→浅灰粉
+val DarkInkOutline = Color(0xFF4C3B44)    // 暗色下描边

app/src/main/java/com/rainy/token/ui/theme/Theme.kt

@@ -13,21 +13,22 @@ import androidx.compose.ui.platform.LocalView
 import androidx.core.view.WindowCompat
 
 /**
- * 雨晴风格主题。
+ * 雨晴风格主题（精致粉调）。
  *
- * - **不使用** dynamicColor（系统主题色），固定使用雨晴樱粉品牌色。
+ * - **不使用** dynamicColor（系统主题色），固定使用雨晴玫瑰粉品牌色。
  *   理由：dynamicColor 会让 APP 视觉随系统变化，破坏品牌一致性；
  *   玩家一眼看到 APP icon + 粉色调就知道是 RainyToken 系列。
- * - 暗色模式：暖深背景 + 亮草莓粉强调，跟 Light 模式同色系不同明度。
+ * - 主色：深玫瑰 #C9436C；容器色：浅玫瑰粉；背景：低饱和粉白渐变。
+ * - 暗色模式：暖深背景 + 亮玫瑰粉强调，跟 Light 模式同色系不同明度。
  */
 private val LightColors = lightColorScheme(
     primary = StrawberryPink,
     onPrimary = PureWhite,
     primaryContainer = StrawberryPinkSoft,
-    onPrimaryContainer = InkWarm,
-    secondary = StrawberryPinkDark,
+    onPrimaryContainer = Color(0xFF5C112C),
+    secondary = Color(0xFFB7698B),
     onSecondary = PureWhite,
-    secondaryContainer = Color(0xFFFFE4EC),
+    secondaryContainer = Color(0xFFFFE7EE),
     onSecondaryContainer = InkWarm,
     tertiary = StatusGreen,
     onTertiary = PureWhite,
@@ -38,32 +39,32 @@ private val LightColors = lightColorScheme(
     surfaceVariant = SnowWhite,
     onSurfaceVariant = InkMuted,
     outline = InkOutline,
-    outlineVariant = Color(0xFFEFE0E5),
+    outlineVariant = Color(0xFFF2E7EB),
     error = StatusRed,
     onError = PureWhite
 )
 
 private val DarkColors = darkColorScheme(
     primary = DarkPrimary,
-    onPrimary = DarkBackground,
-    primaryContainer = StrawberryPinkDark,
-    onPrimaryContainer = PureWhite,
+    onPrimary = Color(0xFF4A1025),
+    primaryContainer = Color(0xFF6B2C42),
+    onPrimaryContainer = DarkOnSurface,
     secondary = StrawberryPink,
     onSecondary = DarkBackground,
     secondaryContainer = Color(0xFF4A2E3A),
     onSecondaryContainer = DarkOnSurface,
-    tertiary = StatusGreen,
-    onTertiary = DarkBackground,
+    tertiary = Color(0xFF7BCF9E),
+    onTertiary = Color(0xFF0D2B1C),
     background = DarkBackground,
     onBackground = DarkOnSurface,
     surface = DarkSurface,
     onSurface = DarkOnSurface,
-    surfaceVariant = Color(0xFF352329),
-    onSurfaceVariant = Color(0xFFC9B8BE),
-    outline = Color(0xFF4D3A42),
-    outlineVariant = Color(0xFF3A2A30),
-    error = Color(0xFFFF6B8E),
-    onError = PureWhite
+    surfaceVariant = Color(0xFF32262C),
+    onSurfaceVariant = Color(0xFFCBB8C0),
+    outline = Color(0xFF4C3B44),
+    outlineVariant = Color(0xFF3B2C33),
+    error = Color(0xFFFF8194),
+    onError = Color(0xFF4A1025)
 )
 
 @Composable

app/src/main/java/com/rainy/token/ui/webview/CodexOAuthScreen.kt

@@ -43,11 +43,15 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
+import com.rainy.token.ui.components.UiText
+import com.rainy.token.ui.components.asString
 import com.rainy.token.ui.theme.StrawberryPink
 
 /**
@@ -77,10 +81,10 @@ fun CodexOAuthScreen(
     Scaffold(
         topBar = {
             TopAppBar(
-                title = { Text("Codex OAuth 登录") },
+                title = { Text(stringResource(R.string.oauth_screen_title)) },
                 navigationIcon = {
                     IconButton(onClick = onBack) {
-                        Icon(Icons.Filled.ArrowBack, contentDescription = "返回")
+                        Icon(Icons.Filled.ArrowBack, contentDescription = stringResource(R.string.action_back))
                     }
                 }
             )
@@ -100,7 +104,7 @@ fun CodexOAuthScreen(
                     ) {
                         CircularProgressIndicator(color = StrawberryPink)
                         Text(
-                            "正在交换 Token...",
+                            stringResource(R.string.oauth_exchanging),
                             modifier = Modifier.padding(top = 16.dp),
                             style = MaterialTheme.typography.bodyLarge
                         )
@@ -116,12 +120,12 @@ fun CodexOAuthScreen(
                         verticalArrangement = Arrangement.Center
                     ) {
                         Text(
-                            uiState.error!!,
+                            uiState.error!!.asString(),
                             style = MaterialTheme.typography.bodyLarge,
-                            color = androidx.compose.ui.graphics.Color(0xFFE91E63)
+                            color = MaterialTheme.colorScheme.error
                         )
                         TextButton(onClick = { viewModel.start(CodexOAuthMode.WEBVIEW) }) {
-                            Text("重试", color = StrawberryPink)
+                            Text(stringResource(R.string.action_retry), color = StrawberryPink)
                         }
                     }
                 }
@@ -180,7 +184,7 @@ fun CodexOAuthScreen(
                     ) {
                         CircularProgressIndicator(color = StrawberryPink)
                         Text(
-                            "正在准备授权...",
+                            stringResource(R.string.oauth_preparing),
                             modifier = Modifier.padding(top = 16.dp),
                             style = MaterialTheme.typography.bodyLarge
                         )
@@ -197,7 +201,7 @@ fun CodexOAuthScreen(
 @Composable
 private fun HeadlessOAuthContent(
     authUrl: String,
-    error: String?,
+    error: UiText?,
     onCopyUrl: () -> Unit,
     onOpenInBrowser: () -> Unit,
     onSubmit: (String) -> Unit,
@@ -213,16 +217,12 @@ private fun HeadlessOAuthContent(
         verticalArrangement = Arrangement.spacedBy(12.dp)
     ) {
         Text(
-            text = "无头模式登录",
+            text = stringResource(R.string.oauth_headless_title),
             style = MaterialTheme.typography.titleMedium,
             color = StrawberryPink
         )
         Text(
-            text = "1. 点击「在浏览器中打开」或复制下方链接到浏览器\n" +
-                    "2. 在 OpenAI 页面完成登录和授权\n" +
-                    "3. 浏览器会跳转到一个 localhost 地址（页面打不开是正常的）\n" +
-                    "4. 复制浏览器地址栏的完整 URL 粘贴到下方输入框\n" +
-                    "5. 点击「提交回调 URL」",
+            text = stringResource(R.string.oauth_steps),
             style = MaterialTheme.typography.bodySmall,
             color = MaterialTheme.colorScheme.outline
         )
@@ -231,7 +231,7 @@ private fun HeadlessOAuthContent(
         OutlinedTextField(
             value = authUrl,
             onValueChange = {},
-            label = { Text("授权链接") },
+            label = { Text(stringResource(R.string.oauth_auth_url_label)) },
             readOnly = true,
             minLines = 3,
             maxLines = 5,
@@ -246,18 +246,18 @@ private fun HeadlessOAuthContent(
                 onClick = onOpenInBrowser,
                 modifier = Modifier.weight(1f)
             ) {
-                Text("在浏览器中打开")
+                Text(stringResource(R.string.action_open_in_browser))
             }
             OutlinedButton(
                 onClick = onCopyUrl,
                 modifier = Modifier.weight(1f)
             ) {
-                Text("复制链接")
+                Text(stringResource(R.string.action_copy_link))
             }
         }
 
         Text(
-            text = "── 登录后粘贴回调 URL ──",
+            text = stringResource(R.string.oauth_paste_callback_hint),
             style = MaterialTheme.typography.labelSmall,
             color = MaterialTheme.colorScheme.outline,
             modifier = Modifier.fillMaxWidth().padding(top = 8.dp),
@@ -267,8 +267,8 @@ private fun HeadlessOAuthContent(
         OutlinedTextField(
             value = callbackUrl,
             onValueChange = { callbackUrl = it },
-            label = { Text("回调 URL") },
-            placeholder = { Text("http://localhost:1455/auth/callback?code=...") },
+            label = { Text(stringResource(R.string.oauth_callback_url_label)) },
+            placeholder = { Text(stringResource(R.string.oauth_callback_url_placeholder)) },
             minLines = 2,
             maxLines = 6,
             modifier = Modifier.fillMaxWidth()
@@ -279,18 +279,18 @@ private fun HeadlessOAuthContent(
             modifier = Modifier.fillMaxWidth(),
             enabled = callbackUrl.isNotBlank()
         ) {
-            Text("提交回调 URL")
+            Text(stringResource(R.string.action_submit_callback))
         }
 
         if (error != null) {
             Text(
-                text = error,
+                text = error.asString(),
                 style = MaterialTheme.typography.bodySmall,
-                color = androidx.compose.ui.graphics.Color(0xFFE91E63),
+                color = MaterialTheme.colorScheme.error,
                 modifier = Modifier.padding(top = 4.dp)
             )
             TextButton(onClick = onRetry) {
-                Text("重新生成授权链接", color = StrawberryPink)
+                Text(stringResource(R.string.action_regenerate_link), color = StrawberryPink)
             }
         }
     }

app/src/main/java/com/rainy/token/ui/webview/CodexOAuthViewModel.kt

@@ -2,11 +2,13 @@ package com.rainy.token.ui.webview
 
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.rainy.token.R
 import com.rainy.token.data.debug.DebugLog
 import com.rainy.token.data.repository.CodexOAuthHelper
 import com.rainy.token.data.repository.CredentialRepository
 import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.service.ServiceType
+import com.rainy.token.ui.components.UiText
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -80,7 +82,14 @@ class CodexOAuthViewModel @Inject constructor(
      */
     private fun handleCallbackUrl(url: String) {
         if (!url.startsWith(CodexOAuthHelper.CALLBACK_PREFIX)) {
-            _uiState.update { it.copy(error = "URL 应以 ${CodexOAuthHelper.CALLBACK_PREFIX} 开头") }
+            _uiState.update {
+                it.copy(
+                    error = UiText.Resource(
+                        R.string.error_oauth_url_prefix,
+                        listOf(CodexOAuthHelper.CALLBACK_PREFIX)
+                    )
+                )
+            }
             return
         }
 
@@ -92,19 +101,21 @@ class CodexOAuthViewModel @Inject constructor(
         if (error != null) {
             val errorDesc = uri.getQueryParameter("error_description") ?: error
             DebugLog.e(TAG, "OAuth 授权失败: $errorDesc")
-            _uiState.update { it.copy(error = "授权失败: $errorDesc") }
+            _uiState.update {
+                it.copy(error = UiText.Resource(R.string.error_oauth_auth_failed, listOf(errorDesc)))
+            }
             return
         }
 
         if (receivedState != _uiState.value.expectedState) {
             DebugLog.e(TAG, "OAuth state 不匹配（CSRF 防护）")
-            _uiState.update { it.copy(error = "State 不匹配，请重试") }
+            _uiState.update { it.copy(error = UiText.Resource(R.string.error_oauth_state_mismatch)) }
             return
         }
 
         if (code.isNullOrBlank()) {
             DebugLog.e(TAG, "OAuth 回调缺少 code 参数")
-            _uiState.update { it.copy(error = "回调缺少授权码") }
+            _uiState.update { it.copy(error = UiText.Resource(R.string.error_oauth_missing_code)) }
             return
         }
 
@@ -118,7 +129,12 @@ class CodexOAuthViewModel @Inject constructor(
 
             if (result == null) {
                 DebugLog.e(TAG, "token 交换失败")
-                _uiState.update { it.copy(exchanging = false, error = "Token 交换失败，请查看调试日志") }
+                _uiState.update {
+                    it.copy(
+                        exchanging = false,
+                        error = UiText.Resource(R.string.error_oauth_token_exchange)
+                    )
+                }
                 return@launch
             }
 
@@ -149,5 +165,5 @@ data class CodexOAuthUiState(
     val expectedState: String? = null,
     val exchanging: Boolean = false,
     val loginSucceeded: Boolean = false,
-    val error: String? = null
+    val error: UiText? = null
 )

app/src/main/java/com/rainy/token/ui/webview/WebViewLoginScreen.kt

@@ -13,11 +13,14 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
@@ -26,12 +29,18 @@ import androidx.compose.material.icons.filled.ArrowBack
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rainy.token.R
+import com.rainy.token.data.debug.DebugLog
 import com.rainy.token.domain.service.ServiceType
+import com.rainy.token.ui.components.asString
 
 /**
  * 通用 WebView 登录容器。计划 4.1：
@@ -44,17 +53,34 @@ import com.rainy.token.domain.service.ServiceType
 @Composable
 fun WebViewLoginScreen(
     service: ServiceType,
+    accountId: String? = null,
     onBack: () -> Unit,
-    onLoginSucceeded: (ServiceType) -> Unit,
+    onLoginSucceeded: (ServiceType, String?) -> Unit,
+    /** 用户已保存的面板基址（Sub2API 的 loginUrl 为空，靠它提供登录入口与可信 host）。 */
+    configuredBaseUrl: String? = null,
     viewModel: WebViewLoginViewModel = hiltViewModel()
 ) {
-    LaunchedEffect(service) { viewModel.bind(service) }
+    // configuredBaseUrl 可选：不传时 ViewModel 自行从凭据仓库读取（Sub2API 自托管实例）
+    LaunchedEffect(service, configuredBaseUrl, accountId) {
+        viewModel.bind(service, configuredBaseUrl, accountId)
+    }
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val snackbarHostState = remember { SnackbarHostState() }
 
-    // 登录成功自动回调
+    // 登录成功自动回调（携带实际写入的账号 ID，供新建账号模式回填）
     LaunchedEffect(uiState.loginSucceeded) {
         if (uiState.loginSucceeded) {
-            onLoginSucceeded(service)
+            onLoginSucceeded(service, uiState.loginAccountId)
+        }
+    }
+
+    // 自动识别服务（WorkBuddy 轮询超时、bindWorkBuddy 网络失败等）没有手动确认弹窗兜底，
+    // 错误通过 Snackbar 呈现，避免用户静默卡在登录页。
+    // key 不含 pendingManualConfirm：错误文本不变时不重复提示（弹窗关闭不回放），且保持互斥。
+    val errorText = uiState.error?.asString()
+    LaunchedEffect(errorText, uiState.loginSucceeded) {
+        if (errorText != null && !uiState.pendingManualConfirm && !uiState.loginSucceeded) {
+            snackbarHostState.showSnackbar(errorText)
         }
     }
 
@@ -63,12 +89,13 @@ fun WebViewLoginScreen(
     }
 
     Scaffold(
+        snackbarHost = { SnackbarHost(snackbarHostState) },
         topBar = {
             TopAppBar(
-                title = { Text("登录 ${service.displayName}") },
+                title = { Text(stringResource(R.string.title_webview_login, service.displayName)) },
                 navigationIcon = {
                     IconButton(onClick = onBack) {
-                        Icon(Icons.Filled.ArrowBack, contentDescription = "返回")
+                        Icon(Icons.Filled.ArrowBack, contentDescription = stringResource(R.string.action_back))
                     }
                 }
             )
@@ -97,9 +124,54 @@ fun WebViewLoginScreen(
                             // 且 TLS fingerprinting 也会识别 WebView。此入口主要作为 fallback，
                             // 主流程走"手动粘贴 Cookie"路线。
 
+                            // 注入 JS 桥：面板登录后把 localStorage 里的登录态回传原生层，
+                            // 实现「网页登录一次即自动配置凭据」，无需手工粘贴 token
+                            addJavascriptInterface(
+                                LoginProbeBridge { json ->
+                                    viewModel.onLocalStorageProbed(parseProbeJson(json))
+                                },
+                                "AndroidBridge"
+                            )
+
                             webViewClient = object : WebViewClient() {
+                                override fun shouldOverrideUrlLoading(
+                                    view: WebView?,
+                                    request: android.webkit.WebResourceRequest?
+                                ): Boolean {
+                                    val url = request?.url?.toString() ?: return false
+                                    return handleOverrideUrl(url)
+                                }
+
+                                @Deprecated("deprecated in API 24, kept for older devices")
+                                override fun shouldOverrideUrlLoading(
+                                    view: WebView?,
+                                    url: String?
+                                ): Boolean {
+                                    url ?: return false
+                                    return handleOverrideUrl(url)
+                                }
+
+                                fun handleOverrideUrl(url: String): Boolean {
+                                    // Trae OAuth 回调：拦截 127.0.0.1:18080/authorize，提取 userJwt
+                                    if (url.startsWith("http://127.0.0.1:18080/authorize")) {
+                                        DebugLog.i("TraeLogin", "回调命中: ${url.toSafeLogUrl()}")
+                                        viewModel.onTraeCallback(url)
+                                        return true
+                                    }
+                                    return false
+                                }
+
+                                override fun onPageStarted(view: WebView?, url: String?, favicon: android.graphics.Bitmap?) {
+                                    DebugLog.i("TraeLogin", "pageStarted: ${url?.toSafeLogUrl()}")
+                                    super.onPageStarted(view, url, favicon)
+                                }
+
                                 override fun onPageFinished(view: WebView?, url: String?) {
-                                    url?.let { viewModel.onPageFinished(it) }
+                                    url ?: return
+                                    // 登录成功后面板会写入 localStorage.auth_token，抓到即自动保存
+                                    view?.evaluateJavascript(viewModel.probeScript, null)
+                                    viewModel.onPageFinished(url)
+                                    DebugLog.i("TraeLogin", "pageFinished: ${url.toSafeLogUrl()}")
                                 }
                             }
                             webChromeClient = WebChromeClient()
@@ -109,13 +181,12 @@ fun WebViewLoginScreen(
                     modifier = Modifier.fillMaxSize()
                 )
             } else {
-                Column(modifier = Modifier
-                    .fillMaxSize()
-                    .padding(16.dp)) {
-                    Text(
-                        text = "未配置登录 URL",
-                        style = MaterialTheme.typography.bodyLarge
-                    )
+                // loginUrl 为空 = ViewModel 正在生成授权地址（Trae/WorkBuddy 需要片刻）
+                Box(
+                    modifier = Modifier.fillMaxSize(),
+                    contentAlignment = Alignment.Center
+                ) {
+                    CircularProgressIndicator()
                 }
             }
         }
@@ -125,23 +196,61 @@ fun WebViewLoginScreen(
     if (uiState.pendingManualConfirm && !uiState.loginSucceeded) {
         AlertDialog(
             onDismissRequest = { viewModel.dismissManualPrompt() },
-            title = { Text("完成登录了吗？") },
+            title = { Text(stringResource(R.string.dialog_login_done_title)) },
             text = {
                 Text(
-                    uiState.error ?: "如果你已经在页面上完成登录但页面没有跳转，" +
-                            "可点击下方按钮让我抓取 Cookie 并保存登录态。"
+                    uiState.error?.asString() ?: stringResource(R.string.dialog_login_done_body)
                 )
             },
             confirmButton = {
                 Button(onClick = { viewModel.confirmLoginManually() }) {
-                    Text("我已登录，保存")
+                    Text(stringResource(R.string.action_login_save))
                 }
             },
             dismissButton = {
                 TextButton(onClick = { viewModel.dismissManualPrompt() }) {
-                    Text("继续等待")
+                    Text(stringResource(R.string.action_keep_waiting))
                 }
             }
         )
     }
+}
+/**
+ * JS → 原生桥：页面脚本通过 window.AndroidBridge.onProbe(json) 回传 localStorage 登录态。
+ *
+ * 用 @JavascriptInterface 注解的方法只允许传基本类型，这里统一走 JSON 字符串，
+ * 解析失败按空处理（页面脚本也可能被站点 CSP 拦掉）。
+ */
+private class LoginProbeBridge(private val onProbe: (String) -> Unit) {
+    @android.webkit.JavascriptInterface
+    fun onProbe(json: String) {
+        runCatching { onProbe(json) }
+    }
+}
+
+/** 解析探测脚本回传的 JSON（扁平 string→string 结构）。 */
+private fun parseProbeJson(json: String): Map<String, String> = runCatching {
+    val obj = org.json.JSONObject(json)
+    buildMap {
+        obj.keys().forEach { k ->
+            val v = obj.optString(k, "")
+            if (v.isNotEmpty()) put(k, v)
+        }
+    }
+}.getOrDefault(emptyMap())
+
+/**
+ * 脱敏日志 URL：只保留 scheme://host/path，去掉 query/fragment（OAuth 回调的
+ * userJwt/userInfo 等敏感参数不落调试日志，与 ViewModel 侧“只记参数名”口径一致）。
+ * 解析失败时回退为截断原文。
+ */
+private fun String.toSafeLogUrl(maxLen: Int = 200): String {
+    val parsed = runCatching { android.net.Uri.parse(this) }.getOrNull()
+    val safe = parsed?.let { u ->
+        val host = u.host ?: ""
+        buildString {
+            append(u.scheme ?: "").append("://").append(host).append(u.path.orEmpty())
+        }
+    }
+    return if (safe.isNullOrBlank()) take(maxLen) else safe
 }

app/src/main/java/com/rainy/token/ui/webview/WebViewLoginViewModel.kt

@@ -1,10 +1,32 @@
 package com.rainy.token.ui.webview
 
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.intOrNull
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.longOrNull
+import com.rainy.token.R
+import com.rainy.token.data.debug.DebugLog
 import com.rainy.token.data.repository.WebViewSessionSaver
+import com.rainy.token.data.repository.CredentialRepository
 import com.rainy.token.domain.model.Credential
 import com.rainy.token.domain.service.ServiceConfigProvider
 import com.rainy.token.domain.service.ServiceType
+import com.rainy.token.ui.components.UiText
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -13,38 +35,356 @@ import kotlinx.coroutines.flow.update
 import javax.inject.Inject
 
 /**
- * WebView 登录容器 ViewModel。计划 4.1：
- *  - 持有目标 URL（来自 ServiceConfig）
- *  - 提供 [onLoginSuccess] 回调：抓 Cookie → 加密存 SecureStorage
- *  - 跟踪"用户手动确认登录"状态（N 秒超时未识别成功时显示按钮）
+ * WebView 登录容器 ViewModel。
+ *
+ * 支持三种服务的软件内登录：
+ * - **Trae**：打开 trae.cn 授权页，用户登录后拦截 `http://127.0.0.1:18080/authorize`
+ *   回调，解析 `userJwt` 中的 JWT 并保存为 [Credential.TraeCredential]。
+ * - **WorkBuddy**：调用 copilot.tencent.com 设备授权 API 获取 QR 码 URL，
+ *   在 WebView 中展示二维码，后台轮询直到用户扫码授权，保存为
+ *   [Credential.WorkBuddyCredential]。
+ * - **Sub2API**：打开自托管面板登录页，注入 JS 读取 localStorage.auth_token。
  */
 @HiltViewModel
 class WebViewLoginViewModel @Inject constructor(
-    private val sessionSaver: WebViewSessionSaver
+    private val sessionSaver: WebViewSessionSaver,
+    private val credentialRepository: CredentialRepository,
+    private val okHttpClient: OkHttpClient
 ) : ViewModel() {
 
     private val _uiState = MutableStateFlow(WebViewLoginUiState())
     val uiState: StateFlow<WebViewLoginUiState> = _uiState.asStateFlow()
 
-    fun bind(service: ServiceType) {
+    /** WorkBuddy 轮询协程，bind 新服务时取消。 */
+    private var workBuddyPollingJob: Job? = null
+
+    /** 目标账号（多账号服务）；null = 新建账号。 */
+    private var accountId: String? = null
+
+    fun bind(service: ServiceType, configuredBaseUrl: String? = null, accountId: String? = null) {
+        workBuddyPollingJob?.cancel()
+        workBuddyPollingJob = null
+        this.accountId = accountId?.takeIf { it.isNotBlank() }
+
         val config = ServiceConfigProvider.get(service)
         _uiState.update {
             it.copy(
                 service = service,
-                loginUrl = config.loginUrl
+                loginUrl = "",
+                loginSucceeded = false,
+                error = null,
+                pendingManualConfirm = false
             )
         }
+
+        when (service) {
+            ServiceType.TRAE -> bindTrae()
+            ServiceType.WORKBUDDY -> bindWorkBuddy()
+            ServiceType.OPENCODE_GO -> bindOpenCodeGo()
+            else -> bindSub2Api(service, config, configuredBaseUrl)
+        }
     }
 
+    // ─── OpenCode Go ────────────────────────────────────────────────────────
+
     /**
-     * 成功 URL 模式匹配（计划 4.1：精确匹配 + fallback）。
-     *
-     * 默认启发：URL 跳转到非登录域 + 路径不包含 /auth/login/signin 等关键词，
-     * 即认为登录完成。具体规则各服务可在 [ServiceConfigProvider] 扩展。
+     * OpenCode Go 应用内登录：WebView 打开 opencode.ai/auth（GitHub / Google OAuth）。
+     * 登录后用户会落到 dashboard（`https://opencode.ai/workspace/{workspaceId}/go`），
+     * 此时从 URL 提取 workspaceId、从 CookieManager 提取 `auth` cookie，
+     * 两者即 [OpenCodeGoRepository.fetchBalance] 所需的全部凭据，自动落库免手抄。
      */
+    private fun bindOpenCodeGo() {
+        _uiState.update {
+            it.copy(loginUrl = "https://opencode.ai/auth", trustedHosts = setOf("opencode.ai"))
+        }
+    }
+
+    /** dashboard URL → 提取 workspaceId 并连同 auth cookie 保存；成功返回 true。 */
+    private fun trySaveOpenCodeSession(url: String): Boolean {
+        val workspaceId = OPENCODE_WORKSPACE_REGEX.find(url)?.groupValues?.get(1) ?: return false
+        val cookieString = android.webkit.CookieManager.getInstance().getCookie(url) ?: return false
+        val authCookie = cookieString.split(";")
+            .mapNotNull { entry ->
+                val parts = entry.trim().split("=", limit = 2)
+                if (parts.size != 2 || parts[0] != "auth") null else parts[1].trim()
+            }
+            .firstOrNull { it.isNotBlank() } ?: return false
+        viewModelScope.launch {
+            val saved = sessionSaver.saveOpenCodeGoSession(
+                authCookie = authCookie,
+                workspaceId = workspaceId
+            )
+            if (saved != null) {
+                _uiState.update {
+                    it.copy(loginSucceeded = true, savedSession = saved, pendingManualConfirm = false, error = null)
+                }
+            }
+        }
+        return true
+    }
+
+    // ─── Trae ──────────────────────────────────────────────────────────────
+
+    private fun bindTrae() {
+        val traceId = randomHex(16)
+        val machineId = randomHex(32)
+        // 设备 ID：claim 签到接口按 x-device-id 做设备级每日去重/风控，要求与 OAuth
+        // 会话绑定的设备一致。这里持久化生成每机唯一 ID（首次生成后跨登录复用），
+        // 登录 URL 与签到 claim 用同一个值。不能每次随机（会话绑定不一致会被风控拒），
+        // 也不可用 userJwt.ClientID（固定客户端标识，所有用户相同，必被按设备限流）。
+        val deviceId = traeDeviceId()
+        val callbackUrl = "http://127.0.0.1:18080/authorize"
+        val authUrl = buildString {
+            append("https://www.trae.cn/authorization?")
+            append("login_version=1&auth_from=solo&login_channel=native_ide&")
+            append("auth_type=local&client_id=en1oxy7wnw8j9n&redirect=0&")
+            append("login_trace_id=$traceId&")
+            append("auth_callback_url=").append(java.net.URLEncoder.encode(callbackUrl, "UTF-8")).append("&")
+            append("machine_id=$machineId&")
+            append("device_id=$deviceId&")
+            append("x_device_id=$deviceId&")
+            append("x_machine_id=$machineId&")
+            append("x_device_brand=PC&x_device_type=PC&")
+            append("x_os_version=1.0&x_app_version=0.1.43&")
+            append("x_app_type=stable&plugin_version=2.3.62834")
+        }
+        DebugLog.i("TraeLogin", "bindTrae: 授权URL已生成 len=${authUrl.length} deviceId持久化=${deviceId.take(6)}…")
+        _uiState.update { it.copy(loginUrl = authUrl) }
+    }
+
+    /** Trae 签到用的持久化设备 ID：首次生成 19 位数字并保存，此后跨登录复用。 */
+    private fun traeDeviceId(): String {
+        val prefs = com.rainy.token.RainyTokenApplication.appContext
+            .getSharedPreferences("trae_login", android.content.Context.MODE_PRIVATE)
+        prefs.getString("device_id", null)?.takeIf { it.isNotBlank() }?.let { return it }
+        val id = randomDigits(19)
+        prefs.edit().putString("device_id", id).apply()
+        return id
+    }
+
+    /**
+     * Trae 授权回调拦截。URL 形如：
+     * `http://127.0.0.1:18080/authorize?userJwt=<JSON>&userInfo=<JSON>&...`
+     *
+     * `userJwt` 是 JSON 字符串，含 `{ Token, RefreshToken, ClientID, TokenExpireAt, ... }`。
+     * 提取 `Token`（即 Cloud-IDE-JWT）保存为 [Credential.TraeCredential]。
+     */
+    fun onTraeCallback(url: String) {
+        val service = _uiState.value.service ?: return
+        if (service != ServiceType.TRAE) return
+        if (_uiState.value.loginSucceeded) return
+
+        val parsed = url.toHttpUrlOrNull() ?: run {
+            DebugLog.w("TraeLogin", "onTraeCallback: URL 解析失败")
+            return
+        }
+        // 只记录参数名（不含 token 值，避免把 userJwt 明文落调试日志）
+        DebugLog.i("TraeLogin", "onTraeCallback: 收到回调，参数=${parsed.queryParameterNames}")
+        // Trae 回调中参数名可能为 userJwt 或 user_jwt，值是 JSON 字符串
+        val userJwtRaw = parsed.queryParameter("userJwt")
+            ?: parsed.queryParameter("user_jwt")
+            ?: run {
+                DebugLog.w("TraeLogin", "onTraeCallback: 无 userJwt/user_jwt 参数")
+                return
+            }
+        val userJwt = try {
+            Json.parseToJsonElement(userJwtRaw).jsonObject
+        } catch (e: Exception) {
+            DebugLog.w("TraeLogin", "onTraeCallback: userJwt JSON 解析失败: ${e.message}")
+            return
+        }
+        val token = userJwt["Token"]?.jsonPrimitive?.contentOrNull
+        if (token.isNullOrBlank()) {
+            DebugLog.w("TraeLogin", "onTraeCallback: 收到回调但 userJwt 无 Token（userJwtKeys=${userJwt.keys}）")
+            return
+        }
+        DebugLog.i("TraeLogin", "onTraeCallback: userJwt 解析成功 token非空=${token.isNotBlank()}")
+        // 设备绑定 ID：登录会话绑定的 App 持久化设备 ID（与授权 URL device_id 一致）。
+        // 注意不能用 userJwt.ClientID——那是固定客户端标识（en1oxy7wnw8j9n），所有
+        // 用户相同，作 x-device-id 会被服务端按设备风控拒绝（「参与用户太多」）。
+        val deviceId = traeDeviceId()
+        // 用户 ID：从回调 userInfo 参数提取，签到按 trae-check 口径拼 ${deviceId}-${userId}。
+        val userId = parsed.queryParameter("userInfo")?.let { raw ->
+            runCatching {
+                val u = Json.parseToJsonElement(raw).jsonObject
+                u["userId"]?.jsonPrimitive?.contentOrNull
+                    ?: u["user_id"]?.jsonPrimitive?.contentOrNull
+                    ?: u["id"]?.jsonPrimitive?.contentOrNull
+                    ?: u["accountId"]?.jsonPrimitive?.contentOrNull
+            }.getOrNull()
+        }
+        DebugLog.i("TraeLogin", "onTraeCallback: userId=${if (userId.isNullOrBlank()) "null" else "ok"}")
+
+        viewModelScope.launch {
+            // 刚成功登录的凭据视为已验证：lastVerifiedAt 记为当前时间，
+            // 否则首页/列表会显示"未验证/未登录"直到进详情页拉余额后才正常
+            val credential = Credential.TraeCredential(
+                service = ServiceType.TRAE,
+                jwt = token,
+                region = "CN",
+                deviceId = deviceId,
+                userId = userId?.takeIf { it.isNotBlank() },
+                lastVerifiedAt = System.currentTimeMillis()
+            )
+            val effectiveId = credentialRepository.save(credential, accountId)
+            _uiState.update {
+                it.copy(loginSucceeded = true, pendingManualConfirm = false, error = null, loginAccountId = effectiveId.ifBlank { null })
+            }
+            DebugLog.i("TraeLogin", "onTraeCallback: 凭据已保存，登录完成")
+        }
+    }
+
+    // ─── WorkBuddy ─────────────────────────────────────────────────────────
+
+    private fun bindWorkBuddy() {
+        viewModelScope.launch {
+            try {
+                val request = Request.Builder()
+                    .url("https://copilot.tencent.com/v2/plugin/auth/state?platform=CLI")
+                    .addHeader("User-Agent", "CLI/2.63.2 CodeBuddy/2.63.2")
+                    .addHeader("Content-Type", "application/json")
+                    .post("{}".toRequestBody("application/json".toMediaTypeOrNull()))
+                    .build()
+                val (body, ok) = withContext(Dispatchers.IO) {
+                    val resp = okHttpClient.newCall(request).execute()
+                    val s = resp.body?.string().orEmpty()
+                    s to resp.isSuccessful
+                }
+                if (!ok || body.isBlank()) {
+                    _uiState.update {
+                        it.copy(error = UiText.Resource(R.string.error_network_generic))
+                    }
+                    return@launch
+                }
+                val json = Json.parseToJsonElement(body).jsonObject
+                val data = json["data"]?.jsonObject
+                val state = data?.get("state")?.jsonPrimitive?.contentOrNull
+                val authURL = data?.get("authUrl")?.jsonPrimitive?.contentOrNull
+                    ?: data?.get("authURL")?.jsonPrimitive?.contentOrNull
+                if (state.isNullOrBlank() || authURL.isNullOrBlank()) {
+                    _uiState.update {
+                        it.copy(error = UiText.Resource(R.string.error_network_generic))
+                    }
+                    return@launch
+                }
+                _uiState.update { it.copy(loginUrl = authURL) }
+                workBuddyPollingJob = viewModelScope.launch { pollWorkBuddyToken(state) }
+            } catch (_: Exception) {
+                _uiState.update {
+                    it.copy(error = UiText.Resource(R.string.error_network_generic))
+                }
+            }
+        }
+    }
+
+    /** 每 2 秒轮询一次 token 接口，120 秒超时。 */
+    private suspend fun pollWorkBuddyToken(state: String) {
+        val timeoutMs = 120_000L
+        val startTime = System.currentTimeMillis()
+        while (System.currentTimeMillis() - startTime < timeoutMs) {
+            if (_uiState.value.loginSucceeded) return
+            try {
+                val request = Request.Builder()
+                    .url("https://copilot.tencent.com/v2/plugin/auth/token?state=$state")
+                    .addHeader("User-Agent", "CLI/2.63.2 CodeBuddy/2.63.2")
+                    .get()
+                    .build()
+                val body = withContext(Dispatchers.IO) {
+                    val resp = okHttpClient.newCall(request).execute()
+                    val s = resp.body?.string().orEmpty()
+                    resp.close()
+                    s
+                }
+                val json = Json.parseToJsonElement(body).jsonObject
+                val code = json["code"]?.jsonPrimitive?.intOrNull ?: -1
+                if (code == 0) {
+                    val data = json["data"]?.jsonObject
+                    val accessToken = data?.get("accessToken")?.jsonPrimitive?.contentOrNull
+                        ?: data?.get("access_token")?.jsonPrimitive?.contentOrNull
+                    val refreshToken = data?.get("refreshToken")?.jsonPrimitive?.contentOrNull
+                        ?: data?.get("refresh_token")?.jsonPrimitive?.contentOrNull
+                    val expiresIn = data?.get("expiresIn")?.jsonPrimitive?.longOrNull
+                        ?: data?.get("expires_in")?.jsonPrimitive?.longOrNull ?: 7200L
+                    if (!accessToken.isNullOrBlank()) {
+                        val expiresAt = System.currentTimeMillis() + expiresIn * 1000
+                        // 刚成功登录的凭据视为已验证（见 Trae 同款注释）
+                        val credential = Credential.WorkBuddyCredential(
+                            service = ServiceType.WORKBUDDY,
+                            accessToken = accessToken,
+                            refreshToken = refreshToken ?: "",
+                            expiresAt = expiresAt,
+                            lastVerifiedAt = System.currentTimeMillis()
+                        )
+                        val effectiveId = credentialRepository.save(credential, accountId)
+                        _uiState.update {
+                            it.copy(
+                                loginSucceeded = true,
+                                pendingManualConfirm = false,
+                                error = null,
+                                loginAccountId = effectiveId.ifBlank { null }
+                            )
+                        }
+                        return
+                    }
+                }
+            } catch (_: Exception) {
+                // 网络异常时继续轮询，直到超时
+            }
+            delay(2000)
+        }
+        _uiState.update { it.copy(error = UiText.Resource(R.string.error_login_timeout)) }
+    }
+
+    // ─── Sub2API (existing) ────────────────────────────────────────────────
+
+    private fun bindSub2Api(
+        service: ServiceType,
+        config: com.rainy.token.domain.service.ServiceConfig,
+        configuredBaseUrl: String?
+    ) {
+        _uiState.update {
+            it.copy(service = service, loginUrl = config.loginUrl, trustedHosts = emptySet())
+        }
+        viewModelScope.launch {
+            val base = configuredBaseUrl
+                ?: (credentialRepository.get(service) as? Credential.Sub2ApiCredential)?.baseUrl
+            val hosts = buildSet {
+                base?.toHttpUrlOrNull()?.host?.let { add(it) }
+                config.loginUrl.toHttpUrlOrNull()?.host?.let { add(it) }
+            }
+            _uiState.update {
+                it.copy(
+                    loginUrl = config.loginUrl.ifBlank { base.orEmpty() },
+                    trustedHosts = hosts
+                )
+            }
+        }
+    }
+
+    // ─── Page lifecycle ────────────────────────────────────────────────────
+
     fun onPageFinished(url: String) {
         val current = _uiState.value
         if (current.loginSucceeded) return
+        // OpenCode：URL 到 dashboard（/workspace/{id}/go）即自动提取凭据，无 dashboard
+        // （如停在 /auth 登录页）则静默等待，不打扰用户操作。
+        if (_uiState.value.service == ServiceType.OPENCODE_GO) {
+            if (!trySaveOpenCodeSession(url) && !looksLikeLoggedInPage(url)) {
+                _uiState.update { it.copy(pendingManualConfirm = false) }
+            }
+            return
+        }
+        // Trae 的登录完成由 OAuth 回调（127.0.0.1:18080/authorize?userJwt=...，onTraeCallback）
+        // 自动判定，onPageFinished 的 URL 关键词启发式对 Trae 不适用：授权页 URL 含 /auth，
+        // 会在用户尚在页面操作时就误弹「登录完成？」提示；且 saveSession 的 cookie 抓取
+        // 对 JWT 凭据无效，反而可能覆盖已保存的凭据。Trae 流程静默等待回调即可，
+        // 想放弃登录由 BackHandler 返回。
+        if (_uiState.value.service == ServiceType.TRAE) return
+        // WorkBuddy 的登录完成由 token 轮询（pollWorkBuddyToken）自动判定：扫码页面 URL
+        // 含 /authorize，关键词启发式会误弹「登录完成？」；且确认后走 cookie 抓取会把
+        // 错误的 SessionCredential 保存到 WORKBUDDY 服务。静默等待轮询结果即可，
+        // 轮询成功自动落库并回调返回，超时由 pollWorkBuddyToken 置 error。
+        if (_uiState.value.service == ServiceType.WORKBUDDY) return
         if (looksLikeLoggedInPage(url)) {
             saveSession(url)
         } else {
@@ -53,6 +393,17 @@ class WebViewLoginViewModel @Inject constructor(
     }
 
     fun confirmLoginManually() {
+        val service = _uiState.value.service ?: return
+        // 防御性守卫：Trae/WorkBuddy/OpenCode 均通过各自的自动识别（回调/轮询/URL 正则）
+        // 完成登录，不应用 cookie 抓取兜底覆盖凭据；未来若有新入口误将 pendingManualConfirm
+        // 置位，这里直接短路，避免把错误的 SessionCredential 写入这些服务。
+        if (service == ServiceType.TRAE ||
+            service == ServiceType.WORKBUDDY ||
+            service == ServiceType.OPENCODE_GO
+        ) {
+            dismissManualPrompt()
+            return
+        }
         val url = _uiState.value.loginUrl
         saveSession(url)
     }
@@ -61,40 +412,138 @@ class WebViewLoginViewModel @Inject constructor(
         _uiState.update { it.copy(pendingManualConfirm = false) }
     }
 
+    fun onLocalStorageProbed(values: Map<String, String>) {
+        val service = _uiState.value.service ?: return
+        if (_uiState.value.loginSucceeded) return
+        if (!isValidProbe(values[SUB2_NONCE_KEY])) return
+        if (service != ServiceType.SUB2API) return
+        val token = values[SUB2_AUTH_TOKEN_KEY].orEmpty()
+        if (token.isBlank()) return
+        val origin = values[SUB2_ORIGIN_KEY].orEmpty()
+        if (!isTrustedOrigin(origin)) return
+        viewModelScope.launch {
+            val saved = sessionSaver.saveSub2ApiPanelSession(
+                baseUrl = origin.ifBlank { _uiState.value.loginUrl },
+                authToken = token,
+                siteIcon = values[SUB2_ICON_KEY],
+                email = values[SUB2_EMAIL_KEY],
+                accountId = this@WebViewLoginViewModel.accountId
+            )
+            if (saved != null) {
+                _uiState.update {
+                    it.copy(
+                        loginSucceeded = true,
+                        pendingManualConfirm = false,
+                        error = null,
+                        // 回填实际写入的账号 ID：新建账号流程返回编辑页时保持编辑该账号，
+                        // 避免用户再次点保存产生重复账号
+                        loginAccountId = saved.accountId.ifBlank { null }
+                    )
+                }
+            }
+        }
+    }
+
+    private fun isTrustedOrigin(origin: String): Boolean {
+        val probeHost = origin.toHttpUrlOrNull()?.host ?: return false
+        val allowed = _uiState.value.trustedHosts
+        if (allowed.isEmpty()) return false
+        return allowed.any { it.equals(probeHost, ignoreCase = true) }
+    }
+
+    private val probeNonce: String = java.util.UUID.randomUUID().toString().replace("-", "")
+    val probeScript: String get() = buildProbeScript(probeNonce)
+    fun isValidProbe(nonce: String?): Boolean =
+        nonce != null && nonce.isNotEmpty() && nonce == probeNonce
+
     private fun saveSession(url: String) {
         val service = _uiState.value.service ?: return
-        val saved = sessionSaver.saveFromCookieManager(service = service, url = url)
-        if (saved != null) {
-            _uiState.update {
-                it.copy(
-                    loginSucceeded = true,
-                    savedSession = saved,
-                    pendingManualConfirm = false
-                )
-            }
-        } else {
-            _uiState.update {
-                it.copy(
-                    error = "未抓到 Cookie，请确认已登录",
-                    pendingManualConfirm = true
-                )
+        viewModelScope.launch {
+            val saved = sessionSaver.saveFromCookieManager(service = service, url = url)
+            if (saved != null) {
+                _uiState.update {
+                    it.copy(
+                        loginSucceeded = true,
+                        savedSession = saved,
+                        pendingManualConfirm = false
+                    )
+                }
+            } else {
+                _uiState.update {
+                    it.copy(
+                        error = UiText.Resource(R.string.error_cookie_not_found),
+                        pendingManualConfirm = true
+                    )
+                }
             }
         }
     }
 
     private fun looksLikeLoggedInPage(url: String): Boolean {
         val u = url.lowercase()
-        // 简单启发：URL 不再包含登录路径关键字
         val loginKeywords = listOf("/auth", "/login", "/signin", "/oauth")
         return loginKeywords.none { u.contains(it) }
     }
+
+    // ─── Helpers ───────────────────────────────────────────────────────────
+
+    private fun randomHex(length: Int): String {
+        val bytes = ByteArray(length / 2)
+        java.security.SecureRandom().nextBytes(bytes)
+        return bytes.joinToString("") { "%02x".format(it) }
+    }
+
+    private fun randomDigits(length: Int): String {
+        val sb = StringBuilder(length)
+        val rnd = java.security.SecureRandom()
+        repeat(length) { sb.append(rnd.nextInt(10)) }
+        return sb.toString()
+    }
+
+    override fun onCleared() {
+        workBuddyPollingJob?.cancel()
+        super.onCleared()
+    }
 }
 
+private const val SUB2_AUTH_TOKEN_KEY = "auth_token"
+private const val SUB2_ORIGIN_KEY = "origin"
+private const val SUB2_ICON_KEY = "site_icon"
+private const val SUB2_EMAIL_KEY = "email"
+private const val SUB2_NONCE_KEY = "nonce"
+
+/** OpenCode dashboard URL 中的 workspaceId：`/workspace/{id}/go`。 */
+private val OPENCODE_WORKSPACE_REGEX = Regex("""/workspace/([^/?#]+)/go""")
+
+internal fun buildProbeScript(nonce: String): String = """
+(function () {
+  try {
+    var out = {};
+    var t = window.localStorage.getItem('auth_token');
+    if (t) out.auth_token = t;
+    var u = window.localStorage.getItem('auth_user');
+    if (u) {
+      try { out.email = (JSON.parse(u) || {}).email || ''; } catch (e) {}
+    }
+    var icon = document.querySelector('link[rel~="icon"]');
+    if (icon && icon.href) out.site_icon = icon.href;
+    out.origin = window.location.origin;
+    out.nonce = '$nonce';
+    if (window.AndroidBridge && window.AndroidBridge.onProbe) {
+      window.AndroidBridge.onProbe(JSON.stringify(out));
+    }
+  } catch (e) {}
+})();
+"""
+
 data class WebViewLoginUiState(
     val service: ServiceType? = null,
     val loginUrl: String = "",
+    val trustedHosts: Set<String> = emptySet(),
     val loginSucceeded: Boolean = false,
     val savedSession: Credential.SessionCredential? = null,
     val pendingManualConfirm: Boolean = false,
-    val error: String? = null
-)
+    val error: UiText? = null,
+    /** Trae/WorkBuddy 登录实际写入的账号 ID（新建账号模式时用于回填信用编辑页）。 */
+    val loginAccountId: String? = null
+)

app/src/main/java/com/rainy/token/ui/webview/WebViewPageScreen.kt

@@ -0,0 +1,118 @@
+package com.rainy.token.ui.webview
+
+import android.view.ViewGroup
+import android.webkit.WebChromeClient
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ArrowBack
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.viewinterop.AndroidView
+import com.rainy.token.R
+
+/**
+ * 通用 WebView 页面容器。用于在 App 内打开外部操作页（如 DeepSeek 充值页）。
+ *
+ * - 复用 [WebViewLoginScreen] 的 WebView 模式：JS/DOM 存储开启，适配移动视口；
+ * - 页面加载后用页面标题替换顶栏标题（失败则保持传入标题）；
+ * - 返回键优先回退页内历史，无历史时退出页面。
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun WebViewPageScreen(
+    url: String,
+    title: String,
+    onBack: () -> Unit
+) {
+    var webView: WebView? = remember { null }
+    var pageTitle by remember { mutableStateOf(title) }
+
+    // 顶栏返回与系统返回保持一致：优先回退页内历史，无历史才退出
+    val goBack: () -> Unit = {
+        if (webView?.canGoBack() == true) {
+            webView?.goBack()
+        } else {
+            onBack()
+        }
+    }
+    BackHandler(onBack = goBack)
+
+    // 页面销毁时释放 WebView 原生资源，避免内存泄漏；先移除父级再 destroy，规避
+    // "Calling destroy while still attached" 的极端时序崩溃
+    DisposableEffect(Unit) {
+        onDispose {
+            webView?.let { view ->
+                view.parent?.let { (it as? ViewGroup)?.removeView(view) }
+                view.destroy()
+            }
+            webView = null
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text(pageTitle) },
+                navigationIcon = {
+                    IconButton(onClick = goBack) {
+                        Icon(
+                            Icons.Filled.ArrowBack,
+                            contentDescription = stringResource(R.string.action_back)
+                        )
+                    }
+                }
+            )
+        }
+    ) { innerPadding ->
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(innerPadding)
+        ) {
+            AndroidView(
+                factory = { context ->
+                    WebView(context).apply {
+                        layoutParams = ViewGroup.LayoutParams(
+                            ViewGroup.LayoutParams.MATCH_PARENT,
+                            ViewGroup.LayoutParams.MATCH_PARENT
+                        )
+                        settings.javaScriptEnabled = true
+                        settings.domStorageEnabled = true
+                        settings.useWideViewPort = true
+                        settings.loadWithOverviewMode = true
+
+                        webViewClient = object : WebViewClient() {
+                            override fun onPageFinished(view: WebView?, url: String?) {
+                                // 用网页真实标题替换占位标题（忽略空白标题）
+                                view?.title?.takeIf { it.isNotBlank() }?.let { loaded ->
+                                    if (loaded != pageTitle) pageTitle = loaded
+                                }
+                            }
+                        }
+                        webChromeClient = WebChromeClient()
+                        webView = this
+                        loadUrl(url)
+                    }
+                },
+                modifier = Modifier.fillMaxSize()
+            )
+        }
+    }
+}

app/src/main/java/com/rainy/token/ui/widget/OpenCodeGoWidgetProvider.kt

@@ -8,17 +8,23 @@ import android.content.Context
 import android.content.Intent
 import android.content.res.ColorStateList
 import android.util.TypedValue
+import android.view.View
 import android.widget.RemoteViews
 import com.rainy.token.MainActivity
 import com.rainy.token.R
 import com.rainy.token.data.cache.BalanceCache
 import com.rainy.token.data.cache.balanceCacheDataStore
+import com.rainy.token.data.local.SecureStorage
+import com.rainy.token.data.local.secureStorageDataStore
+import com.rainy.token.data.repository.CredentialRepository
 import com.rainy.token.domain.service.ServiceType
 import com.rainy.token.ui.components.normalizeWindowLabel
+import com.rainy.token.util.LocaleManager
 import kotlinx.coroutines.runBlocking
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
+import kotlin.math.roundToInt
 
 /**
  * OpenCode Go 桌面小组件（MIUI Widget）。
@@ -55,11 +61,25 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
         appWidgetManager: AppWidgetManager,
         appWidgetIds: IntArray
     ) {
-        var selectedHasCachedData = false
+        // 每次渲染都用最新语言偏好重新包装 context：Application 层的 wrap 在进程启动时固定，
+        // 应用内切换语言后不会自动更新，必须在这里按当前偏好重建，否则 widget 文本停留在旧语言
+        val localized = LocaleManager.wrapContext(context)
+
+        // 已配置服务只读一次（Keystore 解密有成本）；未配置的服务不进轮换、DS 行整体隐藏
+        val configured = configuredServices(context)
+        val dsConfigured = isCredentialPresent(context, ServiceType.DEEPSEEK)
+        val selectedService = currentDisplayService(context, configured)
 
         for (widgetId in appWidgetIds) {
             val views = RemoteViews(context.packageName, R.layout.widget_opencode_go)
 
+            // 署名动态设置：与行标签同源（跟随应用内语言），
+            // 避免 XML 静态文本由宿主进程按系统语言渲染造成中英混搭
+            views.setTextViewText(R.id.widget_brand, localized.getString(R.string.widget_brand))
+
+            // DeepSeek 余额标签同样动态设置（静态 XML 文本由 Launcher 按系统语言解析）
+            views.setTextViewText(R.id.widget_ds_label, localized.getString(R.string.widget_deepseek_balance))
+
             // 点击左上角品牌 → 打开 APP；点击其它内容区域 → 切换服务；刷新按钮单独刷新。
             val openAppIntent = Intent(context, MainActivity::class.java).apply {
                 flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
@@ -91,51 +111,92 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
                 try {
                     val dataStore = context.applicationContext.balanceCacheDataStore
                     val cache = BalanceCache(dataStore)
-                    val selectedService = currentDisplayService(context)
-                    views.setTextViewText(R.id.widget_switch, shortName(selectedService))
-                    views.setTextViewText(R.id.widget_service_title, "${selectedService.displayName} · 额度")
-                    views.setImageViewResource(R.id.widget_logo, widgetLogo(selectedService))
-                    // Ollama logo 是正方形，XML 默认 22x12 是给宽扁 logo 的
-                    if (selectedService == ServiceType.OLLAMA) {
-                        views.setViewLayoutWidth(R.id.widget_logo, 14f, TypedValue.COMPLEX_UNIT_DIP)
-                        views.setViewLayoutHeight(R.id.widget_logo, 14f, TypedValue.COMPLEX_UNIT_DIP)
+                    views.setViewVisibility(
+                        R.id.widget_ds_row,
+                        if (dsConfigured) View.VISIBLE else View.GONE
+                    )
+                    if (selectedService == null || configured.isEmpty()) {
+                        // 轮换区没有任何已配置服务：
+                        // - DeepSeek 已配置 → 标题回退「DeepSeek 余额」，只展示 DS 余额行
+                        // - 全都没配置 → 展示引导空态，不展示任何服务数据
+                        views.setTextViewText(R.id.widget_switch, "")
+                        val emptyLogo = if (dsConfigured) ServiceType.DEEPSEEK else ServiceType.OPENCODE_GO
+                        views.setImageViewResource(R.id.widget_logo, widgetLogo(emptyLogo))
+                        // DeepSeek logo 是方形，XML 默认 22x12 会压扁，用正方形盒
+                        if (emptyLogo == ServiceType.DEEPSEEK) {
+                            views.setViewLayoutWidth(R.id.widget_logo, 14f, TypedValue.COMPLEX_UNIT_DIP)
+                            views.setViewLayoutHeight(R.id.widget_logo, 14f, TypedValue.COMPLEX_UNIT_DIP)
+                        } else {
+                            views.setViewLayoutWidth(R.id.widget_logo, 22f, TypedValue.COMPLEX_UNIT_DIP)
+                            views.setViewLayoutHeight(R.id.widget_logo, 12f, TypedValue.COMPLEX_UNIT_DIP)
+                        }
+                        views.setTextViewText(
+                            R.id.widget_service_title,
+                            localized.getString(
+                                if (dsConfigured) R.string.widget_deepseek_balance
+                                else R.string.widget_not_configured
+                            )
+                        )
+                        setEmptyState(views, localized)
                     } else {
-                        views.setViewLayoutWidth(R.id.widget_logo, 22f, TypedValue.COMPLEX_UNIT_DIP)
-                        views.setViewLayoutHeight(R.id.widget_logo, 12f, TypedValue.COMPLEX_UNIT_DIP)
-                    }
-                    val cached = cache.get(selectedService)
-                    if (cached != null) {
-                        selectedHasCachedData = true
-                        populateServiceRows(views, selectedService, cached.balance)
-
-                        val sdf = SimpleDateFormat("MM-dd HH:mm", Locale.getDefault())
-                        val timeText = "更新 " + sdf.format(Date(cached.fetchedAt))
-                        views.setTextViewText(R.id.widget_updated, timeText)
-                    } else {
-                        setEmptyState(views)
                         views.setTextViewText(R.id.widget_switch, shortName(selectedService))
-                        views.setTextViewText(R.id.widget_service_title, "${selectedService.displayName} · 额度")
-                    }
+                        views.setTextViewText(
+                            R.id.widget_service_title,
+                            localized.getString(R.string.widget_service_quota, selectedService.displayName)
+                        )
+                        views.setImageViewResource(R.id.widget_logo, widgetLogo(selectedService))
+                        // Ollama logo 是正方形，XML 默认 22x12 是给宽扁 logo 的
+                        if (selectedService == ServiceType.OLLAMA) {
+                            views.setViewLayoutWidth(R.id.widget_logo, 14f, TypedValue.COMPLEX_UNIT_DIP)
+                            views.setViewLayoutHeight(R.id.widget_logo, 14f, TypedValue.COMPLEX_UNIT_DIP)
+                        } else {
+                            views.setViewLayoutWidth(R.id.widget_logo, 22f, TypedValue.COMPLEX_UNIT_DIP)
+                            views.setViewLayoutHeight(R.id.widget_logo, 12f, TypedValue.COMPLEX_UNIT_DIP)
+                        }
+                        val cached = cache.get(selectedService)
+                        if (cached != null) {
+                            populateServiceRows(views, localized, selectedService, cached.balance)
 
-                    // DeepSeek 余额
-                    val dsCached = cache.get(ServiceType.DEEPSEEK)
-                    if (dsCached != null && dsCached.balance.amount > 0) {
-                        val dsBal = dsCached.balance
-                        val dsText = dsBal.unit + String.format("%.2f", dsBal.amount)
-                        views.setTextViewText(R.id.widget_ds_amount, dsText)
-                    } else {
-                        views.setTextViewText(R.id.widget_ds_amount, "—")
+                            val sdf = SimpleDateFormat("MM-dd HH:mm", Locale.getDefault())
+                            val timeText = sdf.format(Date(cached.fetchedAt))
+                            views.setTextViewText(
+                                R.id.widget_updated,
+                                localized.getString(R.string.widget_updated_at, timeText)
+                            )
+                        } else {
+                            setEmptyState(views, localized)
+                            views.setTextViewText(R.id.widget_switch, shortName(selectedService))
+                            views.setTextViewText(
+                                R.id.widget_service_title,
+                                localized.getString(R.string.widget_service_quota, selectedService.displayName)
+                            )
+                        }
+                    }
+                    // DeepSeek 余额独立于轮换区填充，且必须放在所有 setEmptyState 之后：
+                    // setEmptyState 会把 widget_ds_amount 写成 "—"，后填的真值才能覆盖它
+                    if (dsConfigured) {
+                        val dsCached = cache.get(ServiceType.DEEPSEEK)
+                        if (dsCached != null && dsCached.balance.amount > 0) {
+                            val dsBal = dsCached.balance
+                            val dsText = dsBal.unit + String.format("%.2f", dsBal.amount)
+                            views.setTextViewText(R.id.widget_ds_amount, dsText)
+                        } else {
+                            views.setTextViewText(R.id.widget_ds_amount, "—")
+                        }
                     }
                 } catch (_: Exception) {
-                    setEmptyState(views)
+                    setEmptyState(views, localized)
                 }
             }
 
             appWidgetManager.updateAppWidget(widgetId, views)
         }
 
-        // 自动刷新：缓存为空 或 超过冷却时间 → 触发后台刷新
-        if (!selectedHasCachedData || shouldAutoRefresh(context)) {
+        // 自动刷新：有已配置服务且超过冷却时间 → 触发后台刷新。
+        // 缓存命中与否不参与决策——receiver 现在无条件重渲染，若以「缓存为空」为由
+        // 绕过冷却，刷新失败时会形成 onUpdate → 广播 → 失败 → 重渲染 → 再广播的
+        // 无冷却重试环；冷却约束是唯一的节流阀。
+        if ((configured.isNotEmpty() || dsConfigured) && shouldAutoRefresh(context)) {
             markAutoRefreshTime(context)
             context.sendBroadcast(WidgetRefreshReceiver.createIntent(context))
         }
@@ -143,21 +204,22 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
 
     private fun populateServiceRows(
         views: RemoteViews,
+        context: Context,
         service: ServiceType,
         balance: com.rainy.token.domain.model.ServiceBalance
     ) {
         val extras = balance.extras
         when (service) {
             ServiceType.OPENCODE_GO -> {
-                setRowLabel(views, "5h", "本周", "本月")
+                setRowLabel(views, context.getString(R.string.window_5h_short), context.getString(R.string.window_weekly), context.getString(R.string.window_monthly))
                 populateRow(views, R.id.row1_pct, R.id.row1_bar, R.id.row1_reset,
-                    pct = extras["rolling.pct"]?.toIntOrNull(),
+                    pct = extras["rolling.pct"]?.toFloatOrNull()?.roundToInt(),
                     resetSec = extras["rolling.resetInSec"]?.toLongOrNull())
                 populateRow(views, R.id.row2_pct, R.id.row2_bar, R.id.row2_reset,
-                    pct = extras["weekly.pct"]?.toIntOrNull(),
+                    pct = extras["weekly.pct"]?.toFloatOrNull()?.roundToInt(),
                     resetSec = extras["weekly.resetInSec"]?.toLongOrNull())
                 populateRow(views, R.id.row3_pct, R.id.row3_bar, R.id.row3_reset,
-                    pct = extras["monthly.pct"]?.toIntOrNull(),
+                    pct = extras["monthly.pct"]?.toFloatOrNull()?.roundToInt(),
                     resetSec = extras["monthly.resetInSec"]?.toLongOrNull())
             }
             ServiceType.COMMANDCODE_GO -> {
@@ -165,7 +227,7 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
                     if (used == null || cap == null || cap <= 0) return null
                     return ((used / cap) * 100).toInt().coerceIn(0, 100)
                 }
-                setRowLabel(views, "5h", "本周", "本月")
+                setRowLabel(views, context.getString(R.string.window_5h_short), context.getString(R.string.window_weekly), context.getString(R.string.window_monthly))
                 populateRow(views, R.id.row1_pct, R.id.row1_bar, R.id.row1_reset,
                     pct = calcPct(extras["fiveHour.used"]?.toDoubleOrNull(), extras["fiveHour.cap"]?.toDoubleOrNull()),
                     resetSec = extras["fiveHour.resetInSec"]?.toLongOrNull())
@@ -180,23 +242,32 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
                 val windowCount = extras.keys
                     .mapNotNull { key -> key.removePrefix("window_").substringBefore('.').toIntOrNull() }
                     .distinct().maxOrNull()?.plus(1) ?: 0
-                val windows = (0 until windowCount).map { index ->
-                    val label = normalizeWindowLabel(extras["window_$index.label"] ?: "Usage")
+                val weeklyLabel = context.getString(R.string.window_every_week)
+                val monthlyLabel = context.getString(R.string.window_every_month)
+                val usageLabel = context.getString(R.string.window_usage)
+                // 仅主模型窗口进入桌面组件；Spark 独立限额为次要通道，不占用组件行位
+                val normal = mutableListOf<Triple<String, Int?, Long?>>()
+                for (index in 0 until windowCount) {
+                    if (extras["window_$index.group"] == "SPARK") continue
+                    val rawLabel = extras["window_$index.label"] ?: "usage"
+                    val label = normalizeWindowLabel(
+                        rawLabel,
+                        weeklyLabel = weeklyLabel,
+                        monthlyLabel = monthlyLabel,
+                        usageLabel = usageLabel
+                    )
                     val remaining = extras["window_$index.remainingPct"]?.toIntOrNull()
                     val resetAt = extras["window_$index.resetAt"]?.toLongOrNull()?.takeIf { it > 0 }
-                    Triple(label, remaining?.let { (100 - it).coerceIn(0, 100) }, resetAt?.let { (it - System.currentTimeMillis()) / 1000 }?.takeIf { it > 0 })
+                    normal.add(Triple(label, remaining?.let { (100 - it).coerceIn(0, 100) }, resetAt?.let { (it - System.currentTimeMillis()) / 1000 }?.takeIf { it > 0 }))
                 }
                 // 判断是否有 5h 窗口
-                val has5h = windows.any { it.first.contains("5") }
-                // 始终保留 5h 槽位在第一行
-                val row1 = if (!has5h) {
-                    Triple("5h", null, null)
-                } else {
-                    windows.firstOrNull { it.first.contains("5") } ?: windows.getOrNull(0) ?: Triple("5h", null, null)
-                }
-                val otherWindows = windows.filter { it != row1 }
-                val row2 = otherWindows.getOrNull(0) ?: Triple("每周", null, null)
-                val row3 = otherWindows.getOrNull(1) ?: Triple("每月", null, null)
+                val has5h = normal.any { it.first.contains("5") }
+                // 始终保留 5h 槽位在第一行（按索引取行，避免内容相同的窗口被误过滤）
+                val row1Idx = if (has5h) (normal.indexOfFirst { it.first.contains("5") }.takeIf { it >= 0 } ?: 0) else -1
+                val row1 = if (row1Idx >= 0) normal[row1Idx] else Triple("5h", null, null)
+                val otherWindows = normal.filterIndexed { idx, _ -> idx != row1Idx }
+                val row2 = otherWindows.getOrNull(0) ?: Triple(weeklyLabel, null, null)
+                val row3 = otherWindows.getOrNull(1) ?: Triple(monthlyLabel, null, null)
                 setRowLabel(views, row1.first, row2.first, row3.first)
                 listOf(
                     Triple(R.id.row1_pct, R.id.row1_bar, R.id.row1_reset),
@@ -207,9 +278,12 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
                     populateRow(views, ids.first, ids.second, ids.third, pct = window.second, resetSec = window.third)
                 }
             }
-            ServiceType.DEEPSEEK -> setEmptyState(views)
+            ServiceType.DEEPSEEK -> setEmptyState(views, context)
+            ServiceType.TRAE,
+            ServiceType.WORKBUDDY,
+            ServiceType.SUB2API -> setEmptyState(views, context)
             ServiceType.OLLAMA -> {
-                setRowLabel(views, "5h", "每周", "")
+                setRowLabel(views, context.getString(R.string.window_5h_short), context.getString(R.string.window_every_week), "")
                 populateRow(views, R.id.row1_pct, R.id.row1_bar, R.id.row1_reset,
                     pct = extras["session.pct"]?.toFloatOrNull()?.toInt(),
                     resetSec = extras["session.resetAt"]?.toLongOrNull()?.let { (it - System.currentTimeMillis()) / 1000 }?.takeIf { it > 0 })
@@ -223,8 +297,11 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
                 views.setTextViewText(R.id.row3_reset, "")
                 // Plan 信息合并到标题行
                 val plan = extras["plan"] ?: ""
-                val titleText = if (plan.isNotEmpty()) "${service.displayName} · $plan"
-                    else "${service.displayName} · 额度"
+                val titleText = if (plan.isNotEmpty()) {
+                    context.getString(R.string.widget_quota_with_plan, service.displayName, plan)
+                } else {
+                    context.getString(R.string.widget_service_quota, service.displayName)
+                }
                 views.setTextViewText(R.id.widget_service_title, titleText)
             }
         }
@@ -262,15 +339,15 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
     /** 根据用量百分比动态改进度条颜色 */
     private fun setProgressColor(views: RemoteViews, barViewId: Int, pct: Int) {
         val color = when {
-            pct >= 80 -> 0xFFE91E63.toInt()   // 玫红
+            pct >= 80 -> 0xFFD64A6E.toInt()   // 玫红
             pct >= 50 -> 0xFFFFA726.toInt()   // 暖橙
-            else -> 0xFFFF85A2.toInt()         // 草莓粉
+            else -> 0xFFC9436C.toInt()         // 深玫瑰（主色）
         }
         views.setColorStateList(barViewId, "setProgressTintList", ColorStateList.valueOf(color))
     }
 
-    private fun setEmptyState(views: RemoteViews) {
-        views.setTextViewText(R.id.widget_updated, "暂无数据")
+    private fun setEmptyState(views: RemoteViews, context: Context) {
+        views.setTextViewText(R.id.widget_updated, context.getString(R.string.widget_no_data))
         for (pctId in listOf(R.id.row1_pct, R.id.row2_pct, R.id.row3_pct)) {
             views.setTextViewText(pctId, "—")
         }
@@ -307,14 +384,57 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
                 .apply()
         }
 
-        fun currentDisplayService(context: Context): ServiceType {
-            val key = autoRefreshPrefs(context).getString(KEY_DISPLAY_SERVICE, ServiceType.OPENCODE_GO.storageKey)
-            return DISPLAY_SERVICES.firstOrNull { it.storageKey == key } ?: ServiceType.OPENCODE_GO
+        /**
+         * 已配置凭据的服务（本地存在 credential 即视为已配置）。
+         * 小组件只在这些服务间轮换展示；未配置的不占位。
+         * 注：只覆盖 [DISPLAY_SERVICES]（轮换区），DeepSeek 单独用 [isCredentialPresent] 判断。
+         */
+        fun configuredServices(context: Context): List<ServiceType> {
+            val repository = widgetCredentialRepository(context)
+            return runCatching {
+                runBlocking {
+                    DISPLAY_SERVICES.filter { repository.get(it) != null }
+                }
+            }.getOrDefault(emptyList())
         }
 
+        /** 指定服务本地是否已保存凭据（DeepSeek 余额行显隐用）。 */
+        fun isCredentialPresent(context: Context, service: ServiceType): Boolean {
+            val repository = widgetCredentialRepository(context)
+            return runCatching {
+                runBlocking { repository.get(service) != null }
+            }.getOrDefault(false)
+        }
+
+        private fun widgetCredentialRepository(context: Context): CredentialRepository {
+            val appContext = context.applicationContext
+            return CredentialRepository(
+                secureStorage = SecureStorage(appContext.secureStorageDataStore),
+                balanceCache = BalanceCache(appContext.balanceCacheDataStore)
+            )
+        }
+
+        /**
+         * 当前展示的服务：仅在已配置集合内取用户选择；选择失效（服务被删除）
+         * 时回退第一个已配置服务；一个都没配置返回 null（Widget 展示引导空态）。
+         */
+        fun currentDisplayService(context: Context): ServiceType? =
+            currentDisplayService(context, configuredServices(context))
+
+        /** 同上，但复用已读好的 [configured]，避免一次更新里多次 Keystore 解密。 */
+        fun currentDisplayService(context: Context, configured: List<ServiceType>): ServiceType? {
+            if (configured.isEmpty()) return null
+            val key = autoRefreshPrefs(context).getString(KEY_DISPLAY_SERVICE, null)
+            return configured.firstOrNull { it.storageKey == key } ?: configured.first()
+        }
+
+        /** 只在已配置服务间轮换。 */
         private fun switchDisplayService(context: Context) {
-            val current = currentDisplayService(context)
-            val next = DISPLAY_SERVICES[(DISPLAY_SERVICES.indexOf(current).coerceAtLeast(0) + 1) % DISPLAY_SERVICES.size]
+            val configured = configuredServices(context)
+            if (configured.size <= 1) return
+            val current = currentDisplayService(context, configured)
+            val currentIndex = current?.let { configured.indexOf(it) } ?: -1
+            val next = configured[(currentIndex.coerceAtLeast(0) + 1) % configured.size]
             autoRefreshPrefs(context).edit().putString(KEY_DISPLAY_SERVICE, next.storageKey).apply()
         }
 
@@ -324,6 +444,9 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
             ServiceType.CODEX -> "Codex"
             ServiceType.DEEPSEEK -> "DS"
             ServiceType.OLLAMA -> "Ollama"
+            ServiceType.TRAE -> "Trae"
+            ServiceType.WORKBUDDY -> "WB"
+            ServiceType.SUB2API -> "S2API"
         }
 
         private fun widgetLogo(service: ServiceType): Int = when (service) {
@@ -331,6 +454,10 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
             ServiceType.CODEX -> R.drawable.ic_codex_logo_widget // PNG for RemoteViews compatibility
             ServiceType.DEEPSEEK -> R.drawable.ic_deepseek_logo
             ServiceType.OLLAMA -> R.drawable.ic_ollama_logo_widget
+            // 新服务暂不进桌面组件轮播（DISPLAY_SERVICES 未包含），这里用占位 logo 保证穷尽
+            ServiceType.TRAE,
+            ServiceType.WORKBUDDY,
+            ServiceType.SUB2API -> R.drawable.ic_deepseek_logo
         }
 
         /**
@@ -352,12 +479,14 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
         }
 
         fun showRefreshing(context: Context) {
+            // 与 onUpdate 同理：用最新语言偏好包装，避免进程启动后切换语言不生效
+            val localized = LocaleManager.wrapContext(context)
             val appWidgetManager = AppWidgetManager.getInstance(context)
             val component = ComponentName(context, OpenCodeGoWidgetProvider::class.java)
             val ids = appWidgetManager.getAppWidgetIds(component)
             ids.forEach { id ->
                 val views = RemoteViews(context.packageName, R.layout.widget_opencode_go)
-                views.setTextViewText(R.id.widget_updated, "刷新中…")
+                views.setTextViewText(R.id.widget_updated, localized.getString(R.string.widget_refreshing))
                 appWidgetManager.partiallyUpdateAppWidget(id, views)
             }
         }

app/src/main/java/com/rainy/token/ui/widget/WidgetRefreshReceiver.kt

@@ -23,26 +23,30 @@ class WidgetRefreshReceiver : BroadcastReceiver() {
         if (isRefreshing) return
         isRefreshing = true
         val pendingResult = goAsync()
-        val entryPoint = EntryPointAccessors.fromApplication(
-            appContext, WidgetRefreshEntryPoint::class.java
-        )
-        val useCase = entryPoint.refreshBalanceUseCase()
         OpenCodeGoWidgetProvider.showRefreshing(appContext)
 
         CoroutineScope(Dispatchers.IO).launch {
             try {
+                // EntryPoint 获取也放进 try：任何异常都必须落到 finally，
+                // 否则 isRefreshing 卡死 true、pendingResult 泄漏
+                val entryPoint = EntryPointAccessors.fromApplication(
+                    appContext, WidgetRefreshEntryPoint::class.java
+                )
+                val useCase = entryPoint.refreshBalanceUseCase()
                 val selectedService = OpenCodeGoWidgetProvider.currentDisplayService(appContext)
-                val refreshed = withTimeoutOrNull(25_000L) {
-                    val selectedResult = useCase(selectedService)
-                    val dsResult = useCase(ServiceType.DEEPSEEK)
-                    selectedResult.isSuccess || dsResult.isSuccess
-                } == true
-                if (refreshed) {
-                    OpenCodeGoWidgetProvider.notifyDataChanged(appContext)
+                val dsConfigured = OpenCodeGoWidgetProvider.isCredentialPresent(appContext, ServiceType.DEEPSEEK)
+                if (selectedService != null || dsConfigured) {
+                    withTimeoutOrNull(25_000L) {
+                        // 只刷新「当前展示的服务 + 已配置的 DeepSeek」；未配置的不发请求
+                        selectedService?.let { useCase(it) }
+                        if (dsConfigured) useCase(ServiceType.DEEPSEEK)
+                    }
                 }
             } catch (_: Exception) {
                 // 静默，Widget 保留旧数据
             } finally {
+                // 无论成败都重渲染：清掉「刷新中」占位，零配置时也能立即恢复空态文案
+                OpenCodeGoWidgetProvider.notifyDataChanged(appContext)
                 isRefreshing = false
                 pendingResult.finish()
             }

app/src/main/java/com/rainy/token/util/LocaleManager.kt

@@ -0,0 +1,98 @@
+package com.rainy.token.util
+
+import android.content.Context
+import android.content.res.Configuration
+import android.os.Build
+import android.os.LocaleList
+import java.util.Locale
+
+/**
+ * 应用内语言偏好管理（自建轻量方案，不引入 appcompat 依赖）。
+ *
+ * 语言值约定：
+ * - `null`（未设置）= 跟随系统
+ * - `"zh"` = 简体中文（匹配 values-b+zh+Hans，BCP-47 写法，覆盖中国大陆等简体地区）
+ * - `"zh-Hant"` = 繁体中文（匹配 values-b+zh+Hant，BCP-47 写法，覆盖台/港/澳所有繁体地区）
+ * - `"en"` = English（匹配默认 values/ 英文资源）
+ *
+ * 注：AGP 9 资源合并器不接受 values-zh-Hans/values-zh-Hant 目录名，故用等价的
+ * BCP-47 写法 values-b+zh+Hans / values-b+zh+Hant；编译产物同为
+ * language=zh + script=Hans/Hant 配置。
+ *
+ * 在 [Application] 与 [MainActivity] 的 attachBaseContext 中调用 [wrapContext]
+ * 应用偏好；切换语言后由设置页保存偏好并 recreate Activity 触发重新解析。
+ *
+ * Android 13+（TIRAMISU）与系统"应用语言"页同步：读写统一走 framework 的
+ * [android.app.LocaleManager]，私有 SharedPreferences 仅在 API < 33 或
+ * framework 未设置时作为兜底——避免应用内偏好与系统级设置互相覆盖造成双源冲突。
+ */
+object LocaleManager {
+
+    private const val PREFS_NAME = "locale_prefs"
+    private const val KEY_LOCALE = "locale"
+
+    /** 当前生效的语言代码；null = 跟随系统 */
+    fun getLocaleCode(context: Context): String? {
+        // Android 13+：framework 是唯一权威源（系统"应用语言"页与应用内选择共用）
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            val locales = context.getSystemService(android.app.LocaleManager::class.java)?.applicationLocales
+            if (locales != null && !locales.isEmpty) {
+                for (i in 0 until locales.size()) {
+                    val l = locales.get(i)
+                    when {
+                        l.language == "zh" && l.script != "Hant" -> return "zh"
+                        l.language == "zh" && l.script == "Hant" -> return "zh-Hant"
+                        l.language == "en" -> return "en"
+                    }
+                }
+                return null // 系统选了不支持的第三方语言 → 回退默认英文资源
+            }
+            // framework 未设置（跟随系统）：一次性迁移旧 SharedPreferences 偏好到
+            // framework 后清除，避免升级设备上过期偏好复活（framework 才是唯一权威源）
+            migrateLegacyPrefs(context)
+            return null
+        }
+        // API < 33：回退私有偏好
+        val code = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .getString(KEY_LOCALE, null) ?: return null
+        return code.takeIf { it == "zh" || it == "zh-Hant" || it == "en" }
+    }
+
+    /** 把 API < 33 时代写入的私有偏好一次性迁移到 framework 并清除 */
+    private fun migrateLegacyPrefs(context: Context) {
+        // 方法体内守卫：lint 据此识别 API33 调用（@RequiresApi 注解在本环境解析异常）
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return
+        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val code = prefs.getString(KEY_LOCALE, null) ?: return
+        context.getSystemService(android.app.LocaleManager::class.java)
+            ?.setApplicationLocales(LocaleList.forLanguageTags(code))
+        prefs.edit().remove(KEY_LOCALE).apply()
+    }
+
+    /** 保存语言偏好；传 null 表示跟随系统 */
+    fun saveLocale(context: Context, code: String?) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            // Android 13+：写入系统"应用语言"，framework 生效并自动重建 Activity
+            context.getSystemService(android.app.LocaleManager::class.java)
+                ?.setApplicationLocales(LocaleList.forLanguageTags(code ?: ""))
+            return
+        }
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .putString(KEY_LOCALE, code)
+            .apply()
+    }
+
+    /** 把 base context 包装上应用语言配置；未设置偏好时原样返回 */
+    fun wrapContext(base: Context): Context {
+        val code = getLocaleCode(base) ?: return base
+        val locale = when (code) {
+            "zh" -> Locale.SIMPLIFIED_CHINESE
+            "zh-Hant" -> Locale.forLanguageTag("zh-Hant")
+            else -> Locale.ENGLISH
+        }
+        val config = Configuration(base.resources.configuration)
+        config.setLocales(android.os.LocaleList(locale))
+        return base.createConfigurationContext(config)
+    }
+}

app/src/main/res/drawable-night/widget_bg.xml

@@ -3,8 +3,8 @@
 <shape xmlns:android="http://schemas.android.com/apk/res/android"
     android:shape="rectangle">
     <corners android:radius="16dp" />
-    <solid android:color="#2D1825" />
+    <solid android:color="#1A1417" />
     <stroke
         android:width="1dp"
-        android:color="#4D2D3D" />
+        android:color="#4C3B44" />
 </shape>

app/src/main/res/drawable/ic_launcher_background.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- 雨晴Token 背景 · 樱粉渐变 -->
+<!-- 雨晴Token 背景 · 精致粉调渐变 -->
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:aapt="http://schemas.android.com/aapt"
     android:width="108dp"
@@ -12,10 +12,10 @@
                 android:startX="0" android:startY="0"
                 android:endX="108" android:endY="108"
                 android:type="linear">
-                <item android:offset="0" android:color="#FFF0F5" />
-                <item android:offset="0.5" android:color="#FFD1DC" />
-                <item android:offset="1" android:color="#FFB3C1" />
+                <item android:offset="0" android:color="#FFF9FB" />
+                <item android:offset="0.5" android:color="#FDEFF4" />
+                <item android:offset="1" android:color="#FBDCE8" />
             </gradient>
         </aapt:attr>
     </path>
-</vector>
+</vector>

app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -7,14 +7,14 @@
     android:viewportHeight="108">
 
     <!--
-        配色统一雨晴品牌系：
-        · 水滴：草莓粉 #FF85A2（主品牌色）
-        · sparkle：樱粉 #FFD1DC（浅层次）
+        配色统一雨晴品牌系（精致粉调）：
+        · 水滴：深玫瑰 #C9436C（主品牌色）
+        · sparkle：浅玫瑰粉 #FFC9D8（浅层次）
         · 高光：白色
-        · 背景：樱粉渐变 #FFF0F5→#FFD1DC→#FFB3C1
+        · 背景：粉白渐变 #FFF9FB→#FDEFF4→#FBDCE8
     -->
 
-    <!-- 大水滴 · 草莓粉 -->
+    <!-- 大水滴 · 深玫瑰 -->
     <path
         android:pathData="
             M54,30
@@ -24,7 +24,7 @@
             Q64,76 68,68
             Q72,62 64,50
             Q54,30 54,30Z"
-        android:fillColor="#FF85A2" />
+        android:fillColor="#C9436C" />
 
     <!-- 水滴高光 · 白色椭圆 -->
     <path
@@ -32,24 +32,24 @@
         android:fillColor="#FFFFFF"
         android:fillAlpha="0.75" />
 
-    <!-- sparkle 小太阳 · 樱粉 · 右上角 (72,32) -->
+    <!-- sparkle 小太阳 · 浅玫瑰粉 · 右上角 (72,32) -->
     <path android:pathData="M72,22L72,42"
-        android:strokeColor="#FFD1DC" android:strokeWidth="3"
+        android:strokeColor="#FFC9D8" android:strokeWidth="3"
         android:strokeLineCap="round"
         android:fillColor="@android:color/transparent" />
     <path android:pathData="M62,32L82,32"
-        android:strokeColor="#FFD1DC" android:strokeWidth="3"
+        android:strokeColor="#FFC9D8" android:strokeWidth="3"
         android:strokeLineCap="round"
         android:fillColor="@android:color/transparent" />
     <path android:pathData="M66,26L78,38"
-        android:strokeColor="#FFD1DC" android:strokeWidth="2"
+        android:strokeColor="#FFC9D8" android:strokeWidth="2"
         android:strokeLineCap="round"
         android:fillColor="@android:color/transparent" />
     <path android:pathData="M78,26L66,38"
-        android:strokeColor="#FFD1DC" android:strokeWidth="2"
+        android:strokeColor="#FFC9D8" android:strokeWidth="2"
         android:strokeLineCap="round"
         android:fillColor="@android:color/transparent" />
     <path android:pathData="M72,32m-2.5,0a2.5,2.5 0,1,1 5,0a2.5,2.5 0,1,1 -5,0"
-        android:fillColor="#FFD1DC" />
+        android:fillColor="#FFC9D8" />
 
 </vector>

app/src/main/res/drawable/ic_rainy_wordmark.xml

@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
   RainyToken 几何字标 · 与 OpenCode Go logo 完全同构
-  同样的两个 24x30 S 形方块拼接，只是配色换成雨晴粉色系：
-  - Go 深色 #211E1E → 粉色 #C2185B
-  - Go 浅色 #CFCECD → 浅粉 #FFD1DC
+  同样的两个 24x30 S 形方块拼接，只是配色换成雨晴精致粉系：
+  - Go 深色 #211E1E → 深玫瑰 #C9436C
+  - Go 浅色 #CFCECD → 浅玫瑰粉 #FFC9D8
   viewBox 和 path 与 ic_opencode_go_logo 完全一致
 -->
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
@@ -11,20 +11,20 @@
     android:height="30dp"
     android:viewportWidth="54"
     android:viewportHeight="30">
-    <!-- 左块（深粉） -->
+    <!-- 左块（深玫瑰） -->
     <path
-        android:fillColor="#C2185B"
+        android:fillColor="#C9436C"
         android:pathData="M24 30H0V0H24V6H6V24H18V18H12V12H24V30Z"/>
     <!-- 左块 S 内弯（浅粉） -->
     <path
-        android:fillColor="#FFD1DC"
+        android:fillColor="#FFC9D8"
         android:pathData="M12 18H18V24H6V12H12V18Z"/>
     <!-- 右块 S 内弯（浅粉） -->
     <path
-        android:fillColor="#FFD1DC"
+        android:fillColor="#FFC9D8"
         android:pathData="M48 12V24H36V12H48Z"/>
-    <!-- 右块（深粉） -->
+    <!-- 右块（深玫瑰） -->
     <path
-        android:fillColor="#C2185B"
+        android:fillColor="#C9436C"
         android:pathData="M54 30H30V0H54V30ZM36 24H48V6H36V24Z"/>
 </vector>

app/src/main/res/drawable/ic_workbuddy_logo.xml

@@ -0,0 +1,30 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="40dp"
+    android:height="40dp"
+    android:viewportWidth="40"
+    android:viewportHeight="40">
+    <!-- 圆角渐变底（源自官网 SVG paint0_linear：#0EC8A9 → #01C886） -->
+    <path android:pathData="M20,0C31.046,0 40,8.954 40,20C40,31.046 31.046,40 20,40C8.954,40 0,31.046 0,20C0,8.954 8.954,0 20,0Z">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:startColor="#0EC8A9"
+                android:endColor="#01C886"
+                android:startX="20"
+                android:startY="0"
+                android:endX="20"
+                android:endY="40" />
+        </aapt:attr>
+    </path>
+    <!-- 主体图形（官网 SVG 白色路径，去除高斯模糊滤镜后保留轮廓） -->
+    <path
+        android:pathData="M28.5931,3.12762C28.9853,2.77585 29.0091,2.76226 29.2968,2.74499C29.7628,2.71096 30.1894,2.93488 30.916,3.59634C32.6132,5.13875 34.9769,8.30904 36.4462,11.0168L37.0138,12.0682L37.8156,12.4668C38.5896,12.8579 39.8593,13.6593 40.3898,14.0895C40.6297,14.2878 40.6638,14.2925 40.9133,14.1954C42.0388,13.7572 43.6506,14.3382 45.0727,15.7024C46.3529,16.9294 47.5794,19.026 48.0491,20.7757C48.1177,21.0574 48.2087,21.6628 48.2419,22.1134C48.349,23.6964 47.8414,24.9608 46.8637,25.5331C46.664,25.6484 46.6505,25.6795 46.6561,26.1774C46.7011,28.5481 46.0621,30.9144 44.7785,33.2221C43.3293,35.8133 40.7489,38.4945 37.2566,41.0199C35.3813,42.3846 30.9445,44.9701 28.9382,45.8778C24.1324,48.0414 20.2794,48.8709 16.9329,48.4609C14.9368,48.219 12.6769,47.44 11.34,46.5355C10.9885,46.2925 10.9325,46.2774 10.6637,46.3543C9.2327,46.7651 7.35867,45.9207 5.76659,44.1535C5.13165,43.4471 4.1065,41.7127 3.77404,40.7843C3.0054,38.6118 3.15852,36.6506 4.18236,35.4799C4.44671,35.1785 4.45511,35.1658 4.39735,34.6589C4.30195,33.8289 4.25837,32.6008 4.30192,31.808L4.33666,31.0674L3.22502,29.101C1.5033,26.0375 0.409325,23.4645 -0.012563,21.4992C-0.235219,20.4218 -0.221193,19.9436 0.0522186,19.5899C0.21871,19.3763 0.764928,19.1545 1.42322,19.0329C3.08041,18.742 6.69466,19.0056 10.7155,19.7155L11.1329,19.788L12.0511,18.976C13.5747,17.6264 14.587,16.8696 16.4531,15.706C18.3981,14.4891 20.5929,13.4877 23.0648,12.695L23.8577,12.4414L24.2939,11.2964C25.8547,7.17615 27.4533,4.13844 28.5931,3.12762ZM15.5182,24.243C13.7542,25.2615 12.8718,25.7706 12.2236,26.3413C9.59893,28.6526 8.61811,32.3134 9.73545,35.6274C10.0114,36.4457 10.5201,37.3283 11.5386,39.0923C12.5571,40.8564 13.0671,41.7383 13.6378,42.3864C15.9491,45.0112 19.6103,45.9929 22.9243,44.8755C23.7426,44.5995 24.6249,44.0899 26.3888,43.0714L36.5375,37.2121C38.3016,36.1936 39.184,35.6845 39.8321,35.1137C42.4568,32.8024 43.4373,29.1409 42.3198,25.8269C42.0438,25.0086 41.5342,24.1264 40.5158,22.3624C39.4973,20.5983 38.9882,19.7159 38.4175,19.0678C36.8263,17.2506 35.0162,16.0207 33.2109,15.4111C32.0906,15.0345 31.0169,14.8711 29.9888,14.9141C29.9121,14.9172 29.8379,14.9248 29.7661,14.9368C29.6944,14.9489 29.6241,14.963 29.5553,14.9785L29.5553,14.9785C28.5066,15.2051 27.5082,15.6179 26.5601,16.2168C25.612,16.8157 24.7347,17.5885 23.9283,18.5352C23.1219,19.4819 22.4032,20.5843 21.7722,21.8423C21.1412,23.1003 20.6135,24.5007 20.189,26.0436C19.7645,27.5865 19.4573,29.2539 19.2674,31.0458C19.0775,32.8377 19.0159,34.7359 19.0826,36.7404C19.1493,38.7449 19.3424,40.8284 19.6619,42.991C19.6698,42.9989 19.6777,43.0068 19.6856,43.0147C19.6935,43.0226 19.7014,43.0305 19.7093,43.0384L19.7093,43.0384C20.758,42.8118 21.7564,42.399 22.7045,41.8001C23.6526,41.2012 24.5299,40.4284 25.3363,39.4817C26.1427,38.535 26.8614,37.4326 27.4924,36.1746C28.1234,34.9166 28.6511,33.5162 29.0756,31.9733C29.5001,30.4304 29.8073,28.763 29.9972,26.9711C30.1871,25.1792 30.2487,23.281 30.182,21.2765C30.1153,19.272 29.9222,17.1885 29.6027,15.0259L29.5948,15.018C29.5869,15.0101 29.579,15.0022 29.5711,14.9943C28.5224,15.2209 27.524,15.6337 26.5759,16.2326C25.6278,16.8315 24.7505,17.6043 23.9441,18.551C23.1377,19.4977 22.419,20.6001 21.788,21.8581C21.157,23.1161 20.6293,24.5165 20.2048,26.0594C19.7803,27.6023 19.4731,29.2697 19.2832,31.0616C19.0933,32.8535 19.0317,34.7517 19.0984,36.7562C19.1651,38.7607 19.3582,40.8442 19.6777,43.0068L19.6777,43.0068Z"
+        android:fillColor="#FFFFFF" />
+    <!-- 白色小装饰条（官网 SVG 两个 rect） -->
+    <path
+        android:pathData="M18.5,32.9L16.5,31.3C15.9,32.4 16.2,33.8 17.3,34.4L19.3,36C19.9,34.9 19.6,33.5 18.5,32.9Z"
+        android:fillColor="#FFFFFF" />
+    <path
+        android:pathData="M29.3,26.7L27.3,25.1C26.7,26.2 27,27.6 28.1,28.2L30.1,29.8C30.7,28.7 30.4,27.3 29.3,26.7Z"
+        android:fillColor="#FFFFFF" />
+</vector>

app/src/main/res/drawable/widget_bg.xml

@@ -2,8 +2,8 @@
 <shape xmlns:android="http://schemas.android.com/apk/res/android"
     android:shape="rectangle">
     <corners android:radius="16dp" />
-    <solid android:color="#FFF0F5" />
+    <solid android:color="#FFF9FB" />
     <stroke
         android:width="1dp"
-        android:color="#FFD1DC" />
+        android:color="#F2DCE4" />
 </shape>

app/src/main/res/layout-night/widget_opencode_go.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- MIUI Widget 深色模式布局 — 文字颜色适配暗色背景 #2D1825 -->
+<!-- MIUI Widget 深色模式布局 — 文字颜色适配暗色背景 #1A1417 -->
 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@android:id/background"
     android:layout_width="match_parent"
@@ -35,7 +35,7 @@
             android:layout_width="10dp"
             android:layout_height="24dp"
             android:text=">"
-            android:textColor="#8A7A82"
+            android:textColor="#CBB8C0"
             android:textSize="14sp"
             android:gravity="center" />
 
@@ -44,7 +44,7 @@
             android:layout_width="48dp"
             android:layout_height="24dp"
             android:text="OCGO"
-            android:textColor="#FF85A2"
+            android:textColor="#FFA9BF"
             android:textSize="10sp"
             android:textStyle="bold"
             android:layout_marginStart="6dp"
@@ -64,6 +64,8 @@
             android:id="@+id/widget_updated"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
+            android:maxLines="1"
+            android:ellipsize="end"
             android:text="--"
             android:textColor="#D4C4CC"
             android:textSize="10sp" />
@@ -73,7 +75,7 @@
             android:layout_width="40dp"
             android:layout_height="24dp"
             android:text="↻"
-            android:textColor="#FF85A2"
+            android:textColor="#FFA9BF"
             android:textSize="20sp"
             android:layout_marginStart="6dp"
             android:gravity="center" />
@@ -96,8 +98,8 @@
             android:id="@+id/widget_service_title"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="OpenCode Go · 用量"
-            android:textColor="#C4A0AB"
+            android:text="@string/widget_title_opencode"
+            android:textColor="#CBB8C0"
             android:textSize="11sp" />
     </LinearLayout>
 
@@ -109,11 +111,12 @@
         android:gravity="center_vertical"
         android:layout_marginBottom="3dp">
         <TextView android:id="@+id/row1_label"
-            android:layout_width="36dp" android:layout_height="wrap_content"
-            android:text="5h" android:textColor="#C4A0AB" android:textSize="11sp" />
+            android:layout_width="44dp" android:layout_height="wrap_content"
+            android:maxLines="1" android:ellipsize="end"
+            android:text="5h" android:textColor="#CBB8C0" android:textSize="11sp" />
         <TextView android:id="@+id/row1_pct"
             android:layout_width="38dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#FFD1DC" android:textSize="12sp"
+            android:text="--" android:textColor="#FFC9D8" android:textSize="12sp"
             android:textStyle="bold" android:gravity="end" />
         <ProgressBar android:id="@+id/row1_bar"
             style="@android:style/Widget.ProgressBar.Horizontal"
@@ -123,7 +126,7 @@
             android:progressTint="@color/widget_bar_5h" />
         <TextView android:id="@+id/row1_reset"
             android:layout_width="48dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#8A7A82" android:textSize="10sp" />
+            android:text="--" android:textColor="#CBB8C0" android:textSize="10sp" />
     </LinearLayout>
 
     <!-- 本周 -->
@@ -134,11 +137,12 @@
         android:gravity="center_vertical"
         android:layout_marginBottom="3dp">
         <TextView android:id="@+id/row2_label"
-            android:layout_width="36dp" android:layout_height="wrap_content"
-            android:text="本周" android:textColor="#C4A0AB" android:textSize="11sp" />
+            android:layout_width="44dp" android:layout_height="wrap_content"
+            android:maxLines="1" android:ellipsize="end"
+            android:text="@string/window_weekly" android:textColor="#CBB8C0" android:textSize="11sp" />
         <TextView android:id="@+id/row2_pct"
             android:layout_width="38dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#FFD1DC" android:textSize="12sp"
+            android:text="--" android:textColor="#FFC9D8" android:textSize="12sp"
             android:textStyle="bold" android:gravity="end" />
         <ProgressBar android:id="@+id/row2_bar"
             style="@android:style/Widget.ProgressBar.Horizontal"
@@ -148,7 +152,7 @@
             android:progressTint="@color/widget_bar_weekly" />
         <TextView android:id="@+id/row2_reset"
             android:layout_width="48dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#8A7A82" android:textSize="10sp" />
+            android:text="--" android:textColor="#CBB8C0" android:textSize="10sp" />
     </LinearLayout>
 
     <!-- 本月 -->
@@ -159,11 +163,12 @@
         android:gravity="center_vertical"
         android:layout_marginBottom="3dp">
         <TextView android:id="@+id/row3_label"
-            android:layout_width="36dp" android:layout_height="wrap_content"
-            android:text="本月" android:textColor="#C4A0AB" android:textSize="11sp" />
+            android:layout_width="44dp" android:layout_height="wrap_content"
+            android:maxLines="1" android:ellipsize="end"
+            android:text="@string/window_monthly" android:textColor="#CBB8C0" android:textSize="11sp" />
         <TextView android:id="@+id/row3_pct"
             android:layout_width="38dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#FFD1DC" android:textSize="12sp"
+            android:text="--" android:textColor="#FFC9D8" android:textSize="12sp"
             android:textStyle="bold" android:gravity="end" />
         <ProgressBar android:id="@+id/row3_bar"
             style="@android:style/Widget.ProgressBar.Horizontal"
@@ -173,11 +178,12 @@
             android:progressTint="@color/widget_bar_monthly" />
         <TextView android:id="@+id/row3_reset"
             android:layout_width="48dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#8A7A82" android:textSize="10sp" />
+            android:text="--" android:textColor="#CBB8C0" android:textSize="10sp" />
     </LinearLayout>
 
-    <!-- DeepSeek 余额 -->
+    <!-- DeepSeek 余额（未配置 DeepSeek 时整行隐藏，id 供 RemoteViews setViewVisibility） -->
     <LinearLayout
+        android:id="@+id/widget_ds_row"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:orientation="horizontal"
@@ -190,17 +196,18 @@
             android:adjustViewBounds="true"
             android:layout_marginEnd="5dp" />
         <TextView
+            android:id="@+id/widget_ds_label"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="DeepSeek 余额"
-            android:textColor="#C4A0AB"
+            android:text="@string/widget_deepseek_balance"
+            android:textColor="#CBB8C0"
             android:textSize="11sp" />
         <TextView
             android:id="@+id/widget_ds_amount"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="--"
-            android:textColor="#FFD1DC"
+            android:textColor="#FFC9D8"
             android:textSize="11sp"
             android:textStyle="bold"
             android:layout_marginStart="4dp" />
@@ -222,10 +229,11 @@
             android:progressBackgroundTint="#00000000"
             android:indeterminate="false" />
         <TextView
+            android:id="@+id/widget_brand"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="雨晴喵"
-            android:textColor="#8A7A82"
+            android:text="@string/widget_brand"
+            android:textColor="#CBB8C0"
             android:textSize="9sp" />
     </LinearLayout>
 

app/src/main/res/layout/widget_opencode_go.xml

@@ -36,7 +36,7 @@
             android:layout_width="10dp"
             android:layout_height="24dp"
             android:text=">"
-            android:textColor="#C4A0AB"
+            android:textColor="#7A6870"
             android:textSize="14sp"
             android:gravity="center" />
 
@@ -45,7 +45,7 @@
             android:layout_width="48dp"
             android:layout_height="24dp"
             android:text="OCGO"
-            android:textColor="#FF85A2"
+            android:textColor="#C9436C"
             android:textSize="10sp"
             android:textStyle="bold"
             android:layout_marginStart="6dp"
@@ -66,8 +66,10 @@
             android:id="@+id/widget_updated"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
+            android:maxLines="1"
+            android:ellipsize="end"
             android:text="--"
-            android:textColor="#C4A0AB"
+            android:textColor="#7A6870"
             android:textSize="10sp" />
 
         <TextView
@@ -75,7 +77,7 @@
             android:layout_width="40dp"
             android:layout_height="24dp"
             android:text="↻"
-            android:textColor="#FF85A2"
+            android:textColor="#C9436C"
             android:textSize="20sp"
             android:layout_marginStart="6dp"
             android:gravity="center" />
@@ -102,8 +104,8 @@
             android:id="@+id/widget_service_title"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="OpenCode Go · 用量"
-            android:textColor="#8A7A82"
+            android:text="@string/widget_title_opencode"
+            android:textColor="#7A6870"
             android:textSize="11sp" />
     </LinearLayout>
 
@@ -116,12 +118,13 @@
         android:layout_marginBottom="3dp">
 
         <TextView android:id="@+id/row1_label"
-            android:layout_width="36dp" android:layout_height="wrap_content"
-            android:text="5h" android:textColor="#8A7A82" android:textSize="11sp" />
+            android:layout_width="44dp" android:layout_height="wrap_content"
+            android:maxLines="1" android:ellipsize="end"
+            android:text="5h" android:textColor="#7A6870" android:textSize="11sp" />
 
         <TextView android:id="@+id/row1_pct"
             android:layout_width="38dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#3D2C35" android:textSize="12sp"
+            android:text="--" android:textColor="#3A2B31" android:textSize="12sp"
             android:textStyle="bold" android:gravity="end" />
 
         <ProgressBar android:id="@+id/row1_bar"
@@ -133,7 +136,7 @@
 
         <TextView android:id="@+id/row1_reset"
             android:layout_width="48dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#B0A0A7" android:textSize="10sp" />
+            android:text="--" android:textColor="#7A6870" android:textSize="10sp" />
     </LinearLayout>
 
     <!-- 本周 -->
@@ -145,12 +148,13 @@
         android:layout_marginBottom="3dp">
 
         <TextView android:id="@+id/row2_label"
-            android:layout_width="36dp" android:layout_height="wrap_content"
-            android:text="本周" android:textColor="#8A7A82" android:textSize="11sp" />
+            android:layout_width="44dp" android:layout_height="wrap_content"
+            android:maxLines="1" android:ellipsize="end"
+            android:text="@string/window_weekly" android:textColor="#7A6870" android:textSize="11sp" />
 
         <TextView android:id="@+id/row2_pct"
             android:layout_width="38dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#3D2C35" android:textSize="12sp"
+            android:text="--" android:textColor="#3A2B31" android:textSize="12sp"
             android:textStyle="bold" android:gravity="end" />
 
         <ProgressBar android:id="@+id/row2_bar"
@@ -162,7 +166,7 @@
 
         <TextView android:id="@+id/row2_reset"
             android:layout_width="48dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#B0A0A7" android:textSize="10sp" />
+            android:text="--" android:textColor="#7A6870" android:textSize="10sp" />
     </LinearLayout>
 
     <!-- 本月 -->
@@ -174,12 +178,13 @@
         android:layout_marginBottom="3dp">
 
         <TextView android:id="@+id/row3_label"
-            android:layout_width="36dp" android:layout_height="wrap_content"
-            android:text="本月" android:textColor="#8A7A82" android:textSize="11sp" />
+            android:layout_width="44dp" android:layout_height="wrap_content"
+            android:maxLines="1" android:ellipsize="end"
+            android:text="@string/window_monthly" android:textColor="#7A6870" android:textSize="11sp" />
 
         <TextView android:id="@+id/row3_pct"
             android:layout_width="38dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#3D2C35" android:textSize="12sp"
+            android:text="--" android:textColor="#3A2B31" android:textSize="12sp"
             android:textStyle="bold" android:gravity="end" />
 
         <ProgressBar android:id="@+id/row3_bar"
@@ -191,11 +196,12 @@
 
         <TextView android:id="@+id/row3_reset"
             android:layout_width="48dp" android:layout_height="wrap_content"
-            android:text="--" android:textColor="#B0A0A7" android:textSize="10sp" />
+            android:text="--" android:textColor="#7A6870" android:textSize="10sp" />
     </LinearLayout>
 
-    <!-- DeepSeek 余额 -->
+    <!-- DeepSeek 余额（未配置 DeepSeek 时整行隐藏，id 供 RemoteViews setViewVisibility） -->
     <LinearLayout
+        android:id="@+id/widget_ds_row"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:orientation="horizontal"
@@ -211,10 +217,11 @@
             android:layout_marginEnd="5dp" />
 
         <TextView
+            android:id="@+id/widget_ds_label"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="DeepSeek 余额"
-            android:textColor="#8A7A82"
+            android:text="@string/widget_deepseek_balance"
+            android:textColor="#7A6870"
             android:textSize="11sp" />
 
         <TextView
@@ -222,7 +229,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="--"
-            android:textColor="#3D2C35"
+            android:textColor="#3A2B31"
             android:textSize="11sp"
             android:textStyle="bold"
             android:layout_marginStart="4dp" />
@@ -247,10 +254,11 @@
             android:indeterminate="false" />
 
         <TextView
+            android:id="@+id/widget_brand"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="雨晴喵"
-            android:textColor="#D4C4CC"
+            android:text="@string/widget_brand"
+            android:textColor="#7A6870"
             android:textSize="9sp" />
     </LinearLayout>