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

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

README.en.md

@@ -59,7 +59,7 @@ RainyToken (雨晴Token) — AI Balance & Usage Quota Query · the Rainy Family
 | ➕ **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 · Strawberry Pink #FF85A2 · Sakura Pink #FFD1DC |
+| 🎀 **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 |

README.md

@@ -59,7 +59,7 @@ RainyToken（雨晴Token）— AI Balance & Usage Quota Query · the Rainy Famil
 | ➕ **一键添桌面** | 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/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

@@ -15,7 +15,7 @@ import dagger.hilt.android.AndroidEntryPoint
  *
  * 布局策略：
  *  - 外层只套 RainyTokenTheme（统一品牌色 + 字体）
- *  - 再套 RainyBackground（樱粉渐变背景，全局共享）
+ *  - 再套 RainyBackground（精致粉调渐变背景，全局共享）
  *  - NavHost 在背景之上，每个页面自己用 Scaffold 处理 TopAppBar 和 padding
  *  - **不**在外层再套 Scaffold —— 避免双 Scaffold 嵌套的 padding 计算混乱
  */

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

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/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
     }
@@ -42,6 +55,16 @@ class CredentialRepository @Inject constructor(
         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(
         val testedFingerprint: String,
         val previousIdentity: String?,
@@ -49,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))
         }
     }
 
@@ -124,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
@@ -137,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() }
             )
         }
 
@@ -185,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
         }
@@ -197,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 &&
@@ -213,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
@@ -246,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?,
@@ -275,27 +560,162 @@ class CredentialRepository @Inject constructor(
         )
     }
 
-    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
@@ -439,6 +859,10 @@ class CredentialRepository @Inject constructor(
             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(

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

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("凭据已变更，本次请求结果已丢弃")
 

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

@@ -13,6 +13,9 @@ import java.time.temporal.ChronoUnit
 import java.util.TimeZone
 import javax.inject.Singleton
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonArray
@@ -61,8 +64,8 @@ class Sub2ApiRepository constructor(
     private val json = Json { ignoreUnknownKeys = true }
     private val jsonMedia = "application/json".toMediaType()
 
-    suspend fun fetchBalance(): Result<ServiceBalance> = withContext(Dispatchers.IO) {
-        val credential = credentialRepository.get(ServiceType.SUB2API)
+    suspend fun fetchBalance(accountId: String? = null): Result<ServiceBalance> = withContext(Dispatchers.IO) {
+        val credential = credentialRepository.get(ServiceType.SUB2API, accountId)
             ?: return@withContext Result.failure(RepositoryError.InvalidCredential())
         if (credential !is Credential.Sub2ApiCredential) {
             return@withContext Result.failure(RepositoryError.InvalidCredential())
@@ -70,10 +73,14 @@ class Sub2ApiRepository constructor(
         val base = normalizeBase(credential.baseUrl)
         if (base.isBlank()) return@withContext Result.failure(RepositoryError.InvalidCredential())
 
-        // 面板模式：WebView 登录获取的 authToken 走用户级接口（全账号数据，与网页一致）
+        // 面板模式：WebView 登录获取的 authToken 走用户级接口（全账号数据，与网页一致）。
+        // token 过期（401/403）时自动用邮箱+密码重新登录换新 token 后重试一次；
+        // 只有自动重登也失败（账号问题）才返回错误，由 UI 引导手动登录。
         val panelToken = credential.authToken?.trim().takeUnless { it.isNullOrEmpty() }
         if (panelToken != null) {
-            return@withContext fetchPanelBalance(base, panelToken)
+            return@withContext withPanelAutoRefresh(accountId) { b, cred, token ->
+                fetchPanelBalance(b, token, cred, accountId)
+            }
         }
 
         val auth = resolveAuth(base, credential) ?: return@withContext Result.failure(
@@ -122,8 +129,8 @@ class Sub2ApiRepository constructor(
             extras = stats.extras,
             sub2UsageDetail = parseUsageDetail(resp.body).takeIf { it.isNotEmpty }
         )
-        balanceCache.put(ServiceType.SUB2API, balance)
-        credentialRepository.save(credential.copy(lastVerifiedAt = System.currentTimeMillis()))
+        balanceCache.put(ServiceType.SUB2API, balance, accountId)
+        credentialRepository.save(credential.copy(lastVerifiedAt = System.currentTimeMillis()), accountId)
         Result.success(balance)
     }
 
@@ -255,7 +262,12 @@ class Sub2ApiRepository constructor(
      * - GET /api/v1/usage/dashboard/models?… → 全账号模型分布
      * - GET /api/v1/usage/dashboard/snapshot-v2?granularity=day → 每日趋势（近30天）
      */
-    private suspend fun fetchPanelBalance(base: String, token: String): Result<ServiceBalance> {
+    private suspend fun fetchPanelBalance(
+        base: String,
+        token: String,
+        credential: Credential.Sub2ApiCredential,
+        accountId: String? = null
+    ): Result<ServiceBalance> {
         val tz = java.net.URLEncoder.encode(TimeZone.getDefault().id, "UTF-8")
         val today = java.time.LocalDate.now()
         val monthStart = today.withDayOfMonth(1).toString()
@@ -345,7 +357,15 @@ class Sub2ApiRepository constructor(
         )
         // 面板模式提前 return 时也要写余额缓存，否则主页列表读不到（显示「待获取」）。
         // 通过 RefreshWriteSession 机制暂存，随本次成功刷新一起提交。
-        balanceCache.put(ServiceType.SUB2API, panelBalance)
+        balanceCache.put(ServiceType.SUB2API, panelBalance, accountId)
+        // 面板请求成功即证明凭据验证通过：同步更新 lastVerifiedAt（对齐非面板 fetchBalance 路径），
+        // 否则面板登录超过 7 天（token 仍有效）后详情页会把凭据误标为「未配置或已过期」。
+        // 注意这里必须回写本次请求实际使用的 [token]：自动重登后 [token] 已是新值，
+        // 若沿用旧的 credential 会覆盖掉刚刷新的 token，导致下一个请求再次 401。
+        credentialRepository.save(
+            credential.copy(authToken = token, lastVerifiedAt = System.currentTimeMillis()),
+            accountId
+        )
         return Result.success(panelBalance)
     }
 
@@ -356,17 +376,38 @@ class Sub2ApiRepository constructor(
      * 用于「今天」窗口——按天只有一根柱子没有信息量，改为按小时展示。
      * 若面板版本不支持 hour 粒度（返回空/报错），返回空列表，由调用方回退到按天。
      */
-    suspend fun fetchHourlyTrend(date: LocalDate): Result<List<Sub2DailyUsage>> = withContext(Dispatchers.IO) {
-        val credential = credentialRepository.get(ServiceType.SUB2API) as? Credential.Sub2ApiCredential
+    suspend fun fetchHourlyTrend(date: LocalDate, accountId: String? = null): Result<List<Sub2DailyUsage>> = withContext(Dispatchers.IO) {
+        val credential = credentialRepository.get(ServiceType.SUB2API, accountId) as? Credential.Sub2ApiCredential
             ?: return@withContext Result.success(emptyList())
         val base = normalizeBase(credential.baseUrl)
         if (base.isBlank()) return@withContext Result.success(emptyList())
         val panelToken = credential.authToken?.trim().takeUnless { it.isNullOrEmpty() }
-        val auth = if (panelToken != null) {
-            AuthHeader("Authorization", "Bearer " + panelToken)
-        } else {
-            resolveAuth(base, credential) ?: return@withContext Result.success(emptyList())
+        if (panelToken != null) {
+            // 面板模式：token 过期自动重登后重试；自动重登失败仍静默回退（小时趋势非主链路）
+            return@withContext withPanelAutoRefresh(accountId) panelTrendBlock@ { b, _, token ->
+                val auth = AuthHeader("Authorization", "Bearer " + token)
+                val day = date.toString()
+                val resp = get(
+                    b,
+                    "/api/v1/usage/dashboard/snapshot-v2?start_date=$day&end_date=$day" +
+                        "&granularity=hour&include_trend=true&include_model_stats=false" +
+                        "&include_group_stats=false&timezone=" + tzParam(),
+                    auth
+                )
+                if (resp == null) return@panelTrendBlock Result.success(emptyList())
+                // token 过期要交给 withPanelAutoRefresh 自动重登重试，不能静默归零
+                if (resp.code == 401 || resp.code == 403) {
+                    return@panelTrendBlock Result.failure(
+                        RepositoryError.InvalidCredential("Sub2API 面板登录已失效，请重新网页登录")
+                    )
+                }
+                // 其余不支持/错误：静默回退，让「今天」仍能显示按天柱状图
+                if (resp.code !in 200..299) return@panelTrendBlock Result.success(emptyList())
+                val list = runCatching { parsePanelTrend(resp.body) }.getOrDefault(emptyList())
+                Result.success(list)
+            }
         }
+        val auth = resolveAuth(base, credential) ?: return@withContext Result.success(emptyList())
         val day = date.toString()
         val resp = get(
             base,
@@ -526,38 +567,56 @@ class Sub2ApiRepository constructor(
      */
     data class WindowModelStats(val stats: List<Sub2ModelStat>, val allTime: Boolean = false)
 
+    /**
+     * 单个 Key 在所选窗口内的用量汇总（来源：面板「使用记录」页的
+     * GET /api/v1/usage/stats?start_date=&end_date=&api_key_id=N，实测 v0.2.10）。
+     *
+     * 未使用过的 Key 该端点返回 404 API_KEY_NOT_FOUND，故用 [unused] 表示
+     * 「面板无该 Key 的记录」，UI 显示为 0 而不是报错。
+     */
+    data class KeyUsageStat(
+        val keyId: Long,
+        val name: String,
+        val groupName: String?,
+        val requests: Long,
+        val totalTokens: Long,
+        val cost: Double,
+        val unused: Boolean = false
+    )
+
     /** 可用分组（切换分组选择器数据）。 */
     data class PanelGroup(val id: Long, val name: String, val rateMultiplier: Double, val description: String = "")
 
     /** Key 列表。 */
-    suspend fun fetchPanelKeys(): Result<List<PanelApiKey>> = withContext(Dispatchers.IO) {
-        val (auth, base) = panelAuthOrNull() ?: return@withContext Result.failure(RepositoryError.InvalidCredential("请先登录面板（账号密码或网页登录）"))
-        val resp = get(base, "/api/v1/keys?page=1&page_size=100&sort_by=created_at&sort_order=desc&timezone=" + tzParam(), auth)
-            ?: return@withContext Result.failure(RepositoryError.Unknown(IllegalStateException("获取 Key 列表失败")))
-        panelFailure(resp)?.let { return@withContext Result.failure(it) }
-        val body = resp.body
-        runCatching {
-            val root = json.parseToJsonElement(body).jsonObject
-            val data = root["data"]?.jsonObject ?: root
-            val items = data["items"] as? JsonArray ?: JsonArray(emptyList())
-            items.mapNotNull { el ->
-                val o = el.jsonObject
-                PanelApiKey(
-                    id = o.longOr("id") ?: 0L,
-                    name = o.scalar("name") ?: "",
-                    key = o.scalar("key") ?: "",
-                    groupId = o["group_id"]?.jsonPrimitive?.contentOrNull?.toLongOrNull(),
-                    status = o.scalar("status") ?: "",
-                    lastUsedAt = o.scalar("last_used_at"),
-                    createdAt = o.scalar("created_at"),
-                    quota = o.numberOr("quota") ?: 0.0
-                )
-            }
-        }.fold(
-            onSuccess = { Result.success(it) },
-            onFailure = { Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "面板响应解析失败")) }
-        )
-    }
+    suspend fun fetchPanelKeys(accountId: String? = null): Result<List<PanelApiKey>> =
+        withPanelAutoRefresh(accountId) panelKeysBlock@ { base, _, token ->
+            val auth = AuthHeader("Authorization", "Bearer " + token)
+            val resp = get(base, "/api/v1/keys?page=1&page_size=100&sort_by=created_at&sort_order=desc&timezone=" + tzParam(), auth)
+                ?: return@panelKeysBlock Result.failure(RepositoryError.Unknown(IllegalStateException("获取 Key 列表失败")))
+            panelFailure(resp)?.let { return@panelKeysBlock Result.failure(it) }
+            val body = resp.body
+            runCatching {
+                val root = json.parseToJsonElement(body).jsonObject
+                val data = root["data"]?.jsonObject ?: root
+                val items = data["items"] as? JsonArray ?: JsonArray(emptyList())
+                items.mapNotNull { el ->
+                    val o = el.jsonObject
+                    PanelApiKey(
+                        id = o.longOr("id") ?: 0L,
+                        name = o.scalar("name") ?: "",
+                        key = o.scalar("key") ?: "",
+                        groupId = o["group_id"]?.jsonPrimitive?.contentOrNull?.toLongOrNull(),
+                        status = o.scalar("status") ?: "",
+                        lastUsedAt = o.scalar("last_used_at"),
+                        createdAt = o.scalar("created_at"),
+                        quota = o.numberOr("quota") ?: 0.0
+                    )
+                }
+            }.fold(
+                onSuccess = { Result.success(it) },
+                onFailure = { Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "面板响应解析失败")) }
+            )
+        }
 
     /**
      * 按面板 Token / 用户 API Key 两种认证方式，拉取指定日期区间内的分模型统计
@@ -565,9 +624,9 @@ class Sub2ApiRepository constructor(
      * 面板模式：GET /api/v1/usage/dashboard/models?start_date=&end_date=…
      * Key 模式：GET /v1/usage?days=&start_date=&end_date=…（404/400 自动兜底 /api/v1/usage）。
      */
-    suspend fun fetchWindowModelStats(startDate: LocalDate, endDate: LocalDate): Result<WindowModelStats> =
+    suspend fun fetchWindowModelStats(startDate: LocalDate, endDate: LocalDate, accountId: String? = null): Result<WindowModelStats> =
         withContext(Dispatchers.IO) {
-            val credential = credentialRepository.get(ServiceType.SUB2API) as? Credential.Sub2ApiCredential
+            val credential = credentialRepository.get(ServiceType.SUB2API, accountId) as? Credential.Sub2ApiCredential
                 ?: return@withContext Result.failure(RepositoryError.InvalidCredential("请先配置 Sub2API 凭据"))
             val base = normalizeBase(credential.baseUrl)
             if (base.isBlank()) return@withContext Result.failure(RepositoryError.InvalidCredential())
@@ -576,27 +635,32 @@ class Sub2ApiRepository constructor(
             val tz = tzParam()
             val panelToken = credential.authToken?.trim().takeUnless { it.isNullOrEmpty() }
 
-            val models: WindowModelStats = if (panelToken != null) {
-                val auth = AuthHeader("Authorization", "Bearer " + panelToken)
-                val resp = get(base, "/api/v1/usage/dashboard/models?start_date=$start&end_date=$end&model_source=requested&timezone=$tz", auth)
-                    ?: return@withContext Result.failure(RepositoryError.Unknown(IllegalStateException("获取窗口模型统计失败")))
-                panelFailure(resp)?.let { return@withContext Result.failure(it) }
-                val list = runCatching { parsePanelModels(resp.body) }.getOrElse { e ->
-                    return@withContext Result.failure(
-                        RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "面板响应解析失败: " + e.message)
-                    )
+            if (panelToken != null) {
+                // 面板模式：token 过期（401/403）自动重登换新 token 后重试一次
+                return@withContext withPanelAutoRefresh(accountId) block@ { b, _, token ->
+                    val auth = AuthHeader("Authorization", "Bearer " + token)
+                    val resp = get(b, "/api/v1/usage/dashboard/models?start_date=$start&end_date=$end&model_source=requested&timezone=$tz", auth)
+                        ?: return@block Result.failure(RepositoryError.Unknown(IllegalStateException("获取窗口模型统计失败")))
+                    panelFailure(resp)?.let { return@block Result.failure(it) }
+                    val list = runCatching { parsePanelModels(resp.body) }.getOrElse { e ->
+                        return@block Result.failure(
+                            RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "面板响应解析失败: " + e.message)
+                        )
+                    }
+                    Result.success(WindowModelStats(list.sortedByDescending { it.cost }, allTime = false))
                 }
-                WindowModelStats(list.sortedByDescending { it.cost }, allTime = false)
-            } else {
-                val auth = resolveAuth(base, credential)
-                    ?: return@withContext Result.failure(RepositoryError.InvalidCredential("Sub2API 认证失败，请检查 API Key"))
-                // 实测（xxcsn.site v0.2.1）：下游 /v1/usage 的 model_stats 是「历史累计」口径，
-                // days / start_date / end_date 只影响 daily_usage，不影响 model_stats——
-                // 所以直接用它无法回答「本周期用了哪些模型」。
-                // 先用当前 sk-key 反查它在面板里的 id，再走带日期窗口的 dashboard/models
-                //（该端点支持 api_key_id 且窗口生效，实测 key 维度 today=0 / 7d=8 条）。
-                val scoped = fetchKeyScopedWindowModelStats(base, panelToken, credential, start, end, tz)
-                if (scoped != null) return@withContext scoped
+            }
+
+            // Key 模式：resolveAuth 每次请求都用邮箱+密码（或 apiKey）现取 token，不存在长期过期问题
+            val auth = resolveAuth(base, credential)
+                ?: return@withContext Result.failure(RepositoryError.InvalidCredential("Sub2API 认证失败，请检查 API Key"))
+            // 实测（xxcsn.site v0.2.1）：下游 /v1/usage 的 model_stats 是「历史累计」口径，
+            // days / start_date / end_date 只影响 daily_usage，不影响 model_stats——
+            // 所以直接用它无法回答「本周期用了哪些模型」。
+            // 先用当前 sk-key 反查它在面板里的 id，再走带日期窗口的 dashboard/models
+            //（该端点支持 api_key_id 且窗口生效，实测 key 维度 today=0 / 7d=8 条）。
+            val scoped = fetchKeyScopedWindowModelStats(base, panelToken, credential, start, end, tz)
+            if (scoped != null) return@withContext scoped
 
                 // 兜底：只能拿到历史累计口径，仍返回结果，但由调用方按「累计」展示，避免误导成周期数据。
                 val days = (ChronoUnit.DAYS.between(startDate, endDate) + 1).coerceIn(1L, 90L)
@@ -615,10 +679,8 @@ class Sub2ApiRepository constructor(
                     )
                 }
                 // allTime=true：这是历史累计口径，UI 必须标注「累计」，不能冒充所选周期
-                WindowModelStats(list.sortedByDescending { it.cost }, allTime = true)
-            }
-            Result.success(models)
-        }
+                Result.success(WindowModelStats(list.sortedByDescending { it.cost }, allTime = true))
+    }
 
     /**
      * Key 模式下按日期窗口取分模型统计（实测 xxcsn.site v0.2.1）。
@@ -663,59 +725,139 @@ class Sub2ApiRepository constructor(
         }.getOrNull()
     }
 
+    /**
+     * 按 Key 统计（面板「使用记录」页口径，v0.2.10 实测）。
+     *
+     * 先取 Key 列表，再对每个 Key 调
+     * GET /api/v1/usage/stats?start_date=&end_date=&api_key_id=N。
+     * 未使用过的 Key 返回 404 API_KEY_NOT_FOUND —— 属「无记录」而非错误，
+     * 标记为 [KeyUsageStat.unused] 并计 0，不中断整个列表。
+     *
+     * 说明：面板没有「一次拿到所有 Key 用量」的端点（dashboard 下 keys 相关路由均 404，
+     * /api/v1/keys 上的 usage_1d/5h/7d 实测恒为 0），所以必须逐个查询，
+     * 故用 coroutineScope + async 并行，避免 Key 多时串行等待过久。
+     */
+    suspend fun fetchKeyUsageStats(startDate: LocalDate, endDate: LocalDate, accountId: String? = null): Result<List<KeyUsageStat>> =
+        withPanelAutoRefresh(accountId) keyStatsBlock@ { base, _, token ->
+            // Key 列表由 fetchPanelKeys 获取（其内部同样带自动刷新，可能已换新 token）
+            val keys = fetchPanelKeys(accountId).getOrElse { return@keyStatsBlock Result.failure(it) }
+            if (keys.isEmpty()) return@keyStatsBlock Result.success(emptyList())
+            // fetchPanelKeys 刷新成功后会落库新 token，这里重读一次最新凭据；
+            // 未刷新则沿用传入 token
+            val freshCredential = credentialRepository.get(ServiceType.SUB2API, accountId) as? Credential.Sub2ApiCredential
+            val authToken = freshCredential?.authToken?.trim()?.takeIf { it.isNotEmpty() } ?: token
+            val auth = AuthHeader("Authorization", "Bearer " + authToken)
+
+            val start = startDate.toString()
+            val end = endDate.toString()
+            val tz = tzParam()
+            // 分组名映射（展示「Key · 分组」），拉取失败不影响主流程
+            val groups = runCatching { fetchPanelGroups(accountId).getOrNull().orEmpty() }
+                .getOrDefault(emptyList())
+                .associateBy { it.id }
+
+            val stats = coroutineScope {
+                keys.map { k ->
+                    async(Dispatchers.IO) {
+                        val resp = get(
+                            base,
+                            "/api/v1/usage/stats?start_date=$start&end_date=$end" +
+                                "&api_key_id=${k.id}&timezone=$tz",
+                            auth
+                        )
+                        val unused = resp == null || resp.code == 404
+                        val usage = if (!unused && resp!!.code in 200..299) {
+                            runCatching { parseKeyUsage(resp.body) }.getOrNull()
+                        } else null
+                        KeyUsageStat(
+                            keyId = k.id,
+                            name = k.name,
+                            groupName = k.groupId?.let { groups[it]?.name },
+                            requests = usage?.first ?: 0L,
+                            totalTokens = usage?.second ?: 0L,
+                            cost = usage?.third ?: 0.0,
+                            unused = unused
+                        )
+                    }
+                }.awaitAll()
+            }
+            Result.success(
+                stats.sortedWith(
+                    compareByDescending<KeyUsageStat> { it.cost }
+                        .thenByDescending { it.requests }
+                        .thenBy { it.name }
+                )
+            )
+        }
+
+    /** 解析 usage/stats → (requests, totalTokens, actualCost)。 */
+    private fun parseKeyUsage(body: String): Triple<Long, Long, Double>? {
+        val root = json.parseToJsonElement(body).jsonObject
+        val d = root["data"]?.jsonObject ?: root
+        val requests = d.longOr("total_requests") ?: return null
+        val tokens = d.longOr("total_tokens") ?: 0L
+        val cost = d.numberOr("total_actual_cost") ?: d.numberOr("total_cost") ?: 0.0
+        return Triple(requests, tokens, cost)
+    }
+
     /**
      * 新建 Key：POST /api/v1/keys {name, group_id?} → 返回明文 sk-key。
      * 兼容多种响应形态：data 为对象（key / api_key / sk_key / token 字段）、data 为字符串，
      * 并把网关错误信息（message / error）透传给 UI，避免「响应异常」掩盖真实原因。
      */
-    suspend fun createPanelKey(name: String, groupId: Long? = null): Result<String> = withContext(Dispatchers.IO) {
-        val (auth, base) = panelAuthOrNull() ?: return@withContext Result.failure(RepositoryError.InvalidCredential("请先登录面板"))
-        val body = buildJsonObject {
-            put("name", name)
-            if (groupId != null) put("group_id", groupId)
-        }.toString()
-        val resp = post(base, "/api/v1/keys", auth, body)
-            ?: return@withContext Result.failure(RepositoryError.Unknown(IllegalStateException("创建 Key 失败（网络异常）")))
-        runCatching {
-            val obj = json.parseToJsonElement(resp.body).jsonObject
-            // 业务码字段并集：code / status 任一存在即按其判定；再叠加 success 布尔
-            val codeNum = obj.numberOr("code", "status") ?: 0.0
-            val successFlag = obj["success"]?.jsonPrimitive?.contentOrNull?.toBooleanStrictOrNull()
-            if (resp.code !in 200..299 || codeNum != 0.0 || successFlag == false) {
-                val msg = obj.scalar("message", "error") ?: "HTTP " + resp.code
-                return@runCatching Result.failure(RepositoryError.Unknown(IllegalStateException(msg)))
+    suspend fun createPanelKey(name: String, groupId: Long? = null, accountId: String? = null): Result<String> =
+        withPanelAutoRefresh(accountId) block@ { base, _, token ->
+            val auth = AuthHeader("Authorization", "Bearer " + token)
+            val body = buildJsonObject {
+                put("name", name)
+                if (groupId != null) put("group_id", groupId)
+            }.toString()
+            val resp = post(base, "/api/v1/keys", auth, body)
+                ?: return@block Result.failure(RepositoryError.Unknown(IllegalStateException("创建 Key 失败（网络异常）")))
+            // HTTP 401/403 表示面板登录失效（自动重登后重试）；其余按业务/网络错误透传
+            if (resp.code == 401 || resp.code == 403) {
+                return@block Result.failure(RepositoryError.InvalidCredential("Sub2API 面板登录已失效，请重新网页登录"))
             }
-            val data = obj["data"]
-            val key = when (data) {
-                is JsonObject -> data.scalar("key", "api_key", "sk_key", "token")
-                is JsonPrimitive -> data.contentOrNull?.takeIf { it.isNotBlank() }
-                null -> obj.scalar("key", "api_key", "sk_key", "token")
-                else -> null
+            runCatching {
+                val obj = json.parseToJsonElement(resp.body).jsonObject
+                // 业务码字段并集：code / status 任一存在即按其判定；再叠加 success 布尔
+                val codeNum = obj.numberOr("code", "status") ?: 0.0
+                val successFlag = obj["success"]?.jsonPrimitive?.contentOrNull?.toBooleanStrictOrNull()
+                if (resp.code !in 200..299 || codeNum != 0.0 || successFlag == false) {
+                    val msg = obj.scalar("message", "error") ?: "HTTP " + resp.code
+                    return@runCatching Result.failure(RepositoryError.Unknown(IllegalStateException(msg)))
+                }
+                val data = obj["data"]
+                val key = when (data) {
+                    is JsonObject -> data.scalar("key", "api_key", "sk_key", "token")
+                    is JsonPrimitive -> data.contentOrNull?.takeIf { it.isNotBlank() }
+                    null -> obj.scalar("key", "api_key", "sk_key", "token")
+                    else -> null
+                }
+                if (key != null) Result.success(key)
+                else {
+                    // 不丢信息：把响应片段带给用户/日志，方便排查面板响应形态
+                    Result.failure(
+                        RepositoryError.Unknown(IllegalStateException("创建成功但未在响应中找到 Key：" + resp.body.take(120)))
+                    )
+                }
+            }.getOrElse { e ->
+                Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "创建 Key 响应解析失败: " + e.message))
             }
-            if (key != null) Result.success(key)
-            else {
-                // 不丢信息：把响应片段带给用户/日志，方便排查面板响应形态
-                Result.failure(
-                    RepositoryError.Unknown(IllegalStateException("创建成功但未在响应中找到 Key：" + resp.body.take(120)))
-                )
-            }
-        }.getOrElse { e ->
-            Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "创建 Key 响应解析失败: " + e.message))
         }
-    }
 
     /** 修改 Key（切换分组 / 增删黑白名单 / 额度等）：PUT /api/v1/keys/{id}。 */
-    suspend fun updatePanelKey(id: Long, groupId: Long? = null, patch: Map<String, String> = emptyMap()): Result<Boolean> =
-        withContext(Dispatchers.IO) {
-            val (auth, base) = panelAuthOrNull() ?: return@withContext Result.failure(RepositoryError.InvalidCredential("请先登录面板"))
+    suspend fun updatePanelKey(id: Long, groupId: Long? = null, patch: Map<String, String> = emptyMap(), accountId: String? = null): Result<Boolean> =
+        withPanelAutoRefresh(accountId) block@ { base, _, token ->
+            val auth = AuthHeader("Authorization", "Bearer " + token)
             val body = buildJsonObject {
                 if (groupId != null) put("group_id", groupId)
                 patch.forEach { (k, v) -> put(k, v) }
             }.toString()
             val resp = put(base, "/api/v1/keys/" + id, auth, body)
-                ?: return@withContext Result.failure(RepositoryError.Unknown(IllegalStateException("修改 Key 失败")))
-            panelFailure(resp)?.let { return@withContext Result.failure(it) }
-            return@withContext runCatching {
+                ?: return@block Result.failure(RepositoryError.Unknown(IllegalStateException("修改 Key 失败")))
+            panelFailure(resp)?.let { return@block Result.failure(it) }
+            return@block runCatching {
                 val obj = json.parseToJsonElement(resp.body).jsonObject
                 // 兼容 {code:0} 与 {success:true} 两种面板响应形态
                 val ok = obj.numberOr("code", "status")?.let { it == 0.0 }
@@ -735,119 +877,174 @@ class Sub2ApiRepository constructor(
      * 面板返回形态不统一（{code:0} / {success:true} / 204 空体），因此判定顺序为：
      * HTTP 2xx 且没有业务错误码即视为成功；解析不出 JSON 也不当作失败（部分版本返回空体）。
      */
-    suspend fun deletePanelKey(id: Long): Result<Boolean> = withContext(Dispatchers.IO) {
-        val (auth, base) = panelAuthOrNull()
-            ?: return@withContext Result.failure(RepositoryError.InvalidCredential("请先登录面板"))
-        val resp = delete(base, "/api/v1/keys/" + id, auth)
-            ?: return@withContext Result.failure(RepositoryError.Unknown(IllegalStateException("删除 Key 失败（网络异常）")))
-        if (resp.code !in 200..299) {
-            return@withContext Result.failure(mapSubHttpError(resp.code))
+    suspend fun deletePanelKey(id: Long, accountId: String? = null): Result<Boolean> =
+        withPanelAutoRefresh(accountId) block@ { base, _, token ->
+            val auth = AuthHeader("Authorization", "Bearer " + token)
+            val resp = delete(base, "/api/v1/keys/" + id, auth)
+                ?: return@block Result.failure(RepositoryError.Unknown(IllegalStateException("删除 Key 失败（网络异常）")))
+            if (resp.code !in 200..299) {
+                return@block Result.failure(mapSubHttpError(resp.code))
+            }
+            // 2xx 但体里带业务错误码（部分面板用 200 + code!=0 表达失败）
+            val bizError = runCatching {
+                val obj = json.parseToJsonElement(resp.body).jsonObject
+                val codeNum = obj.numberOr("code", "status")
+                val successFlag = obj["success"]?.jsonPrimitive?.contentOrNull?.toBooleanStrictOrNull()
+                if (codeNum != null && codeNum != 0.0) obj.scalar("message", "error") ?: "删除 Key 失败"
+                else if (successFlag == false) obj.scalar("message", "error") ?: "删除 Key 失败"
+                else null
+            }.getOrNull()
+            if (bizError != null) {
+                Result.failure(RepositoryError.Unknown(IllegalStateException(bizError)))
+            } else {
+                Result.success(true)
+            }
         }
-        // 2xx 但体里带业务错误码（部分面板用 200 + code!=0 表达失败）
-        val bizError = runCatching {
-            val obj = json.parseToJsonElement(resp.body).jsonObject
-            val codeNum = obj.numberOr("code", "status")
-            val successFlag = obj["success"]?.jsonPrimitive?.contentOrNull?.toBooleanStrictOrNull()
-            if (codeNum != null && codeNum != 0.0) obj.scalar("message", "error") ?: "删除 Key 失败"
-            else if (successFlag == false) obj.scalar("message", "error") ?: "删除 Key 失败"
-            else null
-        }.getOrNull()
-        if (bizError != null) {
-            Result.failure(RepositoryError.Unknown(IllegalStateException(bizError)))
-        } else {
-            Result.success(true)
-        }
-    }
 
     /** 可用分组列表（切换分组选择器）。 */
-    suspend fun fetchPanelGroups(): Result<List<PanelGroup>> = withContext(Dispatchers.IO) {
-        val (auth, base) = panelAuthOrNull() ?: return@withContext Result.failure(RepositoryError.InvalidCredential("请先登录面板"))
-        val resp = get(base, "/api/v1/groups/available", auth)
-            ?: return@withContext Result.failure(RepositoryError.Unknown(IllegalStateException("获取分组失败")))
-        panelFailure(resp)?.let { return@withContext Result.failure(it) }
-        val body = resp.body
-        runCatching {
-            val root = json.parseToJsonElement(body).jsonObject
-            (root["data"] as? JsonArray ?: JsonArray(emptyList())).mapNotNull { el ->
-                val o = el.jsonObject
-                PanelGroup(
-                    id = o.longOr("id") ?: 0L,
-                    name = o.scalar("name") ?: "",
-                    rateMultiplier = o.numberOr("rate_multiplier") ?: 1.0,
-                    description = o.scalar("description") ?: ""
-                )
-            }
-        }.fold(
-            onSuccess = { Result.success(it) },
-            onFailure = { Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "面板响应解析失败")) }
-        )
-    }
+    suspend fun fetchPanelGroups(accountId: String? = null): Result<List<PanelGroup>> =
+        withPanelAutoRefresh(accountId) panelGroupsBlock@ { base, _, token ->
+            val auth = AuthHeader("Authorization", "Bearer " + token)
+            val resp = get(base, "/api/v1/groups/available", auth)
+                ?: return@panelGroupsBlock Result.failure(RepositoryError.Unknown(IllegalStateException("获取分组失败")))
+            panelFailure(resp)?.let { return@panelGroupsBlock Result.failure(it) }
+            val body = resp.body
+            runCatching {
+                val root = json.parseToJsonElement(body).jsonObject
+                (root["data"] as? JsonArray ?: JsonArray(emptyList())).mapNotNull { el ->
+                    val o = el.jsonObject
+                    PanelGroup(
+                        id = o.longOr("id") ?: 0L,
+                        name = o.scalar("name") ?: "",
+                        rateMultiplier = o.numberOr("rate_multiplier") ?: 1.0,
+                        description = o.scalar("description") ?: ""
+                    )
+                }
+            }.fold(
+                onSuccess = { Result.success(it) },
+                onFailure = { Result.failure(RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "面板响应解析失败")) }
+            )
+        }
 
     /** 兑换卡密：POST /api/v1/redeem {code} → code=0 或业务错误（REDEEM_*）。 */
-    suspend fun redeemPanelCode(code: String): Result<String> = withContext(Dispatchers.IO) {
-        val (auth, base) = panelAuthOrNull() ?: return@withContext Result.failure(RepositoryError.InvalidCredential("请先登录面板"))
-        val body = buildJsonObject { put("code", code.trim()) }.toString()
-        val resp = post(base, "/api/v1/redeem", auth, body)
-            ?: return@withContext Result.failure(RepositoryError.Unknown(IllegalStateException("兑换失败")))
-        // 兑换失败时面板用 HTTP 404/400 + {code,message,reason} 表达业务错误
-        // （实测：code=404, message="redeem code not found", reason=REDEEM_CODE_NOT_FOUND）。
-        // 因此这里必须先解析 body 再判定状态，否则会把「兑换码不存在」等具体原因吞成通用 HTTP 错误。
-        val parsed = runCatching { json.parseToJsonElement(resp.body).jsonObject }.getOrNull()
-            ?: return@withContext Result.failure(
-                RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "兑换响应解析失败（HTTP " + resp.code + "）")
-            )
-        val codeNum = parsed.numberOr("code")
-        val successFlag = parsed["success"]?.jsonPrimitive?.contentOrNull?.toBooleanStrictOrNull()
-        val msg = parsed.scalar("message", "error", "reason") ?: ""
-        val ok = resp.code in 200..299 && when {
-            codeNum != null -> codeNum == 0.0
-            successFlag != null -> successFlag
-            // 既无 code 也无 success：响应里能解析出 data 即视为成功
-            else -> parsed["data"] != null
-        }
-        if (!ok) {
-            // 面板用英文 message + 机器可读 reason 表达业务错误（实测：
-            // 404 REDEEM_CODE_NOT_FOUND / 409 REDEEM_CODE_USED）。
-            // 中文用户看不懂英文原文，这里把已确认的 reason 译成中文，未知 reason 原样透传便于排查。
-            val reason = parsed.scalar("reason")
-            val localized = when (reason) {
-                "REDEEM_CODE_NOT_FOUND" -> "兑换码不存在，请检查是否输入正确"
-                "REDEEM_CODE_USED" -> "该兑换码已被使用"
-                "REDEEM_CODE_EXPIRED" -> "该兑换码已过期"
-                "REDEEM_CODE_DISABLED" -> "该兑换码已被禁用"
-                else -> null
+    suspend fun redeemPanelCode(code: String, accountId: String? = null): Result<String> =
+        withPanelAutoRefresh(accountId) block@ { base, _, token ->
+            val auth = AuthHeader("Authorization", "Bearer " + token)
+            val body = buildJsonObject { put("code", code.trim()) }.toString()
+            val resp = post(base, "/api/v1/redeem", auth, body)
+                ?: return@block Result.failure(RepositoryError.Unknown(IllegalStateException("兑换失败")))
+            // 兑换失败时面板用 HTTP 404/400 + {code,message,reason} 表达业务错误
+            // （实测：code=404, message="redeem code not found", reason=REDEEM_CODE_NOT_FOUND）。
+            // 因此这里必须先解析 body 再判定状态，否则会把「兑换码不存在」等具体原因吞成通用 HTTP 错误。
+            val parsed = runCatching { json.parseToJsonElement(resp.body).jsonObject }.getOrNull()
+                ?: return@block Result.failure(
+                    RepositoryError.ParseError(RepositoryError.ParseErrorReason.MALFORMED_RESPONSE, "兑换响应解析失败（HTTP " + resp.code + "）")
+                )
+            val codeNum = parsed.numberOr("code")
+            val successFlag = parsed["success"]?.jsonPrimitive?.contentOrNull?.toBooleanStrictOrNull()
+            val msg = parsed.scalar("message", "error", "reason") ?: ""
+            val ok = resp.code in 200..299 && when {
+                codeNum != null -> codeNum == 0.0
+                successFlag != null -> successFlag
+                // 既无 code 也无 success：响应里能解析出 data 即视为成功
+                else -> parsed["data"] != null
             }
-            // 业务错误优先用面板文案；凭据失效仍按 401/403 归类，便于 UI 区分「去登录」
-            val text = localized ?: msg.ifBlank { "兑换失败（HTTP " + resp.code + "）" }
-            val business = RepositoryError.Unknown(IllegalStateException(text))
-            val failure = when (resp.code) {
-                401, 403 -> RepositoryError.InvalidCredential("Sub2API 面板登录已失效，请重新网页登录")
-                else -> business
+            if (!ok) {
+                // 面板用英文 message + 机器可读 reason 表达业务错误（实测：
+                // 404 REDEEM_CODE_NOT_FOUND / 409 REDEEM_CODE_USED）。
+                // 中文用户看不懂英文原文，这里把已确认的 reason 译成中文，未知 reason 原样透传便于排查。
+                val reason = parsed.scalar("reason")
+                val localized = when (reason) {
+                    "REDEEM_CODE_NOT_FOUND" -> "兑换码不存在，请检查是否输入正确"
+                    "REDEEM_CODE_USED" -> "该兑换码已被使用"
+                    "REDEEM_CODE_EXPIRED" -> "该兑换码已过期"
+                    "REDEEM_CODE_DISABLED" -> "该兑换码已被禁用"
+                    else -> null
+                }
+                // 业务错误优先用面板文案；凭据失效仍按 401/403 归类，便于 UI 区分「去登录」
+                val text = localized ?: msg.ifBlank { "兑换失败（HTTP " + resp.code + "）" }
+                val business = RepositoryError.Unknown(IllegalStateException(text))
+                val failure = when (resp.code) {
+                    401, 403 -> RepositoryError.InvalidCredential("Sub2API 面板登录已失效，请重新网页登录")
+                    else -> business
+                }
+                return@block Result.failure(failure)
             }
-            return@withContext Result.failure(failure)
+            // 实测成功响应：{"code":0,"data":{"id":57,"type":"balance","value":50,"status":"used",...}}
+            // 注意 value 是数字（50）而非字符串，必须走 numberOr，否则金额显示不出来。
+            // data 期望是对象；若某实例返回字符串/数字，jsonObject 会抛异常中断协程，这里降级为「无金额」文案
+            val data = parsed["data"] as? JsonObject
+            val amount = data?.numberOr("value")
+            val typeSuffix = when (data?.scalar("type")) {
+                "balance" -> " 余额"
+                "subscription" -> " 订阅"
+                else -> ""
+            }
+            val amountText = amount?.let { "（+" + trimNum(it) + typeSuffix + "）" } ?: ""
+            Result.success("兑换成功" + amountText)
         }
-        // 实测成功响应：{"code":0,"data":{"id":57,"type":"balance","value":50,"status":"used",...}}
-        // 注意 value 是数字（50）而非字符串，必须走 numberOr，否则金额显示不出来。
-        // data 期望是对象；若某实例返回字符串/数字，jsonObject 会抛异常中断协程，这里降级为「无金额」文案
-        val data = parsed["data"] as? JsonObject
-        val amount = data?.numberOr("value")
-        val typeSuffix = when (data?.scalar("type")) {
-            "balance" -> " 余额"
-            "subscription" -> " 订阅"
-            else -> ""
+
+    /**
+     * 面板操作统一包装：为指定账号读取凭据，用 authToken 执行 [block]；
+     *
+     * 自动刷新语义：
+     * - 首次请求返回 [RepositoryError.InvalidCredential]（HTTP 401/403 = token 过期/登录失效）时，
+     *   用账号的邮箱+密码自动重新登录换取新 token，保存到该账号后【重试一次】；
+     * - 自动重登失败（邮箱/密码已变、面板关闭账号密码登录、网络异常）→ 返回原错误，
+     *   由 UI 引导用户真正去手动登录；
+     * - 重试后仍失败 → 返回第二次请求的错误。
+     *
+     * 多账号注意：accountId=null 语义是「默认账号」（不是新建）。回写刷新后的 token 前
+     * 必须先解析出真实账号 ID，否则 [CredentialRepository.save] 对多账号服务会把
+     * null accountId 当成「新建账号」，造成每次过期重登都新建一个重复账号。
+     */
+    private suspend fun <T> withPanelAutoRefresh(
+        accountId: String?,
+        block: suspend (base: String, credential: Credential.Sub2ApiCredential, token: String) -> Result<T>
+    ): Result<T> = withContext(Dispatchers.IO) {
+        val targetAccountId = if (accountId.isNullOrBlank()) {
+            credentialRepository.getDefaultAccount(ServiceType.SUB2API)?.id
+        } else {
+            accountId
         }
-        val amountText = amount?.let { "（+" + trimNum(it) + typeSuffix + "）" } ?: ""
-        Result.success("兑换成功" + amountText)
+        val credential = credentialRepository.get(ServiceType.SUB2API, targetAccountId) as? Credential.Sub2ApiCredential
+            ?: return@withContext Result.failure(RepositoryError.InvalidCredential("请先配置 Sub2API 凭据"))
+        val base = normalizeBase(credential.baseUrl)
+        if (base.isBlank()) return@withContext Result.failure(RepositoryError.InvalidCredential())
+        val initialToken = credential.authToken?.trim()?.takeIf { it.isNotEmpty() }
+            ?: return@withContext Result.failure(RepositoryError.InvalidCredential("请先登录面板（账号密码或网页登录）"))
+
+        var token = initialToken
+        repeat(2) { attempt ->
+            val result = block(base, credential, token)
+            val failure = result.exceptionOrNull()
+            // block 内出现的 InvalidCredential 均来自面板 HTTP 401/403（登录失效）
+            if (attempt == 0 && failure is RepositoryError.InvalidCredential) {
+                val lockKey = targetAccountId ?: credential.service.storageKey
+                val lock = panelRefreshLocks.getOrPut(lockKey) { kotlinx.coroutines.sync.Mutex() }
+                // 同一账号并发刷新去重：锁被占用说明已有请求在重登，本次不再并发登录
+                if (lock.tryLock()) {
+                    try {
+                        val refreshed = loginPanel(base, credential.email, credential.password).getOrNull()
+                        if (refreshed != null && refreshed.isNotBlank()) {
+                            token = refreshed
+                            credentialRepository.save(credential.copy(authToken = refreshed), targetAccountId)
+                            return@repeat
+                        }
+                    } finally {
+                        lock.unlock()
+                    }
+                }
+                // 自动重登失败（或被并发刷新占用）= 账号问题，返回原错误引导手动登录
+                return@withContext result
+            }
+            return@withContext result
+        }
+        Result.failure(RepositoryError.InvalidCredential("Sub2API 自动登录失败，请手动重新登录"))
     }
 
-    /** 面板凭证获取（token 非空时）；返回 (auth, base) 或 null。 */
-    private suspend fun panelAuthOrNull(): Pair<AuthHeader, String>? {
-        val credential = credentialRepository.get(ServiceType.SUB2API) as? Credential.Sub2ApiCredential ?: return null
-        val token = credential.authToken?.trim().takeUnless { it.isNullOrEmpty() } ?: return null
-        val base = normalizeBase(credential.baseUrl)
-        if (base.isBlank()) return null
-        return AuthHeader("Authorization", "Bearer " + token) to base
-    }
+    /** 按账号的面板刷新互斥锁（避免并发 401 时多次 loginPanel 互相作废 token）。 */
+    private val panelRefreshLocks = java.util.concurrent.ConcurrentHashMap<String, kotlinx.coroutines.sync.Mutex>()
 
     private fun tzParam(): String = java.net.URLEncoder.encode(TimeZone.getDefault().id, "UTF-8")
 

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

@@ -1,6 +1,7 @@
 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
@@ -12,11 +13,13 @@ 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
@@ -55,8 +58,8 @@ class TraeRepository constructor(
 
     private val json = Json { ignoreUnknownKeys = true }
 
-    suspend fun fetchBalance(): Result<ServiceBalance> = withContext(Dispatchers.IO) {
-        val credential = credentialRepository.get(ServiceType.TRAE)
+    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())
@@ -77,8 +80,15 @@ class TraeRepository constructor(
         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(mapHttpError(resp.code))
+                    return@withContext Result.failure(
+                        if (resp.code == 401 || resp.code == 403) {
+                            authErrorFor(credential.jwt.trim())
+                        } else {
+                            mapHttpError(resp.code)
+                        }
+                    )
                 }
                 text
             }
@@ -102,8 +112,8 @@ class TraeRepository constructor(
             totalQuota = parsed.totalQuota,
             extras = parsed.extras
         )
-        balanceCache.put(ServiceType.TRAE, balance)
-        credentialRepository.save(credential.copy(lastVerifiedAt = System.currentTimeMillis()))
+        balanceCache.put(ServiceType.TRAE, balance, accountId)
+        credentialRepository.save(credential.copy(lastVerifiedAt = System.currentTimeMillis()), accountId)
         Result.success(balance)
     }
 
@@ -127,7 +137,12 @@ class TraeRepository constructor(
         }
 
         // 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
@@ -135,26 +150,47 @@ class TraeRepository constructor(
             val pack = packEl.jsonObject
             val base = pack["entitlement_base_info"]?.jsonObject
             val quota = base?.get("quota")?.jsonObject
-            val name = pack.getString("display_desc") ?: base?.getString("name") ?: "pack[$index]"
+            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["$name.unlimited"] = "true"
+                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["$name.limit"] = limit.toString()
-                        extras["$name.used"] = used?.let { trimNum(it) } ?: "?"
+                        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()
+        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) {
@@ -195,26 +231,83 @@ class TraeRepository constructor(
 
     // ---------- 每日签到（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,
-        val message: String
+        /** 服务端原始提示文案（仅作 [outcome] 之外的补充透传） */
+        val message: String,
+        /** 动作语义结果：UI 按此本地化，不依赖 [message] 语言 */
+        val outcome: CheckinOutcome,
+        /** 服务端错误码（outcome=FAILED 时可能有；-1 表示未提供） */
+        val code: Long = -1L
     )
 
     /**
-     * 执行 Trae 每日签到（CN 区）。
-     * 接口：POST https://api.trae.cn/trae/api/v2/ug/checkin_credits/claim body {}。
-     * 头：Cloud-IDE-JWT <jwt> + x-device-id（claim 按设备做每日去重——用 JWT 派生的稳定
-     * 伪 deviceId，同账号稳定、不同账号不同，避免共享 device-id 被拦）。
-     * 语义：code 0/200 成功；code 1001 或消息含「已签到/已领取/already」=账号已签；
-     * 消息含「设备/device」=设备级拦截（提示而非报错）。
+     * 执行 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(): Result<CheckinResult> = withContext(Dispatchers.IO) {
-        val credential = credentialRepository.get(ServiceType.TRAE)
+    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())
@@ -222,77 +315,205 @@ class TraeRepository constructor(
         val regionKey = credential.region.uppercase().takeIf { it == "INTL" } ?: "CN"
         if (regionKey == "INTL") {
             return@withContext Result.success(
-                CheckinResult(false, false, 0, "INTL 区签到接口暂未支持，请用 CN 区账号")
+                CheckinResult(
+                    success = false,
+                    alreadyChecked = false,
+                    points = 0,
+                    message = "",
+                    outcome = CheckinOutcome.INTL_UNSUPPORTED
+                )
             )
         }
-        val request = Request.Builder()
-            .url("https://api.trae.cn/trae/api/v2/ug/checkin_credits/claim")
-            .addHeader("Authorization", "Cloud-IDE-JWT " + credential.jwt.trim())
-            .addHeader("Content-Type", "application/json")
-            .addHeader("x-device-id", stableDeviceId(credential.jwt.trim()))
-            .post("{}".toRequestBody("application/json".toMediaType()))
-            .build()
-
-        val body = try {
-            okHttpClient.newCall(request).execute().use { resp ->
-                val text = resp.body?.string().orEmpty()
-                if (resp.code == 401 || resp.code == 403) {
-                    return@withContext Result.failure(RepositoryError.InvalidCredential())
-                }
-                if (!resp.isSuccessful && resp.code != 400) {
-                    return@withContext Result.failure(mapHttpError(resp.code))
-                }
-                // 400 也可能是业务失败（已签/设备拦截），交给 body 判断
-                text
-            }
-        } catch (e: IOException) {
-            return@withContext Result.failure(RepositoryError.Network(e))
-        } catch (e: Throwable) {
-            return@withContext Result.failure(RepositoryError.Unknown(e))
+        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 判定仍权威
 
-        parseCheckin(body)
+        // 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
     }
 
-    /** 解析 claim 响应（code/message/points 多候选；语义判断见 checkIn 注释）。 */
-    private fun parseCheckin(body: String): Result<CheckinResult> = runCatching {
-        val root = json.parseToJsonElement(body).jsonObject
-        val data = root["data"]?.jsonObject ?: root
-        val code = data.numberOr("code")?.toLong() ?: root.numberOr("code")?.toLong() ?: -1L
-        val msg = data.scalarOr("message", "msg") ?: root.scalarOr("message", "msg") ?: ""
-        val points = (data.numberOr("points") ?: root.numberOr("points"))?.toLong() ?: 0L
-
-        val succeeded = code == 0L || code == 200L
-        val lowerMsg = msg.lowercase()
-        val deviceBlock = msg.contains("设备") || lowerMsg.contains("device") || lowerMsg.contains("machine")
-        val already = code == 1001L || (!deviceBlock && (
-            msg.contains("已签到") || msg.contains("已经签到") || msg.contains("明日再来") ||
-                msg.contains("今日已完成") || msg.contains("已领取") ||
-                lowerMsg.contains("already") || lowerMsg.contains("checked") || lowerMsg.contains("claimed")
-            ))
-
-        when {
-            succeeded -> Result.success(
-                CheckinResult(true, false, points.takeIf { it > 0 } ?: 200L, msg.ifBlank { "签到成功" })
-            )
-            already -> Result.success(CheckinResult(true, true, 0L, "今日已签到"))
-            deviceBlock -> Result.success(CheckinResult(false, false, 0L, msg.ifBlank { "该设备今日签到次数已达上限" }))
-            else -> Result.success(CheckinResult(false, false, 0L, msg.ifBlank { "签到失败（code=" + code + "）" }))
+    /**
+     * 签到系 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))
         }
-    }.getOrElse { Result.failure(RepositoryError.Unknown(it)) }
+    }
 
-    /** 由 JWT 派生稳定伪 deviceId：同账号恒定、不同账号不同（防 claim 设备级去重误伤）。 */
-    private fun stableDeviceId(seed: String): String = runCatching {
-        val digest = java.security.MessageDigest.getInstance("SHA-256")
-            .digest(("rainytoken:" + seed).toByteArray())
-        digest.take(12).joinToString("") { "%02x".format(it) }
-    }.getOrDefault("rainytoken-device")
-
-    private fun JsonObject.scalarOr(vararg keys: String): String? {
-        for (key in keys) {
-            this[key]?.jsonPrimitive?.contentOrNull?.takeIf { it.isNotBlank() }?.let { return it }
-        }
-        return null
+    /** 生成抓包格式 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) {
@@ -302,6 +523,44 @@ class TraeRepository constructor(
         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 会连续剥离集合内任意字符，
@@ -315,4 +574,165 @@ class TraeRepository constructor(
         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

@@ -22,6 +22,12 @@ class WebViewSessionSaver @Inject constructor(
     private val credentialRepository: CredentialRepository
 ) {
 
+    /** Sub2API 面板登录保存结果：凭据 + 实际写入的账号 ID（新建账号时返回新 ID）。 */
+    data class SavedSub2PanelSession(
+        val credential: Credential.Sub2ApiCredential,
+        val accountId: String
+    )
+
     /**
      * 提取并保存 Cookie 列表。返回保存后的凭据。
      */
@@ -57,17 +63,19 @@ class WebViewSessionSaver @Inject constructor(
      * @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
-    ): Credential.Sub2ApiCredential? {
+        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) as? Credential.Sub2ApiCredential
+        val existing = credentialRepository.get(ServiceType.SUB2API, accountId) as? Credential.Sub2ApiCredential
         val credential = Credential.Sub2ApiCredential(
             service = ServiceType.SUB2API,
             baseUrl = base,
@@ -78,8 +86,37 @@ class WebViewSessionSaver @Inject constructor(
             siteIcon = siteIcon?.takeIf { it.isNotBlank() } ?: existing?.siteIcon,
             lastVerifiedAt = System.currentTimeMillis()
         )
-        credentialRepository.save(credential)
-        return credential
+        // 返回实际写入的账号 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
     }
 
     /**

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

@@ -1,6 +1,7 @@
 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
@@ -63,8 +64,8 @@ class WorkBuddyRepository constructor(
         put("QueryResourceId", buildJsonArray { })
     }.toString()
 
-    suspend fun fetchBalance(): Result<ServiceBalance> = withContext(Dispatchers.IO) {
-        val credential = credentialRepository.get(ServiceType.WORKBUDDY)
+    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())
@@ -113,7 +114,8 @@ class WorkBuddyRepository constructor(
                             } else {
                                 credential.expiresAt.coerceAtLeast(System.currentTimeMillis())
                             }
-                        )
+                        ),
+                        accountId
                     )
                     access = refreshed.accessToken
                     refresh = refreshed.refreshToken
@@ -137,6 +139,15 @@ class WorkBuddyRepository constructor(
             )
         }
 
+        // 细粒度账户明细（官网个人中心同源数据）：每个资源包的已用/总量/剩余/到期时间。
+        // 独立请求，失败仅降级（保留 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,
@@ -144,13 +155,37 @@ class WorkBuddyRepository constructor(
             monthlySpent = parsed.used.takeIf { it > 0 },
             totalQuota = parsed.size.takeIf { it > 0 },
             isAvailable = parsed.amount > 0 || parsed.size > 0,
-            extras = parsed.extras
+            extras = mergedExtras
         )
-        balanceCache.put(ServiceType.WORKBUDDY, balance)
-        credentialRepository.save(credential.copy(lastVerifiedAt = System.currentTimeMillis()))
+        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()
@@ -205,7 +240,71 @@ class WorkBuddyRepository constructor(
         return null
     }
 
-    /** 解析 Packages/Accounts：CycleRemain/Used/TotalCapacity（多候选）。无任何包/数据时抛异常。 */
+    /**
+ * 解析 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
@@ -221,26 +320,54 @@ class WorkBuddyRepository constructor(
         var frozen = 0.0
         var unitRaw: String? = null
         val extras = linkedMapOf<String, String>()
-        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"}"
+        // 结构化包明细（名称/编码/已用/总量/剩余/到期/周期重置），详情页按官方语义分组展示。
+        // 键名带 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" }
+            ?.let {
+                extras["subscription"] = "true"
+                // 订阅套餐的包编码：详情页据此把该包归入「套餐积分」区，其余归「平台奖励积分」
+                extras["subscription_code"] = it
+            }
 
         return ParsedWorkBuddy(
             amount = amount,
@@ -280,8 +407,41 @@ class WorkBuddyRepository constructor(
         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=每日/今日积分。
@@ -293,21 +453,27 @@ class WorkBuddyRepository constructor(
         val dailyCredit: Long,
         val todayCredit: Long,
         val activityName: String,
-        /** 签到动作后的提示（签到成功/今日已签）；查询模式为空串 */
-        val message: String = ""
+        /** 服务端原始提示文案（可能是中文/英文；仅作 [outcome] 之外的补充透传） */
+        val message: String = "",
+        /** 动作语义结果：UI 按此本地化，不依赖 [message] 语言 */
+        val outcome: CheckinOutcome = CheckinOutcome.QUERY
     )
 
     /** 查询今日签到状态。uid 未知时省略 X-User-Id 头（源码确认该头可选）。 */
-    suspend fun fetchCheckinStatus(): Result<CheckinStatus> = withContext(Dispatchers.IO) {
-        val credential = credentialRepository.get(ServiceType.WORKBUDDY)
+    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 兜底）
-        val body = authedPost(credential, "/v2/billing/meter/checkin-activity-status")
-            ?: authedPost(credential, "/v2/billing/meter/checkin-status")
-            ?: return@withContext Result.failure(RepositoryError.Unknown())
+        // 共享轮换状态：前一条路径轮换出的新 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 = {
@@ -325,42 +491,108 @@ class WorkBuddyRepository constructor(
      * 执行今日签到（幂等：code=0 成功 / code=10001 已签，两种都算成功；源码确认 HTTP 400 也可能是已签）。
      * 成功/已签后刷新一次状态并附带 message 提示。
      */
-    suspend fun checkIn(): Result<CheckinStatus> = withContext(Dispatchers.IO) {
-        val credential = credentialRepository.get(ServiceType.WORKBUDDY)
+    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 = authedPost(credential, "/v2/billing/meter/daily-checkin")
-            ?: return@withContext Result.failure(RepositoryError.Unknown())
+        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 root = json.parseToJsonElement(body).jsonObject
-            val obj = root["data"]?.jsonObject ?: root
-            obj.scalar("code", "Code")?.toLongOrNull() ?: -1L
-        }.getOrDefault(-1L)
-        val status = fetchCheckinStatus().getOrNull()
+            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?.copy(message = "签到成功 +" + (status.todayCredit.takeIf { it > 0 } ?: status.dailyCredit) + " 积分")
-                    ?: CheckinStatus(true, true, 1, 0, 0, "", "签到成功")
+                (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
+                )
             )
-            code == 10001L -> Result.success(status?.copy(message = "今日已签到") ?: CheckinStatus(true, true, 0, 0, 0, "", "今日已签到"))
             else -> {
-                val msg = runCatching {
-                    val root = json.parseToJsonElement(body).jsonObject
-                    val obj = root["data"]?.jsonObject ?: root
-                    obj.scalar("msg", "message", "Message") ?: ""
-                }.getOrDefault("")
-                if (status != null) Result.success(status.copy(message = if (msg.isBlank()) "签到失败" else msg))
-                else Result.failure(RepositoryError.Unknown())
+                if (status != null) {
+                    Result.success(status.copy(message = msg, outcome = CheckinOutcome.FAILED))
+                } else {
+                    Result.failure(RepositoryError.Unknown())
+                }
             }
         }
     }
 
-    /** 带自动 refresh 一次的 POST（Bearer）；返回响应体，失败 null。 */
-    private fun authedPost(credential: Credential.WorkBuddyCredential, path: String): String? {
+    /**
+     * [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)
@@ -371,45 +603,78 @@ class WorkBuddyRepository constructor(
                 .build()
             val resp = try {
                 okHttpClient.newCall(request).execute()
-            } catch (_: Throwable) {
-                return null
+            } 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 body
+                code in 200..299 -> return AuthedPostResult.Ok(body, rotated)
                 (code == 401 || code == 403) && attempt == 0 -> {
-                    val refreshed = tryRefesh(refresh) ?: return null
-                    // 轮换后的凭据由调用方主流程 save（此处仅内存内继续），避免半途改库
+                    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 null
+                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
     }
 
-    /** 解析 checkin-activity-status 响应（data 平铺或 data 包裹，防御式多候选）。 */
-    private fun parseCheckin(body: String): CheckinStatus {
-        val root = json.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.longOr(vararg keys: String): Long? {
-        for (key in keys) {
-            this[key]?.jsonPrimitive?.contentOrNull?.toLongOrNull()?.let { return it }
-        }
-        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) {
@@ -433,4 +698,48 @@ class WorkBuddyRepository constructor(
         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

@@ -19,6 +19,7 @@ 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
@@ -204,6 +205,16 @@ object NetworkModule {
     /**
      * Sub2API 仓库：自托管实例（凭据里的 baseUrl）+ 管理面板 API。
      */
+    /**
+     * 更新仓库：读取 Gitea 上的 update.json 并下载 APK。
+     */
+    @Provides
+    @Singleton
+    fun provideUpdateRepository(
+        okHttpClient: OkHttpClient,
+        @ApplicationContext context: Context
+    ): UpdateRepository = UpdateRepository(okHttpClient, context)
+
     @Provides
     @Singleton
     fun provideSub2ApiRepository(

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

@@ -66,6 +66,13 @@ sealed class 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(
@@ -74,6 +81,19 @@ sealed class Credential {
         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()
 

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/service/ServiceConfigProvider.kt

@@ -78,13 +78,17 @@ object ServiceConfigProvider {
             type = ServiceType.TRAE,
             method = FetchMethod.REST_API,
             loginUrl = "",
-            displayUnit = "Credits"
+            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"
+            displayUnit = "Credits",
+            // 官网订阅定价页
+            externalUrl = "https://www.workbuddy.cn/pricing/"
         ),
         ServiceType.SUB2API to ServiceConfig(
             type = ServiceType.SUB2API,

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

@@ -26,5 +26,16 @@ enum class ServiceType(
     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,6 +3,7 @@ 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
@@ -29,6 +30,7 @@ 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>,
@@ -38,8 +40,11 @@ class RefreshBalanceUseCase @Inject constructor(
     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()
@@ -57,13 +62,13 @@ class RefreshBalanceUseCase @Inject constructor(
                     ollamaRepositoryProvider.get().fetchBalance()
                 }
                 ServiceType.TRAE -> retryOnTransientError {
-                    traeRepositoryProvider.get().fetchBalance()
+                    traeRepositoryProvider.get().fetchBalance(accountId)
                 }
                 ServiceType.WORKBUDDY -> retryOnTransientError {
-                    workBuddyRepositoryProvider.get().fetchBalance()
+                    workBuddyRepositoryProvider.get().fetchBalance(accountId)
                 }
                 ServiceType.SUB2API -> retryOnTransientError {
-                    sub2ApiRepositoryProvider.get().fetchBalance()
+                    sub2ApiRepositoryProvider.get().fetchBalance(accountId)
                 }
             }
         }
@@ -92,11 +97,86 @@ class RefreshBalanceUseCase @Inject constructor(
             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/ui/RainyTokenNavHost.kt

@@ -50,12 +50,13 @@ import com.rainy.token.ui.dashboard.UsageDataScreen
 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.UsageStatScreen
 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
@@ -77,19 +78,35 @@ object Routes {
     const val DASHBOARD = "dashboard"
     const val SETTINGS = "settings"
     const val API_MANAGEMENT = "api_management"
-    const val USAGE_STAT = "usage_stat"
     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 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}"
-    fun serviceDetail(type: ServiceType) = "service/${type.name}"
+    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"
@@ -104,15 +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 UsageStat : DetailPane()
     object Heatmap : DetailPane()
+    /** 通用外部页面（充值/订阅页），App 内 WebView 打开。 */
+    data class WebPage(val url: String, val title: String) : DetailPane()
 }
 
 @Composable
@@ -204,30 +226,34 @@ private fun CompactNavHost() {
         }
     ) {
         composable(Routes.DASHBOARD) {
+            val rechargeLabel = stringResource(R.string.action_recharge)
             DashboardScreen(
                 onOpenSettings = { navController.navigate(Routes.SETTINGS) },
                 onOpenApiManagement = { navController.navigate(Routes.API_MANAGEMENT) },
-                onOpenUsageStat = { navController.navigate(Routes.USAGE_STAT) },
-                onOpenService = { type -> navController.navigate(Routes.serviceDetail(type)) },
+                onOpenService = { type, accountId ->
+                    navController.navigate(Routes.serviceDetail(type, accountId))
+                },
                 onOpenUsageDetail = { navController.navigate(Routes.USAGE_DETAIL) },
                 onOpenCcgoUsageDetail = { navController.navigate(Routes.CCGO_USAGE_DETAIL) },
-                onOpenHeatmap = { navController.navigate(Routes.HEATMAP) }
-            )
-        }
-        composable(Routes.API_MANAGEMENT) {
-            val rechargeLabel = stringResource(R.string.action_recharge)
-            ApiManagementScreen(
-                onBack = guardedPop,
-                onConfigure = { type -> navController.navigate(Routes.credentialEdit(type)) },
-                onRecharge = { type ->
+                onOpenHeatmap = { navController.navigate(Routes.HEATMAP) },
+                onOpenRecharge = { type ->
                     ServiceConfigProvider.get(type).externalUrl?.let { url ->
                         navController.navigate(Routes.webviewPage(url, rechargeLabel))
                     }
                 }
             )
         }
-        composable(Routes.USAGE_STAT) {
-            UsageStatScreen(onBack = guardedPop)
+        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) {
             UsageDetailScreen(
@@ -285,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)
         }
@@ -304,39 +341,83 @@ 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))
@@ -380,6 +461,8 @@ private fun ExpandedLayout() {
         prevPane = detailPane
     }
 
+    val rechargeLabel = stringResource(R.string.action_recharge)
+
     Row(modifier = Modifier.fillMaxSize()) {
         Box(
             modifier = Modifier
@@ -389,11 +472,17 @@ private fun ExpandedLayout() {
             DashboardScreen(
                 onOpenSettings = { detailPane = DetailPane.Settings },
                 onOpenApiManagement = { detailPane = DetailPane.ApiManagement },
-                onOpenUsageStat = { detailPane = DetailPane.UsageStat },
-                onOpenService = { type -> detailPane = DetailPane.ServiceDetail(type) },
+                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
             )
         }
@@ -412,6 +501,9 @@ private fun ExpandedLayout() {
             ExpandedDetailPane(
                 pane = detailPane,
                 onClose = { detailPane = DetailPane.Empty },
+                onSwitchAccount = { svc, acc ->
+                    detailPane = DetailPane.ServiceDetail(svc, acc)
+                },
                 onCredentialEditClosed = { dashboardVm.reloadLocalState() }
             )
         }
@@ -422,6 +514,7 @@ private fun ExpandedLayout() {
 private fun ExpandedDetailPane(
     pane: DetailPane,
     onClose: () -> Unit,
+    onSwitchAccount: (ServiceType, String?) -> Unit = { _, _ -> },
     onCredentialEditClosed: () -> Unit = {}
 ) {
     when (pane) {
@@ -434,8 +527,8 @@ private fun ExpandedDetailPane(
             }
         }
         is DetailPane.ServiceDetail -> {
-            // key(pane.type)：切换服务时重建嵌套导航栈，避免停留在上一个服务的充值页
-            key(pane.type) {
+            // key(pane.type + accountId)：切换服务/账号时重建嵌套导航栈，避免停留在上一个页面
+            key("${pane.type.name}:${pane.accountId.orEmpty()}") {
                 val navController = rememberNavController()
             NavHost(
                 navController = navController,
@@ -446,9 +539,11 @@ private fun ExpandedDetailPane(
                     val rechargeLabel = LocalContext.current.getString(R.string.action_recharge)
                     ServiceDetailScreen(
                         service = pane.type,
+                        accountId = pane.accountId,
                         onBack = onClose,
+                        onSwitchAccount = onSwitchAccount,
                         onConfigureCredential = { onClose() },
-                        onStartWebViewLogin = { },
+                        onStartWebViewLogin = { _, _ -> },
                         onOpenRecharge = { svc ->
                             ServiceConfigProvider.get(svc).externalUrl?.let { url ->
                                 navController.navigate(Routes.webviewPage(url, rechargeLabel))
@@ -534,8 +629,12 @@ private fun ExpandedDetailPane(
         is DetailPane.Heatmap -> {
             HeatmapScreen(onBack = onClose)
         }
-        is DetailPane.UsageStat -> {
-            UsageStatScreen(onBack = onClose)
+        is DetailPane.WebPage -> {
+            WebViewPageScreen(
+                url = pane.url,
+                title = pane.title,
+                onBack = onClose
+            )
         }
         is DetailPane.ApiManagement -> {
             val apiNavController = rememberNavController()
@@ -558,7 +657,7 @@ private fun ExpandedDetailPane(
                     val rechargeLabel = LocalContext.current.getString(R.string.action_recharge)
                     ApiManagementScreen(
                         onBack = onClose,
-                        onConfigure = { type -> apiNavController.navigate(Routes.credentialEdit(type)) },
+                        onConfigure = { type -> apiNavController.navigate(credentialEntry(type)) },
                         onRecharge = { type ->
                             ServiceConfigProvider.get(type).externalUrl?.let { url ->
                                 apiNavController.navigate(Routes.webviewPage(url, rechargeLabel))
@@ -566,16 +665,35 @@ private fun ExpandedDetailPane(
                         }
                     )
                 }
-                composable(
-                    route = Routes.CREDENTIAL_EDIT,
-                    arguments = listOf(navArgument("type") { type = NavType.StringType })
-                ) { entry ->
+                composable(Routes.ACCOUNTS) { entry ->
                     val type = parseServiceType(entry.arguments?.getString("type"))
-                    CredentialEditScreen(
+                    AccountManagementScreen(
                         service = type,
                         onBack = { apiNavController.popBackStack() },
-                        onStartWebViewLogin = { svc ->
-                            apiNavController.navigate(Routes.webviewLogin(svc))
+                        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) }
@@ -583,13 +701,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 = { apiNavController.popBackStack() },
-                        onLoginSucceeded = { apiNavController.popBackStack() }
+                        onLoginSucceeded = { _, effectiveId ->
+                            if (!effectiveId.isNullOrBlank()) {
+                                apiNavController.previousBackStackEntry?.savedStateHandle?.set(
+                                    CredentialEditViewModel.KEY_LOGIN_ACCOUNT_ID, effectiveId
+                                )
+                            }
+                            apiNavController.popBackStack()
+                        }
                     )
                 }
                 composable(Routes.CODEX_OAUTH) {
@@ -635,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() })
                 }
@@ -655,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) }
@@ -670,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

@@ -1,6 +1,7 @@
 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
@@ -10,6 +11,7 @@ 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
@@ -17,6 +19,7 @@ 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
@@ -29,7 +32,6 @@ import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Snackbar
 import androidx.compose.material3.SnackbarHost
@@ -50,6 +52,7 @@ 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
@@ -57,11 +60,13 @@ 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
@@ -69,10 +74,11 @@ import java.util.Date
 import java.util.Locale
 
 /**
- * API 管理页：按供应商集中展示/管理已保存的凭据。
+ * API 管理页（记事本式）。
  *
- * 每个供应商一张卡：状态、Key 掩码、最后验证、缓存余额，以及
- * 配置/编辑、测试连接、删除（需确认）操作；DeepSeek 额外提供充值入口。
+ * 心智模型像记事本：正文只有「已添加」的服务条目，右上角 **+** 从剩余服务里选一个
+ * 添加（进入对应配置流程）；未配置的服务不占卡片。条目点击即编辑，行内提供
+ * 测试连接 / 删除（需确认），有官方充值/订阅页的服务额外给入口。
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -88,6 +94,7 @@ fun ApiManagementScreen(
     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 {
@@ -112,6 +119,15 @@ fun ApiManagementScreen(
                             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
+                        )
+                    }
                 }
             )
         },
@@ -124,11 +140,14 @@ fun ApiManagementScreen(
             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,
-                    onConfigure = { onConfigure(row.service) },
+                    onEdit = { onConfigure(row.service) },
                     onTest = { viewModel.test(row.service) },
                     onDelete = { pendingDelete = row.service },
                     onRecharge = { onRecharge(row.service) }
@@ -137,6 +156,17 @@ fun ApiManagementScreen(
         }
     }
 
+    if (showAddPicker) {
+        AddServicePickerDialog(
+            addable = uiState.addable,
+            onPick = { service ->
+                showAddPicker = false
+                onConfigure(service)
+            },
+            onDismiss = { showAddPicker = false }
+        )
+    }
+
     pendingDelete?.let { service ->
         AlertDialog(
             onDismissRequest = { pendingDelete = null },
@@ -163,17 +193,137 @@ fun ApiManagementScreen(
     }
 }
 
+/** 空态引导：还没有添加任何条目时展示，给出「+ 添加」动作。 */
+@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,
-    onConfigure: () -> Unit,
+    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(),
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable { onEdit() },
         shape = RoundedCornerShape(20.dp),
         colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
         elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
@@ -189,7 +339,11 @@ private fun ApiRowCard(
                         fontWeight = FontWeight.SemiBold
                     )
                     Text(
-                        text = row.maskedCredential ?: stringResource(R.string.api_mgmt_unconfigured),
+                        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()
                     )
@@ -225,52 +379,38 @@ private fun ApiRowCard(
                     }
                 }
                 Spacer(modifier = Modifier.width(8.dp))
-                // 测试连接（进行中转圈）+ 删除
-                if (testing) {
-                    CircularProgressIndicator(
-                        modifier = Modifier.size(20.dp),
-                        color = StrawberryPink,
-                        strokeWidth = 2.dp
-                    )
-                } else {
-                    TextButton(onClick = onTest, enabled = row.isConfigured) {
-                        Text(stringResource(R.string.api_mgmt_test))
+                // 测试连接（进行中转圈）+ 删除；多账号服务行内不提供（避免只对默认账号操作 / 误删全部账号）
+                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
+                        )
                     }
                 }
-                IconButton(onClick = onDelete, enabled = row.isConfigured) {
-                    Icon(
-                        imageVector = Icons.Filled.Delete,
-                        contentDescription = stringResource(R.string.action_delete),
-                        tint = if (row.isConfigured) MaterialTheme.colorScheme.error else inkMuted().copy(alpha = 0.4f)
-                    )
-                }
-            }
-
-            Spacer(modifier = Modifier.height(8.dp))
-
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.spacedBy(8.dp)
-            ) {
-                Button(
-                    onClick = onConfigure,
-                    modifier = Modifier.weight(1f),
-                    colors = ButtonDefaults.buttonColors(
-                        containerColor = StrawberryPink,
-                        contentColor = Color.White
-                    )
-                ) {
-                    Text(
-                        if (row.isConfigured) {
-                            stringResource(R.string.api_mgmt_edit)
-                        } else {
-                            stringResource(R.string.api_mgmt_configure)
-                        }
-                    )
-                }
-                if (row.service == ServiceType.DEEPSEEK) {
-                    OutlinedButton(onClick = onRecharge, modifier = Modifier.weight(1f)) {
-                        Text(stringResource(R.string.action_recharge))
+                if (rechargeUrl != null) {
+                    TextButton(onClick = onRecharge) {
+                        Text(
+                            stringResource(R.string.action_recharge),
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
+                        )
                     }
                 }
             }
@@ -281,7 +421,7 @@ private fun ApiRowCard(
 @Composable
 private fun StatusDot(state: CredentialStatus.State) {
     val color = when (state) {
-        CredentialStatus.State.OK -> Color(0xFF3BB273)
+        CredentialStatus.State.OK -> StatusGreen
         CredentialStatus.State.WARNING -> StatusOrange
         CredentialStatus.State.EXPIRED -> MaterialTheme.colorScheme.error
         CredentialStatus.State.NOT_CONFIGURED -> inkMuted().copy(alpha = 0.5f)

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

@@ -21,10 +21,11 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 
 /**
- * API 管理页 ViewModel。
+ * API 管理页 ViewModel（记事本式）。
  *
- * 按供应商集中展示已保存凭据的状态与摘要（Key 掩码、最后验证、缓存余额），
- * 提供测试连接 / 删除操作。编辑走既有 credential_edit 页面。
+ * 列表只展示「已添加」的凭据条目（Key 掩码、最后验证、缓存余额），
+ * 未配置的服务不占位；右上角 + 从 [addable] 里选服务新增。
+ * 提供测试连接 / 删除操作，编辑走既有 credential_edit 页面。
  */
 @HiltViewModel
 class ApiManagementViewModel @Inject constructor(
@@ -49,7 +50,7 @@ class ApiManagementViewModel @Inject constructor(
     fun load() {
         viewModelScope.launch {
             val states = credentialRepository.readLocalStates()
-            val rows = ServiceType.entries.map { type ->
+            val all = ServiceType.entries.map { type ->
                 val local = states.getValue(type)
                 val cred = credentialRepository.get(type)
                 ApiRowUi(
@@ -57,10 +58,21 @@ class ApiManagementViewModel @Inject constructor(
                     state = local.status.state,
                     lastVerifiedAt = local.status.lastVerifiedAt,
                     cachedBalance = local.cachedBalance,
-                    maskedCredential = maskCredential(cred)
+                    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 }
                 )
             }
-            _uiState.update { it.copy(rows = rows) }
         }
     }
 
@@ -128,6 +140,7 @@ class ApiManagementViewModel @Inject constructor(
     }
 
     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)
@@ -143,11 +156,19 @@ data class ApiRowUi(
     val state: CredentialStatus.State,
     val lastVerifiedAt: Long,
     val cachedBalance: CachedBalance?,
-    val maskedCredential: String?
+    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 rows: List<ApiRowUi> = emptyList(),
+    /** 尚未添加的服务（右上角 + 的可选列表）。 */
+    val addable: List<ServiceType> = emptyList()
 )

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

@@ -39,6 +39,8 @@ 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)
@@ -103,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/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

@@ -44,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(
@@ -59,7 +59,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(
@@ -120,20 +120,34 @@ fun ServiceIcon(
             }
         }
         ServiceType.TRAE -> {
-            LetterIcon(
-                letter = "T",
-                background = Color(0xFF20242E),
-                modifier = modifier,
-                size = size
-            )
+            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 -> {
-            LetterIcon(
-                letter = "W",
-                background = Color(0xFF3339FF),
-                modifier = modifier,
-                size = size
-            )
+            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(

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
@@ -44,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(

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

@@ -38,6 +38,8 @@ 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
@@ -84,10 +86,12 @@ 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
@@ -96,7 +100,10 @@ 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
@@ -127,19 +134,22 @@ import java.util.Locale
 fun DashboardScreen(
     onOpenSettings: () -> Unit,
     onOpenApiManagement: () -> Unit,
-    onOpenUsageStat: () -> Unit,
-    onOpenService: (ServiceType) -> 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()
@@ -164,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 据此同步用量数据
@@ -202,6 +218,45 @@ fun DashboardScreen(
         )
     }
 
+    // 每日自动签到结果汇报：「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)
+                }
+            }
+        )
+    }
+
     Scaffold(
         containerColor = Color.Transparent,
         topBar = {
@@ -228,13 +283,6 @@ fun DashboardScreen(
                             tint = StrawberryPink
                         )
                     }
-                    IconButton(onClick = onOpenUsageStat) {
-                        Icon(
-                            imageVector = Icons.Filled.DateRange,
-                            contentDescription = stringResource(R.string.usage_stat_title),
-                            tint = StrawberryPink
-                        )
-                    }
                     IconButton(
                         onClick = { viewModel.refresh() },
                         enabled = !uiState.refreshing
@@ -298,14 +346,49 @@ fun DashboardScreen(
                             .padding(contentPadding),
                         verticalArrangement = Arrangement.spacedBy(12.dp)
                     ) {
-                        // 随机小技巧提示（每次启动随机一条）
+                        // 随机小技巧提示（每次启动随机一条）+ 最右侧自动签到开关
                         val tipTextRes = remember { AppTips.randomHintRes() }
-                        Text(
-                            text = "💡 " + stringResource(tipTextRes),
-                            style = MaterialTheme.typography.bodySmall,
-                            color = inkMuted(),
-                            modifier = Modifier.padding(horizontal = 4.dp)
-                        )
+                        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,
@@ -314,7 +397,11 @@ fun DashboardScreen(
                             onOpenCcgoUsageDetail = onOpenCcgoUsageDetail,
                             onOpenService = onOpenService,
                             onOpenHeatmap = onOpenHeatmap,
-                            onOpenSub2PanelManagement = { showSub2PanelManagement = true },
+                            onOpenSub2PanelManagement = { accountId ->
+                                viewModel.openSub2Panel(accountId)
+                                showSub2PanelManagement = true
+                            },
+                            onOpenRecharge = onOpenRecharge,
                             refreshTrigger = usageSyncTrigger
                         )
                         DraggableDashboardCards(
@@ -382,6 +469,12 @@ fun DashboardScreen(
     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 列表与分组
@@ -408,7 +501,7 @@ fun DashboardScreen(
                         .verticalScroll(scrollState)
                 ) {
                     com.rainy.token.ui.servicedetail.Sub2ApiPanelManagement(
-                        balance = uiState.cards.firstOrNull { it.service == ServiceType.SUB2API }?.cachedBalance?.balance,
+                        balance = panelBalanceCard?.cachedBalance?.balance,
                         keysState = panelKeysState,
                         groups = panelGroups,
                         actionMessage = panelActionMessage,
@@ -453,9 +546,10 @@ private fun rememberDashboardItems(
     onOpenSettings: () -> Unit,
     onOpenUsageDetail: () -> Unit,
     onOpenCcgoUsageDetail: () -> Unit,
-    onOpenService: (ServiceType) -> Unit,
+    onOpenService: (ServiceType, String?) -> Unit,
     onOpenHeatmap: () -> Unit,
-    onOpenSub2PanelManagement: () -> Unit,
+    onOpenSub2PanelManagement: (String?) -> Unit,
+    onOpenRecharge: (ServiceType) -> Unit,
     refreshTrigger: Int
 ): List<DashboardHomeItem> {
     val defaultItems = buildList {
@@ -486,11 +580,19 @@ private fun rememberDashboardItems(
                 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
@@ -498,9 +600,15 @@ private fun rememberDashboardItems(
                     },
                     // Token 活动热力图入口仅 OCGO 服务卡片显示（数据只统计 OCGO）
                     onOpenHeatmap = if (card.service == ServiceType.OPENCODE_GO) onOpenHeatmap else null,
-                    // Sub2API 面板管理快捷入口（首页弹窗）
+                    // Sub2API 面板管理快捷入口（首页弹窗）：绑定当前卡片所属账号
                     onOpenPanelManagement = if (card.service == ServiceType.SUB2API) {
-                        { onOpenSub2PanelManagement() }
+                        { accountId -> onOpenSub2PanelManagement(accountId ?: card.accountId) }
+                    } else {
+                        null
+                    },
+                    // 充值/订阅入口：有官方 externalUrl 的服务（DeepSeek/Trae/WorkBuddy）在卡片上直开
+                    onOpenRecharge = if (ServiceConfigProvider.get(card.service).externalUrl != null) {
+                        { onOpenRecharge(card.service) }
                     } else {
                         null
                     },
@@ -509,10 +617,54 @@ private fun rememberDashboardItems(
         }
     }
     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>,
@@ -750,10 +902,12 @@ private fun DraggableDashboardCards(
 @Composable
 private fun DashboardCard(
     card: DashboardCardUi,
+    accountLabel: String? = null,
     onClick: () -> Unit,
     onOpenUsageDetail: (() -> Unit)? = null,
     onOpenHeatmap: (() -> Unit)? = null,
-    onOpenPanelManagement: (() -> Unit)? = null,
+    onOpenPanelManagement: ((String?) -> Unit)? = null,
+    onOpenRecharge: (() -> Unit)? = null,
 ) {
     Card(
         modifier = Modifier
@@ -774,22 +928,60 @@ private fun DashboardCard(
                 }
                 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(
-                        // Sub2API 显示登录方式（邮箱登录 / API 登录），其余服务用固定描述
-                        text = if (card.service == ServiceType.SUB2API) {
-                            sub2AuthModeText(card)
-                        } else {
-                            stringResource(secondaryLineRes(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())
             }
 
@@ -840,7 +1032,7 @@ private fun DashboardCard(
                 }
             }
 
-            // ─── 底部：左侧更新时间/错误信息，右侧「面板管理」入口（同一行、右对齐）───
+            // ─── 底部：左侧更新时间/错误信息，右侧「面板管理 / 充值订阅」入口（同一行、右对齐）───
             Spacer(modifier = Modifier.height(12.dp))
             Row(verticalAlignment = Alignment.CenterVertically) {
                 Text(
@@ -864,7 +1056,7 @@ private fun DashboardCard(
                     // 注意：Material3 的最小尺寸挂在 TextButton 内层节点上，外层 modifier 传
                     // defaultMinSize(0) 压不下去（实测为 no-op），这里不再写无用约束。
                     TextButton(
-                        onClick = onOpenPanelManagement,
+                        onClick = { onOpenPanelManagement?.invoke(card.accountId) },
                         contentPadding = PaddingValues(0.dp)
                     ) {
                         Text(
@@ -885,6 +1077,32 @@ private fun DashboardCard(
                         )
                     }
                 }
+                // 充值/订阅入口（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)
+                        )
+                    }
+                }
             }
         }
     }

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

@@ -13,10 +13,12 @@ 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
@@ -39,6 +41,8 @@ import kotlinx.coroutines.sync.Mutex
 class DashboardViewModel @Inject constructor(
     private val credentialRepository: CredentialRepository,
     private val refreshBalanceUseCase: RefreshBalanceUseCase,
+    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() {
@@ -51,15 +55,84 @@ 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 的最新卡片：
      * - 以当前已配置服务（configuredTypes）为准重建，新增服务即时出现、删除服务即时消失；
@@ -70,92 +143,64 @@ class DashboardViewModel @Inject constructor(
      */
     fun reloadLocalState() {
         viewModelScope.launch {
-            val localStates = credentialRepository.readLocalStates()
-            val configured = configuredTypes(localStates).toSet()
+            val accountStates = credentialRepository.readAccountStates()
             _uiState.update { state ->
-                val previousByService = state.cards.associateBy { it.service }
-                // 保留用户既有顺序；新配置的服务追加到尾部（按枚举顺序）
-                val existingOrder = state.cards
-                    .mapIndexed { index, card -> card.service to index }
-                    .toMap()
-                val orderedTypes = configured.sortedWith(
-                    compareBy({ existingOrder[it] ?: Int.MAX_VALUE }, { it.ordinal })
-                )
-                state.copy(
-                    cards = orderedTypes.map { type ->
-                        val local = localStates.getValue(type)
-                        val card = previousByService[type]
-                        if (card == null) {
-                            buildCard(local, lastFetchError = null)
-                        } else {
-                            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 = configuredTypes(localStates).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 = configuredTypes(localStates).map { type ->
-                    val result = results[type]
-                    val error = result?.exceptionOrNull()
+                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 }
                         ?.let { errorToUiText(it) }
-                    buildCard(localStates.getValue(type), lastFetchError = errorUi)
+                    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 {
@@ -164,23 +209,85 @@ class DashboardViewModel @Inject constructor(
         }
     }
 
-    /** 已配置凭据（state != NOT_CONFIGURED）的服务，首页只显示这些。 */
-    private fun configuredTypes(
-        localStates: Map<ServiceType, CredentialRepository.LocalState>
-    ): List<ServiceType> = ServiceType.entries.filter { type ->
-        localStates.getValue(type).status.state != CredentialStatus.State.NOT_CONFIGURED
+    /**
+     * 基于最新账号状态重建卡片列表，尽量保留旧顺序：
+     *  - 同一服务内默认账号在前，其余按账号创建顺序；
+     *  - 新增账号追加到同服务现有卡片之后；服务整体顺序沿用旧顺序，新服务按枚举追加。
+     */
+    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,
+        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,
-        siteIcon = (local.credential as? Credential.Sub2ApiCredential)?.siteIcon
+        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(
@@ -210,12 +317,26 @@ class DashboardViewModel @Inject constructor(
     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()
@@ -227,7 +348,7 @@ class DashboardViewModel @Inject constructor(
         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().fold(
+            sub2ApiRepository.fetchPanelKeys(_sub2PanelAccountId.value).fold(
                 onSuccess = { list ->
                     _panelKeysState.value = com.rainy.token.ui.servicedetail.PanelKeysState.Success(list)
                 },
@@ -238,18 +359,30 @@ class DashboardViewModel @Inject constructor(
         }
     }
 
-    /** 加载可用分组；已非空则跳过（只要加载过一次即可复用）。 */
+    /** 面板分组缓存所属账号（防止切换账号后仍显示上一个账号的分组）。 */
+    private var _panelGroupsAccountId: String? = null
+
+    /** 加载可用分组；同一账号加载过一次则跳过，切换账号后强制重拉。 */
     fun loadPanelGroups() {
         viewModelScope.launch {
-            if (_panelGroups.value.isNotEmpty()) return@launch
-            sub2ApiRepository.fetchPanelGroups().onSuccess { _panelGroups.value = it }
+            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).fold(
+            sub2ApiRepository.createPanelKey(name, groupId, _sub2PanelAccountId.value).fold(
                 onSuccess = { key ->
                     _recentlyCreatedKey.value = key
                     _panelActionMessage.value = "已创建 Key：" + maskPanelKey(key) + "（请在弹出的窗口复制完整 Key）"
@@ -263,7 +396,7 @@ class DashboardViewModel @Inject constructor(
     /** 切换 Key 所属分组：成功后刷新列表。 */
     fun switchPanelGroup(keyId: Long, groupId: Long) {
         viewModelScope.launch {
-            sub2ApiRepository.updatePanelKey(keyId, groupId).fold(
+            sub2ApiRepository.updatePanelKey(keyId, groupId, accountId = _sub2PanelAccountId.value).fold(
                 onSuccess = {
                     _panelActionMessage.value = "分组已切换"
                     loadPanelKeys()
@@ -276,7 +409,7 @@ class DashboardViewModel @Inject constructor(
     /** 删除 Key：成功后刷新列表。 */
     fun deletePanelKey(keyId: Long) {
         viewModelScope.launch {
-            sub2ApiRepository.deletePanelKey(keyId).fold(
+            sub2ApiRepository.deletePanelKey(keyId, _sub2PanelAccountId.value).fold(
                 onSuccess = {
                     _panelActionMessage.value = "已删除 Key"
                     loadPanelKeys()
@@ -289,10 +422,10 @@ class DashboardViewModel @Inject constructor(
     /** 兑换卡密：成功后刷新余额与 Key 列表。 */
     fun redeemPanelCode(code: String) {
         viewModelScope.launch {
-            sub2ApiRepository.redeemPanelCode(code).fold(
+            sub2ApiRepository.redeemPanelCode(code, _sub2PanelAccountId.value).fold(
                 onSuccess = { msg ->
                     _panelActionMessage.value = msg
-                    refreshBalanceUseCase(ServiceType.SUB2API)
+                    refreshBalanceUseCase(ServiceType.SUB2API, _sub2PanelAccountId.value)
                     loadPanelKeys()
                 },
                 onFailure = { e -> _panelActionMessage.value = "兑换失败：" + (e.message ?: "") }
@@ -315,19 +448,40 @@ 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: UiText?,
     /** 站点 Logo URL（Sub2API 面板登录后抓取；非空时主页卡片用它替换内置图标）。 */
-    val siteIcon: String? = null
+    val siteIcon: String? = null,
+    /** 今日已签到角标（仅可签到服务有值，见 [CHECKIN_SERVICES]）。 */
+    val checkedInToday: Boolean = false
 ) {
     /** 余额展示主数字。优先取缓存，错误时也展示（不隐藏，让用户看到旧值 + 红点提示）。 */
     val displayBalance: ServiceBalance? get() = cachedBalance?.balance
+
+    /** 卡片唯一键：`{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(

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

@@ -101,6 +101,9 @@ internal fun BalanceMainArea(card: DashboardCardUi) {
         card.service == ServiceType.SUB2API -> {
             Sub2ApiBalanceWithUsage(balance)
         }
+        card.service == ServiceType.TRAE -> {
+            TraeSplitMainBalance(balance)
+        }
         else -> {
             Row(verticalAlignment = Alignment.Bottom) {
                 Text(
@@ -135,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) {
@@ -575,6 +645,43 @@ internal fun sub2AuthModeText(card: DashboardCardUi): String {
     }
 }
 
+/**
+ * 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) {

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

@@ -76,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
@@ -89,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)

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

@@ -1,275 +0,0 @@
-package com.rainy.token.ui.dashboard
-
-import androidx.compose.foundation.background
-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.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.ArrowBack
-import androidx.compose.material.icons.filled.Refresh
-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.Text
-import androidx.compose.material3.TopAppBar
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-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.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.domain.model.CredentialStatus
-import com.rainy.token.domain.model.ServiceBalance
-import com.rainy.token.ui.components.ServiceIcon
-import com.rainy.token.ui.components.formatAmount
-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 java.util.Locale
-
-/**
- * 用量统计页：按已配置服务展示用量指标（余额、本月消费、总额度、下次重置、附加信息），
- * 顶栏一键全部刷新。数据来自缓存 + 在线刷新，与 API 管理页（只管凭据）分离。
- */
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun UsageStatScreen(
-    onBack: () -> Unit,
-    viewModel: UsageStatViewModel = hiltViewModel()
-) {
-    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-
-    Scaffold(
-        topBar = {
-            TopAppBar(
-                title = { Text(stringResource(R.string.usage_stat_title)) },
-                navigationIcon = {
-                    IconButton(onClick = onBack) {
-                        Icon(
-                            Icons.Filled.ArrowBack,
-                            contentDescription = stringResource(R.string.action_back)
-                        )
-                    }
-                },
-                actions = {
-                    if (uiState.refreshing) {
-                        CircularProgressIndicator(
-                            modifier = Modifier
-                                .padding(end = 16.dp)
-                                .size(20.dp),
-                            color = StrawberryPink,
-                            strokeWidth = 2.dp
-                        )
-                    } else {
-                        IconButton(onClick = { viewModel.refreshAll() }) {
-                            Icon(
-                                Icons.Filled.Refresh,
-                                contentDescription = stringResource(R.string.action_refresh),
-                                tint = StrawberryPink
-                            )
-                        }
-                    }
-                }
-            )
-        }
-    ) { innerPadding ->
-        when {
-            !uiState.initialized -> Box(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(innerPadding)
-            )
-            uiState.rows.isEmpty() -> Box(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(innerPadding),
-                contentAlignment = Alignment.Center
-            ) {
-                Text(
-                    text = stringResource(R.string.usage_stat_empty),
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = inkMuted()
-                )
-            }
-            else -> LazyColumn(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(innerPadding),
-                contentPadding = PaddingValues(16.dp),
-                verticalArrangement = Arrangement.spacedBy(12.dp)
-            ) {
-                items(uiState.rows, key = { it.service.storageKey }) { row ->
-                    UsageStatRowCard(row = row)
-                }
-                if (uiState.lastFailureCount > 0) {
-                    item(key = "failure_note") {
-                        Text(
-                            text = stringResource(
-                                R.string.usage_stat_failed,
-                                uiState.lastFailureCount
-                            ),
-                            style = MaterialTheme.typography.labelMedium,
-                            color = MaterialTheme.colorScheme.error
-                        )
-                    }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun UsageStatRowCard(row: UsageStatRowUi) {
-    val balance = row.balance
-    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(16.dp)) {
-            Row(verticalAlignment = Alignment.CenterVertically) {
-                ServiceIcon(service = row.service, size = 44)
-                Spacer(modifier = Modifier.width(12.dp))
-                Text(
-                    text = row.service.displayName,
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.SemiBold,
-                    modifier = Modifier.weight(1f)
-                )
-                UsageStatDot(state = row.state)
-            }
-
-            Spacer(modifier = Modifier.height(10.dp))
-
-            if (balance == null) {
-                Text(
-                    text = stringResource(R.string.usage_stat_never_fetched),
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = inkMuted()
-                )
-                return@Column
-            }
-
-            Text(
-                text = "${formatAmount(balance.amount)} ${balance.unit}",
-                style = MaterialTheme.typography.headlineSmall,
-                fontWeight = FontWeight.Bold
-            )
-            Spacer(modifier = Modifier.height(6.dp))
-
-            val metrics = buildList {
-                balance.monthlySpent?.let {
-                    add(stringResource(R.string.usage_stat_monthly_spent) to "${formatAmount(it)} ${balance.unit}")
-                }
-                balance.totalQuota?.let {
-                    add(stringResource(R.string.usage_stat_total_quota) to "${formatAmount(it)} ${balance.unit}")
-                }
-                balance.nextResetAt?.let {
-                    add(stringResource(R.string.usage_stat_next_reset) to formatTime(it))
-                }
-            }
-            metrics.forEach { (label, value) ->
-                MetricLine(label = label, value = value)
-            }
-
-            // extras 只透传对用户友好的键；过滤掉技术键与 JSON 模型数组，避免卡片被长串污染
-            val friendlyExtras = balance.extras.filterKeys { key ->
-                val k = key.lowercase()
-                !k.contains("models") &&
-                    !k.contains("resetinsec") &&
-                    !k.contains("resetat") &&
-                    !k.contains("raw") &&
-                    !k.endsWith(".unlimited")
-            }
-            if (friendlyExtras.isNotEmpty()) {
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.spacedBy(6.dp)
-                ) {
-                    friendlyExtras.entries.take(3).forEach { (key, value) ->
-                        Text(
-                            text = "$key: $value",
-                            style = MaterialTheme.typography.labelSmall,
-                            color = inkMuted()
-                        )
-                    }
-                }
-            }
-
-            if (row.fetchedAt > 0L) {
-                Spacer(modifier = Modifier.height(6.dp))
-                Text(
-                    text = stringResource(R.string.usage_stat_fetched_at, formatTime(row.fetchedAt)),
-                    style = MaterialTheme.typography.labelSmall,
-                    color = inkMuted()
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun MetricLine(label: String, value: String) {
-    Row(modifier = Modifier.padding(vertical = 2.dp)) {
-        Text(
-            text = label,
-            style = MaterialTheme.typography.bodySmall,
-            color = inkMuted(),
-            modifier = Modifier.width(96.dp)
-        )
-        Text(
-            text = value,
-            style = MaterialTheme.typography.bodySmall,
-            fontWeight = FontWeight.Medium
-        )
-    }
-}
-
-@Composable
-private fun UsageStatDot(state: CredentialStatus.State) {
-    val color = when (state) {
-        CredentialStatus.State.OK -> Color(0xFF3BB273)
-        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 formatTime(ts: Long): String {
-    if (ts <= 0L) return "—"
-    return runCatching {
-        SimpleDateFormat("MM-dd HH:mm", Locale.getDefault()).format(Date(ts))
-    }.getOrDefault("—")
-}

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

@@ -1,100 +0,0 @@
-package com.rainy.token.ui.dashboard
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.rainy.token.data.cache.BalanceCache
-import com.rainy.token.data.cache.CachedBalance
-import com.rainy.token.data.repository.CredentialRepository
-import com.rainy.token.domain.model.CredentialStatus
-import com.rainy.token.domain.model.ServiceBalance
-import com.rainy.token.domain.service.ServiceType
-import com.rainy.token.domain.usecase.RefreshBalanceUseCase
-import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.coroutineScope
-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。
- *
- * 按已配置的服务展示用量指标（余额、本月消费、总额度、下次重置、附加信息），
- * 支持一键全部刷新。数据来自缓存（无网可见旧值）+ 可触发在线刷新。
- */
-@HiltViewModel
-class UsageStatViewModel @Inject constructor(
-    private val credentialRepository: CredentialRepository,
-    private val balanceCache: BalanceCache,
-    private val refreshBalanceUseCase: RefreshBalanceUseCase
-) : ViewModel() {
-
-    private val _uiState = MutableStateFlow(UsageStatUiState())
-    val uiState: StateFlow<UsageStatUiState> = _uiState.asStateFlow()
-
-    init {
-        load()
-    }
-
-    fun load() {
-        viewModelScope.launch {
-            val rows = buildRows()
-            _uiState.update { it.copy(rows = rows, refreshing = false, initialized = true, lastFailureCount = 0) }
-        }
-    }
-
-    fun refreshAll() {
-        viewModelScope.launch {
-            val types = _uiState.value.rows.map { it.service }
-            if (types.isEmpty()) return@launch
-            _uiState.update { it.copy(refreshing = true, lastFailureCount = 0) }
-            val failures = coroutineScope {
-                types.map { type ->
-                    async { type to refreshBalanceUseCase(type).isSuccess }
-                }.awaitAll()
-            }.count { !it.second }
-            val rows = buildRows()
-            // 先刷新行，再单独写失败计数：避免前者把失败数清零（load 会重置）
-            _uiState.update { it.copy(rows = rows, refreshing = false) }
-            _uiState.update { it.copy(lastFailureCount = failures) }
-        }
-    }
-
-    /** 读取本地凭据 + 余额缓存，构建行数据（纯读，不发网络）。 */
-    private suspend fun buildRows(): List<UsageStatRowUi> {
-        val states = credentialRepository.readLocalStates()
-        val cached = balanceCache.getAll()
-        return ServiceType.entries
-            .filter { type ->
-                states.getValue(type).status.state != CredentialStatus.State.NOT_CONFIGURED
-            }
-            .map { type ->
-                val cachedBalance = cached[type]
-                UsageStatRowUi(
-                    service = type,
-                    balance = cachedBalance?.balance,
-                    fetchedAt = cachedBalance?.fetchedAt ?: 0L,
-                    state = states.getValue(type).status.state
-                )
-            }
-    }
-}
-
-data class UsageStatRowUi(
-    val service: ServiceType,
-    val balance: ServiceBalance?,
-    val fetchedAt: Long,
-    val state: CredentialStatus.State
-)
-
-data class UsageStatUiState(
-    val rows: List<UsageStatRowUi> = emptyList(),
-    val refreshing: Boolean = false,
-    val lastFailureCount: Int = 0,
-    /** 首帧 true 前不渲染空态，避免闪一下"暂无已配置服务" */
-    val initialized: Boolean = false
-)

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

@@ -289,6 +289,8 @@ private data class LoadResult(
 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 ->

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

@@ -66,24 +66,24 @@ import kotlinx.coroutines.flow.first
 
 // ── 热力图颜色 ──────────────────────────────────────────────
 
-/** 亮色模式 6 级粉色梯度 */
+/** 亮色模式 6 级玫瑰粉梯度（精致粉调，最高级与主色一致） */
 private val LightHeatmapColors = listOf(
-    Color(0xFFEFE0E5), // Level 0: 极浅暖灰
-    Color(0xFFFFD6E0), // Level 1: 浅樱粉
-    Color(0xFFFFB3C6), // Level 2: 草莓粉柔
-    Color(0xFFFF85A2), // Level 3: 草莓粉
-    Color(0xFFFF6B8E), // Level 4: 草莓粉深
-    Color(0xFFE84973), // Level 5: 玫红
+    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 级粉色梯度 */
+/** 暗色模式 6 级玫瑰粉梯度 */
 private val DarkHeatmapColors = listOf(
-    Color(0xFF3A2A30), // Level 0: 暖深灰
-    Color(0xFF4A2E3A), // Level 1
-    Color(0xFF6B3D4A), // Level 2
-    Color(0xFF8B4D5A), // Level 3
-    Color(0xFFB86880), // Level 4
-    Color(0xFFD67F9A), // Level 5
+    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） */

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

@@ -17,6 +17,7 @@ import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.foundation.verticalScroll
+import androidx.compose.foundation.horizontalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.ArrowBack
 import androidx.compose.material3.AlertDialog
@@ -29,6 +30,8 @@ import androidx.compose.material3.DropdownMenuItem
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.ExposedDropdownMenuBox
 import androidx.compose.material3.ExposedDropdownMenuDefaults
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.FilterChipDefaults
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
@@ -54,6 +57,7 @@ import androidx.compose.ui.draw.clip
 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.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.Lifecycle
@@ -62,6 +66,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.rainy.token.R
 import com.rainy.token.data.repository.ModelUsageRow
 import com.rainy.token.data.repository.OpenCodeGoRepository
+import com.rainy.token.data.repository.WorkBuddyRepository
 import com.rainy.token.data.repository.WindowModelUsage
 import com.rainy.token.domain.model.ServiceBalance
 import com.rainy.token.domain.model.TriggerSummary
@@ -80,6 +85,11 @@ import com.rainy.token.ui.components.isFiveHourLabel
 import com.rainy.token.ui.theme.inkMuted
 import com.rainy.token.ui.theme.StrawberryPink
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonPrimitive
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
@@ -100,13 +110,15 @@ import java.util.Locale
 @Composable
 fun ServiceDetailScreen(
     service: ServiceType,
+    accountId: String? = null,
     onBack: () -> Unit,
+    onSwitchAccount: (ServiceType, String?) -> Unit = { _, _ -> },
     onConfigureCredential: (ServiceType) -> Unit,
-    onStartWebViewLogin: (ServiceType) -> Unit,
+    onStartWebViewLogin: (ServiceType, String?) -> Unit,
     onOpenRecharge: (ServiceType) -> Unit = { },
     viewModel: ServiceDetailViewModel = hiltViewModel()
 ) {
-    LaunchedEffect(service) { viewModel.bind(service) }
+    LaunchedEffect(service, accountId) { viewModel.bind(service, accountId) }
     // 从凭据编辑页返回时重新读取凭据状态 + 缓存
     LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
         viewModel.reloadCredentialState()
@@ -117,9 +129,27 @@ fun ServiceDetailScreen(
     val selectedModel by viewModel.selectedModel.collectAsStateWithLifecycle()
     val modelsLoading by viewModel.modelsLoading.collectAsStateWithLifecycle()
     val checkinState by viewModel.checkinState.collectAsStateWithLifecycle()
+    val checkinInfo by viewModel.checkinInfo.collectAsStateWithLifecycle()
+    val accounts by viewModel.accounts.collectAsStateWithLifecycle()
+
+    // 解析当前账号（显式 accountId 优先；未指定则默认账号）
+    val currentAccount: com.rainy.token.domain.model.ServiceAccountInfo? =
+        accounts.firstOrNull { it.id == accountId }
+            ?: if (accountId.isNullOrBlank()) {
+                accounts.firstOrNull { it.isDefault } ?: accounts.firstOrNull()
+            } else {
+                null
+            }
+    val accountLabel: String? = currentAccount?.let { account ->
+        account.label?.takeIf { it.isNotBlank() }
+            ?: stringResource(R.string.account_fallback_name, accounts.indexOf(account) + 1)
+    }
+
     // 面板管理（Key/分组/兑换）已移到首页 Sub2API 卡片的「面板管理」入口，
     // 详情页只保留用量明细所需的窗口统计状态。
     val panelWindowStats by viewModel.panelWindowStats.collectAsStateWithLifecycle()
+    val panelKeyStats by viewModel.panelKeyStats.collectAsStateWithLifecycle()
+    val hourlyTrend by viewModel.hourlyTrend.collectAsStateWithLifecycle()
     val config = ServiceConfigProvider.get(service)
     val isManualMode = config.method == FetchMethod.MANUAL
 
@@ -140,7 +170,11 @@ fun ServiceDetailScreen(
                         ServiceIcon(service = service, size = 32)
                         Spacer(modifier = Modifier.width(10.dp))
                         Text(
-                            text = service.displayName,
+                            text = if (accountLabel != null) {
+                                stringResource(R.string.service_detail_title_with_account, service.displayName, accountLabel)
+                            } else {
+                                service.displayName
+                            },
                             style = MaterialTheme.typography.titleLarge,
                             fontWeight = FontWeight.SemiBold
                         )
@@ -168,6 +202,18 @@ fun ServiceDetailScreen(
             contentPadding = PaddingValues(16.dp),
             verticalArrangement = Arrangement.spacedBy(12.dp)
         ) {
+            // 多账号服务：账号切换器（仅展示单个账号时不显示，保持旧版视觉）
+            if (ServiceType.isMultiAccount(service) && accounts.size > 1) {
+                item {
+                    AccountSwitcherRow(
+                        accounts = accounts,
+                        selectedId = currentAccount?.id,
+                        fallbackName = { index -> stringResource(R.string.account_fallback_name, index + 1) },
+                        onSelected = { id -> onSwitchAccount(service, id) }
+                    )
+                }
+            }
+
             // 主余额卡
             item { MainBalanceCard(state = uiState.state, service = service) }
 
@@ -188,16 +234,42 @@ fun ServiceDetailScreen(
                 ServiceType.OLLAMA -> {
                     item { OllamaUsageCard(uiState.state) }
                 }
-                ServiceType.TRAE,
-                ServiceType.WORKBUDDY -> {
-                    // 每日签到卡（WorkBuddy/Trae 共用）；下方仍展示通用 extras
+                ServiceType.TRAE -> {
+                    // 每日签到卡；未配置凭据时展示引导卡，避免暴露必然失败的签到按钮
                     item {
-                        CheckinCard(
-                            state = checkinState,
-                            onCheckin = { viewModel.checkin() }
-                        )
+                        if (uiState.hasCredential) {
+                            CheckinCard(
+                                state = checkinState,
+                                todayCheckedIn = checkinInfo?.todayCheckedIn == true,
+                                streakDays = checkinInfo?.streakDays ?: 0L,
+                                isTrae = true,
+                                onCheckin = { viewModel.checkin() }
+                            )
+                        } else {
+                            CheckinNeedCredentialCard()
+                        }
                     }
-                    item { GenericExtrasCard(uiState.state) }
+                    // 权益包积分明细（拆开显示每包总额/已用/剩余）；无 entitlement.* 数据时该卡不渲染
+                    item { TraePacksCard(uiState.state) }
+                    // 账户信息（总积分/已消耗/计费方式等，本地化标签，不暴露英文原始键）
+                    item { TraeAccountInfoCard(uiState.state) }
+                }
+                ServiceType.WORKBUDDY -> {
+                    item {
+                        if (uiState.hasCredential) {
+                            CheckinCard(
+                                state = checkinState,
+                                todayCheckedIn = checkinInfo?.todayCheckedIn == true,
+                                streakDays = checkinInfo?.streakDays ?: 0L,
+                                isTrae = false,
+                                onCheckin = { viewModel.checkin() }
+                            )
+                        } else {
+                            CheckinNeedCredentialCard()
+                        }
+                    }
+                    // 资源明细（资源 ID 美化为「资源 #007」+ 余额；套餐/冻结/付费信息归账户信息）
+                    item { WorkBuddyResourcesCard(uiState.state) }
                 }
                 ServiceType.SUB2API -> {
                     // 新明细卡：模型筛选 + 时间窗口 + 柱状图；无结构化明细时内部回退 GenericExtrasCard
@@ -205,7 +277,11 @@ fun ServiceDetailScreen(
                         Sub2ApiUsageCard(
                             state = uiState.state,
                             windowStatsState = panelWindowStats,
-                            onLoadWindowModelStats = { from, to -> viewModel.loadPanelWindowModelStats(from, to) }
+                            onLoadWindowModelStats = { from, to -> viewModel.loadPanelWindowModelStats(from, to) },
+                            hourlyTrend = hourlyTrend,
+                            onLoadHourlyTrend = { date -> viewModel.loadHourlyTrend(date) },
+                            keyStatsState = panelKeyStats,
+                            onLoadKeyStats = { from, to -> viewModel.loadPanelKeyStats(from, to) }
                         )
                     }
                     // 面板管理（Key 列表/新建/分组/兑换）不再在详情页展示：
@@ -239,7 +315,7 @@ fun ServiceDetailScreen(
                     modelsLoading = modelsLoading,
                     onRefresh = { viewModel.refresh() },
                     onConfigureCredential = { onConfigureCredential(service) },
-                    onStartWebViewLogin = { onStartWebViewLogin(service) },
+                    onStartWebViewLogin = { onStartWebViewLogin(service, accountId) },
                     onOpenRecharge = config.externalUrl?.let { { onOpenRecharge(service) } },
                     onTriggerUsage = { viewModel.triggerUsage() },
                     onSelectModel = { viewModel.selectModel(it) },
@@ -272,6 +348,46 @@ fun ServiceDetailScreen(
     }
 }
 
+/**
+ * 多账号服务的账号切换器：横向可滚动的 FilterChip 行，默认账号带「默认」角标。
+ */
+@Composable
+private fun AccountSwitcherRow(
+    accounts: List<com.rainy.token.domain.model.ServiceAccountInfo>,
+    selectedId: String?,
+    fallbackName: @Composable (Int) -> String,
+    onSelected: (String) -> Unit
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .horizontalScroll(rememberScrollState()),
+        horizontalArrangement = Arrangement.spacedBy(8.dp)
+    ) {
+        accounts.forEachIndexed { index, account ->
+            val label = account.label?.takeIf { it.isNotBlank() } ?: fallbackName(index)
+            val selected = account.id == selectedId
+            FilterChip(
+                selected = selected,
+                onClick = { if (!selected) onSelected(account.id) },
+                label = {
+                    Text(
+                        text = if (account.isDefault) {
+                            stringResource(R.string.account_chip_default, label)
+                        } else {
+                            label
+                        },
+                        maxLines = 1
+                    )
+                },
+                colors = FilterChipDefaults.filterChipColors(
+                    selectedContainerColor = StrawberryPink.copy(alpha = 0.14f)
+                )
+            )
+        }
+    }
+}
+
 /**
  * CommandCode 专属：月度用量卡 + 窗口进度条。
  *
@@ -944,9 +1060,9 @@ private fun MainBalanceCard(state: State, service: ServiceType) {
                         contentAlignment = Alignment.Center
                     ) { CircularProgressIndicator(color = StrawberryPink) }
                 }
-                is State.Fresh -> BalanceBigNumber(state.data)
+                is State.Fresh -> BalanceBigNumber(state.data, service)
                 is State.Stale -> {
-                    BalanceBigNumber(state.data)
+                    BalanceBigNumber(state.data, service)
                     Spacer(modifier = Modifier.height(8.dp))
                     Text(
                         text = stringResource(R.string.msg_stale_cache, formatTime(state.lastFetchedAt)),
@@ -955,7 +1071,7 @@ private fun MainBalanceCard(state: State, service: ServiceType) {
                     )
                 }
                 is State.Error -> {
-                    BalanceBigNumber(state.cached)
+                    BalanceBigNumber(state.cached, service)
                     Spacer(modifier = Modifier.height(8.dp))
                     Text(
                         text = stringResource(R.string.msg_showing_last_balance),
@@ -976,7 +1092,7 @@ private fun MainBalanceCard(state: State, service: ServiceType) {
 }
 
 @Composable
-private fun BalanceBigNumber(balance: ServiceBalance?) {
+private fun BalanceBigNumber(balance: ServiceBalance?, service: ServiceType) {
     if (balance == null) {
         Text(
             text = "—",
@@ -1016,6 +1132,34 @@ private fun BalanceBigNumber(balance: ServiceBalance?) {
             color = inkMuted()
         )
     }
+    // WorkBuddy：账户信息（冻结 / 付费 / 订阅）并入主余额卡，与「当前余额」同区展示
+    if (service == ServiceType.WORKBUDDY) {
+        val extras = balance.extras
+        val accountRows = buildList {
+            extras["frozen"]?.takeIf { it != "0" }?.let {
+                add(stringResource(R.string.extra_label_frozen) to "$it ${balance.unit}")
+            }
+            extras["is_paid_user"]?.let {
+                add(
+                    stringResource(R.string.extra_label_is_paid_user) to
+                        stringResource(if (it == "true") R.string.extra_value_yes else R.string.extra_value_no)
+                )
+            }
+            if (extras["subscription"] == "true") {
+                add(stringResource(R.string.extra_label_subscription) to stringResource(R.string.extra_value_yes))
+            }
+        }
+        if (accountRows.isNotEmpty()) {
+            Spacer(modifier = Modifier.height(12.dp))
+            Text(
+                text = stringResource(R.string.detail_account_info_title),
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.SemiBold
+            )
+            Spacer(modifier = Modifier.height(4.dp))
+            accountRows.forEach { (label, value) -> InfoRow(label = label, value = value) }
+        }
+    }
 }
 
 /**
@@ -1092,7 +1236,14 @@ private fun BreakdownRow(label: String, value: Double, unit: String) {
  * 结果消息直接采用官方响应语义（签到成功/今日已签到/设备拦截/失败原因）。
  */
 @Composable
-private fun CheckinCard(state: CheckinState, onCheckin: () -> Unit) {
+private fun CheckinCard(
+    state: CheckinState,
+    todayCheckedIn: Boolean,
+    streakDays: Long,
+    isTrae: Boolean = false,
+    onCheckin: () -> Unit
+) {
+    val actionDone = todayCheckedIn || state is CheckinState.Done
     Card(
         modifier = Modifier.fillMaxWidth(),
         shape = RoundedCornerShape(20.dp),
@@ -1114,27 +1265,60 @@ private fun CheckinCard(state: CheckinState, onCheckin: () -> Unit) {
             Spacer(modifier = Modifier.height(12.dp))
             when (state) {
                 is CheckinState.Done -> Text(
-                    text = state.message,
+                    text = state.message.asString(),
                     style = MaterialTheme.typography.bodyMedium,
                     color = MaterialTheme.colorScheme.primary
                 )
                 is CheckinState.Error -> Text(
-                    text = state.message,
+                    text = state.message.asString(),
                     style = MaterialTheme.typography.bodySmall,
                     color = MaterialTheme.colorScheme.error
                 )
-                else -> Unit
+                // 提示态（设备级拦截等）：中性色，且不置灰按钮
+                is CheckinState.Notice -> Text(
+                    text = state.message.asString(),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = inkMuted()
+                )
+                // 尚未点过按钮但预取到「今日已签」：给出连签提示
+                else -> if (todayCheckedIn) {
+                    Text(
+                        text = if (streakDays > 0) {
+                            stringResource(R.string.checkin_already_streak, streakDays)
+                        } else {
+                            stringResource(R.string.checkin_already)
+                        },
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+            }
+            // Trae 签到失败/提示时附设备 ID 获取路径（签到须用官方客户端绑定设备，
+            // 9074 风控根因；用户换设备后可按此路径自查新 did）。INTL 不支持与设备无关，不提示。
+            val hintRelevant = state is CheckinState.Notice ||
+                (state is CheckinState.Error && state.showDeviceHint)
+            if (isTrae && hintRelevant) {
+                Spacer(modifier = Modifier.height(6.dp))
+                Text(
+                    text = stringResource(R.string.checkin_trae_device_hint),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = inkMuted()
+                )
             }
             Spacer(modifier = Modifier.height(12.dp))
             Button(
                 onClick = onCheckin,
-                enabled = state !is CheckinState.Loading,
+                enabled = state !is CheckinState.Loading && !actionDone,
                 modifier = Modifier.fillMaxWidth().height(44.dp),
                 shape = RoundedCornerShape(12.dp)
             ) {
                 Text(
                     text = stringResource(
-                        if (state is CheckinState.Loading) R.string.checkin_loading else R.string.checkin_action
+                        when {
+                            state is CheckinState.Loading -> R.string.checkin_loading
+                            actionDone -> R.string.checkin_action_done
+                            else -> R.string.checkin_action
+                        }
                     )
                 )
             }
@@ -1142,9 +1326,374 @@ private fun CheckinCard(state: CheckinState, onCheckin: () -> Unit) {
     }
 }
 
+/** 未配置凭据时的签到占位卡：引导去配置，而不是直接暴露必然失败的签到按钮。 */
+@Composable
+private fun CheckinNeedCredentialCard() {
+    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.checkin_title),
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.SemiBold
+            )
+            Spacer(modifier = Modifier.height(6.dp))
+            Text(
+                text = stringResource(R.string.checkin_need_credential),
+                style = MaterialTheme.typography.bodySmall,
+                color = inkMuted()
+            )
+        }
+    }
+}
+
+/**
+ * Trae 权益包积分明细卡：把 balance.extras 中固定前缀键 entitlement.$i.* 拆开逐包展示，
+ * 并按 available_endpoint 分成「通用积分」（TraeCode/TraeWork 均可用）与
+ * 「Work 专属积分」（仅 TraeWork）两个分区，各带小计，与官方用量页口径一致。
+ * 只在存在 entitlement.* 数据时渲染；其余键仍由 [GenericExtrasCard] 展示。
+ */
+@Composable
+internal fun TraePacksCard(state: State) {
+    val balance = when (state) {
+        is State.Fresh -> state.data
+        is State.Stale -> state.data
+        is State.Error -> state.cached
+        else -> null
+    }
+    val extras = balance?.extras ?: return
+    val packs = buildList<PackLine> {
+        var i = 0
+        while (true) {
+            val name = extras["entitlement.$i.name"] ?: break
+            val unlimited = extras["entitlement.$i.unlimited"] == "true"
+            val limit = extras["entitlement.$i.limit"]?.toLongOrNull()
+            val used = extras["entitlement.$i.used"]?.toDoubleOrNull()
+            val remaining = extras["entitlement.$i.remaining"]?.toDoubleOrNull()
+            val isWork = extras["entitlement.$i.endpoint"] == "1"
+            add(PackLine(name, limit, used, remaining, unlimited, isWork))
+            i++
+        }
+    }
+    if (packs.isEmpty()) return
+
+    val generalTotal = extras["general_credits"]?.toDoubleOrNull()
+    val workTotal = extras["work_credits"]?.toDoubleOrNull()
+    val generalPacks = packs.filter { !it.isWork }
+    val workPacks = packs.filter { it.isWork }
+
+    val unlimitedLabel = stringResource(R.string.trae_pack_unlimited)
+    val remainingFmt = stringResource(R.string.trae_pack_remaining_fmt)
+    val generalTitle = stringResource(R.string.trae_general_credits_title)
+    val workTitle = stringResource(R.string.trae_work_credits_title)
+
+    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(16.dp),
+            verticalArrangement = Arrangement.spacedBy(5.dp)
+        ) {
+            Text(
+                text = stringResource(R.string.trae_packs_title),
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.SemiBold
+            )
+            // 通用积分区（available_endpoint=0：TraeCode/TraeWork 均可用）
+            if (generalTotal != null || generalPacks.isNotEmpty()) {
+                TraeSectionRow(generalTitle, generalTotal)
+                generalPacks.forEach { p ->
+                    Text(
+                        text = traePackLine(p, unlimitedLabel, remainingFmt),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = inkMuted()
+                    )
+                }
+            }
+            // Work 专属积分区（available_endpoint=1：仅 TraeWork 可用）
+            if (workTotal != null || workPacks.isNotEmpty()) {
+                TraeSectionRow(workTitle, workTotal)
+                workPacks.forEach { p ->
+                    Text(
+                        text = traePackLine(p, unlimitedLabel, remainingFmt),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = inkMuted()
+                    )
+                }
+            }
+        }
+    }
+}
+
+/** 分区标题行：左侧分区名，右侧小计（通用/Work 专属各一组）。 */
+@Composable
+private fun TraeSectionRow(title: String, total: Double?) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.SpaceBetween
+    ) {
+        Text(
+            text = title,
+            style = MaterialTheme.typography.labelMedium,
+            fontWeight = FontWeight.Medium
+        )
+        if (total != null) {
+            Text(
+                text = formatAmount(total),
+                style = MaterialTheme.typography.labelMedium,
+                fontWeight = FontWeight.Medium
+            )
+        }
+    }
+}
+
+/** 单个权益包的展示行文案（剩余/总额/已用，或无限额度）。 */
+private fun traePackLine(p: PackLine, unlimitedLabel: String, remainingFmt: String): String =
+    if (p.unlimited) {
+        "${p.name}: $unlimitedLabel"
+    } else {
+        val limitStr = p.limit?.toString() ?: "?"
+        val usedStr = p.used?.let { formatAmount(it) } ?: "?"
+        val remStr = p.remaining?.let { formatAmount(it) } ?: "?"
+        "${p.name}: " + String.format(Locale.US, remainingFmt, remStr, limitStr, usedStr)
+    }
+
+/** Trae 单个权益包展示行。 */
+private data class PackLine(
+    val name: String,
+    val limit: Long?,
+    val used: Double?,
+    val remaining: Double?,
+    val unlimited: Boolean,
+    val isWork: Boolean
+)
+
+/**
+ * Trae 账户信息卡：只展示对用户有意义的账户级指标（总积分/已消耗/消耗比例/权益包数），
+ * 原始布尔键（is_credits_billing / is_dollar_usage_billing）合并为一行「计费方式」，
+ * is_new_user 仅在为新用户时展示。数据缺失的行自动隐藏；无任何数据时整卡不渲染。
+ */
+@Composable
+internal fun TraeAccountInfoCard(state: State) {
+    val balance = when (state) {
+        is State.Fresh -> state.data
+        is State.Stale -> state.data
+        is State.Error -> state.cached
+        else -> null
+    }
+    val extras = balance?.extras ?: return
+
+    val unit = balance.unit
+    val rows = buildList {
+        extras["total_credits"]?.let {
+            add(stringResource(R.string.extra_label_total_credits) to "$it $unit")
+        }
+        extras["consumed_credits"]?.let {
+            add(stringResource(R.string.extra_label_consumed_credits) to "$it $unit")
+        }
+        extras["consumption_ratio"]?.toDoubleOrNull()?.let {
+            add(stringResource(R.string.extra_label_consumption_ratio) to "%.1f%%".format(it * 100))
+        }
+        extras["pack_count"]?.toIntOrNull()?.takeIf { it > 0 }?.let {
+            add(stringResource(R.string.extra_label_pack_count) to it.toString())
+        }
+        // 计费方式：两个英文布尔键合并为一行自然语言
+        val billingLabel = 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
+        }
+        billingLabel?.let {
+            add(stringResource(R.string.extra_label_billing_mode) to it)
+        }
+        if (extras["is_new_user"] == "true") {
+            add(stringResource(R.string.extra_label_is_new_user) to stringResource(R.string.extra_value_yes))
+        }
+    }
+    if (rows.isEmpty()) return
+
+    AccountInfoCard(title = stringResource(R.string.detail_account_info_title), rows = rows)
+}
+
+/**
+ * WorkBuddy 资源卡：按官网个人中心语义分区展示结构化包明细（extras["wb_detail_raw"]）。
+ *
+ *  - 「套餐积分」区：订阅套餐包，展示 已用/总量 + 剩余 + 下次权益周期更新时间；
+ *  - 「平台奖励积分」区：奖励类包，展示 可用数量 · 剩余合计，各行带到期时间；
+ *  - 「账户信息」区：套餐数/冻结/付费用户/订阅状态。
+ *
+ * 旧缓存无 wb_detail_raw 时回退为「资源 #007」简化行。无任何数据时整卡不渲染。
+ */
+@Composable
+internal fun WorkBuddyResourcesCard(state: State) {
+    val balance = when (state) {
+        is State.Fresh -> state.data
+        is State.Stale -> state.data
+        is State.Error -> state.cached
+        else -> null
+    }
+    val extras = balance?.extras ?: return
+    val unit = balance.unit
+    val packs = remember(extras) { parseWorkBuddyPacks(extras[WorkBuddyRepository.KEY_DETAIL_RAW]) }
+    // 套餐包编码：优先用仓库算好的 KEY_PLAN_CODE；旧数据回退到 summary 的 subscription_code
+    val planCode = extras[WorkBuddyRepository.KEY_PLAN_CODE]
+        ?: extras["subscription_code"].orEmpty()
+
+    // 分区：套餐积分 vs 平台奖励积分（依据 PackageCode 分组，与官网个人中心口径一致）
+    // 账户信息（frozen/付费/订阅）已并入主余额卡 MainBalanceCard
+    if (packs.isEmpty()) return
+    val planPacks = if (planCode.isNotBlank()) packs.filter { it.code == planCode } else emptyList()
+    val rewardPacks = packs - planPacks.toSet()
+    val planTotal = planPacks.sumOf { it.remain }
+
+    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(16.dp),
+            verticalArrangement = Arrangement.spacedBy(5.dp)
+        ) {
+            // ── 套餐积分：已用/总量 + 剩余 + 周期结束时间 ──
+            if (planPacks.isNotEmpty()) {
+                Text(
+                    text = stringResource(R.string.wb_plan_title),
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.SemiBold
+                )
+                InfoRow(
+                    label = stringResource(R.string.wb_plan_used_total),
+                    value = "${formatAmount(planPacks.sumOf { it.used })} / ${formatAmount(planPacks.sumOf { it.total })} $unit"
+                )
+                InfoRow(
+                    label = stringResource(R.string.extra_label_remaining),
+                    value = "${formatAmount(planTotal)} $unit"
+                )
+                planPacks.firstNotNullOfOrNull { it.cycleEnd }?.let {
+                    InfoRow(label = stringResource(R.string.wb_plan_next_reset), value = it)
+                }
+                Spacer(modifier = Modifier.height(6.dp))
+            }
+
+            // ── 平台奖励积分：逐行列出到期时间 + 剩余 ──
+            if (rewardPacks.isNotEmpty()) {
+                Text(
+                    text = stringResource(R.string.wb_reward_title),
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.SemiBold
+                )
+                rewardPacks
+                    .sortedWith(compareBy({ it.expireAt == null }, { it.expireAt ?: "" }))
+                    .forEachIndexed { index, p ->
+                        val label = p.expireAt?.let {
+                            stringResource(R.string.wb_reward_expire, it)
+                        } ?: stringResource(R.string.wb_reward_item, index + 1)
+                        InfoRow(label = label, value = "${formatAmount(p.remain)} $unit")
+                    }
+                Spacer(modifier = Modifier.height(6.dp))
+            }
+        }
+    }
+}
+
+/** WorkBuddy 单个资源包（结构化明细行）。 */
+private data class WbPack(
+    val code: String,
+    val name: String,
+    val remain: Double,
+    val used: Double,
+    val total: Double,
+    /** 周期结束时间（CycleEndTime，形如 "2026-09-30 23:59:59"） */
+    val cycleEnd: String?,
+    /** 到期时间（ExpiredTime；null=未到期） */
+    val expireAt: String?,
+    /** 0=生效中，3=已过期（服务端枚举，其余值按未知处理） */
+    val status: Int
+) {
+    val cycleReset: String? get() = cycleEnd
+}
+
+/** 解析 extras[KEY_DETAIL_RAW]（WorkBuddyRepository 序列化的账户明细 JSON 数组）。 */
+private fun parseWorkBuddyPacks(raw: String?): List<WbPack> {
+    if (raw.isNullOrBlank()) return emptyList()
+    return runCatching {
+        Json.parseToJsonElement(raw).jsonArray.mapNotNull { el ->
+            val o = el as? JsonObject ?: return@mapNotNull null
+            WbPack(
+                code = o["code"]?.jsonPrimitive?.contentOrNull.orEmpty(),
+                name = o["name"]?.jsonPrimitive?.contentOrNull.orEmpty(),
+                remain = o["remain"]?.jsonPrimitive?.doubleOrNull ?: return@mapNotNull null,
+                used = o["used"]?.jsonPrimitive?.doubleOrNull ?: 0.0,
+                total = o["total"]?.jsonPrimitive?.doubleOrNull ?: 0.0,
+                cycleEnd = o["cycleEnd"]?.jsonPrimitive?.contentOrNull?.takeIf { it.isNotBlank() },
+                expireAt = o["expiredAt"]?.jsonPrimitive?.contentOrNull?.takeIf { it.isNotBlank() },
+                status = o["status"]?.jsonPrimitive?.doubleOrNull?.toInt() ?: -1
+            )
+        }
+    }.getOrDefault(emptyList())
+}
+
+/** 通用「账户信息」卡：标题 + 左灰标签/右强调值 行列表。 */
+@Composable
+private fun AccountInfoCard(title: String, rows: List<Pair<String, String>>) {
+    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(16.dp),
+            verticalArrangement = Arrangement.spacedBy(5.dp)
+        ) {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.SemiBold
+            )
+            rows.forEach { (label, value) -> InfoRow(label = label, value = value) }
+        }
+    }
+}
+
+/** 明细行：左标签（灰）+ 右值（强调，右对齐），避免「key: value」裸奔样式。 */
+@Composable
+private fun InfoRow(label: String, value: String) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodySmall,
+            color = inkMuted(),
+            modifier = Modifier.weight(1f)
+        )
+        Text(
+            text = value,
+            style = MaterialTheme.typography.bodySmall,
+            fontWeight = FontWeight.Medium,
+            textAlign = TextAlign.End
+        )
+    }
+}
+
 /**
  * 通用明细卡：把 balance.extras 中的友好键逐行展示（Trae 权益包 / WorkBuddy 资源 /
  * Sub2API 账户等）。技术键（models / reset* / raw 等）一律过滤。
+ *
+ * 已知技术键（consumed_credits / pack_count / is_paid_user 等）映射为本地化标签；
+ * 未知键（权益包名等，由服务端按用户 locale 返回）原样展示。
  */
 @Composable
 internal fun GenericExtrasCard(state: State) {
@@ -1157,7 +1706,11 @@ internal fun GenericExtrasCard(state: State) {
     val extras = balance?.extras ?: return
     val friendly = extras.filterKeys { key ->
         val k = key.lowercase()
-        !k.contains("models") &&
+        // entitlement.* 键由 TraePacksCard 专门拆开渲染，不得进入通用卡
+        !k.startsWith("entitlement.") &&
+            // 通用/Work 专属小计由 TraePacksCard 分区标题展示，避免重复
+            k != "general_credits" && k != "work_credits" &&
+            !k.contains("models") &&
             !k.contains("reset") &&
             !k.contains("raw") &&
             !k.endsWith(".unlimited") &&
@@ -1165,6 +1718,38 @@ internal fun GenericExtrasCard(state: State) {
             !k.endsWith(".limit")
     }
     if (friendly.isEmpty()) return
+
+    val yesLabel = stringResource(R.string.extra_value_yes)
+    val noLabel = stringResource(R.string.extra_value_no)
+    val labelMap = mapOf(
+        "total_credits" to stringResource(R.string.extra_label_total_credits),
+        "consumed_credits" to stringResource(R.string.extra_label_consumed_credits),
+        "consumption_ratio" to stringResource(R.string.extra_label_consumption_ratio),
+        "pack_count" to stringResource(R.string.extra_label_pack_count),
+        "is_credits_billing" to stringResource(R.string.extra_label_is_credits_billing),
+        "is_dollar_usage_billing" to stringResource(R.string.extra_label_is_dollar_usage_billing),
+        "is_new_user" to stringResource(R.string.extra_label_is_new_user),
+        "packages" to stringResource(R.string.extra_label_packages),
+        "frozen" to stringResource(R.string.extra_label_frozen),
+        "is_paid_user" to stringResource(R.string.extra_label_is_paid_user),
+        "subscription" to stringResource(R.string.extra_label_subscription)
+    )
+    val knownOrder = listOf(
+        "total_credits", "consumed_credits", "consumption_ratio", "pack_count",
+        "is_credits_billing", "is_dollar_usage_billing", "is_new_user",
+        "packages", "frozen", "is_paid_user", "subscription"
+    )
+    val sorted = friendly.entries.sortedWith { a, b ->
+        val ai = knownOrder.indexOf(a.key)
+        val bi = knownOrder.indexOf(b.key)
+        when {
+            ai >= 0 && bi < 0 -> -1
+            ai < 0 && bi >= 0 -> 1
+            ai >= 0 && bi >= 0 -> ai.compareTo(bi)
+            else -> a.key.compareTo(b.key)
+        }
+    }
+
     Card(
         modifier = Modifier.fillMaxWidth(),
         shape = RoundedCornerShape(20.dp),
@@ -1180,9 +1765,11 @@ internal fun GenericExtrasCard(state: State) {
                 style = MaterialTheme.typography.titleSmall,
                 fontWeight = FontWeight.SemiBold
             )
-            friendly.forEach { (key, value) ->
+            sorted.forEach { (key, value) ->
+                val label = labelMap[key] ?: key
+                val formatted = formatExtraValue(key, value, yesLabel, noLabel)
                 Text(
-                    text = "$key: $value",
+                    text = "$label: $formatted",
                     style = MaterialTheme.typography.bodySmall,
                     color = inkMuted()
                 )
@@ -1191,6 +1778,21 @@ internal fun GenericExtrasCard(state: State) {
     }
 }
 
+/** 格式化 extras 值：布尔 → 是/否，比例 → 百分比，其余原样。 */
+private fun formatExtraValue(
+    key: String,
+    value: String,
+    yes: String,
+    no: String
+): String = when (key) {
+    "is_credits_billing", "is_dollar_usage_billing", "is_new_user",
+    "is_paid_user", "subscription" ->
+        if (value.equals("true", ignoreCase = true)) yes else no
+    "consumption_ratio" ->
+        value.toDoubleOrNull()?.let { "%.1f%%".format(it * 100) } ?: value
+    else -> value
+}
+
 @Composable
 private fun ErrorCard(message: String) {
     Card(

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

@@ -7,11 +7,14 @@ 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
@@ -32,12 +35,20 @@ class ServiceDetailViewModel @Inject constructor(
     private val credentialRepository: CredentialRepository,
     private val balanceCache: BalanceCache,
     private val refreshBalanceUseCase: RefreshBalanceUseCase,
-    private val workBuddyRepository: com.rainy.token.data.repository.WorkBuddyRepository,
-    private val traeRepository: com.rainy.token.data.repository.TraeRepository,
+    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()
 
@@ -57,32 +68,138 @@ class ServiceDetailViewModel @Inject constructor(
     private val _checkinState = MutableStateFlow<CheckinState>(CheckinState.Idle)
     val checkinState: StateFlow<CheckinState> = _checkinState.asStateFlow()
 
-    /** 触发每日签到：仅 WORKBUDDY / TRAE 有效；结果消息来自官方响应语义。 */
+    /**
+     * 进入详情页时预取的「今日签到信息」（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
+        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 -> workBuddyRepository.checkIn().fold(
+                ServiceType.WORKBUDDY -> refreshBalanceUseCase.checkInWorkBuddy(accountId).fold(
                     onSuccess = { s ->
-                        CheckinState.Done(
-                            s.message.ifBlank {
-                                if (s.todayCheckedIn) "今日已签到（连签 " + s.streakDays + " 天）" else "签到成功"
+                        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))
+                        }
                     },
-                    onFailure = { e -> CheckinState.Error(e.message ?: "签到失败，请检查凭据") }
+                    // RepositoryError.message 是硬编码中文，必须走 errorMessage() 本地化映射
+                    onFailure = { e -> CheckinState.Error(errorMessage(e)) }
                 )
-                ServiceType.TRAE -> traeRepository.checkIn().fold(
-                    onSuccess = { r -> CheckinState.Done(r.message) },
-                    onFailure = { e -> CheckinState.Error(e.message ?: "签到失败，请检查凭据") }
+                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("该服务不支持签到")
+                else -> CheckinState.Error(UiText.Resource(R.string.checkin_unsupported))
+            }
+            if (generation == serviceGeneration) {
+                _checkinState.value = result
+                // 签到成功后刷新「今日已签到/连签」摘要，让按钮态即时更新
+                if (result is CheckinState.Done) preloadCheckinInfo(service, accountId)
             }
-            if (generation == serviceGeneration) _checkinState.value = result
         }
     }
 
@@ -113,7 +230,7 @@ class ServiceDetailViewModel @Inject constructor(
         val generation = ++panelWindowStatsGeneration
         _panelWindowStats.value = PanelWindowStatsState.Loading
         viewModelScope.launch {
-            val result = sub2ApiRepository.fetchWindowModelStats(from, to)
+            val result = sub2ApiRepository.fetchWindowModelStats(from, to, _accountId.value)
             // 过时结果（用户已切换到别的窗口）直接丢弃，不写状态
             if (generation != panelWindowStatsGeneration) return@launch
             result.fold(
@@ -128,7 +245,52 @@ class ServiceDetailViewModel @Inject constructor(
     fun loadPanelGroups() {
         viewModelScope.launch {
             if (_panelGroups.value.isNotEmpty()) return@launch
-            sub2ApiRepository.fetchPanelGroups().onSuccess { _panelGroups.value = it }
+            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 用量失败") }
+            )
         }
     }
 
@@ -137,7 +299,7 @@ class ServiceDetailViewModel @Inject constructor(
         viewModelScope.launch {
             if (_panelKeysState.value is PanelKeysState.Loading) return@launch
             _panelKeysState.value = PanelKeysState.Loading
-            sub2ApiRepository.fetchPanelKeys().fold(
+            sub2ApiRepository.fetchPanelKeys(_accountId.value).fold(
                 onSuccess = { list -> _panelKeysState.value = PanelKeysState.Success(list) },
                 onFailure = { e -> _panelKeysState.value = PanelKeysState.Error(e.message ?: "加载 Key 列表失败") }
             )
@@ -152,7 +314,7 @@ class ServiceDetailViewModel @Inject constructor(
 
     fun createPanelKey(name: String, groupId: Long?) {
         viewModelScope.launch {
-            sub2ApiRepository.createPanelKey(name, groupId).fold(
+            sub2ApiRepository.createPanelKey(name, groupId, _accountId.value).fold(
                 onSuccess = { key ->
                     _recentlyCreatedKey.value = key
                     _panelActionMessage.value = "已创建 Key：" + maskPanelKey(key) + "（请在弹出的窗口复制完整 Key）"
@@ -165,7 +327,7 @@ class ServiceDetailViewModel @Inject constructor(
 
     fun switchPanelGroup(keyId: Long, groupId: Long) {
         viewModelScope.launch {
-            sub2ApiRepository.updatePanelKey(keyId, groupId).fold(
+            sub2ApiRepository.updatePanelKey(keyId, groupId, accountId = _accountId.value).fold(
                 onSuccess = {
                     _panelActionMessage.value = "分组已切换"
                     loadPanelKeys()
@@ -177,10 +339,10 @@ class ServiceDetailViewModel @Inject constructor(
 
     fun redeemPanelCode(code: String) {
         viewModelScope.launch {
-            sub2ApiRepository.redeemPanelCode(code).fold(
+            sub2ApiRepository.redeemPanelCode(code, _accountId.value).fold(
                 onSuccess = { msg ->
                     _panelActionMessage.value = msg
-                    refreshBalanceUseCase(ServiceType.SUB2API)
+                    refreshBalanceUseCase(ServiceType.SUB2API, _accountId.value)
                     loadPanelKeys()
                 },
                 onFailure = { e -> _panelActionMessage.value = "兑换失败：" + (e.message ?: "") }
@@ -237,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
@@ -314,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) }
 
@@ -338,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
 
@@ -531,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)
@@ -540,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(
@@ -555,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())
@@ -571,16 +757,17 @@ class ServiceDetailViewModel @Inject constructor(
                 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)
@@ -594,7 +781,10 @@ class ServiceDetailViewModel @Inject constructor(
                         UiText.Resource(R.string.error_credential_not_configured),
                         RepositoryError.InvalidCredential()
                     )
-                cached != null && status.state == CredentialStatus.State.OK ->
+                // OK 与 WARNING 都视为「凭据可用」：WARNING 仅是提示建议重新验证（如面板登录较久），
+                // 凭据仍有效，不应误报为「未配置或已过期」——否则能正常刷新余额却显示错误。
+                cached != null && (status.state == CredentialStatus.State.OK ||
+                    status.state == CredentialStatus.State.WARNING) ->
                     // 缓存新鲜（≤5 分钟）时视为最新数据直接展示，避免"刚刷新完进详情却显示缓存"的困惑
                     if (isCacheFresh(cached.fetchedAt)) {
                         State.Fresh(cached.balance)
@@ -696,6 +886,8 @@ class ServiceDetailViewModel @Inject constructor(
             _serviceType.value != type
 
     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 ->
@@ -750,11 +942,22 @@ class ServiceDetailViewModel @Inject constructor(
 }
 
 /** 每日签到 UI 状态。 */
+/** 每日签到 UI 状态。消息用 [UiText] 承载，由 UI 层按当前 Locale 解析（支持多语言）。 */
 sealed class CheckinState {
     data object Idle : CheckinState()
     data object Loading : CheckinState()
-    data class Done(val message: String) : CheckinState()
-    data class Error(val message: String) : 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 列表状态。 */
@@ -777,6 +980,19 @@ sealed class 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()

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

@@ -5,6 +5,7 @@ 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
@@ -242,21 +243,44 @@ internal fun Sub2ApiPanelManagement(
                                         overflow = TextOverflow.Ellipsis
                                     )
                                 }
-                                TextButton(onClick = {
-                                    copyToClipboard(context, key.key, copiedToast)
-                                }) { Text(stringResource(R.string.action_copy), style = MaterialTheme.typography.labelSmall) }
-                                if (groups.isNotEmpty()) {
-                                    TextButton(onClick = { switchForKeyId = key.id }) {
-                                        Text(stringResource(R.string.sub2_panel_group_column), style = MaterialTheme.typography.labelSmall)
+                                // 三个操作紧凑排布（用户反馈「间隔有点宽」）。
+                                // 注意：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)
+                                        )
                                     }
-                                }
-                                // 删除：用图标而非文字，避免一行挤下三个按钮在窄屏折行
-                                IconButton(onClick = { deleteForKeyId = key.id }) {
+                                    // 删除：用图标而非文字，避免一行挤下三个按钮在窄屏折行
                                     Icon(
                                         imageVector = Icons.Filled.Delete,
                                         contentDescription = stringResource(R.string.action_delete),
                                         tint = MaterialTheme.colorScheme.error,
-                                        modifier = Modifier.size(18.dp)
+                                        modifier = Modifier
+                                            .clip(RoundedCornerShape(4.dp))
+                                            .clickable { deleteForKeyId = key.id }
+                                            .padding(2.dp)
+                                            .size(18.dp)
                                     )
                                 }
                             }

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

@@ -1,14 +1,18 @@
 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
@@ -20,6 +24,7 @@ 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
@@ -29,10 +34,12 @@ 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
@@ -65,7 +72,10 @@ internal fun Sub2ApiUsageCard(
     onLoadWindowModelStats: ((from: LocalDate, to: LocalDate) -> Unit)? = null,
     /** 「今天」窗口的按小时趋势；非空时用小时柱替代按天柱（按天只有一根柱没有信息量）。 */
     hourlyTrend: List<Sub2DailyUsage> = emptyList(),
-    onLoadHourlyTrend: (() -> Unit)? = null
+    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
@@ -104,6 +114,8 @@ internal fun Sub2ApiUsageCard(
             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)) {
@@ -125,7 +137,10 @@ internal fun Sub2ApiUsageCard(
 
             // 「今天」改为按小时展示：只有一根按天柱子看不出分布，故拉当天小时趋势
             LaunchedEffect(window) {
-                if (window == Sub2Window.TODAY) onLoadHourlyTrend?.invoke()
+                if (window == Sub2Window.TODAY) {
+                    val (from, _) = window.range()
+                    onLoadHourlyTrend?.invoke(from)
+                }
             }
             // 小时数据只在「今天」窗口且拿到 ≥2 个小时桶时才用。
             // 实测面板可能把整天聚合成单个 "00:00" 桶（时区/活动量原因），
@@ -140,6 +155,14 @@ internal fun Sub2ApiUsageCard(
                     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(
@@ -248,15 +271,26 @@ internal fun Sub2ApiUsageCard(
                         )
                     }
 
-                    // 每日明细只在按天且有数据时列出（按小时时逐小时列会过长）
-                    if (!isHourly) {
-                        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))
+                    // 每日/每小时明细列表
+                    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) {
@@ -270,7 +304,7 @@ internal fun Sub2ApiUsageCard(
                 }
             }
 
-            // ── 按模型统计（整卡始终展示，数据随所选时间周期变化）──
+            // ── 明细分区：「按模型 / 按 Key」两个 tab（数据都随所选时间周期变化）──
             val statsLoading = window != Sub2Window.ALL &&
                 (windowStatsState is PanelWindowStatsState.Idle || windowStatsState is PanelWindowStatsState.Loading)
             val statsError = (windowStatsState as? PanelWindowStatsState.Error)?.message
@@ -278,63 +312,79 @@ internal fun Sub2ApiUsageCard(
             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(14.dp))
-                Text(
-                    text = stringResource(R.string.sub2_models_header) +
-                        if (windowStatsAllTime) stringResource(R.string.sub2_models_alltime_suffix) else "",
-                    style = MaterialTheme.typography.labelLarge,
-                    color = inkMuted()
-                )
-                Spacer(modifier = Modifier.height(8.dp))
+                Spacer(modifier = Modifier.height(10.dp))
 
-                // 模型筛选 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) }
-                        )
-                    }
+                // 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(8.dp))
+                Spacer(modifier = Modifier.height(12.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)
+                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)
+                                    )
+                                }
                             }
                         }
                     }
@@ -344,6 +394,90 @@ internal fun Sub2ApiUsageCard(
     }
 }
 
+/** 明细分区 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),

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/CredentialEditScreen.kt

@@ -53,6 +53,8 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
 import kotlinx.coroutines.delay
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
@@ -78,13 +80,18 @@ import com.rainy.token.domain.service.ServiceType
 @Composable
 fun CredentialEditScreen(
     service: ServiceType,
+    accountId: String? = null,
     onBack: () -> Unit,
-    onStartWebViewLogin: (ServiceType) -> Unit,
+    onStartWebViewLogin: (ServiceType, String?) -> Unit,
     onWebViewLoginSuccess: (ServiceType) -> Unit,
     onStartCodexOAuth: () -> Unit = {},
     viewModel: CredentialEditViewModel = hiltViewModel()
 ) {
-    LaunchedEffect(service) { viewModel.bind(service) }
+    LaunchedEffect(service, accountId) { viewModel.bind(service, accountId) }
+    // 从 WebView 登录页返回时，登录流程可能已改写当前账号凭据，重载表单
+    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
+        viewModel.reload()
+    }
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
     val snackbarHostState = remember { SnackbarHostState() }
     val context = LocalContext.current
@@ -100,10 +107,23 @@ fun CredentialEditScreen(
         }
     }
 
+    // 多账号服务：标题带账号名（新建账号尚无 ID 时也提示是「新账号」）
+    val titleText = when {
+        ServiceType.isMultiAccount(service) && uiState.accountId != null ->
+            stringResource(
+                R.string.service_detail_title_with_account,
+                service.displayName,
+                uiState.accountLabel ?: stringResource(R.string.account_fallback_name, uiState.accountIndex)
+            )
+        ServiceType.isMultiAccount(service) && !uiState.hasExisting ->
+            stringResource(R.string.account_new_credential_title, service.displayName)
+        else -> service.displayName
+    }
+
     Scaffold(
         topBar = {
             TopAppBar(
-                title = { Text(service.displayName) },
+                title = { Text(titleText) },
                 navigationIcon = {
                     IconButton(onClick = onBack) {
                         Icon(Icons.Filled.ArrowBack, contentDescription = stringResource(R.string.action_back))
@@ -134,9 +154,12 @@ fun CredentialEditScreen(
                     TraeCredentialForm(
                         jwt = uiState.traeJwt,
                         region = uiState.traeRegion,
+                        checkinDeviceId = uiState.traeCheckinDeviceId,
                         hasExisting = uiState.hasExisting,
                         onJwtChange = viewModel::updateTraeJwt,
                         onRegionChange = viewModel::updateTraeRegion,
+                        onCheckinDeviceIdChange = viewModel::updateTraeCheckinDeviceId,
+                        onStartInAppLogin = { onStartWebViewLogin(ServiceType.TRAE, accountId) },
                         onSave = viewModel::saveTraeCredential
                     )
                 } else if (service == ServiceType.WORKBUDDY) {
@@ -146,6 +169,7 @@ fun CredentialEditScreen(
                         hasExisting = uiState.hasExisting,
                         onAccessChange = viewModel::updateWorkBuddyAccess,
                         onRefreshChange = viewModel::updateWorkBuddyRefresh,
+                        onStartInAppLogin = { onStartWebViewLogin(ServiceType.WORKBUDDY, accountId) },
                         onSave = viewModel::saveWorkBuddyCredential
                     )
                 } else if (service == ServiceType.SUB2API) {
@@ -243,6 +267,7 @@ fun CredentialEditScreen(
                                 onImportFromClipboard = { viewModel.importFromClipboard(context) },
                                 onCopyLoginUrl = { copyToClipboard(context, uiState.loginUrl) },
                                 onOpenLoginUrl = { openInBrowser(context, uiState.loginUrl) },
+                                onStartInAppLogin = { onStartWebViewLogin(ServiceType.OPENCODE_GO, accountId) },
                                 onShowHelp = { showGoHelp = true },
                                 onApiKeyChange = viewModel::updateTriggerApiKey,
                                 onSaveApiKey = { viewModel.saveTriggerApiKey() }
@@ -486,6 +511,7 @@ private fun OpenCodeGoForm(
     onImportFromClipboard: () -> Unit,
     onCopyLoginUrl: () -> Unit,
     onOpenLoginUrl: () -> Unit,
+    onStartInAppLogin: () -> Unit,
     onShowHelp: () -> Unit,
     onApiKeyChange: (String) -> Unit,
     onSaveApiKey: () -> Unit
@@ -496,6 +522,10 @@ private fun OpenCodeGoForm(
         style = MaterialTheme.typography.bodySmall,
         color = MaterialTheme.colorScheme.outline
     )
+    // 主推入口：应用内登录自动抓 auth cookie + workspaceId，免手动开 DevTools 手抄
+    OutlinedButton(onClick = onStartInAppLogin, modifier = Modifier.fillMaxWidth()) {
+        Text(text = stringResource(R.string.action_login_in_app))
+    }
     OutlinedButton(onClick = onImportFromClipboard, modifier = Modifier.fillMaxWidth()) {
         Text(text = stringResource(R.string.action_import_from_clipboard))
     }
@@ -748,9 +778,12 @@ private fun ManualCookieForm(
 private fun TraeCredentialForm(
     jwt: String,
     region: String,
+    checkinDeviceId: String,
     hasExisting: Boolean,
     onJwtChange: (String) -> Unit,
     onRegionChange: (String) -> Unit,
+    onCheckinDeviceIdChange: (String) -> Unit,
+    onStartInAppLogin: () -> Unit,
     onSave: () -> Unit
 ) {
     Text(text = stringResource(R.string.credential_title_trae), style = MaterialTheme.typography.titleMedium)
@@ -759,6 +792,12 @@ private fun TraeCredentialForm(
         style = MaterialTheme.typography.bodySmall,
         color = MaterialTheme.colorScheme.outline
     )
+    OutlinedButton(
+        onClick = onStartInAppLogin,
+        modifier = Modifier.fillMaxWidth()
+    ) {
+        Text(stringResource(R.string.action_login_in_app))
+    }
     OutlinedTextField(
         value = jwt,
         onValueChange = onJwtChange,
@@ -784,11 +823,85 @@ private fun TraeCredentialForm(
             onSelect = { onRegionChange("INTL") }
         )
     }
+    OutlinedTextField(
+        value = checkinDeviceId,
+        onValueChange = onCheckinDeviceIdChange,
+        label = { Text(stringResource(R.string.field_trae_checkin_device_id)) },
+        supportingText = { Text(stringResource(R.string.field_trae_checkin_device_hint)) },
+        singleLine = true,
+        modifier = Modifier.fillMaxWidth()
+    )
+    var showDeviceIdGuide by remember { mutableStateOf(false) }
+    TextButton(onClick = { showDeviceIdGuide = true }) {
+        Text(stringResource(R.string.field_trae_device_id_howto))
+    }
+    if (showDeviceIdGuide) {
+        TraeDeviceIdGuideDialog(onDismiss = { showDeviceIdGuide = false })
+    }
     Button(onClick = onSave, enabled = jwt.isNotBlank(), modifier = Modifier.fillMaxWidth()) {
         Text(if (hasExisting) stringResource(R.string.action_update) else stringResource(R.string.action_save))
     }
 }
 
+/** 设备 ID 获取分步指引弹窗：面向不熟悉电脑操作的用户，含一键复制日志目录路径。 */
+@Composable
+private fun TraeDeviceIdGuideDialog(onDismiss: () -> Unit) {
+    val context = LocalContext.current
+    // 环境变量形式：Win+R 与资源管理器地址栏都能展开 %APPDATA%，相对路径在两处都打不开
+    val logPath = "%APPDATA%\\Trae CN\\logs"
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.field_trae_device_id_howto_title)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(10.dp)) {
+                Text(
+                    stringResource(R.string.field_trae_device_id_howto_step1),
+                    style = MaterialTheme.typography.bodyMedium
+                )
+                // 路径 + 一键复制（小白直接粘到资源管理器地址栏）
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(8.dp)
+                ) {
+                    Text(
+                        logPath,
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.weight(1f, fill = true)
+                    )
+                    TextButton(onClick = {
+                        val cm = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+                        cm.setPrimaryClip(ClipData.newPlainText("trae_log_path", logPath))
+                        // 复制反馈：小白需要确认复制成功（R.string 引用须在 composable 内解析）
+                        android.widget.Toast.makeText(
+                            context,
+                            context.getString(R.string.msg_path_copied),
+                            android.widget.Toast.LENGTH_SHORT
+                        ).show()
+                    }) {
+                        Text(stringResource(R.string.action_copy))
+                    }
+                }
+                Text(
+                    stringResource(R.string.field_trae_device_id_howto_step2),
+                    style = MaterialTheme.typography.bodyMedium
+                )
+                Text(
+                    stringResource(R.string.field_trae_device_id_howto_step3),
+                    style = MaterialTheme.typography.bodyMedium
+                )
+                Text(
+                    stringResource(R.string.field_trae_device_id_howto_step4),
+                    style = MaterialTheme.typography.bodyMedium
+                )
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.action_close)) }
+        }
+    )
+}
+
 @Composable
 private fun RegionButton(label: String, selected: Boolean, onSelect: () -> Unit) {
     OutlinedButton(onClick = onSelect) {
@@ -806,6 +919,7 @@ private fun WorkBuddyCredentialForm(
     hasExisting: Boolean,
     onAccessChange: (String) -> Unit,
     onRefreshChange: (String) -> Unit,
+    onStartInAppLogin: () -> Unit,
     onSave: () -> Unit
 ) {
     Text(text = stringResource(R.string.credential_title_workbuddy), style = MaterialTheme.typography.titleMedium)
@@ -814,6 +928,12 @@ private fun WorkBuddyCredentialForm(
         style = MaterialTheme.typography.bodySmall,
         color = MaterialTheme.colorScheme.outline
     )
+    OutlinedButton(
+        onClick = onStartInAppLogin,
+        modifier = Modifier.fillMaxWidth()
+    ) {
+        Text(stringResource(R.string.action_login_in_app))
+    }
     OutlinedTextField(
         value = access,
         onValueChange = onAccessChange,

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

@@ -40,7 +40,8 @@ import kotlinx.serialization.json.jsonPrimitive
 class CredentialEditViewModel @Inject constructor(
     private val credentialRepository: CredentialRepository,
     private val refreshBalanceUseCaseProvider: Provider<RefreshBalanceUseCase>,
-    private val sub2ApiRepository: Sub2ApiRepository
+    private val sub2ApiRepository: Sub2ApiRepository,
+    private val savedStateHandle: androidx.lifecycle.SavedStateHandle
 ) : ViewModel() {
 
     /** Sub2 站点信息探测（baseUrl 输入 debounce 后触发）。 */
@@ -52,25 +53,45 @@ class CredentialEditViewModel @Inject constructor(
 
     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) {
@@ -102,6 +123,7 @@ class CredentialEditViewModel @Inject constructor(
                     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(),
@@ -190,6 +212,8 @@ class CredentialEditViewModel @Inject constructor(
             }
             val err = result.exceptionOrNull()
             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 ->
@@ -279,6 +303,10 @@ class CredentialEditViewModel @Inject constructor(
         _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
@@ -288,17 +316,30 @@ class CredentialEditViewModel @Inject constructor(
             return
         }
         viewModelScope.launch {
-            val existing = credentialRepository.get(type) as? Credential.TraeCredential
-            credentialRepository.save(
+            // 新建账号模式（多账号服务 + 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()
         }
     }
 
@@ -322,19 +363,28 @@ class CredentialEditViewModel @Inject constructor(
             return
         }
         viewModelScope.launch {
-            val existing = credentialRepository.get(type) as? Credential.WorkBuddyCredential
-            credentialRepository.save(
+            // 新建账号模式（多账号服务 + 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()
         }
     }
 
@@ -419,7 +469,13 @@ class CredentialEditViewModel @Inject constructor(
         val email = current.sub2Email.trim()
         val password = current.sub2Password.trim()
         viewModelScope.launch {
-            val existing = credentialRepository.get(type) as? Credential.Sub2ApiCredential
+            // 新建账号模式（多账号服务 + 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 之一
@@ -427,7 +483,7 @@ class CredentialEditViewModel @Inject constructor(
                 _uiState.update { it.copy(message = UiText.Resource(R.string.error_sub2_required)) }
                 return@launch
             }
-            credentialRepository.save(
+            val effectiveId = credentialRepository.save(
                 (existing ?: Credential.Sub2ApiCredential(service = type, baseUrl = base, email = email, password = password))
                     .copy(
                         baseUrl = base,
@@ -437,8 +493,10 @@ class CredentialEditViewModel @Inject constructor(
                         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))
             }
@@ -766,10 +824,19 @@ 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(
+                    accountId = null,
+                    accountLabel = null,
+                    accountIndex = 0,
                     message = UiText.Resource(R.string.msg_credential_deleted),
                     hasExisting = false,
                     apiKey = "",
@@ -782,6 +849,7 @@ class CredentialEditViewModel @Inject constructor(
                     triggerApiKey = "",
                     traeJwt = "",
                     traeRegion = "CN",
+                    traeCheckinDeviceId = "",
                     workBuddyAccess = "",
                     workBuddyRefresh = "",
                     sub2BaseUrl = "",
@@ -793,10 +861,40 @@ class CredentialEditViewModel @Inject constructor(
         }
     }
 
+    /** 多账号服务：按当前账号 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
+                )
+            }
+        }
+    }
+
     fun clearMessage() {
         _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()
@@ -853,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 = "",
@@ -868,6 +972,8 @@ data class CredentialEditUiState(
     /** 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 = "",

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

@@ -54,6 +54,11 @@ 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
@@ -73,6 +78,7 @@ import com.rainy.token.util.LocaleManager
 fun SettingsScreen(
     onBack: () -> Unit,
     onEditCredential: (ServiceType) -> Unit,
+    onManageAccounts: (ServiceType) -> Unit = {},
     onOpenTips: () -> Unit = {},
     onOpenDebugLog: () -> Unit = {},
     viewModel: SettingsViewModel = hiltViewModel()
@@ -137,10 +143,17 @@ fun SettingsScreen(
                         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 {
@@ -152,6 +165,9 @@ fun SettingsScreen(
                 item {
                     DebugLogCard(onClick = { onOpenDebugLog() })
                 }
+                item {
+                    UpdateCard()
+                }
                 item {
                     Spacer(modifier = Modifier.padding(top = 8.dp))
                     AboutCard()
@@ -261,7 +277,11 @@ private fun LanguageDialog(onDismiss: () -> Unit) {
 }
 
 @Composable
-private fun CredentialStatusCard(status: CredentialStatus, onClick: () -> Unit) {
+private fun CredentialStatusCard(
+    status: CredentialStatus,
+    accountCount: Int = 0,
+    onClick: () -> Unit
+) {
     Card(
         modifier = Modifier
             .fillMaxWidth()
@@ -283,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)
@@ -294,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(

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

@@ -122,7 +122,7 @@ fun CodexOAuthScreen(
                         Text(
                             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(stringResource(R.string.action_retry), color = StrawberryPink)
@@ -286,7 +286,7 @@ private fun HeadlessOAuthContent(
             Text(
                 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) {

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,6 +29,8 @@ 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
@@ -33,6 +38,7 @@ 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
 
@@ -47,22 +53,34 @@ import com.rainy.token.ui.components.asString
 @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()
 ) {
     // configuredBaseUrl 可选：不传时 ViewModel 自行从凭据仓库读取（Sub2API 自托管实例）
-    LaunchedEffect(service, configuredBaseUrl) {
-        viewModel.bind(service, configuredBaseUrl)
+    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)
         }
     }
 
@@ -71,6 +89,7 @@ fun WebViewLoginScreen(
     }
 
     Scaffold(
+        snackbarHost = { SnackbarHost(snackbarHostState) },
         topBar = {
             TopAppBar(
                 title = { Text(stringResource(R.string.title_webview_login, service.displayName)) },
@@ -115,11 +134,44 @@ fun WebViewLoginScreen(
                             )
 
                             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 ?: return
                                     // 登录成功后面板会写入 localStorage.auth_token，抓到即自动保存
                                     view?.evaluateJavascript(viewModel.probeScript, null)
                                     viewModel.onPageFinished(url)
+                                    DebugLog.i("TraeLogin", "pageFinished: ${url.toSafeLogUrl()}")
                                 }
                             }
                             webChromeClient = WebChromeClient()
@@ -129,13 +181,12 @@ fun WebViewLoginScreen(
                     modifier = Modifier.fillMaxSize()
                 )
             } else {
-                Column(modifier = Modifier
-                    .fillMaxSize()
-                    .padding(16.dp)) {
-                    Text(
-                        text = stringResource(R.string.error_login_url_missing),
-                        style = MaterialTheme.typography.bodyLarge
-                    )
+                // loginUrl 为空 = ViewModel 正在生成授权地址（Trae/WorkBuddy 需要片刻）
+                Box(
+                    modifier = Modifier.fillMaxSize(),
+                    contentAlignment = Alignment.Center
+                ) {
+                    CircularProgressIndicator()
                 }
             }
         }
@@ -187,3 +238,19 @@ private fun parseProbeJson(json: String): Map<String, String> = runCatching {
         }
     }
 }.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

@@ -2,10 +2,27 @@ 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
@@ -18,32 +35,316 @@ 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 credentialRepository: com.rainy.token.data.repository.CredentialRepository
+    private val credentialRepository: CredentialRepository,
+    private val okHttpClient: OkHttpClient
 ) : ViewModel() {
 
     private val _uiState = MutableStateFlow(WebViewLoginUiState())
     val uiState: StateFlow<WebViewLoginUiState> = _uiState.asStateFlow()
 
-    /**
-     * @param configuredBaseUrl 用户已保存的自托管实例基址（Sub2API 用）。
-     *   用于把「可信 host」限定为用户自己配置的域名，登录过程中跳转到的第三方页面
-     *   无法借此写入凭据。
-     */
-    fun bind(service: ServiceType, configuredBaseUrl: String? = null) {
+    /** 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 = "",
+                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 ────────────────────────────────────────────────────────
+
+    /**
+     * 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())
         }
-        // Sub2API 是自托管实例：loginUrl 为空，登录入口与可信 host 都来自用户已保存的 baseUrl。
-        // 这里自己从凭据仓库取，避免每个导航调用点都要传一遍（漏传会直接导致登录页打不开）。
         viewModelScope.launch {
             val base = configuredBaseUrl
                 ?: (credentialRepository.get(service) as? Credential.Sub2ApiCredential)?.baseUrl
@@ -60,15 +361,30 @@ class WebViewLoginViewModel @Inject constructor(
         }
     }
 
-    /**
-     * 成功 URL 模式匹配（计划 4.1：精确匹配 + fallback）。
-     *
-     * 默认启发：URL 跳转到非登录域 + 路径不包含 /auth/login/signin 等关键词，
-     * 即认为登录完成。具体规则各服务可在 [ServiceConfigProvider] 扩展。
-     */
+    // ─── 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 {
@@ -77,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)
     }
@@ -85,45 +412,38 @@ class WebViewLoginViewModel @Inject constructor(
         _uiState.update { it.copy(pendingManualConfirm = false) }
     }
 
-    /**
-     * 面板登录成功后由 WebView 注入 JS 回调，把 localStorage 里的凭据回传。
-     *
-     * Sub2API 面板把登录态放在 localStorage.auth_token（JWT）；抓到即代表登录成功，
-     * 无需用户在设置页手工粘贴 token。
-     */
     fun onLocalStorageProbed(values: Map<String, String>) {
         val service = _uiState.value.service ?: return
         if (_uiState.value.loginSucceeded) return
-        // nonce 校验：拒绝非本次注入脚本发出的调用（防第三方页面伪造）
         if (!isValidProbe(values[SUB2_NONCE_KEY])) return
-        // 只有自托管面板走 localStorage 抓取；其余服务的登录态在 Cookie 里，
-        // 由 onPageFinished(真实带 path 的 URL) 负责，避免用 origin 查 Cookie 查不到而误报。
         if (service != ServiceType.SUB2API) return
         val token = values[SUB2_AUTH_TOKEN_KEY].orEmpty()
         if (token.isBlank()) return
         val origin = values[SUB2_ORIGIN_KEY].orEmpty()
-        // 防凭据投毒：登录容器会加载第三方页面（OAuth / CDN），它们同样能调到 JS 桥。
-        // 只有 origin 与用户配置的面板基址同源时才接受，避免被伪造的 auth_token 覆盖凭据。
         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]
+                email = values[SUB2_EMAIL_KEY],
+                accountId = this@WebViewLoginViewModel.accountId
             )
             if (saved != null) {
                 _uiState.update {
-                    it.copy(loginSucceeded = true, pendingManualConfirm = false, error = null)
+                    it.copy(
+                        loginSucceeded = true,
+                        pendingManualConfirm = false,
+                        error = null,
+                        // 回填实际写入的账号 ID：新建账号流程返回编辑页时保持编辑该账号，
+                        // 避免用户再次点保存产生重复账号
+                        loginAccountId = saved.accountId.ifBlank { null }
+                    )
                 }
             }
         }
     }
 
-    /**
-     * origin 是否可信：必须与用户填写/已知的面板基址同 host。
-     * 登录页会跳转到第三方域（OAuth、CDN），那些页面注入的脚本不应改写本地凭据。
-     */
     private fun isTrustedOrigin(origin: String): Boolean {
         val probeHost = origin.toHttpUrlOrNull()?.host ?: return false
         val allowed = _uiState.value.trustedHosts
@@ -131,17 +451,8 @@ class WebViewLoginViewModel @Inject constructor(
         return allowed.any { it.equals(probeHost, ignoreCase = true) }
     }
 
-    /**
-     * 每次会话的随机串，随探测脚本一起注入；回传时必须带上它才被接受。
-     * 登录容器会加载第三方页面（OAuth / CDN），仅靠「origin 同源校验」不足以防止
-     * 它们直接调用 JS 桥伪造 payload，nonce 让伪造者无法构造合法调用。
-     */
     private val probeNonce: String = java.util.UUID.randomUUID().toString().replace("-", "")
-
-    /** 探测脚本（注入 nonce，回传时会带回来校验）。 */
     val probeScript: String get() = buildProbeScript(probeNonce)
-
-    /** 校验回传是否来自本次注入的脚本。 */
     fun isValidProbe(nonce: String?): Boolean =
         nonce != null && nonce.isNotEmpty() && nonce == probeNonce
 
@@ -170,24 +481,40 @@ class WebViewLoginViewModel @Inject constructor(
 
     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()
+    }
 }
 
-/** 面板 localStorage 中承载登录态的键（与网页端一致）。 */
 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"
 
-/**
- * 在页面里读取面板登录态并回传。
- * 通过 window.AndroidBridge（由 WebView 注入）回调，避免 evaluateJavascript 的返回值在
- * onPageFinished 时机不可靠的问题。
- */
+/** OpenCode dashboard URL 中的 workspaceId：`/workspace/{id}/go`。 */
+private val OPENCODE_WORKSPACE_REGEX = Regex("""/workspace/([^/?#]+)/go""")
+
 internal fun buildProbeScript(nonce: String): String = """
 (function () {
   try {
@@ -212,10 +539,11 @@ internal fun buildProbeScript(nonce: String): String = """
 data class WebViewLoginUiState(
     val service: ServiceType? = null,
     val loginUrl: String = "",
-    /** 允许通过 JS 桥写入凭据的 host 白名单（来自用户配置的面板基址 / 登录 URL）。 */
     val trustedHosts: Set<String> = emptySet(),
     val loginSucceeded: Boolean = false,
     val savedSession: Credential.SessionCredential? = null,
     val pendingManualConfirm: Boolean = false,
-    val error: UiText? = null
+    val error: UiText? = null,
+    /** Trae/WorkBuddy 登录实际写入的账号 ID（新建账号模式时用于回填信用编辑页）。 */
+    val loginAccountId: String? = null
 )

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

@@ -8,11 +8,15 @@ 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
@@ -57,12 +61,15 @@ 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)
 
@@ -104,49 +111,78 @@ 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,
-                        localized.getString(R.string.widget_service_quota, selectedService.displayName)
+                    views.setViewVisibility(
+                        R.id.widget_ds_row,
+                        if (dsConfigured) View.VISIBLE else View.GONE
                     )
-                    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) {
-                        selectedHasCachedData = true
-                        populateServiceRows(views, localized, selectedService, cached.balance)
-
-                        val sdf = SimpleDateFormat("MM-dd HH:mm", Locale.getDefault())
-                        val timeText = sdf.format(Date(cached.fetchedAt))
+                    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_updated,
-                            localized.getString(R.string.widget_updated_at, timeText)
+                            R.id.widget_service_title,
+                            localized.getString(
+                                if (dsConfigured) R.string.widget_deepseek_balance
+                                else R.string.widget_not_configured
+                            )
                         )
-                    } else {
                         setEmptyState(views, localized)
+                    } else {
                         views.setTextViewText(R.id.widget_switch, shortName(selectedService))
                         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, localized)
@@ -156,8 +192,11 @@ class OpenCodeGoWidgetProvider : AppWidgetProvider() {
             appWidgetManager.updateAppWidget(widgetId, views)
         }
 
-        // 自动刷新：缓存为空 或 超过冷却时间 → 触发后台刷新
-        if (!selectedHasCachedData || shouldAutoRefresh(context)) {
+        // 自动刷新：有已配置服务且超过冷却时间 → 触发后台刷新。
+        // 缓存命中与否不参与决策——receiver 现在无条件重渲染，若以「缓存为空」为由
+        // 绕过冷却，刷新失败时会形成 onUpdate → 广播 → 失败 → 重渲染 → 再广播的
+        // 无冷却重试环；冷却约束是唯一的节流阀。
+        if ((configured.isNotEmpty() || dsConfigured) && shouldAutoRefresh(context)) {
             markAutoRefreshTime(context)
             context.sendBroadcast(WidgetRefreshReceiver.createIntent(context))
         }
@@ -300,9 +339,9 @@ 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))
     }
@@ -345,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()
         }
 

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/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,9 +12,9 @@
                 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>

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"
@@ -75,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" />
@@ -99,7 +99,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="@string/widget_title_opencode"
-            android:textColor="#C4A0AB"
+            android:textColor="#CBB8C0"
             android:textSize="11sp" />
     </LinearLayout>
 
@@ -113,10 +113,10 @@
         <TextView android:id="@+id/row1_label"
             android:layout_width="44dp" android:layout_height="wrap_content"
             android:maxLines="1" android:ellipsize="end"
-            android:text="5h" android:textColor="#C4A0AB" android:textSize="11sp" />
+            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"
@@ -126,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>
 
     <!-- 本周 -->
@@ -139,10 +139,10 @@
         <TextView android:id="@+id/row2_label"
             android:layout_width="44dp" android:layout_height="wrap_content"
             android:maxLines="1" android:ellipsize="end"
-            android:text="@string/window_weekly" android:textColor="#C4A0AB" android:textSize="11sp" />
+            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"
@@ -152,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>
 
     <!-- 本月 -->
@@ -165,10 +165,10 @@
         <TextView android:id="@+id/row3_label"
             android:layout_width="44dp" android:layout_height="wrap_content"
             android:maxLines="1" android:ellipsize="end"
-            android:text="@string/window_monthly" android:textColor="#C4A0AB" android:textSize="11sp" />
+            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"
@@ -178,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"
@@ -199,14 +200,14 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="@string/widget_deepseek_balance"
-            android:textColor="#C4A0AB"
+            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" />
@@ -232,7 +233,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="@string/widget_brand"
-            android:textColor="#8A7A82"
+            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"
@@ -69,7 +69,7 @@
             android:maxLines="1"
             android:ellipsize="end"
             android:text="--"
-            android:textColor="#C4A0AB"
+            android:textColor="#7A6870"
             android:textSize="10sp" />
 
         <TextView
@@ -77,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" />
@@ -105,7 +105,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="@string/widget_title_opencode"
-            android:textColor="#8A7A82"
+            android:textColor="#7A6870"
             android:textSize="11sp" />
     </LinearLayout>
 
@@ -120,11 +120,11 @@
         <TextView android:id="@+id/row1_label"
             android:layout_width="44dp" android:layout_height="wrap_content"
             android:maxLines="1" android:ellipsize="end"
-            android:text="5h" android:textColor="#8A7A82" android:textSize="11sp" />
+            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"
@@ -136,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>
 
     <!-- 本周 -->
@@ -150,11 +150,11 @@
         <TextView android:id="@+id/row2_label"
             android:layout_width="44dp" android:layout_height="wrap_content"
             android:maxLines="1" android:ellipsize="end"
-            android:text="@string/window_weekly" android:textColor="#8A7A82" android:textSize="11sp" />
+            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"
@@ -166,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>
 
     <!-- 本月 -->
@@ -180,11 +180,11 @@
         <TextView android:id="@+id/row3_label"
             android:layout_width="44dp" android:layout_height="wrap_content"
             android:maxLines="1" android:ellipsize="end"
-            android:text="@string/window_monthly" android:textColor="#8A7A82" android:textSize="11sp" />
+            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"
@@ -196,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"
@@ -220,7 +221,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="@string/widget_deepseek_balance"
-            android:textColor="#8A7A82"
+            android:textColor="#7A6870"
             android:textSize="11sp" />
 
         <TextView
@@ -228,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" />
@@ -257,7 +258,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="@string/widget_brand"
-            android:textColor="#D4C4CC"
+            android:textColor="#7A6870"
             android:textSize="9sp" />
     </LinearLayout>
 

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

@@ -42,7 +42,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="@string/widget_auto_refresh"
-            android:textColor="#C4A0AB"
+            android:textColor="#7A6870"
             android:textSize="10sp" />
     </LinearLayout>
 
@@ -64,7 +64,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="@string/widget_title_opencode"
-            android:textColor="#8A7A82"
+            android:textColor="#7A6870"
             android:textSize="11sp" />
     </LinearLayout>
 
@@ -79,11 +79,11 @@
         <TextView
             android:layout_width="44dp" android:layout_height="wrap_content"
             android:maxLines="1" android:ellipsize="end"
-            android:text="5h" android:textColor="#8A7A82" android:textSize="11sp" />
+            android:text="5h" android:textColor="#7A6870" android:textSize="11sp" />
 
         <TextView
             android:layout_width="38dp" android:layout_height="wrap_content"
-            android:text="42%" android:textColor="#3D2C35" android:textSize="12sp"
+            android:text="42%" android:textColor="#3A2B31" android:textSize="12sp"
             android:textStyle="bold" android:gravity="end" />
 
         <ProgressBar
@@ -91,7 +91,7 @@
             android:layout_width="0dp" android:layout_height="6dp"
             android:layout_weight="1" android:layout_marginStart="8dp"
             android:layout_marginEnd="8dp" android:max="100" android:progress="42"
-            android:progressTint="#FF85A2" />
+            android:progressTint="#C9436C" />
     </LinearLayout>
 
     <!-- 本周 -->
@@ -105,11 +105,11 @@
         <TextView
             android:layout_width="44dp" android:layout_height="wrap_content"
             android:maxLines="1" android:ellipsize="end"
-            android:text="@string/window_weekly" android:textColor="#8A7A82" android:textSize="11sp" />
+            android:text="@string/window_weekly" android:textColor="#7A6870" android:textSize="11sp" />
 
         <TextView
             android:layout_width="38dp" android:layout_height="wrap_content"
-            android:text="68%" android:textColor="#3D2C35" android:textSize="12sp"
+            android:text="68%" android:textColor="#3A2B31" android:textSize="12sp"
             android:textStyle="bold" android:gravity="end" />
 
         <ProgressBar
@@ -131,11 +131,11 @@
         <TextView
             android:layout_width="44dp" android:layout_height="wrap_content"
             android:maxLines="1" android:ellipsize="end"
-            android:text="@string/window_monthly" android:textColor="#8A7A82" android:textSize="11sp" />
+            android:text="@string/window_monthly" android:textColor="#7A6870" android:textSize="11sp" />
 
         <TextView
             android:layout_width="38dp" android:layout_height="wrap_content"
-            android:text="35%" android:textColor="#3D2C35" android:textSize="12sp"
+            android:text="35%" android:textColor="#3A2B31" android:textSize="12sp"
             android:textStyle="bold" android:gravity="end" />
 
         <ProgressBar
@@ -143,7 +143,7 @@
             android:layout_width="0dp" android:layout_height="6dp"
             android:layout_weight="1" android:layout_marginStart="8dp"
             android:layout_marginEnd="8dp" android:max="100" android:progress="35"
-            android:progressTint="#FF85A2" />
+            android:progressTint="#C9436C" />
     </LinearLayout>
 
     <!-- DeepSeek 余额 -->
@@ -165,14 +165,14 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="@string/widget_deepseek_balance"
-            android:textColor="#8A7A82"
+            android:textColor="#7A6870"
             android:textSize="11sp" />
 
         <TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="¥18.00"
-            android:textColor="#3D2C35"
+            android:textColor="#3A2B31"
             android:textSize="11sp"
             android:textStyle="bold"
             android:layout_marginStart="4dp" />

app/src/main/res/values-b+zh+Hans/strings.xml

@@ -18,6 +18,7 @@
     <string name="action_delete">删除</string>
     <string name="action_clear">清除</string>
     <string name="action_save">保存</string>
+    <string name="action_login_in_app">软件内登录</string>
     <string name="action_jump">跳转</string>
     <string name="action_prev_page">◀ 上一页</string>
     <string name="action_next_page">下一页 ▶</string>
@@ -45,22 +46,18 @@
     <string name="nav_empty_subtitle">点击左侧卡片即可</string>
     <string name="title_settings">设置</string>
     <string name="api_mgmt_title">API 管理</string>
-    <string name="api_mgmt_configure">配置</string>
-    <string name="api_mgmt_edit">编辑</string>
     <string name="api_mgmt_test">测试</string>
+    <string name="api_mgmt_add">添加 API Key</string>
+    <string name="api_mgmt_add_picker_title">添加服务</string>
+    <string name="api_mgmt_all_added">所有服务都已添加</string>
+    <string name="api_mgmt_empty_title">还没有添加任何 API</string>
+    <string name="api_mgmt_empty_body">点击右上角「+」添加一个 API Key</string>
     <string name="api_mgmt_delete_title">删除凭据？</string>
     <string name="api_mgmt_delete_body">将删除 %1$s 已保存的凭据。</string>
     <string name="api_mgmt_unconfigured">未配置</string>
+    <string name="api_mgmt_accounts_subtitle">%1$d 个账号 · 点按管理</string>
     <string name="api_mgmt_last_verified">最后验证：%1$s</string>
     <string name="api_mgmt_cached_balance">缓存余额：%1$s %2$s</string>
-    <string name="usage_stat_title">用量统计</string>
-    <string name="usage_stat_empty">暂无已配置服务</string>
-    <string name="usage_stat_failed">%1$d 项刷新失败</string>
-    <string name="usage_stat_never_fetched">尚未获取</string>
-    <string name="usage_stat_fetched_at">更新于 %1$s</string>
-    <string name="usage_stat_monthly_spent">本月消费</string>
-    <string name="usage_stat_total_quota">总额度</string>
-    <string name="usage_stat_next_reset">下次重置</string>
     <string name="api_mgmt_test_success">✅ %1$s 连接成功：%2$s %3$s</string>
     <string name="api_mgmt_test_fail">❌ %1$s 连接失败：%2$s</string>
     <string name="api_mgmt_err_invalid">凭据无效</string>
@@ -140,10 +137,50 @@
     <string name="service_desc_workbuddy">OAuth · CodeBuddy 同体系积分</string>
     <string name="service_desc_sub2api">自托管面板 · 用户级 sk- Key 余额</string>
     <string name="detail_extras_title">明细</string>
+    <string name="detail_account_info_title">账户信息</string>
+    <string name="detail_resources_title">资源明细</string>
+    <string name="wb_resource_label">资源 #%1$s</string>
+    <string name="wb_plan_title">套餐积分</string>
+    <string name="wb_plan_used_total">已用/总量</string>
+    <string name="wb_plan_in_use">使用中</string>
+    <string name="wb_plan_next_reset">下次权益周期更新</string>
+    <string name="wb_reward_title">平台奖励积分</string>
+    <string name="wb_reward_expire">到期：%1$s</string>
+    <string name="wb_reward_item">奖励包 %1$d</string>
+    <string name="extra_label_remaining">剩余</string>
+    <string name="extra_label_billing_mode">计费方式</string>
+    <string name="extra_value_billing_credits">积分</string>
+    <string name="extra_value_billing_dollar">美元</string>
+    <string name="extra_label_billing_mode_desc">%1$s计费</string>
+    <string name="extra_value_subscription_active">订阅中</string>
+    <string name="extra_value_paid_user">付费用户</string>
+    <string name="extra_value_free_user">免费用户</string>
+    <string name="extra_label_consumed_credits">已消耗</string>
+    <string name="extra_label_consumption_ratio">消耗比例</string>
+    <string name="extra_label_total_credits">总积分</string>
+    <string name="extra_label_pack_count">权益包</string>
+    <string name="extra_label_packages">套餐数</string>
+    <string name="extra_label_frozen">冻结</string>
+    <string name="extra_label_is_credits_billing">积分计费</string>
+    <string name="extra_label_is_dollar_usage_billing">美元计费</string>
+    <string name="extra_label_is_new_user">新用户</string>
+    <string name="extra_label_is_paid_user">付费用户</string>
+    <string name="extra_label_subscription">订阅</string>
+    <string name="extra_value_yes">是</string>
+    <string name="extra_value_no">否</string>
     <string name="credential_title_trae">Trae 凭据</string>
     <string name="credential_hint_trae">粘贴 Trae 登录态中的 Cloud-IDE-JWT（ey… 开头）。请求头按 Authorization: Cloud-IDE-JWT 发送。</string>
     <string name="field_trae_jwt">Cloud-IDE-JWT</string>
     <string name="field_trae_region">区域</string>
+    <string name="field_trae_checkin_device_id">签到设备 ID（可选）</string>
+    <string name="field_trae_checkin_device_hint">签到须使用官方客户端绑定的设备 ID。若持续失败，请在电脑客户端日志（AppData\\Roaming\\Trae CN\\logs\\日期目录\\main.log）中搜索 did=，将最新的值粘贴到此处。留空则使用内置默认。</string>
+    <string name="field_trae_device_id_howto">设备 ID 怎么找？（分步指引）</string>
+    <string name="msg_path_copied">路径已复制，粘贴到 Win+R 或文件资源管理器即可</string>
+    <string name="field_trae_device_id_howto_title">查找设备 ID（4 步）</string>
+    <string name="field_trae_device_id_howto_step1">1. 在电脑上按 Win+R，粘贴下面的路径后回车（或复制后粘贴到文件资源管理器地址栏）：</string>
+    <string name="field_trae_device_id_howto_step2">2. 打开文件夹名里日期最新的那个文件夹。</string>
+    <string name="field_trae_device_id_howto_step3">3. 用记事本打开 main.log。</string>
+    <string name="field_trae_device_id_howto_step4">4. 按 Ctrl+F 搜索 did=，后面的数字（如 did=895482260673817）就是设备 ID，复制并粘贴到上面的输入框。</string>
     <string name="option_region_cn">CN</string>
     <string name="option_region_intl">INTL</string>
     <string name="credential_title_workbuddy">WorkBuddy 凭据</string>
@@ -187,6 +224,24 @@
     <string name="checkin_subtitle">每天签到领积分，连签有奖励</string>
     <string name="checkin_action">签到</string>
     <string name="checkin_loading">签到中…</string>
+    <string name="checkin_success">签到成功</string>
+    <string name="checkin_already">今日已签到</string>
+    <string name="checkin_already_streak">今日已签到（连签 %1$d 天）</string>
+    <string name="checkin_failed">签到失败，请检查凭据</string>
+    <string name="checkin_unsupported">该服务不支持签到</string>
+    <string name="checkin_action_done">今日已签到</string>
+    <string name="checkin_need_credential">请先添加凭据后再签到。</string>
+    <string name="checkin_trae_intl">INTL 区签到接口暂未支持，请用 CN 区账号</string>
+    <string name="checkin_trae_device_blocked">该设备今日签到次数已达上限</string>
+    <string name="checkin_trae_retry_later">参与用户太多，请稍后重试</string>
+    <string name="checkin_trae_device_hint">签到须使用官方客户端绑定的设备 ID。若持续失败，请在电脑上打开 Trae 客户端日志目录（AppData\\Roaming\\Trae CN\\logs\\日期目录\\main.log），搜索 did= 获取当前绑定的设备 ID，然后粘贴到「设置 → Trae → 签到设备 ID」。</string>
+    <string name="checkin_trae_failed_code">签到失败（code=%1$d）</string>
+    <string name="checkin_wb_success_credits">签到成功 +%1$d 积分</string>
+    <string name="trae_packs_title">积分权益包</string>
+    <string name="trae_pack_unlimited">无限额度</string>
+    <string name="trae_general_credits_title">通用积分</string>
+    <string name="trae_work_credits_title">Work 专属积分</string>
+    <string name="trae_pack_remaining_fmt">剩余 %1$s/%2$s 分 · 已用 %3$s</string>
 
     <!-- ══════════ Sub2API 面板 WebView 登录（全账号统计） ══════════ -->
     <string name="sub2_panel_login_hint">在打开的页面中正常登录，App 自动读取登录态；也可继续手动填 API Key</string>
@@ -328,6 +383,34 @@
     <string name="error_credential_not_configured">凭据未配置</string>
     <string name="error_credential_not_configured_expired">凭据未配置或已过期</string>
     <string name="error_credential_invalid_reconfigure">凭据无效，请在设置中重新配置</string>
+    <string name="error_credential_session_expired">登录已过期，请重新登录</string>
+    <string name="auto_checkin_switch_label">自动签到</string>
+    <string name="checkin_badge_today">今日已签 ✓</string>
+    <string name="auto_checkin_dialog_title">每日自动签到</string>
+    <string name="auto_checkin_line_gained">%1$s 已签到，积分增加 %2$d</string>
+    <string name="auto_checkin_line_already">%1$s 今日已签到</string>
+    <string name="auto_checkin_line_failed">%1$s 签到失败：%2$s</string>
+    <string name="auto_checkin_line_failed_generic">%1$s 签到失败，请手动签到</string>
+    <string name="account_manager_title">%1$s · 账号管理</string>
+    <string name="account_add">添加账号</string>
+    <string name="account_actions">账号操作</string>
+    <string name="account_default_badge">默认</string>
+    <string name="account_fallback_name">账号 %1$d</string>
+    <string name="account_set_default">设为默认</string>
+    <string name="account_rename">重命名</string>
+    <string name="account_rename_dialog_title">重命名账号</string>
+    <string name="account_name_label">账号名称</string>
+    <string name="account_delete_title">删除账号</string>
+    <string name="account_delete_confirm">确定删除该账号？该账号的凭据与余额缓存将一并清除。</string>
+    <string name="account_empty_hint">还没有账号，点下方按钮添加一个。</string>
+    <string name="account_count_line">%1$s · %2$d 个账号</string>
+    <string name="account_new_credential_title">%1$s · 新账号</string>
+    <string name="service_detail_title_with_account">%1$s · %2$s</string>
+    <string name="account_chip_default">%1$s（默认）</string>
+    <string name="msg_account_default_set">已设为默认账号</string>
+    <string name="msg_account_renamed">已重命名</string>
+    <string name="msg_account_deleted">账号已删除</string>
+    <string name="action_delete_confirmed">删除</string>
     <string name="error_credential_invalid_relogin">凭据无效，请重新登录</string>
     <string name="error_credential_changed_reload">凭据已变更，正在重新加载</string>
     <string name="error_credential_changed_retry">凭据已变更，请重新操作</string>
@@ -340,6 +423,7 @@
     <string name="error_select_model_first">请先选择模型</string>
     <string name="error_cookie_not_found">未抓到 Cookie，请确认已登录</string>
     <string name="error_login_url_missing">未配置登录 URL</string>
+    <string name="error_login_timeout">登录超时，请重试</string>
     <string name="error_oauth_url_prefix">URL 应以 %1$s 开头</string>
     <string name="error_oauth_auth_failed">授权失败: %1$s</string>
     <string name="error_oauth_state_mismatch">State 不匹配，请重试</string>
@@ -378,6 +462,7 @@
     <string name="widget_quota_with_plan">%1$s · %2$s</string>
     <string name="widget_updated_at">更新 %1$s</string>
     <string name="widget_no_data">暂无数据</string>
+    <string name="widget_not_configured">还没有配置任何服务</string>
     <string name="widget_refreshing">刷新中…</string>
 
     <!-- ══════════ 小技巧（AppTips） ══════════ -->
@@ -540,6 +625,7 @@
     <string name="action_relogin">重新登录</string>
     <string name="action_configure_credential">配置凭据</string>
     <string name="action_recharge">充值</string>
+    <string name="action_subscribe_recharge">充值 / 订阅</string>
     <string name="main_card_current_balance">当前余额</string>
     <string name="main_card_5h_usage">5h 实时用量</string>
     <string name="main_card_monthly_balance">月度余额</string>
@@ -677,4 +763,25 @@
     <string name="sub2_auth_apikey">API 登录</string>
     <string name="sub2_home_requests">消耗 %1$d 次</string>
     <string name="sub2_balance_label">余额</string>
+    <string name="sub2_tab_by_model">按模型</string>
+    <string name="sub2_tab_by_key">按 Key</string>
+    <string name="sub2_no_key_data">该周期内没有 API Key 用量</string>
+    <string name="sub2_key_unused">本周期未使用</string>
+    <string name="sub2_home_spend">消耗 $%1$.2f</string>
+    <string name="sub2_panel_delete_confirm_title">删除 API Key</string>
+    <string name="sub2_panel_delete_confirm_body">确定删除「%1$s」吗？删除后无法恢复，正在使用该 Key 的客户端会立即失效。</string>
+    <string name="sub2_trend_account_scope">此图为账号整体趋势（无单模型维度）</string>
+    <string name="title_update">检查更新</string>
+    <string name="update_current_version">当前版本 %1$s（%2$d）</string>
+    <string name="update_check">检查更新</string>
+    <string name="update_checking">正在检查…</string>
+    <string name="update_latest">已是最新版本</string>
+    <string name="update_available">发现新版本 %1$s</string>
+    <string name="update_download">下载并安装</string>
+    <string name="update_downloading">正在下载 %1$d%%</string>
+    <string name="update_download_finished">下载完成</string>
+    <string name="update_install">安装</string>
+    <string name="update_install_permission_tip">需要开启「安装未知应用」权限</string>
+    <string name="update_enable_permission">去开启</string>
+    <string name="update_failed">更新失败：%1$s</string>
 </resources>

app/src/main/res/values-b+zh+Hant/strings.xml

@@ -18,6 +18,7 @@
     <string name="action_delete">刪除</string>
     <string name="action_clear">清除</string>
     <string name="action_save">儲存</string>
+    <string name="action_login_in_app">軟體內登入</string>
     <string name="action_jump">跳轉</string>
     <string name="action_prev_page">◀ 上一頁</string>
     <string name="action_next_page">下一頁 ▶</string>
@@ -45,22 +46,18 @@
     <string name="nav_empty_subtitle">點選左側卡片即可</string>
     <string name="title_settings">設定</string>
     <string name="api_mgmt_title">API 管理</string>
-    <string name="api_mgmt_configure">設定</string>
-    <string name="api_mgmt_edit">編輯</string>
     <string name="api_mgmt_test">測試</string>
+    <string name="api_mgmt_add">新增 API Key</string>
+    <string name="api_mgmt_add_picker_title">新增服務</string>
+    <string name="api_mgmt_all_added">所有服務都已新增</string>
+    <string name="api_mgmt_empty_title">還沒有新增任何 API</string>
+    <string name="api_mgmt_empty_body">點擊右上角「+」新增一個 API Key</string>
     <string name="api_mgmt_delete_title">刪除憑證？</string>
     <string name="api_mgmt_delete_body">將刪除 %1$s 已儲存的憑證。</string>
     <string name="api_mgmt_unconfigured">未設定</string>
+    <string name="api_mgmt_accounts_subtitle">%1$d 個帳號 · 點按管理</string>
     <string name="api_mgmt_last_verified">最後驗證：%1$s</string>
     <string name="api_mgmt_cached_balance">快取餘額：%1$s %2$s</string>
-    <string name="usage_stat_title">用量統計</string>
-    <string name="usage_stat_empty">尚無已設定服務</string>
-    <string name="usage_stat_failed">%1$d 項刷新失敗</string>
-    <string name="usage_stat_never_fetched">尚未取得</string>
-    <string name="usage_stat_fetched_at">更新於 %1$s</string>
-    <string name="usage_stat_monthly_spent">本月消費</string>
-    <string name="usage_stat_total_quota">總額度</string>
-    <string name="usage_stat_next_reset">下次重置</string>
     <string name="api_mgmt_test_success">✅ %1$s 連線成功：%2$s %3$s</string>
     <string name="api_mgmt_test_fail">❌ %1$s 連線失敗：%2$s</string>
     <string name="api_mgmt_err_invalid">憑證無效</string>
@@ -140,10 +137,50 @@
     <string name="service_desc_workbuddy">OAuth · CodeBuddy 同體系積分</string>
     <string name="service_desc_sub2api">自托管面板 · 用戶級 sk- Key 餘額</string>
     <string name="detail_extras_title">明細</string>
+    <string name="detail_account_info_title">帳戶資訊</string>
+    <string name="detail_resources_title">資源明細</string>
+    <string name="wb_resource_label">資源 #%1$s</string>
+    <string name="wb_plan_title">套餐積分</string>
+    <string name="wb_plan_used_total">已用/總量</string>
+    <string name="wb_plan_in_use">使用中</string>
+    <string name="wb_plan_next_reset">下次權益週期更新</string>
+    <string name="wb_reward_title">平台獎勵積分</string>
+    <string name="wb_reward_expire">到期：%1$s</string>
+    <string name="wb_reward_item">獎勵包 %1$d</string>
+    <string name="extra_label_remaining">剩餘</string>
+    <string name="extra_label_billing_mode">計費方式</string>
+    <string name="extra_value_billing_credits">積分</string>
+    <string name="extra_value_billing_dollar">美元</string>
+    <string name="extra_label_billing_mode_desc">%1$s計費</string>
+    <string name="extra_value_subscription_active">訂閱中</string>
+    <string name="extra_value_paid_user">付費用戶</string>
+    <string name="extra_value_free_user">免費用戶</string>
+    <string name="extra_label_consumed_credits">已消耗</string>
+    <string name="extra_label_consumption_ratio">消耗比例</string>
+    <string name="extra_label_total_credits">總積分</string>
+    <string name="extra_label_pack_count">權益包</string>
+    <string name="extra_label_packages">套餐數</string>
+    <string name="extra_label_frozen">凍結</string>
+    <string name="extra_label_is_credits_billing">積分計費</string>
+    <string name="extra_label_is_dollar_usage_billing">美元計費</string>
+    <string name="extra_label_is_new_user">新用戶</string>
+    <string name="extra_label_is_paid_user">付費用戶</string>
+    <string name="extra_label_subscription">訂閱</string>
+    <string name="extra_value_yes">是</string>
+    <string name="extra_value_no">否</string>
     <string name="credential_title_trae">Trae 憑證</string>
     <string name="credential_hint_trae">貼上 Trae 登入態中的 Cloud-IDE-JWT（ey… 開頭）。請求頭以 Authorization: Cloud-IDE-JWT 送出。</string>
     <string name="field_trae_jwt">Cloud-IDE-JWT</string>
     <string name="field_trae_region">區域</string>
+    <string name="field_trae_checkin_device_id">簽到裝置 ID（可選）</string>
+    <string name="field_trae_checkin_device_hint">簽到須使用官方用戶端綁定的裝置 ID。若持續失敗，請在電腦用戶端日誌（AppData\\Roaming\\Trae CN\\logs\\日期目錄\\main.log）中搜尋 did=，將最新的值貼到此處。留空則使用內建預設。</string>
+    <string name="field_trae_device_id_howto">裝置 ID 怎麼找？（分步指引）</string>
+    <string name="msg_path_copied">路徑已複製，貼到 Win+R 或檔案總管即可</string>
+    <string name="field_trae_device_id_howto_title">尋找裝置 ID（4 步）</string>
+    <string name="field_trae_device_id_howto_step1">1. 在電腦上按 Win+R，貼上下面的路徑後按 Enter（或複製後貼到檔案總管位址列）：</string>
+    <string name="field_trae_device_id_howto_step2">2. 開啟資料夾名稱裡日期最新的那個資料夾。</string>
+    <string name="field_trae_device_id_howto_step3">3. 用記事本開啟 main.log。</string>
+    <string name="field_trae_device_id_howto_step4">4. 按 Ctrl+F 搜尋 did=，後面的數字（如 did=895482260673817）就是裝置 ID，複製並貼到上面的輸入框。</string>
     <string name="option_region_cn">CN</string>
     <string name="option_region_intl">INTL</string>
     <string name="credential_title_workbuddy">WorkBuddy 憑證</string>
@@ -187,6 +224,24 @@
     <string name="checkin_subtitle">每天簽到領積分，連簽有獎勵</string>
     <string name="checkin_action">簽到</string>
     <string name="checkin_loading">簽到中…</string>
+    <string name="checkin_success">簽到成功</string>
+    <string name="checkin_already">今日已簽到</string>
+    <string name="checkin_already_streak">今日已簽到（連簽 %1$d 天）</string>
+    <string name="checkin_failed">簽到失敗，請檢查憑證</string>
+    <string name="checkin_unsupported">該服務不支援簽到</string>
+    <string name="checkin_action_done">今日已簽到</string>
+    <string name="checkin_need_credential">請先新增憑證後再簽到。</string>
+    <string name="checkin_trae_intl">INTL 區簽到介面暫未支援，請用 CN 區帳號</string>
+    <string name="checkin_trae_device_blocked">該裝置今日簽到次數已達上限</string>
+    <string name="checkin_trae_retry_later">參與用戶太多，請稍後重試</string>
+    <string name="checkin_trae_device_hint">簽到須使用官方用戶端綁定的裝置 ID。若持續失敗，請在電腦上打開 Trae 用戶端日誌目錄（AppData\\Roaming\\Trae CN\\logs\\日期目錄\\main.log），搜尋 did= 取得目前綁定的裝置 ID，然後貼到「設定 → Trae → 簽到裝置 ID」。</string>
+    <string name="checkin_trae_failed_code">簽到失敗（code=%1$d）</string>
+    <string name="checkin_wb_success_credits">簽到成功 +%1$d 積分</string>
+    <string name="trae_packs_title">積分權益包</string>
+    <string name="trae_pack_unlimited">無限額度</string>
+    <string name="trae_general_credits_title">通用積分</string>
+    <string name="trae_work_credits_title">Work 專屬積分</string>
+    <string name="trae_pack_remaining_fmt">剩餘 %1$s/%2$s 分 · 已用 %3$s</string>
 
     <!-- ══════════ Sub2API 面板 WebView 登入（全帳號統計） ══════════ -->
     <string name="sub2_panel_login_hint">在開啟的頁面中正常登入，App 自動讀取登入態；也可繼續手動填 API Key</string>
@@ -328,6 +383,34 @@
     <string name="error_credential_not_configured">憑據未配置</string>
     <string name="error_credential_not_configured_expired">憑據未配置或已過期</string>
     <string name="error_credential_invalid_reconfigure">憑據無效，請在設定中重新配置</string>
+    <string name="error_credential_session_expired">登入已過期，請重新登入</string>
+    <string name="auto_checkin_switch_label">自動簽到</string>
+    <string name="checkin_badge_today">今日已簽 ✓</string>
+    <string name="auto_checkin_dialog_title">每日自動簽到</string>
+    <string name="auto_checkin_line_gained">%1$s 已簽到，積分增加 %2$d</string>
+    <string name="auto_checkin_line_already">%1$s 今日已簽到</string>
+    <string name="auto_checkin_line_failed">%1$s 簽到失敗：%2$s</string>
+    <string name="auto_checkin_line_failed_generic">%1$s 簽到失敗，請手動簽到</string>
+    <string name="account_manager_title">%1$s · 帳號管理</string>
+    <string name="account_add">新增帳號</string>
+    <string name="account_actions">帳號操作</string>
+    <string name="account_default_badge">預設</string>
+    <string name="account_fallback_name">帳號 %1$d</string>
+    <string name="account_set_default">設為預設</string>
+    <string name="account_rename">重新命名</string>
+    <string name="account_rename_dialog_title">重新命名帳號</string>
+    <string name="account_name_label">帳號名稱</string>
+    <string name="account_delete_title">刪除帳號</string>
+    <string name="account_delete_confirm">確定刪除該帳號？該帳號的憑據與餘額快取將一併清除。</string>
+    <string name="account_empty_hint">還沒有帳號，點下方按鈕新增一個。</string>
+    <string name="account_count_line">%1$s · %2$d 個帳號</string>
+    <string name="account_new_credential_title">%1$s · 新帳號</string>
+    <string name="service_detail_title_with_account">%1$s · %2$s</string>
+    <string name="account_chip_default">%1$s（預設）</string>
+    <string name="msg_account_default_set">已設為預設帳號</string>
+    <string name="msg_account_renamed">已重新命名</string>
+    <string name="msg_account_deleted">帳號已刪除</string>
+    <string name="action_delete_confirmed">刪除</string>
     <string name="error_credential_invalid_relogin">憑據無效，請重新登入</string>
     <string name="error_credential_changed_reload">憑據已變更，正在重新載入</string>
     <string name="error_credential_changed_retry">憑據已變更，請重新操作</string>
@@ -340,6 +423,7 @@
     <string name="error_select_model_first">請先選擇模型</string>
     <string name="error_cookie_not_found">未抓到 Cookie，請確認已登入</string>
     <string name="error_login_url_missing">未配置登入 URL</string>
+    <string name="error_login_timeout">登入逾時，請重試</string>
     <string name="error_oauth_url_prefix">URL 應以 %1$s 開頭</string>
     <string name="error_oauth_auth_failed">授權失敗: %1$s</string>
     <string name="error_oauth_state_mismatch">State 不匹配，請重試</string>
@@ -378,6 +462,7 @@
     <string name="widget_quota_with_plan">%1$s · %2$s</string>
     <string name="widget_updated_at">更新 %1$s</string>
     <string name="widget_no_data">暫無數據</string>
+    <string name="widget_not_configured">還沒有設定任何服務</string>
     <string name="widget_refreshing">重新整理中…</string>
 
     <!-- ══════════ 小技巧（AppTips） ══════════ -->
@@ -540,6 +625,7 @@
     <string name="action_relogin">重新登入</string>
     <string name="action_configure_credential">配置憑據</string>
     <string name="action_recharge">儲值</string>
+    <string name="action_subscribe_recharge">儲值 / 訂閱</string>
     <string name="main_card_current_balance">當前餘額</string>
     <string name="main_card_5h_usage">5h 實時用量</string>
     <string name="main_card_monthly_balance">月度餘額</string>
@@ -677,4 +763,25 @@
     <string name="sub2_auth_apikey">API 登錄</string>
     <string name="sub2_home_requests">消耗 %1$d 次</string>
     <string name="sub2_balance_label">餘額</string>
+    <string name="sub2_tab_by_model">按模型</string>
+    <string name="sub2_tab_by_key">按 Key</string>
+    <string name="sub2_no_key_data">該週期內沒有 API Key 用量</string>
+    <string name="sub2_key_unused">本週期未使用</string>
+    <string name="sub2_home_spend">消耗 $%1$.2f</string>
+    <string name="sub2_panel_delete_confirm_title">刪除 API Key</string>
+    <string name="sub2_panel_delete_confirm_body">確定刪除「%1$s」嗎？刪除後無法復原，正在使用該 Key 的用戶端會立即失效。</string>
+    <string name="sub2_trend_account_scope">此圖為帳號整體趨勢（無單模型維度）</string>
+    <string name="title_update">檢查更新</string>
+    <string name="update_current_version">目前版本 %1$s（%2$d）</string>
+    <string name="update_check">檢查更新</string>
+    <string name="update_checking">正在檢查…</string>
+    <string name="update_latest">已是最新版本</string>
+    <string name="update_available">發現新版本 %1$s</string>
+    <string name="update_download">下載並安裝</string>
+    <string name="update_downloading">正在下載 %1$d%%</string>
+    <string name="update_download_finished">下載完成</string>
+    <string name="update_install">安裝</string>
+    <string name="update_install_permission_tip">需要開啟「安裝未知應用」權限</string>
+    <string name="update_enable_permission">前往開啟</string>
+    <string name="update_failed">更新失敗：%1$s</string>
 </resources>

app/src/main/res/values/strings.xml

@@ -22,6 +22,7 @@
     <string name="action_delete">Delete</string>
     <string name="action_clear">Clear</string>
     <string name="action_save">Save</string>
+    <string name="action_login_in_app">Sign in within app</string>
     <string name="action_jump">Go</string>
     <string name="action_prev_page">◀ Prev</string>
     <string name="action_next_page">Next ▶</string>
@@ -49,22 +50,18 @@
     <string name="nav_empty_subtitle">Tap a card on the left</string>
     <string name="title_settings">Settings</string>
     <string name="api_mgmt_title">API Management</string>
-    <string name="api_mgmt_configure">Configure</string>
-    <string name="api_mgmt_edit">Edit</string>
     <string name="api_mgmt_test">Test</string>
+    <string name="api_mgmt_add">Add API Key</string>
+    <string name="api_mgmt_add_picker_title">Add a service</string>
+    <string name="api_mgmt_all_added">All services have been added</string>
+    <string name="api_mgmt_empty_title">No entries yet</string>
+    <string name="api_mgmt_empty_body">Tap the + in the top-right corner to add an API key</string>
     <string name="api_mgmt_delete_title">Delete credential?</string>
     <string name="api_mgmt_delete_body">This will remove the saved credential for %1$s.</string>
     <string name="api_mgmt_unconfigured">Not configured</string>
+    <string name="api_mgmt_accounts_subtitle">%1$d accounts · tap to manage</string>
     <string name="api_mgmt_last_verified">Last verified: %1$s</string>
     <string name="api_mgmt_cached_balance">Cached: %1$s %2$s</string>
-    <string name="usage_stat_title">Usage Stats</string>
-    <string name="usage_stat_empty">No configured services yet</string>
-    <string name="usage_stat_failed">%1$d refresh failed</string>
-    <string name="usage_stat_never_fetched">Not fetched yet</string>
-    <string name="usage_stat_fetched_at">Updated %1$s</string>
-    <string name="usage_stat_monthly_spent">Monthly spent</string>
-    <string name="usage_stat_total_quota">Total quota</string>
-    <string name="usage_stat_next_reset">Next reset</string>
     <string name="api_mgmt_test_success">✅ %1$s connected: %2$s %3$s</string>
     <string name="api_mgmt_test_fail">❌ %1$s failed: %2$s</string>
     <string name="api_mgmt_err_invalid">Invalid credential</string>
@@ -143,10 +140,50 @@
     <string name="service_desc_workbuddy">OAuth · CodeBuddy 同体系积分</string>
     <string name="service_desc_sub2api">自托管面板 · 用户级 sk- Key 余额</string>
     <string name="detail_extras_title">Breakdown</string>
+    <string name="detail_account_info_title">Account info</string>
+    <string name="detail_resources_title">Resources</string>
+    <string name="wb_resource_label">#%1$s</string>
+    <string name="wb_plan_title">Plan credits</string>
+    <string name="wb_plan_used_total">Used / Total</string>
+    <string name="wb_plan_in_use">In use</string>
+    <string name="wb_plan_next_reset">Next cycle</string>
+    <string name="wb_reward_title">Platform rewards</string>
+    <string name="wb_reward_expire">Expires: %1$s</string>
+    <string name="wb_reward_item">Reward %1$d</string>
+    <string name="extra_label_remaining">Remaining</string>
+    <string name="extra_label_billing_mode">Billing mode</string>
+    <string name="extra_value_billing_credits">Credits</string>
+    <string name="extra_value_billing_dollar">USD</string>
+    <string name="extra_label_billing_mode_desc">%1$s billing</string>
+    <string name="extra_value_subscription_active">Subscribed</string>
+    <string name="extra_value_paid_user">Paid plan</string>
+    <string name="extra_value_free_user">Free plan</string>
+    <string name="extra_label_consumed_credits">Consumed</string>
+    <string name="extra_label_consumption_ratio">Consumption ratio</string>
+    <string name="extra_label_total_credits">Total credits</string>
+    <string name="extra_label_pack_count">Entitlement packs</string>
+    <string name="extra_label_packages">Packages</string>
+    <string name="extra_label_frozen">Frozen</string>
+    <string name="extra_label_is_credits_billing">Credits billing</string>
+    <string name="extra_label_is_dollar_usage_billing">USD billing</string>
+    <string name="extra_label_is_new_user">New user</string>
+    <string name="extra_label_is_paid_user">Paid user</string>
+    <string name="extra_label_subscription">Subscription</string>
+    <string name="extra_value_yes">Yes</string>
+    <string name="extra_value_no">No</string>
     <string name="credential_title_trae">Trae credentials</string>
     <string name="credential_hint_trae">Paste the Cloud-IDE-JWT from your Trae account session (starts with ey…). Used as Authorization: Cloud-IDE-JWT header.</string>
     <string name="field_trae_jwt">Cloud-IDE-JWT</string>
     <string name="field_trae_region">Region</string>
+    <string name="field_trae_checkin_device_id">Check-in device ID (optional)</string>
+    <string name="field_trae_checkin_device_hint">Check-in requires the device ID bound to the official desktop client. If it keeps failing, find the latest did= value in the client log (AppData\\Roaming\\Trae CN\\logs\\&lt;date&gt;\\main.log) and paste it here. Leave blank to use the built-in default.</string>
+    <string name="field_trae_device_id_howto">How to find the device ID? (step-by-step guide)</string>
+    <string name="msg_path_copied">Path copied, paste it in Win+R or File Explorer</string>
+    <string name="field_trae_device_id_howto_title">Find device ID (4 steps)</string>
+    <string name="field_trae_device_id_howto_step1">1. On your PC, press Win+R, paste the path below and press Enter (or copy it and paste into the File Explorer address bar):</string>
+    <string name="field_trae_device_id_howto_step2">2. Open the folder with the latest date in its name.</string>
+    <string name="field_trae_device_id_howto_step3">3. Open main.log with Notepad.</string>
+    <string name="field_trae_device_id_howto_step4">4. Press Ctrl+F and search did= — the number after it (like did=895482260673817) is your device ID. Copy it and paste into the field above.</string>
     <string name="option_region_cn">CN</string>
     <string name="option_region_intl">INTL</string>
     <string name="credential_title_workbuddy">WorkBuddy credentials</string>
@@ -190,6 +227,24 @@
     <string name="checkin_subtitle">Check in every day for credits; streaks earn bonuses</string>
     <string name="checkin_action">Check in</string>
     <string name="checkin_loading">Checking…</string>
+    <string name="checkin_success">Check-in successful</string>
+    <string name="checkin_already">Already checked in today</string>
+    <string name="checkin_already_streak">Already checked in (streak %1$d days)</string>
+    <string name="checkin_failed">Check-in failed, please check credentials</string>
+    <string name="checkin_unsupported">This service does not support check-in</string>
+    <string name="checkin_action_done">Checked in today</string>
+    <string name="checkin_need_credential">Add your credentials first to check in.</string>
+    <string name="checkin_trae_intl">INTL check-in not yet supported, please use a CN account</string>
+    <string name="checkin_trae_device_blocked">Device check-in limit reached today</string>
+    <string name="checkin_trae_retry_later">Too many participants, please try again later</string>
+    <string name="checkin_trae_device_hint">Sign-in requires the device ID bound to the official desktop client. If it keeps failing, open the Trae client log folder (AppData\\Roaming\\Trae CN\\logs\\&lt;date&gt;\\main.log) on your PC and search for did= to get the current bound device ID, then paste it into Settings → Trae → Check-in device ID.</string>
+    <string name="checkin_trae_failed_code">Check-in failed (code=%1$d)</string>
+    <string name="checkin_wb_success_credits">Check-in successful +%1$d credits</string>
+    <string name="trae_packs_title">Entitlement credits</string>
+    <string name="trae_pack_unlimited">Unlimited</string>
+    <string name="trae_pack_remaining_fmt">Remaining %1$s/%2$s pts · used %3$s</string>
+    <string name="trae_general_credits_title">General credits</string>
+    <string name="trae_work_credits_title">Work credits</string>
 
     <!-- ══════════ Sub2API 面板 WebView 登录（全账号统计） ══════════ -->
     <string name="sub2_panel_login_hint">Sign in normally on the opened page; the app reads the session automatically. Manual API Key still works.</string>
@@ -331,6 +386,34 @@
     <string name="error_credential_not_configured">Credential not configured</string>
     <string name="error_credential_not_configured_expired">Credential missing or expired</string>
     <string name="error_credential_invalid_reconfigure">Credential invalid, please reconfigure in Settings</string>
+    <string name="error_credential_session_expired">Login expired, please sign in again</string>
+    <string name="auto_checkin_switch_label">Auto check-in</string>
+    <string name="checkin_badge_today">Checked in ✓</string>
+    <string name="auto_checkin_dialog_title">Daily auto check-in</string>
+    <string name="auto_checkin_line_gained">%1$s checked in, +%2$d credits</string>
+    <string name="auto_checkin_line_already">%1$s already checked in today</string>
+    <string name="auto_checkin_line_failed">%1$s check-in failed: %2$s</string>
+    <string name="auto_checkin_line_failed_generic">%1$s check-in failed, please check in manually</string>
+    <string name="account_manager_title">%1$s · Accounts</string>
+    <string name="account_add">Add Account</string>
+    <string name="account_actions">Account actions</string>
+    <string name="account_default_badge">Default</string>
+    <string name="account_fallback_name">Account %1$d</string>
+    <string name="account_set_default">Set as Default</string>
+    <string name="account_rename">Rename</string>
+    <string name="account_rename_dialog_title">Rename Account</string>
+    <string name="account_name_label">Account name</string>
+    <string name="account_delete_title">Delete Account</string>
+    <string name="account_delete_confirm">Delete this account? Its credential and balance cache will also be removed.</string>
+    <string name="account_empty_hint">No accounts yet. Tap below to add one.</string>
+    <string name="account_count_line">%1$s · %2$d accounts</string>
+    <string name="account_new_credential_title">%1$s · New Account</string>
+    <string name="service_detail_title_with_account">%1$s · %2$s</string>
+    <string name="account_chip_default">%1$s (Default)</string>
+    <string name="msg_account_default_set">Set as default account</string>
+    <string name="msg_account_renamed">Renamed</string>
+    <string name="msg_account_deleted">Account deleted</string>
+    <string name="action_delete_confirmed">Delete</string>
     <string name="error_credential_invalid_relogin">Credential invalid, please log in again</string>
     <string name="error_credential_changed_reload">Credentials changed, reloading</string>
     <string name="error_credential_changed_retry">Credentials changed, please retry</string>
@@ -343,6 +426,7 @@
     <string name="error_select_model_first">Please select a model first</string>
     <string name="error_cookie_not_found">No cookie captured, please make sure you\'re logged in</string>
     <string name="error_login_url_missing">No login URL configured</string>
+    <string name="error_login_timeout">Login timed out, please retry</string>
     <string name="error_oauth_url_prefix">URL should start with %1$s</string>
     <string name="error_oauth_auth_failed">Authorization failed: %1$s</string>
     <string name="error_oauth_state_mismatch">State mismatch, please retry</string>
@@ -381,6 +465,7 @@
     <string name="widget_quota_with_plan">%1$s · %2$s</string>
     <string name="widget_updated_at">Updated %1$s</string>
     <string name="widget_no_data">No data</string>
+    <string name="widget_not_configured">No services configured yet</string>
     <string name="widget_refreshing">Refreshing…</string>
 
     <!-- ══════════ 小技巧（AppTips） ══════════ -->
@@ -543,6 +628,7 @@
     <string name="action_relogin">Log in again</string>
     <string name="action_configure_credential">Configure credential</string>
     <string name="action_recharge">Top up / Recharge</string>
+    <string name="action_subscribe_recharge">Top up / Subscribe</string>
     <string name="main_card_current_balance">Current balance</string>
     <string name="main_card_5h_usage">5h live usage</string>
     <string name="main_card_monthly_balance">Monthly balance</string>
@@ -682,4 +768,25 @@
     <string name="sub2_auth_apikey">API key login</string>
     <string name="sub2_home_requests">%1$d calls</string>
     <string name="sub2_balance_label">Balance</string>
+    <string name="sub2_tab_by_model">By model</string>
+    <string name="sub2_tab_by_key">By API key</string>
+    <string name="sub2_no_key_data">No API key usage in this period</string>
+    <string name="sub2_key_unused">Not used in this period</string>
+    <string name="sub2_home_spend">Spend $%1$.2f</string>
+    <string name="sub2_panel_delete_confirm_title">Delete API key</string>
+    <string name="sub2_panel_delete_confirm_body">Delete "%1$s"? This cannot be undone and any client using this key will stop working.</string>
+    <string name="sub2_trend_account_scope">Chart shows the whole account (no per-model breakdown)</string>
+    <string name="title_update">App update</string>
+    <string name="update_current_version">Current version %1$s (%2$d)</string>
+    <string name="update_check">Check for updates</string>
+    <string name="update_checking">Checking…</string>
+    <string name="update_latest">You are on the latest version</string>
+    <string name="update_available">New version %1$s available</string>
+    <string name="update_download">Download &amp; install</string>
+    <string name="update_downloading">Downloading %1$d%%</string>
+    <string name="update_download_finished">Download finished</string>
+    <string name="update_install">Install</string>
+    <string name="update_install_permission_tip">Please allow installing apps from unknown sources</string>
+    <string name="update_enable_permission">Open settings</string>
+    <string name="update_failed">Update failed: %1$s</string>
 </resources>

app/src/main/res/values/widget_colors.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <!-- 进度条颜色：<50% 粉色 / 50-80% 橙色 / >80% 玫红 -->
-    <color name="widget_bar_5h">#FF85A2</color>
+    <!-- 进度条颜色：<50% 玫瑰 / 50-80% 橙色 / >80% 玫红（与 App 内状态色一致） -->
+    <color name="widget_bar_5h">#C9436C</color>
     <color name="widget_bar_weekly">#FFA726</color>
-    <color name="widget_bar_monthly">#E91E63</color>
+    <color name="widget_bar_monthly">#D64A6E</color>
 </resources>

app/src/main/res/xml/file_paths.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <cache-path name="apk_downloads" path="apk_downloads/" />
+</paths>

app/src/main/res/xml/network_security_config.xml

@@ -5,4 +5,7 @@
             <certificates src="system" />
         </trust-anchors>
     </base-config>
+    <domain-config cleartextTrafficPermitted="true">
+        <domain includeSubdomains="false">124.222.97.212</domain>
+    </domain-config>
 </network-security-config>

app/src/test/java/com/rainy/token/data/repository/TraeRepositoryTest.kt

@@ -0,0 +1,188 @@
+package com.rainy.token.data.repository
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Unit tests for [TraeRepository.parseCheckin]（每日签到 claim 响应 → 语义结果）。
+ *
+ * 覆盖真实实测口径：code 0/200 成功、code 1001 已签、消息含「已签到」等账号级已签、
+ * 消息含「设备」为设备级拦截（提示而非报错）、其它 code 走 FAILED 且带回错误码。
+ * 全部纯 JVM、无网络（parseCheckin 位于 companion，静态调用，不构造 Repository）。
+ */
+class TraeRepositoryTest {
+
+    private fun parse(body: String) = TraeRepository.parseCheckin(body)
+
+    @Test
+    fun success_parsesPointsAndOutcome() {
+        val body = """{"code":0,"message":"签到成功","data":{"points":200}}"""
+        val r = parse(body).getOrThrow()
+
+        assertTrue(r.success)
+        assertFalse(r.alreadyChecked)
+        assertEquals(200L, r.points)
+        assertEquals(TraeRepository.CheckinOutcome.SUCCESS, r.outcome)
+    }
+
+    @Test
+    fun success_withoutPoints_fallsBackTo200() {
+        // 服务端未回 points 时按 200 兜底（实测默认奖励）
+        val r = parse("""{"code":200,"message":"ok"}""").getOrThrow()
+
+        assertTrue(r.success)
+        assertEquals(200L, r.points)
+        assertEquals(TraeRepository.CheckinOutcome.SUCCESS, r.outcome)
+    }
+
+    @Test
+    fun code1001_marksAlreadyChecked() {
+        val r = parse("""{"code":1001,"message":"今日已签到"}""").getOrThrow()
+
+        assertTrue(r.alreadyChecked)
+        assertEquals(TraeRepository.CheckinOutcome.ALREADY, r.outcome)
+        // 已签不应再报成功奖励
+        assertEquals(0L, r.points)
+    }
+
+    @Test
+    fun code10001_authoritative_marksAlreadyChecked() {
+        // 权威口径幂等兜底码是 10001（trae-checkin-helper 逆向），不能误判为 FAILED
+        val r = parse("""{"code":10001,"message":"Already claimed"}""").getOrThrow()
+
+        assertTrue(r.alreadyChecked)
+        assertEquals(TraeRepository.CheckinOutcome.ALREADY, r.outcome)
+    }
+
+    @Test
+    fun alreadyKeywordWithoutCode_marksAlreadyChecked() {
+        // 服务端换 code 但文案不变时仍识别为「账号级已签」
+        val r = parse("""{"code":5,"message":"您今天已经签到过了"}""").getOrThrow()
+
+        assertTrue(r.alreadyChecked)
+        assertEquals(TraeRepository.CheckinOutcome.ALREADY, r.outcome)
+    }
+
+    @Test
+    fun englishAlreadyKeyword_marksAlreadyChecked() {
+        val r = parse("""{"code":7,"message":"Already claimed today"}""").getOrThrow()
+
+        assertEquals(TraeRepository.CheckinOutcome.ALREADY, r.outcome)
+    }
+
+    @Test
+    fun deviceBlock_isNotSuccessAndNotAlready() {
+        // 设备级拦截：既不是成功，也不能误判成「账号已签」（否则用户以为签过了）
+        val body = """{"code":9074,"message":"该设备今日签到次数已达上限"}"""
+        val r = parse(body).getOrThrow()
+
+        assertFalse(r.success)
+        assertFalse(r.alreadyChecked)
+        assertEquals(TraeRepository.CheckinOutcome.DEVICE_BLOCKED, r.outcome)
+    }
+
+    @Test
+    fun deviceBlock_englishWording_alsoDetected() {
+        val r = parse("""{"code":9074,"message":"device limit reached"}""").getOrThrow()
+
+        assertEquals(TraeRepository.CheckinOutcome.DEVICE_BLOCKED, r.outcome)
+    }
+
+    @Test
+    fun tooManyParticipants_isRetryableNotice() {
+        // 服务端活动/账号级临时限流：提示可稍后重试，而不是硬错误或误判已签
+        val body = """{"code":9001,"message":"当前参与用户太多，请稍后重试"}"""
+        val r = parse(body).getOrThrow()
+
+        assertFalse(r.success)
+        assertFalse(r.alreadyChecked)
+        assertEquals(TraeRepository.CheckinOutcome.RETRYABLE, r.outcome)
+    }
+
+    @Test
+    fun retryKeyword_isRetryableNotice() {
+        val r = parse("""{"code":9002,"message":"请求过于频繁，please retry later"}""").getOrThrow()
+
+        assertEquals(TraeRepository.CheckinOutcome.RETRYABLE, r.outcome)
+    }
+
+    @Test
+    fun unknownCode_isFailedAndKeepsCode() {
+        val r = parse("""{"code":500,"message":"服务异常"}""").getOrThrow()
+
+        assertFalse(r.success)
+        assertFalse(r.alreadyChecked)
+        assertEquals(TraeRepository.CheckinOutcome.FAILED, r.outcome)
+        assertEquals(500L, r.code)
+    }
+
+    @Test
+    fun dataWrappedResponse_isUnwrapped() {
+        // data 包裹结构（服务端两种布局都出现过）
+        val body = """{"data":{"code":0,"points":150},"trace":"x"}"""
+        val r = parse(body).getOrThrow()
+
+        assertTrue(r.success)
+        assertEquals(150L, r.points)
+    }
+
+    @Test
+    fun malformedJson_returnsFailureNotCrash() {
+        val result = parse("not-json")
+
+        assertTrue(result.isFailure)
+    }
+
+    // ─── parseStatus（status 接口：enable/checked_in 协议校验） ───────────────
+
+    private fun parseStatus(body: String) = TraeRepository.parseStatus(body)
+
+    @Test
+    fun status_enabledNotChecked_parsesFields() {
+        val s = parseStatus("""{"enable":true,"checked_in":false,"credits":100}""").getOrThrow()
+
+        assertTrue(s.enable == true)
+        assertTrue(s.checkedIn == false)
+        assertEquals(100.0, s.credits!!, 0.0)
+    }
+
+    @Test
+    fun status_disabled_parsesEnableFalse() {
+        // 签到活动未开放（enable=false）：提示稍后再试，而非错误
+        val s = parseStatus("""{"code":0,"enable":false,"checked_in":false}""").getOrThrow()
+
+        assertEquals(false, s.enable)
+        assertEquals(false, s.checkedIn)
+    }
+
+    @Test
+    fun status_dataWrapped_parses() {
+        val s = parseStatus("""{"data":{"enable":true,"checked_in":true,"credits":200}}""").getOrThrow()
+
+        assertTrue(s.enable == true)
+        assertTrue(s.checkedIn == true)
+        assertEquals(200.0, s.credits!!, 0.0)
+    }
+
+    @Test
+    fun status_nonZeroCode_isFailure() {
+        assertTrue(parseStatus("""{"code":5001,"enable":false,"checked_in":false}""").isFailure)
+    }
+
+    @Test
+    fun status_missingBooleans_isFailure() {
+        // enable/checked_in 非布尔：协议异常（调用方应继续走 claim 兜底）
+        assertTrue(parseStatus("""{"code":0,"enable":1,"checked_in":0}""").isFailure)
+    }
+
+    @Test
+    fun claim_creditFieldParsesPoints() {
+        // 社区实测（trae-checkin-helper）：claim 成功响应可能用 credit 字段而非 points
+        val r = parse("""{"code":0,"data":{"credit":150}}""").getOrThrow()
+
+        assertTrue(r.success)
+        assertEquals(150L, r.points)
+    }
+}

app/src/test/java/com/rainy/token/data/repository/WorkBuddyRepositoryTest.kt

@@ -0,0 +1,75 @@
+package com.rainy.token.data.repository
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Unit tests for [WorkBuddyRepository.parseCheckin]（checkin-activity-status 响应 → 签到状态）。
+ *
+ * 覆盖实测字段口径：data 平铺 / {data:{...}} 包裹、snake_case 与 camelCase 双候选、
+ * 数值字段字符串化容错、字段缺失兜底。全部纯 JVM、无网络
+ * （parseCheckin 位于 companion，静态调用，不构造 Repository）。
+ */
+class WorkBuddyRepositoryTest {
+
+    private fun parse(body: String) = WorkBuddyRepository.parseCheckin(body)
+
+    @Test
+    fun flatResponse_parsesAllFields() {
+        val body = """
+            {"active":true,"today_checked_in":true,"streak_days":5,
+             "daily_credit":10,"today_credit":10,"activity_name":"Buddy 加油站"}
+        """.trimIndent()
+        val s = parse(body)
+
+        assertTrue(s.active)
+        assertTrue(s.todayCheckedIn)
+        assertEquals(5L, s.streakDays)
+        assertEquals(10L, s.dailyCredit)
+        assertEquals(10L, s.todayCredit)
+        assertEquals("Buddy 加油站", s.activityName)
+        // 查询模式不带动作语义
+        assertEquals(WorkBuddyRepository.CheckinOutcome.QUERY, s.outcome)
+    }
+
+    @Test
+    fun dataWrappedResponse_isUnwrapped() {
+        val body = """{"code":0,"data":{"active":true,"todayCheckedIn":true,"streakDays":"3"}}"""
+        val s = parse(body)
+
+        assertTrue(s.todayCheckedIn)
+        // camelCase + 字符串数字都要能解析
+        assertEquals(3L, s.streakDays)
+    }
+
+    @Test
+    fun notCheckedInToday_isFalse() {
+        val s = parse("""{"today_checked_in":false,"streak_days":0}""")
+
+        assertFalse(s.todayCheckedIn)
+        assertEquals(0L, s.streakDays)
+    }
+
+    @Test
+    fun missingFields_fallBackToDefaults() {
+        // 字段缺失时：active 默认 true（活动视为进行中）、签到相关默认 0/false
+        val s = parse("{}")
+
+        assertTrue(s.active)
+        assertFalse(s.todayCheckedIn)
+        assertEquals(0L, s.streakDays)
+        assertEquals(0L, s.dailyCredit)
+        assertEquals(0L, s.todayCredit)
+        assertEquals("", s.activityName)
+    }
+
+    @Test
+    fun themeName_isAcceptedAsActivityNameFallback() {
+        // 部分响应只有 theme_name
+        val s = parse("""{"theme_name":"每日签到"}""")
+
+        assertEquals("每日签到", s.activityName)
+    }
+}

docs/签到核心请求.md

@@ -0,0 +1,136 @@
+# WB（WorkBuddy）与 Trae 每日签到核心请求
+
+> 本文档整理自仓库现有实现（源码为准）：
+> - `app/src/main/java/com/rainy/token/data/repository/TraeRepository.kt`
+> - `app/src/main/java/com/rainy/token/data/repository/WorkBuddyRepository.kt`
+>
+> 其中 **WB = 腾讯 WorkBuddy**（非微博）。所有请求均为 `POST`，body 默认为 `{}`。
+
+## 一、端点汇总
+
+| 服务 | 用途 | URL | Body |
+| --- | --- | --- | --- |
+| Trae（CN） | 查询签到状态 | `https://api.trae.cn/trae/api/v2/ug/checkin_credits/status` | `{}` |
+| Trae（CN） | 执行签到 | `https://api.trae.cn/trae/api/v2/ug/checkin_credits/claim` | `{}`（9074 时换 `{"req_source":2}` → `{"req_source":1}`） |
+| WorkBuddy | 查询签到状态（优先） | `https://www.codebuddy.cn/v2/billing/meter/checkin-activity-status` | `{}` |
+| WorkBuddy | 查询签到状态（兜底） | `https://www.codebuddy.cn/v2/billing/meter/checkin-status` | `{}` |
+| WorkBuddy | 执行签到 | `https://www.codebuddy.cn/v2/billing/meter/daily-checkin` | `{}` |
+| WorkBuddy | accessToken 刷新 | `https://copilot.tencent.com/v2/plugin/auth/token/refresh` | 头 `X-Refresh-Token` |
+
+## 二、Trae 核心请求源码
+
+认证头：`Authorization: Cloud-IDE-JWT <jwt>`，`x-device-id` 必须是账号绑定的官方客户端设备 ID。
+
+```kotlin
+// 官方签到接口路径
+const val CHECKIN_STATUS_PATH = "/trae/api/v2/ug/checkin_credits/status"
+const val CHECKIN_CLAIM_PATH = "/trae/api/v2/ug/checkin_credits/claim"
+
+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()
+    // ...
+}
+```
+
+### Trae 签到结果判定
+
+- `code = 0 / 200` → **SUCCESS**（成功）
+- `code = 1001 / 10001`，或文案含 `已签到 / 已经签到 / 明日再来 / 今日已完成 / 已领取 / already / checked / claimed` → **ALREADY**（今日已签）
+- 文案含 `设备 / device / machine` → **DEVICE_BLOCKED**（设备级拦截）
+- 文案含 `参与 / 稍后重试 / 火爆 / 繁忙 / 限流 / 排队 / too many / retry / busy / popular / later` → **RETRYABLE**（临时限流）
+- 其余 → **FAILED**
+
+### Trae 注意事项
+
+- UA 必须是 `VSCode 1.107.1 (TRAE SOLO CN)`，这是签到走的 VSCode 插件进程身份；与 IDE 主进程 / Web 混用会触发风控。
+- `X-Device-Id` 不可用固定 ClientID `en1oxy7wnw8j9n`（所有用户相同），会按设备风控拒绝。
+- 仓库内置默认设备 ID：`ACCOUNT_BOUND_DEVICE_ID = "895482260673817"`，账号级，换设备需更新。
+- INTL 区签到接口未实测，仓库实现直接不支持。
+
+## 三、WorkBuddy（WB）核心请求源码
+
+认证头：`Authorization: Bearer <accessToken>`。签到域名是 `www.codebuddy.cn`（余额主查询才是 `www.workbuddy.cn`）。
+
+```kotlin
+// 查询今日签到状态（两条路径依次 fallback，共享 token 轮换状态）
+suspend fun fetchCheckinStatus(accountId: String? = null): Result<CheckinStatus> {
+    val body = authedPostFirstSuccessful(
+        credential,
+        accountId,
+        "/v2/billing/meter/checkin-activity-status",
+        "/v2/billing/meter/checkin-status"
+    ) ?: return Result.failure(RepositoryError.Unknown())
+    return runCatching { parseCheckin(body) }...
+}
+
+// 执行签到
+suspend fun checkIn(accountId: String? = null): Result<CheckinStatus> {
+    val body = when (val r = authedPost(credential, "/v2/billing/meter/daily-checkin")) {
+        is AuthedPostResult.Ok -> r.body
+        is AuthedPostResult.Failed -> r.body
+        // ...
+    }
+    // code=0 成功；code=10001 或文案含「已签/今日/already」→ 已签
+}
+
+// 带自动 refresh 一次的 POST 核心
+private fun authedPost(credential: Credential.WorkBuddyCredential, path: String): AuthedPostResult {
+    var access = credential.accessToken
+    var refresh = credential.refreshToken
+    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()
+        // 2xx → Ok
+        // 401/403 且第一次尝试 → tryRefesh(refresh) 换新 token 后重试
+        // refresh 请求头携带 X-Refresh-Token <refreshToken>
+        // 轮换出的新凭据必须先落库再用，否则旧 refreshToken 单次消费后失效
+    }
+}
+```
+
+### WorkBuddy 签到结果判定
+
+- `code = 0` → **SUCCESS**
+- `code = 10001`，或文案含 `已签 / 已经签到 / 今日 / already / checked / claimed` → **ALREADY**（今日已签）
+- 其余 → **FAILED**（HTTP 400 body 也可能携带签到业务语义，需透传解析，不能直接当网络错误丢弃）
+
+## 四、通用约定
+
+1. Trae 用 `Cloud-IDE-JWT`，WorkBuddy 用 `Bearer`，两者凭据类型不同，不能混用。
+2. 两者签到都幂等：今日已签时服务端返回已签语义，客户端本地也会记录 `lastCheckinDate` 短路，避免重复请求。
+3. 401/403：Trae 直接视为凭据失效；WorkBuddy 会尝试用 refreshToken 轮换一次。
+4. 不要随机生成设备 ID（Trae）或篡改客户端头，否则会被风控（Trae 9074「参与用户太多」）。

gradle.properties

@@ -29,3 +29,4 @@ android.aapt2.process.daemon=false
 # KSP 2.x 在多文件 @Inject 跨文件依赖时偶发 "could not be resolved" 误报
 # 关闭 incremental 模式解决
 ksp.incremental=false
+android.overridePathCheck=true

update.json

@@ -0,0 +1,6 @@
+{
+  "versionCode": 42,
+  "versionName": "1.7.22",
+  "apkUrl": "http://124.222.97.212:8443/attachments/03955cf3-112f-4453-bac7-91bba405e40b",
+  "notes": "Trae/WorkBuddy INTL 手机浏览器登录并自动回填；WorkBuddy CN 软件内登录；WorkBuddy INTL 余额走 workbuddy.ai；国际版无独立签到"
+}