dsh-client-auto-continue 0.7.2 → 0.7.4

package/README.md

@@ -43,7 +43,7 @@ For [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (`dsh we
 - **Idempotency guard** — before resuming, the plugin inspects the last tool call: if its result is unconfirmed (the turn died mid-tool, e.g. a `git push` that may have gone through), the resume message tells the model to check state first and not to rerun; if the tool is confirmed done, it says so and asks not to repeat it; a failed tool gets no guard (retrying it is the point). Both guard texts are configurable (`{tool}` / `{result}` placeholders)
 - **Pause** — a global **Pause auto-continue** toggle in the settings card stops everything (live + scan) instantly; per-session pauses (e.g. via a notification button) suspend only one session until they expire. The **Resume now** notification button is the one explicit exception: pressing it is the user asking for exactly one send, pause or not
 - **Notification buttons** — notifications carry **Resume now** (send immediately, ignoring cooldown, the consecutive cap and any pause) and **Pause this session 1h** actions
-- **Loop guard** — watches **running** turns too: many short model messages inside a short time window with no tool call in between (the "Let me read…" spin), or the same tool called repeatedly with the **same arguments and the same results** (a changed argument or result counts as progress), trips the guard, which cancels the turn and restarts it with a configurable loop text ("stop repeating, try another way"). The cancel carries an internal marker so it is never confused with a user stop — the restart only happens for guard-initiated cancels. Thresholds, the time window and the loop text are configurable
+- **Loop guard** — watches **running** turns too. Three signals trip the guard, which cancels the turn and restarts it with a configurable loop text ("stop repeating, try another way"): the model repeating the **exact same message** several times (any length — e.g. "Let me test variants of the regex…" ×7), many short messages inside a short time window with no tool call in between (the "Let me read…" spin), or the same tool called repeatedly with the **same arguments and the same results** (a changed argument or result counts as progress). The cancel carries an internal marker so it is never confused with a user stop — the restart only happens for guard-initiated cancels. Thresholds, the time window and the loop text are configurable
 - **Stats panel** — the settings card shows today's auto-continue count, recoveries, failures, permanent skips, give-ups and loop breaks, broken down by error code, with a one-click reset
 - **Browser notifications** — optional alerts when auto-continue fires, gives up, or hits a permanent error; the browser asks for permission on first use, and nothing is shown again after a denial
 
@@ -177,6 +177,7 @@ auto-continue:
   loopShortChars: 40
   loopWindowMs: 30000
   loopShortCount: 12
+  loopRepeatText: 4
   loopToolRepeat: 5
   loopText: '(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)'
 ```
@@ -202,6 +203,7 @@ auto-continue:
 | Short-sentence max (chars) | `40` | A model message shorter than this counts as a short sentence (spinning signal) |
 | Short-sentence window (ms) | `30000` | Consecutive short sentences must land inside this window; normal thinking spread over time is not misjudged |
 | Short-sentence threshold | `12` | Consecutive short sentences inside the window, with no tool call in between, trip the loop guard |
+| Identical message count | `4` | Consecutive identical messages (any length) trip the loop guard — the strongest spinning signal |
 | Same-tool repeat count | `5` | Consecutive calls of the same tool with identical arguments and results trip the loop guard |
 | Loop text | `(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)` | Text sent after the loop guard restarts a turn; `{tool}` placeholder |
 | Guard text (unconfirmed result) | `(上一步工具「{tool}」可能未完成, 先确认状态再继续, 不要重复执行)` | Appended when the last tool may have partially executed; `{tool}` placeholder |
@@ -230,7 +232,7 @@ The plugin is browser-only and touches **no files, credentials, or network beyon
 
 - It opens the same two read-only event streams the web UI already uses (no extra server, no third-party endpoints)
 - The engine's **only automatic write** is `sessions.prompt` — the same call the Send button makes — with the text you configured (saving the settings card writes the `auto-continue` section of `~/.dsh/settings.yaml` through the normal settings API, exactly like any other setting)
-- Browser storage is limited to small `localStorage` keys: cross-tab coordination stamps, per-session pauses, and the daily stats counters
+- Browser storage is limited to small `localStorage` keys: cross-tab send locks and counts (a hard cap that stops duplicate sends even with several tabs open), per-session pauses, and the daily stats counters
 - Browser notifications are opt-in (`notify` setting) and permission is requested on first use only
 
 ---
@@ -241,7 +243,7 @@ The plugin is browser-only and touches **no files, credentials, or network beyon
 npm run typecheck   # tsc --noEmit
 npm run build       # lib/client.js + lib/index.js + lib/types
 npm run watch       # rebuild on change; host HMR hot-reloads without a page refresh
-npm run test        # node tests/simulate.mjs — 36 behavioral scenarios
+npm run test        # node tests/simulate.mjs — 40 behavioral scenarios
 ```
 
 While `npm run watch` runs, the profile's client-hmr row polls `lib/client.js` every 500 ms and hot-reloads the plugin in the browser — no server restart needed for code changes.

package/README.zh.md

@@ -43,7 +43,7 @@
 - **幂等护栏** — 续跑前检查上一步工具调用: 结果未确认(回合在工具执行中途夭折, 如 `git push` 可能已经推上去了)时, 续跑消息会提示模型先确认状态、不要重复执行; 工具已确认成功时说明已完成、请勿重复; 工具失败则不加护栏(重试本来就是目的)。两段护栏文本都可配置(支持 `{tool}` / `{result}` 占位符)
 - **暂停** — 设置卡片里的全局 **暂停自动继续** 开关可立即停掉一切(实时 + 扫描); 会话级暂停(如通过通知按钮)只挂起单个会话, 到期自动恢复。唯一的显式例外是通知里的 **立即续跑** 按钮——按下它等于用户明确要求发送这一次, 不受暂停限制
 - **通知按钮** — 通知带 **立即续跑**(无视冷却、连续上限与暂停, 马上发送)和 **暂停该会话 1 小时** 按钮
-- **循环守卫** — 连**运行中的回合**也盯着: 短时间内连续多条短句且期间无工具调用(典型的「Let me read…」空转), 或同一工具被连续反复调用且**参数与结果都相同**(参数或结果有变化视为有进展), 都会触发守卫: 取消当前回合并用可配置的循环提示文本重启(「停止重复, 换一种方式」)。取消带有内部来源标记, 绝不会与用户手动停止混淆——只有守卫发起的取消才会重启。阈值、时间窗与提示文本都可配置
+- **循环守卫** — 连**运行中的回合**也盯着, 三个信号都会触发守卫(取消当前回合并用可配置的循环提示文本重启, 「停止重复, 换一种方式」): 模型**连续输出完全相同的消息**(不限长度, 如 "Let me test variants of the regex…" 连续 7 遍)、短时间内连续多条短句且期间无工具调用(典型的「Let me read…」空转)、或同一工具被连续反复调用且**参数与结果都相同**(参数或结果有变化视为有进展)。取消带有内部来源标记, 绝不会与用户手动停止混淆——只有守卫发起的取消才会重启。阈值、时间窗与提示文本都可配置
 - **统计面板** — 设置卡片展示今日自动继续次数、恢复成功、继续后失败、永久性跳过、达上限停止、循环打断, 按错误码统计, 可一键清零
 - **浏览器通知** — 可选: 自动继续成功 / 放弃 / 遇到永久性错误时弹出提醒; 首次使用时请求权限, 被拒绝后不再打扰
 
@@ -177,6 +177,7 @@ auto-continue:
   loopShortChars: 40
   loopWindowMs: 30000
   loopShortCount: 12
+  loopRepeatText: 4
   loopToolRepeat: 5
   loopText: '(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)'
 ```
@@ -202,6 +203,7 @@ auto-continue:
 | 短句长度上限 (字符) | `40` | 模型消息文本短于该值计为一条短句(空转信号) |
 | 短句时间窗 (ms) | `30000` | 连续短句必须落在这个时间窗内; 正常思考的短文本散布在长时间里不会被误判 |
 | 连续短句阈值 | `12` | 时间窗内连续多少条短句且期间无工具调用时判定空转循环 |
+| 相同消息重复次数 | `4` | 连续输出多少条完全相同的消息时判定空转(不限长度, 最强信号) |
 | 同工具重复次数 | `5` | 同工具+同参数+同结果的连续调用多少次时判定死循环 |
 | 循环提示文本 | `(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)` | 打断后重启回合时发送的文本; 支持 {tool} 占位符 |
 | 结果未确认时的护栏文本 | `(上一步工具「{tool}」可能未完成, 先确认状态再继续, 不要重复执行)` | 上一步工具可能已部分执行时附加; 支持 {tool} 占位符 |
@@ -230,7 +232,7 @@ auto-continue:
 
 - 只复用 webui 本身就在用的两条只读事件流(无额外服务、无第三方端点)
 - 引擎**唯一会自动执行的写入**是 `sessions.prompt`——与点「发送」按钮完全相同的调用, 内容为你配置的文本(设置卡片里保存配置会通过常规设置 API 写入 `~/.dsh/settings.yaml` 的 `auto-continue` 段落, 与任何其他设置一样)
-- 浏览器存储仅限于少量 `localStorage` 键: 跨标签页协调时间戳、会话级暂停、每日统计计数
+- 浏览器存储仅限于少量 `localStorage` 键: 跨标签页发送锁与发送计数(多标签页同时打开时也绝不重复刷屏的硬上限)、会话级暂停、每日统计计数
 - 浏览器通知是可选开启的(`notify` 设置), 仅在首次使用时请求一次权限
 
 ---
@@ -241,7 +243,7 @@ auto-continue:
 npm run typecheck   # tsc --noEmit
 npm run build       # lib/client.js + lib/index.js + lib/types
 npm run watch       # 监听变更自动重建; 宿主 HMR 免刷新热重载
-npm run test        # node tests/simulate.mjs — 36 个行为场景
+npm run test        # node tests/simulate.mjs — 40 个行为场景
 ```
 
 `npm run watch` 运行时, profile 的 client-hmr 行每 500ms 轮询 `lib/client.js` 并在浏览器中热重载插件——改代码无需重启服务。

package/lib/client.js

@@ -63,6 +63,7 @@ var DEFAULT_CONFIG = {
   loopShortChars: 40,
   loopWindowMs: 3e4,
   loopShortCount: 12,
+  loopRepeatText: 4,
   loopToolRepeat: 5,
   loopText: "(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)"
 };
@@ -102,6 +103,7 @@ function resolveConfig(section) {
     loopShortChars: Math.max(1, numberOr(value.loopShortChars, DEFAULT_CONFIG.loopShortChars)),
     loopWindowMs: Math.max(1e3, numberOr(value.loopWindowMs, DEFAULT_CONFIG.loopWindowMs)),
     loopShortCount: Math.max(2, numberOr(value.loopShortCount, DEFAULT_CONFIG.loopShortCount)),
+    loopRepeatText: Math.max(2, numberOr(value.loopRepeatText, DEFAULT_CONFIG.loopRepeatText)),
     loopToolRepeat: Math.max(2, numberOr(value.loopToolRepeat, DEFAULT_CONFIG.loopToolRepeat)),
     loopText: typeof value.loopText === "string" && value.loopText.trim() !== "" ? value.loopText : DEFAULT_CONFIG.loopText
   };
@@ -202,31 +204,85 @@ function clientTimeZone() {
 var lockPrefix = "dsh-auto-continue:";
 var lockKey = (sessionId) => `${lockPrefix}lock:${sessionId}`;
 var stampKey = (sessionId) => `${lockPrefix}last:${sessionId}`;
-function claimSend(sessionId) {
+var countKey = (sessionId) => `${lockPrefix}count:${sessionId}`;
+function readLastSent(sessionId) {
   try {
-    const token = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    localStorage.setItem(lockKey(sessionId), token);
-    return localStorage.getItem(lockKey(sessionId)) === token;
+    const raw = localStorage.getItem(stampKey(sessionId));
+    if (raw === null) return { at: 0, text: "" };
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.text === "string") {
+      return { at: Number(parsed.at) || 0, text: parsed.text };
+    }
+    return { at: Number(raw) || 0, text: "" };
   } catch {
-    return true;
+    return { at: 0, text: "" };
   }
 }
-function releaseSend(sessionId) {
+function readLastSend(sessionId) {
+  return readLastSent(sessionId).at;
+}
+function writeLastSend(sessionId, at, text) {
   try {
-    localStorage.removeItem(lockKey(sessionId));
+    localStorage.setItem(stampKey(sessionId), JSON.stringify({ at, text }));
   } catch {
   }
 }
-function readLastSend(sessionId) {
+var SEND_COUNT_WINDOW_MS = 10 * 60 * 1e3;
+function readSendCount(sessionId) {
   try {
-    return Number(localStorage.getItem(stampKey(sessionId)) ?? 0) || 0;
+    const raw = localStorage.getItem(countKey(sessionId));
+    if (raw === null) return { at: 0, count: 0 };
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.count === "number") {
+      const at = Number(parsed.at) || 0;
+      if (Date.now() - at > SEND_COUNT_WINDOW_MS) return { at: 0, count: 0 };
+      return { at, count: parsed.count };
+    }
+  } catch {
+  }
+  return { at: 0, count: 0 };
+}
+function bumpSendCount(sessionId) {
+  try {
+    const current2 = readSendCount(sessionId);
+    localStorage.setItem(
+      countKey(sessionId),
+      JSON.stringify({ at: Date.now(), count: current2.count + 1 })
+    );
   } catch {
-    return 0;
   }
 }
-function writeLastSend(sessionId, at) {
+function clearSendCount(sessionId) {
   try {
-    localStorage.setItem(stampKey(sessionId), String(at));
+    localStorage.removeItem(countKey(sessionId));
+  } catch {
+  }
+}
+async function withSendLock(sessionId, body) {
+  const nav = globalThis.navigator;
+  if (nav?.locks !== void 0) {
+    await nav.locks.request(`dsh-auto-continue:send:${sessionId}`, body);
+    return;
+  }
+  if (!claimSend(sessionId)) return;
+  try {
+    await body();
+  } finally {
+    releaseSend(sessionId);
+  }
+}
+function claimSend(sessionId) {
+  try {
+    const token = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    localStorage.setItem(lockKey(sessionId), token);
+    return localStorage.getItem(lockKey(sessionId)) === token;
+  } catch {
+    return true;
+  }
+}
+function releaseSend(sessionId) {
+  try {
+    localStorage.removeItem(lockKey(sessionId));
   } catch {
   }
 }
@@ -334,19 +390,24 @@ var freshState = () => ({
   pendingRecoveryAt: 0,
   shortRun: 0,
   lastShortAt: 0,
+  lastAssistantText: "",
+  sameTextRun: 0,
   toolRun: void 0,
   loopFired: false,
-  loopCancelled: false
+  loopCancelled: false,
+  loopRetryTimer: void 0
 });
 var RECOVERY_WINDOW_MS = 10 * 60 * 1e3;
-function isOurEcho(state, event) {
+var ECHO_WINDOW_MS = 10 * 60 * 1e3;
+function isOurEcho(state, sessionId, event) {
   if (event.type !== "user/message") return false;
   const message = event.data;
   if (message.source.kind !== "user") return false;
-  if (state.lastSentText === "") return false;
-  if (Date.now() - state.lastAutoAt > 3e4) return false;
+  const last = readLastSent(sessionId);
+  if (last.at === 0 || last.text === "") return false;
+  if (Date.now() - last.at > ECHO_WINDOW_MS) return false;
   const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
-  return text === state.lastSentText;
+  return text === last.text;
 }
 async function pumpStream(open, onFrame, onReconnect, getBackoff, log, signal) {
   let backoff = getBackoff();
@@ -406,6 +467,7 @@ var AutoContinueRunner = class {
     this.hostAbort.abort();
     for (const state of this.states.values()) {
       if (state.pendingTimer !== void 0) clearTimeout(state.pendingTimer);
+      if (state.loopRetryTimer !== void 0) clearTimeout(state.loopRetryTimer);
     }
     this.states.clear();
   }
@@ -506,7 +568,14 @@ ${frame.event.data.arguments}`;
   onAssistantMessage(sessionId, state, event) {
     if (!this.getConfig().loopGuard) return;
     const text = this.assistantText(event);
-    if (text.trim().length < this.getConfig().loopShortChars) {
+    const trimmed = text.trim();
+    if (trimmed !== "" && trimmed === state.lastAssistantText) {
+      state.sameTextRun += 1;
+    } else {
+      state.lastAssistantText = trimmed;
+      state.sameTextRun = 1;
+    }
+    if (trimmed.length < this.getConfig().loopShortChars) {
       const now = Date.now();
       if (now - state.lastShortAt > this.getConfig().loopWindowMs) {
         state.shortRun = 0;
@@ -525,7 +594,10 @@ ${frame.event.data.arguments}`;
     if (state.loopFired) return;
     if (!state.running) return;
     const config = this.getConfig();
-    if (state.shortRun >= config.loopShortCount) {
+    if (state.sameTextRun >= config.loopRepeatText) {
+      this.log(`检测到空转循环 ${sessionId}: 连续 ${state.sameTextRun} 条相同消息`);
+      void this.interruptLoop(sessionId, state);
+    } else if (state.shortRun >= config.loopShortCount) {
       this.log(`检测到空转循环 ${sessionId}: 连续 ${state.shortRun} 条短句且无工具调用`);
       void this.interruptLoop(sessionId, state);
     } else if (state.toolRun !== void 0 && state.toolRun.count >= config.loopToolRepeat) {
@@ -568,9 +640,15 @@ ${frame.event.data.arguments}`;
         state.lastToolResult = void 0;
         state.shortRun = 0;
         state.lastShortAt = 0;
+        state.lastAssistantText = "";
+        state.sameTextRun = 0;
         state.toolRun = void 0;
         state.loopFired = false;
         state.loopCancelled = false;
+        if (state.loopRetryTimer !== void 0) {
+          clearTimeout(state.loopRetryTimer);
+          state.loopRetryTimer = void 0;
+        }
         this.cancelPending(sessionId, "宿主自行开启新回合");
         break;
       case "turn/end": {
@@ -580,21 +658,34 @@ ${frame.event.data.arguments}`;
         if (reason.kind === "completed") {
           state.consecutive = 0;
           state.lastFailure = void 0;
+          clearSendCount(sessionId);
           this.noteRecovery(sessionId, "completed");
         } else if (reason.kind === "aborted") {
           if (state.loopCancelled) {
             state.loopCancelled = false;
             state.loopFired = false;
-            state.consecutive = 0;
             state.pendingRecoveryAt = 0;
             state.shortRun = 0;
             state.lastShortAt = 0;
+            state.lastAssistantText = "";
+            state.sameTextRun = 0;
             state.toolRun = void 0;
-            state.lastAttemptAt = 0;
-            this.schedule(sessionId, "loop:aborted");
+            const cooldown = this.cooldownFor(state);
+            const remaining = cooldown - (Date.now() - state.lastAttemptAt);
+            if (remaining > 0) {
+              if (state.loopRetryTimer !== void 0) clearTimeout(state.loopRetryTimer);
+              state.loopRetryTimer = setTimeout(() => {
+                state.loopRetryTimer = void 0;
+                this.schedule(sessionId, "loop:aborted");
+              }, remaining);
+              this.log(`loop 重启延迟 ${remaining}ms(冷却期) ${sessionId}`);
+            } else {
+              this.schedule(sessionId, "loop:aborted");
+            }
           } else {
             state.consecutive = 0;
             state.pendingRecoveryAt = 0;
+            clearSendCount(sessionId);
           }
         } else if (reason.kind === "blocked") {
         } else if (reason.kind === "interrupted") {
@@ -619,9 +710,10 @@ ${frame.event.data.arguments}`;
         break;
       }
       case "user/message":
-        if (isOurEcho(state, event)) break;
+        if (isOurEcho(state, sessionId, event)) break;
         if (event.data.source.kind === "user") {
           state.consecutive = 0;
+          clearSendCount(sessionId);
           this.cancelPending(sessionId, "用户手动发送消息");
         }
         break;
@@ -793,12 +885,8 @@ ${frame.event.data.arguments}`;
       this.log(`跳过 ${sessionId}: 已有排队消息`);
       return;
     }
-    if (!force && Date.now() - readLastSend(sessionId) < this.cooldownFor(state)) {
-      this.log(`跳过 ${sessionId}: 其他标签页刚发送过`);
-      return;
-    }
-    if (!claimSend(sessionId)) {
-      this.log(`跳过 ${sessionId}: 其他标签页正在发送`);
+    if (!force && readSendCount(sessionId).count >= config.maxConsecutive) {
+      this.log(`跳过 ${sessionId}: 发送计数已达上限 ${config.maxConsecutive}, 等待用户介入或成功回合`);
       return;
     }
     const template = reason.startsWith("loop:") ? config.loopText : reason.includes("max-tokens") ? config.continueTextMaxTokens : config.continueText;
@@ -812,51 +900,65 @@ ${frame.event.data.arguments}`;
     }
     const text = this.buildContinueText(config, state, template, sessionTitle);
     const zone = clientTimeZone();
-    state.lastAttemptAt = Date.now();
-    try {
-      const response = await this.api.sessions.prompt({
-        sessionId,
-        mode: "queue",
-        content: [{ type: "text", text }],
-        ...zone === void 0 ? {} : { clientTimeZone: zone }
-      });
-      if (response.result.ok) {
-        const now = Date.now();
-        state.consecutive += 1;
-        state.lastAutoAt = now;
-        state.lastSentText = text;
-        state.pendingRecoveryAt = now;
-        writeLastSend(sessionId, now);
-        bumpStat({ sent: 1, ...state.lastFailure !== void 0 ? { code: state.lastFailure.code } : {} });
-        this.log(`已自动发送「${text}」到 ${sessionId}(${reason}), 第 ${state.consecutive} 次连续`);
-        if (config.notify) {
-          notify(
-            "dsh-auto-continue: 已自动继续",
-            `${sessionId}: 已发送「${text}」(第 ${state.consecutive} 次连续)`,
-            this.notifyOptions(sessionId)
-          );
-        }
-        if (state.consecutive >= config.maxConsecutive) {
-          bumpStat({ gaveUp: 1 });
-          this.log(`达到连续上限 ${config.maxConsecutive} 次, 停止自动继续 ${sessionId}`);
+    await withSendLock(sessionId, async () => {
+      if (this.disposed) return;
+      if (state.queued > 0) {
+        this.log(`跳过 ${sessionId}: 已有排队消息`);
+        return;
+      }
+      if (!force && Date.now() - readLastSend(sessionId) < this.cooldownFor(state)) {
+        this.log(`跳过 ${sessionId}: 其他标签页刚发送过`);
+        return;
+      }
+      if (!force && readSendCount(sessionId).count >= config.maxConsecutive) {
+        this.log(`跳过 ${sessionId}: 发送计数已达上限 ${config.maxConsecutive}, 等待用户介入或成功回合`);
+        return;
+      }
+      state.lastAttemptAt = Date.now();
+      try {
+        const response = await this.api.sessions.prompt({
+          sessionId,
+          mode: "queue",
+          content: [{ type: "text", text }],
+          ...zone === void 0 ? {} : { clientTimeZone: zone }
+        });
+        if (response.result.ok) {
+          const now = Date.now();
+          state.consecutive += 1;
+          state.lastAutoAt = now;
+          state.lastSentText = text;
+          state.pendingRecoveryAt = now;
+          writeLastSend(sessionId, now, text);
+          bumpSendCount(sessionId);
+          bumpStat({ sent: 1, ...state.lastFailure !== void 0 ? { code: state.lastFailure.code } : {} });
+          this.log(`已自动发送「${text}」到 ${sessionId}(${reason}), 第 ${state.consecutive} 次连续`);
           if (config.notify) {
             notify(
-              "dsh-auto-continue: 已停止自动继续",
-              `${sessionId}: 连续失败 ${state.consecutive} 次, 需要人工介入`,
+              "dsh-auto-continue: 已自动继续",
+              `${sessionId}: 已发送「${text}」(第 ${state.consecutive} 次连续)`,
               this.notifyOptions(sessionId)
             );
           }
+          if (state.consecutive >= config.maxConsecutive) {
+            bumpStat({ gaveUp: 1 });
+            this.log(`达到连续上限 ${config.maxConsecutive} 次, 停止自动继续 ${sessionId}`);
+            if (config.notify) {
+              notify(
+                "dsh-auto-continue: 已停止自动继续",
+                `${sessionId}: 连续失败 ${state.consecutive} 次, 需要人工介入`,
+                this.notifyOptions(sessionId)
+              );
+            }
+          }
+        } else {
+          this.log(
+            `发送失败 ${sessionId}: ${response.result.error.code} ${response.result.error.message}`
+          );
         }
-      } else {
-        this.log(
-          `发送失败 ${sessionId}: ${response.result.error.code} ${response.result.error.message}`
-        );
+      } catch (error) {
+        this.log(`发送异常 ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
       }
-    } catch (error) {
-      this.log(`发送异常 ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
-    } finally {
-      releaseSend(sessionId);
-    }
+    });
   }
   /**
    * 组装本次续跑消息: 模板填充 + 幂等护栏。
@@ -1082,6 +1184,8 @@ var zh = {
   "field.loopWindowMsHint": "连续短句必须落在这个时间窗内; 正常思考的短文本散布在长时间里不会被误判。",
   "field.loopShortCount": "连续短句阈值",
   "field.loopShortCountHint": "时间窗内连续多少条短句且期间无工具调用时判定空转循环。",
+  "field.loopRepeatText": "相同消息重复次数",
+  "field.loopRepeatTextHint": "连续输出多少条完全相同的消息时判定空转(最强信号, 不限长度, 如模型反复说同一句话)。",
   "field.loopToolRepeat": "同工具重复次数",
   "field.loopToolRepeatHint": "同工具+同参数+同结果的连续调用多少次时判定死循环; 参数或结果有变化视为有进展。",
   "field.loopText": "循环提示文本",
@@ -1165,6 +1269,8 @@ var en = {
   "field.loopWindowMsHint": "Consecutive short sentences must land inside this window; normal thinking spread over time is not misjudged.",
   "field.loopShortCount": "Short-sentence threshold",
   "field.loopShortCountHint": "How many consecutive short sentences inside the window, with no tool call, trip the loop guard.",
+  "field.loopRepeatText": "Identical message count",
+  "field.loopRepeatTextHint": "How many consecutive identical messages trip the guard (strongest signal, any length, e.g. the model repeating the same line).",
   "field.loopToolRepeat": "Same-tool repeat count",
   "field.loopToolRepeatHint": "How many consecutive calls of the same tool with identical arguments and results trip the loop guard; a changed argument or result counts as progress.",
   "field.loopText": "Loop text",
@@ -1578,6 +1684,7 @@ var AutoContinueSettingsCardController = class {
       numberField("loopShortChars", 1),
       numberField("loopWindowMs", 1e3),
       numberField("loopShortCount", 2),
+      numberField("loopRepeatText", 2),
       numberField("loopToolRepeat", 2),
       textField("loopText")
     ]);
@@ -1609,6 +1716,7 @@ var AutoContinueSettingsCardController = class {
       loopShortChars: this.form.field("loopShortChars"),
       loopWindowMs: this.form.field("loopWindowMs"),
       loopShortCount: this.form.field("loopShortCount"),
+      loopRepeatText: this.form.field("loopRepeatText"),
       loopToolRepeat: this.form.field("loopToolRepeat"),
       loopText: this.form.field("loopText")
     };
@@ -2150,6 +2258,19 @@ function AutoContinueSettingsCard(props) {
             onReset: () => props.resetField("loopToolRepeat")
           }
         ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          ValueField,
+          {
+            id: "auto-continue-loop-repeat-text",
+            label: t("field.loopRepeatText"),
+            hint: t("field.loopRepeatTextHint"),
+            numeric: true,
+            ...shared,
+            ...state.loopRepeatText,
+            onEdit: (text) => props.edit("loopRepeatText", text),
+            onReset: () => props.resetField("loopRepeatText")
+          }
+        ),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
           ValueField,
           {