dsh-client-auto-continue 0.6.3 → 0.7.1

package/README.md

@@ -43,7 +43,8 @@ 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
-- **Stats panel** — the settings card shows today's auto-continue count, recoveries, failures, permanent skips and give-ups, broken down by error code, with a one-click reset
+- **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
+- **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
 
 It watches the live event streams and reacts to:
@@ -172,6 +173,11 @@ auto-continue:
   backoffFactor: 2
   backoffMaxMs: 300000
   notify: false
+  loopGuard: true
+  loopShortChars: 40
+  loopShortCount: 8
+  loopToolRepeat: 4
+  loopText: '(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)'
 ```
 
 **How the card works:**
@@ -191,8 +197,13 @@ auto-continue:
 | Continue text | `继续` | Text automatically sent after an interruption |
 | Continue text (max tokens) | `继续` | Text sent when the output token ceiling is reached (same placeholders) |
 | Idempotency guard | `on` | Inspect the last tool call before resuming and steer the model (see What It Does) |
-| Guard text (unconfirmed result) | `(上一步工具「{tool}」可能未完成…)` | Appended when the last tool may have partially executed; `{tool}` placeholder |
-| Guard text (tool succeeded) | `(上一步工具「{tool}」已完成…)` | Appended when the last tool is confirmed done; `{tool}` / `{result}` placeholders |
+| 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 |
+| 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 |
 | Grace period (ms) | `3000` | Wait after an interruption; cancelled if the host recovers on its own |
 | Cooldown (ms) | `20000` | Min interval between auto-continues per session (failed attempts count too) |
 | Max consecutive | `3` | Max consecutive auto-continues; stops until a user intervenes or a turn completes |
@@ -228,7 +239,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 — 29 behavioral scenarios
+npm run test        # node tests/simulate.mjs — 34 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,8 @@
 - **幂等护栏** — 续跑前检查上一步工具调用: 结果未确认(回合在工具执行中途夭折, 如 `git push` 可能已经推上去了)时, 续跑消息会提示模型先确认状态、不要重复执行; 工具已确认成功时说明已完成、请勿重复; 工具失败则不加护栏(重试本来就是目的)。两段护栏文本都可配置(支持 `{tool}` / `{result}` 占位符)
 - **暂停** — 设置卡片里的全局 **暂停自动继续** 开关可立即停掉一切(实时 + 扫描); 会话级暂停(如通过通知按钮)只挂起单个会话, 到期自动恢复。唯一的显式例外是通知里的 **立即续跑** 按钮——按下它等于用户明确要求发送这一次, 不受暂停限制
 - **通知按钮** — 通知带 **立即续跑**(无视冷却、连续上限与暂停, 马上发送)和 **暂停该会话 1 小时** 按钮
-- **统计面板** — 设置卡片展示今日自动继续次数、恢复成功、继续后失败、永久性跳过、达上限停止, 按错误码分布, 可一键清零
+- **循环守卫** — 连**运行中的回合**也盯着: 连续多条短句且期间无工具调用(典型的「Let me read…」空转), 或同一工具被连续反复调用, 都会触发守卫: 取消当前回合并用可配置的循环提示文本重启(「停止重复, 换一种方式」)。取消带有内部来源标记, 绝不会与用户手动停止混淆——只有守卫发起的取消才会重启。阈值与提示文本都可配置
+- **统计面板** — 设置卡片展示今日自动继续次数、恢复成功、继续后失败、永久性跳过、达上限停止、循环打断, 按错误码统计, 可一键清零
 - **浏览器通知** — 可选: 自动继续成功 / 放弃 / 遇到永久性错误时弹出提醒; 首次使用时请求权限, 被拒绝后不再打扰
 
 插件监听实时事件流, 对以下情况作出反应:
@@ -172,6 +173,11 @@ auto-continue:
   backoffFactor: 2
   backoffMaxMs: 300000
   notify: false
+  loopGuard: true
+  loopShortChars: 40
+  loopShortCount: 8
+  loopToolRepeat: 4
+  loopText: '(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)'
 ```
 
 **卡片操作说明:**
@@ -191,8 +197,13 @@ auto-continue:
 | 继续文本 | `继续` | 中断后自动发送的消息内容 |
 | 超限时的继续文本 | `继续` | 达到输出 token 上限时自动发送的文本(支持相同占位符) |
 | 幂等护栏 | 开 | 续跑前检查上一步工具调用并给出指引(见「它做什么」) |
-| 结果未确认时的护栏文本 | `(上一步工具「{tool}」可能未完成…)` | 上一步工具可能已部分执行时附加; 支持 {tool} 占位符 |
-| 工具已成功时的护栏文本 | `(上一步工具「{tool}」已完成…)` | 上一步工具已确认成功时附加; 支持 {tool} / {result} 占位符 |
+| 循环守卫 | 开 | 检测运行中的回合空转并重启(见「它做什么」) |
+| 短句长度上限 (字符) | `40` | 模型消息文本短于该值计为一条短句(空转信号) |
+| 连续短句阈值 | `8` | 连续多少条短句且期间无工具调用时判定空转循环 |
+| 相同工具连续次数 | `4` | 连续调用同一工具多少次时判定死循环 |
+| 循环提示文本 | `(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)` | 打断后重启回合时发送的文本; 支持 {tool} 占位符 |
+| 结果未确认时的护栏文本 | `(上一步工具「{tool}」可能未完成, 先确认状态再继续, 不要重复执行)` | 上一步工具可能已部分执行时附加; 支持 {tool} 占位符 |
+| 工具已成功时的护栏文本 | `(上一步工具「{tool}」已完成, 结果: {result}; 不要重复执行, 直接继续)` | 上一步工具已确认成功时附加; 支持 {tool} / {result} 占位符 |
 | 宽限期 (ms) | `3000` | 中断后等待的时长; 期间宿主自行恢复则取消 |
 | 冷却时间 (ms) | `20000` | 同一会话两次自动「继续」的最小间隔(失败尝试也计入) |
 | 最大连续次数 | `3` | 同一会话连续自动「继续」上限; 超过后停止, 直到用户介入或成功回合 |
@@ -228,7 +239,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 — 29 个行为场景
+npm run test        # node tests/simulate.mjs — 34 个行为场景
 ```
 
 `npm run watch` 运行时, profile 的 client-hmr 行每 500ms 轮询 `lib/client.js` 并在浏览器中热重载插件——改代码无需重启服务。

package/lib/client.js

@@ -58,7 +58,12 @@ var DEFAULT_CONFIG = {
   backoffFactor: 2,
   backoffMaxMs: 3e5,
   notify: false,
-  paused: false
+  paused: false,
+  loopGuard: true,
+  loopShortChars: 40,
+  loopShortCount: 8,
+  loopToolRepeat: 4,
+  loopText: "(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)"
 };
 function numberOr(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
@@ -91,7 +96,12 @@ function resolveConfig(section) {
     backoffFactor: Math.max(1, numberOr(value.backoffFactor, DEFAULT_CONFIG.backoffFactor)),
     backoffMaxMs: numberOr(value.backoffMaxMs, DEFAULT_CONFIG.backoffMaxMs),
     notify: booleanOr(value.notify, DEFAULT_CONFIG.notify),
-    paused: booleanOr(value.paused, DEFAULT_CONFIG.paused)
+    paused: booleanOr(value.paused, DEFAULT_CONFIG.paused),
+    loopGuard: booleanOr(value.loopGuard, DEFAULT_CONFIG.loopGuard),
+    loopShortChars: Math.max(1, numberOr(value.loopShortChars, DEFAULT_CONFIG.loopShortChars)),
+    loopShortCount: Math.max(2, numberOr(value.loopShortCount, DEFAULT_CONFIG.loopShortCount)),
+    loopToolRepeat: Math.max(2, numberOr(value.loopToolRepeat, DEFAULT_CONFIG.loopToolRepeat)),
+    loopText: typeof value.loopText === "string" && value.loopText.trim() !== "" ? value.loopText : DEFAULT_CONFIG.loopText
   };
 }
 function isNonHumanReason(kind) {
@@ -285,7 +295,7 @@ function bumpStat(delta) {
   const list = readStats();
   let day = list.find((item) => item.date === todayKey());
   if (day === void 0) {
-    day = { date: todayKey(), sent: 0, skipped: 0, recovered: 0, failed: 0, gaveUp: 0, byCode: {} };
+    day = { date: todayKey(), sent: 0, skipped: 0, recovered: 0, failed: 0, gaveUp: 0, looped: 0, byCode: {} };
     list.unshift(day);
   }
   if (delta.sent !== void 0) day.sent += delta.sent;
@@ -293,13 +303,14 @@ function bumpStat(delta) {
   if (delta.recovered !== void 0) day.recovered += delta.recovered;
   if (delta.failed !== void 0) day.failed += delta.failed;
   if (delta.gaveUp !== void 0) day.gaveUp += delta.gaveUp;
+  if (delta.looped !== void 0) day.looped += delta.looped;
   if (delta.code !== void 0) day.byCode[delta.code] = (day.byCode[delta.code] ?? 0) + 1;
   writeStats(list.slice(0, STATS_MAX_DAYS));
 }
 function readTodayStats() {
   const today = todayKey();
   const found = readStats().find((item) => item.date === today);
-  return found ?? { date: today, sent: 0, skipped: 0, recovered: 0, failed: 0, gaveUp: 0, byCode: {} };
+  return found ?? { date: today, sent: 0, skipped: 0, recovered: 0, failed: 0, gaveUp: 0, looped: 0, byCode: {} };
 }
 function resetTodayStats() {
   writeStats(readStats().filter((item) => item.date !== todayKey()));
@@ -318,7 +329,11 @@ var freshState = () => ({
   lastTool: void 0,
   lastToolResult: void 0,
   lastTurn: void 0,
-  pendingRecoveryAt: 0
+  pendingRecoveryAt: 0,
+  shortRun: 0,
+  toolRun: void 0,
+  loopFired: false,
+  loopCancelled: false
 });
 var RECOVERY_WINDOW_MS = 10 * 60 * 1e3;
 function isOurEcho(state, event) {
@@ -429,12 +444,22 @@ var AutoContinueRunner = class {
             const state = this.state(frame.sessionId);
             state.lastTool = name;
             state.lastToolResult = "pending";
+            state.shortRun = 0;
+            if (state.toolRun?.name === name) {
+              state.toolRun.count += 1;
+            } else {
+              state.toolRun = { name, count: 1 };
+            }
+            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);
           }
+        } else if (frame.event.type === "assistant/message") {
+          const state = this.state(frame.sessionId);
+          this.onAssistantMessage(frame.sessionId, state, frame.event);
         }
         this.onSessionEvent(frame.sessionId, frame.event);
         break;
@@ -449,6 +474,65 @@ var AutoContinueRunner = class {
         break;
     }
   }
+  /** 从 assistant/message 事件提取纯文本。 */
+  assistantText(event) {
+    const content = event.data.message.content;
+    if (!Array.isArray(content)) return "";
+    return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+  }
+  /**
+   * loop guard 信号 1(空转): 连续短句且期间无工具调用。
+   * 短句 = 模型消息文本短于 loopShortChars; 长句或工具调用都会重置计数。
+   */
+  onAssistantMessage(sessionId, state, event) {
+    if (!this.getConfig().loopGuard) return;
+    const text = this.assistantText(event);
+    if (text.trim().length < this.getConfig().loopShortChars) {
+      state.shortRun += 1;
+    } else {
+      state.shortRun = 0;
+    }
+    this.checkLoop(sessionId, state);
+  }
+  /** 两个循环信号的公共检查; 命中且本回合未打断过则打断。 */
+  checkLoop(sessionId, state) {
+    if (!this.getConfig().loopGuard) return;
+    if (state.loopFired) return;
+    if (!state.running) return;
+    const config = this.getConfig();
+    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} 次`);
+      void this.interruptLoop(sessionId, state);
+    }
+  }
+  /**
+   * 打断运行中的回合: cancel(带来源标记)+ 进冷却。
+   * 随后的 turn/end aborted 会因 loopCancelled 走「可恢复中断」路径,
+   * 用 loopText 重启回合——不会与用户手动停止混淆。
+   */
+  async interruptLoop(sessionId, state) {
+    if (state.loopFired) return;
+    if (Date.now() - state.lastAttemptAt < this.cooldownFor(state)) {
+      this.log(`跳过循环打断 ${sessionId}: 处于冷却期`);
+      return;
+    }
+    state.loopFired = true;
+    state.loopCancelled = true;
+    state.lastAttemptAt = Date.now();
+    bumpStat({ looped: 1 });
+    try {
+      const response = await this.api.sessions.cancel({ sessionId });
+      this.log(
+        `已打断循环 ${sessionId}: ${response.result.ok ? "cancel 已受理" : "cancel 被拒绝"}`
+      );
+    } catch (error) {
+      this.log(`打断循环失败 ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+      state.loopCancelled = false;
+    }
+  }
   onSessionEvent(sessionId, event) {
     const state = this.state(sessionId);
     switch (event.type) {
@@ -456,6 +540,10 @@ var AutoContinueRunner = class {
         state.running = true;
         state.lastTool = void 0;
         state.lastToolResult = void 0;
+        state.shortRun = 0;
+        state.toolRun = void 0;
+        state.loopFired = false;
+        state.loopCancelled = false;
         this.cancelPending(sessionId, "宿主自行开启新回合");
         break;
       case "turn/end": {
@@ -467,8 +555,19 @@ var AutoContinueRunner = class {
           state.lastFailure = void 0;
           this.noteRecovery(sessionId, "completed");
         } else if (reason.kind === "aborted") {
-          state.consecutive = 0;
-          state.pendingRecoveryAt = 0;
+          if (state.loopCancelled) {
+            state.loopCancelled = false;
+            state.loopFired = false;
+            state.consecutive = 0;
+            state.pendingRecoveryAt = 0;
+            state.shortRun = 0;
+            state.toolRun = void 0;
+            state.lastAttemptAt = 0;
+            this.schedule(sessionId, "loop:aborted");
+          } else {
+            state.consecutive = 0;
+            state.pendingRecoveryAt = 0;
+          }
         } else if (reason.kind === "blocked") {
         } else if (reason.kind === "interrupted") {
           state.consecutive = 0;
@@ -636,7 +735,7 @@ var AutoContinueRunner = class {
       void this.fire(sessionId, reason);
     }, config.graceMs);
     state.pendingTimer = timer;
-    const template = reason.includes("max-tokens") ? config.continueTextMaxTokens : config.continueText;
+    const template = reason.startsWith("loop:") ? config.loopText : reason.includes("max-tokens") ? config.continueTextMaxTokens : config.continueText;
     this.log(
       `检测到非人为中断 ${sessionId}(${reason}), ${config.graceMs}ms 后自动发送「${template}」`
     );
@@ -674,7 +773,7 @@ var AutoContinueRunner = class {
       this.log(`跳过 ${sessionId}: 其他标签页正在发送`);
       return;
     }
-    const template = reason.includes("max-tokens") ? config.continueTextMaxTokens : config.continueText;
+    const template = reason.startsWith("loop:") ? config.loopText : reason.includes("max-tokens") ? config.continueTextMaxTokens : config.continueText;
     let sessionTitle;
     if (template.includes("{sessionTitle}")) {
       sessionTitle = this.titles.get(sessionId);
@@ -946,6 +1045,17 @@ var zh = {
   "stats.recovered": "恢复成功",
   "stats.failed": "继续后仍失败",
   "stats.gaveUp": "停止(达上限)",
+  "stats.looped": "循环打断",
+  "field.loopGuard": "循环守卫",
+  "field.loopGuardHint": "检测运行中的回合空转: 连续短句且无工具调用, 或连续调用相同工具时, 自动取消并用循环提示文本重启回合。",
+  "field.loopShortChars": "短句长度上限 (字符)",
+  "field.loopShortCharsHint": "模型消息文本短于该值计为一条短句(空转信号)。",
+  "field.loopShortCount": "连续短句阈值",
+  "field.loopShortCountHint": "连续多少条短句且期间无工具调用时判定空转循环。",
+  "field.loopToolRepeat": "相同工具连续次数",
+  "field.loopToolRepeatHint": "连续调用同一工具多少次时判定死循环。",
+  "field.loopText": "循环提示文本",
+  "field.loopTextHint": "打断后重启回合时发送的文本, 支持 {tool} 占位符。",
   "stats.byCode": "按错误码统计",
   "stats.empty": "今天还没有自动继续记录。",
   "stats.reset": "清零",
@@ -1016,6 +1126,17 @@ var en = {
   "stats.recovered": "Recovered",
   "stats.failed": "Failed after",
   "stats.gaveUp": "Gave up (cap)",
+  "stats.looped": "Loops broken",
+  "field.loopGuard": "Loop guard",
+  "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.loopShortCount": "Short-sentence threshold",
+  "field.loopShortCountHint": "How many consecutive short sentences with no tool call trip the loop guard.",
+  "field.loopToolRepeat": "Same-tool repeat count",
+  "field.loopToolRepeatHint": "How many consecutive identical tool calls trip the loop guard.",
+  "field.loopText": "Loop text",
+  "field.loopTextHint": "Text sent after the loop guard restarts a turn; supports the {tool} placeholder.",
   "stats.byCode": "By error code",
   "stats.empty": "No auto-continue activity today.",
   "stats.reset": "Reset",
@@ -1420,7 +1541,12 @@ var AutoContinueSettingsCardController = class {
       booleanField("classify"),
       numberField("backoffFactor", 1),
       numberField("backoffMaxMs", 0),
-      booleanField("notify")
+      booleanField("notify"),
+      booleanField("loopGuard"),
+      numberField("loopShortChars", 1),
+      numberField("loopShortCount", 2),
+      numberField("loopToolRepeat", 2),
+      textField("loopText")
     ]);
     this.store = this.form.bind(() => this.projection(), import_client.createSnapshotStore);
   }
@@ -1445,7 +1571,12 @@ var AutoContinueSettingsCardController = class {
       classify: this.form.field("classify"),
       backoffFactor: this.form.field("backoffFactor"),
       backoffMaxMs: this.form.field("backoffMaxMs"),
-      notify: this.form.field("notify")
+      notify: this.form.field("notify"),
+      loopGuard: this.form.field("loopGuard"),
+      loopShortChars: this.form.field("loopShortChars"),
+      loopShortCount: this.form.field("loopShortCount"),
+      loopToolRepeat: this.form.field("loopToolRepeat"),
+      loopText: this.form.field("loopText")
     };
   }
   /**
@@ -1563,7 +1694,7 @@ function LivePanels(props) {
     return () => clearInterval(timer);
   }, []);
   const stats = readTodayStats();
-  const hasStats = stats.sent + stats.skipped + stats.recovered + stats.failed + stats.gaveUp > 0;
+  const hasStats = stats.sent + stats.skipped + stats.recovered + stats.failed + stats.gaveUp + stats.looped > 0;
   const codes = Object.entries(stats.byCode).sort((a, b) => b[1] - a[1]).slice(0, 5);
   const paused = pausedSessions();
   return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
@@ -1604,6 +1735,10 @@ function LivePanels(props) {
           /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
             /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: t("stats.gaveUp") }),
             /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { children: stats.gaveUp })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: t("stats.looped") }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { children: stats.looped })
           ] })
         ] }),
         codes.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dshAcCodes", children: [
@@ -1697,6 +1832,7 @@ function AutoContinueSettingsCard(props) {
             ...shared,
             ...state.continueText,
             onEdit: (text) => props.edit("continueText", text),
+            placeholder: DEFAULT_CONFIG.continueText,
             onReset: () => props.resetField("continueText")
           }
         ),
@@ -1709,6 +1845,7 @@ function AutoContinueSettingsCard(props) {
             ...shared,
             ...state.continueTextMaxTokens,
             onEdit: (text) => props.edit("continueTextMaxTokens", text),
+            placeholder: DEFAULT_CONFIG.continueTextMaxTokens,
             onReset: () => props.resetField("continueTextMaxTokens")
           }
         ),
@@ -1733,6 +1870,7 @@ function AutoContinueSettingsCard(props) {
             ...shared,
             ...state.guardPendingText,
             onEdit: (text) => props.edit("guardPendingText", text),
+            placeholder: DEFAULT_CONFIG.guardPendingText,
             onReset: () => props.resetField("guardPendingText")
           }
         ),
@@ -1745,6 +1883,7 @@ function AutoContinueSettingsCard(props) {
             ...shared,
             ...state.guardDoneText,
             onEdit: (text) => props.edit("guardDoneText", text),
+            placeholder: DEFAULT_CONFIG.guardDoneText,
             onReset: () => props.resetField("guardDoneText")
           }
         ),
@@ -1913,6 +2052,70 @@ function AutoContinueSettingsCard(props) {
             onReset: () => props.resetField("notify")
           }
         ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          BooleanField,
+          {
+            id: "auto-continue-loop-guard",
+            label: t("field.loopGuard"),
+            hint: t("field.loopGuardHint"),
+            ...shared,
+            ...state.loopGuard,
+            onEdit: (text) => props.edit("loopGuard", text),
+            onReset: () => props.resetField("loopGuard")
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          ValueField,
+          {
+            id: "auto-continue-loop-short-chars",
+            label: t("field.loopShortChars"),
+            hint: t("field.loopShortCharsHint"),
+            numeric: true,
+            ...shared,
+            ...state.loopShortChars,
+            onEdit: (text) => props.edit("loopShortChars", text),
+            onReset: () => props.resetField("loopShortChars")
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          ValueField,
+          {
+            id: "auto-continue-loop-short-count",
+            label: t("field.loopShortCount"),
+            hint: t("field.loopShortCountHint"),
+            numeric: true,
+            ...shared,
+            ...state.loopShortCount,
+            onEdit: (text) => props.edit("loopShortCount", text),
+            onReset: () => props.resetField("loopShortCount")
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          ValueField,
+          {
+            id: "auto-continue-loop-tool-repeat",
+            label: t("field.loopToolRepeat"),
+            hint: t("field.loopToolRepeatHint"),
+            numeric: true,
+            ...shared,
+            ...state.loopToolRepeat,
+            onEdit: (text) => props.edit("loopToolRepeat", text),
+            onReset: () => props.resetField("loopToolRepeat")
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          ValueField,
+          {
+            id: "auto-continue-loop-text",
+            label: t("field.loopText"),
+            hint: t("field.loopTextHint"),
+            ...shared,
+            ...state.loopText,
+            onEdit: (text) => props.edit("loopText", text),
+            placeholder: DEFAULT_CONFIG.loopText,
+            onReset: () => props.resetField("loopText")
+          }
+        ),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LivePanels, { t })
       ]
     }