oh-my-opencode 0.3.0 → 0.3.1

package/README.ko.md

@@ -106,7 +106,19 @@ opencode --version  # 1.0.132 이상이어야 함
 cat ~/.config/opencode/opencode.json  # plugin 배열에 "oh-my-opencode"가 있어야 함
 ```
 
-> **참고**: 모델 인증이 필요하면, `opencode` 실행 후 `/connect` 명령어를 사용하거나, tmux를 통해 `opencode auth login`을 안내하세요.
+### 4단계: 인증정보 설정
+
+plugin 에 oh my opencode 를 추가했다면, tmux 를 사용하여 다음의 내용을 진행주세요.
+
+1. tmux 를 사용하여 셸 열기
+2. opencode auth login > Provider Anthropic > Login method Claude Pro/Max > 사용자에게 oauth 화면에서 인증하라고 안내
+3. 사용자에게 macOS 일 경우 VibeProxy, 아닐 경우 CLIProxyAPI 를 사용하여 OpenAI / Google 인증을 완료하라고 안내
+
+### ⚠️ 주의
+
+**사용자가 명시적으로 요청하지 않는 한, `oh-my-opencode.json` 설정 파일을 생성하거나 수정하지 마세요.**
+
+플러그인은 설정 파일 없이도 기본값으로 완벽하게 동작합니다. 설정 파일은 사용자가 커스터마이징을 원할 때만 필요합니다.
 
 </details>
 
@@ -326,7 +338,7 @@ Schema 자동 완성이 지원됩니다:
 
 각 에이전트에서 지원하는 옵션: `model`, `temperature`, `top_p`, `prompt`, `tools`, `disable`, `description`, `mode`, `color`, `permission`.
 
-또는 `disabled_agents`로 비활성화할 수 있습니다:
+또는 ~/.config/opencode/oh-my-opencode.json 혹은 .opencode/oh-my-opencode.json 의 `disabled_agents` 를 사용하여 비활성화할 수 있습니다:
 
 ```json
 {
@@ -338,7 +350,9 @@ Schema 자동 완성이 지원됩니다:
 
 ### MCPs
 
-내장된 MCP를 비활성화합니다:
+기본적으로 Context7, Exa MCP 를 지원합니다.
+
+이것이 마음에 들지 않는다면, ~/.config/opencode/oh-my-opencode.json 혹은 .opencode/oh-my-opencode.json 의 `disabled_mcps` 를 사용하여 비활성화할 수 있습니다:
 
 ```json
 {
@@ -346,13 +360,13 @@ Schema 자동 완성이 지원됩니다:
 }
 ```
 
-더 자세한 내용은 [OpenCode MCP Servers](https://opencode.ai/docs/mcp-servers)를 참조하세요.
-
 ### LSP
 
-Oh My OpenCode의 LSP 도구는 오직 **리팩토링(이름 변경, 코드 액션)만을 위한 것**입니다. 분석용 LSP는 OpenCode 자체에서 처리합니다.
+OpenCode 는 분석을 위해 LSP 도구를 제공합니다.
+Oh My OpenCode 에서는 LSP 의 리팩토링(이름 변경, 코드 액션) 도구를 제공합니다.
+OpenCode 에서 지원하는 모든 LSP 구성 및 커스텀 설정 (opencode.json 에 설정 된 것) 을 그대로 지원하고, Oh My OpenCode 만을 위한 추가적인 설정도 아래와 같이 설정 할 수 있습니다.
 
-`lsp` 옵션을 통해 LSP 서버를 설정합니다:
+~/.config/opencode/oh-my-opencode.json 혹은 .opencode/oh-my-opencode.json 의 `lsp` 옵션을 통해 LSP 서버를 추가로 설정 할 수 있습니다:
 
 ```json
 {

package/README.md

@@ -28,11 +28,12 @@ Oh My OpenCode
 oMoMoMoMoMo···
 
 If you work in tech, you likely appreciated [Claude Code](https://www.claude.com/product/claude-code).
-If you are a hacker, you will fucking falling in love with [OpenCode](https://github.com/sst/opencode).
+If you are a hacker, you will fucking fall in love with [OpenCode](https://github.com/sst/opencode).
 
-You don't write code just for a paycheck? You write because you genuinely love it?
-
-To you, OpenCode will feel like the paradigm shift from Windows to Linux. Not you? It's still worth the investment. Give it 10 minutes. Your work and life will improve. I promise.
+Do you remember the first time you switched from Windows to Linux? The excitement of configuring everything just the way you wanted?
+In an era where that romance feels lost, OpenCode will be that project for you.
+If you love coding and computers, OpenCode will feel exactly like that moment you first touched Linux after years of Windows.
+Even if you don't, invest a little time. Boost your skills and productivity by multipliers.
 
 ## TL;DR
 
@@ -42,7 +43,7 @@ To you, OpenCode will feel like the paradigm shift from Windows to Linux. Not yo
     - For OpenAI models, I recommend the [OpenCode-OpenAI-Codex-Auth plugin](https://github.com/numman-ali/opencode-openai-codex-auth).
     - For Gemini and GPT, use [VibeProxy (macOS Only)](https://github.com/automazeio/vibeproxy) or [CLIProxyAPI](https://github.com/router-for-me/CLIProxyAPI).
 - **Truth be told, the rest is optional. Just install it. Once set up, no further learning is required. It simply evolves.**
-- **Paste this document into Claude Code, OpenCode, or Cursor, instruct it to install, and ask for assistance if needed. It works seamlessly.**
+- **Paste this document into Claude Code, OpenCode, or Cursor, instruct it to install, and ask for assistance if needed. It just installs.**
   - If you are an LLM Agent, install the required plugins and dependencies, then run `opencode auth login` via tmux to assist the user with configuration.
 
 ## Installation
@@ -104,7 +105,19 @@ opencode --version  # Should be >= 1.0.132
 cat ~/.config/opencode/opencode.json  # Should contain "oh-my-opencode" in plugin array
 ```
 
-> **Note**: If model authentication is needed, run `opencode` and use `/connect` command, or assist the user with `opencode auth login` via tmux.
+### Step 4: Configure Authentication
+
+Once `oh-my-opencode` is added to the plugin list, use `tmux` to proceed with the following:
+
+1. Open a shell using `tmux`.
+2. Run `opencode auth login` > Select Provider `Anthropic` > Select Login method `Claude Pro/Max` > Instruct the user to authenticate via the OAuth screen.
+3. Recommend the setup: [VibeProxy](https://github.com/automazeio/vibeproxy) for macOS users, or [CLIProxyAPI](https://github.com/router-for-me/CLIProxyAPI) for others.
+
+### ⚠️ Warning
+
+**Do NOT create or modify the `oh-my-opencode.json` configuration file unless the user explicitly requests it.**
+
+The plugin works perfectly with default settings without any configuration file. The configuration file is only needed when the user wants customization.
 
 </details>
 
@@ -115,7 +128,7 @@ OpenCode is limitlessly extensible and customizable. Zero screen flicker.
 You can mix and orchestrate models to your exact specifications.
 It is feature-rich. It is elegant. It handles the terminal without hesitation. It is high-performance.
 
-But here is the catch: the learning curve is steep. There is a lot to master.
+But here is the catch: the learning curve is steep. There is a lot to master. And your time is expensive.
 
 Inspired by [AmpCode](https://ampcode.com) and [Claude Code](https://code.claude.com/docs/en/overview), I have implemented their features here—often with superior execution.
 Because this is OpenCode.
@@ -323,7 +336,7 @@ Override built-in agent settings:
 
 Each agent supports: `model`, `temperature`, `top_p`, `prompt`, `tools`, `disable`, `description`, `mode`, `color`, `permission`.
 
-Or disable agents via `disabled_agents`:
+Or you can disable them using `disabled_agents` in `~/.config/opencode/oh-my-opencode.json` or `.opencode/oh-my-opencode.json`:
 
 ```json
 {
@@ -335,7 +348,9 @@ Available agents: `oracle`, `librarian`, `explore`, `frontend-ui-ux-engineer`, `
 
 ### MCPs
 
-Disable built-in MCPs:
+By default, Context7 and Exa MCP are supported.
+
+If you don't want these, you can disable them using `disabled_mcps` in `~/.config/opencode/oh-my-opencode.json` or `.opencode/oh-my-opencode.json`:
 
 ```json
 {
@@ -343,13 +358,13 @@ Disable built-in MCPs:
 }
 ```
 
-See [OpenCode MCP Servers](https://opencode.ai/docs/mcp-servers) for more.
-
 ### LSP
 
-Oh My OpenCode's LSP tools are for **refactoring only** (rename, code actions). Analysis LSP is handled by OpenCode itself.
+OpenCode provides LSP tools for analysis.
+Oh My OpenCode provides LSP tools for refactoring (rename, code actions).
+It supports all LSP configurations and custom settings supported by OpenCode (those configured in opencode.json), and you can also configure additional settings specifically for Oh My OpenCode as shown below.
 
-Configure LSP servers via `lsp` option:
+You can configure additional LSP servers via the `lsp` option in `~/.config/opencode/oh-my-opencode.json` or `.opencode/oh-my-opencode.json`:
 
 ```json
 {
@@ -389,7 +404,7 @@ If this sounds arrogant and you have a superior solution, send a PR. You are wel
 
 As of now, I have no affiliation with any of the projects or models mentioned here. This plugin is purely based on personal experimentation and preference.
 
-I constructed 99% of this project using OpenCode. I focused on functional verification. This documentation has been personally reviewed and comprehensively rewritten, so you can rely on it with confidence.
+I constructed 99% of this project using OpenCode. I focused on functional verification, and honestly, I don't know how to write proper TypeScript. **But I personally reviewed and comprehensively rewritten this documentation, so you can rely on it with confidence.**
 ## Warnings
 
 - If you are on [1.0.132](https://github.com/sst/opencode/releases/tag/v1.0.132) or lower, OpenCode has a bug that might break config.

package/dist/hooks/session-recovery/storage.d.ts

@@ -7,6 +7,7 @@ export declare function hasContent(part: StoredPart): boolean;
 export declare function messageHasContent(messageID: string): boolean;
 export declare function injectTextPart(sessionID: string, messageID: string, text: string): boolean;
 export declare function findEmptyMessages(sessionID: string): string[];
+export declare function findEmptyMessageByIndex(sessionID: string, targetIndex: number): string | null;
 export declare function findFirstEmptyMessage(sessionID: string): string | null;
 export declare function findMessagesWithThinkingBlocks(sessionID: string): string[];
 export declare function findMessagesWithOrphanThinking(sessionID: string): string[];

package/dist/index.js

@@ -633,6 +633,7 @@ function createTodoContinuationEnforcer(ctx) {
   const remindedSessions = new Set;
   const interruptedSessions = new Set;
   const errorSessions = new Set;
+  const pendingTimers = new Map;
   return async ({ event }) => {
     const props = event.properties;
     if (event.type === "session.error") {
@@ -642,6 +643,11 @@ function createTodoContinuationEnforcer(ctx) {
         if (detectInterrupt(props?.error)) {
           interruptedSessions.add(sessionID);
         }
+        const timer = pendingTimers.get(sessionID);
+        if (timer) {
+          clearTimeout(timer);
+          pendingTimers.delete(sessionID);
+        }
       }
       return;
     }
@@ -649,61 +655,73 @@ function createTodoContinuationEnforcer(ctx) {
       const sessionID = props?.sessionID;
       if (!sessionID)
         return;
-      await new Promise((resolve) => setTimeout(resolve, 150));
-      const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID);
-      interruptedSessions.delete(sessionID);
-      errorSessions.delete(sessionID);
-      if (shouldBypass) {
-        return;
-      }
-      if (remindedSessions.has(sessionID)) {
-        return;
-      }
-      let todos = [];
-      try {
-        const response = await ctx.client.session.todo({
-          path: { id: sessionID }
-        });
-        todos = response.data ?? response;
-      } catch {
-        return;
-      }
-      if (!todos || todos.length === 0) {
-        return;
-      }
-      const incomplete = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
-      if (incomplete.length === 0) {
-        return;
-      }
-      remindedSessions.add(sessionID);
-      if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID)) {
-        remindedSessions.delete(sessionID);
-        return;
-      }
-      try {
-        await ctx.client.session.prompt({
-          path: { id: sessionID },
-          body: {
-            parts: [
-              {
-                type: "text",
-                text: `${CONTINUATION_PROMPT}
+      const existingTimer = pendingTimers.get(sessionID);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+      const timer = setTimeout(async () => {
+        pendingTimers.delete(sessionID);
+        const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID);
+        interruptedSessions.delete(sessionID);
+        errorSessions.delete(sessionID);
+        if (shouldBypass) {
+          return;
+        }
+        if (remindedSessions.has(sessionID)) {
+          return;
+        }
+        let todos = [];
+        try {
+          const response = await ctx.client.session.todo({
+            path: { id: sessionID }
+          });
+          todos = response.data ?? response;
+        } catch {
+          return;
+        }
+        if (!todos || todos.length === 0) {
+          return;
+        }
+        const incomplete = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
+        if (incomplete.length === 0) {
+          return;
+        }
+        remindedSessions.add(sessionID);
+        if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID)) {
+          remindedSessions.delete(sessionID);
+          return;
+        }
+        try {
+          await ctx.client.session.prompt({
+            path: { id: sessionID },
+            body: {
+              parts: [
+                {
+                  type: "text",
+                  text: `${CONTINUATION_PROMPT}
 
 [Status: ${todos.length - incomplete.length}/${todos.length} completed, ${incomplete.length} remaining]`
-              }
-            ]
-          },
-          query: { directory: ctx.directory }
-        });
-      } catch {
-        remindedSessions.delete(sessionID);
-      }
+                }
+              ]
+            },
+            query: { directory: ctx.directory }
+          });
+        } catch {
+          remindedSessions.delete(sessionID);
+        }
+      }, 200);
+      pendingTimers.set(sessionID, timer);
     }
     if (event.type === "message.updated") {
       const info = props?.info;
       const sessionID = info?.sessionID;
       if (sessionID && info?.role === "user") {
         remindedSessions.delete(sessionID);
+        const timer = pendingTimers.get(sessionID);
+        if (timer) {
+          clearTimeout(timer);
+          pendingTimers.delete(sessionID);
+        }
       }
     }
     if (event.type === "session.deleted") {
@@ -712,6 +730,11 @@ function createTodoContinuationEnforcer(ctx) {
         remindedSessions.delete(sessionInfo.id);
         interruptedSessions.delete(sessionInfo.id);
         errorSessions.delete(sessionInfo.id);
+        const timer = pendingTimers.get(sessionInfo.id);
+        if (timer) {
+          clearTimeout(timer);
+          pendingTimers.delete(sessionInfo.id);
+        }
       }
     }
   };
@@ -723,16 +746,8 @@ var CONTEXT_WARNING_THRESHOLD = 0.7;
 var CONTEXT_REMINDER = `[SYSTEM REMINDER - 1M Context Window]
 
 You are using Anthropic Claude with 1M context window.
-Current usage has exceeded 75%.
-
-RECOMMENDATIONS:
-- Consider compacting the session if available
-- Break complex tasks into smaller, focused sessions
-- Be concise in your responses
-- Avoid redundant file reads
-
-You have access to 1M tokens - use them wisely. Do NOT rush or skip tasks.
-Complete your work thoroughly despite the context usage warning.`;
+You have plenty of context remaining - do NOT rush or skip tasks.
+Complete your work thoroughly and methodically.`;
 function createContextWindowMonitorHook(ctx) {
   const remindedSessions = new Set;
   const toolExecuteAfter = async (input, output) => {
@@ -854,7 +869,13 @@ function readMessages(sessionID) {
       continue;
     }
   }
-  return messages.sort((a, b) => a.id.localeCompare(b.id));
+  return messages.sort((a, b) => {
+    const aTime = a.time?.created ?? 0;
+    const bTime = b.time?.created ?? 0;
+    if (aTime !== bTime)
+      return aTime - bTime;
+    return a.id.localeCompare(b.id);
+  });
 }
 function readParts(messageID) {
   const partDir = join2(PART_STORAGE, messageID);
@@ -918,19 +939,26 @@ function injectTextPart(sessionID, messageID, text) {
 function findEmptyMessages(sessionID) {
   const messages = readMessages(sessionID);
   const emptyIds = [];
-  for (let i = 0;i < messages.length; i++) {
-    const msg = messages[i];
+  for (const msg of messages) {
     if (msg.role !== "assistant")
       continue;
-    const isLastMessage = i === messages.length - 1;
-    if (isLastMessage)
-      continue;
     if (!messageHasContent(msg.id)) {
       emptyIds.push(msg.id);
     }
   }
   return emptyIds;
 }
+function findEmptyMessageByIndex(sessionID, targetIndex) {
+  const messages = readMessages(sessionID);
+  if (targetIndex < 0 || targetIndex >= messages.length)
+    return null;
+  const targetMsg = messages[targetIndex];
+  if (targetMsg.role !== "assistant")
+    return null;
+  if (messageHasContent(targetMsg.id))
+    return null;
+  return targetMsg.id;
+}
 function findMessagesWithThinkingBlocks(sessionID) {
   const messages = readMessages(sessionID);
   const result = [];
@@ -1025,6 +1053,11 @@ function getErrorMessage(error) {
   const errorObj = error;
   return (errorObj.data?.message || errorObj.error?.message || errorObj.message || "").toLowerCase();
 }
+function extractMessageIndex(error) {
+  const message = getErrorMessage(error);
+  const match = message.match(/messages\.(\d+)/);
+  return match ? parseInt(match[1], 10) : null;
+}
 function detectErrorType(error) {
   const message = getErrorMessage(error);
   if (message.includes("tool_use") && message.includes("tool_result")) {
@@ -1091,14 +1124,21 @@ async function recoverThinkingDisabledViolation(_client, sessionID, _failedAssis
   }
   return anySuccess;
 }
-async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory) {
-  const emptyMessageIDs = findEmptyMessages(sessionID);
-  if (emptyMessageIDs.length === 0) {
-    const fallbackID = failedAssistantMsg.info?.id;
-    if (!fallbackID)
-      return false;
-    return injectTextPart(sessionID, fallbackID, "(interrupted)");
+async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory, error) {
+  const targetIndex = extractMessageIndex(error);
+  const failedID = failedAssistantMsg.info?.id;
+  if (targetIndex !== null) {
+    const targetMessageID = findEmptyMessageByIndex(sessionID, targetIndex);
+    if (targetMessageID) {
+      return injectTextPart(sessionID, targetMessageID, "(interrupted)");
+    }
   }
+  if (failedID) {
+    if (injectTextPart(sessionID, failedID, "(interrupted)")) {
+      return true;
+    }
+  }
+  const emptyMessageIDs = findEmptyMessages(sessionID);
   let anySuccess = false;
   for (const messageID of emptyMessageIDs) {
     if (injectTextPart(sessionID, messageID, "(interrupted)")) {
@@ -1171,10 +1211,11 @@ function createSessionRecoveryHook(ctx) {
       } else if (errorType === "thinking_disabled_violation") {
         success = await recoverThinkingDisabledViolation(ctx.client, sessionID, failedMsg);
       } else if (errorType === "empty_content_message") {
-        success = await recoverEmptyContentMessage(ctx.client, sessionID, failedMsg, ctx.directory);
+        success = await recoverEmptyContentMessage(ctx.client, sessionID, failedMsg, ctx.directory, info.error);
       }
       return success;
-    } catch {
+    } catch (err) {
+      console.error("[session-recovery] Recovery failed:", err);
       return false;
     } finally {
       processingErrors.delete(assistantMsgID);
@@ -1811,6 +1852,280 @@ function createEmptyTaskResponseDetectorHook(_ctx) {
     }
   };
 }
+// src/hooks/anthropic-auto-compact/parser.ts
+var TOKEN_LIMIT_PATTERNS = [
+  /(\d+)\s*tokens?\s*>\s*(\d+)\s*maximum/i,
+  /prompt.*?(\d+).*?tokens.*?exceeds.*?(\d+)/i,
+  /(\d+).*?tokens.*?limit.*?(\d+)/i,
+  /context.*?length.*?(\d+).*?maximum.*?(\d+)/i,
+  /max.*?context.*?(\d+).*?but.*?(\d+)/i
+];
+var TOKEN_LIMIT_KEYWORDS = [
+  "prompt is too long",
+  "is too long",
+  "context_length_exceeded",
+  "max_tokens",
+  "token limit",
+  "context length",
+  "too many tokens"
+];
+function extractTokensFromMessage(message) {
+  for (const pattern of TOKEN_LIMIT_PATTERNS) {
+    const match = message.match(pattern);
+    if (match) {
+      const num1 = parseInt(match[1], 10);
+      const num2 = parseInt(match[2], 10);
+      return num1 > num2 ? { current: num1, max: num2 } : { current: num2, max: num1 };
+    }
+  }
+  return null;
+}
+function isTokenLimitError(text) {
+  const lower = text.toLowerCase();
+  return TOKEN_LIMIT_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
+}
+function parseAnthropicTokenLimitError(err) {
+  if (typeof err === "string") {
+    if (isTokenLimitError(err)) {
+      const tokens = extractTokensFromMessage(err);
+      return {
+        currentTokens: tokens?.current ?? 0,
+        maxTokens: tokens?.max ?? 0,
+        errorType: "token_limit_exceeded_string"
+      };
+    }
+    return null;
+  }
+  if (!err || typeof err !== "object")
+    return null;
+  const errObj = err;
+  const dataObj = errObj.data;
+  const responseBody = dataObj?.responseBody;
+  const errorMessage = errObj.message;
+  const errorData = errObj.error;
+  const nestedError = errorData?.error;
+  const textSources = [];
+  if (typeof responseBody === "string")
+    textSources.push(responseBody);
+  if (typeof errorMessage === "string")
+    textSources.push(errorMessage);
+  if (typeof errorData?.message === "string")
+    textSources.push(errorData.message);
+  if (typeof errObj.body === "string")
+    textSources.push(errObj.body);
+  if (typeof errObj.details === "string")
+    textSources.push(errObj.details);
+  if (typeof errObj.reason === "string")
+    textSources.push(errObj.reason);
+  if (typeof errObj.description === "string")
+    textSources.push(errObj.description);
+  if (typeof nestedError?.message === "string")
+    textSources.push(nestedError.message);
+  if (typeof dataObj?.message === "string")
+    textSources.push(dataObj.message);
+  if (typeof dataObj?.error === "string")
+    textSources.push(dataObj.error);
+  if (textSources.length === 0) {
+    try {
+      const jsonStr = JSON.stringify(errObj);
+      if (isTokenLimitError(jsonStr)) {
+        textSources.push(jsonStr);
+      }
+    } catch {}
+  }
+  const combinedText = textSources.join(" ");
+  if (!isTokenLimitError(combinedText))
+    return null;
+  if (typeof responseBody === "string") {
+    try {
+      const jsonPatterns = [
+        /data:\s*(\{[\s\S]*?\})\s*$/m,
+        /(\{"type"\s*:\s*"error"[\s\S]*?\})/,
+        /(\{[\s\S]*?"error"[\s\S]*?\})/
+      ];
+      for (const pattern of jsonPatterns) {
+        const dataMatch = responseBody.match(pattern);
+        if (dataMatch) {
+          try {
+            const jsonData = JSON.parse(dataMatch[1]);
+            const message = jsonData.error?.message || "";
+            const tokens = extractTokensFromMessage(message);
+            if (tokens) {
+              return {
+                currentTokens: tokens.current,
+                maxTokens: tokens.max,
+                requestId: jsonData.request_id,
+                errorType: jsonData.error?.type || "token_limit_exceeded"
+              };
+            }
+          } catch {}
+        }
+      }
+      const bedrockJson = JSON.parse(responseBody);
+      if (typeof bedrockJson.message === "string" && isTokenLimitError(bedrockJson.message)) {
+        return {
+          currentTokens: 0,
+          maxTokens: 0,
+          errorType: "bedrock_input_too_long"
+        };
+      }
+    } catch {}
+  }
+  for (const text of textSources) {
+    const tokens = extractTokensFromMessage(text);
+    if (tokens) {
+      return {
+        currentTokens: tokens.current,
+        maxTokens: tokens.max,
+        errorType: "token_limit_exceeded"
+      };
+    }
+  }
+  if (isTokenLimitError(combinedText)) {
+    return {
+      currentTokens: 0,
+      maxTokens: 0,
+      errorType: "token_limit_exceeded_unknown"
+    };
+  }
+  return null;
+}
+
+// src/hooks/anthropic-auto-compact/executor.ts
+async function getLastAssistant(sessionID, client, directory) {
+  try {
+    const resp = await client.session.messages({
+      path: { id: sessionID },
+      query: { directory }
+    });
+    const data = resp.data;
+    if (!Array.isArray(data))
+      return null;
+    const reversed = [...data].reverse();
+    const last = reversed.find((m) => {
+      const msg = m;
+      const info = msg.info;
+      return info?.role === "assistant";
+    });
+    if (!last)
+      return null;
+    return last.info ?? null;
+  } catch {
+    return null;
+  }
+}
+async function executeCompact(sessionID, msg, autoCompactState, client, directory) {
+  try {
+    const providerID = msg.providerID;
+    const modelID = msg.modelID;
+    if (providerID && modelID) {
+      await client.session.summarize({
+        path: { id: sessionID },
+        body: { providerID, modelID },
+        query: { directory }
+      });
+      setTimeout(async () => {
+        try {
+          await client.tui.submitPrompt({ query: { directory } });
+        } catch {}
+      }, 500);
+    }
+    autoCompactState.pendingCompact.delete(sessionID);
+    autoCompactState.errorDataBySession.delete(sessionID);
+  } catch {}
+}
+
+// src/hooks/anthropic-auto-compact/index.ts
+function createAutoCompactState() {
+  return {
+    pendingCompact: new Set,
+    errorDataBySession: new Map
+  };
+}
+function createAnthropicAutoCompactHook(ctx) {
+  const autoCompactState = createAutoCompactState();
+  const eventHandler = async ({ event }) => {
+    const props = event.properties;
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info;
+      if (sessionInfo?.id) {
+        autoCompactState.pendingCompact.delete(sessionInfo.id);
+        autoCompactState.errorDataBySession.delete(sessionInfo.id);
+      }
+      return;
+    }
+    if (event.type === "session.error") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      const parsed = parseAnthropicTokenLimitError(props?.error);
+      if (parsed) {
+        autoCompactState.pendingCompact.add(sessionID);
+        autoCompactState.errorDataBySession.set(sessionID, parsed);
+      }
+      return;
+    }
+    if (event.type === "message.updated") {
+      const info = props?.info;
+      const sessionID = info?.sessionID;
+      if (sessionID && info?.role === "assistant" && info.error) {
+        const parsed = parseAnthropicTokenLimitError(info.error);
+        if (parsed) {
+          parsed.providerID = info.providerID;
+          parsed.modelID = info.modelID;
+          autoCompactState.pendingCompact.add(sessionID);
+          autoCompactState.errorDataBySession.set(sessionID, parsed);
+        }
+      }
+      return;
+    }
+    if (event.type === "session.idle") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      if (!autoCompactState.pendingCompact.has(sessionID))
+        return;
+      const errorData = autoCompactState.errorDataBySession.get(sessionID);
+      if (errorData?.providerID && errorData?.modelID) {
+        await ctx.client.tui.showToast({
+          body: {
+            title: "Auto Compact",
+            message: "Token limit exceeded. Summarizing session...",
+            variant: "warning",
+            duration: 3000
+          }
+        }).catch(() => {});
+        await executeCompact(sessionID, { providerID: errorData.providerID, modelID: errorData.modelID }, autoCompactState, ctx.client, ctx.directory);
+        return;
+      }
+      const lastAssistant = await getLastAssistant(sessionID, ctx.client, ctx.directory);
+      if (!lastAssistant) {
+        autoCompactState.pendingCompact.delete(sessionID);
+        return;
+      }
+      if (lastAssistant.summary === true) {
+        autoCompactState.pendingCompact.delete(sessionID);
+        return;
+      }
+      if (!lastAssistant.modelID || !lastAssistant.providerID) {
+        autoCompactState.pendingCompact.delete(sessionID);
+        return;
+      }
+      await ctx.client.tui.showToast({
+        body: {
+          title: "Auto Compact",
+          message: "Token limit exceeded. Summarizing session...",
+          variant: "warning",
+          duration: 3000
+        }
+      }).catch(() => {});
+      await executeCompact(sessionID, lastAssistant, autoCompactState, ctx.client, ctx.directory);
+    }
+  };
+  return {
+    event: eventHandler
+  };
+}
 // src/hooks/think-mode/detector.ts
 var ENGLISH_PATTERNS = [/\bultrathink\b/i, /\bthink\b/i];
 var MULTILINGUAL_KEYWORDS = [
@@ -19041,6 +19356,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const emptyTaskResponseDetector = createEmptyTaskResponseDetectorHook(ctx);
   const thinkMode = createThinkModeHook();
   const claudeCodeHooks = createClaudeCodeHooksHook(ctx, {});
+  const anthropicAutoCompact = createAnthropicAutoCompactHook(ctx);
   updateTerminalTitle({ sessionId: "main" });
   return {
     tool: builtinTools,
@@ -19089,6 +19405,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await contextWindowMonitor.event(input);
       await directoryAgentsInjector.event(input);
       await thinkMode.event(input);
+      await anthropicAutoCompact.event(input);
       const { event } = input;
       const props = event.properties;
       if (event.type === "session.created") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",