opencode-auto-resume 1.1.17 → 1.1.19

package/README.md

@@ -46,6 +46,20 @@ A separate **tool-call loop detector** catches the model calling the same tool 3
 
 Loop detection runs in two places. At idle, tool names are scanned from recent assistant messages. **Live**, every `tool.execute.before` hook fingerprints the call as `tool name + arguments` — so a subagent stuck re-reading the same file/range (even alternating between two near-identical argument sets, which never produces 3 consecutive identical calls) is caught after 6+ calls in the repeating cycle. On live detection the plugin aborts the running turn immediately (this is the sanctioned exception to the never-abort-busy rule: 6+ identical name+args fingerprints prove a hallucinated loop, and the current call has not started yet) and then sends `TOOL_LOOP_RECOVERY_PROMPT`. Esc-cancelled sessions are never touched.
 
+---
+
+### Unknown tool suggestion
+
+When the model calls a tool that does not exist (a typo, a hallucinated name, or a tool from a different plugin that isn't loaded), OpenCode returns a `tool` part with `state.status = "error"`. If the same wrong tool name appears **2 times** in the session's message history, the plugin:
+
+1. Fetches the list of available tools via `ctx.client.tool.ids()` (cached for 5 minutes).
+2. Computes the closest match by Levenshtein distance (case-insensitive, threshold = half the wrong name's length).
+3. Sends a continue prompt that names the wrong tool, states it does not exist, suggests the closest match (if one was found), and lists the first 20 available tools for reference.
+
+The suggestion fires once per busy cycle. A new user message resets the counter so the suggestion can fire again on a fresh cycle. Tool parts that already succeeded (`state.status = "completed"`) and parts for tools that do exist are skipped.
+
+Threshold and cache are compile-time constants (`UNKNOWN_TOOL_THRESHOLD = 2`, `TOOL_IDS_CACHE_MS = 5 min`). The detection runs at idle, alongside the tool-text recovery check.
+
 _Motivated by:_
 - [#22142](https://github.com/anomalyco/opencode/issues/22142) — Repetitive tool-call loops with alibaba-coding-plan-cn/qwen3.6-plus
 - [#16218](https://github.com/anomalyco/opencode/issues/16218) — Model repeats the same response in a loop after generating an answer
@@ -203,6 +217,8 @@ The agent can call the built-in `task_complete` tool to signal that all work is
 
 If `task_complete` is called while open todos remain, the call is rejected (up to `maxRetries` times) with a message asking the agent to finish the remaining work first.
 
+Repeat calls with no new user message in between are guarded: the first acknowledgement carries an explicit stop instruction, the second returns a repeat warning, and the third and subsequent calls are rejected as errors. This breaks the ack self-loop where the acknowledgement tool-result is fed back into the turn and a stuck model re-emits `task_complete` instead of ending with text. The counter resets on a genuine user message, on the block path above, or when any other tool runs in between.
+
 ---
 
 ### 🎉 emoji completion
@@ -312,6 +328,10 @@ session.status events:
 
 todo.updated events:
   └─ track real todo state (not regex on message text)
+     └─ if missing (no event received): idle path + task_complete
+        fetch on-demand via session.todo() API so the
+        open-todos reminder and the 🎉 completion latch see
+        real state, not a stale empty array.
 
 Timer loop (every 5s):
   for each busy session:
@@ -395,6 +415,8 @@ With options:
 | `thinkingToolRecoveryPrompt` | `THINKING_TOOL_RECOVERY_PROMPT` | Override the thinking-tool recovery prompt |
 | `doneWithoutWorkPrompt` | `DONE_WITHOUT_WORK_PROMPT` | Override the done-claim-with-open-todos prompt |
 | `doneWithoutDetailsPrompt` | `DONE_WITHOUT_DETAILS_PROMPT` | Override the done-claim-with-no-todos report prompt |
+| `doneClaimPatterns` | `DONE_CLAIM_PATTERNS` | Array of regex strings overriding the default done-claim detection patterns (case-insensitive, multiline). Invalid regexes are skipped. Empty array falls back to defaults. |
+| `readyToContinuePatterns` | `READY_TO_CONTINUE_PATTERNS` | Array of regex strings overriding the default ready-to-continue detection patterns (case-insensitive). Invalid regexes are skipped. Empty array falls back to defaults. |
 | `silentDeadStreamMinTokens` | `200` | Min output tokens to treat a textless `finish:"unknown"` message as a dead stream |
 | `busyStallStrategy` | `"continue"` | Busy-stall response: `"continue"`, `"abort"` (abort-first), or `"off"` (disabled) |
 | `contextSaturationThreshold` | `0.85` | Ratio of used/usable context that routes a saturated parent to magic-context `ctx-wrapup` (only when magic-context is installed) |

package/dist/index.js

@@ -12363,7 +12363,8 @@ var DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS = [
   "streaming response failed",
   "stream.*fail",
   "connection.*reset",
-  "connection.*closed"
+  "connection.*closed",
+  "aborted due to timeout"
 ];
 var MAX_IDLE_SESSIONS = 50;
 var IDLE_CLEANUP_MS = 10 * 60000;
@@ -12371,7 +12372,12 @@ var SESSION_DISCOVERY_INTERVAL_MS = 60000;
 var TOOL_TEXT_RECOVERY_PROMPT = "Your last message contained a raw tool call printed as text instead of being executed. " + "Please use the proper tool calling mechanism to execute it.";
 var THINKING_TOOL_RECOVERY_PROMPT = "I noticed you have a tool call generated in your thinking/reasoning. " + "Please execute it using the proper tool calling mechanism instead of keeping it in reasoning.";
 var TOOL_LOOP_RECOVERY_PROMPT = "I notice you've been calling the same tool multiple times in a row without making progress. " + "Please step back and reassess your approach. Consider: " + "1) Are you stuck in a loop? 2) Do you need different information first? " + "3) Should you try a different tool or break the task into smaller steps? " + "Take a moment to think about what's blocking you and propose a different strategy.";
+var TASK_COMPLETE_ACK = "Task completion acknowledged. No further continuation will be sent. " + "End your turn now with a brief text reply \u2014 do not call task_complete or any other tool again " + "unless the user sends a new message.";
+var TASK_COMPLETE_REPEAT_WARNING = "Task completion acknowledged already on your previous call \u2014 completion is recorded. " + "End your turn now with a brief text reply. Do not call task_complete again; " + "further repeat calls are rejected as errors.";
+var TASK_COMPLETE_REPEAT_ERROR = "task_complete already acknowledged twice with no new user message or tool work since \u2014 " + "completion is recorded. End your turn with text and make no further tool calls.";
 var CTX_WRAPUP_TRIGGER = "ctx-wrapup";
+var UNKNOWN_TOOL_THRESHOLD = 2;
+var TOOL_IDS_CACHE_MS = 5 * 60000;
 var TOOL_TEXT_PATTERNS = [
   /<function\s*=/i,
   /<function>/i,
@@ -12422,7 +12428,7 @@ function containsToolCallAsText(text) {
   }
   return false;
 }
-function containsReadyToContinuePattern(text) {
+function containsReadyToContinuePattern(text, patterns = READY_TO_CONTINUE_PATTERNS) {
   const lines = text.split(`
 `);
   const lastLine = lines[lines.length - 1]?.trim();
@@ -12430,7 +12436,7 @@ function containsReadyToContinuePattern(text) {
     return false;
   const lastLines = lines.slice(-3).join(`
 `);
-  return READY_TO_CONTINUE_PATTERNS.some((pat) => pat.test(lastLines));
+  return patterns.some((pat) => pat.test(lastLines));
 }
 var DONE_CLAIM_PATTERNS = [
   /^task\s+done[.!]*$/im,
@@ -12450,12 +12456,12 @@ var DONE_CLAIM_PATTERNS = [
 ];
 var DONE_WITHOUT_WORK_PROMPT = "I need you to verify more carefully that you have actually completed all the required tasks. " + "Your response indicated you're done, but no work was detected. Please check your todo list " + "and complete any remaining work.";
 var DONE_WITHOUT_DETAILS_PROMPT = "Your last response claimed the task is complete but contained no work description. This is not acceptable. " + "You MUST respond now with a full, detailed report of everything you did: " + "for each file you modified, state the full path and the exact changes; " + "list every command you ran to verify and its result; state the final outcome. " + "Do NOT reply with 'done', 'task completed', or any short acknowledgment \u2014 " + "your ONLY acceptable response right now is this detailed report. Write it now.";
-function containsDoneClaimPattern(text) {
+function containsDoneClaimPattern(text, patterns = DONE_CLAIM_PATTERNS) {
   const lines = text.split(`
 `);
   const lastLines = lines.slice(-5).join(`
 `);
-  return DONE_CLAIM_PATTERNS.some((pat) => pat.test(lastLines));
+  return patterns.some((pat) => pat.test(lastLines));
 }
 function containsWorkDescription(text) {
   if (/`[^`\n]*\.[a-zA-Z0-9]{1,8}[^`\n]*`/.test(text))
@@ -12466,6 +12472,42 @@ function containsWorkDescription(text) {
     return true;
   return false;
 }
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  if (m === 0)
+    return n;
+  if (n === 0)
+    return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0;j <= n; j++)
+    prev[j] = j;
+  for (let i = 1;i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1;j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    const tmp = prev;
+    prev = curr;
+    curr = tmp;
+  }
+  return prev[n];
+}
+function suggestClosestTool(wrongName, available) {
+  const lower = wrongName.toLowerCase();
+  let best = null;
+  let bestDist = Infinity;
+  for (const id of available) {
+    const dist = levenshtein(lower, id.toLowerCase());
+    const threshold = Math.max(2, Math.floor(lower.length / 2));
+    if (dist < bestDist && dist <= threshold) {
+      bestDist = dist;
+      best = id;
+    }
+  }
+  return best;
+}
 function isStreamingFailure(errorName, errorMessage, errorNames = DEFAULT_STREAMING_FAILURE_ERROR_NAMES, messagePatterns = DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS) {
   if (!errorName && !errorMessage)
     return false;
@@ -12633,6 +12675,30 @@ var AutoResumePlugin = async (ctx, options) => {
   const contextSaturationThreshold = options?.contextSaturationThreshold ?? 0.85;
   const subagentNativeCompactionEnabled = options?.subagentNativeCompactionEnabled ?? false;
   const activeUserWindowMs = options?.activeUserWindowMs ?? DEFAULT_ACTIVE_USER_WINDOW_MS;
+  const doneClaimPatterns = (() => {
+    const raw = options?.doneClaimPatterns;
+    if (!Array.isArray(raw) || raw.length === 0)
+      return DONE_CLAIM_PATTERNS;
+    return raw.map((s) => {
+      try {
+        return new RegExp(s, "im");
+      } catch {
+        return null;
+      }
+    }).filter((r) => r !== null);
+  })();
+  const readyToContinuePatterns = (() => {
+    const raw = options?.readyToContinuePatterns;
+    if (!Array.isArray(raw) || raw.length === 0)
+      return READY_TO_CONTINUE_PATTERNS;
+    return raw.map((s) => {
+      try {
+        return new RegExp(s, "i");
+      } catch {
+        return null;
+      }
+    }).filter((r) => r !== null);
+  })();
   const dbg = (...args) => {
     if (debug)
       console.log("[debug]", ...args);
@@ -12707,6 +12773,7 @@ var AutoResumePlugin = async (ctx, options) => {
         orphanWatchStartAt: null,
         aborting: false,
         pluginAbortInFlight: false,
+        pluginAbortAt: 0,
         toolTextRecovered: false,
         toolTextAttempts: 0,
         continueTimestamps: [],
@@ -12727,6 +12794,7 @@ var AutoResumePlugin = async (ctx, options) => {
         completionSignaled: false,
         todoNudgeAttempts: 0,
         taskCompleteOverrides: 0,
+        taskCompleteSignals: 0,
         doneClaimNoTodosAttempts: 0,
         lastUserMessageAt: 0,
         pendingTools: 0,
@@ -12735,7 +12803,10 @@ var AutoResumePlugin = async (ctx, options) => {
         pendingRecoveryReason: null,
         pendingRecoveryAt: 0,
         recoveryAttempts: 0,
-        watchdogRetryGuard: false
+        watchdogRetryGuard: false,
+        unknownToolErrors: new Map,
+        unknownToolSuggestionSent: false,
+        checkedToolPartIDs: new Set
       };
       sessions.set(sid, w);
     }
@@ -12871,6 +12942,10 @@ var AutoResumePlugin = async (ctx, options) => {
     }
     if (w.userCancelled || w.completionSignaled)
       return;
+    if (w.gaveUp) {
+      await log("debug", `${short(sid)} - gaveUp latched, refusing further continue prompts`);
+      return;
+    }
     if (!w.continuing)
       dbg(`State transition on ${short(sid)}: continuing=false -> true`);
     w.continuing = true;
@@ -12972,7 +13047,6 @@ var AutoResumePlugin = async (ctx, options) => {
             } catch (err) {
               const errMsg = err instanceof Error ? err.message : String(err);
               await log("warn", `${short(sid)} - recovery retry failed: ${errMsg}`);
-              w.recoveryAttempts = 0;
             }
             w.watchdogRetryGuard = false;
           } else {
@@ -12984,8 +13058,11 @@ var AutoResumePlugin = async (ctx, options) => {
             dbg(`Watchdog check on ${short(sid)}: status=${w.status}, recoveryAttempts=${w.recoveryAttempts}, maxRetries=${maxRecoveryRetries}, watchdogLatencyMs=${Date.now() - w.lastRetryAt} -> ABORT_RESUME`);
             const resumed = await tryAbortAndResume(sid, w);
             if (!resumed && !w.aborting) {
-              await log("warn", `Recovery exhausted on ${short(sid)}: attempts=${w.recoveryAttempts}, lastError=abort+resume failed`);
-              dbg(`Watchdog check on ${short(sid)}: status=${w.status} -> GAVE_UP`);
+              w.gaveUp = true;
+              w.pendingRecovery = false;
+              w.pendingRecoveryReason = null;
+              await log("warn", `Recovery exhausted on ${short(sid)}: attempts=${w.recoveryAttempts}, lastError=abort+resume failed \u2014 GAVE UP (re-arms on next user message)`);
+              dbg(`Watchdog check on ${short(sid)}: status=${w.status} -> GAVE_UP (latched)`);
               if (w.pendingRecoveryAt > 0) {
                 dbg(`Total recovery cycle on ${short(sid)} (failed): totalCycleMs=${Date.now() - w.pendingRecoveryAt}`);
               }
@@ -13054,6 +13131,73 @@ var AutoResumePlugin = async (ctx, options) => {
     messagesInflight.set(sid, p);
     return p;
   }
+  let cachedToolIds = null;
+  let cachedToolIdsAt = 0;
+  async function getAvailableToolIds() {
+    if (cachedToolIds && Date.now() - cachedToolIdsAt < TOOL_IDS_CACHE_MS) {
+      return cachedToolIds;
+    }
+    try {
+      const result = await ctx.client.tool.ids();
+      const ids = result.data ?? [];
+      cachedToolIds = ids;
+      cachedToolIdsAt = Date.now();
+      return ids;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      await log("warn", `Failed to fetch tool IDs: ${msg}`);
+      return cachedToolIds ?? [];
+    }
+  }
+  async function checkForUnknownToolCalls(sid, w) {
+    if (w.unknownToolSuggestionSent)
+      return false;
+    if (w.userCancelled || w.completionSignaled)
+      return false;
+    try {
+      const available = await getAvailableToolIds();
+      if (available.length === 0)
+        return false;
+      const messages = await getSessionMessages(sid);
+      for (const msg of messages) {
+        const parts = msg.parts;
+        if (!parts)
+          continue;
+        for (const part of parts) {
+          const partType = part.type;
+          if (partType !== "tool")
+            continue;
+          const partId = part.id ?? part.callID ?? "";
+          if (!partId || w.checkedToolPartIDs.has(partId))
+            continue;
+          w.checkedToolPartIDs.add(partId);
+          const state = part.state;
+          if (!state || state.status !== "error")
+            continue;
+          const toolName = part.tool ?? "";
+          if (!toolName || available.includes(toolName))
+            continue;
+          const count = (w.unknownToolErrors.get(toolName) ?? 0) + 1;
+          w.unknownToolErrors.set(toolName, count);
+          if (count < UNKNOWN_TOOL_THRESHOLD)
+            continue;
+          const suggestion = suggestClosestTool(toolName, available);
+          const toolList = available.slice(0, 20).join(", ");
+          const prompt = suggestion ? `You tried to use the tool "${toolName}" ${count} times, but it does not exist. ` + `The closest matching tool is "${suggestion}". ` + `Please use "${suggestion}" instead and adjust your arguments accordingly. ` + `Available tools include: ${toolList}.` : `You tried to use the tool "${toolName}" ${count} times, but it does not exist. ` + `Please check the available tools and use the correct one. ` + `Available tools include: ${toolList}.`;
+          w.unknownToolSuggestionSent = true;
+          w.toolTextRecovered = true;
+          await log("warn", `${short(sid)} - unknown tool "${toolName}" called ${count}x, suggesting "${suggestion ?? "(none)"}"`);
+          await sendContinuePrompt(sid, prompt, w);
+          return true;
+        }
+      }
+      return false;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      await log("warn", `${short(sid)} - checkForUnknownToolCalls error: ${msg}`);
+      return false;
+    }
+  }
   function roleOf(msg) {
     if (!msg)
       return;
@@ -13441,6 +13585,15 @@ var AutoResumePlugin = async (ctx, options) => {
         await log("info", `${short(sid)} - user recently active, skipping tool-text check`);
         return;
       }
+      if ((w.todos || []).length === 0) {
+        try {
+          const fetched = await fetchSessionTodos(sid);
+          if (fetched.length > 0)
+            w.todos = fetched;
+        } catch (e) {
+          dbg(`checkForToolCallAsText sid=${short(sid)}: lazy todo fetch error: ${e}`);
+        }
+      }
       const recent = messages.slice(-3);
       let bestCandidate = null;
       let allAssistantText = "";
@@ -13538,7 +13691,7 @@ var AutoResumePlugin = async (ctx, options) => {
               bestCandidate = candidate;
             }
           }
-          if (containsReadyToContinuePattern(text)) {
+          if (containsReadyToContinuePattern(text, readyToContinuePatterns)) {
             const todos = w.todos || [];
             const hasOpenTodos = todos.some(isOpenTodo);
             if (!hasOpenTodos && todos.length > 0) {
@@ -13558,16 +13711,42 @@ var AutoResumePlugin = async (ctx, options) => {
               await log("info", `${short(sid)} - skipping continue, todos appear completed (attempt ${w.todoCheckAttempts}/2)`);
               continue;
             }
-            const candidate = {
-              prompt: containsDoneClaimPattern(text) ? doneWithoutWorkPrompt : continuePrompt,
-              source: containsDoneClaimPattern(text) ? "done-claim" : "ready-to-continue",
-              priority: 1
-            };
-            if (!bestCandidate || candidate.priority < bestCandidate.priority) {
-              bestCandidate = candidate;
+            if (containsDoneClaimPattern(text, doneClaimPatterns)) {
+              const todos = w.todos || [];
+              const hasOpenTodos = todos.some(isOpenTodo);
+              if (hasOpenTodos) {
+                const candidate = {
+                  prompt: doneWithoutWorkPrompt,
+                  source: "done-claim",
+                  priority: 1
+                };
+                if (!bestCandidate || candidate.priority < bestCandidate.priority) {
+                  bestCandidate = candidate;
+                }
+              } else if (!containsWorkDescription(allAssistantText)) {
+                if (w.doneClaimNoTodosAttempts < maxRetries) {
+                  const candidate = {
+                    prompt: doneWithoutDetailsPrompt,
+                    source: "done-claim-no-todos",
+                    priority: 1
+                  };
+                  if (!bestCandidate || candidate.priority < bestCandidate.priority) {
+                    bestCandidate = candidate;
+                  }
+                }
+              }
+            } else {
+              const candidate = {
+                prompt: continuePrompt,
+                source: "ready-to-continue",
+                priority: 1
+              };
+              if (!bestCandidate || candidate.priority < bestCandidate.priority) {
+                bestCandidate = candidate;
+              }
             }
           }
-          if (!bestCandidate && containsDoneClaimPattern(text)) {
+          if (!bestCandidate && containsDoneClaimPattern(text, doneClaimPatterns)) {
             const todos = w.todos || [];
             const hasOpenTodos = todos.some(isOpenTodo);
             if (hasOpenTodos) {
@@ -13652,6 +13831,7 @@ var AutoResumePlugin = async (ctx, options) => {
           await log("info", `${short(sid)} - max open-todos nudges (${maxRetries}) reached, waiting for activity`);
           return;
         }
+        w.todoNudgeAttempts++;
       } else if (isDoneClaimNoTodos) {
         w.doneClaimNoTodosAttempts++;
       } else {
@@ -13707,6 +13887,7 @@ var AutoResumePlugin = async (ctx, options) => {
     const idleSec = Math.round((Date.now() - (w.orphanWatchStartAt ?? w.lastActivityAt)) / 1000);
     await log("info", `Abort+Resume on ${short(sid)} (${idleSec}s idle). Aborting...`);
     w.pluginAbortInFlight = true;
+    w.pluginAbortAt = Date.now();
     try {
       await ctx.client.session.abort({ path: { id: sid } });
       await log("info", `${short(sid)} - abort OK`);
@@ -13716,6 +13897,7 @@ var AutoResumePlugin = async (ctx, options) => {
       await log("warn", `${short(sid)} - abort failed: ${errMsg}`);
       w.aborting = false;
       w.pluginAbortInFlight = false;
+      w.pluginAbortAt = 0;
       return false;
     }
     await new Promise((resolve) => setTimeout(resolve, ABORT_CONTINUE_DELAY_MS));
@@ -13740,6 +13922,7 @@ var AutoResumePlugin = async (ctx, options) => {
       return false;
     } finally {
       w.pluginAbortInFlight = false;
+      w.pluginAbortAt = 0;
     }
   }
   async function tryResume(sid, w, reason, prompt) {
@@ -14283,6 +14466,9 @@ var AutoResumePlugin = async (ctx, options) => {
           w.status = "idle";
           resetIdleFlags(w);
           dbg(`session.idle sid=${short(sid)}: resetIdleFlags done, toolTextRecovered=${w.toolTextRecovered}, toolTextAttempts=${w.toolTextAttempts}, maxRetries=${maxRetries}`);
+          if (!w.unknownToolSuggestionSent && !w.completionSignaled && !w.userCancelled) {
+            checkForUnknownToolCalls(sid, w);
+          }
           if (resumeOnActionIntent && !w.toolTextRecovered && !w.completionSignaled) {
             setTimeout(async () => {
               try {
@@ -14360,6 +14546,9 @@ var AutoResumePlugin = async (ctx, options) => {
           if (w) {
             w.doneClaimNoTodosAttempts = 0;
             w.lastUserMessageAt = Date.now();
+            w.unknownToolErrors.clear();
+            w.unknownToolSuggestionSent = false;
+            w.checkedToolPartIDs.clear();
           }
           break;
         }
@@ -14398,10 +14587,16 @@ var AutoResumePlugin = async (ctx, options) => {
         const isMessageAborted = errorName === "MessageAbortedError";
         if (isMessageAborted) {
           for (const [wSid, w] of sessions) {
-            if (!w.pluginAbortInFlight) {
+            const PLUGIN_ABORT_GRACE_MS = 1000;
+            const isOwnAbort = w.pluginAbortInFlight && Date.now() - (w.pluginAbortAt || 0) < PLUGIN_ABORT_GRACE_MS;
+            if (!isOwnAbort) {
               w.userCancelled = true;
               w.status = "idle";
               resetIdleFlags(w);
+              if (w.toolTextTimer) {
+                clearTimeout(w.toolTextTimer);
+                w.toolTextTimer = null;
+              }
             }
           }
           log("info", "User abort (ESC)");
@@ -14452,20 +14647,40 @@ var AutoResumePlugin = async (ctx, options) => {
     }
   }
   const taskCompleteTool = tool({
-    description: "Signal that all work is complete and stop automatic continuation prompts. Call this ONLY after finishing everything requested.",
+    description: "Signal that all work is complete and stop automatic continuation prompts. Call this ONLY after finishing everything requested. Call exactly once per completed round of work \u2014 repeat calls with no new user message in between are rejected.",
     args: {},
     execute: async (_args, ctx) => {
       const w = sessions.get(ctx.sessionID);
       if (w) {
         if (!w.isSubagent) {
+          if ((w.todos || []).length === 0) {
+            try {
+              const fetched = await fetchSessionTodos(ctx.sessionID);
+              if (fetched.length > 0)
+                w.todos = fetched;
+            } catch (e) {
+              dbg(`task_complete sid=${short(ctx.sessionID)}: lazy todo fetch error: ${e}`);
+            }
+          }
           const openTodos = (w.todos || []).filter((t) => t.status === "pending" || t.status === "in_progress");
           if (openTodos.length > 0 && w.taskCompleteOverrides < maxRetries) {
             w.taskCompleteOverrides++;
+            w.taskCompleteSignals = 0;
             const reminder = buildOpenTodosReminder(w.todos);
             const blockMsg = `Mark any finished todos complete and do not redo completed work.
 ${reminder}`;
             await log("info", `${short(ctx.sessionID)} - task_complete blocked: ${openTodos.length} open todos remain (override ${w.taskCompleteOverrides}/${maxRetries})`);
-            await sendContinuePrompt(ctx.sessionID, blockMsg, w);
+            let awaitingInput = false;
+            try {
+              awaitingInput = hasPendingUserInput(await getSessionMessages(ctx.sessionID));
+            } catch (e) {
+              dbg(`task_complete block: awaiting-input check error: ${e}`);
+            }
+            if (awaitingInput) {
+              await log("info", `${short(ctx.sessionID)} - task_complete blocked but user input pending, skipping visible nudge`);
+            } else {
+              await sendContinuePrompt(ctx.sessionID, blockMsg, w);
+            }
             return blockMsg;
           }
         }
@@ -14476,8 +14691,13 @@ ${reminder}`;
           w.toolTextTimer = null;
         }
         log("info", `${short(ctx.sessionID)} - task_complete called, ${w.isSubagent ? "subagent" : "agent"} done`);
+        w.taskCompleteSignals++;
+        if (w.taskCompleteSignals === 2)
+          return TASK_COMPLETE_REPEAT_WARNING;
+        if (w.taskCompleteSignals > 2)
+          throw new Error(TASK_COMPLETE_REPEAT_ERROR);
       }
-      return "Task completion acknowledged. No further continuation will be sent.";
+      return TASK_COMPLETE_ACK;
     }
   });
   return {
@@ -14509,6 +14729,7 @@ ${reminder}`;
       if (w.userCancelled || w.completionSignaled) {
         w.userCancelled = false;
         w.completionSignaled = false;
+        w.taskCompleteSignals = 0;
         await log("info", `${short(sid)} - new user message, re-arming auto-resume`);
       }
     },
@@ -14519,6 +14740,8 @@ ${reminder}`;
       w.pendingTools++;
       w.lastActivityAt = Date.now();
       const toolName = input.tool ?? "unknown";
+      if (toolName !== "task_complete")
+        w.taskCompleteSignals = 0;
       const rawArgs = hookArgs?.args ?? input.args;
       w.liveToolSigs.push(toolCallSignature(toolName, rawArgs));
       if (w.liveToolSigs.length > 15)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-auto-resume",
-  "version": "1.1.17",
+  "version": "1.1.19",
   "description": "OpenCode plugin that automatically resumes stalled LLM sessions when thinking/streaming freezes mid-generation.",
   "keywords": [
     "opencode",