@xmanrui/dsh-im 4.19.2 → 4.20.1

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/wecom.mjs

@@ -23,7 +23,7 @@ export default {
   '暂无可用选项。': 'No options are available.',
   '预设仅用于之后的新会话。': 'Presets apply to future new sessions.',
   '部分模型暂不可用，可稍后重试。': 'Some models are unavailable. Try again later.',
-  '工作区已变化，请从新菜单重新选择。': 'The workspace changed. Please select again from the new menu.',
+  '工作区已变化，请发送 /m 重新打开菜单后选择。': 'The workspace changed. Send /m to reopen the menu and select again.',
   // Help text (wecom-bridge.mjs)
   '企业微信机器人已连接 DeepSeek Harness。': 'The Enterprise WeChat bot is connected to DeepSeek Harness.',
 

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

@@ -608,27 +608,17 @@ export class WecomHarnessBridge {
     return structuredClone(this.#status);
   }
 
-  #mainMenu() {
-    return wecomMenu({
-      workspace: this.#harness.currentWorkspace?.(),
-      workspaces: [[t('更多选项…'), '/menu workspaces']],
-    });
-  }
-
-  async #showMain(frame, { welcome = false } = {}) {
+  async #showMain(frame) {
     const previousFailure = this.#status.lastMessageError;
     const key = conversationKey(frame);
     const workspace = this.#harness.currentWorkspace?.();
     const sessionId = this.#state.sessionFor(key);
-    // The welcome reply has a five-second deadline. Show immediate controls,
-    // then load the selectors independently of that reply window.
-    if (welcome) await this.#sendMenu(frame, this.#mainMenu(), { welcome: true });
     const options = { signal: this.#signal };
     const settled = await Promise.allSettled([
       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);
       })(),
@@ -650,12 +640,10 @@ export class WecomHarnessBridge {
       currentPreset: currentPreset ? `/preset ${/^\d+$/u.test(currentPreset) ? 'id:' : ''}${currentPreset}` : '/preset --default',
       presetLabel: settings?.agentPresetCatalog?.items.find((item) => item.id === currentPreset)?.label,
     });
-    await this.#sendMenu(frame, settingsMenu, { active: welcome });
-    if (!welcome) {
-      await this.#sendMenu(frame, wecomMenu({ workspace,
-        workspaces: (paths?.paths ?? (workspace ? [workspace] : [])).map((path) => [path, `/workspace ${path}`]),
-      }), { active: true });
-    }
+    await this.#sendMenu(frame, settingsMenu);
+    await this.#sendMenu(frame, wecomMenu({ workspace,
+      workspaces: (paths?.paths ?? (workspace ? [workspace] : [])).map((path) => [path, `/workspace ${path}`]),
+    }), { active: true });
     this.#clearMenuFailure(previousFailure);
   }
 
@@ -682,17 +670,14 @@ export class WecomHarnessBridge {
     return wecomTemplateCard(menu, taskId);
   }
 
-  async #sendMenu(frame, menu, { welcome = false, active = false } = {}) {
+  async #sendMenu(frame, menu, { active = false } = {}) {
     this.#signal?.throwIfAborted();
     const body = bodyOf(frame);
     const chatId = body.chattype === 'group' ? body.chatid : body.from.userid;
     const card = this.#rememberMenu(frame, menu);
-    const operation = welcome ? 'replyWelcome'
-      : active || this.#cardFrames.has(frame) ? 'sendMessage' : 'replyTemplateCard';
+    const operation = active || this.#cardFrames.has(frame) ? 'sendMessage' : 'replyTemplateCard';
     try {
-      if (welcome) {
-        await this.#client.replyWelcome(frame, { msgtype: 'template_card', template_card: card });
-      } else if (active || this.#cardFrames.has(frame)) {
+      if (active || this.#cardFrames.has(frame)) {
         await this.#client.sendMessage(chatId, { msgtype: 'template_card', template_card: card });
       } else {
         await this.#client.replyTemplateCard(frame, card);
@@ -704,16 +689,7 @@ export class WecomHarnessBridge {
       // Only a definite card rejection can safely fall back to text.
       if (error.code !== 'channel-delivery-failed' || error.providerCode === undefined) throw error;
       this.#logger.warn?.('[dsh-im:wecom] menu delivery failed; using text:', wecomSendDiagnostic(error));
-      if (welcome) {
-        const content = wecomMenuText(menu);
-        try {
-          await this.#client.replyWelcome(frame, { msgtype: 'text', text: { content } });
-        } catch (cause) {
-          throw wecomSendError(cause, 'replyWelcome');
-        }
-      } else {
-        await this.#sendImmediate(frame, chatId, wecomMenuText(menu));
-      }
+      await this.#sendImmediate(frame, chatId, wecomMenuText(menu));
     }
   }
 
@@ -744,7 +720,7 @@ export class WecomHarnessBridge {
     const body = bodyOf(frame);
     const senderId = nonEmptyString(body.from?.userid);
     const type = body.event?.eventtype;
-    if (!senderId || !['enter_chat', 'template_card_event'].includes(type)) return;
+    if (!senderId || type !== 'template_card_event') return;
     const chattype = body.chattype ?? (body.chatid ? 'group' : 'single');
     if (!['single', 'group'].includes(chattype) || (chattype === 'group' && !body.chatid)) return;
     const normalized = { ...frame, body: { ...body, chattype } };
@@ -753,17 +729,13 @@ export class WecomHarnessBridge {
       conversationType: chattype === 'single' ? 'direct' : 'group', senderIds: senderId, isCommand: true,
     });
     if (!access.allowed) {
-      if (type === 'template_card_event' && access.reason === 'command-not-allowed') {
+      if (access.reason === 'command-not-allowed') {
         await this.#sendActive(chatId, t(COMMAND_PERMISSION_DENIED_MESSAGE));
       }
       return;
     }
     await this.#state.markSeen(body.msgid);
     const key = conversationKey(normalized);
-    if (type === 'enter_chat') {
-      if (chattype === 'single') await this.#showMain(normalized, { welcome: true });
-      return;
-    }
     // Live callbacks nest these fields; older SDK examples show them flat.
     const callback = body.event.template_card_event ?? body.event;
     const entry = this.#menus.get(callback.task_id);
@@ -807,7 +779,7 @@ export class WecomHarnessBridge {
     const navigation = commands.find((command) => parseWecomMenu(command));
     if (navigation) commands = [navigation];
     if (!navigation && entry.workspace !== this.#harness.currentWorkspace?.()) {
-      await this.#sendActive(chatId, t('工作区已变化，请从新菜单重新选择。'));
+      await this.#sendActive(chatId, t('工作区已变化，请发送 /m 重新打开菜单后选择。'));
     } else {
       for (const [index, command] of commands.entries()) {
         const commandFrame = { ...normalized, body: { ...normalized.body,
@@ -818,10 +790,6 @@ export class WecomHarnessBridge {
       }
       if (!commands.length) await this.#sendActive(chatId, t('设置未改变。'));
     }
-    if (!navigation) {
-      this.#cardFrames.add(normalized);
-      await this.#showMain(normalized);
-    }
   }
 
   async #runMenuCommand(frame, text, _harness, _state, key) {
@@ -852,7 +820,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/wecom/wecom-runtime.mjs

@@ -168,7 +168,7 @@ export class WecomRuntime {
     client.on('reconnecting', onReconnecting);
     client.on('error', onError);
     client.on('message', onMessage);
-    client.on('event.enter_chat', (frame) => this.#bridge?.acceptEvent(frame));
+    // Menus are opened explicitly with /m or /menu; chat entry stays silent.
     client.on('event.template_card_event', (frame) => this.#bridge?.acceptEvent(frame));
 
     let timer;