@downcity/agent 1.1.400 → 1.1.408

package/src/executor/core-engine/CoreEngineRunner.ts

@@ -34,6 +34,7 @@ import {
   type ModelStepResult,
   type ModelStepToolCall,
 } from "@executor/model/ModelStepRunner.js";
+import { is_retryable_empty_model_stream_failure } from "@executor/model/ModelStreamFailure.js";
 import { CoreEngineMessageState } from "@executor/core-engine/CoreEngineMessageState.js";
 import {
   deep_compact_model_messages,
@@ -58,6 +59,10 @@ const TURN_STOPPED_MESSAGE = "Turn stopped";
 
 /** Provider context-length error 在当前 step 内最多压缩重试三次。 */
 const MAX_CONTEXT_ERROR_COMPACTION_RETRIES = 3;
+/** 无任何可见输出时，临时 Provider 流错误的最大自动重试次数。 */
+const MAX_EMPTY_STREAM_RETRIES = 2;
+/** 无输出流错误的重试退避，避免立即重复冲击同一 Provider。 */
+const EMPTY_STREAM_RETRY_DELAYS_MS = [300, 1_000] as const;
 
 interface CoreEngineRunnerOptions {
   /** 当前 Session 稳定标识。 */
@@ -181,6 +186,7 @@ export class CoreEngineRunner {
 
       let incomplete_response_recovery_count = 0;
       let context_error_compaction_retries = 0;
+      let empty_stream_retry_count = 0;
       let compact_pending = false;
       let compact_validation_pending = Boolean(
         persisted_compaction_summary_id &&
@@ -293,6 +299,24 @@ export class CoreEngineRunner {
           ) {
             await input.turn_context.output.assistant.abort_step();
           }
+          if (
+            is_retryable_empty_model_stream_failure(error) &&
+            empty_stream_retry_count < MAX_EMPTY_STREAM_RETRIES
+          ) {
+            empty_stream_retry_count += 1;
+            await this.logger.log("warn", "[agent] model_stream.retry", {
+              session_id,
+              retry_count: empty_stream_retry_count,
+              error_code: error.code,
+              error: error.message,
+              provider_request_id: error.provider_request_id ?? null,
+            });
+            await wait_for_stream_retry(
+              EMPTY_STREAM_RETRY_DELAYS_MS[empty_stream_retry_count - 1] ?? 1_000,
+              input.turn_context.lifecycle.abort_signal,
+            );
+            continue;
+          }
           const compact_error = this.should_compact_on_error(error)
             ? error
             : last_observed_stream_error;
@@ -328,6 +352,7 @@ export class CoreEngineRunner {
         }
 
         context_error_compaction_retries = 0;
+        empty_stream_retry_count = 0;
         const last_step = executed_steps[executed_steps.length - 1];
         if (!last_step) break;
 
@@ -533,6 +558,25 @@ export class CoreEngineRunner {
   }
 }
 
+/** 等待下一次模型流重试，并在 Turn 停止时立即结束等待。 */
+async function wait_for_stream_retry(
+  delay_ms: number,
+  abort_signal: AbortSignal,
+): Promise<void> {
+  if (abort_signal.aborted) throw abort_signal.reason;
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      abort_signal.removeEventListener("abort", on_abort);
+      resolve();
+    }, delay_ms);
+    const on_abort = (): void => {
+      clearTimeout(timer);
+      reject(abort_signal.reason);
+    };
+    abort_signal.addEventListener("abort", on_abort, { once: true });
+  });
+}
+
 /** 在工具执行前接入 Session canonical Interaction 生命周期。 */
 async function resolve_tool_approval(input: {
   call: ModelStepToolCall;

package/src/executor/model/ModelGenerate.ts

@@ -51,7 +51,9 @@ export async function generate_model(
       tools.set(event.content_id, { tool_call_id: event.tool_call_id, tool_name: event.tool_name });
     } else if (event.type === "tool_call_finish") {
       const tool = tools.get(event.content_id);
-      if (tool) tool_calls.push({ type: "tool_call", ...tool, input: event.input });
+      if (tool && !event.input_error) {
+        tool_calls.push({ type: "tool_call", ...tool, input: event.input });
+      }
     } else if (event.type === "model_usage") usage = event.usage;
     else if (event.type === "model_finish") finish_reason = event.finish_reason;
   }

package/src/executor/model/ModelStepRunner.ts

@@ -26,6 +26,7 @@ import type {
   SessionAssistantMessagePart,
   SessionAssistantToolPart,
 } from "@/types/session/SessionMessage.js";
+import { ModelStreamFailure } from "@/executor/model/ModelStreamFailure.js";
 
 /** 单个工具调用的执行事实。 */
 export interface ModelStepToolCall {
@@ -35,6 +36,8 @@ export interface ModelStepToolCall {
   tool_name: string;
   /** 已解析工具输入。 */
   input: ModelJsonValue;
+  /** 模型生成的工具输入无法解析时记录的错误。 */
+  input_error?: string;
 }
 
 /** 单个工具结果的执行事实。 */
@@ -162,7 +165,14 @@ class StepEventCollector {
 
   /** 消费单个标准模型事件。 */
   accept(event: ModelStreamEvent): void {
-    if (event.type === "model_error") throw new Error(event.error.message);
+    if (event.type === "model_error") {
+      throw new ModelStreamFailure(
+        event.error,
+        this.text.length > 0 ||
+          this.reasoning_by_id.size > 0 ||
+          this.tool_by_content_id.size > 0,
+      );
+    }
     if (event.type === "text_start") {
       this.text_by_id.set(event.content_id, "");
     } else if (event.type === "text_delta") {
@@ -213,6 +223,7 @@ class StepEventCollector {
       const tool = this.tool_by_content_id.get(event.content_id);
       if (tool) {
         tool.input = event.input;
+        if (event.input_error) tool.input_error = event.input_error;
         this.model_content.push({
           type: "tool_call",
           tool_call_id: tool.tool_call_id,
@@ -265,6 +276,14 @@ async function execute_tools(
 ): Promise<ModelStepToolResult[]> {
   const results: ModelStepToolResult[] = [];
   for (const call of calls) {
+    if (call.input_error) {
+      results.push({
+        ...call,
+        success: false,
+        output: { error: call.input_error },
+      });
+      continue;
+    }
     const tool = input.tools[call.tool_name];
     if (!tool || typeof tool.execute !== "function") {
       results.push({
@@ -292,7 +311,11 @@ async function execute_tools(
         abort_signal: input.abort_signal,
       };
       const output = await tool.execute(call.input, options);
-      results.push({ ...call, success: true, output });
+      results.push({
+        ...call,
+        success: !is_structured_tool_failure(output),
+        output,
+      });
     } catch (error) {
       results.push({
         ...call,
@@ -304,6 +327,12 @@ async function execute_tools(
   return results;
 }
 
+/** 识别 Tool 正常返回的结构化失败，避免把业务失败标记成执行成功。 */
+function is_structured_tool_failure(output: unknown): boolean {
+  if (!output || typeof output !== "object" || Array.isArray(output)) return false;
+  return (output as { success?: unknown }).success === false;
+}
+
 /** 把 System 快照转换成标准 ModelMessage。 */
 function convert_system_messages(messages: SessionSystemMessage[]): ModelMessage[] {
   return messages.map((message) => ({
@@ -373,9 +402,11 @@ function append_tool_results(
 
 /** 从结构化工具失败结果中提取可展示错误文本。 */
 function read_tool_error(value: unknown): string {
-  if (value && typeof value === "object" && "error" in value) {
-    const error = (value as { error?: unknown }).error;
-    if (typeof error === "string" && error.trim()) return error;
+  if (value && typeof value === "object") {
+    const result = value as { error?: unknown; message?: unknown; output?: unknown };
+    for (const candidate of [result.error, result.message, result.output]) {
+      if (typeof candidate === "string" && candidate.trim()) return candidate;
+    }
   }
   return "Tool execution failed";
 }

package/src/executor/model/ModelStreamFailure.ts

@@ -0,0 +1,44 @@
+/**
+ * 模型流失败对象。
+ *
+ * 该对象完整保留 Model Protocol 的错误分类，避免 Executor 只能依赖错误文本
+ * 判断是否可以重试。它只描述一次模型流失败，不负责决定恢复策略。
+ */
+
+import type { ModelError } from "@downcity/type";
+
+/** 一次具有稳定协议语义的模型流失败。 */
+export class ModelStreamFailure extends Error {
+  /** Downcity 稳定模型错误码。 */
+  readonly code: ModelError["code"];
+
+  /** 当前模型调用是否可以安全重试。 */
+  readonly retryable: boolean;
+
+  /** 失败前是否已经向用户发布正文或工具输入。 */
+  readonly has_partial_output: boolean;
+
+  /** Provider 返回的可观测请求标识。 */
+  readonly provider_request_id?: string;
+
+  constructor(error: ModelError, has_partial_output: boolean) {
+    super(error.message);
+    this.name = "ModelStreamFailure";
+    this.code = error.code;
+    this.retryable = error.retryable;
+    this.has_partial_output = has_partial_output;
+    if (error.provider_request_id) {
+      this.provider_request_id = error.provider_request_id;
+    }
+  }
+}
+
+/** 判断未知错误是否为可安全自动重试的无输出模型流失败。 */
+export function is_retryable_empty_model_stream_failure(
+  error: unknown,
+): error is ModelStreamFailure {
+  return error instanceof ModelStreamFailure &&
+    error.retryable &&
+    !error.has_partial_output &&
+    error.code !== "cancelled";
+}

package/src/group/GroupDispatchSession.ts

@@ -0,0 +1,175 @@
+/**
+ * GroupDispatchSession：单个 GroupSession 独享的持久化调度执行边界。
+ *
+ * 本对象统一拥有调度队列、当前模型取消信号和调度 Turn 状态。调度策略只负责决策，
+ * 不再自行拥有跨 GroupSession 的运行状态或停止语义。
+ */
+
+import { nanoid } from "nanoid";
+import type {
+  GroupDispatchSessionDataStore,
+  GroupDispatchSessionInput,
+  GroupDispatchSessionOptions,
+  GroupDispatchSessionResult,
+  GroupDispatchTurnRecord,
+} from "@/types/group/GroupDispatchSession.js";
+
+/** 主动停止 Dispatch Session 时使用的内部错误。 */
+export class GroupDispatchStoppedError extends Error {
+  constructor() {
+    super("Group dispatch stopped");
+    this.name = "GroupDispatchStoppedError";
+  }
+}
+
+/** GroupSession 私有的调度 Session。 */
+export class GroupDispatchSession {
+  private readonly dispatch_strategy: GroupDispatchSessionOptions["dispatch_strategy"];
+  private store?: GroupDispatchSessionDataStore;
+  private queue_tail: Promise<void> = Promise.resolve();
+  private active_abort_controller?: AbortController;
+  private stopping = false;
+  private disposed = false;
+
+  constructor(options: GroupDispatchSessionOptions) {
+    this.dispatch_strategy = options.dispatch_strategy;
+  }
+
+  /** 绑定持久化视图，并把进程中断留下的运行态明确收口为 stopped。 */
+  async initialize(store: GroupDispatchSessionDataStore): Promise<this> {
+    if (this.store && this.store !== store) {
+      throw new Error("GroupDispatchSession is already initialized with another Store");
+    }
+    if (this.store === store) return this;
+    this.store = store;
+    const interrupted_turns = (await store.list_turns()).filter((turn) => (
+      turn.status === "queued" || turn.status === "running"
+    ));
+    for (const turn of interrupted_turns) {
+      await store.append_turn({
+        ...turn,
+        status: "stopped",
+        error: "Group dispatch interrupted before recovery",
+        updated_at: Date.now(),
+      });
+    }
+    return this;
+  }
+
+  /** 按提交顺序执行一次调度，并在返回前持久化最终决定。 */
+  decide(input: GroupDispatchSessionInput): Promise<GroupDispatchSessionResult> {
+    this.assert_available();
+    const store = this.require_store();
+    const created_at = Date.now();
+    const queued_turn: GroupDispatchTurnRecord = {
+      dispatch_id: `group-dispatch-${nanoid(12)}`,
+      trigger: input.trigger,
+      message_id: input.message.id,
+      pending_message_ids: input.pending_messages.map((message) => message.id),
+      status: "queued",
+      created_at,
+      updated_at: created_at,
+    };
+    const persist_queued = store.append_turn(queued_turn);
+    const operation = this.queue_tail.then(async () => {
+      await persist_queued;
+      return await this.execute_turn(input, queued_turn);
+    });
+    this.queue_tail = operation.then(() => undefined, () => undefined);
+    return operation;
+  }
+
+  /** 中断当前模型调用，并让尚未开始的调度 Turn 按队列顺序收口。 */
+  async stop(): Promise<void> {
+    if (this.disposed || this.stopping) return;
+    this.stopping = true;
+    this.active_abort_controller?.abort(new GroupDispatchStoppedError());
+    await this.queue_tail;
+    this.active_abort_controller = undefined;
+    this.stopping = false;
+  }
+
+  /** 永久释放当前 Dispatch Session。 */
+  async dispose(): Promise<void> {
+    if (this.disposed) return;
+    await this.stop();
+    this.disposed = true;
+    this.store = undefined;
+  }
+
+  /** 执行队首调度 Turn，确保成功、失败和停止都形成持久化终态。 */
+  private async execute_turn(
+    input: GroupDispatchSessionInput,
+    queued_turn: GroupDispatchTurnRecord,
+  ): Promise<GroupDispatchSessionResult> {
+    const store = this.require_store();
+    if (this.stopping || this.disposed) {
+      await this.persist_terminal_turn(queued_turn, "stopped", "Group dispatch stopped");
+      throw new GroupDispatchStoppedError();
+    }
+    const abort_controller = new AbortController();
+    this.active_abort_controller = abort_controller;
+    await store.append_turn({
+      ...queued_turn,
+      status: "running",
+      updated_at: Date.now(),
+    });
+    try {
+      const decision = await this.dispatch_strategy.decide_dispatch({
+        ...input,
+        abort_signal: abort_controller.signal,
+      });
+      if (this.stopping || this.disposed || abort_controller.signal.aborted) {
+        throw new GroupDispatchStoppedError();
+      }
+      await store.append_turn({
+        ...queued_turn,
+        status: "completed",
+        decision,
+        updated_at: Date.now(),
+      });
+      return { dispatch_id: queued_turn.dispatch_id, decision };
+    } catch (error) {
+      if (
+        error instanceof GroupDispatchStoppedError ||
+        this.stopping ||
+        this.disposed ||
+        abort_controller.signal.aborted
+      ) {
+        await this.persist_terminal_turn(queued_turn, "stopped", "Group dispatch stopped");
+        throw new GroupDispatchStoppedError();
+      }
+      const detail = error instanceof Error ? error.message : String(error);
+      await this.persist_terminal_turn(queued_turn, "failed", detail);
+      throw error;
+    } finally {
+      if (this.active_abort_controller === abort_controller) {
+        this.active_abort_controller = undefined;
+      }
+    }
+  }
+
+  /** 提交没有 decision 的失败或停止终态。 */
+  private async persist_terminal_turn(
+    turn: GroupDispatchTurnRecord,
+    status: "failed" | "stopped",
+    error: string,
+  ): Promise<void> {
+    await this.require_store().append_turn({
+      ...turn,
+      status,
+      error,
+      updated_at: Date.now(),
+    });
+  }
+
+  private require_store(): GroupDispatchSessionDataStore {
+    if (!this.store) throw new Error("GroupDispatchSession is not initialized");
+    return this.store;
+  }
+
+  private assert_available(): void {
+    if (this.disposed) throw new Error("GroupDispatchSession is disposed");
+    if (this.stopping) throw new Error("GroupDispatchSession is stopping");
+  }
+}

package/src/group/GroupSession.ts

@@ -17,6 +17,11 @@ import type { DispatchDecision, DispatchNode, DispatchStrategy } from "@/types/g
 import type { WorkspaceBase } from "@downcity/workspace";
 import type { GroupSessionDataStore } from "@/types/group/GroupSessionStore.js";
 import type { RespondSessionInteractionInput } from "@/types/session/SessionInteraction.js";
+import {
+  GroupDispatchSession,
+  GroupDispatchStoppedError,
+} from "@/group/GroupDispatchSession.js";
+import type { GroupDispatchSessionResult } from "@/types/group/GroupDispatchSession.js";
 
 const max_auto_dispatch_count = 32;
 
@@ -47,7 +52,7 @@ export class GroupSession implements GroupSessionContract {
   private readonly group_name: string;
   private readonly instruction?: string;
   private readonly members: readonly Agent[];
-  private readonly dispatch_strategy: DispatchStrategy;
+  private readonly dispatch_session: GroupDispatchSession;
   private readonly workspace?: WorkspaceBase;
   private readonly messages_by_id: GroupMessage[] = [];
   private readonly subscribers = new Set<GroupEventSubscriber>();
@@ -77,7 +82,9 @@ export class GroupSession implements GroupSessionContract {
     this.group_name = options.group_name;
     this.instruction = options.instruction;
     this.members = options.members;
-    this.dispatch_strategy = options.dispatch_strategy;
+    this.dispatch_session = new GroupDispatchSession({
+      dispatch_strategy: options.dispatch_strategy,
+    });
     this.workspace = options.workspace;
     this.workspace_id = options.workspace?.id;
   }
@@ -90,6 +97,7 @@ export class GroupSession implements GroupSessionContract {
     if (this.store === store) return this;
     this.store = store;
     await store.initialize();
+    await this.dispatch_session.initialize(store.dispatch_session);
     const metadata = await store.read_metadata();
     if (metadata.group_id !== this.group_id) {
       throw new Error(`GroupSession "${this.id}" belongs to another Group`);
@@ -112,7 +120,8 @@ export class GroupSession implements GroupSessionContract {
         turn_id: checkpoint.turn_id,
         root_message_id: checkpoint.root_message_id,
         context_message_ids: checkpoint.context_message_ids,
-        auto_pending: true,
+        dispatch_stage: checkpoint.dispatch_stage,
+        auto_pending: checkpoint.dispatch_stage === "auto",
         stopped: false,
         recovered: true,
       });
@@ -151,7 +160,12 @@ export class GroupSession implements GroupSessionContract {
     if (Object.keys(valid_member_session_ids).length !== Object.keys(member_session_ids).length) {
       await store.update_metadata({ member_session_ids: valid_member_session_ids });
     }
-    if (this.group_turns_by_id.size > 0 || this.auto_frontier_messages.length > 0) {
+    for (const group_turn of this.group_turns_by_id.values()) {
+      if (group_turn.dispatch_stage !== "user") continue;
+      const message = this.messages_by_id.find((item) => item.id === group_turn.root_message_id);
+      if (message) this.start_user_dispatch(message, group_turn);
+    }
+    if ([...this.group_turns_by_id.values()].some((turn) => turn.auto_pending) || this.auto_frontier_messages.length > 0) {
       this.request_auto_dispatch();
     }
     return this;
@@ -169,19 +183,14 @@ export class GroupSession implements GroupSessionContract {
       turn_id,
       root_message_id: message.id,
       context_message_ids: [...context_message_ids, message.id],
+      dispatch_stage: "user",
       auto_pending: false,
       stopped: false,
     };
     this.group_turns_by_id.set(turn_id, group_turn);
     await this.persist_dispatch_checkpoint();
     this.publish_status(turn_id, "dispatching", { message_id: message.id });
-    const dispatch = this.run_user_dispatch(message, turn_id);
-    group_turn.user_dispatch = dispatch;
-    this.pending_deliveries.add(dispatch);
-    void dispatch.finally(() => {
-      this.pending_deliveries.delete(dispatch);
-      if (group_turn.auto_pending) this.request_auto_dispatch();
-    });
+    this.start_user_dispatch(message, group_turn);
     return { turn_id, success: true, message_count: this.messages_by_id.length };
   }
 
@@ -217,7 +226,10 @@ export class GroupSession implements GroupSessionContract {
     if (this.disposed) return;
     this.stop_requested = true;
     this.publish_status(undefined, "stopped");
-    await Promise.allSettled([...this.member_sessions.values()].map((session) => session.stop()));
+    await Promise.allSettled([
+      this.dispatch_session.stop(),
+      ...[...this.member_sessions.values()].map((session) => session.stop()),
+    ]);
     await Promise.allSettled([...this.pending_deliveries]);
     if (this.auto_dispatch_promise) await this.auto_dispatch_promise;
     this.auto_dispatch_requested = false;
@@ -232,6 +244,7 @@ export class GroupSession implements GroupSessionContract {
   async dispose(): Promise<void> {
     if (this.disposed) return;
     await this.stop();
+    await this.dispatch_session.dispose();
     this.disposed = true;
     this.subscribers.clear();
     for (const unsubscribe of this.member_session_unsubscribes.values()) unsubscribe();
@@ -250,28 +263,53 @@ export class GroupSession implements GroupSessionContract {
     const group_turn = this.group_turns_by_id.get(turn_id);
     if (!group_turn) return;
     try {
-      const decision = await this.decide_dispatch("user", message, [message]);
+      const dispatch = await this.decide_dispatch("user", message, [message]);
       const context_messages = group_turn.context_message_ids
         .map((message_id) => this.messages_by_id.find((item) => item.id === message_id))
         .filter((item): item is GroupMessage => Boolean(item));
-      await this.run_dispatch_plan(decision, message, context_messages, turn_id);
+      await this.run_dispatch_plan(
+        dispatch.decision,
+        message,
+        context_messages,
+        turn_id,
+        dispatch.dispatch_id,
+      );
       if (this.stop_requested || this.disposed) {
         group_turn.stopped = true;
         this.group_turns_by_id.delete(turn_id);
         await this.persist_dispatch_checkpoint();
         return;
       }
-      group_turn.auto_pending = true;
+      if (dispatch.decision.terminal) {
+        this.group_turns_by_id.delete(turn_id);
+      } else {
+        group_turn.dispatch_stage = "auto";
+        group_turn.auto_pending = true;
+      }
       await this.persist_dispatch_checkpoint();
+      if (dispatch.decision.terminal) this.publish_status(turn_id, "idle");
     } catch (error) {
       group_turn.stopped = this.stop_requested;
-      await this.append_dispatch_failure(message, error);
+      if (!(error instanceof GroupDispatchStoppedError)) {
+        await this.append_dispatch_failure(message, error);
+      }
       this.group_turns_by_id.delete(turn_id);
       await this.persist_dispatch_checkpoint();
       this.publish_status(turn_id, this.stop_requested ? "stopped" : "failed");
     }
   }
 
+  /** 登记一次用户调度运行；新建和恢复必须经过同一个生命周期入口。 */
+  private start_user_dispatch(message: GroupMessage, group_turn: GroupTurnRuntime): void {
+    const dispatch = this.run_user_dispatch(message, group_turn.turn_id);
+    group_turn.user_dispatch = dispatch;
+    this.pending_deliveries.add(dispatch);
+    void dispatch.finally(() => {
+      this.pending_deliveries.delete(dispatch);
+      if (group_turn.auto_pending) this.request_auto_dispatch();
+    });
+  }
+
   /** GroupSession 唯一的自动调度循环，统一消费已完成成员产生的新消息。 */
   private request_auto_dispatch(): void {
     if (this.stop_requested || this.disposed) return;
@@ -299,8 +337,8 @@ export class GroupSession implements GroupSessionContract {
         const message = frontier_messages[frontier_messages.length - 1];
         this.publish_status(undefined, "dispatching", { message_id: message.id });
         try {
-          const decision = await this.decide_dispatch("auto", message, frontier_messages);
-          const dispatch_key = JSON.stringify(decision);
+          const dispatch = await this.decide_dispatch("auto", message, frontier_messages);
+          const dispatch_key = JSON.stringify(dispatch.decision);
           if (this.auto_dispatch_path_keys.has(dispatch_key)) {
             await this.append_message({ sender_type: "system", sender_id: "system", text: "Group auto dispatch detected a repeated path.", reply_to: message.id });
             frontier_messages = [];
@@ -311,8 +349,14 @@ export class GroupSession implements GroupSessionContract {
             continue;
           }
           this.auto_dispatch_path_keys.add(dispatch_key);
-          frontier_messages = await this.run_dispatch_plan(decision, message, this.messages_by_id, undefined, `group-dispatch-${nanoid(12)}`);
-          if (decision.terminal || frontier_messages.length === 0) {
+          frontier_messages = await this.run_dispatch_plan(
+            dispatch.decision,
+            message,
+            this.messages_by_id,
+            undefined,
+            dispatch.dispatch_id,
+          );
+          if (dispatch.decision.terminal || frontier_messages.length === 0) {
             frontier_messages = [];
             this.auto_frontier_messages = [];
             this.auto_dispatch_path_keys.clear();
@@ -324,6 +368,7 @@ export class GroupSession implements GroupSessionContract {
             this.auto_dispatch_requested = true;
           }
         } catch (error) {
+          if (error instanceof GroupDispatchStoppedError) return;
           await this.append_dispatch_failure(message, error);
           this.publish_status(undefined, "failed");
           frontier_messages = [];
@@ -361,16 +406,21 @@ export class GroupSession implements GroupSessionContract {
       batch_turns.forEach((group_turn) => { group_turn.auto_pending = false; });
       for (const message of candidate_messages) this.consumed_auto_message_ids.add(message.id);
       await this.persist_dispatch_checkpoint();
-      const dispatch_id = `group-dispatch-${nanoid(12)}`;
       dispatch_count = 0;
       const message = candidate_messages[candidate_messages.length - 1];
       this.publish_status(undefined, "dispatching", { message_id: message.id });
       try {
-        const decision = await this.decide_dispatch("auto", message, pending_messages);
+        const dispatch = await this.decide_dispatch("auto", message, pending_messages);
         const context_messages = this.messages_by_id.filter((item) => item.turn_id && batch_turn_ids.has(item.turn_id));
-        const outputs = await this.run_dispatch_plan(decision, message, context_messages, undefined, dispatch_id);
+        const outputs = await this.run_dispatch_plan(
+          dispatch.decision,
+          message,
+          context_messages,
+          undefined,
+          dispatch.dispatch_id,
+        );
         for (const turn_id of batch_turn_ids) this.group_turns_by_id.delete(turn_id);
-        if (decision.terminal || outputs.length === 0) {
+        if (dispatch.decision.terminal || outputs.length === 0) {
           this.auto_frontier_messages = [];
           await this.persist_dispatch_checkpoint();
           this.publish_status(undefined, "idle");
@@ -381,6 +431,7 @@ export class GroupSession implements GroupSessionContract {
           this.auto_dispatch_requested = true;
         }
       } catch (error) {
+        if (error instanceof GroupDispatchStoppedError) return;
         await this.append_dispatch_failure(message, error);
         this.publish_status(undefined, "failed");
         for (const turn_id of batch_turn_ids) this.group_turns_by_id.delete(turn_id);
@@ -394,8 +445,8 @@ export class GroupSession implements GroupSessionContract {
     trigger: "user" | "auto",
     message: GroupMessage,
     pending_messages: readonly GroupMessage[],
-  ): Promise<DispatchDecision> {
-    return await this.dispatch_strategy.decide_dispatch({
+  ): Promise<GroupDispatchSessionResult> {
+    return await this.dispatch_session.decide({
       trigger,
       message,
       pending_messages,
@@ -537,7 +588,10 @@ export class GroupSession implements GroupSessionContract {
         await this.append_member_failure(agent, message, result.error || "未知错误");
         return null;
       }
-      if (!result.text?.trim()) return null;
+      if (!result.text?.trim()) {
+        await this.append_member_failure(agent, message, "未生成有效回复");
+        return null;
+      }
       const reply = await this.append_message({
         sender_type: "agent",
         sender_id: agent.id,
@@ -653,7 +707,7 @@ export class GroupSession implements GroupSessionContract {
       `Current message from ${message.sender_type === "agent" ? message.sender_id : "user"}: ${message.text}`,
       dispatch_instruction,
       `你只能代表成员 ${agent.id} 自己发言。不得代替、指挥、裁定、总结或转述其他成员；不得假装自己是其他成员；不得创建队长、裁判或协调者。`,
-      "如果不需要你发言，返回空内容。",
+      "你已被 Group 调度选中，必须直接回复当前消息。",
     ].filter(Boolean).join("\n");
   }
 
@@ -695,6 +749,7 @@ export class GroupSession implements GroupSessionContract {
           turn_id: group_turn.turn_id,
           root_message_id: group_turn.root_message_id,
           context_message_ids: [...group_turn.context_message_ids],
+          dispatch_stage: group_turn.dispatch_stage,
         })),
       auto_frontier_message_ids: this.auto_frontier_messages.map((message) => message.id),
     });