release: v2.7.1

fix(todo-continuation-enforcer): simplify implementation and remove 10s throttle blocking background task completion
Removes the complex state machine and 10-second throttle (MIN_INJECTION_INTERVAL_MS) that was causing background task completion to hang. The hook now: - Uses straightforward error cooldown logic instead of complex injection throttling - Removes unnecessary state tracking that was delaying continuation injection - Maintains all safety checks (recovery mode, running tasks, error state) - Keeps countdown behavior with toast notifications Fixes #312 - Resolves v2.7.0 issue where background task completion would freeze the agent due to injection delays. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)
2025-12-28 18:14:11 +00:00 · 2025-12-29 03:10:43 +09:00 · 2025-12-29 02:29:46 +09:00 · 2025-12-29 01:09:28 +09:00 · 2025-12-28 19:42:56 +09:00 · 2025-12-28 19:23:29 +09:00
60 changed files with 2347 additions and 676 deletions
--- a/.github/workflows/sisyphus-agent.yml
+++ b/.github/workflows/sisyphus-agent.yml
@@ -86,14 +86,19 @@ jobs:

          # Install OpenCode (skip if cached)
          if ! command -v opencode &>/dev/null; then
-            for i in 1 2 3; do
-              echo "Attempt $i: Installing OpenCode..."
-              curl -fsSL https://opencode.ai/install -o /tmp/opencode-install.sh
-              if file /tmp/opencode-install.sh | grep -q "shell script\|text"; then
-                bash /tmp/opencode-install.sh && break
+            echo "Installing OpenCode..."
+            curl -fsSL https://opencode.ai/install -o /tmp/opencode-install.sh
+            
+            # Try default installer first, fallback to pinned version if it fails
+            if file /tmp/opencode-install.sh | grep -q "shell script\|text"; then
+              if ! bash /tmp/opencode-install.sh 2>&1; then
+                echo "Default installer failed, trying with pinned version..."
+                bash /tmp/opencode-install.sh --version 1.0.204
              fi
-              echo "Download corrupted, retrying in 5s..."
-            done
+            else
+              echo "Download corrupted, trying direct install with pinned version..."
+              bash <(curl -fsSL https://opencode.ai/install) --version 1.0.204
+            fi
          fi
          opencode --version

--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,7 +1,7 @@
 # PROJECT KNOWLEDGE BASE

-**Generated:** 2025-12-24T17:07:00+09:00
-**Commit:** 0172241
+**Generated:** 2025-12-28T19:26:00+09:00
+**Commit:** 122e918
 **Branch:** dev

 ## OVERVIEW
--- a/README.ja.md
+++ b/README.ja.md
@@ -390,14 +390,47 @@ gh repo star code-yeongyu/oh-my-opencode
 </details>


+## アンインストール
+
+oh-my-opencode を削除するには：
+
+1. **OpenCode 設定からプラグインを削除**
+
+   `~/.config/opencode/opencode.json` (または `opencode.jsonc`) を編集し、`plugin` 配列から `"oh-my-opencode"` を削除します：
+
+   ```bash
+   # jq を使用する例
+   jq '.plugin = [.plugin[] | select(. != "oh-my-opencode")]' \
+       ~/.config/opencode/opencode.json > /tmp/oc.json && \
+       mv /tmp/oc.json ~/.config/opencode/opencode.json
+   ```
+
+2. **設定ファイルの削除 (オプション)**
+
+   ```bash
+   # ユーザー設定を削除
+   rm -f ~/.config/opencode/oh-my-opencode.json
+
+   # プロジェクト設定を削除 (存在する場合)
+   rm -f .opencode/oh-my-opencode.json
+   ```
+
+3. **削除の確認**
+
+   ```bash
+   opencode --version
+   # プラグインがロードされなくなっているはずです
+   ```
+
+
 ## 機能

 ### Agents: あなたの新しいチームメイト

 - **Sisyphus** (`anthropic/claude-opus-4-5`): **デフォルトエージェントです。** OpenCode のための強力な AI オーケストレーターです。専門のサブエージェントを活用して、複雑なタスクを計画、委任、実行します。バックグラウンドタスクへの委任と Todo ベースのワークフローを重視します。最大の推論能力を発揮するため、Claude Opus 4.5 と拡張思考 (32k token budget) を使用します。
 - **oracle** (`openai/gpt-5.2`): アーキテクチャ、コードレビュー、戦略立案のための専門アドバイザー。GPT-5.2 の卓越した論理的推論と深い分析能力を活用します。AmpCode からインスピレーションを得ました。
- **librarian** (`anthropic/claude-sonnet-4-5`): マルチリポジトリ分析、ドキュメント検索、実装例の調査を担当。Claude Sonnet 4.5 を使用して、深いコードベース理解と GitHub リサーチ、根拠に基づいた回答を提供します。AmpCode からインスピレーションを得ました。
- **explore** (`opencode/grok-code`): 高速なコードベース探索、ファイルパターンマッチング。Claude Code は Haiku を使用しますが、私たちは Grok を使います。現在無料であり、極めて高速で、ファイル探索タスクには十分な知能を備えているからです。Claude Code からインスピレーションを得ました。
+- **librarian** (`anthropic/claude-sonnet-4-5` または `google/gemini-3-flash`): マルチリポジトリ分析、ドキュメント検索、実装例の調査を担当。Antigravity 認証が設定されている場合は Gemini 3 Flash を使用し、それ以外は Claude Sonnet 4.5 を使用して、深いコードベース理解と GitHub リサーチ、根拠に基づいた回答を提供します。AmpCode からインスピレーションを得ました。
+- **explore** (`opencode/grok-code`、`google/gemini-3-flash`、または `anthropic/claude-haiku-4-5`): 高速なコードベース探索、ファイルパターンマッチング。Antigravity 認証が設定されている場合は Gemini 3 Flash を使用し、Claude max20 が利用可能な場合は Haiku を使用し、それ以外は Grok を使います。Claude Code からインスピレーションを得ました。
 - **frontend-ui-ux-engineer** (`google/gemini-3-pro-preview`): 開発者に転身したデザイナーという設定です。素晴らしい UI を作ります。美しく独創的な UI コードを生成することに長けた Gemini を使用します。
 - **document-writer** (`google/gemini-3-pro-preview`): テクニカルライティングの専門家という設定です。Gemini は文筆家であり、流れるような文章を書きます。
 - **multimodal-looker** (`google/gemini-3-flash`): 視覚コンテンツ解釈のための専門エージェント。PDF、画像、図表を分析して情報を抽出します。
@@ -457,6 +490,19 @@ Ask @explore for the policy on this feature
 - **ast_grep_search**: AST 認識コードパターン検索 (25言語対応)
 - **ast_grep_replace**: AST 認識コード置換

+#### セッション管理
+
+OpenCode セッション履歴をナビゲートおよび検索するためのツール：
+
+- **session_list**: 日付およびリミットでフィルタリングしながらすべての OpenCode セッションを一覧表示
+- **session_read**: 特定のセッションからメッセージと履歴を読み取る
+- **session_search**: セッションメッセージ全体を全文検索
+- **session_info**: セッションに関するメタデータと統計情報を取得
+
+これらのツールにより、エージェントは以前の会話を参照し、セッション間の継続性を維持できます。
+
+- **call_omo_agent**: 専門的な explore/librarian エージェントを起動。非同期実行のための `run_in_background` パラメータをサポート。
+
 #### Context Is All You Need
 - **Directory AGENTS.md / README.md Injector**: ファイルを読み込む際、`AGENTS.md` と `README.md` の内容を自動的に注入します。ファイルディレクトリからプロジェクトルートまで遡り、パス上の **すべて** の `AGENTS.md` ファイルを収集します。ネストされたディレクトリごとの指示をサポートします：
  ```
@@ -619,7 +665,7 @@ Oh My OpenCode は以下の場所からフックを読み込んで実行しま

 | プラットフォーム | ユーザー設定パス |
 |------------------|------------------|
-| **Windows** | `~/.config/opencode/oh-my-opencode.json` (優先) または `%APPDATA%\opencode\oh-my-opencode.json` (フォールバック) |
+| **Windows** | `~/.config/opencode/oh-my-opencode.json` (推奨) または `%APPDATA%\opencode\oh-my-opencode.json` (fallback) |
 | **macOS/Linux** | `~/.config/opencode/oh-my-opencode.json` |

 スキーマ自動補完がサポートされています：
@@ -630,6 +676,36 @@ Oh My OpenCode は以下の場所からフックを読み込んで実行しま
 }
 ```

+### JSONC のサポート
+
+`oh-my-opencode` 設定ファイルは JSONC (コメント付き JSON) をサポートしています：
+- 行コメント: `// コメント`
+- ブロックコメント: `/* コメント */`
+- 末尾のカンマ: `{ "key": "value", }`
+
+`oh-my-opencode.jsonc` と `oh-my-opencode.json` の両方が存在する場合、`.jsonc` が優先されます。
+
+**コメント付きの例：**
+
+```jsonc
+{
+  "$schema": "https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/master/assets/oh-my-opencode.schema.json",
+  
+  // Antigravity OAuth 経由で Google Gemini を有効にする
+  "google_auth": false,
+  
+  /* エージェントのオーバーライド - 特定のタスクに合わせてモデルをカスタマイズ */
+  "agents": {
+    "oracle": {
+      "model": "openai/gpt-5.2"  // 戦略的な推論のための GPT
+    },
+    "explore": {
+      "model": "opencode/grok-code"  // 探索のための高速かつ無料のモデル
+    },
+  },
+}
+```
+
 ### Google Auth

 **推奨**: 外部の [`opencode-antigravity-auth`](https://github.com/NoeFabris/opencode-antigravity-auth) プラグインを使用してください。マルチアカウントロードバランシング、より多くのモデル（Antigravity 経由の Claude を含む）、活発なメンテナンスを提供します。[インストール > Google Gemini](#42-google-gemini-antigravity-oauth) を参照。
@@ -792,7 +868,7 @@ Oh My OpenCode は以下の場所からフックを読み込んで実行しま
 }
 ```

-利用可能なフック：`todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `tool-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`, `interactive-bash-session`, `empty-message-sanitizer`
+利用可能なフック：`todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `tool-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`, `interactive-bash-session`, `empty-message-sanitizer`, `preemptive-compaction`, `compaction-context-injector`, `thinking-block-validator`, `claude-code-hooks`

 **`auto-update-checker`と`startup-toast`について**: `startup-toast` フックは `auto-update-checker` のサブ機能です。アップデートチェックは有効なまま起動トースト通知のみを無効化するには、`disabled_hooks` に `"startup-toast"` を追加してください。すべてのアップデートチェック機能（トーストを含む）を無効化するには、`"auto-update-checker"` を追加してください。

@@ -857,7 +933,7 @@ OpenCode でサポートされるすべての LSP 構成およびカスタム設
 | `aggressive_truncation`     | `false`    | トークン制限を超えた場合、ツール出力を積極的に切り詰めて制限内に収めます。デフォルトの切り詰めより積極的です。不十分な場合は要約/復元にフォールバックします。                 |
 | `auto_resume`               | `false`    | thinking block エラーや thinking disabled violation からの回復成功後、自動的にセッションを再開します。最後のユーザーメッセージを抽出して続行します。                        |
 | `truncate_all_tool_outputs` | `true`     | プロンプトが長くなりすぎるのを防ぐため、コンテキストウィンドウの使用状況に基づいてすべてのツール出力を動的に切り詰めます。完全なツール出力が必要な場合は`false`に設定して無効化します。 |
-| `dcp_on_compaction_failure` | `false`    | 有効にすると、DCP（Dynamic Context Pruning）はコンパクション（要約）が失敗した後にのみ実行され、その後コンパクションを再試行します。通常時は DCP は実行されません。トークン制限に達した際によりスマートな回復が必要な場合は有効にしてください。 |
+| `dcp_for_compaction`        | `false`    | 有効にすると、トークン制限エラー発生時にDCP（Dynamic Context Pruning）が最初に実行され、その後コンパクションが実行されます。DCPが不要なコンテキストを整理した後、すぐにコンパクションが進行します。トークン制限に達した際によりスマートな回復が必要な場合は有効にしてください。 |

 **警告**：これらの機能は実験的であり、予期しない動作を引き起こす可能性があります。影響を理解した場合にのみ有効にしてください。

--- a/README.ko.md
+++ b/README.ko.md
@@ -387,14 +387,47 @@ gh repo star code-yeongyu/oh-my-opencode
 </details>


+## 언인스톨
+
+oh-my-opencode를 제거하려면:
+
+1. **OpenCode 설정에서 플러그인 제거**
+
+   `~/.config/opencode/opencode.json` (또는 `opencode.jsonc`)를 편집하여 `plugin` 배열에서 `"oh-my-opencode"`를 제거합니다:
+
+   ```bash
+   # jq 사용 예시
+   jq '.plugin = [.plugin[] | select(. != "oh-my-opencode")]' \
+       ~/.config/opencode/opencode.json > /tmp/oc.json && \
+       mv /tmp/oc.json ~/.config/opencode/opencode.json
+   ```
+
+2. **설정 파일 삭제 (선택 사항)**
+
+   ```bash
+   # 사용자 설정 삭제
+   rm -f ~/.config/opencode/oh-my-opencode.json
+
+   # 프로젝트 설정 삭제 (존재하는 경우)
+   rm -f .opencode/oh-my-opencode.json
+   ```
+
+3. **제거 확인**
+
+   ```bash
+   opencode --version
+   # 플러그인이 더 이상 로드되지 않아야 합니다
+   ```
+
+
 ## 기능

 ### Agents: 당신의 새로운 팀원들

 - **Sisyphus** (`anthropic/claude-opus-4-5`): **기본 에이전트입니다.** OpenCode를 위한 강력한 AI 오케스트레이터입니다. 전문 서브에이전트를 활용하여 복잡한 작업을 계획, 위임, 실행합니다. 백그라운드 태스크 위임과 todo 기반 워크플로우를 강조합니다. 최대 추론 능력을 위해 Claude Opus 4.5와 확장된 사고(32k 버짓)를 사용합니다.
 - **oracle** (`openai/gpt-5.2`): 아키텍처, 코드 리뷰, 전략 수립을 위한 전문가 조언자. GPT-5.2의 뛰어난 논리적 추론과 깊은 분석 능력을 활용합니다. AmpCode 에서 영감을 받았습니다.
- **librarian** (`anthropic/claude-sonnet-4-5`): 멀티 레포 분석, 문서 조회, 구현 예제 담당. Claude Sonnet 4.5를 사용하여 깊은 코드베이스 이해와 GitHub 조사, 근거 기반의 답변을 제공합니다. AmpCode 에서 영감을 받았습니다.
- **explore** (`opencode/grok-code`): 빠른 코드베이스 탐색, 파일 패턴 매칭. Claude Code는 Haiku를 쓰지만, 우리는 Grok을 씁니다. 현재 무료이고, 극도로 빠르며, 파일 탐색 작업에 충분한 지능을 갖췄기 때문입니다. Claude Code 에서 영감을 받았습니다.
+- **librarian** (`anthropic/claude-sonnet-4-5` 또는 `google/gemini-3-flash`): 멀티 레포 분석, 문서 조회, 구현 예제 담당. Antigravity 인증이 설정된 경우 Gemini 3 Flash를 사용하고, 그렇지 않으면 Claude Sonnet 4.5를 사용하여 깊은 코드베이스 이해와 GitHub 조사, 근거 기반의 답변을 제공합니다. AmpCode 에서 영감을 받았습니다.
+- **explore** (`opencode/grok-code`, `google/gemini-3-flash`, 또는 `anthropic/claude-haiku-4-5`): 빠른 코드베이스 탐색, 파일 패턴 매칭. Antigravity 인증이 설정된 경우 Gemini 3 Flash를 사용하고, Claude max20이 있으면 Haiku를 사용하며, 그 외에는 Grok을 씁니다. Claude Code 에서 영감을 받았습니다.
 - **frontend-ui-ux-engineer** (`google/gemini-3-pro-preview`): 개발자로 전향한 디자이너라는 설정을 갖고 있습니다. 멋진 UI를 만듭니다. 아름답고 창의적인 UI 코드를 생성하는 데 탁월한 Gemini를 사용합니다.
 - **document-writer** (`google/gemini-3-pro-preview`): 기술 문서 전문가라는 설정을 갖고 있습니다. Gemini 는 문학가입니다. 글을 기가막히게 씁니다.
 - **multimodal-looker** (`google/gemini-3-flash`): 시각적 콘텐츠 해석을 위한 전문 에이전트. PDF, 이미지, 다이어그램을 분석하여 정보를 추출합니다.
@@ -450,6 +483,18 @@ Syntax Highlighting, Autocomplete, Refactoring, Navigation, Analysis, 그리고
 - **lsp_code_action_resolve**: 코드 액션 적용
 - **ast_grep_search**: AST 인식 코드 패턴 검색 (25개 언어)
 - **ast_grep_replace**: AST 인식 코드 교체
+- **call_omo_agent**: 전문 explore/librarian 에이전트를 생성합니다. 비동기 실행을 위한 `run_in_background` 파라미터를 지원합니다.
+
+#### 세션 관리 (Session Management)
+
+OpenCode 세션 히스토리를 탐색하고 검색하기 위한 도구들입니다:
+
+- **session_list**: 날짜 및 개수 제한 필터링을 포함한 모든 OpenCode 세션 목록 조회
+- **session_read**: 특정 세션의 메시지 및 히스토리 읽기
+- **session_search**: 세션 메시지 전체 텍스트 검색
+- **session_info**: 세션에 대한 메타데이터 및 통계 정보 조회
+
+이 도구들을 통해 에이전트는 이전 대화를 참조하고 세션 간의 연속성을 유지할 수 있습니다.

 #### Context is all you need.
 - **Directory AGENTS.md / README.md Injector**: 파일을 읽을 때 `AGENTS.md`, `README.md` 내용을 자동으로 주입합니다. 파일 디렉토리부터 프로젝트 루트까지 탐색하며, 경로 상의 **모든** `AGENTS.md` 파일을 수집합니다. 중첩된 디렉토리별 지침을 지원합니다:
@@ -602,6 +647,10 @@ Oh My OpenCode는 다음 위치의 훅을 읽고 실행합니다:
 - **Empty Message Sanitizer**: 빈 채팅 메시지로 인한 API 오류를 방지합니다. 전송 전 메시지 내용을 자동으로 정리합니다.
 - **Grep Output Truncator**: grep은 산더미 같은 텍스트를 반환할 수 있습니다. 남은 컨텍스트 윈도우에 따라 동적으로 출력을 축소합니다—50% 여유 공간 유지, 최대 50k 토큰.
 - **Tool Output Truncator**: 같은 아이디어, 더 넓은 범위. Grep, Glob, LSP 도구, AST-grep의 출력을 축소합니다. 한 번의 장황한 검색이 전체 컨텍스트를 잡아먹는 것을 방지합니다.
+- **선제적 압축 (Preemptive Compaction)**: 세션 토큰 한계에 도달하기 전에 선제적으로 세션을 압축합니다. 문제가 발생하기 전에 미리 실행됩니다.
+- **압축 컨텍스트 주입기 (Compaction Context Injector)**: 세션 압축 중에 중요한 컨텍스트(AGENTS.md, 현재 디렉토리 정보 등)를 유지하여 중요한 상태를 잃지 않도록 합니다.
+- **사고 블록 검증기 (Thinking Block Validator)**: 사고(thinking) 블록의 형식이 올바른지 검증하여 잘못된 형식으로 인한 API 오류를 방지합니다.
+- **Claude Code 훅 (Claude Code Hooks)**: Claude Code의 settings.json에 설정된 훅을 실행합니다. PreToolUse/PostToolUse/UserPromptSubmit/Stop 이벤트를 지원하는 호환성 레이어입니다.

 ## 설정

@@ -613,7 +662,7 @@ Oh My OpenCode는 다음 위치의 훅을 읽고 실행합니다:

 | 플랫폼 | 사용자 설정 경로 |
 |--------|------------------|
-| **Windows** | `~/.config/opencode/oh-my-opencode.json` (우선) 또는 `%APPDATA%\opencode\oh-my-opencode.json` (fallback) |
+| **Windows** | `~/.config/opencode/oh-my-opencode.json` (권장) 또는 `%APPDATA%\opencode\oh-my-opencode.json` (fallback) |
 | **macOS/Linux** | `~/.config/opencode/oh-my-opencode.json` |

 Schema 자동 완성이 지원됩니다:
@@ -624,6 +673,36 @@ Schema 자동 완성이 지원됩니다:
 }
 ```

+### JSONC 지원
+
+`oh-my-opencode` 설정 파일은 JSONC(주석이 포함된 JSON)를 지원합니다:
+- 한 줄 주석: `// 주석`
+- 블록 주석: `/* 주석 */`
+- 후행 콤마(Trailing commas): `{ "key": "value", }`
+
+`oh-my-opencode.jsonc`와 `oh-my-opencode.json` 파일이 모두 존재할 경우, `.jsonc` 파일이 우선순위를 갖습니다.
+
+**주석이 포함된 예시:**
+
+```jsonc
+{
+  "$schema": "https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/master/assets/oh-my-opencode.schema.json",
+  
+  // Antigravity OAuth를 통해 Google Gemini 활성화
+  "google_auth": false,
+  
+  /* 에이전트 오버라이드 - 특정 작업에 대한 모델 커스터마이징 */
+  "agents": {
+    "oracle": {
+      "model": "openai/gpt-5.2"  // 전략적 추론을 위한 GPT
+    },
+    "explore": {
+      "model": "opencode/grok-code"  // 탐색을 위한 빠르고 무료인 모델
+    },
+  },
+}
+```
+
 ### Google Auth

 **권장**: 외부 [`opencode-antigravity-auth`](https://github.com/NoeFabris/opencode-antigravity-auth) 플러그인을 사용하세요. 멀티 계정 로드밸런싱, 더 많은 모델(Antigravity를 통한 Claude 포함), 활발한 유지보수를 제공합니다. [설치 > Google Gemini](#42-google-gemini-antigravity-oauth) 참조.
@@ -786,7 +865,7 @@ Schema 자동 완성이 지원됩니다:
 }
 ```

-사용 가능한 훅: `todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `tool-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`, `interactive-bash-session`, `empty-message-sanitizer`
+사용 가능한 훅: `todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `tool-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`, `interactive-bash-session`, `empty-message-sanitizer`, `preemptive-compaction`, `compaction-context-injector`, `thinking-block-validator`, `claude-code-hooks`

 **`auto-update-checker`와 `startup-toast`에 대한 참고사항**: `startup-toast` 훅은 `auto-update-checker`의 하위 기능입니다. 업데이트 확인은 유지하면서 시작 토스트 알림만 비활성화하려면 `disabled_hooks`에 `"startup-toast"`를 추가하세요. 모든 업데이트 확인 기능(토스트 포함)을 비활성화하려면 `"auto-update-checker"`를 추가하세요.

@@ -851,7 +930,7 @@ OpenCode 에서 지원하는 모든 LSP 구성 및 커스텀 설정 (opencode.js
 | `aggressive_truncation`     | `false` | 토큰 제한을 초과하면 도구 출력을 공격적으로 잘라내어 제한 내에 맞춥니다. 기본 truncation보다 더 공격적입니다. 부족하면 요약/복구로 fallback합니다.                      |
 | `auto_resume`               | `false` | thinking block 에러나 thinking disabled violation으로부터 성공적으로 복구한 후 자동으로 세션을 재개합니다. 마지막 사용자 메시지를 추출하여 계속합니다.                |
 | `truncate_all_tool_outputs` | `true`  | 프롬프트가 너무 길어지는 것을 방지하기 위해 컨텍스트 윈도우 사용량에 따라 모든 도구 출력을 동적으로 잘라냅니다. 전체 도구 출력이 필요한 경우 `false`로 설정하여 비활성화하세요. |
-| `dcp_on_compaction_failure` | `false` | 활성화하면, DCP(Dynamic Context Pruning)가 compaction(요약) 실패 후에만 실행되고 compaction을 재시도합니다. DCP는 평소에는 실행되지 않습니다. 토큰 제한에 도달했을 때 더 스마트한 복구를 원하면 활성화하세요. |
+| `dcp_for_compaction`        | `false` | 활성화하면, 토큰 제한 에러 발생 시 DCP(Dynamic Context Pruning)가 가장 먼저 실행되고, 그 다음 compaction이 실행됩니다. DCP가 불필요한 컨텍스트를 정리한 후 바로 compaction이 진행됩니다. 토큰 제한에 도달했을 때 더 스마트한 복구를 원하면 활성화하세요. |

 **경고**: 이 기능들은 실험적이며 예상치 못한 동작을 유발할 수 있습니다. 의미를 이해한 경우에만 활성화하세요.

--- a/README.md
+++ b/README.md
@@ -465,8 +465,8 @@ To remove oh-my-opencode:

 - **Sisyphus** (`anthropic/claude-opus-4-5`): **The default agent.** A powerful AI orchestrator for OpenCode. Plans, delegates, and executes complex tasks using specialized subagents with aggressive parallel execution. Emphasizes background task delegation and todo-driven workflow. Uses Claude Opus 4.5 with extended thinking (32k budget) for maximum reasoning capability.
 - **oracle** (`openai/gpt-5.2`): Architecture, code review, strategy. Uses GPT-5.2 for its stellar logical reasoning and deep analysis. Inspired by AmpCode.
- **librarian** (`anthropic/claude-sonnet-4-5`): Multi-repo analysis, doc lookup, implementation examples. Uses Claude Sonnet 4.5 for deep codebase understanding and GitHub research with evidence-based answers. Inspired by AmpCode.
- **explore** (`opencode/grok-code`): Fast codebase exploration and pattern matching. Claude Code uses Haiku; we use Grok—it's free, blazing fast, and plenty smart for file traversal. Inspired by Claude Code.
+- **librarian** (`anthropic/claude-sonnet-4-5` or `google/gemini-3-flash`): Multi-repo analysis, doc lookup, implementation examples. Uses Gemini 3 Flash when Antigravity auth is configured, otherwise Claude Sonnet 4.5 for deep codebase understanding and GitHub research with evidence-based answers. Inspired by AmpCode.
+- **explore** (`opencode/grok-code`, `google/gemini-3-flash`, or `anthropic/claude-haiku-4-5`): Fast codebase exploration and pattern matching. Uses Gemini 3 Flash when Antigravity auth is configured, Haiku when Claude max20 is available, otherwise Grok. Inspired by Claude Code.
 - **frontend-ui-ux-engineer** (`google/gemini-3-pro-high`): A designer turned developer. Builds gorgeous UIs. Gemini excels at creative, beautiful UI code.
 - **document-writer** (`google/gemini-3-flash`): Technical writing expert. Gemini is a wordsmith—writes prose that flows.
 - **multimodal-looker** (`google/gemini-3-flash`): Visual content specialist. Analyzes PDFs, images, diagrams to extract information.
@@ -522,6 +522,18 @@ Hand your best tools to your best colleagues. Now they can properly refactor, na
 - **lsp_code_action_resolve**: Apply code action
 - **ast_grep_search**: AST-aware code pattern search (25 languages)
 - **ast_grep_replace**: AST-aware code replacement
+- **call_omo_agent**: Spawn specialized explore/librarian agents. Supports `run_in_background` parameter for async execution.
+
+#### Session Management
+
+Tools to navigate and search your OpenCode session history:
+
+- **session_list**: List all OpenCode sessions with filtering by date and limit
+- **session_read**: Read messages and history from a specific session
+- **session_search**: Full-text search across session messages
+- **session_info**: Get metadata and statistics about a session
+
+These tools enable agents to reference previous conversations and maintain continuity across sessions.

 #### Context Is All You Need
 - **Directory AGENTS.md / README.md Injector**: Auto-injects `AGENTS.md` and `README.md` when reading files. Walks from file directory to project root, collecting **all** `AGENTS.md` files along the path. Supports nested directory-specific instructions:
@@ -674,6 +686,10 @@ When agents thrive, you thrive. But I want to help you directly too.
 - **Empty Message Sanitizer**: Prevents API errors from empty chat messages by automatically sanitizing message content before sending.
 - **Grep Output Truncator**: Grep can return mountains of text. This dynamically truncates output based on your remaining context window—keeps 50% headroom, caps at 50k tokens.
 - **Tool Output Truncator**: Same idea, broader scope. Truncates output from Grep, Glob, LSP tools, and AST-grep. Prevents one verbose search from eating your entire context.
+- **Preemptive Compaction**: Compacts session proactively before hitting hard token limits. Runs before you get into trouble.
+- **Compaction Context Injector**: Preserves critical context (AGENTS.md, current directory info) during session compaction so you don't lose important state.
+- **Thinking Block Validator**: Validates thinking blocks to ensure proper formatting and prevent API errors from malformed thinking content.
+- **Claude Code Hooks**: Executes hooks from Claude Code's settings.json - this is the compatibility layer that runs PreToolUse/PostToolUse/UserPromptSubmit/Stop hooks.

 ## Configuration

@@ -888,7 +904,7 @@ Disable specific built-in hooks via `disabled_hooks` in `~/.config/opencode/oh-m
 }
 ```

-Available hooks: `todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `tool-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`, `interactive-bash-session`, `empty-message-sanitizer`
+Available hooks: `todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `tool-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`, `interactive-bash-session`, `empty-message-sanitizer`, `preemptive-compaction`, `compaction-context-injector`, `thinking-block-validator`, `claude-code-hooks`

 **Note on `auto-update-checker` and `startup-toast`**: The `startup-toast` hook is a sub-feature of `auto-update-checker`. To disable only the startup toast notification while keeping update checking enabled, add `"startup-toast"` to `disabled_hooks`. To disable all update checking features (including the toast), add `"auto-update-checker"` to `disabled_hooks`.

@@ -953,7 +969,7 @@ Opt-in experimental features that may change or be removed in future versions. U
 | `aggressive_truncation`     | `false` | When token limit is exceeded, aggressively truncates tool outputs to fit within limits. More aggressive than the default truncation behavior. Falls back to summarize/revert if insufficient. |
 | `auto_resume`               | `false` | Automatically resumes session after successful recovery from thinking block errors or thinking disabled violations. Extracts the last user message and continues.                            |
 | `truncate_all_tool_outputs` | `true`  | Dynamically truncates ALL tool outputs based on context window usage to prevent prompts from becoming too long. Disable by setting to `false` if you need full tool outputs.                 |
-| `dcp_on_compaction_failure` | `false` | When enabled, Dynamic Context Pruning (DCP) runs only after compaction (summarize) fails, then retries compaction. DCP does NOT run during normal operations. Enable this for smarter recovery when hitting token limits. |
+| `dcp_for_compaction`        | `false` | When enabled, Dynamic Context Pruning (DCP) runs FIRST when token limit errors occur, before attempting compaction. DCP prunes redundant context, then compaction runs immediately. Enable this for smarter recovery when hitting token limits. |

 **Warning**: These features are experimental and may cause unexpected behavior. Enable only if you understand the implications.

--- a/README.zh-cn.md
+++ b/README.zh-cn.md
@@ -398,14 +398,47 @@ gh repo star code-yeongyu/oh-my-opencode
 </details>


+## 卸载
+
+要移除 oh-my-opencode：
+
+1. **从 OpenCode 配置中移除插件**
+
+   编辑 `~/.config/opencode/opencode.json` (或 `opencode.jsonc`)，从 `plugin` 数组中移除 `"oh-my-opencode"`：
+
+   ```bash
+   # 使用 jq 的示例
+   jq '.plugin = [.plugin[] | select(. != "oh-my-opencode")]' \
+       ~/.config/opencode/opencode.json > /tmp/oc.json && \
+       mv /tmp/oc.json ~/.config/opencode/opencode.json
+   ```
+
+2. **删除配置文件 (可选)**
+
+   ```bash
+   # 删除用户配置
+   rm -f ~/.config/opencode/oh-my-opencode.json
+
+   # 删除项目配置 (如果存在)
+   rm -f .opencode/oh-my-opencode.json
+   ```
+
+3. **确认移除**
+
+   ```bash
+   opencode --version
+   # 插件不应再被加载
+   ```
+
+
 ## 功能

 ### Agents：你的神队友

 - **Sisyphus** (`anthropic/claude-opus-4-5`)：**默认 Agent。** OpenCode 专属的强力 AI 编排器。指挥专业子 Agent 搞定复杂任务。主打后台任务委派和 Todo 驱动。用 Claude Opus 4.5 加上扩展思考（32k token 预算），智商拉满。
 - **oracle** (`openai/gpt-5.2`)：架构师、代码审查员、战略家。GPT-5.2 的逻辑推理和深度分析能力不是盖的。致敬 AmpCode。
- **librarian** (`anthropic/claude-sonnet-4-5`)：多仓库分析、查文档、找示例。Claude Sonnet 4.5 深入理解代码库，GitHub 调研，给出的答案都有据可查。致敬 AmpCode。
- **explore** (`opencode/grok-code`)：极速代码库扫描、模式匹配。Claude Code 用 Haiku，我们用 Grok——免费、飞快、扫文件够用了。致敬 Claude Code。
+- **librarian** (`anthropic/claude-sonnet-4-5` 或 `google/gemini-3-flash`)：多仓库分析、查文档、找示例。配置 Antigravity 认证时使用 Gemini 3 Flash，否则使用 Claude Sonnet 4.5 深入理解代码库，GitHub 调研，给出的答案都有据可查。致敬 AmpCode。
+- **explore** (`opencode/grok-code`、`google/gemini-3-flash` 或 `anthropic/claude-haiku-4-5`)：极速代码库扫描、模式匹配。配置 Antigravity 认证时使用 Gemini 3 Flash，Claude max20 可用时使用 Haiku，否则用 Grok。致敬 Claude Code。
 - **frontend-ui-ux-engineer** (`google/gemini-3-pro-preview`)：设计师出身的程序员。UI 做得那是真漂亮。Gemini 写这种创意美观的代码是一绝。
 - **document-writer** (`google/gemini-3-pro-preview`)：技术写作专家。Gemini 文笔好，写出来的东西读着顺畅。
 - **multimodal-looker** (`google/gemini-3-flash`)：视觉内容专家。PDF、图片、图表，看一眼就知道里头有啥。
@@ -461,6 +494,18 @@ OhMyOpenCode 让这些成为可能。
 - **lsp_code_action_resolve**：应用代码操作
 - **ast_grep_search**：AST 感知代码搜索（支持 25 种语言）
 - **ast_grep_replace**：AST 感知代码替换
+- **call_omo_agent**: 产生专门的 explore/librarian Agent。支持用于异步执行的 `run_in_background` 参数。
+
+#### 会话管理 (Session Management)
+
+用于导航和搜索 OpenCode 会话历史的工具：
+
+- **session_list**: 列出所有 OpenCode 会话，支持按日期和数量限制进行过滤
+- **session_read**: 读取特定会话的消息和历史记录
+- **session_search**: 在会话消息中进行全文搜索
+- **session_info**: 获取有关会话的元数据和统计信息
+
+这些工具使 Agent 能够引用之前的对话并保持跨会话的连续性。

 #### 上下文就是一切 (Context is all you need)
 - **Directory AGENTS.md / README.md 注入器**：读文件时自动把 `AGENTS.md` 和 `README.md` 塞进去。从当前目录一路往上找，路径上**所有** `AGENTS.md` 全都带上。支持嵌套指令：
@@ -620,7 +665,12 @@ Agent 爽了，你自然也爽。但我还想直接让你爽。

 配置文件（优先级从高到低）：
 1. `.opencode/oh-my-opencode.json`（项目级）
-2. `~/.config/opencode/oh-my-opencode.json`（用户级）
+2. 用户配置（按平台）：
+
+| 平台 | 用户配置路径 |
+|----------|------------------|
+| **Windows** | `~/.config/opencode/oh-my-opencode.json` (首选) 或 `%APPDATA%\opencode\oh-my-opencode.json` (备选) |
+| **macOS/Linux** | `~/.config/opencode/oh-my-opencode.json` |

 支持 Schema 自动补全：

@@ -630,6 +680,36 @@ Agent 爽了，你自然也爽。但我还想直接让你爽。
 }
 ```

+### JSONC 支持
+
+`oh-my-opencode` 配置文件支持 JSONC（带注释的 JSON）：
+- 行注释：`// 注释`
+- 块注释：`/* 注释 */`
+- 尾随逗号：`{ "key": "value", }`
+
+当 `oh-my-opencode.jsonc` 和 `oh-my-opencode.json` 文件同时存在时，`.jsonc` 优先。
+
+**带注释的示例：**
+
+```jsonc
+{
+  "$schema": "https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/master/assets/oh-my-opencode.schema.json",
+  
+  // 通过 Antigravity OAuth 启用 Google Gemini
+  "google_auth": false,
+  
+  /* Agent 覆盖 - 为特定任务自定义模型 */
+  "agents": {
+    "oracle": {
+      "model": "openai/gpt-5.2"  // 用于战略推理的 GPT
+    },
+    "explore": {
+      "model": "opencode/grok-code"  // 快速且免费的搜索模型
+    },
+  },
+}
+```
+
 ### Google Auth

 **强推**：用外部 [`opencode-antigravity-auth`](https://github.com/NoeFabris/opencode-antigravity-auth) 插件。多账号负载均衡、更多模型（包括 Antigravity 版 Claude）、有人维护。看 [安装 > Google Gemini](#42-google-gemini-antigravity-oauth)。
@@ -792,7 +872,7 @@ Sisyphus Agent 也能自定义：
 }
 ```

-可关的 hook：`todo-continuation-enforcer`、`context-window-monitor`、`session-recovery`、`session-notification`、`comment-checker`、`grep-output-truncator`、`tool-output-truncator`、`directory-agents-injector`、`directory-readme-injector`、`empty-task-response-detector`、`think-mode`、`anthropic-auto-compact`、`rules-injector`、`background-notification`、`auto-update-checker`、`startup-toast`、`keyword-detector`、`agent-usage-reminder`、`non-interactive-env`、`interactive-bash-session`、`empty-message-sanitizer`
+可关的 hook：`todo-continuation-enforcer`、`context-window-monitor`、`session-recovery`、`session-notification`、`comment-checker`、`grep-output-truncator`、`tool-output-truncator`、`directory-agents-injector`、`directory-readme-injector`、`empty-task-response-detector`、`think-mode`、`anthropic-auto-compact`、`rules-injector`、`background-notification`、`auto-update-checker`、`startup-toast`、`keyword-detector`、`agent-usage-reminder`、`non-interactive-env`、`interactive-bash-session`、`empty-message-sanitizer`、`preemptive-compaction`、`compaction-context-injector`、`thinking-block-validator`、`claude-code-hooks`

 **关于 `auto-update-checker` 和 `startup-toast`**: `startup-toast` hook 是 `auto-update-checker` 的子功能。若想保持更新检查但只禁用启动提示通知，在 `disabled_hooks` 中添加 `"startup-toast"`。若要禁用所有更新检查功能（包括提示），添加 `"auto-update-checker"`。

@@ -857,7 +937,7 @@ Oh My OpenCode 送你重构工具（重命名、代码操作）。
 | `aggressive_truncation`     | `false` | 超出 token 限制时，激进地截断工具输出以适应限制。比默认截断更激进。不够的话会回退到摘要/恢复。                                                     |
 | `auto_resume`               | `false` | 从 thinking block 错误或 thinking disabled violation 成功恢复后，自动恢复会话。提取最后一条用户消息继续执行。                                     |
 | `truncate_all_tool_outputs` | `true`  | 为防止提示过长，根据上下文窗口使用情况动态截断所有工具输出。如需完整工具输出，设置为 `false` 禁用此功能。                                           |
-| `dcp_on_compaction_failure` | `false` | 启用后，DCP（动态上下文剪枝）仅在压缩（摘要）失败后运行，然后重试压缩。平时 DCP 不会运行。当达到 token 限制时需要更智能的恢复请启用此选项。                   |
+| `dcp_for_compaction`        | `false` | 启用后，当发生 token 限制错误时，DCP（动态上下文剪枝）首先运行，然后立即执行压缩。DCP 清理不必要的上下文后，压缩立即进行。当达到 token 限制时需要更智能的恢复请启用此选项。 |

 **警告**：这些功能是实验性的，可能会导致意外行为。只有在理解其影响的情况下才启用。

--- a/assets/oh-my-opencode.schema.json
+++ b/assets/oh-my-opencode.schema.json
@@ -64,6 +64,15 @@
        ]
      }
    },
+    "disabled_commands": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": [
+          "init-deep"
+        ]
+      }
+    },
    "agents": {
      "type": "object",
      "properties": {
@@ -1375,6 +1384,14 @@
        }
      }
    },
+    "comment_checker": {
+      "type": "object",
+      "properties": {
+        "custom_prompt": {
+          "type": "string"
+        }
+      }
+    },
    "experimental": {
      "type": "object",
      "properties": {
@@ -1487,7 +1504,7 @@
            }
          }
        },
-        "dcp_on_compaction_failure": {
+        "dcp_for_compaction": {
          "type": "boolean"
        }
      }
--- a/bun.lock
+++ b/bun.lock
@@ -8,7 +8,7 @@
        "@ast-grep/cli": "^0.40.0",
        "@ast-grep/napi": "^0.40.0",
        "@clack/prompts": "^0.11.0",
-        "@code-yeongyu/comment-checker": "^0.6.0",
+        "@code-yeongyu/comment-checker": "^0.6.1",
        "@openauthjs/openauth": "^0.4.3",
        "@opencode-ai/plugin": "^1.0.162",
        "@opencode-ai/sdk": "^1.0.162",
@@ -73,7 +73,7 @@

    "@clack/prompts": ["@clack/prompts@0.11.0", "", { "dependencies": { "@clack/core": "0.5.0", "picocolors": "^1.0.0", "sisteransi": "^1.0.5" } }, "sha512-pMN5FcrEw9hUkZA4f+zLlzivQSeQf5dRGJjSUbvVYDLvpKCdQx5OaknvKzgbtXOizhP+SJJJjqEbOe55uKKfAw=="],

-    "@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.6.0", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-VtDPrhbUJcb5BIS18VMcY/N/xSLbMr6dpU9MO1NYQyEDhI4pSIx07K4gOlCutG/nHVCjO+HEarn8rttODP+5UA=="],
+    "@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.6.1", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-BBremX+Y5aW8sTzlhHrLsKParupYkPOVUYmq9STrlWvBvfAme6w5IWuZCLl6nHIQScRDdvGdrAjPycJC86EZFA=="],

    "@openauthjs/openauth": ["@openauthjs/openauth@0.4.3", "", { "dependencies": { "@standard-schema/spec": "1.0.0-beta.3", "aws4fetch": "1.0.20", "jose": "5.9.6" }, "peerDependencies": { "arctic": "^2.2.2", "hono": "^4.0.0" } }, "sha512-RlnjqvHzqcbFVymEwhlUEuac4utA5h4nhSK/i2szZuQmxTIqbGUxZ+nM+avM+VV4Ing+/ZaNLKILoXS3yrkOOw=="],

--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "oh-my-opencode",
-  "version": "2.6.2",
+  "version": "2.7.1",
  "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
@@ -53,7 +53,7 @@
    "@ast-grep/cli": "^0.40.0",
    "@ast-grep/napi": "^0.40.0",
    "@clack/prompts": "^0.11.0",
-    "@code-yeongyu/comment-checker": "^0.6.0",
+    "@code-yeongyu/comment-checker": "^0.6.1",
    "@openauthjs/openauth": "^0.4.3",
    "@opencode-ai/plugin": "^1.0.162",
    "@opencode-ai/sdk": "^1.0.162",
--- a/signatures/cla.json
+++ b/signatures/cla.json
@@ -63,6 +63,14 @@
      "created_at": "2025-12-27T17:05:50Z",
      "repoId": 1108837393,
      "pullRequestNo": 288
+    },
+    {
+      "name": "SyedTahirHussan",
+      "id": 9879266,
+      "comment_id": 3694598917,
+      "created_at": "2025-12-28T09:24:03Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 306
    }
  ]
 }
--- a/src/agents/AGENTS.md
+++ b/src/agents/AGENTS.md
@@ -0,0 +1,89 @@
+# AGENTS KNOWLEDGE BASE
+
+## OVERVIEW
+
+AI agent definitions for multi-model orchestration. 7 specialized agents: Sisyphus (orchestrator), oracle (strategy), librarian (research), explore (grep), frontend-ui-ux-engineer, document-writer, multimodal-looker.
+
+## STRUCTURE
+
+```
+agents/
+├── sisyphus.ts              # Primary orchestrator (Claude Opus 4.5)
+├── oracle.ts                # Strategic advisor (GPT-5.2)
+├── librarian.ts             # Multi-repo research (Claude Sonnet 4.5)
+├── explore.ts               # Fast codebase grep (Grok Code)
+├── frontend-ui-ux-engineer.ts  # UI generation (Gemini 3 Pro)
+├── document-writer.ts       # Technical docs (Gemini 3 Flash)
+├── multimodal-looker.ts     # PDF/image analysis (Gemini 3 Flash)
+├── build-prompt.ts          # Shared build agent prompt
+├── plan-prompt.ts           # Shared plan agent prompt
+├── types.ts                 # AgentModelConfig interface
+├── utils.ts                 # createBuiltinAgents(), getAgentName()
+└── index.ts                 # builtinAgents export
+```
+
+## AGENT MODELS
+
+| Agent | Default Model | Fallback | Purpose |
+|-------|---------------|----------|---------|
+| Sisyphus | anthropic/claude-opus-4-5 | - | Primary orchestrator with extended thinking |
+| oracle | openai/gpt-5.2 | - | Architecture, debugging, code review |
+| librarian | anthropic/claude-sonnet-4-5 | google/gemini-3-flash | Docs, OSS research, GitHub examples |
+| explore | opencode/grok-code | google/gemini-3-flash, anthropic/claude-haiku-4-5 | Fast contextual grep |
+| frontend-ui-ux-engineer | google/gemini-3-pro-preview | - | UI/UX code generation |
+| document-writer | google/gemini-3-pro-preview | - | Technical writing |
+| multimodal-looker | google/gemini-3-flash | - | PDF/image analysis |
+
+## HOW TO ADD AN AGENT
+
+1. Create `src/agents/my-agent.ts`:
+   ```typescript
+   import type { AgentConfig } from "@opencode-ai/sdk"
+   
+   export const myAgent: AgentConfig = {
+     model: "provider/model-name",
+     temperature: 0.1,
+     system: "Agent system prompt...",
+     tools: { include: ["tool1", "tool2"] },  // or exclude: [...]
+   }
+   ```
+2. Add to `builtinAgents` in `src/agents/index.ts`
+3. Update `types.ts` if adding new config options
+
+## AGENT CONFIG OPTIONS
+
+| Option | Type | Description |
+|--------|------|-------------|
+| model | string | Model identifier (provider/model-name) |
+| temperature | number | 0.0-1.0, most use 0.1 for consistency |
+| system | string | System prompt (can be multiline template literal) |
+| tools | object | `{ include: [...] }` or `{ exclude: [...] }` |
+| top_p | number | Optional nucleus sampling |
+| maxTokens | number | Optional max output tokens |
+
+## MODEL FALLBACK LOGIC
+
+`createBuiltinAgents()` in utils.ts handles model fallback:
+
+1. Check user config override (`agents.{name}.model`)
+2. Check installer settings (claude max20, gemini antigravity)
+3. Use default model
+
+**Fallback order for explore**:
+- If gemini antigravity enabled → `google/gemini-3-flash`
+- If claude max20 enabled → `anthropic/claude-haiku-4-5`
+- Default → `opencode/grok-code` (free)
+
+## ANTI-PATTERNS (AGENTS)
+
+- **High temperature**: Don't use >0.3 for code-related agents
+- **Broad tool access**: Prefer explicit `include` over unrestricted access
+- **Monolithic prompts**: Keep prompts focused; delegate to specialized agents
+- **Missing fallbacks**: Consider free/cheap fallbacks for rate-limited models
+
+## SHARED PROMPTS
+
+- **build-prompt.ts**: Base prompt for build agents (OpenCode default + Sisyphus variants)
+- **plan-prompt.ts**: Base prompt for plan agents (Planner-Sisyphus)
+
+Used by `src/index.ts` when creating Builder-Sisyphus and Planner-Sisyphus variants.
--- a/src/auth/antigravity/fetch.ts
+++ b/src/auth/antigravity/fetch.ts
@@ -17,16 +17,15 @@
 * Debug logging available via ANTIGRAVITY_DEBUG=1 environment variable.
 */

-import { ANTIGRAVITY_ENDPOINT_FALLBACKS, ANTIGRAVITY_DEFAULT_PROJECT_ID } from "./constants"
-import { fetchProjectContext, clearProjectContextCache } from "./project"
-import { isTokenExpired, refreshAccessToken, parseStoredToken, formatTokenForStorage } from "./token"
+import { ANTIGRAVITY_ENDPOINT_FALLBACKS } from "./constants"
+import { fetchProjectContext, clearProjectContextCache, invalidateProjectContextByRefreshToken } from "./project"
+import { isTokenExpired, refreshAccessToken, parseStoredToken, formatTokenForStorage, AntigravityTokenRefreshError } from "./token"
 import { transformRequest } from "./request"
 import { convertRequestBody, hasOpenAIMessages } from "./message-converter"
 import {
  transformResponse,
  transformStreamingResponse,
  isStreamingResponse,
-  extractSignatureFromSsePayload,
 } from "./response"
 import { normalizeToolsForGemini, type OpenAITool } from "./tools"
 import { extractThinkingBlocks, shouldIncludeThinking, transformResponseThinking } from "./thinking"
@@ -391,7 +390,6 @@ export function createAntigravityFetch(
      try {
        const newTokens = await refreshAccessToken(refreshParts.refreshToken, clientId, clientSecret)

-        // Update cached tokens
        cachedTokens = {
          type: "antigravity",
          access_token: newTokens.access_token,
@@ -400,10 +398,8 @@ export function createAntigravityFetch(
          timestamp: Date.now(),
        }

-        // Clear project context cache on token refresh
        clearProjectContextCache()

-        // Format and save new tokens
        const formattedRefresh = formatTokenForStorage(
          newTokens.refresh_token,
          refreshParts.projectId || "",
@@ -418,6 +414,16 @@ export function createAntigravityFetch(

        debugLog("Token refreshed successfully")
      } catch (error) {
+        if (error instanceof AntigravityTokenRefreshError) {
+          if (error.isInvalidGrant) {
+            debugLog(`[REFRESH] Token revoked (invalid_grant), clearing caches`)
+            invalidateProjectContextByRefreshToken(refreshParts.refreshToken)
+            clearProjectContextCache()
+          }
+          throw new Error(
+            `Antigravity: Token refresh failed: ${error.description || error.message}${error.code ? ` (${error.code})` : ""}`
+          )
+        }
        throw new Error(
          `Antigravity: Token refresh failed: ${error instanceof Error ? error.message : "Unknown error"}`
        )
@@ -535,11 +541,33 @@ export function createAntigravityFetch(
            debugLog("[401] Token refreshed, retrying request...")
            return executeWithEndpoints()
          } catch (refreshError) {
+            if (refreshError instanceof AntigravityTokenRefreshError) {
+              if (refreshError.isInvalidGrant) {
+                debugLog(`[401] Token revoked (invalid_grant), clearing caches`)
+                invalidateProjectContextByRefreshToken(refreshParts.refreshToken)
+                clearProjectContextCache()
+              }
+              debugLog(`[401] Token refresh failed: ${refreshError.description || refreshError.message}`)
+              return new Response(
+                JSON.stringify({
+                  error: {
+                    message: refreshError.description || refreshError.message,
+                    type: refreshError.isInvalidGrant ? "token_revoked" : "unauthorized",
+                    code: refreshError.code || "token_refresh_failed",
+                  },
+                }),
+                {
+                  status: 401,
+                  statusText: "Unauthorized",
+                  headers: { "Content-Type": "application/json" },
+                }
+              )
+            }
            debugLog(`[401] Token refresh failed: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`)
            return new Response(
              JSON.stringify({
                error: {
-                  message: `Token refresh failed: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`,
+                  message: refreshError instanceof Error ? refreshError.message : "Unknown error",
                  type: "unauthorized",
                  code: "token_refresh_failed",
                },
--- a/src/auth/antigravity/project.ts
+++ b/src/auth/antigravity/project.ts
@@ -267,3 +267,8 @@ export function clearProjectContextCache(accessToken?: string): void {
    projectContextCache.clear()
  }
 }
+
+export function invalidateProjectContextByRefreshToken(_refreshToken: string): void {
+  projectContextCache.clear()
+  debugLog(`[invalidateProjectContextByRefreshToken] Cleared all project context cache due to refresh token invalidation`)
+}
--- a/src/auth/antigravity/token.ts
+++ b/src/auth/antigravity/token.ts
@@ -1,8 +1,3 @@
-/**
- * Antigravity token management utilities.
- * Handles token expiration checking, refresh, and storage format parsing.
- */
-
 import {
  ANTIGRAVITY_CLIENT_ID,
  ANTIGRAVITY_CLIENT_SECRET,
@@ -13,33 +8,86 @@ import type {
  AntigravityRefreshParts,
  AntigravityTokenExchangeResult,
  AntigravityTokens,
+  OAuthErrorPayload,
+  ParsedOAuthError,
 } from "./types"

-/**
- * Check if the access token is expired.
- * Includes a 60-second safety buffer to refresh before actual expiration.
- *
- * @param tokens - The Antigravity tokens to check
- * @returns true if the token is expired or will expire within the buffer period
- */
-export function isTokenExpired(tokens: AntigravityTokens): boolean {
-  // Calculate when the token expires (timestamp + expires_in in ms)
-  // timestamp is in milliseconds, expires_in is in seconds
-  const expirationTime = tokens.timestamp + tokens.expires_in * 1000
+export class AntigravityTokenRefreshError extends Error {
+  code?: string
+  description?: string
+  status: number
+  statusText: string
+  responseBody?: string

-  // Check if current time is past (expiration - buffer)
+  constructor(options: {
+    message: string
+    code?: string
+    description?: string
+    status: number
+    statusText: string
+    responseBody?: string
+  }) {
+    super(options.message)
+    this.name = "AntigravityTokenRefreshError"
+    this.code = options.code
+    this.description = options.description
+    this.status = options.status
+    this.statusText = options.statusText
+    this.responseBody = options.responseBody
+  }
+
+  get isInvalidGrant(): boolean {
+    return this.code === "invalid_grant"
+  }
+
+  get isNetworkError(): boolean {
+    return this.status === 0
+  }
+}
+
+function parseOAuthErrorPayload(text: string | undefined): ParsedOAuthError {
+  if (!text) {
+    return {}
+  }
+
+  try {
+    const payload = JSON.parse(text) as OAuthErrorPayload
+    let code: string | undefined
+
+    if (typeof payload.error === "string") {
+      code = payload.error
+    } else if (payload.error && typeof payload.error === "object") {
+      code = payload.error.status ?? payload.error.code
+    }
+
+    return {
+      code,
+      description: payload.error_description,
+    }
+  } catch {
+    return { description: text }
+  }
+}
+
+export function isTokenExpired(tokens: AntigravityTokens): boolean {
+  const expirationTime = tokens.timestamp + tokens.expires_in * 1000
  return Date.now() >= expirationTime - ANTIGRAVITY_TOKEN_REFRESH_BUFFER_MS
 }

-/**
- * Refresh an access token using a refresh token.
- * Exchanges the refresh token for a new access token via Google's OAuth endpoint.
- *
- * @param refreshToken - The refresh token to use
- * @param clientId - Optional custom client ID (defaults to ANTIGRAVITY_CLIENT_ID)
- * @param clientSecret - Optional custom client secret (defaults to ANTIGRAVITY_CLIENT_SECRET)
- * @returns Token exchange result with new access token, or throws on error
- */
+const MAX_REFRESH_RETRIES = 3
+const INITIAL_RETRY_DELAY_MS = 1000
+
+function calculateRetryDelay(attempt: number): number {
+  return Math.min(INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt), 10000)
+}
+
+function isRetryableError(status: number): boolean {
+  if (status === 0) return true
+  if (status === 429) return true
+  if (status >= 500 && status < 600) return true
+  return false
+}
+
 export async function refreshAccessToken(
  refreshToken: string,
  clientId: string = ANTIGRAVITY_CLIENT_ID,
@@ -52,35 +100,81 @@ export async function refreshAccessToken(
    client_secret: clientSecret,
  })

-  const response = await fetch(GOOGLE_TOKEN_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-    },
-    body: params,
+  let lastError: AntigravityTokenRefreshError | undefined
+
+  for (let attempt = 0; attempt <= MAX_REFRESH_RETRIES; attempt++) {
+    try {
+      const response = await fetch(GOOGLE_TOKEN_URL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: params,
+      })
+
+      if (response.ok) {
+        const data = (await response.json()) as {
+          access_token: string
+          refresh_token?: string
+          expires_in: number
+          token_type: string
+        }
+
+        return {
+          access_token: data.access_token,
+          refresh_token: data.refresh_token || refreshToken,
+          expires_in: data.expires_in,
+          token_type: data.token_type,
+        }
+      }
+
+      const responseBody = await response.text().catch(() => undefined)
+      const parsed = parseOAuthErrorPayload(responseBody)
+
+      lastError = new AntigravityTokenRefreshError({
+        message: parsed.description || `Token refresh failed: ${response.status} ${response.statusText}`,
+        code: parsed.code,
+        description: parsed.description,
+        status: response.status,
+        statusText: response.statusText,
+        responseBody,
+      })
+
+      if (parsed.code === "invalid_grant") {
+        throw lastError
+      }
+
+      if (!isRetryableError(response.status)) {
+        throw lastError
+      }
+
+      if (attempt < MAX_REFRESH_RETRIES) {
+        const delay = calculateRetryDelay(attempt)
+        await new Promise((resolve) => setTimeout(resolve, delay))
+      }
+    } catch (error) {
+      if (error instanceof AntigravityTokenRefreshError) {
+        throw error
+      }
+
+      lastError = new AntigravityTokenRefreshError({
+        message: error instanceof Error ? error.message : "Network error during token refresh",
+        status: 0,
+        statusText: "Network Error",
+      })
+
+      if (attempt < MAX_REFRESH_RETRIES) {
+        const delay = calculateRetryDelay(attempt)
+        await new Promise((resolve) => setTimeout(resolve, delay))
+      }
+    }
+  }
+
+  throw lastError || new AntigravityTokenRefreshError({
+    message: "Token refresh failed after all retries",
+    status: 0,
+    statusText: "Max Retries Exceeded",
  })
-
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => "Unknown error")
-    throw new Error(
-      `Token refresh failed: ${response.status} ${response.statusText} - ${errorText}`
-    )
-  }
-
-  const data = (await response.json()) as {
-    access_token: string
-    refresh_token?: string
-    expires_in: number
-    token_type: string
-  }
-
-  return {
-    access_token: data.access_token,
-    // Google may return a new refresh token, fall back to the original
-    refresh_token: data.refresh_token || refreshToken,
-    expires_in: data.expires_in,
-    token_type: data.token_type,
-  }
 }

 /**
--- a/src/auth/antigravity/types.ts
+++ b/src/auth/antigravity/types.ts
@@ -194,3 +194,20 @@ export interface AntigravityRefreshParts {
  projectId?: string
  managedProjectId?: string
 }
+
+/**
+ * OAuth error payload from Google
+ * Google returns errors in multiple formats, this handles all of them
+ */
+export interface OAuthErrorPayload {
+  error?: string | { status?: string; code?: string; message?: string }
+  error_description?: string
+}
+
+/**
+ * Parsed OAuth error with normalized fields
+ */
+export interface ParsedOAuthError {
+  code?: string
+  description?: string
+}
--- a/src/cli/config-manager.ts
+++ b/src/cli/config-manager.ts
@@ -146,9 +146,16 @@ export function generateOmoConfig(installConfig: InstallConfig): Record<string,

  if (!installConfig.hasClaude) {
    agents["Sisyphus"] = { model: "opencode/big-pickle" }
+  }
+
+  if (installConfig.hasGemini) {
+    agents["librarian"] = { model: "google/gemini-3-flash" }
+    agents["explore"] = { model: "google/gemini-3-flash" }
+  } else if (installConfig.hasClaude && installConfig.isMax20) {
+    agents["explore"] = { model: "anthropic/claude-haiku-4-5" }
+  } else {
    agents["librarian"] = { model: "opencode/big-pickle" }
-  } else if (!installConfig.isMax20) {
-    agents["librarian"] = { model: "opencode/big-pickle" }
+    agents["explore"] = { model: "opencode/big-pickle" }
  }

  if (!installConfig.hasChatGPT) {
--- a/src/config/index.ts
+++ b/src/config/index.ts
@@ -5,6 +5,7 @@ export {
  McpNameSchema,
  AgentNameSchema,
  HookNameSchema,
+  BuiltinCommandNameSchema,
  SisyphusAgentConfigSchema,
  ExperimentalConfigSchema,
 } from "./schema"
@@ -16,6 +17,7 @@ export type {
  McpName,
  AgentName,
  HookName,
+  BuiltinCommandName,
  SisyphusAgentConfig,
  ExperimentalConfig,
  DynamicContextPruningConfig,
--- a/src/config/schema.ts
+++ b/src/config/schema.ts
@@ -67,6 +67,10 @@ export const HookNameSchema = z.enum([
  "thinking-block-validator",
 ])

+export const BuiltinCommandNameSchema = z.enum([
+  "init-deep",
+])
+
 export const AgentOverrideConfigSchema = z.object({
  model: z.string().optional(),
  temperature: z.number().min(0).max(2).optional(),
@@ -115,6 +119,11 @@ export const SisyphusAgentConfigSchema = z.object({
  replace_plan: z.boolean().optional(),
 })

+export const CommentCheckerConfigSchema = z.object({
+  /** Custom prompt to replace the default warning message. Use {{comments}} placeholder for detected comments XML. */
+  custom_prompt: z.string().optional(),
+})
+
 export const DynamicContextPruningConfigSchema = z.object({
  /** Enable dynamic context pruning (default: false) */
  enabled: z.boolean().default(false),
@@ -162,8 +171,8 @@ export const ExperimentalConfigSchema = z.object({
  truncate_all_tool_outputs: z.boolean().default(true),
  /** Dynamic context pruning configuration */
  dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
-  /** Run DCP only when compaction (summarize) fails, then retry compaction (default: false) */
-  dcp_on_compaction_failure: z.boolean().optional(),
+  /** Enable DCP (Dynamic Context Pruning) for compaction - runs first when token limit exceeded (default: false) */
+  dcp_for_compaction: z.boolean().optional(),
 })

 export const OhMyOpenCodeConfigSchema = z.object({
@@ -171,10 +180,12 @@ export const OhMyOpenCodeConfigSchema = z.object({
  disabled_mcps: z.array(McpNameSchema).optional(),
  disabled_agents: z.array(BuiltinAgentNameSchema).optional(),
  disabled_hooks: z.array(HookNameSchema).optional(),
+  disabled_commands: z.array(BuiltinCommandNameSchema).optional(),
  agents: AgentOverridesSchema.optional(),
  claude_code: ClaudeCodeConfigSchema.optional(),
  google_auth: z.boolean().optional(),
  sisyphus_agent: SisyphusAgentConfigSchema.optional(),
+  comment_checker: CommentCheckerConfigSchema.optional(),
  experimental: ExperimentalConfigSchema.optional(),
  auto_update: z.boolean().optional(),
 })
@@ -184,7 +195,9 @@ export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>
 export type AgentOverrides = z.infer<typeof AgentOverridesSchema>
 export type AgentName = z.infer<typeof AgentNameSchema>
 export type HookName = z.infer<typeof HookNameSchema>
+export type BuiltinCommandName = z.infer<typeof BuiltinCommandNameSchema>
 export type SisyphusAgentConfig = z.infer<typeof SisyphusAgentConfigSchema>
+export type CommentCheckerConfig = z.infer<typeof CommentCheckerConfigSchema>
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>
 export type DynamicContextPruningConfig = z.infer<typeof DynamicContextPruningConfigSchema>

--- a/src/features/AGENTS.md
+++ b/src/features/AGENTS.md
@@ -12,10 +12,12 @@ features/
 │   ├── manager.ts              # Task lifecycle, notifications
 │   ├── manager.test.ts
 │   └── types.ts
+├── builtin-commands/           # Built-in slash command definitions
 ├── claude-code-agent-loader/   # Load agents from ~/.claude/agents/*.md
 ├── claude-code-command-loader/ # Load commands from ~/.claude/commands/*.md
 ├── claude-code-mcp-loader/     # Load MCPs from .mcp.json
 │   └── env-expander.ts         # ${VAR} expansion
+├── claude-code-plugin-loader/  # Load external plugins from installed_plugins.json
 ├── claude-code-session-state/  # Session state persistence
 ├── claude-code-skill-loader/   # Load skills from ~/.claude/skills/*/SKILL.md
 └── hook-message-injector/      # Inject messages into conversation
--- a/src/features/background-agent/manager.ts
+++ b/src/features/background-agent/manager.ts
@@ -325,6 +325,7 @@ export class BackgroundManager {

    log("[background-agent] Sending notification to parent session:", { parentSessionID: task.parentSessionID })

+    const taskId = task.id
    setTimeout(async () => {
      try {
        const messageDir = getMessageDir(task.parentSessionID)
@@ -344,10 +345,13 @@ export class BackgroundManager {
          },
          query: { directory: this.directory },
        })
-        this.clearNotificationsForTask(task.id)
+        this.clearNotificationsForTask(taskId)
        log("[background-agent] Successfully sent prompt to parent session:", { parentSessionID: task.parentSessionID })
      } catch (error) {
        log("[background-agent] prompt failed:", String(error))
+      } finally {
+        this.tasks.delete(taskId)
+        log("[background-agent] Removed completed task from memory:", taskId)
      }
    }, 200)
  }
--- a/src/features/builtin-commands/commands.ts
+++ b/src/features/builtin-commands/commands.ts
@@ -0,0 +1,35 @@
+import type { CommandDefinition } from "../claude-code-command-loader"
+import type { BuiltinCommandName, BuiltinCommands } from "./types"
+import { INIT_DEEP_TEMPLATE } from "./templates/init-deep"
+
+const BUILTIN_COMMAND_DEFINITIONS: Record<BuiltinCommandName, Omit<CommandDefinition, "name">> = {
+  "init-deep": {
+    description: "(builtin) Initialize hierarchical AGENTS.md knowledge base",
+    template: `<command-instruction>
+${INIT_DEEP_TEMPLATE}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+    argumentHint: "[--create-new] [--max-depth=N]",
+  },
+}
+
+export function loadBuiltinCommands(
+  disabledCommands?: BuiltinCommandName[]
+): BuiltinCommands {
+  const disabled = new Set(disabledCommands ?? [])
+  const commands: BuiltinCommands = {}
+
+  for (const [name, definition] of Object.entries(BUILTIN_COMMAND_DEFINITIONS)) {
+    if (!disabled.has(name as BuiltinCommandName)) {
+      commands[name] = {
+        name,
+        ...definition,
+      }
+    }
+  }
+
+  return commands
+}
--- a/src/features/builtin-commands/index.ts
+++ b/src/features/builtin-commands/index.ts
@@ -0,0 +1,2 @@
+export * from "./types"
+export * from "./commands"
--- a/src/features/builtin-commands/templates/init-deep.ts
+++ b/src/features/builtin-commands/templates/init-deep.ts
@@ -0,0 +1,394 @@
+export const INIT_DEEP_TEMPLATE = `# Initialize Deep Knowledge Base
+
+Generate comprehensive AGENTS.md files across project hierarchy. Combines root-level project knowledge (gen-knowledge) with complexity-based subdirectory documentation (gen-knowledge-deep).
+
+## Usage
+
+\`\`\`
+/init-deep                      # Analyze and generate hierarchical AGENTS.md
+/init-deep --create-new         # Force create from scratch (ignore existing)
+/init-deep --max-depth=2        # Limit to N directory levels (default: 3)
+\`\`\`
+
+---
+
+## Core Principles
+
+- **Telegraphic Style**: Sacrifice grammar for concision ("Project uses React" → "React 18")
+- **Predict-then-Compare**: Predict standard → find actual → document ONLY deviations
+- **Hierarchy Aware**: Parent covers general, children cover specific
+- **No Redundancy**: Child AGENTS.md NEVER repeats parent content
+- **LSP-First**: Use LSP tools for accurate code intelligence when available (semantic > text search)
+
+---
+
+## Process
+
+<critical>
+**MANDATORY: TodoWrite for ALL phases. Mark in_progress → completed in real-time.**
+</critical>
+
+### Phase 0: Initialize
+
+\`\`\`
+TodoWrite([
+  { id: "p1-analysis", content: "Parallel project structure & complexity analysis", status: "pending", priority: "high" },
+  { id: "p2-scoring", content: "Score directories, determine AGENTS.md locations", status: "pending", priority: "high" },
+  { id: "p3-root", content: "Generate root AGENTS.md with Predict-then-Compare", status: "pending", priority: "high" },
+  { id: "p4-subdirs", content: "Generate subdirectory AGENTS.md files in parallel", status: "pending", priority: "high" },
+  { id: "p5-review", content: "Review, deduplicate, validate all files", status: "pending", priority: "medium" }
+])
+\`\`\`
+
+---
+
+## Phase 1: Parallel Project Analysis
+
+**Mark "p1-analysis" as in_progress.**
+
+Launch **ALL tasks simultaneously**:
+
+<parallel-tasks>
+
+### Structural Analysis (bash - run in parallel)
+\`\`\`bash
+# Task A: Directory depth analysis
+find . -type d -not -path '*/\\.*' -not -path '*/node_modules/*' -not -path '*/venv/*' -not -path '*/__pycache__/*' -not -path '*/dist/*' -not -path '*/build/*' | awk -F/ '{print NF-1}' | sort -n | uniq -c
+
+# Task B: File count per directory  
+find . -type f -not -path '*/\\.*' -not -path '*/node_modules/*' -not -path '*/venv/*' -not -path '*/__pycache__/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -30
+
+# Task C: Code concentration
+find . -type f \\( -name "*.py" -o -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.jsx" -o -name "*.go" -o -name "*.rs" -o -name "*.java" \\) -not -path '*/node_modules/*' -not -path '*/venv/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -20
+
+# Task D: Existing knowledge files
+find . -type f \\( -name "AGENTS.md" -o -name "CLAUDE.md" \\) -not -path '*/node_modules/*' 2>/dev/null
+\`\`\`
+
+### Context Gathering (Explore agents - background_task in parallel)
+
+\`\`\`
+background_task(agent="explore", prompt="Project structure: PREDICT standard {lang} patterns → FIND package.json/pyproject.toml/go.mod → REPORT deviations only")
+
+background_task(agent="explore", prompt="Entry points: PREDICT typical (main.py, index.ts) → FIND actual → REPORT non-standard organization")
+
+background_task(agent="explore", prompt="Conventions: FIND .cursor/rules, .cursorrules, eslintrc, pyproject.toml → REPORT project-specific rules DIFFERENT from defaults")
+
+background_task(agent="explore", prompt="Anti-patterns: FIND comments with 'DO NOT', 'NEVER', 'ALWAYS', 'LEGACY', 'DEPRECATED' → REPORT forbidden patterns")
+
+background_task(agent="explore", prompt="Build/CI: FIND .github/workflows, Makefile, justfile → REPORT non-standard build/deploy patterns")
+
+background_task(agent="explore", prompt="Test patterns: FIND pytest.ini, jest.config, test structure → REPORT unique testing conventions")
+\`\`\`
+
+### Code Intelligence Analysis (LSP tools - run in parallel)
+
+LSP provides semantic understanding beyond text search. Use for accurate code mapping.
+
+\`\`\`
+# Step 1: Check LSP availability
+lsp_servers()  # Verify language server is available
+
+# Step 2: Analyze entry point files (run in parallel)
+# Find entry points first, then analyze each with lsp_document_symbols
+lsp_document_symbols(filePath="src/index.ts")      # Main entry
+lsp_document_symbols(filePath="src/main.py")       # Python entry
+lsp_document_symbols(filePath="cmd/main.go")       # Go entry
+
+# Step 3: Discover key symbols across workspace (run in parallel)
+lsp_workspace_symbols(filePath=".", query="class")      # All classes
+lsp_workspace_symbols(filePath=".", query="interface")  # All interfaces
+lsp_workspace_symbols(filePath=".", query="function")   # Top-level functions
+lsp_workspace_symbols(filePath=".", query="type")       # Type definitions
+
+# Step 4: Analyze symbol centrality (for top 5-10 key symbols)
+# High reference count = central/important concept
+lsp_find_references(filePath="src/index.ts", line=X, character=Y)  # Main export
+\`\`\`
+
+#### LSP Analysis Output Format
+
+\`\`\`
+CODE_INTELLIGENCE = {
+  entry_points: [
+    { file: "src/index.ts", exports: ["Plugin", "createHook"], symbol_count: 12 }
+  ],
+  key_symbols: [
+    { name: "Plugin", type: "class", file: "src/index.ts", refs: 45, role: "Central orchestrator" },
+    { name: "createHook", type: "function", file: "src/utils.ts", refs: 23, role: "Hook factory" }
+  ],
+  module_boundaries: [
+    { dir: "src/hooks", exports: 21, imports_from: ["shared/"] },
+    { dir: "src/tools", exports: 15, imports_from: ["shared/", "hooks/"] }
+  ]
+}
+\`\`\`
+
+<critical>
+**LSP Fallback**: If LSP unavailable (no server installed), skip this section and rely on explore agents + AST-grep patterns.
+</critical>
+
+</parallel-tasks>
+
+**Collect all results. Mark "p1-analysis" as completed.**
+
+---
+
+## Phase 2: Complexity Scoring & Location Decision
+
+**Mark "p2-scoring" as in_progress.**
+
+### Scoring Matrix
+
+| Factor | Weight | Threshold | Source |
+|--------|--------|-----------|--------|
+| File count | 3x | >20 files = high | bash |
+| Subdirectory count | 2x | >5 subdirs = high | bash |
+| Code file ratio | 2x | >70% code = high | bash |
+| Unique patterns | 1x | Has own config | explore |
+| Module boundary | 2x | Has __init__.py/index.ts | bash |
+| **Symbol density** | 2x | >30 symbols = high | LSP |
+| **Export count** | 2x | >10 exports = high | LSP |
+| **Reference centrality** | 3x | Symbols with >20 refs | LSP |
+
+<lsp-scoring>
+**LSP-Enhanced Scoring** (if available):
+
+\`\`\`
+For each directory in candidates:
+  symbols = lsp_document_symbols(dir/index.ts or dir/__init__.py)
+  
+  symbol_score = len(symbols) > 30 ? 6 : len(symbols) > 15 ? 3 : 0
+  export_score = count(exported symbols) > 10 ? 4 : 0
+  
+  # Check if this module is central (many things depend on it)
+  for each exported symbol:
+    refs = lsp_find_references(symbol)
+    if refs > 20: centrality_score += 3
+  
+  total_score += symbol_score + export_score + centrality_score
+\`\`\`
+</lsp-scoring>
+
+### Decision Rules
+
+| Score | Action |
+|-------|--------|
+| **Root (.)** | ALWAYS create AGENTS.md |
+| **High (>15)** | Create dedicated AGENTS.md |
+| **Medium (8-15)** | Create if distinct domain |
+| **Low (<8)** | Skip, parent sufficient |
+
+### Output Format
+
+\`\`\`
+AGENTS_LOCATIONS = [
+  { path: ".", type: "root" },
+  { path: "src/api", score: 18, reason: "high complexity, 45 files" },
+  { path: "src/hooks", score: 12, reason: "distinct domain, unique patterns" },
+]
+\`\`\`
+
+**Mark "p2-scoring" as completed.**
+
+---
+
+## Phase 3: Generate Root AGENTS.md
+
+**Mark "p3-root" as in_progress.**
+
+Root AGENTS.md gets **full treatment** with Predict-then-Compare synthesis.
+
+### Required Sections
+
+\`\`\`markdown
+# PROJECT KNOWLEDGE BASE
+
+**Generated:** {TIMESTAMP}
+**Commit:** {SHORT_SHA}
+**Branch:** {BRANCH}
+
+## OVERVIEW
+
+{1-2 sentences: what project does, core tech stack}
+
+## STRUCTURE
+
+\\\`\\\`\\\`
+{project-root}/
+├── {dir}/      # {non-obvious purpose only}
+└── {entry}     # entry point
+\\\`\\\`\\\`
+
+## WHERE TO LOOK
+
+| Task | Location | Notes |
+|------|----------|-------|
+| Add feature X | \\\`src/x/\\\` | {pattern hint} |
+
+## CODE MAP
+
+{Generated from LSP analysis - shows key symbols and their relationships}
+
+| Symbol | Type | Location | Refs | Role |
+|--------|------|----------|------|------|
+| {MainClass} | Class | \\\`src/index.ts\\\` | {N} | {Central orchestrator} |
+| {createX} | Function | \\\`src/utils.ts\\\` | {N} | {Factory pattern} |
+| {Config} | Interface | \\\`src/types.ts\\\` | {N} | {Configuration contract} |
+
+### Module Dependencies
+
+\\\`\\\`\\\`
+{entry} ──imports──> {core/}
+   │                    │
+   └──imports──> {utils/} <──imports── {features/}
+\\\`\\\`\\\`
+
+<code-map-note>
+**Skip CODE MAP if**: LSP unavailable OR project too small (<10 files) OR no clear module boundaries.
+</code-map-note>
+
+## CONVENTIONS
+
+{ONLY deviations from standard - skip generic advice}
+
+- **{rule}**: {specific detail}
+
+## ANTI-PATTERNS (THIS PROJECT)
+
+{Things explicitly forbidden HERE}
+
+- **{pattern}**: {why} → {alternative}
+
+## UNIQUE STYLES
+
+{Project-specific coding styles}
+
+- **{style}**: {how different}
+
+## COMMANDS
+
+\\\`\\\`\\\`bash
+{dev-command}
+{test-command}
+{build-command}
+\\\`\\\`\\\`
+
+## NOTES
+
+{Gotchas, non-obvious info}
+\`\`\`
+
+### Quality Gates
+
+- [ ] Size: 50-150 lines
+- [ ] No generic advice ("write clean code")
+- [ ] No obvious info ("tests/ has tests")
+- [ ] Every item is project-specific
+
+**Mark "p3-root" as completed.**
+
+---
+
+## Phase 4: Generate Subdirectory AGENTS.md
+
+**Mark "p4-subdirs" as in_progress.**
+
+For each location in AGENTS_LOCATIONS (except root), launch **parallel document-writer agents**:
+
+\`\`\`typescript
+for (const loc of AGENTS_LOCATIONS.filter(l => l.path !== ".")) {
+  background_task({
+    agent: "document-writer",
+    prompt: \\\`
+      Generate AGENTS.md for: \${loc.path}
+      
+      CONTEXT:
+      - Complexity reason: \${loc.reason}
+      - Parent AGENTS.md: ./AGENTS.md (already covers project overview)
+      
+      CRITICAL RULES:
+      1. Focus ONLY on this directory's specific context
+      2. NEVER repeat parent AGENTS.md content
+      3. Shorter is better - 30-80 lines max
+      4. Telegraphic style - sacrifice grammar
+      
+      REQUIRED SECTIONS:
+      - OVERVIEW (1 line: what this directory does)
+      - STRUCTURE (only if >5 subdirs)
+      - WHERE TO LOOK (directory-specific tasks)
+      - CONVENTIONS (only if DIFFERENT from root)
+      - ANTI-PATTERNS (directory-specific only)
+      
+      OUTPUT: Write to \${loc.path}/AGENTS.md
+    \\\`
+  })
+}
+\`\`\`
+
+**Wait for all agents. Mark "p4-subdirs" as completed.**
+
+---
+
+## Phase 5: Review & Deduplicate
+
+**Mark "p5-review" as in_progress.**
+
+### Validation Checklist
+
+For EACH generated AGENTS.md:
+
+| Check | Action if Fail |
+|-------|----------------|
+| Contains generic advice | REMOVE the line |
+| Repeats parent content | REMOVE the line |
+| Missing required section | ADD it |
+| Over 150 lines (root) / 80 lines (subdir) | TRIM |
+| Verbose explanations | REWRITE telegraphic |
+
+### Cross-Reference Validation
+
+\`\`\`
+For each child AGENTS.md:
+  For each line in child:
+    If similar line exists in parent:
+      REMOVE from child (parent already covers)
+\`\`\`
+
+**Mark "p5-review" as completed.**
+
+---
+
+## Final Report
+
+\`\`\`
+=== init-deep Complete ===
+
+Files Generated:
+  ✓ ./AGENTS.md (root, {N} lines)
+  ✓ ./src/hooks/AGENTS.md ({N} lines)
+  ✓ ./src/tools/AGENTS.md ({N} lines)
+
+Directories Analyzed: {N}
+AGENTS.md Created: {N}
+Total Lines: {N}
+
+Hierarchy:
+  ./AGENTS.md
+  ├── src/hooks/AGENTS.md
+  └── src/tools/AGENTS.md
+\`\`\`
+
+---
+
+## Anti-Patterns for THIS Command
+
+- **Over-documenting**: Not every directory needs AGENTS.md
+- **Redundancy**: Child must NOT repeat parent
+- **Generic content**: Remove anything that applies to ALL projects
+- **Sequential execution**: MUST use parallel agents
+- **Deep nesting**: Rarely need AGENTS.md at depth 4+
+- **Verbose style**: "This directory contains..." → just list it
+- **Ignoring LSP**: If LSP available, USE IT - semantic analysis > text grep
+- **LSP without fallback**: Always have explore agent backup if LSP unavailable
+- **Over-referencing**: Don't trace refs for EVERY symbol - focus on exports only`
--- a/src/features/builtin-commands/types.ts
+++ b/src/features/builtin-commands/types.ts
@@ -0,0 +1,9 @@
+import type { CommandDefinition } from "../claude-code-command-loader"
+
+export type BuiltinCommandName = "init-deep"
+
+export interface BuiltinCommandConfig {
+  disabled_commands?: BuiltinCommandName[]
+}
+
+export type BuiltinCommands = Record<string, CommandDefinition>
--- a/src/hooks/AGENTS.md
+++ b/src/hooks/AGENTS.md
@@ -27,6 +27,7 @@ hooks/
 ├── rules-injector/             # Conditional rules from .claude/rules/
 ├── session-recovery/           # Recover from session errors
 ├── think-mode/                 # Auto-detect thinking triggers
+├── thinking-block-validator/   # Validate thinking blocks in messages
 ├── context-window-monitor.ts   # Monitor context usage (standalone)
 ├── empty-task-response-detector.ts
 ├── session-notification.ts     # OS notify on idle (standalone)
--- a/src/hooks/agent-usage-reminder/constants.ts
+++ b/src/hooks/agent-usage-reminder/constants.ts
@@ -1,7 +1,7 @@
 import { join } from "node:path";
-import { xdgData } from "xdg-basedir";
+import { getOpenCodeStorageDir } from "../../shared/data-path";

-export const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
+export const OPENCODE_STORAGE = getOpenCodeStorageDir();
 export const AGENT_USAGE_REMINDER_STORAGE = join(
  OPENCODE_STORAGE,
  "agent-usage-reminder",
--- a/src/hooks/anthropic-auto-compact/executor.ts
+++ b/src/hooks/anthropic-auto-compact/executor.ts
@@ -21,6 +21,8 @@ import {
 } from "../session-recovery/storage";
 import { log } from "../../shared/logger";

+const PLACEHOLDER_TEXT = "[user interrupted]";
+
 type Client = {
  session: {
    messages: (opts: {
@@ -103,6 +105,36 @@ function getOrCreateDcpState(
  return state;
 }

+function sanitizeEmptyMessagesBeforeSummarize(sessionID: string): number {
+  const emptyMessageIds = findEmptyMessages(sessionID);
+  if (emptyMessageIds.length === 0) {
+    return 0;
+  }
+
+  let fixedCount = 0;
+  for (const messageID of emptyMessageIds) {
+    const replaced = replaceEmptyTextParts(messageID, PLACEHOLDER_TEXT);
+    if (replaced) {
+      fixedCount++;
+    } else {
+      const injected = injectTextPart(sessionID, messageID, PLACEHOLDER_TEXT);
+      if (injected) {
+        fixedCount++;
+      }
+    }
+  }
+
+  if (fixedCount > 0) {
+    log("[auto-compact] pre-summarize sanitization fixed empty messages", {
+      sessionID,
+      fixedCount,
+      totalEmpty: emptyMessageIds.length,
+    });
+  }
+
+  return fixedCount;
+}
+
 async function getLastMessagePair(
  sessionID: string,
  client: Client,
@@ -326,6 +358,104 @@ export async function executeCompact(
    const errorData = autoCompactState.errorDataBySession.get(sessionID);
    const truncateState = getOrCreateTruncateState(autoCompactState, sessionID);

+    // DCP FIRST - run before any other recovery attempts when token limit exceeded
+    const dcpState = getOrCreateDcpState(autoCompactState, sessionID);
+    if (
+      experimental?.dcp_for_compaction &&
+      !dcpState.attempted &&
+      errorData?.currentTokens &&
+      errorData?.maxTokens &&
+      errorData.currentTokens > errorData.maxTokens
+    ) {
+      dcpState.attempted = true;
+      log("[auto-compact] DCP triggered FIRST on token limit error", {
+        sessionID,
+        currentTokens: errorData.currentTokens,
+        maxTokens: errorData.maxTokens,
+      });
+
+      const dcpConfig = experimental.dynamic_context_pruning ?? {
+        enabled: true,
+        notification: "detailed" as const,
+        protected_tools: ["task", "todowrite", "todoread", "lsp_rename", "lsp_code_action_resolve"],
+      };
+
+      try {
+        const pruningResult = await executeDynamicContextPruning(
+          sessionID,
+          dcpConfig,
+          client
+        );
+
+        if (pruningResult.itemsPruned > 0) {
+          dcpState.itemsPruned = pruningResult.itemsPruned;
+          log("[auto-compact] DCP successful, proceeding to compaction", {
+            itemsPruned: pruningResult.itemsPruned,
+            tokensSaved: pruningResult.totalTokensSaved,
+          });
+
+          await (client as Client).tui
+            .showToast({
+              body: {
+                title: "Dynamic Context Pruning",
+                message: `Pruned ${pruningResult.itemsPruned} items (~${Math.round(pruningResult.totalTokensSaved / 1000)}k tokens). Running compaction...`,
+                variant: "success",
+                duration: 3000,
+              },
+            })
+            .catch(() => {});
+
+          // After DCP, immediately try summarize
+          const providerID = msg.providerID as string | undefined;
+          const modelID = msg.modelID as string | undefined;
+
+          if (providerID && modelID) {
+            try {
+              sanitizeEmptyMessagesBeforeSummarize(sessionID);
+
+              await (client as Client).tui
+                .showToast({
+                  body: {
+                    title: "Auto Compact",
+                    message: "Summarizing session after DCP...",
+                    variant: "warning",
+                    duration: 3000,
+                  },
+                })
+                .catch(() => {});
+
+              await (client as Client).session.summarize({
+                path: { id: sessionID },
+                body: { providerID, modelID },
+                query: { directory },
+              });
+
+              clearSessionState(autoCompactState, sessionID);
+
+              setTimeout(async () => {
+                try {
+                  await (client as Client).session.prompt_async({
+                    path: { sessionID },
+                    body: { parts: [{ type: "text", text: "Continue" }] },
+                    query: { directory },
+                  });
+                } catch {}
+              }, 500);
+              return;
+            } catch (summarizeError) {
+              log("[auto-compact] summarize after DCP failed, continuing recovery", {
+                error: String(summarizeError),
+              });
+            }
+          }
+        } else {
+          log("[auto-compact] DCP did not prune any items", { sessionID });
+        }
+      } catch (error) {
+        log("[auto-compact] DCP failed", { error: String(error) });
+      }
+    }
+
    if (
      experimental?.aggressive_truncation &&
      errorData?.currentTokens &&
@@ -523,6 +653,8 @@ export async function executeCompact(

      if (providerID && modelID) {
        try {
+          sanitizeEmptyMessagesBeforeSummarize(sessionID);
+
          await (client as Client).tui
            .showToast({
              body: {
@@ -582,67 +714,6 @@ export async function executeCompact(
      }
    }

-    // Try DCP after summarize fails - only once per compaction cycle
-    const dcpState = getOrCreateDcpState(autoCompactState, sessionID);
-    if (experimental?.dcp_on_compaction_failure && !dcpState.attempted) {
-      dcpState.attempted = true;
-      log("[auto-compact] attempting DCP after summarize failed", { sessionID });
-      
-      const dcpConfig = experimental.dynamic_context_pruning ?? {
-        enabled: true,
-        notification: "detailed" as const,
-        protected_tools: ["task", "todowrite", "todoread", "lsp_rename", "lsp_code_action_resolve"],
-      };
-      
-      try {
-        const pruningResult = await executeDynamicContextPruning(
-          sessionID,
-          dcpConfig,
-          client
-        );
-        
-        if (pruningResult.itemsPruned > 0) {
-          dcpState.itemsPruned = pruningResult.itemsPruned;
-          log("[auto-compact] DCP successful, retrying compaction", {
-            itemsPruned: pruningResult.itemsPruned,
-            tokensSaved: pruningResult.totalTokensSaved,
-          });
-          
-          await (client as Client).tui
-            .showToast({
-              body: {
-                title: "Dynamic Context Pruning",
-                message: `Pruned ${pruningResult.itemsPruned} items (~${Math.round(pruningResult.totalTokensSaved / 1000)}k tokens). Retrying compaction...`,
-                variant: "success",
-                duration: 3000,
-              },
-            })
-            .catch(() => {});
-          
-          // Reset retry state to allow compaction to retry summarize
-          retryState.attempt = 0;
-          
-          setTimeout(() => {
-            executeCompact(
-              sessionID,
-              msg,
-              autoCompactState,
-              client,
-              directory,
-              experimental,
-            );
-          }, 500);
-          return;
-        } else {
-          log("[auto-compact] DCP did not prune any items, continuing to revert", { sessionID });
-        }
-      } catch (error) {
-        log("[auto-compact] DCP failed, continuing to revert", {
-          error: String(error),
-        });
-      }
-    }
-
    const fallbackState = getOrCreateFallbackState(autoCompactState, sessionID);

    if (fallbackState.revertAttempt < FALLBACK_CONFIG.maxRevertAttempts) {
--- a/src/hooks/anthropic-auto-compact/parser.ts
+++ b/src/hooks/anthropic-auto-compact/parser.ts
@@ -26,6 +26,7 @@ const TOKEN_LIMIT_KEYWORDS = [
  "context length",
  "too many tokens",
  "non-empty content",
+  "invalid_request_error",
 ]

 const MESSAGE_INDEX_PATTERN = /messages\.(\d+)/
@@ -114,9 +115,10 @@ export function parseAnthropicTokenLimitError(err: unknown): ParsedTokenLimitErr
  if (typeof responseBody === "string") {
    try {
      const jsonPatterns = [
-        /data:\s*(\{[\s\S]*?\})\s*$/m,
-        /(\{"type"\s*:\s*"error"[\s\S]*?\})/,
-        /(\{[\s\S]*?"error"[\s\S]*?\})/,
+        // Greedy match to last } for nested JSON
+        /data:\s*(\{[\s\S]*\})\s*$/m,
+        /(\{"type"\s*:\s*"error"[\s\S]*\})/,
+        /(\{[\s\S]*"error"[\s\S]*\})/,
      ]

      for (const pattern of jsonPatterns) {
--- a/src/hooks/anthropic-auto-compact/pruning-deduplication.ts
+++ b/src/hooks/anthropic-auto-compact/pruning-deduplication.ts
@@ -3,19 +3,13 @@ import { join } from "node:path"
 import type { PruningState, ToolCallSignature } from "./pruning-types"
 import { estimateTokens } from "./pruning-types"
 import { log } from "../../shared/logger"
+import { MESSAGE_STORAGE } from "../../features/hook-message-injector"

 export interface DeduplicationConfig {
  enabled: boolean
  protectedTools?: string[]
 }

-const MESSAGE_STORAGE = join(
-  process.env.HOME || process.env.USERPROFILE || "",
-  ".config",
-  "opencode",
-  "sessions"
-)
-
 interface ToolPart {
  type: string
  callID?: string
--- a/src/hooks/anthropic-auto-compact/pruning-purge-errors.ts
+++ b/src/hooks/anthropic-auto-compact/pruning-purge-errors.ts
@@ -3,6 +3,7 @@ import { join } from "node:path"
 import type { PruningState, ErroredToolCall } from "./pruning-types"
 import { estimateTokens } from "./pruning-types"
 import { log } from "../../shared/logger"
+import { MESSAGE_STORAGE } from "../../features/hook-message-injector"

 export interface PurgeErrorsConfig {
  enabled: boolean
@@ -10,13 +11,6 @@ export interface PurgeErrorsConfig {
  protectedTools?: string[]
 }

-const MESSAGE_STORAGE = join(
-  process.env.HOME || process.env.USERPROFILE || "",
-  ".config",
-  "opencode",
-  "sessions"
-)
-
 interface ToolPart {
  type: string
  callID?: string
--- a/src/hooks/anthropic-auto-compact/pruning-storage.ts
+++ b/src/hooks/anthropic-auto-compact/pruning-storage.ts
@@ -3,13 +3,7 @@ import { join } from "node:path"
 import type { PruningState } from "./pruning-types"
 import { estimateTokens } from "./pruning-types"
 import { log } from "../../shared/logger"
-
-const MESSAGE_STORAGE = join(
-  process.env.HOME || process.env.USERPROFILE || "",
-  ".config",
-  "opencode",
-  "sessions"
-)
+import { MESSAGE_STORAGE } from "../../features/hook-message-injector"

 function getMessageDir(sessionID: string): string | null {
  if (!existsSync(MESSAGE_STORAGE)) return null
--- a/src/hooks/anthropic-auto-compact/pruning-supersede.ts
+++ b/src/hooks/anthropic-auto-compact/pruning-supersede.ts
@@ -3,19 +3,13 @@ import { join } from "node:path"
 import type { PruningState, FileOperation } from "./pruning-types"
 import { estimateTokens } from "./pruning-types"
 import { log } from "../../shared/logger"
+import { MESSAGE_STORAGE } from "../../features/hook-message-injector"

 export interface SupersedeWritesConfig {
  enabled: boolean
  aggressive: boolean
 }

-const MESSAGE_STORAGE = join(
-  process.env.HOME || process.env.USERPROFILE || "",
-  ".config",
-  "opencode",
-  "sessions"
-)
-
 interface ToolPart {
  type: string
  callID?: string
--- a/src/hooks/anthropic-auto-compact/storage.ts
+++ b/src/hooks/anthropic-auto-compact/storage.ts
@@ -1,19 +1,8 @@
 import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
-import { homedir } from "node:os"
 import { join } from "node:path"
-import { xdgData } from "xdg-basedir"
-
-let OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage")
-
-// Fix for macOS where xdg-basedir points to ~/Library/Application Support
-// but OpenCode (cli) uses ~/.local/share
-if (process.platform === "darwin" && !existsSync(OPENCODE_STORAGE)) {
-  const localShare = join(homedir(), ".local", "share", "opencode", "storage")
-  if (existsSync(localShare)) {
-    OPENCODE_STORAGE = localShare
-  }
-}
+import { getOpenCodeStorageDir } from "../../shared/data-path"

+const OPENCODE_STORAGE = getOpenCodeStorageDir()
 const MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message")
 const PART_STORAGE = join(OPENCODE_STORAGE, "part")

--- a/src/hooks/comment-checker/cli.ts
+++ b/src/hooks/comment-checker/cli.ts
@@ -142,8 +142,9 @@ export interface CheckResult {
 * Run comment-checker CLI with given input.
 * @param input Hook input to check
 * @param cliPath Optional explicit path to CLI binary
+ * @param customPrompt Optional custom prompt to replace default warning message
 */
-export async function runCommentChecker(input: HookInput, cliPath?: string): Promise<CheckResult> {
+export async function runCommentChecker(input: HookInput, cliPath?: string, customPrompt?: string): Promise<CheckResult> {
  const binaryPath = cliPath ?? resolvedCliPath ?? COMMENT_CHECKER_CLI_PATH
  
  if (!binaryPath) {
@@ -160,7 +161,12 @@ export async function runCommentChecker(input: HookInput, cliPath?: string): Pro
  debugLog("running comment-checker with input:", jsonInput.substring(0, 200))

  try {
-    const proc = spawn([binaryPath], {
+    const args = [binaryPath]
+    if (customPrompt) {
+      args.push("--prompt", customPrompt)
+    }
+    
+    const proc = spawn(args, {
      stdin: "pipe",
      stdout: "pipe",
      stderr: "pipe",
--- a/src/hooks/comment-checker/index.ts
+++ b/src/hooks/comment-checker/index.ts
@@ -1,5 +1,6 @@
 import type { PendingCall } from "./types"
 import { runCommentChecker, getCommentCheckerPath, startBackgroundInit, type HookInput } from "./cli"
+import type { CommentCheckerConfig } from "../../config/schema"

 import * as fs from "fs"
 import { existsSync } from "fs"
@@ -20,6 +21,7 @@ const pendingCalls = new Map<string, PendingCall>()
 const PENDING_CALL_TTL = 60_000

 let cliPathPromise: Promise<string | null> | null = null
+let cleanupIntervalStarted = false

 function cleanupOldPendingCalls(): void {
  const now = Date.now()
@@ -30,10 +32,13 @@ function cleanupOldPendingCalls(): void {
  }
 }

-setInterval(cleanupOldPendingCalls, 10_000)
+export function createCommentCheckerHooks(config?: CommentCheckerConfig) {
+  debugLog("createCommentCheckerHooks called", { config })

-export function createCommentCheckerHooks() {
-  debugLog("createCommentCheckerHooks called")
+  if (!cleanupIntervalStarted) {
+    cleanupIntervalStarted = true
+    setInterval(cleanupOldPendingCalls, 10_000)
+  }
  
  // Start background CLI initialization (may trigger lazy download)
  startBackgroundInit()
@@ -123,7 +128,7 @@ export function createCommentCheckerHooks() {
        
        // CLI mode only
        debugLog("using CLI:", cliPath)
-        await processWithCli(input, pendingCall, output, cliPath)
+        await processWithCli(input, pendingCall, output, cliPath, config?.custom_prompt)
      } catch (err) {
        debugLog("tool.execute.after failed:", err)
      }
@@ -135,7 +140,8 @@ async function processWithCli(
  input: { tool: string; sessionID: string; callID: string },
  pendingCall: PendingCall,
  output: { output: string },
-  cliPath: string
+  cliPath: string,
+  customPrompt?: string
 ): Promise<void> {
  debugLog("using CLI mode with path:", cliPath)
  
@@ -154,7 +160,7 @@ async function processWithCli(
    },
  }
  
-  const result = await runCommentChecker(hookInput, cliPath)
+  const result = await runCommentChecker(hookInput, cliPath, customPrompt)
  
  if (result.hasComments && result.message) {
    debugLog("CLI detected comments, appending message")
--- a/src/hooks/directory-agents-injector/constants.ts
+++ b/src/hooks/directory-agents-injector/constants.ts
@@ -1,7 +1,7 @@
 import { join } from "node:path";
-import { xdgData } from "xdg-basedir";
+import { getOpenCodeStorageDir } from "../../shared/data-path";

-export const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
+export const OPENCODE_STORAGE = getOpenCodeStorageDir();
 export const AGENTS_INJECTOR_STORAGE = join(
  OPENCODE_STORAGE,
  "directory-agents",
--- a/src/hooks/directory-readme-injector/constants.ts
+++ b/src/hooks/directory-readme-injector/constants.ts
@@ -1,7 +1,7 @@
 import { join } from "node:path";
-import { xdgData } from "xdg-basedir";
+import { getOpenCodeStorageDir } from "../../shared/data-path";

-export const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
+export const OPENCODE_STORAGE = getOpenCodeStorageDir();
 export const README_INJECTOR_STORAGE = join(
  OPENCODE_STORAGE,
  "directory-readme",
--- a/src/hooks/empty-message-sanitizer/index.ts
+++ b/src/hooks/empty-message-sanitizer/index.ts
@@ -42,8 +42,13 @@ export function createEmptyMessageSanitizerHook(): MessagesTransformHook {
    "experimental.chat.messages.transform": async (_input, output) => {
      const { messages } = output

-      for (const message of messages) {
-        if (message.info.role === "user") continue
+      for (let i = 0; i < messages.length; i++) {
+        const message = messages[i]
+        const isLastMessage = i === messages.length - 1
+        const isAssistant = message.info.role === "assistant"
+        
+        // Skip final assistant message (allowed to be empty per API spec)
+        if (isLastMessage && isAssistant) continue

        const parts = message.parts

--- a/src/hooks/interactive-bash-session/constants.ts
+++ b/src/hooks/interactive-bash-session/constants.ts
@@ -1,7 +1,7 @@
 import { join } from "node:path";
-import { xdgData } from "xdg-basedir";
+import { getOpenCodeStorageDir } from "../../shared/data-path";

-export const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
+export const OPENCODE_STORAGE = getOpenCodeStorageDir();
 export const INTERACTIVE_BASH_SESSION_STORAGE = join(
  OPENCODE_STORAGE,
  "interactive-bash-session",
--- a/src/hooks/rules-injector/constants.ts
+++ b/src/hooks/rules-injector/constants.ts
@@ -1,7 +1,7 @@
 import { join } from "node:path";
-import { xdgData } from "xdg-basedir";
+import { getOpenCodeStorageDir } from "../../shared/data-path";

-export const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
+export const OPENCODE_STORAGE = getOpenCodeStorageDir();
 export const RULES_INJECTOR_STORAGE = join(OPENCODE_STORAGE, "rules-injector");

 export const PROJECT_MARKERS = [
--- a/src/hooks/session-recovery/constants.ts
+++ b/src/hooks/session-recovery/constants.ts
@@ -1,7 +1,7 @@
 import { join } from "node:path"
-import { xdgData } from "xdg-basedir"
+import { getOpenCodeStorageDir } from "../../shared/data-path"

-export const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage")
+export const OPENCODE_STORAGE = getOpenCodeStorageDir()
 export const MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message")
 export const PART_STORAGE = join(OPENCODE_STORAGE, "part")

--- a/src/hooks/session-recovery/storage.ts
+++ b/src/hooks/session-recovery/storage.ts
@@ -135,7 +135,16 @@ export function findEmptyMessageByIndex(sessionID: string, targetIndex: number):
  const messages = readMessages(sessionID)

  // API index may differ from storage index due to system messages
-  const indicesToTry = [targetIndex, targetIndex - 1, targetIndex - 2]
+  const indicesToTry = [
+    targetIndex,
+    targetIndex - 1,
+    targetIndex + 1,
+    targetIndex - 2,
+    targetIndex + 2,
+    targetIndex - 3,
+    targetIndex - 4,
+    targetIndex - 5,
+  ]

  for (const idx of indicesToTry) {
    if (idx < 0 || idx >= messages.length) continue
--- a/src/hooks/thinking-block-validator/index.ts
+++ b/src/hooks/thinking-block-validator/index.ts
@@ -51,14 +51,15 @@ function isExtendedThinkingModel(modelID: string): boolean {
 }

 /**
- * Check if a message has tool parts (tool_use)
+ * Check if a message has any content parts (tool_use, text, or other non-thinking content)
 */
-function hasToolParts(parts: Part[]): boolean {
+function hasContentParts(parts: Part[]): boolean {
  if (!parts || parts.length === 0) return false

  return parts.some((part: Part) => {
    const type = part.type as string
-    return type === "tool" || type === "tool_use"
+    // Include tool parts and text parts (anything that's not thinking/reasoning)
+    return type === "tool" || type === "tool_use" || type === "text"
  })
 }

@@ -154,8 +155,8 @@ export function createThinkingBlockValidatorHook(): MessagesTransformHook {
        // Only check assistant messages
        if (msg.info.role !== "assistant") continue

-        // Check if message has tool parts but doesn't start with thinking
-        if (hasToolParts(msg.parts) && !startsWithThinkingBlock(msg.parts)) {
+        // Check if message has content parts but doesn't start with thinking
+        if (hasContentParts(msg.parts) && !startsWithThinkingBlock(msg.parts)) {
          // Find thinking content from previous turns
          const previousThinking = findPreviousThinkingContent(messages, i)

--- a/src/hooks/todo-continuation-enforcer.test.ts
+++ b/src/hooks/todo-continuation-enforcer.test.ts
@@ -0,0 +1,383 @@
+import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test"
+
+import { createTodoContinuationEnforcer } from "./todo-continuation-enforcer"
+import { setMainSession } from "../features/claude-code-session-state"
+import type { BackgroundManager } from "../features/background-agent"
+
+describe("todo-continuation-enforcer", () => {
+  let promptCalls: Array<{ sessionID: string; agent?: string; text: string }>
+  let toastCalls: Array<{ title: string; message: string }>
+
+  function createMockPluginInput() {
+    return {
+      client: {
+        session: {
+          todo: async () => ({ data: [
+            { id: "1", content: "Task 1", status: "pending", priority: "high" },
+            { id: "2", content: "Task 2", status: "completed", priority: "medium" },
+          ]}),
+          prompt: async (opts: any) => {
+            promptCalls.push({
+              sessionID: opts.path.id,
+              agent: opts.body.agent,
+              text: opts.body.parts[0].text,
+            })
+            return {}
+          },
+        },
+        tui: {
+          showToast: async (opts: any) => {
+            toastCalls.push({
+              title: opts.body.title,
+              message: opts.body.message,
+            })
+            return {}
+          },
+        },
+      },
+      directory: "/tmp/test",
+    } as any
+  }
+
+  function createMockBackgroundManager(runningTasks: boolean = false): BackgroundManager {
+    return {
+      getTasksByParentSession: () => runningTasks 
+        ? [{ status: "running" }] 
+        : [],
+    } as any
+  }
+
+  beforeEach(() => {
+    promptCalls = []
+    toastCalls = []
+    setMainSession(undefined)
+  })
+
+  afterEach(() => {
+    setMainSession(undefined)
+  })
+
+  test("should inject continuation when idle with incomplete todos", async () => {
+    // #given - main session with incomplete todos
+    const sessionID = "main-123"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {
+      backgroundManager: createMockBackgroundManager(false),
+    })
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    // #then - countdown toast shown
+    await new Promise(r => setTimeout(r, 100))
+    expect(toastCalls.length).toBeGreaterThanOrEqual(1)
+    expect(toastCalls[0].title).toBe("Todo Continuation")
+
+    // #then - after countdown, continuation injected
+    await new Promise(r => setTimeout(r, 2500))
+    expect(promptCalls.length).toBe(1)
+    expect(promptCalls[0].text).toContain("TODO CONTINUATION")
+  })
+
+  test("should not inject when all todos are complete", async () => {
+    // #given - session with all todos complete
+    const sessionID = "main-456"
+    setMainSession(sessionID)
+
+    const mockInput = createMockPluginInput()
+    mockInput.client.session.todo = async () => ({ data: [
+      { id: "1", content: "Task 1", status: "completed", priority: "high" },
+    ]})
+
+    const hook = createTodoContinuationEnforcer(mockInput, {})
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    await new Promise(r => setTimeout(r, 3000))
+
+    // #then - no continuation injected
+    expect(promptCalls).toHaveLength(0)
+  })
+
+  test("should not inject when background tasks are running", async () => {
+    // #given - session with running background tasks
+    const sessionID = "main-789"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {
+      backgroundManager: createMockBackgroundManager(true),
+    })
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    await new Promise(r => setTimeout(r, 3000))
+
+    // #then - no continuation injected
+    expect(promptCalls).toHaveLength(0)
+  })
+
+  test("should not inject for non-main session", async () => {
+    // #given - main session set, different session goes idle
+    setMainSession("main-session")
+    const otherSession = "other-session"
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - non-main session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID: otherSession } },
+    })
+
+    await new Promise(r => setTimeout(r, 3000))
+
+    // #then - no continuation injected
+    expect(promptCalls).toHaveLength(0)
+  })
+
+  test("should skip injection after recent error", async () => {
+    // #given - session that just had an error
+    const sessionID = "main-error"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - session error occurs
+    await hook.handler({
+      event: { type: "session.error", properties: { sessionID, error: new Error("test") } },
+    })
+
+    // #when - session goes idle immediately after
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    await new Promise(r => setTimeout(r, 3000))
+
+    // #then - no continuation injected (error cooldown)
+    expect(promptCalls).toHaveLength(0)
+  })
+
+  test("should clear error state on user message and allow injection", async () => {
+    // #given - session with error, then user clears it
+    const sessionID = "main-error-clear"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - error occurs
+    await hook.handler({
+      event: { type: "session.error", properties: { sessionID } },
+    })
+
+    // #when - user sends message (clears error immediately)
+    await hook.handler({
+      event: { type: "message.updated", properties: { info: { sessionID, role: "user" } } },
+    })
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    await new Promise(r => setTimeout(r, 2500))
+
+    // #then - continuation injected (error was cleared by user message)
+    expect(promptCalls.length).toBe(1)
+  })
+
+  test("should cancel countdown on user message", async () => {
+    // #given - session starting countdown
+    const sessionID = "main-cancel"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    // #when - user sends message immediately (before 2s countdown)
+    await hook.handler({
+      event: { 
+        type: "message.updated", 
+        properties: { info: { sessionID, role: "user" } } 
+      },
+    })
+
+    // #then - wait past countdown time and verify no injection
+    await new Promise(r => setTimeout(r, 2500))
+    expect(promptCalls).toHaveLength(0)
+  })
+
+  test("should cancel countdown on assistant activity", async () => {
+    // #given - session starting countdown
+    const sessionID = "main-assistant"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    // #when - assistant starts responding
+    await new Promise(r => setTimeout(r, 500))
+    await hook.handler({
+      event: { 
+        type: "message.part.updated", 
+        properties: { info: { sessionID, role: "assistant" } } 
+      },
+    })
+
+    await new Promise(r => setTimeout(r, 3000))
+
+    // #then - no continuation injected (cancelled)
+    expect(promptCalls).toHaveLength(0)
+  })
+
+  test("should cancel countdown on tool execution", async () => {
+    // #given - session starting countdown
+    const sessionID = "main-tool"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    // #when - tool starts executing
+    await new Promise(r => setTimeout(r, 500))
+    await hook.handler({
+      event: { type: "tool.execute.before", properties: { sessionID } },
+    })
+
+    await new Promise(r => setTimeout(r, 3000))
+
+    // #then - no continuation injected (cancelled)
+    expect(promptCalls).toHaveLength(0)
+  })
+
+  test("should skip injection during recovery mode", async () => {
+    // #given - session in recovery mode
+    const sessionID = "main-recovery"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - mark as recovering
+    hook.markRecovering(sessionID)
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    await new Promise(r => setTimeout(r, 3000))
+
+    // #then - no continuation injected
+    expect(promptCalls).toHaveLength(0)
+  })
+
+  test("should inject after recovery complete", async () => {
+    // #given - session was in recovery, now complete
+    const sessionID = "main-recovery-done"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - mark as recovering then complete
+    hook.markRecovering(sessionID)
+    hook.markRecoveryComplete(sessionID)
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    await new Promise(r => setTimeout(r, 3000))
+
+    // #then - continuation injected
+    expect(promptCalls.length).toBe(1)
+  })
+
+  test("should cleanup on session deleted", async () => {
+    // #given - session starting countdown
+    const sessionID = "main-delete"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    // #when - session is deleted during countdown
+    await new Promise(r => setTimeout(r, 500))
+    await hook.handler({
+      event: { type: "session.deleted", properties: { info: { id: sessionID } } },
+    })
+
+    await new Promise(r => setTimeout(r, 3000))
+
+    // #then - no continuation injected (cleaned up)
+    expect(promptCalls).toHaveLength(0)
+  })
+
+  test("should show countdown toast updates", async () => {
+    // #given - session with incomplete todos
+    const sessionID = "main-toast"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    // #then - multiple toast updates during countdown (2s countdown = 2 toasts: "2s" and "1s")
+    await new Promise(r => setTimeout(r, 2500))
+    expect(toastCalls.length).toBeGreaterThanOrEqual(2)
+    expect(toastCalls[0].message).toContain("2s")
+  })
+
+  test("should not have 10s throttle between injections", async () => {
+    // #given - new hook instance (no prior state)
+    const sessionID = "main-no-throttle"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - first idle cycle completes
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+    await new Promise(r => setTimeout(r, 2500))
+
+    // #then - first injection happened
+    expect(promptCalls.length).toBe(1)
+
+    // #when - immediately trigger second idle (no 10s wait needed)
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+    await new Promise(r => setTimeout(r, 2500))
+
+    // #then - second injection also happened (no throttle blocking)
+    expect(promptCalls.length).toBe(2)
+  }, { timeout: 10000 })
+})
--- a/src/hooks/todo-continuation-enforcer.ts
+++ b/src/hooks/todo-continuation-enforcer.ts
@@ -8,7 +8,6 @@ import {
 } from "../features/hook-message-injector"
 import type { BackgroundManager } from "../features/background-agent"
 import { log } from "../shared/logger"
-import { isNonInteractive } from "./non-interactive-env/detector"

 const HOOK_NAME = "todo-continuation-enforcer"

@@ -29,6 +28,13 @@ interface Todo {
  id: string
 }

+interface SessionState {
+  lastErrorAt?: number
+  countdownTimer?: ReturnType<typeof setTimeout>
+  countdownInterval?: ReturnType<typeof setInterval>
+  isRecovering?: boolean
+}
+
 const CONTINUATION_PROMPT = `[SYSTEM REMINDER - TODO CONTINUATION]

 Incomplete tasks remain in your todo list. Continue working on the next pending task.
@@ -37,6 +43,10 @@ Incomplete tasks remain in your todo list. Continue working on the next pending
 - Mark each task complete when finished
 - Do not stop until all tasks are done`

+const COUNTDOWN_SECONDS = 2
+const TOAST_DURATION_MS = 900
+const ERROR_COOLDOWN_MS = 3_000
+
 function getMessageDir(sessionID: string): string | null {
  if (!existsSync(MESSAGE_STORAGE)) return null

@@ -51,29 +61,29 @@ function getMessageDir(sessionID: string): string | null {
  return null
 }

-function detectInterrupt(error: unknown): boolean {
+function isAbortError(error: unknown): boolean {
  if (!error) return false
+  
  if (typeof error === "object") {
    const errObj = error as Record<string, unknown>
    const name = errObj.name as string | undefined
    const message = (errObj.message as string | undefined)?.toLowerCase() ?? ""
+    
    if (name === "MessageAbortedError" || name === "AbortError") return true
    if (name === "DOMException" && message.includes("abort")) return true
    if (message.includes("aborted") || message.includes("cancelled") || message.includes("interrupted")) return true
  }
+  
  if (typeof error === "string") {
    const lower = error.toLowerCase()
    return lower.includes("abort") || lower.includes("cancel") || lower.includes("interrupt")
  }
+  
  return false
 }

-const COUNTDOWN_SECONDS = 2
-const TOAST_DURATION_MS = 900 // Slightly less than 1s so toasts don't overlap
-
-interface CountdownState {
-  secondsRemaining: number
-  intervalId: ReturnType<typeof setInterval>
+function getIncompleteCount(todos: Todo[]): number {
+  return todos.filter(t => t.status !== "completed" && t.status !== "cancelled").length
 }

 export function createTodoContinuationEnforcer(
@@ -81,19 +91,156 @@ export function createTodoContinuationEnforcer(
  options: TodoContinuationEnforcerOptions = {}
 ): TodoContinuationEnforcer {
  const { backgroundManager } = options
-  const remindedSessions = new Set<string>()
-  const interruptedSessions = new Set<string>()
-  const errorSessions = new Set<string>()
-  const recoveringSessions = new Set<string>()
-  const pendingCountdowns = new Map<string, CountdownState>()
-  const preemptivelyInjectedSessions = new Set<string>()
+  const sessions = new Map<string, SessionState>()
+
+  function getState(sessionID: string): SessionState {
+    let state = sessions.get(sessionID)
+    if (!state) {
+      state = {}
+      sessions.set(sessionID, state)
+    }
+    return state
+  }
+
+  function cancelCountdown(sessionID: string): void {
+    const state = sessions.get(sessionID)
+    if (!state) return
+    
+    if (state.countdownTimer) {
+      clearTimeout(state.countdownTimer)
+      state.countdownTimer = undefined
+    }
+    if (state.countdownInterval) {
+      clearInterval(state.countdownInterval)
+      state.countdownInterval = undefined
+    }
+  }
+
+  function cleanup(sessionID: string): void {
+    cancelCountdown(sessionID)
+    sessions.delete(sessionID)
+  }

  const markRecovering = (sessionID: string): void => {
-    recoveringSessions.add(sessionID)
+    const state = getState(sessionID)
+    state.isRecovering = true
+    cancelCountdown(sessionID)
+    log(`[${HOOK_NAME}] Session marked as recovering`, { sessionID })
  }

  const markRecoveryComplete = (sessionID: string): void => {
-    recoveringSessions.delete(sessionID)
+    const state = sessions.get(sessionID)
+    if (state) {
+      state.isRecovering = false
+      log(`[${HOOK_NAME}] Session recovery complete`, { sessionID })
+    }
+  }
+
+  async function showCountdownToast(seconds: number, incompleteCount: number): Promise<void> {
+    await ctx.client.tui.showToast({
+      body: {
+        title: "Todo Continuation",
+        message: `Resuming in ${seconds}s... (${incompleteCount} tasks remaining)`,
+        variant: "warning" as const,
+        duration: TOAST_DURATION_MS,
+      },
+    }).catch(() => {})
+  }
+
+  async function injectContinuation(sessionID: string, incompleteCount: number, total: number): Promise<void> {
+    const state = sessions.get(sessionID)
+    
+    if (state?.isRecovering) {
+      log(`[${HOOK_NAME}] Skipped injection: in recovery`, { sessionID })
+      return
+    }
+
+    if (state?.lastErrorAt && Date.now() - state.lastErrorAt < ERROR_COOLDOWN_MS) {
+      log(`[${HOOK_NAME}] Skipped injection: recent error`, { sessionID })
+      return
+    }
+
+    const hasRunningBgTasks = backgroundManager
+      ? backgroundManager.getTasksByParentSession(sessionID).some(t => t.status === "running")
+      : false
+
+    if (hasRunningBgTasks) {
+      log(`[${HOOK_NAME}] Skipped injection: background tasks running`, { sessionID })
+      return
+    }
+
+    let todos: Todo[] = []
+    try {
+      const response = await ctx.client.session.todo({ path: { id: sessionID } })
+      todos = (response.data ?? response) as Todo[]
+    } catch (err) {
+      log(`[${HOOK_NAME}] Failed to fetch todos`, { sessionID, error: String(err) })
+      return
+    }
+
+    const freshIncompleteCount = getIncompleteCount(todos)
+    if (freshIncompleteCount === 0) {
+      log(`[${HOOK_NAME}] Skipped injection: no incomplete todos`, { sessionID })
+      return
+    }
+
+    const messageDir = getMessageDir(sessionID)
+    const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
+
+    const hasWritePermission = !prevMessage?.tools || 
+      (prevMessage.tools.write !== false && prevMessage.tools.edit !== false)
+    
+    if (!hasWritePermission) {
+      log(`[${HOOK_NAME}] Skipped: agent lacks write permission`, { sessionID, agent: prevMessage?.agent })
+      return
+    }
+
+    const agentName = prevMessage?.agent?.toLowerCase() ?? ""
+    if (agentName === "plan" || agentName === "planner-sisyphus") {
+      log(`[${HOOK_NAME}] Skipped: plan mode agent`, { sessionID, agent: prevMessage?.agent })
+      return
+    }
+
+    const prompt = `${CONTINUATION_PROMPT}\n\n[Status: ${todos.length - freshIncompleteCount}/${todos.length} completed, ${freshIncompleteCount} remaining]`
+
+    try {
+      log(`[${HOOK_NAME}] Injecting continuation`, { sessionID, agent: prevMessage?.agent, incompleteCount: freshIncompleteCount })
+      
+      await ctx.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          agent: prevMessage?.agent,
+          parts: [{ type: "text", text: prompt }],
+        },
+        query: { directory: ctx.directory },
+      })
+      
+      log(`[${HOOK_NAME}] Injection successful`, { sessionID })
+    } catch (err) {
+      log(`[${HOOK_NAME}] Injection failed`, { sessionID, error: String(err) })
+    }
+  }
+
+  function startCountdown(sessionID: string, incompleteCount: number, total: number): void {
+    const state = getState(sessionID)
+    cancelCountdown(sessionID)
+
+    let secondsRemaining = COUNTDOWN_SECONDS
+    showCountdownToast(secondsRemaining, incompleteCount)
+
+    state.countdownInterval = setInterval(() => {
+      secondsRemaining--
+      if (secondsRemaining > 0) {
+        showCountdownToast(secondsRemaining, incompleteCount)
+      }
+    }, 1000)
+
+    state.countdownTimer = setTimeout(() => {
+      cancelCountdown(sessionID)
+      injectContinuation(sessionID, incompleteCount, total)
+    }, COUNTDOWN_SECONDS * 1000)
+
+    log(`[${HOOK_NAME}] Countdown started`, { sessionID, seconds: COUNTDOWN_SECONDS, incompleteCount })
  }

  const handler = async ({ event }: { event: { type: string; properties?: unknown } }): Promise<void> => {
@@ -101,20 +248,13 @@ export function createTodoContinuationEnforcer(

    if (event.type === "session.error") {
      const sessionID = props?.sessionID as string | undefined
-      if (sessionID) {
-        const isInterrupt = detectInterrupt(props?.error)
-        errorSessions.add(sessionID)
-        if (isInterrupt) {
-          interruptedSessions.add(sessionID)
-        }
-        log(`[${HOOK_NAME}] session.error received`, { sessionID, isInterrupt, error: props?.error })
-        
-        const countdown = pendingCountdowns.get(sessionID)
-        if (countdown) {
-          clearInterval(countdown.intervalId)
-          pendingCountdowns.delete(sessionID)
-        }
-      }
+      if (!sessionID) return
+
+      const state = getState(sessionID)
+      state.lastErrorAt = Date.now()
+      cancelCountdown(sessionID)
+      
+      log(`[${HOOK_NAME}] session.error`, { sessionID, isAbort: isAbortError(props?.error) })
      return
    }

@@ -122,285 +262,107 @@ export function createTodoContinuationEnforcer(
      const sessionID = props?.sessionID as string | undefined
      if (!sessionID) return

-      log(`[${HOOK_NAME}] session.idle received`, { sessionID })
+      log(`[${HOOK_NAME}] session.idle`, { sessionID })

      const mainSessionID = getMainSessionID()
      if (mainSessionID && sessionID !== mainSessionID) {
-        log(`[${HOOK_NAME}] Skipped: not main session`, { sessionID, mainSessionID })
+        log(`[${HOOK_NAME}] Skipped: not main session`, { sessionID })
        return
      }

-      const existingCountdown = pendingCountdowns.get(sessionID)
-      if (existingCountdown) {
-        clearInterval(existingCountdown.intervalId)
-        pendingCountdowns.delete(sessionID)
-        log(`[${HOOK_NAME}] Cancelled existing countdown`, { sessionID })
-      }
+      const state = getState(sessionID)

-      // Check if session is in recovery mode - if so, skip entirely without clearing state
-      if (recoveringSessions.has(sessionID)) {
-        log(`[${HOOK_NAME}] Skipped: session in recovery mode`, { sessionID })
+      if (state.isRecovering) {
+        log(`[${HOOK_NAME}] Skipped: in recovery`, { sessionID })
        return
      }

-      const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID)
-      
-      if (shouldBypass) {
-        interruptedSessions.delete(sessionID)
-        errorSessions.delete(sessionID)
-        log(`[${HOOK_NAME}] Skipped: error/interrupt bypass`, { sessionID })
+      if (state.lastErrorAt && Date.now() - state.lastErrorAt < ERROR_COOLDOWN_MS) {
+        log(`[${HOOK_NAME}] Skipped: recent error (cooldown)`, { sessionID })
        return
      }

-      if (remindedSessions.has(sessionID)) {
-        log(`[${HOOK_NAME}] Skipped: already reminded this session`, { sessionID })
+      const hasRunningBgTasks = backgroundManager
+        ? backgroundManager.getTasksByParentSession(sessionID).some(t => t.status === "running")
+        : false
+
+      if (hasRunningBgTasks) {
+        log(`[${HOOK_NAME}] Skipped: background tasks running`, { sessionID })
        return
      }

-      // Check for incomplete todos BEFORE starting countdown
      let todos: Todo[] = []
      try {
-        log(`[${HOOK_NAME}] Fetching todos for session`, { sessionID })
-        const response = await ctx.client.session.todo({
-          path: { id: sessionID },
-        })
+        const response = await ctx.client.session.todo({ path: { id: sessionID } })
        todos = (response.data ?? response) as Todo[]
-        log(`[${HOOK_NAME}] Todo API response`, { sessionID, todosCount: todos?.length ?? 0 })
      } catch (err) {
-        log(`[${HOOK_NAME}] Todo API error`, { sessionID, error: String(err) })
+        log(`[${HOOK_NAME}] Todo fetch failed`, { sessionID, error: String(err) })
        return
      }

      if (!todos || todos.length === 0) {
-        log(`[${HOOK_NAME}] No todos found`, { sessionID })
+        log(`[${HOOK_NAME}] No todos`, { sessionID })
        return
      }

-      const incomplete = todos.filter(
-        (t) => t.status !== "completed" && t.status !== "cancelled"
-      )
-
-      if (incomplete.length === 0) {
-        log(`[${HOOK_NAME}] All todos completed`, { sessionID, total: todos.length })
+      const incompleteCount = getIncompleteCount(todos)
+      if (incompleteCount === 0) {
+        log(`[${HOOK_NAME}] All todos complete`, { sessionID, total: todos.length })
        return
      }

-      log(`[${HOOK_NAME}] Found incomplete todos, starting countdown`, { sessionID, incomplete: incomplete.length, total: todos.length })
-
-      const showCountdownToast = async (seconds: number): Promise<void> => {
-        await ctx.client.tui.showToast({
-          body: {
-            title: "Todo Continuation",
-            message: `Resuming in ${seconds}s... (${incomplete.length} tasks remaining)`,
-            variant: "warning" as const,
-            duration: TOAST_DURATION_MS,
-          },
-        }).catch(() => {})
-      }
-
-      const executeAfterCountdown = async (): Promise<void> => {
-        pendingCountdowns.delete(sessionID)
-        log(`[${HOOK_NAME}] Countdown finished, executing continuation`, { sessionID })
-
-        // Re-check conditions after countdown
-        if (recoveringSessions.has(sessionID)) {
-          log(`[${HOOK_NAME}] Abort: session entered recovery mode during countdown`, { sessionID })
-          return
-        }
-
-        if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID)) {
-          log(`[${HOOK_NAME}] Abort: error/interrupt occurred during countdown`, { sessionID })
-          interruptedSessions.delete(sessionID)
-          errorSessions.delete(sessionID)
-          return
-        }
-
-        let freshTodos: Todo[] = []
-        try {
-          log(`[${HOOK_NAME}] Re-verifying todos after countdown`, { sessionID })
-          const response = await ctx.client.session.todo({
-            path: { id: sessionID },
-          })
-          freshTodos = (response.data ?? response) as Todo[]
-          log(`[${HOOK_NAME}] Fresh todo count`, { sessionID, todosCount: freshTodos?.length ?? 0 })
-        } catch (err) {
-          log(`[${HOOK_NAME}] Failed to re-verify todos`, { sessionID, error: String(err) })
-          return
-        }
-
-        const freshIncomplete = freshTodos.filter(
-          (t) => t.status !== "completed" && t.status !== "cancelled"
-        )
-
-        if (freshIncomplete.length === 0) {
-          log(`[${HOOK_NAME}] Abort: no incomplete todos after countdown`, { sessionID, total: freshTodos.length })
-          return
-        }
-
-        log(`[${HOOK_NAME}] Confirmed incomplete todos, proceeding with injection`, { sessionID, incomplete: freshIncomplete.length, total: freshTodos.length })
-
-        remindedSessions.add(sessionID)
-
-        try {
-          // Get previous message's agent info to respect agent mode
-          const messageDir = getMessageDir(sessionID)
-          const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
-
-          const agentHasWritePermission = !prevMessage?.tools || (prevMessage.tools.write !== false && prevMessage.tools.edit !== false)
-          if (!agentHasWritePermission) {
-            log(`[${HOOK_NAME}] Skipped: previous agent lacks write permission`, { sessionID, agent: prevMessage?.agent, tools: prevMessage?.tools })
-            remindedSessions.delete(sessionID)
-            return
-          }
-
-          log(`[${HOOK_NAME}] Injecting continuation prompt`, { sessionID, agent: prevMessage?.agent })
-          await ctx.client.session.prompt({
-            path: { id: sessionID },
-            body: {
-              agent: prevMessage?.agent,
-              parts: [
-                {
-                  type: "text",
-                  text: `${CONTINUATION_PROMPT}\n\n[Status: ${freshTodos.length - freshIncomplete.length}/${freshTodos.length} completed, ${freshIncomplete.length} remaining]`,
-                },
-              ],
-            },
-            query: { directory: ctx.directory },
-          })
-          log(`[${HOOK_NAME}] Continuation prompt injected successfully`, { sessionID })
-        } catch (err) {
-          log(`[${HOOK_NAME}] Prompt injection failed`, { sessionID, error: String(err) })
-          remindedSessions.delete(sessionID)
-        }
-      }
-
-      let secondsRemaining = COUNTDOWN_SECONDS
-      showCountdownToast(secondsRemaining).catch(() => {})
-
-      const intervalId = setInterval(() => {
-        secondsRemaining--
-        
-        if (secondsRemaining <= 0) {
-          clearInterval(intervalId)
-          pendingCountdowns.delete(sessionID)
-          executeAfterCountdown()
-          return
-        }
-
-        const countdown = pendingCountdowns.get(sessionID)
-        if (!countdown) {
-          clearInterval(intervalId)
-          return
-        }
-
-        countdown.secondsRemaining = secondsRemaining
-        showCountdownToast(secondsRemaining).catch(() => {})
-      }, 1000)
-
-      pendingCountdowns.set(sessionID, { secondsRemaining, intervalId })
+      startCountdown(sessionID, incompleteCount, todos.length)
+      return
    }

    if (event.type === "message.updated") {
      const info = props?.info as Record<string, unknown> | undefined
      const sessionID = info?.sessionID as string | undefined
      const role = info?.role as string | undefined
-      const finish = info?.finish as string | undefined
-      log(`[${HOOK_NAME}] message.updated received`, { sessionID, role, finish })
-      
-      if (sessionID && role === "user") {
-        const countdown = pendingCountdowns.get(sessionID)
-        if (countdown) {
-          clearInterval(countdown.intervalId)
-          pendingCountdowns.delete(sessionID)
-          log(`[${HOOK_NAME}] Cancelled countdown on user message`, { sessionID })
+
+      if (!sessionID) return
+
+      if (role === "user") {
+        const state = sessions.get(sessionID)
+        if (state) {
+          state.lastErrorAt = undefined
        }
-        remindedSessions.delete(sessionID)
-        preemptivelyInjectedSessions.delete(sessionID)
+        cancelCountdown(sessionID)
+        log(`[${HOOK_NAME}] User message: cleared error state`, { sessionID })
      }

-      if (sessionID && role === "assistant" && finish) {
-        remindedSessions.delete(sessionID)
-        preemptivelyInjectedSessions.delete(sessionID)
-        log(`[${HOOK_NAME}] Cleared reminded/preemptive state on assistant finish`, { sessionID })
-
-        const isTerminalFinish = finish && !["tool-calls", "unknown"].includes(finish)
-        if (isTerminalFinish && isNonInteractive()) {
-          log(`[${HOOK_NAME}] Terminal finish in non-interactive mode`, { sessionID, finish })
-
-          const mainSessionID = getMainSessionID()
-          if (mainSessionID && sessionID !== mainSessionID) {
-            log(`[${HOOK_NAME}] Skipped preemptive: not main session`, { sessionID, mainSessionID })
-            return
-          }
-
-          if (preemptivelyInjectedSessions.has(sessionID)) {
-            log(`[${HOOK_NAME}] Skipped preemptive: already injected`, { sessionID })
-            return
-          }
-
-          if (recoveringSessions.has(sessionID) || errorSessions.has(sessionID) || interruptedSessions.has(sessionID)) {
-            log(`[${HOOK_NAME}] Skipped preemptive: session in error/recovery state`, { sessionID })
-            return
-          }
-
-          const hasRunningBgTasks = backgroundManager
-            ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running")
-            : false
-
-          let hasIncompleteTodos = false
-          try {
-            const response = await ctx.client.session.todo({ path: { id: sessionID } })
-            const todos = (response.data ?? response) as Todo[]
-            hasIncompleteTodos = todos?.some((t) => t.status !== "completed" && t.status !== "cancelled") ?? false
-          } catch {
-            log(`[${HOOK_NAME}] Failed to fetch todos for preemptive check`, { sessionID })
-          }
-
-          if (hasRunningBgTasks || hasIncompleteTodos) {
-            log(`[${HOOK_NAME}] Preemptive injection needed`, { sessionID, hasRunningBgTasks, hasIncompleteTodos })
-            preemptivelyInjectedSessions.add(sessionID)
-
-            try {
-              const messageDir = getMessageDir(sessionID)
-              const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
-
-              const prompt = hasRunningBgTasks
-                ? "[SYSTEM] Background tasks are still running. Wait for their completion before proceeding."
-                : CONTINUATION_PROMPT
-
-              await ctx.client.session.prompt({
-                path: { id: sessionID },
-                body: {
-                  agent: prevMessage?.agent,
-                  parts: [{ type: "text", text: prompt }],
-                },
-                query: { directory: ctx.directory },
-              })
-              log(`[${HOOK_NAME}] Preemptive injection successful`, { sessionID })
-            } catch (err) {
-              log(`[${HOOK_NAME}] Preemptive injection failed`, { sessionID, error: String(err) })
-              preemptivelyInjectedSessions.delete(sessionID)
-            }
-          }
-        }
+      if (role === "assistant") {
+        cancelCountdown(sessionID)
      }
+      return
+    }
+
+    if (event.type === "message.part.updated") {
+      const info = props?.info as Record<string, unknown> | undefined
+      const sessionID = info?.sessionID as string | undefined
+      const role = info?.role as string | undefined
+
+      if (sessionID && role === "assistant") {
+        cancelCountdown(sessionID)
+      }
+      return
+    }
+
+    if (event.type === "tool.execute.before" || event.type === "tool.execute.after") {
+      const sessionID = props?.sessionID as string | undefined
+      if (sessionID) {
+        cancelCountdown(sessionID)
+      }
+      return
    }

    if (event.type === "session.deleted") {
      const sessionInfo = props?.info as { id?: string } | undefined
      if (sessionInfo?.id) {
-        remindedSessions.delete(sessionInfo.id)
-        interruptedSessions.delete(sessionInfo.id)
-        errorSessions.delete(sessionInfo.id)
-        recoveringSessions.delete(sessionInfo.id)
-        preemptivelyInjectedSessions.delete(sessionInfo.id)
-        
-        const countdown = pendingCountdowns.get(sessionInfo.id)
-        if (countdown) {
-          clearInterval(countdown.intervalId)
-          pendingCountdowns.delete(sessionInfo.id)
-        }
+        cleanup(sessionInfo.id)
+        log(`[${HOOK_NAME}] Session deleted: cleaned up`, { sessionID: sessionInfo.id })
      }
+      return
    }
  }

--- a/src/index.ts
+++ b/src/index.ts
@@ -32,6 +32,7 @@ import {
  loadOpencodeGlobalCommands,
  loadOpencodeProjectCommands,
 } from "./features/claude-code-command-loader";
+import { loadBuiltinCommands } from "./features/builtin-commands";

 import {
  loadUserAgents,
@@ -169,6 +170,12 @@ function mergeConfigs(
        ...(override.disabled_hooks ?? []),
      ]),
    ],
+    disabled_commands: [
+      ...new Set([
+        ...(base.disabled_commands ?? []),
+        ...(override.disabled_commands ?? []),
+      ]),
+    ],
    claude_code: deepMerge(base.claude_code, override.claude_code),
  };
 }
@@ -233,7 +240,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
    : null;

  const commentChecker = isHookEnabled("comment-checker")
-    ? createCommentCheckerHooks()
+    ? createCommentCheckerHooks(pluginConfig.comment_checker)
    : null;
  const toolOutputTruncator = isHookEnabled("tool-output-truncator")
    ? createToolOutputTruncatorHook(ctx, { experimental: pluginConfig.experimental })
@@ -510,12 +517,14 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
        ...pluginComponents.mcpServers,
      };

+      const builtinCommands = loadBuiltinCommands(pluginConfig.disabled_commands);
      const userCommands = (pluginConfig.claude_code?.commands ?? true) ? loadUserCommands() : {};
      const opencodeGlobalCommands = loadOpencodeGlobalCommands();
      const systemCommands = config.command ?? {};
      const projectCommands = (pluginConfig.claude_code?.commands ?? true) ? loadProjectCommands() : {};
      const opencodeProjectCommands = loadOpencodeProjectCommands();
      config.command = {
+        ...builtinCommands,
        ...userCommands,
        ...opencodeGlobalCommands,
        ...systemCommands,
@@ -632,6 +641,7 @@ export type {
  AgentOverrides,
  McpName,
  HookName,
+  BuiltinCommandName,
 } from "./config";

 // NOTE: Do NOT export functions from main index.ts!
--- a/src/shared/data-path.ts
+++ b/src/shared/data-path.ts
@@ -2,27 +2,20 @@ import * as path from "node:path"
 import * as os from "node:os"

 /**
- * Returns the user-level data directory based on the OS.
- * - Linux/macOS: XDG_DATA_HOME or ~/.local/share
- * - Windows: %LOCALAPPDATA%
+ * Returns the user-level data directory.
+ * Matches OpenCode's behavior via xdg-basedir:
+ * - All platforms: XDG_DATA_HOME or ~/.local/share
 *
- * This follows XDG Base Directory specification on Unix systems
- * and Windows conventions on Windows.
+ * Note: OpenCode uses xdg-basedir which returns ~/.local/share on ALL platforms
+ * including Windows, so we match that behavior exactly.
 */
 export function getDataDir(): string {
-  if (process.platform === "win32") {
-    // Windows: Use %LOCALAPPDATA% (e.g., C:\Users\Username\AppData\Local)
-    return process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local")
-  }
-
-  // Unix: Use XDG_DATA_HOME or fallback to ~/.local/share
  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share")
 }

 /**
 * Returns the OpenCode storage directory path.
- * - Linux/macOS: ~/.local/share/opencode/storage
- * - Windows: %LOCALAPPDATA%\opencode\storage
+ * All platforms: ~/.local/share/opencode/storage
 */
 export function getOpenCodeStorageDir(): string {
  return path.join(getDataDir(), "opencode", "storage")
--- a/src/tools/ast-grep/constants.ts
+++ b/src/tools/ast-grep/constants.ts
@@ -100,8 +100,6 @@ export function setSgCliPath(path: string): void {
  resolvedCliPath = path
 }

-export const SG_CLI_PATH = getSgCliPath()
-
 // CLI supported languages (25 total)
 export const CLI_LANGUAGES = [
  "bash",
@@ -184,21 +182,20 @@ export interface EnvironmentCheckResult {
 * Call this at startup to provide early feedback about missing dependencies.
 */
 export function checkEnvironment(): EnvironmentCheckResult {
+  const cliPath = getSgCliPath()
  const result: EnvironmentCheckResult = {
    cli: {
      available: false,
-      path: SG_CLI_PATH,
+      path: cliPath,
    },
    napi: {
      available: false,
    },
  }

-  // Check CLI availability
-  if (existsSync(SG_CLI_PATH)) {
+  if (existsSync(cliPath)) {
    result.cli.available = true
-  } else if (SG_CLI_PATH === "sg") {
-    // Fallback path - try which/where to find in PATH
+  } else if (cliPath === "sg") {
    try {
      const { spawnSync } = require("child_process")
      const whichResult = spawnSync(process.platform === "win32" ? "where" : "which", ["sg"], {
@@ -213,7 +210,7 @@ export function checkEnvironment(): EnvironmentCheckResult {
      result.cli.error = "Failed to check sg availability"
    }
  } else {
-    result.cli.error = `Binary not found: ${SG_CLI_PATH}`
+    result.cli.error = `Binary not found: ${cliPath}`
  }

  // Check NAPI availability
--- a/src/tools/background-task/tools.ts
+++ b/src/tools/background-task/tools.ts
@@ -37,6 +37,14 @@ function formatDuration(start: Date, end?: Date): string {
  }
 }

+type ToolContextWithMetadata = {
+  sessionID: string
+  messageID: string
+  agent: string
+  abort: AbortSignal
+  metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
+}
+
 export function createBackgroundTask(manager: BackgroundManager): ToolDefinition {
  return tool({
    description: BACKGROUND_TASK_DESCRIPTION,
@@ -46,12 +54,14 @@ export function createBackgroundTask(manager: BackgroundManager): ToolDefinition
      agent: tool.schema.string().describe("Agent type to use (any registered agent)"),
    },
    async execute(args: BackgroundTaskArgs, toolContext) {
+      const ctx = toolContext as ToolContextWithMetadata
+
      if (!args.agent || args.agent.trim() === "") {
        return `❌ Agent parameter is required. Please specify which agent to use (e.g., "explore", "librarian", "build", etc.)`
      }

      try {
-        const messageDir = getMessageDir(toolContext.sessionID)
+        const messageDir = getMessageDir(ctx.sessionID)
        const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
        const parentModel = prevMessage?.model?.providerID && prevMessage?.model?.modelID
          ? { providerID: prevMessage.model.providerID, modelID: prevMessage.model.modelID }
@@ -61,11 +71,16 @@ export function createBackgroundTask(manager: BackgroundManager): ToolDefinition
          description: args.description,
          prompt: args.prompt,
          agent: args.agent.trim(),
-          parentSessionID: toolContext.sessionID,
-          parentMessageID: toolContext.messageID,
+          parentSessionID: ctx.sessionID,
+          parentMessageID: ctx.messageID,
          parentModel,
        })

+        ctx.metadata?.({
+          title: args.description,
+          metadata: { sessionId: task.sessionID },
+        })
+
        return `Background task launched successfully.

 Task ID: ${task.id}
--- a/src/tools/call-omo-agent/tools.ts
+++ b/src/tools/call-omo-agent/tools.ts
@@ -4,6 +4,14 @@ import type { CallOmoAgentArgs } from "./types"
 import type { BackgroundManager } from "../../features/background-agent"
 import { log } from "../../shared/logger"

+type ToolContextWithMetadata = {
+  sessionID: string
+  messageID: string
+  agent: string
+  abort: AbortSignal
+  metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
+}
+
 export function createCallOmoAgent(
  ctx: PluginInput,
  backgroundManager: BackgroundManager
@@ -27,6 +35,7 @@ export function createCallOmoAgent(
      session_id: tool.schema.string().describe("Existing Task session to continue").optional(),
    },
    async execute(args: CallOmoAgentArgs, toolContext) {
+      const toolCtx = toolContext as ToolContextWithMetadata
      log(`[call_omo_agent] Starting with agent: ${args.subagent_type}, background: ${args.run_in_background}`)

      if (!ALLOWED_AGENTS.includes(args.subagent_type as typeof ALLOWED_AGENTS[number])) {
@@ -37,17 +46,17 @@ export function createCallOmoAgent(
        if (args.session_id) {
          return `Error: session_id is not supported in background mode. Use run_in_background=false to continue an existing session.`
        }
-        return await executeBackground(args, toolContext, backgroundManager)
+        return await executeBackground(args, toolCtx, backgroundManager)
      }

-      return await executeSync(args, toolContext, ctx)
+      return await executeSync(args, toolCtx, ctx)
    },
  })
 }

 async function executeBackground(
  args: CallOmoAgentArgs,
-  toolContext: { sessionID: string; messageID: string },
+  toolContext: ToolContextWithMetadata,
  manager: BackgroundManager
 ): Promise<string> {
  try {
@@ -59,6 +68,11 @@ async function executeBackground(
      parentMessageID: toolContext.messageID,
    })

+    toolContext.metadata?.({
+      title: args.description,
+      metadata: { sessionId: task.sessionID },
+    })
+
    return `Background agent task launched successfully.

 Task ID: ${task.id}
@@ -79,7 +93,7 @@ Use \`background_output\` tool with task_id="${task.id}" to check progress:

 async function executeSync(
  args: CallOmoAgentArgs,
-  toolContext: { sessionID: string },
+  toolContext: ToolContextWithMetadata,
  ctx: PluginInput
 ): Promise<string> {
  let sessionID: string
@@ -112,6 +126,11 @@ async function executeSync(
    log(`[call_omo_agent] Created session: ${sessionID}`)
  }

+  toolContext.metadata?.({
+    title: args.description,
+    metadata: { sessionId: sessionID },
+  })
+
  log(`[call_omo_agent] Sending prompt to session ${sessionID}`)
  log(`[call_omo_agent] Prompt text:`, args.prompt.substring(0, 100))

--- a/src/tools/lsp/client.ts
+++ b/src/tools/lsp/client.ts
@@ -1,9 +1,8 @@
 import { spawn, type Subprocess } from "bun"
 import { readFileSync } from "fs"
 import { extname, resolve } from "path"
-import type { ResolvedServer } from "./config"
 import { getLanguageId } from "./config"
-import type { Diagnostic } from "./types"
+import type { Diagnostic, ResolvedServer } from "./types"

 interface ManagedClient {
  client: LSPClient
--- a/src/tools/lsp/config.ts
+++ b/src/tools/lsp/config.ts
@@ -1,16 +1,8 @@
 import { existsSync, readFileSync } from "fs"
 import { join } from "path"
 import { homedir } from "os"
-import { BUILTIN_SERVERS, EXT_TO_LANG } from "./constants"
-
-export interface ResolvedServer {
-  id: string
-  command: string[]
-  extensions: string[]
-  priority: number
-  env?: Record<string, string>
-  initialization?: Record<string, unknown>
-}
+import { BUILTIN_SERVERS, EXT_TO_LANG, LSP_INSTALL_HINTS } from "./constants"
+import type { ResolvedServer, ServerLookupResult } from "./types"

 interface LspEntry {
  disabled?: boolean
@@ -120,23 +112,47 @@ function getMergedServers(): ServerWithSource[] {
  })
 }

-export function findServerForExtension(ext: string): ResolvedServer | null {
+export function findServerForExtension(ext: string): ServerLookupResult {
  const servers = getMergedServers()

  for (const server of servers) {
    if (server.extensions.includes(ext) && isServerInstalled(server.command)) {
      return {
-        id: server.id,
-        command: server.command,
-        extensions: server.extensions,
-        priority: server.priority,
-        env: server.env,
-        initialization: server.initialization,
+        status: "found",
+        server: {
+          id: server.id,
+          command: server.command,
+          extensions: server.extensions,
+          priority: server.priority,
+          env: server.env,
+          initialization: server.initialization,
+        },
      }
    }
  }

-  return null
+  for (const server of servers) {
+    if (server.extensions.includes(ext)) {
+      const installHint =
+        LSP_INSTALL_HINTS[server.id] || `Install '${server.command[0]}' and ensure it's in your PATH`
+      return {
+        status: "not_installed",
+        server: {
+          id: server.id,
+          command: server.command,
+          extensions: server.extensions,
+        },
+        installHint,
+      }
+    }
+  }
+
+  const availableServers = [...new Set(servers.map((s) => s.id))]
+  return {
+    status: "not_configured",
+    extension: ext,
+    availableServers,
+  }
 }

 export function getLanguageId(ext: string): string {
--- a/src/tools/lsp/constants.ts
+++ b/src/tools/lsp/constants.ts
@@ -40,6 +40,37 @@ export const DEFAULT_MAX_REFERENCES = 200
 export const DEFAULT_MAX_SYMBOLS = 200
 export const DEFAULT_MAX_DIAGNOSTICS = 200

+export const LSP_INSTALL_HINTS: Record<string, string> = {
+  typescript: "npm install -g typescript-language-server typescript",
+  deno: "Install Deno from https://deno.land",
+  vue: "npm install -g @vue/language-server",
+  eslint: "npm install -g vscode-langservers-extracted",
+  oxlint: "npm install -g oxlint",
+  biome: "npm install -g @biomejs/biome",
+  gopls: "go install golang.org/x/tools/gopls@latest",
+  "ruby-lsp": "gem install ruby-lsp",
+  basedpyright: "pip install basedpyright",
+  pyright: "pip install pyright",
+  ty: "pip install ty",
+  ruff: "pip install ruff",
+  "elixir-ls": "See https://github.com/elixir-lsp/elixir-ls",
+  zls: "See https://github.com/zigtools/zls",
+  csharp: "dotnet tool install -g csharp-ls",
+  fsharp: "dotnet tool install -g fsautocomplete",
+  "sourcekit-lsp": "Included with Xcode or Swift toolchain",
+  rust: "rustup component add rust-analyzer",
+  clangd: "See https://clangd.llvm.org/installation",
+  svelte: "npm install -g svelte-language-server",
+  astro: "npm install -g @astrojs/language-server",
+  "bash-ls": "npm install -g bash-language-server",
+  jdtls: "See https://github.com/eclipse-jdtls/eclipse.jdt.ls",
+  "yaml-ls": "npm install -g yaml-language-server",
+  "lua-ls": "See https://github.com/LuaLS/lua-language-server",
+  php: "npm install -g intelephense",
+  dart: "Included with Dart SDK",
+  "terraform-ls": "See https://github.com/hashicorp/terraform-ls",
+}
+
 // Synced with OpenCode's server.ts
 // https://github.com/sst/opencode/blob/main/packages/opencode/src/lsp/server.ts
 export const BUILTIN_SERVERS: Record<string, Omit<LSPServerConfig, "id">> = {
--- a/src/tools/lsp/types.ts
+++ b/src/tools/lsp/types.ts
@@ -135,3 +135,23 @@ export interface CodeAction {
  command?: Command
  data?: unknown
 }
+
+export interface ServerLookupInfo {
+  id: string
+  command: string[]
+  extensions: string[]
+}
+
+export type ServerLookupResult =
+  | { status: "found"; server: ResolvedServer }
+  | { status: "not_configured"; extension: string; availableServers: string[] }
+  | { status: "not_installed"; server: ServerLookupInfo; installHint: string }
+
+export interface ResolvedServer {
+  id: string
+  command: string[]
+  extensions: string[]
+  priority: number
+  env?: Record<string, string>
+  initialization?: Record<string, unknown>
+}
--- a/src/tools/lsp/utils.ts
+++ b/src/tools/lsp/utils.ts
@@ -17,6 +17,7 @@ import type {
  TextEdit,
  CodeAction,
  Command,
+  ServerLookupResult,
 } from "./types"

 export function findWorkspaceRoot(filePath: string): string {
@@ -40,15 +41,51 @@ export function findWorkspaceRoot(filePath: string): string {
  return require("path").dirname(resolve(filePath))
 }

+export function formatServerLookupError(result: Exclude<ServerLookupResult, { status: "found" }>): string {
+  if (result.status === "not_installed") {
+    const { server, installHint } = result
+    return [
+      `LSP server '${server.id}' is configured but NOT INSTALLED.`,
+      ``,
+      `Command not found: ${server.command[0]}`,
+      ``,
+      `To install:`,
+      `  ${installHint}`,
+      ``,
+      `Supported extensions: ${server.extensions.join(", ")}`,
+      ``,
+      `After installation, the server will be available automatically.`,
+      `Run 'lsp_servers' tool to verify installation status.`,
+    ].join("\n")
+  }
+
+  return [
+    `No LSP server configured for extension: ${result.extension}`,
+    ``,
+    `Available servers: ${result.availableServers.slice(0, 10).join(", ")}${result.availableServers.length > 10 ? "..." : ""}`,
+    ``,
+    `To add a custom server, configure 'lsp' in oh-my-opencode.json:`,
+    `  {`,
+    `    "lsp": {`,
+    `      "my-server": {`,
+    `        "command": ["my-lsp", "--stdio"],`,
+    `        "extensions": ["${result.extension}"]`,
+    `      }`,
+    `    }`,
+    `  }`,
+  ].join("\n")
+}
+
 export async function withLspClient<T>(filePath: string, fn: (client: LSPClient) => Promise<T>): Promise<T> {
  const absPath = resolve(filePath)
  const ext = extname(absPath)
-  const server = findServerForExtension(ext)
+  const result = findServerForExtension(ext)

-  if (!server) {
-    throw new Error(`No LSP server configured for extension: ${ext}`)
+  if (result.status !== "found") {
+    throw new Error(formatServerLookupError(result))
  }

+  const server = result.server
  const root = findWorkspaceRoot(absPath)
  const client = await lspManager.getClient(root, server)

--- a/src/tools/session-manager/storage.test.ts
+++ b/src/tools/session-manager/storage.test.ts
@@ -23,7 +23,8 @@ mock.module("./constants", () => ({
  TOOL_NAME_PREFIX: "session_",
 }))

-const { getAllSessions, getMessageDir, sessionExists, readSessionMessages, readSessionTodos, getSessionInfo } = await import("./storage")
+const { getAllSessions, getMessageDir, sessionExists, readSessionMessages, readSessionTodos, getSessionInfo } =
+  await import("./storage")

 describe("session-manager storage", () => {
  beforeEach(() => {
@@ -43,48 +44,61 @@ describe("session-manager storage", () => {
    }
  })

-  test("getAllSessions returns empty array when no sessions exist", () => {
-    const sessions = getAllSessions()
-    
+  test("getAllSessions returns empty array when no sessions exist", async () => {
+    // #when
+    const sessions = await getAllSessions()
+
+    // #then
    expect(Array.isArray(sessions)).toBe(true)
    expect(sessions).toEqual([])
  })

  test("getMessageDir finds session in direct path", () => {
+    // #given
    const sessionID = "ses_test123"
    const sessionPath = join(TEST_MESSAGE_STORAGE, sessionID)
    mkdirSync(sessionPath, { recursive: true })
    writeFileSync(join(sessionPath, "msg_001.json"), JSON.stringify({ id: "msg_001", role: "user" }))

+    // #when
    const result = getMessageDir(sessionID)
-    
+
+    // #then
    expect(result).toBe(sessionPath)
  })

  test("sessionExists returns false for non-existent session", () => {
+    // #when
    const exists = sessionExists("ses_nonexistent")
-    
+
+    // #then
    expect(exists).toBe(false)
  })

  test("sessionExists returns true for existing session", () => {
+    // #given
    const sessionID = "ses_exists"
    const sessionPath = join(TEST_MESSAGE_STORAGE, sessionID)
    mkdirSync(sessionPath, { recursive: true })
    writeFileSync(join(sessionPath, "msg_001.json"), JSON.stringify({ id: "msg_001" }))

+    // #when
    const exists = sessionExists(sessionID)
-    
+
+    // #then
    expect(exists).toBe(true)
  })

-  test("readSessionMessages returns empty array for non-existent session", () => {
-    const messages = readSessionMessages("ses_nonexistent")
-    
+  test("readSessionMessages returns empty array for non-existent session", async () => {
+    // #when
+    const messages = await readSessionMessages("ses_nonexistent")
+
+    // #then
    expect(messages).toEqual([])
  })

-  test("readSessionMessages sorts messages by timestamp", () => {
+  test("readSessionMessages sorts messages by timestamp", async () => {
+    // #given
    const sessionID = "ses_test123"
    const sessionPath = join(TEST_MESSAGE_STORAGE, sessionID)
    mkdirSync(sessionPath, { recursive: true })
@@ -98,26 +112,33 @@ describe("session-manager storage", () => {
      JSON.stringify({ id: "msg_001", role: "user", time: { created: 1000 } })
    )

-    const messages = readSessionMessages(sessionID)
-    
+    // #when
+    const messages = await readSessionMessages(sessionID)
+
+    // #then
    expect(messages.length).toBe(2)
    expect(messages[0].id).toBe("msg_001")
    expect(messages[1].id).toBe("msg_002")
  })

-  test("readSessionTodos returns empty array when no todos exist", () => {
-    const todos = readSessionTodos("ses_nonexistent")
-    
+  test("readSessionTodos returns empty array when no todos exist", async () => {
+    // #when
+    const todos = await readSessionTodos("ses_nonexistent")
+
+    // #then
    expect(todos).toEqual([])
  })

-  test("getSessionInfo returns null for non-existent session", () => {
-    const info = getSessionInfo("ses_nonexistent")
-    
+  test("getSessionInfo returns null for non-existent session", async () => {
+    // #when
+    const info = await getSessionInfo("ses_nonexistent")
+
+    // #then
    expect(info).toBeNull()
  })

-  test("getSessionInfo aggregates session metadata correctly", () => {
+  test("getSessionInfo aggregates session metadata correctly", async () => {
+    // #given
    const sessionID = "ses_test123"
    const sessionPath = join(TEST_MESSAGE_STORAGE, sessionID)
    mkdirSync(sessionPath, { recursive: true })
@@ -142,8 +163,10 @@ describe("session-manager storage", () => {
      })
    )

-    const info = getSessionInfo(sessionID)
-    
+    // #when
+    const info = await getSessionInfo(sessionID)
+
+    // #then
    expect(info).not.toBeNull()
    expect(info?.id).toBe(sessionID)
    expect(info?.message_count).toBe(2)
--- a/src/tools/session-manager/storage.ts
+++ b/src/tools/session-manager/storage.ts
@@ -1,23 +1,25 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs"
+import { existsSync, readdirSync } from "node:fs"
+import { readdir, readFile } from "node:fs/promises"
 import { join } from "node:path"
 import { MESSAGE_STORAGE, PART_STORAGE, TODO_DIR, TRANSCRIPT_DIR } from "./constants"
 import type { SessionMessage, SessionInfo, TodoItem } from "./types"

-export function getAllSessions(): string[] {
+export async function getAllSessions(): Promise<string[]> {
  if (!existsSync(MESSAGE_STORAGE)) return []

  const sessions: string[] = []

-  function scanDirectory(dir: string): void {
+  async function scanDirectory(dir: string): Promise<void> {
    try {
-      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const entries = await readdir(dir, { withFileTypes: true })
+      for (const entry of entries) {
        if (entry.isDirectory()) {
          const sessionPath = join(dir, entry.name)
-          const files = readdirSync(sessionPath)
+          const files = await readdir(sessionPath)
          if (files.some((f) => f.endsWith(".json"))) {
            sessions.push(entry.name)
          } else {
-            scanDirectory(sessionPath)
+            await scanDirectory(sessionPath)
          }
        }
      }
@@ -26,7 +28,7 @@ export function getAllSessions(): string[] {
    }
  }

-  scanDirectory(MESSAGE_STORAGE)
+  await scanDirectory(MESSAGE_STORAGE)
  return [...new Set(sessions)]
 }

@@ -38,11 +40,15 @@ export function getMessageDir(sessionID: string): string {
    return directPath
  }

-  for (const dir of readdirSync(MESSAGE_STORAGE)) {
-    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
-    if (existsSync(sessionPath)) {
-      return sessionPath
+  try {
+    for (const dir of readdirSync(MESSAGE_STORAGE)) {
+      const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+      if (existsSync(sessionPath)) {
+        return sessionPath
+      }
    }
+  } catch {
+    return ""
  }

  return ""
@@ -52,29 +58,34 @@ export function sessionExists(sessionID: string): boolean {
  return getMessageDir(sessionID) !== ""
 }

-export function readSessionMessages(sessionID: string): SessionMessage[] {
+export async function readSessionMessages(sessionID: string): Promise<SessionMessage[]> {
  const messageDir = getMessageDir(sessionID)
  if (!messageDir || !existsSync(messageDir)) return []

  const messages: SessionMessage[] = []
-  for (const file of readdirSync(messageDir)) {
-    if (!file.endsWith(".json")) continue
-    try {
-      const content = readFileSync(join(messageDir, file), "utf-8")
-      const meta = JSON.parse(content)
+  try {
+    const files = await readdir(messageDir)
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue
+      try {
+        const content = await readFile(join(messageDir, file), "utf-8")
+        const meta = JSON.parse(content)

-      const parts = readParts(meta.id)
+        const parts = await readParts(meta.id)

-      messages.push({
-        id: meta.id,
-        role: meta.role,
-        agent: meta.agent,
-        time: meta.time,
-        parts,
-      })
-    } catch {
-      continue
+        messages.push({
+          id: meta.id,
+          role: meta.role,
+          agent: meta.agent,
+          time: meta.time,
+          parts,
+        })
+      } catch {
+        continue
+      }
    }
+  } catch {
+    return []
  }

  return messages.sort((a, b) => {
@@ -85,65 +96,75 @@ export function readSessionMessages(sessionID: string): SessionMessage[] {
  })
 }

-function readParts(messageID: string): Array<{ id: string; type: string; [key: string]: unknown }> {
+async function readParts(messageID: string): Promise<Array<{ id: string; type: string; [key: string]: unknown }>> {
  const partDir = join(PART_STORAGE, messageID)
  if (!existsSync(partDir)) return []

  const parts: Array<{ id: string; type: string; [key: string]: unknown }> = []
-  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
+  try {
+    const files = await readdir(partDir)
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue
+      try {
+        const content = await readFile(join(partDir, file), "utf-8")
+        parts.push(JSON.parse(content))
+      } catch {
+        continue
+      }
    }
+  } catch {
+    return []
  }

  return parts.sort((a, b) => a.id.localeCompare(b.id))
 }

-export function readSessionTodos(sessionID: string): TodoItem[] {
+export async function readSessionTodos(sessionID: string): Promise<TodoItem[]> {
  if (!existsSync(TODO_DIR)) return []

-  const todoFiles = readdirSync(TODO_DIR).filter((f) => f.includes(sessionID) && f.endsWith(".json"))
+  try {
+    const allFiles = await readdir(TODO_DIR)
+    const todoFiles = allFiles.filter((f) => f.includes(sessionID) && f.endsWith(".json"))

-  for (const file of todoFiles) {
-    try {
-      const content = readFileSync(join(TODO_DIR, file), "utf-8")
-      const data = JSON.parse(content)
-      if (Array.isArray(data)) {
-        return data.map((item) => ({
-          id: item.id || "",
-          content: item.content || "",
-          status: item.status || "pending",
-          priority: item.priority,
-        }))
+    for (const file of todoFiles) {
+      try {
+        const content = await readFile(join(TODO_DIR, file), "utf-8")
+        const data = JSON.parse(content)
+        if (Array.isArray(data)) {
+          return data.map((item) => ({
+            id: item.id || "",
+            content: item.content || "",
+            status: item.status || "pending",
+            priority: item.priority,
+          }))
+        }
+      } catch {
+        continue
      }
-    } catch {
-      continue
    }
+  } catch {
+    return []
  }

  return []
 }

-export function readSessionTranscript(sessionID: string): number {
+export async function readSessionTranscript(sessionID: string): Promise<number> {
  if (!existsSync(TRANSCRIPT_DIR)) return 0

  const transcriptFile = join(TRANSCRIPT_DIR, `${sessionID}.jsonl`)
  if (!existsSync(transcriptFile)) return 0

  try {
-    const content = readFileSync(transcriptFile, "utf-8")
+    const content = await readFile(transcriptFile, "utf-8")
    return content.trim().split("\n").filter(Boolean).length
  } catch {
    return 0
  }
 }

-export function getSessionInfo(sessionID: string): SessionInfo | null {
-  const messages = readSessionMessages(sessionID)
+export async function getSessionInfo(sessionID: string): Promise<SessionInfo | null> {
+  const messages = await readSessionMessages(sessionID)
  if (messages.length === 0) return null

  const agentsUsed = new Set<string>()
@@ -159,8 +180,8 @@ export function getSessionInfo(sessionID: string): SessionInfo | null {
    }
  }

-  const todos = readSessionTodos(sessionID)
-  const transcriptEntries = readSessionTranscript(sessionID)
+  const todos = await readSessionTodos(sessionID)
+  const transcriptEntries = await readSessionTranscript(sessionID)

  return {
    id: sessionID,
--- a/src/tools/session-manager/tools.ts
+++ b/src/tools/session-manager/tools.ts
@@ -6,8 +6,25 @@ import {
  SESSION_INFO_DESCRIPTION,
 } from "./constants"
 import { getAllSessions, getSessionInfo, readSessionMessages, readSessionTodos, sessionExists } from "./storage"
-import { filterSessionsByDate, formatSessionInfo, formatSessionList, formatSessionMessages, formatSearchResults, searchInSession } from "./utils"
-import type { SessionListArgs, SessionReadArgs, SessionSearchArgs, SessionInfoArgs } from "./types"
+import {
+  filterSessionsByDate,
+  formatSessionInfo,
+  formatSessionList,
+  formatSessionMessages,
+  formatSearchResults,
+  searchInSession,
+} from "./utils"
+import type { SessionListArgs, SessionReadArgs, SessionSearchArgs, SessionInfoArgs, SearchResult } from "./types"
+
+const SEARCH_TIMEOUT_MS = 60_000
+const MAX_SESSIONS_TO_SCAN = 50
+
+function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<T>((_, reject) => setTimeout(() => reject(new Error(`${operation} timed out after ${ms}ms`)), ms)),
+  ])
+}

 export const session_list: ToolDefinition = tool({
  description: SESSION_LIST_DESCRIPTION,
@@ -18,17 +35,17 @@ export const session_list: ToolDefinition = tool({
  },
  execute: async (args: SessionListArgs, _context) => {
    try {
-      let sessions = getAllSessions()
+      let sessions = await getAllSessions()

      if (args.from_date || args.to_date) {
-        sessions = filterSessionsByDate(sessions, args.from_date, args.to_date)
+        sessions = await filterSessionsByDate(sessions, args.from_date, args.to_date)
      }

      if (args.limit && args.limit > 0) {
        sessions = sessions.slice(0, args.limit)
      }

-      return formatSessionList(sessions)
+      return await formatSessionList(sessions)
    } catch (e) {
      return `Error: ${e instanceof Error ? e.message : String(e)}`
    }
@@ -49,13 +66,13 @@ export const session_read: ToolDefinition = tool({
        return `Session not found: ${args.session_id}`
      }

-      let messages = readSessionMessages(args.session_id)
+      let messages = await readSessionMessages(args.session_id)

      if (args.limit && args.limit > 0) {
        messages = messages.slice(0, args.limit)
      }

-      const todos = args.include_todos ? readSessionTodos(args.session_id) : undefined
+      const todos = args.include_todos ? await readSessionTodos(args.session_id) : undefined

      return formatSessionMessages(messages, args.include_todos, todos)
    } catch (e) {
@@ -74,13 +91,31 @@ export const session_search: ToolDefinition = tool({
  },
  execute: async (args: SessionSearchArgs, _context) => {
    try {
-      const sessions = args.session_id ? [args.session_id] : getAllSessions()
+      const resultLimit = args.limit && args.limit > 0 ? args.limit : 20

-      const allResults = sessions.flatMap((sid) => searchInSession(sid, args.query, args.case_sensitive))
+      const searchOperation = async (): Promise<SearchResult[]> => {
+        if (args.session_id) {
+          return searchInSession(args.session_id, args.query, args.case_sensitive, resultLimit)
+        }

-      const limited = args.limit && args.limit > 0 ? allResults.slice(0, args.limit) : allResults.slice(0, 20)
+        const allSessions = await getAllSessions()
+        const sessionsToScan = allSessions.slice(0, MAX_SESSIONS_TO_SCAN)

-      return formatSearchResults(limited)
+        const allResults: SearchResult[] = []
+        for (const sid of sessionsToScan) {
+          if (allResults.length >= resultLimit) break
+
+          const remaining = resultLimit - allResults.length
+          const sessionResults = await searchInSession(sid, args.query, args.case_sensitive, remaining)
+          allResults.push(...sessionResults)
+        }
+
+        return allResults.slice(0, resultLimit)
+      }
+
+      const results = await withTimeout(searchOperation(), SEARCH_TIMEOUT_MS, "Search")
+
+      return formatSearchResults(results)
    } catch (e) {
      return `Error: ${e instanceof Error ? e.message : String(e)}`
    }
@@ -94,7 +129,7 @@ export const session_info: ToolDefinition = tool({
  },
  execute: async (args: SessionInfoArgs, _context) => {
    try {
-      const info = getSessionInfo(args.session_id)
+      const info = await getSessionInfo(args.session_id)

      if (!info) {
        return `Session not found: ${args.session_id}`
--- a/src/tools/session-manager/utils.test.ts
+++ b/src/tools/session-manager/utils.test.ts
@@ -1,21 +1,39 @@
 import { describe, test, expect } from "bun:test"
-import { formatSessionList, formatSessionMessages, formatSessionInfo, formatSearchResults, filterSessionsByDate, searchInSession } from "./utils"
+import {
+  formatSessionList,
+  formatSessionMessages,
+  formatSessionInfo,
+  formatSearchResults,
+  filterSessionsByDate,
+  searchInSession,
+} from "./utils"
 import type { SessionInfo, SessionMessage, SearchResult } from "./types"

 describe("session-manager utils", () => {
-  test("formatSessionList handles empty array", () => {
-    const result = formatSessionList([])
-    
+  test("formatSessionList handles empty array", async () => {
+    // #given
+    const sessions: string[] = []
+
+    // #when
+    const result = await formatSessionList(sessions)
+
+    // #then
    expect(result).toContain("No sessions found")
  })

  test("formatSessionMessages handles empty array", () => {
-    const result = formatSessionMessages([])
-    
+    // #given
+    const messages: SessionMessage[] = []
+
+    // #when
+    const result = formatSessionMessages(messages)
+
+    // #then
    expect(result).toContain("No messages")
  })

  test("formatSessionMessages includes message content", () => {
+    // #given
    const messages: SessionMessage[] = [
      {
        id: "msg_001",
@@ -24,14 +42,17 @@ describe("session-manager utils", () => {
        parts: [{ id: "prt_001", type: "text", text: "Hello world" }],
      },
    ]
-    
+
+    // #when
    const result = formatSessionMessages(messages)
-    
+
+    // #then
    expect(result).toContain("user")
    expect(result).toContain("Hello world")
  })

  test("formatSessionMessages includes todos when requested", () => {
+    // #given
    const messages: SessionMessage[] = [
      {
        id: "msg_001",
@@ -40,20 +61,22 @@ describe("session-manager utils", () => {
        parts: [{ id: "prt_001", type: "text", text: "Test" }],
      },
    ]
-    
    const todos = [
      { id: "1", content: "Task 1", status: "completed" as const },
      { id: "2", content: "Task 2", status: "pending" as const },
    ]
-    
+
+    // #when
    const result = formatSessionMessages(messages, true, todos)
-    
+
+    // #then
    expect(result).toContain("Todos")
    expect(result).toContain("Task 1")
    expect(result).toContain("Task 2")
  })

  test("formatSessionInfo includes all metadata", () => {
+    // #given
    const info: SessionInfo = {
      id: "ses_test123",
      message_count: 42,
@@ -65,9 +88,11 @@ describe("session-manager utils", () => {
      todos: [{ id: "1", content: "Test", status: "pending" }],
      transcript_entries: 123,
    }
-    
+
+    // #when
    const result = formatSessionInfo(info)
-    
+
+    // #then
    expect(result).toContain("ses_test123")
    expect(result).toContain("42")
    expect(result).toContain("build, oracle")
@@ -75,12 +100,18 @@ describe("session-manager utils", () => {
  })

  test("formatSearchResults handles empty array", () => {
-    const result = formatSearchResults([])
-    
+    // #given
+    const results: SearchResult[] = []
+
+    // #when
+    const result = formatSearchResults(results)
+
+    // #then
    expect(result).toContain("No matches")
  })

  test("formatSearchResults formats matches correctly", () => {
+    // #given
    const results: SearchResult[] = [
      {
        session_id: "ses_test123",
@@ -91,9 +122,11 @@ describe("session-manager utils", () => {
        timestamp: Date.now(),
      },
    ]
-    
+
+    // #when
    const result = formatSearchResults(results)
-    
+
+    // #then
    expect(result).toContain("Found 1 matches")
    expect(result).toContain("ses_test123")
    expect(result).toContain("msg_001")
@@ -101,17 +134,26 @@ describe("session-manager utils", () => {
    expect(result).toContain("Matches: 3")
  })

-  test("filterSessionsByDate filters correctly", () => {
+  test("filterSessionsByDate filters correctly", async () => {
+    // #given
    const sessionIDs = ["ses_001", "ses_002", "ses_003"]
-    
-    const result = filterSessionsByDate(sessionIDs)
-    
+
+    // #when
+    const result = await filterSessionsByDate(sessionIDs)
+
+    // #then
    expect(Array.isArray(result)).toBe(true)
  })

-  test("searchInSession finds matches case-insensitively", () => {
-    const results = searchInSession("ses_nonexistent", "test", false)
-    
+  test("searchInSession finds matches case-insensitively", async () => {
+    // #given
+    const sessionID = "ses_nonexistent"
+    const query = "test"
+
+    // #when
+    const results = await searchInSession(sessionID, query, false)
+
+    // #then
    expect(Array.isArray(results)).toBe(true)
    expect(results.length).toBe(0)
  })
--- a/src/tools/session-manager/utils.ts
+++ b/src/tools/session-manager/utils.ts
@@ -1,12 +1,14 @@
 import type { SessionInfo, SessionMessage, SearchResult } from "./types"
 import { getSessionInfo, readSessionMessages } from "./storage"

-export function formatSessionList(sessionIDs: string[]): string {
+export async function formatSessionList(sessionIDs: string[]): Promise<string> {
  if (sessionIDs.length === 0) {
    return "No sessions found."
  }

-  const infos = sessionIDs.map((id) => getSessionInfo(id)).filter((info): info is SessionInfo => info !== null)
+  const infos = (await Promise.all(sessionIDs.map((id) => getSessionInfo(id)))).filter(
+    (info): info is SessionInfo => info !== null
+  )

  if (infos.length === 0) {
    return "No valid sessions found."
@@ -39,7 +41,11 @@ export function formatSessionList(sessionIDs: string[]): string {
  return [formatRow(headers), separator, ...rows.map(formatRow)].join("\n")
 }

-export function formatSessionMessages(messages: SessionMessage[], includeTodos?: boolean, todos?: Array<{id: string; content: string; status: string}>): string {
+export function formatSessionMessages(
+  messages: SessionMessage[],
+  includeTodos?: boolean,
+  todos?: Array<{ id: string; content: string; status: string }>
+): string {
  if (messages.length === 0) {
    return "No messages found in this session."
  }
@@ -116,32 +122,46 @@ export function formatSearchResults(results: SearchResult[]): string {
  return lines.join("\n")
 }

-export function filterSessionsByDate(sessionIDs: string[], fromDate?: string, toDate?: string): string[] {
+export async function filterSessionsByDate(
+  sessionIDs: string[],
+  fromDate?: string,
+  toDate?: string
+): Promise<string[]> {
  if (!fromDate && !toDate) return sessionIDs

  const from = fromDate ? new Date(fromDate) : null
  const to = toDate ? new Date(toDate) : null

-  return sessionIDs.filter((id) => {
-    const info = getSessionInfo(id)
-    if (!info || !info.last_message) return false
+  const results: string[] = []
+  for (const id of sessionIDs) {
+    const info = await getSessionInfo(id)
+    if (!info || !info.last_message) continue

-    if (from && info.last_message < from) return false
-    if (to && info.last_message > to) return false
+    if (from && info.last_message < from) continue
+    if (to && info.last_message > to) continue

-    return true
-  })
+    results.push(id)
+  }
+
+  return results
 }

-export function searchInSession(sessionID: string, query: string, caseSensitive = false): SearchResult[] {
-  const messages = readSessionMessages(sessionID)
+export async function searchInSession(
+  sessionID: string,
+  query: string,
+  caseSensitive = false,
+  maxResults?: number
+): Promise<SearchResult[]> {
+  const messages = await readSessionMessages(sessionID)
  const results: SearchResult[] = []

  const searchQuery = caseSensitive ? query : query.toLowerCase()

  for (const msg of messages) {
+    if (maxResults && results.length >= maxResults) break
+
    let matchCount = 0
-    let excerpts: string[] = []
+    const excerpts: string[] = []

    for (const part of msg.parts) {
      if (part.type === "text" && part.text) {
Author	SHA1	Message	Date
github-actions[bot]	765507648c	release: v2.7.1	2025-12-28 18:14:11 +00:00
YeonGyu-Kim	c10bc5fcdf	fix(todo-continuation-enforcer): simplify implementation and remove 10s throttle blocking background task completion Removes the complex state machine and 10-second throttle (MIN_INJECTION_INTERVAL_MS) that was causing background task completion to hang. The hook now: - Uses straightforward error cooldown logic instead of complex injection throttling - Removes unnecessary state tracking that was delaying continuation injection - Maintains all safety checks (recovery mode, running tasks, error state) - Keeps countdown behavior with toast notifications Fixes #312 - Resolves v2.7.0 issue where background task completion would freeze the agent due to injection delays. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-29 03:10:43 +09:00
YeonGyu-Kim	c0b28b0715	improve sanitize	2025-12-29 02:29:46 +09:00
YeonGyu-Kim	dd60002a0d	fix(sisyphus-agent): handle OpenCode installer failure with pinned version fallback Replace retry loop with intelligent fallback strategy: - Try default installer first (better for version discovery) - On failure, fallback to pinned version 1.0.204 - Handle corrupted downloads with direct fallback install This addresses the sisyphus-agent workflow failure where OpenCode's installer failed with 'Failed to fetch version information' error. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-29 01:09:28 +09:00
YeonGyu-Kim	25d2946b76	Update AGENTS.md with current project state (commit `122e918`, 2025-12-28) 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 19:42:56 +09:00
YeonGyu-Kim	122e918503	Add LSP tool integration to init-deep template for code intelligence analysis Enhanced init-deep.ts template with LSP-First core principle and Code Intelligence Analysis phase: - Added LSP-First principle for semantic code understanding - Integrated lsp_servers, lsp_document_symbols, lsp_workspace_symbols, lsp_find_references in Phase 1 - Added LSP-based scoring factors (symbol density, export count, reference centrality) in Phase 2 - Included CODE_INTELLIGENCE output format specification - Added LSP fallback guidance for unavailable servers - Updated scoring matrix with LSP sources and enhanced metrics 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 19:23:29 +09:00
YeonGyu-Kim	aeff184e0c	docs: add missing hooks, session tools, and sync sections across all READMEs - Added 4 missing hooks to disabled_hooks config: preemptive-compaction, compaction-context-injector, thinking-block-validator, claude-code-hooks - Added session management tools section documenting: session_list, session_read, session_search, session_info, call_omo_agent - Added Uninstallation section to KO/JA/ZH-CN READMEs (synced with EN) - Added JSONC Support section to KO/JA/ZH-CN READMEs (synced with EN) 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 18:25:32 +09:00
github-actions[bot]	b995ea8595	@SyedTahirHussan has signed the CLA in code-yeongyu/oh-my-opencode#306	2025-12-28 09:24:13 +00:00
github-actions[bot]	6e5edafeee	release: v2.7.0	2025-12-28 08:59:46 +00:00
YeonGyu-Kim	bfb5d43bc2	Add AGENTS.md knowledge base documentation files - Add src/agents/AGENTS.md with agent module documentation - Update root AGENTS.md with latest generation timestamp (2025-12-28T17:15:00+09:00, commit f5b74d5) - Update src/features/AGENTS.md with builtin-commands and claude-code-plugin-loader documentation - Update src/hooks/AGENTS.md with thinking-block-validator hook documentation 🤖 Generated with assistance of [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 17:48:33 +09:00
YeonGyu-Kim	385e8a97b0	Add builtin-commands feature with init-deep command and disabled_commands config option - New src/features/builtin-commands/ module with CommandDefinition loader - Implements init-deep command for hierarchical AGENTS.md knowledge base generation - Adds BuiltinCommandName and BuiltinCommandNameSchema to config - Integrates builtin commands loader into main plugin with proper config merging - Supports disabling specific builtin commands via disabled_commands config array 🤖 Generated with assistance of https://github.com/code-yeongyu/oh-my-opencode	2025-12-28 17:48:33 +09:00
YeonGyu-Kim	7daabf9617	Add ctx.metadata() calls for session navigation UI in background/subagent tasks Add metadata() calls to background_task and call_omo_agent tools so that OpenCode UI displays session navigation hints (ctrl+x + arrow keys) like the original Task tool does. This enhances UX by providing consistent session navigation UI for background and subagent tasks. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 17:48:33 +09:00
YeonGyu-Kim	5fbcb88a3f	fix(todo-continuation-enforcer): persist errorBypass mode until user sends message Previously, errorBypass mode was cleared on session.idle, causing continuation to fire again on next idle event. This led to unwanted task resumption after user abort. Changes: - Don't clear errorBypass on session.idle - stay in errorBypass mode - Clear errorBypass to idle only when user sends a new message This ensures that once user aborts, the enforcer respects that decision until the user explicitly sends a message to resume. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 17:48:33 +09:00
YeonGyu-Kim	daa5f6ee5b	fix(todo-continuation-enforcer): redesign with version-token state machine Fixes race conditions, enables continuous enforcement, and eliminates false positives/negatives. - Complete redesign using version-token state machine for race condition prevention - Replaced 5 separate Sets with single Map<sessionID, SessionState> - Changed cancelCountdown() to invalidate() that ALWAYS bumps version regardless of mode - Added background task check BEFORE starting countdown (prevents toast spam when bg tasks running) - Added lastAttemptedAt throttling (10s minimum between attempts, set BEFORE API call) - Removed non-interactive preemptive injection (all paths now use countdown) - Added 3 version checks in executeInjection (start, after todo fetch, before API call) - Removed remindedSessions flag for continuous enforcement Fixes: 1. Race condition where session.idle fired before message.updated cleared reminded state 2. Single-shot behavior that prevented multiple reminders 3. Phantom reminders sent even after agent started working 4. Toast spam when background tasks are running 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 17:48:33 +09:00
Sisyphus	4d66ea9730	fix(lsp): improve error messages when LSP server is not installed (#305 ) Previously, when an LSP server was configured but not installed, the error message said "No LSP server configured" which was misleading. Now the error message distinguishes between: 1. Server not configured at all 2. Server configured but not installed (with installation hints) The new error messages include: - Clear indication of whether server is configured vs installed - Installation commands for each built-in server - Supported file extensions - Configuration examples for custom servers Fixes #304 Co-authored-by: sisyphus-dev-ai <sisyphus-dev-ai@users.noreply.github.com>	2025-12-28 17:38:23 +09:00
sisyphus-dev-ai	4d4273603a	chore: changes by sisyphus-dev-ai	2025-12-28 07:57:05 +00:00
YeonGyu-Kim	7b7c14301e	fix(dcp): correct storage path to match OpenCode's actual location DCP was failing to find session messages because it was looking in ~/.config/opencode/sessions instead of ~/.local/share/opencode/storage. Unified all hooks to use getOpenCodeStorageDir() for cross-platform consistency. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 16:13:50 +09:00
Sisyphus	e3be656f86	fix: disable todo-continuation for plan mode agents (#303 ) * fix: disable todo-continuation for plan mode agents Plan mode agents (e.g., 'plan', 'Planner-Sisyphus') only analyze and plan, they don't implement. The todo-continuation hook was incorrectly triggering for these agents because the existing write permission check only looked at the stored message's tools field, not the agent's permission configuration. This fix adds an explicit check for plan mode agents by name to skip the todo continuation prompt injection. Fixes #293 * chore: changes by sisyphus-dev-ai * fix: address review comments for plan mode agent check - Use exact match for plan mode agents instead of substring match to prevent false positives on agents like 'deployment-planner' - Add plan mode agent check to preemptive injection path (non-interactive mode) which was missing from the initial fix --------- Co-authored-by: sisyphus-dev-ai <sisyphus-dev-ai@users.noreply.github.com>	2025-12-28 16:02:04 +09:00
Sisyphus	c11cb2e3f1	fix: defer module-level side effects to prevent Bun 1.3.5 + macOS 15 segfault (#301 ) - Remove eager SG_CLI_PATH constant; use getSgCliPath() lazily in checkEnvironment() - Move setInterval to inside createCommentCheckerHooks() with guard flag These changes eliminate module-level side effects that could trigger segfaults during plugin initialization on Bun 1.3.5 + macOS 15 due to createRequire() being called during module evaluation. Fixes #292 Co-authored-by: sisyphus-dev-ai <sisyphus-dev-ai@users.noreply.github.com>	2025-12-28 15:55:47 +09:00
YeonGyu-Kim	195e8dcb17	refactor(todo-continuation-enforcer): improve state machine and injection logic Refactored state management to use a single source of truth per-session using a state machine pattern with versioning. Key improvements: - Replace multiple Sets with unified SessionState map for cleaner logic - Add version tokens to invalidate pending callbacks on state changes - Improve countdown timer management with proper cleanup - Add throttle check to prevent rapid injection spam (10s minimum interval) - Enhance injection checks: re-verify todos before injection, check bg tasks - Handle message.part.updated events for streaming activity detection - Add isMainSession() helper for consistent session filtering - Clearer event handler logic with inline comments explaining state transitions - Better logging for debugging state changes and decision points State modes: idle → countingDown → injecting → idle (with recovery/errorBypass) Prevents race conditions from async operations and UI state changes during countdown. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 15:49:13 +09:00
YeonGyu-Kim	284e7f5bc3	fix(anthropic-auto-compact): use correct MESSAGE_STORAGE path for session messages The DCP pruning modules were using a hardcoded path (~/.config/opencode/sessions) that doesn't exist. Sessions are actually stored at ~/.local/share/opencode/storage/message. All pruning modules now import MESSAGE_STORAGE from hook-message-injector, which uses the correct path via getOpenCodeStorageDir(). This fixes the issue where DCP would fail with 'message dir not found' when trying to recover from token limit errors. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 15:49:04 +09:00
YeonGyu-Kim	465c9e511f	feat(comment-checker): pass custom_prompt to CLI - Add customPrompt parameter to runCommentChecker function - Pass --prompt flag to comment-checker CLI when custom_prompt is configured - Wire up config from plugin initialization 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 15:02:00 +09:00
YeonGyu-Kim	18d134fa57	fix(background-agent): prevent memory leak - completed tasks now removed from Map (#302 ) - Add finally block in notifyParentSession() to ensure task cleanup - Call tasks.delete(taskId) after notification sent or on error - Prevents memory accumulation when tasks complete or fail - taskId captured before setTimeout to ensure proper cleanup in async context 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 14:59:06 +09:00
YeonGyu-Kim	092718f82d	fix(thinking-block-validator): handle text content parts in message validation Previously, the validator only checked for tool_use parts, causing 'Expected thinking but found text' errors when messages had text content. Renamed hasToolParts to hasContentParts to include both tool_use and text types. Also added CommentCheckerConfigSchema support for custom prompt configuration. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 14:55:27 +09:00
YeonGyu-Kim	19f504fcfa	fix(session-recovery): improve empty message index search with expanded range Expand the search range when finding empty messages by index to better handle API index vs storage index mismatches. This increases robustness when searching for messages to sanitize with more fallback indices. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 14:40:06 +09:00
YeonGyu-Kim	49f3be5a1f	fix(session-manager): convert blocking sync I/O to async for improved concurrency Convert session-manager storage layer from synchronous blocking I/O (readdirSync, readFileSync) to non-blocking async I/O (readdir, readFile from fs/promises). This fixes hanging issues in session_search and other tools caused by blocking filesystem operations. Changes: - storage.ts: getAllSessions, readSessionMessages, getSessionInfo now async - utils.ts: Updated utility functions to be async-compatible - tools.ts: Added await calls for async storage functions - storage.test.ts, utils.test.ts: Updated tests with async/await patterns This resolves the session_search tool hang issue and improves overall responsiveness. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 14:40:06 +09:00
YeonGyu-Kim	6d6102f1ff	fix(anthropic-auto-compact): sanitize empty messages before summarization Pre-emptively fix empty messages in sessions before running document compression to prevent summarization failures. This prevents accumulation of empty message placeholders that can interfere with context management. 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 14:40:06 +09:00
YeonGyu-Kim	1d7e534b92	Upgrade @code-yeongyu/comment-checker from ^0.6.0 to ^0.6.1 🤖 GENERATED WITH ASSISTANCE OF OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 14:40:06 +09:00
YeonGyu-Kim	17b7dd396e	feat(cli): librarian/explore model fallback based on installer settings (#299 ) * feat(cli): librarian uses gemini-3-flash when hasGemini (antigravity auth) Closes #294 * feat(cli): add explore to gemini-3-flash when hasGemini + update docs * feat(cli): fix explore agent fallback logic to use haiku for max20 Claude users - Use gemini-3-flash for both librarian and explore when hasGemini - Use haiku for explore when Claude max20 is available (hasClaude && isMax20) - Fall back to big-pickle for both when other models unavailable - Updated all README files to document the fallback precedence 🤖 Generated with assistance of [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 14:27:35 +09:00
YeonGyu-Kim	889d80d0ca	feat(anthropic-auto-compact): run DCP first on token limit errors before compaction - Refactored DCP (Dynamic Context Pruning) to execute FIRST when token limit errors occur - Previously, DCP only ran as a fallback after compaction failed - Now DCP runs first to prune redundant context, then compaction executes immediately - Simplified config flag: dcp_on_compaction_failure → dcp_for_compaction - Updated documentation in all 4 README files (EN, KO, JA, ZH-CN) - Updated schema.ts with new config field name and documentation - Updated executor.ts with new DCP-first logic flow 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 14:13:50 +09:00
YeonGyu-Kim	87e229fb62	feat(auth): enhance Antigravity token refresh with robust error handling and retry logic - Add AntigravityTokenRefreshError custom error class with code, description, and status fields - Implement parseOAuthErrorPayload() for parsing Google's various OAuth error response formats - Add retry logic with exponential backoff (3 retries, 1s→2s→4s delay) for transient failures - Add special handling for invalid_grant error - immediately throws without retry and clears caches - Add invalidateProjectContextByRefreshToken() for selective cache invalidation - Update fetch.ts error handling to work with new error class and cache invalidation 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 13:22:42 +09:00