opencode-auto-resume 1.0.23 → 1.1.1

package/README.md

@@ -1,42 +1,162 @@
 # opencode-auto-resume
 
-**Plugin for [OpenCode](https://github.com/anomalyco/opencode) that automatically detects and recovers from LLM session failures — stalls, broken tool calls, hallucination loops, and stuck subagent parents. Fully silent, zero UI pollution.**
+**Plugin for [OpenCode](https://github.com/anomalyco/opencode) that automatically detects and recovers from LLM session failures — stalls, broken tool calls, hallucination loops, stuck subagent parents, and more. Fully silent, zero UI pollution.**
 
 ## What it does
 
-LLM sessions fail in predictable ways. This plugin monitors all sessions and automatically recovers without user intervention.
+LLM sessions fail in predictable ways. This plugin monitors all sessions and automatically recovers without user intervention. Each recovery path below references the upstream OpenCode issues that motivated it — these are problems not yet resolved in the official project.
 
-**Stall recovery** — the stream goes silent but the session stays "busy". The UI shows a blinking cursor with no progress. If no events arrive for 48 seconds, the plugin sends `"continue"` with exponential backoff. After 3 failed attempts it gives up.
+---
+
+### Stall recovery
+
+The stream goes silent but the session stays "busy". The UI shows a blinking cursor with no progress. If no events arrive for 48 seconds (`chunkTimeoutMs` + `gracePeriodMs`), the plugin sends `"continue"` with exponential backoff. After 3 failed attempts it gives up.
 
 The plugin extracts the **agent, model, and provider** from the last session message, so it resumes with the exact same configuration the user was using (build, sisyphus, prometheus, etc.).
-_( [#55](https://github.com/anomalyco/opencode/issues/55), [#199](https://github.com/anomalyco/opencode/issues/199), [#283](https://github.com/anomalyco/opencode/issues/283) )_
 
-**Tool calls as raw text** — the model prints tool invocations as raw XML (`<function=edit>...`) instead of executing them. The session goes idle normally but the tool was never run. On idle, the plugin fetches the last messages and scans for XML tool-call patterns (including truncated and alternative formats). If found, it sends a specific recovery prompt.
-_( [#150](https://github.com/anomalyco/opencode/issues/150), [#313](https://github.com/anomalyco/opencode/issues/313), [#353](https://github.com/anomalyco/opencode/issues/353) )_
+_Motivated by:_
+- [#34214](https://github.com/anomalyco/opencode/issues/34214) — Opencode freezes / becomes unresponsive mid-session
+- [#35207](https://github.com/anomalyco/opencode/issues/35207) — Session hangs indefinitely after MCP tool-call — no timeout recovery (deadlock)
+- [#31655](https://github.com/anomalyco/opencode/issues/31655) — Window completely frozen/unresponsive after reopening a project with a stalled session
+- [#34460](https://github.com/anomalyco/opencode/issues/34460) — Thread freezes after switching to Go model — requires Escape key to unstick
+
+---
+
+### Tool calls as raw text
+
+The model prints tool invocations as raw XML/JSON (`<function=edit>...`, `{"type":"function",...}`) instead of executing them. The session goes idle normally but the tool was never run. On idle, the plugin fetches the last messages and scans for XML tool-call patterns — including truncated and alternative formats. If found, it sends `TOOL_TEXT_RECOVERY_PROMPT` to force a clean tool call.
+
+Also detects tool calls trapped inside **thinking/reasoning** parts and emits `THINKING_TOOL_RECOVERY_PROMPT` to extract them.
+
+_Motivated by:_
+- [#31247](https://github.com/anomalyco/opencode/issues/31247) — Copilot Claude Opus 4.8 emits pseudo tool-call text instead of structured tool calls
+- [#34126](https://github.com/anomalyco/opencode/issues/34126) — OpenAI Chat parser treats standalone text before tool_calls as assistant text
+- [#33959](https://github.com/anomalyco/opencode/issues/33959) — OpenCode Desktop does not execute valid OpenAI tool calls from qwen3-coder:30b (Ollama)
+- [#35689](https://github.com/anomalyco/opencode/issues/35689) — DeepSeek silently stops executing (interleaved reasoning_content dropped in tool call messages)
+
+---
+
+### Hallucination loop
+
+The model generates the same broken output repeatedly. Each `continue` just picks up the broken generation. If a session needs 3+ continues within 10 minutes, the plugin aborts the request and sends `"continue"` fresh, forcing a clean restart.
+
+A separate **tool-call loop detector** also catches the model calling the same tool 3+ consecutive times (or repeating patterns of length 2-5 occurring at least three times). When detected, it emits `TOOL_LOOP_RECOVERY_PROMPT` to break the loop instead of blindly continuing.
+
+_Motivated by:_
+- [#22142](https://github.com/anomalyco/opencode/issues/22142) — Repetitive tool-call loops with alibaba-coding-plan-cn/qwen3.6-plus
+- [#16218](https://github.com/anomalyco/opencode/issues/16218) — Model repeats the same response in a loop after generating an answer
+- [#33216](https://github.com/anomalyco/opencode/issues/33216) — OpenCode Repeatedly Ignores Instructions and Loops Responses
+- [#35784](https://github.com/anomalyco/opencode/issues/35784) — opencode-go/glm-5.2 + read file loop
+- [#25129](https://github.com/anomalyco/opencode/issues/25129) — Thinking mode gets stuck in infinite repetition loop
+
+---
+
+### Orphan parent
+
+A subagent finishes but the parent session stays stuck as "busy" forever. The plugin detects when `busyCount` drops from >1 to 1, waits 15 seconds (`subagentWaitMs`), then aborts and resumes the parent.
+
+_Motivated by:_
+- [#35066](https://github.com/anomalyco/opencode/issues/35066) — notify parent when subagent sessions finish
+- [#33050](https://github.com/anomalyco/opencode/issues/33050) — orphaned sessions continue looping after abort, causing sustained high CPU
+- [#32335](https://github.com/anomalyco/opencode/issues/32335) — opencode run processes don't exit after completing scheduled work, causing memory leak
+
+---
+
+### Subagent stuck detection
+
+Detects when a subagent hasn't received new text for >1 minute (or >3 minutes if a tool call is in progress). If stuck, sends a recovery prompt to the subagent before triggering abort+resume on the parent. This avoids killing a parent that merely has a slow child.
+
+_Motivated by:_
+- [#35073](https://github.com/anomalyco/opencode/issues/35073) — subagent permission asks hang indefinitely (sync subagents treated as interactive)
+- [#35806](https://github.com/anomalyco/opencode/issues/35806) — malformed tool-input stream ordering crashes Session drains
+- [#32580](https://github.com/anomalyco/opencode/issues/32580) — Agent showing repeated thinking
+
+---
+
+### 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.
+
+_Motivated by:_
+- [#26063](https://github.com/anomalyco/opencode/issues/26063) — Tool execution aborted/terminated
+- [#31459](https://github.com/anomalyco/opencode/issues/31459) — "Tool execution aborted" during Preparing write
+- [#5937](https://github.com/Mte90/opencode-auto-resume) — (internal) must never abort a tool execution
+
+---
+
+### Model, agent & provider preservation
+
+When resuming with `"continue"`, the plugin extracts agent, model, and provider from the last session message — falling back to `msg.info.agent` / `msg.info.model` if the top-level field is missing. This preserves the user's UI selection across resumes instead of reverting to the default agent.
 
-**Hallucination loop** — the model generates the same broken output repeatedly. Each continue just picks up the broken generation. If a session needs 3+ continues within 10 minutes, the plugin aborts the request and sends `"continue"` fresh, forcing a clean restart.
-_( [#283](https://github.com/anomalyco/opencode/issues/283), [#353](https://github.com/anomalyco/opencode/issues/353) )_
+_Motivated by:_
+- [#35126](https://github.com/anomalyco/opencode/issues/35126) — Subagents launched via task tool ignore their model: frontmatter and inherit parent agent's model
+- [#35899](https://github.com/anomalyco/opencode/issues/35899) — Web: switching sessions overwrites user-selected model with agent default
+- [#34562](https://github.com/anomalyco/opencode/issues/34562) — Model provider not restored correctly when switching projects
 
-**Orphan parent** — a subagent finishes but the parent session stays stuck as "busy" forever. The plugin detects when busyCount drops from >1 to 1, waits 15 seconds, then aborts and resumes the parent.
-_( [#122](https://github.com/anomalyco/opencode/issues/122), [#199](https://github.com/anomalyco/opencode/issues/199), [#246](https://github.com/anomalyco/opencode/issues/246) )_
+---
 
-**False positives during subagent work** — long tool execution or active subagents can look like a stall. Only the session emitting events gets its timer reset (not all sessions). When multiple sessions are busy, stall detection is paused entirely.
-_( [#55](https://github.com/anomalyco/opencode/issues/55), [#221](https://github.com/anomalyco/opencode/issues/221) )_
+### ESC cancel respected
 
-**ESC cancel** — user presses ESC to cancel a request. The plugin detects `MessageAbortedError` and marks all busy sessions as cancelled, never resuming them.
+User presses ESC to cancel a request. The plugin detects `MessageAbortedError` and marks all busy sessions as cancelled, never resuming them. The grace period (`gracePeriodMs`) also lets late ESC/status events arrive before any action.
 
-**Explicit completion via `task_complete`** — the agent can call the built-in `task_complete` tool to signal that all work is done. When invoked, the plugin stops sending any further "continue" prompts, clears all pending timers, and marks the session as complete. This replaces fragile text-based heuristics (emoji patterns, language detection) with a deterministic signal.
+_Motivated by:_
+- [#28453](https://github.com/anomalyco/opencode/issues/28453) — ACP session/cancel emits agent_error for MessageAbortedError before cancelled result
+- [#32432](https://github.com/anomalyco/opencode/issues/32432) — Cancelled subagents can't be opened in TUI + Ctrl+X intermittently fails
+- [#30144](https://github.com/anomalyco/opencode/issues/30144) — Early prompt cancel can poison directory instance
 
-**Spurious error messages** — after normal completion, OpenCode sometimes fires a `session.error`. All logging goes through `ctx.client.app.log()` (zero `console.log`), and errors on already-idle sessions are silently ignored.
-_( [#128](https://github.com/anomalyco/opencode/pulls/128), [#22](https://github.com/anomalyco/opencode/pulls/22) )_
+---
 
-**Session discovery** — periodically calls `session.list()` to pick up sessions that were missed by event tracking. Idle sessions are cleaned up after 10 minutes to prevent memory leaks.
+### Explicit completion via `task_complete`
 
-**Model preservation** — when resuming with "continue", the plugin extracts agent, model and provider from the last session message (not from `info` field) to preserve the user's UI selection.
-_( [#111](https://github.com/anomalyco/opencode/issues/111), [#277](https://github.com/anomalyco/opencode/issues/277) )_
+The agent can call the built-in `task_complete` tool to signal that all work is done. When invoked, the plugin stops sending any further `"continue"` prompts, clears all pending timers, and marks the session as complete. This replaces fragile text-based heuristics (emoji patterns, language detection) with a deterministic signal.
 
-**Subagent stuck detection** — detects when a subagent hasn't received new text for >1 minute (or >3 minutes if a tool call is in progress). If stuck, sends a recovery prompt before triggering abort+resume on the parent.
-_( [#55](https://github.com/anomalyco/opencode/issues/55), [#60](https://github.com/anomalyco/opencode/issues/60), [#246](https://github.com/anomalyco/opencode/issues/246) )_
+---
+
+### 🎉 emoji completion
+
+An assistant message ending with 🎉 resets the tool-text timer and prevents a trigger — the emoji signals the agent considers the task complete.
+
+---
+
+### Ready-to-continue auto-resume
+
+When the assistant prints phrases like "Ready to continue with task" or "Proceeding with task", the plugin automatically sends `"continue"` without waiting for the user. This catches the common pattern where the model stops to ask for permission it doesn't need.
+
+---
+
+### 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. This uses the real `todo.updated` event state — not regex on the message text.
+
+---
+
+### False-positive protection during subagent work
+
+Long tool execution or active subagents can look like a stall. Only the session emitting events gets its timer reset (not all sessions). When multiple sessions are busy, stall detection is paused entirely. The plugin also clears existing timers before creating a new `setTimeout` in idle handlers to prevent queued continue triggers.
+
+---
+
+### Spurious error suppression
+
+After normal completion, OpenCode sometimes fires a `session.error`. All logging goes through `ctx.client.app.log()` (zero `console.log`), and errors on already-idle sessions are silently ignored.
+
+_Motivated by:_
+- [#33687](https://github.com/anomalyco/opencode/issues/33687) — Interrupted assistant messages retain non-error finish value (orphan tool-input-start abort)
+- [#28958](https://github.com/anomalyco/opencode/issues/28958) — Plugin hook rejection aborts unrelated parallel sessions
+- [#25899](https://github.com/anomalyco/opencode/issues/25899) — ACP prompt() returns stopReason: end_turn + zero usage on user cancel
+
+---
+
+### Session discovery & cleanup
+
+Periodically calls `session.list()` (every 60s) to pick up sessions that were missed by event tracking. Idle sessions are cleaned up after 10 minutes or when the idle map exceeds 50 entries, preventing memory leaks.
+
+_Motivated by:_
+- [#35750](https://github.com/anomalyco/opencode/issues/35750) — Upgrade to 1.17.x hides pre-existing sessions — new path column not back-filled during migration
+- [#33102](https://github.com/anomalyco/opencode/issues/33102) — OpenCode Go workspace subscription is orphaned/hidden and cannot be managed from dashboard
+- [#27759](https://github.com/anomalyco/opencode/issues/27759) — Session heartbeat for multi-session liveness detection
+
+---
 
 ## Architecture
 
@@ -47,17 +167,21 @@ Any SSE Event
 
 session.status events:
   ├─ busy → reset timer, clear retry counters
-  └─ idle → schedule tool-text check (1.5s delay)
-              └─ fetch messages → scan for XML patterns
+  └─ idle → schedule tool-text check (3s delay)
+              └─ fetch messages → scan for XML / thinking-tool patterns
                   ├─ found → send recovery prompt (with backoff)
-                  └─ not found → do nothing
+                  └─ not found → check ready-to-continue / done-claim patterns
               └─ orphan check: busyCount dropped from >1 to 1?
-                  └─ 15s watch → abort + continue
+                  └─ subagentWaitMs watch → abort + continue
+
+todo.updated events:
+  └─ track real todo state (not regex on message text)
 
 Timer loop (every 5s):
   for each busy session:
     ├─ orphan watch active? → wait or abort+continue
     ├─ busyCount > 1? → skip (subagent running)
+    ├─ active tool running? → skip (never abort tools)
     └─ idle > 48s? → hallucination loop? abort : continue with backoff
 
 Periodic (every 60s): session.list() to discover missed sessions
@@ -119,6 +243,8 @@ bun run build
 }
 ```
 
+### Configurable options
+
 | Option | Default | Description |
 |---|---|---|
 | `chunkTimeoutMs` | `45000` | Inactivity timeout before considering stream stalled |
@@ -131,13 +257,19 @@ bun run build
 | `loopMaxContinues` | `3` | Continues in window before triggering abort |
 | `loopWindowMs` | `600000` | Hallucination loop detection window (10 min) |
 
-## Verification
+### Internal constants (not configurable)
 
-To verify the plugin is loaded:
+| Constant | Value | Description |
+|---|---|---|
+| `TOOL_TEXT_CHECK_DELAY_MS` | `3000` | Delay before scanning idle session for tool-as-text |
+| `ABORT_CONTINUE_DELAY_MS` | `2000` | Delay between abort and continue |
+| `MAX_IDLE_SESSIONS` | `50` | Idle session map cap before cleanup |
+| `IDLE_CLEANUP_MS` | `600000` | Idle session age before cleanup (10 min) |
+| `SESSION_DISCOVERY_INTERVAL_MS` | `60000` | `session.list()` poll interval (60s) |
+
+## Verification
 
-1. Check OpenCode logs for: `opencode-auto-resume ready. timeout=45000ms...`
-2. Let a session idle for 48 seconds — it should auto-resume
-3. Check logs for `Stream stall` or `Ready-to-continue pattern detected`
+To verify the plugin is loaded, run `/status` inside OpenCode — it lists all loaded plugins and their versions. You should see `opencode-auto-resume` in the list.
 
 The plugin handles all recovery automatically — no manual intervention needed.
 
@@ -151,3 +283,4 @@ The plugin handles all recovery automatically — no manual intervention needed.
 | Orphan parent not detected | Increase `subagentWaitMs` to `20000` |
 | Hallucination loop not caught | Decrease `loopMaxContinues` to `2` |
 | Tool-text not detected | Check server logs — requires SDK message fetching |
+| Long-running tool killed | Should not happen — active-tool guard prevents it. Report a bug. |

package/dist/index.js

@@ -12346,6 +12346,7 @@ 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 MAX_IDLE_SESSIONS = 50;
 var IDLE_CLEANUP_MS = 10 * 60000;
 var SESSION_DISCOVERY_INTERVAL_MS = 60000;
@@ -12533,9 +12534,17 @@ var AutoResumePlugin = async (ctx, options) => {
     const props = ev.properties;
     return ev.error ?? props?.error;
   }
-  function getStatus(ev) {
+  function getStatusType(ev) {
     const props = ev.properties;
-    return ev.status ?? props?.status;
+    const rawStatus = ev.status ?? props?.status;
+    if (typeof rawStatus === "string")
+      return rawStatus;
+    if (rawStatus && typeof rawStatus === "object") {
+      const type = rawStatus.type;
+      if (typeof type === "string")
+        return type;
+    }
+    return "unknown";
   }
   function short(sid) {
     return sid.length > 12 ? `...${sid.slice(-8)}` : sid;
@@ -12586,8 +12595,7 @@ var AutoResumePlugin = async (ctx, options) => {
     let agent;
     let model;
     try {
-      const msgResp = await ctx.client.session.messages({ path: { id: sid } });
-      const msgs = extractMessages(msgResp);
+      const msgs = await getSessionMessages(sid);
       for (let i = msgs.length - 1;i >= 0; i--) {
         const msg = msgs[i];
         const role = msg.role ?? msg.info?.role;
@@ -12663,6 +12671,60 @@ var AutoResumePlugin = async (ctx, options) => {
       return response.messages;
     return [];
   }
+  async function getSessionMessages(sid) {
+    const response = await ctx.client.session.messages({ path: { id: sid } });
+    return extractMessages(response);
+  }
+  function roleOf(msg) {
+    if (!msg)
+      return;
+    return msg.role ?? msg.info?.role;
+  }
+  async function lastAssistantEndsWithCelebration(sid) {
+    try {
+      const msgs = await getSessionMessages(sid);
+      for (let i = msgs.length - 1;i >= 0; i--) {
+        const msg = msgs[i];
+        if (roleOf(msg) !== "assistant")
+          continue;
+        const parts = msg.parts;
+        if (!parts)
+          continue;
+        let text = "";
+        for (const part of parts) {
+          if (part.type === "text") {
+            text += part.text ?? "";
+          }
+        }
+        const normalized = text.trim().replace(/[.!?]+$/, "");
+        return normalized.endsWith("\uD83C\uDF89");
+      }
+    } catch {}
+    return false;
+  }
+  async function getSessionStatusMap() {
+    try {
+      const response = await ctx.client.session.status();
+      const raw = response.data ?? response;
+      const result = {};
+      if (raw && typeof raw === "object") {
+        for (const [sid, val] of Object.entries(raw)) {
+          if (typeof val === "string") {
+            result[sid] = val;
+          } else if (val && typeof val === "object") {
+            const type = val.type;
+            if (typeof type === "string")
+              result[sid] = type;
+          }
+        }
+      }
+      return result;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      await log("debug", `session.status() failed: ${errMsg}`);
+      return {};
+    }
+  }
   const SUBAGENT_STUCK_MS = 60000;
   const SUBAGENT_RECOVERY_PROMPT = "It looks like you may have stalled or timed out. Please retry the last operation or continue with the task.";
   async function recoverSubagent(subagentSid) {
@@ -12681,14 +12743,11 @@ var AutoResumePlugin = async (ctx, options) => {
   }
   async function hasBusySubagents(parentSid) {
     try {
-      const response = await ctx.client.session.list();
-      const allSessions = extractMessages(response);
-      for (const s of allSessions) {
-        const sId = s.id;
+      const statusMap = await getSessionStatusMap();
+      for (const [sId, statusType] of Object.entries(statusMap)) {
         if (!sId || sId === parentSid)
           continue;
-        const status = s.status;
-        if (status === "busy")
+        if (statusType === "busy")
           return true;
       }
       return false;
@@ -12700,21 +12759,16 @@ var AutoResumePlugin = async (ctx, options) => {
   }
   async function checkSessionHasActiveTool(sid) {
     try {
-      const listResponse = await ctx.client.session.list();
-      const sessions2 = extractMessages(listResponse);
-      const currentSession = sessions2.find((s) => s.id === sid);
-      const status = currentSession?.status;
-      if (status === "busy") {
+      const statusMap = await getSessionStatusMap();
+      if (statusMap[sid] === "busy") {
         await log("debug", `Session ${short(sid)} is busy, likely executing a tool`);
         return true;
       }
-      const response = await ctx.client.session.messages({ path: { id: sid } });
-      const messages = extractMessages(response);
+      const messages = await getSessionMessages(sid);
       const lastMsg = messages[messages.length - 1];
       if (!lastMsg)
         return false;
-      const rawRole = lastMsg?.role ?? lastMsg?.info?.role;
-      if (rawRole !== "assistant")
+      if (roleOf(lastMsg) !== "assistant")
         return false;
       const toolCall = lastMsg.toolCall;
       const toolCalls = lastMsg.tool_calls;
@@ -12729,22 +12783,17 @@ var AutoResumePlugin = async (ctx, options) => {
   }
   async function checkSubagentStatus(parentSid) {
     try {
-      const response = await ctx.client.session.list();
-      const allSessions = extractMessages(response);
+      const statusMap = await getSessionStatusMap();
       const now = Date.now();
       let hasBusySubagent = false;
-      for (const s of allSessions) {
-        const sId = s.id;
+      for (const [sId, statusType] of Object.entries(statusMap)) {
         if (!sId || sId === parentSid)
           continue;
-        const status = s.status;
-        if (status === "busy") {
+        if (statusType === "busy") {
           hasBusySubagent = true;
-          const msgResponse = await ctx.client.session.messages({ path: { id: sId } });
-          const messages = extractMessages(msgResponse);
+          const messages = await getSessionMessages(sId);
           const lastMsg = messages[messages.length - 1];
-          const rawRole = lastMsg?.role ?? lastMsg?.info?.role;
-          if (lastMsg && rawRole === "assistant" && (("error" in lastMsg) || lastMsg.info && ("error" in lastMsg.info))) {
+          if (lastMsg && roleOf(lastMsg) === "assistant" && (("error" in lastMsg) || lastMsg.info && ("error" in lastMsg.info))) {
             await log("debug", `Subagent ${short(sId)} appears crashed`);
             return { status: "crashed" };
           }
@@ -12856,10 +12905,7 @@ var AutoResumePlugin = async (ctx, options) => {
       return;
     await log("debug", `${short(sid)} - checking for tool-call-as-text (attempt ${w.toolTextAttempts + 1})`);
     try {
-      const response = await ctx.client.session.messages({
-        path: { id: sid }
-      });
-      const messages = extractMessages(response);
+      const messages = await getSessionMessages(sid);
       const recent = messages.slice(-3);
       let bestCandidate = null;
       let allAssistantText = "";
@@ -13014,14 +13060,14 @@ var AutoResumePlugin = async (ctx, options) => {
       if (!bestCandidate) {
         const todos = w.todos || [];
         const hasOpenTodos = todos.some((t) => t.status === "pending" || t.status === "in_progress");
-        if (hasOpenTodos && busyCount() === 1) {
+        if (hasOpenTodos && busyCount() === 0) {
           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 continue...`);
           bestCandidate = {
             prompt: "continue",
             source: "idle-with-open-todos",
             priority: 2
           };
-        } else if (hasOpenTodos && busyCount() > 1) {
+        } else if (hasOpenTodos && busyCount() > 0) {
           await log("debug", `${short(sid)} - todos remain open but ${busyCount()} sessions busy (subagents running), skipping continue`);
         }
       }
@@ -13031,7 +13077,7 @@ var AutoResumePlugin = async (ctx, options) => {
       w.toolTextAttempts++;
       await log("info", `${bestCandidate.source} detected on ${short(sid)}! ` + `Attempt ${w.toolTextAttempts}/${maxRetries}. Sending recovery prompt...`);
       const timeSinceActivity = Date.now() - w.lastActivityAt;
-      if (timeSinceActivity < TOOL_TEXT_CHECK_DELAY_MS) {
+      if (timeSinceActivity < MIN_ACTIVITY_GAP_MS) {
         await log("info", `${short(sid)} - skipping ${bestCandidate.source}, session was active ${Math.round(timeSinceActivity / 1000)}s ago`);
         return;
       }
@@ -13161,18 +13207,14 @@ var AutoResumePlugin = async (ctx, options) => {
     timer = setInterval(async () => {
       const now = Date.now();
       const numBusy = busyCount();
+      const statusMap = await getSessionStatusMap();
       for (const [sid, w] of sessions) {
-        try {
-          const listResponse = await ctx.client.session.list();
-          const allSessions = extractMessages(listResponse);
-          const realSession2 = allSessions.find((s) => s.id === sid);
-          const realStatus = realSession2?.status;
-          if (realStatus && realStatus !== w.status) {
-            w.status = realStatus;
-            if (realStatus === "busy")
-              w.idleSince = null;
-          }
-        } catch {}
+        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)
@@ -13183,6 +13225,12 @@ var AutoResumePlugin = async (ctx, options) => {
           const orphanIdle = now - w.orphanWatchStartAt;
           if (orphanIdle >= subagentWaitMs + gracePeriodMs) {
             if (w.resumeAttempts < maxRetries) {
+              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);
@@ -13218,16 +13266,11 @@ var AutoResumePlugin = async (ctx, options) => {
           continue;
         w.lastSubagentCheckAt = now;
         if (w.lastActivityAt > 0 && now - w.lastActivityAt > subagentWaitMs) {
-          try {
-            const listResponse = await ctx.client.session.list();
-            const allSessions = extractMessages(listResponse);
-            const realStatus = realSession?.status;
-            if (realStatus === "busy") {
-              await log("debug", `Session ${short(sid)} is still busy (real status), skipping abort`);
-              w.lastSubagentCheckAt = now;
-              continue;
-            }
-          } catch {}
+          if (realStatus === "busy") {
+            await log("debug", `Session ${short(sid)} is still busy (real status), skipping abort`);
+            w.lastSubagentCheckAt = now;
+            continue;
+          }
           const hasActiveTool = await checkSessionHasActiveTool(sid);
           if (hasActiveTool) {
             await log("debug", `Session ${short(sid)} has active tool call, skipping abort check`);
@@ -13286,14 +13329,14 @@ var AutoResumePlugin = async (ctx, options) => {
       case "session.status": {
         if (!sid)
           break;
-        const status = getStatus(ev);
-        const statusType = status?.type ?? "unknown";
+        const statusType = getStatusType(ev);
         const w = ensureWatch(sid);
         w.status = statusType;
         if (statusType === "busy") {
           w.lastActivityAt = Date.now();
           resetSessionFlags(w);
-          log("debug", `${short(sid)} -> busy (${busyCount()})`);
+          prevBusyCount = busyCount();
+          log("debug", `${short(sid)} -> busy (${prevBusyCount})`);
         } else if (statusType === "idle" || statusType === "interrupted") {
           w.status = "idle";
           resetIdleFlags(w);
@@ -13311,9 +13354,19 @@ var AutoResumePlugin = async (ctx, options) => {
           if (!w.isSubagent) {
             const todos = w.todos || [];
             const hasOpenTodos = todos.some((t) => t.status === "pending" || t.status === "in_progress");
-            if (hasOpenTodos && currentBusy === 1 && !w.toolTextRecovered) {
-              await log("info", `${short(sid)} - idle with ${todos.filter((t) => t.status === "pending" || t.status === "in_progress").length} open todos. Sending continue...`);
-              tryResume(sid, w, "Idle with open todos");
+            if (hasOpenTodos && currentBusy === 0 && !w.toolTextRecovered) {
+              const isCelebration = await lastAssistantEndsWithCelebration(sid);
+              if (isCelebration) {
+                await log("info", `${short(sid)} - \uD83C\uDF89 detected in idle handler, skipping continue`);
+                w.toolTextRecovered = true;
+                if (w.toolTextTimer) {
+                  clearTimeout(w.toolTextTimer);
+                  w.toolTextTimer = null;
+                }
+              } else {
+                await log("info", `${short(sid)} - idle with ${todos.filter((t) => t.status === "pending" || t.status === "in_progress").length} open todos. Sending continue...`);
+                tryResume(sid, w, "Idle with open todos");
+              }
             }
           }
           if (!w.toolTextRecovered && w.toolTextAttempts < maxRetries) {
@@ -13399,14 +13452,12 @@ var AutoResumePlugin = async (ctx, options) => {
           break;
         const props = ev.properties;
         const todos = props?.todos ?? [];
-        const w = sessions.get(sid);
-        if (w) {
-          w.todos = todos.map((t) => ({
-            content: t.content ?? "",
-            status: t.status ?? "pending",
-            priority: t.priority ?? "medium"
-          }));
-        }
+        const w = ensureWatch(sid);
+        w.todos = todos.map((t) => ({
+          content: t.content ?? "",
+          status: t.status ?? "pending",
+          priority: t.priority ?? "medium"
+        }));
         break;
       }
       case "session.error": {

package/package.json

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