opencode-auto-resume 1.1.14 → 1.1.16

package/README.md

@@ -156,6 +156,10 @@ _Motivated by:_
 
 The model stream can die after emitting only reasoning — no text part, no tool call — finalizing with `finish: "unknown"`. OpenCode treats the message as completed and the session goes idle, so no error or stall path triggers. On idle, if the **newest** assistant message has a finish reason, zero text parts, and at least `silentDeadStreamMinTokens` output tokens, the plugin sends a recovery prompt. Only the newest assistant message is evaluated — a delivered text answer means normal completion, and older tool-call steps are never misread as dead streams. Recovery is also skipped if the session has gone busy/retry again before the prompt is sent (race guard).
 
+### Context saturation → magic-context wrapup
+
+A session can fill its usable context window without stalling — it just keeps working until it chokes. The plugin tracks token usage from `message.updated` events and computes the ratio against the model's usable window (`context − min(20k, maxOutput)`, mirroring OpenCode's own overflow math). On idle, when the ratio crosses `contextSaturationThreshold` (default 0.85), routing depends on session kind. For parent sessions, only when magic-context is detected in the host's configured plugin list (`config.get().plugin`), the plugin invokes the registered `ctx-wrapup` command through `client.session.command()` — it does not send `/ctx-wrapup` as prompt text, because prompt text is not expanded into a command. For subagent sessions identified by `parentID` on `session.created`, the default is no intervention: magic-context does run bounded cleanup for subagents (structural-noise/cleared-reasoning strips, heuristic drops, ceiling nudges), but its hard protections — historian compartments, emergency fail-closed abort, caveman compression — skip subagents, and on true overflow the error just propagates to the parent with no deterministic reclaim. Terminal reclamation therefore depends on the agent calling `ctx_reduce` when nudged. If `subagentNativeCompactionEnabled` is `true`, the plugin calls native `session.summarize()` as an opt-in safety net. Fail-safe: provider lookup errors, unknown model limits, user cancellation, or completion signals mean no intervention. Magic-context absence additionally disables only the parent path (the `ctx-wrapup` command would not be registered); the opt-in subagent path needs no magic-context detection because `session.summarize()` is native. This path is magic-context-gated on purpose: magic-context's setup disables OpenCode's native compaction, so unconditionally summarizing a magic-context-managed parent would double-compress and fight its cache-aware historian. One intervention per busy cycle.
+
 ---
 
 ### Active-tool safety guard
@@ -221,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.
 
 ---
 
@@ -261,7 +274,7 @@ All recovery paths fall into three families. Which family fires determines what
 
 Fire only after OpenCode reports the session **idle** — the runner has exited. The prompt starts a new run.
 
-Paths: todo nudges, tool-call-as-text recovery, thinking-tool recovery, action-intent nudge, ready-to-continue, done-claim verification, streaming-failure recovery, silent dead-stream recovery.
+Paths: todo nudges, tool-call-as-text recovery, thinking-tool recovery, action-intent nudge, ready-to-continue, done-claim verification, streaming-failure recovery, silent dead-stream recovery, context-saturation routing (magic-context-gated; parent sessions use `session.command`, subagents use opt-in native `session.summarize`).
 
 ### 2. Busy-silence continue (stream stall)
 
@@ -384,6 +397,9 @@ With options:
 | `doneWithoutDetailsPrompt` | `DONE_WITHOUT_DETAILS_PROMPT` | Override the done-claim-with-no-todos report prompt |
 | `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;
@@ -12370,6 +12371,7 @@ 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 CTX_WRAPUP_TRIGGER = "ctx-wrapup";
 var TOOL_TEXT_PATTERNS = [
   /<function\s*=/i,
   /<function>/i,
@@ -12455,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;
@@ -12619,6 +12630,9 @@ var AutoResumePlugin = async (ctx, options) => {
   const silentDeadStreamMinTokens = options?.silentDeadStreamMinTokens ?? DEFAULT_SILENT_DEAD_STREAM_MIN_TOKENS;
   const rawBusyStallStrategy = options?.busyStallStrategy ?? "continue";
   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);
@@ -12706,12 +12720,15 @@ var AutoResumePlugin = async (ctx, options) => {
         interruptedContinueCount: 0,
         recentToolCalls: [],
         liveToolSigs: [],
+        lastTokenTotal: 0,
+        contextWrapupAttempts: 0,
         toolLoopAttempts: 0,
         isSubagent: false,
         completionSignaled: false,
         todoNudgeAttempts: 0,
         taskCompleteOverrides: 0,
         doneClaimNoTodosAttempts: 0,
+        lastUserMessageAt: 0,
         pendingTools: 0,
         pendingCommands: 0,
         pendingRecovery: false,
@@ -12892,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: {
@@ -12933,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;
@@ -12989,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);
@@ -13124,6 +13173,67 @@ var AutoResumePlugin = async (ctx, options) => {
       return false;
     }
   }
+  let magicContextDetected = null;
+  async function isMagicContextInstalled() {
+    if (magicContextDetected !== null)
+      return magicContextDetected;
+    try {
+      const res = await ctx.client.config?.get?.();
+      const cfg = res?.data;
+      const plugins = cfg?.plugin;
+      if (!Array.isArray(plugins)) {
+        dbg("magic-context detection: plugin list unavailable, treating as not installed");
+        return false;
+      }
+      magicContextDetected = plugins.some((p) => {
+        const spec = typeof p === "string" ? p : Array.isArray(p) ? String(p[0]) : "";
+        return spec.toLowerCase().includes("magic-context");
+      });
+      return magicContextDetected;
+    } catch (e) {
+      const errMsg = e instanceof Error ? e.message : String(e);
+      dbg(`magic-context detection failed, treating as not installed: ${errMsg}`);
+      return false;
+    }
+  }
+  const usableLimitCache = new Map;
+  async function getUsableContextLimit(sid) {
+    try {
+      const msgs = await getSessionMessages(sid);
+      let model;
+      for (let i = msgs.length - 1;i >= 0; i--) {
+        const m = msgs[i];
+        if (m.role === "user") {
+          model = m.model ?? m.info?.model;
+          break;
+        }
+      }
+      if (!model || typeof model.providerID !== "string" || typeof model.modelID !== "string") {
+        return null;
+      }
+      const key = `${model.providerID}/${model.modelID}`;
+      const cached = usableLimitCache.get(key);
+      if (cached !== undefined)
+        return cached;
+      const res = await ctx.client.provider?.get?.();
+      const providers = res?.data ?? res;
+      if (!Array.isArray(providers))
+        return null;
+      const prov = providers.find((p) => p.id === model.providerID);
+      const models = prov?.models;
+      const entry = models?.find((x) => x.id === model.modelID);
+      const limit = entry?.limit;
+      if (!limit || typeof limit.context !== "number" || limit.context === 0)
+        return null;
+      const usable = limit.context - Math.min(20000, limit.output ?? 0);
+      usableLimitCache.set(key, usable);
+      return usable;
+    } catch (e) {
+      const errMsg = e instanceof Error ? e.message : String(e);
+      dbg(`usable-context-limit lookup failed for ${short(sid)}: ${errMsg}`);
+      return null;
+    }
+  }
   async function checkSessionHasActiveTool(sid) {
     try {
       const statusMap = await getSessionStatusMap();
@@ -13234,6 +13344,7 @@ var AutoResumePlugin = async (ctx, options) => {
     w.recentToolCalls = [];
     w.liveToolSigs = [];
     w.toolLoopAttempts = 0;
+    w.contextWrapupAttempts = 0;
     w.pendingRecovery = false;
     w.pendingRecoveryReason = null;
     w.pendingRecoveryAt = 0;
@@ -13244,7 +13355,6 @@ var AutoResumePlugin = async (ctx, options) => {
       w.toolTextTimer = null;
     }
     w.todoNudgeAttempts = 0;
-    w.doneClaimNoTodosAttempts = 0;
     w.continueTimestamps = [];
   }
   function resetIdleFlags(w) {
@@ -13321,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 = "";
@@ -13457,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 = {
@@ -13599,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`);
@@ -13851,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) {
@@ -13942,8 +14081,46 @@ var AutoResumePlugin = async (ctx, options) => {
           }
           prevBusyCount = currentBusy;
           log("debug", `${short(sid)} -> idle (${currentBusy})`);
+          if (w.isSubagent) {
+            try {
+              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 } });
+                  }
+                }
+              }
+            } catch (e) {
+              const errMsg = e instanceof Error ? e.message : String(e);
+              dbg(`session.idle sid=${short(sid)}: context-saturation check error: ${errMsg}`);
+            }
+          }
           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)) {
@@ -13982,6 +14159,27 @@ var AutoResumePlugin = async (ctx, options) => {
                 const errMsg = e instanceof Error ? e.message : String(e);
                 dbg(`session.idle sid=${short(sid)}: silent-dead-stream check error: ${errMsg}`);
               }
+              try {
+                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();
+                    if (!installed)
+                      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: "" }
+                    });
+                  }
+                }
+              } catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                dbg(`session.idle sid=${short(sid)}: context-saturation check error: ${errMsg}`);
+              }
             }
             let todos = w.todos || [];
             if (todos.length === 0) {
@@ -13992,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) {
@@ -14018,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 = "";
@@ -14058,7 +14264,10 @@ var AutoResumePlugin = async (ctx, options) => {
         const w = ensureWatch(sid);
         w.pendingTools = 0;
         w.pendingCommands = 0;
-        log("debug", `New session: ${short(sid)} (${sessions.size})`);
+        const createdProps = ev.properties;
+        const parentID = createdProps?.parentID ?? createdProps?.session?.parentID;
+        w.isSubagent = typeof parentID === "string" && parentID.length > 0;
+        log("debug", `New session: ${short(sid)} (${sessions.size})${w.isSubagent ? " [subagent]" : ""}`);
         break;
       }
       case "session.updated": {
@@ -14082,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 = "";
@@ -14131,6 +14349,34 @@ var AutoResumePlugin = async (ctx, options) => {
         }
         break;
       }
+      case "message.updated": {
+        if (!sid)
+          break;
+        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;
+        if (!tokens)
+          break;
+        const cache = tokens.cache;
+        const total = tokens.total ?? (tokens.input ?? 0) + (tokens.output ?? 0) + (cache?.read ?? 0) + (cache?.write ?? 0);
+        if (typeof total === "number" && total > 0) {
+          const w = ensureWatch(sid);
+          w.lastActivityAt = Date.now();
+          w.lastTokenTotal = total;
+        }
+        break;
+      }
       case "todo.updated": {
         if (!sid)
           break;

package/package.json

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