opencode-auto-resume 1.1.1 → 1.1.3

package/dist/index.js

@@ -12429,6 +12429,18 @@ function containsDoneClaimPattern(text) {
 `);
   return DONE_CLAIM_PATTERNS.some((pat) => pat.test(lastLines));
 }
+function buildOpenTodosReminder(todos) {
+  const open = todos.filter((t) => t.status === "pending" || t.status === "in_progress");
+  if (open.length === 0)
+    return "continue";
+  const list = open.map((t, i) => `${i + 1}. [${t.status}] ${t.content}`).join(`
+`);
+  const plural = open.length > 1 ? "s" : "";
+  return `You have ${open.length} unfinished task${plural}:
+${list}
+
+Please continue working on these task${plural}.`;
+}
 var AutoResumePlugin = async (ctx, options) => {
   const chunkTimeoutMs = options?.chunkTimeoutMs ?? DEFAULT_CHUNK_TIMEOUT_MS;
   const checkIntervalMs = options?.checkIntervalMs ?? DEFAULT_CHECK_INTERVAL_MS;
@@ -12491,7 +12503,11 @@ var AutoResumePlugin = async (ctx, options) => {
         interruptedContinueCount: 0,
         recentToolCalls: [],
         toolLoopAttempts: 0,
-        isSubagent: false
+        isSubagent: false,
+        completionSignaled: false,
+        todoNudgeAttempts: 0,
+        pendingTools: 0,
+        pendingCommands: 0
       };
       sessions.set(sid, w);
     }
@@ -12503,6 +12519,9 @@ var AutoResumePlugin = async (ctx, options) => {
       w.lastActivityAt = Date.now();
     }
   }
+  function hasInflightTools(w) {
+    return w.pendingTools > 0 || w.pendingCommands > 0;
+  }
   function busyCount() {
     let count = 0;
     for (const [, w] of sessions) {
@@ -12824,13 +12843,15 @@ var AutoResumePlugin = async (ctx, options) => {
   function resetSessionFlags(w) {
     w.userCancelled = false;
     w.resumeAttempts = 0;
+    w.pendingTools = 0;
+    w.pendingCommands = 0;
     w.gaveUp = false;
     w.orphanWatchStartAt = null;
     w.aborting = false;
-    if (w.isSubagent) {
-      w.toolTextRecovered = false;
-    }
+    w.toolTextRecovered = false;
     w.toolTextAttempts = 0;
+    w.completionSignaled = false;
+    w.todoNudgeAttempts = 0;
     w.continueTimestamps = [];
     w.idleSince = null;
     w.continuing = false;
@@ -12845,10 +12866,11 @@ var AutoResumePlugin = async (ctx, options) => {
     }
   }
   function resetIdleFlags(w) {
-    w.userCancelled = false;
     w.aborting = false;
     w.orphanWatchStartAt = null;
     w.idleSince = Date.now();
+    w.pendingTools = 0;
+    w.pendingCommands = 0;
   }
   function detectPatternLoop(recentTools) {
     if (recentTools.length < 6)
@@ -13051,6 +13073,7 @@ var AutoResumePlugin = async (ctx, options) => {
       if (normalized.endsWith("\uD83C\uDF89") && (!bestCandidate || bestCandidate.priority > 0)) {
         await log("info", `${short(sid)} - \uD83C\uDF89 completion detected, skipping continue`);
         w.toolTextRecovered = true;
+        w.completionSignaled = true;
         if (w.toolTextTimer) {
           clearTimeout(w.toolTextTimer);
           w.toolTextTimer = null;
@@ -13061,10 +13084,11 @@ var AutoResumePlugin = async (ctx, options) => {
         const todos = w.todos || [];
         const hasOpenTodos = todos.some((t) => t.status === "pending" || t.status === "in_progress");
         if (hasOpenTodos && busyCount() === 0) {
-          await log("info", `${short(sid)} - no activity detected but todos remain open (${todos.filter((t) => t.status === "pending" || t.status === "in_progress").length} tasks). Sending continue...`);
+          const reminder = buildOpenTodosReminder(todos);
+          await log("info", `${short(sid)} - no activity detected but todos remain open (${todos.filter((t) => t.status === "pending" || t.status === "in_progress").length} tasks). Sending reminder...`);
           bestCandidate = {
-            prompt: "continue",
-            source: "idle-with-open-todos",
+            prompt: reminder,
+            source: "idle-with-open-todos-reminder",
             priority: 2
           };
         } else if (hasOpenTodos && busyCount() > 0) {
@@ -13073,15 +13097,28 @@ var AutoResumePlugin = async (ctx, options) => {
       }
       if (!bestCandidate)
         return;
-      w.toolTextRecovered = true;
-      w.toolTextAttempts++;
-      await log("info", `${bestCandidate.source} detected on ${short(sid)}! ` + `Attempt ${w.toolTextAttempts}/${maxRetries}. Sending recovery prompt...`);
+      const isOpenTodosReminder = bestCandidate.source === "idle-with-open-todos-reminder";
+      if (isOpenTodosReminder) {
+        if (w.todoNudgeAttempts >= maxRetries) {
+          await log("info", `${short(sid)} - max open-todos nudges (${maxRetries}) reached for this idle cycle, waiting for activity`);
+          return;
+        }
+        w.todoNudgeAttempts++;
+      } else {
+        w.toolTextRecovered = true;
+        w.toolTextAttempts++;
+      }
+      await log("info", `${bestCandidate.source} detected on ${short(sid)}! ` + `Attempt ${isOpenTodosReminder ? w.todoNudgeAttempts : w.toolTextAttempts}/${maxRetries}. Sending recovery prompt...`);
       const timeSinceActivity = Date.now() - w.lastActivityAt;
       if (timeSinceActivity < MIN_ACTIVITY_GAP_MS) {
         await log("info", `${short(sid)} - skipping ${bestCandidate.source}, session was active ${Math.round(timeSinceActivity / 1000)}s ago`);
         return;
       }
       if (isHallucinationLoop(sid)) {
+        if (hasInflightTools(w)) {
+          await log("debug", `Session ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping hallucination abort`);
+          return;
+        }
         const hasActiveTool = await checkSessionHasActiveTool(sid);
         if (hasActiveTool) {
           await log("debug", `Session ${short(sid)} has active tool, skipping hallucination abort`);
@@ -13141,7 +13178,7 @@ var AutoResumePlugin = async (ctx, options) => {
       return false;
     }
   }
-  async function tryResume(sid, w, reason) {
+  async function tryResume(sid, w, reason, prompt) {
     if (typeof sid !== "string" || !sid) {
       await log("warn", `tryResume called with invalid sid: ${sid}`);
       return false;
@@ -13152,6 +13189,11 @@ var AutoResumePlugin = async (ctx, options) => {
     if (w.lastRetryAt > 0 && elapsedSinceRetry < requiredBackoff)
       return false;
     if (isHallucinationLoop(sid)) {
+      if (hasInflightTools(w)) {
+        await log("debug", `Session ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping hallucination abort`);
+        w.lastRetryAt = now;
+        return false;
+      }
       const hasActiveTool = await checkSessionHasActiveTool(sid);
       if (hasActiveTool) {
         await log("debug", `Session ${short(sid)} has active tool, skipping hallucination abort`);
@@ -13165,7 +13207,7 @@ var AutoResumePlugin = async (ctx, options) => {
     const idleSec = Math.round((now - w.lastActivityAt) / 1000);
     await log("info", `${reason} on ${short(sid)} (${idleSec}s, retry ${w.resumeAttempts}/${maxRetries})`);
     try {
-      await sendContinuePrompt(sid, "continue", w);
+      await sendContinuePrompt(sid, prompt ?? "continue", w);
       await log("info", `${short(sid)} - retry sent`);
       return true;
     } catch (err) {
@@ -13225,6 +13267,11 @@ var AutoResumePlugin = async (ctx, options) => {
           const orphanIdle = now - w.orphanWatchStartAt;
           if (orphanIdle >= subagentWaitMs + gracePeriodMs) {
             if (w.resumeAttempts < maxRetries) {
+              if (hasInflightTools(w)) {
+                await log("debug", `Parent ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping orphan-watch abort`);
+                w.orphanWatchStartAt = now;
+                continue;
+              }
               const hasActiveTool = await checkSessionHasActiveTool(sid);
               if (hasActiveTool) {
                 await log("debug", `Parent ${short(sid)} has active tool call, skipping orphan-watch abort`);
@@ -13271,6 +13318,11 @@ var AutoResumePlugin = async (ctx, options) => {
             w.lastSubagentCheckAt = now;
             continue;
           }
+          if (hasInflightTools(w)) {
+            await log("debug", `Session ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping abort check`);
+            w.lastSubagentCheckAt = now;
+            continue;
+          }
           const hasActiveTool = await checkSessionHasActiveTool(sid);
           if (hasActiveTool) {
             await log("debug", `Session ${short(sid)} has active tool call, skipping abort check`);
@@ -13295,15 +13347,20 @@ var AutoResumePlugin = async (ctx, options) => {
         }
         const idle = now - w.lastActivityAt;
         if (idle >= chunkTimeoutMs + gracePeriodMs) {
-          const hasActiveTool = await checkSessionHasActiveTool(sid);
-          if (hasActiveTool) {
-            await log("debug", `Session ${short(sid)} has active tool call, skipping stall recovery`);
+          if (hasInflightTools(w)) {
+            await log("debug", `Session ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping stall recovery`);
             w.lastSubagentCheckAt = now;
-          } else if (w.resumeAttempts < maxRetries) {
-            tryResume(sid, w, "Stream stall");
-          } else if (!w.gaveUp) {
-            w.gaveUp = true;
-            log("warn", `${short(sid)} - all ${maxRetries} retries exhausted.`);
+          } else {
+            const hasActiveTool = await checkSessionHasActiveTool(sid);
+            if (hasActiveTool) {
+              await log("debug", `Session ${short(sid)} has active tool call, skipping stall recovery`);
+              w.lastSubagentCheckAt = now;
+            } else if (w.resumeAttempts < maxRetries) {
+              tryResume(sid, w, "Stream stall");
+            } else if (!w.gaveUp) {
+              w.gaveUp = true;
+              log("warn", `${short(sid)} - all ${maxRetries} retries exhausted.`);
+            }
           }
         }
       }
@@ -13337,7 +13394,17 @@ var AutoResumePlugin = async (ctx, options) => {
           resetSessionFlags(w);
           prevBusyCount = busyCount();
           log("debug", `${short(sid)} -> busy (${prevBusyCount})`);
-        } else if (statusType === "idle" || statusType === "interrupted") {
+        } else if (statusType === "interrupted") {
+          w.status = "idle";
+          resetIdleFlags(w);
+          w.userCancelled = true;
+          if (w.toolTextTimer) {
+            clearTimeout(w.toolTextTimer);
+            w.toolTextTimer = null;
+          }
+          prevBusyCount = busyCount();
+          log("info", `${short(sid)} -> interrupted by user, backing off`);
+        } else if (statusType === "idle") {
           w.status = "idle";
           resetIdleFlags(w);
           const currentBusy = busyCount();
@@ -13350,32 +13417,33 @@ var AutoResumePlugin = async (ctx, options) => {
             }
           }
           prevBusyCount = currentBusy;
-          log("debug", `${short(sid)} -> idle (${currentBusy})${statusType === "interrupted" ? " (interrupted)" : ""}`);
+          log("debug", `${short(sid)} -> idle (${currentBusy})`);
           if (!w.isSubagent) {
             const todos = w.todos || [];
             const hasOpenTodos = todos.some((t) => t.status === "pending" || t.status === "in_progress");
-            if (hasOpenTodos && currentBusy === 0 && !w.toolTextRecovered) {
+            if (hasOpenTodos && currentBusy === 0 && !w.completionSignaled && !w.userCancelled) {
               const isCelebration = await lastAssistantEndsWithCelebration(sid);
               if (isCelebration) {
                 await log("info", `${short(sid)} - \uD83C\uDF89 detected in idle handler, skipping continue`);
                 w.toolTextRecovered = true;
+                w.completionSignaled = true;
                 if (w.toolTextTimer) {
                   clearTimeout(w.toolTextTimer);
                   w.toolTextTimer = null;
                 }
               } else {
-                await log("info", `${short(sid)} - idle with ${todos.filter((t) => t.status === "pending" || t.status === "in_progress").length} open todos. Sending continue...`);
-                tryResume(sid, w, "Idle with open todos");
+                const reminder = buildOpenTodosReminder(todos);
+                await log("info", `${short(sid)} - idle with ${todos.filter((t) => t.status === "pending" || t.status === "in_progress").length} open todos. Sending reminder...`);
+                tryResume(sid, w, "Idle with open todos", reminder);
               }
             }
           }
-          if (!w.toolTextRecovered && w.toolTextAttempts < maxRetries) {
+          if (!w.completionSignaled && !w.userCancelled && w.toolTextAttempts < maxRetries) {
             if (w.toolTextTimer)
               clearTimeout(w.toolTextTimer);
-            const checkDelay = statusType === "interrupted" ? 500 : TOOL_TEXT_CHECK_DELAY_MS;
             w.toolTextTimer = setTimeout(() => {
               checkForToolCallAsText(sid, w);
-            }, checkDelay);
+            }, TOOL_TEXT_CHECK_DELAY_MS);
           }
         } else if (statusType === "retry") {
           touchSession(sid);
@@ -13386,7 +13454,9 @@ var AutoResumePlugin = async (ctx, options) => {
       case "session.created": {
         if (!sid)
           break;
-        ensureWatch(sid);
+        const w = ensureWatch(sid);
+        w.pendingTools = 0;
+        w.pendingCommands = 0;
         log("debug", `New session: ${short(sid)} (${sessions.size})`);
         break;
       }
@@ -13417,33 +13487,14 @@ var AutoResumePlugin = async (ctx, options) => {
           break;
         const w = sessions.get(sid);
         if (w) {
-          const wasJustContinued = w.continuing || Date.now() - w.lastRetryAt < 2000;
           w.status = "idle";
           resetIdleFlags(w);
-          log("debug", `${short(sid)} -> interrupted${wasJustContinued ? " (after continue)" : ""}`);
-          if (wasJustContinued && w.interruptedContinueCount < 3 && !w.toolTextRecovered && w.toolTextAttempts < maxRetries) {
-            w.interruptedContinueCount++;
-            await log("info", `${short(sid)} - continue was interrupted (${w.interruptedContinueCount}/3), retrying...`);
-            w.continuing = false;
-            try {
-              await sendContinuePrompt(sid, "continue", w);
-              await log("info", `${short(sid)} - interrupted continue retried`);
-            } catch (err) {
-              const errMsg = err instanceof Error ? err.message : String(err);
-              await log("warn", `${short(sid)} - interrupted continue retry failed: ${errMsg}`);
-            }
-            return;
-          } else if (wasJustContinued && w.interruptedContinueCount >= 3) {
-            await log("warn", `${short(sid)} - too many interrupted continues (${w.interruptedContinueCount}), stopping retries`);
-            w.interruptedContinueCount = 0;
-          }
-          if (!w.toolTextRecovered && w.toolTextAttempts < maxRetries) {
-            if (w.toolTextTimer)
-              clearTimeout(w.toolTextTimer);
-            w.toolTextTimer = setTimeout(() => {
-              checkForToolCallAsText(sid, w);
-            }, 500);
+          w.userCancelled = true;
+          if (w.toolTextTimer) {
+            clearTimeout(w.toolTextTimer);
+            w.toolTextTimer = null;
           }
+          log("info", `${short(sid)} -> interrupted by user, backing off`);
         }
         break;
       }
@@ -13479,11 +13530,25 @@ var AutoResumePlugin = async (ctx, options) => {
           break;
         const errorMessage = errorObj?.data?.message ?? String(errorObj?.data ?? "");
         log("debug", `Session error: ${errorName} - ${errorMessage}`);
+        if (sid) {
+          const w = sessions.get(sid);
+          if (w) {
+            w.pendingTools = 0;
+            w.pendingCommands = 0;
+          }
+        }
         break;
       }
       case "command.executed": {
-        for (const [, w] of sessions) {
-          resetSessionFlags(w);
+        for (const [, w2] of sessions) {
+          resetSessionFlags(w2);
+        }
+        if (!sid)
+          break;
+        const w = sessions.get(sid);
+        if (w) {
+          w.pendingCommands = Math.max(0, w.pendingCommands - 1);
+          w.lastActivityAt = Date.now();
         }
         break;
       }
@@ -13497,6 +13562,7 @@ var AutoResumePlugin = async (ctx, options) => {
       if (w) {
         if (!w.isSubagent) {
           w.toolTextRecovered = true;
+          w.completionSignaled = true;
           if (w.toolTextTimer) {
             clearTimeout(w.toolTextTimer);
             w.toolTextTimer = null;
@@ -13520,11 +13586,33 @@ var AutoResumePlugin = async (ctx, options) => {
     },
     tool: {
       task_complete: taskCompleteTool
+    },
+    "tool.execute.before": async (input) => {
+      if (!input?.sessionID)
+        return;
+      const w = ensureWatch(input.sessionID);
+      w.pendingTools++;
+      w.lastActivityAt = Date.now();
+    },
+    "command.execute.before": async (input) => {
+      if (!input?.sessionID)
+        return;
+      const w = ensureWatch(input.sessionID);
+      w.pendingCommands++;
+      w.lastActivityAt = Date.now();
+    },
+    "tool.execute.after": async (input) => {
+      if (!input?.sessionID)
+        return;
+      const w = ensureWatch(input.sessionID);
+      w.pendingTools = Math.max(0, w.pendingTools - 1);
+      w.lastActivityAt = Date.now();
     }
   };
 };
 var src_default = AutoResumePlugin;
 export {
   src_default as default,
+  buildOpenTodosReminder,
   AutoResumePlugin
 };

package/package.json

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