dsh-client-auto-continue 0.7.1 → 0.7.3

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 consecutive short model messages with no tool call in between (the "Let me read…" spin), or the same tool called repeatedly, 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 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
 
@@ -175,8 +175,10 @@ auto-continue:
   notify: false
   loopGuard: true
   loopShortChars: 40
-  loopShortCount: 8
-  loopToolRepeat: 4
+  loopWindowMs: 30000
+  loopShortCount: 12
+  loopRepeatText: 4
+  loopToolRepeat: 5
   loopText: '(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)'
 ```
 
@@ -199,8 +201,10 @@ auto-continue:
 | Idempotency guard | `on` | Inspect the last tool call before resuming and steer the model (see What It Does) |
 | Loop guard | `on` | Detect a running turn spinning in place and restart it (see What It Does) |
 | Short-sentence max (chars) | `40` | A model message shorter than this counts as a short sentence (spinning signal) |
-| Short-sentence threshold | `8` | Consecutive short sentences with no tool call in between trip the loop guard |
-| Same-tool repeat count | `4` | Consecutive identical tool calls trip the loop guard |
+| 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 |
 | Guard text (tool succeeded) | `(上一步工具「{tool}」已完成, 结果: {result}; 不要重复执行, 直接继续)` | Appended when the last tool is confirmed done; `{tool}` / `{result}` placeholders |
@@ -239,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 — 34 behavioral scenarios
+npm run test        # node tests/simulate.mjs — 38 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…」空转)、或同一工具被连续反复调用且**参数与结果都相同**(参数或结果有变化视为有进展)。取消带有内部来源标记, 绝不会与用户手动停止混淆——只有守卫发起的取消才会重启。阈值、时间窗与提示文本都可配置
 - **统计面板** — 设置卡片展示今日自动继续次数、恢复成功、继续后失败、永久性跳过、达上限停止、循环打断, 按错误码统计, 可一键清零
 - **浏览器通知** — 可选: 自动继续成功 / 放弃 / 遇到永久性错误时弹出提醒; 首次使用时请求权限, 被拒绝后不再打扰
 
@@ -175,8 +175,10 @@ auto-continue:
   notify: false
   loopGuard: true
   loopShortChars: 40
-  loopShortCount: 8
-  loopToolRepeat: 4
+  loopWindowMs: 30000
+  loopShortCount: 12
+  loopRepeatText: 4
+  loopToolRepeat: 5
   loopText: '(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)'
 ```
 
@@ -199,8 +201,10 @@ auto-continue:
 | 幂等护栏 | 开 | 续跑前检查上一步工具调用并给出指引(见「它做什么」) |
 | 循环守卫 | 开 | 检测运行中的回合空转并重启(见「它做什么」) |
 | 短句长度上限 (字符) | `40` | 模型消息文本短于该值计为一条短句(空转信号) |
-| 连续短句阈值 | `8` | 连续多少条短句且期间无工具调用时判定空转循环 |
-| 相同工具连续次数 | `4` | 连续调用同一工具多少次时判定死循环 |
+| 短句时间窗 (ms) | `30000` | 连续短句必须落在这个时间窗内; 正常思考的短文本散布在长时间里不会被误判 |
+| 连续短句阈值 | `12` | 时间窗内连续多少条短句且期间无工具调用时判定空转循环 |
+| 相同消息重复次数 | `4` | 连续输出多少条完全相同的消息时判定空转(不限长度, 最强信号) |
+| 同工具重复次数 | `5` | 同工具+同参数+同结果的连续调用多少次时判定死循环 |
 | 循环提示文本 | `(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)` | 打断后重启回合时发送的文本; 支持 {tool} 占位符 |
 | 结果未确认时的护栏文本 | `(上一步工具「{tool}」可能未完成, 先确认状态再继续, 不要重复执行)` | 上一步工具可能已部分执行时附加; 支持 {tool} 占位符 |
 | 工具已成功时的护栏文本 | `(上一步工具「{tool}」已完成, 结果: {result}; 不要重复执行, 直接继续)` | 上一步工具已确认成功时附加; 支持 {tool} / {result} 占位符 |
@@ -239,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 — 34 个行为场景
+npm run test        # node tests/simulate.mjs — 38 个行为场景
 ```
 
 `npm run watch` 运行时, profile 的 client-hmr 行每 500ms 轮询 `lib/client.js` 并在浏览器中热重载插件——改代码无需重启服务。

package/lib/client.js

@@ -61,8 +61,10 @@ var DEFAULT_CONFIG = {
   paused: false,
   loopGuard: true,
   loopShortChars: 40,
-  loopShortCount: 8,
-  loopToolRepeat: 4,
+  loopWindowMs: 3e4,
+  loopShortCount: 12,
+  loopRepeatText: 4,
+  loopToolRepeat: 5,
   loopText: "(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)"
 };
 function numberOr(value, fallback) {
@@ -99,7 +101,9 @@ function resolveConfig(section) {
     paused: booleanOr(value.paused, DEFAULT_CONFIG.paused),
     loopGuard: booleanOr(value.loopGuard, DEFAULT_CONFIG.loopGuard),
     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
   };
@@ -331,6 +335,9 @@ var freshState = () => ({
   lastTurn: void 0,
   pendingRecoveryAt: 0,
   shortRun: 0,
+  lastShortAt: 0,
+  lastAssistantText: "",
+  sameTextRun: 0,
   toolRun: void 0,
   loopFired: false,
   loopCancelled: false
@@ -445,17 +452,32 @@ var AutoContinueRunner = class {
             state.lastTool = name;
             state.lastToolResult = "pending";
             state.shortRun = 0;
-            if (state.toolRun?.name === name) {
-              state.toolRun.count += 1;
+            const key = `${name}
+${frame.event.data.arguments}`;
+            if (state.toolRun?.key === key) {
+              state.toolRun.waiting = true;
             } else {
-              state.toolRun = { name, count: 1 };
+              state.toolRun = { key, count: 1, lastResult: void 0, waiting: false };
             }
-            this.checkLoop(frame.sessionId, state);
           }
         } else if (frame.event.type === "tool/result") {
           const state = this.state(frame.sessionId);
           if (state.lastToolResult === "pending") {
-            state.lastToolResult = toolResultFacts(frame.event.data);
+            const facts = toolResultFacts(frame.event.data);
+            state.lastToolResult = facts;
+            const run = state.toolRun;
+            if (run !== void 0 && run.waiting) {
+              run.waiting = false;
+              if (run.lastResult !== void 0 && run.lastResult === facts.excerpt) {
+                run.count += 1;
+                this.checkLoop(frame.sessionId, state);
+              } else {
+                run.lastResult = facts.excerpt;
+                run.count = 1;
+              }
+            } else if (run !== void 0 && !run.waiting) {
+              run.lastResult = facts.excerpt;
+            }
           }
         } else if (frame.event.type === "assistant/message") {
           const state = this.state(frame.sessionId);
@@ -481,16 +503,30 @@ var AutoContinueRunner = class {
     return content.filter((part) => part.type === "text").map((part) => part.text).join("");
   }
   /**
-   * loop guard 信号 1(空转): 连续短句且期间无工具调用。
-   * 短句 = 模型消息文本短于 loopShortChars; 长句或工具调用都会重置计数。
+   * loop guard 信号 1(空转): 时间窗内连续短句且期间无工具调用。
+   * 短句 = 模型消息文本短于 loopShortChars; 长句、工具调用、或短句间隔超过
+   * loopWindowMs(正常思考的短文本散布在长时间里)都会重置计数。
    */
   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;
+      }
       state.shortRun += 1;
+      state.lastShortAt = now;
     } else {
       state.shortRun = 0;
+      state.lastShortAt = 0;
     }
     this.checkLoop(sessionId, state);
   }
@@ -500,11 +536,15 @@ var AutoContinueRunner = class {
     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) {
-      this.log(`检测到工具死循环 ${sessionId}: 「${state.toolRun.name}」连续 ${state.toolRun.count} 次`);
+      const toolName = state.toolRun.key.split("\n")[0] ?? "?";
+      this.log(`检测到工具死循环 ${sessionId}: 「${toolName}」连续 ${state.toolRun.count} 次(同参数同结果)`);
       void this.interruptLoop(sessionId, state);
     }
   }
@@ -541,6 +581,9 @@ var AutoContinueRunner = class {
         state.lastTool = void 0;
         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;
@@ -561,6 +604,9 @@ var AutoContinueRunner = class {
             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");
@@ -1050,10 +1096,14 @@ var zh = {
   "field.loopGuardHint": "检测运行中的回合空转: 连续短句且无工具调用, 或连续调用相同工具时, 自动取消并用循环提示文本重启回合。",
   "field.loopShortChars": "短句长度上限 (字符)",
   "field.loopShortCharsHint": "模型消息文本短于该值计为一条短句(空转信号)。",
+  "field.loopWindowMs": "短句时间窗 (ms)",
+  "field.loopWindowMsHint": "连续短句必须落在这个时间窗内; 正常思考的短文本散布在长时间里不会被误判。",
   "field.loopShortCount": "连续短句阈值",
-  "field.loopShortCountHint": "连续多少条短句且期间无工具调用时判定空转循环。",
-  "field.loopToolRepeat": "相同工具连续次数",
-  "field.loopToolRepeatHint": "连续调用同一工具多少次时判定死循环。",
+  "field.loopShortCountHint": "时间窗内连续多少条短句且期间无工具调用时判定空转循环。",
+  "field.loopRepeatText": "相同消息重复次数",
+  "field.loopRepeatTextHint": "连续输出多少条完全相同的消息时判定空转(最强信号, 不限长度, 如模型反复说同一句话)。",
+  "field.loopToolRepeat": "同工具重复次数",
+  "field.loopToolRepeatHint": "同工具+同参数+同结果的连续调用多少次时判定死循环; 参数或结果有变化视为有进展。",
   "field.loopText": "循环提示文本",
   "field.loopTextHint": "打断后重启回合时发送的文本, 支持 {tool} 占位符。",
   "stats.byCode": "按错误码统计",
@@ -1131,10 +1181,14 @@ var en = {
   "field.loopGuardHint": "Detects a running turn spinning in place — many short sentences with no tool calls, or the same tool repeating — cancels it and restarts with the loop text.",
   "field.loopShortChars": "Short-sentence max (chars)",
   "field.loopShortCharsHint": "A model message shorter than this counts as a short sentence (spinning signal).",
+  "field.loopWindowMs": "Short-sentence window (ms)",
+  "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 with no tool call trip the loop guard.",
+  "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 identical tool calls trip the loop guard.",
+  "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",
   "field.loopTextHint": "Text sent after the loop guard restarts a turn; supports the {tool} placeholder.",
   "stats.byCode": "By error code",
@@ -1544,7 +1598,9 @@ var AutoContinueSettingsCardController = class {
       booleanField("notify"),
       booleanField("loopGuard"),
       numberField("loopShortChars", 1),
+      numberField("loopWindowMs", 1e3),
       numberField("loopShortCount", 2),
+      numberField("loopRepeatText", 2),
       numberField("loopToolRepeat", 2),
       textField("loopText")
     ]);
@@ -1574,7 +1630,9 @@ var AutoContinueSettingsCardController = class {
       notify: this.form.field("notify"),
       loopGuard: this.form.field("loopGuard"),
       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")
     };
@@ -2077,6 +2135,19 @@ function AutoContinueSettingsCard(props) {
             onReset: () => props.resetField("loopShortChars")
           }
         ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          ValueField,
+          {
+            id: "auto-continue-loop-window-ms",
+            label: t("field.loopWindowMs"),
+            hint: t("field.loopWindowMsHint"),
+            numeric: true,
+            ...shared,
+            ...state.loopWindowMs,
+            onEdit: (text) => props.edit("loopWindowMs", text),
+            onReset: () => props.resetField("loopWindowMs")
+          }
+        ),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
           ValueField,
           {
@@ -2103,6 +2174,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,
           {