@xmanrui/dsh-im 4.19.2 → 4.20.0

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

@@ -35,6 +35,11 @@ export const SHARED_COMMAND_CATALOG = Object.freeze([
   defineCatalogCommand('workspace', '切换工作区', [
     '/workspace 工作区序号或绝对路径  切换工作区',
   ], { aliases: ['ws'] }),
+  defineCatalogCommand('conv', '设置当前对话专属工作区', [
+    '/conv 或 /conversation  查看当前对话工作区',
+    '/conv 工作区绝对路径或序号  设置当前对话专属工作区',
+    '/conv clear  清除专属工作区，回到 bot 默认工作区',
+  ], { aliases: ['conversation', 'thread'] }),
   defineCatalogCommand('workspacelist', '列出工作区绝对路径', [
     '/workspacelist  列出工作区绝对路径',
     '/ws、/wsl、/workspaces  工作区命令别名',

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

@@ -80,11 +80,21 @@ export async function runCompactCommand(text, harness, state, conversationKey, o
   if (typeof sessionId !== 'string' || !sessionId) {
     return commandResult(t('当前聊天还没有可压缩的会话，请先发送一条消息。'));
   }
-  if (typeof harness?.executeCommand !== 'function') {
-    return commandResult(t('当前机器人暂不支持上下文压缩。'));
-  }
   try {
-    const execution = await harness.executeCommand(sessionId, '/compact', options);
+    let execution;
+    if (typeof harness?.workspaceSession === 'function') {
+      const session = harness.workspaceSession(sessionId, conversationKey);
+      if (typeof session?.executeCommand !== 'function') {
+        return commandResult(t('当前机器人暂不支持上下文压缩。'));
+      }
+      execution = await session.executeCommand('/compact', options);
+    } else {
+      // Legacy Harnesses have no scoped Session handle to carry the route fence.
+      if (typeof harness?.executeCommand !== 'function') {
+        return commandResult(t('当前机器人暂不支持上下文压缩。'));
+      }
+      execution = await harness.executeCommand(sessionId, '/compact', options);
+    }
     if (execution === undefined) {
       return commandResult(t('当前 Harness 未注册 /compact 命令，请确认上下文压缩组件已启用。'));
     }

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

@@ -24,7 +24,7 @@ function boundSession(harness, state, key) {
   if (typeof harness?.workspaceSession !== 'function') {
     throw new TypeError('Harness does not support workspace sessions');
   }
-  const session = harness.workspaceSession(sessionId);
+  const session = harness.workspaceSession(sessionId, key);
   if (!session || typeof session !== 'object') {
     throw new TypeError('Harness returned an invalid workspace session');
   }

package/src/channels/shared/deferred-delivery-coordinator.mjs

@@ -128,7 +128,7 @@ export function createDeferredDeliveryCoordinator({
           entry = { ...entry, turn: outcome.turn };
         }
         if (stopping) {
-          const session = harness.workspaceSession?.(entry.sessionId);
+          const session = harness.workspaceSession?.(entry.sessionId, entry.key);
           const stopped = typeof session?.stopDeferredTurn === 'function'
             ? await session.stopDeferredTurn({ turn: entry.turn, promptRpcId: entry.promptRpcId }, {
                 signal: activeSignal, isCurrent: () => bound(entry),

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

@@ -124,7 +124,7 @@ export async function runHistoryCommand(text, harness, state, key, {
   }
 
   try {
-    const session = harness?.workspaceSession?.(sessionId);
+    const session = harness?.workspaceSession?.(sessionId, key);
     if (typeof session?.readHistory !== 'function') {
       return commandResult(t('当前 Harness 暂不支持读取会话历史。'));
     }

package/src/channels/shared/i18n-en/shared-a.mjs

@@ -125,6 +125,47 @@ export default {
   '/compact  压缩当前会话的较早上下文': '/compact  Compact the earlier context of the current session',
   '/workspace 工作区序号或绝对路径  切换工作区':
     '/workspace <workspace index or absolute path>  Switch workspace',
+  '设置当前对话专属工作区': 'Set a workspace dedicated to this conversation',
+  '/conv 或 /conversation  查看当前对话工作区':
+    '/conv or /conversation  Show the workspace of this conversation',
+  '/conv 工作区绝对路径或序号  设置当前对话专属工作区':
+    '/conv <workspace absolute path or index>  Set a workspace dedicated to this conversation',
+  '/conv clear  清除专属工作区，回到 bot 默认工作区':
+    '/conv clear  Clear the dedicated workspace and fall back to the bot default',
+  '对话专属：/conv 工作区序号或绝对路径（仅影响当前对话）':
+    'Dedicated to this conversation: /conv <workspace index or absolute path> (affects this conversation only)',
+  '当前对话工作区：{workspace}': 'This conversation uses the workspace: {workspace}',
+  '状态：已为该对话显式绑定，之后修改 bot 默认工作区不会影响本对话。':
+    'Status: explicitly bound for this conversation; changing the bot default workspace later will not affect it.',
+  '状态：未显式绑定，当前跟随 bot 默认工作区。':
+    'Status: not explicitly bound; this conversation currently follows the bot default workspace.',
+  '当前对话工作区已切换为：{workspace}': 'This conversation now uses the workspace: {workspace}',
+  '已清除对话专属工作区，当前使用 bot 默认工作区：{workspace}（之后默认工作区的变化会同步到本对话）':
+    'Cleared the dedicated workspace. This conversation now uses the bot default: {workspace} (later changes to that default follow here as well)',
+  '可切换的工作区（{count}）：': 'Available workspaces ({count}):',
+  '用法：/conv 工作区序号或绝对路径': 'Usage: /conv <workspace index or absolute path>',
+  '清除：/conv clear': 'Clear: /conv clear',
+  '{message}\n用法：/conv 工作区绝对路径': '{message}\nUsage: /conv <workspace absolute path>',
+  '当前机器人暂不支持按对话设置专属工作区。':
+    'This bot does not support per-conversation workspaces yet.',
+  '当前机器人暂不支持设置对话工作区。':
+    'This bot does not support setting a conversation workspace yet.',
+  '当前消息缺少可设置的对话上下文。':
+    'This message has no conversation context to bind a workspace to.',
+  '暂时无法读取当前对话工作区，请稍后重试。':
+    'This conversation workspace is temporarily unavailable. Please try again later.',
+  '暂时无法清除对话工作区，请稍后重试。':
+    'The conversation workspace could not be cleared right now. Please try again later.',
+  '机器人正在移除或已重新接入，无法读取对话工作区。':
+    'The bot is being removed or was reconnected, so the conversation workspace cannot be read.',
+  '机器人正在移除或已重新接入，无法清除对话工作区。':
+    'The bot is being removed or was reconnected, so the conversation workspace cannot be cleared.',
+  '机器人正在移除或已重新接入，无法切换对话工作区。':
+    'The bot is being removed or was reconnected, so the conversation workspace cannot be switched.',
+  '不带工作区参数时，/sessionlist 默认列出当前对话的有效工作区。':
+    'Without a workspace argument, /sessionlist lists the workspace this conversation effectively uses.',
+  '不带工作区参数时，默认列出当前对话的有效工作区（未设置对话专属工作区时即 bot 默认工作区）。':
+    'Without a workspace argument it lists the workspace this conversation effectively uses (the bot default when no conversation workspace is set).',
   '/workspacelist  列出工作区绝对路径': '/workspacelist  List absolute workspace paths',
   '/ws、/wsl、/workspaces  工作区命令别名': '/ws, /wsl, /workspaces  Workspace command aliases',
   '/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题':

package/src/channels/shared/i18n-en/weixin.mjs

@@ -1,5 +1,7 @@
+import diagnostics from '../../weixin/connection-error.en.mjs';
 // English translations (weixin area). Keys are exact Chinese literals passed to t().
 export default {
+  ...diagnostics,
   // weixin-bridge.mjs
   '微信已连接 DeepSeek Harness。': 'WeChat is connected to DeepSeek Harness.',
   '结果文件「{name}」已生成，但微信机器人当前没有文件消息发送权限，请检查机器人文件消息能力。': 'The result file "{name}" was generated, but the WeChat bot currently has no permission to send file messages. Please check the bot\'s file messaging capability.',

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

@@ -443,7 +443,7 @@ async function boundSession(harness, state, key, options) {
   if (typeof harness?.workspaceSession !== 'function') {
     throw new TypeError('Harness does not support workspace sessions');
   }
-  const session = harness.workspaceSession(sessionId);
+  const session = harness.workspaceSession(sessionId, key);
   if (!session || typeof session.sessionExists !== 'function') {
     throw new TypeError('Harness returned an invalid workspace session');
   }
@@ -705,11 +705,13 @@ export async function runModelCommand(text, harness, state, key, options = {}) {
           throw new TypeError('Harness cannot create a conversation session');
         }
         // An explicit choice must remain usable even when the saved bot model expires.
-        const sessionId = await harness.createSession({ ...requestOptions, inheritBotModel: false });
+        const sessionId = await harness.createSession({
+          ...requestOptions, inheritBotModel: false, conversationKey: key,
+        });
         if (typeof sessionId !== 'string' || !sessionId) {
           throw new TypeError('Harness returned an invalid session id');
         }
-        const session = harness.workspaceSession(sessionId);
+        const session = harness.workspaceSession(sessionId, key);
         applied = await selectAndVerifyModel(session, selection, requestOptions);
         const currentSessionId = state.sessionFor(key);
         if (typeof currentSessionId === 'string' && currentSessionId) {

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

@@ -1062,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"
+};