opencode-auto-resume 1.1.9 → 1.1.10

package/dist/index.js

@@ -12439,13 +12439,17 @@ var DONE_CLAIM_PATTERNS = [
   /^task\s+completed[.!]*$/im,
   /^all\s+tasks?\s+complete[.!]*$/im,
   /^all\s+tasks?\s+completed[.!]*$/im,
-  /^(?:i['']?m\s+)?done\s+with\s+task/im
+  /^(?:i['']?m\s+)?done\s+with\s+task/im,
+  /\bdone\s+with\s+(?:the\s+)?(?:task|work|implementation)/im,
+  /\bfinished\s+(?:the\s+)?(?:task|work|implementation)/im,
+  /\b(?:all|everything)\s+(?:is\s+)?(?:complete|done|finished)/im,
+  /\bnothing\s+(?:else\s+)?(?:left|remaining|to do)/im
 ];
 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.";
 function containsDoneClaimPattern(text) {
   const lines = text.split(`
 `);
-  const lastLines = lines.slice(-3).join(`
+  const lastLines = lines.slice(-5).join(`
 `);
   return DONE_CLAIM_PATTERNS.some((pat) => pat.test(lastLines));
 }
@@ -12592,7 +12596,22 @@ var AutoResumePlugin = async (ctx, options) => {
     recordContinue(sid);
     return w.continueTimestamps.length >= loopMaxContinues;
   }
+  const recentLogMsgs = new Map;
+  const LOG_DEDUP_WINDOW_MS = 5000;
   async function log(level, msg) {
+    if (level === "debug") {
+      const key = `${level}:${msg}`;
+      const now = Date.now();
+      const last = recentLogMsgs.get(key);
+      if (last && now - last < LOG_DEDUP_WINDOW_MS)
+        return;
+      recentLogMsgs.set(key, now);
+      if (recentLogMsgs.size > 200) {
+        const oldest = [...recentLogMsgs.entries()].sort((a, b) => a[1] - b[1]);
+        for (let i = 0;i < 100; i++)
+          recentLogMsgs.delete(oldest[i][0]);
+      }
+    }
     try {
       await ctx.client.app.log({ body: { service: "auto-resume", level, message: msg } });
     } catch (e) {
@@ -12782,6 +12801,8 @@ var AutoResumePlugin = async (ctx, options) => {
       await log("debug", `${short(sid)} - continue already in progress, skipping`);
       return;
     }
+    if (w.userCancelled || w.completionSignaled)
+      return;
     if (!w.continuing)
       dbg(`State transition on ${short(sid)}: continuing=false -> true`);
     w.continuing = true;
@@ -12917,9 +12938,21 @@ var AutoResumePlugin = async (ctx, options) => {
       return response.messages;
     return [];
   }
+  const messagesInflight = new Map;
   async function getSessionMessages(sid) {
-    const response = await ctx.client.session.messages({ path: { id: sid } });
-    return extractMessages(response);
+    const inflight = messagesInflight.get(sid);
+    if (inflight)
+      return inflight;
+    const p = (async () => {
+      try {
+        const response = await ctx.client.session.messages({ path: { id: sid } });
+        return extractMessages(response);
+      } finally {
+        messagesInflight.delete(sid);
+      }
+    })();
+    messagesInflight.set(sid, p);
+    return p;
   }
   function roleOf(msg) {
     if (!msg)
@@ -12971,6 +13004,43 @@ var AutoResumePlugin = async (ctx, options) => {
       return {};
     }
   }
+  const todoCache = new Map;
+  const todoInflight = new Map;
+  const TODO_CACHE_TTL_MS = 2000;
+  async function fetchSessionTodos(sid) {
+    if (typeof sid !== "string" || !sid.startsWith("ses"))
+      return [];
+    const cached2 = todoCache.get(sid);
+    if (cached2 && Date.now() - cached2.fetchedAt < TODO_CACHE_TTL_MS)
+      return cached2.todos;
+    const inflight = todoInflight.get(sid);
+    if (inflight)
+      return inflight;
+    const p = (async () => {
+      try {
+        const todoFn = ctx.client.session.todo;
+        if (typeof todoFn !== "function")
+          return [];
+        const response = await todoFn.call(ctx.client.session, { path: { id: sid } });
+        const rawTodos = response.data ?? response;
+        if (!Array.isArray(rawTodos))
+          return [];
+        const todos = rawTodos.map((t) => ({
+          content: t?.content ?? "",
+          status: t?.status ?? "pending",
+          priority: t?.priority ?? "medium"
+        }));
+        todoCache.set(sid, { todos, fetchedAt: Date.now() });
+        return todos;
+      } catch {
+        return [];
+      } finally {
+        todoInflight.delete(sid);
+      }
+    })();
+    todoInflight.set(sid, p);
+    return p;
+  }
   const SUBAGENT_STUCK_MS = 60000;
   const SUBAGENT_RECOVERY_PROMPT = "It looks like you may have stalled or timed out. Please retry the last operation or continue with the task.";
   async function recoverSubagent(subagentSid) {
@@ -13096,6 +13166,34 @@ var AutoResumePlugin = async (ctx, options) => {
     w.recoveryAttempts = 0;
     w.watchdogRetryGuard = false;
   }
+  function resetBusyFlags(w) {
+    w.resumeAttempts = 0;
+    w.lastRetryAt = 0;
+    w.pendingTools = 0;
+    w.pendingCommands = 0;
+    w.gaveUp = false;
+    w.orphanWatchStartAt = null;
+    w.aborting = false;
+    w.toolTextRecovered = false;
+    w.toolTextAttempts = 0;
+    w.todoCheckAttempts = 0;
+    w.checkingToolText = false;
+    w.interruptedContinueCount = 0;
+    w.recentToolCalls = [];
+    w.toolLoopAttempts = 0;
+    w.pendingRecovery = false;
+    w.pendingRecoveryReason = null;
+    w.pendingRecoveryAt = 0;
+    w.recoveryAttempts = 0;
+    w.watchdogRetryGuard = false;
+    if (w.toolTextTimer) {
+      clearTimeout(w.toolTextTimer);
+      w.toolTextTimer = null;
+    }
+    w.todoNudgeAttempts = 0;
+    w.doneClaimNoTodosAttempts = 0;
+    w.continueTimestamps = [];
+  }
   function resetIdleFlags(w) {
     w.aborting = false;
     w.orphanWatchStartAt = null;
@@ -13331,14 +13429,19 @@ var AutoResumePlugin = async (ctx, options) => {
       const trimmedText = allAssistantText.trim();
       const normalized = trimmedText.replace(/[.!?]+$/, "");
       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;
+        const openCount = getOpenTodos(w.todos || []).length;
+        if (openCount > 0) {
+          await log("info", `${short(sid)} - \uD83C\uDF89 detected but ${openCount} open todos remain, NOT latching completion`);
+        } else {
+          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;
+          }
+          return;
         }
-        return;
       }
       if (!bestCandidate) {
         const todos = w.todos || [];
@@ -13412,9 +13515,10 @@ var AutoResumePlugin = async (ctx, options) => {
       await log("warn", `Invalid sid for abort: ${sid} (must start with "ses_")`);
       return false;
     }
+    if (w.userCancelled || w.completionSignaled)
+      return false;
     if (w.aborting)
       return false;
-    w.aborting = true;
     const idleSec = Math.round((Date.now() - (w.orphanWatchStartAt ?? w.lastActivityAt)) / 1000);
     await log("info", `Abort+Resume on ${short(sid)} (${idleSec}s idle). Aborting...`);
     try {
@@ -13500,7 +13604,12 @@ var AutoResumePlugin = async (ctx, options) => {
               w.idleSince = Date.now();
           }
           if (isNew) {
-            log("debug", `Discovered session ${short(sid)} via list()`);
+            log("debug", `Discovered session ${short(sid)} via list() \u2014 fetching todos`);
+            const fetched = await fetchSessionTodos(sid);
+            if (fetched.length > 0) {
+              const w = sessions.get(sid);
+              w.todos = fetched;
+            }
           }
         }
       }
@@ -13526,7 +13635,7 @@ var AutoResumePlugin = async (ctx, options) => {
           }
           if (w.status !== "busy")
             continue;
-          if (w.userCancelled)
+          if (w.userCancelled || w.completionSignaled)
             continue;
           if (w.aborting)
             continue;
@@ -13666,6 +13775,12 @@ var AutoResumePlugin = async (ctx, options) => {
             continue;
           if (busyCount() !== 0)
             continue;
+          if ((w.todos || []).length === 0) {
+            const fetched = await fetchSessionTodos(sid);
+            if (fetched.length > 0) {
+              w.todos = fetched;
+            }
+          }
           const open = getOpenTodos(w.todos || []);
           if (open.length === 0)
             continue;
@@ -13677,8 +13792,13 @@ var AutoResumePlugin = async (ctx, options) => {
             continue;
           const isCelebration = await lastAssistantEndsWithCelebration(sid);
           if (isCelebration) {
-            w.toolTextRecovered = true;
-            w.completionSignaled = true;
+            const openCount = getOpenTodos(w.todos || []).length;
+            if (openCount > 0) {
+              await log("info", `${short(sid)} - \uD83C\uDF89 detected in periodic recheck but ${openCount} open todos remain, NOT latching completion`);
+            } else {
+              w.toolTextRecovered = true;
+              w.completionSignaled = true;
+            }
             continue;
           }
           const reminder = buildOpenTodosReminder(w.todos || []);
@@ -13719,7 +13839,7 @@ var AutoResumePlugin = async (ctx, options) => {
           if (w.pendingRecovery) {
             dbg(`Pending recovery cleared on ${short(sid)}: reason=session-busy`);
           }
-          resetSessionFlags(w);
+          resetBusyFlags(w);
           prevBusyCount = busyCount();
           log("debug", `${short(sid)} -> busy (${prevBusyCount})`);
         } else if (statusType === "interrupted") {
@@ -13763,23 +13883,27 @@ var AutoResumePlugin = async (ctx, options) => {
                 dbg(`session.idle sid=${short(sid)}: streaming-failure check error: ${errMsg}`);
               }
             }
-            const todos = w.todos || [];
+            let todos = w.todos || [];
+            if (todos.length === 0) {
+              const fetched = await fetchSessionTodos(sid);
+              if (fetched.length > 0) {
+                w.todos = fetched;
+                todos = fetched;
+              }
+            }
             const open = getOpenTodos(todos);
             if (open.length > 0 && currentBusy === 0 && !w.completionSignaled && !w.userCancelled && w.todoNudgeAttempts < maxRetries) {
               const isCelebration = await lastAssistantEndsWithCelebration(sid);
+              await log("info", `${short(sid)} - open todos=${open.length}, isCelebration=${isCelebration}, currentBusy=${currentBusy}`);
               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)} - \uD83C\uDF89 detected but ${open.length} open todos remain, sending nudge`);
+                const reminder = buildOpenTodosReminder(todos);
+                await tryResume(sid, w, "Idle with open todos (celebration false positive)", reminder);
                 w.todoNudgeAttempts++;
+              } else {
                 const reminder = buildOpenTodosReminder(todos);
-                await log("info", `${short(sid)} - idle with ${open.length} open todos. Sending reminder (nudge ${w.todoNudgeAttempts}/${maxRetries})...`);
                 await tryResume(sid, w, "Idle with open todos", reminder);
+                w.todoNudgeAttempts++;
               }
             }
           }
@@ -13793,8 +13917,7 @@ var AutoResumePlugin = async (ctx, options) => {
                     dbg(`session.idle sid=${short(idleSid)}: skipping action intent, session is warming up (${Date.now() - idleW.createdAt}ms < ${warmupMs}ms)`);
                     return;
                   }
-                  const response = await ctx.client.session.messages({ path: { id: idleSid } });
-                  const msgs = extractMessages(response);
+                  const msgs = await getSessionMessages(idleSid);
                   const lastAssistantMsg = msgs.slice().reverse().find((m) => (m.role ?? m.info?.role) === "assistant");
                   if (lastAssistantMsg) {
                     let lastText = "";
@@ -13804,7 +13927,7 @@ var AutoResumePlugin = async (ctx, options) => {
                     }
                     if (containsActionIntent(lastText)) {
                       const w2 = sessions.get(idleSid);
-                      if (!w2 || w2.toolTextRecovered || w2.completionSignaled || w2.status !== "idle")
+                      if (!w2 || w2.toolTextRecovered || w2.completionSignaled || w2.userCancelled || w2.status !== "idle")
                         return;
                       w2.toolTextRecovered = true;
                       w2.toolTextAttempts++;
@@ -13858,8 +13981,7 @@ var AutoResumePlugin = async (ctx, options) => {
                   dbg(`session.idle sid=${short(sid)}: skipping action intent, session is warming up (${Date.now() - w.createdAt}ms < ${warmupMs}ms)`);
                   return;
                 }
-                const response = await ctx.client.session.messages({ path: { id: sid } });
-                const msgs = extractMessages(response);
+                const msgs = await getSessionMessages(sid);
                 const lastAssistantMsg = msgs.slice().reverse().find((m) => (m.role ?? m.info?.role) === "assistant");
                 if (lastAssistantMsg) {
                   let lastText = "";
@@ -13869,7 +13991,7 @@ var AutoResumePlugin = async (ctx, options) => {
                   }
                   if (containsActionIntent(lastText)) {
                     const w2 = sessions.get(sid);
-                    if (!w2 || w2.toolTextRecovered || w2.completionSignaled || w2.status !== "idle")
+                    if (!w2 || w2.toolTextRecovered || w2.completionSignaled || w2.userCancelled || w2.status !== "idle")
                       return;
                     w2.toolTextRecovered = true;
                     w2.toolTextAttempts++;
@@ -13968,16 +14090,14 @@ var AutoResumePlugin = async (ctx, options) => {
         break;
       }
       case "command.executed": {
-        for (const [sid2, w2] of sessions) {
-          if (w2.pendingRecovery) {
-            dbg(`Pending recovery cleared on ${short(sid2)}: reason=user-command`);
-          }
-          resetSessionFlags(w2);
-        }
         if (!sid)
           break;
         const w = sessions.get(sid);
         if (w) {
+          if (w.pendingRecovery) {
+            dbg(`Pending recovery cleared on ${short(sid)}: reason=user-command`);
+          }
+          resetBusyFlags(w);
           w.pendingCommands = Math.max(0, w.pendingCommands - 1);
           w.lastActivityAt = Date.now();
         }

package/package.json

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