dsh-client-auto-continue 0.11.2 → 0.11.4

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 去重)。 */
@@ -79,7 +86,7 @@ export interface HostNotice {
   title: string;
   body: string;
   /** 会话 id(通知按钮「立即续跑 / 暂停该会话」作用于它)。 */
-  sessionId?: SessionId;
+  sessionId: SessionId;
   actions: NotifyAction[];
   /** 产生时间。 */
   at: number;
@@ -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');
@@ -505,6 +550,7 @@ export class AutoContinueRunner {
       this.bumpStat({ skipped: 1, code: failure.code });
       if (config.notify) {
         this.notify(
+          sessionId,
           copy.notContinuedTitle,
           copy.permanentErrorBody(sessionId, summary),
           this.notifyOptions(sessionId, config.locale),
@@ -563,11 +609,17 @@ export class AutoContinueRunner {
   }
 
   /** 通知桥: 产生一条通知事件, SSE 端点推给 browser 侧展示。 */
-  private notify(title: string, body: string, options?: NotifyOptions): void {
+  private notify(
+    sessionId: SessionId,
+    title: string,
+    body: string,
+    options?: NotifyOptions,
+  ): void {
     const notice: HostNotice = {
       id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
       title,
       body,
+      sessionId,
       ...(options?.actions !== undefined && options.actions.length > 0
         ? { actions: options.actions }
         : { actions: [] }),
@@ -704,22 +756,27 @@ 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} 次连续`);
       if (config.notify) {
         const copy = NOTICE_COPY[config.locale];
         this.notify(
+          sessionId,
           copy.continuedTitle,
           copy.continuedBody(sessionId, text, state.consecutive),
           this.notifyOptions(sessionId, config.locale),
@@ -731,6 +788,7 @@ export class AutoContinueRunner {
         if (config.notify) {
           const copy = NOTICE_COPY[config.locale];
           this.notify(
+            sessionId,
             copy.stoppedTitle,
             copy.stoppedBody(sessionId, state.consecutive),
             this.notifyOptions(sessionId, config.locale),
@@ -756,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,
@@ -777,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> {
@@ -818,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);
@@ -843,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;
@@ -856,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;
   }
@@ -868,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);
   }
 }