dsh-bot-team 1.1.0 → 1.3.0

package/host/service.js

@@ -10,12 +10,20 @@ import { appendFile, mkdir, stat } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 
 import { openRepository } from './domain.js';
+import { currentConversationId, conversationIdOf, isCurrentMemberSession } from './conversations.js';
+import { collectNativeConversationBlockers, nativeConversationCapability } from './native-activity.js';
+import { openPluginStorageDomain } from './storage-layout.js';
 import { CHAT_DISPLAY_SETTINGS_KEY, isChatDisplaySettings, normalizeChatDisplaySettings } from './chat-settings.js';
 import { Personas } from './personas.js';
 import { AgentPool } from './agents.js';
+import { BackgroundInteractions } from './background-interactions.js';
+import { BotSessionVisibility } from './session-visibility.js';
 import { Engine } from './engine.js';
-import { readMessageExecution } from './execution.js';
+import { isDiscussionActive, MAX_DISCUSSION_ROUNDS } from './discussion-flow.js';
+import { readBotSessionHistory, readBotSessionLog, readMessageExecution } from './execution.js';
+import { serializeBotSessionLog } from './session-export.js';
 import { registerRoutes } from './routes.js';
+import { UpdateChecker } from './update-check.js';
 import { BOT_TEAM_TOOL_NAMES, registerBotTeamTools } from './tools.js';
 import { GroupBus, asString, fail, json, newId, now, trimmed } from './util.js';
 import {
@@ -34,12 +42,13 @@ import {
 } from './layout.js';
 import { parseMentionsFromText, renderGroupContext, renderPersona } from './prompt.js';
 import { buildGroupPdf } from './pdf.js';
-import { defaultWorkspaceDir, ensureWorkspaceDir, isStandardLayout, migrateLegacyLayout } from './workspace.js';
+import { defaultWorkspaceDir, ensureWorkspaceDir, isStandardLayout, migrateLegacyLayout, normalizeWorkspacePath, sessionCwdMatches, validateProjectWorkspace } from './workspace.js';
 
 class ServiceError extends Error {
-  constructor(code, message) {
+  constructor(code, message, details) {
     super(message);
     this.code = code;
+    if (details) this.details = details;
   }
 }
 
@@ -55,7 +64,7 @@ try {
 export const PLUGIN_INFO = Object.freeze({
   name: 'Bot Team',
   packageName: typeof pluginPackage.name === 'string' ? pluginPackage.name : 'dsh-bot-team',
-  version: typeof pluginPackage.version === 'string' ? pluginPackage.version : '1.1.0',
+  version: typeof pluginPackage.version === 'string' ? pluginPackage.version : '1.3.0',
   author: typeof pluginPackage.author === 'string'
     ? pluginPackage.author
     : pluginPackage.author && typeof pluginPackage.author.name === 'string'
@@ -75,9 +84,15 @@ const ATTACHMENT_ID_RE = /^sha256:[0-9a-f]{64}$/;
 
 const BOT_COLORS = ['#2f7ed8', '#8b5cf6', '#0d9488', '#d97706', '#db2777', '#4f46e5', '#65a30d', '#dc2626'];
 
-// Avatar grammar: preset seeds are robot mascots, art IDs are the bundled SVG pack.
+// Avatar grammar: preset seeds are mascots; bundled Bot art may include a stable palette ID.
 const AVATAR_PRESET_RE = /^preset:[a-z0-9-]{1,40}$/;
-const AVATAR_ART_IDS = new Set(['planet', 'rocket', 'cloud', 'bolt', 'leaf', 'flame', 'star', 'moon', 'wave', 'flower']);
+const AVATAR_ART_IDS = new Set([
+  // Keep the original illustrations valid for saved Bot and group records.
+  'planet', 'rocket', 'cloud', 'bolt', 'leaf', 'flame', 'star', 'moon', 'wave', 'flower',
+  'bot-orbit', 'bot-spark', 'bot-circuit', 'bot-pixel', 'bot-scout', 'bot-assistant', 'bot-core', 'bot-android',
+  'group-team', 'group-bots', 'group-network', 'group-dialogue', 'group-lab', 'group-huddle', 'group-swarm', 'group-community',
+]);
+const AVATAR_ART_PALETTES = new Set(['sky', 'violet', 'mint', 'orange', 'pink', 'indigo', 'teal', 'slate']);
 const MAX_AVATAR_CHARS = 800000;
 
 function normalizeAvatar(value) {
@@ -90,9 +105,13 @@ function normalizeAvatar(value) {
     return text;
   }
   if (text.startsWith('art:')) {
-    const id = text.slice('art:'.length);
-    if (!AVATAR_ART_IDS.has(id)) throw new ServiceError('invalid-input', '未知的插画头像');
-    return `art:${id}`;
+    const match = /^art:([a-z0-9-]+)(?::([a-z0-9-]+))?$/.exec(text);
+    if (!match || !AVATAR_ART_IDS.has(match[1])) throw new ServiceError('invalid-input', '未知的插画头像');
+    const [, id, paletteId] = match;
+    if (paletteId && (!id.startsWith('bot-') || !AVATAR_ART_PALETTES.has(paletteId))) {
+      throw new ServiceError('invalid-input', '未知的头像配色');
+    }
+    return text;
   }
   if (text.startsWith('data:image/')) {
     if (text.length > MAX_AVATAR_CHARS) throw new ServiceError('invalid-input', '头像图片过大');
@@ -116,15 +135,19 @@ function optionalText(value, max) {
 }
 
 export class BotTeamService {
-  constructor(ctx, config) {
+  constructor(ctx, config, dependencies = {}) {
     this.ctx = ctx;
     this.config = config;
     this.logger = ctx.logger;
     this.bus = new GroupBus();
+    this.updateChecker = new UpdateChecker({ currentVersion: PLUGIN_INFO.version, ...dependencies.updateCheck });
     this.repo = null;
     this.personas = null;
     this.pool = null;
     this.engine = null;
+    this.conversationChanges = new Set();
+    this.workspaceChanges = new Set();
+    this.workspaceOperations = new Map();
     this.modelCatalogCache = null;
     this.smokeState = null;
     this.routeDispose = registerRoutes(ctx, this);
@@ -132,13 +155,15 @@ export class BotTeamService {
     this.disposed = false;
 
     this.ready = this.init();
+    // Update detection is independent of chat startup and never delays ready.
+    void this.updateChecker.check();
     this.ready.catch((error) => {
       this.logger?.error?.(`bot-team: init failed: ${String(error && error.stack ? error.stack : error)}`);
     });
   }
 
   async init() {
-    this.repo = await openRepository(this.ctx, this.logger);
+    this.repo = await openRepository(this.ctx, this.logger, spec => openPluginStorageDomain(this.ctx.storageDomain, spec, this.logger));
     const migration = await this.repo.runMigrations();
     if (migration.applied.length > 0) {
       this.logger?.info?.('bot-team: migrated domain records to schema v' + migration.version);
@@ -152,6 +177,14 @@ export class BotTeamService {
         )}`);
       }
     }
+    // Older group records already allowed custom workspaces; expose them as
+    // imported projects without changing the directory or its contents.
+    for (const group of this.repo.groups.values()) {
+      if (typeof group.projectWorkspaceCwd === 'string') continue;
+      group.projectWorkspaceCwd = group.workspaceCwd && !sessionCwdMatches(group.workspaceCwd, defaultWorkspaceDir(this.config, group))
+        ? group.workspaceCwd : '';
+      await this.repo.putGroup(group);
+    }
     this.personas = new Personas(this.config.botsDir, this.logger);
     this.pool = new AgentPool({
       ctx: this.ctx,
@@ -160,6 +193,7 @@ export class BotTeamService {
       config: this.config,
       logger: this.logger,
     });
+    this.pool.assertAdmission = (groupId) => this.assertWorkspaceStable(groupId);
     this.pool.attachPrompt({
       renderPersona: (botId, groupId) => renderPersona(this.repo, this.personas, botId, groupId),
       renderGroupContext: (botId, groupId) => renderGroupContext(this.repo, botId, groupId),
@@ -172,10 +206,17 @@ export class BotTeamService {
       bus: this.bus,
       config: this.config,
       logger: this.logger,
-      quotaGuard: (groupId, turns) => this.checkQuota(groupId, turns),
-      taskHook: (job, message, status) => this.onTaskJobFinished(job, message, status),
+      quotaGuard: (groupId) => this.checkQuota(groupId),
+      discussionGuard: (discussion) => this.assertDiscussionNativeIdle(discussion),
+      workspaceGuard: (groupId) => this.assertWorkspaceStable(groupId),
+      taskHook: async (job, message, status) => {
+        await this.onTaskJobFinished(job, message, status);
+        await this.visibility?.reconcile();
+      },
     });
+    this.engine.assertAdmission = (groupId) => this.assertWorkspaceStable(groupId);
     this.pool.attachStreamHandler((payload) => this.engine.onAssistantStream(payload));
+    this.interactions = new BackgroundInteractions({ ctx: this.ctx, repo: this.repo, bus: this.bus });
     this.toolDispose = registerBotTeamTools({
       ctx: this.ctx,
       service: this,
@@ -183,6 +224,13 @@ export class BotTeamService {
       logger: this.logger,
     });
     await this.personas.preload(this.repo.allBots().map((bot) => bot.botId));
+    await this.pool.ready;
+    await this.engine.recoverNativeSessions();
+    this.visibility = new BotSessionVisibility({
+      ctx: this.ctx, repo: this.repo, logger: this.logger,
+      isBusy: sessionId => this.engine.activeBySession.has(sessionId),
+    });
+    await this.visibility.ready;
     this.logger?.info?.(`bot-team: ready (domain bot_team, bots=${this.repo.bots.size}, groups=${this.repo.groups.size})`);
 
     if (this.config.smokeTest) {
@@ -193,12 +241,175 @@ export class BotTeamService {
     return this;
   }
 
+  conversationState(groupId) {
+    const conversation = this.repo?.activeConversation?.(groupId) || null;
+    const group = this.repo?.getGroup?.(groupId);
+    return {
+      activeConversationId: conversation?.conversationId || group?.activeConversationId || null,
+      currentConversationId: conversation?.conversationId || group?.activeConversationId || null,
+      conversationVersion: conversation?.ordinal || group?.conversationVersion || 0,
+      currentConversation: conversation,
+    };
+  }
+
+  conversationCapability() {
+    if (typeof this.repo?.commitConversation !== 'function') return { supported: false, reason: '会话存储尚未就绪' };
+    return nativeConversationCapability({ ctx: this.ctx, pool: this.pool });
+  }
+
+  isCurrentRecord(record) {
+    return !!record && conversationIdOf(this.repo, record) === currentConversationId(this.repo, record.groupId);
+  }
+
+  assertCurrentRecord(record) {
+    if (record && !this.isCurrentRecord(record)) {
+      throw new ServiceError('historical-target', '目标属于已结束的会话，请选取内容后在当前会话重新发起', this.conversationState(record.groupId));
+    }
+  }
+
+  assertExpectedConversation(groupId, expected, required = false) {
+    const state = this.conversationState(groupId);
+    if (!state.currentConversationId) return;
+    if (expected === undefined || expected === null || expected === '') {
+      if (required) throw new ServiceError('reload-required', '聊天已支持独立会话，请刷新页面后重试', state);
+      return;
+    }
+    if (expected !== state.currentConversationId) throw new ServiceError('stale-conversation', '聊天已开始新会话，草稿已保留', state);
+  }
+
+  async conversationBlockers(groupId, { ownChange = false } = {}) {
+    const blockers = [];
+    const add = (code, message) => blockers.push({ code, kind: 'chat', groupId, message });
+    if (!ownChange && this.conversationChanges?.has(groupId)) add('conversation-changing', '正在新建会话');
+    if (this.workspaceChanges?.has(groupId)) add('workspace-changing', '正在切换项目目录');
+    if (this.workspaceOperations?.get(groupId) > 0) add('operation-pending', '聊天操作尚未完成');
+    if (this.engine?.isRunning?.(groupId)) add('execution-running', '仍有运行或排队的回复');
+    if (this.engine?.hasPendingWork?.(groupId)) add('execution-settling', '执行结果尚未保存完成');
+    if (this.repo?.activeDiscussionOf?.(groupId)) add('discussion-running', '讨论尚未结束');
+    if (this.pool?.isPreparingGroup?.(groupId)) add('agent-preparing', 'Bot 正在准备会话');
+    const capability = this.conversationCapability();
+    if (!capability.supported) add('native-capability-unavailable', capability.reason || '宿主无法验证后台工作状态');
+    else {
+      try {
+        blockers.push(...await collectNativeConversationBlockers({ ctx: this.ctx, repo: this.repo, pool: this.pool, groupId, interactions: this.interactions }));
+      } catch (error) {
+        add('native-state-unavailable', '无法确认后台工作状态：' + String(error?.message || error));
+      }
+    }
+    return blockers;
+  }
+
+  async newConversation(input) {
+    this.conversationRequests ??= new Map();
+    const key = JSON.stringify([input.groupId, input.requestId]);
+    const existing = this.conversationRequests.get(key);
+    if (existing) {
+      if (existing.expectedConversationId !== input.expectedConversationId) throw new ServiceError('conflict', 'requestId 已用于其他会话请求');
+      return { ...await existing.promise, created: false };
+    }
+    const promise = this.performNewConversation(input);
+    this.conversationRequests.set(key, { expectedConversationId: input.expectedConversationId, promise });
+    try { return await promise; }
+    finally { this.conversationRequests.delete(key); }
+  }
+
+  async performNewConversation(input) {
+    const groupId = String(input.groupId || '');
+    if (!this.repo.getGroup(groupId)) throw new ServiceError('not-found', '群不存在');
+    const requestId = String(input.requestId || '');
+    if (!/^[a-zA-Z0-9_-]{1,160}$/.test(requestId)) throw new ServiceError('invalid-input', '新建会话需要有效的 requestId');
+    const previous = this.repo.conversationsOf(groupId).find((item) => item.requestId === requestId);
+    if (previous) {
+      if (previous.previousConversationId !== input.expectedConversationId) throw new ServiceError('conflict', 'requestId 已用于其他会话请求');
+      return { created: false, conversation: previous, ...this.conversationState(groupId) };
+    }
+    this.assertExpectedConversation(groupId, input.expectedConversationId, true);
+    this.assertWorkspaceStable(groupId);
+    const capability = this.conversationCapability();
+    if (!capability.supported) throw new ServiceError('conversation-capability-unavailable', capability.reason || '宿主无法验证后台工作状态');
+    this.conversationChanges ??= new Set();
+    this.conversationChanges.add(groupId);
+    try {
+      const check = async () => {
+        this.assertExpectedConversation(groupId, input.expectedConversationId, true);
+        const blockers = await this.conversationBlockers(groupId, { ownChange: true });
+        if (blockers.length) throw new ServiceError('conversation-busy', blockers.map((item) => item.message).join('；'), { ...this.conversationState(groupId), blockers });
+      };
+      const flush = async () => {
+        try { await this.repo.flushGroupWrites(groupId); }
+        catch (error) { throw new ServiceError('storage-failed', '聊天更改尚未保存成功：' + String(error?.message || error)); }
+      };
+      await check();
+      await flush();
+      await check();
+      for (const member of this.repo.membersOf(groupId)) {
+        try { await this.pool.disposeMember(member.membershipId, { strict: true }); }
+        catch (error) { throw new ServiceError('session-release-failed', '旧会话释放失败：' + String(error?.message || error)); }
+      }
+      await check();
+      await flush();
+      let result;
+      try { result = await this.repo.commitConversation(groupId, { expectedConversationId: input.expectedConversationId, requestId }); }
+      catch (error) {
+        if (['stale-conversation', 'conflict', 'invalid-input', 'conversation-corrupt'].includes(error?.code)) throw error;
+        throw new ServiceError('storage-failed', '新会话保存失败：' + String(error?.message || error));
+      }
+      try {
+        Promise.resolve(this.interactions?.reconcile?.()).catch((error) => this.logger?.warn?.('bot-team: conversation interaction refresh failed: ' + String(error)));
+        this.bus.emit(groupId, { type: 'conversation.started', groupId, ...result, ...this.conversationState(groupId) });
+      } catch (error) {
+        this.logger?.warn?.('bot-team: conversation committed; notification failed: ' + String(error));
+      }
+      return { ...result, ...this.conversationState(groupId) };
+    } finally {
+      this.conversationChanges.delete(groupId);
+    }
+  }
+
+  messageConversationBoundaries(groupId, messages, { beforeSeq, afterSeq } = {}) {
+    const all = this.repo.conversationsOf?.(groupId) || [];
+    if (!messages.length) return all.filter((item) => (beforeSeq === undefined || item.afterSeq < beforeSeq) && (afterSeq === undefined || item.afterSeq >= afterSeq));
+    const first = messages[0].seq;
+    const last = messages.at(-1).seq;
+    const leading = [...all].reverse().find((item) => item.afterSeq < first);
+    return all.filter((item) => item.afterSeq === leading?.afterSeq || (item.afterSeq >= first && (beforeSeq === undefined || item.afterSeq <= last)));
+  }
+
+  handleConversations(request) {
+    return this.withReady(() => {
+      const params = new URL(request.url).searchParams;
+      const groupId = params.get('groupId') || '';
+      if (!this.repo.getGroup(groupId)) return json(fail('not-found', '群不存在'), 404);
+      const requestedLimit = Number(params.get('limit'));
+      const limit = Number.isSafeInteger(requestedLimit) && requestedLimit > 0 ? Math.min(requestedLimit, 200) : 100;
+      const all = this.repo.conversationsOf(groupId);
+      const id = params.get('conversationId');
+      if (id) {
+        const conversation = all.find((item) => item.conversationId === id);
+        if (!conversation) return json(fail('not-found', '会话不存在'), 404);
+        const rawCursor = params.get('cursor');
+        const cursor = rawCursor === null ? 0 : Number(rawCursor);
+        if (!Number.isSafeInteger(cursor) || cursor < 0) return json(fail('invalid-input', '会话日志游标无效'), 400);
+        const bindings = this.repo.sessionBindingsOf(groupId, id);
+        const sessionBindings = bindings.slice(cursor, cursor + limit);
+        const hasMore = cursor + sessionBindings.length < bindings.length;
+        return json({ ok: true, groupId, conversation, sessionBindings, hasMore, nextCursor: hasMore ? cursor + sessionBindings.length : null, ...this.conversationState(groupId) });
+      }
+      const before = params.has('beforeOrdinal') ? Number(params.get('beforeOrdinal')) : Infinity;
+      if (before !== Infinity && (!Number.isSafeInteger(before) || before < 1)) return json(fail('invalid-input', '会话分页游标无效'), 400);
+      const filtered = all.filter((item) => item.ordinal < before);
+      const conversations = filtered.slice(-limit);
+      return json({ ok: true, groupId, conversations, hasMore: filtered.length > conversations.length, nextBeforeOrdinal: conversations[0]?.ordinal ?? null, ...this.conversationState(groupId) });
+    });
+  }
+
   // ── HTTP handlers ────────────────────────────────────────────────────────
-  async withReady(operation) {
+  async withReady(operation, signal) {
     try {
       await this.ready;
       return await operation();
     } catch (error) {
+      if (signal?.aborted) throw signal.reason ?? error;
       const code = error instanceof ServiceError ? error.code : 'not-ready';
       const status = code === 'not-ready' ? 503 : 400;
       return json(fail(code, String(error && error.message ? error.message : error)), status);
@@ -213,6 +424,13 @@ export class BotTeamService {
     return this.withReady(async () => json(await this.bootstrapPayload()));
   }
 
+  async handleUpdateHttp(request) {
+    const updateInfo = request.method === 'POST'
+      ? await this.updateChecker.check({ force: true })
+      : this.updateChecker.snapshot();
+    return json({ ok: true, updateInfo });
+  }
+
   async bootstrapPayload() {
     const usageByGroup = new Map();
     for (const group of this.repo.groups.values()) {
@@ -226,14 +444,18 @@ export class BotTeamService {
       }
       usageByGroup.set(group.groupId, { inputTokens: input, outputTokens: output, totalTokens: input + output });
     }
-    const groups = this.repo.allGroups().map((group) => {
+    const groups = await Promise.all(this.repo.allGroups().map(async (group) => {
+      const blockers = await this.conversationBlockers(group.groupId);
       const members = this.repo.membersOf(group.groupId);
       const lastMessage = this.repo.lastMessageOf(group.groupId);
-      const discussions = this.repo.discussionsOf(group.groupId);
-      const activeDiscussion = discussions.find((discussion) => discussion.status === 'running') || null;
+      const discussions = this.repo.discussionsOf(group.groupId).filter((item) => this.isCurrentRecord(item));
+      const activeDiscussion = discussions.find(isDiscussionActive) || null;
       const latestDiscussion = discussions[0] || null;
       return {
         ...group,
+        ...this.conversationState(group.groupId),
+        canStartConversation: blockers.length === 0,
+        conversationBlockers: blockers,
         memberIds: members.map((member) => member.membershipId),
         running: this.engine.isRunning(group.groupId),
         usage: usageByGroup.get(group.groupId) || { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
@@ -253,9 +475,10 @@ export class BotTeamService {
             }
           : null,
       };
-    });
+    }));
     return {
       ok: true,
+      capabilities: { conversations: this.conversationCapability().supported, expectedConversationId: true },
       bots: this.repo.allBots(),
       groups,
       folders: this.repo.allFolders(),
@@ -263,6 +486,7 @@ export class BotTeamService {
       directGroupCount: [...this.repo.groups.values()].filter(isDirectGroup).length,
       members: [...this.repo.members.values()].map((member) => ({
         ...member,
+        currentSessionId: isCurrentMemberSession(this.repo, member) ? member.sessionId : null,
         running: this.engine.running.has(member.membershipId),
       })),
       config: {
@@ -273,7 +497,6 @@ export class BotTeamService {
         defaultCwd: this.config.defaultCwd,
         botSandbox: this.config.botSandbox,
         botApprovalPolicy: this.config.botApprovalPolicy,
-        maxTurnsPerHour: this.config.maxTurnsPerHour,
         dailyTokenBudget: this.config.dailyTokenBudget,
         schemaVersion: this.repo.schemaVersion(),
       },
@@ -282,6 +505,7 @@ export class BotTeamService {
       modelCatalog: await this.getModelCatalog(),
       // A preference save may complete while model catalog discovery awaits I/O.
       chatDisplaySettings: this.getChatDisplaySettings(),
+      updateInfo: this.updateChecker?.snapshot(),
       smoke: this.smokeState,
     };
   }
@@ -310,6 +534,8 @@ export class BotTeamService {
         groupId,
         messages,
         hasMore,
+        ...this.conversationState(groupId),
+        conversationBoundaries: this.messageConversationBoundaries(groupId, messages, { beforeSeq: beforeRaw, afterSeq: afterRaw }),
         running: this.engine.isRunning(groupId),
       });
     });
@@ -329,6 +555,8 @@ export class BotTeamService {
           members: this.repo.membersOf(groupId),
           bots: this.repo.allBots(),
           messages: this.repo.messagesOf(groupId),
+          conversations: this.repo.conversationsOf?.(groupId) || [],
+          truncated: false,
           lang,
           fontPath: this.config.pdfFontPath || '',
         });
@@ -378,6 +606,63 @@ export class BotTeamService {
     });
   }
 
+  /** Read a group-owned Bot Session without activating it through ordinary Session routing. */
+  handleSessionHistory(request) {
+    return this.withReady(async () => {
+      const url = new URL(request.url);
+      let response;
+      try {
+        response = json(await readBotSessionHistory({
+          ctx: this.ctx,
+          repo: this.repo,
+          groupId: url.searchParams.get('groupId') || '',
+          sessionId: url.searchParams.get('sessionId') || '',
+          afterSeq: url.searchParams.get('afterSeq'),
+          limit: url.searchParams.get('limit'),
+          signal: request.signal,
+        }));
+      } catch (error) {
+        if (request.signal.aborted) throw error;
+        const code = ['not-found', 'invalid-input'].includes(error?.code) ? error.code : 'session-history-failed';
+        const status = code === 'not-found' ? 404 : code === 'invalid-input' ? 400 : 500;
+        response = json(fail(code, code === 'session-history-failed' ? 'Session history read failed' : String(error?.message || error)), status);
+      }
+      response.headers.set('cache-control', 'no-store');
+      return response;
+    }, request.signal);
+  }
+
+  /** Export the canonical persisted log without activating the Bot session. */
+  handleSessionExport(request) {
+    return this.withReady(async () => {
+      const url = new URL(request.url);
+      try {
+        const result = await readBotSessionLog({
+          ctx: this.ctx,
+          repo: this.repo,
+          groupId: url.searchParams.get('groupId') || '',
+          sessionId: url.searchParams.get('sessionId') || '',
+          signal: request.signal,
+        });
+        if (!result.ok || result.availability !== 'available') return json(result, 503);
+        const filename = 'session-' + result.sessionId.replace(/[^a-zA-Z0-9._-]/g, '_') + '.jsonl';
+        return new Response(serializeBotSessionLog(result.header, result.events), {
+          headers: {
+            'content-type': 'application/x-ndjson; charset=utf-8',
+            'content-disposition': 'attachment; filename="' + filename + '"',
+            'cache-control': 'no-store',
+            'x-content-type-options': 'nosniff',
+          },
+        });
+      } catch (error) {
+        if (request.signal.aborted) throw error;
+        const code = ['not-found', 'invalid-input'].includes(error?.code) ? error.code : 'session-export-failed';
+        return json(fail(code, code === 'session-export-failed' ? 'Session log export failed' : String(error?.message || error)),
+          code === 'not-found' ? 404 : code === 'invalid-input' ? 400 : 500);
+      }
+    }, request.signal);
+  }
+
   handleEvents(request) {
     const url = new URL(request.url);
     const groupId = url.searchParams.get('groupId') || '';
@@ -439,6 +724,7 @@ export class BotTeamService {
             at: now(),
             running: service.engine.isRunning(groupId),
             chatDisplaySettings: service.getChatDisplaySettings(),
+            ...service.conversationState(groupId),
           });
           // Push current member statuses so a reconnecting page is consistent.
           for (const member of service.repo.membersOf(groupId)) {
@@ -502,7 +788,7 @@ export class BotTeamService {
     }
     return this.withReady(async () => {
       try {
-        const result = await this.dispatch(body && body.action, body && body.payload);
+        const result = await this.dispatch(body && body.action, body && body.payload, { external: true });
         return json({ ok: true, result });
       } catch (error) {
         const code = error instanceof ServiceError
@@ -510,7 +796,13 @@ export class BotTeamService {
           : error && typeof error.code === 'string'
             ? error.code
             : 'internal';
-        return json(fail(code, String(error && error.message ? error.message : error)), code === 'internal' ? 500 : 400);
+        const status = ['stale-conversation', 'conversation-busy', 'historical-target', 'reload-required', 'conflict'].includes(code) ? 409
+          : code === 'not-found' && body?.action === 'conversation.new' ? 404
+            : code === 'conversation-capability-unavailable' ? 503
+              : ['internal', 'storage-failed', 'session-release-failed', 'conversation-corrupt'].includes(code) ? 500 : 400;
+        const conversationError = ['stale-conversation', 'conversation-busy', 'historical-target', 'reload-required', 'storage-failed', 'session-release-failed', 'conversation-corrupt'].includes(code);
+        const details = error?.details || (conversationError && body?.payload?.groupId ? this.conversationState(body.payload.groupId) : undefined);
+        return json({ ...fail(code, String(error && error.message ? error.message : error)), ...(details ? { details } : {}) }, status);
       }
     });
   }
@@ -606,6 +898,10 @@ export class BotTeamService {
   }
 
   async listSkills(groupId, memberId = '') {
+    return this.withWorkspaceOperation(groupId, () => this.listSkillsInWorkspace(groupId, memberId));
+  }
+
+  async listSkillsInWorkspace(groupId, memberId) {
     const group = this.repo.getGroup(groupId);
     if (!group) throw new ServiceError('not-found', `群 ${groupId} 不存在`);
     const members = this.repo.membersOf(groupId).filter(
@@ -704,16 +1000,57 @@ export class BotTeamService {
   }
 
   // ── action dispatch ──────────────────────────────────────────────────────
-  async dispatch(action, payload = {}) {
+  actionGroupIds(action, input) {
+    const ids = new Set();
+    const add = (value) => { if (value && this.repo.getGroup(value)) ids.add(value); };
+    add(input.groupId);
+    add(this.repo.getMember?.(input.membershipId)?.groupId);
+    add(this.repo.getTask?.(input.taskId)?.groupId);
+    add(this.repo.getDiscussion?.(input.discussionId)?.groupId);
+    for (const key of ['messageId', 'targetMessageId', 'reviewMessageId']) add(this.repo.messages?.get(input[key])?.groupId);
+    if (input.botId && ['bot.update', 'bot.delete', 'persona.write', 'direct.open'].includes(action)) {
+      for (const member of this.repo.membersOfBot(input.botId)) add(member.groupId);
+    }
+    if (['group.reorder', 'folder.delete'].includes(action)) for (const group of this.repo.allGroups()) add(group.groupId);
+    return [...ids].sort();
+  }
+
+  async dispatch(action, payload = {}, { external = false } = {}) {
     await this.ready;
-    const input = payload && typeof payload === 'object' ? payload : {};
+    const input = payload && typeof payload === 'object' && !Array.isArray(payload) ? { ...payload } : {};
+    if (action === 'conversation.new') return this.newConversation(input);
+    const groupIds = this.actionGroupIds(action, input);
+    const executing = ['message.post', 'message.retry', 'message.stop', 'review.request', 'review.revise',
+      'discussion.start', 'discussion.stop', 'discussion.control', 'interaction.respond', 'task.create', 'task.dispatch',
+      'task.dispatch_ready', 'task.review', 'task.accept', 'task.request_changes', 'task.revise', 'task.update', 'task.cancel'].includes(action);
+    if (executing) {
+      for (const groupId of groupIds) this.assertExpectedConversation(groupId, input.expectedConversationId, external);
+      if (input.expectedConversationId === undefined && groupIds.length === 1) input.expectedConversationId = currentConversationId(this.repo, groupIds[0]);
+    }
+    // Workspace changes provide their own exclusive admission; counting that
+    // same request as an ordinary operation would make it block itself.
+    if (action === 'group.workspace.set' || (action === 'group.update' && input.workspaceCwd !== undefined)
+      || ['interaction.list', 'ui.report'].includes(action)) return this.dispatchAction(action, input);
+    const perform = (index) => index < groupIds.length
+      ? this.withWorkspaceOperation(groupIds[index], () => perform(index + 1))
+      : this.dispatchAction(action, input);
+    return perform(0);
+  }
+
+  async dispatchAction(action, input) {
     switch (action) {
+      case 'interaction.list':
+        return this.interactions.snapshot(input.groupId);
+      case 'interaction.respond':
+        return this.interactions.respond(input);
       case 'settings.chatDisplay.update':
         return this.updateChatDisplaySettings(input);
       case 'group.create':
         return this.createGroup(input);
       case 'group.update':
         return this.updateGroup(input);
+      case 'group.workspace.set':
+        return this.setGroupWorkspace(input);
       case 'group.delete':
         return this.deleteGroup(input);
       case 'group.reorder':
@@ -742,6 +1079,8 @@ export class BotTeamService {
         return this.updateMember(input);
       case 'message.post':
         return this.postMessage(input);
+      case 'message.delete':
+        return this.deleteMessage(input);
       case 'message.stop':
         return this.stopGroup(input);
       case 'message.retry':
@@ -753,7 +1092,11 @@ export class BotTeamService {
       case 'discussion.start':
         return this.startDiscussion(input);
       case 'discussion.stop':
-        return this.engine.stopDiscussion(String(input.discussionId || ''));
+        return this.stopDiscussion(input);
+      case 'discussion.control':
+        return this.controlDiscussion(input);
+      case 'discussion.get':
+        return this.getDiscussion(input);
       case 'task.create':
         return this.createTask(input);
       case 'task.dispatch':
@@ -799,6 +1142,7 @@ export class BotTeamService {
   }
 
   isTaskReady(task) {
+    if (!this.isCurrentRecord(task)) return { ready: false, blockers: [{ taskId: task.taskId, title: task.title, status: 'historical' }] };
     const blockers = [];
     for (const dependencyId of task.dependsOn || []) {
       const dependency = this.repo.getTask(dependencyId);
@@ -825,7 +1169,9 @@ export class BotTeamService {
 
   listTasks(groupId, options = {}) {
     const includeClosed = options.includeClosed === true;
-    let tasks = this.repo.tasksOf(groupId).map((task) => this.taskView(task));
+    let tasks = this.repo.tasksOf(groupId)
+      .filter((task) => options.includeHistorical === true || this.isCurrentRecord(task))
+      .map((task) => this.taskView(task));
     if (options.taskId) tasks = tasks.filter((task) => task.taskId === options.taskId);
     if (options.status) tasks = tasks.filter((task) => task.status === options.status);
     if (!includeClosed && !options.status) {
@@ -847,6 +1193,7 @@ export class BotTeamService {
       if (taskId && dependencyId === taskId) throw new ServiceError('invalid-input', '任务不能依赖自身');
       const dependency = all.get(dependencyId);
       if (!dependency) throw new ServiceError('invalid-input', '依赖任务不存在：' + dependencyId);
+      this.assertCurrentRecord(dependency);
       if (dependency.status === 'cancelled') throw new ServiceError('invalid-input', '依赖任务已取消：' + dependency.title);
     }
     if (taskId && ids.length > 0) {
@@ -875,10 +1222,12 @@ export class BotTeamService {
 
   /** After a task is accepted, notify and mark dependents that became dispatchable. */
   async unblockDependents(task) {
+    if (!this.isCurrentRecord(task)) return [];
     const dependents = this.repo
       .tasksOf(task.groupId)
       .filter(
         (candidate) =>
+          this.isCurrentRecord(candidate) &&
           candidate.taskId !== task.taskId &&
           (candidate.dependsOn || []).includes(task.taskId) &&
           candidate.status !== 'accepted' &&
@@ -906,9 +1255,9 @@ export class BotTeamService {
     return views;
   }
 
-  requireTaskQuota(groupId, turns) {
+  requireTaskQuota(groupId) {
     try {
-      this.engine.assertQuota(groupId, turns);
+      this.engine.assertQuota(groupId);
     } catch (error) {
       if (error && error.code) throw new ServiceError(error.code, String(error.message));
       throw error;
@@ -941,6 +1290,7 @@ export class BotTeamService {
     const task = {
       taskId: newId('task'),
       groupId,
+      conversationId: currentConversationId(this.repo, groupId),
       title,
       description,
       acceptance,
@@ -988,6 +1338,8 @@ export class BotTeamService {
   async dispatchTask(input) {
     const task = this.repo.getTask(String(input.taskId || ''));
     if (!task) throw new ServiceError('not-found', '任务不存在');
+    this.assertCurrentRecord(task);
+    this.assertExpectedConversation(task.groupId, input.expectedConversationId);
     if (task.status !== 'pending') throw new ServiceError('invalid-input', '只有待派发的任务可以派发（当前：' + task.status + '）');
     const readiness = this.isTaskReady(task);
     if (!readiness.ready) {
@@ -996,23 +1348,27 @@ export class BotTeamService {
         '任务被依赖阻塞：' + readiness.blockers.map((blocker) => blocker.title + '（' + blocker.status + '）').join('、'),
       );
     }
-    this.requireTaskQuota(task.groupId, 1);
-    task.status = 'in_progress';
-    await this.repo.putTask(task);
-    this.emitTask(task);
-    this.engine.enqueueTaskTurn({ taskId: task.taskId, phase: 'dispatch' });
-    return task;
+    this.requireTaskQuota(task.groupId);
+    return this.withWorkspaceOperation(task.groupId, async () => {
+      task.status = 'in_progress';
+      await this.repo.putTask(task);
+      this.emitTask(task);
+      this.engine.enqueueTaskTurn({ taskId: task.taskId, phase: 'dispatch' });
+      return task;
+    });
   }
 
   async reviewTask(input) {
     const task = this.repo.getTask(String(input.taskId || ''));
     if (!task) throw new ServiceError('not-found', '任务不存在');
+    this.assertCurrentRecord(task);
+    this.assertExpectedConversation(task.groupId, input.expectedConversationId);
     if (task.status !== 'delivered') throw new ServiceError('invalid-input', '只有已交付的任务可以评审（当前：' + task.status + '）');
     const reviewerMembershipId = String(input.reviewerMembershipId || task.reviewerMembershipId || '');
     const reviewer = this.repo.getMember(reviewerMembershipId);
     if (!reviewer || reviewer.groupId !== task.groupId) throw new ServiceError('invalid-input', '评审者不在该群里');
     if (!task.deliverableMessageId) throw new ServiceError('invalid-input', '任务还没有交付物');
-    this.requireTaskQuota(task.groupId, 1);
+    this.requireTaskQuota(task.groupId);
     const instructions =
       optionalText(input.instructions, 2000) ||
       '请按验收标准评审该任务的交付物：第一行输出 结论：通过 或 结论：需修改，然后给理由与具体修改建议。' +
@@ -1035,20 +1391,26 @@ export class BotTeamService {
   async acceptTask(input) {
     const task = this.repo.getTask(String(input.taskId || ''));
     if (!task) throw new ServiceError('not-found', '任务不存在');
+    this.assertCurrentRecord(task);
+    this.assertExpectedConversation(task.groupId, input.expectedConversationId);
     if (task.status !== 'delivered' && task.status !== 'changes_requested') {
       throw new ServiceError('invalid-input', '当前状态不能验收（' + task.status + '）');
     }
-    task.status = 'accepted';
-    task.acceptedAt = now();
-    await this.repo.putTask(task);
-    this.emitTask(task);
-    await this.unblockDependents(task);
-    return this.taskView(task);
+    return this.withWorkspaceOperation(task.groupId, async () => {
+      task.status = 'accepted';
+      task.acceptedAt = now();
+      await this.repo.putTask(task);
+      this.emitTask(task);
+      await this.unblockDependents(task);
+      return this.taskView(task);
+    });
   }
 
   async updateTask(input) {
     const task = this.repo.getTask(String(input.taskId || ''));
     if (!task) throw new ServiceError('not-found', '任务不存在');
+    this.assertCurrentRecord(task);
+    this.assertExpectedConversation(task.groupId, input.expectedConversationId);
     if (task.status === 'accepted' || task.status === 'cancelled') {
       throw new ServiceError('invalid-input', '已验收/已取消的任务不能编辑');
     }
@@ -1083,6 +1445,8 @@ export class BotTeamService {
   async requestTaskChanges(input) {
     const task = this.repo.getTask(String(input.taskId || ''));
     if (!task) throw new ServiceError('not-found', '任务不存在');
+    this.assertCurrentRecord(task);
+    this.assertExpectedConversation(task.groupId, input.expectedConversationId);
     if (task.status !== 'delivered') throw new ServiceError('invalid-input', '只有已交付的任务可以要求修改（当前：' + task.status + '）');
     task.status = 'changes_requested';
     task.changesRequestedAt = now();
@@ -1094,6 +1458,8 @@ export class BotTeamService {
   async reviseTask(input) {
     const task = this.repo.getTask(String(input.taskId || ''));
     if (!task) throw new ServiceError('not-found', '任务不存在');
+    this.assertCurrentRecord(task);
+    this.assertExpectedConversation(task.groupId, input.expectedConversationId);
     if (task.status !== 'changes_requested') throw new ServiceError('invalid-input', '只有被要求修改的任务可以重新交付（当前：' + task.status + '）');
     const readiness = this.isTaskReady(task);
     if (!readiness.ready) {
@@ -1102,22 +1468,27 @@ export class BotTeamService {
         '任务被依赖阻塞：' + readiness.blockers.map((blocker) => blocker.title + '（' + blocker.status + '）').join('、'),
       );
     }
-    this.requireTaskQuota(task.groupId, 1);
-    task.status = 'in_progress';
-    await this.repo.putTask(task);
-    this.emitTask(task);
-    this.engine.enqueueTaskTurn({ taskId: task.taskId, phase: 'revision' });
-    return task;
+    this.requireTaskQuota(task.groupId);
+    return this.withWorkspaceOperation(task.groupId, async () => {
+      task.status = 'in_progress';
+      await this.repo.putTask(task);
+      this.emitTask(task);
+      this.engine.enqueueTaskTurn({ taskId: task.taskId, phase: 'revision' });
+      return task;
+    });
   }
 
   async cancelTask(input) {
     const task = this.repo.getTask(String(input.taskId || ''));
     if (!task) throw new ServiceError('not-found', '任务不存在');
+    this.assertCurrentRecord(task);
+    this.assertExpectedConversation(task.groupId, input.expectedConversationId);
     if (task.status === 'accepted') throw new ServiceError('invalid-input', '已验收的任务不能取消');
     const dependents = this.repo
       .tasksOf(task.groupId)
       .filter(
         (candidate) =>
+          this.isCurrentRecord(candidate) &&
           candidate.taskId !== task.taskId &&
           (candidate.dependsOn || []).includes(task.taskId) &&
           candidate.status !== 'accepted' &&
@@ -1153,7 +1524,7 @@ export class BotTeamService {
       const taskId = job && job.meta ? job.meta.taskId : undefined;
       if (!taskId) return;
       const task = this.repo.getTask(taskId);
-      if (!task) return;
+      if (!task || !this.isCurrentRecord(task) || (job.conversationId && job.conversationId !== currentConversationId(this.repo, task.groupId))) return;
       if (job.kind === 'task' || job.kind === 'task_revision') {
         if (status === 'done' && message) {
           task.status = 'delivered';
@@ -1172,6 +1543,7 @@ export class BotTeamService {
         task.revision = (task.revision || 0) + 1;
       }
       await this.repo.putTask(task);
+      if (!this.isCurrentRecord(task)) return;
       this.emitTask(task);
       if (task.status === 'accepted') await this.unblockDependents(task);
     } catch (hookError) {
@@ -1188,7 +1560,8 @@ export class BotTeamService {
     const reviewerMembershipId = String(input.reviewerMembershipId || '');
     const instructions = optionalText(input.instructions, 2000);
     try {
-      return this.engine.requestReview({ groupId, targetMessageId, reviewerMembershipId, instructions });
+      this.assertExpectedConversation(groupId, input.expectedConversationId);
+      return this.engine.requestReview({ groupId, targetMessageId, reviewerMembershipId, instructions, expectedConversationId: input.expectedConversationId });
     } catch (error) {
       if (error && error.code) throw new ServiceError(error.code, String(error.message));
       throw error;
@@ -1202,6 +1575,7 @@ export class BotTeamService {
       return this.engine.requestRevision({
         groupId: String(input.groupId || ''),
         reviewMessageId: String(input.reviewMessageId || ''),
+        expectedConversationId: input.expectedConversationId,
       });
     } catch (error) {
       if (error && error.code) throw new ServiceError(error.code, String(error.message));
@@ -1214,26 +1588,128 @@ export class BotTeamService {
     const group = this.repo.getGroup(groupId);
     if (!group) throw new ServiceError('not-found', '群不存在');
     if (isDirectGroup(group)) throw new ServiceError('invalid-input', '单聊不支持多轮讨论，请使用群聊');
+    this.assertExpectedConversation(groupId, input.expectedConversationId);
+    const modern = input.mode === 'debate' || input.format === 'structured';
+    if (modern && (typeof input.topic !== 'string' || input.topic.length > 2000)) {
+      throw new ServiceError('invalid-input', '讨论议题必须是字符串且不能超过 2000 字');
+    }
     const topic = requireText(input.topic, '讨论议题', 2000);
     const roundsRaw = Number(input.rounds);
-    const rounds = Number.isInteger(roundsRaw) ? Math.min(Math.max(roundsRaw, 1), 5) : 2;
-    const membershipIds = Array.isArray(input.membershipIds)
-      ? input.membershipIds.filter((value) => typeof value === 'string')
-      : this.repo.membersOf(groupId).map((member) => member.membershipId);
+    const rounds = modern ? input.rounds : (Number.isInteger(roundsRaw) ? Math.min(Math.max(roundsRaw, 1), MAX_DISCUSSION_ROUNDS) : 2);
+    const fields = ['mode', 'format', 'goal', 'background', 'summaryMembershipId', 'proMembershipId',
+      'conMembershipId', 'judgeMembershipId', 'proPosition', 'conPosition', 'responseLength', 'language',
+      'perspectives', 'contextMessageIds', 'requestId'];
+    const config = Object.fromEntries(fields.filter(key => input[key] !== undefined).map(key => [key, input[key]]));
     try {
       return await this.engine.startDiscussion({
-        groupId,
-        topic,
-        membershipIds,
-        rounds,
-        summarize: input.summarize === true,
+        ...config, groupId, topic, rounds,
+        ...(input.membershipIds !== undefined ? { membershipIds: input.membershipIds } : {}),
+        ...(input.summarize !== undefined ? { summarize: input.summarize } : modern ? {} : { summarize: false }),
+        expectedConversationId: input.expectedConversationId,
       });
     } catch (error) {
-      if (error && error.code) throw new ServiceError(error.code, String(error.message));
+      if (error?.code) throw new ServiceError(error.code, String(error.message), error.details);
+      throw error;
+    }
+  }
+
+  requireDiscussion(input) {
+    const discussion = this.repo.getDiscussion(String(input.discussionId || ''));
+    if (!discussion || (input.groupId !== undefined && input.groupId !== discussion.groupId)) {
+      throw new ServiceError('not-found', '讨论不存在或不属于当前群');
+    }
+    return discussion;
+  }
+
+  /** Read a single run, including older conversations, without changing its state. */
+  getDiscussion(input) {
+    const discussion = this.requireDiscussion(input);
+    const conversationId = conversationIdOf(this.repo, discussion);
+    const transcript = this.repo.messagesOf(discussion.groupId).filter(message =>
+      message.groupId === discussion.groupId && conversationIdOf(this.repo, message) === conversationId
+      && message.meta?.discussionId === discussion.discussionId);
+    const finalMessage = [...transcript].reverse().find(message => {
+      if (message.status !== 'done' || message.meta?.summary !== true) return false;
+      if (discussion.protocolVersion < 2 || !message.meta.stepId) return true;
+      const step = discussion.steps?.find(item => item.stepId === message.meta.stepId);
+      return step?.status === 'done' && (!step.messageIds?.length || step.messageIds.includes(message.messageId));
+    });
+    const finalStep = [...(discussion.steps || [])].reverse().find(step => step.status === 'done' && ['summary', 'judgement'].includes(step.phase));
+    // The runner assembles all native turns of the accepted logical attempt.
+    // Keep its result readable even when an original message was later deleted.
+    const summary = finalStep && typeof discussion.summary === 'string' ? discussion.summary : finalMessage?.text;
+    const available = new Set(transcript.map(message => message.messageId));
+    const missingMessageIds = [...new Set((discussion.steps || []).flatMap(step => step.messageIds || []))]
+      .filter(id => !available.has(id));
+    return structuredClone({ discussion, transcript,
+      ...(summary !== undefined ? { summary: String(summary || '') } : {}),
+      ...(['pro', 'con', 'tie', 'insufficient'].includes(discussion.verdict) ? { verdict: discussion.verdict } : {}),
+      missingMessageIds,
+    });
+  }
+
+  async controlDiscussion(input) {
+    const discussion = this.requireDiscussion(input);
+    this.assertCurrentRecord(discussion);
+    this.assertExpectedConversation(discussion.groupId, input.expectedConversationId);
+    this.assertWorkspaceStable(discussion.groupId);
+    if (input.expectedRevision !== undefined && (!Number.isSafeInteger(input.expectedRevision) || input.expectedRevision < 0)) {
+      throw new ServiceError('invalid-input', '讨论版本无效，请刷新后重试');
+    }
+    const operation = String(input.operation || '');
+    if (!['pause', 'resume', 'retry', 'finish', 'stop', 'add_context'].includes(operation)) {
+      throw new ServiceError('invalid-input', '不支持的讨论操作');
+    }
+    if (input.requestId !== undefined && (typeof input.requestId !== 'string' || !input.requestId.trim() || input.requestId.length > 160)) {
+      throw new ServiceError('invalid-input', '讨论请求标识无效');
+    }
+    try {
+      return await this.engine.controlDiscussion({
+        discussionId: discussion.discussionId, groupId: discussion.groupId, operation,
+        expectedConversationId: input.expectedConversationId, expectedRevision: input.expectedRevision,
+        requestId: input.requestId, text: input.text, contextMessageIds: input.contextMessageIds,
+      });
+    } catch (error) {
+      if (error?.code) throw new ServiceError(error.code, String(error.message), error.details);
       throw error;
     }
   }
 
+  async stopDiscussion(input) {
+    const discussion = this.repo.getDiscussion(String(input.discussionId || ''));
+    if (!discussion) return { stopped: false };
+    if (discussion.protocolVersion >= 2) {
+      const current = await this.controlDiscussion({ ...input, operation: 'stop' });
+      return { stopped: current.status === 'stopped', discussion: current };
+    }
+    this.requireDiscussion(input);
+    this.assertCurrentRecord(discussion);
+    return this.engine.stopDiscussion(discussion.discussionId);
+  }
+
+  /** Inspect only participating member sessions; do not cancel unrelated work. */
+  async assertDiscussionNativeIdle(discussion) {
+    const membershipIds = new Set(discussion.memberIds || []);
+    const sessionIds = new Set((discussion.steps || []).flatMap(step => (step.attempts || []).map(attempt => attempt.sessionId)).filter(Boolean));
+    const members = new Map([...this.repo.members].filter(([id, member]) => member.groupId === discussion.groupId && membershipIds.has(id)));
+    for (const member of members.values()) if (member.sessionId) sessionIds.add(member.sessionId);
+    const scopedRepo = Object.create(this.repo);
+    scopedRepo.members = members;
+    scopedRepo.sessionBindings = new Map([...(this.repo.sessionBindings || [])].filter(([, binding]) =>
+      binding.groupId === discussion.groupId && (membershipIds.has(binding.membershipId) || sessionIds.has(binding.sessionId))));
+    const scopedPool = Object.create(this.pool || null);
+    scopedPool.owned = new Map([...(this.pool?.owned || [])].filter(([agent, ownership]) => membershipIds.has(ownership.membershipId) || sessionIds.has(agent.id)));
+    scopedPool.isPreparingGroup = () => [...(this.pool?.preparing?.keys() || []), ...(this.pool?.submitting?.keys() || []),
+      ...[...(this.pool?.overlayPreparing?.values() || [])].map(value => value.membershipId)].some(id => membershipIds.has(id));
+    const scopedInteractions = {
+      entries: new Map([...(this.interactions?.entries || [])].filter(([, entry]) => membershipIds.has(entry.view?.membershipId) || sessionIds.has(entry.view?.sessionId))),
+      responding: new Set([...(this.interactions?.responding || [])].filter(entry => membershipIds.has(entry.view?.membershipId) || sessionIds.has(entry.view?.sessionId))),
+    };
+    const blockers = (await collectNativeConversationBlockers({ ctx: this.ctx, repo: scopedRepo, pool: scopedPool,
+      groupId: discussion.groupId, interactions: scopedInteractions })).filter(blocker => !blocker.membershipId || membershipIds.has(blocker.membershipId));
+    if (blockers.length) throw new ServiceError('native-busy', '讨论成员的原生活动尚未结束，暂不能重新派发', { blockers });
+  }
+
   /**
    * Client-side UI verification breadcrumbs (page rendered, bootstrap/messages
    * loaded, SSE hello). Recorded into the same smoke log so M1 verification has
@@ -1282,26 +1758,100 @@ export class BotTeamService {
     return folder;
   }
 
+  assertWorkspaceStable(groupId) {
+    if (this.conversationChanges?.has(groupId)) {
+      throw new ServiceError('conversation-busy', '正在新建会话，请稍后重试', this.conversationState(groupId));
+    }
+    if (this.workspaceChanges?.has(groupId)) {
+      throw new ServiceError('busy', '正在切换项目目录，请稍后重试');
+    }
+  }
+
+  /** Reserve a group before an async operation can prepare an agent or enqueue work. */
+  async withWorkspaceOperation(groupId, operation) {
+    this.assertWorkspaceStable(groupId);
+    this.workspaceOperations ??= new Map();
+    this.workspaceOperations.set(groupId, (this.workspaceOperations.get(groupId) || 0) + 1);
+    try {
+      return await operation();
+    } finally {
+      const remaining = this.workspaceOperations.get(groupId) - 1;
+      if (remaining > 0) this.workspaceOperations.set(groupId, remaining);
+      else this.workspaceOperations.delete(groupId);
+    }
+  }
+
+  workspaceBusy(groupId) {
+    return this.engine.isRunning(groupId)
+      || this.engine.hasPendingWork?.(groupId)
+      || this.repo.activeDiscussionOf(groupId)
+      || this.workspaceOperations?.get(groupId) > 0
+      || this.pool.isPreparingGroup?.(groupId);
+  }
+
+  /** Hold admission closed from before the first filesystem await through persistence. */
+  async withWorkspaceChange(groupId, value, commit) {
+    const group = this.repo.getGroup(groupId);
+    if (!group) throw new ServiceError('not-found', '群不存在');
+    const fallback = defaultWorkspaceDir(this.config, group);
+    const normalized = normalizeWorkspacePath(value);
+    // The legacy settings form always posts workspaceCwd, including the default.
+    const selected = normalized && !sessionCwdMatches(normalized, fallback) ? normalized : '';
+    const current = group.workspaceCwd || fallback;
+    this.assertWorkspaceStable(groupId);
+    if (sessionCwdMatches(selected || fallback, current) && (group.projectWorkspaceCwd || '') === selected) {
+      return this.withWorkspaceOperation(groupId, () => commit({ workspaceCwd: current, projectWorkspaceCwd: selected }));
+    }
+    if (this.workspaceBusy(groupId)) {
+      throw new ServiceError('busy', '当前聊天有运行、排队或准备中的任务或讨论，请结束后再切换项目目录');
+    }
+    this.workspaceChanges ??= new Set();
+    this.workspaceChanges.add(groupId);
+    try {
+      const projectWorkspaceCwd = selected ? await validateProjectWorkspace(selected) : '';
+      const workspaceCwd = projectWorkspaceCwd || fallback;
+      if (!selected && !(await ensureWorkspaceDir(fallback, this.logger))) {
+        throw new ServiceError('invalid-input', '无法准备默认工作目录');
+      }
+      if (!sessionCwdMatches(current, workspaceCwd)) {
+        // Await disposal before publishing the new root. The session id remains
+        // durable; AgentPool.ensure rotates it when its creation cwd differs.
+        for (const member of this.repo.membersOf(groupId)) {
+          await this.pool.disposeMember(member.membershipId, { strict: true });
+        }
+      }
+      return await commit({ workspaceCwd, projectWorkspaceCwd });
+    } finally {
+      this.workspaceChanges.delete(groupId);
+    }
+  }
+
+  async setGroupWorkspace(input) {
+    const workspaceCwd = normalizeWorkspacePath(input.workspaceCwd);
+    return this.updateGroup({ groupId: input.groupId, workspaceCwd });
+  }
+
   async createGroup(input) {
     const title = requireText(input.title, '群名称', 120);
     if (this.groupChats().length >= this.config.maxGroups) {
       throw new ServiceError('limit', `群数量已达上限 ${this.config.maxGroups}`);
     }
-    const workspaceCwd = optionalText(input.workspaceCwd, 1024);
-    if (workspaceCwd && !path.isAbsolute(workspaceCwd)) {
-      throw new ServiceError('invalid-input', 'workspaceCwd 必须是绝对路径');
-    }
+    const selected = normalizeWorkspacePath(input.workspaceCwd ?? '');
+    const projectWorkspaceCwd = selected ? await validateProjectWorkspace(selected) : '';
     const folder = await this.requireFolder(input.folderId);
     const avatar = normalizeAvatar(input.avatar);
     const groupId = newId('grp');
-    const groupWorkspace = workspaceCwd || defaultWorkspaceDir(this.config, { kind: 'group', groupId });
-    await ensureWorkspaceDir(groupWorkspace, this.logger);
+    const groupWorkspace = projectWorkspaceCwd || defaultWorkspaceDir(this.config, { kind: 'group', groupId });
+    if (!projectWorkspaceCwd && !(await ensureWorkspaceDir(groupWorkspace, this.logger))) {
+      throw new ServiceError('invalid-input', '无法准备默认工作目录');
+    }
     const group = {
       groupId,
       kind: 'group',
       title,
       topic: optionalText(input.topic, 2000),
       workspaceCwd: groupWorkspace,
+      projectWorkspaceCwd,
       folderId: folder ? folder.folderId : null,
       order: nextOrder(this.groupsInFolder(folder ? folder.folderId : null)),
       ...(avatar ? { avatar } : {}),
@@ -1311,43 +1861,58 @@ export class BotTeamService {
     };
     await this.repo.putGroup(group);
     this.logger?.info?.(`bot-team: created group ${group.groupId} "${title}"`);
-    return group;
+    return this.repo.getGroup(group.groupId);
   }
 
   async updateGroup(input) {
-    const group = this.repo.getGroup(String(input.groupId || ''));
-    if (!group) throw new ServiceError('not-found', '群不存在');
-    if (input.title !== undefined) {
-      if (isDirectGroup(group)) throw new ServiceError('invalid-input', '单聊名称随 Bot 名称自动更新');
-      group.title = requireText(input.title, '群名称', 120);
-    }
-    if (input.topic !== undefined) group.topic = optionalText(input.topic, 2000);
-    if (input.workspaceCwd !== undefined) {
-      const workspaceCwd = optionalText(input.workspaceCwd, 1024);
-      if (workspaceCwd && !path.isAbsolute(workspaceCwd)) {
-        throw new ServiceError('invalid-input', 'workspaceCwd 必须是绝对路径');
+    const groupId = String(input.groupId || '');
+    if (!this.repo.getGroup(groupId)) throw new ServiceError('not-found', '群不存在');
+    const commit = async (workspace = {}) => {
+      let folder;
+      if (input.folderId !== undefined) {
+        if (isDirectGroup(this.repo.getGroup(groupId))) throw new ServiceError('invalid-input', '单聊不能放进分组');
+        folder = await this.requireFolder(input.folderId);
       }
-      const nextWorkspace = workspaceCwd || defaultWorkspaceDir(this.config, group);
-      group.workspaceCwd = nextWorkspace;
-      await ensureWorkspaceDir(nextWorkspace, this.logger);
-    }
-    if (input.avatar !== undefined) {
-      const avatar = normalizeAvatar(input.avatar);
-      if (avatar) group.avatar = avatar;
-      else delete group.avatar;
-    }
-    if (input.folderId !== undefined) {
-      if (isDirectGroup(group)) throw new ServiceError('invalid-input', '单聊不能放进分组');
-      const folder = await this.requireFolder(input.folderId);
-      const nextFolderId = folder ? folder.folderId : null;
-      if (groupFolderIdOf(group) !== nextFolderId) {
-        group.folderId = nextFolderId;
-        group.order = nextOrder(this.groupsInFolder(nextFolderId));
+      // Read after all asynchronous validation so a running turn cannot have its
+      // newly allocated sequence overwritten by a stale group snapshot.
+      const previous = this.repo.getGroup(groupId);
+      if (!previous) throw new ServiceError('not-found', '群不存在');
+      const group = { ...previous, ...workspace };
+      if (input.title !== undefined) {
+        if (isDirectGroup(group)) throw new ServiceError('invalid-input', '单聊名称随 Bot 名称自动更新');
+        group.title = requireText(input.title, '群名称', 120);
       }
-    }
-    await this.repo.putGroup(group);
-    this.bus.emit(group.groupId, { type: 'group.updated', group });
-    return group;
+      if (input.topic !== undefined) group.topic = optionalText(input.topic, 2000);
+      if (input.avatar !== undefined) {
+        const avatar = normalizeAvatar(input.avatar);
+        if (avatar) group.avatar = avatar;
+        else delete group.avatar;
+      }
+      if (input.folderId !== undefined) {
+        const nextFolderId = folder ? folder.folderId : null;
+        if (groupFolderIdOf(group) !== nextFolderId) {
+          group.folderId = nextFolderId;
+          group.order = nextOrder(this.groupsInFolder(nextFolderId));
+        }
+      }
+      if (JSON.stringify(group) === JSON.stringify(previous)) return previous;
+      try {
+        await this.repo.putGroup(group);
+      } catch (error) {
+        // putGroup publishes to the in-memory map before its durable write.
+        // Keep failed workspace changes invisible once admission opens again.
+        if (this.repo.getGroup(groupId) === group) {
+          previous.nextSeq = Math.max(previous.nextSeq || 0, group.nextSeq || 0);
+          this.repo.groups.set(groupId, previous);
+        }
+        throw error;
+      }
+      this.bus.emit(groupId, { type: 'group.updated', group });
+      return group;
+    };
+    return input.workspaceCwd !== undefined
+      ? this.withWorkspaceChange(groupId, input.workspaceCwd, commit)
+      : this.withWorkspaceOperation(groupId, () => commit());
   }
 
   async deleteGroup(input) {
@@ -1392,6 +1957,7 @@ export class BotTeamService {
         title: bot.name,
         topic: '',
         workspaceCwd: defaultWorkspaceDir(this.config, { kind: 'direct', botId: bot.botId }),
+        projectWorkspaceCwd: '',
         folderId: null,
         order: nextOrder(this.directGroups()),
         nextSeq: 0,
@@ -1416,7 +1982,7 @@ export class BotTeamService {
       }
       if (changed) await this.repo.putGroup(direct);
     }
-    await ensureWorkspaceDir(direct.workspaceCwd, this.logger);
+    if (!direct.projectWorkspaceCwd) await ensureWorkspaceDir(direct.workspaceCwd, this.logger);
     const members = this.repo.membersOf(direct.groupId);
     if (!members.some((member) => member.botId === bot.botId)) {
       const at = now();
@@ -1433,7 +1999,7 @@ export class BotTeamService {
       };
       if (!this.repo.members.has(member.membershipId)) await this.repo.putMember(member);
     }
-    return direct;
+    return this.repo.getGroup(direct.groupId);
   }
 
   async openDirect(input) {
@@ -1548,6 +2114,7 @@ export class BotTeamService {
     const provider = requireText(input.provider, 'provider', 80);
     const model = requireText(input.model, 'model', 160);
     const avatar = normalizeAvatar(input.avatar);
+    const signature = optionalText(input.signature, 120);
     const reasoningEffort = optionalText(input.reasoningEffort, 80);
     const maxTokensRaw = Number(input.maxTokens);
     const bot = {
@@ -1559,6 +2126,7 @@ export class BotTeamService {
       // Retained in the record schema for compatibility; every bot is full-capability.
       capability: 'work',
       ...(avatar ? { avatar } : {}),
+      ...(signature ? { signature } : {}),
       ...(reasoningEffort ? { reasoningEffort } : {}),
       ...(Number.isInteger(maxTokensRaw) && maxTokensRaw > 0 ? { maxTokens: Math.min(maxTokensRaw, 200000) } : {}),
       createdAt: now(),
@@ -1591,6 +2159,11 @@ export class BotTeamService {
       if (avatar) bot.avatar = avatar;
       else delete bot.avatar;
     }
+    if (input.signature !== undefined) {
+      const signature = optionalText(input.signature, 120);
+      if (signature) bot.signature = signature;
+      else delete bot.signature;
+    }
     if (input.reasoningEffort !== undefined) {
       const effort = optionalText(input.reasoningEffort, 80);
       if (effort) bot.reasoningEffort = effort;
@@ -1666,9 +2239,9 @@ export class BotTeamService {
       createdAt: now(),
       updatedAt: now(),
     };
-    await this.repo.putMember(member);
-    this.bus.emit(group.groupId, { type: 'member.added', member });
-    return member;
+    const saved = await this.repo.putMember(member);
+    this.bus.emit(group.groupId, { type: 'member.added', member: saved });
+    return saved;
   }
 
   async removeMember(input) {
@@ -1688,16 +2261,20 @@ export class BotTeamService {
     if (!member) throw new ServiceError('not-found', '成员不存在');
     if (input.enabled !== undefined) member.enabled = input.enabled !== false;
     if (Number.isInteger(input.order)) member.order = input.order;
-    await this.repo.putMember(member);
-    this.bus.emit(member.groupId, { type: 'member.updated', member });
-    return member;
+    const saved = await this.repo.putMember(member);
+    this.bus.emit(member.groupId, { type: 'member.updated', member: saved });
+    return saved;
   }
 
   async postMessage(input) {
     const groupId = String(input.groupId || '');
     const group = this.repo.getGroup(groupId);
     if (!group) throw new ServiceError('not-found', '群不存在');
-    const text = asString(input.text, this.config.maxMessageChars).trim();
+    const text = String(input.text ?? '').trim();
+    if (text.length > this.config.maxMessageChars) throw new ServiceError('invalid-input', '消息超过长度上限');
+    if (text === '/new') throw new ServiceError('command-required', '请使用新建会话指令入口');
+    if (/^[/]new\s/.test(text)) throw new ServiceError('invalid-command', '请单独发送 /new');
+    this.assertExpectedConversation(groupId, input.expectedConversationId);
     const attachments = this.normalizeMessageAttachments(input.attachments);
     if (!text && attachments.length === 0) throw new ServiceError('invalid-input', '消息不能为空');
     const groupMembers = this.repo.membersOf(groupId);
@@ -1714,7 +2291,50 @@ export class BotTeamService {
       mentions = parseMentionsFromText(this.repo, groupId, text);
     }
     const replyTo = typeof input.replyTo === 'string' && input.replyTo ? input.replyTo : null;
-    return this.engine.postHumanMessage({ groupId, text, mentions, replyTo, attachments });
+    return this.engine.postHumanMessage({ groupId, text, mentions, replyTo, attachments, expectedConversationId: input.expectedConversationId ?? currentConversationId(this.repo, groupId) });
+  }
+
+  async deleteMessage(input) {
+    const groupId = String(input.groupId || '');
+    const messageId = String(input.messageId || '');
+    const group = this.repo.getGroup(groupId);
+    const message = this.repo.getMessage(messageId);
+    if (!group || !message || message.groupId !== groupId) {
+      throw new ServiceError('not-found', '消息不存在或不属于本聊天');
+    }
+    if (['system', 'approval'].includes(message.kind) || !['human', 'bot'].includes(message.author?.type)) {
+      throw new ServiceError('invalid-input', '只能删除普通聊天消息');
+    }
+    if (message.status === 'pending' || message.status === 'streaming') {
+      throw new ServiceError('busy', '消息正在生成，请结束后再删除');
+    }
+    if (!['done', 'error', 'stopped'].includes(message.status ?? 'done')) {
+      throw new ServiceError('invalid-input', '消息状态不支持删除');
+    }
+    // A native goal may have a done reply while waiting for its next turn, and
+    // a stopped job may still be finishing durable writes. Status alone is not
+    // enough: its current placeholder must survive until that work releases it.
+    // Queued/preparing turns still need their trigger and review inputs when
+    // constructing the prompt, so keep those records until the job settles.
+    const jobs = [
+      ...(this.engine.running?.values() ?? []),
+      ...(this.engine.activeBySession?.values() ?? []),
+      ...(this.engine.pendingWork ?? []),
+      ...(this.engine.queue ?? []),
+    ];
+    if (jobs.some((job) =>
+      [job.placeholderId, job.triggerMessageId, job.reviewTargetId, job.reviewMessageId].includes(messageId) ||
+      (job.kind === 'revision' && this.repo.getMessage(job.reviewMessageId)?.meta?.reviewOf === messageId))) {
+      throw new ServiceError('busy', '消息仍被执行中的任务使用，请结束后再删除');
+    }
+    if (!await this.repo.deleteMessageStrict(messageId)) {
+      throw new ServiceError('not-found', '消息不存在或不属于本聊天');
+    }
+    this.bus.emit(groupId, { type: 'message.deleted', groupId, messageId });
+    // Keep the existing group update signal; message.deleted consumers refresh
+    // bootstrap for the preview. Deletion must not count as new group activity.
+    this.bus.emit(groupId, { type: 'group.updated', group });
+    return { groupId, messageId, deleted: true };
   }
 
   async stopGroup(input) {
@@ -1808,31 +2428,18 @@ export class BotTeamService {
     return value;
   }
 
-  /** Per-group usage guard: hourly bot turns + daily token budget. */
-  checkQuota(groupId, turns = 1) {
-    const nowMs = Date.now();
-    const dayStart = new Date(nowMs);
+  /** Per-group usage guard: daily token budget, reset at local midnight. */
+  checkQuota(groupId) {
+    const dayStart = new Date(Date.now());
     dayStart.setHours(0, 0, 0, 0);
-    const hourAgo = nowMs - 3600 * 1000;
     const dayStartMs = dayStart.getTime();
-    let turnsLastHour = 0;
     let tokensToday = 0;
     for (const message of this.repo.messagesOf(groupId)) {
       if (!message.createdAt) continue;
-      const isBot = message.author && message.author.type === 'bot' && message.status === 'done';
-      if (isBot && message.createdAt >= hourAgo) turnsLastHour += 1;
       if (message.createdAt >= dayStartMs && message.usage) {
         tokensToday += (message.usage.totalTokens ?? ((message.usage.inputTokens ?? 0) + (message.usage.outputTokens ?? 0)));
       }
     }
-    if (turnsLastHour + turns > this.config.maxTurnsPerHour) {
-      return {
-        ok: false,
-        reason: '本群最近一小时已触发 ' + turnsLastHour + ' 轮回复（上限 ' + this.config.maxTurnsPerHour + '），请稍候再试',
-        turnsLastHour,
-        limit: this.config.maxTurnsPerHour,
-      };
-    }
     if (tokensToday >= this.config.dailyTokenBudget) {
       return {
         ok: false,
@@ -1841,7 +2448,7 @@ export class BotTeamService {
         limit: this.config.dailyTokenBudget,
       };
     }
-    return { ok: true, turnsLastHour, tokensToday, turnsLimit: this.config.maxTurnsPerHour, tokenLimit: this.config.dailyTokenBudget };
+    return { ok: true, tokensToday, tokenLimit: this.config.dailyTokenBudget };
   }
 
   healthPayload() {
@@ -1854,14 +2461,13 @@ export class BotTeamService {
       config: {
         botSandbox: this.config.botSandbox,
         botApprovalPolicy: this.config.botApprovalPolicy,
-        maxTurnsPerHour: this.config.maxTurnsPerHour,
         dailyTokenBudget: this.config.dailyTokenBudget,
         maxParallelTurns: this.config.maxParallelTurns,
         enableModelTools: this.config.enableModelTools,
       },
       toolNames: BOT_TEAM_TOOL_NAMES,
       quotas: Object.fromEntries(
-        [...this.repo.groups.values()].map((group) => [group.groupId, this.checkQuota(group.groupId, 0)]),
+        [...this.repo.groups.values()].map((group) => [group.groupId, this.checkQuota(group.groupId)]),
       ),
       smoke: this.smokeState,
       at: Date.now(),
@@ -2354,8 +2960,15 @@ export class BotTeamService {
           health.domain.schemaVersion >= 6 &&
           health.domain.counts.messages > 0 &&
           health.toolNames.length === BOT_TEAM_TOOL_NAMES.length;
-        quotaPass = this.checkQuota(group.groupId, 1).ok === true;
-        quotaDenyPass = this.checkQuota(group.groupId, 999999).ok === false;
+        const quota = this.checkQuota(group.groupId);
+        quotaPass = quota.ok === true;
+        const dailyTokenBudget = this.config.dailyTokenBudget;
+        try {
+          this.config.dailyTokenBudget = quota.tokensToday;
+          quotaDenyPass = this.checkQuota(group.groupId).ok === false;
+        } finally {
+          this.config.dailyTokenBudget = dailyTokenBudget;
+        }
         const agentA2 = this.pool.current(memberA.membershipId);
         if (agentA2 && agentA2.session) {
           const modes = agentA2.session
@@ -2555,6 +3168,7 @@ export class BotTeamService {
   async dispose() {
     if (this.disposed) return;
     this.disposed = true;
+    this.updateChecker?.dispose();
     try {
       await this.routeDispose?.();
     } catch {
@@ -2565,6 +3179,16 @@ export class BotTeamService {
     } catch {
       /* noop */
     }
+    try {
+      await this.interactions?.dispose();
+    } catch {
+      /* noop */
+    }
+    try {
+      await this.visibility?.dispose();
+    } catch {
+      /* noop */
+    }
     try {
       await this.engine?.dispose();
     } catch {