feat(enums): 接入 /meta/enums 权威枚举表，删掉客户端硬编码映射

客户端此前自带 platform / mood / mode 三张硬编码标签表，会与服务端漂移——
实测已经漂了：客户端把 `web` 显示成「Web」，权威表里是「网页」。

- data：MetaApi（GET /api/v1/meta/enums）+ MetaDto + MetaRepository，
  经 ApiClientFactory 创建以复用既有 token / 401 处理
- domain/enums/EnumCatalog.kt：标签查找器，**不含任何硬编码兜底表**；
  不在表内的取值一律原样返回（api-client §1.1 的未知值回落红线）；
  platformLabelOrNull 供 deviceId 前缀这类「认识/不认识要走不同回落」的调用方用；
  空 id 或空 label 一律不入表（否则角标会显示空白，或查空串凭空借到别人的标签）
- core/prefs/EnumPreferences.kt：last-good 快照，baseUrl+username 指纹闸门，
  换服务器/账号即作废，登出清空
- EnumCatalogViewModel + LocalEnumCatalog：在 CyreneRoot 注入（与 LocalAppPrefs 同套路），
  聊天角标与管理页共读同一份
- 删除 platformLabels / personaModeLabels / moodLabels；MessageSource 与 AdminFormat
  改为查表，并保留各自原有的原样回落

为什么不留硬编码兜底表：没有登录就看不到任何消息，而权威表在登录前后即会拉取，
所以 last-good 快照几乎总是存在；留着硬编码表等于把「漂移」重新引进来，而且是无声的——
旧标签和新鲜标签长得一模一样。

不转换的：trace kind/status、memory scope、thinking.mode、WS session_busy 的 mode 集合——
它们都不在 /meta/enums 内，且原本就已按原样回落。

测试：115 全绿（88 → +27：MetaDtoRealPayload 8 / EnumCatalog 7 / EnumPrefs 3 /
MessageSource 8，AdminFormatTest 改写并 +1），其中 /meta/enums 与登录响应一样
用真实抓取的响应体做夹具。

app/src/main/kotlin/top/yeij/cyrene/app/AppContainer.kt

@@ -4,12 +4,15 @@ import android.content.Context
 import top.yeij.cyrene.core.auth.AuthManager
 import top.yeij.cyrene.core.auth.SessionStore
 import top.yeij.cyrene.core.prefs.AppSettings
+import top.yeij.cyrene.core.prefs.EnumPreferences
 import top.yeij.cyrene.core.prefs.SessionPreferences
 import top.yeij.cyrene.data.api.AdminApi
 import top.yeij.cyrene.data.api.ApiClientFactory
+import top.yeij.cyrene.data.api.MetaApi
 import top.yeij.cyrene.data.api.SessionsApi
 import top.yeij.cyrene.data.repository.AdminRepository
 import top.yeij.cyrene.data.repository.MessageRepository
+import top.yeij.cyrene.data.repository.MetaRepository
 import top.yeij.cyrene.data.repository.SessionRepository
 import top.yeij.cyrene.data.ws.ChatSocket
 
@@ -18,6 +21,7 @@ class AppContainer(context: Context) {
 
     val sessionStore: SessionStore = SessionStore(context.applicationContext)
     val sessionPreferences: SessionPreferences = SessionPreferences(context.applicationContext)
+    val enumPreferences: EnumPreferences = EnumPreferences(context.applicationContext)
     val appSettings: AppSettings = AppSettings(context.applicationContext)
     val authManager: AuthManager = AuthManager(sessionStore)
 
@@ -67,6 +71,28 @@ class AppContainer(context: Context) {
 
     val adminRepository: AdminRepository get() = AdminRepository(adminApi)
 
+    private var cachedMetaApi: MetaApi? = null
+    private var cachedMetaBaseUrl: String? = null
+
+    /** 枚举权威表客户端；同样与 [sessionsApi] 同源（同一 baseUrl、同一 token/401 处理）。 */
+    val metaApi: MetaApi
+        get() {
+            val baseUrl = authManager.currentBaseUrl
+            val cached = cachedMetaApi
+            if (cached != null && cachedMetaBaseUrl == baseUrl) return cached
+            val created = ApiClientFactory.create(
+                baseUrl = baseUrl,
+                service = MetaApi::class.java,
+                tokenProvider = { sessionStore.load().token },
+                onUnauthorized = { authManager.onSessionExpired() },
+            )
+            cachedMetaBaseUrl = baseUrl
+            cachedMetaApi = created
+            return created
+        }
+
+    val metaRepository: MetaRepository get() = MetaRepository(metaApi)
+
     fun createChatSocket(): ChatSocket = ChatSocket(
         baseUrlProvider = { authManager.currentBaseUrl },
         tokenProvider = { sessionStore.load().token },

app/src/main/kotlin/top/yeij/cyrene/app/CyreneRoot.kt

@@ -11,19 +11,27 @@ import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.platform.LocalView
 import androidx.core.view.WindowCompat
+import androidx.lifecycle.viewmodel.compose.viewModel
+import androidx.lifecycle.viewmodel.initializer
+import androidx.lifecycle.viewmodel.viewModelFactory
 import top.yeij.cyrene.core.prefs.AppPrefs
 import top.yeij.cyrene.core.prefs.LocalAppPrefs
 import top.yeij.cyrene.core.prefs.ThemeMode
 import top.yeij.cyrene.core.theme.CyreneTheme
+import top.yeij.cyrene.domain.enums.LocalEnumCatalog
 import top.yukonga.miuix.kmp.theme.ColorSchemeMode
 
 /**
- * 应用根：读 App 偏好 → 决定 Miuix 主题模式 → 通过 [LocalAppPrefs] 下发给渲染层，
+ * 应用根：读 App 偏好 → 决定 Miuix 主题模式 → 通过 [LocalAppPrefs] / [LocalEnumCatalog] 下发给渲染层，
  * 同时把系统栏图标明暗跟着主题走（否则浅色模式下白字白底看不见）。
  */
 @Composable
 fun CyreneRoot(container: AppContainer) {
     val prefs by container.appSettings.data.collectAsState(initial = AppPrefs())
+    val enumCatalogViewModel: EnumCatalogViewModel = viewModel(
+        factory = viewModelFactory { initializer { EnumCatalogViewModel(container) } },
+    )
+    val catalog by enumCatalogViewModel.catalog.collectAsState()
     val darkTheme = when (prefs.themeMode) {
         ThemeMode.System -> isSystemInDarkTheme()
         ThemeMode.Light -> false
@@ -41,7 +49,10 @@ fun CyreneRoot(container: AppContainer) {
         }
     }
 
-    CompositionLocalProvider(LocalAppPrefs provides prefs) {
+    CompositionLocalProvider(
+        LocalAppPrefs provides prefs,
+        LocalEnumCatalog provides catalog,
+    ) {
         CyreneTheme(mode = prefs.themeMode.toColorSchemeMode()) {
             CyreneApp(container)
         }

app/src/main/kotlin/top/yeij/cyrene/app/EnumCatalogViewModel.kt

@@ -0,0 +1,53 @@
+package top.yeij.cyrene.app
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import top.yeij.cyrene.core.auth.SessionState
+import top.yeij.cyrene.domain.enums.EnumCatalog
+
+/**
+ * 枚举权威表（api-client §1.1）的应用级持有者：先用本地快照渲染，再拉一次权威表。
+ *
+ * - 登录 / 静默重登后拉取；**拉取失败保持现状**（快照或原样 id），绝不因此清空角标；
+ * - 快照按 `baseUrl + username` 指纹认领：换服务器/账号即作废；
+ * - 登出时落盘快照与内存标签一并清掉（此时界面只剩登录页，不会闪空角标）。
+ */
+class EnumCatalogViewModel(private val container: AppContainer) : ViewModel() {
+
+    private val _catalog = MutableStateFlow(EnumCatalog.Empty)
+    val catalog: StateFlow<EnumCatalog> = _catalog.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            container.authManager.state.collect { state ->
+                if (state == SessionState.LoggedOut) {
+                    container.enumPreferences.clear()
+                    _catalog.value = EnumCatalog.Empty
+                    return@collect
+                }
+                val fingerprint = fingerprint()
+                // 先用快照渲染（没有就原样显示 id），拉取不阻塞首帧
+                val snapshot = container.enumPreferences.data.first()
+                _catalog.value = EnumCatalog.of(snapshot.tableFor(fingerprint))
+                if (state is SessionState.LoggedIn) refresh(fingerprint)
+            }
+        }
+    }
+
+    private fun refresh(fingerprint: String) {
+        viewModelScope.launch {
+            container.metaRepository.enums().onSuccess { table ->
+                container.enumPreferences.save(table, fingerprint)
+                _catalog.value = EnumCatalog.of(table)
+            }
+        }
+    }
+
+    private fun fingerprint(): String =
+        "${container.authManager.currentBaseUrl}|${container.sessionStore.load().username.orEmpty()}"
+}

app/src/main/kotlin/top/yeij/cyrene/core/prefs/EnumPreferences.kt

@@ -0,0 +1,63 @@
+package top.yeij.cyrene.core.prefs
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import top.yeij.cyrene.data.api.ApiClientFactory
+import top.yeij.cyrene.data.api.dto.EnumTableDto
+
+private val Context.enumDataStore: DataStore<Preferences> by preferencesDataStore("cyrene_enums")
+
+/**
+ * 枚举权威表的本地回退快照（§1.1）。
+ *
+ * @param table 上次成功拉取的权威表；拉取失败时先用它渲染（绝不因此清空角标）
+ * @param fingerprint `baseUrl + username`：换服务器/账号后快照作废
+ */
+data class EnumPrefs(
+    val table: EnumTableDto? = null,
+    val fingerprint: String = "",
+) {
+
+    /** 指纹匹配才认这份快照——绝不把别的服务器/账号的标签拿来用。 */
+    fun tableFor(fingerprint: String): EnumTableDto? = table?.takeIf { this.fingerprint == fingerprint }
+}
+
+class EnumPreferences(context: Context) {
+
+    private val json = ApiClientFactory.json
+
+    private val store: DataStore<Preferences> = context.applicationContext.enumDataStore
+
+    val data: Flow<EnumPrefs> = store.data.map { prefs ->
+        EnumPrefs(
+            table = prefs[KEY_TABLE].decodeTable(),
+            fingerprint = prefs[KEY_FINGERPRINT].orEmpty(),
+        )
+    }
+
+    suspend fun save(table: EnumTableDto, fingerprint: String) {
+        store.edit { prefs ->
+            prefs[KEY_TABLE] = json.encodeToString(EnumTableDto.serializer(), table)
+            prefs[KEY_FINGERPRINT] = fingerprint
+        }
+    }
+
+    /** 登出 / 切换服务器时清空。 */
+    suspend fun clear() {
+        store.edit { it.clear() }
+    }
+
+    private fun String?.decodeTable(): EnumTableDto? = this
+        ?.let { runCatching { json.decodeFromString(EnumTableDto.serializer(), it) }.getOrNull() }
+
+    private companion object {
+        val KEY_TABLE = stringPreferencesKey("enum_table")
+        val KEY_FINGERPRINT = stringPreferencesKey("enum_fingerprint")
+    }
+}

app/src/main/kotlin/top/yeij/cyrene/data/api/MetaApi.kt

@@ -0,0 +1,16 @@
+package top.yeij.cyrene.data.api
+
+import top.yeij.cyrene.data.api.dto.EnumTableDto
+import retrofit2.Response
+import retrofit2.http.GET
+
+/**
+ * 共享枚举权威表端点（api-client §1.1 / api-reference §3.7）。
+ * 任意已认证角色可读（与 `GET /sessions` 同级），无 token 回 `401`；
+ * 纯内存投影，没有其它错误码。按本工程惯例单独成接口。
+ */
+interface MetaApi {
+
+    @GET("api/v1/meta/enums")
+    suspend fun enums(): Response<ApiEnvelope<EnumTableDto>>
+}

app/src/main/kotlin/top/yeij/cyrene/data/api/dto/MetaDto.kt

@@ -0,0 +1,29 @@
+package top.yeij.cyrene.data.api.dto
+
+import kotlinx.serialization.Serializable
+
+/**
+ * `GET /api/v1/meta/enums` 表内一项（api-client §1.1）。
+ * [id] 是**唯一可比对**的值（契约 id 为小写、大小写敏感）；[label] 只是显示默认值，
+ * 自带 i18n 的客户端可以覆盖。
+ */
+@Serializable
+data class EnumItemDto(
+    val id: String = "",
+    val label: String = "",
+)
+
+/**
+ * `platform` / `mood` / `mode` 的共享枚举权威表——客户端**不必硬编码**即可拿到稳定映射。
+ *
+ * 字段全部带默认值：只下发部分表（或 `null`）时仍能解码，缺失的那一类按「表内无此项」
+ * 走原样回落，而不是让整次解码失败。
+ * [unknown] 是机器可读的未知值回落约定，当前恒为 `"display-raw"`（原样显示，见 §1.1 红线）。
+ */
+@Serializable
+data class EnumTableDto(
+    val platforms: List<EnumItemDto> = emptyList(),
+    val moods: List<EnumItemDto> = emptyList(),
+    val modes: List<EnumItemDto> = emptyList(),
+    val unknown: String = "",
+)

app/src/main/kotlin/top/yeij/cyrene/data/repository/MetaRepository.kt

@@ -0,0 +1,22 @@
+package top.yeij.cyrene.data.repository
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import top.yeij.cyrene.data.api.MetaApi
+import top.yeij.cyrene.data.api.apiCall
+import top.yeij.cyrene.data.api.dto.EnumTableDto
+
+/**
+ * 枚举权威表取数层（api-client §1.1）。
+ * 仓库不持有持久化状态：调用方失败时保留上次快照（见 [top.yeij.cyrene.core.prefs.EnumPreferences]）。
+ */
+class MetaRepository(
+    private val api: MetaApi,
+    private val dispatcher: CoroutineDispatcher = Dispatchers.IO,
+) {
+
+    suspend fun enums(): Result<EnumTableDto> = withContext(dispatcher) {
+        apiCall { api.enums() }
+    }
+}

app/src/main/kotlin/top/yeij/cyrene/domain/admin/AdminFormat.kt

@@ -2,6 +2,7 @@ package top.yeij.cyrene.domain.admin
 
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonObject
+import top.yeij.cyrene.domain.enums.EnumCatalog
 import top.yeij.cyrene.domain.parse.ContentPart
 import top.yeij.cyrene.domain.parse.parse
 import java.math.BigDecimal
@@ -72,32 +73,12 @@ private val traceStatusLabels = mapOf(
     "error" to "失败",
 )
 
-private val personaModeLabels = mapOf(
-    "chat" to "对话",
-    "code" to "代码",
-    "home" to "家居",
-    "work" to "工作",
-    "docs" to "文档",
-    "voice" to "语音",
-    "vision" to "视觉",
-    "agents" to "智能体",
-    "settings" to "设置",
-)
-
 private val memoryScopeLabels = mapOf(
     "user" to "用户",
     "persona" to "人格",
     "project" to "项目",
 )
 
-private val moodLabels = mapOf(
-    "calm" to "平静",
-    "happy" to "开心",
-    "excited" to "兴奋",
-    "sad" to "低落",
-    "angry" to "生气",
-)
-
 /**
  * 未知取值回落约定（api-client §1 红线）：不在表中的取值**原样返回**——
  * 不丢弃、不报错、不替换占位符。服务端新增取值属非破坏性变更。
@@ -106,11 +87,16 @@ fun traceKindLabel(raw: String): String = traceKindLabels[raw] ?: raw
 
 fun traceStatusLabel(raw: String): String = traceStatusLabels[raw] ?: raw
 
-fun personaModeLabel(raw: String): String = personaModeLabels[raw] ?: raw
+/**
+ * `mode` / `mood` 的标签来自 `/meta/enums` 的权威表（[catalog]），客户端不再硬编码——
+ * 表里没有的取值同样原样返回（[EnumCatalog] 负责该回落）。
+ * `trace` / `memory` 那几类**不在**该端点的表内，各自保留本地映射（见上）。
+ */
+fun personaModeLabel(raw: String, catalog: EnumCatalog): String = catalog.modeLabel(raw)
 
 fun memoryScopeLabel(raw: String): String = memoryScopeLabels[raw] ?: raw
 
-fun moodLabel(raw: String): String = moodLabels[raw] ?: raw
+fun moodLabel(raw: String, catalog: EnumCatalog): String = catalog.moodLabel(raw)
 
 /** 三态展示：null（未配置）与 true/false 是**三种不同**状态，不能合并。 */
 fun triStateLabel(value: Boolean?): String = when (value) {

app/src/main/kotlin/top/yeij/cyrene/domain/enums/EnumCatalog.kt

@@ -0,0 +1,63 @@
+package top.yeij.cyrene.domain.enums
+
+import androidx.compose.runtime.staticCompositionLocalOf
+import top.yeij.cyrene.data.api.dto.EnumItemDto
+import top.yeij.cyrene.data.api.dto.EnumTableDto
+
+/**
+ * 枚举标签查找器（api-client §1.1）：`/meta/enums` 抓到什么就查什么。
+ *
+ * **未知取值回落（红线）**：不在表内的取值一律**原样返回**——不丢弃、不报错、不替换占位符、
+ * 不猜测；服务端新增取值属非破坏性变更，不得因此清空角标或中断渲染。
+ *
+ * 因此这里**没有任何硬编码兜底表**：宁可显示原始 id，也不能让客户端自建的表与服务端漂移。
+ * 还没拿到表（未登录 / 首次拉取失败且无快照）时用 [Empty]，一切原样显示。
+ *
+ * 判定只比对 `id`（大小写敏感，契约 id 为小写）；`label` 仅作显示默认值。
+ */
+class EnumCatalog private constructor(
+    private val platforms: Map<String, String>,
+    private val moods: Map<String, String>,
+    private val modes: Map<String, String>,
+) {
+
+    /** 表内 → 默认标签；不在表内 → 原始值。 */
+    fun platformLabel(id: String): String = platforms[id] ?: id
+
+    fun moodLabel(id: String): String = moods[id] ?: id
+
+    fun modeLabel(id: String): String = modes[id] ?: id
+
+    /**
+     * 表内 → 默认标签；不在表内 → `null`。
+     * 给「认识」与「不认识」需要走**不同**回落的调用方用（如 `deviceId` 前缀：
+     * 认识的平台名取友好标签，不认识的原样显示整串 `deviceId`，而不是只留前缀）。
+     */
+    fun platformLabelOrNull(id: String): String? = platforms[id]
+
+    companion object {
+        /** 尚无权威表：一切原样显示。 */
+        val Empty = EnumCatalog(emptyMap(), emptyMap(), emptyMap())
+
+        fun of(table: EnumTableDto?): EnumCatalog = if (table == null) {
+            Empty
+        } else {
+            EnumCatalog(
+                platforms = table.platforms.toLabels(),
+                moods = table.moods.toLabels(),
+                modes = table.modes.toLabels(),
+            )
+        }
+
+        /**
+         * 空 id 不入表：否则查空串会拿到别人的标签，等于凭空造出一个标签。
+         * 空 label 同样不入表：查得到却没有标签只会把角标显示成空白，不如原样显示 id。
+         */
+        private fun List<EnumItemDto>.toLabels(): Map<String, String> = mapNotNull { item ->
+            item.takeIf { it.id.isNotBlank() && it.label.isNotBlank() }?.let { it.id to it.label }
+        }.toMap()
+    }
+}
+
+/** 全局注入枚举标签查找器，供聊天角标 / 管理页等深层组件读取（与 `LocalAppPrefs` 同套路）。 */
+val LocalEnumCatalog = staticCompositionLocalOf { EnumCatalog.Empty }

app/src/main/kotlin/top/yeij/cyrene/ui/admin/AdminPersonaScreen.kt

@@ -25,6 +25,7 @@ import top.yeij.cyrene.domain.admin.moodLabel
 import top.yeij.cyrene.domain.admin.orDash
 import top.yeij.cyrene.domain.admin.personaModeLabel
 import top.yeij.cyrene.domain.admin.triStateLabel
+import top.yeij.cyrene.domain.enums.LocalEnumCatalog
 import top.yeij.cyrene.ui.common.PreferenceCard
 import top.yukonga.miuix.kmp.basic.Text
 import top.yukonga.miuix.kmp.theme.MiuixTheme
@@ -62,6 +63,7 @@ fun AdminPersonaScreen(viewModel: AdminViewModel, role: AdminRole, onBack: () ->
 
 @Composable
 private fun PersonaCard(persona: PersonaSummaryDto) {
+    val catalog = LocalEnumCatalog.current
     PreferenceCard {
         Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 12.dp)) {
             Row(verticalAlignment = Alignment.CenterVertically) {
@@ -76,11 +78,14 @@ private fun PersonaCard(persona: PersonaSummaryDto) {
             }
             PersonaDetail("id", persona.id)
             PersonaDetail("character", persona.character.ifBlank { "-" })
-            // mode 是开放集合：未知取值原样显示。
-            PersonaDetail("mode", personaModeLabel(persona.mode).ifBlank { "-" })
+            // mode 是开放集合：权威表里没有的取值原样显示。
+            PersonaDetail("mode", personaModeLabel(persona.mode, catalog).ifBlank { "-" })
             PersonaDetail("记忆域", persona.memoryNamespace.ifBlank { "-" })
             // mood 为空表示「该角色暂无被跟踪的情绪」，不伪造默认值。
-            PersonaDetail("情绪", persona.mood?.takeIf { it.isNotBlank() }?.let(::moodLabel) ?: "暂无")
+            PersonaDetail(
+                "情绪",
+                persona.mood?.takeIf { it.isNotBlank() }?.let { moodLabel(it, catalog) } ?: "暂无",
+            )
             PersonaDetail("思考", thinkingLabel(persona.thinking))
             persona.avatar?.let { PersonaDetail("avatar", it) }
         }

app/src/main/kotlin/top/yeij/cyrene/ui/chat/MessageBubble.kt

@@ -20,6 +20,7 @@ import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
 import top.yeij.cyrene.core.prefs.LocalAppPrefs
 import top.yeij.cyrene.data.api.dto.HistoryMessageDto
+import top.yeij.cyrene.domain.enums.LocalEnumCatalog
 import top.yeij.cyrene.domain.parse.ContentPart
 import top.yeij.cyrene.domain.parse.ParsedBubble
 import top.yeij.cyrene.domain.parse.parse
@@ -43,13 +44,16 @@ private const val CURSOR = "▍"
 @Composable
 fun MessageBubble(message: HistoryMessageDto) {
     val isUser = message.role == "user"
+    // 这里的 `chat` 是 **mode id**，与 `/meta/enums` 的 modes 表里那一条同源但用途不同：
+    // 表只能给「id → 标签」，说不出哪个 mode 是「按 markup 切气泡的聊天式渲染」，
+    // 所以这条字面量刻意保留为客户端渲染契约，不表驱动。
     val isChat = message.mode.isNullOrBlank() || message.mode == "chat"
     val bubbles = remember(message.content, isChat) {
         val parsed = if (isChat) parse(message.content).filterNot { it.isEmpty } else emptyList()
         parsed.ifEmpty { listOf(plainBubble(message.content)) }
     }
 
-    MessageGroup(isUser = isUser, footer = messageSourceLabel(message)) {
+    MessageGroup(isUser = isUser, footer = messageSourceLabel(message, LocalEnumCatalog.current)) {
         message.thinking?.takeIf { it.isNotBlank() }?.let { ThinkingCard(it) }
         message.image?.takeIf { it.isNotBlank() }?.let { ChatImage(it) }
         bubbles.forEachIndexed { index, bubble ->

app/src/main/kotlin/top/yeij/cyrene/ui/chat/MessageSource.kt

@@ -1,42 +1,39 @@
 package top.yeij.cyrene.ui.chat
 
 import top.yeij.cyrene.data.api.dto.HistoryMessageDto
-
-private val platformLabels = mapOf(
-    "web" to "Web",
-    "kook" to "KOOK",
-    "weixin-ilink" to "微信",
-    "qq-obv11" to "QQ",
-    "telegram" to "Telegram",
-    "webhook" to "Webhook",
-)
+import top.yeij.cyrene.domain.enums.EnumCatalog
 
 /**
  * 来源角标（S1.3）：每条消息默认显示来源。
  * - 主人发的 → 「来自 X」（从哪一端发出）
  * - 昔涟发的 → 「发送至 X」（回到哪一端）
  * 优先用 `deviceId` 区分具体端，再回落到 `platform`；两者都没有则不显示。
+ *
+ * 平台名到标签的映射来自 `/meta/enums` 的权威表（[catalog]），**不含任何硬编码表**：
+ * 表里没有的取值原样显示（红线），未登录 / 尚无快照时全部原样。
  */
-fun messageSourceLabel(message: HistoryMessageDto): String? {
-    val name = sourceName(message) ?: return null
+fun messageSourceLabel(message: HistoryMessageDto, catalog: EnumCatalog): String? {
+    val name = sourceName(message, catalog) ?: return null
     val verb = if (message.role == "assistant") "发送至" else "来自"
     return "$verb $name"
 }
 
-private fun sourceName(message: HistoryMessageDto): String? {
+private fun sourceName(message: HistoryMessageDto, catalog: EnumCatalog): String? {
     val deviceId = message.deviceId
     if (!deviceId.isNullOrBlank()) {
+        // 下面两条是 device 粒度、与平台表无关的端标识，不参与权威表映射。
         if (deviceId.startsWith("voiceassist")) return "安卓"
         if (deviceId.startsWith("web:")) {
             val browser = deviceId.removePrefix("web:").substringBefore(':')
             return "Web($browser)"
         }
-        // IM 端 deviceId 形如 <平台名>:<配置id>:<uid>，只取平台名做友好显示
-        platformLabels[deviceId.substringBefore(':')]?.let { return it }
-        return deviceId
+        // IM 端 deviceId 形如 <平台名>:<配置id>:<uid>，只取平台名做友好显示；
+        // 平台名不在表里（服务端新增渠道）则整串原样显示，不丢信息也不猜。
+        val platform = deviceId.substringBefore(':')
+        return catalog.platformLabelOrNull(platform) ?: deviceId
     }
 
     val platform = message.platform
-    if (!platform.isNullOrBlank()) return platformLabels[platform] ?: platform
+    if (!platform.isNullOrBlank()) return catalog.platformLabel(platform)
     return null
 }