@xmanrui/dsh-im 4.19.1 → 4.20.0

package/src/channels/shared/workspace-command.mjs

@@ -6,6 +6,7 @@ import { WORKSPACE_SESSION_STALE } from './workspace-session.mjs';
 
 const WORKSPACE_COMMAND = /^\/(?:workspace|ws)(?:\s+([\s\S]+))?$/i;
 const WORKSPACE_LIST_COMMAND = /^\/(?:workspacelist|workspaces|wsl)(?:\s+([\s\S]+))?$/i;
+const THREAD_WORKSPACE_COMMAND = /^\/(?:conv|conversation|thread)(?:\s+([\s\S]+))?$/i;
 const SESSION_LIST_COMMAND = /^\/(?:sessionlist|sessions)(?:\s+([\s\S]+))?$/i;
 const SESSION_BIND_PREFIX = /^\/session(?=$|\s)/i;
 const SESSION_BIND_COMMAND = /^\/session[ \t]+([^\s]+)$/i;
@@ -21,6 +22,7 @@ const SESSION_LIST_USAGE = [
   '/sessionlist --limit N  列出当前工作区前 N 个会话（N 为正整数）',
   '/sessionlist 工作区序号  按 /workspacelist 序号列出会话',
   '/sessionlist 工作区绝对路径  列出指定工作区会话',
+  '不带工作区参数时，默认列出当前对话的有效工作区（未设置对话专属工作区时即 bot 默认工作区）。',
 ].join('\n');
 
 function commandResult(message, messages = [message]) {
@@ -158,7 +160,9 @@ async function runWorkspaceListCommand(match, harness) {
       )),
       '',
       t('切换用法：/workspace 工作区序号或绝对路径'),
+      t('对话专属：/conv 工作区序号或绝对路径（仅影响当前对话）'),
       t('查看会话：/sessionlist 工作区序号或绝对路径'),
+      t('不带工作区参数时，/sessionlist 默认列出当前对话的有效工作区。'),
     ];
     const message = lines.join('\n');
     return commandResult(message, splitWorkspaceCommandMessage(message));
@@ -170,8 +174,22 @@ async function runWorkspaceListCommand(match, harness) {
   }
 }
 
+async function conversationEffectiveWorkspace(harness, conversationKey) {
+  if (typeof harness?.currentConversationWorkspace !== 'function'
+    || typeof conversationKey !== 'string' || !conversationKey) return null;
+  const [current] = await existingWorkspacePaths([harness.currentConversationWorkspace(conversationKey)]);
+  harness.assertWorkspaceScope?.();
+  return current ?? null;
+}
+
 export async function resolveSessionListWorkspace(selector, harness, options = {}) {
   if (!selector) {
+    // With no explicit selector the listing follows the conversation's effective
+    // workspace, so /conv B makes /sessionlist list B instead of the bot default.
+    if (options.conversationKey) {
+      const effective = await conversationEffectiveWorkspace(harness, options.conversationKey);
+      if (effective) return { workspace: effective };
+    }
     if (typeof harness?.currentWorkspace !== 'function') {
       return { error: t('当前机器人没有可用的工作区。') };
     }
@@ -242,21 +260,23 @@ function sessionListMessage(workspace, sessions, { currentWorkspace = false } =
   ].join('\n');
 }
 
-async function currentSessionListWorkspace(harness) {
+async function currentSessionListWorkspace(harness, conversationKey) {
+  const effective = await conversationEffectiveWorkspace(harness, conversationKey);
+  if (effective) return effective;
   if (typeof harness?.currentWorkspace !== 'function') return null;
   const [current] = await existingWorkspacePaths([harness.currentWorkspace()]);
   harness.assertWorkspaceScope?.();
   return current ?? null;
 }
 
-async function runSessionListCommand(match, harness) {
+async function runSessionListCommand(match, harness, conversationKey) {
   const request = parseSessionListArgument(match[1]);
   if (request.error) return commandResult(request.error);
   if (typeof harness?.listWorkspaceSessions !== 'function') {
     return commandResult(t('当前机器人暂不支持列出工作区会话。'));
   }
   try {
-    const resolved = await resolveSessionListWorkspace(request.selector, harness);
+    const resolved = await resolveSessionListWorkspace(request.selector, harness, { conversationKey });
     if (resolved.error) return commandResult(resolved.error);
     const listed = await harness.listWorkspaceSessions(resolved.workspace);
     if (!listed || !Array.isArray(listed.sessions)) {
@@ -264,7 +284,7 @@ async function runSessionListCommand(match, harness) {
     }
     harness.assertWorkspaceScope?.();
     const workspace = normalizedWorkspacePath(listed.workspace) ?? resolved.workspace;
-    const currentWorkspace = await currentSessionListWorkspace(harness);
+    const currentWorkspace = await currentSessionListWorkspace(harness, conversationKey);
     const sessions = request.limit === null
       ? listed.sessions
       : listed.sessions.slice(0, request.limit);
@@ -311,13 +331,15 @@ async function runSessionBindCommand(command, harness, conversationKey) {
   const match = SESSION_BIND_COMMAND.exec(command);
   let sessionId = match?.[1];
   if (typeof sessionId === 'string' && /^\d+$/u.test(sessionId)) {
-    // 序号模式：把 /session N 解析成当前工作区会话列表中的第 N 个会话
+    // Use the same effective-workspace resolver as /sessionlist, so its indexes
+    // cannot select a session from the bot default after /conv sets an override.
     if (typeof harness?.listWorkspaceSessions !== 'function'
-      || typeof harness?.currentWorkspace !== 'function') {
+      || (typeof harness?.currentWorkspace !== 'function'
+        && typeof harness?.currentConversationWorkspace !== 'function')) {
       return commandResult(t('当前机器人暂不支持按序号绑定，请使用 /session Session ID。'));
     }
     try {
-      const selected = await selectedWorkspacePath(harness.currentWorkspace());
+      const selected = await resolveSessionListWorkspace('', harness, { conversationKey });
       if (selected.error) return commandResult(selected.error);
       const listed = await harness.listWorkspaceSessions(selected.workspace);
       if (!listed || !Array.isArray(listed.sessions)) {
@@ -371,14 +393,96 @@ async function runSessionBindCommand(command, harness, conversationKey) {
   }
 }
 
+async function runConversationWorkspaceCommand(command, harness, conversationKey) {
+  if (typeof harness?.currentConversationWorkspace !== 'function') {
+    return commandResult(t('当前机器人暂不支持按对话设置专属工作区。'));
+  }
+  if (typeof conversationKey !== 'string' || !conversationKey) {
+    return commandResult(t('当前消息缺少可设置的对话上下文。'));
+  }
+  const argument = THREAD_WORKSPACE_COMMAND.exec(command)?.[1]?.trim() ?? '';
+  if (!argument) {
+    try {
+      const current = harness.currentConversationWorkspace(conversationKey);
+      harness.assertWorkspaceScope?.();
+      const lines = [t('当前对话工作区：{workspace}', { workspace: current })];
+      // 明确区分「显式绑定」与「回落 bot 默认」，否则用户无法判断之后改默认值会不会影响本对话。
+      const bound = typeof harness?.hasConversationWorkspaceOverride === 'function'
+        && harness.hasConversationWorkspaceOverride(conversationKey) === true;
+      lines.push(bound
+        ? t('状态：已为该对话显式绑定，之后修改 bot 默认工作区不会影响本对话。')
+        : t('状态：未显式绑定，当前跟随 bot 默认工作区。'));
+      // 顺带列出可切换的工作区，省得先跑一次 /workspacelist 再回来切。
+      try {
+        const { paths } = await workspacePathSnapshot(harness);
+        if (paths.length > 0) {
+          lines.push('', t('可切换的工作区（{count}）：', { count: paths.length }));
+          for (const [index, workspace] of paths.entries()) {
+            lines.push(`${index + 1}. ${workspace}${workspace === current ? t('（当前）') : ''}`);
+          }
+        }
+      } catch { /* 列表拿不到不影响主信息 */ }
+      lines.push('', t('用法：/conv 工作区序号或绝对路径'), t('清除：/conv clear'));
+      const message = lines.join('\n');
+      return commandResult(message, splitWorkspaceCommandMessage(message));
+    } catch (error) {
+      if (error?.code === 'workspace-bot-not-found') {
+        return commandResult(t('机器人正在移除或已重新接入，无法读取对话工作区。'));
+      }
+      return commandResult(t('暂时无法读取当前对话工作区，请稍后重试。'));
+    }
+  }
+  if (/^(?:--default|clear)$/iu.test(argument)) {
+    try {
+      const current = await harness.clearConversationWorkspace(conversationKey);
+      harness.assertWorkspaceScope?.();
+      return commandResult(t('已清除对话专属工作区，当前使用 bot 默认工作区：{workspace}（之后默认工作区的变化会同步到本对话）', { workspace: current }));
+    } catch (error) {
+      if (error?.code === 'workspace-bot-not-found') {
+        return commandResult(t('机器人正在移除或已重新接入，无法清除对话工作区。'));
+      }
+      return commandResult(t('暂时无法清除对话工作区，请稍后重试。'));
+    }
+  }
+  if (typeof harness?.switchConversationWorkspace !== 'function') {
+    return commandResult(t('当前机器人暂不支持设置对话工作区。'));
+  }
+  try {
+    let selected = argument;
+    if (/^\d+$/u.test(argument)) {
+      const { paths } = await workspacePathSnapshot(harness);
+      const position = Number(argument);
+      if (!Number.isSafeInteger(position) || position < 1 || position > paths.length) {
+        return commandResult(t('工作区序号不存在，请先执行 /workspacelist。'));
+      }
+      selected = paths[position - 1];
+    }
+    const current = await harness.switchConversationWorkspace(conversationKey, selected);
+    return commandResult(t('当前对话工作区已切换为：{workspace}', { workspace: current }));
+  } catch (error) {
+    if (['workspace-not-absolute', 'workspace-not-found', 'workspace-not-directory'].includes(error?.code)) {
+      return commandResult(t(`{message}
+用法：/conv 工作区绝对路径`, { message: error.message }));
+    }
+    if (error?.code === 'workspace-bot-not-found') {
+      return commandResult(t('机器人正在移除或已重新接入，无法切换对话工作区。'));
+    }
+    throw error;
+  }
+}
+
 export async function runWorkspaceCommand(text, harness, conversationKey) {
   if (!isWorkspaceCommand(text)) return null;
   const command = text.trim();
+  const threadMatch = THREAD_WORKSPACE_COMMAND.exec(command);
+  if (threadMatch) {
+    return runConversationWorkspaceCommand(command, harness, conversationKey);
+  }
   if (SESSION_BIND_PREFIX.test(command)) {
     return runSessionBindCommand(command, harness, conversationKey);
   }
   const sessionListMatch = SESSION_LIST_COMMAND.exec(command);
-  if (sessionListMatch) return runSessionListCommand(sessionListMatch, harness);
+  if (sessionListMatch) return runSessionListCommand(sessionListMatch, harness, conversationKey);
   const listMatch = WORKSPACE_LIST_COMMAND.exec(command);
   if (listMatch) return runWorkspaceListCommand(listMatch, harness);
   const match = WORKSPACE_COMMAND.exec(command);
@@ -423,5 +527,6 @@ export function isWorkspaceCommand(text) {
   return SESSION_BIND_PREFIX.test(command)
     || SESSION_LIST_COMMAND.test(command)
     || WORKSPACE_LIST_COMMAND.test(command)
-    || WORKSPACE_COMMAND.test(command);
+    || WORKSPACE_COMMAND.test(command)
+    || THREAD_WORKSPACE_COMMAND.test(command);
 }

package/src/channels/shared/workspace-session.mjs

@@ -3,9 +3,45 @@ import { initialSessionTitle } from './session-title.mjs';
 
 export const WORKSPACE_SESSION_STALE = 'workspace-session-stale';
 
-function workspaceSession(harness, sessionId) {
+function workspaceSessionStaleError() {
+  const error = new Error('The conversation workspace changed before the prompt was sent.');
+  error.code = WORKSPACE_SESSION_STALE;
+  return error;
+}
+
+/**
+ * Read the conversation's effective-workspace generation. A bot-scoped Harness
+ * exposes it; anything else (plain fixtures, older Harnesses) yields null and
+ * disables the conversation-level fence without changing existing behavior.
+ */
+function readConversationGeneration(harness, conversationKey) {
+  return typeof harness?.conversationWorkspaceGeneration === 'function'
+    ? harness.conversationWorkspaceGeneration(conversationKey) ?? null
+    : null;
+}
+
+function conversationGenerationMoved(harness, conversationKey, generation) {
+  if (generation === null) return false;
+  return readConversationGeneration(harness, conversationKey) !== generation;
+}
+
+/**
+ * Wait for a conversation-level workspace switch that is still committing.
+ * An explicit /conv publishes its fence before it persists, so a message that
+ * is already in flight must settle on the new workspace instead of resolving a
+ * session in the one being left behind.
+ */
+async function awaitPendingConversationSwitch(harness, conversationKey) {
+  if (typeof harness?.pendingConversationWorkspaceSwitch !== 'function') return;
+  const pending = harness.pendingConversationWorkspaceSwitch(conversationKey);
+  if (pending && typeof pending.then === 'function') await pending.catch(() => undefined);
+}
+
+function workspaceSession(harness, sessionId, conversationKey) {
   if (typeof harness.workspaceSession === 'function') {
-    return harness.workspaceSession(sessionId);
+    return conversationKey
+      ? harness.workspaceSession(sessionId, conversationKey)
+      : harness.workspaceSession(sessionId);
   }
   const session = {
     sessionId,
@@ -67,12 +103,20 @@ export async function askInWorkspaceSession({
   while (true) {
     try {
       const binding = await withSessionBindingLock(state, key, async () => {
+        await awaitPendingConversationSwitch(harness, key);
         let sessionId = state.sessionFor(key);
-        let session = sessionId ? workspaceSession(harness, sessionId) : null;
+        let session = sessionId ? workspaceSession(harness, sessionId, key) : null;
         if (!session || !(await sessionExists(session, existsOptions))) {
-          sessionId = await createSession(harness, createOptions);
+          sessionId = await createSession(harness, {
+            conversationKey: key,
+            ...(createOptions ?? {}),
+          });
           if (await state.setSession(key, sessionId) === false) return null;
-          session = workspaceSession(harness, sessionId);
+          // Binding committed: capture the conversation's effective-workspace
+          // generation together with the session, so the prompt below is fenced
+          // against a conversation switch that only commits after the bind.
+          const conversationGeneration = readConversationGeneration(harness, key);
+          session = workspaceSession(harness, sessionId, key);
           if (initialTitle && typeof session.renameTitle === 'function') {
             try {
               await session.renameTitle(initialTitle, renameOptions);
@@ -83,6 +127,12 @@ export async function askInWorkspaceSession({
               console.warn('[dsh-im] unable to set the initial Session title:', error?.message ?? error);
             }
           }
+          // A switch that committed while the title was being set has already
+          // cleared the mapping and must not receive this prompt.
+          if (conversationGenerationMoved(harness, key, conversationGeneration)) {
+            throw workspaceSessionStaleError();
+          }
+          return { sessionId, session };
         }
         return { sessionId, session };
       });

package/src/channels/telegram/telegram-runtime.mjs

@@ -524,10 +524,10 @@ export class TelegramBotClient {
 
         const fallback = await this.#sendPlain(target, text);
         const terminalText = fallback.deliveryOutcome === 'sent'
-          ? '回复已发送。'
+          ? t('回复已发送。')
           : fallback.deliveryOutcome === 'unknown'
-            ? '回复发送结果未能确认。'
-            : '消息发送失败，请稍后重试。';
+            ? t('回复发送结果未能确认。')
+            : t('消息发送失败，请稍后重试。');
         try {
           await this.#api.editMessageText({
             chatId: target.chatId,
@@ -717,13 +717,13 @@ export class TelegramBotClient {
         keepalive: true,
         logger: this.#logger,
       });
-      await stream.update(createTextDeliveryBlock('正在处理…', 'plain'));
+      await stream.update(createTextDeliveryBlock(t('正在处理…'), 'plain'));
       return stream;
     }
 
     const placeholder = await this.#api.sendMessage({
       chatId: target.chatId,
-      text: '正在处理…',
+      text: t('正在处理…'),
       replyToMessageId: target.replyToMessageId,
       messageThreadId: target.messageThreadId,
       signal: this.#signal,
@@ -824,6 +824,14 @@ export class TelegramRuntime {
   #abortController = null;
   #pollTask = null;
   #starting = null;
+  // True only while #start() is between "started connecting" and "ready",
+  // which is the one window a skipped refresh must be reconciled. A refresh on
+  // a never-started or already-stopped runtime stays a no-op.
+  #connecting = false;
+  // True when a language switch arrived while the runtime was connecting, so a
+  // refreshCommandMenu() had nothing to push. Reconciled once startup
+  // completes, so the platform always ends up with the latest language.
+  #menuDirty = false;
 
   constructor({
     config,
@@ -902,6 +910,7 @@ export class TelegramRuntime {
 
   async #start() {
     await this.stop();
+    this.#connecting = true;
     this.#status.startedAt = new Date().toISOString();
     this.#status.connectionState = 'connecting';
     this.#status.lastError = null;
@@ -930,14 +939,7 @@ export class TelegramRuntime {
         throw error;
       }
       try {
-        const commands = telegramCommandMenu(this.#commandCatalog);
-        // Both operations use the existing default scope and language. Sending
-        // the full list replaces old entries; an empty catalog clears that list.
-        if (commands.length > 0) {
-          await api.setMyCommands({ commands, signal: controller.signal });
-        } else {
-          await api.deleteMyCommands({ signal: controller.signal });
-        }
+        await this.#sendCommandMenu(api, controller.signal);
         await api.setChatMenuButton({ menuButton: COMMANDS_MENU_BUTTON, signal: controller.signal });
       } catch (error) {
         this.#logger.warn?.(
@@ -973,6 +975,21 @@ export class TelegramRuntime {
       this.#status.connectionState = 'connected';
       this.#status.lastCheckedAt = now;
       this.#status.lastConnectedAt = now;
+      // A language switch that landed while we were connecting was skipped by
+      // refreshCommandMenu(); re-send the menu now that the API is usable, so
+      // the platform ends with the latest language instead of the one that was
+      // current when #sendCommandMenu first ran.
+      if (this.#menuDirty) {
+        this.#menuDirty = false;
+        try {
+          await this.#sendCommandMenu(api, controller.signal);
+        } catch (error) {
+          this.#logger.warn?.(
+            `[dsh-im:telegram] bot ${this.#config.botId} command menu catch-up failed:`,
+            error,
+          );
+        }
+      }
       this.#pollTask = this.#poll(cursor, controller.signal);
       this.#pollTask.catch((error) => {
         if (controller.signal.aborted) return;
@@ -988,6 +1005,51 @@ export class TelegramRuntime {
       this.#status.lastError = error?.message ?? String(error);
       await this.stop();
       throw error;
+    } finally {
+      // Whether the bot is now ready or the attempt failed, the connecting
+      // window is over. A failed attempt also drops any unreconciled dirty
+      // flag: a later retry re-sends the menu from scratch in the current
+      // language anyway.
+      this.#connecting = false;
+      this.#menuDirty = false;
+    }
+  }
+
+  // Both operations use the existing default scope and language. Sending the
+  // full list replaces old entries; an empty catalog clears that list.
+  async #sendCommandMenu(api, signal) {
+    const commands = telegramCommandMenu(this.#commandCatalog);
+    if (commands.length > 0) await api.setMyCommands({ commands, signal });
+    else await api.deleteMyCommands({ signal });
+  }
+
+  /**
+   * Re-send the command menu in the current host message language.
+   *
+   * The menu Telegram shows is registered once per connection, so a language
+   * change would otherwise stay invisible until the bot reconnected. This
+   * replaces the text only: the chat menu button is owned by connect.
+   * @returns whether a connected bot accepted the refreshed menu.
+   */
+  async refreshCommandMenu() {
+    const api = this.#api;
+    const signal = this.#abortController?.signal;
+    if (!this.#status.ready || !api || !signal || signal.aborted) {
+      // A refresh during an in-progress connection must not be lost: mark the
+      // menu dirty so #start() reconciles it the moment the bot is ready. A
+      // never-started or stopped runtime stays a no-op, as before.
+      if (this.#connecting) this.#menuDirty = true;
+      return false;
+    }
+    try {
+      await this.#sendCommandMenu(api, signal);
+      return true;
+    } catch (error) {
+      this.#logger.warn?.(
+        `[dsh-im:telegram] bot ${this.#config.botId} command menu refresh failed:`,
+        error,
+      );
+      return false;
     }
   }
 
@@ -1000,7 +1062,7 @@ export class TelegramRuntime {
     }
     const sessionId = this.#state.sessionFor(key);
     const session = typeof sessionId === 'string' && sessionId
-      ? this.#harness.workspaceSession?.(sessionId)
+      ? this.#harness.workspaceSession?.(sessionId, key)
       : null;
     const text = await recoverAssistantTextByTimestamp({ session, quotedAt, signal });
     return text ? { content: text } : { unavailableReason: 'not-delivered' };

package/src/channels/wecom/wecom-bridge.mjs

@@ -628,7 +628,7 @@ export class WecomHarnessBridge {
       workspacePathSnapshot(this.#harness, options),
       this.#harness.listWorkspaceSessions?.(workspace, options),
       (async () => {
-        const session = sessionId ? this.#harness.workspaceSession?.(sessionId) : null;
+        const session = sessionId ? this.#harness.workspaceSession?.(sessionId, key) : null;
         return typeof session?.models === 'function'
           ? session.models(options) : this.#harness.listModels?.(options);
       })(),
@@ -852,7 +852,7 @@ export class WecomHarnessBridge {
         } else if (menu.section === 'models') {
           title = t('🧠 切换模型');
           const sessionId = this.#state.sessionFor(key);
-          const session = sessionId ? this.#harness.workspaceSession?.(sessionId) : null;
+          const session = sessionId ? this.#harness.workspaceSession?.(sessionId, key) : null;
           const catalog = typeof session?.models === 'function'
             ? await session.models(options) : await this.#harness.listModels(options);
           entries = catalog.groups.flatMap((group) => group.models.map((model) => [

package/src/channels/weixin/connection-error.en.mjs

@@ -0,0 +1,116 @@
+// Shared diagnostic copy for the WeChat Host and settings client.
+export default {
+  "插件版本": "Plugin version",
+  "DSH 微信管理接口返回了无法识别的响应，请重新读取状态。": "The DSH WeChat management endpoint returned an invalid response. Refresh the status.",
+  "无法读取现有登录凭据。请检查 DSH 凭据存储。": "Could not read the saved login credential. Check the DSH credential store.",
+  "登录凭据无法写入 DSH 凭据存储。请检查凭据存储是否可写。": "Could not save the login credential to DSH. Check whether the credential store is writable.",
+  "账号配置无法写入本机。请检查 DSH_HOME 目录权限。": "Could not save the account configuration. Check permissions on DSH_HOME.",
+  "无法初始化账号状态或工作区。请检查 DSH_HOME 和工作区目录。": "Could not prepare the account state or workspace. Check DSH_HOME and the workspace directory.",
+  "插件无法连接当前 Harness，请检查宿主是否已就绪。": "The plugin could not connect to this Harness. Check whether the host is ready.",
+  "Harness 健康检查超时。请确认 dsh web 未阻塞。": "The Harness health check timed out. Check whether the host is responsive.",
+  "Harness 健康检查需要身份认证。请检查代理、网关或自定义鉴权配置。": "The Harness health check requires authentication. Check proxy, gateway or custom authentication settings.",
+  "本机 Harness 请求被代理要求认证。请让回环地址绕过代理，并检查 NO_PROXY 配置。": "The proxy requires authentication for the local Harness request. Bypass the proxy for loopback addresses and check NO_PROXY.",
+  "Harness 异常拒绝了回环地址的健康检查。请检查 HTTP 代理、Harness 源码版本和构建产物。": "Harness rejected a loopback health check. Check the HTTP proxy and the running Harness build.",
+  "Harness 的 Host 信任检查拒绝了非回环地址请求。请检查 harnessBaseUrl 与 trustedHosts 配置。": "Harness rejected the non-loopback Host. Check harnessBaseUrl and trustedHosts.",
+  "健康检查收到了非 Harness 标准的 403 拒绝响应。请检查代理或网关配置。": "The health check received a non-standard HTTP 403 response. Check proxy or gateway settings.",
+  "找不到 Harness 健康检查接口。请确认 Harness 与插件版本兼容。": "The Harness health check endpoint was not found. Check Harness and plugin compatibility.",
+  "Harness 健康检查返回服务错误。请查看 DSH 日志。": "The Harness health check returned a service error. Check the DSH logs.",
+  "Harness 返回了无法识别的响应。请确认 Harness 与插件版本兼容。": "Harness returned an unrecognized response. Check Harness and plugin compatibility.",
+  "Harness 拒绝了健康检查请求。请查看 DSH 日志。": "Harness rejected the health check. Check the DSH logs.",
+  "Harness 健康检查发生未知错误。请查看 DSH 日志。": "The Harness health check failed with an unknown error. Check the DSH logs.",
+  "消息连接初始化失败。请查看 DSH 日志后重试。": "The message connection could not start. Check the DSH logs and retry.",
+  "暂时无法访问微信服务。": "The WeChat service is temporarily unreachable.",
+  "微信服务请求超时。": "The WeChat service request timed out.",
+  "微信服务请求失败（HTTP {status}）。": "The WeChat service request failed (HTTP {status}).",
+  "微信服务返回了无法解析的响应。": "The WeChat service returned an unparseable response.",
+  "微信服务没有返回有效二维码。": "The WeChat service did not return a valid QR code.",
+  "微信服务返回了不受信任的扫码地址。": "The WeChat service returned an untrusted QR-code URL.",
+  "微信服务返回了无效的连接地址。": "The WeChat service returned an invalid connection URL.",
+  "微信服务返回了不受信任的连接地址。": "The WeChat service returned an untrusted connection URL.",
+  "拒绝访问不受信任的微信服务地址。": "Refusing to access an untrusted WeChat service URL.",
+  "微信服务返回了无法识别的扫码状态。": "The WeChat service returned an unrecognized QR-code status.",
+  "微信授权成功，但返回的账号凭据不完整。": "WeChat authorized the account but returned incomplete credentials.",
+  "微信服务拒绝了二维码申请。": "The WeChat service rejected the QR-code request.",
+  "已取得扫码地址，但本机二维码图片生成失败。": "The login URL was obtained, but the QR-code image could not be generated locally.",
+  "无法生成微信二维码。": "Could not generate a WeChat QR code.",
+  "这次微信绑定任务已不存在，请重新读取状态或生成二维码。": "This WeChat setup attempt no longer exists. Refresh the status or generate a new QR code.",
+  "这次微信绑定任务当前不能提交配对码，请重新读取状态。": "This setup attempt is not waiting for a pairing code. Refresh the status.",
+  "登录凭据缺失，请移除账号后重新扫码。": "The login credential is missing. Remove the account and scan a new QR code.",
+  "微信登录凭据已失效，请移除账号后重新扫码。": "The WeChat login credential has expired. Remove the account and scan a new QR code.",
+  "无法从 DSH 凭据存储移除微信登录凭据。": "Could not remove the WeChat login credential from the DSH credential store.",
+  "微信账号配置移除失败。": "Could not remove the WeChat account configuration.",
+  "无法读取微信账号状态文件。": "Could not read the WeChat account state file.",
+  "无法保存微信账号状态文件。": "Could not save the WeChat account state file.",
+  "微信账号已移除，但本机状态文件清理失败。": "The WeChat account was removed, but its local state file could not be cleaned up.",
+  "无法保存微信工作区设置。": "Could not save the WeChat workspace settings.",
+  "微信账号已移除，但工作区设置清理失败。": "The WeChat account was removed, but its workspace settings could not be cleaned up.",
+  "微信账号连接启动失败。": "The WeChat account connection could not start.",
+  "微信消息同步请求被拒绝。": "WeChat rejected the message sync request.",
+  "微信服务未确认停止通知。": "WeChat did not confirm the stop notification.",
+  "微信消息连接停止时发生错误。": "An error occurred while stopping the WeChat connection.",
+  "无法读取微信连接状态，请重新读取；之前的操作可能已完成。": "Could not read the WeChat connection status. Refresh it; the previous operation may have completed.",
+  "微信激活过程中发生未知错误。": "An unknown error occurred while activating the WeChat account.",
+  "微信操作发生未知错误。": "The WeChat operation failed with an unknown error.",
+  "微信配置格式错误，请检查 config.json 和 workspaces.json 后重启 DSH。": "The WeChat configuration is invalid. Check config.json and workspaces.json, then restart DSH.",
+  "微信配置访问权限不足，请检查数据目录权限后重启 DSH。": "The WeChat configuration could not be accessed. Check the data directory permissions and restart DSH.",
+  "微信初始化失败，请查看 DSH 启动日志。": "WeChat initialization failed. Check the DSH startup logs.",
+  "微信连接未就绪。": "The WeChat connection is not ready.",
+  "微信操作失败后，原账号状态恢复失败。": "The previous account state could not be restored after the failed WeChat operation.",
+  "原账号状态尚未确认，请重新读取状态，并反馈诊断信息。": "The previous account state has not been confirmed. Refresh the status and share the diagnostic information.",
+  "操作未完成，已恢复之前的本机状态。请处理上述问题后重试。": "The operation did not complete. The previous local state was restored. Resolve the problem above before retrying.",
+  "凭据由只读来源提供，请在启动 DSH 的配置中检查该来源。": "The credential comes from a read-only source. Check that source in the configuration used to launch DSH.",
+  "微信服务域名解析失败，请检查运行 DSH 的机器的网络和 DNS 设置后重试。": "The WeChat service domain could not be resolved. Check the network and DNS settings on the machine running DSH and retry.",
+  "请检查 DSH 数据目录和对应文件的读写权限。": "Check read and write permissions on the DSH data directory and the affected file.",
+  "磁盘空间不足，请释放空间后重试。": "The disk is full. Free up space and retry.",
+  "本机文件格式无效，请检查对应配置或状态文件；不要清空登录凭据。": "The local file format is invalid. Check the affected configuration or state file; do not clear login credentials.",
+  "请检查运行 DSH 的机器的系统时间、证书和网络设置。": "Check the system time, certificates and network settings on the machine running DSH.",
+  "请移除失效接入并重新扫码绑定。": "Remove the invalid connection and scan a new QR code to connect.",
+  "请确认当前 DSH 宿主已就绪，并检查 Harness 与插件实际运行版本及宿主日志。": "Check that this DSH host is ready, and check the running Harness and plugin versions and the host logs.",
+  "微信服务限流，请稍后重试。": "The WeChat service is rate-limiting requests. Try again later.",
+  "访问被拒绝，请检查服务访问限制；HTTP 状态本身不能确认登录凭据已失效。": "Access was denied. Check service access restrictions; the HTTP status alone does not establish that the login credential expired.",
+  "请检查运行 DSH 的机器能否访问微信服务，然后重试。": "Check whether the machine running DSH can access the WeChat service, then retry.",
+  "请按参考号查看 DSH 日志，并复制诊断信息反馈。": "Find this reference in the DSH logs and copy the diagnostic information when reporting the issue.",
+  "无法完成微信管理请求，请检查 DSH 连接后重新读取状态。": "The WeChat management request could not be completed. Check the DSH connection and refresh the status.",
+  "查询微信扫码状态失败": "Could not query WeChat QR-code status",
+  "无法完成微信管理请求": "Could not complete the WeChat management request",
+  "无法生成微信二维码": "Could not generate a WeChat QR code",
+  "状态读取失败，以下是上次读取的状态。": "Status refresh failed. The last known status is shown below.",
+  "诊断详情": "Diagnostic details",
+  "诊断信息": "Diagnostic information",
+  "复制诊断信息": "Copy diagnostic information",
+  "诊断信息已复制": "Diagnostic information copied",
+  "未取得 Host 诊断参考号。": "No diagnostic reference was received from the host.",
+  "无法访问剪贴板，请选择并复制以下诊断信息。": "Clipboard access is unavailable. Select and copy the diagnostic information below.",
+  "错误码": "Error code",
+  "失败阶段": "Failed step",
+  "底层原因": "Underlying cause",
+  "HTTP 状态": "HTTP status",
+  "微信返回码": "WeChat return code",
+  "参考号": "Reference",
+  "发生时间": "Time",
+  "加载微信配置": "Load WeChat configuration",
+  "申请二维码": "Request QR code",
+  "生成二维码图片": "Generate QR-code image",
+  "查询扫码状态": "Query QR-code status",
+  "提交配对码": "Submit pairing code",
+  "取消绑定": "Cancel setup",
+  "读取登录凭据": "Read login credential",
+  "保存登录凭据": "Save login credential",
+  "移除登录凭据": "Remove login credential",
+  "保存账号配置": "Save account configuration",
+  "移除账号配置": "Remove account configuration",
+  "读取账号状态": "Read account state",
+  "保存账号状态": "Save account state",
+  "清理账号状态": "Clean up account state",
+  "保存工作区设置": "Save workspace settings",
+  "清理工作区设置": "Clean up workspace settings",
+  "准备消息连接": "Prepare message connection",
+  "激活微信账号": "Activate WeChat account",
+  "检查 DSH 宿主": "Check DSH host",
+  "启动微信连接": "Start WeChat connection",
+  "同步微信消息": "Sync WeChat messages",
+  "停止微信连接": "Stop WeChat connection",
+  "读取连接状态": "Read connection status",
+  "恢复原账号状态": "Restore previous account state",
+  "访问 DSH 管理接口": "Access DSH management API"
+};