@xmanrui/dsh-im 0.3.0 → 0.5.0

package/plugin-src/host/channels/wecom/rpc.mjs

@@ -1,5 +1,6 @@
 import QRCode from 'qrcode';
 import { resolveRpcAuthority } from '../../rpc-authority.mjs';
+import { publicWorkspaceError, SET_WORKSPACE_ENDPOINT, validWorkspacePayload } from '../shared/workspace-rpc.mjs';
 
 export const WECOM_RPC_CHANNEL = '/wecom';
 export const WECOM_ENDPOINTS = Object.freeze({
@@ -10,6 +11,7 @@ export const WECOM_ENDPOINTS = Object.freeze({
   bindCredentials: 'bot.bind-credentials',
   reconnectBot: 'bot.reconnect',
   deleteBot: 'bot.delete',
+  setWorkspace: SET_WORKSPACE_ENDPOINT,
 });
 export const WECOM_RPC_ENDPOINTS = Object.freeze(Object.values(WECOM_ENDPOINTS));
 
@@ -57,6 +59,10 @@ function payloadFailure(endpoint, payload) {
     return exactKeys(payload, ['botId', 'confirm']) && validId(payload.botId) && payload.confirm === true
       ? null : 'bot.delete requires a botId and confirm=true.';
   }
+  if (endpoint === WECOM_ENDPOINTS.setWorkspace) {
+    return validWorkspacePayload(payload)
+      ? null : '请输入工作区绝对路径。';
+  }
   return 'Unknown Enterprise WeChat endpoint.';
 }
 
@@ -125,16 +131,24 @@ export function createWecomRpcHandler(controller, { encodeQr = qrDataUrl } = {})
         value = await publicStatus(await controller.bindCredentials(payload), cachedEncode);
       } else if (endpoint === WECOM_ENDPOINTS.reconnectBot) {
         value = await publicStatus(await controller.reconnectBot(payload.botId), cachedEncode);
+      } else if (endpoint === WECOM_ENDPOINTS.setWorkspace) {
+        if (typeof controller.updateWorkspace !== 'function') throw new Error('Workspace update is unavailable');
+        value = await publicStatus(
+          await controller.updateWorkspace(payload.botId, payload.workspace),
+          cachedEncode,
+        );
       } else {
         value = await publicStatus(await controller.deleteBot(payload.botId), cachedEncode);
       }
       return signal?.aborted
         ? { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } }
         : { ok: true, value };
-    } catch {
+    } catch (error) {
+      const workspaceError = publicWorkspaceError(error);
       return signal?.aborted
         ? { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } }
-        : { ok: false, error: { code: 'wecom-operation-failed', message: '企业微信操作失败，请稍后重试。' } };
+        : { ok: false, error: workspaceError
+          ?? { code: 'wecom-operation-failed', message: '企业微信操作失败，请稍后重试。' } };
     }
   };
 }

package/plugin-src/host/channels/weixin/production.mjs

@@ -8,6 +8,12 @@ import { WeixinStateStore } from '../../../../src/channels/weixin/state-store.mj
 import { createWeixinApi } from '../../../../src/channels/weixin/weixin-api.mjs';
 import { WeixinController } from '../../../../src/channels/weixin/weixin-controller.mjs';
 import { WeixinRuntime } from '../../../../src/channels/weixin/weixin-runtime.mjs';
+import {
+  BotWorkspaceStore,
+  createBotWorkspaceScope,
+  createWorkspaceAwareController,
+  observeBotWorkspaceRemovals,
+} from '../../../../src/channels/shared/bot-workspace-store.mjs';
 import { createConnectionSupervisor } from './connection-supervisor.mjs';
 
 function harnessOrigin(webServer, configured) {
@@ -26,6 +32,7 @@ function pluginPaths(config) {
     root,
     config: resolve(config.configPath ?? join(root, 'config.json')),
     accounts: resolve(config.accountsDir ?? join(root, 'accounts')),
+    workspaces: resolve(config.workspacesPath ?? join(root, 'workspaces.json')),
   };
 }
 
@@ -45,6 +52,16 @@ export async function createProductionController(ctx, config = {}, internals = {
     : (ctx.logger ?? console);
   const paths = pluginPaths(config);
   const configStore = await new ConfigStore(paths.config).load();
+  const defaultWorkspace = resolve(config.workspace ?? process.cwd());
+  const WorkspaceStore = internals.WorkspaceStore ?? BotWorkspaceStore;
+  const workspaces = internals.workspaces
+    ?? await new WorkspaceStore(paths.workspaces, { defaultWorkspace }).load();
+  const configuredBots = configStore.list();
+  await workspaces.reconcile(configuredBots.map((bot) => bot.botId));
+  await Promise.all(configuredBots.map((bot) => workspaces.ensure(bot.botId)));
+  const observedConfigStore = typeof configStore.remove === 'function'
+    ? observeBotWorkspaceRemovals(configStore, { workspaces })
+    : configStore;
   const stateStores = new Map();
 
   const statePath = (botId) => resolve(paths.accounts, botId, 'state.json');
@@ -58,24 +75,26 @@ export async function createProductionController(ctx, config = {}, internals = {
   };
   const harness = new Harness({
     baseUrl: harnessOrigin(ctx.webServer, config.harnessBaseUrl),
-    workspace: resolve(config.workspace ?? process.cwd()),
+    workspace: defaultWorkspace,
     agentPreset: config.agentPreset ?? 'standard',
     autostart: false,
     dshBin: config.dshBin ?? 'dsh',
   });
-  const controller = new Controller({
+  const coreController = new Controller({
     api,
     credentials: ctx.credentials,
-    configStore,
+    configStore: observedConfigStore,
     logger,
     createRuntime: async ({ botId, config: accountConfig, token }) => {
       const state = await stateFor(botId);
+      await workspaces.ensure(botId);
+      const workspaceScope = createBotWorkspaceScope(harness, { botId, workspaces, state });
       return new Runtime({
         api,
         config: accountConfig,
         token,
-        harness,
-        state,
+        harness: workspaceScope.harness,
+        state: workspaceScope.state,
         replyTimeoutMs: config.replyTimeoutMs ?? 600_000,
         maxMessageChars: config.maxMessageChars ?? 4_000,
         logger: {
@@ -91,15 +110,16 @@ export async function createProductionController(ctx, config = {}, internals = {
       stateStores.delete(botId);
       if (state && typeof state.remove === 'function') {
         await state.remove();
-        return;
-      }
-      try {
-        await unlink(statePath(botId));
-      } catch (error) {
-        if (error?.code !== 'ENOENT') throw error;
+      } else {
+        try {
+          await unlink(statePath(botId));
+        } catch (error) {
+          if (error?.code !== 'ENOENT') throw error;
+        }
       }
     },
   });
+  const controller = createWorkspaceAwareController(coreController, { workspaces, stateFor });
   const supervisor = createSupervisor({
     controller,
     harness,

package/plugin-src/host/channels/weixin/rpc.mjs

@@ -1,5 +1,10 @@
 import QRCode from 'qrcode';
 import { resolveRpcAuthority } from '../../rpc-authority.mjs';
+import {
+  publicWorkspaceError,
+  SET_WORKSPACE_ENDPOINT,
+  validWorkspacePayload,
+} from '../shared/workspace-rpc.mjs';
 
 export const WEIXIN_RPC_CHANNEL = '/weixin';
 export const WEIXIN_ENDPOINTS = Object.freeze({
@@ -10,6 +15,7 @@ export const WEIXIN_ENDPOINTS = Object.freeze({
   cancelProvisioning: 'provision.cancel',
   reconnectBot: 'bot.reconnect',
   deleteBot: 'bot.delete',
+  setWorkspace: SET_WORKSPACE_ENDPOINT,
 });
 export const WEIXIN_RPC_ENDPOINTS = Object.freeze(Object.values(WEIXIN_ENDPOINTS));
 
@@ -58,6 +64,10 @@ function payloadFailure(endpoint, payload) {
       ? null
       : 'bot.delete requires a botId and confirm=true.';
   }
+  if (endpoint === WEIXIN_ENDPOINTS.setWorkspace) {
+    return validWorkspacePayload(payload)
+      ? null : '请输入工作区绝对路径。';
+  }
   return 'Unknown Weixin endpoint.';
 }
 
@@ -156,12 +166,21 @@ export function createWeixinRpcHandler(controller, { encodeQr = qrDataUrl } = {}
         if (!value) return badRequest('The provisioning attempt no longer exists.');
       } else if (endpoint === WEIXIN_ENDPOINTS.reconnectBot) {
         value = await publicStatus(await controller.reconnectBot(payload.botId), cachedEncode);
+      } else if (endpoint === WEIXIN_ENDPOINTS.setWorkspace) {
+        if (typeof controller.updateWorkspace !== 'function') throw new Error('Workspace update is unavailable');
+        value = await publicStatus(
+          await controller.updateWorkspace(payload.botId, payload.workspace),
+          cachedEncode,
+        );
       } else {
         value = await publicStatus(await controller.deleteBot(payload.botId), cachedEncode);
       }
       return signal?.aborted ? cancelled() : { ok: true, value };
-    } catch {
-      return signal?.aborted ? cancelled() : internalFailure();
+    } catch (error) {
+      const workspaceError = publicWorkspaceError(error);
+      return signal?.aborted ? cancelled() : workspaceError
+        ? { ok: false, error: workspaceError }
+        : internalFailure();
     }
   };
 }

package/plugin-src/host/channels/whatsapp/production.mjs

@@ -8,6 +8,12 @@ import { WhatsappStateStore } from '../../../../src/channels/whatsapp/state-stor
 import { WhatsappController } from '../../../../src/channels/whatsapp/whatsapp-controller.mjs';
 import { WhatsappRuntime } from '../../../../src/channels/whatsapp/whatsapp-runtime.mjs';
 import { createWhatsappWebSession } from '../../../../src/channels/whatsapp/whatsapp-web-session.mjs';
+import {
+  BotWorkspaceStore,
+  createBotWorkspaceScope,
+  createWorkspaceAwareController,
+  observeBotWorkspaceRemovals,
+} from '../../../../src/channels/shared/bot-workspace-store.mjs';
 import { createTokenConnectionSupervisor } from '../shared/connection-supervisor.mjs';
 
 const AUTH_DIRECTORY_PATTERN = /^[a-f0-9-]{36}$/;
@@ -32,6 +38,7 @@ function pluginPaths(config) {
   return {
     config: resolve(config.configPath ?? join(root, 'config.json')),
     bots: resolve(config.botsDir ?? join(root, 'bots')),
+    workspaces: resolve(config.workspacesPath ?? join(root, 'workspaces.json')),
     authPath,
   };
 }
@@ -49,6 +56,16 @@ export async function createProductionController(ctx, config = {}, internals = {
   const createSupervisor = internals.createConnectionSupervisor ?? createTokenConnectionSupervisor;
   const paths = pluginPaths(config);
   const configStore = await new ConfigStore(paths.config).load();
+  const defaultWorkspace = resolve(config.workspace ?? process.cwd());
+  const WorkspaceStore = internals.WorkspaceStore ?? BotWorkspaceStore;
+  const workspaces = internals.workspaces
+    ?? await new WorkspaceStore(paths.workspaces, { defaultWorkspace }).load();
+  const configuredBots = configStore.list();
+  await workspaces.reconcile(configuredBots.map((bot) => bot.botId));
+  await Promise.all(configuredBots.map((bot) => workspaces.ensure(bot.botId)));
+  const observedConfigStore = typeof configStore.remove === 'function'
+    ? observeBotWorkspaceRemovals(configStore, { workspaces })
+    : configStore;
   const stateStores = new Map();
   const statePath = (botId) => resolve(paths.bots, botId, 'state.json');
   const stateFor = async (botId) => {
@@ -61,31 +78,36 @@ export async function createProductionController(ctx, config = {}, internals = {
   };
   const harness = new Harness({
     baseUrl: harnessOrigin(ctx.webServer, config.harnessBaseUrl),
-    workspace: resolve(config.workspace ?? process.cwd()),
+    workspace: defaultWorkspace,
     agentPreset: config.agentPreset ?? 'standard',
     autostart: false,
     dshBin: config.dshBin ?? 'dsh',
   });
-  const controller = new Controller({
-    configStore,
+  const coreController = new Controller({
+    configStore: observedConfigStore,
     authPath: paths.authPath,
     createSession,
     logger,
-    createRuntime: async ({ botId, config: botConfig, authDir }) => new Runtime({
-      config: botConfig,
-      authDir,
-      harness,
-      state: await stateFor(botId),
-      replyTimeoutMs: config.replyTimeoutMs ?? 600_000,
-      connectTimeoutMs: config.connectTimeoutMs ?? 30_000,
-      createSession,
-      logger: {
-        error: (...args) => logger.error?.(`[${botId}]`, ...args),
-        warn: (...args) => logger.warn?.(`[${botId}]`, ...args),
-        info: (...args) => logger.info?.(`[${botId}]`, ...args),
-        debug: (...args) => logger.debug?.(`[${botId}]`, ...args),
-      },
-    }),
+    createRuntime: async ({ botId, config: botConfig, authDir }) => {
+      const state = await stateFor(botId);
+      await workspaces.ensure(botId);
+      const workspaceScope = createBotWorkspaceScope(harness, { botId, workspaces, state });
+      return new Runtime({
+        config: botConfig,
+        authDir,
+        harness: workspaceScope.harness,
+        state: workspaceScope.state,
+        replyTimeoutMs: config.replyTimeoutMs ?? 600_000,
+        connectTimeoutMs: config.connectTimeoutMs ?? 30_000,
+        createSession,
+        logger: {
+          error: (...args) => logger.error?.(`[${botId}]`, ...args),
+          warn: (...args) => logger.warn?.(`[${botId}]`, ...args),
+          info: (...args) => logger.info?.(`[${botId}]`, ...args),
+          debug: (...args) => logger.debug?.(`[${botId}]`, ...args),
+        },
+      });
+    },
     deleteAuth: (authDirectory) => rm(paths.authPath(authDirectory), {
       recursive: true,
       force: true,
@@ -93,14 +115,18 @@ export async function createProductionController(ctx, config = {}, internals = {
     deleteState: async ({ botId }) => {
       const state = stateStores.get(botId);
       stateStores.delete(botId);
-      if (state && typeof state.remove === 'function') return state.remove();
-      try {
-        await unlink(statePath(botId));
-      } catch (error) {
-        if (error?.code !== 'ENOENT') throw error;
+      if (state && typeof state.remove === 'function') {
+        await state.remove();
+      } else {
+        try {
+          await unlink(statePath(botId));
+        } catch (error) {
+          if (error?.code !== 'ENOENT') throw error;
+        }
       }
     },
   });
+  const controller = createWorkspaceAwareController(coreController, { workspaces, stateFor });
   const supervisor = createSupervisor({
     channel: 'whatsapp',
     controller,

package/plugin-src/host/channels/whatsapp/rpc.mjs

@@ -1,6 +1,7 @@
 import QRCode from 'qrcode';
 
 import { resolveRpcAuthority } from '../../rpc-authority.mjs';
+import { publicWorkspaceError, SET_WORKSPACE_ENDPOINT, validWorkspacePayload } from '../shared/workspace-rpc.mjs';
 
 export const WHATSAPP_RPC_CHANNEL = '/whatsapp';
 export const WHATSAPP_ENDPOINTS = Object.freeze({
@@ -10,6 +11,7 @@ export const WHATSAPP_ENDPOINTS = Object.freeze({
   cancelProvisioning: 'provision.cancel',
   reconnectBot: 'bot.reconnect',
   deleteBot: 'bot.delete',
+  setWorkspace: SET_WORKSPACE_ENDPOINT,
 });
 export const WHATSAPP_RPC_ENDPOINTS = Object.freeze(Object.values(WHATSAPP_ENDPOINTS));
 
@@ -44,6 +46,10 @@ function payloadFailure(endpoint, payload) {
     return exactKeys(payload, ['botId', 'confirm']) && validId(payload.botId)
       && payload.confirm === true ? null : 'bot.delete requires a botId and confirm=true.';
   }
+  if (endpoint === WHATSAPP_ENDPOINTS.setWorkspace) {
+    return validWorkspacePayload(payload)
+      ? null : '请输入工作区绝对路径。';
+  }
   return 'Unknown WhatsApp endpoint.';
 }
 
@@ -114,16 +120,24 @@ export function createWhatsappRpcHandler(controller, { encodeQr = qrDataUrl } =
         value = sanitizePublic(await controller.cancelProvisioning(payload.attemptId));
       } else if (endpoint === WHATSAPP_ENDPOINTS.reconnectBot) {
         value = await publicStatus(await controller.reconnectBot(payload.botId), cachedEncode);
+      } else if (endpoint === WHATSAPP_ENDPOINTS.setWorkspace) {
+        if (typeof controller.updateWorkspace !== 'function') throw new Error('Workspace update is unavailable');
+        value = await publicStatus(
+          await controller.updateWorkspace(payload.botId, payload.workspace),
+          cachedEncode,
+        );
       } else {
         value = await publicStatus(await controller.deleteBot(payload.botId), cachedEncode);
       }
       return signal?.aborted
         ? { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } }
         : { ok: true, value };
-    } catch {
+    } catch (error) {
+      const workspaceError = publicWorkspaceError(error);
       return signal?.aborted
         ? { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } }
-        : { ok: false, error: { code: 'whatsapp-operation-failed', message: 'WhatsApp 操作失败，请稍后重试。' } };
+        : { ok: false, error: workspaceError
+          ?? { code: 'whatsapp-operation-failed', message: 'WhatsApp 操作失败，请稍后重试。' } };
     }
   };
 }

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

@@ -3,6 +3,8 @@ import {
   splitDingtalkText,
 } from './dingtalk-api.mjs';
 import { createDingTalkCardStream } from './dingtalk-card-stream.mjs';
+import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
+import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
 
 const CARD_INITIAL_TEXT = '已连接 DeepSeek Harness，正在思考…';
 const CARD_ERROR_TEXT = '消息处理失败，请稍后重试。';
@@ -12,6 +14,7 @@ const HELP_TEXT = [
   '',
   '直接发送文字即可继续当前会话。',
   '/new  开启一个全新会话',
+  '/workspace 工作区绝对路径  切换工作区',
   '/status  检查连接状态',
   '/help  显示本帮助',
 ].join('\n');
@@ -213,12 +216,12 @@ export class DingtalkHarnessBridge {
         await this.#send(sessionWebhook, '已开启新会话。请发送你的问题。');
         return;
       }
-
-      let sessionId = this.#state.sessionFor(key);
-      if (!sessionId || !(await this.#harness.sessionExists(sessionId, { signal: this.#signal }))) {
-        sessionId = await this.#harness.createSession({ signal: this.#signal });
-        await this.#state.setSession(key, sessionId);
+      const workspaceCommand = await runWorkspaceCommand(text, this.#harness);
+      if (workspaceCommand) {
+        await this.#send(sessionWebhook, workspaceCommand.message);
+        return;
       }
+
       if (typeof this.#api.createAiCard === 'function'
         && typeof this.#api.updateAiCard === 'function'
         && typeof this.#api.finishAiCard === 'function') {
@@ -232,12 +235,20 @@ export class DingtalkHarnessBridge {
         });
         cardStarted = await cardStream.start(CARD_INITIAL_TEXT);
       }
-      const answer = await this.#harness.ask(sessionId, text, {
-        timeoutMs: this.#replyTimeoutMs,
-        signal: this.#signal,
-        onUpdate: cardStarted
-          ? (update) => cardStream.push(progressText(update))
-          : undefined,
+      const { answer } = await askInWorkspaceSession({
+        harness: this.#harness,
+        state: this.#state,
+        key,
+        text,
+        createOptions: { signal: this.#signal },
+        existsOptions: { signal: this.#signal },
+        askOptions: {
+          timeoutMs: this.#replyTimeoutMs,
+          signal: this.#signal,
+          onUpdate: cardStarted
+            ? (update) => cardStream.push(progressText(update))
+            : undefined,
+        },
       });
       const streamed = cardStarted && await cardStream.finish(answer);
       if (!streamed) await this.#send(sessionWebhook, answer);

package/src/channels/dingtalk/dingtalk-controller.mjs

@@ -610,7 +610,12 @@ export class DingtalkController {
         await this.#stopRuntime(identity.botId);
         if (previousConfig) await this.#configStore.save(previousConfig).catch(() => undefined);
         else if (this.#configStore.get(identity.botId)) {
-          await this.#configStore.remove(identity.botId).catch(() => undefined);
+          const removed = await this.#configStore.remove(identity.botId).catch(() => null);
+          if (removed) {
+            await this.#deleteState({ botId: identity.botId, config }).catch((cleanupError) => {
+              this.#logger.warn?.('[dsh-dingtalk] failed to clean up cancelled bot state:', cleanupError);
+            });
+          }
         }
         await this.#restoreCredential(identity.secretRef, previousSecret);
         if (previousConfig && cleanString(previousSecret?.value)) {

package/src/channels/dingtalk/harness-client.mjs

@@ -217,10 +217,11 @@ export class HarnessClient {
   }
 
   async workspaceId(options = {}) {
-    const { items } = await this.rpc('workspace.list', {}, 30_000, options);
-    const existing = items.find((item) => item.path === this.#workspace);
+    const { workspace = this.#workspace, ...rpcOptions } = options;
+    const { items } = await this.rpc('workspace.list', {}, 30_000, rpcOptions);
+    const existing = items.find((item) => item.path === workspace);
     if (existing) return existing.workspaceId;
-    const created = await this.rpc('workspace.create', { path: this.#workspace }, 30_000, options);
+    const created = await this.rpc('workspace.create', { path: workspace }, 30_000, rpcOptions);
     return created.workspace.workspaceId;
   }
 

package/src/channels/dingtalk/state-store.mjs

@@ -117,6 +117,11 @@ export class DingtalkStateStore {
     await this.#persist();
   }
 
+  async clearSessions() {
+    this.#state.sessions = {};
+    await this.#persist();
+  }
+
   hasSeen(messageId) {
     const id = nonEmptyString(messageId);
     return Boolean(id && this.#state.seenMessageIds.includes(id));

package/src/channels/discord/discord-api.mjs

@@ -108,7 +108,7 @@ export class DiscordApi {
         headers: {
           authorization: `Bot ${this.#token}`,
           'content-type': 'application/json',
-          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.3.0)',
+          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.5.0)',
         },
         ...(body === undefined ? {} : { body: JSON.stringify(body) }),
         signal: requestSignal(signal, timeoutMs),

package/src/channels/feishu/bridge.mjs

@@ -5,12 +5,15 @@ import {
   isBotSender,
   splitText,
 } from './message-utils.mjs';
+import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
+import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
 
 const HELP_TEXT = [
   '北汇星河 AIOS 已连接 DeepSeek Harness。',
   '',
   '直接发送问题即可继续当前会话。',
   '/new  开启一个全新会话',
+  '/workspace 工作区绝对路径  切换工作区',
   '/status  检查连接状态',
   '/help  显示本帮助',
 ].join('\n');
@@ -106,25 +109,30 @@ export class FeishuHarnessBridge {
       await this.#send(event.message.chat_id, '飞书机器人与 DeepSeek Harness 连接正常。');
       return;
     }
-
-    let sessionId = this.#state.sessionFor(key);
-    if (!sessionId || !(await this.#harness.sessionExists(sessionId))) {
-      sessionId = await this.#harness.createSession();
-      await this.#state.setSession(key, sessionId);
+    const workspaceCommand = await runWorkspaceCommand(text, this.#harness);
+    if (workspaceCommand) {
+      await this.#send(event.message.chat_id, workspaceCommand.message);
+      return;
     }
 
-    console.info(`[bridge] processing ${event.message.chat_type} message ${messageId} in ${sessionId}`);
-    await this.#answerWithStream(event, sessionId, text);
+    console.info(`[bridge] processing ${event.message.chat_type} message ${messageId}`);
+    await this.#answerWithStream(event, key, text);
     this.#status.messagesReplied += 1;
     this.#status.lastReplyAt = new Date().toISOString();
     this.#status.lastError = null;
   }
 
-  async #answerWithStream(event, sessionId, text) {
+  async #answerWithStream(event, key, text) {
     const chatId = event.message.chat_id;
     const messageId = event.message.message_id;
     if (!this.#channel?.stream) {
-      const answer = await this.#harness.ask(sessionId, text, { timeoutMs: this.#replyTimeoutMs });
+      const { answer } = await askInWorkspaceSession({
+        harness: this.#harness,
+        state: this.#state,
+        key,
+        text,
+        askOptions: { timeoutMs: this.#replyTimeoutMs },
+      });
       for (const chunk of splitText(answer)) await this.#send(chatId, chunk);
       this.#status.streamFallbacks = (this.#status.streamFallbacks ?? 0) + 1;
       return;
@@ -136,13 +144,19 @@ export class FeishuHarnessBridge {
       await this.#channel.stream(chatId, {
         markdown: async (controller) => {
           promptStarted = true;
-          completedAnswer = await this.#harness.ask(sessionId, text, {
-            timeoutMs: this.#replyTimeoutMs,
-            onUpdate: async (update) => {
-              await controller.setContent(this.#progressText(update));
-              this.#status.streamUpdates = (this.#status.streamUpdates ?? 0) + 1;
+          ({ answer: completedAnswer } = await askInWorkspaceSession({
+            harness: this.#harness,
+            state: this.#state,
+            key,
+            text,
+            askOptions: {
+              timeoutMs: this.#replyTimeoutMs,
+              onUpdate: async (update) => {
+                await controller.setContent(this.#progressText(update));
+                this.#status.streamUpdates = (this.#status.streamUpdates ?? 0) + 1;
+              },
             },
-          });
+          }));
           await controller.setContent(completedAnswer);
         },
       }, { replyTo: messageId });
@@ -158,7 +172,13 @@ export class FeishuHarnessBridge {
       if (promptStarted) throw error;
 
       console.warn('[bridge] native Feishu stream unavailable; using text fallback:', error.message);
-      const answer = await this.#harness.ask(sessionId, text, { timeoutMs: this.#replyTimeoutMs });
+      const { answer } = await askInWorkspaceSession({
+        harness: this.#harness,
+        state: this.#state,
+        key,
+        text,
+        askOptions: { timeoutMs: this.#replyTimeoutMs },
+      });
       for (const chunk of splitText(answer)) await this.#send(chatId, chunk);
       this.#status.streamFallbacks = (this.#status.streamFallbacks ?? 0) + 1;
     }

package/src/channels/feishu/harness-client.mjs

@@ -197,17 +197,18 @@ export class HarnessClient {
     throw new Error(`Harness did not become ready: ${lastError?.message ?? 'timeout'}`);
   }
 
-  async workspaceId() {
+  async workspaceId(options = {}) {
+    const workspace = options.workspace ?? this.#workspace;
     const { items } = await this.rpc('workspace.list', {});
-    const existing = items.find((item) => item.path === this.#workspace);
+    const existing = items.find((item) => item.path === workspace);
     if (existing) return existing.workspaceId;
-    const created = await this.rpc('workspace.create', { path: this.#workspace });
+    const created = await this.rpc('workspace.create', { path: workspace });
     return created.workspace.workspaceId;
   }
 
-  async createSession() {
+  async createSession(options = {}) {
     await this.ensureRunning();
-    const workspaceId = await this.workspaceId();
+    const workspaceId = await this.workspaceId(options);
     const created = await this.rpc('session.create', {
       workspaceId,
       agentPreset: this.#agentPreset,

package/src/channels/feishu/state-store.mjs

@@ -41,6 +41,11 @@ export class StateStore {
     await this.#persist();
   }
 
+  async clearSessions() {
+    this.#state.sessions = {};
+    await this.#persist();
+  }
+
   hasSeen(messageId) {
     return this.#state.seenMessageIds.includes(messageId);
   }