opencode-auto-resume 1.1.2 → 1.1.3

package/dist/index.js

@@ -12505,7 +12505,9 @@ var AutoResumePlugin = async (ctx, options) => {
         toolLoopAttempts: 0,
         isSubagent: false,
         completionSignaled: false,
-        todoNudgeAttempts: 0
+        todoNudgeAttempts: 0,
+        pendingTools: 0,
+        pendingCommands: 0
       };
       sessions.set(sid, w);
     }
@@ -12517,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) {
@@ -12838,6 +12843,8 @@ 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;
@@ -12859,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)
@@ -13107,6 +13115,10 @@ var AutoResumePlugin = async (ctx, options) => {
         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`);
@@ -13177,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`);
@@ -13250,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`);
@@ -13296,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`);
@@ -13320,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.`);
+            }
           }
         }
       }
@@ -13362,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();
@@ -13375,11 +13417,11 @@ 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.completionSignaled) {
+            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`);
@@ -13396,13 +13438,12 @@ var AutoResumePlugin = async (ctx, options) => {
               }
             }
           }
-          if (!w.completionSignaled && 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);
@@ -13413,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;
       }
@@ -13444,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;
       }
@@ -13506,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;
       }
@@ -13548,6 +13586,27 @@ 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();
     }
   };
 };

package/package.json

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