dsh-workspace-api-key 0.2.15 → 0.2.17

package/README.md

@@ -26,6 +26,8 @@ session key  →  workspace key  →  system default
 - **A search switch per workspace** — every workspace row carries a `同步搜索 API` checkbox. Ticked, the `web_search` / `web_fetch` calls made by sessions in that directory use the key they would use for chat (`session → workspace → system default`); unticked, they keep the key the official 设置 → 插件 → 网页搜索 page manages. A session with its own key always wins, so "sync on, session configured separately" spends the session key, not the search key.
 - **Search warnings that arrive before the failure** — when a search key is configured but `启用新版 Web 搜索 API` is off, or when the new API is on but its key ref is empty, the panel shows a warning banner and the entering-session overlay says it too, in one line you can act on. The overlay stays quiet about search problems when the search provider is not the one in use.
 - **A usage guide** — `使用说明` at the top of the panel recommends two keys: a chat default (`default`) and a search default (`search-default`), so the two budgets stay separate; it also draws the cascade and lists the situations that trigger a warning.
+- **A way back from Settings** — Settings → API Key 分配 keeps an "open the panel" button and explains the overflow-menu and reload routes, so an unpinned sidebar icon is never a dead end.
+- **Language-aware UI** — the panel follows the web GUI language from `@deepseek-ai/dsh-client-locale`: English when the GUI is English, Chinese when it is Chinese. Answers produced by the host half (connection-test details, search warnings) are translated in the browser half, so the panel does not mix languages.
 
 ## How it works
 
@@ -79,7 +81,7 @@ The command forwards its arguments to pnpm inside the profile directory, so the
 pnpm add dsh-workspace-api-key          # or: npm install dsh-workspace-api-key
 ```
 
-Pin a version with `dsh-workspace-api-key@0.2.15`, or install straight from the repository with `dsh-workspace-api-key@github:COH2357/dsh-workspace-api-key` (a git-hosted plugin is built from source on install).
+Pin a version with `dsh-workspace-api-key@0.2.17`, or install straight from the repository with `dsh-workspace-api-key@github:COH2357/dsh-workspace-api-key` (a git-hosted plugin is built from source on install).
 
 Then add `"dsh-workspace-api-key"` to `dsh.profile.bundles` in that profile's `package.json` and restart DSH. For local development, use a link instead:
 
@@ -91,7 +93,7 @@ Then add `"dsh-workspace-api-key"` to `dsh.profile.bundles` in that profile's `p
 
 ```sh
 node test/host.test.mjs     # 177 assertions
-node test/client.test.mjs   # 173 assertions
+node test/client.test.mjs   # 180 assertions
 ```
 
 Neither suite needs a running DSH process. The host suite drives `apply()` against a mock context (fake `credentials`, `workspaceRegistry`, `agents`, `sessionController`, `sessions`, `webServer`, stubbed `fetch`) and covers ref derivation, the session → workspace → default cascade, workspace matching, redirecting a second adapter's `apiKeyEnv`, clearing back to the default, 401/402/429/5xx classification, the loopback and origin checks, state persistence, the session probe including the `{items}` envelope, the live-session fallback, and subagent and blank sessions being hidden, and the search scope with a stand-in `web` service and a stand-in settings service: the legacy route keeping the chat cascade, the new provider keeping its own key, the workspace switch taking over, a session key outranking both, the panel's own search default key being used and cleared, the three search warnings, and the search connection test. The client suite loads `lib/client.js` through a minimal `window.__ModuleLoader__` plus a small React runtime, renders the panel and the overlay, and asserts slot registration, the first render, session expand/collapse, per-session saving and testing, sessions recovered from the browser-side store when the host has none (with `displayTitle` winning and subagent sessions hidden), the ungrouped-directory card, the stale and mismatch prompts, the "go configure" hand-off, graceful degradation without a session list, back-navigation when `ctx.get('layout')` only becomes available after the plugin was applied, and the search UI: the switch on every workspace row, the `/wsk-api/search-sync` call it makes, the warning banner, and the usage dialog.

package/README.zh.md

@@ -26,6 +26,8 @@ DSH 只从一个全局凭据 ref（默认 `DEEPSEEK_API_KEY`）解析 DeepSeek k
 - **每个工作区一个搜索开关** —— 每个工作区行上都有「同步搜索 API」复选框。勾选后，该目录下会话发出的 `web_search` / `web_fetch` 请求改用它们聊天时用的那把 key（会话 → 工作区 → 系统默认）；不勾选则继续用官方「设置 → 插件 → 网页搜索」里配置的那把 key。会话自己配了 key 时永远优先，所以「工作区同步、会话单独设置」花的是会话那把 key，而不是搜索默认 key。
 - **在失败之前就提醒的搜索告警** —— 配了搜索 key 但没打开「启用新版 Web 搜索 API」，或者新版 API 打开了但它的 key ref 是空的，面板会显示提醒条，点进会话时的覆盖层也会用一句可直接照做的话说明；当生效的搜索通道不是新版 API 时，覆盖层不会拿搜索问题打扰你。
 - **使用说明** —— 面板顶部有「使用说明」，推荐两把 key 分工：聊天默认用 `default`，搜索默认用 `search-default`，两份预算互不干扰；里面还画了层级，并列出了会触发提醒的几种情况。
+- **面板入口也能从设置里找回来** —— 「设置 → API Key 分配」里还有一个「打开 API Key 分配面板」按钮：侧栏图标被取消固定时，点它就能回到这里；那里也写明了「更多」菜单和刷新页面两条找回途径。
+- **界面跟随 DSH 语言** —— 面板跟随 `@deepseek-ai/dsh-client-locale`：Web 界面是英文时显示英文，是中文时保持中文；宿主半边返回的提示（连接测试详情、搜索提醒）也在浏览器半边翻译，界面不会中英混排。
 
 ## 实现方式
 
@@ -79,7 +81,7 @@ dsh plugin --profile web add dsh-workspace-api-key
 pnpm add dsh-workspace-api-key          # 或者：npm install dsh-workspace-api-key
 ```
 
-锁版本用 `dsh-workspace-api-key@0.2.15`；直接从仓库装则用 `dsh-workspace-api-key@github:COH2357/dsh-workspace-api-key`（git 来源的插件会在安装时现场构建）。
+锁版本用 `dsh-workspace-api-key@0.2.17`；直接从仓库装则用 `dsh-workspace-api-key@github:COH2357/dsh-workspace-api-key`（git 来源的插件会在安装时现场构建）。
 
 然后把 `"dsh-workspace-api-key"` 加进该 profile `package.json` 的 `dsh.profile.bundles`，重启 DSH。本地开发用 link 代替：
 
@@ -91,7 +93,7 @@ pnpm add dsh-workspace-api-key          # 或者：npm install dsh-workspace-api
 
 ```sh
 node test/host.test.mjs     # 177 条断言
-node test/client.test.mjs   # 173 条断言
+node test/client.test.mjs   # 180 条断言
 ```
 
 两个套件都不需要启动 DSH。宿主套件用一个假 ctx（假的 `credentials`、`workspaceRegistry`、`agents`、`sessionController`、`sessions`、`webServer`，以及打桩的 `fetch`）驱动 `apply()`，覆盖 ref 派生、会话→工作区→默认的级联、工作区匹配、把第二个适配器的 `apiKeyEnv` 一起重定向、清回默认、401/402/429/5xx 的判定、回环与来源校验、状态落盘，以及会话探针（含 `{items}` 信封与 live 兜底）。浏览器套件通过一个极小的 `window.__ModuleLoader__` 与自制 React 运行时加载 `lib/client.js`，渲染出面板与覆盖层，断言槽注册、首屏渲染、会话折叠/展开、会话级保存与测试、宿主列不出会话时从浏览器端存储恢复会话（标题取 `displayTitle`、隐藏子代理会话与空会话、浏览器端只认识一部分会话时不挤掉宿主行）、会话列表服务晚于插件提供时的重试、未分组目录卡片、失效与不匹配提醒、「去配置」的交接、没有会话列表时的降级，以及 `ctx.get('layout')` 在插件 apply 之后才可用时返回键仍然有效。宿主套件还带一个假的 `web` 服务与假的设置服务，验证搜索作用域：旧通道沿用聊天层级、新版通道用它自己的 key、工作区开关接管、会话 key 压过两者、面板自己的搜索默认 key 生效与清除、三类搜索提醒，以及搜索连接测试。浏览器套件覆盖搜索相关界面：每个工作区行的「同步搜索 API」复选框、它发出的 `/wsk-api/search-sync`、提醒条与「使用说明」弹窗。

package/lib/client.js

@@ -5,9 +5,276 @@ window.__ModuleLoader__.load({
     Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 
     const React = require('react')
-    const h = React.createElement
+    const rawCreateElement = React.createElement
     const { useState, useEffect, useCallback, useRef } = React
 
+    // ─────────────────────────── localization ───────────────────────────
+    // The web GUI's language is owned by @deepseek-ai/dsh-client-locale. This
+    // plugin keeps one English catalog keyed by the Chinese source copy: when
+    // the active language is Chinese the catalog is bypassed and every string
+    // is used exactly as written, otherwise rendered text is translated.
+    // Messages produced by the host half (which has no locale of its own) are
+    // covered by EN_HOST and the pattern rules below.
+    const EN = {
+      "勾选后：该目录下会话的搜索/抓取请求改用聊天用的那把 key（会话单独配置仍然优先）。不勾则用「设置 → 插件 → 网页搜索」里配置的 key。": "When checked: search/fetch calls from sessions in this directory use the chat key (session-level keys still win). Unchecked, they use the key from Settings → Plugins → Web Search.",
+  "连接正常": "Connected",
+  "key 无效": "Invalid key",
+  "余额不足": "Out of balance",
+  "被限流": "Rate limited",
+  "无法连接": "Unreachable",
+  "测试失败": "Test failed",
+  "鉴权失败": "Authentication failed",
+  "本会话专属": "Session key",
+  "工作区专属": "Workspace key",
+  "系统默认": "System default",
+  "未记录服务商": "Provider not recorded",
+  "未知": "Unknown",
+  "你打开了「启用新版 Web 搜索 API」，但搜索 key 还没有配置：这个会话里的搜索会直接失败。": "\"New Web Search API\" is enabled, but no search key is configured: searches in this session will fail.",
+  "你配置了搜索专用的 API Key，但「启用新版 Web 搜索 API」没有打开，所以那把 key 现在不会被使用。": "A search-only API key is configured, but \"New Web Search API\" is off, so that key is not being used.",
+  "（空会话）": "(empty session)",
+  "（没有目录）": "(no directory)",
+  "模型未知": "Model unknown",
+  "搜索默认 key 已清除：搜索改用官方搜索页里配的那把 key。": "Search default key cleared: searches use the key configured on the official search page.",
+  "官方「网页搜索」页仍指向原来的 ref，两处暂时不是同一把。": "The official \"Web Search\" page still points at the previous ref, so the two are temporarily different keys.",
+  "官方「网页搜索」页的 API Key 输入框也指向这个 ref：以后两边改的是同一把 key。": "The API Key field on the official \"Web Search\" page now points at this ref too: both places edit the same key.",
+  "已同步：该目录下会话的搜索请求改用聊天用的那把 key（会话单独配置仍然优先）。": "Synced: searches from sessions in this directory use the chat key (a session-level key still wins).",
+  "已取消同步：该目录的搜索请求改用「设置 → 插件 → 网页搜索」里配置的 key。": "Sync off: searches in this directory use the key from Settings → Plugins → Web Search.",
+  "旧版（未重启应用）": "older version (app not restarted)",
+  "不可用": "Unavailable",
+  "（live 兜底）": "(live fallback)",
+  "（不指定）": "(not specified)",
+  "改用系统默认": "Use system default",
+  "为该工作区指定一把专属 key；留空并保存即继续使用系统默认。": "Set a dedicated key for this workspace; leave empty and save to keep using the system default.",
+  "sk-…（留空 = 使用上层设置）": "sk-… (empty = use the level above)",
+  "这把 key 属于哪个服务商（用于进入会话时判断是否匹配）": "Which provider this key belongs to (used to detect mismatches when entering a session)",
+  "保存中…": "Saving…",
+  "保存": "Save",
+  "用这把 key 测试": "Test this key",
+  "取消": "Cancel",
+  "凭据引用：保存时由宿主按这个会话/目录的 ID 生成，保存后这里会显示出来": "Credential ref: generated by the host from this session/directory ID on save; it appears here afterwards.",
+  "key 已失效": "Key invalid",
+  "服务商不匹配": "Provider mismatch",
+  " · 未配置 key": " · no key configured",
+  "清除标记": "Clear flag",
+  "测试中…": "Testing…",
+  "测试连接": "Test connection",
+  "收起": "Collapse",
+  "配置": "Configure",
+  "折叠会话": "Collapse sessions",
+  "展开会话": "Expand sessions",
+  "专属 key": "Dedicated key",
+  "未分组目录": "Ungrouped directory",
+  "目录已不存在": "Directory no longer exists",
+  "勾选后：该目录下会话的搜索/抓取请求改用聊天用的那把 key": "When checked: search/fetch calls from sessions in this directory use the chat key",
+  "（会话单独配置仍然优先）。不勾则用「设置 → 插件 → 网页搜索」里配置的 key。": "(session-level keys still win). Unchecked, they use the key from Settings → Plugins → Web Search.",
+  "同步搜索 API": "Sync search API",
+  "搜索用这里的 key": "Searches use this key",
+  "搜索用搜索默认 key": "Searches use the search default key",
+  "搜索用搜索插件里的 key": "Searches use the search plugin's key",
+  "（搜索插件）": "(search plugin)",
+  "使用说明": "Usage guide",
+  "推荐用法（两把 key，各管一件事）": "Recommended setup (two keys, one job each)",
+  "先到「设置 → 模型」配一把系统默认 key，例如就叫 ": "First, set a system default key in Settings → Models, named e.g. ",
+  "。没有单独配置的地方都用它聊天。": ". Everywhere without its own key uses it for chat.",
+  "再回到本页的「搜索默认 key」，放一把搜索专用的 key，例如 ": "Then, back on this page, put a search-only key in \"Search default key\", e.g. ",
+  "。搜索请求默认用它，和聊天那把分开计费。": ". Searches use it by default, billed separately from the chat key.",
+  "保存时插件会把官方「设置 → 插件 → 网页搜索」里的 API Key 指向同一个 ref，": "On save the plugin points the official Settings → Plugins → Web Search API Key at the same ref,",
+  "所以那个页面显示、修改的都是这把 key，两边不会各存一份。": "so that page shows and edits this key; there is no second copy.",
+  "平时不用再管：聊天按工作区/会话的 key 走，搜索走搜索默认 key，两边账单互不影响。": "Nothing else to do: chat uses workspace/session keys, search uses the search default key, and the bills don't affect each other.",
+  "想按工作区核算搜索花费": "Track search spend per workspace",
+  "在该工作区行勾上「同步搜索 API」：这个目录下会话的搜索就改用聊天那套层级 key": "Tick \"Sync search API\" on that workspace: searches from its sessions use the chat key cascade",
+  "（会话 key → 工作区 key → 系统默认），不再用搜索默认 key。": "(session key → workspace key → system default) instead of the search default key.",
+  "不勾的目录继续用搜索默认 key。两种方式可以同时存在，一个工作区一个样。": "Unticked directories keep using the search default key. Both styles can coexist, one per workspace.",
+  "搜索 key 的优先级（从高到低）": "Search key precedence (highest first)",
+  "会话单独配置的 key —— 该会话的聊天与搜索都用它，永远最优先": "A session's own key — used for both chat and search in that session, always first",
+  "工作区勾了「同步搜索 API」—— 该工作区下会话的搜索改用：工作区 key → 系统默认 key": "Workspace with \"Sync search API\" on — its sessions search with: workspace key → system default key",
+  "搜索默认 key —— 没勾同步时，搜索用它": "Search default key — used by searches when sync is off",
+  "官方「网页搜索」页里配的那把 —— 面板没配搜索默认 key 时的兜底": "The key on the official \"Web Search\" page — fallback when this panel has no search default key",
+  "（它默认就是系统默认 key ": "(by default that is the system default key ",
+  "，与聊天共用）": ", shared with chat)",
+  "官方「设置 → 插件 → 网页搜索」那个 Key 框怎么办": "What about the Key field in Settings → Plugins → Web Search?",
+  "官方那个输入框写的永远是「当前 API 段的 ": "That field always writes the ref named by the current API section's ",
+  " 指向的 ref」，默认就是聊天那把（": ", which defaults to the chat key (",
+  "本插件启动后会把它指到插件自己的搜索 ref（": "On startup this plugin points it at its own search ref (",
+  "等于把官方那个 key 设置接管过来：从今往后官方页里填的也是这把搜索 key，": "This takes over the official key setting: from now on that page edits this search key,",
+  "不会再把聊天 key 顶掉，也不会出现「两把搜索 key 各管一半」。": "so it can no longer overwrite the chat key or split search between two keys.",
+  "所以日常只需要在本页配搜索 key，官方那一页可以不管；本插件只改 ": "So normally you only configure the search key here and can leave the official page alone; the plugin only changes ",
+  " 这个指向，永远不动你的 key 内容。": " that pointer and never touches your key values.",
+  "会被提醒的几种情况": "Situations that trigger a warning",
+  "配了搜索 key，但没打开「启用新版 Web 搜索 API」→ 那把 key 其实不会被用到，面板顶部会提示。": "A search key is set but \"New Web Search API\" is off → that key is unused; the panel shows a notice.",
+  "打开了新版搜索 API，但既没有搜索默认 key、官方那把也是空的 → 任何搜索都会失败，面板顶部会提示。": "The new search API is on but neither the search default key nor the official key is set → every search fails; the panel shows a notice.",
+  "勾了同步，但该工作区既没有专属 key、系统默认 key 也没配 → 会提示先去配一把。": "Sync is on but the workspace has no key and no system default key is set → a notice asks you to set one first.",
+  "搜索默认 key 存好了，但官方页还指着聊天那把 → 会提示点「同步到官方设置」，一键对齐。": "The search default key is saved but the official page still points at the chat key → a notice offers \"Sync to official settings\" to align them.",
+  "原则": "Principles",
+  "提醒只报告、不替你改 key。插件绝不会自动切换或替换你的 key，避免计费被悄悄改到别的账号上。": "Warnings only report; they never change your key. The plugin never switches or replaces keys automatically, so billing cannot silently move to another account.",
+  "知道了": "Got it",
+  "尚未配置系统默认 API Key": "No system default API key configured",
+  "当前没有任何可用的 DEEPSEEK_API_KEY。可以到「设置 → 模型」里配置系统默认 key，": "There is no usable DEEPSEEK_API_KEY. Set a system default key in Settings → Models,",
+  "也可以直接为某个工作区写一把专属 key。": "or write a dedicated key for a workspace below.",
+  "可以重新配置这把 key，或让该工作区改用系统默认设置。": "Reconfigure this key, or let the workspace fall back to the system default.",
+  "重新配置": "Reconfigure",
+  "改用系统设置": "Use system settings",
+  "稍后": "Later",
+  "返回会话": "Back to conversation",
+  "返回": "Back",
+  "API Key 分配": "API Keys",
+  "按工作区 / 会话隔离计费": "Per-workspace and per-session billing",
+  "刷新中…": "Refreshing…",
+  "刷新": "Refresh",
+  "请确认 DSH Web 服务正在运行、且本插件的宿主半边已加载。": "Make sure the DSH Web service is running and this plugin's host half is loaded.",
+  "宿主端插件还是旧版本：所以看不到会话列表，也没有按会话配置。": "The host half is still an older version: no session list and no per-session configuration.",
+  "请「完全退出」DSH Desktop 再重新打开（关闭窗口 / 刷新页面都不够：宿主代码只在启动时加载）。": "Fully quit DSH and reopen it (closing the window or refreshing the page is not enough: host code loads at startup).",
+  "当前 DSH 版本没有提供会话列表服务，只能按工作区配置 key。": "This DSH version provides no session list service; only workspace keys can be configured.",
+  "宿主报告 0 个会话，浏览器端也没有拿到会话列表，所以没有可展开的列表。": "The host reports 0 sessions and the browser has no session list either, so there is nothing to expand.",
+  "只有「会话记录里带 cwd」的会话才能挂到工作区/未分组目录下。": "Only sessions whose log records a cwd can be attached to a workspace or ungrouped directory.",
+  "拿到会话了，但没有一个能对上工作区/目录（路径不匹配）。": "Sessions were found, but none matches a workspace/directory (path mismatch).",
+  "系统默认设置": "System default",
+  "未配置": "Not configured",
+  "被环境变量遮蔽（只读）": "Shadowed by an environment variable (read-only)",
+  "没有单独配置的工作区/会话，一律使用这把 key。": "Workspaces and sessions without their own key use this one.",
+  "搜索默认 key": "Search default key",
+  "已配置": "Configured",
+  "搜索请求默认用它，和聊天那把 key 分开计费。": "Searches use it by default, billed separately from chat.",
+  "工作区勾了「同步搜索 API」时改用该工作区的聊天层级；会话单独配置永远最优先。": "With \"Sync search API\" on for a workspace, searches use its chat cascade; a session's own key always wins.",
+  "官方「网页搜索」页现在仍指着聊天那把 key（DEEPSEEK_API_KEY）——保存一次搜索 key 后，插件会把它接过来。": "The official \"Web Search\" page still points at the chat key (DEEPSEEK_API_KEY); after you save a search key once, the plugin takes it over.",
+  "你之前保存过搜索默认 key，但官方页还指向聊天那把。": "You saved a search default key earlier, but the official page still points at the chat key.",
+  "同步到官方设置": "Sync to official settings",
+  "sk-…（留空 = 用官方搜索页里配的那把）": "sk-… (empty = use the key from the official search page)",
+  "搜索默认": "Search default",
+  "清除": "Clear",
+  "展开工作区可以看到它下面的会话，并单独给某个会话指定 key（会话 > 工作区 > 系统默认）。": "Expand a workspace to see its sessions and give one its own key (session > workspace > system default).",
+  "还没有工作区。先在侧栏「工作区」里新建一个。": "No workspaces yet. Create one in the Workspaces section of the sidebar first.",
+  "这些目录里的会话没有挂在工作区下（侧栏的「未分组」），同样可以单独配置。": "Sessions in these directories are not under a workspace (the sidebar's \"Ungrouped\"); they can be configured the same way.",
+  "只有侧栏真的会显示的目录才列在这里（刚建好、还没发过消息的空会话不算）。": "Only directories the sidebar actually shows are listed (brand-new empty sessions with no message do not count).",
+  "这些目录已经不是注册的工作区了，对应的 key 仍留在凭据库里。可改用系统默认以清理。": "These directories are no longer registered workspaces; their keys remain in the credential store. Switch them to the system default to clean up.",
+  "专属 key 存进 DSH 凭据库中的独立引用，因此换 key 不写进会话日志、也不影响历史回放。": "Dedicated keys are stored as separate refs in the DSH credential store, so changing a key never enters session logs or affects replay.",
+  "这个会话用的 API Key 已失效": "The API key for this session is invalid",
+  "这个会话的 API Key 可能不匹配": "The API key for this session may not match",
+  "网页搜索的配置需要确认": "Web search configuration needs attention",
+  "会话": "Session",
+  "模型": "Model",
+  "生效 key": "Effective key",
+  "插件不会自动更换 key —— 用哪把 key 由你决定，避免计费被悄悄改到别的账号上。": "The plugin never swaps keys automatically — you decide which key is used, so billing cannot silently move to another account.",
+  "去配置": "Configure",
+  "继续用当前 key": "Keep current key",
+  "清除本会话配置": "Clear this session's setting",
+  "API Key 提醒": "API Key notice",
+  "面板入口": "Panel entry",
+  "左侧栏的「API Key 分配」图标可以像其他面板一样取消固定。取消之后它还在侧栏底部的「更多」菜单里，并不是被卸载。": "The \"API Key Allocation\" icon in the left sidebar can be unpinned like any other panel. Unpinning only moves it into the sidebar's More menu; the panel itself is not removed.",
+  "如果找不到它，可以：": "If you cannot find it, you can:",
+  "点下面的按钮，直接打开面板；": "press the button below to open the panel directly;",
+  "或者点侧栏底部的「更多」菜单，未固定的面板都列在那里；": "or open the More menu at the sidebar's bottom, where unpinned panels are listed;",
+  "再或者按 Ctrl+R 刷新页面 —— 面板固定状态只存在内存里，刷新就会恢复默认。": "or press Ctrl+R to reload the page — the pin state lives only in memory, so a reload restores the defaults.",
+  "打开 API Key 分配面板": "Open the API Key Allocation panel",
+  "已切到该面板：如果它还是没出现，说明面板正在加载，稍等一下。": "Switched to that panel: if it has not appeared yet, it is still loading — give it a moment.",
+  "这里同时管着每个工作区 / 会话的 key 与搜索通道；面板右上角的「使用说明」有完整的优先级说明。": "This panel manages the key and search channel of every workspace and session; the \"How to use\" button in its header explains the full precedence order."
+}
+
+    const EN_HOST = {
+      "现在搜索走的是 DeepSeek Messages 通道，用的是聊天那把 key。": "Searches currently use the DeepSeek Messages channel and the chat key.",
+      "这些工作区勾了「同步搜索 API」，但既没有工作区专属 key，系统默认 key 也没配置：": "These workspaces have \"Sync search API\" on, but neither a workspace key nor a system default key is configured:",
+      "搜索会用空 key 发出去。给这些工作区各配一把，或先配好系统默认 key。": "searches would go out with an empty key. Give each of them a key, or configure the system default first.",
+      "当前搜索走旧的 Messages 通道，它本来就用聊天通道的 key（会话 → 工作区 → 系统默认），": "Searches use the legacy Messages channel, which already uses the chat key (session → workspace → system default),",
+      "所以这个开关只影响「启用新版 Web 搜索 API」之后的行为。": "so this switch only affects behavior after \"New Web Search API\" is enabled.",
+      "要让它生效，请到「设置 → 插件 → 网页搜索」打开那个开关；若暂时不想用新版 API，可以忽略本条。": "To enable it, turn on the switch in Settings → Plugins → Web Search; ignore this notice if you do not want the new API for now.",
+      "点面板上的「同步到官方设置」，官方页的 API Key 输入框就会改到同一个 ref，两处以后改的是同一把 key。": "Click \"Sync to official settings\" in the panel and the official API Key field moves to the same ref; both then edit the same key.",
+      "在本面板的「搜索默认 key」里保存一把后，插件会自动把官方配置指过去，两边就分开了。": "Save one under \"Search default key\" in this panel and the plugin points the official setting at it, separating the two.",
+  "连接正常，key 可用": "Connected; key works",
+  "key 无效（401/403）": "Invalid key (401/403)",
+  "被限流（429），但 key 本身可能有效": "Rate limited (429), but the key itself may be valid",
+  "余额/配额不足（402）": "Balance/quota exhausted (402)",
+  "请求参数被拒": "request rejected",
+  "credentials 服务不可用": "credentials service unavailable",
+  "credentials 服务不可用，无法写入 API key": "credentials service unavailable; cannot store the API key",
+  "面板请求超时（8 秒）：DSH 的某个服务没有响应": "Panel request timed out (8s): a DSH service did not respond",
+  "缺少 sessionId": "missing sessionId",
+  "缺少 path": "missing path",
+  "无法为该会话生成凭据引用": "cannot derive a credential ref for this session",
+  "无法为该路径生成凭据引用": "cannot derive a credential ref for this path",
+  "无法规范化该路径": "cannot normalize this path",
+  "搜索 key 已配置，但「启用新版 Web 搜索 API」没打开": "Search key is configured, but \"New Web Search API\" is off",
+  "搜索默认 key 还没配置：搜索暂时沿用聊天那把 key": "No search default key yet: searches currently share the chat key",
+  "新版 Web 搜索 API 已启用，但搜索 key 没有配置": "New Web Search API is enabled, but no search key is configured",
+  "搜索默认 key 已配置，但「启用新版 Web 搜索 API」没打开": "Search default key is configured, but \"New Web Search API\" is off",
+  "搜索默认 key 已保存，但官方「网页搜索」页仍指向聊天那把": "Search default key is saved, but the official \"Web Search\" page still points at the chat key",
+  "「同步搜索 API」现在没有区别": "\"Sync search API\" currently makes no difference"
+}
+
+    const EN_HOST_RULES = [
+      [/^官方页现在绑的是 (.+)（与聊天共用），所以那里看不到 (.+) 这把。$/, "The official page binds $1 (shared with chat), so it cannot show $2."],
+      [/^所以面板里的 (.+) 不会被使用。$/, "so $1 in the panel is not used."],
+      [/^现在搜索读的是 (.+)（和聊天共用一把），所以搜索与聊天的花费算在一起。$/, "Searches read $1 (shared with chat), so search and chat spending are counted together."],
+      [/^鉴权通过（HTTP 400：(.+)）$/, "Authenticated (HTTP 400: $1)"],
+      [/^请求超时（(\d+)ms）：(.+)$/, "Request timed out ($1ms): $2"],
+      [/^（404：端点 (.+) 不存在，检查 baseURL）$/, "(404: endpoint $1 not found; check baseURL)"],
+      [/^（404：端点 (.+) 不存在，检查「Search \/ Fetch API 基础地址」）$/, "(404: endpoint $1 not found; check the Search / Fetch API base URL)"],
+      [/^搜索通道正常，返回 (\d+) 条结果（(.+)）$/, "Search channel OK, $1 result(s) ($2)"],
+      [/^搜索通道正常（(.+)）$/, "Search channel OK ($1)"]
+    ]
+
+    const i18n = { english: false, listeners: new Set() }
+
+    function refreshI18n(ctx) {
+      let english = false
+      try {
+        const locale = ctx?.get?.('locale')
+        const snapshot = locale?.getSnapshot?.() ?? locale?.getLocale?.()
+        const active = snapshot?.active
+        english = typeof active === 'string' && !active.toLowerCase().startsWith('zh')
+      } catch {
+        english = false
+      }
+      i18n.english = english
+    }
+
+    function notifyI18n() {
+      for (const listener of [...i18n.listeners]) {
+        try { listener() } catch { /* a broken listener must not break the switch */ }
+      }
+    }
+
+    function tr(value) {
+      if (typeof value !== 'string' || i18n.english !== true) return value
+      const hit = EN[value] ?? EN_HOST[value]
+      if (hit !== undefined) return hit
+      for (const [pattern, replacement] of EN_HOST_RULES) {
+        if (pattern.test(value)) return value.replace(pattern, replacement)
+      }
+      return value
+    }
+
+    function tf(zh, en) {
+      return i18n.english === true ? en : zh
+    }
+
+    function trChild(value) {
+      if (typeof value === 'string') return tr(value)
+      if (Array.isArray(value)) return value.map(trChild)
+      return value
+    }
+
+    const TRANSLATED_PROPS = ['title', 'placeholder', 'aria-label', 'alt', 'label']
+    function h(type, props, ...children) {
+      let next = props
+      if (props !== null && typeof props === 'object') {
+        next = { ...props }
+        for (const key of TRANSLATED_PROPS) {
+          if (typeof next[key] === 'string') next[key] = tr(next[key])
+        }
+      }
+      return rawCreateElement(type, next, ...children.map(trChild))
+    }
+
+    function useI18n() {
+      const [, setTick] = useState(0)
+      useEffect(() => {
+        if (host.ctx !== null) refreshI18n(host.ctx)
+        const listener = () => setTick((tick) => tick + 1)
+        i18n.listeners.add(listener)
+        return () => { i18n.listeners.delete(listener) }
+      }, [])
+    }
+
     const API_BASE = '/wsk-api'
     const STYLE_ID = 'wsk-styles'
     const PANEL_ID = 'workspace-api-key'
@@ -144,15 +411,15 @@ window.__ModuleLoader__.load({
       try {
         res = await window.fetch(`${API_BASE}${path}`, init)
       } catch (err) {
-        throw new Error(`无法访问插件宿主接口（${String(err?.message ?? err)}）`)
+        throw new Error(tf(`无法访问插件宿主接口（${String(err?.message ?? err)}）`, `Could not reach the plugin host API (${String(err?.message ?? err)})`))
       }
       let body = null
       try {
         body = await res.json()
       } catch {
-        throw new Error(`宿主接口返回了非 JSON 响应（HTTP ${res.status}）`)
+        throw new Error(tf(`宿主接口返回了非 JSON 响应（HTTP ${res.status}）`, `The host API returned a non-JSON response (HTTP ${res.status})`))
       }
-      if (body === null || body === undefined) throw new Error(`宿主接口返回空响应（HTTP ${res.status}）`)
+      if (body === null || body === undefined) throw new Error(tf(`宿主接口返回空响应（HTTP ${res.status}）`, `The host API returned an empty response (HTTP ${res.status})`))
       if (res.ok !== true || body.ok === false) throw new Error(body.error ?? `HTTP ${res.status}`)
       return body
     }
@@ -164,27 +431,27 @@ window.__ModuleLoader__.load({
 
     function verdictText(verdict) {
       switch (verdict) {
-        case 'ok': return '连接正常'
-        case 'invalid': return 'key 无效'
-        case 'quota': return '余额不足'
-        case 'rate-limit': return '被限流'
-        case 'unreachable': return '无法连接'
-        default: return '测试失败'
+        case 'ok': return tr('连接正常')
+        case 'invalid': return tr('key 无效')
+        case 'quota': return tr('余额不足')
+        case 'rate-limit': return tr('被限流')
+        case 'unreachable': return tr('无法连接')
+        default: return tr('测试失败')
       }
     }
 
     function invalidReason(flag) {
       if (flag === null || flag === undefined) return undefined
       if (flag.status !== 'invalid') return undefined
-      return flag.message ?? '鉴权失败'
+      return tr(flag.message) ?? tr('鉴权失败')
     }
 
     // 生效层级：会话级 > 工作区级 > 系统默认
     function levelText(level) {
       switch (level) {
-        case 'session': return '本会话专属'
-        case 'workspace': return '工作区专属'
-        default: return '系统默认'
+        case 'session': return tr('本会话专属')
+        case 'workspace': return tr('工作区专属')
+        default: return tr('系统默认')
       }
     }
 
@@ -194,9 +461,9 @@ window.__ModuleLoader__.load({
 
     function mismatchText(mismatch) {
       if (mismatch === null || mismatch === undefined) return undefined
-      const key = mismatch.keyProvider ?? '未记录服务商'
-      const session = mismatch.sessionProvider ?? '未知'
-      return `这把 key 是为「${key}」准备的，当前会话用的是「${session}」`
+      const key = mismatch.keyProvider ?? tr('未记录服务商')
+      const session = mismatch.sessionProvider ?? tr('未知')
+      return tf(`这把 key 是为「${key}」准备的，当前会话用的是「${session}」`, `This key is for "${key}", but the current session uses "${session}"`)
     }
 
     /**
@@ -207,19 +474,19 @@ window.__ModuleLoader__.load({
       if (search === null || search === undefined) return undefined
       if (search.apiChannel === true) {
         if (search.keyConfigured === false) {
-          return '你打开了「启用新版 Web 搜索 API」，但搜索 key 还没有配置：这个会话里的搜索会直接失败。'
+          return tr('你打开了「启用新版 Web 搜索 API」，但搜索 key 还没有配置：这个会话里的搜索会直接失败。')
         }
         return undefined
       }
       if (search.leftoverKey === true) {
-        return '你配置了搜索专用的 API Key，但「启用新版 Web 搜索 API」没有打开，所以那把 key 现在不会被使用。'
+        return tr('你配置了搜索专用的 API Key，但「启用新版 Web 搜索 API」没有打开，所以那把 key 现在不会被使用。')
       }
       return undefined
     }
 
     function sessionLabel(session) {
       const title = typeof session.title === 'string' && session.title !== '' ? session.title : undefined
-      return title ?? (session.blank === true ? '（空会话）' : String(session.sessionId).slice(0, 12))
+      return title ?? (session.blank === true ? tr('（空会话）') : String(session.sessionId).slice(0, 12))
     }
 
     // ─────────────────── 会话树：宿主行 + 浏览器端列表 ───────────────────
@@ -431,8 +698,8 @@ window.__ModuleLoader__.load({
     }
 
     function modelText(session) {
-      if (typeof session.provider !== 'string' || session.provider === '') return '模型未知'
-      return `${session.provider} / ${session.model ?? '默认模型'}`
+      if (typeof session.provider !== 'string' || session.provider === '') return tr('模型未知')
+      return tf(`${session.provider} / ${session.model ?? '默认模型'}`, `${session.provider} / ${session.model ?? 'default model'}`)
     }
 
     // ─────────────────────────────── 图标 ───────────────────────────────
@@ -505,7 +772,50 @@ window.__ModuleLoader__.load({
 
     // ─────────────────────────────── 主页面 ───────────────────────────────
 
+    /**
+     * 「设置 → API Key 分配」这一栏：侧栏图标没了也能从这里回到面板。
+     *
+     * 侧栏的面板图标是 DSH 的「面板固定」状态（`@deepseek-ai/dsh-client-ui-sidebar`
+     * 的 panel-pins）。取消固定只把图标挪进侧栏底部的「更多」菜单，面板本身没被卸载；
+     * 那套固定状态只保存在内存里，刷新页面就恢复默认，而且没有对外 API，
+     * 插件没法替用户把图标钉回去 —— 所以这里提供一个不会消失的入口。
+     */
+    function SettingsSection() {
+      useI18n()
+      const [opened, setOpened] = useState(false)
+      const openPanel = () => {
+        try {
+          const layout = host.ctx === null ? undefined : host.ctx.get('layout')
+          if (layout === undefined || layout === null) return
+          if (typeof layout.selectPanel !== 'function') return
+          layout.selectPanel(PANEL_ID)
+          setOpened(true)
+        } catch {
+          /* layout 不可用时保持说明文字，用户还能走「更多」菜单 */
+        }
+      }
+      return h('div', { className: 'wsk-body' },
+        h('div', { className: 'wsk-card' },
+          h('h4', null, '面板入口'),
+          h('div', { className: 'wsk-hint' },
+            '左侧栏的「API Key 分配」图标可以像其他面板一样取消固定。取消之后它还在侧栏底部的「更多」菜单里，并不是被卸载。'),
+          h('div', { className: 'wsk-hint' }, '如果找不到它，可以：'),
+          h('ul', { className: 'wsk-hint', style: { margin: '6px 0 10px 18px' } },
+            h('li', null, '点下面的按钮，直接打开面板；'),
+            h('li', null, '或者点侧栏底部的「更多」菜单，未固定的面板都列在那里；'),
+            h('li', null, '再或者按 Ctrl+R 刷新页面 —— 面板固定状态只存在内存里，刷新就会恢复默认。')),
+          h('button', { type: 'button', className: 'wsk-btn primary', onClick: openPanel },
+            '打开 API Key 分配面板'),
+          opened
+            ? h('div', { className: 'wsk-hint', style: { marginTop: 8 } },
+                '已切到该面板：如果它还是没出现，说明面板正在加载，稍等一下。')
+            : null,
+          h('div', { className: 'wsk-hint', style: { marginTop: 10 } },
+            '这里同时管着每个工作区 / 会话的 key 与搜索通道；面板右上角的「使用说明」有完整的优先级说明。')))
+    }
+
     function WorkspaceKeyPage(props) {
+      useI18n()
       const [state, setState] = useState(null)
       const [error, setError] = useState(null)
       const [busy, setBusy] = useState(false)
@@ -646,12 +956,12 @@ window.__ModuleLoader__.load({
             setNotice({
               kind: 'ok',
               text: trimmed === ''
-                ? `${target.title}：已改用${scope === 'session' ? '上层' : '系统默认'}设置`
+                ? tf(`${target.title}：已改用${scope === 'session' ? '上层' : '系统默认'}设置`, `${target.title}: switched to the ${scope === 'session' ? 'level above' : 'system default'}`)
                 : target.kind === 'session'
-                  ? `${target.title}：已保存本会话专属 key`
+                  ? tf(`${target.title}：已保存本会话专属 key`, `${target.title}: saved a key for this session`)
                   : wasCleared
-                    ? `${target.title}：已改用系统默认设置`
-                    : `${target.title}：已保存专属 key`,
+                    ? tf(`${target.title}：已改用系统默认设置`, `${target.title}: switched back to the system default`)
+                    : tf(`${target.title}：已保存专属 key`, `${target.title}: saved a dedicated key`),
             })
           }
           return true
@@ -682,14 +992,14 @@ window.__ModuleLoader__.load({
           } else if (bound?.ok === false) {
             setNotice({
               kind: 'warn',
-              text: `key 已保存在 ${next?.search?.defaultRef ?? '搜索默认 ref'}，但没能改官方设置（${bound.reason}）：`
-                + '官方「网页搜索」页仍指向原来的 ref，两处暂时不是同一把。',
+              text: tf(`key 已保存在 ${next?.search?.defaultRef ?? '搜索默认 ref'}，但没能改官方设置（${bound.reason}）：`, `Key saved to ${next?.search?.defaultRef ?? 'the search default ref'}, but the official setting could not be changed (${bound.reason}):`)
+                + tf('官方「网页搜索」页仍指向原来的 ref，两处暂时不是同一把。', 'The official "Web Search" page still points at the previous ref, so the two are temporarily different keys.'),
             })
           } else {
             setNotice({
               kind: 'ok',
-              text: `搜索默认 key 已保存到 ${next?.search?.defaultRef ?? '搜索默认 ref'}，`
-                + '官方「网页搜索」页的 API Key 输入框也指向这个 ref：以后两边改的是同一把 key。',
+              text: tf(`搜索默认 key 已保存到 ${next?.search?.defaultRef ?? '搜索默认 ref'}，`, `Search default key saved to ${next?.search?.defaultRef ?? 'the search default ref'}, `)
+                + tf('官方「网页搜索」页的 API Key 输入框也指向这个 ref：以后两边改的是同一把 key。', 'The API Key field on the official "Web Search" page now points at this ref too: both places edit the same key.'),
             })
           }
         } catch (err) {
@@ -707,8 +1017,8 @@ window.__ModuleLoader__.load({
           applyState(next)
           const bound = next?.bound
           setNotice(bound?.ok === false
-            ? { kind: 'warn', text: `没能改官方设置：${bound.reason}` }
-            : { kind: 'ok', text: `已同步：官方「网页搜索」页现在绑定 ${next?.search?.officialRef ?? next?.search?.defaultRef ?? '同一个 ref'}，与面板改的是同一把 key。` })
+            ? { kind: 'warn', text: tf(`没能改官方设置：${bound.reason}`, `Could not change the official setting: ${bound.reason}`) }
+            : { kind: 'ok', text: tf(`已同步：官方「网页搜索」页现在绑定 ${next?.search?.officialRef ?? next?.search?.defaultRef ?? '同一个 ref'}，与面板改的是同一把 key。`, `Synced: the official "Web Search" page now binds ${next?.search?.officialRef ?? next?.search?.defaultRef ?? 'the same ref'} — the same key this panel edits.`) })
         } catch (err) {
           if (alive.current) setNotice({ kind: 'bad', text: `${err?.message ?? err}` })
         } finally {
@@ -766,7 +1076,7 @@ window.__ModuleLoader__.load({
           applyState(await api('/clear-flag', { method: 'POST', body: JSON.stringify(body) }))
           if (alive.current) {
             setTests((prev) => ({ ...prev, [id]: undefined }))
-            setNotice({ kind: 'info', text: `${title}：已清除失效标记` })
+            setNotice({ kind: 'info', text: tf(`${title}：已清除失效标记`, `${title}: invalid flag cleared`) })
           }
         } catch (err) {
           if (alive.current) setNotice({ kind: 'bad', text: String(err?.message ?? err) })
@@ -803,31 +1113,31 @@ window.__ModuleLoader__.load({
         if (state === null) return undefined
         const hostVersion = typeof state.pluginVersion === 'string'
           ? state.pluginVersion
-          : '旧版（未重启应用）'
+          : tr('旧版（未重启应用）')
         const sessions = probe === undefined
-          ? '未知'
+          ? tr('未知')
           : probe.available !== true
-            ? '不可用'
-            : `${probe.count} 个${probe.shape !== undefined ? `（${probe.shape}）` : ''}`
-              + (probe.source === 'sessions' ? '（live 兜底）' : '')
-        const listError = probe?.error !== undefined ? ` · list 报错：${probe.error}` : ''
-        const noCwd = probe?.withoutCwd > 0 ? ` · ${probe.withoutCwd} 个没有 cwd` : ''
-        const subs = probe?.subagents > 0 ? ` · 已跳过 ${probe.subagents} 个子代理会话` : ''
-        const blanks = (view?.sessionBlanks ?? 0) > 0 ? ` · 已跳过 ${view.sessionBlanks} 个空会话` : ''
+            ? tr('不可用')
+            : tf(`${probe.count} 个${probe.shape !== undefined ? `（${probe.shape}）` : ''}`, `${probe.count} session(s)${probe.shape !== undefined ? ` (${probe.shape})` : ''}`)
+              + (probe.source === 'sessions' ? tf('（live 兜底）', ' (live fallback)') : '')
+        const listError = probe?.error !== undefined ? tf(` · list 报错：${probe.error}`, ` · list() error: ${tr(probe.error)}`) : ''
+        const noCwd = probe?.withoutCwd > 0 ? tf(` · ${probe.withoutCwd} 个没有 cwd`, ` · ${probe.withoutCwd} without cwd`) : ''
+        const subs = probe?.subagents > 0 ? tf(` · 已跳过 ${probe.subagents} 个子代理会话`, ` · skipped ${probe.subagents} subagent session(s)`) : ''
+        const blanks = (view?.sessionBlanks ?? 0) > 0 ? tf(` · 已跳过 ${view.sessionBlanks} 个空会话`, ` · skipped ${view.sessionBlanks} empty session(s)`) : ''
         // 宿主只标注「这个目录里只有还没说过话的空会话」，列不列由本文件按侧栏语义决定
         // （空会话里只有当前打开的那一个算数）——所以这里说的是「宿主标了几个」。
         const blankDirs = Array.isArray(state.hiddenBlankDirs) && state.hiddenBlankDirs.length > 0
-          ? ` · ${state.hiddenBlankDirs.length} 个目录只有空会话（未分组里不列）`
+          ? tf(` · ${state.hiddenBlankDirs.length} 个目录只有空会话（未分组里不列）`, ` · ${state.hiddenBlankDirs.length} directories contain only empty sessions (not listed under Ungrouped)`)
           : ''
         const searchDiag = searchInfo === undefined
           ? ''
-          : ` · 搜索通道：${searchInfo.apiChannel === true ? '新版 API' : 'Messages'}`
-            + `（${searchInfo.keyRef ?? '—'}${searchInfo.keyMasked ? ` · ${searchInfo.keyMasked}` : ' · 未配置'}）`
-            + (searchInfo.syncCount > 0 ? ` · 已同步 ${searchInfo.syncCount} 个目录` : '')
-        return `插件 v${hostVersion} · 状态存储 v${state.storeVersion ?? '—'}`
-          + ` · 宿主会话列表：${sessions}${listError}${noCwd}${subs}`
-          + ` · 浏览器会话列表：${clientCount} 个${blanks}${blankDirs}`
-          + ` · 工作区 ${grouped.length} + 未分组 ${ungrouped.length} · 挂在目录下的会话 ${sessionTotal}`
+          : tf(` · 搜索通道：${searchInfo.apiChannel === true ? '新版 API' : 'Messages'}`, ` · search channel: ${searchInfo.apiChannel === true ? 'new API' : 'Messages'}`)
+            + tf(`（${searchInfo.keyRef ?? '—'}${searchInfo.keyMasked ? ` · ${searchInfo.keyMasked}` : ' · 未配置'}）`, ` (${searchInfo.keyRef ?? '—'}${searchInfo.keyMasked ? ` · ${searchInfo.keyMasked}` : ' · not configured'})`)
+            + (searchInfo.syncCount > 0 ? tf(` · 已同步 ${searchInfo.syncCount} 个目录`, ` · synced ${searchInfo.syncCount} director${searchInfo.syncCount === 1 ? 'y' : 'ies'}`) : '')
+        return tf(`插件 v${hostVersion} · 状态存储 v${state.storeVersion ?? '—'}`, `plugin v${hostVersion} · state store v${state.storeVersion ?? '—'}`)
+          + tf(` · 宿主会话列表：${sessions}${listError}${noCwd}${subs}`, ` · host sessions: ${sessions}${listError}${noCwd}${subs}`)
+          + tf(` · 浏览器会话列表：${clientCount} 个${blanks}${blankDirs}`, ` · browser sessions: ${clientCount}${blanks}${blankDirs}`)
+          + tf(` · 工作区 ${grouped.length} + 未分组 ${ungrouped.length} · 挂在目录下的会话 ${sessionTotal}`, ` · workspaces ${grouped.length} + ungrouped ${ungrouped.length} · sessions attached to directories ${sessionTotal}`)
           + searchDiag
       }
 
@@ -837,8 +1147,8 @@ window.__ModuleLoader__.load({
         const paths = Array.isArray(state.workspacePathSample) ? state.workspacePathSample : []
         if (cwds.length === 0 && paths.length === 0) return null
         return h('div', { className: 'wsk-hint', style: { marginTop: 4 } },
-          cwds.length > 0 ? h('div', null, `会话 cwd 样本：${cwds.join(' | ')}`) : null,
-          paths.length > 0 ? h('div', null, `工作区路径样本：${paths.join(' | ')}`) : null)
+          cwds.length > 0 ? h('div', null, tf(`会话 cwd 样本：${cwds.join(' | ')}`, `Session cwd samples: ${cwds.join(' | ')}`)) : null,
+          paths.length > 0 ? h('div', null, tf(`工作区路径样本：${paths.join(' | ')}`, `Workspace path samples: ${paths.join(' | ')}`)) : null)
       }
 
       const providerOptions = (current, fallback) => {
@@ -854,14 +1164,14 @@ window.__ModuleLoader__.load({
         const isSession = target.kind === 'session'
         const current = isSession ? target.level : target.configured === true ? 'workspace' : 'default'
         const fallbackLabel = isSession
-          ? `清除本会话配置（改回${target.workspaceConfigured === true ? '工作区' : '系统默认'}）`
+          ? tf(`清除本会话配置（改回${target.workspaceConfigured === true ? '工作区' : '系统默认'}）`, `Clear this session's setting (back to ${target.workspaceConfigured === true ? 'workspace' : 'system default'})`)
           : '改用系统默认'
         return h('div', { className: 'wsk-editor' },
           h('div', { className: 'wsk-hint' },
             isSession
-              ? `当前生效：${levelText(current)}${target.keyMasked ? `（${target.keyMasked}）` : ''}。`
+              ? tf(`当前生效：${levelText(current)}${target.keyMasked ? `（${target.keyMasked}）` : ''}。`, `Currently effective: ${levelText(current)}${target.keyMasked ? ` (${target.keyMasked})` : ''}.`)
               : target.configured === true
-                ? `该工作区当前使用专属 key${target.keyMasked ? `（${target.keyMasked}）` : ''}。留空并保存即恢复使用系统默认。`
+                ? tf(`该工作区当前使用专属 key${target.keyMasked ? `（${target.keyMasked}）` : ''}。留空并保存即恢复使用系统默认。`, `This workspace uses a dedicated key${target.keyMasked ? ` (${target.keyMasked})` : ''}. Leave empty and save to fall back to the system default.`)
                 : '为该工作区指定一把专属 key；留空并保存即继续使用系统默认。'),
           h('input', {
             className: 'wsk-input',
@@ -901,7 +1211,7 @@ window.__ModuleLoader__.load({
             }, '取消')),
           h('div', { className: 'wsk-hint' }, target.ref === undefined || target.ref === null
             ? '凭据引用：保存时由宿主按这个会话/目录的 ID 生成，保存后这里会显示出来'
-            : `凭据引用：${target.ref}`))
+            : tf(`凭据引用：${target.ref}`, `Credential ref: ${target.ref}`)))
       }
 
       const renderSession = (ws, session) => {
@@ -932,8 +1242,8 @@ window.__ModuleLoader__.load({
                   : null),
               h('div', { className: 'wsk-path' },
                 `${modelText(session)}` +
-                (session.effectiveKeyMasked ? ` · 生效 key ${session.effectiveKeyMasked}` : ' · 未配置 key') +
-                (hasOwn && session.keyMasked ? ` · 本会话 ${session.keyMasked}` : '')),
+                (session.effectiveKeyMasked ? tf(` · 生效 key ${session.effectiveKeyMasked}`, ` · effective key ${session.effectiveKeyMasked}`) : ' · 未配置 key') +
+                (hasOwn && session.keyMasked ? tf(` · 本会话 ${session.keyMasked}`, ` · this session ${session.keyMasked}`) : '')),
               reason !== undefined
                 ? h('div', { className: 'wsk-hint', style: { color: 'var(--wsk-bad)', marginTop: 3 } }, reason)
                 : null,
@@ -992,7 +1302,7 @@ window.__ModuleLoader__.load({
                       key: 'tgl', type: 'button', className: 'wsk-toggle',
                       title: open ? '折叠会话' : '展开会话',
                       onClick: () => toggle(ws.path),
-                    }, caretSvg(12, open), h('span', null, `会话 ${sessions.length}`))
+                    }, caretSvg(12, open), h('span', null, tf(`会话 ${sessions.length}`, `Sessions ${sessions.length}`)))
                   : null,
                 h('span', { key: 'n' }, title),
                 reason !== undefined
@@ -1034,9 +1344,9 @@ window.__ModuleLoader__.load({
                         : '搜索用搜索插件里的 key')),
               ws.kind !== 'orphan' && searchInfo?.apiChannel === true && ws.searchKeyMasked !== undefined
                 ? h('div', { key: 'sk', className: 'wsk-hint', style: { marginTop: 2 } },
-                    `搜索生效 key：${ws.searchKeyMasked || '未配置'}`,
+                    tf(`搜索生效 key：${ws.searchKeyMasked || '未配置'}`, `Effective search key: ${ws.searchKeyMasked || 'not configured'}`),
                     ws.searchSync === true
-                      ? `（${ws.configured === true ? '本目录专属' : '系统默认'}）`
+                      ? tf(`（${ws.configured === true ? '本目录专属' : '系统默认'}）`, ` (${ws.configured === true ? 'this directory' : 'system default'})`)
                       : '（搜索插件）')
                 : null,
               reason !== undefined
@@ -1136,10 +1446,10 @@ window.__ModuleLoader__.load({
         const ws = prompt.ws
         const reason = invalidReason(ws.invalid)
         return h(Dialog, {
-          title: `${ws.title} 的 API Key 已失效`,
+          title: tf(`${ws.title} 的 API Key 已失效`, `${ws.title}: API key invalid`),
           body: h('div', null,
             h('div', null, reason),
-            h('div', { className: 'wsk-hint', style: { marginTop: 6 } }, `工作区：${prettyPath(ws.path)}`),
+            h('div', { className: 'wsk-hint', style: { marginTop: 6 } }, tf(`工作区：${prettyPath(ws.path)}`, `Workspace: ${prettyPath(ws.path)}`)),
             h('div', { className: 'wsk-hint' }, '可以重新配置这把 key，或让该工作区改用系统默认设置。')),
           onDismiss: () => setPrompt(null),
           actions: [
@@ -1198,7 +1508,7 @@ window.__ModuleLoader__.load({
             : null,
           error !== null
             ? h('div', { className: 'wsk-msg bad', style: { marginBottom: 12 } },
-                `读取失败：${error}`,
+                tf(`读取失败：${error}`, `Failed to load: ${tr(error)}`),
                 h('div', { className: 'wsk-hint' }, '请确认 DSH Web 服务正在运行、且本插件的宿主半边已加载。'))
             : null,
           hostIsStale
@@ -1247,14 +1557,14 @@ window.__ModuleLoader__.load({
                   h('span', { key: 'r' }, defaultRef?.ref ?? DEFAULT_REF),
                   defaultRef?.configured === true
                     ? h('span', { key: 's', className: 'wsk-badge ok' },
-                        `已配置${defaultRef.source ? ` · ${defaultRef.source}` : ''}`)
+                        tf(`已配置${defaultRef.source ? ` · ${defaultRef.source}` : ''}`, `Configured${defaultRef.source ? ` · ${defaultRef.source}` : ''}`))
                     : h('span', { key: 's', className: 'wsk-badge bad' }, '未配置'),
                   defaultRef?.writable === false
                     ? h('span', { key: 'w', className: 'wsk-badge warn' }, '被环境变量遮蔽（只读）')
                     : null),
                 h('div', { className: 'wsk-hint' },
                   '没有单独配置的工作区/会话，一律使用这把 key。',
-                  defaultRef?.keyMasked ? ` 当前值：${defaultRef.keyMasked}` : '')),
+                  defaultRef?.keyMasked ? tf(` 当前值：${defaultRef.keyMasked}`, ` current value: ${defaultRef.keyMasked}`) : '')),
               h('div', { className: 'wsk-actions' },
                 h('button', {
                   type: 'button', className: 'wsk-btn',
@@ -1277,11 +1587,11 @@ window.__ModuleLoader__.load({
                       + '工作区勾了「同步搜索 API」时改用该工作区的聊天层级；会话单独配置永远最优先。'),
                     h('div', { className: 'wsk-hint' },
                       searchInfo.defaultConfigured === true && searchInfo.defaultKeyMasked
-                        ? `当前值：${searchInfo.defaultKeyMasked}。`
+                        ? tf(`当前值：${searchInfo.defaultKeyMasked}。`, `Current value: ${searchInfo.defaultKeyMasked}.`)
                         : '',
                       searchInfo.officialShared === true
                         ? '官方「网页搜索」页现在仍指着聊天那把 key（DEEPSEEK_API_KEY）——保存一次搜索 key 后，插件会把它接过来。'
-                        : `官方「网页搜索」页已由本插件接管：那里填的也是 ${searchInfo.officialRef ?? 'DEEPSEEK_API_KEY_SEARCH'} 这一把，不会再误改聊天 key。`),
+                        : tf(`官方「网页搜索」页已由本插件接管：那里填的也是 ${searchInfo.officialRef ?? 'DEEPSEEK_API_KEY_SEARCH'} 这一把，不会再误改聊天 key。`, `The official "Web Search" page is managed by this plugin: it edits ${searchInfo.officialRef ?? 'DEEPSEEK_API_KEY_SEARCH'}, so it can no longer overwrite the chat key.`)),
                     searchInfo.officialShared === true && searchInfo.ownedConfigured === true
                       ? h('div', { className: 'wsk-hint' },
                           '你之前保存过搜索默认 key，但官方页还指向聊天那把。',
@@ -1331,7 +1641,7 @@ window.__ModuleLoader__.load({
             : null,
 
           h('div', { className: 'wsk-card', style: { background: 'transparent', border: 0, padding: 0 } },
-            h('h4', { style: { marginBottom: 6 } }, `工作区（${grouped.length}）`),
+            h('h4', { style: { marginBottom: 6 } }, tf(`工作区（${grouped.length}）`, `Workspaces (${grouped.length})`)),
             h('div', { className: 'wsk-hint', style: { marginBottom: 6 } },
               '展开工作区可以看到它下面的会话，并单独给某个会话指定 key（会话 > 工作区 > 系统默认）。'),
             grouped.length === 0
@@ -1340,7 +1650,7 @@ window.__ModuleLoader__.load({
 
           ungrouped.length > 0
             ? h('div', { className: 'wsk-card' },
-                h('h4', null, `未分组目录（${ungrouped.length}）`),
+                h('h4', null, tf(`未分组目录（${ungrouped.length}）`, `Ungrouped directories (${ungrouped.length})`)),
                 h('div', { className: 'wsk-hint', style: { marginBottom: 6 } },
                   '这些目录里的会话没有挂在工作区下（侧栏的「未分组」），同样可以单独配置。'
                   + '只有侧栏真的会显示的目录才列在这里（刚建好、还没发过消息的空会话不算）。'),
@@ -1349,7 +1659,7 @@ window.__ModuleLoader__.load({
 
           orphans.length > 0
             ? h('div', { className: 'wsk-card' },
-                h('h4', null, `已失效的配置（${orphans.length}）`),
+                h('h4', null, tf(`已失效的配置（${orphans.length}）`, `Stale settings (${orphans.length})`)),
                 h('div', { className: 'wsk-hint', style: { marginBottom: 6 } },
                   '这些目录已经不是注册的工作区了，对应的 key 仍留在凭据库里。可改用系统默认以清理。'),
                 h('div', { className: 'wsk-list' }, orphans.map((ws) => renderWorkspace(ws))))
@@ -1357,7 +1667,7 @@ window.__ModuleLoader__.load({
 
           h('div', { className: 'wsk-hint' },
             '专属 key 存进 DSH 凭据库中的独立引用，因此换 key 不写进会话日志、也不影响历史回放。',
-            state?.statePath ? h('div', null, `状态文件：${state.statePath}`) : null,
+            state?.statePath ? h('div', null, tf(`状态文件：${state.statePath}`, `State file: ${state.statePath}`)) : null,
             diagText() !== undefined ? h('div', { className: 'wsk-diag' }, diagText()) : null)),
 
         renderPrompt(),
@@ -1368,6 +1678,7 @@ window.__ModuleLoader__.load({
 
     function createOverlayWatcher(ctx) {
       return function ApiKeyWatch() {
+        useI18n()
         const [prompt, setPrompt] = useState(null)
         const asked = useRef(new Set())
 
@@ -1489,7 +1800,7 @@ window.__ModuleLoader__.load({
               : '网页搜索的配置需要确认',
           body: h('div', null,
             kv('会话', prompt.title ?? String(prompt.sessionId ?? '').slice(0, 12)),
-            kv('模型', `${prompt.provider ?? '未知'} / ${prompt.model ?? '默认模型'}`),
+            kv('模型', tf(`${prompt.provider ?? '未知'} / ${prompt.model ?? '默认模型'}`, `${prompt.provider ?? 'Unknown'} / ${prompt.model ?? 'default model'}`)),
             kv('生效 key', `${levelText(prompt.level)}${prompt.keyMasked ? ` · ${prompt.keyMasked}` : ''}`),
             invalid !== undefined
               ? h('div', { className: 'wsk-hint', style: { marginTop: 8, color: 'var(--wsk-bad)' } }, invalid)
@@ -1520,13 +1831,21 @@ window.__ModuleLoader__.load({
     }
 
     function res2Upper(prompt) {
-      return prompt.level === 'session' ? '清除本会话配置' : '改用系统默认'
+      return prompt.level === 'session' ? tr('清除本会话配置') : tr('改用系统默认')
     }
 
     // ─────────────────────────────── 插件入口 ───────────────────────────────
 
     function apply(ctx) {
       ensureStyles()
+      refreshI18n(ctx)
+      const locale = ctx.get('locale')
+      if (locale !== undefined && locale !== null && typeof locale.subscribe === 'function') {
+        ctx.effect(() => locale.subscribe(() => {
+          refreshI18n(ctx)
+          notifyI18n()
+        }), 'workspace-api-key: locale subscription')
+      }
       const slots = ctx.get('slots')
       if (slots === undefined || slots === null) return
       host.ctx = ctx
@@ -1549,7 +1868,7 @@ window.__ModuleLoader__.load({
           name: 'sidebar.panellist',
           id: PANEL_ID,
           order: 1,
-          label: () => 'API Key 分配',
+          label: () => tr('API Key 分配'),
         }, KeyIcon)), 'workspace-api-key: sidebar row')
 
       ctx.effect(() => slots.inject('main', () =>
@@ -1559,12 +1878,20 @@ window.__ModuleLoader__.load({
           inject: () => ({ back, sessions: ctx.get('sessions') }),
         }, WorkspaceKeyPage)), 'workspace-api-key: main page')
 
+      ctx.effect(() => slots.inject('settings.section', () =>
+        slots.register({
+          name: 'settings.section',
+          id: PANEL_ID,
+          order: 60,
+          label: () => tr('API Key 分配'),
+        }, SettingsSection)), 'workspace-api-key: settings section')
+
       ctx.effect(() => slots.inject('shell.overlay', () =>
         slots.register({
           name: 'shell.overlay',
           id: OVERLAY_ID,
           order: 60,
-          label: 'API Key 提醒',
+          label: tr('API Key 提醒'),
         }, createOverlayWatcher(ctx))), 'workspace-api-key: session entry watcher')
     }
 

package/lib/index.js

@@ -83,18 +83,29 @@ const SEARCH_DEFAULT_REF = 'DEEPSEEK_API_KEY_SEARCH'
  *
  * 配置本身用缓存：`credentials.resolve` 是热路径，不能每次都去 `settings.describe()`。
  */
-/** 重新读一次官方「网页搜索」配置（同步，无缓存——配置随时可能被官方页改掉）。 */
+let webCache
+
+/** 重新读一次官方「网页搜索」配置（只在请求/面板刷新这类「非热路径」里调用）。 */
 function refreshWebCache(ctx) {
   try {
-    return readWebSettings(ctx)
+    webCache = readWebSettings(ctx)
   } catch {
-    return webDefaults()
+    webCache = webCache ?? webDefaults()
   }
+  return webCache
 }
 
-/** 取官方「网页搜索」配置。 */
+/**
+ * 取官方「网页搜索」配置——**只读缓存，绝不在 resolve 热路径里重新解析**。
+ *
+ * `settings.describe()` 会 interpolate 各条目的配置，而配置里可能有 `credential-ref`，
+ * 那等于从 credentials 服务内部再调回 credentials。0.2.15 就是在 resolve 里调 describe：
+ * 搜索 → resolve(搜索 ref) → describe → describe 又去 resolve → 服务自己等自己，
+ * promise 永远不 settle。表现就是 `web_search` 卡满 60 秒，面板接口也一起挂住。
+ * 缓存由 apply()、每个 HTTP 请求入口、面板刷新时更新。
+ */
 function currentWeb(ctx) {
-  return refreshWebCache(ctx)
+  return webCache ?? webDefaults()
 }
 
 /**
@@ -232,11 +243,11 @@ function workspaceIndex(ctx) {
 }
 
 /** cwd → 工作区描述；没有匹配工作区时回退成「以该目录为单位」。 */
-function locateWorkspace(ctx, cwd) {
+function locateWorkspace(ctx, cwd, index) {
   if (cwd === undefined) return undefined
   const norm = normPath(cwd)
   if (norm === undefined) return undefined
-  const hit = workspaceIndex(ctx).get(norm)
+  const hit = (index ?? workspaceIndex(ctx)).get(norm)
   if (hit !== undefined) return { ...hit, kind: 'workspace' }
   return { id: undefined, path: cwd, title: basename(cwd) || cwd, kind: 'directory' }
 }
@@ -245,7 +256,7 @@ function locateWorkspace(ctx, cwd) {
  * 给定会话/目录，算出当前生效的覆盖层级（纯函数，不读凭据）：
  * session → workspace → default。
  */
-function effectiveOverride(ctx, state, { sessionId, cwd }) {
+function effectiveOverride(ctx, state, { sessionId, cwd }, index) {
   if (sessionId !== undefined) {
     const sref = sessionRef(sessionId)
     if (sref !== undefined && state.overrides[sref] !== undefined) {
@@ -253,7 +264,9 @@ function effectiveOverride(ctx, state, { sessionId, cwd }) {
     }
   }
   if (cwd !== undefined) {
-    const ws = locateWorkspace(ctx, cwd)
+    // index 是可选的「工作区索引」快照：面板一次要算几十个会话，每行都去
+    // registry.list() 一遍会让整个事件循环卡住（0.2.16 实测 /state 要 50 秒）。
+    const ws = locateWorkspace(ctx, cwd, index)
     const wref = ws !== undefined ? derivedRef(ws.path) : undefined
     if (wref !== undefined && state.overrides[wref] !== undefined) {
       return { level: 'workspace', ref: wref, entry: state.overrides[wref], workspace: ws }
@@ -379,7 +392,7 @@ async function reconcileOfficialSearchRef(ctx) {
  *   旧 Messages 通道：搜索就在用聊天 key，固定返回搜索 ref。
  */
 async function searchRefFor(ctx, state, { sessionId, cwd, web, searchDefault }) {
-  const w = web ?? readWebSettings(ctx)
+  const w = web ?? currentWeb(ctx)
   if (!w.apiChannel) return w.searchKeyEnv
   const own = sessionOverrideRef(state, sessionId)
   if (own !== undefined) return own
@@ -792,8 +805,10 @@ function interceptableRefs(ctx, state) {
   // 搜索/抓取通道的 ref 也要拦：用户可能把「新版 Web 搜索 API」的 key 指到
   // 独立 ref（例如 DEEPSEEK_SEARCH_API_KEY）。不拦的话，勾了「同步搜索 API」
   // 也会静默不生效——面板显示已同步、实际还在用系统默认 key。
+  // 注意这里走 currentWeb（缓存）而不是 readWebSettings：本函数在 credentials.resolve
+  // 的热路径上被调用，每次都 settings.describe() 会把聊天通道一并拖慢。
   try {
-    const web = readWebSettings(ctx)
+    const web = currentWeb(ctx)
     for (const ref of [web.apiKeyEnv, web.legacyKeyEnv]) {
       if (typeof ref === 'string' && ref !== '') refs.add(ref)
     }
@@ -1294,6 +1309,16 @@ export function apply(ctx) {
 
   // ── 1. 包装 credentials.resolve（按 ref 分辨搜索/抓取通道）──────────
   refreshWebCache(ctx)
+  // 官方页改了「网页搜索」配置就丢掉缓存：解析热路径只读缓存，不能自己去 describe。
+  try {
+    ctx.effect(() =>
+      ctx.on('settings/document-updated', () => {
+        webCache = undefined
+      }),
+    )
+  } catch (err) {
+    log('settings listener unavailable: %s', String(err?.message ?? err))
+  }
   installResolver(ctx, state)
   // 「直接禁用官方页面里的搜索 key 设置」：把官方 apiKeyEnv 指到插件自有 ref（异步、失败不影响启动）。
   void reconcileOfficialSearchRef(ctx)
@@ -1530,7 +1555,7 @@ async function readJson(req) {
 }
 
 /** 一个会话的展示 + 生效情况（供面板与会话进入提醒使用）。 */
-async function sessionRow(ctx, state, row, fallbackCwd) {
+async function sessionRow(ctx, state, row, fallbackCwd, index) {
   const sessionId = typeof row?.sessionId === 'string' && row.sessionId !== '' ? row.sessionId : undefined
   if (sessionId === undefined) return undefined
   const selection = modelSelectionOf(row)
@@ -1538,7 +1563,7 @@ async function sessionRow(ctx, state, row, fallbackCwd) {
   const ref = sessionRef(sessionId)
   const entry = ref !== undefined ? state.overrides[ref] : undefined
   const directHit = entry !== undefined ? await resolveKey(ctx, ref) : undefined
-  const eff = effectiveOverride(ctx, state, { sessionId, cwd })
+  const eff = effectiveOverride(ctx, state, { sessionId, cwd }, index)
   const effHit = eff.ref !== undefined ? await resolveKey(ctx, eff.ref) : undefined
   return {
     sessionId,
@@ -1570,14 +1595,19 @@ async function sessionRow(ctx, state, row, fallbackCwd) {
   }
 }
 
-async function workspaceRow(ctx, state, { id, path: dir, title, kind }, rows, claimed) {
+async function workspaceRow(ctx, state, { id, path: dir, title, kind }, rows, claimed, env) {
+  // 每个工作区行都要的一份上下文（工作区索引、官方搜索配置、搜索默认 key 是否已配）。
+  // 由 snapshot() 统一算一次传进来：panel 打开一次要渲染 20+ 行，每行各算一遍
+  // settings.describe() + registry.list() 会把事件循环卡住（0.2.16 实测 /state ≈ 50 s）。
+  const index = env?.index
+  const web = env?.web ?? currentWeb(ctx)
   const ref = derivedRef(dir)
   const configured = ref !== undefined && state.overrides[ref] !== undefined
   const desc = configured ? await describeKey(ctx, ref) : undefined
   const hit = configured ? await resolveKey(ctx, ref) : undefined
   const sessions = []
   for (const row of rows) {
-    const item = await sessionRow(ctx, state, row, dir)
+    const item = await sessionRow(ctx, state, row, dir, index)
     if (item !== undefined) sessions.push(item)
   }
   sessions.sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))
@@ -1585,9 +1615,9 @@ async function workspaceRow(ctx, state, { id, path: dir, title, kind }, rows, cl
   // 搜索通道：只有新版 Search/Fetch API 才有「同步 / 不同步」的区别（旧 Messages
   // 通道本来就用聊天 key）。这里给出「该工作区的搜索请求实际会用哪把 key」，
   // 让用户勾了复选框之后马上能看到效果，而不用等到搜索失败才发现。
-  const web = readWebSettings(ctx)
   const synced = state.searchSync?.[normPath(dir)] === true
-  const searchDefaultConfigured = web.apiChannel && (await describeKey(ctx, searchDefaultRefOf(web))).configured === true
+  const searchDefaultConfigured = env?.searchDefaultConfigured
+    ?? (web.apiChannel && (await describeKey(ctx, searchDefaultRefOf(web))).configured === true)
   const searchKeyRef = web.apiChannel
     ? synced
       ? configured
@@ -1634,11 +1664,21 @@ function hasVisibleSession(rows) {
 }
 
 async function snapshot(ctx, state) {
+  const startedAt = Date.now()
+  // 官方「网页搜索」配置：每次面板刷新都重读一次（缓存只在请求入口更新，解析路径只读）。
+  // 整个 snapshot 只读这一次：下面每行都用 currentWeb(ctx) 拿缓存，不再各自 describe。
+  const web = refreshWebCache(ctx)
+  // 工作区索引也一样：一次 snapshot 只调一次 registry.list()，行渲染复用同一份快照。
+  const index = workspaceIndex(ctx)
   const credentials = ctx.get('credentials')
   const defaultRefName = 'DEEPSEEK_API_KEY'
   const defaultInfo = await describeKey(ctx, defaultRefName)
   const defaultHit = await resolveKey(ctx, defaultRefName)
   const probe = await sessionProbe(ctx)
+  const probeMs = Date.now() - startedAt
+  const searchDefaultConfigured = web.apiChannel
+    && (await describeKey(ctx, searchDefaultRefOf(web))).configured === true
+  const rowEnv = { index, web, searchDefaultConfigured }
   const rows = probe.rows
   const byCwd = new Map()
   for (const row of rows) {
@@ -1662,7 +1702,7 @@ async function snapshot(ctx, state) {
     }
     if (typeof dir !== 'string' || dir === '') continue
     const norm = normPath(dir)
-    workspaces.push(await workspaceRow(ctx, state, { id, path: dir, title, kind: 'workspace' }, byCwd.get(norm) ?? [], claimed))
+    workspaces.push(await workspaceRow(ctx, state, { id, path: dir, title, kind: 'workspace' }, byCwd.get(norm) ?? [], claimed, rowEnv))
   }
 
   // 有覆盖记录、但对应工作区已不在注册表里的（被删掉的工作区）也列出来，方便清理。
@@ -1702,7 +1742,7 @@ async function snapshot(ctx, state) {
     const dir = typeof list[0]?.cwd === 'string' ? list[0].cwd : norm
     // 诊断用：这个目录里一个「真实会话」都没有（界面把它藏起来，但用户能看到原因）。
     if (!hasVisibleSession(list)) hiddenBlankDirs.push(dir)
-    ungrouped.push(await workspaceRow(ctx, state, { id: undefined, path: dir, title: basename(dir) || dir, kind: 'directory' }, list))
+    ungrouped.push(await workspaceRow(ctx, state, { id: undefined, path: dir, title: basename(dir) || dir, kind: 'directory' }, list, undefined, rowEnv))
   }
 
   // 会话级覆盖总览（含已不在列表里的会话，便于清理）。
@@ -1728,8 +1768,7 @@ async function snapshot(ctx, state) {
   }
 
   // ── 搜索 / 抓取通道总览 ──────────────────────────────────────────────
-  // 每次面板刷新都重读一次：开关改过之后，缓存必须跟着变。
-  const web = refreshWebCache(ctx)
+  // 上面的 refreshWebCache() 已经把官方配置读到 web 里了，这里直接复用。
   const searchKeyRef = web.searchKeyEnv
   const searchKeyInfo = await describeKey(ctx, searchKeyRef)
   const searchKeyHit = await resolveKey(ctx, searchKeyRef)
@@ -1740,10 +1779,13 @@ async function snapshot(ctx, state) {
   const syncPaths = Object.keys(state.searchSync ?? {}).filter((key) => state.searchSync[key] === true)
   const warnings = await searchWarnings(ctx, state, web)
 
+  const totalMs = Date.now() - startedAt
   return {
     ok: true,
     pluginVersion: PLUGIN_VERSION,
     storeVersion: STATE_VERSION,
+    // 面板卡顿排查用：会话探针（宿主 list 一次要扫所有会话）与整行的耗时。
+    timings: { probeMs, rowsMs: Math.max(0, totalMs - probeMs), totalMs },
     sessionProbe: {
       available: probe.available,
       count: probe.count,
@@ -1765,7 +1807,7 @@ async function snapshot(ctx, state) {
     },
     providers: providerList(ctx),
     interceptableRefs: [...interceptableRefs(ctx, state)],
-    workspaceCount: workspaceIndex(ctx).size,
+    workspaceCount: index.size,
     credentialsAvailable: credentials !== undefined,
     sessionListAvailable: probe.available,
     sessionControllerAvailable: sessionListAvailable(ctx),
@@ -1918,7 +1960,8 @@ async function checkSession(ctx, state, params) {
 
 /** 进会话提醒用的搜索通道摘要（不含明文 key）。 */
 async function searchStateOf(ctx, state, { sessionId, cwd }) {
-  const web = readWebSettings(ctx)
+  // 面板/会话入口不是热路径，但也没必要每次 describe：缓存由请求入口与设置事件维护。
+  const web = currentWeb(ctx)
   const sync = workspaceSynced(state, cwd)
   if (!web.apiChannel) {
     const idle = web.apiLiteralKey !== undefined
@@ -1936,6 +1979,20 @@ async function searchStateOf(ctx, state, { sessionId, cwd }) {
 }
 
 async function handle(ctx, state, req, res) {
+  // 每个请求进来先刷新一次网页搜索配置：解析热路径只读缓存。
+  refreshWebCache(ctx)
+  // 看门狗：任何一次 await 卡住都不该让面板/测试按钮一直转圈。
+  const watchdog = setTimeout(() => {
+    if (res.writableEnded === true) return
+    try {
+      res.writeHead(504, { 'content-type': 'application/json; charset=utf-8' })
+      res.end(JSON.stringify({ ok: false, error: '面板请求超时（8 秒）：DSH 的某个服务没有响应' }))
+    } catch {
+      /* 已经写过了就忽略 */
+    }
+  }, 8000)
+  watchdog.unref?.()
+  if (typeof res.on === 'function') res.on('close', () => clearTimeout(watchdog))
   if (!isTrusted(req)) {
     res.writeHead(403)
     res.end('forbidden')
@@ -1992,7 +2049,7 @@ async function handle(ctx, state, req, res) {
       // 于是面板和官方页改的是同一把 key，不会各存一份。官方还指向聊天那把（DEEPSEEK_API_KEY）时，
       // 先把两套搜索插件的 apiKeyEnv 改到插件自有 ref，再写值。
       if (body.scope === 'search-default') {
-        const web = readWebSettings(ctx)
+        const web = refreshWebCache(ctx)
         const official = officialSearchRef(web)
         const needsBind = official === DEFAULT_API_KEY_REF
         const target = needsBind ? SEARCH_DEFAULT_REF : official
@@ -2052,7 +2109,7 @@ async function handle(ctx, state, req, res) {
 
     if (pathname === `${API_BASE}/test` && method === 'POST') {
       const body = await readJson(req)
-      const web = readWebSettings(ctx)
+      const web = refreshWebCache(ctx)
       const channel = body.channel === 'search' ? 'search' : 'chat'
       let key = typeof body.key === 'string' && body.key.trim() !== '' ? body.key.trim() : undefined
       let sourceRef = typeof body.ref === 'string' && body.ref !== '' ? body.ref : undefined

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-workspace-api-key",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "A DeepSeek Harness plugin that binds a separate DeepSeek API key to each workspace, or to a single session, so the spend of one key stays with the sessions you choose.",
   "type": "module",
   "license": "MIT",
@@ -50,6 +50,6 @@
     "lib/client.js"
   ],
   "scripts": {
-    "test": "node test/host.test.mjs && node test/client.test.mjs"
+    "test": "node test/host.test.mjs && node test/client.test.mjs && node test/client-i18n.test.mjs"
   }
 }