release: v0.1.31

deps: bump @code-yeongyu/comment-checker to 0.4.4
🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)
2025-12-09 05:42:03 +00:00 · 2025-12-09 14:41:07 +09:00 · 2025-12-09 02:50:19 +00:00 · 2025-12-09 11:49:17 +09:00 · 2025-12-09 11:49:11 +09:00 · 2025-12-09 11:49:00 +09:00
47 changed files with 1682 additions and 960 deletions
--- a/README.ko.md
+++ b/README.ko.md
@@ -13,7 +13,7 @@
    - [Tools](#tools)
      - [내장 LSP Tools](#내장-lsp-tools)
      - [내장 AST-Grep Tools](#내장-ast-grep-tools)
-      - [Safe Grep](#safe-grep)
+      - [Grep](#grep)
      - [내장 MCPs](#내장-mcps)
    - [기타 편의 기능](#기타-편의-기능)
  - [설정](#설정)
@@ -142,6 +142,17 @@ OpenCode 는 아주 확장가능하고 아주 커스터마이저블합니다.
  - **Thinking Disabled Violation**: thinking 이 비활성화인데 thinking 블록이 있을 때 → thinking 블록 제거
  - **Empty Content Message**: 메시지가 thinking/meta 블록만 있고 실제 내용이 없을 때 → 파일시스템을 통해 "(interrupted)" 텍스트 주입
 - **Comment Checker**: 코드 수정 후 불필요한 주석을 감지하여 보고합니다. BDD 패턴, 지시어, 독스트링 등 유효한 주석은 똑똑하게 제외하고, AI가 남긴 흔적을 제거하여 코드를 깨끗하게 유지합니다.
+- **Directory AGENTS.md Injector**: 파일을 읽을 때 `AGENTS.md` 내용을 자동으로 주입합니다. 파일 디렉토리부터 프로젝트 루트까지 탐색하며, 경로 상의 **모든** `AGENTS.md` 파일을 수집합니다. 중첩된 디렉토리별 지침을 지원합니다:
+  ```
+  project/
+  ├── AGENTS.md              # 프로젝트 전체 컨텍스트
+  ├── src/
+  │   ├── AGENTS.md          # src 전용 컨텍스트
+  │   └── components/
+  │       ├── AGENTS.md      # 컴포넌트 전용 컨텍스트
+  │       └── Button.tsx     # 이 파일을 읽으면 위 3개 AGENTS.md 모두 주입
+  ```
+  `Button.tsx`를 읽으면 순서대로 주입됩니다: `project/AGENTS.md` → `src/AGENTS.md` → `components/AGENTS.md`. 각 디렉토리의 컨텍스트는 세션당 한 번만 주입됩니다. Claude Code의 CLAUDE.md 기능에서 영감을 받았습니다.

 ### Agents

@@ -185,11 +196,16 @@ OpenCode 는 아주 확장가능하고 아주 커스터마이저블합니다.
 - **ast_grep_search**: AST 인식 코드 패턴 검색 (25개 언어)
 - **ast_grep_replace**: AST 인식 코드 교체

-#### Safe Grep
- **safe_grep**: 안전 제한이 있는 콘텐츠 검색 (5분 타임아웃, 10MB 출력 제한).
+#### Grep
+- **grep**: 안전 제한이 있는 콘텐츠 검색 (5분 타임아웃, 10MB 출력 제한). OpenCode의 내장 `grep` 도구를 대체합니다.
  - 기본 grep 도구는 시간제한이 걸려있지 않습니다. 대형 코드베이스에서 광범위한 패턴을 검색하면 CPU가 폭발하고 무한히 멈출 수 있습니다.
-  - safe_grep 은 timeout 과 더 엄격한 출력 제한을 적용합니다.
-  - **주의**: 기본 grep 도구는 Agent 를 햇갈리게 하지 않기 위해 비활성화됩니다. 그러나 SafeGrep 은 Grep 이 제공하는 모든 기능을 제공합니다.
+  - 이 도구는 엄격한 제한을 적용하며, 내장 `grep`을 완전히 대체합니다.
+
+#### Glob
+
+- **glob**: 타임아웃 보호가 있는 파일 패턴 매칭 (60초). OpenCode 내장 `glob` 도구를 대체합니다.
+  - 기본 `glob`은 타임아웃이 없습니다. ripgrep이 멈추면 무한정 대기합니다.
+  - 이 도구는 타임아웃을 강제하고 만료 시 프로세스를 종료합니다.

 #### 내장 MCPs

--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@ English | [한국어](README.ko.md)
    - [Tools](#tools)
      - [Built-in LSP Tools](#built-in-lsp-tools)
      - [Built-in AST-Grep Tools](#built-in-ast-grep-tools)
-      - [Safe Grep](#safe-grep)
+      - [Grep](#grep)
      - [Built-in MCPs](#built-in-mcps)
    - [Other Features](#other-features)
  - [Configuration](#configuration)
@@ -138,6 +138,17 @@ I believe in the right tool for the job. For your wallet's sake, use CLIProxyAPI
  - **Thinking Disabled Violation**: When thinking blocks exist but thinking is disabled → strips thinking blocks
  - **Empty Content Message**: When message has only thinking/meta blocks without actual content → injects "(interrupted)" text via filesystem
 - **Comment Checker**: Detects and reports unnecessary comments after code modifications. Smartly ignores valid patterns (BDD, directives, docstrings, shebangs) to keep the codebase clean from AI-generated artifacts.
+- **Directory AGENTS.md Injector**: Automatically injects `AGENTS.md` contents when reading files. Searches upward from the file's directory to project root, collecting **all** `AGENTS.md` files along the path hierarchy. This enables nested, directory-specific instructions:
+  ```
+  project/
+  ├── AGENTS.md              # Project-wide context
+  ├── src/
+  │   ├── AGENTS.md          # src-specific context
+  │   └── components/
+  │       ├── AGENTS.md      # Component-specific context
+  │       └── Button.tsx     # Reading this injects ALL 3 AGENTS.md files
+  ```
+  When reading `Button.tsx`, the hook injects contexts in order: `project/AGENTS.md` → `src/AGENTS.md` → `components/AGENTS.md`. Each directory's context is injected only once per session. Inspired by Claude Code's CLAUDE.md feature.

 ### Agents
 - **oracle** (`openai/gpt-5.1`): The architect. Expert in code reviews and strategy. Uses GPT-5.1 for its unmatched logic and reasoning capabilities. Inspired by AmpCode.
@@ -181,12 +192,17 @@ The features you use in your editor—other agents cannot access them. Oh My Ope
 - **ast_grep_search**: AST-aware code pattern search (25 languages)
 - **ast_grep_replace**: AST-aware code replacement

-#### Safe Grep
+#### Grep

- **safe_grep**: Content search with safety limits (5min timeout, 10MB output).
+- **grep**: Content search with safety limits (5min timeout, 10MB output). Overrides OpenCode's built-in `grep` tool.
  - The default `grep` lacks safeguards. On a large codebase, a broad pattern can cause CPU overload and indefinite hanging.
-  - `safe_grep` enforces strict limits.
-  - **Note**: Default `grep` is disabled to prevent Agent confusion. `safe_grep` delivers full `grep` functionality with safety assurance.
+  - This tool enforces strict limits and completely replaces the built-in `grep`.
+
+#### Glob
+
+- **glob**: File pattern matching with timeout protection (60s). Overrides OpenCode's built-in `glob` tool.
+  - The default `glob` lacks timeout. If ripgrep hangs, it waits indefinitely.
+  - This tool enforces timeouts and kills the process on expiration.

 #### Built-in MCPs

--- a/bun.lock
+++ b/bun.lock
@@ -7,13 +7,14 @@
      "dependencies": {
        "@ast-grep/cli": "^0.40.0",
        "@ast-grep/napi": "^0.40.0",
-        "@code-yeongyu/comment-checker": "^0.4.1",
+        "@code-yeongyu/comment-checker": "^0.4.4",
        "@opencode-ai/plugin": "^1.0.7",
        "xdg-basedir": "^5.1.0",
        "zod": "^4.1.8",
      },
      "devDependencies": {
        "bun-types": "latest",
+        "oh-my-opencode": "^0.1.30",
        "typescript": "^5.7.3",
      },
      "peerDependencies": {
@@ -63,7 +64,7 @@

    "@ast-grep/napi-win32-x64-msvc": ["@ast-grep/napi-win32-x64-msvc@0.40.0", "", { "os": "win32", "cpu": "x64" }, "sha512-Hk2IwfPqMFGZt5SRxsoWmGLxBXxprow4LRp1eG6V8EEiJCNHxZ9ZiEaIc5bNvMDBjHVSnqZAXT22dROhrcSKQg=="],

-    "@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.4.1", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-E7p1V8CsRj9hMbwENd9BfxZGWYu+lKS5tXGuNNcNtkRMhWvwM/ononysKpLB7LXdxfSYAn0j7heJydyzEmm+lg=="],
+    "@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.4.4", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-vsbdLMQYJJNDV/baTDnNqqg/MZwA+9nz7TE6Mybj8zjZVTCn4ZivH4hAdD5p4fLxhGZEJ5x1UDmXA6pAGA7lHA=="],

    "@opencode-ai/plugin": ["@opencode-ai/plugin@1.0.128", "", { "dependencies": { "@opencode-ai/sdk": "1.0.128", "zod": "4.1.8" } }, "sha512-M5vjz3I6KeoBSNduWmT5iHXRtTLCqICM5ocs+WrB3uxVorslcO3HVwcLzrERh/ntpxJ/1xhnHQaeG6Mg+P744A=="],

@@ -99,6 +100,8 @@

    "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],

+    "oh-my-opencode": ["oh-my-opencode@0.1.30", "", { "dependencies": { "@ast-grep/cli": "^0.40.0", "@ast-grep/napi": "^0.40.0", "@code-yeongyu/comment-checker": "^0.4.1", "@opencode-ai/plugin": "^1.0.7", "xdg-basedir": "^5.1.0", "zod": "^4.1.8" }, "peerDependencies": { "bun": ">=1.0.0" } }, "sha512-pXGGgL/7Jcz3yuGJJTI72BKern2egwfRz2LQZTBq+jl+pNCybOvGvXtFmR+WGlF8O3ZjL1wIHypBbIVuHOBzxg=="],
+
    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],

    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
@@ -106,5 +109,7 @@
    "xdg-basedir": ["xdg-basedir@5.1.0", "", {}, "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ=="],

    "zod": ["zod@4.1.8", "", {}, "sha512-5R1P+WwQqmmMIEACyzSvo4JXHY5WiAFHRMg+zBZKgKS+Q1viRa0C1hmUKtHltoIFKtIdki3pRxkmpP74jnNYHQ=="],
+
+    "oh-my-opencode/@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.4.1", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-E7p1V8CsRj9hMbwENd9BfxZGWYu+lKS5tXGuNNcNtkRMhWvwM/ononysKpLB7LXdxfSYAn0j7heJydyzEmm+lg=="],
  }
 }
--- a/notepad.md
+++ b/notepad.md
@@ -59,3 +59,85 @@ All tasks execution STARTED: Thu Dec 4 16:52:57 KST 2025

 ---

+## [2025-12-08 18:56] - Task 1: Remove unused import formatWorkspaceEdit from LSP tools
+
+### DISCOVERED ISSUES
+- None - simple import cleanup task
+
+### IMPLEMENTATION DECISIONS
+- Removed only `formatWorkspaceEdit` from import list at line 17
+- Kept all other imports intact (formatCodeActions, applyWorkspaceEdit, formatApplyResult remain)
+- Verified the function exists in utils.ts:212 but is truly unused in tools.ts
+
+### PROBLEMS FOR NEXT TASKS
+- None identified for remaining tasks
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, bundled 200 modules
+- Ran: `rg "formatWorkspaceEdit" src/tools/lsp/tools.ts` → no matches (confirmed removal)
+
+### LEARNINGS
+- Convention: This project uses `bun run typecheck` (tsc --noEmit) and `bun run build` for verification
+- The `formatWorkspaceEdit` function still exists in utils.ts - it's exported but just not used in tools.ts
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-08 19:00] - Task 2: Remove unused ThinkingPart interface and fallbackRevertStrategy function
+
+### DISCOVERED ISSUES
+- None - both items were genuinely unused (no callers found)
+
+### IMPLEMENTATION DECISIONS
+- Removed `ThinkingPart` interface (lines 37-40) - defined but never referenced
+- Removed `fallbackRevertStrategy` function (lines 189-244) - defined but never called
+- Added comment explaining removal reason as per task requirements
+- Kept `ThinkingPartType`, `prependThinkingPart`, `stripThinkingParts` - these are different items and ARE used
+
+### PROBLEMS FOR NEXT TASKS
+- None identified
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, bundled 200 modules
+- Ran: `rg "ThinkingPart" src/hooks/session-recovery/` → only related types/functions found, interface removed
+- Ran: `rg "fallbackRevertStrategy" src/hooks/session-recovery/` → only comment found, function removed
+- Ran: `rg "createSessionRecoveryHook" src/hooks/` → exports intact
+
+### LEARNINGS
+- `ThinkingPart` interface vs `ThinkingPartType` type vs `prependThinkingPart` function - different entities, verify before removing
+- `fallbackRevertStrategy` was likely a planned feature that never got integrated into the recovery flow
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-08 19:04] - Task 3: Remove unused builtinMcps export from MCP module
+
+### DISCOVERED ISSUES
+- None - `builtinMcps` export was genuinely unused (no external importers)
+
+### IMPLEMENTATION DECISIONS
+- Removed `export const builtinMcps = allBuiltinMcps` from line 24
+- Kept `allBuiltinMcps` const - used internally by `createBuiltinMcps` function
+- Kept `createBuiltinMcps` function - actively used in src/index.ts:89
+
+### PROBLEMS FOR NEXT TASKS
+- None identified
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, bundled 200 modules
+- Ran: `rg "builtinMcps" src/mcp/index.ts` → no matches (export removed)
+- Ran: `rg "createBuiltinMcps" src/mcp/index.ts` → function still exists
+
+### LEARNINGS
+- `createBuiltinMcps` function vs `builtinMcps` export - function is used, direct export is not
+- Internal const `allBuiltinMcps` should be kept since it's referenced by the function
+
+소요 시간: ~2분
+
+---
+
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "oh-my-opencode",
-  "version": "0.1.26",
+  "version": "0.1.31",
  "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
@@ -44,13 +44,14 @@
  "dependencies": {
    "@ast-grep/cli": "^0.40.0",
    "@ast-grep/napi": "^0.40.0",
-    "@code-yeongyu/comment-checker": "^0.4.1",
+    "@code-yeongyu/comment-checker": "^0.4.4",
    "@opencode-ai/plugin": "^1.0.7",
    "xdg-basedir": "^5.1.0",
    "zod": "^4.1.8"
  },
  "devDependencies": {
    "bun-types": "latest",
+    "oh-my-opencode": "^0.1.30",
    "typescript": "^5.7.3"
  },
  "peerDependencies": {
--- a/src/hooks/anthropic-auto-compact/executor.ts
+++ b/src/hooks/anthropic-auto-compact/executor.ts
@@ -0,0 +1,74 @@
+import type { AutoCompactState } from "./types"
+
+type Client = {
+  session: {
+    messages: (opts: { path: { id: string }; query?: { directory?: string } }) => Promise<unknown>
+    summarize: (opts: {
+      path: { id: string }
+      body: { providerID: string; modelID: string }
+      query: { directory: string }
+    }) => Promise<unknown>
+  }
+  tui: {
+    submitPrompt: (opts: { query: { directory: string } }) => Promise<unknown>
+  }
+}
+
+export async function getLastAssistant(
+  sessionID: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  client: any,
+  directory: string
+): Promise<Record<string, unknown> | null> {
+  try {
+    const resp = await (client as Client).session.messages({
+      path: { id: sessionID },
+      query: { directory },
+    })
+
+    const data = (resp as { data?: unknown[] }).data
+    if (!Array.isArray(data)) return null
+
+    const reversed = [...data].reverse()
+    const last = reversed.find((m) => {
+      const msg = m as Record<string, unknown>
+      const info = msg.info as Record<string, unknown> | undefined
+      return info?.role === "assistant"
+    })
+    if (!last) return null
+    return (last as { info?: Record<string, unknown> }).info ?? null
+  } catch {
+    return null
+  }
+}
+
+export async function executeCompact(
+  sessionID: string,
+  msg: Record<string, unknown>,
+  autoCompactState: AutoCompactState,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  client: any,
+  directory: string
+): Promise<void> {
+  try {
+    const providerID = msg.providerID as string | undefined
+    const modelID = msg.modelID as string | undefined
+
+    if (providerID && modelID) {
+      await (client as Client).session.summarize({
+        path: { id: sessionID },
+        body: { providerID, modelID },
+        query: { directory },
+      })
+
+      setTimeout(async () => {
+        try {
+          await (client as Client).tui.submitPrompt({ query: { directory } })
+        } catch {}
+      }, 500)
+    }
+
+    autoCompactState.pendingCompact.delete(sessionID)
+    autoCompactState.errorDataBySession.delete(sessionID)
+  } catch {}
+}
--- a/src/hooks/anthropic-auto-compact/index.ts
+++ b/src/hooks/anthropic-auto-compact/index.ts
@@ -0,0 +1,123 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import type { AutoCompactState, ParsedTokenLimitError } from "./types"
+import { parseAnthropicTokenLimitError } from "./parser"
+import { executeCompact, getLastAssistant } from "./executor"
+
+function createAutoCompactState(): AutoCompactState {
+  return {
+    pendingCompact: new Set<string>(),
+    errorDataBySession: new Map<string, ParsedTokenLimitError>(),
+  }
+}
+
+export function createAnthropicAutoCompactHook(ctx: PluginInput) {
+  const autoCompactState = createAutoCompactState()
+
+  const eventHandler = async ({ event }: { event: { type: string; properties?: unknown } }) => {
+    const props = event.properties as Record<string, unknown> | undefined
+
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info as { id?: string } | undefined
+      if (sessionInfo?.id) {
+        autoCompactState.pendingCompact.delete(sessionInfo.id)
+        autoCompactState.errorDataBySession.delete(sessionInfo.id)
+      }
+      return
+    }
+
+    if (event.type === "session.error") {
+      const sessionID = props?.sessionID as string | undefined
+      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 as Record<string, unknown> | undefined
+      const sessionID = info?.sessionID as string | undefined
+
+      if (sessionID && info?.role === "assistant" && info.error) {
+        const parsed = parseAnthropicTokenLimitError(info.error)
+        if (parsed) {
+          parsed.providerID = info.providerID as string | undefined
+          parsed.modelID = info.modelID as string | undefined
+          autoCompactState.pendingCompact.add(sessionID)
+          autoCompactState.errorDataBySession.set(sessionID, parsed)
+        }
+      }
+      return
+    }
+
+    if (event.type === "session.idle") {
+      const sessionID = props?.sessionID as string | undefined
+      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" as const,
+              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" as const,
+            duration: 3000,
+          },
+        })
+        .catch(() => {})
+
+      await executeCompact(sessionID, lastAssistant, autoCompactState, ctx.client, ctx.directory)
+    }
+  }
+
+  return {
+    event: eventHandler,
+  }
+}
+
+export type { AutoCompactState, ParsedTokenLimitError } from "./types"
+export { parseAnthropicTokenLimitError } from "./parser"
+export { executeCompact, getLastAssistant } from "./executor"
--- a/src/hooks/anthropic-auto-compact/parser.ts
+++ b/src/hooks/anthropic-auto-compact/parser.ts
@@ -0,0 +1,154 @@
+import type { ParsedTokenLimitError } from "./types"
+
+interface AnthropicErrorData {
+  type: "error"
+  error: {
+    type: string
+    message: string
+  }
+  request_id?: string
+}
+
+const 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,
+]
+
+const 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: string): { current: number; max: number } | null {
+  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: string): boolean {
+  const lower = text.toLowerCase()
+  return TOKEN_LIMIT_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()))
+}
+
+export function parseAnthropicTokenLimitError(err: unknown): ParsedTokenLimitError | null {
+  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 as Record<string, unknown>
+
+  const dataObj = errObj.data as Record<string, unknown> | undefined
+  const responseBody = dataObj?.responseBody
+  const errorMessage = errObj.message as string | undefined
+  const errorData = errObj.error as Record<string, unknown> | undefined
+  const nestedError = errorData?.error as Record<string, unknown> | undefined
+
+  const textSources: string[] = []
+
+  if (typeof responseBody === "string") textSources.push(responseBody)
+  if (typeof errorMessage === "string") textSources.push(errorMessage)
+  if (typeof errorData?.message === "string") textSources.push(errorData.message as string)
+  if (typeof errObj.body === "string") textSources.push(errObj.body as string)
+  if (typeof errObj.details === "string") textSources.push(errObj.details as string)
+  if (typeof errObj.reason === "string") textSources.push(errObj.reason as string)
+  if (typeof errObj.description === "string") textSources.push(errObj.description as string)
+  if (typeof nestedError?.message === "string") textSources.push(nestedError.message as string)
+  if (typeof dataObj?.message === "string") textSources.push(dataObj.message as string)
+  if (typeof dataObj?.error === "string") textSources.push(dataObj.error as string)
+
+  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: AnthropicErrorData = 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
+}
--- a/src/hooks/anthropic-auto-compact/types.ts
+++ b/src/hooks/anthropic-auto-compact/types.ts
@@ -0,0 +1,13 @@
+export interface ParsedTokenLimitError {
+  currentTokens: number
+  maxTokens: number
+  requestId?: string
+  errorType: string
+  providerID?: string
+  modelID?: string
+}
+
+export interface AutoCompactState {
+  pendingCompact: Set<string>
+  errorDataBySession: Map<string, ParsedTokenLimitError>
+}
--- a/src/hooks/comment-checker/cli.ts
+++ b/src/hooks/comment-checker/cli.ts
@@ -15,36 +15,13 @@ function debugLog(...args: unknown[]) {
  }
 }

-type Platform = "darwin" | "linux" | "win32" | "unsupported"
-
-function getPlatformPackageName(): string | null {
-  const platform = process.platform as Platform
-  const arch = process.arch
-
-  const platformMap: Record<string, string> = {
-    "darwin-arm64": "@code-yeongyu/comment-checker-darwin-arm64",
-    "darwin-x64": "@code-yeongyu/comment-checker-darwin-x64",
-    "linux-arm64": "@code-yeongyu/comment-checker-linux-arm64",
-    "linux-x64": "@code-yeongyu/comment-checker-linux-x64",
-    "win32-x64": "@code-yeongyu/comment-checker-windows-x64",
-  }
-
-  return platformMap[`${platform}-${arch}`] ?? null
-}
-
 function getBinaryName(): string {
  return process.platform === "win32" ? "comment-checker.exe" : "comment-checker"
 }

-/**
- * Synchronously find comment-checker binary path.
- * Checks installed packages, homebrew, cache, and system PATH.
- * Does NOT trigger download.
- */
 function findCommentCheckerPathSync(): string | null {
  const binaryName = getBinaryName()

-  // 1. Try to find from @code-yeongyu/comment-checker package
  try {
    const require = createRequire(import.meta.url)
    const cliPkgPath = require.resolve("@code-yeongyu/comment-checker/package.json")
@@ -59,46 +36,12 @@ function findCommentCheckerPathSync(): string | null {
    debugLog("main package not installed")
  }

-  // 2. Try platform-specific package directly (legacy, for backwards compatibility)
-  const platformPkg = getPlatformPackageName()
-  if (platformPkg) {
-    try {
-      const require = createRequire(import.meta.url)
-      const pkgPath = require.resolve(`${platformPkg}/package.json`)
-      const pkgDir = dirname(pkgPath)
-      const binaryPath = join(pkgDir, "bin", binaryName)
-
-      if (existsSync(binaryPath)) {
-        debugLog("found binary in platform package:", binaryPath)
-        return binaryPath
-      }
-    } catch {
-      debugLog("platform package not installed:", platformPkg)
-    }
-  }
-
-  // 3. Try homebrew installation (macOS)
-  if (process.platform === "darwin") {
-    const homebrewPaths = [
-      "/opt/homebrew/bin/comment-checker",
-      "/usr/local/bin/comment-checker",
-    ]
-    for (const path of homebrewPaths) {
-      if (existsSync(path)) {
-        debugLog("found binary via homebrew:", path)
-        return path
-      }
-    }
-  }
-
-  // 4. Try cached binary (lazy download location)
  const cachedPath = getCachedBinaryPath()
  if (cachedPath) {
    debugLog("found binary in cache:", cachedPath)
    return cachedPath
  }

-  // 5. Try system PATH (as fallback)
  debugLog("no binary found in known locations")
  return null
 }
--- a/src/hooks/comment-checker/constants.ts
+++ b/src/hooks/comment-checker/constants.ts
@@ -72,6 +72,10 @@ PRIORITY-BASED ACTION GUIDELINES:
 \t-> Make the code itself clearer so it can be understood without comments/docstrings.
 \t-> For verbose docstrings: refactor code to be self-documenting instead of adding lengthy explanations.

+CODE SMELL WARNING: Using comments as visual separators (e.g., "// =========", "# ---", "// *** Section ***")
+is a code smell. If you need separators, your file is too long or poorly organized.
+Refactor into smaller modules or use proper code organization instead of comment-based section dividers.
+
 MANDATORY REQUIREMENT: You must acknowledge this hook message and take one of the above actions.
 Review in the above priority order and take the corresponding action EVERY TIME this appears.

--- a/src/hooks/directory-agents-injector/constants.ts
+++ b/src/hooks/directory-agents-injector/constants.ts
@@ -0,0 +1,9 @@
+import { join } from "node:path";
+import { xdgData } from "xdg-basedir";
+
+export const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
+export const AGENTS_INJECTOR_STORAGE = join(
+  OPENCODE_STORAGE,
+  "directory-agents",
+);
+export const AGENTS_FILENAME = "AGENTS.md";
--- a/src/hooks/directory-agents-injector/index.ts
+++ b/src/hooks/directory-agents-injector/index.ts
@@ -0,0 +1,126 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import {
+  loadInjectedPaths,
+  saveInjectedPaths,
+  clearInjectedPaths,
+} from "./storage";
+import { AGENTS_FILENAME } from "./constants";
+
+interface ToolExecuteInput {
+  tool: string;
+  sessionID: string;
+  callID: string;
+}
+
+interface ToolExecuteOutput {
+  title: string;
+  output: string;
+  metadata: unknown;
+}
+
+interface EventInput {
+  event: {
+    type: string;
+    properties?: unknown;
+  };
+}
+
+export function createDirectoryAgentsInjectorHook(ctx: PluginInput) {
+  const sessionCaches = new Map<string, Set<string>>();
+
+  function getSessionCache(sessionID: string): Set<string> {
+    if (!sessionCaches.has(sessionID)) {
+      sessionCaches.set(sessionID, loadInjectedPaths(sessionID));
+    }
+    return sessionCaches.get(sessionID)!;
+  }
+
+  function resolveFilePath(title: string): string | null {
+    if (!title) return null;
+    if (title.startsWith("/")) return title;
+    return resolve(ctx.directory, title);
+  }
+
+  function findAgentsMdUp(startDir: string): string[] {
+    const found: string[] = [];
+    let current = startDir;
+
+    while (true) {
+      const agentsPath = join(current, AGENTS_FILENAME);
+      if (existsSync(agentsPath)) {
+        found.push(agentsPath);
+      }
+
+      if (current === ctx.directory) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      if (!parent.startsWith(ctx.directory)) break;
+      current = parent;
+    }
+
+    return found.reverse();
+  }
+
+  const toolExecuteAfter = async (
+    input: ToolExecuteInput,
+    output: ToolExecuteOutput,
+  ) => {
+    if (input.tool.toLowerCase() !== "read") return;
+
+    const filePath = resolveFilePath(output.title);
+    if (!filePath) return;
+
+    const dir = dirname(filePath);
+    const cache = getSessionCache(input.sessionID);
+    const agentsPaths = findAgentsMdUp(dir);
+
+    const toInject: { path: string; content: string }[] = [];
+
+    for (const agentsPath of agentsPaths) {
+      const agentsDir = dirname(agentsPath);
+      if (cache.has(agentsDir)) continue;
+
+      try {
+        const content = readFileSync(agentsPath, "utf-8");
+        toInject.push({ path: agentsPath, content });
+        cache.add(agentsDir);
+      } catch {}
+    }
+
+    if (toInject.length === 0) return;
+
+    for (const { path, content } of toInject) {
+      output.output += `\n\n[Directory Context: ${path}]\n${content}`;
+    }
+
+    saveInjectedPaths(input.sessionID, cache);
+  };
+
+  const eventHandler = async ({ event }: EventInput) => {
+    const props = event.properties as Record<string, unknown> | undefined;
+
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info as { id?: string } | undefined;
+      if (sessionInfo?.id) {
+        sessionCaches.delete(sessionInfo.id);
+        clearInjectedPaths(sessionInfo.id);
+      }
+    }
+
+    if (event.type === "session.compacted") {
+      const sessionID = (props?.sessionID ??
+        (props?.info as { id?: string } | undefined)?.id) as string | undefined;
+      if (sessionID) {
+        sessionCaches.delete(sessionID);
+        clearInjectedPaths(sessionID);
+      }
+    }
+  };
+
+  return {
+    "tool.execute.after": toolExecuteAfter,
+    event: eventHandler,
+  };
+}
--- a/src/hooks/directory-agents-injector/storage.ts
+++ b/src/hooks/directory-agents-injector/storage.ts
@@ -0,0 +1,48 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+import { AGENTS_INJECTOR_STORAGE } from "./constants";
+import type { InjectedPathsData } from "./types";
+
+function getStoragePath(sessionID: string): string {
+  return join(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
+}
+
+export function loadInjectedPaths(sessionID: string): Set<string> {
+  const filePath = getStoragePath(sessionID);
+  if (!existsSync(filePath)) return new Set();
+
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const data: InjectedPathsData = JSON.parse(content);
+    return new Set(data.injectedPaths);
+  } catch {
+    return new Set();
+  }
+}
+
+export function saveInjectedPaths(sessionID: string, paths: Set<string>): void {
+  if (!existsSync(AGENTS_INJECTOR_STORAGE)) {
+    mkdirSync(AGENTS_INJECTOR_STORAGE, { recursive: true });
+  }
+
+  const data: InjectedPathsData = {
+    sessionID,
+    injectedPaths: [...paths],
+    updatedAt: Date.now(),
+  };
+
+  writeFileSync(getStoragePath(sessionID), JSON.stringify(data, null, 2));
+}
+
+export function clearInjectedPaths(sessionID: string): void {
+  const filePath = getStoragePath(sessionID);
+  if (existsSync(filePath)) {
+    unlinkSync(filePath);
+  }
+}
--- a/src/hooks/directory-agents-injector/types.ts
+++ b/src/hooks/directory-agents-injector/types.ts
@@ -0,0 +1,5 @@
+export interface InjectedPathsData {
+  sessionID: string;
+  injectedPaths: string[];
+  updatedAt: number;
+}
--- a/src/hooks/empty-task-response-detector.ts
+++ b/src/hooks/empty-task-response-detector.ts
@@ -0,0 +1,27 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+
+const EMPTY_RESPONSE_WARNING = `[Task Empty Response Warning]
+
+Task invocation completed but returned no response. This indicates the agent either:
+- Failed to execute properly
+- Did not terminate correctly
+- Returned an empty result
+
+Note: The call has already completed - you are NOT waiting for a response. Proceed accordingly.`
+
+export function createEmptyTaskResponseDetectorHook(_ctx: PluginInput) {
+  return {
+    "tool.execute.after": async (
+      input: { tool: string; sessionID: string; callID: string },
+      output: { title: string; output: string; metadata: unknown }
+    ) => {
+      if (input.tool !== "Task") return
+
+      const responseText = output.output?.trim() ?? ""
+
+      if (responseText === "") {
+        output.output = EMPTY_RESPONSE_WARNING
+      }
+    },
+  }
+}
--- a/src/hooks/grep-blocker.ts
+++ b/src/hooks/grep-blocker.ts
@@ -1,18 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-
-const BLOCKED_MESSAGE =
-  "Error: [BLOCKED] grep has no timeout and can freeze the system. " +
-  "It is permanently disabled. Use 'safe_grep' instead."
-
-export function createGrepBlocker(_ctx: PluginInput) {
-  return {
-    "tool.execute.before": async (
-      input: { tool: string; sessionID: string; callID: string },
-      _output: { args: unknown }
-    ) => {
-      if (input.tool === "grep") {
-        throw new Error(BLOCKED_MESSAGE)
-      }
-    },
-  }
-}
--- a/src/hooks/index.ts
+++ b/src/hooks/index.ts
@@ -1,7 +1,9 @@
-export { createTodoContinuationEnforcer } from "./todo-continuation-enforcer"
-export { createContextWindowMonitorHook } from "./context-window-monitor"
-export { createSessionNotification } from "./session-notification"
-export { createSessionRecoveryHook } from "./session-recovery"
-export { createCommentCheckerHooks } from "./comment-checker"
-export { createGrepOutputTruncatorHook } from "./grep-output-truncator"
-export { createPulseMonitorHook } from "./pulse-monitor"
+export { createTodoContinuationEnforcer } from "./todo-continuation-enforcer";
+export { createContextWindowMonitorHook } from "./context-window-monitor";
+export { createSessionNotification } from "./session-notification";
+export { createSessionRecoveryHook } from "./session-recovery";
+export { createCommentCheckerHooks } from "./comment-checker";
+export { createGrepOutputTruncatorHook } from "./grep-output-truncator";
+export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";
+export { createEmptyTaskResponseDetectorHook } from "./empty-task-response-detector";
+export { createAnthropicAutoCompactHook } from "./anthropic-auto-compact";
--- a/src/hooks/pulse-monitor.ts
+++ b/src/hooks/pulse-monitor.ts
@@ -1,142 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-
-export function createPulseMonitorHook(ctx: PluginInput) {
-  const STANDARD_TIMEOUT = 5 * 60 * 1000 // 5 minutes
-  const THINKING_TIMEOUT = 5 * 60 * 1000 // 5 minutes
-  const CHECK_INTERVAL = 5 * 1000 // 5 seconds
-  
-  let lastHeartbeat = Date.now()
-  let isMonitoring = false
-  let currentSessionID: string | null = null
-  let monitorTimer: ReturnType<typeof setInterval> | null = null
-  let isThinking = false
-  
-  const startMonitoring = (sessionID: string) => {
-    if (currentSessionID !== sessionID) {
-      currentSessionID = sessionID
-      // Reset thinking state when switching sessions or starting new
-      isThinking = false
-    }
-    
-    lastHeartbeat = Date.now()
-    
-    if (!isMonitoring) {
-      isMonitoring = true
-      if (monitorTimer) clearInterval(monitorTimer)
-      
-      monitorTimer = setInterval(async () => {
-        if (!isMonitoring || !currentSessionID) return
-        
-        const timeSinceLastHeartbeat = Date.now() - lastHeartbeat
-        const currentTimeout = isThinking ? THINKING_TIMEOUT : STANDARD_TIMEOUT
-        
-        if (timeSinceLastHeartbeat > currentTimeout) {
-          await recoverStalledSession(currentSessionID, timeSinceLastHeartbeat, isThinking)
-        }
-      }, CHECK_INTERVAL)
-    }
-  }
-  
-  const stopMonitoring = () => {
-    isMonitoring = false
-    if (monitorTimer) {
-      clearInterval(monitorTimer)
-      monitorTimer = null
-    }
-  }
-  
-  const updateHeartbeat = (isThinkingUpdate?: boolean) => {
-    if (isMonitoring) {
-      lastHeartbeat = Date.now()
-      if (isThinkingUpdate !== undefined) {
-        isThinking = isThinkingUpdate
-      }
-    }
-  }
-  
-  const recoverStalledSession = async (sessionID: string, stalledDuration: number, wasThinking: boolean) => {
-    stopMonitoring()
-    
-    try {
-      const durationSec = Math.round(stalledDuration/1000)
-      const typeStr = wasThinking ? "Thinking" : "Standard"
-      
-      // 1. Notify User
-      await ctx.client.tui.showToast({
-        body: {
-            title: "Pulse Monitor: Cardiac Arrest",
-            message: `Session stalled (${typeStr}) for ${durationSec}s. Defibrillating...`,
-            variant: "error",
-            duration: 5000
-        }
-      }).catch(() => {})
-      
-      // 2. Abort current generation (Defibrillation shock)
-      await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {})
-      
-      // 3. Wait a bit for state to settle
-      await new Promise(resolve => setTimeout(resolve, 1500))
-      
-      // 4. Prompt "continue" to kickstart (CPR)
-      await ctx.client.session.prompt({
-        path: { id: sessionID },
-        body: { parts: [{ type: "text", text: "The connection was unstable and stalled. Please continue from where you left off." }] },
-        query: { directory: ctx.directory }
-      })
-      
-      // Resume monitoring
-      startMonitoring(sessionID)
-      
-    } catch (err) {
-      console.error("[PulseMonitor] Recovery failed:", err)
-      // If recovery fails, we stop monitoring to avoid loops
-      stopMonitoring()
-    }
-  }
-
-  return {
-    event: async (input: { event: any }) => {
-      const { event } = input
-      const props = event.properties as Record<string, any> | undefined
-      
-      // Monitor both session updates and part updates to capture token flow
-      if (event.type === "session.updated" || event.type === "message.part.updated") {
-        // Try to get sessionID from various common locations
-        const sessionID = props?.info?.id || props?.sessionID
-        
-        if (sessionID) {
-            if (!isMonitoring) startMonitoring(sessionID)
-            
-            // Check for thinking indicators in the payload
-            let thinkingUpdate: boolean | undefined = undefined
-            
-            if (event.type === "message.part.updated") {
-                const part = props?.part
-                if (part) {
-                    const THINKING_TYPES = ["thinking", "redacted_thinking", "reasoning"]
-                    if (THINKING_TYPES.includes(part.type)) {
-                        thinkingUpdate = true
-                    } else if (part.type === "text" || part.type === "tool_use") {
-                        thinkingUpdate = false
-                    }
-                }
-            }
-            
-            updateHeartbeat(thinkingUpdate)
-        }
-      } else if (event.type === "session.idle" || event.type === "session.error" || event.type === "session.stopped") {
-        stopMonitoring()
-      }
-    },
-    "tool.execute.before": async () => {
-        // Pause monitoring while tool runs locally (tools can take time)
-        stopMonitoring()
-    },
-    "tool.execute.after": async (input: { sessionID: string }) => {
-        // Resume monitoring after tool finishes
-        if (input.sessionID) {
-            startMonitoring(input.sessionID)
-        }
-    }
-  }
-}
--- a/src/hooks/session-recovery.ts
+++ b/src/hooks/session-recovery.ts
@@ -1,552 +0,0 @@
-/**
- * Session Recovery - Message State Error Recovery
- *
- * Handles FOUR specific scenarios:
- * 1. tool_use block exists without tool_result
- *    - Recovery: inject tool_result with "cancelled" content
- *
- * 2. Thinking block order violation (first block must be thinking)
- *    - Recovery: prepend empty thinking block
- *
- * 3. Thinking disabled but message contains thinking blocks
- *    - Recovery: strip thinking/redacted_thinking blocks
- *
- * 4. Empty content message (non-empty content required)
- *    - Recovery: inject text part directly via filesystem
- */
-
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
-import { xdgData } from "xdg-basedir"
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { createOpencodeClient } from "@opencode-ai/sdk"
-
-type Client = ReturnType<typeof createOpencodeClient>
-
-const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage")
-const MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message")
-const PART_STORAGE = join(OPENCODE_STORAGE, "part")
-
-type RecoveryErrorType = "tool_result_missing" | "thinking_block_order" | "thinking_disabled_violation" | "empty_content_message" | null
-
-interface MessageInfo {
-  id?: string
-  role?: string
-  sessionID?: string
-  parentID?: string
-  error?: unknown
-}
-
-interface ToolUsePart {
-  type: "tool_use"
-  id: string
-  name: string
-  input: Record<string, unknown>
-}
-
-interface ThinkingPart {
-  type: "thinking"
-  thinking: string
-}
-
-interface MessagePart {
-  type: string
-  id?: string
-  text?: string
-  thinking?: string
-  name?: string
-  input?: Record<string, unknown>
-}
-
-interface MessageData {
-  info?: MessageInfo
-  parts?: MessagePart[]
-}
-
-function getErrorMessage(error: unknown): string {
-  if (!error) return ""
-  if (typeof error === "string") return error.toLowerCase()
-  const errorObj = error as { data?: { message?: string }; message?: string }
-  return (errorObj.data?.message || errorObj.message || "").toLowerCase()
-}
-
-function detectErrorType(error: unknown): RecoveryErrorType {
-  const message = getErrorMessage(error)
-
-  if (message.includes("tool_use") && message.includes("tool_result")) {
-    return "tool_result_missing"
-  }
-
-  if (
-    message.includes("thinking") &&
-    (message.includes("first block") || message.includes("must start with") || message.includes("preceeding"))
-  ) {
-    return "thinking_block_order"
-  }
-
-  if (message.includes("thinking is disabled") && message.includes("cannot contain")) {
-    return "thinking_disabled_violation"
-  }
-
-  if (message.includes("non-empty content") || message.includes("must have non-empty content")) {
-    return "empty_content_message"
-  }
-
-  return null
-}
-
-function extractToolUseIds(parts: MessagePart[]): string[] {
-  return parts.filter((p): p is ToolUsePart => p.type === "tool_use" && !!p.id).map((p) => p.id)
-}
-
-async function recoverToolResultMissing(
-  client: Client,
-  sessionID: string,
-  failedAssistantMsg: MessageData
-): Promise<boolean> {
-  const parts = failedAssistantMsg.parts || []
-  const toolUseIds = extractToolUseIds(parts)
-
-  if (toolUseIds.length === 0) {
-    return false
-  }
-
-  const toolResultParts = toolUseIds.map((id) => ({
-    type: "tool_result" as const,
-    tool_use_id: id,
-    content: "Operation cancelled by user (ESC pressed)",
-  }))
-
-  try {
-    await client.session.prompt({
-      path: { id: sessionID },
-      // @ts-expect-error - SDK types may not include tool_result parts, but runtime accepts it
-      body: { parts: toolResultParts },
-    })
-
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function recoverThinkingBlockOrder(
-  client: Client,
-  sessionID: string,
-  failedAssistantMsg: MessageData,
-  directory: string
-): Promise<boolean> {
-  const messageID = failedAssistantMsg.info?.id
-  if (!messageID) {
-    return false
-  }
-
-  const existingParts = failedAssistantMsg.parts || []
-  const patchedParts: MessagePart[] = [{ type: "thinking", thinking: "" } as ThinkingPart, ...existingParts]
-
-  try {
-    // @ts-expect-error - Experimental API
-    await client.message?.update?.({
-      path: { id: messageID },
-      body: { parts: patchedParts },
-    })
-
-    return true
-  } catch {
-    // message.update not available
-  }
-
-  try {
-    // @ts-expect-error - Experimental API
-    await client.session.patch?.({
-      path: { id: sessionID },
-      body: {
-        messageID,
-        parts: patchedParts,
-      },
-    })
-
-    return true
-  } catch {
-    // session.patch not available
-  }
-
-  return await fallbackRevertStrategy(client, sessionID, failedAssistantMsg, directory)
-}
-
-async function recoverThinkingDisabledViolation(
-  client: Client,
-  sessionID: string,
-  failedAssistantMsg: MessageData
-): Promise<boolean> {
-  const messageID = failedAssistantMsg.info?.id
-  if (!messageID) {
-    return false
-  }
-
-  const existingParts = failedAssistantMsg.parts || []
-  const strippedParts = existingParts.filter((p) => p.type !== "thinking" && p.type !== "redacted_thinking")
-
-  if (strippedParts.length === 0) {
-    return false
-  }
-
-  try {
-    // @ts-expect-error - Experimental API
-    await client.message?.update?.({
-      path: { id: messageID },
-      body: { parts: strippedParts },
-    })
-
-    return true
-  } catch {
-    // message.update not available
-  }
-
-  try {
-    // @ts-expect-error - Experimental API
-    await client.session.patch?.({
-      path: { id: sessionID },
-      body: {
-        messageID,
-        parts: strippedParts,
-      },
-    })
-
-    return true
-  } catch {
-    // session.patch not available
-  }
-
-  return false
-}
-
-const THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"])
-const META_TYPES = new Set(["step-start", "step-finish"])
-
-interface StoredMessageMeta {
-  id: string
-  sessionID: string
-  role: string
-  parentID?: string
-}
-
-interface StoredPart {
-  id: string
-  sessionID: string
-  messageID: string
-  type: string
-  text?: string
-}
-
-function generatePartId(): string {
-  const timestamp = Date.now().toString(16)
-  const random = Math.random().toString(36).substring(2, 10)
-  return `prt_${timestamp}${random}`
-}
-
-function getMessageDir(sessionID: string): string {
-  const projectHash = readdirSync(MESSAGE_STORAGE).find((dir) => {
-    const sessionDir = join(MESSAGE_STORAGE, dir)
-    try {
-      return readdirSync(sessionDir).some((f) => f.includes(sessionID.replace("ses_", "")))
-    } catch {
-      return false
-    }
-  })
-
-  if (projectHash) {
-    return join(MESSAGE_STORAGE, projectHash, sessionID)
-  }
-
-  for (const dir of readdirSync(MESSAGE_STORAGE)) {
-    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
-    if (existsSync(sessionPath)) {
-      return sessionPath
-    }
-  }
-
-  return ""
-}
-
-function readMessagesFromStorage(sessionID: string): StoredMessageMeta[] {
-  const messageDir = getMessageDir(sessionID)
-  if (!messageDir || !existsSync(messageDir)) return []
-
-  const messages: StoredMessageMeta[] = []
-  for (const file of readdirSync(messageDir)) {
-    if (!file.endsWith(".json")) continue
-    try {
-      const content = readFileSync(join(messageDir, file), "utf-8")
-      messages.push(JSON.parse(content))
-    } catch {
-      continue
-    }
-  }
-
-  return messages.sort((a, b) => a.id.localeCompare(b.id))
-}
-
-function readPartsFromStorage(messageID: string): StoredPart[] {
-  const partDir = join(PART_STORAGE, messageID)
-  if (!existsSync(partDir)) return []
-
-  const parts: StoredPart[] = []
-  for (const file of readdirSync(partDir)) {
-    if (!file.endsWith(".json")) continue
-    try {
-      const content = readFileSync(join(partDir, file), "utf-8")
-      parts.push(JSON.parse(content))
-    } catch {
-      continue
-    }
-  }
-
-  return parts
-}
-
-function injectTextPartToStorage(sessionID: string, messageID: string, text: string): boolean {
-  const partDir = join(PART_STORAGE, messageID)
-
-  if (!existsSync(partDir)) {
-    mkdirSync(partDir, { recursive: true })
-  }
-
-  const partId = generatePartId()
-  const part: StoredPart = {
-    id: partId,
-    sessionID,
-    messageID,
-    type: "text",
-    text,
-  }
-
-  try {
-    writeFileSync(join(partDir, `${partId}.json`), JSON.stringify(part, null, 2))
-    return true
-  } catch {
-    return false
-  }
-}
-
-function findEmptyContentMessageFromStorage(sessionID: string): string | null {
-  const messages = readMessagesFromStorage(sessionID)
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i]
-    if (msg.role !== "assistant") continue
-
-    const isLastMessage = i === messages.length - 1
-    if (isLastMessage) continue
-
-    const parts = readPartsFromStorage(msg.id)
-    const hasContent = parts.some((p) => {
-      if (THINKING_TYPES.has(p.type)) return false
-      if (META_TYPES.has(p.type)) return false
-      if (p.type === "text" && p.text?.trim()) return true
-      if (p.type === "tool_use") return true
-      if (p.type === "tool_result") return true
-      return false
-    })
-
-    if (!hasContent && parts.length > 0) {
-      return msg.id
-    }
-  }
-
-  return null
-}
-
-function hasNonEmptyOutput(msg: MessageData): boolean {
-  const parts = msg.parts
-  if (!parts || parts.length === 0) return false
-
-  return parts.some((p) => {
-    if (THINKING_TYPES.has(p.type)) return false
-    if (p.type === "step-start" || p.type === "step-finish") return false
-    if (p.type === "text" && p.text && p.text.trim()) return true
-    if (p.type === "tool_use" && p.id) return true
-    if (p.type === "tool_result") return true
-    return false
-  })
-}
-
-function findEmptyContentMessage(msgs: MessageData[]): MessageData | null {
-  for (let i = 0; i < msgs.length; i++) {
-    const msg = msgs[i]
-    const isLastMessage = i === msgs.length - 1
-    const isAssistant = msg.info?.role === "assistant"
-
-    if (isLastMessage && isAssistant) continue
-
-    if (!hasNonEmptyOutput(msg)) {
-      return msg
-    }
-  }
-  return null
-}
-
-async function recoverEmptyContentMessage(
-  _client: Client,
-  sessionID: string,
-  failedAssistantMsg: MessageData,
-  _directory: string
-): Promise<boolean> {
-  const emptyMessageID = findEmptyContentMessageFromStorage(sessionID) || failedAssistantMsg.info?.id
-  if (!emptyMessageID) return false
-
-  return injectTextPartToStorage(sessionID, emptyMessageID, "(interrupted)")
-}
-
-async function fallbackRevertStrategy(
-  client: Client,
-  sessionID: string,
-  failedAssistantMsg: MessageData,
-  directory: string
-): Promise<boolean> {
-  const parentMsgID = failedAssistantMsg.info?.parentID
-
-  const messagesResp = await client.session.messages({
-    path: { id: sessionID },
-    query: { directory },
-  })
-  const msgs = (messagesResp as { data?: MessageData[] }).data
-  if (!msgs || msgs.length === 0) {
-    return false
-  }
-
-  let targetUserMsg: MessageData | null = null
-  if (parentMsgID) {
-    targetUserMsg = msgs.find((m) => m.info?.id === parentMsgID) ?? null
-  }
-  if (!targetUserMsg) {
-    for (let i = msgs.length - 1; i >= 0; i--) {
-      if (msgs[i].info?.role === "user") {
-        targetUserMsg = msgs[i]
-        break
-      }
-    }
-  }
-
-  if (!targetUserMsg?.parts?.length) {
-    return false
-  }
-
-  await client.session.revert({
-    path: { id: sessionID },
-    body: { messageID: targetUserMsg.info?.id ?? "" },
-    query: { directory },
-  })
-
-  const textParts = targetUserMsg.parts
-    .filter((p) => p.type === "text" && p.text)
-    .map((p) => ({ type: "text" as const, text: p.text ?? "" }))
-
-  if (textParts.length === 0) {
-    return false
-  }
-
-  await client.session.prompt({
-    path: { id: sessionID },
-    body: { parts: textParts },
-    query: { directory },
-  })
-
-  return true
-}
-
-export function createSessionRecoveryHook(ctx: PluginInput) {
-  const processingErrors = new Set<string>()
-  let onAbortCallback: ((sessionID: string) => void) | null = null
-
-  const setOnAbortCallback = (callback: (sessionID: string) => void): void => {
-    onAbortCallback = callback
-  }
-
-  const isRecoverableError = (error: unknown): boolean => {
-    return detectErrorType(error) !== null
-  }
-
-  const handleSessionRecovery = async (info: MessageInfo): Promise<boolean> => {
-    if (!info || info.role !== "assistant" || !info.error) return false
-
-    const errorType = detectErrorType(info.error)
-    if (!errorType) return false
-
-    const sessionID = info.sessionID
-    const assistantMsgID = info.id
-
-    if (!sessionID || !assistantMsgID) return false
-    if (processingErrors.has(assistantMsgID)) return false
-    processingErrors.add(assistantMsgID)
-
-    try {
-      await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {})
-
-      if (onAbortCallback) {
-        onAbortCallback(sessionID)
-      }
-
-      const messagesResp = await ctx.client.session.messages({
-        path: { id: sessionID },
-        query: { directory: ctx.directory },
-      })
-      const msgs = (messagesResp as { data?: MessageData[] }).data
-
-      const failedMsg = msgs?.find((m) => m.info?.id === assistantMsgID)
-      if (!failedMsg) {
-        return false
-      }
-
-      const toastTitles: Record<RecoveryErrorType & string, string> = {
-        tool_result_missing: "Tool Crash Recovery",
-        thinking_block_order: "Thinking Block Recovery",
-        thinking_disabled_violation: "Thinking Strip Recovery",
-        empty_content_message: "Empty Message Recovery",
-      }
-      const toastMessages: Record<RecoveryErrorType & string, string> = {
-        tool_result_missing: "Injecting cancelled tool results...",
-        thinking_block_order: "Fixing message structure...",
-        thinking_disabled_violation: "Stripping thinking blocks...",
-        empty_content_message: "Deleting empty message...",
-      }
-      const toastTitle = toastTitles[errorType]
-      const toastMessage = toastMessages[errorType]
-
-      await ctx.client.tui
-        .showToast({
-          body: {
-            title: toastTitle,
-            message: toastMessage,
-            variant: "warning",
-            duration: 3000,
-          },
-        })
-        .catch(() => {})
-
-      let success = false
-
-      if (errorType === "tool_result_missing") {
-        success = await recoverToolResultMissing(ctx.client, sessionID, failedMsg)
-      } else if (errorType === "thinking_block_order") {
-        success = await recoverThinkingBlockOrder(ctx.client, sessionID, failedMsg, ctx.directory)
-      } 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)
-      }
-
-      return success
-    } catch {
-      return false
-    } finally {
-      processingErrors.delete(assistantMsgID)
-    }
-  }
-
-  return {
-    handleSessionRecovery,
-    isRecoverableError,
-    setOnAbortCallback,
-  }
-}
--- a/src/hooks/session-recovery/constants.ts
+++ b/src/hooks/session-recovery/constants.ts
@@ -0,0 +1,10 @@
+import { join } from "node:path"
+import { xdgData } from "xdg-basedir"
+
+export const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage")
+export const MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message")
+export const PART_STORAGE = join(OPENCODE_STORAGE, "part")
+
+export const THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"])
+export const META_TYPES = new Set(["step-start", "step-finish"])
+export const CONTENT_TYPES = new Set(["text", "tool", "tool_use", "tool_result"])
--- a/src/hooks/session-recovery/index.ts
+++ b/src/hooks/session-recovery/index.ts
@@ -0,0 +1,281 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import type { createOpencodeClient } from "@opencode-ai/sdk"
+import {
+  findEmptyMessages,
+  findMessagesWithOrphanThinking,
+  findMessagesWithThinkingBlocks,
+  injectTextPart,
+  prependThinkingPart,
+  stripThinkingParts,
+} from "./storage"
+import type { MessageData } from "./types"
+
+type Client = ReturnType<typeof createOpencodeClient>
+
+type RecoveryErrorType =
+  | "tool_result_missing"
+  | "thinking_block_order"
+  | "thinking_disabled_violation"
+  | "empty_content_message"
+  | null
+
+interface MessageInfo {
+  id?: string
+  role?: string
+  sessionID?: string
+  parentID?: string
+  error?: unknown
+}
+
+interface ToolUsePart {
+  type: "tool_use"
+  id: string
+  name: string
+  input: Record<string, unknown>
+}
+
+interface MessagePart {
+  type: string
+  id?: string
+  text?: string
+  thinking?: string
+  name?: string
+  input?: Record<string, unknown>
+}
+
+function getErrorMessage(error: unknown): string {
+  if (!error) return ""
+  if (typeof error === "string") return error.toLowerCase()
+  const errorObj = error as {
+    data?: { message?: string }
+    message?: string
+    error?: { message?: string }
+  }
+  return (errorObj.data?.message || errorObj.error?.message || errorObj.message || "").toLowerCase()
+}
+
+function detectErrorType(error: unknown): RecoveryErrorType {
+  const message = getErrorMessage(error)
+
+  if (message.includes("tool_use") && message.includes("tool_result")) {
+    return "tool_result_missing"
+  }
+
+  if (
+    message.includes("thinking") &&
+    (message.includes("first block") || message.includes("must start with") || message.includes("preceeding"))
+  ) {
+    return "thinking_block_order"
+  }
+
+  if (message.includes("thinking is disabled") && message.includes("cannot contain")) {
+    return "thinking_disabled_violation"
+  }
+
+  if (message.includes("non-empty content") || message.includes("must have non-empty content")) {
+    return "empty_content_message"
+  }
+
+  return null
+}
+
+function extractToolUseIds(parts: MessagePart[]): string[] {
+  return parts.filter((p): p is ToolUsePart => p.type === "tool_use" && !!p.id).map((p) => p.id)
+}
+
+async function recoverToolResultMissing(
+  client: Client,
+  sessionID: string,
+  failedAssistantMsg: MessageData
+): Promise<boolean> {
+  const parts = failedAssistantMsg.parts || []
+  const toolUseIds = extractToolUseIds(parts)
+
+  if (toolUseIds.length === 0) {
+    return false
+  }
+
+  const toolResultParts = toolUseIds.map((id) => ({
+    type: "tool_result" as const,
+    tool_use_id: id,
+    content: "Operation cancelled by user (ESC pressed)",
+  }))
+
+  try {
+    await client.session.prompt({
+      path: { id: sessionID },
+      // @ts-expect-error - SDK types may not include tool_result parts
+      body: { parts: toolResultParts },
+    })
+
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function recoverThinkingBlockOrder(
+  _client: Client,
+  sessionID: string,
+  _failedAssistantMsg: MessageData,
+  _directory: string
+): Promise<boolean> {
+  const orphanMessages = findMessagesWithOrphanThinking(sessionID)
+
+  if (orphanMessages.length === 0) {
+    return false
+  }
+
+  let anySuccess = false
+  for (const messageID of orphanMessages) {
+    if (prependThinkingPart(sessionID, messageID)) {
+      anySuccess = true
+    }
+  }
+
+  return anySuccess
+}
+
+async function recoverThinkingDisabledViolation(
+  _client: Client,
+  sessionID: string,
+  _failedAssistantMsg: MessageData
+): Promise<boolean> {
+  const messagesWithThinking = findMessagesWithThinkingBlocks(sessionID)
+
+  if (messagesWithThinking.length === 0) {
+    return false
+  }
+
+  let anySuccess = false
+  for (const messageID of messagesWithThinking) {
+    if (stripThinkingParts(messageID)) {
+      anySuccess = true
+    }
+  }
+
+  return anySuccess
+}
+
+async function recoverEmptyContentMessage(
+  _client: Client,
+  sessionID: string,
+  failedAssistantMsg: MessageData,
+  _directory: string
+): Promise<boolean> {
+  const emptyMessageIDs = findEmptyMessages(sessionID)
+
+  if (emptyMessageIDs.length === 0) {
+    const fallbackID = failedAssistantMsg.info?.id
+    if (!fallbackID) return false
+    return injectTextPart(sessionID, fallbackID, "(interrupted)")
+  }
+
+  let anySuccess = false
+  for (const messageID of emptyMessageIDs) {
+    if (injectTextPart(sessionID, messageID, "(interrupted)")) {
+      anySuccess = true
+    }
+  }
+
+  return anySuccess
+}
+
+// NOTE: fallbackRevertStrategy was removed (2025-12-08)
+// Reason: Function was defined but never called - no error recovery paths used it.
+// All error types have dedicated recovery functions (recoverToolResultMissing,
+// recoverThinkingBlockOrder, recoverThinkingDisabledViolation, recoverEmptyContentMessage).
+
+export function createSessionRecoveryHook(ctx: PluginInput) {
+  const processingErrors = new Set<string>()
+  let onAbortCallback: ((sessionID: string) => void) | null = null
+
+  const setOnAbortCallback = (callback: (sessionID: string) => void): void => {
+    onAbortCallback = callback
+  }
+
+  const isRecoverableError = (error: unknown): boolean => {
+    return detectErrorType(error) !== null
+  }
+
+  const handleSessionRecovery = async (info: MessageInfo): Promise<boolean> => {
+    if (!info || info.role !== "assistant" || !info.error) return false
+
+    const errorType = detectErrorType(info.error)
+    if (!errorType) return false
+
+    const sessionID = info.sessionID
+    const assistantMsgID = info.id
+
+    if (!sessionID || !assistantMsgID) return false
+    if (processingErrors.has(assistantMsgID)) return false
+    processingErrors.add(assistantMsgID)
+
+    try {
+      await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {})
+
+      if (onAbortCallback) {
+        onAbortCallback(sessionID)
+      }
+
+      const messagesResp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory },
+      })
+      const msgs = (messagesResp as { data?: MessageData[] }).data
+
+      const failedMsg = msgs?.find((m) => m.info?.id === assistantMsgID)
+      if (!failedMsg) {
+        return false
+      }
+
+      const toastTitles: Record<RecoveryErrorType & string, string> = {
+        tool_result_missing: "Tool Crash Recovery",
+        thinking_block_order: "Thinking Block Recovery",
+        thinking_disabled_violation: "Thinking Strip Recovery",
+        empty_content_message: "Empty Message Recovery",
+      }
+      const toastMessages: Record<RecoveryErrorType & string, string> = {
+        tool_result_missing: "Injecting cancelled tool results...",
+        thinking_block_order: "Fixing message structure...",
+        thinking_disabled_violation: "Stripping thinking blocks...",
+        empty_content_message: "Fixing empty message...",
+      }
+
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: toastTitles[errorType],
+            message: toastMessages[errorType],
+            variant: "warning",
+            duration: 3000,
+          },
+        })
+        .catch(() => {})
+
+      let success = false
+
+      if (errorType === "tool_result_missing") {
+        success = await recoverToolResultMissing(ctx.client, sessionID, failedMsg)
+      } else if (errorType === "thinking_block_order") {
+        success = await recoverThinkingBlockOrder(ctx.client, sessionID, failedMsg, ctx.directory)
+      } 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)
+      }
+
+      return success
+    } catch {
+      return false
+    } finally {
+      processingErrors.delete(assistantMsgID)
+    }
+  }
+
+  return {
+    handleSessionRecovery,
+    isRecoverableError,
+    setOnAbortCallback,
+  }
+}
--- a/src/hooks/session-recovery/storage.ts
+++ b/src/hooks/session-recovery/storage.ts
@@ -0,0 +1,235 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { MESSAGE_STORAGE, PART_STORAGE, THINKING_TYPES, META_TYPES } from "./constants"
+import type { StoredMessageMeta, StoredPart, StoredTextPart } from "./types"
+
+export function generatePartId(): string {
+  const timestamp = Date.now().toString(16)
+  const random = Math.random().toString(36).substring(2, 10)
+  return `prt_${timestamp}${random}`
+}
+
+export function getMessageDir(sessionID: string): string {
+  if (!existsSync(MESSAGE_STORAGE)) return ""
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) {
+    return directPath
+  }
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) {
+      return sessionPath
+    }
+  }
+
+  return ""
+}
+
+export function readMessages(sessionID: string): StoredMessageMeta[] {
+  const messageDir = getMessageDir(sessionID)
+  if (!messageDir || !existsSync(messageDir)) return []
+
+  const messages: StoredMessageMeta[] = []
+  for (const file of readdirSync(messageDir)) {
+    if (!file.endsWith(".json")) continue
+    try {
+      const content = readFileSync(join(messageDir, file), "utf-8")
+      messages.push(JSON.parse(content))
+    } catch {
+      continue
+    }
+  }
+
+  return messages.sort((a, b) => a.id.localeCompare(b.id))
+}
+
+export function readParts(messageID: string): StoredPart[] {
+  const partDir = join(PART_STORAGE, messageID)
+  if (!existsSync(partDir)) return []
+
+  const parts: StoredPart[] = []
+  for (const file of readdirSync(partDir)) {
+    if (!file.endsWith(".json")) continue
+    try {
+      const content = readFileSync(join(partDir, file), "utf-8")
+      parts.push(JSON.parse(content))
+    } catch {
+      continue
+    }
+  }
+
+  return parts
+}
+
+export function hasContent(part: StoredPart): boolean {
+  if (THINKING_TYPES.has(part.type)) return false
+  if (META_TYPES.has(part.type)) return false
+
+  if (part.type === "text") {
+    const textPart = part as StoredTextPart
+    return !!(textPart.text?.trim())
+  }
+
+  if (part.type === "tool" || part.type === "tool_use") {
+    return true
+  }
+
+  if (part.type === "tool_result") {
+    return true
+  }
+
+  return false
+}
+
+export function messageHasContent(messageID: string): boolean {
+  const parts = readParts(messageID)
+  return parts.some(hasContent)
+}
+
+export function injectTextPart(sessionID: string, messageID: string, text: string): boolean {
+  const partDir = join(PART_STORAGE, messageID)
+
+  if (!existsSync(partDir)) {
+    mkdirSync(partDir, { recursive: true })
+  }
+
+  const partId = generatePartId()
+  const part: StoredTextPart = {
+    id: partId,
+    sessionID,
+    messageID,
+    type: "text",
+    text,
+    synthetic: true,
+  }
+
+  try {
+    writeFileSync(join(partDir, `${partId}.json`), JSON.stringify(part, null, 2))
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function findEmptyMessages(sessionID: string): string[] {
+  const messages = readMessages(sessionID)
+  const emptyIds: string[] = []
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i]
+    if (msg.role !== "assistant") continue
+
+    const isLastMessage = i === messages.length - 1
+    if (isLastMessage) continue
+
+    if (!messageHasContent(msg.id)) {
+      emptyIds.push(msg.id)
+    }
+  }
+
+  return emptyIds
+}
+
+export function findFirstEmptyMessage(sessionID: string): string | null {
+  const emptyIds = findEmptyMessages(sessionID)
+  return emptyIds.length > 0 ? emptyIds[0] : null
+}
+
+export function findMessagesWithThinkingBlocks(sessionID: string): string[] {
+  const messages = readMessages(sessionID)
+  const result: string[] = []
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i]
+    if (msg.role !== "assistant") continue
+
+    const isLastMessage = i === messages.length - 1
+    if (isLastMessage) continue
+
+    const parts = readParts(msg.id)
+    const hasThinking = parts.some((p) => THINKING_TYPES.has(p.type))
+    if (hasThinking) {
+      result.push(msg.id)
+    }
+  }
+
+  return result
+}
+
+export function findMessagesWithOrphanThinking(sessionID: string): string[] {
+  const messages = readMessages(sessionID)
+  const result: string[] = []
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i]
+    if (msg.role !== "assistant") continue
+
+    const isLastMessage = i === messages.length - 1
+    if (isLastMessage) continue
+
+    const parts = readParts(msg.id)
+    if (parts.length === 0) continue
+
+    const sortedParts = [...parts].sort((a, b) => a.id.localeCompare(b.id))
+    const firstPart = sortedParts[0]
+
+    const hasThinking = parts.some((p) => THINKING_TYPES.has(p.type))
+    const firstIsThinking = THINKING_TYPES.has(firstPart.type)
+
+    if (hasThinking && !firstIsThinking) {
+      result.push(msg.id)
+    }
+  }
+
+  return result
+}
+
+export function prependThinkingPart(sessionID: string, messageID: string): boolean {
+  const partDir = join(PART_STORAGE, messageID)
+
+  if (!existsSync(partDir)) {
+    mkdirSync(partDir, { recursive: true })
+  }
+
+  const partId = `prt_0000000000_thinking`
+  const part = {
+    id: partId,
+    sessionID,
+    messageID,
+    type: "thinking",
+    thinking: "",
+    synthetic: true,
+  }
+
+  try {
+    writeFileSync(join(partDir, `${partId}.json`), JSON.stringify(part, null, 2))
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function stripThinkingParts(messageID: string): boolean {
+  const partDir = join(PART_STORAGE, messageID)
+  if (!existsSync(partDir)) return false
+
+  let anyRemoved = false
+  for (const file of readdirSync(partDir)) {
+    if (!file.endsWith(".json")) continue
+    try {
+      const filePath = join(partDir, file)
+      const content = readFileSync(filePath, "utf-8")
+      const part = JSON.parse(content) as StoredPart
+      if (THINKING_TYPES.has(part.type)) {
+        unlinkSync(filePath)
+        anyRemoved = true
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return anyRemoved
+}
--- a/src/hooks/session-recovery/types.ts
+++ b/src/hooks/session-recovery/types.ts
@@ -0,0 +1,82 @@
+export type ThinkingPartType = "thinking" | "redacted_thinking" | "reasoning"
+export type MetaPartType = "step-start" | "step-finish"
+export type ContentPartType = "text" | "tool" | "tool_use" | "tool_result"
+
+export interface StoredMessageMeta {
+  id: string
+  sessionID: string
+  role: "user" | "assistant"
+  parentID?: string
+  time?: {
+    created: number
+    completed?: number
+  }
+  error?: unknown
+}
+
+export interface StoredTextPart {
+  id: string
+  sessionID: string
+  messageID: string
+  type: "text"
+  text: string
+  synthetic?: boolean
+  ignored?: boolean
+}
+
+export interface StoredToolPart {
+  id: string
+  sessionID: string
+  messageID: string
+  type: "tool"
+  callID: string
+  tool: string
+  state: {
+    status: "pending" | "running" | "completed" | "error"
+    input: Record<string, unknown>
+    output?: string
+    error?: string
+  }
+}
+
+export interface StoredReasoningPart {
+  id: string
+  sessionID: string
+  messageID: string
+  type: "reasoning"
+  text: string
+}
+
+export interface StoredStepPart {
+  id: string
+  sessionID: string
+  messageID: string
+  type: "step-start" | "step-finish"
+}
+
+export type StoredPart = StoredTextPart | StoredToolPart | StoredReasoningPart | StoredStepPart | {
+  id: string
+  sessionID: string
+  messageID: string
+  type: string
+  [key: string]: unknown
+}
+
+export interface MessageData {
+  info?: {
+    id?: string
+    role?: string
+    sessionID?: string
+    parentID?: string
+    error?: unknown
+  }
+  parts?: Array<{
+    type: string
+    id?: string
+    text?: string
+    thinking?: string
+    name?: string
+    input?: Record<string, unknown>
+    callID?: string
+  }>
+}
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,59 +1,70 @@
-import type { Plugin } from "@opencode-ai/plugin"
-import { createBuiltinAgents } from "./agents"
-import { createTodoContinuationEnforcer, createContextWindowMonitorHook, createSessionRecoveryHook, createCommentCheckerHooks, createGrepOutputTruncatorHook, createPulseMonitorHook } from "./hooks"
-import { updateTerminalTitle } from "./features/terminal"
-import { builtinTools } from "./tools"
-import { createBuiltinMcps } from "./mcp"
-import { OhMyOpenCodeConfigSchema, type OhMyOpenCodeConfig } from "./config"
-import * as fs from "fs"
-import * as path from "path"
+import type { Plugin } from "@opencode-ai/plugin";
+import { createBuiltinAgents } from "./agents";
+import {
+  createTodoContinuationEnforcer,
+  createContextWindowMonitorHook,
+  createSessionRecoveryHook,
+  createCommentCheckerHooks,
+  createGrepOutputTruncatorHook,
+  createDirectoryAgentsInjectorHook,
+  createEmptyTaskResponseDetectorHook,
+} from "./hooks";
+import { updateTerminalTitle } from "./features/terminal";
+import { builtinTools } from "./tools";
+import { createBuiltinMcps } from "./mcp";
+import { OhMyOpenCodeConfigSchema, type OhMyOpenCodeConfig } from "./config";
+import * as fs from "fs";
+import * as path from "path";

 function loadPluginConfig(directory: string): OhMyOpenCodeConfig {
  const configPaths = [
    path.join(directory, "oh-my-opencode.json"),
    path.join(directory, ".oh-my-opencode.json"),
-  ]
+  ];

  for (const configPath of configPaths) {
    try {
      if (fs.existsSync(configPath)) {
-        const content = fs.readFileSync(configPath, "utf-8")
-        const rawConfig = JSON.parse(content)
-        const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig)
+        const content = fs.readFileSync(configPath, "utf-8");
+        const rawConfig = JSON.parse(content);
+        const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);

        if (!result.success) {
-          console.error(`[oh-my-opencode] Config validation error in ${configPath}:`)
+          console.error(
+            `[oh-my-opencode] Config validation error in ${configPath}:`,
+          );
          for (const issue of result.error.issues) {
-            console.error(`  - ${issue.path.join(".")}: ${issue.message}`)
+            console.error(`  - ${issue.path.join(".")}: ${issue.message}`);
          }
-          return {}
+          return {};
        }

-        return result.data
+        return result.data;
      }
    } catch {
      // Ignore parse errors, use defaults
    }
  }

-  return {}
+  return {};
 }

 const OhMyOpenCodePlugin: Plugin = async (ctx) => {
-  const todoContinuationEnforcer = createTodoContinuationEnforcer(ctx)
-  const contextWindowMonitor = createContextWindowMonitorHook(ctx)
-  const sessionRecovery = createSessionRecoveryHook(ctx)
-  const pulseMonitor = createPulseMonitorHook(ctx)
-  const commentChecker = createCommentCheckerHooks()
-  const grepOutputTruncator = createGrepOutputTruncatorHook(ctx)
+  const todoContinuationEnforcer = createTodoContinuationEnforcer(ctx);
+  const contextWindowMonitor = createContextWindowMonitorHook(ctx);
+  const sessionRecovery = createSessionRecoveryHook(ctx);
+  const commentChecker = createCommentCheckerHooks();
+  const grepOutputTruncator = createGrepOutputTruncatorHook(ctx);
+  const directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
+  const emptyTaskResponseDetector = createEmptyTaskResponseDetectorHook(ctx);

-  updateTerminalTitle({ sessionId: "main" })
+  updateTerminalTitle({ sessionId: "main" });

-  const pluginConfig = loadPluginConfig(ctx.directory)
+  const pluginConfig = loadPluginConfig(ctx.directory);

-  let mainSessionID: string | undefined
-  let currentSessionID: string | undefined
-  let currentSessionTitle: string | undefined
+  let mainSessionID: string | undefined;
+  let currentSessionID: string | undefined;
+  let currentSessionTitle: string | undefined;

  return {
    tool: builtinTools,
@@ -61,76 +72,79 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
    config: async (config) => {
      const agents = createBuiltinAgents(
        pluginConfig.disabled_agents,
-        pluginConfig.agents
-      )
+        pluginConfig.agents,
+      );

      config.agent = {
        ...config.agent,
        ...agents,
-      }
+      };
      config.tools = {
        ...config.tools,
-        grep: false,
-      }
+      };
      config.mcp = {
        ...config.mcp,
        ...createBuiltinMcps(pluginConfig.disabled_mcps),
-      }
+      };
    },

    event: async (input) => {
-      await todoContinuationEnforcer(input)
-      await contextWindowMonitor.event(input)
-      await pulseMonitor.event(input)
+      await todoContinuationEnforcer(input);
+      await contextWindowMonitor.event(input);
+      await directoryAgentsInjector.event(input);

-      const { event } = input
-      const props = event.properties as Record<string, unknown> | undefined
+      const { event } = input;
+      const props = event.properties as Record<string, unknown> | undefined;

      if (event.type === "session.created") {
-        const sessionInfo = props?.info as { id?: string; title?: string; parentID?: string } | undefined
+        const sessionInfo = props?.info as
+          | { id?: string; title?: string; parentID?: string }
+          | undefined;
        if (!sessionInfo?.parentID) {
-          mainSessionID = sessionInfo?.id
-          currentSessionID = sessionInfo?.id
-          currentSessionTitle = sessionInfo?.title
+          mainSessionID = sessionInfo?.id;
+          currentSessionID = sessionInfo?.id;
+          currentSessionTitle = sessionInfo?.title;
          updateTerminalTitle({
            sessionId: currentSessionID || "main",
            status: "idle",
            directory: ctx.directory,
            sessionTitle: currentSessionTitle,
-          })
+          });
        }
      }

      if (event.type === "session.updated") {
-        const sessionInfo = props?.info as { id?: string; title?: string; parentID?: string } | undefined
+        const sessionInfo = props?.info as
+          | { id?: string; title?: string; parentID?: string }
+          | undefined;
        if (!sessionInfo?.parentID) {
-          currentSessionID = sessionInfo?.id
-          currentSessionTitle = sessionInfo?.title
+          currentSessionID = sessionInfo?.id;
+          currentSessionTitle = sessionInfo?.title;
          updateTerminalTitle({
            sessionId: currentSessionID || "main",
            status: "processing",
            directory: ctx.directory,
            sessionTitle: currentSessionTitle,
-          })
+          });
        }
      }

      if (event.type === "session.deleted") {
-        const sessionInfo = props?.info as { id?: string } | undefined
+        const sessionInfo = props?.info as { id?: string } | undefined;
        if (sessionInfo?.id === mainSessionID) {
-          mainSessionID = undefined
-          currentSessionID = undefined
-          currentSessionTitle = undefined
+          mainSessionID = undefined;
+          currentSessionID = undefined;
+          currentSessionTitle = undefined;
          updateTerminalTitle({
            sessionId: "main",
            status: "idle",
-          })
+          });
        }
      }

      if (event.type === "session.error") {
-        const sessionID = props?.sessionID as string | undefined
-        const error = props?.error
+        const sessionID = props?.sessionID as string | undefined;
+        const error = props?.error;

        if (sessionRecovery.isRecoverableError(error)) {
          const messageInfo = {
@@ -138,15 +152,18 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
            role: "assistant" as const,
            sessionID,
            error,
-          }
-          const recovered = await sessionRecovery.handleSessionRecovery(messageInfo)
+          };
+          const recovered =
+            await sessionRecovery.handleSessionRecovery(messageInfo);

          if (recovered && sessionID && sessionID === mainSessionID) {
-            await ctx.client.session.prompt({
-              path: { id: sessionID },
-              body: { parts: [{ type: "text", text: "continue" }] },
-              query: { directory: ctx.directory },
-            }).catch(() => {})
+            await ctx.client.session
+              .prompt({
+                path: { id: sessionID },
+                body: { parts: [{ type: "text", text: "continue" }] },
+                query: { directory: ctx.directory },
+              })
+              .catch(() => {});
          }
        }

@@ -156,26 +173,25 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
            status: "error",
            directory: ctx.directory,
            sessionTitle: currentSessionTitle,
-          })
+          });
        }
      }

      if (event.type === "session.idle") {
-        const sessionID = props?.sessionID as string | undefined
+        const sessionID = props?.sessionID as string | undefined;
        if (sessionID && sessionID === mainSessionID) {
          updateTerminalTitle({
            sessionId: sessionID,
            status: "idle",
            directory: ctx.directory,
            sessionTitle: currentSessionTitle,
-          })
+          });
        }
      }
    },

    "tool.execute.before": async (input, output) => {
-      await pulseMonitor["tool.execute.before"]()
-      await commentChecker["tool.execute.before"](input, output)
+      await commentChecker["tool.execute.before"](input, output);

      if (input.sessionID === mainSessionID) {
        updateTerminalTitle({
@@ -184,15 +200,16 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
          currentTool: input.tool,
          directory: ctx.directory,
          sessionTitle: currentSessionTitle,
-        })
+        });
      }
    },

    "tool.execute.after": async (input, output) => {
-      await pulseMonitor["tool.execute.after"](input)
-      await grepOutputTruncator["tool.execute.after"](input, output)
-      await contextWindowMonitor["tool.execute.after"](input, output)
-      await commentChecker["tool.execute.after"](input, output)
+      await grepOutputTruncator["tool.execute.after"](input, output);
+      await contextWindowMonitor["tool.execute.after"](input, output);
+      await commentChecker["tool.execute.after"](input, output);
+      await directoryAgentsInjector["tool.execute.after"](input, output);
+      await emptyTaskResponseDetector["tool.execute.after"](input, output);

      if (input.sessionID === mainSessionID) {
        updateTerminalTitle({
@@ -200,13 +217,13 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
          status: "idle",
          directory: ctx.directory,
          sessionTitle: currentSessionTitle,
-        })
+        });
      }
    },
-  }
-}
+  };
+};

-export default OhMyOpenCodePlugin
+export default OhMyOpenCodePlugin;

 export type {
  OhMyOpenCodeConfig,
@@ -214,4 +231,4 @@ export type {
  AgentOverrideConfig,
  AgentOverrides,
  McpName,
-} from "./config"
+} from "./config";
--- a/src/mcp/index.ts
+++ b/src/mcp/index.ts
@@ -20,5 +20,3 @@ export function createBuiltinMcps(disabledMcps: McpName[] = []) {

  return mcps
 }
-
-export const builtinMcps = allBuiltinMcps
--- a/src/tools/ast-grep/tools.ts
+++ b/src/tools/ast-grep/tools.ts
@@ -1,9 +1,8 @@
 import { tool } from "@opencode-ai/plugin/tool"
-import { CLI_LANGUAGES, NAPI_LANGUAGES, LANG_EXTENSIONS } from "./constants"
+import { CLI_LANGUAGES } from "./constants"
 import { runSg } from "./cli"
-import { analyzeCode, transformCode, getRootInfo } from "./napi"
-import { formatSearchResult, formatReplaceResult, formatAnalyzeResult, formatTransformResult } from "./utils"
-import type { CliLanguage, NapiLanguage } from "./types"
+import { formatSearchResult, formatReplaceResult } from "./utils"
+import type { CliLanguage } from "./types"

 function showOutputToUser(context: unknown, output: string): void {
  const ctx = context as { metadata?: (input: { metadata: { output: string } }) => void }
@@ -110,83 +109,4 @@ export const ast_grep_replace = tool({
  },
 })

-export const ast_grep_languages = tool({
-  description:
-    "List all supported languages for ast-grep tools with their file extensions. " +
-    "Use this to determine valid language options.",
-  args: {},
-  execute: async (_args, context) => {
-    const lines: string[] = [`Supported Languages (${CLI_LANGUAGES.length}):`]
-    for (const lang of CLI_LANGUAGES) {
-      const exts = LANG_EXTENSIONS[lang]?.join(", ") || ""
-      lines.push(`  ${lang}: ${exts}`)
-    }
-    lines.push("")
-    lines.push(`NAPI (in-memory) languages: ${NAPI_LANGUAGES.join(", ")}`)
-    const output = lines.join("\n")
-    showOutputToUser(context, output)
-    return output
-  },
-})

-export const ast_grep_analyze = tool({
-  description:
-    "Parse code and extract AST structure with pattern matching (in-memory). " +
-    "Extracts meta-variable bindings. Only for: html, javascript, tsx, css, typescript. " +
-    "Use for detailed code analysis without file I/O.",
-  args: {
-    code: tool.schema.string().describe("Source code to analyze"),
-    lang: tool.schema.enum(NAPI_LANGUAGES).describe("Language (html, javascript, tsx, css, typescript)"),
-    pattern: tool.schema.string().optional().describe("Pattern to find (omit for root structure)"),
-    extractMetaVars: tool.schema.boolean().optional().describe("Extract meta-variable bindings (default: true)"),
-  },
-  execute: async (args, context) => {
-    try {
-      if (!args.pattern) {
-        const info = getRootInfo(args.code, args.lang as NapiLanguage)
-        const output = `Root kind: ${info.kind}\nChildren: ${info.childCount}`
-        showOutputToUser(context, output)
-        return output
-      }
-
-      const results = analyzeCode(args.code, args.lang as NapiLanguage, args.pattern, args.extractMetaVars !== false)
-      const output = formatAnalyzeResult(results, args.extractMetaVars !== false)
-      showOutputToUser(context, output)
-      return output
-    } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`
-      showOutputToUser(context, output)
-      return output
-    }
-  },
-})
-
-export const ast_grep_transform = tool({
-  description:
-    "Transform code in-memory using AST-aware rewriting. " +
-    "Only for: html, javascript, tsx, css, typescript. " +
-    "Returns transformed code without writing to filesystem.",
-  args: {
-    code: tool.schema.string().describe("Source code to transform"),
-    lang: tool.schema.enum(NAPI_LANGUAGES).describe("Language"),
-    pattern: tool.schema.string().describe("Pattern to match"),
-    rewrite: tool.schema.string().describe("Replacement (can use $VAR from pattern)"),
-  },
-  execute: async (args, context) => {
-    try {
-      const { transformed, editCount } = transformCode(
-        args.code,
-        args.lang as NapiLanguage,
-        args.pattern,
-        args.rewrite
-      )
-      const output = formatTransformResult(args.code, transformed, editCount)
-      showOutputToUser(context, output)
-      return output
-    } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`
-      showOutputToUser(context, output)
-      return output
-    }
-  },
-})
--- a/src/tools/glob/cli.ts
+++ b/src/tools/glob/cli.ts
@@ -0,0 +1,129 @@
+import { spawn } from "bun"
+import {
+  resolveGrepCli,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_LIMIT,
+  DEFAULT_MAX_DEPTH,
+  DEFAULT_MAX_OUTPUT_BYTES,
+  RG_FILES_FLAGS,
+} from "./constants"
+import type { GlobOptions, GlobResult, FileMatch } from "./types"
+import { stat } from "node:fs/promises"
+
+function buildRgArgs(options: GlobOptions): string[] {
+  const args: string[] = [
+    ...RG_FILES_FLAGS,
+    `--max-depth=${Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)}`,
+  ]
+
+  if (options.hidden) args.push("--hidden")
+  if (options.noIgnore) args.push("--no-ignore")
+
+  args.push(`--glob=${options.pattern}`)
+
+  return args
+}
+
+function buildFindArgs(options: GlobOptions): string[] {
+  const args: string[] = ["."]
+
+  const maxDepth = Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)
+  args.push("-maxdepth", String(maxDepth))
+
+  args.push("-type", "f")
+  args.push("-name", options.pattern)
+
+  if (!options.hidden) {
+    args.push("-not", "-path", "*/.*")
+  }
+
+  return args
+}
+
+async function getFileMtime(filePath: string): Promise<number> {
+  try {
+    const stats = await stat(filePath)
+    return stats.mtime.getTime()
+  } catch {
+    return 0
+  }
+}
+
+export async function runRgFiles(options: GlobOptions): Promise<GlobResult> {
+  const cli = resolveGrepCli()
+  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS)
+  const limit = Math.min(options.limit ?? DEFAULT_LIMIT, DEFAULT_LIMIT)
+
+  const isRg = cli.backend === "rg"
+  const args = isRg ? buildRgArgs(options) : buildFindArgs(options)
+
+  const paths = options.paths?.length ? options.paths : ["."]
+  if (isRg) {
+    args.push(...paths)
+  }
+
+  const cwd = paths[0] || "."
+
+  const proc = spawn([cli.path, ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    cwd: isRg ? undefined : cwd,
+  })
+
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    const id = setTimeout(() => {
+      proc.kill()
+      reject(new Error(`Glob search timeout after ${timeout}ms`))
+    }, timeout)
+    proc.exited.then(() => clearTimeout(id))
+  })
+
+  try {
+    const stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise])
+    const stderr = await new Response(proc.stderr).text()
+    const exitCode = await proc.exited
+
+    if (exitCode > 1 && stderr.trim()) {
+      return {
+        files: [],
+        totalFiles: 0,
+        truncated: false,
+        error: stderr.trim(),
+      }
+    }
+
+    const truncatedOutput = stdout.length >= DEFAULT_MAX_OUTPUT_BYTES
+    const outputToProcess = truncatedOutput ? stdout.substring(0, DEFAULT_MAX_OUTPUT_BYTES) : stdout
+
+    const lines = outputToProcess.trim().split("\n").filter(Boolean)
+
+    const files: FileMatch[] = []
+    let truncated = false
+
+    for (const line of lines) {
+      if (files.length >= limit) {
+        truncated = true
+        break
+      }
+
+      const filePath = isRg ? line : `${cwd}/${line}`
+      const mtime = await getFileMtime(filePath)
+      files.push({ path: filePath, mtime })
+    }
+
+    files.sort((a, b) => b.mtime - a.mtime)
+
+    return {
+      files,
+      totalFiles: files.length,
+      truncated: truncated || truncatedOutput,
+    }
+  } catch (e) {
+    return {
+      files: [],
+      totalFiles: 0,
+      truncated: false,
+      error: e instanceof Error ? e.message : String(e),
+    }
+  }
+}
--- a/src/tools/glob/constants.ts
+++ b/src/tools/glob/constants.ts
@@ -0,0 +1,12 @@
+export { resolveGrepCli, type GrepBackend } from "../grep/constants"
+
+export const DEFAULT_TIMEOUT_MS = 60_000
+export const DEFAULT_LIMIT = 100
+export const DEFAULT_MAX_DEPTH = 20
+export const DEFAULT_MAX_OUTPUT_BYTES = 10 * 1024 * 1024
+
+export const RG_FILES_FLAGS = [
+  "--files",
+  "--color=never",
+  "--glob=!.git/*",
+] as const
--- a/src/tools/glob/index.ts
+++ b/src/tools/glob/index.ts
@@ -0,0 +1,3 @@
+import { glob } from "./tools"
+
+export { glob }
--- a/src/tools/glob/tools.ts
+++ b/src/tools/glob/tools.ts
@@ -0,0 +1,36 @@
+import { tool } from "@opencode-ai/plugin/tool"
+import { runRgFiles } from "./cli"
+import { formatGlobResult } from "./utils"
+
+export const glob = tool({
+  description:
+    "Fast file pattern matching tool with safety limits (60s timeout, 100 file limit). " +
+    "Supports glob patterns like \"**/*.js\" or \"src/**/*.ts\". " +
+    "Returns matching file paths sorted by modification time. " +
+    "Use this tool when you need to find files by name patterns.",
+  args: {
+    pattern: tool.schema.string().describe("The glob pattern to match files against"),
+    path: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "The directory to search in. If not specified, the current working directory will be used. " +
+          "IMPORTANT: Omit this field to use the default directory. DO NOT enter \"undefined\" or \"null\" - " +
+          "simply omit it for the default behavior. Must be a valid directory path if provided."
+      ),
+  },
+  execute: async (args) => {
+    try {
+      const paths = args.path ? [args.path] : undefined
+
+      const result = await runRgFiles({
+        pattern: args.pattern,
+        paths,
+      })
+
+      return formatGlobResult(result)
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : String(e)}`
+    }
+  },
+})
--- a/src/tools/glob/types.ts
+++ b/src/tools/glob/types.ts
@@ -0,0 +1,21 @@
+export interface FileMatch {
+  path: string
+  mtime: number
+}
+
+export interface GlobResult {
+  files: FileMatch[]
+  totalFiles: number
+  truncated: boolean
+  error?: string
+}
+
+export interface GlobOptions {
+  pattern: string
+  paths?: string[]
+  hidden?: boolean
+  noIgnore?: boolean
+  maxDepth?: number
+  timeout?: number
+  limit?: number
+}
--- a/src/tools/glob/utils.ts
+++ b/src/tools/glob/utils.ts
@@ -0,0 +1,26 @@
+import type { GlobResult } from "./types"
+
+export function formatGlobResult(result: GlobResult): string {
+  if (result.error) {
+    return `Error: ${result.error}`
+  }
+
+  if (result.files.length === 0) {
+    return "No files found"
+  }
+
+  const lines: string[] = []
+  lines.push(`Found ${result.totalFiles} file(s)`)
+  lines.push("")
+
+  for (const file of result.files) {
+    lines.push(file.path)
+  }
+
+  if (result.truncated) {
+    lines.push("")
+    lines.push("(Results are truncated. Consider using a more specific path or pattern.)")
+  }
+
+  return lines.join("\n")
+}
--- a/src/tools/safe-grep/cli.ts
+++ b/src/tools/safe-grep/cli.ts
--- a/src/tools/safe-grep/constants.ts
+++ b/src/tools/safe-grep/constants.ts
--- a/src/tools/grep/index.ts
+++ b/src/tools/grep/index.ts
@@ -0,0 +1,3 @@
+import { grep } from "./tools"
+
+export { grep }
--- a/src/tools/safe-grep/tools.ts
+++ b/src/tools/safe-grep/tools.ts
@@ -2,7 +2,7 @@ import { tool } from "@opencode-ai/plugin/tool"
 import { runRg } from "./cli"
 import { formatGrepResult } from "./utils"

-export const safe_grep = tool({
+export const grep = tool({
  description:
    "Fast content search tool with safety limits (60s timeout, 10MB output). " +
    "Searches file contents using regular expressions. " +
--- a/src/tools/safe-grep/types.ts
+++ b/src/tools/safe-grep/types.ts
--- a/src/tools/safe-grep/utils.ts
+++ b/src/tools/safe-grep/utils.ts
--- a/src/tools/index.ts
+++ b/src/tools/index.ts
@@ -17,7 +17,8 @@ import {
  ast_grep_replace,
 } from "./ast-grep"

-import { safe_grep } from "./safe-grep"
+import { grep } from "./grep"
+import { glob } from "./glob"

 export const builtinTools = {
  lsp_hover,
@@ -33,5 +34,6 @@ export const builtinTools = {
  lsp_code_action_resolve,
  ast_grep_search,
  ast_grep_replace,
-  safe_grep,
+  grep,
+  glob,
 }
--- a/src/tools/lsp/tools.ts
+++ b/src/tools/lsp/tools.ts
@@ -14,7 +14,6 @@ import {
  formatDiagnostic,
  filterDiagnosticsBySeverity,
  formatPrepareRenameResult,
-  formatWorkspaceEdit,
  formatCodeActions,
  applyWorkspaceEdit,
  formatApplyResult,
--- a/src/tools/safe-grep/index.ts
+++ b/src/tools/safe-grep/index.ts
@@ -1,3 +0,0 @@
-import { safe_grep } from "./tools"
-
-export { safe_grep }
--- a/test-dir/AGENTS.md
+++ b/test-dir/AGENTS.md
@@ -0,0 +1,4 @@
+## Root Level Rules
+
+- Root rule 1
+- Root rule 2
--- a/test-dir/another.ts
+++ b/test-dir/another.ts
@@ -0,0 +1,3 @@
+export const config = {
+  strict: true
+}
--- a/test-dir/nested/AGENTS.md
+++ b/test-dir/nested/AGENTS.md
@@ -0,0 +1,4 @@
+## Nested Level Rules
+
+- Nested rule 1 (더 specific)
+- Nested rule 2
--- a/test-dir/nested/deep.ts
+++ b/test-dir/nested/deep.ts
@@ -0,0 +1 @@
+export const deep = true
--- a/test-dir/test.ts
+++ b/test-dir/test.ts
@@ -0,0 +1,3 @@
+export function greet(name: string): string {
+  return `Hello, ${name}!`
+}
Author	SHA1	Message	Date
github-actions[bot]	e07a25baa4	release: v0.1.31	2025-12-09 05:42:03 +00:00
YeonGyu-Kim	08ede0a28d	deps: bump @code-yeongyu/comment-checker to 0.4.4 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 14:41:07 +09:00
github-actions[bot]	a711d58289	release: v0.1.30	2025-12-09 02:50:19 +00:00
YeonGyu-Kim	431ec14991	docs: update notepad with cleanup task logs 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 11:49:17 +09:00
YeonGyu-Kim	62cae8114d	refactor(comment-checker): simplify binary path resolution and add separator warning - Remove platform-specific package lookup logic - Remove homebrew path resolution - Add code smell warning for comment separators 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 11:49:11 +09:00
YeonGyu-Kim	e6eafe267a	refactor(ast-grep): remove NAPI-based tools 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 11:49:00 +09:00
YeonGyu-Kim	e4ef832405	feat(hooks): add anthropic-auto-compact hook 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 11:48:53 +09:00
YeonGyu-Kim	ef6d67645e	refactor(hooks): remove pulse-monitor hook 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 11:48:46 +09:00
YeonGyu-Kim	227d93f106	docs(readme-ko): clarify nested AGENTS.md injection behavior with example Added directory tree example showing how multiple AGENTS.md files are collected and injected in hierarchical order when reading nested files. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 10:38:05 +09:00
github-actions[bot]	edff922afb	release: v0.1.29	2025-12-09 01:37:46 +00:00
YeonGyu-Kim	45bdcf3580	docs(readme): clarify nested AGENTS.md injection behavior with example Added directory tree example showing how multiple AGENTS.md files are collected and injected in hierarchical order when reading nested files. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 10:36:34 +09:00
YeonGyu-Kim	b07dd22093	fix(pulse-monitor): reset heartbeat after tool execution to prevent false positives Tools can take arbitrary time, so we need a fresh baseline after execution. Previously, lastHeartbeat wasn't updated after tool.execute.after, causing stalled detection to trigger immediately after long-running tools. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 10:36:34 +09:00
YeonGyu-Kim	c7d29fea48	refactor(mcp): remove unused builtinMcps export 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 10:36:34 +09:00
YeonGyu-Kim	55675497a5	refactor(session-recovery): remove unused ThinkingPart interface and fallbackRevertStrategy function 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 10:36:34 +09:00
YeonGyu-Kim	ae2d347d81	refactor(lsp): remove unused formatWorkspaceEdit import 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 10:36:34 +09:00
github-actions[bot]	2683de825a	release: v0.1.28	2025-12-08 08:52:28 +00:00
YeonGyu-Kim	0b5c8250ca	fix(pulse-monitor): prevent false positive stalled detection after tool execution Remove forced monitoring restart in tool.execute.after to avoid false positive stalled session detection when LLM legitimately completes response after tool run. Monitoring now resumes naturally on next session/message event. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-08 17:51:06 +09:00
github-actions[bot]	66fcd8570b	release: v0.1.27	2025-12-08 08:01:03 +00:00
YeonGyu-Kim	5cd3f0cbf2	docs: add Directory AGENTS.md Injector hook documentation 🤖 GENERATED BY [OPENCODE](https://opencode.ai/)	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	9a9512b705	test: add test directory with sample files	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	6ece7476ef	feat(hooks): add empty-task-response-detector hook	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	9ed23d4037	feat(hooks): implement directory-agents-injector hook	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	79b791117a	fix(session-recovery): improve error message extraction	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	4e328a937c	feat(hooks): integrate directory-agents-injector hook into plugin pipeline - Add directoryAgentsInjector to plugin event handlers - Wire up tool.execute.after hook for directory agents injection - Fix: Format src/index.ts with consistent semicolon style	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	a500f0c9ad	export(hooks): add directory-agents-injector hook to public API - Export createDirectoryAgentsInjectorHook from hooks index - Fix: Formatting (add semicolons to match code style)	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	16806da615	refactor(session-recovery): process entire message history for empty/thinking block recovery - Scan all non-final assistant messages for empty content, orphan thinking blocks, and disabled thinking - Add storage utility functions: findMessagesWithThinkingBlocks, findMessagesWithOrphanThinking, stripThinkingParts, prependThinkingPart - Fix: Previously only processed single failed message, now handles multiple broken messages in history - Improve: Use filesystem-based recovery instead of unreliable SDK APIs	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	c5f651c0a9	refactor(hooks): remove grep-blocker (grep tool now overrides built-in) The grep tool now properly overrides OpenCode's built-in grep, making the blocker hook unnecessary. Generated by [OpenCode](https://opencode.ai/)	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	ed3d7a55f4	feat(tools): add glob tool with timeout protection - Override OpenCode's built-in glob with 60s timeout - Kill process on expiration to prevent indefinite hanging - Reuse grep's CLI resolver for ripgrep detection Generated by [OpenCode](https://opencode.ai/)	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	b77dd2fcdf	refactor(tools): rename safe-grep to grep with override capability	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	64b3564760	refactor(session-recovery): extract storage utilities to separate module Split session-recovery.ts into modular structure: - types.ts: SDK-aligned type definitions - constants.ts: storage paths and part type sets - storage.ts: reusable read/write operations - index.ts: main recovery hook logic	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	0df7e9b10b	fix(session-recovery): recognize 'tool' type as valid content OpenCode storage uses 'tool' type for tool calls, but the hasContent check only recognized 'tool_use' (Anthropic API format). This caused messages with tool calls to be incorrectly identified as empty.	2025-12-08 17:00:02 +09:00
YeonGyu-Kim	aa35f2eab6	fix(session-recovery): detect empty messages with zero parts Previously, findEmptyContentMessageFromStorage only detected messages with parts.length > 0 that had no content. This missed the case where a message has zero parts entirely, causing infinite recovery loops.	2025-12-08 17:00:02 +09:00