dsh-bot-team 1.1.0 → 1.3.0

package/host/engine.js

@@ -23,14 +23,17 @@ import {
   parseReviewVerdict,
 } from './prompt.js';
 import { newId, now, withTimeout } from './util.js';
+import { DiscussionRunner } from './discussion-runner.js';
+import { isDiscussionActive } from './discussion-flow.js';
 import { LastRequestMetrics } from './message-metrics.js';
+import { currentConversationId, conversationFloor, conversationIdOf, isCurrentMemberSession } from './conversations.js';
 
 const executionSeq = (value) => Number.isSafeInteger(value) && value >= 0;
 const executionTurn = (value) => Number.isSafeInteger(value) && value > 0;
-const executionEvent = (type) => /^(?:turn|step|user|assistant|tool|tools|ptc|approval|llm|request|compaction)\//.test(type);
+const executionEvent = (type) => typeof type === 'string';
 
 export class Engine {
-  constructor({ ctx, repo, pool, personas, bus, config, logger, quotaGuard, taskHook }) {
+  constructor({ ctx, repo, pool, personas, bus, config, logger, quotaGuard, taskHook, workspaceGuard, assertAdmission, discussionGuard }) {
     this.ctx = ctx;
     this.repo = repo;
     this.pool = pool;
@@ -40,6 +43,12 @@ export class Engine {
     this.logger = logger;
     this.quotaGuard = quotaGuard || (() => ({ ok: true }));
     this.taskHook = taskHook || (() => {});
+    this.workspaceGuard = workspaceGuard || (() => {});
+    this.assertAdmission = assertAdmission || this.workspaceGuard;
+    this.pendingWork = new Set();
+    this.discussionGuard = discussionGuard || (async () => {});
+    this.discussionRunner = new DiscussionRunner(this);
+    this.pumpBlocks = new Set();
 
     this.queue = [];
     this.running = new Map(); // membershipId -> job
@@ -48,16 +57,150 @@ export class Engine {
     this.discussionWaiters = new Map(); // discussionId -> [{ resolve }]
     this.disposed = false;
 
-    this.offSession = ctx.on('session/event', (session, event) => this.onSessionEvent(session, event));
+    this.offSession = ctx.on('session/event', (session, event) => this.onSessionEvent(session, event), { global: true });
     this.offClaim = pool.attachClaimHandler?.((payload) => this.onInboxClaim(payload));
+    if (ctx.get?.('goals')) this.offGoal = ctx.on('goal/activation-changed', ({ sessionId }) => {
+      const job = this.activeBySession.get(sessionId);
+      queueMicrotask(() => { this.checkNativeGoal(sessionId, job); this.discussionRunner.nativeSettled(sessionId); });
+    }, { global: true });
+  }
+
+  admitConversation(groupId, expectedConversationId) {
+    this.assertAdmission(groupId);
+    const conversationId = currentConversationId(this.repo, groupId);
+    const group = this.repo.getGroup(groupId);
+    if (group?.activeConversationId) {
+      if (conversationId !== group.activeConversationId) throw Object.assign(new Error('聊天会话归属不可用'), { code: 'conversation-corrupt' });
+      conversationFloor(this.repo, groupId);
+    }
+    if (expectedConversationId !== undefined && expectedConversationId !== conversationId) {
+      throw Object.assign(new Error('聊天已开始新会话，请重新选择当前会话'), {
+        code: 'stale-conversation', details: { currentConversationId: conversationId },
+      });
+    }
+    return conversationId;
+  }
+
+  isCurrentRecord(record, groupId = record?.groupId) {
+    if (!record || record.groupId !== groupId) return false;
+    try {
+      const current = currentConversationId(this.repo, groupId);
+      if (this.repo.getGroup(groupId)?.activeConversationId && !current) return false;
+      return !current || conversationIdOf(this.repo, record) === current;
+    } catch { return false; }
+  }
+
+  assertCurrentTarget(groupId, record) {
+    if (!record || record.groupId !== groupId) {
+      throw Object.assign(new Error('目标不存在或不属于本群'), { code: 'not-found' });
+    }
+    if (!this.isCurrentRecord(record, groupId)) {
+      throw Object.assign(new Error('历史会话不能继续执行，请选取内容后在当前会话重新发送'), { code: 'historical-target' });
+    }
+    return record;
+  }
+
+  isCurrentJob(job) {
+    if (!job || !this.isCurrentRecord(job)) return false;
+    const member = this.repo.getMember(job.membershipId);
+    if (!member || member.groupId !== job.groupId) return false;
+    // Legacy adapters without a conversation pointer may expose a different
+    // actual Agent id. Once migrated, session ownership is mandatory.
+    if (this.repo.getGroup(job.groupId)?.activeConversationId && job.sessionId) {
+      return isCurrentMemberSession(this.repo, member, job.sessionId);
+    }
+    return true;
+  }
+
+  assertJobCurrent(job) {
+    if (!this.isCurrentJob(job)) {
+      throw Object.assign(new Error('本次执行所属会话已结束'), { code: 'stale-conversation' });
+    }
+  }
+
+  assertJobTargets(job) {
+    // The pre-migration test adapters have no task/conversation repositories.
+    if (!this.repo.getGroup(job.groupId)?.activeConversationId) return;
+    const messageIds = [job.triggerMessageId, job.reviewTargetId, job.reviewMessageId,
+      job.meta?.retryOf, job.meta?.reviewOf, job.meta?.revisionOf];
+    if (job.meta?.taskId) {
+      const task = this.assertCurrentTarget(job.groupId, this.repo.getTask?.(job.meta.taskId));
+      messageIds.push(task.deliverableMessageId, task.reviewReplyMessageId);
+      for (const dependencyId of task.dependencies || task.dependsOn || []) {
+        this.assertCurrentTarget(job.groupId, this.repo.getTask?.(dependencyId));
+      }
+    }
+    if (job.discussionId) this.assertCurrentTarget(job.groupId, this.repo.getDiscussion?.(job.discussionId));
+    for (const id of messageIds.filter(Boolean)) this.assertCurrentTarget(job.groupId, this.repo.getMessage(id));
+    const review = job.reviewMessageId ? this.repo.getMessage(job.reviewMessageId) : null;
+    if (review?.meta?.reviewOf) this.assertCurrentTarget(job.groupId, this.repo.getMessage(review.meta.reviewOf));
+  }
+
+  contextFor(job, member, rebuild = false) {
+    this.assertJobCurrent(job);
+    const floor = conversationFloor(this.repo, job.groupId);
+    const from = rebuild ? floor : Math.max(floor, Number.isInteger(member.lastSeenSeq) ? member.lastSeenSeq : 0);
+    const context = this.repo.messagesBetween(job.groupId, from, job.triggerSeq)
+      .filter(message => message.messageId !== job.placeholderId && this.isCurrentRecord(message, job.groupId));
+    const maximum = this.config.maxContextMessages;
+    return Number.isInteger(maximum) && maximum > 0 ? context.slice(-maximum) : context;
+  }
+
+  async advanceMemberCursor(job) {
+    // These prompts contain an explicit transcript, not the ordinary chat context.
+    if (job.discussionId || ['discussion', 'summary', 'discussion_step'].includes(job.kind)) return;
+    this.assertJobCurrent(job);
+    const member = this.repo.getMember(job.membershipId);
+    const lastSeenSeq = Math.max(member.lastSeenSeq || 0, conversationFloor(this.repo, job.groupId), job.triggerSeq || 0);
+    const updated = { ...member, lastSeenSeq };
+    if (this.repo.putMemberStrict) await this.repo.putMemberStrict(updated, {
+      expectedConversationId: job.conversationId, expectedSessionId: member.sessionId, preserveSession: true,
+    });
+    else {
+      // Compatibility with adapters predating strict, copy-on-write members.
+      Object.assign(member, updated);
+      this.repo.touchMember(member);
+    }
+    this.assertJobCurrent(job);
+  }
+
+  captureQuote(groupId, replyTo) {
+    if (!replyTo) return null;
+    const target = this.repo.getMessage(replyTo);
+    if (!target || target.groupId !== groupId) {
+      throw Object.assign(new Error('回复的原消息不存在或不属于本群'), { code: 'invalid-input' });
+    }
+    const attachments = (target.attachments || []).map(attachment => {
+      const store = this.ctx.get?.('attachments');
+      let path;
+      try { path = store?.fileHostPath?.(attachment); } catch { /* rejected below */ }
+      if (typeof path !== 'string' || !path) {
+        throw Object.assign(new Error('引用消息的附件已不可用，请重新选择'), { code: 'invalid-input' });
+      }
+      return { attachmentId: attachment.attachmentId, name: attachment.name, bytes: attachment.bytes, path };
+    });
+    const conversationId = conversationIdOf(this.repo, target);
+    if (this.repo.getGroup(groupId)?.activeConversationId && !conversationId) {
+      throw Object.assign(new Error('引用消息的会话归属不可用'), { code: 'invalid-input' });
+    }
+    return {
+      messageId: target.messageId, conversationId,
+      author: { ...target.author }, text: String(target.text || ''), attachments, capturedAt: now(),
+    };
   }
 
   // ── message helpers ──────────────────────────────────────────────────────
   createMessage(fields) {
+    const conversationId = fields.conversationId ?? currentConversationId(this.repo, fields.groupId);
+    if (conversationId !== currentConversationId(this.repo, fields.groupId)) {
+      throw Object.assign(new Error('本次执行所属会话已结束'), { code: 'stale-conversation' });
+    }
     const seq = this.repo.allocateSeq(fields.groupId);
     const message = {
       messageId: newId('msg'),
       groupId: fields.groupId,
+      conversationId,
+      ...(fields.quote ? { quote: structuredClone(fields.quote) } : {}),
       seq,
       author: fields.author,
       kind: fields.kind ?? 'chat',
@@ -98,6 +241,7 @@ export class Engine {
    * points the user there and tracks the outcome.
    */
   approvalMessage(job, data) {
+    if (!this.isCurrentJob(job)) return;
     const member = this.repo.getMember(job.membershipId);
     const bot = member ? this.repo.getBot(member.botId) : undefined;
     const name = bot?.name || 'Bot';
@@ -105,6 +249,7 @@ export class Engine {
     const text = `${name} 请求权限：工具 ${data.toolName}${reason ? `（${reason}）` : ''}。`;
     const message = this.createMessage({
       groupId: job.groupId,
+      conversationId: job.conversationId,
       author: { type: 'system', name: '审批' },
       text,
       status: 'done',
@@ -114,6 +259,7 @@ export class Engine {
         membershipId: job.membershipId,
         botId: member?.botId ?? null,
         sessionId: job.sessionId,
+        nativeSession: true,
         toolName: String(data.toolName || ''),
         reason,
         approvalState: 'pending',
@@ -137,25 +283,29 @@ export class Engine {
   }
 
   // ── public dispatch ──────────────────────────────────────────────────────
-  assertQuota(groupId, turns = 1) {
-    const result = this.quotaGuard(groupId, turns);
+  assertQuota(groupId) {
+    this.assertAdmission(groupId);
+    const result = this.quotaGuard(groupId);
     if (!result || result.ok) return;
     const error = new Error(result.reason || '本群额度已用完，请稍后再试');
     error.code = 'quota';
     throw error;
   }
 
-  postHumanMessage({ groupId, text, mentions, author, replyTo, attachments }) {
+  postHumanMessage({ groupId, text, mentions = [], author, replyTo, attachments, humanInput = true, expectedConversationId }) {
+    const conversationId = this.admitConversation(groupId, expectedConversationId);
     const group = this.repo.getGroup(groupId);
-    if (!group) throw new Error(`group ${groupId} does not exist`);
-    let replyToId = null;
-    if (replyTo) {
-      const target = this.repo.getMessage(replyTo);
-      if (!target || target.groupId !== groupId) {
-        throw Object.assign(new Error('回复的原消息不存在或不属于本群'), { code: 'invalid-input' });
-      }
-      replyToId = target.messageId;
+    if (!group) throw new Error('group ' + groupId + ' does not exist');
+    const command = String(text || '').trim();
+    if (command === '/new') throw Object.assign(new Error('请使用新建会话管理操作'), { code: 'command-required' });
+    if (/^\/new\s/.test(command)) throw Object.assign(new Error('/new 不接受参数'), { code: 'invalid-command' });
+    const quote = this.captureQuote(groupId, replyTo);
+    const quoteSize = quote ? quote.text.length + JSON.stringify(quote.author).length + JSON.stringify(quote.attachments).length : 0;
+    const inputSize = String(text || '').length + quoteSize + (attachments?.length ? JSON.stringify(attachments).length : 0);
+    if (inputSize > (this.config.maxMessageChars || 40000)) {
+      throw Object.assign(new Error('消息与引用内容超过输入大小上限，请减少内容后重试'), { code: 'invalid-input' });
     }
+    const replyToId = quote?.messageId || null;
     const message = this.createMessage({
       groupId,
       author: author || { type: 'human', name: '用户' },
@@ -163,6 +313,8 @@ export class Engine {
       mentions,
       attachments,
       replyTo: replyToId,
+      conversationId,
+      quote,
       status: 'done',
     });
     this.bus.emit(groupId, { type: 'message.added', message });
@@ -174,15 +326,17 @@ export class Engine {
       if (!this.repo.getBot(member.botId)) continue;
       if (!targets.some((candidate) => candidate.membershipId === member.membershipId)) targets.push(member);
     }
-    if (targets.length > 0) this.assertQuota(groupId, targets.length);
+    if (targets.length > 0) this.assertQuota(groupId);
     for (const member of targets) {
       this.queue.push({
         jobId: newId('job'),
         groupId,
+        conversationId,
         membershipId: member.membershipId,
         triggerSeq: message.seq,
         triggerMessageId: message.messageId,
         kind: 'chat',
+        humanInput,
         state: 'queued',
       });
     }
@@ -191,7 +345,7 @@ export class Engine {
   }
 
   pump(groupId) {
-    if (this.disposed) return;
+    if (this.disposed || this.pumpBlocks.has(groupId)) return;
     const runnable = [];
     const busy = new Set(
       [...this.running.values()].filter((job) => job.groupId === groupId).map((job) => job.membershipId),
@@ -199,6 +353,10 @@ export class Engine {
     let running = this.runningCount(groupId);
     for (const job of this.queue) {
       if (job.groupId !== groupId) continue;
+      if (job.stepId) {
+        const discussion = this.repo.getDiscussion(job.discussionId);
+        if (!discussion || this.discussionRunner.closed.has(job.discussionId) || !['running', 'finalizing'].includes(discussion.status)) continue;
+      }
       if (running >= this.config.maxParallelTurns) break;
       if (busy.has(job.membershipId)) continue;
       busy.add(job.membershipId);
@@ -222,7 +380,24 @@ export class Engine {
     return this.queue.filter((job) => job.groupId === groupId).length;
   }
 
-  startJob(job) {
+  startJob(job, observed = null) {
+    try {
+      job.conversationId = this.admitConversation(job.groupId, job.conversationId);
+      this.assertJobCurrent(job);
+      this.assertJobTargets(job);
+      if (observed && !isCurrentMemberSession(this.repo, this.repo.getMember(job.membershipId), observed.session.id)) {
+        throw Object.assign(new Error('原生会话已不是当前会话'), { code: 'stale-conversation' });
+      }
+    } catch (error) {
+      job.finished = true;
+      job.state = 'error';
+      job.error = String(error?.message || error);
+      job.done = job.stepId ? this.discussionRunner.finished(job).catch(failure => this.discussionRunner.failed(job.discussionId, failure)) : Promise.resolve();
+      job.done.then(() => job.resolveDone?.());
+      if (!job.stepId && job.discussionId) this.advanceDiscussion(job.discussionId, false);
+      this.checkIdle(job.groupId);
+      return;
+    }
     job.state = 'running';
     job.turn = null;
     job.submitted = false;
@@ -242,6 +417,9 @@ export class Engine {
     job.streamText = '';
     job.requestMetrics = new LastRequestMetrics();
     job.finished = false;
+    job.following = [];
+    job.awaitingContinuation = false;
+    job.nativeObserved = observed !== null;
     job.done = new Promise((resolve) => {
       job.resolveDone = resolve;
     });
@@ -253,8 +431,9 @@ export class Engine {
       this.finishJob(job, 'error', '成员或 Bot 已不存在');
       return;
     }
-    const placeholder = this.createMessage({
+    const placeholder = observed?.message || this.createMessage({
       groupId: job.groupId,
+      conversationId: job.conversationId,
       author: {
         type: 'bot',
         botId: member.botId,
@@ -271,34 +450,59 @@ export class Engine {
       meta: { ...(job.meta || {}), execution: job.execution },
     });
     job.placeholderId = placeholder.messageId;
-    this.bus.emit(job.groupId, { type: 'message.added', message: placeholder });
+    if (observed?.message) {
+      placeholder.status = 'pending';
+      placeholder.error = null;
+      this.bus.emit(job.groupId, { type: 'message.updated', message: placeholder });
+    } else this.bus.emit(job.groupId, { type: 'message.added', message: placeholder });
     this.bus.emit(job.groupId, {
       type: 'member.status',
+      conversationId: job.conversationId,
       membershipId: member.membershipId,
       status: 'running',
     });
 
-    const previousSeen = Number.isInteger(member.lastSeenSeq) ? member.lastSeenSeq : 0;
-    const context = this.repo
-      .messagesBetween(job.groupId, previousSeen, job.triggerSeq)
-      .filter((message) => message.messageId !== placeholder.messageId);
-    member.lastSeenSeq = job.triggerSeq;
-    this.repo.touchMember(member);
+    const context = this.contextFor(job, member);
     job.context = context;
 
-    job.timer = setTimeout(() => this.abortJob(job, 'timeout'), this.config.turnTimeoutMs);
+    if (observed) {
+      job.sessionId = observed.session.id;
+      job.submitted = true;
+      job.nativeInput = true;
+      this.activeBySession.set(job.sessionId, job);
+      this.recordExecution(job, { sessionId: job.sessionId, submittedSeq: observed.event.seq }, observed.event.seq);
+      return;
+    }
+    if (this.config.turnTimeoutMs > 0) job.timer = setTimeout(() => this.abortJob(job, 'timeout'), this.config.turnTimeoutMs);
     void this.runJob(job, member, bot, context);
   }
 
   async runJob(job, member, bot, context) {
+    this.pendingWork.add(job);
     try {
+      this.admitConversation(job.groupId, job.conversationId);
+      this.assertJobTargets(job);
+      if (job.stepId) await this.discussionRunner.prepare(job);
+      if (job.finished) return;
+      const previousSessionId = member.sessionId;
+      const previousConversationId = member.sessionConversationId;
       const agent = await this.pool.ensure(member.membershipId);
       if (job.finished) return;
       if (this.disposed || job.state === 'stopped') {
         this.finishJob(job, 'stopped', '已停止');
         return;
       }
+      // ensure persists a replacement member. Never write the pre-ensure object
+      // back over the new session mapping or its conversation ownership.
+      member = this.repo.getMember(job.membershipId);
       job.sessionId = agent.id;
+      this.assertJobCurrent(job);
+      this.assertJobTargets(job);
+      const rebuild = member.sessionId !== previousSessionId || previousConversationId !== member.sessionConversationId;
+      context = this.contextFor(job, member, rebuild);
+      job.context = context;
+      await this.advanceMemberCursor(job);
+      if (job.finished) return;
       this.activeBySession.set(agent.id, job);
       await this.persistExecution(job, { sessionId: agent.id });
       if (job.finished) return;
@@ -310,7 +514,11 @@ export class Engine {
       }
 
       if (job.finished) return;
-      const prompt = this.buildPrompt(job, bot, context);
+      this.admitConversation(job.groupId, job.conversationId);
+      this.assertJobCurrent(job);
+      this.assertJobTargets(job);
+      if (job.stepId) this.discussionRunner.assertDispatch(job);
+      const prompt = job.promptText ?? this.buildPrompt(job, bot, context);
       job.promptPreview = prompt.slice(0, 2000);
       const inputMessageId = newId('umsg');
       // Session.seq is the next accepted event index, an inclusive search floor.
@@ -322,21 +530,42 @@ export class Engine {
       // A stop/timeout may have occurred while the durable write was pending.
       if (job.finished) return;
 
+      this.admitConversation(job.groupId, job.conversationId);
+      this.assertJobCurrent(job);
+      this.assertJobTargets(job);
+
+      if (job.stepId) this.discussionRunner.assertDispatch(job);
+
       // M0 P1: followup puts the EXACT value into the durable inbox — it must be
       // a complete UserMessage (role + id + content + source). Claims may fire
       // synchronously, so arm correlation only after the write has succeeded.
       job.submitted = true;
-      await agent.followup({
+      const input = {
         role: 'user',
         id: inputMessageId,
         content: [{ type: 'text', text: prompt }],
-        source: { kind: 'user' },
-      });
+        source: job.humanInput === true
+          ? { kind: 'user' }
+          : { kind: 'bot-team', groupId: job.groupId, ...(job.conversationId ? { conversationId: job.conversationId } : {}), jobId: job.jobId },
+      };
+      const assertActive = () => {
+        if (job.finished) throw Object.assign(new Error('本次执行已结束'), { code: 'stopped' });
+        this.assertJobCurrent(job); this.assertJobTargets(job);
+        if (job.stepId) this.discussionRunner.assertDispatch(job);
+      };
+      if (this.pool.submit) await this.pool.submit(agent, input, assertActive);
+      else { assertActive(); await agent.followup(input); }
+      if (job.finished && job.stepId) this.withdrawDiscussionInput(job);
       await job.done;
     } catch (error) {
       this.finishJob(job, 'error', String(error && error.message ? error.message : error));
     } finally {
       if (job.timer) clearTimeout(job.timer);
+      this.pendingWork.delete(job);
+      if (job.finished && job.stepId) {
+        this.withdrawDiscussionInput(job);
+        if (this.repo.getDiscussion(job.discussionId)?.status === 'stopping') this.discussionRunner.checkStopping(job.discussionId);
+      }
     }
   }
 
@@ -344,12 +573,15 @@ export class Engine {
     this.bus.emit(job.groupId, {
       type: 'execution.updated',
       messageId: job.placeholderId,
+      conversationId: job.conversationId,
+      sessionId: job.execution.sessionId,
       seq: executionSeq(seq) ? seq : null,
       ...(includeExecution ? { execution: { ...job.execution } } : {}),
     });
   }
 
   async persistExecution(job, patch, seq = null) {
+    this.assertJobCurrent(job);
     const message = this.repo.messages.get(job.placeholderId);
     if (!message) throw new Error('无法保存执行记录：回复消息不存在');
     job.execution = { ...job.execution, ...patch };
@@ -357,16 +589,22 @@ export class Engine {
     message.updatedAt = now();
     // Do not use putMessage here: it deliberately swallows storage failures.
     const saved = this.repo.putMessageStrict(message);
-    this.emitExecutionUpdated(job, seq, true);
     await saved;
+    if (job.stepId) await this.discussionRunner.execution(job);
+    if (this.isCurrentJob(job)) this.emitExecutionUpdated(job, seq, true);
+  }
+
+  recordExecution(job, patch, seq) {
+    void this.persistExecution(job, patch, seq).catch(error => this.executionFailed(job, error));
   }
 
   executionFailed(job, error) {
     if (job.finished) return;
+    const scoped = this.activeBySession.get(job.sessionId) === job && (!job.stepId || job.turn !== null);
     this.finishJob(job, 'error', `无法保存执行记录：${String(error?.message || error)}`);
-    if (job.submitted && job.execution.endSeq === null) {
+    if (scoped && !job.nativeObserved && job.submitted && job.execution.endSeq === null) {
       try {
-        this.ctx.agents.get(job.sessionId)?.cancel?.({ kind: 'user' }, { keepInbox: false });
+        this.ctx.agents.get(job.sessionId)?.cancel?.({ kind: 'user' }, { keepInbox: Boolean(job.stepId) });
       } catch (cancelError) {
         this.logger?.warn?.(`bot-team: cancel agent failed: ${String(cancelError)}`);
       }
@@ -386,17 +624,165 @@ export class Engine {
 
   onInboxClaim(payload) {
     const job = this.activeBySession.get(payload?.agent?.id);
-    if (!job || job.finished || job.ending || !job.submitted) return;
+    if (!job || job.finished || job.ending || !job.submitted || !this.isCurrentJob(job)) return;
+    if (this.ctx.agents.get(payload.agent.id) !== payload.agent) return;
     if (!job.execution.inputMessageId || payload.message?.id !== job.execution.inputMessageId) return;
     this.bindExecutionTurn(job, payload.turn);
   }
 
+  /** Reattach group observation to already-live native Agents after plugin reload. */
+  async recoverNativeSessions() {
+    const query = this.ctx.get?.('sessionQuery');
+    for (const member of this.repo.members?.values() || []) {
+      if (!isCurrentMemberSession(this.repo, member, member.sessionId)) continue;
+      const conversationId = currentConversationId(this.repo, member.groupId);
+      const agent = member.sessionId ? this.ctx.agents.get?.(member.sessionId) : null;
+      if (!agent || this.activeBySession.has(agent.id)) continue;
+      try {
+        const snapshot = typeof agent.session?.snapshotEvents === 'function'
+          ? { events: agent.session.snapshotEvents() }
+          : await query?.readSession?.(agent.id);
+        if (this.disposed) return;
+        if (currentConversationId(this.repo, member.groupId) !== conversationId ||
+            !isCurrentMemberSession(this.repo, this.repo.getMember(member.membershipId), agent.id)) continue;
+        this.admitConversation(member.groupId, conversationId);
+        if (this.ctx.agents.get(agent.id) !== agent || this.pool.memberForSession?.(agent.id)?.membershipId !== member.membershipId || this.running.has(member.membershipId)) continue;
+        const events = snapshot?.events;
+        if (!Array.isArray(events)) continue;
+        const startIndex = events.findLastIndex(event => event.type === 'turn/start');
+        if (startIndex < 0) continue;
+        const turnEvents = events.slice(startIndex);
+        const start = turnEvents[0];
+        if (!executionTurn(start.data?.turn) || !executionSeq(start.seq)) continue;
+        const ended = turnEvents.some(event => event.type === 'turn/end' && event.data?.turn === start.data.turn);
+        if (ended && !this.nativeGoalPending(agent.id)) continue;
+        const previous = this.repo.messagesOf(member.groupId).findLast(message =>
+          this.isCurrentRecord(message, member.groupId) && message.author?.membershipId === member.membershipId &&
+          message.meta?.execution?.sessionId === agent.id &&
+          message.meta.execution.turn === start.data.turn && message.meta.execution.startSeq === start.seq);
+        const discussion = previous?.meta?.discussionId ? this.repo.getDiscussion?.(previous.meta.discussionId) : null;
+        const linked = discussion && isDiscussionActive(discussion) && this.isCurrentRecord(discussion);
+        const kind = linked ? (previous.meta.stepId ? 'discussion_step' : previous.meta.summary ? 'summary' : 'discussion')
+          : previous?.meta?.taskPhase === 'revision' ? 'task_revision' : previous?.kind || 'native';
+        const job = {
+          jobId: previous?.meta?.execution?.jobId || newId('job'),
+          groupId: member.groupId, conversationId, membershipId: member.membershipId,
+          triggerSeq: member.lastSeenSeq || 0, triggerMessageId: previous?.replyTo || null,
+          kind, messageKind: previous?.kind, meta: { ...(previous?.meta || {}), nativeSession: true },
+          ...(linked ? { discussionId: discussion.discussionId, stepId: previous.meta.stepId, attemptId: previous.meta.attemptId, round: previous.meta.round } : {}),
+          previousReplies: linked ? this.repo.messagesOf(member.groupId).filter(message =>
+            message.messageId !== previous?.messageId && message.meta?.execution?.jobId === previous?.meta?.execution?.jobId &&
+            message.meta?.attemptId === previous?.meta?.attemptId).map(message => message.messageId) : [],
+        };
+        this.startJob(job, { session: agent.session, event: start, message: previous });
+        for (const event of turnEvents) this.onSessionEvent(agent.session, event);
+      } catch (error) {
+        this.logger?.warn?.('bot-team: native observation recovery failed: ' + String(error));
+      }
+    }
+  }
+
+  /** Follow native goals without treating their first completed turn as the task end. */
+  nativeGoalPending(sessionId) {
+    const member = this.pool.memberForSession?.(sessionId);
+    if (!member || !isCurrentMemberSession(this.repo, member, sessionId)) return false;
+    const agent = this.ctx.agents.get(sessionId);
+    const goals = this.ctx.get?.('goals');
+    if (!agent || !goals?.get) return false;
+    try {
+      const goal = goals.get(agent);
+      return goal?.phase === 'active' && goal.activation === 'armed';
+    } catch { return false; }
+  }
+
+  checkNativeGoal(sessionId, expectedJob = this.activeBySession.get(sessionId)) {
+    const job = this.activeBySession.get(sessionId);
+    if (job !== expectedJob || this.disposed || !job?.awaitingContinuation || job.finished || !this.isCurrentJob(job)) return;
+    if (this.nativeGoalPending(sessionId)) return;
+    const agent = this.ctx.agents.get(sessionId);
+    const goal = agent ? this.ctx.get?.('goals')?.get(agent) : null;
+    if (goal?.phase === 'blocked') this.finishJob(job, 'error', goal.blockedReason?.message || '原生目标已阻塞');
+    else if (goal?.phase === 'paused' || (goal?.phase === 'active' && goal.activation !== 'armed')) this.finishJob(job, 'stopped', '原生目标已暂停');
+    else this.finishJob(job, 'done');
+  }
+
+  /** A turn started from the native window, scheduler, or a child reply still belongs in the group. */
+  adoptNativeTurn(session, event) {
+    if (event.type !== 'turn/start' || !executionTurn(event.data?.turn) || !executionSeq(event.seq)) return null;
+    const member = this.pool.memberForSession?.(session.id);
+    if (!member || !isCurrentMemberSession(this.repo, member, session.id) || this.running.has(member.membershipId)) return null;
+    let conversationId;
+    try { conversationId = this.admitConversation(member.groupId); } catch { return null; }
+    const job = {
+      jobId: newId('job'), groupId: member.groupId, conversationId, membershipId: member.membershipId,
+      triggerSeq: member.lastSeenSeq || 0, triggerMessageId: null, kind: 'native',
+      meta: { nativeSession: true },
+    };
+    this.startJob(job, { session, event });
+    return job.finished ? null : job;
+  }
+
+  startNativeContinuation(job, session, event) {
+    if (!this.isCurrentJob(job)) return false;
+    try { this.admitConversation(job.groupId, job.conversationId); } catch { return false; }
+    const previous = this.repo.getMessage(job.placeholderId);
+    if (!previous) throw new Error('Native continuation lost its preceding reply');
+    job.previousReplies = [...(job.previousReplies || []), job.placeholderId];
+    job.turn = null;
+    job.turnStarts = new Map();
+    job.observedTurn = null;
+    job.observedTurnSeq = -1;
+    job.steps = [];
+    job.streamText = '';
+    job.streamAttemptId = null;
+    job.usage = null;
+    job.requestMetrics = new LastRequestMetrics();
+    job.awaitingContinuation = false;
+    job.nativeInput = true;
+    job.execution = {
+      version: 1, jobId: job.jobId, sessionId: session.id, inputMessageId: null,
+      turn: null, startSeq: null, endSeq: null, submittedSeq: event.seq,
+    };
+    const message = this.createMessage({
+      groupId: job.groupId, conversationId: job.conversationId, author: previous.author, status: 'pending',
+      kind: previous.kind, provider: previous.provider, model: previous.model,
+      reasoningEffort: previous.reasoningEffort, replyTo: previous.messageId,
+      meta: { ...(job.meta || {}), nativeSession: true, execution: job.execution },
+    });
+    job.placeholderId = message.messageId;
+    this.bus.emit(job.groupId, { type: 'message.added', message });
+    return true;
+  }
+
+  replayFollowing(job) {
+    const following = job.following?.splice(0) || [];
+    for (const item of following) {
+      if (item.stream) this.onAssistantStream(item.stream);
+      else this.onSessionEvent(item.session, item.event);
+    }
+  }
+
   onSessionEvent(session, event) {
     if (!session || !event) return;
-    const job = this.activeBySession.get(session.id);
-    if (!job || job.finished || job.ending) return;
+    if (this.disposed) return;
+    const live = this.ctx.agents.get(session.id);
+    if (live?.session && live.session !== session) return;
+    if (event.type === 'turn/end') this.discussionRunner.nativeSettled(session.id);
+    const job = this.activeBySession.get(session.id) || this.adoptNativeTurn(session, event);
+    if (!job || job.finished || !this.isCurrentJob(job)) return;
+    if (job.ending) { job.following.push({ session, event }); return; }
     const data = event.data || {};
-    const correlated = Boolean(job.execution.inputMessageId);
+    if (job.awaitingContinuation) {
+      if (event.type === 'turn/start') {
+        if (!this.startNativeContinuation(job, session, event)) return;
+      }
+      else {
+        if (event.type.startsWith('goal/')) queueMicrotask(() => this.checkNativeGoal(session.id, job));
+        if (executionSeq(event.seq)) this.emitExecutionUpdated(job, event.seq);
+        return;
+      }
+    }
+    const correlated = Boolean(job.execution.inputMessageId) || job.nativeInput;
     if (correlated && !job.submitted) return;
     if (executionSeq(event.seq) && executionSeq(job.execution.submittedSeq) && event.seq < job.execution.submittedSeq) return;
 
@@ -425,7 +811,11 @@ export class Engine {
       return;
     }
     if (event.type === 'user/message' && correlated) {
-      if ((data.id ?? data.message?.id) !== job.execution.inputMessageId) return;
+      const inputId = data.id ?? data.message?.id;
+      if (job.nativeInput && !job.execution.inputMessageId && typeof inputId === 'string') {
+        this.recordExecution(job, { inputMessageId: inputId }, event.seq);
+      }
+      if (inputId !== job.execution.inputMessageId) return;
       // Accepted user/message contains the UserMessage itself, without a turn.
       // Its exact ID disambiguates the enclosing turn/start candidate.
       this.bindExecutionTurn(job, executionTurn(data.turn) ? data.turn : job.observedTurn);
@@ -464,6 +854,7 @@ export class Engine {
       if (combined) {
         this.bus.emit(job.groupId, {
           type: 'message.replace',
+          conversationId: job.conversationId,
           messageId: job.placeholderId,
           text: combined,
         });
@@ -474,7 +865,16 @@ export class Engine {
   }
 
   finishTurn(job, reason = {}) {
+    if (job.finished) return;
+    if (!this.isCurrentJob(job)) { this.finishJob(job, 'stopped', '本次执行所属会话已结束'); return; }
+    job.ending = false;
     if (reason.kind === 'completed') {
+      if (this.nativeGoalPending(job.sessionId) || job.following?.some(item => item.event?.type === 'turn/start')) {
+        this.settleMessage(job, 'done');
+        job.awaitingContinuation = true;
+        this.replayFollowing(job);
+        return;
+      }
       this.finishJob(job, 'done');
     } else if (reason.kind === 'aborted') {
       this.finishJob(job, 'stopped', reason.reason && reason.reason.kind === 'user' ? '已停止' : '已中断');
@@ -488,8 +888,11 @@ export class Engine {
 
   onAssistantStream(payload) {
     if (!payload || !payload.agent || !payload.frame) return;
+    if (this.ctx.agents.get(payload.agent.id) !== payload.agent) return;
     const job = this.activeBySession.get(payload.agent.id);
-    if (!job || job.finished || job.ending || job.turn === null || job.observedTurn !== job.turn) return;
+    if (!job || job.finished || !this.isCurrentJob(job)) return;
+    if (job.ending) { job.following.push({ stream: payload }); return; }
+    if (job.awaitingContinuation || job.turn === null || job.observedTurn !== job.turn) return;
     const frame = payload.frame;
     if (executionTurn(frame.turn) && frame.turn !== job.turn) return;
     if (frame.type === 'start') {
@@ -513,41 +916,61 @@ export class Engine {
       job.streamText += frame.chunk.text;
       this.bus.emit(job.groupId, {
         type: 'message.delta',
+        conversationId: job.conversationId,
         messageId: job.placeholderId,
         chunk: frame.chunk.text,
       });
     }
   }
 
+  withdrawDiscussionInput(job) {
+    if (!job?.stepId || !job.sessionId || !job.execution?.inputMessageId) return 0;
+    if (this.activeBySession.get(job.sessionId) !== job && (!this.repo || !this.isCurrentRecord(job))) return 0;
+    const inbox = this.ctx.agents.get(job.sessionId)?.inbox;
+    if (typeof inbox?.splice !== 'function') return 0;
+    let removed = 0;
+    try {
+      for (const [lane, key] of [['next-turn', 'nextTurn'], ['next-step', 'nextStep']]) {
+        if (!Array.isArray(inbox[key])) continue;
+        for (let index = inbox[key].length - 1; index >= 0; index -= 1) {
+          const input = inbox[key][index];
+          if (input?.id !== job.execution.inputMessageId) continue;
+          // Persisted input identity remains authoritative if native admission
+          // normalizes the source. Preserve an explicitly different job source.
+          if (input.source?.kind === 'bot-team' && input.source.jobId && input.source.jobId !== job.jobId) continue;
+          inbox.splice(lane, index, 1, []); removed += 1;
+        }
+      }
+    } catch (error) { this.logger?.warn?.('bot-team: exact discussion input withdrawal failed: ' + String(error)); }
+    return removed;
+  }
+
   abortJob(job, cause) {
     if (!job || job.finished) return;
     job.state = 'stopped';
+    this.withdrawDiscussionInput(job);
     try {
       job.abortController?.abort();
     } catch {
       /* noop */
     }
     const agent = job.sessionId ? this.ctx.agents.get(job.sessionId) : undefined;
-    if (agent && typeof agent.cancel === 'function') {
+    const owned = agent && this.pool.owns?.(agent);
+    const scoped = this.activeBySession.get(job.sessionId) === job && (!job.stepId || job.turn !== null);
+    if (agent && scoped && (cause !== 'dispose' || owned) && typeof agent.cancel === 'function') {
       try {
-        agent.cancel({ kind: 'user' }, { keepInbox: false });
+        // A shared native session may contain unrelated queued inputs.
+        agent.cancel({ kind: 'user' }, { keepInbox: Boolean(job.stepId) });
       } catch (error) {
         this.logger?.warn?.(`bot-team: cancel agent failed: ${String(error)}`);
       }
     }
-    const reason = cause === 'timeout' ? '本轮超时，已停止' : cause === 'dispose' ? '插件已卸载' : '已停止';
+    const reason = cause === 'timeout' ? '本轮超时，已停止' : cause === 'dispose' ? (owned ? 'Bot Team 已卸载，后台执行已停止' : 'Bot Team 已断开观察；原生会话仍由 DSH 管理') : '已停止';
     this.finishJob(job, 'stopped', reason);
   }
 
-  finishJob(job, status, error) {
-    if (!job || job.finished) return;
-    job.finished = true;
-    job.state = status;
-    if (job.timer) clearTimeout(job.timer);
-    if (job.sessionId) this.activeBySession.delete(job.sessionId);
-    this.running.delete(job.membershipId);
-
-    const text = (job.steps.filter(Boolean).join('\n\n') || job.streamText || '').trim();
+  settleMessage(job, status, error) {
+    const text = ((job.steps || []).filter(Boolean).join('\n\n') || job.streamText || '').trim();
     const message = job.placeholderId ? this.repo.messages.get(job.placeholderId) : undefined;
     if (message) {
       message.text = text;
@@ -556,57 +979,89 @@ export class Engine {
       message.usage = job.usage ?? null;
       message.generationStats = job.requestMetrics?.finish(status) ?? null;
       message.kind = job.messageKind ?? message.kind ?? 'chat';
-      const meta = { ...(message.meta || {}), ...(job.meta || {}), execution: job.execution };
+      const meta = { ...(message.meta || {}), ...(job.meta || {}), execution: job.execution,
+        ...(job.stepId ? { logicalJobComplete: job.finished === true } : {}) };
       if (job.kind === 'review' && status === 'done') {
         const verdict = parseReviewVerdict(text);
         if (verdict) meta.verdict = verdict;
       }
       if (Object.keys(meta).length > 0) message.meta = meta;
       message.updatedAt = now();
-      this.repo.putMessage(message);
+      if (job.stepId) {
+        const saved = Promise.resolve(this.repo.putMessageStrict(message)).catch(saveError => {
+          job.discussionPersistenceError = String(saveError?.message || saveError);
+        });
+        job.discussionMessageWrites = Promise.all([job.discussionMessageWrites, saved]);
+      } else this.repo.putMessage(message);
       this.bus.emit(job.groupId, { type: 'message.updated', message });
       // The accepted end event may have invalidated before this final status.
       // A null seq also refreshes stopped jobs and bypasses event deduplication.
       this.emitExecutionUpdated(job, null, true);
     }
+    return message;
+  }
+
+  finishJob(job, status, error) {
+    if (!job || job.finished) return;
+    job.finished = true;
+    job.state = status;
+    job.error = error || null;
+    if (job.timer) clearTimeout(job.timer);
+    const current = this.isCurrentJob(job);
+    if (job.sessionId && this.activeBySession.get(job.sessionId) === job) this.activeBySession.delete(job.sessionId);
+    if (this.running.get(job.membershipId) === job) this.running.delete(job.membershipId);
+
+    const message = this.settleMessage(job, status, error);
     if (job.approvalMessages && job.approvalMessages.size > 0) {
       for (const approvalId of [...job.approvalMessages.keys()]) {
         this.settleApproval(job, approvalId, 'cancelled');
       }
     }
-    this.bus.emit(job.groupId, {
+    if (current) this.bus.emit(job.groupId, {
       type: 'member.status',
+      conversationId: job.conversationId,
       membershipId: job.membershipId,
       status: status === 'done' ? 'idle' : status === 'stopped' ? 'idle' : 'error',
       ...(status === 'error' ? { error: error ?? '未知错误' } : {}),
     });
     try {
-      const hookResult = this.taskHook(job, message, status);
+      const hookResult = current ? this.taskHook(job, message, status) : undefined;
       if (hookResult && typeof hookResult.then === 'function') {
+        const pendingHook = { groupId: job.groupId, conversationId: job.conversationId };
+        this.pendingWork.add(pendingHook);
         hookResult.catch((hookError) => {
           this.logger?.warn?.('bot-team: task hook failed: ' + String(hookError));
-        });
+        }).finally(() => this.pendingWork.delete(pendingHook));
       }
     } catch (hookError) {
       this.logger?.warn?.('bot-team: task hook failed: ' + String(hookError));
     }
-    job.resolveDone?.();
-    job.state = status;
-    this.pump(job.groupId);
-    this.afterJobFinished(job);
-    this.checkIdle(job.groupId);
+    if (job.stepId) {
+      const pending = { groupId: job.groupId, conversationId: job.conversationId };
+      this.pendingWork.add(pending);
+      void this.discussionRunner.finished(job).catch(failure => this.discussionRunner.failed(job.discussionId, failure))
+        .finally(() => {
+          this.pendingWork.delete(pending); job.resolveDone?.();
+          this.pump(job.groupId); this.checkIdle(job.groupId);
+        });
+    } else {
+      job.resolveDone?.();
+      this.pump(job.groupId);
+      if (current) this.afterJobFinished(job);
+      this.checkIdle(job.groupId);
+    }
   }
 
   /** Discussion bookkeeping + review-side effects after one job settles. */
   afterJobFinished(job) {
-    if (!job) return;
+    if (!job || !this.isCurrentJob(job)) return;
     if (job.kind === 'discussion' && job.discussionId) {
       this.advanceDiscussion(job.discussionId, job.state === 'done');
       return;
     }
     if (job.kind === 'summary' && job.discussionId) {
       const discussion = this.repo.getDiscussion(job.discussionId);
-      if (discussion && discussion.status === 'running') {
+      if (discussion && discussion.status === 'running' && this.isCurrentRecord(discussion)) {
         discussion.status = job.state === 'done' ? 'done' : 'stopped';
         discussion.updatedAt = now();
         this.repo.putDiscussion(discussion);
@@ -624,7 +1079,7 @@ export class Engine {
 
   advanceDiscussion(discussionId, ok) {
     const discussion = this.repo.getDiscussion(discussionId);
-    if (!discussion || discussion.status !== 'running') return;
+    if (!discussion || discussion.status !== 'running' || !this.isCurrentRecord(discussion)) return;
     if (!ok) {
       discussion.status = 'stopped';
       discussion.stopReason = 'member-error';
@@ -632,6 +1087,7 @@ export class Engine {
       this.repo.putDiscussion(discussion);
       this.bus.emit(discussion.groupId, { type: 'discussion.updated', discussion });
       this.systemMessage(discussion.groupId, `讨论「${discussion.topic}」因成员执行失败而停止。`);
+      this.settleDiscussionWaiters(discussionId);
       return;
     }
     discussion.currentIndex = (discussion.currentIndex ?? 0) + 1;
@@ -647,14 +1103,17 @@ export class Engine {
   }
 
   /** Enqueue one task delivery turn for the task's assignee. */
-  enqueueTaskTurn({ taskId, phase }) {
+  enqueueTaskTurn({ taskId, phase, expectedConversationId }) {
     const task = this.repo.getTask(taskId);
     if (!task) throw Object.assign(new Error('任务不存在'), { code: 'not-found' });
     const group = this.repo.getGroup(task.groupId);
     if (!group) throw Object.assign(new Error('任务所在群不存在'), { code: 'not-found' });
+    const conversationId = this.admitConversation(task.groupId, expectedConversationId);
+    this.assertCurrentTarget(task.groupId, task);
     const triggerSeq = this.repo.lastMessageOf(task.groupId)?.seq ?? 0;
     this.enqueueJob({
       groupId: task.groupId,
+      conversationId,
       membershipId: task.assigneeMembershipId,
       kind: phase === 'revision' ? 'task_revision' : 'task',
       triggerSeq,
@@ -679,10 +1138,13 @@ export class Engine {
 
   // ── M2: review / revision ───────────────────────────────────────────────
   enqueueJob(spec) {
+    const conversationId = this.admitConversation(spec.groupId, spec.conversationId ?? spec.expectedConversationId);
+    this.assertJobTargets(spec);
     const job = {
       jobId: newId('job'),
       state: 'queued',
       ...spec,
+      conversationId,
     };
     this.queue.push(job);
     this.pump(job.groupId);
@@ -697,14 +1159,17 @@ export class Engine {
     return bot?.name ?? message.author?.name ?? 'Bot';
   }
 
-  requestReview({ groupId, targetMessageId, reviewerMembershipId, instructions, taskId }) {
+  requestReview({ groupId, targetMessageId, reviewerMembershipId, instructions, taskId, expectedConversationId }) {
+    const conversationId = this.admitConversation(groupId, expectedConversationId);
     const target = this.repo.messages.get(targetMessageId);
     if (!target || target.groupId !== groupId) throw Object.assign(new Error('待评审消息不存在'), { code: 'not-found' });
+    this.assertCurrentTarget(groupId, target);
+    if (taskId) this.assertCurrentTarget(groupId, this.repo.getTask?.(taskId));
     const member = this.repo.getMember(reviewerMembershipId);
     if (!member || member.groupId !== groupId) throw Object.assign(new Error('评审者不在群里'), { code: 'invalid-input' });
     const reviewer = this.repo.getBot(member.botId);
     if (!reviewer) throw Object.assign(new Error('评审者 Bot 不存在'), { code: 'not-found' });
-    this.assertQuota(groupId, 1);
+    this.assertQuota(groupId);
     const requestMessage = this.createMessage({
       groupId,
       author: { type: 'system', name: '系统' },
@@ -718,6 +1183,7 @@ export class Engine {
     this.bus.emit(groupId, { type: 'message.added', message: requestMessage });
     this.enqueueJob({
       groupId,
+      conversationId,
       membershipId: reviewerMembershipId,
       kind: 'review',
       triggerSeq: requestMessage.seq,
@@ -730,12 +1196,15 @@ export class Engine {
     return { requestMessage, reviewer: reviewer.name };
   }
 
-  requestRevision({ groupId, reviewMessageId }) {
+  requestRevision({ groupId, reviewMessageId, expectedConversationId }) {
+    const conversationId = this.admitConversation(groupId, expectedConversationId);
     const review = this.repo.messages.get(reviewMessageId);
     if (!review || review.groupId !== groupId) throw Object.assign(new Error('评审消息不存在'), { code: 'not-found' });
+    this.assertCurrentTarget(groupId, review);
     const targetId = review.meta && review.meta.reviewOf;
     const target = targetId ? this.repo.messages.get(targetId) : undefined;
     if (!target) throw Object.assign(new Error('找不到被评审的原消息'), { code: 'not-found' });
+    this.assertCurrentTarget(groupId, target);
     const membershipId = target.author && target.author.membershipId;
     if (!membershipId || target.author.type !== 'bot') {
       throw Object.assign(new Error('只有 Bot 的消息可以要求作者修改'), { code: 'invalid-input' });
@@ -743,7 +1212,7 @@ export class Engine {
     const member = this.repo.getMember(membershipId);
     const bot = member ? this.repo.getBot(member.botId) : undefined;
     if (!member || !bot) throw Object.assign(new Error('原消息作者已不在群里'), { code: 'not-found' });
-    this.assertQuota(groupId, 1);
+    this.assertQuota(groupId);
     const reviewerName = this.authorNameOf(review);
     const requestMessage = this.createMessage({
       groupId,
@@ -758,6 +1227,7 @@ export class Engine {
     this.bus.emit(groupId, { type: 'message.added', message: requestMessage });
     this.enqueueJob({
       groupId,
+      conversationId,
       membershipId,
       kind: 'revision',
       triggerSeq: requestMessage.seq,
@@ -769,13 +1239,15 @@ export class Engine {
     return { requestMessage, author: bot.name };
   }
 
-  retryMessage(messageId) {
+  retryMessage(messageId, expectedConversationId) {
     const message = this.repo.messages.get(messageId);
     if (!message) throw Object.assign(new Error('消息不存在'), { code: 'not-found' });
+    const conversationId = this.admitConversation(message.groupId, expectedConversationId);
+    this.assertCurrentTarget(message.groupId, message);
     if (message.author?.type !== 'bot') throw Object.assign(new Error('只能重试 Bot 的回复'), { code: 'invalid-input' });
     const member = this.repo.getMember(message.author.membershipId);
     if (!member) throw Object.assign(new Error('该 Bot 已不在群里'), { code: 'not-found' });
-    this.assertQuota(message.groupId, 1);
+    this.assertQuota(message.groupId);
     const meta = message.meta || {};
     if (message.kind === 'discussion') {
       throw Object.assign(new Error('讨论消息不支持单条重试，请重新发起讨论'), { code: 'invalid-input' });
@@ -783,6 +1255,7 @@ export class Engine {
     if (message.kind === 'review' && meta.reviewOf) {
       return this.enqueueJob({
         groupId: message.groupId,
+        conversationId,
         membershipId: member.membershipId,
         kind: 'review',
         triggerSeq: message.seq,
@@ -796,6 +1269,7 @@ export class Engine {
     if (message.kind === 'revision' && meta.reviewOf) {
       return this.enqueueJob({
         groupId: message.groupId,
+        conversationId,
         membershipId: member.membershipId,
         kind: 'revision',
         triggerSeq: message.seq,
@@ -807,6 +1281,7 @@ export class Engine {
     }
     return this.enqueueJob({
       groupId: message.groupId,
+      conversationId,
       membershipId: member.membershipId,
       kind: 'chat',
       triggerSeq: message.seq,
@@ -817,61 +1292,31 @@ export class Engine {
   }
 
   // ── M2: multi-round discussion ──────────────────────────────────────────
-  async startDiscussion({ groupId, topic, membershipIds, rounds, summarize }) {
-    const group = this.repo.getGroup(groupId);
-    if (!group) throw Object.assign(new Error('群不存在'), { code: 'not-found' });
-    if (this.repo.activeDiscussionOf(groupId)) {
-      throw Object.assign(new Error('该群已有进行中的讨论，请先停止或等待结束'), { code: 'conflict' });
-    }
-    const members = [];
-    for (const membershipId of membershipIds) {
-      const member = this.repo.getMember(membershipId);
-      if (member && member.groupId === groupId && member.enabled !== false && this.repo.getBot(member.botId)) {
-        members.push(member.membershipId);
-      }
-    }
-    if (members.length === 0) throw Object.assign(new Error('请选择至少一个讨论成员'), { code: 'invalid-input' });
-    this.assertQuota(groupId, members.length);
-    const discussion = {
-      discussionId: newId('dsc'),
-      groupId,
-      topic,
-      memberIds: members,
-      rounds,
-      currentRound: 1,
-      currentIndex: 0,
-      currentSpeaker: members[0],
-      summarize: summarize === true,
-      summaryStarted: false,
-      status: 'running',
-      startSeq: 0,
-      startMessageId: null,
-      createdAt: now(),
-      updatedAt: now(),
-    };
-    const startMessage = this.createMessage({
-      groupId,
-      author: { type: 'system', name: '系统' },
-      text: `开始讨论：${topic}（${members.length} 位成员，共 ${rounds} 轮${summarize ? '，结束生成总结' : ''}）`,
-      kind: 'discussion',
-      status: 'done',
-      meta: { discussionId: discussion.discussionId, event: 'start' },
-    });
-    discussion.startSeq = startMessage.seq;
-    discussion.startMessageId = startMessage.messageId;
-    await this.repo.putDiscussion(discussion);
-    this.bus.emit(groupId, { type: 'message.added', message: startMessage });
-    this.bus.emit(groupId, { type: 'discussion.updated', discussion });
-    this.scheduleDiscussion(discussion.discussionId);
-    return discussion;
+  async startDiscussion(input) {
+    return this.discussionRunner.start(input);
+  }
+
+  async controlDiscussion(input) {
+    const discussion = this.repo.getDiscussion(input.discussionId);
+    if (!discussion) throw Object.assign(new Error('讨论不存在'), { code: 'not-found' });
+    if (discussion.protocolVersion === 2) return this.discussionRunner.control(input);
+    this.admitConversation(discussion.groupId, input.expectedConversationId);
+    this.assertCurrentTarget(discussion.groupId, discussion);
+    if (input.operation !== 'stop') throw Object.assign(new Error('旧版讨论只支持停止，请新建讨论以使用步骤控制'), { code: 'invalid-input' });
+    await this.stopDiscussion(input.discussionId);
+    return this.repo.getDiscussion(input.discussionId);
   }
 
   scheduleDiscussion(discussionId) {
     if (this.disposed) return;
     const discussion = this.repo.getDiscussion(discussionId);
-    if (!discussion || discussion.status !== 'running') return;
+    if (discussion?.protocolVersion === 2) {
+      if (!this.isCurrentRecord(discussion) || !['running', 'finalizing'].includes(discussion.status)) return;
+      return this.discussionRunner.schedule(discussionId);
+    }
+    if (!discussion || discussion.status !== 'running' || !this.isCurrentRecord(discussion)) return;
     try {
-      this.assertQuota(discussion.groupId, 1);
+      this.assertQuota(discussion.groupId);
     } catch (error) {
       this.stopDiscussionInternal(discussion, 'quota', String(error && error.message ? error.message : error));
       return;
@@ -884,6 +1329,7 @@ export class Engine {
         this.bus.emit(discussion.groupId, { type: 'discussion.updated', discussion });
         this.enqueueJob({
           groupId: discussion.groupId,
+          conversationId: conversationIdOf(this.repo, discussion),
           membershipId: discussion.memberIds[0],
           kind: 'summary',
           discussionId,
@@ -922,6 +1368,7 @@ export class Engine {
     this.bus.emit(discussion.groupId, { type: 'discussion.updated', discussion });
     this.enqueueJob({
       groupId: discussion.groupId,
+      conversationId: conversationIdOf(this.repo, discussion),
       membershipId,
       kind: 'discussion',
       discussionId,
@@ -935,23 +1382,30 @@ export class Engine {
   }
 
   stopDiscussionInternal(discussion, reason, message) {
-    if (!discussion || discussion.status !== 'running') return;
+    if (!discussion || discussion.status !== 'running' || !this.isCurrentRecord(discussion)) return;
     discussion.status = 'stopped';
     discussion.stopReason = reason;
     discussion.currentSpeaker = null;
     this.repo.putDiscussion(discussion);
     this.bus.emit(discussion.groupId, { type: 'discussion.updated', discussion });
     this.systemMessage(discussion.groupId, '讨论「' + discussion.topic + '」已停止：' + message);
+    this.queue = this.queue.filter((queued) => queued.discussionId !== discussion.discussionId);
     for (const job of [...this.running.values()]) {
       if (job.discussionId === discussion.discussionId && !job.finished) this.abortJob(job, 'user');
     }
-    this.queue = this.queue.filter((queued) => queued.discussionId !== discussion.discussionId);
     this.settleDiscussionWaiters(discussion.discussionId);
   }
 
   stopDiscussion(discussionId) {
     const discussion = this.repo.getDiscussion(discussionId);
     if (!discussion) throw Object.assign(new Error('讨论不存在'), { code: 'not-found' });
+    this.admitConversation(discussion.groupId);
+    this.assertCurrentTarget(discussion.groupId, discussion);
+    if (discussion.protocolVersion === 2) {
+      const stopped = isDiscussionActive(discussion);
+      return this.controlDiscussion({ discussionId, operation: 'stop', expectedConversationId: discussion.conversationId })
+        .then(() => ({ stopped }));
+    }
     if (discussion.status !== 'running') return { stopped: false };
     discussion.status = 'stopped';
     discussion.stopReason = 'user';
@@ -959,9 +1413,6 @@ export class Engine {
     this.repo.putDiscussion(discussion);
     this.bus.emit(discussion.groupId, { type: 'discussion.updated', discussion });
     this.systemMessage(discussion.groupId, `讨论「${discussion.topic}」已停止。`);
-    for (const job of [...this.running.values()]) {
-      if (job.discussionId === discussionId && !job.finished) this.abortJob(job, 'user');
-    }
     const keep = [];
     for (const queued of this.queue) {
       if (queued.discussionId === discussionId) {
@@ -975,6 +1426,9 @@ export class Engine {
       }
     }
     this.queue = keep;
+    for (const job of [...this.running.values()]) {
+      if (job.discussionId === discussionId && !job.finished) this.abortJob(job, 'user');
+    }
     this.settleDiscussionWaiters(discussionId);
     return { stopped: true };
   }
@@ -982,6 +1436,8 @@ export class Engine {
   discussionTranscript(discussion) {
     return this.repo.messagesOf(discussion.groupId).filter(
       (message) =>
+        this.isCurrentRecord(message, discussion.groupId) &&
+        conversationIdOf(this.repo, message) === conversationIdOf(this.repo, discussion) &&
         message.meta &&
         message.meta.discussionId === discussion.discussionId &&
         message.author &&
@@ -1003,7 +1459,7 @@ export class Engine {
 
   whenDiscussionSettled(discussionId, timeoutMs = 600000) {
     const discussion = this.repo.getDiscussion(discussionId);
-    if (!discussion || discussion.status !== 'running') return Promise.resolve(true);
+    if (!discussion || !isDiscussionActive(discussion) || discussion.status === 'paused') return Promise.resolve(true);
     return new Promise((resolve) => {
       const entry = { resolve, timer: setTimeout(() => resolve(false), timeoutMs) };
       const list = this.discussionWaiters.get(discussionId) ?? [];
@@ -1013,6 +1469,9 @@ export class Engine {
   }
 
   buildPrompt(job, bot, context) {
+    this.assertJobCurrent(job);
+    this.assertJobTargets(job);
+    context = context.filter(message => this.isCurrentRecord(message, job.groupId) && message.seq > conversationFloor(this.repo, job.groupId));
     if (job.promptText) return job.promptText;
     if (job.kind === 'task') {
       const task = job.meta && job.meta.taskId ? this.repo.getTask(job.meta.taskId) : undefined;
@@ -1122,62 +1581,53 @@ export class Engine {
   }
 
   stopMember(membershipId) {
-    let stopped = 0;
     const job = this.running.get(membershipId);
-    if (job && !job.finished) {
-      this.abortJob(job, 'user');
-      stopped += 1;
-    }
-    const keep = [];
-    for (const queued of this.queue) {
-      if (queued.membershipId === membershipId) {
-        stopped += 1;
-        this.bus.emit(queued.groupId, {
-          type: 'member.status',
-          membershipId: queued.membershipId,
-          status: 'idle',
-        });
-      } else {
-        keep.push(queued);
-      }
+    const affected = new Set([job?.groupId, ...this.queue.filter(item => item.membershipId === membershipId).map(item => item.groupId)].filter(Boolean));
+    for (const groupId of affected) this.pumpBlocks.add(groupId);
+    let stopped = 0;
+    const discussions = new Set([job?.discussionId, ...this.queue.filter(item => item.membershipId === membershipId).map(item => item.discussionId)].filter(Boolean));
+    for (const id of discussions) {
+      const discussion = this.repo.getDiscussion(id);
+      if (discussion?.protocolVersion === 2) void this.discussionRunner.interrupt(id).catch(error => this.discussionRunner.failed(id, error));
     }
-    this.queue = keep;
+    // Drain first: abortJob -> finishJob may synchronously pump another job.
+    this.queue = this.queue.filter(queued => {
+      if (queued.membershipId !== membershipId) return true;
+      stopped += 1;
+      this.bus.emit(queued.groupId, { type: 'member.status', membershipId, status: 'idle' });
+      return false;
+    });
+    if (job && !job.finished) { this.abortJob(job, 'user'); stopped += 1; }
+    for (const groupId of affected) { this.pumpBlocks.delete(groupId); this.pump(groupId); this.checkIdle(groupId); }
     return { stopped };
   }
 
   stopGroup(groupId) {
+    this.pumpBlocks.add(groupId);
     let stopped = 0;
-    // Stop running discussions first so their jobs do not advance afterwards.
+    // Close all discussion schedulers before clearing queues or cancelling jobs.
     for (const discussion of this.repo.discussionsOf(groupId)) {
-      if (discussion.status === 'running') {
-        discussion.status = 'stopped';
-        discussion.stopReason = 'user';
-        discussion.currentSpeaker = null;
+      if (!isDiscussionActive(discussion) || !this.isCurrentRecord(discussion, groupId)) continue;
+      if (discussion.protocolVersion === 2) {
+        void this.discussionRunner.interrupt(discussion.discussionId, { stop: true }).catch(error => this.discussionRunner.failed(discussion.discussionId, error));
+      } else {
+        discussion.status = 'stopped'; discussion.stopReason = 'user'; discussion.currentSpeaker = null;
         this.repo.putDiscussion(discussion);
         this.bus.emit(groupId, { type: 'discussion.updated', discussion });
         this.settleDiscussionWaiters(discussion.discussionId);
-        this.systemMessage(groupId, `讨论「${discussion.topic}」已停止。`);
       }
     }
+    this.queue = this.queue.filter(job => {
+      if (job.groupId !== groupId) return true;
+      stopped += 1;
+      this.bus.emit(groupId, { type: 'member.status', membershipId: job.membershipId, status: 'idle' });
+      return false;
+    });
     for (const job of [...this.running.values()]) {
       if (job.groupId !== groupId || job.finished) continue;
-      this.abortJob(job, 'user');
-      stopped += 1;
+      this.abortJob(job, 'user'); stopped += 1;
     }
-    const keep = [];
-    for (const job of this.queue) {
-      if (job.groupId === groupId) {
-        stopped += 1;
-        this.bus.emit(groupId, {
-          type: 'member.status',
-          membershipId: job.membershipId,
-          status: 'idle',
-        });
-      } else {
-        keep.push(job);
-      }
-    }
-    this.queue = keep;
+    this.pumpBlocks.delete(groupId);
     this.checkIdle(groupId);
     return { stopped };
   }
@@ -1203,6 +1653,10 @@ export class Engine {
     });
   }
 
+  hasPendingWork(groupId) {
+    return [...this.pendingWork].some((operation) => operation.groupId === groupId);
+  }
+
   isRunning(groupId) {
     return this.runningCount(groupId) > 0 || this.queuedCount(groupId) > 0;
   }
@@ -1212,6 +1666,7 @@ export class Engine {
     try {
       this.offSession?.();
       this.offClaim?.();
+      this.offGoal?.();
     } catch {
       /* noop */
     }