opencode-auto-resume 1.1.15 → 1.1.16

package/README.md

@@ -225,7 +225,16 @@ When the assistant ends a line with `:` ("Next, I will edit the file:") — anno
 
 ### Done-claim verification
 
-If the assistant claims the task is done ("task done", "finished", "all complete") but open todos remain, the plugin sends `DONE_WITHOUT_WORK_PROMPT` asking the agent to verify and finish remaining work. If it claims done with **no** open todos but the response contains no description of the work, the plugin sends `DONE_WITHOUT_DETAILS_PROMPT` — an imperative prompt demanding a concrete report (files changed, commands run, results). Both use the real `todo.updated` event state — not regex on the message text.
+If the assistant claims the task is done ("task done", "finished", "all complete") but open todos remain, the plugin sends `DONE_WITHOUT_WORK_PROMPT` asking the agent to verify and finish remaining work. If it claims done with **no** open todos and the response carries no work description, the plugin sends `DONE_WITHOUT_DETAILS_PROMPT` — an imperative prompt demanding a concrete report (files changed, commands run, results). A response that already contains file paths, verification output, or result sections satisfies the demand on its own and never triggers the prompt. The budget is capped at `maxRetries` across busy cycles (going busy no longer re-arms it); only a genuinely new inbound user message re-arms it. Both use the real `todo.updated` event state — not regex on the message text.
+
+---
+
+### User-input awareness
+
+The session is not stalled while the ball is in the user's court. Two gates stand down idle nudges:
+
+- **Awaiting input**: the newest assistant message holds a `tool_use` part with `state.status: "pending"` (e.g. an open `question` tool call). All idle checks, the periodic recheck, delayed action-intent callbacks, and the tool-text scan skip prompting until a newer user message clears the gate. Completed tool calls never engage it.
+- **Recently active user**: any inbound user message within `activeUserWindowMs` (default 15 minutes) means the user is engaged — likely composing a reply, which leaves no pending tool call behind. Open-todos nudges (idle + periodic), the tool-text reminder fallback, and action-intent callbacks stand down until the window expires.
 
 ---
 
@@ -389,6 +398,7 @@ With options:
 | `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) |
+| `activeUserWindowMs` | `900000` | Inbound-user-message recency window (15 min) during which idle nudges stand down (user likely composing) |
 | `subagentNativeCompactionEnabled` | `false` | Opt-in native `session.summarize()` for saturated subagent sessions (no magic-context detection required) |
 
 Message patterns are matched case-insensitively. Error names use exact match.

package/dist/index.js

@@ -12337,6 +12337,7 @@ tool.schema = exports_external;
 // src/index.ts
 var DEFAULT_CHUNK_TIMEOUT_MS = 45000;
 var DEFAULT_CHECK_INTERVAL_MS = 5000;
+var DEFAULT_ACTIVE_USER_WINDOW_MS = 15 * 60000;
 var DEFAULT_GRACE_PERIOD_MS = 3000;
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_MAX_BACKOFF_MS = 8000;
@@ -12456,6 +12457,15 @@ function containsDoneClaimPattern(text) {
 `);
   return DONE_CLAIM_PATTERNS.some((pat) => pat.test(lastLines));
 }
+function containsWorkDescription(text) {
+  if (/`[^`\n]*\.[a-zA-Z0-9]{1,8}[^`\n]*`/.test(text))
+    return true;
+  if (/[\w\-~.][\w\-.~\/]*\/[\w\-.~]*\.[a-zA-Z]{1,8}\b/.test(text))
+    return true;
+  if (/^(changed|modified|deleted|created|updated|renamed|moved|files?\s+changed|verification|verified|tests?(?:\s+run|\s+passing|\s+pass)?|results?|outcome|commands?\s+(?:run|executed))/im.test(text))
+    return true;
+  return false;
+}
 function isStreamingFailure(errorName, errorMessage, errorNames = DEFAULT_STREAMING_FAILURE_ERROR_NAMES, messagePatterns = DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS) {
   if (!errorName && !errorMessage)
     return false;
@@ -12622,6 +12632,7 @@ var AutoResumePlugin = async (ctx, options) => {
   const busyStallStrategy = rawBusyStallStrategy === "abort" || rawBusyStallStrategy === "off" ? rawBusyStallStrategy : "continue";
   const contextSaturationThreshold = options?.contextSaturationThreshold ?? 0.85;
   const subagentNativeCompactionEnabled = options?.subagentNativeCompactionEnabled ?? false;
+  const activeUserWindowMs = options?.activeUserWindowMs ?? DEFAULT_ACTIVE_USER_WINDOW_MS;
   const dbg = (...args) => {
     if (debug)
       console.log("[debug]", ...args);
@@ -12717,6 +12728,7 @@ var AutoResumePlugin = async (ctx, options) => {
         todoNudgeAttempts: 0,
         taskCompleteOverrides: 0,
         doneClaimNoTodosAttempts: 0,
+        lastUserMessageAt: 0,
         pendingTools: 0,
         pendingCommands: 0,
         pendingRecovery: false,
@@ -12897,6 +12909,8 @@ var AutoResumePlugin = async (ctx, options) => {
         }
       }
       dbg(`Recovery prompt sent to ${short(sid)}: prompt="${text.length > 80 ? `${text.slice(0, 80)}...` : text}", agent=${agent ?? "(default)"}, model=${model ? `${model.providerID}/${model.modelID}` : "(default)"}`);
+      if (w.userCancelled || w.completionSignaled)
+        return;
       const response = await ctx.client.session.prompt({
         path: { id: sid },
         body: {
@@ -12938,7 +12952,12 @@ var AutoResumePlugin = async (ctx, options) => {
     setTimeout(async () => {
       if (w.status !== "busy") {
         if (w.pendingRecovery) {
-          if (w.recoveryAttempts < maxRecoveryRetries) {
+          if (w.userCancelled || w.completionSignaled) {
+            w.pendingRecovery = false;
+            w.pendingRecoveryReason = null;
+            w.recoveryAttempts = 0;
+            await log("info", `${short(sid)} - recovery disarmed: session cancelled/completed while awaiting watchdog`);
+          } else if (w.recoveryAttempts < maxRecoveryRetries) {
             w.recoveryAttempts++;
             dbg(`State transition on ${short(sid)}: recoveryAttempts=${w.recoveryAttempts - 1} -> ${w.recoveryAttempts}`);
             w.watchdogRetryGuard = true;
@@ -12994,6 +13013,31 @@ var AutoResumePlugin = async (ctx, options) => {
       return response.messages;
     return [];
   }
+  function hasPendingUserInput(messages) {
+    for (let i = messages.length - 1;i >= 0; i--) {
+      const msg = messages[i];
+      const rawRole = msg.role ?? msg.info?.role;
+      if (rawRole === "user")
+        return false;
+      if (rawRole !== "assistant")
+        continue;
+      const parts = msg.parts;
+      if (!parts)
+        return false;
+      for (const part of parts) {
+        if (part.type !== "tool_use")
+          continue;
+        const state = part.state;
+        if (state?.status === "pending")
+          return true;
+      }
+      return false;
+    }
+    return false;
+  }
+  function userRecentlyActive(w) {
+    return w.lastUserMessageAt > 0 && Date.now() - w.lastUserMessageAt < activeUserWindowMs;
+  }
   const messagesInflight = new Map;
   async function getSessionMessages(sid) {
     const inflight = messagesInflight.get(sid);
@@ -13311,7 +13355,6 @@ var AutoResumePlugin = async (ctx, options) => {
       w.toolTextTimer = null;
     }
     w.todoNudgeAttempts = 0;
-    w.doneClaimNoTodosAttempts = 0;
     w.continueTimestamps = [];
   }
   function resetIdleFlags(w) {
@@ -13388,6 +13431,16 @@ var AutoResumePlugin = async (ctx, options) => {
     await log("debug", `${short(sid)} - checking for tool-call-as-text (attempt ${w.toolTextAttempts + 1})`);
     try {
       const messages = await getSessionMessages(sid);
+      if (hasPendingUserInput(messages)) {
+        w.checkingToolText = false;
+        await log("info", `${short(sid)} - awaiting user input (pending tool_use), skipping tool-text check`);
+        return;
+      }
+      if (userRecentlyActive(w)) {
+        w.checkingToolText = false;
+        await log("info", `${short(sid)} - user recently active, skipping tool-text check`);
+        return;
+      }
       const recent = messages.slice(-3);
       let bestCandidate = null;
       let allAssistantText = "";
@@ -13524,6 +13577,8 @@ var AutoResumePlugin = async (ctx, options) => {
                 source: "done-claim-no-emoji",
                 priority: 1
               };
+            } else if (containsWorkDescription(allAssistantText)) {
+              await log("info", `${short(sid)} - model claims done with no open todos, but the response already contains a work description. Skipping details prompt...`);
             } else if (w.doneClaimNoTodosAttempts < maxRetries) {
               await log("info", `${short(sid)} - model claims done with no open todos. Sending details prompt (attempt ${w.doneClaimNoTodosAttempts + 1}/${maxRetries})...`);
               bestCandidate = {
@@ -13666,6 +13721,11 @@ var AutoResumePlugin = async (ctx, options) => {
     await new Promise((resolve) => setTimeout(resolve, ABORT_CONTINUE_DELAY_MS));
     if (w.status === "busy")
       w.status = "idle";
+    if (w.userCancelled || w.completionSignaled) {
+      w.aborting = false;
+      await log("info", `${short(sid)} - abort+resume stood down: session cancelled/completed during abort delay`);
+      return false;
+    }
     try {
       await sendContinuePrompt(sid, continuePrompt, w);
       await log("info", `${short(sid)} - abort+continue done`);
@@ -13918,6 +13978,18 @@ var AutoResumePlugin = async (ctx, options) => {
             continue;
           if (busyCount() !== 0)
             continue;
+          try {
+            if (hasPendingUserInput(await getSessionMessages(sid))) {
+              await log("info", `${short(sid)} - awaiting user input (pending tool_use), skipping periodic open-todos nudge`);
+              continue;
+            }
+          } catch (e) {
+            dbg(`periodic recheck sid=${short(sid)}: awaiting-input check error: ${e}`);
+          }
+          if (userRecentlyActive(w)) {
+            await log("info", `${short(sid)} - user recently active, skipping periodic open-todos nudge`);
+            continue;
+          }
           if ((w.todos || []).length === 0) {
             const fetched = await fetchSessionTodos(sid);
             if (fetched.length > 0) {
@@ -14011,12 +14083,24 @@ var AutoResumePlugin = async (ctx, options) => {
           log("debug", `${short(sid)} -> idle (${currentBusy})`);
           if (w.isSubagent) {
             try {
-              if (w.lastTokenTotal > 0 && w.contextWrapupAttempts < 1 && !w.userCancelled && !w.completionSignaled && !w.aborting) {
+              let subAwaitingInput = false;
+              try {
+                subAwaitingInput = hasPendingUserInput(await getSessionMessages(sid));
+              } catch (e) {
+                dbg(`session.idle sid=${short(sid)}: awaiting-input check error: ${e}`);
+              }
+              if (subAwaitingInput) {
+                await log("info", `${short(sid)} - awaiting user input (pending tool_use), skipping subagent saturation check`);
+              } else if (userRecentlyActive(w)) {
+                await log("info", `${short(sid)} - user recently active, skipping subagent saturation check`);
+              } else if (w.lastTokenTotal > 0 && w.contextWrapupAttempts < 1 && !w.userCancelled && !w.completionSignaled && !w.aborting) {
                 const usable = await getUsableContextLimit(sid);
                 if (usable && w.lastTokenTotal / usable >= contextSaturationThreshold) {
                   if (subagentNativeCompactionEnabled) {
                     w.contextWrapupAttempts++;
                     await log("warn", `${short(sid)} - context saturation (subagent): ${w.lastTokenTotal}/${usable} tokens (${Math.round(w.lastTokenTotal / usable * 100)}% of usable); triggering native compaction`);
+                    if (w.userCancelled || w.completionSignaled)
+                      break;
                     await ctx.client.session.summarize({ path: { id: sid } });
                   }
                 }
@@ -14027,7 +14111,16 @@ var AutoResumePlugin = async (ctx, options) => {
             }
           }
           if (!w.isSubagent) {
-            if (!w.pendingRecovery && !w.completionSignaled && !w.userCancelled && !w.aborting) {
+            let awaitingUserInput = false;
+            try {
+              awaitingUserInput = hasPendingUserInput(await getSessionMessages(sid));
+            } catch (e) {
+              dbg(`session.idle sid=${short(sid)}: awaiting-input check error: ${e}`);
+            }
+            if (awaitingUserInput) {
+              await log("info", `${short(sid)} - awaiting user input (pending tool_use), standing down all idle checks/nudges`);
+            }
+            if (!awaitingUserInput && !w.pendingRecovery && !w.completionSignaled && !w.userCancelled && !w.aborting) {
               try {
                 const errInfo = getLastAssistantError(await getSessionMessages(sid));
                 if (errInfo && isStreamingFailure(errInfo.name, errInfo.message, streamingFailureErrorNames, streamingFailureMessagePatterns)) {
@@ -14067,7 +14160,7 @@ var AutoResumePlugin = async (ctx, options) => {
                 dbg(`session.idle sid=${short(sid)}: silent-dead-stream check error: ${errMsg}`);
               }
               try {
-                if (w.lastTokenTotal > 0 && w.contextWrapupAttempts < 1 && !w.userCancelled && !w.completionSignaled) {
+                if (w.lastTokenTotal > 0 && w.contextWrapupAttempts < 1 && !w.userCancelled && !w.completionSignaled && !userRecentlyActive(w)) {
                   const usable = await getUsableContextLimit(sid);
                   if (usable && w.lastTokenTotal / usable >= contextSaturationThreshold) {
                     const installed = await isMagicContextInstalled();
@@ -14075,6 +14168,8 @@ var AutoResumePlugin = async (ctx, options) => {
                       break;
                     w.contextWrapupAttempts++;
                     await log("warn", `${short(sid)} - context saturation: ${w.lastTokenTotal}/${usable} tokens (${Math.round(w.lastTokenTotal / usable * 100)}% of usable); sending magic-context wrapup command`);
+                    if (w.userCancelled || w.completionSignaled)
+                      break;
                     await ctx.client.session.command({
                       path: { id: sid },
                       body: { command: CTX_WRAPUP_TRIGGER, arguments: "" }
@@ -14095,7 +14190,7 @@ var AutoResumePlugin = async (ctx, options) => {
               }
             }
             const open = getOpenTodos(todos);
-            if (open.length > 0 && currentBusy === 0 && !w.completionSignaled && !w.userCancelled && w.todoNudgeAttempts < maxRetries) {
+            if (open.length > 0 && currentBusy === 0 && !awaitingUserInput && !userRecentlyActive(w) && !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) {
@@ -14121,6 +14216,14 @@ var AutoResumePlugin = async (ctx, options) => {
                     return;
                   }
                   const msgs = await getSessionMessages(idleSid);
+                  if (hasPendingUserInput(msgs)) {
+                    dbg(`session.idle sid=${short(idleSid)}: awaiting user input, skipping action-intent prompt`);
+                    return;
+                  }
+                  if (userRecentlyActive(idleW)) {
+                    dbg(`session.idle sid=${short(idleSid)}: user recently active, skipping action-intent prompt`);
+                    return;
+                  }
                   const lastAssistantMsg = msgs.slice().reverse().find((m) => (m.role ?? m.info?.role) === "assistant");
                   if (lastAssistantMsg) {
                     let lastText = "";
@@ -14188,6 +14291,15 @@ var AutoResumePlugin = async (ctx, options) => {
                   return;
                 }
                 const msgs = await getSessionMessages(sid);
+                if (hasPendingUserInput(msgs)) {
+                  dbg(`session.idle sid=${short(sid)}: awaiting user input, skipping action-intent prompt`);
+                  return;
+                }
+                const w2pre = sessions.get(sid);
+                if (w2pre && userRecentlyActive(w2pre)) {
+                  dbg(`session.idle sid=${short(sid)}: user recently active, skipping action-intent prompt`);
+                  return;
+                }
                 const lastAssistantMsg = msgs.slice().reverse().find((m) => (m.role ?? m.info?.role) === "assistant");
                 if (lastAssistantMsg) {
                   let lastText = "";
@@ -14243,6 +14355,14 @@ var AutoResumePlugin = async (ctx, options) => {
         const props = ev.properties;
         const info = props?.info;
         const role = info?.role ?? props?.role;
+        if (role === "user") {
+          const w = sessions.get(sid);
+          if (w) {
+            w.doneClaimNoTodosAttempts = 0;
+            w.lastUserMessageAt = Date.now();
+          }
+          break;
+        }
         if (role !== "assistant")
           break;
         const tokens = info?.tokens ?? props?.tokens;

package/package.json

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