opencode-auto-resume 1.1.3 → 1.1.6

package/README.md

@@ -73,6 +73,81 @@ _Motivated by:_
 
 ---
 
+### Streaming failure recovery
+
+The AI provider's streaming response can fail mid-stream (connection reset, timeout, socket close). When the provider reports an error whose **name** matches `streamingFailureErrorNames` (exact, case-sensitive) or whose **message** matches `streamingFailureMessagePatterns` (regex, case-insensitive), the plugin arms a deferred recovery instead of relying only on the generic stall timeout. Invalid regex patterns fall back to substring matching.
+
+**Default error names:**
+- `ProviderError`, `APIError`, `StreamError`, `ConnectionError`, `TimeoutError`
+
+**Default message patterns:**
+- `streaming response failed`, `stream.*fail`, `connection.*reset`, `connection.*closed`
+
+#### Recovery behavior
+
+1. **Detection**: `session.error` is classified via `isStreamingFailure()` against the configured error names and message patterns
+2. **State transition**: the session's `pendingRecovery` flag is armed with the error name (`pendingRecoveryReason`) and timestamp (`pendingRecoveryAt`)
+3. **Recovery attempt**: once the session is idle and the backoff delay has elapsed, the timer loop sends a recovery prompt
+4. **Watchdog**: if the session is still not busy 3 seconds after the prompt, the recovery is retried (up to `maxRecoveryRetries`) with exponential backoff
+5. **Escalation**: when retries are exhausted, the plugin aborts the session and resumes it (`abort+resume`); `gaveUp` is set if that also fails
+
+#### Configuration
+
+Add to your plugin options (in `opencode.jsonc`):
+
+```json
+{
+  "streamingFailureErrorNames": ["ProviderError", "APIError", "StreamError", "ConnectionError", "TimeoutError"],
+  "streamingFailureMessagePatterns": ["streaming response failed", "stream.*fail", "connection.*reset", "connection.*closed"],
+  "maxRecoveryRetries": 2,
+  "baseBackoffMs": 1000,
+  "maxBackoffMs": 8000
+}
+```
+
+#### State machine addition
+
+New per-session recovery fields added to the state machine:
+- `pendingRecovery` — failure detected, recovery armed
+- `pendingRecoveryReason` — error name that triggered the recovery
+- `pendingRecoveryAt` — detection timestamp (backoff anchor)
+- `recoveryAttempts` — recovery attempt counter
+- `watchdogRetryGuard` — watchdog retry in progress (keeps the recovery armed)
+
+Recovery chain: `pendingRecovery` → recovery attempt → `recoveryAttempts` retry → `abort+resume` → `gaveUp`.
+
+See [Recovery Flow Documentation](docs/architecture/recovery-flow.md) for the full state machine.
+
+#### Example scenario
+
+```
+1. AI provider starts streaming response
+2. Network interruption causes "connection reset" error mid-stream
+3. System detects "ConnectionError" matches streamingFailureErrorNames
+4. Session's pendingRecovery flag is armed (reason=ConnectionError)
+5. Session goes idle; timer loop waits until the backoff delay has elapsed
+6. Recovery prompt sent (recoveryAttempts=1)
+7. Success → session busy → recovery flags cleared
+   Still not busy after 3s → watchdog retry (attempt 2/2)
+   Still not busy after 3s → maxRecoveryRetries reached → abort + resume
+   Abort+continue fails → gaveUp
+```
+
+#### Configuration reference
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `streamingFailureErrorNames` | `string[]` | `["ProviderError","APIError","StreamError","ConnectionError","TimeoutError"]` | Error names that indicate a streaming failure (exact, case-sensitive) |
+| `streamingFailureMessagePatterns` | `string[]` | `["streaming response failed","stream.*fail","connection.*reset","connection.*closed"]` | Regex patterns matching streaming failure messages (case-insensitive) |
+| `maxRecoveryRetries` | `number` | `2` | Maximum streaming-failure recovery attempts before abort+resume escalation |
+| `baseBackoffMs` | `number` | `1000` | Initial backoff delay in milliseconds |
+| `maxBackoffMs` | `number` | `8000` | Maximum backoff delay cap in milliseconds |
+
+_Motivated by:_
+- [EPIC: Streaming Failure Recovery](docs/EPIC-Streaming-Recovery-OpenCode-Auto-Resume-v3.md) — recovery requests not consistently creating new assistant executions after mid-stream failures
+
+---
+
 ### Active-tool safety guard
 
 Before **any** abort, the plugin calls `checkSessionHasActiveTool()` to verify the session isn't mid-tool-execution. If a tool is running, the abort is skipped. This prevents the plugin from killing a long-running build, test suite, or command — even when it looks like a stall.
@@ -190,11 +265,7 @@ Periodic: cleanup idle sessions older than 10min or >50 entries
 
 ## Installation
 
-### Via npm (recommended)
-
-```bash
-npm install opencode-auto-resume
-```
+### Opencode
 
 Add to your `opencode.jsonc`:
 
@@ -219,17 +290,6 @@ With options:
 }
 ```
 
-### Via GitHub (manual clone)
-
-OpenCode may clone the repository to `~/.config/opencode/plugins/opencode-auto-resume/` automatically.
-
-**To update** the plugin:
-```bash
-cd ~/.config/opencode/plugins/opencode-auto-resume
-git pull
-bun run build
-```
-
 ## Configuration
 
 ```json
@@ -256,6 +316,11 @@ bun run build
 | `subagentWaitMs` | `15000` | Wait before treating orphan parent as stuck |
 | `loopMaxContinues` | `3` | Continues in window before triggering abort |
 | `loopWindowMs` | `600000` | Hallucination loop detection window (10 min) |
+| `streamingFailureErrorNames` | `["ProviderError","APIError","StreamError","ConnectionError","TimeoutError"]` | Error names that classify as streaming failures (exact match) |
+| `streamingFailureMessagePatterns` | `["streaming response failed","stream.*fail","connection.*reset","connection.*closed"]` | Regex patterns (case-insensitive) in error messages indicating streaming failure |
+| `maxRecoveryRetries` | `2` | Max streaming-failure recovery attempts before abort+resume escalation |
+
+Message patterns are matched case-insensitively. Error names use exact match.
 
 ### Internal constants (not configurable)
 

package/dist/index.js

@@ -12345,8 +12345,24 @@ var DEFAULT_SUBAGENT_WAIT_MS = 15000;
 var ABORT_CONTINUE_DELAY_MS = 2000;
 var DEFAULT_LOOP_MAX_CONTINUES = 3;
 var DEFAULT_LOOP_WINDOW_MS = 10 * 60000;
-var TOOL_TEXT_CHECK_DELAY_MS = 3000;
-var MIN_ACTIVITY_GAP_MS = 1000;
+var DEFAULT_TOOL_TEXT_CHECK_DELAY_MS = 3000;
+var DEFAULT_MAX_RECOVERY_RETRIES = 2;
+var DEFAULT_MIN_ACTIVITY_GAP_MS = 1000;
+var DEFAULT_WARMUP_MS = 15000;
+var DEFAULT_DEBUG = false;
+var DEFAULT_STREAMING_FAILURE_ERROR_NAMES = [
+  "ProviderError",
+  "APIError",
+  "StreamError",
+  "ConnectionError",
+  "TimeoutError"
+];
+var DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS = [
+  "streaming response failed",
+  "stream.*fail",
+  "connection.*reset",
+  "connection.*closed"
+];
 var MAX_IDLE_SESSIONS = 50;
 var IDLE_CLEANUP_MS = 10 * 60000;
 var SESSION_DISCOVERY_INTERVAL_MS = 60000;
@@ -12388,13 +12404,17 @@ var READY_TO_CONTINUE_PATTERNS = [
   /will continue with task/i,
   /moving on to task/i
 ];
+function stripCodeBlocks(text) {
+  return text.replace(/```[\s\S]*?```/g, "").replace(/`[^`\n]+`/g, "");
+}
 function containsToolCallAsText(text) {
   if (text.length <= 10)
     return false;
-  if (TOOL_TEXT_PATTERNS.some((pat) => pat.test(text)))
+  const stripped = stripCodeBlocks(text);
+  if (TOOL_TEXT_PATTERNS.some((pat) => pat.test(stripped)))
     return true;
   for (const { open, close } of TRUNCATED_XML_PATTERNS) {
-    if (open.test(text) && !close.test(text))
+    if (open.test(stripped) && !close.test(stripped))
       return true;
   }
   return false;
@@ -12429,17 +12449,97 @@ function containsDoneClaimPattern(text) {
 `);
   return DONE_CLAIM_PATTERNS.some((pat) => pat.test(lastLines));
 }
+function isStreamingFailure(errorName, errorMessage, errorNames = DEFAULT_STREAMING_FAILURE_ERROR_NAMES, messagePatterns = DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS) {
+  if (!errorName && !errorMessage)
+    return false;
+  if (errorName && errorNames.includes(errorName)) {
+    return true;
+  }
+  if (errorMessage) {
+    const lowerMessage = errorMessage.toLowerCase();
+    for (const pattern of messagePatterns) {
+      try {
+        if (new RegExp(pattern, "i").test(lowerMessage))
+          return true;
+      } catch {
+        if (lowerMessage.includes(pattern.toLowerCase()))
+          return true;
+      }
+    }
+  }
+  return false;
+}
+function getLastAssistantError(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    const role = msg.role ?? msg.info?.role;
+    if (role !== "assistant")
+      continue;
+    const info = msg.info;
+    const err = msg.error ?? info?.error;
+    if (err) {
+      const data = err.data;
+      const name = err.name ?? "";
+      const message = data?.message ?? err.message ?? "";
+      return { name, message };
+    }
+    const parts = msg.parts;
+    if (parts) {
+      for (let j = parts.length - 1;j >= 0; j--) {
+        const part = parts[j];
+        if (part.type !== "retry")
+          continue;
+        const partErr = part.error;
+        if (!partErr)
+          continue;
+        const data = partErr.data;
+        const name = partErr.name ?? "";
+        const message = data?.message ?? partErr.message ?? "";
+        return { name, message };
+      }
+    }
+  }
+  return null;
+}
+function backoffMs(attempt, baseBackoffMs = DEFAULT_BASE_BACKOFF_MS, maxBackoffMs = DEFAULT_MAX_BACKOFF_MS) {
+  return Math.min(baseBackoffMs * Math.pow(2, attempt - 1), maxBackoffMs);
+}
+function containsActionIntent(text) {
+  if (text.length <= 15)
+    return false;
+  const cleaned = text.replace(/<[a-zA-Z/?][^>]*>/g, "").trim();
+  const lines = cleaned.split(`
+`);
+  let lastLine = "";
+  for (let i = lines.length - 1;i >= 0; i--) {
+    if (lines[i].trim().length > 0) {
+      lastLine = lines[i].trim();
+      break;
+    }
+  }
+  return lastLine.endsWith(":") && lastLine.length > 5 && lastLine.length < 500;
+}
+function isOpenTodo(t) {
+  return t.status === "pending" || t.status === "in_progress";
+}
+function getOpenTodos(todos) {
+  return todos.filter(isOpenTodo);
+}
 function buildOpenTodosReminder(todos) {
+  if (!Array.isArray(todos))
+    return "continue";
   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" : "";
+  const taskWord = open.length > 1 ? "tasks" : "task";
+  const thisWord = open.length > 1 ? "these" : "this";
   return `You have ${open.length} unfinished task${plural}:
 ${list}
 
-Please continue working on these task${plural}.`;
+Please continue working on ${thisWord} ${taskWord}.`;
 }
 var AutoResumePlugin = async (ctx, options) => {
   const chunkTimeoutMs = options?.chunkTimeoutMs ?? DEFAULT_CHUNK_TIMEOUT_MS;
@@ -12451,6 +12551,23 @@ var AutoResumePlugin = async (ctx, options) => {
   const subagentWaitMs = options?.subagentWaitMs ?? DEFAULT_SUBAGENT_WAIT_MS;
   const loopMaxContinues = options?.loopMaxContinues ?? DEFAULT_LOOP_MAX_CONTINUES;
   const loopWindowMs = options?.loopWindowMs ?? DEFAULT_LOOP_WINDOW_MS;
+  const toolTextCheckDelayMs = options?.toolTextCheckDelayMs ?? DEFAULT_TOOL_TEXT_CHECK_DELAY_MS;
+  const maxRecoveryRetries = options?.maxRecoveryRetries ?? DEFAULT_MAX_RECOVERY_RETRIES;
+  const minActivityGapMs = options?.minActivityGapMs ?? DEFAULT_MIN_ACTIVITY_GAP_MS;
+  const warmupMs = options?.warmupMs ?? DEFAULT_WARMUP_MS;
+  const debug = options?.debug ?? DEFAULT_DEBUG;
+  const streamingFailureErrorNames = options?.streamingFailureErrorNames ?? DEFAULT_STREAMING_FAILURE_ERROR_NAMES;
+  const streamingFailureMessagePatterns = options?.streamingFailureMessagePatterns ?? DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS;
+  const resumeOnActionIntent = options?.resumeOnActionIntent !== false;
+  const continuePrompt = options?.continuePrompt ?? "continue";
+  const actionIntentPrompt = options?.actionIntentPrompt ?? continuePrompt;
+  const toolTextRecoveryPrompt = options?.toolTextRecoveryPrompt ?? TOOL_TEXT_RECOVERY_PROMPT;
+  const thinkingToolRecoveryPrompt = options?.thinkingToolRecoveryPrompt ?? THINKING_TOOL_RECOVERY_PROMPT;
+  const doneWithoutWorkPrompt = options?.doneWithoutWorkPrompt ?? DONE_WITHOUT_WORK_PROMPT;
+  const dbg = (...args) => {
+    if (debug)
+      console.log("[debug]", ...args);
+  };
   const sessions = new Map;
   let timer = null;
   let discoveryTimer = null;
@@ -12476,12 +12593,27 @@ var AutoResumePlugin = async (ctx, options) => {
   async function log(level, msg) {
     try {
       await ctx.client.app.log({ body: { service: "auto-resume", level, message: msg } });
-    } catch {}
+    } catch (e) {
+      console.error("[auto-resume] log() failed:", e instanceof Error ? e.message : String(e));
+    }
+  }
+  async function safe(fn, ctxLabel) {
+    try {
+      return await fn();
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.error(`[auto-resume] ${ctxLabel}: ${msg}`);
+      try {
+        await log("error", `${ctxLabel}: ${msg}`);
+      } catch {}
+      return;
+    }
   }
   function ensureWatch(sid) {
     let w = sessions.get(sid);
     if (!w) {
       w = {
+        createdAt: Date.now(),
         lastActivityAt: Date.now(),
         status: "unknown",
         userCancelled: false,
@@ -12506,8 +12638,15 @@ var AutoResumePlugin = async (ctx, options) => {
         isSubagent: false,
         completionSignaled: false,
         todoNudgeAttempts: 0,
+        taskCompleteOverrides: 0,
+        doneClaimNoTodosAttempts: 0,
         pendingTools: 0,
-        pendingCommands: 0
+        pendingCommands: 0,
+        pendingRecovery: false,
+        pendingRecoveryReason: null,
+        pendingRecoveryAt: 0,
+        recoveryAttempts: 0,
+        watchdogRetryGuard: false
       };
       sessions.set(sid, w);
     }
@@ -12568,9 +12707,6 @@ var AutoResumePlugin = async (ctx, options) => {
   function short(sid) {
     return sid.length > 12 ? `...${sid.slice(-8)}` : sid;
   }
-  function backoffMs(attempt) {
-    return Math.min(baseBackoffMs * Math.pow(2, attempt - 1), maxBackoffMs);
-  }
   function cleanupIdleSessions() {
     const now = Date.now();
     const toDelete = [];
@@ -12605,12 +12741,52 @@ var AutoResumePlugin = async (ctx, options) => {
       log("debug", `Cleaned up ${toDelete.length} idle session(s). Map size: ${sessions.size}`);
     }
   }
+  function getPromptResponsePayload(result) {
+    if (!result || typeof result !== "object")
+      return null;
+    const raw = result;
+    const data = raw.data;
+    if (data && typeof data === "object" && "parts" in data) {
+      return data;
+    }
+    if ("parts" in raw) {
+      return raw;
+    }
+    return null;
+  }
+  async function logPromptResponse(result, context) {
+    const payload = getPromptResponsePayload(result);
+    const isRetry = context.isRetry ?? false;
+    if (!payload) {
+      await log("debug", `${short(context.sessionId)} - session.prompt() response has unexpected structure: ${JSON.stringify({ sessionId: context.sessionId, isRetry, rawResponse: JSON.stringify(result) })}`);
+      return;
+    }
+    const parts = Array.isArray(payload.parts) ? payload.parts : [];
+    const partsCount = parts.length;
+    const info = payload.info && typeof payload.info === "object" ? payload.info : undefined;
+    const infoKeys = info ? Object.keys(info) : [];
+    const hasParts = partsCount > 0;
+    await log("debug", `${short(context.sessionId)} - session.prompt() response received: ${JSON.stringify({ sessionId: context.sessionId, isRetry, hasParts, partsCount, infoKeys, info })}`);
+    if (partsCount === 0) {
+      await log("warn", `${short(context.sessionId)} - session.prompt() returned empty parts array - possible stream initiation failure: ${JSON.stringify({ sessionId: context.sessionId, isRetry, responseInfo: info, partsCount })}`);
+    }
+    if (info && "error" in info) {
+      await log("warn", `${short(context.sessionId)} - session.prompt() response.info contains error indicator: ${JSON.stringify({ sessionId: context.sessionId, isRetry, errorInfo: info.error })}`);
+    }
+    await log("debug", `${short(context.sessionId)} - session.prompt() raw response: ${JSON.stringify({ sessionId: context.sessionId, isRetry, rawResponse: JSON.stringify(result, null, 2) })}`);
+  }
   async function sendContinuePrompt(sid, text, w) {
-    if (w.continuing) {
+    if (w.continuing && !w.watchdogRetryGuard) {
       await log("debug", `${short(sid)} - continue already in progress, skipping`);
       return;
     }
+    if (!w.continuing)
+      dbg(`State transition on ${short(sid)}: continuing=false -> true`);
     w.continuing = true;
+    if (w.watchdogRetryGuard) {
+      w.pendingRecovery = true;
+    }
+    w.watchdogRetryGuard = false;
     let agent;
     let model;
     try {
@@ -12641,7 +12817,8 @@ var AutoResumePlugin = async (ctx, options) => {
           break;
         }
       }
-      await ctx.client.session.prompt({
+      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)"}`);
+      const response = await ctx.client.session.prompt({
         path: { id: sid },
         body: {
           parts: [{ type: "text", text }],
@@ -12649,6 +12826,7 @@ var AutoResumePlugin = async (ctx, options) => {
           model
         }
       });
+      await logPromptResponse(response, { sessionId: sid });
       await log("debug", `${short(sid)} - prompt sent with agent: ${agent ?? "(default)"}, model: ${model ? `${model.providerID}/${model.modelID}` : "(default)"}`);
       recordContinue(sid);
       w.lastRetryAt = Date.now();
@@ -12656,10 +12834,11 @@ var AutoResumePlugin = async (ctx, options) => {
       const errMsg = err instanceof Error ? err.message : String(err);
       await log("warn", `${short(sid)} - prompt failed: ${errMsg}`);
       try {
-        await ctx.client.session.prompt({
+        const retryResponse = await ctx.client.session.prompt({
           path: { id: sid },
           body: { parts: [{ type: "text", text }], agent, model }
         });
+        await logPromptResponse(retryResponse, { sessionId: sid, isRetry: true });
         recordContinue(sid);
         w.lastRetryAt = Date.now();
       } catch (retryErr) {
@@ -12668,6 +12847,8 @@ var AutoResumePlugin = async (ctx, options) => {
         throw retryErr;
       }
     } finally {
+      if (w.continuing)
+        dbg(`State transition on ${short(sid)}: continuing=true -> false`);
       w.continuing = false;
       w.todoCheckAttempts = 0;
       if (w.toolTextTimer) {
@@ -12677,9 +12858,53 @@ var AutoResumePlugin = async (ctx, options) => {
     }
     setTimeout(async () => {
       if (w.status !== "busy") {
-        await log("warn", `${short(sid)} - prompt sent >${TOOL_TEXT_CHECK_DELAY_MS / 1000}s ago but session is still ${w.status}`);
+        if (w.pendingRecovery) {
+          if (w.recoveryAttempts < maxRecoveryRetries) {
+            w.recoveryAttempts++;
+            dbg(`State transition on ${short(sid)}: recoveryAttempts=${w.recoveryAttempts - 1} -> ${w.recoveryAttempts}`);
+            w.watchdogRetryGuard = true;
+            await log("warn", `${short(sid)} - recovery attempt ${w.recoveryAttempts}/${maxRecoveryRetries} after prompt timeout`);
+            await log("warn", `Recovery failed on ${short(sid)} - session still ${w.status}: attempt=${w.recoveryAttempts}, maxRetries=${maxRecoveryRetries}, nextAction=retry`);
+            dbg(`Watchdog check on ${short(sid)}: status=${w.status}, recoveryAttempts=${w.recoveryAttempts}, maxRetries=${maxRecoveryRetries}, watchdogLatencyMs=${Date.now() - w.lastRetryAt} -> RETRY`);
+            const retryBackoffMs = backoffMs(w.recoveryAttempts, baseBackoffMs, maxBackoffMs);
+            await log("info", `Retrying recovery on ${short(sid)}: attempt=${w.recoveryAttempts}, backoffMs=${retryBackoffMs}`);
+            dbg(`Retrying recovery on ${short(sid)}: recoveryAttempts=${w.recoveryAttempts}, backoffMs=${retryBackoffMs}, pendingRecoveryReason=${w.pendingRecoveryReason}`);
+            try {
+              await sendContinuePrompt(sid, continuePrompt, w);
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              await log("warn", `${short(sid)} - recovery retry failed: ${errMsg}`);
+              w.recoveryAttempts = 0;
+            }
+            w.watchdogRetryGuard = false;
+          } else {
+            dbg(`Pending recovery cleared on ${short(sid)}: reason=recovery-attempt`);
+            w.pendingRecovery = false;
+            await log("warn", `${short(sid)} - max recovery attempts (${maxRecoveryRetries}) reached, escalating to abort+resume`);
+            await log("warn", `Recovery failed on ${short(sid)} - session still ${w.status}: attempt=${w.recoveryAttempts}, maxRetries=${maxRecoveryRetries}, nextAction=abort-resume`);
+            await log("warn", `Escalating to abort+resume on ${short(sid)}: attempt=${w.recoveryAttempts}`);
+            dbg(`Watchdog check on ${short(sid)}: status=${w.status}, recoveryAttempts=${w.recoveryAttempts}, maxRetries=${maxRecoveryRetries}, watchdogLatencyMs=${Date.now() - w.lastRetryAt} -> ABORT_RESUME`);
+            const resumed = await tryAbortAndResume(sid, w);
+            if (!resumed && !w.aborting) {
+              await log("warn", `Recovery exhausted on ${short(sid)}: attempts=${w.recoveryAttempts}, lastError=abort+resume failed`);
+              dbg(`Watchdog check on ${short(sid)}: status=${w.status} -> GAVE_UP`);
+              if (w.pendingRecoveryAt > 0) {
+                dbg(`Total recovery cycle on ${short(sid)} (failed): totalCycleMs=${Date.now() - w.pendingRecoveryAt}`);
+              }
+            }
+          }
+        } else {
+          await log("warn", `${short(sid)} - prompt sent >${toolTextCheckDelayMs / 1000}s ago but session is still ${w.status}`);
+        }
+      } else {
+        const elapsedMs = Date.now() - w.lastRetryAt;
+        await log("info", `Recovery successful on ${short(sid)}: elapsedMs=${elapsedMs}`);
+        dbg(`Watchdog check on ${short(sid)}: status=busy, elapsedMs=${elapsedMs} -> SUCCESS`);
+        if (w.pendingRecoveryAt > 0) {
+          dbg(`Total recovery cycle on ${short(sid)}: totalCycleMs=${Date.now() - w.pendingRecoveryAt}`);
+        }
       }
-    }, TOOL_TEXT_CHECK_DELAY_MS);
+    }, toolTextCheckDelayMs);
   }
   function extractMessages(response) {
     if (Array.isArray(response))
@@ -12851,7 +13076,6 @@ var AutoResumePlugin = async (ctx, options) => {
     w.toolTextRecovered = false;
     w.toolTextAttempts = 0;
     w.completionSignaled = false;
-    w.todoNudgeAttempts = 0;
     w.continueTimestamps = [];
     w.idleSince = null;
     w.continuing = false;
@@ -12864,6 +13088,11 @@ var AutoResumePlugin = async (ctx, options) => {
       clearTimeout(w.toolTextTimer);
       w.toolTextTimer = null;
     }
+    w.pendingRecovery = false;
+    w.pendingRecoveryReason = null;
+    w.pendingRecoveryAt = 0;
+    w.recoveryAttempts = 0;
+    w.watchdogRetryGuard = false;
   }
   function resetIdleFlags(w) {
     w.aborting = false;
@@ -12917,9 +13146,10 @@ var AutoResumePlugin = async (ctx, options) => {
     if (w.checkingToolText)
       return;
     w.checkingToolText = true;
+    dbg(`checkForToolCallAsText called for ${short(sid)}, userCancelled=${w.userCancelled}, toolTextRecovered=${w.toolTextRecovered}, toolTextAttempts=${w.toolTextAttempts}`);
     if (w.toolTextAttempts > 0) {
       const elapsed = Date.now() - w.lastRetryAt;
-      const requiredBackoff = backoffMs(w.toolTextAttempts);
+      const requiredBackoff = backoffMs(w.toolTextAttempts, baseBackoffMs, maxBackoffMs);
       if (elapsed < requiredBackoff)
         return;
     }
@@ -12990,7 +13220,7 @@ var AutoResumePlugin = async (ctx, options) => {
               }
             } else {
               const candidate = {
-                prompt: "continue",
+                prompt: continuePrompt,
                 source: "tool-use",
                 priority: 1
               };
@@ -13017,7 +13247,7 @@ var AutoResumePlugin = async (ctx, options) => {
               }
             }
             const candidate = {
-              prompt: isReasoning ? THINKING_TOOL_RECOVERY_PROMPT : TOOL_TEXT_RECOVERY_PROMPT,
+              prompt: isReasoning ? thinkingToolRecoveryPrompt : toolTextRecoveryPrompt,
               source: isReasoning ? "reasoning" : "text",
               priority: 0
             };
@@ -13027,13 +13257,13 @@ var AutoResumePlugin = async (ctx, options) => {
           }
           if (containsReadyToContinuePattern(text)) {
             const todos = w.todos || [];
-            const hasOpenTodos = todos.some((t) => t.status === "pending" || t.status === "in_progress");
+            const hasOpenTodos = todos.some(isOpenTodo);
             if (!hasOpenTodos && todos.length > 0) {
               w.todoCheckAttempts++;
               if (w.todoCheckAttempts >= 2) {
                 await log("info", `${short(sid)} - todos completed but agent hasn't closed them. Sending continue...`);
                 const candidate2 = {
-                  prompt: "continue",
+                  prompt: continuePrompt,
                   source: "todo-completed-continue",
                   priority: 1
                 };
@@ -13046,7 +13276,7 @@ var AutoResumePlugin = async (ctx, options) => {
               continue;
             }
             const candidate = {
-              prompt: containsDoneClaimPattern(text) ? DONE_WITHOUT_WORK_PROMPT : "continue",
+              prompt: containsDoneClaimPattern(text) ? doneWithoutWorkPrompt : continuePrompt,
               source: containsDoneClaimPattern(text) ? "done-claim" : "ready-to-continue",
               priority: 1
             };
@@ -13056,14 +13286,42 @@ var AutoResumePlugin = async (ctx, options) => {
           }
           if (!bestCandidate && containsDoneClaimPattern(text)) {
             const todos = w.todos || [];
-            const hasOpenTodos = todos.some((t) => t.status === "pending" || t.status === "in_progress");
+            const hasOpenTodos = todos.some(isOpenTodo);
             if (hasOpenTodos) {
               await log("info", `${short(sid)} - model claims done but todos remain open. Sending recovery prompt...`);
               bestCandidate = {
-                prompt: DONE_WITHOUT_WORK_PROMPT,
+                prompt: doneWithoutWorkPrompt,
                 source: "done-claim-no-emoji",
                 priority: 1
               };
+            } else if (w.doneClaimNoTodosAttempts < maxRetries) {
+              await log("info", `${short(sid)} - model claims done with no open todos. Sending verification prompt (attempt ${w.doneClaimNoTodosAttempts + 1}/${maxRetries})...`);
+              bestCandidate = {
+                prompt: doneWithoutWorkPrompt,
+                source: "done-claim-no-todos",
+                priority: 1
+              };
+            }
+          }
+        }
+      }
+      if (resumeOnActionIntent) {
+        const lastAssistantMsg = messages.slice().reverse().find((m) => (m.role ?? m.info?.role) === "assistant");
+        if (lastAssistantMsg) {
+          let lastAssistantText = "";
+          for (const part of lastAssistantMsg.parts || []) {
+            lastAssistantText += (part.text ?? "") + `
+`;
+          }
+          if (containsActionIntent(lastAssistantText)) {
+            dbg(`ACTION INTENT DETECTED in checkForToolCallAsText for ${short(sid)}`);
+            const candidate = {
+              prompt: actionIntentPrompt,
+              source: "action-intent",
+              priority: 2
+            };
+            if (!bestCandidate || candidate.priority < bestCandidate.priority) {
+              bestCandidate = candidate;
             }
           }
         }
@@ -13082,10 +13340,10 @@ var AutoResumePlugin = async (ctx, options) => {
       }
       if (!bestCandidate) {
         const todos = w.todos || [];
-        const hasOpenTodos = todos.some((t) => t.status === "pending" || t.status === "in_progress");
+        const hasOpenTodos = todos.some(isOpenTodo);
         if (hasOpenTodos && busyCount() === 0) {
           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...`);
+          await log("info", `${short(sid)} - no activity detected but todos remain open (${getOpenTodos(todos).length} tasks). Sending reminder...`);
           bestCandidate = {
             prompt: reminder,
             source: "idle-with-open-todos-reminder",
@@ -13098,19 +13356,22 @@ var AutoResumePlugin = async (ctx, options) => {
       if (!bestCandidate)
         return;
       const isOpenTodosReminder = bestCandidate.source === "idle-with-open-todos-reminder";
+      const isDoneClaimNoTodos = bestCandidate.source === "done-claim-no-todos";
       if (isOpenTodosReminder) {
         if (w.todoNudgeAttempts >= maxRetries) {
-          await log("info", `${short(sid)} - max open-todos nudges (${maxRetries}) reached for this idle cycle, waiting for activity`);
+          await log("info", `${short(sid)} - max open-todos nudges (${maxRetries}) reached, waiting for activity`);
           return;
         }
-        w.todoNudgeAttempts++;
+      } else if (isDoneClaimNoTodos) {
+        w.doneClaimNoTodosAttempts++;
       } 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 attemptNum = isOpenTodosReminder ? w.todoNudgeAttempts : isDoneClaimNoTodos ? w.doneClaimNoTodosAttempts : w.toolTextAttempts;
+      await log("info", `${bestCandidate.source} detected on ${short(sid)}! ` + `Attempt ${attemptNum}/${maxRetries}. Sending recovery prompt...`);
       const timeSinceActivity = Date.now() - w.lastActivityAt;
-      if (timeSinceActivity < MIN_ACTIVITY_GAP_MS) {
+      if (timeSinceActivity < minActivityGapMs) {
         await log("info", `${short(sid)} - skipping ${bestCandidate.source}, session was active ${Math.round(timeSinceActivity / 1000)}s ago`);
         return;
       }
@@ -13129,6 +13390,8 @@ var AutoResumePlugin = async (ctx, options) => {
       } else {
         try {
           await sendContinuePrompt(sid, bestCandidate.prompt, w);
+          if (isOpenTodosReminder)
+            w.todoNudgeAttempts++;
           await log("info", `${short(sid)} - ${bestCandidate.source} recovery sent (attempt ${w.toolTextAttempts})`);
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err);
@@ -13155,6 +13418,7 @@ var AutoResumePlugin = async (ctx, options) => {
     try {
       await ctx.client.session.abort({ path: { id: sid } });
       await log("info", `${short(sid)} - abort OK`);
+      dbg(`Abort succeeded on ${short(sid)}, waiting ${ABORT_CONTINUE_DELAY_MS}ms before continue prompt`);
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
       await log("warn", `${short(sid)} - abort failed: ${errMsg}`);
@@ -13165,7 +13429,7 @@ var AutoResumePlugin = async (ctx, options) => {
     if (w.status === "busy")
       w.status = "idle";
     try {
-      await sendContinuePrompt(sid, "continue", w);
+      await sendContinuePrompt(sid, continuePrompt, w);
       await log("info", `${short(sid)} - abort+continue done`);
       w.orphanWatchStartAt = null;
       w.resumeAttempts++;
@@ -13185,7 +13449,7 @@ var AutoResumePlugin = async (ctx, options) => {
     }
     const now = Date.now();
     const elapsedSinceRetry = now - w.lastRetryAt;
-    const requiredBackoff = backoffMs(w.resumeAttempts);
+    const requiredBackoff = backoffMs(w.resumeAttempts, baseBackoffMs, maxBackoffMs);
     if (w.lastRetryAt > 0 && elapsedSinceRetry < requiredBackoff)
       return false;
     if (isHallucinationLoop(sid)) {
@@ -13207,7 +13471,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, prompt ?? "continue", w);
+      await sendContinuePrompt(sid, prompt ?? continuePrompt, w);
       await log("info", `${short(sid)} - retry sent`);
       return true;
     } catch (err) {
@@ -13247,129 +13511,188 @@ var AutoResumePlugin = async (ctx, options) => {
     if (timer)
       return;
     timer = setInterval(async () => {
-      const now = Date.now();
-      const numBusy = busyCount();
-      const statusMap = await getSessionStatusMap();
-      for (const [sid, w] of sessions) {
-        const realStatus = statusMap[sid];
-        if (realStatus && realStatus !== w.status) {
-          w.status = realStatus;
-          if (realStatus === "busy")
-            w.idleSince = null;
-        }
-        if (w.status !== "busy")
-          continue;
-        if (w.userCancelled)
-          continue;
-        if (w.aborting)
-          continue;
-        if (w.orphanWatchStartAt !== null) {
-          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`);
-                w.orphanWatchStartAt = now;
-                continue;
-              }
-              const subStatus = await checkSubagentStatus(sid);
-              if (subStatus.status === "crashed" && subStatus.stuckSid) {
-                const recovered = await recoverSubagent(subStatus.stuckSid);
-                if (recovered) {
-                  await log("info", `Sent recovery prompt to stuck subagent ${short(subStatus.stuckSid)}, waiting...`);
-                } else {
-                  await log("info", `Subagent crashed, triggering abort+resume on ${short(sid)}`);
-                  tryAbortAndResume(sid, w);
+      await safe(async () => {
+        const now = Date.now();
+        const numBusy = busyCount();
+        const statusMap = await getSessionStatusMap();
+        for (const [sid, w] of sessions) {
+          const realStatus = statusMap[sid];
+          if (realStatus && realStatus !== w.status) {
+            w.status = realStatus;
+            if (realStatus === "busy")
+              w.idleSince = null;
+          }
+          if (w.status !== "busy")
+            continue;
+          if (w.userCancelled)
+            continue;
+          if (w.aborting)
+            continue;
+          if (w.orphanWatchStartAt !== null) {
+            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`);
+                  w.orphanWatchStartAt = now;
+                  continue;
                 }
-              } else if (subStatus.status === "idle") {
-                const hasBusySub = await hasBusySubagents(sid);
-                if (hasBusySub) {
-                  await log("debug", `Subagents exist but not busy yet, waiting for startup...`);
+                const subStatus = await checkSubagentStatus(sid);
+                if (subStatus.status === "crashed" && subStatus.stuckSid) {
+                  const recovered = await recoverSubagent(subStatus.stuckSid);
+                  if (recovered) {
+                    await log("info", `Sent recovery prompt to stuck subagent ${short(subStatus.stuckSid)}, waiting...`);
+                  } else {
+                    await log("info", `Subagent crashed, triggering abort+resume on ${short(sid)}`);
+                    tryAbortAndResume(sid, w);
+                  }
+                } else if (subStatus.status === "idle") {
+                  const hasBusySub = await hasBusySubagents(sid);
+                  if (hasBusySub) {
+                    await log("debug", `Subagents exist but not busy yet, waiting for startup...`);
+                  } else {
+                    await log("info", `Parent ${short(sid)} stuck with no active subagents. Triggering abort+resume.`);
+                    tryAbortAndResume(sid, w);
+                  }
                 } else {
-                  await log("info", `Parent ${short(sid)} stuck with no active subagents. Triggering abort+resume.`);
-                  tryAbortAndResume(sid, w);
+                  await log("debug", `Subagent still running, waiting...`);
                 }
-              } else {
-                await log("debug", `Subagent still running, waiting...`);
+              } else if (!w.gaveUp) {
+                w.gaveUp = true;
+                dbg(`State transition on ${short(sid)}: gaveUp=false -> true`);
+                w.orphanWatchStartAt = null;
+                w.aborting = false;
+                log("warn", `${short(sid)} - orphan retries exhausted.`);
               }
-            } else if (!w.gaveUp) {
-              w.gaveUp = true;
-              w.orphanWatchStartAt = null;
-              w.aborting = false;
-              log("warn", `${short(sid)} - orphan retries exhausted.`);
             }
-          }
-          continue;
-        }
-        if (numBusy > 1)
-          continue;
-        if (now - w.lastSubagentCheckAt < checkIntervalMs * 2)
-          continue;
-        w.lastSubagentCheckAt = now;
-        if (w.lastActivityAt > 0 && now - w.lastActivityAt > subagentWaitMs) {
-          if (realStatus === "busy") {
-            await log("debug", `Session ${short(sid)} is still busy (real status), skipping abort`);
-            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;
+          if (numBusy > 1)
             continue;
-          }
-          const hasActiveTool = await checkSessionHasActiveTool(sid);
-          if (hasActiveTool) {
-            await log("debug", `Session ${short(sid)} has active tool call, skipping abort check`);
-            w.lastSubagentCheckAt = now;
+          if (now - w.lastSubagentCheckAt < checkIntervalMs * 2)
             continue;
+          w.lastSubagentCheckAt = now;
+          if (w.lastActivityAt > 0 && now - w.lastActivityAt > subagentWaitMs) {
+            if (realStatus === "busy") {
+              await log("debug", `Session ${short(sid)} is still busy (real status), skipping abort`);
+              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`);
+              w.lastSubagentCheckAt = now;
+              continue;
+            }
+            const subStatus = await checkSubagentStatus(sid);
+            if (subStatus.status === "idle" || subStatus.status === "unknown") {
+              await log("info", `Parent ${short(sid)} stuck with no active subagents. Triggering abort+resume.`);
+              tryAbortAndResume(sid, w);
+              continue;
+            } else if (subStatus.status === "crashed" && subStatus.stuckSid) {
+              const recovered = await recoverSubagent(subStatus.stuckSid);
+              if (recovered) {
+                await log("info", `Sent recovery prompt to stuck subagent ${short(subStatus.stuckSid)}, waiting...`);
+              } else {
+                await log("info", `Parent ${short(sid)} subagent recovery failed. Triggering abort+resume.`);
+                tryAbortAndResume(sid, w);
+              }
+              continue;
+            }
           }
-          const subStatus = await checkSubagentStatus(sid);
-          if (subStatus.status === "idle" || subStatus.status === "unknown") {
-            await log("info", `Parent ${short(sid)} stuck with no active subagents. Triggering abort+resume.`);
-            tryAbortAndResume(sid, w);
-            continue;
-          } else if (subStatus.status === "crashed" && subStatus.stuckSid) {
-            const recovered = await recoverSubagent(subStatus.stuckSid);
-            if (recovered) {
-              await log("info", `Sent recovery prompt to stuck subagent ${short(subStatus.stuckSid)}, waiting...`);
+          const idle = now - w.lastActivityAt;
+          if (idle >= chunkTimeoutMs + gracePeriodMs) {
+            if (hasInflightTools(w)) {
+              await log("debug", `Session ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping stall recovery`);
+              w.lastSubagentCheckAt = now;
             } else {
-              await log("info", `Parent ${short(sid)} subagent recovery failed. Triggering abort+resume.`);
-              tryAbortAndResume(sid, w);
+              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;
+                dbg(`State transition on ${short(sid)}: gaveUp=false -> true`);
+                log("warn", `${short(sid)} - all ${maxRetries} retries exhausted.`);
+              }
             }
-            continue;
           }
         }
-        const idle = now - w.lastActivityAt;
-        if (idle >= chunkTimeoutMs + gracePeriodMs) {
-          if (hasInflightTools(w)) {
-            await log("debug", `Session ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping stall recovery`);
-            w.lastSubagentCheckAt = now;
-          } 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.`);
+        for (const [sid, w] of sessions) {
+          if (w.pendingRecovery && w.status === "idle" && !w.userCancelled && !w.aborting && !w.continuing && !w.gaveUp && w.recoveryAttempts === 0) {
+            dbg(`Pending recovery check on ${short(sid)}: pendingRecovery=${w.pendingRecovery}, status=${w.status}, userCancelled=${w.userCancelled}, aborting=${w.aborting}, continuing=${w.continuing}, gaveUp=${w.gaveUp}, recoveryAttempts=${w.recoveryAttempts}, pendingRecoveryAt=${w.pendingRecoveryAt}`);
+            const elapsed = Date.now() - w.pendingRecoveryAt;
+            const requiredBackoff2 = backoffMs(w.recoveryAttempts, baseBackoffMs, maxBackoffMs);
+            if (elapsed < requiredBackoff2) {
+              dbg(`Backoff check on ${short(sid)}: elapsed=${elapsed}ms, required=${requiredBackoff2}ms, attempt=${w.recoveryAttempts}, pass=false`);
+              dbg(`Pending recovery on ${short(sid)} waiting for backoff: ${requiredBackoff2 - elapsed}ms remaining`);
+              continue;
+            }
+            dbg(`Backoff check on ${short(sid)}: elapsed=${elapsed}ms, required=${requiredBackoff2}ms, attempt=${w.recoveryAttempts}, pass=true`);
+            await log("info", `Pending recovery triggered on ${short(sid)}: reason=${w.pendingRecoveryReason}, attempt=${w.recoveryAttempts + 1}, maxRetries=${maxRecoveryRetries}`);
+            dbg(`Recovery timing on ${short(sid)}: detectionToAttemptMs=${Date.now() - w.pendingRecoveryAt}`);
+            w.recoveryAttempts++;
+            dbg(`State transition on ${short(sid)}: recoveryAttempts=${w.recoveryAttempts - 1} -> ${w.recoveryAttempts}`);
+            try {
+              await sendContinuePrompt(sid, continuePrompt, w);
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              await log("warn", `${short(sid)} - pending recovery failed: ${errMsg}`);
+              w.recoveryAttempts = 0;
             }
           }
+          if (w.status !== "idle")
+            continue;
+          if (w.isSubagent)
+            continue;
+          if (w.userCancelled || w.completionSignaled)
+            continue;
+          if (w.continuing)
+            continue;
+          if (busyCount() !== 0)
+            continue;
+          const open = getOpenTodos(w.todos || []);
+          if (open.length === 0)
+            continue;
+          if (w.todoNudgeAttempts >= maxRetries)
+            continue;
+          const elapsedSinceLastNudge = Date.now() - w.lastRetryAt;
+          const requiredBackoff = backoffMs(w.todoNudgeAttempts, baseBackoffMs, maxBackoffMs);
+          if (w.lastRetryAt > 0 && elapsedSinceLastNudge < requiredBackoff)
+            continue;
+          const isCelebration = await lastAssistantEndsWithCelebration(sid);
+          if (isCelebration) {
+            w.toolTextRecovered = true;
+            w.completionSignaled = true;
+            continue;
+          }
+          const reminder = buildOpenTodosReminder(w.todos || []);
+          const sent = await tryResume(sid, w, "Idle with open todos (periodic)", reminder);
+          if (sent) {
+            w.todoNudgeAttempts++;
+            await log("info", `${short(sid)} - idle periodic recheck: nudge ${w.todoNudgeAttempts}/${maxRetries}`);
+          }
         }
-      }
-      cleanupIdleSessions();
+        cleanupIdleSessions();
+      }, "periodic timer");
     }, checkIntervalMs);
     if (timer.unref)
       timer.unref();
     discoveryTimer = setInterval(() => {
-      discoverSessions();
+      safe(discoverSessions, "discoveryTimer").catch(() => {});
     }, SESSION_DISCOVERY_INTERVAL_MS);
     if (discoveryTimer.unref)
       discoveryTimer.unref();
@@ -13391,6 +13714,9 @@ var AutoResumePlugin = async (ctx, options) => {
         w.status = statusType;
         if (statusType === "busy") {
           w.lastActivityAt = Date.now();
+          if (w.pendingRecovery) {
+            dbg(`Pending recovery cleared on ${short(sid)}: reason=session-busy`);
+          }
           resetSessionFlags(w);
           prevBusyCount = busyCount();
           log("debug", `${short(sid)} -> busy (${prevBusyCount})`);
@@ -13419,9 +13745,25 @@ var AutoResumePlugin = async (ctx, options) => {
           prevBusyCount = currentBusy;
           log("debug", `${short(sid)} -> idle (${currentBusy})`);
           if (!w.isSubagent) {
+            if (!w.pendingRecovery && !w.completionSignaled && !w.userCancelled && !w.aborting) {
+              try {
+                const errInfo = getLastAssistantError(await getSessionMessages(sid));
+                if (errInfo && isStreamingFailure(errInfo.name, errInfo.message, streamingFailureErrorNames, streamingFailureMessagePatterns)) {
+                  w.pendingRecovery = true;
+                  w.pendingRecoveryReason = errInfo.name;
+                  w.pendingRecoveryAt = Date.now();
+                  dbg(`State transition on ${short(sid)}: pendingRecovery=false -> true, reason=${errInfo.name}`);
+                  await log("info", `${short(sid)} - streaming failure detected on idle: ${errInfo.name} - ${errInfo.message}`);
+                  await tryResume(sid, w, "Streaming failure on idle", continuePrompt);
+                }
+              } catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                dbg(`session.idle sid=${short(sid)}: streaming-failure check error: ${errMsg}`);
+              }
+            }
             const todos = w.todos || [];
-            const hasOpenTodos = todos.some((t) => t.status === "pending" || t.status === "in_progress");
-            if (hasOpenTodos && currentBusy === 0 && !w.completionSignaled && !w.userCancelled) {
+            const open = getOpenTodos(todos);
+            if (open.length > 0 && currentBusy === 0 && !w.completionSignaled && !w.userCancelled && w.todoNudgeAttempts < maxRetries) {
               const isCelebration = await lastAssistantEndsWithCelebration(sid);
               if (isCelebration) {
                 await log("info", `${short(sid)} - \uD83C\uDF89 detected in idle handler, skipping continue`);
@@ -13432,18 +13774,52 @@ var AutoResumePlugin = async (ctx, options) => {
                   w.toolTextTimer = null;
                 }
               } else {
+                w.todoNudgeAttempts++;
                 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);
+                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);
               }
             }
           }
           if (!w.completionSignaled && !w.userCancelled && w.toolTextAttempts < maxRetries) {
+            if (resumeOnActionIntent && !w.toolTextRecovered) {
+              const idleSid = sid;
+              const idleW = w;
+              setTimeout(async () => {
+                try {
+                  if (Date.now() - idleW.createdAt < warmupMs) {
+                    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 lastAssistantMsg = msgs.slice().reverse().find((m) => (m.role ?? m.info?.role) === "assistant");
+                  if (lastAssistantMsg) {
+                    let lastText = "";
+                    for (const part of lastAssistantMsg.parts || []) {
+                      lastText += (part.text ?? "") + `
+`;
+                    }
+                    if (containsActionIntent(lastText)) {
+                      const w2 = sessions.get(idleSid);
+                      if (!w2 || w2.toolTextRecovered || w2.completionSignaled || w2.status !== "idle")
+                        return;
+                      w2.toolTextRecovered = true;
+                      w2.toolTextAttempts++;
+                      dbg(`session.idle sid=${short(idleSid)}: ACTION INTENT DETECTED, sending "${actionIntentPrompt.slice(0, 40)}..."`);
+                      await sendContinuePrompt(idleSid, actionIntentPrompt, w2);
+                    }
+                  }
+                } catch (e) {
+                  dbg(`session.idle sid=${short(idleSid)}: delayed check error: ${e}`);
+                }
+              }, 500);
+            }
             if (w.toolTextTimer)
               clearTimeout(w.toolTextTimer);
             w.toolTextTimer = setTimeout(() => {
               checkForToolCallAsText(sid, w);
-            }, TOOL_TEXT_CHECK_DELAY_MS);
+            }, toolTextCheckDelayMs);
           }
         } else if (statusType === "retry") {
           touchSession(sid);
@@ -13472,12 +13848,45 @@ var AutoResumePlugin = async (ctx, options) => {
         if (w) {
           w.status = "idle";
           resetIdleFlags(w);
-          if (!w.toolTextRecovered && w.toolTextAttempts < maxRetries) {
+          dbg(`session.idle sid=${short(sid)}: resetIdleFlags done, toolTextRecovered=${w.toolTextRecovered}, toolTextAttempts=${w.toolTextAttempts}, maxRetries=${maxRetries}`);
+          if (resumeOnActionIntent && !w.toolTextRecovered && !w.completionSignaled) {
+            setTimeout(async () => {
+              try {
+                if (Date.now() - w.createdAt < warmupMs) {
+                  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 lastAssistantMsg = msgs.slice().reverse().find((m) => (m.role ?? m.info?.role) === "assistant");
+                if (lastAssistantMsg) {
+                  let lastText = "";
+                  for (const part of lastAssistantMsg.parts || []) {
+                    lastText += (part.text ?? "") + `
+`;
+                  }
+                  if (containsActionIntent(lastText)) {
+                    const w2 = sessions.get(sid);
+                    if (!w2 || w2.toolTextRecovered || w2.completionSignaled || w2.status !== "idle")
+                      return;
+                    w2.toolTextRecovered = true;
+                    w2.toolTextAttempts++;
+                    dbg(`session.idle sid=${short(sid)}: ACTION INTENT DETECTED, sending "${actionIntentPrompt.slice(0, 40)}..."`);
+                    await sendContinuePrompt(sid, actionIntentPrompt, w2);
+                  }
+                }
+              } catch (e) {
+                dbg(`session.idle sid=${short(sid)}: delayed check error: ${e}`);
+              }
+            }, 500);
+          }
+          const shouldSet = !w.toolTextRecovered && w.toolTextAttempts < maxRetries;
+          if (shouldSet) {
             if (w.toolTextTimer)
               clearTimeout(w.toolTextTimer);
             w.toolTextTimer = setTimeout(() => {
               checkForToolCallAsText(sid, w);
-            }, TOOL_TEXT_CHECK_DELAY_MS);
+            }, toolTextCheckDelayMs);
           }
         }
         break;
@@ -13514,6 +13923,7 @@ var AutoResumePlugin = async (ctx, options) => {
       case "session.error": {
         const errorObj = getError(ev);
         const errorName = errorObj?.name ?? "";
+        const errorMessage = errorObj?.data?.message ?? String(errorObj?.data ?? "");
         const isMessageAborted = errorName === "MessageAbortedError";
         if (isMessageAborted) {
           for (const [wSid, w] of sessions) {
@@ -13526,9 +13936,24 @@ var AutoResumePlugin = async (ctx, options) => {
           log("info", "User abort (ESC)");
           break;
         }
+        const isStreamingFail = isStreamingFailure(errorName, errorMessage, streamingFailureErrorNames, streamingFailureMessagePatterns);
+        if (isStreamingFail) {
+          if (sid) {
+            const w = sessions.get(sid);
+            if (w && w.status === "busy") {
+              w.pendingRecovery = true;
+              w.pendingRecoveryReason = errorName;
+              w.pendingRecoveryAt = Date.now();
+              dbg(`State transition on ${short(sid)}: pendingRecovery=false -> true, reason=${errorName}`);
+              await log("info", `Streaming failure detected on ${short(sid)}: errorName=${errorName}, errorMessage=${errorMessage}, pendingRecoveryReason=${errorName}`);
+            }
+            log("info", `Streaming failure detected: ${errorName} - ${errorMessage}`);
+          } else {
+            log("warn", `Streaming failure detected but no session ID: ${errorName} - ${errorMessage}`);
+          }
+        }
         if (busyCount() === 0)
           break;
-        const errorMessage = errorObj?.data?.message ?? String(errorObj?.data ?? "");
         log("debug", `Session error: ${errorName} - ${errorMessage}`);
         if (sid) {
           const w = sessions.get(sid);
@@ -13540,7 +13965,10 @@ var AutoResumePlugin = async (ctx, options) => {
         break;
       }
       case "command.executed": {
-        for (const [, w2] of sessions) {
+        for (const [sid2, w2] of sessions) {
+          if (w2.pendingRecovery) {
+            dbg(`Pending recovery cleared on ${short(sid2)}: reason=user-command`);
+          }
           resetSessionFlags(w2);
         }
         if (!sid)
@@ -13561,6 +13989,12 @@ var AutoResumePlugin = async (ctx, options) => {
       const w = sessions.get(ctx2.sessionID);
       if (w) {
         if (!w.isSubagent) {
+          const openTodos = (w.todos || []).filter((t) => t.status === "pending" || t.status === "in_progress");
+          if (openTodos.length > 0 && w.taskCompleteOverrides < maxRetries) {
+            w.taskCompleteOverrides++;
+            await log("info", `${short(ctx2.sessionID)} - task_complete blocked: ${openTodos.length} open todos remain (override ${w.taskCompleteOverrides}/${maxRetries})`);
+            return `You have ${openTodos.length} unfinished task(s). Please complete all remaining work before signaling completion.`;
+          }
           w.toolTextRecovered = true;
           w.completionSignaled = true;
           if (w.toolTextTimer) {
@@ -13579,7 +14013,11 @@ var AutoResumePlugin = async (ctx, options) => {
         initialised = true;
         log("info", `opencode-auto-resume ready. timeout=${chunkTimeoutMs}ms, orphan=${subagentWaitMs}ms, loop=${loopMaxContinues}x/${loopWindowMs / 1000}s`);
       }
-      handleEvent(event);
+      handleEvent(event).catch((e) => {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`[auto-resume] handleEvent error: ${msg}`);
+        log("error", `handleEvent error: ${msg}`).catch(() => {});
+      });
     },
     config: async () => {
       log("info", `opencode-auto-resume config OK`);
@@ -13612,7 +14050,10 @@ var AutoResumePlugin = async (ctx, options) => {
 };
 var src_default = AutoResumePlugin;
 export {
+  isStreamingFailure,
+  getLastAssistantError,
   src_default as default,
   buildOpenTodosReminder,
+  backoffMs,
   AutoResumePlugin
 };

package/package.json

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