dsh-client-auto-continue 0.11.3 → 0.11.4

package/lib/types/host/engine.d.ts

@@ -74,8 +74,8 @@ export declare class AutoContinueRunner {
     private checkLoop;
     /**
      * 打断运行中的回合: cancel(带来源标记)+ 进冷却。
-     * 随后的 turn/end aborted 会因 loopCancelled 走「可恢复中断」路径,
-     * 用 loopText 重启回合——不会与用户手动停止混淆。
+     * 只有随后持久化的 turn/end 精确携带专属 hook cause 时,
+     * 才会用 loopText 重启回合——DSH 的 first-cause 语义保证用户 Stop 优先。
      */
     private interruptLoop;
     private onSessionEvent;

package/lib/types/shared/core.d.ts

@@ -152,21 +152,92 @@ export interface ToolResultFacts {
     ok: boolean;
     /** 工具输出的文本摘要(截断)。 */
     excerpt: string;
+    /** 完整模型可见内容 + 错误状态的定长稳定指纹(loop guard 比较用)。 */
+    identity: string;
 }
-/** 从 tool/result 事件载荷提取成功与否与文本摘要。 */
-export declare function toolResultFacts(data: {
+interface ToolResultData {
+    turn?: unknown;
+    step?: unknown;
     error?: {
         name?: string;
         code?: string;
     };
     message?: {
+        source?: {
+            kind?: string;
+            callId?: unknown;
+        };
         content?: Array<{
             type?: string;
+            toolCallId?: unknown;
             content?: unknown;
             isError?: boolean;
         }>;
     };
-}): ToolResultFacts;
+}
+/**
+ * 取工具结果的关联 id。新版 DSH 的权威位置是 message.source.callId，
+ * 同时接受模型可见 block 上的 toolCallId；两者冲突时宁可忽略，不猜测配对。
+ */
+export declare function toolResultCallId(data: ToolResultData): string | undefined;
+/** 从 tool/result 事件载荷提取成功与否与文本摘要。 */
+export declare function toolResultFacts(data: ToolResultData): ToolResultFacts;
+/** loop guard 在后续 step 边界确认的连续重复信号。 */
+export interface ToolRepeatSignal {
+    tool: string;
+    count: number;
+}
+export type ToolGuardState = {
+    kind: 'none';
+} | {
+    kind: 'pending';
+    tool: string;
+} | {
+    kind: 'done';
+    tool: string;
+    result: string;
+} | {
+    kind: 'failed';
+    tool: string;
+};
+/**
+ * 每个会话的工具调用关联器。
+ *
+ * 集中封装事件关联、step 边界确认、护栏读取与重置。内部按 callId 配对，
+ * 乱序结果先缓存、再按调用顺序推进 loop 计数。队列和去重 id 都有硬上限；
+ * 超限或载荷无法关联时会打断重复计数，宁可漏报也不误杀健康回合。
+ */
+export declare class ToolInvocationTracker {
+    private readonly pendingById;
+    private readonly pendingInOrder;
+    private readonly seenCalls;
+    private readonly seenInOrder;
+    private latest;
+    private run;
+    private repeatSignal;
+    private lastEventSeq;
+    reset(): void;
+    /** 新回合边界：清空工具态，同时把重放水位推进到 turn/start。 */
+    startTurn(seq: number): void;
+    /** 回合已结束：保留最后一次调用的护栏，丢弃不再可用的 loop 关联态。 */
+    resetRepeat(): void;
+    recordCall(event: SessionEvent<'tool/call'>): boolean;
+    recordResult(event: SessionEvent<'tool/result'>): ToolRepeatSignal | undefined;
+    guard(): ToolGuardState;
+    lastTool(): string | undefined;
+    /** 下一模型 step 是稳定边界；此前 replacement/新调用会先清除候选。 */
+    confirmRepeatAtStep(seq: number): ToolRepeatSignal | undefined;
+    /** 非工具 surface range replacement（如 compaction summary）同样终止旧工具证据。 */
+    recordSurfaceReplacement(seq: number): void;
+    restore(events: readonly SessionEvent[], untilSeq: number): void;
+    private acceptEventSeq;
+    private breakCorrelation;
+    private invalidateRunHistory;
+    private trim;
+    private drainCompleted;
+    private advanceRun;
+    private refreshRepeatSignal;
+}
 /** 自适应退避: 同一会话连续失败时的有效冷却间隔。 */
 export declare function effectiveCooldown(consecutive: number, base: number, factor: number, max: number): number;
 export declare function sleep(ms: number): Promise<void>;
@@ -196,12 +267,10 @@ export declare function emptyDayStats(): DayStats;
 export interface SessionState {
     /** 连续自动「继续」次数; 成功回合或用户手动介入后归零。 */
     consecutive: number;
-    /** 上次自动「继续」时间戳。 */
-    lastAutoAt: number;
     /** 上次自动「继续」尝试(成功或失败)时间戳; 防止失败场景下的快速重试循环。 */
     lastAttemptAt: number;
-    /** 我们上次自动发送的文本(用于识别自己的回显)。 */
-    lastSentText: string;
+    /** 尚未回显到会话事件流的自动发送消息 ID。 */
+    pendingEchoMessageIds: Map<string, number>;
     /** 宽限期定时器(进行中的待发送)。 */
     pendingTimer: ReturnType<typeof setTimeout> | undefined;
     /** 宿主权威 running 位(来自 host/session-status 与回合事件)。 */
@@ -214,10 +283,8 @@ export interface SessionState {
     lastFailure: FailureFacts | undefined;
     /** 最近一次失败的发生时间(模板 {elapsed} 与恢复统计用)。 */
     lastFailureAt: number;
-    /** 失败前最后一次工具调用的名称(模板 {tool} 与幂等护栏用)。 */
-    lastTool: string | undefined;
-    /** 上一步工具调用的结果状态: 'pending' = 已发起未见结果(可能已部分执行)。 */
-    lastToolResult: 'pending' | ToolResultFacts | undefined;
+    /** callId 精确配对的工具调用、幂等护栏与 loop 重复态。 */
+    tools: ToolInvocationTracker;
     /** 失败回合的编号(模板 {turn})。 */
     lastTurn: number | undefined;
     /** 我们最近一次自动发送的时间戳; 0 = 没有待确认的恢复。 */
@@ -230,29 +297,18 @@ export interface SessionState {
     lastAssistantText: string;
     /** 连续相同文本消息数(最强空转信号, 不限长度)。 */
     sameTextRun: number;
-    /**
-     * 工具重复信号(loop guard 信号 2: 死循环)。
-     * 只有「同工具 + 同参数 + 同结果」的连续调用才累计; 参数或结果有变化视为有进展, 计数重置。
-     */
-    toolRun: {
-        /** 工具名 + 参数(用于判定是否同一调用)。 */
-        key: string;
-        /** 连续相同调用数(结果确认后更新)。 */
-        count: number;
-        /** 上次该调用的结果摘要(比较用)。 */
-        lastResult: string | undefined;
-        /** 本次调用等待结果确认。 */
-        waiting: boolean;
-    } | undefined;
     /** 本回合已触发过 loop guard(防重复打断)。 */
     loopFired: boolean;
     /** loop 重启的延迟定时器(冷却结束后再 schedule)。 */
     loopRetryTimer: ReturnType<typeof setTimeout> | undefined;
-    /** 我们主动 cancel 过本回合(区分用户停止)。 */
-    loopCancelled: boolean;
 }
 export declare const freshState: () => SessionState;
 export declare const RECOVERY_WINDOW_MS: number;
 export declare const ECHO_WINDOW_MS: number;
+/** Track an identified plugin message before handing it to the host queue. */
+export declare function trackPendingEcho(state: SessionState, messageId: string): void;
+/** Roll back tracking when the host rejects a queued message. */
+export declare function forgetPendingEcho(state: SessionState, messageId: string): void;
+/** Match and consume one plugin-owned `user/message` event by stable message ID. */
 export declare function isOurEcho(state: SessionState, event: SessionEvent): boolean;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-client-auto-continue",
   "description": "DSH Web UI plugin: automatically sends a localized continue prompt when a request is interrupted by network errors or other non-human causes",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",

package/src/host/engine.ts

@@ -19,11 +19,11 @@ import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session/types';
 import type { Session } from '@deepseek-ai/dsh-session';
 import {
   DEFAULT_CONFIG,
-  ECHO_WINDOW_MS,
   RECOVERY_WINDOW_MS,
   effectiveCooldown,
   emptyDayStats,
   fillTemplate,
+  forgetPendingEcho,
   freshState,
   isNonHumanReason,
   isOurEcho,
@@ -32,7 +32,7 @@ import {
   resolveConfig,
   sleep,
   todayKey,
-  toolResultFacts,
+  trackPendingEcho,
   type AutoContinueConfig,
   type AutoContinueLocale,
   type DayStats,
@@ -41,6 +41,7 @@ import {
   type NotifyAction,
   type NotifyOptions,
   type TemplateContext,
+  type ToolRepeatSignal,
 } from '../shared/core.ts';
 
 const NOTICE_COPY = {
@@ -72,6 +73,12 @@ const NOTICE_COPY = {
   },
 } as const satisfies Record<AutoContinueLocale, Record<string, unknown>>;
 
+/** Durable cancel identity reserved for this plugin's loop guard. */
+const LOOP_GUARD_CANCEL_CAUSE = {
+  kind: 'hook',
+  reason: 'dsh-auto-continue:loop-guard',
+} as const;
+
 /** 通知桥事件: host 引擎产生, browser 侧订阅展示(Notification / 动作按钮)。 */
 export interface HostNotice {
   /** 稳定标识(供 browser 去重)。 */
@@ -87,15 +94,57 @@ export interface HostNotice {
 
 /** 自动发送后, 在该窗口内出现的回合结束才计入恢复统计。 */
 
-/** 回显识别窗口: 排队消息可能几分钟后才被模型处理到, 窗口必须远大于排队延迟。 */
-
-/**
- * 判定一条 user/message 是否是我们自己自动发送的回显。
- * 单实例引擎: 内存态即可; 排队消息可能几分钟后才被模型处理, 窗口保持 10 分钟。
- */
 /** SSE 帧外壳: `{ rpcId, payload }`。 */
 type FrameEnvelope<T> = { payload: T };
 
+/** Session history APIs across the supported DSH host releases. */
+type CompatibleSession = Session & {
+  readonly events?: readonly SessionEvent[];
+  snapshotEvents?: () => readonly SessionEvent[];
+};
+
+/** Read one stable event-log snapshot on both legacy and DSH 0.1.2 hosts. */
+function snapshotSessionEvents(session: Session): readonly SessionEvent[] {
+  const compatible = session as CompatibleSession;
+  if (typeof compatible.snapshotEvents === 'function') return compatible.snapshotEvents();
+  if (compatible.events !== undefined) return compatible.events;
+  throw new TypeError('session exposes neither snapshotEvents() nor events');
+}
+
+/** Interpret host failure payloads without trusting persisted or plugin-provided event shapes. */
+function parseFailureFacts(value: unknown): FailureFacts | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+  const failure = value as { code?: unknown; message?: unknown; status?: unknown };
+  const code = typeof failure.code === 'string' && failure.code.trim() !== ''
+    ? failure.code
+    : undefined;
+  const message = typeof failure.message === 'string' && failure.message.trim() !== ''
+    ? failure.message
+    : undefined;
+  const status = typeof failure.status === 'number' && Number.isFinite(failure.status)
+    ? failure.status
+    : undefined;
+  if (code === undefined && message === undefined && status === undefined) return undefined;
+  return {
+    code: code ?? 'UNKNOWN',
+    message: message ?? code ?? `HTTP ${status}`,
+    ...(status !== undefined ? { status } : {}),
+  };
+}
+
+/** Read a reason discriminator defensively because session history can outlive its schema. */
+function readReasonKind(value: unknown): string | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+  const kind = (value as { kind?: unknown }).kind;
+  return typeof kind === 'string' && kind.trim() !== '' ? kind : undefined;
+}
+
+function isLoopGuardCancelReason(value: unknown): boolean {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  const cause = value as { kind?: unknown; reason?: unknown };
+  return cause.kind === LOOP_GUARD_CANCEL_CAUSE.kind && cause.reason === LOOP_GUARD_CANCEL_CAUSE.reason;
+}
+
 /**
  * 事件流泵: 带指数退避的 SSE 重连循环。
  * - 从未收到任何帧(宿主未就绪): 退避重试, 不触发扫描
@@ -155,9 +204,17 @@ export class AutoContinueRunner {
     private readonly getConfig: () => AutoContinueConfig,
   ) {
     // 单实例事件源: 宿主进程内的会话事件 firehose, 天然覆盖所有会话。
-    this.disposeSessionEvents = ctx.on('session/event', (session, event) =>
-      this.onHostEvent(session, event),
-    );
+    this.disposeSessionEvents = ctx.on('session/event', (session, event) => {
+      try {
+        this.onHostEvent(session, event);
+      } catch (error) {
+        console.error(
+          `[auto-continue] 会话事件处理异常 ${session.id}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+    });
     const config = this.getConfig();
     if (config.scanOnBoot) {
       void this.bootScanLoop();
@@ -254,42 +311,26 @@ export class AutoContinueRunner {
    */
   private onHostEvent(session: Session, event: SessionEvent): void {
     const sessionId = session.id;
+    if (
+      (event.type === 'user/message' || event.type === 'assistant/message') &&
+      typeof event.surfaceOp === 'object' &&
+      event.surfaceOp !== null
+    ) {
+      // Compaction replacement 不是新消息，也可能 shadow 整段工具结果。
+      this.state(sessionId).tools.recordSurfaceReplacement(event.seq);
+      return;
+    }
     if (event.type === 'tool/call') {
-      const name = event.data.name;
-      if (typeof name === 'string') {
-        const state = this.state(sessionId);
-        state.lastTool = name;
-        state.lastToolResult = 'pending'; // 已发起, 尚未见结果
-        // loop guard 信号 2: 同工具+同参数才可能是循环; 参数变化 = 有进展
-        // (工具调用本身也重置短句信号)。计数在结果确认后才推进。
-        state.shortRun = 0;
-        const key = `${name}\n${event.data.arguments}`;
-        if (state.toolRun?.key === key) {
-          state.toolRun.waiting = true; // 结果到达时与上次结果比较
-        } else {
-          state.toolRun = { key, count: 1, lastResult: undefined, waiting: false };
-        }
-      }
+      const state = this.state(sessionId);
+      // 任何新鲜调用都代表进展（即使缺关联 id）；旧帧重放不能清短句 streak。
+      if (state.tools.recordCall(event)) state.shortRun = 0;
     } else if (event.type === 'tool/result') {
       const state = this.state(sessionId);
-      if (state.lastToolResult === 'pending') {
-        const facts = toolResultFacts(event.data);
-        state.lastToolResult = facts;
-        // 结果确认: 与上次相同 → 计数推进; 不同 → 有进展, 重置
-        const run = state.toolRun;
-        if (run !== undefined && run.waiting) {
-          run.waiting = false;
-          if (run.lastResult !== undefined && run.lastResult === facts.excerpt) {
-            run.count += 1;
-            this.checkLoop(sessionId, state);
-          } else {
-            run.lastResult = facts.excerpt;
-            run.count = 1;
-          }
-        } else if (run !== undefined && !run.waiting) {
-          run.lastResult = facts.excerpt;
-        }
-      }
+      state.tools.recordResult(event);
+    } else if (event.type === 'step/start') {
+      const state = this.state(sessionId);
+      const repeat = state.tools.confirmRepeatAtStep(event.seq);
+      if (repeat !== undefined) this.checkLoop(sessionId, state, repeat);
     } else if (event.type === 'assistant/message') {
       const state = this.state(sessionId);
       this.onAssistantMessage(sessionId, state, event);
@@ -339,30 +380,33 @@ export class AutoContinueRunner {
   }
 
   /** 两个循环信号的公共检查; 命中且本回合未打断过则打断。 */
-  private checkLoop(sessionId: SessionId, state: SessionState): void {
+  private checkLoop(
+    sessionId: SessionId,
+    state: SessionState,
+    toolRepeat?: ToolRepeatSignal,
+  ): void {
     if (!this.getConfig().loopGuard) return;
     if (state.loopFired) return;
     if (!state.running) return; // 只干预运行中的回合
     const config = this.getConfig();
     if (state.sameTextRun >= config.loopRepeatText) {
       this.log(`检测到空转循环 ${sessionId}: 连续 ${state.sameTextRun} 条相同消息`);
-      void this.interruptLoop(sessionId, state);
+      this.interruptLoop(sessionId, state);
     } else if (state.shortRun >= config.loopShortCount) {
       this.log(`检测到空转循环 ${sessionId}: 连续 ${state.shortRun} 条短句且无工具调用`);
-      void this.interruptLoop(sessionId, state);
-    } else if (state.toolRun !== undefined && state.toolRun.count >= config.loopToolRepeat) {
-      const toolName = state.toolRun.key.split('\n')[0] ?? '?';
-      this.log(`检测到工具死循环 ${sessionId}: 「${toolName}」连续 ${state.toolRun.count} 次(同参数同结果)`);
-      void this.interruptLoop(sessionId, state);
+      this.interruptLoop(sessionId, state);
+    } else if (toolRepeat !== undefined && toolRepeat.count >= config.loopToolRepeat) {
+      this.log(`检测到工具死循环 ${sessionId}: 「${toolRepeat.tool}」连续 ${toolRepeat.count} 次(同参数同结果)`);
+      this.interruptLoop(sessionId, state);
     }
   }
 
   /**
    * 打断运行中的回合: cancel(带来源标记)+ 进冷却。
-   * 随后的 turn/end aborted 会因 loopCancelled 走「可恢复中断」路径,
-   * 用 loopText 重启回合——不会与用户手动停止混淆。
+   * 只有随后持久化的 turn/end 精确携带专属 hook cause 时,
+   * 才会用 loopText 重启回合——DSH 的 first-cause 语义保证用户 Stop 优先。
    */
-  private async interruptLoop(sessionId: SessionId, state: SessionState): Promise<void> {
+  private interruptLoop(sessionId: SessionId, state: SessionState): void {
     if (state.loopFired) return;
     // 打断本身受冷却约束: 距上次打断/发送太近时不再打断, 防止反复打断刷屏
     if (Date.now() - state.lastAttemptAt < this.cooldownFor(state)) {
@@ -370,21 +414,19 @@ export class AutoContinueRunner {
       return;
     }
     state.loopFired = true;
-    state.loopCancelled = true;
     state.lastAttemptAt = Date.now(); // 打断计入冷却, 防反复打断
-    this.bumpStat({ looped: 1 });
     try {
       const agent = this.ctx.agents.get(sessionId);
       if (agent === undefined) {
         this.log(`打断循环失败 ${sessionId}: 无 live agent`);
-        state.loopCancelled = false;
+        state.loopFired = false;
         return;
       }
-      agent.cancel({ kind: 'user' }, { keepInbox: true });
+      agent.cancel(LOOP_GUARD_CANCEL_CAUSE, { keepInbox: true });
       this.log(`已打断循环 ${sessionId}: cancel 已受理`);
     } catch (error) {
       this.log(`打断循环失败 ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
-      state.loopCancelled = false;
+      state.loopFired = false;
     }
   }
 
@@ -394,16 +436,13 @@ export class AutoContinueRunner {
       case 'turn/start':
         state.running = true;
         // 新回合开始: 清空上一步工具调用状态, 避免跨回合误用护栏
-        state.lastTool = undefined;
-        state.lastToolResult = undefined;
+        state.tools.startTurn(event.seq);
         // loop guard 状态按回合重置
         state.shortRun = 0;
         state.lastShortAt = 0;
         state.lastAssistantText = '';
         state.sameTextRun = 0;
-        state.toolRun = undefined;
         state.loopFired = false;
-        state.loopCancelled = false;
         if (state.loopRetryTimer !== undefined) {
           clearTimeout(state.loopRetryTimer);
           state.loopRetryTimer = undefined;
@@ -412,26 +451,32 @@ export class AutoContinueRunner {
         break;
       case 'turn/end': {
         state.running = false;
+        const loopCancelPending = state.loopFired;
+        state.loopFired = false;
         this.cancelPending(sessionId, '收到新的 turn/end');
         const reason = event.data.reason;
-        if (reason.kind === 'completed') {
+        const reasonKind = readReasonKind(reason);
+        if (reasonKind === undefined) {
+          console.error(`[auto-continue] 忽略畸形 turn/end ${sessionId}: reason 无法解释`);
+          break;
+        }
+        if (reasonKind === 'completed') {
           // 成功回合: 恢复健康状态, 并确认上一次自动发送的效果
           state.consecutive = 0;
           state.lastFailure = undefined;
           this.noteRecovery(sessionId, 'completed');
-        } else if (reason.kind === 'aborted') {
-          if (state.loopCancelled) {
+        } else if (reasonKind === 'aborted') {
+          if (isLoopGuardCancelReason((reason as { reason?: unknown }).reason)) {
             // 我们自己的 loop guard 打断: 视为可恢复中断, 用循环提示文本重启回合。
             // 不清 consecutive / lastAttemptAt: 冷却与连续上限在 loop 路径同样生效,
             // 防止无限打断重发(issue #13); 打断本身受冷却约束, 重启也要等冷却。
-            state.loopCancelled = false;
-            state.loopFired = false;
+            if (loopCancelPending) this.bumpStat({ looped: 1 });
             state.pendingRecoveryAt = 0;
             state.shortRun = 0;
             state.lastShortAt = 0;
             state.lastAssistantText = '';
             state.sameTextRun = 0;
-            state.toolRun = undefined;
+            state.tools.resetRepeat();
             // 重启受冷却约束(防紧密打断循环): 等剩余冷却结束后再调度
             const cooldown = this.cooldownFor(state);
             const remaining = cooldown - (Date.now() - state.lastAttemptAt);
@@ -454,27 +499,27 @@ export class AutoContinueRunner {
             state.consecutive = 0;
             state.pendingRecoveryAt = 0;
           }
-        } else if (reason.kind === 'blocked') {
+        } else if (reasonKind === 'blocked') {
           // 策略拒绝: 不自动继续
-        } else if (reason.kind === 'interrupted') {
+        } else if (reasonKind === 'interrupted') {
           // 实时路径的 interrupted 仅来自崩溃修复重载(loop 从不实时发出);
           // 用户手动停止在 DSH 中标记为 aborted, 不走到这里。实时流里出现
           // interrupted 视为异常中断, 不自动继续——宿主崩溃孤儿回合由扫描恢复。
           state.consecutive = 0;
           state.pendingRecoveryAt = 0;
-        } else if (reason.kind === 'error') {
+        } else if (reasonKind === 'error') {
           // 记录失败事实(分类与模板填充用), 然后按类型处理
-          const error = reason.error;
-          state.lastFailure = {
-            code: typeof error.code === 'string' ? error.code : 'UNKNOWN',
-            message: typeof error.message === 'string' ? error.message : String(error),
-            ...(typeof error.status === 'number' ? { status: error.status } : {}),
-          };
+          const failure = parseFailureFacts((reason as { error?: unknown }).error);
+          if (failure === undefined) {
+            console.error(`[auto-continue] 忽略畸形 turn/end ${sessionId}: error details 无法解释`);
+            break;
+          }
+          state.lastFailure = failure;
           state.lastTurn = event.data.turn;
           state.lastFailureAt = Date.now();
           this.noteRecovery(sessionId, 'error');
           this.onTurnFailure(sessionId, 'turn/end:error', state.lastFailure);
-        } else if (reason.kind === 'max-tokens') {
+        } else if (reasonKind === 'max-tokens') {
           state.lastFailureAt = Date.now();
           this.noteRecovery(sessionId, 'error');
           this.schedule(sessionId, 'turn/end:max-tokens');
@@ -711,16 +756,20 @@ export class AutoContinueRunner {
     }
     state.lastAttemptAt = Date.now(); // 先记账: 无论成败, 本次尝试都进入冷却
     try {
-      agent.followup(
-        createUserMessage({
-          content: [{ type: 'text', text }],
-          source: { kind: 'user' },
-        }),
-      );
+      const message = createUserMessage({
+        content: [{ type: 'text', text }],
+        source: { kind: 'user' },
+      });
+      // `followup` may publish the matching session event synchronously.
+      trackPendingEcho(state, message.id);
+      try {
+        agent.followup(message);
+      } catch (error) {
+        forgetPendingEcho(state, message.id);
+        throw error;
+      }
       const now = Date.now();
       state.consecutive += 1;
-      state.lastAutoAt = now;
-      state.lastSentText = text;
       state.pendingRecoveryAt = now; // 等待窗口内的下一个回合结束来判定恢复结果
       this.bumpStat({ sent: 1, ...(state.lastFailure !== undefined ? { code: state.lastFailure.code } : {}) });
       this.log(`已自动发送「${text}」到 ${sessionId}(${reason}), 第 ${state.consecutive} 次连续`);
@@ -765,7 +814,7 @@ export class AutoContinueRunner {
   ): string {
     let text = fillTemplate(template, {
       facts: state.lastFailure,
-      tool: state.lastTool,
+      tool: state.tools.lastTool(),
       turn: state.lastTurn,
       errorCount: state.consecutive + 1,
       elapsedMs: state.lastFailureAt > 0 ? Date.now() - state.lastFailureAt : undefined,
@@ -786,12 +835,7 @@ export class AutoContinueRunner {
     tool?: string;
     result?: string;
   } {
-    if (state.lastTool === undefined || state.lastToolResult === undefined) return { kind: 'none' };
-    if (state.lastToolResult === 'pending') return { kind: 'pending', tool: state.lastTool };
-    if (state.lastToolResult.ok) {
-      return { kind: 'done', tool: state.lastTool, result: state.lastToolResult.excerpt };
-    }
-    return { kind: 'failed', tool: state.lastTool };
+    return state.tools.guard();
   }
 
   private async bootScanLoop(): Promise<void> {
@@ -827,12 +871,31 @@ export class AutoContinueRunner {
     if (config.paused) return true; // 全局暂停: 不做任何扫描
     // 只扫 live agents(host 重启后 agent-loop 会 resume 崩溃会话, 冷会话无需处理)
     const now = Date.now();
-    const candidates: { sessionId: SessionId; events: readonly SessionEvent[] }[] = [];
+    const candidates: {
+      sessionId: SessionId;
+      events: readonly SessionEvent[];
+      lastActivityAt: number;
+      listIndex: number;
+    }[] = [];
     for (const agent of this.ctx.agents.list()) {
       const session = agent.session;
       if (session.header.origin === 'subagent') continue; // 子代理由父代理处理
-      candidates.push({ sessionId: session.id, events: session.events });
-    }
+      const events = snapshotSessionEvents(session);
+      const lastActivityAt = events.reduce(
+        (latest, event) => Math.max(latest, event.time),
+        Number.isFinite(session.header.createdAt) ? session.header.createdAt : 0,
+      );
+      candidates.push({
+        sessionId: session.id,
+        events,
+        lastActivityAt,
+        listIndex: candidates.length,
+      });
+    }
+    candidates.sort(
+      (left, right) =>
+        right.lastActivityAt - left.lastActivityAt || left.listIndex - right.listIndex,
+    );
     for (const candidate of candidates.slice(0, config.scanLimit)) {
       if (this.disposed) return true;
       const state = this.state(candidate.sessionId);
@@ -852,7 +915,8 @@ export class AutoContinueRunner {
       }
       if (lastEnd === undefined) continue;
       const reason = lastEnd.data.reason;
-      if (!isNonHumanReason(reason.kind)) continue;
+      const reasonKind = readReasonKind(reason);
+      if (reasonKind === undefined || !isNonHumanReason(reasonKind)) continue;
       if (lastEnd.time < now - config.freshMs) continue; // 太久远, 不翻旧账
       // 该 turn/end 之后不能有新回合或用户消息(说明已被处理)
       let superseded = false;
@@ -865,8 +929,21 @@ export class AutoContinueRunner {
       if (superseded) continue;
       // 幂等护栏: 从历史事件里重建上一步工具调用的执行状态
       this.applyGuardFromEvents(state, events, lastEnd.seq);
-      this.log(`扫描发现中断 ${candidate.sessionId}(turn/end:${reason.kind}), 安排自动继续`);
-      this.schedule(candidate.sessionId, `scan:turn/end:${reason.kind}`);
+      const scanReason = `scan:turn/end:${reasonKind}`;
+      this.log(`扫描发现中断 ${candidate.sessionId}(turn/end:${reasonKind}), 交给恢复策略处理`);
+      if (reasonKind === 'error') {
+        const failure = parseFailureFacts((reason as { error?: unknown }).error);
+        if (failure === undefined) {
+          console.error(`[auto-continue] 忽略畸形扫描 turn/end ${candidate.sessionId}: error details 无法解释`);
+          continue;
+        }
+        state.lastFailure = failure;
+        state.lastTurn = lastEnd.data.turn;
+        state.lastFailureAt = lastEnd.time;
+        this.onTurnFailure(candidate.sessionId, scanReason, state.lastFailure);
+      } else {
+        this.schedule(candidate.sessionId, scanReason);
+      }
     }
     return true;
   }
@@ -877,22 +954,6 @@ export class AutoContinueRunner {
     events: readonly SessionEvent[],
     untilSeq: number,
   ): void {
-    state.lastTool = undefined;
-    state.lastToolResult = undefined;
-    let call: SessionEvent<'tool/call'> | undefined;
-    for (const event of events) {
-      if (event.seq >= untilSeq) continue;
-      if (event.type === 'tool/call') call = event;
-    }
-    if (call === undefined) return;
-    state.lastTool = call.data.name;
-    state.lastToolResult = 'pending';
-    for (const event of events) {
-      if (event.seq <= call.seq || event.seq >= untilSeq) continue;
-      if (event.type === 'tool/result') {
-        state.lastToolResult = toolResultFacts(event.data);
-        break;
-      }
-    }
+    state.tools.restore(events, untilSeq);
   }
 }