opencode-auto-resume 1.1.14 → 1.1.15

package/README.md

@@ -156,6 +156,10 @@ _Motivated by:_
 
 The model stream can die after emitting only reasoning — no text part, no tool call — finalizing with `finish: "unknown"`. OpenCode treats the message as completed and the session goes idle, so no error or stall path triggers. On idle, if the **newest** assistant message has a finish reason, zero text parts, and at least `silentDeadStreamMinTokens` output tokens, the plugin sends a recovery prompt. Only the newest assistant message is evaluated — a delivered text answer means normal completion, and older tool-call steps are never misread as dead streams. Recovery is also skipped if the session has gone busy/retry again before the prompt is sent (race guard).
 
+### Context saturation → magic-context wrapup
+
+A session can fill its usable context window without stalling — it just keeps working until it chokes. The plugin tracks token usage from `message.updated` events and computes the ratio against the model's usable window (`context − min(20k, maxOutput)`, mirroring OpenCode's own overflow math). On idle, when the ratio crosses `contextSaturationThreshold` (default 0.85), routing depends on session kind. For parent sessions, only when magic-context is detected in the host's configured plugin list (`config.get().plugin`), the plugin invokes the registered `ctx-wrapup` command through `client.session.command()` — it does not send `/ctx-wrapup` as prompt text, because prompt text is not expanded into a command. For subagent sessions identified by `parentID` on `session.created`, the default is no intervention: magic-context does run bounded cleanup for subagents (structural-noise/cleared-reasoning strips, heuristic drops, ceiling nudges), but its hard protections — historian compartments, emergency fail-closed abort, caveman compression — skip subagents, and on true overflow the error just propagates to the parent with no deterministic reclaim. Terminal reclamation therefore depends on the agent calling `ctx_reduce` when nudged. If `subagentNativeCompactionEnabled` is `true`, the plugin calls native `session.summarize()` as an opt-in safety net. Fail-safe: provider lookup errors, unknown model limits, user cancellation, or completion signals mean no intervention. Magic-context absence additionally disables only the parent path (the `ctx-wrapup` command would not be registered); the opt-in subagent path needs no magic-context detection because `session.summarize()` is native. This path is magic-context-gated on purpose: magic-context's setup disables OpenCode's native compaction, so unconditionally summarizing a magic-context-managed parent would double-compress and fight its cache-aware historian. One intervention per busy cycle.
+
 ---
 
 ### Active-tool safety guard
@@ -261,7 +265,7 @@ All recovery paths fall into three families. Which family fires determines what
 
 Fire only after OpenCode reports the session **idle** — the runner has exited. The prompt starts a new run.
 
-Paths: todo nudges, tool-call-as-text recovery, thinking-tool recovery, action-intent nudge, ready-to-continue, done-claim verification, streaming-failure recovery, silent dead-stream recovery.
+Paths: todo nudges, tool-call-as-text recovery, thinking-tool recovery, action-intent nudge, ready-to-continue, done-claim verification, streaming-failure recovery, silent dead-stream recovery, context-saturation routing (magic-context-gated; parent sessions use `session.command`, subagents use opt-in native `session.summarize`).
 
 ### 2. Busy-silence continue (stream stall)
 
@@ -384,6 +388,8 @@ With options:
 | `doneWithoutDetailsPrompt` | `DONE_WITHOUT_DETAILS_PROMPT` | Override the done-claim-with-no-todos report prompt |
 | `silentDeadStreamMinTokens` | `200` | Min output tokens to treat a textless `finish:"unknown"` message as a dead stream |
 | `busyStallStrategy` | `"continue"` | Busy-stall response: `"continue"`, `"abort"` (abort-first), or `"off"` (disabled) |
+| `contextSaturationThreshold` | `0.85` | Ratio of used/usable context that routes a saturated parent to magic-context `ctx-wrapup` (only when magic-context is installed) |
+| `subagentNativeCompactionEnabled` | `false` | Opt-in native `session.summarize()` for saturated subagent sessions (no magic-context detection required) |
 
 Message patterns are matched case-insensitively. Error names use exact match.
 

package/dist/index.js

@@ -12370,6 +12370,7 @@ var SESSION_DISCOVERY_INTERVAL_MS = 60000;
 var TOOL_TEXT_RECOVERY_PROMPT = "Your last message contained a raw tool call printed as text instead of being executed. " + "Please use the proper tool calling mechanism to execute it.";
 var THINKING_TOOL_RECOVERY_PROMPT = "I noticed you have a tool call generated in your thinking/reasoning. " + "Please execute it using the proper tool calling mechanism instead of keeping it in reasoning.";
 var TOOL_LOOP_RECOVERY_PROMPT = "I notice you've been calling the same tool multiple times in a row without making progress. " + "Please step back and reassess your approach. Consider: " + "1) Are you stuck in a loop? 2) Do you need different information first? " + "3) Should you try a different tool or break the task into smaller steps? " + "Take a moment to think about what's blocking you and propose a different strategy.";
+var CTX_WRAPUP_TRIGGER = "ctx-wrapup";
 var TOOL_TEXT_PATTERNS = [
   /<function\s*=/i,
   /<function>/i,
@@ -12619,6 +12620,8 @@ var AutoResumePlugin = async (ctx, options) => {
   const silentDeadStreamMinTokens = options?.silentDeadStreamMinTokens ?? DEFAULT_SILENT_DEAD_STREAM_MIN_TOKENS;
   const rawBusyStallStrategy = options?.busyStallStrategy ?? "continue";
   const busyStallStrategy = rawBusyStallStrategy === "abort" || rawBusyStallStrategy === "off" ? rawBusyStallStrategy : "continue";
+  const contextSaturationThreshold = options?.contextSaturationThreshold ?? 0.85;
+  const subagentNativeCompactionEnabled = options?.subagentNativeCompactionEnabled ?? false;
   const dbg = (...args) => {
     if (debug)
       console.log("[debug]", ...args);
@@ -12706,6 +12709,8 @@ var AutoResumePlugin = async (ctx, options) => {
         interruptedContinueCount: 0,
         recentToolCalls: [],
         liveToolSigs: [],
+        lastTokenTotal: 0,
+        contextWrapupAttempts: 0,
         toolLoopAttempts: 0,
         isSubagent: false,
         completionSignaled: false,
@@ -13124,6 +13129,67 @@ var AutoResumePlugin = async (ctx, options) => {
       return false;
     }
   }
+  let magicContextDetected = null;
+  async function isMagicContextInstalled() {
+    if (magicContextDetected !== null)
+      return magicContextDetected;
+    try {
+      const res = await ctx.client.config?.get?.();
+      const cfg = res?.data;
+      const plugins = cfg?.plugin;
+      if (!Array.isArray(plugins)) {
+        dbg("magic-context detection: plugin list unavailable, treating as not installed");
+        return false;
+      }
+      magicContextDetected = plugins.some((p) => {
+        const spec = typeof p === "string" ? p : Array.isArray(p) ? String(p[0]) : "";
+        return spec.toLowerCase().includes("magic-context");
+      });
+      return magicContextDetected;
+    } catch (e) {
+      const errMsg = e instanceof Error ? e.message : String(e);
+      dbg(`magic-context detection failed, treating as not installed: ${errMsg}`);
+      return false;
+    }
+  }
+  const usableLimitCache = new Map;
+  async function getUsableContextLimit(sid) {
+    try {
+      const msgs = await getSessionMessages(sid);
+      let model;
+      for (let i = msgs.length - 1;i >= 0; i--) {
+        const m = msgs[i];
+        if (m.role === "user") {
+          model = m.model ?? m.info?.model;
+          break;
+        }
+      }
+      if (!model || typeof model.providerID !== "string" || typeof model.modelID !== "string") {
+        return null;
+      }
+      const key = `${model.providerID}/${model.modelID}`;
+      const cached = usableLimitCache.get(key);
+      if (cached !== undefined)
+        return cached;
+      const res = await ctx.client.provider?.get?.();
+      const providers = res?.data ?? res;
+      if (!Array.isArray(providers))
+        return null;
+      const prov = providers.find((p) => p.id === model.providerID);
+      const models = prov?.models;
+      const entry = models?.find((x) => x.id === model.modelID);
+      const limit = entry?.limit;
+      if (!limit || typeof limit.context !== "number" || limit.context === 0)
+        return null;
+      const usable = limit.context - Math.min(20000, limit.output ?? 0);
+      usableLimitCache.set(key, usable);
+      return usable;
+    } catch (e) {
+      const errMsg = e instanceof Error ? e.message : String(e);
+      dbg(`usable-context-limit lookup failed for ${short(sid)}: ${errMsg}`);
+      return null;
+    }
+  }
   async function checkSessionHasActiveTool(sid) {
     try {
       const statusMap = await getSessionStatusMap();
@@ -13234,6 +13300,7 @@ var AutoResumePlugin = async (ctx, options) => {
     w.recentToolCalls = [];
     w.liveToolSigs = [];
     w.toolLoopAttempts = 0;
+    w.contextWrapupAttempts = 0;
     w.pendingRecovery = false;
     w.pendingRecoveryReason = null;
     w.pendingRecoveryAt = 0;
@@ -13942,6 +14009,23 @@ var AutoResumePlugin = async (ctx, options) => {
           }
           prevBusyCount = currentBusy;
           log("debug", `${short(sid)} -> idle (${currentBusy})`);
+          if (w.isSubagent) {
+            try {
+              if (w.lastTokenTotal > 0 && w.contextWrapupAttempts < 1 && !w.userCancelled && !w.completionSignaled && !w.aborting) {
+                const usable = await getUsableContextLimit(sid);
+                if (usable && w.lastTokenTotal / usable >= contextSaturationThreshold) {
+                  if (subagentNativeCompactionEnabled) {
+                    w.contextWrapupAttempts++;
+                    await log("warn", `${short(sid)} - context saturation (subagent): ${w.lastTokenTotal}/${usable} tokens (${Math.round(w.lastTokenTotal / usable * 100)}% of usable); triggering native compaction`);
+                    await ctx.client.session.summarize({ path: { id: sid } });
+                  }
+                }
+              }
+            } catch (e) {
+              const errMsg = e instanceof Error ? e.message : String(e);
+              dbg(`session.idle sid=${short(sid)}: context-saturation check error: ${errMsg}`);
+            }
+          }
           if (!w.isSubagent) {
             if (!w.pendingRecovery && !w.completionSignaled && !w.userCancelled && !w.aborting) {
               try {
@@ -13982,6 +14066,25 @@ var AutoResumePlugin = async (ctx, options) => {
                 const errMsg = e instanceof Error ? e.message : String(e);
                 dbg(`session.idle sid=${short(sid)}: silent-dead-stream check error: ${errMsg}`);
               }
+              try {
+                if (w.lastTokenTotal > 0 && w.contextWrapupAttempts < 1 && !w.userCancelled && !w.completionSignaled) {
+                  const usable = await getUsableContextLimit(sid);
+                  if (usable && w.lastTokenTotal / usable >= contextSaturationThreshold) {
+                    const installed = await isMagicContextInstalled();
+                    if (!installed)
+                      break;
+                    w.contextWrapupAttempts++;
+                    await log("warn", `${short(sid)} - context saturation: ${w.lastTokenTotal}/${usable} tokens (${Math.round(w.lastTokenTotal / usable * 100)}% of usable); sending magic-context wrapup command`);
+                    await ctx.client.session.command({
+                      path: { id: sid },
+                      body: { command: CTX_WRAPUP_TRIGGER, arguments: "" }
+                    });
+                  }
+                }
+              } catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                dbg(`session.idle sid=${short(sid)}: context-saturation check error: ${errMsg}`);
+              }
             }
             let todos = w.todos || [];
             if (todos.length === 0) {
@@ -14058,7 +14161,10 @@ var AutoResumePlugin = async (ctx, options) => {
         const w = ensureWatch(sid);
         w.pendingTools = 0;
         w.pendingCommands = 0;
-        log("debug", `New session: ${short(sid)} (${sessions.size})`);
+        const createdProps = ev.properties;
+        const parentID = createdProps?.parentID ?? createdProps?.session?.parentID;
+        w.isSubagent = typeof parentID === "string" && parentID.length > 0;
+        log("debug", `New session: ${short(sid)} (${sessions.size})${w.isSubagent ? " [subagent]" : ""}`);
         break;
       }
       case "session.updated": {
@@ -14131,6 +14237,26 @@ var AutoResumePlugin = async (ctx, options) => {
         }
         break;
       }
+      case "message.updated": {
+        if (!sid)
+          break;
+        const props = ev.properties;
+        const info = props?.info;
+        const role = info?.role ?? props?.role;
+        if (role !== "assistant")
+          break;
+        const tokens = info?.tokens ?? props?.tokens;
+        if (!tokens)
+          break;
+        const cache = tokens.cache;
+        const total = tokens.total ?? (tokens.input ?? 0) + (tokens.output ?? 0) + (cache?.read ?? 0) + (cache?.write ?? 0);
+        if (typeof total === "number" && total > 0) {
+          const w = ensureWatch(sid);
+          w.lastActivityAt = Date.now();
+          w.lastTokenTotal = total;
+        }
+        break;
+      }
       case "todo.updated": {
         if (!sid)
           break;

package/package.json

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