release: v2.7.0

- 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)

.github/workflows/ci.yml

@@ -120,15 +120,19 @@ jobs:
             echo "Updating existing draft release..."
             gh release edit next \
               --title "Upcoming Changes 🍿" \
-              --notes "${{ steps.notes.outputs.notes }}" \
-              --draft
+              --notes-file - \
+              --draft <<'EOF'
+          ${{ steps.notes.outputs.notes }}
+          EOF
           else
             echo "Creating new draft release..."
             gh release create next \
               --title "Upcoming Changes 🍿" \
-              --notes "${{ steps.notes.outputs.notes }}" \
+              --notes-file - \
               --draft \
-              --target ${{ github.sha }}
+              --target ${{ github.sha }} <<'EOF'
+          ${{ steps.notes.outputs.notes }}
+          EOF
           fi
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/sisyphus-agent.yml

@@ -6,12 +6,10 @@ on:
       prompt:
         description: "Custom prompt"
         required: false
+  # Only issue_comment works for fork PRs (secrets available)
+  # pull_request_review/pull_request_review_comment do NOT get secrets for fork PRs
   issue_comment:
     types: [created]
-  pull_request_review:
-    types: [submitted]
-  pull_request_review_comment:
-    types: [created]
 
 jobs:
   agent:
@@ -19,9 +17,9 @@ jobs:
     # @sisyphus-dev-ai mention only (maintainers, exclude self)
     if: |
       github.event_name == 'workflow_dispatch' ||
-      (contains(github.event.comment.body || github.event.review.body, '@sisyphus-dev-ai') &&
-       (github.event.comment.user.login || github.event.review.user.login) != 'sisyphus-dev-ai' &&
-       contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.comment.author_association || github.event.review.author_association))
+      (contains(github.event.comment.body, '@sisyphus-dev-ai') &&
+       github.event.comment.user.login != 'sisyphus-dev-ai' &&
+       contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.comment.author_association))
 
     # Minimal default GITHUB_TOKEN permissions
     permissions:
@@ -71,7 +69,13 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-bun-
 
-      # Install OpenCode + oh-my-opencode + auth in single step
+      # Build local oh-my-opencode
+      - name: Build oh-my-opencode
+        run: |
+          bun install
+          bun run build
+
+      # Install OpenCode + configure local plugin + auth in single step
       - name: Setup OpenCode with oh-my-opencode
         env:
           OPENCODE_AUTH_JSON: ${{ secrets.OPENCODE_AUTH_JSON }}
@@ -89,12 +93,19 @@ jobs:
                 bash /tmp/opencode-install.sh && break
               fi
               echo "Download corrupted, retrying in 5s..."
-              sleep 5
             done
           fi
           opencode --version
 
-          bunx oh-my-opencode install --no-tui --claude=max20 --chatgpt=no --gemini=no
+          # Run local oh-my-opencode install (uses built dist)
+          bun run dist/cli/index.js install --no-tui --claude=max20 --chatgpt=no --gemini=no
+
+          # Override plugin to use local file reference
+          OPENCODE_JSON=~/.config/opencode/opencode.json
+          REPO_PATH=$(pwd)
+          jq --arg path "file://$REPO_PATH/src/index.ts" '
+            .plugin = [.plugin[] | select(. != "oh-my-opencode")] + [$path]
+          ' "$OPENCODE_JSON" > /tmp/oc.json && mv /tmp/oc.json "$OPENCODE_JSON"
 
           OPENCODE_JSON=~/.config/opencode/opencode.json
           jq --arg baseURL "$ANTHROPIC_BASE_URL" --arg apiKey "$ANTHROPIC_API_KEY" '
@@ -173,6 +184,25 @@ jobs:
           )"
           ```
 
+          ### GitHub Markdown Rules (MUST FOLLOW)
+
+          **Code blocks MUST have EXACTLY 3 backticks and language identifier:**
+          - CORRECT: ` ```bash ` ... ` ``` `
+          - WRONG: ` ``` ` (no language), ` ```` ` (4 backticks), ` `` ` (2 backticks)
+          
+          **Every opening ` ``` ` MUST have a closing ` ``` ` on its own line:**
+          ```
+          ```bash
+          code here
+          ```
+          ```
+          
+          **NO trailing backticks or spaces after closing ` ``` `**
+          
+          **For inline code, use SINGLE backticks:** `code` not ```code```
+          
+          **Lists inside code blocks break rendering - avoid them or use plain text**
+
           ### Rules
           - EVERY response = GitHub comment (use heredoc for proper escaping)
           - Code changes = PR (never push main/master)
@@ -197,39 +227,30 @@ jobs:
         id: context
         env:
           GITHUB_TOKEN: ${{ secrets.GH_PAT }}
+          EVENT_NAME: ${{ github.event_name }}
+          ISSUE_NUMBER: ${{ github.event.issue.number }}
+          COMMENT_BODY: ${{ github.event.comment.body }}
+          COMMENT_AUTHOR: ${{ github.event.comment.user.login }}
+          COMMENT_ID_VAL: ${{ github.event.comment.id }}
+          REPO: ${{ github.repository }}
         run: |
-          EVENT="${{ github.event_name }}"
-
-          if [[ "$EVENT" == "issue_comment" ]]; then
-            ISSUE_NUM="${{ github.event.issue.number }}"
-            COMMENT="${{ github.event.comment.body }}"
-            AUTHOR="${{ github.event.comment.user.login }}"
-            COMMENT_ID="${{ github.event.comment.id }}"
+          if [[ "$EVENT_NAME" == "issue_comment" ]]; then
+            ISSUE_NUM="$ISSUE_NUMBER"
+            AUTHOR="$COMMENT_AUTHOR"
+            COMMENT_ID="$COMMENT_ID_VAL"
 
             # Check if PR or Issue
-            if gh api "repos/${{ github.repository }}/issues/${ISSUE_NUM}" | jq -e '.pull_request' > /dev/null; then
+            if gh api "repos/$REPO/issues/${ISSUE_NUM}" | jq -e '.pull_request' > /dev/null; then
               echo "type=pr" >> $GITHUB_OUTPUT
               echo "number=${ISSUE_NUM}" >> $GITHUB_OUTPUT
             else
               echo "type=issue" >> $GITHUB_OUTPUT
               echo "number=${ISSUE_NUM}" >> $GITHUB_OUTPUT
             fi
-          elif [[ "$EVENT" == "pull_request_review_comment" ]]; then
-            echo "type=pr" >> $GITHUB_OUTPUT
-            echo "number=${{ github.event.pull_request.number }}" >> $GITHUB_OUTPUT
-            COMMENT="${{ github.event.comment.body }}"
-            AUTHOR="${{ github.event.comment.user.login }}"
-            COMMENT_ID="${{ github.event.comment.id }}"
-          elif [[ "$EVENT" == "pull_request_review" ]]; then
-            echo "type=pr" >> $GITHUB_OUTPUT
-            echo "number=${{ github.event.pull_request.number }}" >> $GITHUB_OUTPUT
-            COMMENT="${{ github.event.review.body }}"
-            AUTHOR="${{ github.event.review.user.login }}"
-            COMMENT_ID=""
           fi
 
           echo "comment<<EOF" >> $GITHUB_OUTPUT
-          echo "$COMMENT" >> $GITHUB_OUTPUT
+          echo "$COMMENT_BODY" >> $GITHUB_OUTPUT
           echo "EOF" >> $GITHUB_OUTPUT
           echo "author=$AUTHOR" >> $GITHUB_OUTPUT
           echo "comment_id=$COMMENT_ID" >> $GITHUB_OUTPUT
@@ -264,32 +285,47 @@ jobs:
               --add-label "sisyphus: working" || true
           fi
 
-      - name: Run OpenCode
+      - name: Run oh-my-opencode
         env:
           GITHUB_TOKEN: ${{ secrets.GH_PAT }}
+          USER_COMMENT: ${{ steps.context.outputs.comment }}
+          COMMENT_AUTHOR: ${{ steps.context.outputs.author }}
+          CONTEXT_TYPE: ${{ steps.context.outputs.type }}
+          CONTEXT_NUMBER: ${{ steps.context.outputs.number }}
+          REPO_NAME: ${{ github.repository }}
+          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
         run: |
           export PATH="$HOME/.opencode/bin:$PATH"
 
-          PROMPT="
-          Your username is @sisyphus-dev-ai, mentioned by @${{ steps.context.outputs.author }} in ${{ github.repository }}.
+          PROMPT=$(cat <<'PROMPT_EOF'
+          Your username is @sisyphus-dev-ai, mentioned by @AUTHOR_PLACEHOLDER in REPO_PLACEHOLDER.
 
           ## Context
-          - Type: ${{ steps.context.outputs.type }}
-          - Number: #${{ steps.context.outputs.number }}
-          - Repository: ${{ github.repository }}
-          - Default Branch: ${{ github.event.repository.default_branch }}
+          - Type: TYPE_PLACEHOLDER
+          - Number: #NUMBER_PLACEHOLDER
+          - Repository: REPO_PLACEHOLDER
+          - Default Branch: BRANCH_PLACEHOLDER
 
           ## User's Request
-          ${{ steps.context.outputs.comment }}
+          COMMENT_PLACEHOLDER
 
           ---
 
-          First, acknowledge with \`gh issue comment ${{ steps.context.outputs.number }} --body \"👋 Hey @${{ steps.context.outputs.author }}! I'm on it...\"\`
+          First, acknowledge with `gh issue comment NUMBER_PLACEHOLDER --body "👋 Hey @AUTHOR_PLACEHOLDER! I'm on it..."`
 
           Then write everything using the todo tools.
-          Then investigate and satisfy the request. Only if user requested to you to work explicitely, then use plan agent to plan, todo obsessivley then create a PR to \`${{ github.event.repository.default_branch }}\` branch."
+          Then investigate and satisfy the request. Only if user requested to you to work explicitely, then use plan agent to plan, todo obsessivley then create a PR to `BRANCH_PLACEHOLDER` branch.
+          PROMPT_EOF
+          )
 
-          opencode run "$PROMPT"
+          PROMPT="${PROMPT//AUTHOR_PLACEHOLDER/$COMMENT_AUTHOR}"
+          PROMPT="${PROMPT//REPO_PLACEHOLDER/$REPO_NAME}"
+          PROMPT="${PROMPT//TYPE_PLACEHOLDER/$CONTEXT_TYPE}"
+          PROMPT="${PROMPT//NUMBER_PLACEHOLDER/$CONTEXT_NUMBER}"
+          PROMPT="${PROMPT//BRANCH_PLACEHOLDER/$DEFAULT_BRANCH}"
+          PROMPT="${PROMPT//COMMENT_PLACEHOLDER/$USER_COMMENT}"
+
+          stdbuf -oL -eL bun run dist/cli/index.js run "$PROMPT"
 
       # Push changes (as sisyphus-dev-ai)
       - name: Push changes

AGENTS.md

@@ -1,7 +1,7 @@
 # PROJECT KNOWLEDGE BASE
 
-**Generated:** 2025-12-24T17:07:00+09:00
-**Commit:** 0172241
+**Generated:** 2025-12-28T17:15:00+09:00
+**Commit:** f5b74d5
 **Branch:** dev
 
 ## OVERVIEW

README.ja.md

@@ -56,6 +56,8 @@
 
 > "Oh My Opencodeは頂点に立っています、敵はいません" — [RyanOnThePath](https://x.com/RyanOnThePath/status/2001438321252118548)
 
+> "シジフォスという名前自体が美しいじゃないですか?" — Sigrid ([@sigridjin_eth](https://x.com/sigridjin_eth))
+
 ---
 
 ## 目次
@@ -394,8 +396,8 @@ gh repo star code-yeongyu/oh-my-opencode
 
 - **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、画像、図表を分析して情報を抽出します。
@@ -599,8 +601,7 @@ Oh My OpenCode は以下の場所からフックを読み込んで実行しま
 - **Agent Usage Reminder**: 検索ツールを直接呼び出す際、バックグラウンドタスクを通じた専門エージェントの活用を推奨するリマインダーを表示します。
 - **Anthropic Auto Compact**: Claude モデルがトークン制限に達すると、自動的にセッションを要約・圧縮します。手動での介入は不要です。
 - **Session Recovery**: セッションエラー（ツールの結果欠落、thinking ブロックの問題、空のメッセージなど）から自動復旧します。セッションが途中でクラッシュすることはありません。もしクラッシュしても復旧します。
-- **Auto Update Checker**: oh-my-opencode の新バージョンがリリースされると通知します。
-- **Startup Toast**: OhMyOpenCode ロード時にウェルカムメッセージを表示します。セッションを正しく始めるための、ささやかな "oMoMoMo" です。
+- **Auto Update Checker**: oh-my-opencode の新バージョンを自動でチェックし、設定を自動更新できます。現在のバージョンと Sisyphus ステータスを表示する起動トースト通知を表示します（Sisyphus 有効時は「Sisyphus on steroids is steering OpenCode」、無効時は「OpenCode is now on Steroids. oMoMoMoMo...」）。全機能を無効化するには `disabled_hooks` に `"auto-update-checker"` を、トースト通知のみ無効化するには `"startup-toast"` を追加してください。[設定 > フック](#フック) 参照。
 - **Background Notification**: バックグラウンドエージェントのタスクが完了すると通知を受け取ります。
 - **Session Notification**: エージェントがアイドル状態になると OS 通知を送ります。macOS、Linux、Windows で動作します—エージェントが入力を待っている時を見逃しません。
 - **Empty Task Response Detector**: Task ツールが空の応答を返すと検知します。既に空の応答が返ってきているのに、いつまでも待ち続ける状況を防ぎます。
@@ -714,24 +715,48 @@ Oh My OpenCode は以下の場所からフックを読み込んで実行しま
 
 ### Sisyphus Agent
 
-有効時（デフォルト）、Sisyphus は2つのプライマリエージェントを追加し、内蔵エージェントをサブエージェントに降格させます：
+有効時（デフォルト）、Sisyphus はオプションの特殊エージェントを備えた強力なオーケストレーターを提供します：
 
 - **Sisyphus**: プライマリオーケストレーターエージェント (Claude Opus 4.5)
-- **Planner-Sisyphus**: OpenCode の plan エージェントの全設定を実行時に継承 (description に "OhMyOpenCode version" を追加)
-- **build**: サブエージェントに降格
-- **plan**: サブエージェントに降格
+- **Builder-Sisyphus**: OpenCode のデフォルトビルドエージェント（SDK 制限により名前変更、デフォルトで無効）
+- **Planner-Sisyphus**: OpenCode のデフォルトプランエージェント（SDK 制限により名前変更、デフォルトで有効）
 
-Sisyphus を無効化して元の build/plan エージェントを復元するには：
+**設定オプション：**
 
 ```json
 {
-  "omo_agent": {
+  "sisyphus_agent": {
+    "disabled": false,
+    "default_builder_enabled": false,
+    "planner_enabled": true,
+    "replace_plan": true
+  }
+}
+```
+
+**例：Builder-Sisyphus を有効化：**
+
+```json
+{
+  "sisyphus_agent": {
+    "default_builder_enabled": true
+  }
+}
+```
+
+これにより、Sisyphus と並行して Builder-Sisyphus エージェントを有効化できます。Sisyphus が有効な場合、デフォルトのビルドエージェントは常にサブエージェントモードに降格されます。
+
+**例：すべての Sisyphus オーケストレーションを無効化：**
+
+```json
+{
+  "sisyphus_agent": {
     "disabled": true
   }
 }
 ```
 
-他のエージェント同様、Sisyphus と Planner-Sisyphus もカスタマイズ可能です：
+他のエージェント同様、Sisyphus エージェントもカスタマイズ可能です：
 
 ```json
 {
@@ -740,6 +765,9 @@ Sisyphus を無効化して元の build/plan エージェントを復元する
       "model": "anthropic/claude-sonnet-4",
       "temperature": 0.3
     },
+    "Builder-Sisyphus": {
+      "model": "anthropic/claude-opus-4"
+    },
     "Planner-Sisyphus": {
       "model": "openai/gpt-5.2"
     }
@@ -747,9 +775,12 @@ Sisyphus を無効化して元の build/plan エージェントを復元する
 }
 ```
 
-| オプション | デフォルト | 説明 |
-|------------|------------|------|
-| `disabled` | `false` | `true` の場合、Sisyphus エージェントを無効化し、元の build/plan をプライマリとして復元します。`false` (デフォルト) の場合、Sisyphus と Planner-Sisyphus がプライマリエージェントになります。 |
+| オプション                  | デフォルト | 説明                                                                                                                                                         |
+| --------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `disabled`                  | `false` | `true` の場合、すべての Sisyphus オーケストレーションを無効化し、元の build/plan をプライマリとして復元します。                                                                       |
+| `default_builder_enabled`   | `false` | `true` の場合、Builder-Sisyphus エージェントを有効化します（OpenCode build と同じ、SDK 制限により名前変更）。デフォルトでは無効です。                                                   |
+| `planner_enabled`           | `true`  | `true` の場合、Planner-Sisyphus エージェントを有効化します（OpenCode plan と同じ、SDK 制限により名前変更）。デフォルトで有効です。                                                       |
+| `replace_plan`              | `true`  | `true` の場合、デフォルトのプランエージェントをサブエージェントモードに降格させます。`false` に設定すると、Planner-Sisyphus とデフォルトのプランの両方を利用できます。                                |
 
 ### Hooks
 
@@ -763,6 +794,8 @@ Sisyphus を無効化して元の build/plan エージェントを復元する
 
 利用可能なフック：`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`
 
+**`auto-update-checker`と`startup-toast`について**: `startup-toast` フックは `auto-update-checker` のサブ機能です。アップデートチェックは有効なまま起動トースト通知のみを無効化するには、`disabled_hooks` に `"startup-toast"` を追加してください。すべてのアップデートチェック機能（トーストを含む）を無効化するには、`"auto-update-checker"` を追加してください。
+
 ### MCPs
 
 コンテキスト7、Exa、grep.app MCP がデフォルトで有効になっています。
@@ -812,15 +845,19 @@ OpenCode でサポートされるすべての LSP 構成およびカスタム設
 {
   "experimental": {
     "aggressive_truncation": true,
-    "auto_resume": true
+    "auto_resume": true,
+    "truncate_all_tool_outputs": false,
+    "dcp_on_compaction_failure": true
   }
 }
 ```
 
-| オプション               | デフォルト | 説明                                                                                                                                                                   |
-| ------------------------ | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `aggressive_truncation`  | `false`    | トークン制限を超えた場合、ツール出力を積極的に切り詰めて制限内に収めます。デフォルトの切り詰めより積極的です。不十分な場合は要約/復元にフォールバックします。                 |
-| `auto_resume`            | `false`    | thinking block エラーや thinking disabled violation からの回復成功後、自動的にセッションを再開します。最後のユーザーメッセージを抽出して続行します。                        |
+| オプション                  | デフォルト | 説明                                                                                                                                                                   |
+| --------------------------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `aggressive_truncation`     | `false`    | トークン制限を超えた場合、ツール出力を積極的に切り詰めて制限内に収めます。デフォルトの切り詰めより積極的です。不十分な場合は要約/復元にフォールバックします。                 |
+| `auto_resume`               | `false`    | thinking block エラーや thinking disabled violation からの回復成功後、自動的にセッションを再開します。最後のユーザーメッセージを抽出して続行します。                        |
+| `truncate_all_tool_outputs` | `true`     | プロンプトが長くなりすぎるのを防ぐため、コンテキストウィンドウの使用状況に基づいてすべてのツール出力を動的に切り詰めます。完全なツール出力が必要な場合は`false`に設定して無効化します。 |
+| `dcp_for_compaction`        | `false`    | 有効にすると、トークン制限エラー発生時にDCP（Dynamic Context Pruning）が最初に実行され、その後コンパクションが実行されます。DCPが不要なコンテキストを整理した後、すぐにコンパクションが進行します。トークン制限に達した際によりスマートな回復が必要な場合は有効にしてください。 |
 
 **警告**：これらの機能は実験的であり、予期しない動作を引き起こす可能性があります。影響を理解した場合にのみ有効にしてください。
 
@@ -868,11 +905,16 @@ OpenCode が Debian / ArchLinux だとしたら、Oh My OpenCode は Ubuntu / [O
   - [修正 PR](https://github.com/sst/opencode/pull/5040) は 1.0.132 以降にマージされたため、新しいバージョンを使用してください。
     - 余談：この PR も、OhMyOpenCode の Librarian、Explore、Oracle セットアップを活用して偶然発見され、修正されました。
 
-*素晴らしいヒーロー画像を作成してくれた [@junhoyeo](https://github.com/junhoyeo) に感謝します*
-
 ## こちらの企業の専門家にご愛用いただいています
 
 - [Indent](https://indentcorp.com)
   - Making Spray - influencer marketing solution, vovushop - crossborder commerce platform, vreview - ai commerce review marketing solution
 - [Google](https://google.com)
 - [Microsoft](https://microsoft.com)
+
+## スポンサー
+- **Numman Ali** [GitHub](https://github.com/numman-ali) [X](https://x.com/nummanali)
+  - 最初のスポンサー
+- **Aaron Iker** [GitHub](https://github.com/aaroniker) [X](https://x.com/aaroniker)
+
+*素晴らしいヒーロー画像を作成してくれた [@junhoyeo](https://github.com/junhoyeo) に感謝します*

README.ko.md

@@ -53,6 +53,8 @@
 
 > "Oh My Opencode는 독보적입니다, 경쟁자가 없습니다" — [RyanOnThePath](https://x.com/RyanOnThePath/status/2001438321252118548)
 
+> "시지푸스 이름 자체가 이쁘잖아요?" — Sigrid ([@sigridjin_eth](https://x.com/sigridjin_eth))
+
 ---
 
 ## 목차
@@ -391,8 +393,8 @@ gh repo star code-yeongyu/oh-my-opencode
 
 - **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, 이미지, 다이어그램을 분석하여 정보를 추출합니다.
@@ -593,8 +595,7 @@ Oh My OpenCode는 다음 위치의 훅을 읽고 실행합니다:
 - **Agent Usage Reminder**: 검색 도구를 직접 호출할 때, 백그라운드 작업을 통한 전문 에이전트 활용을 권장하는 리마인더를 표시합니다.
 - **Anthropic Auto Compact**: Claude 모델이 토큰 제한에 도달하면 자동으로 세션을 요약하고 압축합니다. 수동 개입 없이 작업을 계속할 수 있습니다.
 - **Session Recovery**: 세션 에러(누락된 도구 결과, thinking 블록 문제, 빈 메시지 등)에서 자동 복구합니다. 돌다가 세션이 망가지지 않습니다. 망가져도 복구됩니다.
-- **Auto Update Checker**: oh-my-opencode의 새 버전이 출시되면 알림을 표시합니다.
-- **Startup Toast**: OhMyOpenCode 로드 시 환영 메시지를 표시합니다. 세션을 제대로 시작하기 위한 작은 "oMoMoMo".
+- **Auto Update Checker**: oh-my-opencode의 새 버전을 자동으로 확인하고 설정을 자동 업데이트할 수 있습니다. 현재 버전과 Sisyphus 상태를 표시하는 시작 토스트 알림을 표시합니다 (Sisyphus 활성화 시 "Sisyphus on steroids is steering OpenCode", 비활성화 시 "OpenCode is now on Steroids. oMoMoMoMo..."). 모든 기능을 비활성화하려면 `disabled_hooks`에 `"auto-update-checker"`를, 토스트 알림만 비활성화하려면 `"startup-toast"`를 추가하세요. [설정 > 훅](#훅) 참조.
 - **Background Notification**: 백그라운드 에이전트 작업이 완료되면 알림을 받습니다.
 - **Session Notification**: 에이전트가 대기 상태가 되면 OS 알림을 보냅니다. macOS, Linux, Windows에서 작동—에이전트가 입력을 기다릴 때 놓치지 마세요.
 - **Empty Task Response Detector**: Task 도구가 빈 응답을 반환하면 감지합니다. 이미 빈 응답이 왔는데 무한정 기다리는 상황을 방지합니다.
@@ -708,14 +709,38 @@ Schema 자동 완성이 지원됩니다:
 
 ### Sisyphus Agent
 
-활성화 시(기본값), oh-my-opencode 는 두 개의 primary 에이전트를 추가하고 내장 에이전트를 subagent로 강등합니다:
+활성화 시 (기본값), Sisyphus는 옵션으로 선택 가능한 특화 에이전트들과 함께 강력한 오케스트레이터를 제공합니다:
 
 - **Sisyphus**: Primary 오케스트레이터 에이전트 (Claude Opus 4.5)
-- **Planner-Sisyphus**: OpenCode plan 에이전트의 모든 설정을 런타임에 상속 (description에 "OhMyOpenCode version" 추가)
-- **build**: subagent로 강등
-- **plan**: subagent로 강등
+- **Builder-Sisyphus**: OpenCode 기본 빌드 에이전트 (SDK 제한으로 이름만 변경, 기본적으로 비활성화)
+- **Planner-Sisyphus**: OpenCode 기본 플랜 에이전트 (SDK 제한으로 이름만 변경, 기본적으로 활성화)
 
-Sisyphus 를 비활성화하고 원래 build/plan 에이전트를 복원하려면:
+**설정 옵션:**
+
+```json
+{
+  "sisyphus_agent": {
+    "disabled": false,
+    "default_builder_enabled": false,
+    "planner_enabled": true,
+    "replace_plan": true
+  }
+}
+```
+
+**예시: Builder-Sisyphus 활성화하기:**
+
+```json
+{
+  "sisyphus_agent": {
+    "default_builder_enabled": true
+  }
+}
+```
+
+이렇게 하면 Sisyphus와 함께 Builder-Sisyphus 에이전트를 활성화할 수 있습니다. Sisyphus가 활성화되면 기본 빌드 에이전트는 항상 subagent 모드로 강등됩니다.
+
+**예시: 모든 Sisyphus 오케스트레이션 비활성화:**
 
 ```json
 {
@@ -725,7 +750,7 @@ Sisyphus 를 비활성화하고 원래 build/plan 에이전트를 복원하려
 }
 ```
 
-다른 에이전트처럼 Sisyphus 와 Planner-Sisyphus도 커스터마이징할 수 있습니다:
+다른 에이전트처럼 Sisyphus 에이전트들도 커스터마이징할 수 있습니다:
 
 ```json
 {
@@ -734,6 +759,9 @@ Sisyphus 를 비활성화하고 원래 build/plan 에이전트를 복원하려
       "model": "anthropic/claude-sonnet-4",
       "temperature": 0.3
     },
+    "Builder-Sisyphus": {
+      "model": "anthropic/claude-opus-4"
+    },
     "Planner-Sisyphus": {
       "model": "openai/gpt-5.2"
     }
@@ -741,9 +769,12 @@ Sisyphus 를 비활성화하고 원래 build/plan 에이전트를 복원하려
 }
 ```
 
-| 옵션       | 기본값  | 설명                                                                                                                                       |
-| ---------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-| `disabled` | `false` | `true`면 Sisyphus 에이전트를 비활성화하고 원래 build/plan을 primary로 복원합니다. `false`(기본값)면 Sisyphus와 Planner-Sisyphus가 primary 에이전트가 됩니다. |
+| 옵션                        | 기본값   | 설명                                                                                                                                                  |
+| --------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `disabled`                  | `false` | `true`면 모든 Sisyphus 오케스트레이션을 비활성화하고 원래 build/plan을 primary로 복원합니다.                                                                       |
+| `default_builder_enabled`   | `false` | `true`면 Builder-Sisyphus 에이전트를 활성화합니다 (OpenCode build와 동일, SDK 제한으로 이름만 변경). 기본적으로 비활성화되어 있습니다.                                      |
+| `planner_enabled`           | `true`  | `true`면 Planner-Sisyphus 에이전트를 활성화합니다 (OpenCode plan과 동일, SDK 제한으로 이름만 변경). 기본적으로 활성화되어 있습니다.                                          |
+| `replace_plan`              | `true`  | `true`면 기본 플랜 에이전트를 subagent 모드로 강등시킵니다. `false`로 설정하면 Planner-Sisyphus와 기본 플랜을 모두 사용할 수 있습니다.                                        |
 
 ### Hooks
 
@@ -757,6 +788,8 @@ Sisyphus 를 비활성화하고 원래 build/plan 에이전트를 복원하려
 
 사용 가능한 훅: `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`
 
+**`auto-update-checker`와 `startup-toast`에 대한 참고사항**: `startup-toast` 훅은 `auto-update-checker`의 하위 기능입니다. 업데이트 확인은 유지하면서 시작 토스트 알림만 비활성화하려면 `disabled_hooks`에 `"startup-toast"`를 추가하세요. 모든 업데이트 확인 기능(토스트 포함)을 비활성화하려면 `"auto-update-checker"`를 추가하세요.
+
 ### MCPs
 
 기본적으로 Context7, Exa, grep.app MCP 를 지원합니다.
@@ -806,15 +839,19 @@ OpenCode 에서 지원하는 모든 LSP 구성 및 커스텀 설정 (opencode.js
 {
   "experimental": {
     "aggressive_truncation": true,
-    "auto_resume": true
+    "auto_resume": true,
+    "truncate_all_tool_outputs": false,
+    "dcp_on_compaction_failure": true
   }
 }
 ```
 
-| 옵션                     | 기본값  | 설명                                                                                                                                                              |
-| ------------------------ | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `aggressive_truncation`  | `false` | 토큰 제한을 초과하면 도구 출력을 공격적으로 잘라내어 제한 내에 맞춥니다. 기본 truncation보다 더 공격적입니다. 부족하면 요약/복구로 fallback합니다.                      |
-| `auto_resume`            | `false` | thinking block 에러나 thinking disabled violation으로부터 성공적으로 복구한 후 자동으로 세션을 재개합니다. 마지막 사용자 메시지를 추출하여 계속합니다.                |
+| 옵션                        | 기본값  | 설명                                                                                                                                                              |
+| --------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `aggressive_truncation`     | `false` | 토큰 제한을 초과하면 도구 출력을 공격적으로 잘라내어 제한 내에 맞춥니다. 기본 truncation보다 더 공격적입니다. 부족하면 요약/복구로 fallback합니다.                      |
+| `auto_resume`               | `false` | thinking block 에러나 thinking disabled violation으로부터 성공적으로 복구한 후 자동으로 세션을 재개합니다. 마지막 사용자 메시지를 추출하여 계속합니다.                |
+| `truncate_all_tool_outputs` | `true`  | 프롬프트가 너무 길어지는 것을 방지하기 위해 컨텍스트 윈도우 사용량에 따라 모든 도구 출력을 동적으로 잘라냅니다. 전체 도구 출력이 필요한 경우 `false`로 설정하여 비활성화하세요. |
+| `dcp_for_compaction`        | `false` | 활성화하면, 토큰 제한 에러 발생 시 DCP(Dynamic Context Pruning)가 가장 먼저 실행되고, 그 다음 compaction이 실행됩니다. DCP가 불필요한 컨텍스트를 정리한 후 바로 compaction이 진행됩니다. 토큰 제한에 도달했을 때 더 스마트한 복구를 원하면 활성화하세요. |
 
 **경고**: 이 기능들은 실험적이며 예상치 못한 동작을 유발할 수 있습니다. 의미를 이해한 경우에만 활성화하세요.
 
@@ -862,11 +899,16 @@ OpenCode 를 사용하여 이 프로젝트의 99% 를 작성했습니다. 기능
   - [이를 고치는 PR 이 1.0.132 배포 이후에 병합되었으므로](https://github.com/sst/opencode/pull/5040) 이 변경사항이 포함된 최신 버전을 사용해주세요.
     - TMI: PR 도 OhMyOpenCode 의 셋업의 Librarian, Explore, Oracle 을 활용하여 우연히 발견하고 해결되었습니다.
 
-*멋진 히어로 이미지를 만들어주신 히어로 [@junhoyeo](https://github.com/junhoyeo) 께 감사드립니다*
-
 ## 다음 기업의 능력있는 개인들이 사용하고 있습니다
 
 - [Indent](https://indentcorp.com)
   - Making Spray - influencer marketing solution, vovushop - crossborder commerce platform, vreview - ai commerce review marketing solution
 - [Google](https://google.com)
 - [Microsoft](https://microsoft.com)
+
+## 스폰서
+- **Numman Ali** [GitHub](https://github.com/numman-ali) [X](https://x.com/nummanali)
+  - 첫 번째 스폰서
+- **Aaron Iker** [GitHub](https://github.com/aaroniker) [X](https://x.com/aaroniker)
+
+*멋진 히어로 이미지를 만들어주신 히어로 [@junhoyeo](https://github.com/junhoyeo) 께 감사드립니다*

README.md

@@ -61,6 +61,8 @@ No stupid token consumption massive subagents here. No bloat tools here.
 
 > "Oh My Opencode is king of the hill and has no contenders" — [RyanOnThePath](https://x.com/RyanOnThePath/status/2001438321252118548)
 
+> "Isn't the name Sisyphus itself beautiful?" — Sigrid ([@sigridjin_eth](https://x.com/sigridjin_eth))
+
 ---
 
 ## Contents
@@ -463,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.
@@ -665,8 +667,7 @@ When agents thrive, you thrive. But I want to help you directly too.
 - **Agent Usage Reminder**: When you call search tools directly, reminds you to leverage specialized agents via background tasks for better results.
 - **Anthropic Auto Compact**: When Claude models hit token limits, automatically summarizes and compacts the session—no manual intervention needed.
 - **Session Recovery**: Automatically recovers from session errors (missing tool results, thinking block issues, empty messages). Sessions don't crash mid-run. Even if they do, they recover.
-- **Auto Update Checker**: Notifies you when a new version of oh-my-opencode is available.
-- **Startup Toast**: Shows a welcome message when OhMyOpenCode loads. A little "oMoMoMo" to start your session right.
+- **Auto Update Checker**: Automatically checks for new versions of oh-my-opencode and can auto-update your configuration. Shows startup toast notifications displaying current version and Sisyphus status ("Sisyphus on steroids is steering OpenCode" when enabled, or "OpenCode is now on Steroids. oMoMoMoMo..." otherwise). Disable all features with `"auto-update-checker"` in `disabled_hooks`, or disable just toast notifications with `"startup-toast"` in `disabled_hooks`. See [Configuration > Hooks](#hooks).
 - **Background Notification**: Get notified when background agent tasks complete.
 - **Session Notification**: Sends OS notifications when agents go idle. Works on macOS, Linux, and Windows—never miss when your agent needs input.
 - **Empty Task Response Detector**: Catches when Task tool returns nothing. Warns you about potential agent failures so you don't wait forever for a response that already came back empty.
@@ -695,6 +696,36 @@ Schema autocomplete supported:
 }
 ```
 
+### JSONC Support
+
+The `oh-my-opencode` configuration file supports JSONC (JSON with Comments):
+- Line comments: `// comment`
+- Block comments: `/* comment */`
+- Trailing commas: `{ "key": "value", }`
+
+When both `oh-my-opencode.jsonc` and `oh-my-opencode.json` files exist, `.jsonc` takes priority.
+
+**Example with comments:**
+
+```jsonc
+{
+  "$schema": "https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/master/assets/oh-my-opencode.schema.json",
+  
+  // Enable Google Gemini via Antigravity OAuth
+  "google_auth": false,
+  
+  /* Agent overrides - customize models for specific tasks */
+  "agents": {
+    "oracle": {
+      "model": "openai/gpt-5.2"  // GPT for strategic reasoning
+    },
+    "explore": {
+      "model": "opencode/grok-code"  // Free & fast for exploration
+    },
+  },
+}
+```
+
 ### Google Auth
 
 **Recommended**: Use the external [`opencode-antigravity-auth`](https://github.com/NoeFabris/opencode-antigravity-auth) plugin. It provides multi-account load balancing, more models (including Claude via Antigravity), and active maintenance. See [Installation > Google Gemini](#google-gemini-antigravity-oauth).
@@ -780,24 +811,48 @@ Available agents: `oracle`, `librarian`, `explore`, `frontend-ui-ux-engineer`, `
 
 ### Sisyphus Agent
 
-When enabled (default), Sisyphus adds two primary agents and demotes the built-in agents to subagents:
+When enabled (default), Sisyphus provides a powerful orchestrator with optional specialized agents:
 
 - **Sisyphus**: Primary orchestrator agent (Claude Opus 4.5)
-- **Planner-Sisyphus**: Inherits all settings from OpenCode's plan agent at runtime (description appended with "OhMyOpenCode version")
-- **build**: Demoted to subagent
-- **plan**: Demoted to subagent
+- **Builder-Sisyphus**: OpenCode's default build agent, renamed due to SDK limitations (disabled by default)
+- **Planner-Sisyphus**: OpenCode's default plan agent, renamed due to SDK limitations (enabled by default)
 
-To disable Sisyphus and restore the original build/plan agents:
+**Configuration Options:**
 
 ```json
 {
-  "omo_agent": {
+  "sisyphus_agent": {
+    "disabled": false,
+    "default_builder_enabled": false,
+    "planner_enabled": true,
+    "replace_plan": true
+  }
+}
+```
+
+**Example: Enable Builder-Sisyphus:**
+
+```json
+{
+  "sisyphus_agent": {
+    "default_builder_enabled": true
+  }
+}
+```
+
+This enables Builder-Sisyphus agent alongside Sisyphus. The default build agent is always demoted to subagent mode when Sisyphus is enabled.
+
+**Example: Disable all Sisyphus orchestration:**
+
+```json
+{
+  "sisyphus_agent": {
     "disabled": true
   }
 }
 ```
 
-You can also customize Sisyphus and Planner-Sisyphus like other agents:
+You can also customize Sisyphus agents like other agents:
 
 ```json
 {
@@ -806,6 +861,9 @@ You can also customize Sisyphus and Planner-Sisyphus like other agents:
       "model": "anthropic/claude-sonnet-4",
       "temperature": 0.3
     },
+    "Builder-Sisyphus": {
+      "model": "anthropic/claude-opus-4"
+    },
     "Planner-Sisyphus": {
       "model": "openai/gpt-5.2"
     }
@@ -813,9 +871,12 @@ You can also customize Sisyphus and Planner-Sisyphus like other agents:
 }
 ```
 
-| Option     | Default | Description                                                                                                                                   |
-| ---------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
-| `disabled` | `false` | When `true`, disables Sisyphus agents and restores original build/plan as primary. When `false` (default), Sisyphus and Planner-Sisyphus become primary agents. |
+| Option                      | Default | Description                                                                                                                                         |
+| --------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `disabled`                  | `false` | When `true`, disables all Sisyphus orchestration and restores original build/plan as primary.                                                       |
+| `default_builder_enabled`   | `false` | When `true`, enables Builder-Sisyphus agent (same as OpenCode build, renamed due to SDK limitations). Disabled by default.                         |
+| `planner_enabled`           | `true`  | When `true`, enables Planner-Sisyphus agent (same as OpenCode plan, renamed due to SDK limitations). Enabled by default.                           |
+| `replace_plan`              | `true`  | When `true`, demotes default plan agent to subagent mode. Set to `false` to keep both Planner-Sisyphus and default plan available.                 |
 
 ### Hooks
 
@@ -829,6 +890,8 @@ 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`
 
+**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`.
+
 ### MCPs
 
 Context7, Exa, and grep.app MCP enabled by default.
@@ -878,15 +941,19 @@ Opt-in experimental features that may change or be removed in future versions. U
 {
   "experimental": {
     "aggressive_truncation": true,
-    "auto_resume": true
+    "auto_resume": true,
+    "truncate_all_tool_outputs": false,
+    "dcp_on_compaction_failure": true
   }
 }
 ```
 
-| Option                   | Default | Description                                                                                                                                                                                  |
-| ------------------------ | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `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.                            |
+| Option                      | Default | Description                                                                                                                                                                                  |
+| --------------------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `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_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.
 
@@ -934,11 +1001,16 @@ I have no affiliation with any project or model mentioned here. This is purely p
   - [The fix](https://github.com/sst/opencode/pull/5040) was merged after 1.0.132—use a newer version.
     - Fun fact: That PR was discovered and fixed thanks to OhMyOpenCode's Librarian, Explore, and Oracle setup.
 
-*Special thanks to [@junhoyeo](https://github.com/junhoyeo) for this amazing hero image.*
-
 ## Loved by professionals at
 
 - [Indent](https://indentcorp.com)
   - Making Spray - influencer marketing solution, vovushop - crossborder commerce platform, vreview - ai commerce review marketing solution
 - [Google](https://google.com)
 - [Microsoft](https://microsoft.com)
+
+## Sponsors
+- **Numman Ali** [GitHub](https://github.com/numman-ali) [X](https://x.com/nummanali)
+  - The first sponsor
+- **Aaron Iker** [GitHub](https://github.com/aaroniker) [X](https://x.com/aaroniker)
+
+*Special thanks to [@junhoyeo](https://github.com/junhoyeo) for this amazing hero image.*

README.zh-cn.md

@@ -58,6 +58,8 @@
 
 > "Oh My Opencode 独孤求败，没有对手" — [RyanOnThePath](https://x.com/RyanOnThePath/status/2001438321252118548)
 
+> "西西弗斯这个名字本身不就很美吗?" — Sigrid ([@sigridjin_eth](https://x.com/sigridjin_eth))
+
 ---
 
 ## 目录
@@ -402,8 +404,8 @@ gh repo star code-yeongyu/oh-my-opencode
 
 - **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、图片、图表，看一眼就知道里头有啥。
@@ -604,8 +606,7 @@ Agent 爽了，你自然也爽。但我还想直接让你爽。
 - **Agent 使用提醒**：你自己搜东西的时候，弹窗提醒你"这种事让后台专业 Agent 干更好"。
 - **Anthropic 自动压缩**：Claude Token 爆了？自动总结压缩会话——不用你操心。
 - **会话恢复**：工具没结果？Thinking 卡住？消息是空的？自动恢复。会话崩不了，崩了也能救回来。
-- **自动更新检查**：oh-my-opencode 更新了会告诉你。
-- **启动提示**：加载时来句"oMoMoMo"，开启元气满满的一次会话。
+- **自动更新检查**：自动检查 oh-my-opencode 新版本并可自动更新配置。显示启动提示通知，展示当前版本和 Sisyphus 状态（Sisyphus 启用时显示「Sisyphus on steroids is steering OpenCode」，禁用时显示「OpenCode is now on Steroids. oMoMoMoMo...」）。要禁用全部功能，在 `disabled_hooks` 中添加 `"auto-update-checker"`；只禁用提示通知，添加 `"startup-toast"`。详见 [配置 > Hooks](#hooks)。
 - **后台通知**：后台 Agent 活儿干完了告诉你。
 - **会话通知**：Agent 没事干了发系统通知。macOS、Linux、Windows 通吃——别让 Agent 等你。
 - **空 Task 响应检测**：Task 工具回了个寂寞？立马报警，别傻傻等一个永远不会来的响应。
@@ -714,24 +715,48 @@ Agent 爽了，你自然也爽。但我还想直接让你爽。
 
 ### Sisyphus Agent
 
-默认开启。Sisyphus 会加两个主 Agent，把原来的降级成小弟：
+默认开启。Sisyphus 提供一个强力的编排器，带可选的专门 Agent：
 
 - **Sisyphus**：主编排 Agent（Claude Opus 4.5）
-- **Planner-Sisyphus**：运行时继承 OpenCode plan Agent 所有设置（描述里加了"OhMyOpenCode version"）
-- **build**：降级为子 Agent
-- **plan**：降级为子 Agent
+- **Builder-Sisyphus**：OpenCode 默认构建 Agent（因 SDK 限制仅改名，默认禁用）
+- **Planner-Sisyphus**：OpenCode 默认计划 Agent（因 SDK 限制仅改名，默认启用）
 
-想禁用 Sisyphus 恢复原来的？
+**配置选项：**
 
 ```json
 {
-  "omo_agent": {
+  "sisyphus_agent": {
+    "disabled": false,
+    "default_builder_enabled": false,
+    "planner_enabled": true,
+    "replace_plan": true
+  }
+}
+```
+
+**示例：启用 Builder-Sisyphus：**
+
+```json
+{
+  "sisyphus_agent": {
+    "default_builder_enabled": true
+  }
+}
+```
+
+这样能和 Sisyphus 一起启用 Builder-Sisyphus Agent。启用 Sisyphus 后，默认构建 Agent 总会降级为子 Agent 模式。
+
+**示例：禁用所有 Sisyphus 编排：**
+
+```json
+{
+  "sisyphus_agent": {
     "disabled": true
   }
 }
 ```
 
-Sisyphus 和 Planner-Sisyphus 也能自定义：
+Sisyphus Agent 也能自定义：
 
 ```json
 {
@@ -740,6 +765,9 @@ Sisyphus 和 Planner-Sisyphus 也能自定义：
       "model": "anthropic/claude-sonnet-4",
       "temperature": 0.3
     },
+    "Builder-Sisyphus": {
+      "model": "anthropic/claude-opus-4"
+    },
     "Planner-Sisyphus": {
       "model": "openai/gpt-5.2"
     }
@@ -747,9 +775,12 @@ Sisyphus 和 Planner-Sisyphus 也能自定义：
 }
 ```
 
-| 选项       | 默认值  | 说明                                                                                                                                       |
-| ---------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-| `disabled` | `false` | 设为 `true` 就禁用 Sisyphus，恢复原来的 build/plan。设为 `false`（默认）就是 Sisyphus 和 Planner-Sisyphus 掌权。 |
+| 选项                        | 默认值   | 说明                                                                                                                                              |
+| --------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `disabled`                  | `false` | 设为 `true` 就禁用所有 Sisyphus 编排，恢复原来的 build/plan。                                                                                              |
+| `default_builder_enabled`   | `false` | 设为 `true` 就启用 Builder-Sisyphus Agent（与 OpenCode build 相同，因 SDK 限制仅改名）。默认禁用。                                                           |
+| `planner_enabled`           | `true`  | 设为 `true` 就启用 Planner-Sisyphus Agent（与 OpenCode plan 相同，因 SDK 限制仅改名）。默认启用。                                                             |
+| `replace_plan`              | `true`  | 设为 `true` 就把默认计划 Agent 降级为子 Agent 模式。设为 `false` 可以同时保留 Planner-Sisyphus 和默认计划。                                                        |
 
 ### Hooks
 
@@ -763,6 +794,8 @@ Sisyphus 和 Planner-Sisyphus 也能自定义：
 
 可关的 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`
 
+**关于 `auto-update-checker` 和 `startup-toast`**: `startup-toast` hook 是 `auto-update-checker` 的子功能。若想保持更新检查但只禁用启动提示通知，在 `disabled_hooks` 中添加 `"startup-toast"`。若要禁用所有更新检查功能（包括提示），添加 `"auto-update-checker"`。
+
 ### MCPs
 
 默认送你 Context7、Exa 和 grep.app MCP。
@@ -812,15 +845,19 @@ Oh My OpenCode 送你重构工具（重命名、代码操作）。
 {
   "experimental": {
     "aggressive_truncation": true,
-    "auto_resume": true
+    "auto_resume": true,
+    "truncate_all_tool_outputs": false,
+    "dcp_on_compaction_failure": true
   }
 }
 ```
 
-| 选项                     | 默认值  | 说明                                                                                                                                           |
-| ------------------------ | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| `aggressive_truncation`  | `false` | 超出 token 限制时，激进地截断工具输出以适应限制。比默认截断更激进。不够的话会回退到摘要/恢复。                                                     |
-| `auto_resume`            | `false` | 从 thinking block 错误或 thinking disabled violation 成功恢复后，自动恢复会话。提取最后一条用户消息继续执行。                                     |
+| 选项                        | 默认值  | 说明                                                                                                                                           |
+| --------------------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| `aggressive_truncation`     | `false` | 超出 token 限制时，激进地截断工具输出以适应限制。比默认截断更激进。不够的话会回退到摘要/恢复。                                                     |
+| `auto_resume`               | `false` | 从 thinking block 错误或 thinking disabled violation 成功恢复后，自动恢复会话。提取最后一条用户消息继续执行。                                     |
+| `truncate_all_tool_outputs` | `true`  | 为防止提示过长，根据上下文窗口使用情况动态截断所有工具输出。如需完整工具输出，设置为 `false` 禁用此功能。                                           |
+| `dcp_for_compaction`        | `false` | 启用后，当发生 token 限制错误时，DCP（动态上下文剪枝）首先运行，然后立即执行压缩。DCP 清理不必要的上下文后，压缩立即进行。当达到 token 限制时需要更智能的恢复请启用此选项。 |
 
 **警告**：这些功能是实验性的，可能会导致意外行为。只有在理解其影响的情况下才启用。
 
@@ -867,11 +904,16 @@ Oh My OpenCode 送你重构工具（重命名、代码操作）。
   - [修复 PR](https://github.com/sst/opencode/pull/5040) 在 1.0.132 之后才合进去——请用新版本。
     - 花絮：这 bug 也是靠 OhMyOpenCode 的 Librarian、Explore、Oracle 配合发现并修好的。
 
-*感谢 [@junhoyeo](https://github.com/junhoyeo) 制作了这张超帅的 hero 图。*
-
 ## 以下企业的专业人士都在用
 
 - [Indent](https://indentcorp.com)
   - Making Spray - influencer marketing solution, vovushop - crossborder commerce platform, vreview - ai commerce review marketing solution
 - [Google](https://google.com)
 - [Microsoft](https://microsoft.com)
+
+## 赞助者
+- **Numman Ali** [GitHub](https://github.com/numman-ali) [X](https://x.com/nummanali)
+  - 第一位赞助者
+- **Aaron Iker** [GitHub](https://github.com/aaroniker) [X](https://x.com/aaroniker)
+
+*感谢 [@junhoyeo](https://github.com/junhoyeo) 制作了这张超帅的 hero 图。*

assets/oh-my-opencode.schema.json

@@ -59,7 +59,17 @@
           "agent-usage-reminder",
           "non-interactive-env",
           "interactive-bash-session",
-          "empty-message-sanitizer"
+          "empty-message-sanitizer",
+          "thinking-block-validator"
+        ]
+      }
+    },
+    "disabled_commands": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": [
+          "init-deep"
         ]
       }
     },
@@ -408,6 +418,120 @@
             }
           }
         },
+        "OpenCode-Builder": {
+          "type": "object",
+          "properties": {
+            "model": {
+              "type": "string"
+            },
+            "temperature": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 2
+            },
+            "top_p": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "prompt": {
+              "type": "string"
+            },
+            "prompt_append": {
+              "type": "string"
+            },
+            "tools": {
+              "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
+              "additionalProperties": {
+                "type": "boolean"
+              }
+            },
+            "disable": {
+              "type": "boolean"
+            },
+            "description": {
+              "type": "string"
+            },
+            "mode": {
+              "type": "string",
+              "enum": [
+                "subagent",
+                "primary",
+                "all"
+              ]
+            },
+            "color": {
+              "type": "string",
+              "pattern": "^#[0-9A-Fa-f]{6}$"
+            },
+            "permission": {
+              "type": "object",
+              "properties": {
+                "edit": {
+                  "type": "string",
+                  "enum": [
+                    "ask",
+                    "allow",
+                    "deny"
+                  ]
+                },
+                "bash": {
+                  "anyOf": [
+                    {
+                      "type": "string",
+                      "enum": [
+                        "ask",
+                        "allow",
+                        "deny"
+                      ]
+                    },
+                    {
+                      "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
+                      "additionalProperties": {
+                        "type": "string",
+                        "enum": [
+                          "ask",
+                          "allow",
+                          "deny"
+                        ]
+                      }
+                    }
+                  ]
+                },
+                "webfetch": {
+                  "type": "string",
+                  "enum": [
+                    "ask",
+                    "allow",
+                    "deny"
+                  ]
+                },
+                "doom_loop": {
+                  "type": "string",
+                  "enum": [
+                    "ask",
+                    "allow",
+                    "deny"
+                  ]
+                },
+                "external_directory": {
+                  "type": "string",
+                  "enum": [
+                    "ask",
+                    "allow",
+                    "deny"
+                  ]
+                }
+              }
+            }
+          }
+        },
         "Planner-Sisyphus": {
           "type": "object",
           "properties": {
@@ -1225,6 +1349,18 @@
         },
         "hooks": {
           "type": "boolean"
+        },
+        "plugins": {
+          "type": "boolean"
+        },
+        "plugins_override": {
+          "type": "object",
+          "propertyNames": {
+            "type": "string"
+          },
+          "additionalProperties": {
+            "type": "boolean"
+          }
         }
       }
     },
@@ -1236,6 +1372,23 @@
       "properties": {
         "disabled": {
           "type": "boolean"
+        },
+        "default_builder_enabled": {
+          "type": "boolean"
+        },
+        "planner_enabled": {
+          "type": "boolean"
+        },
+        "replace_plan": {
+          "type": "boolean"
+        }
+      }
+    },
+    "comment_checker": {
+      "type": "object",
+      "properties": {
+        "custom_prompt": {
+          "type": "string"
         }
       }
     },
@@ -1257,6 +1410,101 @@
           "maximum": 0.95
         },
         "truncate_all_tool_outputs": {
+          "default": true,
+          "type": "boolean"
+        },
+        "dynamic_context_pruning": {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "default": false,
+              "type": "boolean"
+            },
+            "notification": {
+              "default": "detailed",
+              "type": "string",
+              "enum": [
+                "off",
+                "minimal",
+                "detailed"
+              ]
+            },
+            "turn_protection": {
+              "type": "object",
+              "properties": {
+                "enabled": {
+                  "default": true,
+                  "type": "boolean"
+                },
+                "turns": {
+                  "default": 3,
+                  "type": "number",
+                  "minimum": 1,
+                  "maximum": 10
+                }
+              }
+            },
+            "protected_tools": {
+              "default": [
+                "task",
+                "todowrite",
+                "todoread",
+                "lsp_rename",
+                "lsp_code_action_resolve",
+                "session_read",
+                "session_write",
+                "session_search"
+              ],
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "strategies": {
+              "type": "object",
+              "properties": {
+                "deduplication": {
+                  "type": "object",
+                  "properties": {
+                    "enabled": {
+                      "default": true,
+                      "type": "boolean"
+                    }
+                  }
+                },
+                "supersede_writes": {
+                  "type": "object",
+                  "properties": {
+                    "enabled": {
+                      "default": true,
+                      "type": "boolean"
+                    },
+                    "aggressive": {
+                      "default": false,
+                      "type": "boolean"
+                    }
+                  }
+                },
+                "purge_errors": {
+                  "type": "object",
+                  "properties": {
+                    "enabled": {
+                      "default": true,
+                      "type": "boolean"
+                    },
+                    "turns": {
+                      "default": 5,
+                      "type": "number",
+                      "minimum": 1,
+                      "maximum": 20
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "dcp_for_compaction": {
           "type": "boolean"
         }
       }

bun.lock

@@ -8,11 +8,13 @@
         "@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",
         "commander": "^14.0.2",
         "hono": "^4.10.4",
+        "jsonc-parser": "^3.3.1",
         "picocolors": "^1.1.1",
         "picomatch": "^4.0.2",
         "xdg-basedir": "^5.1.0",
@@ -71,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=="],
 
@@ -109,6 +111,8 @@
 
     "jose": ["jose@5.9.6", "", {}, "sha512-AMlnetc9+CV9asI19zHmrgS/WYsWUwCn2R7RzlbJWD7F9eWYUTGyBmU9o6PxngtLGOiDGPRu+Uc4fhKzbpteZQ=="],
 
+    "jsonc-parser": ["jsonc-parser@3.3.1", "", {}, "sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ=="],
+
     "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
 
     "picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],

package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "2.5.2",
+  "version": "2.7.0",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -53,11 +53,13 @@
     "@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",
     "commander": "^14.0.2",
     "hono": "^4.10.4",
+    "jsonc-parser": "^3.3.1",
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.2",
     "xdg-basedir": "^5.1.0",

signatures/cla.json

@@ -15,6 +15,54 @@
       "created_at": "2025-12-25T06:19:27Z",
       "repoId": 1108837393,
       "pullRequestNo": 217
+    },
+    {
+      "name": "mylukin",
+      "id": 1021019,
+      "comment_id": 3691531529,
+      "created_at": "2025-12-25T15:15:29Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 240
+    },
+    {
+      "name": "codewithkenzo",
+      "id": 115878491,
+      "comment_id": 3691825625,
+      "created_at": "2025-12-25T23:47:52Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 253
+    },
+    {
+      "name": "stevenvo",
+      "id": 875426,
+      "comment_id": 3692141372,
+      "created_at": "2025-12-26T05:16:12Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 248
+    },
+    {
+      "name": "harshav167",
+      "id": 80092815,
+      "comment_id": 3693666997,
+      "created_at": "2025-12-27T04:40:35Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 268
+    },
+    {
+      "name": "adam2am",
+      "id": 128839448,
+      "comment_id": 3694022446,
+      "created_at": "2025-12-27T14:49:05Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 281
+    },
+    {
+      "name": "devxoul",
+      "id": 931655,
+      "comment_id": 3694098760,
+      "created_at": "2025-12-27T17:05:50Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 288
     }
   ]
 }

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.

src/agents/build-prompt.ts

@@ -0,0 +1,68 @@
+/**
+ * OpenCode's default build agent system prompt.
+ *
+ * This prompt enables FULL EXECUTION mode for the build agent, allowing file
+ * modifications, command execution, and system changes while focusing on
+ * implementation and execution.
+ *
+ * Inspired by OpenCode's build agent behavior.
+ * 
+ * @see https://github.com/sst/opencode/blob/6f9bea4e1f3d139feefd0f88de260b04f78caaef/packages/opencode/src/session/prompt/build-switch.txt
+ * @see https://github.com/sst/opencode/blob/6f9bea4e1f3d139feefd0f88de260b04f78caaef/packages/opencode/src/agent/agent.ts#L118-L125
+ */
+export const BUILD_SYSTEM_PROMPT = `<system-reminder>
+# Build Mode - System Reminder
+
+BUILD MODE ACTIVE - you are in EXECUTION phase. Your responsibility is to:
+- Implement features and make code changes
+- Execute commands and run tests
+- Fix bugs and refactor code
+- Deploy and build systems
+- Make all necessary file modifications
+
+You have FULL permissions to edit files, run commands, and make system changes.
+This is the implementation phase - execute decisively and thoroughly.
+
+---
+
+## Responsibility
+
+Your current responsibility is to implement, build, and execute. You should:
+- Write and modify code to accomplish the user's goals
+- Run tests and builds to verify your changes
+- Fix errors and issues that arise
+- Use all available tools to complete the task efficiently
+- Delegate to specialized agents when appropriate for better results
+
+**NOTE:** You should ask the user for clarification when requirements are ambiguous,
+but once the path is clear, execute confidently. The goal is to deliver working,
+tested, production-ready solutions.
+
+---
+
+## Important
+
+The user wants you to execute and implement. You SHOULD make edits, run necessary
+tools, and make changes to accomplish the task. Use your full capabilities to
+deliver excellent results.
+</system-reminder>
+`
+
+/**
+ * OpenCode's default build agent permission configuration.
+ *
+ * Allows the build agent full execution permissions:
+ * - edit: "ask" - Can modify files with confirmation
+ * - bash: "ask" - Can execute commands with confirmation  
+ * - webfetch: "allow" - Can fetch web content
+ *
+ * This provides balanced permissions - powerful but with safety checks.
+ * 
+ * @see https://github.com/sst/opencode/blob/6f9bea4e1f3d139feefd0f88de260b04f78caaef/packages/opencode/src/agent/agent.ts#L57-L68
+ * @see https://github.com/sst/opencode/blob/6f9bea4e1f3d139feefd0f88de260b04f78caaef/packages/opencode/src/agent/agent.ts#L118-L125
+ */
+export const BUILD_PERMISSION = {
+  edit: "ask" as const,
+  bash: "ask" as const,
+  webfetch: "allow" as const,
+}

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",
                 },

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`)
+}

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,
-  }
 }
 
 /**

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
+}

src/cli/config-manager.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { join } from "node:path"
+import { parseJsonc } from "../shared"
 import type { ConfigMergeResult, DetectedConfig, InstallConfig } from "./types"
 
 const OPENCODE_CONFIG_DIR = join(homedir(), ".config", "opencode")
@@ -39,80 +40,10 @@ export function detectConfigFormat(): { format: ConfigFormat; path: string } {
   return { format: "none", path: OPENCODE_JSON }
 }
 
-function stripJsoncComments(content: string): string {
-  let result = ""
-  let i = 0
-  let inString = false
-  let escape = false
-
-  while (i < content.length) {
-    const char = content[i]
-
-    if (escape) {
-      result += char
-      escape = false
-      i++
-      continue
-    }
-
-    if (char === "\\") {
-      result += char
-      escape = true
-      i++
-      continue
-    }
-
-    if (char === '"' && !inString) {
-      inString = true
-      result += char
-      i++
-      continue
-    }
-
-    if (char === '"' && inString) {
-      inString = false
-      result += char
-      i++
-      continue
-    }
-
-    if (inString) {
-      result += char
-      i++
-      continue
-    }
-
-    // Outside string - check for comments
-    if (char === "/" && content[i + 1] === "/") {
-      // Line comment - skip to end of line
-      while (i < content.length && content[i] !== "\n") {
-        i++
-      }
-      continue
-    }
-
-    if (char === "/" && content[i + 1] === "*") {
-      // Block comment - skip to */
-      i += 2
-      while (i < content.length - 1 && !(content[i] === "*" && content[i + 1] === "/")) {
-        i++
-      }
-      i += 2
-      continue
-    }
-
-    result += char
-    i++
-  }
-
-  return result.replace(/,(\s*[}\]])/g, "$1")
-}
-
 function parseConfig(path: string, isJsonc: boolean): OpenCodeConfig | null {
   try {
     const content = readFileSync(path, "utf-8")
-    const cleaned = isJsonc ? stripJsoncComments(content) : content
-    return JSON.parse(cleaned) as OpenCodeConfig
+    return parseJsonc<OpenCodeConfig>(content)
   } catch {
     return null
   }
@@ -215,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) {
@@ -252,8 +190,7 @@ export function writeOmoConfig(installConfig: InstallConfig): ConfigMergeResult
 
     if (existsSync(OMO_CONFIG)) {
       const content = readFileSync(OMO_CONFIG, "utf-8")
-      const cleaned = stripJsoncComments(content)
-      const existing = JSON.parse(cleaned) as Record<string, unknown>
+      const existing = parseJsonc<Record<string, unknown>>(content)
       delete existing.agents
       const merged = deepMerge(existing, newConfig)
       writeFileSync(OMO_CONFIG, JSON.stringify(merged, null, 2) + "\n")
@@ -484,7 +421,7 @@ export function detectCurrentConfig(): DetectedConfig {
 
   try {
     const content = readFileSync(OMO_CONFIG, "utf-8")
-    const omoConfig = JSON.parse(stripJsoncComments(content)) as OmoConfigData
+    const omoConfig = parseJsonc<OmoConfigData>(content)
 
     const agents = omoConfig.agents ?? {}
 

src/cli/get-local-version/formatter.ts

@@ -0,0 +1,66 @@
+import color from "picocolors"
+import type { VersionInfo } from "./types"
+
+const SYMBOLS = {
+  check: color.green("✓"),
+  cross: color.red("✗"),
+  arrow: color.cyan("→"),
+  info: color.blue("ℹ"),
+  warn: color.yellow("⚠"),
+  pin: color.magenta("📌"),
+  dev: color.cyan("🔧"),
+}
+
+export function formatVersionOutput(info: VersionInfo): string {
+  const lines: string[] = []
+
+  lines.push("")
+  lines.push(color.bold(color.white("oh-my-opencode Version Information")))
+  lines.push(color.dim("─".repeat(50)))
+  lines.push("")
+
+  if (info.currentVersion) {
+    lines.push(`  Current Version: ${color.cyan(info.currentVersion)}`)
+  } else {
+    lines.push(`  Current Version: ${color.dim("unknown")}`)
+  }
+
+  if (!info.isLocalDev && info.latestVersion) {
+    lines.push(`  Latest Version:  ${color.cyan(info.latestVersion)}`)
+  }
+
+  lines.push("")
+
+  switch (info.status) {
+    case "up-to-date":
+      lines.push(`  ${SYMBOLS.check} ${color.green("You're up to date!")}`)
+      break
+    case "outdated":
+      lines.push(`  ${SYMBOLS.warn} ${color.yellow("Update available")}`)
+      lines.push(`  ${color.dim("Run:")} ${color.cyan("cd ~/.config/opencode && bun update oh-my-opencode")}`)
+      break
+    case "local-dev":
+      lines.push(`  ${SYMBOLS.dev} ${color.cyan("Running in local development mode")}`)
+      lines.push(`  ${color.dim("Using file:// protocol from config")}`)
+      break
+    case "pinned":
+      lines.push(`  ${SYMBOLS.pin} ${color.magenta(`Version pinned to ${info.pinnedVersion}`)}`)
+      lines.push(`  ${color.dim("Update check skipped for pinned versions")}`)
+      break
+    case "error":
+      lines.push(`  ${SYMBOLS.cross} ${color.red("Unable to check for updates")}`)
+      lines.push(`  ${color.dim("Network error or npm registry unavailable")}`)
+      break
+    case "unknown":
+      lines.push(`  ${SYMBOLS.info} ${color.yellow("Version information unavailable")}`)
+      break
+  }
+
+  lines.push("")
+
+  return lines.join("\n")
+}
+
+export function formatJsonOutput(info: VersionInfo): string {
+  return JSON.stringify(info, null, 2)
+}

src/cli/get-local-version/index.ts

@@ -0,0 +1,104 @@
+import { getCachedVersion, getLatestVersion, isLocalDevMode, findPluginEntry } from "../../hooks/auto-update-checker/checker"
+import type { GetLocalVersionOptions, VersionInfo } from "./types"
+import { formatVersionOutput, formatJsonOutput } from "./formatter"
+
+export async function getLocalVersion(options: GetLocalVersionOptions = {}): Promise<number> {
+  const directory = options.directory ?? process.cwd()
+  
+  try {
+    if (isLocalDevMode(directory)) {
+      const currentVersion = getCachedVersion()
+      const info: VersionInfo = {
+        currentVersion,
+        latestVersion: null,
+        isUpToDate: false,
+        isLocalDev: true,
+        isPinned: false,
+        pinnedVersion: null,
+        status: "local-dev",
+      }
+      
+      console.log(options.json ? formatJsonOutput(info) : formatVersionOutput(info))
+      return 0
+    }
+
+    const pluginInfo = findPluginEntry(directory)
+    if (pluginInfo?.isPinned) {
+      const info: VersionInfo = {
+        currentVersion: pluginInfo.pinnedVersion,
+        latestVersion: null,
+        isUpToDate: false,
+        isLocalDev: false,
+        isPinned: true,
+        pinnedVersion: pluginInfo.pinnedVersion,
+        status: "pinned",
+      }
+      
+      console.log(options.json ? formatJsonOutput(info) : formatVersionOutput(info))
+      return 0
+    }
+
+    const currentVersion = getCachedVersion()
+    if (!currentVersion) {
+      const info: VersionInfo = {
+        currentVersion: null,
+        latestVersion: null,
+        isUpToDate: false,
+        isLocalDev: false,
+        isPinned: false,
+        pinnedVersion: null,
+        status: "unknown",
+      }
+      
+      console.log(options.json ? formatJsonOutput(info) : formatVersionOutput(info))
+      return 1
+    }
+
+    const latestVersion = await getLatestVersion()
+    
+    if (!latestVersion) {
+      const info: VersionInfo = {
+        currentVersion,
+        latestVersion: null,
+        isUpToDate: false,
+        isLocalDev: false,
+        isPinned: false,
+        pinnedVersion: null,
+        status: "error",
+      }
+      
+      console.log(options.json ? formatJsonOutput(info) : formatVersionOutput(info))
+      return 0
+    }
+
+    const isUpToDate = currentVersion === latestVersion
+    const info: VersionInfo = {
+      currentVersion,
+      latestVersion,
+      isUpToDate,
+      isLocalDev: false,
+      isPinned: false,
+      pinnedVersion: null,
+      status: isUpToDate ? "up-to-date" : "outdated",
+    }
+
+    console.log(options.json ? formatJsonOutput(info) : formatVersionOutput(info))
+    return 0
+
+  } catch (error) {
+    const info: VersionInfo = {
+      currentVersion: null,
+      latestVersion: null,
+      isUpToDate: false,
+      isLocalDev: false,
+      isPinned: false,
+      pinnedVersion: null,
+      status: "error",
+    }
+    
+    console.log(options.json ? formatJsonOutput(info) : formatVersionOutput(info))
+    return 1
+  }
+}
+
+export * from "./types"

src/cli/get-local-version/types.ts

@@ -0,0 +1,14 @@
+export interface VersionInfo {
+  currentVersion: string | null
+  latestVersion: string | null
+  isUpToDate: boolean
+  isLocalDev: boolean
+  isPinned: boolean
+  pinnedVersion: string | null
+  status: "up-to-date" | "outdated" | "local-dev" | "pinned" | "error" | "unknown"
+}
+
+export interface GetLocalVersionOptions {
+  directory?: string
+  json?: boolean
+}

src/cli/index.ts

@@ -1,7 +1,11 @@
 #!/usr/bin/env bun
 import { Command } from "commander"
 import { install } from "./install"
+import { run } from "./run"
+import { getLocalVersion } from "./get-local-version"
 import type { InstallArgs } from "./types"
+import type { RunOptions } from "./run"
+import type { GetLocalVersionOptions } from "./get-local-version/types"
 
 const packageJson = await import("../../package.json")
 const VERSION = packageJson.version
@@ -44,6 +48,59 @@ Model Providers:
     process.exit(exitCode)
   })
 
+program
+  .command("run <message>")
+  .description("Run opencode with todo/background task completion enforcement")
+  .option("-a, --agent <name>", "Agent to use (default: Sisyphus)")
+  .option("-d, --directory <path>", "Working directory")
+  .option("-t, --timeout <ms>", "Timeout in milliseconds (default: 30 minutes)", parseInt)
+  .addHelpText("after", `
+Examples:
+  $ bunx oh-my-opencode run "Fix the bug in index.ts"
+  $ bunx oh-my-opencode run --agent Sisyphus "Implement feature X"
+  $ bunx oh-my-opencode run --timeout 3600000 "Large refactoring task"
+
+Unlike 'opencode run', this command waits until:
+  - All todos are completed or cancelled
+  - All child sessions (background tasks) are idle
+`)
+  .action(async (message: string, options) => {
+    const runOptions: RunOptions = {
+      message,
+      agent: options.agent,
+      directory: options.directory,
+      timeout: options.timeout,
+    }
+    const exitCode = await run(runOptions)
+    process.exit(exitCode)
+  })
+
+program
+  .command("get-local-version")
+  .description("Show current installed version and check for updates")
+  .option("-d, --directory <path>", "Working directory to check config from")
+  .option("--json", "Output in JSON format for scripting")
+  .addHelpText("after", `
+Examples:
+  $ bunx oh-my-opencode get-local-version
+  $ bunx oh-my-opencode get-local-version --json
+  $ bunx oh-my-opencode get-local-version --directory /path/to/project
+
+This command shows:
+  - Current installed version
+  - Latest available version on npm
+  - Whether you're up to date
+  - Special modes (local dev, pinned version)
+`)
+  .action(async (options) => {
+    const versionOptions: GetLocalVersionOptions = {
+      directory: options.directory,
+      json: options.json ?? false,
+    }
+    const exitCode = await getLocalVersion(versionOptions)
+    process.exit(exitCode)
+  })
+
 program
   .command("version")
   .description("Show version information")

src/cli/run/completion.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect, mock, spyOn } from "bun:test"
+import type { RunContext, Todo, ChildSession, SessionStatus } from "./types"
+
+const createMockContext = (overrides: {
+  todo?: Todo[]
+  childrenBySession?: Record<string, ChildSession[]>
+  statuses?: Record<string, SessionStatus>
+} = {}): RunContext => {
+  const {
+    todo = [],
+    childrenBySession = { "test-session": [] },
+    statuses = {},
+  } = overrides
+
+  return {
+    client: {
+      session: {
+        todo: mock(() => Promise.resolve({ data: todo })),
+        children: mock((opts: { path: { id: string } }) =>
+          Promise.resolve({ data: childrenBySession[opts.path.id] ?? [] })
+        ),
+        status: mock(() => Promise.resolve({ data: statuses })),
+      },
+    } as unknown as RunContext["client"],
+    sessionID: "test-session",
+    directory: "/test",
+    abortController: new AbortController(),
+  }
+}
+
+describe("checkCompletionConditions", () => {
+  it("returns true when no todos and no children", async () => {
+    // #given
+    spyOn(console, "log").mockImplementation(() => {})
+    const ctx = createMockContext()
+    const { checkCompletionConditions } = await import("./completion")
+
+    // #when
+    const result = await checkCompletionConditions(ctx)
+
+    // #then
+    expect(result).toBe(true)
+  })
+
+  it("returns false when incomplete todos exist", async () => {
+    // #given
+    spyOn(console, "log").mockImplementation(() => {})
+    const ctx = createMockContext({
+      todo: [
+        { id: "1", content: "Done", status: "completed", priority: "high" },
+        { id: "2", content: "WIP", status: "in_progress", priority: "high" },
+      ],
+    })
+    const { checkCompletionConditions } = await import("./completion")
+
+    // #when
+    const result = await checkCompletionConditions(ctx)
+
+    // #then
+    expect(result).toBe(false)
+  })
+
+  it("returns true when all todos completed or cancelled", async () => {
+    // #given
+    spyOn(console, "log").mockImplementation(() => {})
+    const ctx = createMockContext({
+      todo: [
+        { id: "1", content: "Done", status: "completed", priority: "high" },
+        { id: "2", content: "Skip", status: "cancelled", priority: "medium" },
+      ],
+    })
+    const { checkCompletionConditions } = await import("./completion")
+
+    // #when
+    const result = await checkCompletionConditions(ctx)
+
+    // #then
+    expect(result).toBe(true)
+  })
+
+  it("returns false when child session is busy", async () => {
+    // #given
+    spyOn(console, "log").mockImplementation(() => {})
+    const ctx = createMockContext({
+      childrenBySession: {
+        "test-session": [{ id: "child-1" }],
+        "child-1": [],
+      },
+      statuses: { "child-1": { type: "busy" } },
+    })
+    const { checkCompletionConditions } = await import("./completion")
+
+    // #when
+    const result = await checkCompletionConditions(ctx)
+
+    // #then
+    expect(result).toBe(false)
+  })
+
+  it("returns true when all children idle", async () => {
+    // #given
+    spyOn(console, "log").mockImplementation(() => {})
+    const ctx = createMockContext({
+      childrenBySession: {
+        "test-session": [{ id: "child-1" }, { id: "child-2" }],
+        "child-1": [],
+        "child-2": [],
+      },
+      statuses: {
+        "child-1": { type: "idle" },
+        "child-2": { type: "idle" },
+      },
+    })
+    const { checkCompletionConditions } = await import("./completion")
+
+    // #when
+    const result = await checkCompletionConditions(ctx)
+
+    // #then
+    expect(result).toBe(true)
+  })
+
+  it("returns false when grandchild is busy (recursive)", async () => {
+    // #given
+    spyOn(console, "log").mockImplementation(() => {})
+    const ctx = createMockContext({
+      childrenBySession: {
+        "test-session": [{ id: "child-1" }],
+        "child-1": [{ id: "grandchild-1" }],
+        "grandchild-1": [],
+      },
+      statuses: {
+        "child-1": { type: "idle" },
+        "grandchild-1": { type: "busy" },
+      },
+    })
+    const { checkCompletionConditions } = await import("./completion")
+
+    // #when
+    const result = await checkCompletionConditions(ctx)
+
+    // #then
+    expect(result).toBe(false)
+  })
+
+  it("returns true when all descendants idle (recursive)", async () => {
+    // #given
+    spyOn(console, "log").mockImplementation(() => {})
+    const ctx = createMockContext({
+      childrenBySession: {
+        "test-session": [{ id: "child-1" }],
+        "child-1": [{ id: "grandchild-1" }],
+        "grandchild-1": [{ id: "great-grandchild-1" }],
+        "great-grandchild-1": [],
+      },
+      statuses: {
+        "child-1": { type: "idle" },
+        "grandchild-1": { type: "idle" },
+        "great-grandchild-1": { type: "idle" },
+      },
+    })
+    const { checkCompletionConditions } = await import("./completion")
+
+    // #when
+    const result = await checkCompletionConditions(ctx)
+
+    // #then
+    expect(result).toBe(true)
+  })
+})

src/cli/run/completion.ts

@@ -0,0 +1,79 @@
+import pc from "picocolors"
+import type { RunContext, Todo, ChildSession, SessionStatus } from "./types"
+
+export async function checkCompletionConditions(ctx: RunContext): Promise<boolean> {
+  try {
+    if (!await areAllTodosComplete(ctx)) {
+      return false
+    }
+
+    if (!await areAllChildrenIdle(ctx)) {
+      return false
+    }
+
+    return true
+  } catch (err) {
+    console.error(pc.red(`[completion] API error: ${err}`))
+    return false
+  }
+}
+
+async function areAllTodosComplete(ctx: RunContext): Promise<boolean> {
+  const todosRes = await ctx.client.session.todo({ path: { id: ctx.sessionID } })
+  const todos = (todosRes.data ?? []) as Todo[]
+
+  const incompleteTodos = todos.filter(
+    (t) => t.status !== "completed" && t.status !== "cancelled"
+  )
+
+  if (incompleteTodos.length > 0) {
+    console.log(pc.dim(`  Waiting: ${incompleteTodos.length} todos remaining`))
+    return false
+  }
+
+  return true
+}
+
+async function areAllChildrenIdle(ctx: RunContext): Promise<boolean> {
+  const allStatuses = await fetchAllStatuses(ctx)
+  return areAllDescendantsIdle(ctx, ctx.sessionID, allStatuses)
+}
+
+async function fetchAllStatuses(
+  ctx: RunContext
+): Promise<Record<string, SessionStatus>> {
+  const statusRes = await ctx.client.session.status()
+  return (statusRes.data ?? {}) as Record<string, SessionStatus>
+}
+
+async function areAllDescendantsIdle(
+  ctx: RunContext,
+  sessionID: string,
+  allStatuses: Record<string, SessionStatus>
+): Promise<boolean> {
+  const childrenRes = await ctx.client.session.children({
+    path: { id: sessionID },
+  })
+  const children = (childrenRes.data ?? []) as ChildSession[]
+
+  for (const child of children) {
+    const status = allStatuses[child.id]
+    if (status && status.type !== "idle") {
+      console.log(
+        pc.dim(`  Waiting: session ${child.id.slice(0, 8)}... is ${status.type}`)
+      )
+      return false
+    }
+
+    const descendantsIdle = await areAllDescendantsIdle(
+      ctx,
+      child.id,
+      allStatuses
+    )
+    if (!descendantsIdle) {
+      return false
+    }
+  }
+
+  return true
+}

src/cli/run/events.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from "bun:test"
+import { createEventState, type EventState } from "./events"
+import type { RunContext, EventPayload } from "./types"
+
+const createMockContext = (sessionID: string = "test-session"): RunContext => ({
+  client: {} as RunContext["client"],
+  sessionID,
+  directory: "/test",
+  abortController: new AbortController(),
+})
+
+async function* toAsyncIterable<T>(items: T[]): AsyncIterable<T> {
+  for (const item of items) {
+    yield item
+  }
+}
+
+describe("createEventState", () => {
+  it("creates initial state with correct defaults", () => {
+    // #given / #when
+    const state = createEventState()
+
+    // #then
+    expect(state.mainSessionIdle).toBe(false)
+    expect(state.lastOutput).toBe("")
+    expect(state.lastPartText).toBe("")
+    expect(state.currentTool).toBe(null)
+  })
+})
+
+describe("event handling", () => {
+  it("session.idle sets mainSessionIdle to true for matching session", async () => {
+    // #given
+    const ctx = createMockContext("my-session")
+    const state = createEventState()
+
+    const payload: EventPayload = {
+      type: "session.idle",
+      properties: { sessionID: "my-session" },
+    }
+
+    const events = toAsyncIterable([payload])
+    const { processEvents } = await import("./events")
+
+    // #when
+    await processEvents(ctx, events, state)
+
+    // #then
+    expect(state.mainSessionIdle).toBe(true)
+  })
+
+  it("session.idle does not affect state for different session", async () => {
+    // #given
+    const ctx = createMockContext("my-session")
+    const state = createEventState()
+
+    const payload: EventPayload = {
+      type: "session.idle",
+      properties: { sessionID: "other-session" },
+    }
+
+    const events = toAsyncIterable([payload])
+    const { processEvents } = await import("./events")
+
+    // #when
+    await processEvents(ctx, events, state)
+
+    // #then
+    expect(state.mainSessionIdle).toBe(false)
+  })
+
+  it("session.status with busy type sets mainSessionIdle to false", async () => {
+    // #given
+    const ctx = createMockContext("my-session")
+    const state: EventState = {
+      mainSessionIdle: true,
+      mainSessionError: false,
+      lastError: null,
+      lastOutput: "",
+      lastPartText: "",
+      currentTool: null,
+    }
+
+    const payload: EventPayload = {
+      type: "session.status",
+      properties: { sessionID: "my-session", status: { type: "busy" } },
+    }
+
+    const events = toAsyncIterable([payload])
+    const { processEvents } = await import("./events")
+
+    // #when
+    await processEvents(ctx, events, state)
+
+    // #then
+    expect(state.mainSessionIdle).toBe(false)
+  })
+})

src/cli/run/events.ts

@@ -0,0 +1,279 @@
+import pc from "picocolors"
+import type {
+  RunContext,
+  EventPayload,
+  SessionIdleProps,
+  SessionStatusProps,
+  SessionErrorProps,
+  MessageUpdatedProps,
+  MessagePartUpdatedProps,
+  ToolExecuteProps,
+  ToolResultProps,
+} from "./types"
+
+export interface EventState {
+  mainSessionIdle: boolean
+  mainSessionError: boolean
+  lastError: string | null
+  lastOutput: string
+  lastPartText: string
+  currentTool: string | null
+}
+
+export function createEventState(): EventState {
+  return {
+    mainSessionIdle: false,
+    mainSessionError: false,
+    lastError: null,
+    lastOutput: "",
+    lastPartText: "",
+    currentTool: null,
+  }
+}
+
+export async function processEvents(
+  ctx: RunContext,
+  stream: AsyncIterable<unknown>,
+  state: EventState
+): Promise<void> {
+  for await (const event of stream) {
+    if (ctx.abortController.signal.aborted) break
+
+    try {
+      const payload = event as EventPayload
+      if (!payload?.type) {
+        console.error(pc.dim(`[event] no type: ${JSON.stringify(event)}`))
+        continue
+      }
+
+      logEventVerbose(ctx, payload)
+
+      handleSessionError(ctx, payload, state)
+      handleSessionIdle(ctx, payload, state)
+      handleSessionStatus(ctx, payload, state)
+      handleMessagePartUpdated(ctx, payload, state)
+      handleMessageUpdated(ctx, payload, state)
+      handleToolExecute(ctx, payload, state)
+      handleToolResult(ctx, payload, state)
+    } catch (err) {
+      console.error(pc.red(`[event error] ${err}`))
+    }
+  }
+}
+
+function logEventVerbose(ctx: RunContext, payload: EventPayload): void {
+  const props = payload.properties as Record<string, unknown> | undefined
+  const info = props?.info as Record<string, unknown> | undefined
+  const sessionID = props?.sessionID ?? info?.sessionID
+  const isMainSession = sessionID === ctx.sessionID
+  const sessionTag = isMainSession
+    ? pc.green("[MAIN]")
+    : pc.yellow(`[${String(sessionID).slice(0, 8)}]`)
+
+  switch (payload.type) {
+    case "session.idle":
+    case "session.status": {
+      const status = (props?.status as { type?: string })?.type ?? "idle"
+      console.error(pc.dim(`${sessionTag} ${payload.type}: ${status}`))
+      break
+    }
+
+    case "message.part.updated": {
+      const partProps = props as MessagePartUpdatedProps | undefined
+      const role = partProps?.info?.role ?? "unknown"
+      const part = partProps?.part
+      if (part?.type === "text" && part.text) {
+        const preview = part.text.slice(0, 100).replace(/\n/g, "\\n")
+        console.error(
+          pc.dim(`${sessionTag} message.part (${role}): "${preview}${part.text.length > 100 ? "..." : ""}"`)
+        )
+      } else if (part?.type === "tool-invocation") {
+        const toolPart = part as { toolName?: string; state?: string }
+        console.error(
+          pc.dim(`${sessionTag} message.part (tool): ${toolPart.toolName} [${toolPart.state}]`)
+        )
+      }
+      break
+    }
+
+    case "message.updated": {
+      const msgProps = props as MessageUpdatedProps | undefined
+      const role = msgProps?.info?.role ?? "unknown"
+      const content = msgProps?.content ?? ""
+      const preview = content.slice(0, 100).replace(/\n/g, "\\n")
+      console.error(
+        pc.dim(`${sessionTag} message.updated (${role}): "${preview}${content.length > 100 ? "..." : ""}"`)
+      )
+      break
+    }
+
+    case "tool.execute": {
+      const toolProps = props as ToolExecuteProps | undefined
+      const toolName = toolProps?.name ?? "unknown"
+      const input = toolProps?.input ?? {}
+      const inputStr = JSON.stringify(input).slice(0, 150)
+      console.error(
+        pc.cyan(`${sessionTag} ⚡ TOOL.EXECUTE: ${pc.bold(toolName)}`)
+      )
+      console.error(pc.dim(`   input: ${inputStr}${inputStr.length >= 150 ? "..." : ""}`))
+      break
+    }
+
+    case "tool.result": {
+      const resultProps = props as ToolResultProps | undefined
+      const output = resultProps?.output ?? ""
+      const preview = output.slice(0, 200).replace(/\n/g, "\\n")
+      console.error(
+        pc.green(`${sessionTag} ✓ TOOL.RESULT: "${preview}${output.length > 200 ? "..." : ""}"`)
+      )
+      break
+    }
+
+    default:
+      console.error(pc.dim(`${sessionTag} ${payload.type}`))
+  }
+}
+
+function handleSessionIdle(
+  ctx: RunContext,
+  payload: EventPayload,
+  state: EventState
+): void {
+  if (payload.type !== "session.idle") return
+
+  const props = payload.properties as SessionIdleProps | undefined
+  if (props?.sessionID === ctx.sessionID) {
+    state.mainSessionIdle = true
+  }
+}
+
+function handleSessionStatus(
+  ctx: RunContext,
+  payload: EventPayload,
+  state: EventState
+): void {
+  if (payload.type !== "session.status") return
+
+  const props = payload.properties as SessionStatusProps | undefined
+  if (props?.sessionID === ctx.sessionID && props?.status?.type === "busy") {
+    state.mainSessionIdle = false
+  }
+}
+
+function handleSessionError(
+  ctx: RunContext,
+  payload: EventPayload,
+  state: EventState
+): void {
+  if (payload.type !== "session.error") return
+
+  const props = payload.properties as SessionErrorProps | undefined
+  if (props?.sessionID === ctx.sessionID) {
+    state.mainSessionError = true
+    state.lastError = props?.error
+      ? String(props.error instanceof Error ? props.error.message : props.error)
+      : "Unknown error"
+    console.error(pc.red(`\n[session.error] ${state.lastError}`))
+  }
+}
+
+function handleMessagePartUpdated(
+  ctx: RunContext,
+  payload: EventPayload,
+  state: EventState
+): void {
+  if (payload.type !== "message.part.updated") return
+
+  const props = payload.properties as MessagePartUpdatedProps | undefined
+  if (props?.info?.sessionID !== ctx.sessionID) return
+  if (props?.info?.role !== "assistant") return
+
+  const part = props.part
+  if (!part) return
+
+  if (part.type === "text" && part.text) {
+    const newText = part.text.slice(state.lastPartText.length)
+    if (newText) {
+      process.stdout.write(newText)
+    }
+    state.lastPartText = part.text
+  }
+}
+
+function handleMessageUpdated(
+  ctx: RunContext,
+  payload: EventPayload,
+  state: EventState
+): void {
+  if (payload.type !== "message.updated") return
+
+  const props = payload.properties as MessageUpdatedProps | undefined
+  if (props?.info?.sessionID !== ctx.sessionID) return
+  if (props?.info?.role !== "assistant") return
+
+  const content = props.content
+  if (!content || content === state.lastOutput) return
+
+  if (state.lastPartText.length === 0) {
+    const newContent = content.slice(state.lastOutput.length)
+    if (newContent) {
+      process.stdout.write(newContent)
+    }
+  }
+  state.lastOutput = content
+}
+
+function handleToolExecute(
+  ctx: RunContext,
+  payload: EventPayload,
+  state: EventState
+): void {
+  if (payload.type !== "tool.execute") return
+
+  const props = payload.properties as ToolExecuteProps | undefined
+  if (props?.sessionID !== ctx.sessionID) return
+
+  const toolName = props?.name || "unknown"
+  state.currentTool = toolName
+
+  let inputPreview = ""
+  if (props?.input) {
+    const input = props.input
+    if (input.command) {
+      inputPreview = ` ${pc.dim(String(input.command).slice(0, 60))}`
+    } else if (input.pattern) {
+      inputPreview = ` ${pc.dim(String(input.pattern).slice(0, 40))}`
+    } else if (input.filePath) {
+      inputPreview = ` ${pc.dim(String(input.filePath))}`
+    } else if (input.query) {
+      inputPreview = ` ${pc.dim(String(input.query).slice(0, 40))}`
+    }
+  }
+
+  process.stdout.write(`\n${pc.cyan("⚡")} ${pc.bold(toolName)}${inputPreview}\n`)
+}
+
+function handleToolResult(
+  ctx: RunContext,
+  payload: EventPayload,
+  state: EventState
+): void {
+  if (payload.type !== "tool.result") return
+
+  const props = payload.properties as ToolResultProps | undefined
+  if (props?.sessionID !== ctx.sessionID) return
+
+  const output = props?.output || ""
+  const maxLen = 200
+  const preview = output.length > maxLen 
+    ? output.slice(0, maxLen) + "..." 
+    : output
+  
+  if (preview.trim()) {
+    const lines = preview.split("\n").slice(0, 3)
+    process.stdout.write(pc.dim(`   └─ ${lines.join("\n      ")}\n`))
+  }
+
+  state.currentTool = null
+  state.lastPartText = ""
+}

src/cli/run/index.ts

@@ -0,0 +1,2 @@
+export { run } from "./runner"
+export type { RunOptions, RunContext } from "./types"

src/cli/run/runner.ts

@@ -0,0 +1,121 @@
+import { createOpencode } from "@opencode-ai/sdk"
+import pc from "picocolors"
+import type { RunOptions, RunContext } from "./types"
+import { checkCompletionConditions } from "./completion"
+import { createEventState, processEvents } from "./events"
+
+const POLL_INTERVAL_MS = 500
+const DEFAULT_TIMEOUT_MS = 0
+
+export async function run(options: RunOptions): Promise<number> {
+  const {
+    message,
+    agent,
+    directory = process.cwd(),
+    timeout = DEFAULT_TIMEOUT_MS,
+  } = options
+
+  console.log(pc.cyan("Starting opencode server..."))
+
+  const abortController = new AbortController()
+  let timeoutId: ReturnType<typeof setTimeout> | null = null
+
+  // timeout=0 means no timeout (run until completion)
+  if (timeout > 0) {
+    timeoutId = setTimeout(() => {
+      console.log(pc.yellow("\nTimeout reached. Aborting..."))
+      abortController.abort()
+    }, timeout)
+  }
+
+  try {
+    const { client, server } = await createOpencode({
+      signal: abortController.signal,
+    })
+
+    const cleanup = () => {
+      if (timeoutId) clearTimeout(timeoutId)
+      server.close()
+    }
+
+    process.on("SIGINT", () => {
+      console.log(pc.yellow("\nInterrupted. Shutting down..."))
+      cleanup()
+      process.exit(130)
+    })
+
+    try {
+      const sessionRes = await client.session.create({
+        body: { title: "oh-my-opencode run" },
+      })
+
+      const sessionID = sessionRes.data?.id
+      if (!sessionID) {
+        console.error(pc.red("Failed to create session"))
+        return 1
+      }
+
+      console.log(pc.dim(`Session: ${sessionID}`))
+
+      const ctx: RunContext = {
+        client,
+        sessionID,
+        directory,
+        abortController,
+      }
+
+      const events = await client.event.subscribe()
+      const eventState = createEventState()
+      const eventProcessor = processEvents(ctx, events.stream, eventState)
+
+      console.log(pc.dim("\nSending prompt..."))
+      await client.session.promptAsync({
+        path: { id: sessionID },
+        body: {
+          agent,
+          parts: [{ type: "text", text: message }],
+        },
+        query: { directory },
+      })
+
+      console.log(pc.dim("Waiting for completion...\n"))
+
+      while (!abortController.signal.aborted) {
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
+
+        if (!eventState.mainSessionIdle) {
+          continue
+        }
+
+        // Check if session errored - exit with failure if so
+        if (eventState.mainSessionError) {
+          console.error(pc.red(`\n\nSession ended with error: ${eventState.lastError}`))
+          console.error(pc.yellow("Check if todos were completed before the error."))
+          cleanup()
+          process.exit(1)
+        }
+
+        const shouldExit = await checkCompletionConditions(ctx)
+        if (shouldExit) {
+          console.log(pc.green("\n\nAll tasks completed."))
+          cleanup()
+          process.exit(0)
+        }
+      }
+
+      await eventProcessor.catch(() => {})
+      cleanup()
+      return 130
+    } catch (err) {
+      cleanup()
+      throw err
+    }
+  } catch (err) {
+    if (timeoutId) clearTimeout(timeoutId)
+    if (err instanceof Error && err.name === "AbortError") {
+      return 130
+    }
+    console.error(pc.red(`Error: ${err}`))
+    return 1
+  }
+}

src/cli/run/types.ts

@@ -0,0 +1,76 @@
+import type { OpencodeClient } from "@opencode-ai/sdk"
+
+export interface RunOptions {
+  message: string
+  agent?: string
+  directory?: string
+  timeout?: number
+}
+
+export interface RunContext {
+  client: OpencodeClient
+  sessionID: string
+  directory: string
+  abortController: AbortController
+}
+
+export interface Todo {
+  id: string
+  content: string
+  status: string
+  priority: string
+}
+
+export interface SessionStatus {
+  type: "idle" | "busy" | "retry"
+}
+
+export interface ChildSession {
+  id: string
+}
+
+export interface EventPayload {
+  type: string
+  properties?: Record<string, unknown>
+}
+
+export interface SessionIdleProps {
+  sessionID?: string
+}
+
+export interface SessionStatusProps {
+  sessionID?: string
+  status?: { type?: string }
+}
+
+export interface MessageUpdatedProps {
+  info?: { sessionID?: string; role?: string }
+  content?: string
+}
+
+export interface MessagePartUpdatedProps {
+  info?: { sessionID?: string; role?: string }
+  part?: {
+    type?: string
+    text?: string
+    name?: string
+    input?: unknown
+  }
+}
+
+export interface ToolExecuteProps {
+  sessionID?: string
+  name?: string
+  input?: Record<string, unknown>
+}
+
+export interface ToolResultProps {
+  sessionID?: string
+  name?: string
+  output?: string
+}
+
+export interface SessionErrorProps {
+  sessionID?: string
+  error?: unknown
+}

src/config/index.ts

@@ -5,6 +5,7 @@ export {
   McpNameSchema,
   AgentNameSchema,
   HookNameSchema,
+  BuiltinCommandNameSchema,
   SisyphusAgentConfigSchema,
   ExperimentalConfigSchema,
 } from "./schema"
@@ -16,6 +17,8 @@ export type {
   McpName,
   AgentName,
   HookName,
+  BuiltinCommandName,
   SisyphusAgentConfig,
   ExperimentalConfig,
+  DynamicContextPruningConfig,
 } from "./schema"

src/config/schema.ts

@@ -30,6 +30,7 @@ export const OverridableAgentNameSchema = z.enum([
   "build",
   "plan",
   "Sisyphus",
+  "OpenCode-Builder",
   "Planner-Sisyphus",
   "oracle",
   "librarian",
@@ -63,6 +64,11 @@ export const HookNameSchema = z.enum([
   "non-interactive-env",
   "interactive-bash-session",
   "empty-message-sanitizer",
+  "thinking-block-validator",
+])
+
+export const BuiltinCommandNameSchema = z.enum([
+  "init-deep",
 ])
 
 export const AgentOverrideConfigSchema = z.object({
@@ -86,6 +92,7 @@ export const AgentOverridesSchema = z.object({
   build: AgentOverrideConfigSchema.optional(),
   plan: AgentOverrideConfigSchema.optional(),
   Sisyphus: AgentOverrideConfigSchema.optional(),
+  "OpenCode-Builder": AgentOverrideConfigSchema.optional(),
   "Planner-Sisyphus": AgentOverrideConfigSchema.optional(),
   oracle: AgentOverrideConfigSchema.optional(),
   librarian: AgentOverrideConfigSchema.optional(),
@@ -101,10 +108,56 @@ export const ClaudeCodeConfigSchema = z.object({
   skills: z.boolean().optional(),
   agents: z.boolean().optional(),
   hooks: z.boolean().optional(),
+  plugins: z.boolean().optional(),
+  plugins_override: z.record(z.string(), z.boolean()).optional(),
 })
 
 export const SisyphusAgentConfigSchema = z.object({
   disabled: z.boolean().optional(),
+  default_builder_enabled: z.boolean().optional(),
+  planner_enabled: z.boolean().optional(),
+  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),
+  /** Notification level: off, minimal, or detailed (default: detailed) */
+  notification: z.enum(["off", "minimal", "detailed"]).default("detailed"),
+  /** Turn protection - prevent pruning recent tool outputs */
+  turn_protection: z.object({
+    enabled: z.boolean().default(true),
+    turns: z.number().min(1).max(10).default(3),
+  }).optional(),
+  /** Tools that should never be pruned */
+  protected_tools: z.array(z.string()).default([
+    "task", "todowrite", "todoread",
+    "lsp_rename", "lsp_code_action_resolve",
+    "session_read", "session_write", "session_search",
+  ]),
+  /** Pruning strategies configuration */
+  strategies: z.object({
+    /** Remove duplicate tool calls (same tool + same args) */
+    deduplication: z.object({
+      enabled: z.boolean().default(true),
+    }).optional(),
+    /** Prune write inputs when file subsequently read */
+    supersede_writes: z.object({
+      enabled: z.boolean().default(true),
+      /** Aggressive mode: prune any write if ANY subsequent read */
+      aggressive: z.boolean().default(false),
+    }).optional(),
+    /** Prune errored tool inputs after N turns */
+    purge_errors: z.object({
+      enabled: z.boolean().default(true),
+      turns: z.number().min(1).max(20).default(5),
+    }).optional(),
+  }).optional(),
 })
 
 export const ExperimentalConfigSchema = z.object({
@@ -114,8 +167,12 @@ export const ExperimentalConfigSchema = z.object({
   preemptive_compaction: z.boolean().optional(),
   /** Threshold percentage to trigger preemptive compaction (default: 0.80) */
   preemptive_compaction_threshold: z.number().min(0.5).max(0.95).optional(),
-  /** Truncate all tool outputs, not just whitelisted tools (default: false) */
-  truncate_all_tool_outputs: z.boolean().optional(),
+  /** Truncate all tool outputs, not just whitelisted tools (default: true) */
+  truncate_all_tool_outputs: z.boolean().default(true),
+  /** Dynamic context pruning configuration */
+  dynamic_context_pruning: DynamicContextPruningConfigSchema.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({
@@ -123,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(),
 })
@@ -136,7 +195,10 @@ 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>
 
 export { McpNameSchema, type McpName } from "../mcp/types"

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

src/features/background-agent/manager.ts

@@ -57,7 +57,7 @@ export class BackgroundManager {
   private notifications: Map<string, BackgroundTask[]>
   private client: OpencodeClient
   private directory: string
-  private pollingInterval?: Timer
+  private pollingInterval?: ReturnType<typeof setInterval>
 
   constructor(ctx: PluginInput) {
     this.tasks = new Map()
@@ -99,6 +99,7 @@ export class BackgroundManager {
         toolCalls: 0,
         lastUpdate: new Date(),
       },
+      parentModel: input.parentModel,
     }
 
     this.tasks.set(task.id, task)
@@ -286,6 +287,7 @@ export class BackgroundManager {
     this.pollingInterval = setInterval(() => {
       this.pollRunningTasks()
     }, 2000)
+    this.pollingInterval.unref()
   }
 
   private stopPolling(): void {
@@ -295,6 +297,12 @@ export class BackgroundManager {
     }
   }
 
+  cleanup(): void {
+    this.stopPolling()
+    this.tasks.clear()
+    this.notifications.clear()
+  }
+
   private notifyParentSession(task: BackgroundTask): void {
     const duration = this.formatDuration(task.startedAt, task.completedAt)
 
@@ -317,23 +325,33 @@ 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)
         const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
 
+        const modelContext = task.parentModel ?? prevMessage?.model
+        const modelField = modelContext?.providerID && modelContext?.modelID
+          ? { providerID: modelContext.providerID, modelID: modelContext.modelID }
+          : undefined
+
         await this.client.session.prompt({
           path: { id: task.parentSessionID },
           body: {
             agent: prevMessage?.agent,
+            model: modelField,
             parts: [{ type: "text", text: message }],
           },
           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)
   }

src/features/background-agent/types.ts

@@ -26,6 +26,7 @@ export interface BackgroundTask {
   result?: string
   error?: string
   progress?: TaskProgress
+  parentModel?: { providerID: string; modelID: string }
 }
 
 export interface LaunchInput {
@@ -34,4 +35,5 @@ export interface LaunchInput {
   agent: string
   parentSessionID: string
   parentMessageID: string
+  parentModel?: { providerID: string; modelID: string }
 }

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
+}

src/features/builtin-commands/index.ts

@@ -0,0 +1,2 @@
+export * from "./types"
+export * from "./commands"

src/features/builtin-commands/templates/init-deep.ts

@@ -0,0 +1,299 @@
+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
+
+---
+
+## 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")
+\`\`\`
+
+</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 |
+|--------|--------|-----------|
+| File count | 3x | >20 files = high |
+| Subdirectory count | 2x | >5 subdirs = high |
+| Code file ratio | 2x | >70% code = high |
+| Unique patterns | 1x | Has own config |
+| Module boundary | 2x | Has __init__.py/index.ts |
+
+### 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} |
+
+## 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`

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>

src/features/claude-code-agent-loader/loader.ts

@@ -1,9 +1,9 @@
 import { existsSync, readdirSync, readFileSync } from "fs"
-import { homedir } from "os"
 import { join, basename } from "path"
 import type { AgentConfig } from "@opencode-ai/sdk"
 import { parseFrontmatter } from "../../shared/frontmatter"
 import { isMarkdownFile } from "../../shared/file-utils"
+import { getClaudeConfigDir } from "../../shared"
 import type { AgentScope, AgentFrontmatter, LoadedAgent } from "./types"
 
 function parseToolsConfig(toolsStr?: string): Record<string, boolean> | undefined {
@@ -68,7 +68,7 @@ function loadAgentsFromDir(agentsDir: string, scope: AgentScope): LoadedAgent[]
 }
 
 export function loadUserAgents(): Record<string, AgentConfig> {
-  const userAgentsDir = join(homedir(), ".claude", "agents")
+  const userAgentsDir = join(getClaudeConfigDir(), "agents")
   const agents = loadAgentsFromDir(userAgentsDir, "user")
 
   const result: Record<string, AgentConfig> = {}

src/features/claude-code-command-loader/loader.ts

@@ -1,9 +1,9 @@
 import { existsSync, readdirSync, readFileSync } from "fs"
-import { homedir } from "os"
 import { join, basename } from "path"
 import { parseFrontmatter } from "../../shared/frontmatter"
 import { sanitizeModelField } from "../../shared/model-sanitizer"
 import { isMarkdownFile } from "../../shared/file-utils"
+import { getClaudeConfigDir } from "../../shared"
 import type { CommandScope, CommandDefinition, CommandFrontmatter, LoadedCommand } from "./types"
 
 function loadCommandsFromDir(commandsDir: string, scope: CommandScope): LoadedCommand[] {
@@ -68,7 +68,7 @@ function commandsToRecord(commands: LoadedCommand[]): Record<string, CommandDefi
 }
 
 export function loadUserCommands(): Record<string, CommandDefinition> {
-  const userCommandsDir = join(homedir(), ".claude", "commands")
+  const userCommandsDir = join(getClaudeConfigDir(), "commands")
   const commands = loadCommandsFromDir(userCommandsDir, "user")
   return commandsToRecord(commands)
 }
@@ -80,6 +80,7 @@ export function loadProjectCommands(): Record<string, CommandDefinition> {
 }
 
 export function loadOpencodeGlobalCommands(): Record<string, CommandDefinition> {
+  const { homedir } = require("os")
   const opencodeCommandsDir = join(homedir(), ".config", "opencode", "command")
   const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode")
   return commandsToRecord(commands)

src/features/claude-code-mcp-loader/loader.ts

@@ -1,6 +1,6 @@
 import { existsSync } from "fs"
-import { homedir } from "os"
 import { join } from "path"
+import { getClaudeConfigDir } from "../../shared"
 import type {
   ClaudeCodeMcpConfig,
   LoadedMcpServer,
@@ -16,11 +16,11 @@ interface McpConfigPath {
 }
 
 function getMcpConfigPaths(): McpConfigPath[] {
-  const home = homedir()
+  const claudeConfigDir = getClaudeConfigDir()
   const cwd = process.cwd()
 
   return [
-    { path: join(home, ".claude", ".mcp.json"), scope: "user" },
+    { path: join(claudeConfigDir, ".mcp.json"), scope: "user" },
     { path: join(cwd, ".mcp.json"), scope: "project" },
     { path: join(cwd, ".claude", ".mcp.json"), scope: "local" },
   ]

src/features/claude-code-plugin-loader/index.ts

@@ -0,0 +1,3 @@
+export * from "./types"
+export * from "./loader"
+export type { PluginLoaderOptions, ClaudeSettings } from "./types"

src/features/claude-code-plugin-loader/loader.ts

@@ -0,0 +1,480 @@
+import { existsSync, readdirSync, readFileSync } from "fs"
+import { homedir } from "os"
+import { join, basename } from "path"
+import type { AgentConfig } from "@opencode-ai/sdk"
+import { parseFrontmatter } from "../../shared/frontmatter"
+import { sanitizeModelField } from "../../shared/model-sanitizer"
+import { isMarkdownFile, resolveSymlink } from "../../shared/file-utils"
+import { log } from "../../shared/logger"
+import { expandEnvVarsInObject } from "../claude-code-mcp-loader/env-expander"
+import { transformMcpServer } from "../claude-code-mcp-loader/transformer"
+import type { CommandDefinition, CommandFrontmatter } from "../claude-code-command-loader/types"
+import type { SkillMetadata } from "../claude-code-skill-loader/types"
+import type { AgentFrontmatter } from "../claude-code-agent-loader/types"
+import type { ClaudeCodeMcpConfig, McpServerConfig } from "../claude-code-mcp-loader/types"
+import type {
+  InstalledPluginsDatabase,
+  PluginInstallation,
+  PluginManifest,
+  LoadedPlugin,
+  PluginLoadResult,
+  PluginLoadError,
+  PluginScope,
+  HooksConfig,
+  ClaudeSettings,
+  PluginLoaderOptions,
+} from "./types"
+
+const CLAUDE_PLUGIN_ROOT_VAR = "${CLAUDE_PLUGIN_ROOT}"
+
+function getPluginsBaseDir(): string {
+  // Allow override for testing
+  if (process.env.CLAUDE_PLUGINS_HOME) {
+    return process.env.CLAUDE_PLUGINS_HOME
+  }
+  return join(homedir(), ".claude", "plugins")
+}
+
+function getInstalledPluginsPath(): string {
+  return join(getPluginsBaseDir(), "installed_plugins.json")
+}
+
+function resolvePluginPath(path: string, pluginRoot: string): string {
+  return path.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot)
+}
+
+function resolvePluginPaths<T>(obj: T, pluginRoot: string): T {
+  if (obj === null || obj === undefined) return obj
+  if (typeof obj === "string") {
+    return resolvePluginPath(obj, pluginRoot) as T
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => resolvePluginPaths(item, pluginRoot)) as T
+  }
+  if (typeof obj === "object") {
+    const result: Record<string, unknown> = {}
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = resolvePluginPaths(value, pluginRoot)
+    }
+    return result as T
+  }
+  return obj
+}
+
+function loadInstalledPlugins(): InstalledPluginsDatabase | null {
+  const dbPath = getInstalledPluginsPath()
+  if (!existsSync(dbPath)) {
+    return null
+  }
+
+  try {
+    const content = readFileSync(dbPath, "utf-8")
+    return JSON.parse(content) as InstalledPluginsDatabase
+  } catch (error) {
+    log("Failed to load installed plugins database", error)
+    return null
+  }
+}
+
+function getClaudeSettingsPath(): string {
+  if (process.env.CLAUDE_SETTINGS_PATH) {
+    return process.env.CLAUDE_SETTINGS_PATH
+  }
+  return join(homedir(), ".claude", "settings.json")
+}
+
+function loadClaudeSettings(): ClaudeSettings | null {
+  const settingsPath = getClaudeSettingsPath()
+  if (!existsSync(settingsPath)) {
+    return null
+  }
+
+  try {
+    const content = readFileSync(settingsPath, "utf-8")
+    return JSON.parse(content) as ClaudeSettings
+  } catch (error) {
+    log("Failed to load Claude settings", error)
+    return null
+  }
+}
+
+function loadPluginManifest(installPath: string): PluginManifest | null {
+  const manifestPath = join(installPath, ".claude-plugin", "plugin.json")
+  if (!existsSync(manifestPath)) {
+    return null
+  }
+
+  try {
+    const content = readFileSync(manifestPath, "utf-8")
+    return JSON.parse(content) as PluginManifest
+  } catch (error) {
+    log(`Failed to load plugin manifest from ${manifestPath}`, error)
+    return null
+  }
+}
+
+function derivePluginNameFromKey(pluginKey: string): string {
+  const atIndex = pluginKey.indexOf("@")
+  if (atIndex > 0) {
+    return pluginKey.substring(0, atIndex)
+  }
+  return pluginKey
+}
+
+function isPluginEnabled(
+  pluginKey: string,
+  settingsEnabledPlugins: Record<string, boolean> | undefined,
+  overrideEnabledPlugins: Record<string, boolean> | undefined
+): boolean {
+  if (overrideEnabledPlugins && pluginKey in overrideEnabledPlugins) {
+    return overrideEnabledPlugins[pluginKey]
+  }
+  if (settingsEnabledPlugins && pluginKey in settingsEnabledPlugins) {
+    return settingsEnabledPlugins[pluginKey]
+  }
+  return true
+}
+
+function extractPluginEntries(
+  db: InstalledPluginsDatabase
+): Array<[string, PluginInstallation | undefined]> {
+  if (db.version === 1) {
+    return Object.entries(db.plugins).map(([key, installation]) => [key, installation])
+  }
+  return Object.entries(db.plugins).map(([key, installations]) => [key, installations[0]])
+}
+
+export function discoverInstalledPlugins(options?: PluginLoaderOptions): PluginLoadResult {
+  const db = loadInstalledPlugins()
+  const settings = loadClaudeSettings()
+  const plugins: LoadedPlugin[] = []
+  const errors: PluginLoadError[] = []
+
+  if (!db || !db.plugins) {
+    return { plugins, errors }
+  }
+
+  const settingsEnabledPlugins = settings?.enabledPlugins
+  const overrideEnabledPlugins = options?.enabledPluginsOverride
+
+  for (const [pluginKey, installation] of extractPluginEntries(db)) {
+    if (!installation) continue
+
+    if (!isPluginEnabled(pluginKey, settingsEnabledPlugins, overrideEnabledPlugins)) {
+      log(`Plugin disabled: ${pluginKey}`)
+      continue
+    }
+
+    const { installPath, scope, version } = installation
+
+    if (!existsSync(installPath)) {
+      errors.push({
+        pluginKey,
+        installPath,
+        error: "Plugin installation path does not exist",
+      })
+      continue
+    }
+
+    const manifest = loadPluginManifest(installPath)
+    const pluginName = manifest?.name || derivePluginNameFromKey(pluginKey)
+
+    const loadedPlugin: LoadedPlugin = {
+      name: pluginName,
+      version: version || manifest?.version || "unknown",
+      scope: scope as PluginScope,
+      installPath,
+      pluginKey,
+      manifest: manifest ?? undefined,
+    }
+
+    if (existsSync(join(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join(installPath, "commands")
+    }
+    if (existsSync(join(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join(installPath, "agents")
+    }
+    if (existsSync(join(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join(installPath, "skills")
+    }
+
+    const hooksPath = join(installPath, "hooks", "hooks.json")
+    if (existsSync(hooksPath)) {
+      loadedPlugin.hooksPath = hooksPath
+    }
+
+    const mcpPath = join(installPath, ".mcp.json")
+    if (existsSync(mcpPath)) {
+      loadedPlugin.mcpPath = mcpPath
+    }
+
+    plugins.push(loadedPlugin)
+    log(`Discovered plugin: ${pluginName}@${version} (${scope})`, { installPath, hasManifest: !!manifest })
+  }
+
+  return { plugins, errors }
+}
+
+export function loadPluginCommands(
+  plugins: LoadedPlugin[]
+): Record<string, CommandDefinition> {
+  const commands: Record<string, CommandDefinition> = {}
+
+  for (const plugin of plugins) {
+    if (!plugin.commandsDir || !existsSync(plugin.commandsDir)) continue
+
+    const entries = readdirSync(plugin.commandsDir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      if (!isMarkdownFile(entry)) continue
+
+      const commandPath = join(plugin.commandsDir, entry.name)
+      const commandName = basename(entry.name, ".md")
+      const namespacedName = `${plugin.name}:${commandName}`
+
+      try {
+        const content = readFileSync(commandPath, "utf-8")
+        const { data, body } = parseFrontmatter<CommandFrontmatter>(content)
+
+        const wrappedTemplate = `<command-instruction>
+${body.trim()}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`
+
+        const formattedDescription = `(plugin: ${plugin.name}) ${data.description || ""}`
+
+        commands[namespacedName] = {
+          name: namespacedName,
+          description: formattedDescription,
+          template: wrappedTemplate,
+          agent: data.agent,
+          model: sanitizeModelField(data.model, "claude-code"),
+          subtask: data.subtask,
+          argumentHint: data["argument-hint"],
+        }
+
+        log(`Loaded plugin command: ${namespacedName}`, { path: commandPath })
+      } catch (error) {
+        log(`Failed to load plugin command: ${commandPath}`, error)
+      }
+    }
+  }
+
+  return commands
+}
+
+export function loadPluginSkillsAsCommands(
+  plugins: LoadedPlugin[]
+): Record<string, CommandDefinition> {
+  const skills: Record<string, CommandDefinition> = {}
+
+  for (const plugin of plugins) {
+    if (!plugin.skillsDir || !existsSync(plugin.skillsDir)) continue
+
+    const entries = readdirSync(plugin.skillsDir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue
+
+      const skillPath = join(plugin.skillsDir, entry.name)
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
+
+      const resolvedPath = resolveSymlink(skillPath)
+      const skillMdPath = join(resolvedPath, "SKILL.md")
+      if (!existsSync(skillMdPath)) continue
+
+      try {
+        const content = readFileSync(skillMdPath, "utf-8")
+        const { data, body } = parseFrontmatter<SkillMetadata>(content)
+
+        const skillName = data.name || entry.name
+        const namespacedName = `${plugin.name}:${skillName}`
+        const originalDescription = data.description || ""
+        const formattedDescription = `(plugin: ${plugin.name} - Skill) ${originalDescription}`
+
+        const wrappedTemplate = `<skill-instruction>
+Base directory for this skill: ${resolvedPath}/
+File references (@path) in this skill are relative to this directory.
+
+${body.trim()}
+</skill-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`
+
+        skills[namespacedName] = {
+          name: namespacedName,
+          description: formattedDescription,
+          template: wrappedTemplate,
+          model: sanitizeModelField(data.model),
+        }
+
+        log(`Loaded plugin skill: ${namespacedName}`, { path: resolvedPath })
+      } catch (error) {
+        log(`Failed to load plugin skill: ${skillPath}`, error)
+      }
+    }
+  }
+
+  return skills
+}
+
+function parseToolsConfig(toolsStr?: string): Record<string, boolean> | undefined {
+  if (!toolsStr) return undefined
+
+  const tools = toolsStr.split(",").map((t) => t.trim()).filter(Boolean)
+  if (tools.length === 0) return undefined
+
+  const result: Record<string, boolean> = {}
+  for (const tool of tools) {
+    result[tool.toLowerCase()] = true
+  }
+  return result
+}
+
+export function loadPluginAgents(
+  plugins: LoadedPlugin[]
+): Record<string, AgentConfig> {
+  const agents: Record<string, AgentConfig> = {}
+
+  for (const plugin of plugins) {
+    if (!plugin.agentsDir || !existsSync(plugin.agentsDir)) continue
+
+    const entries = readdirSync(plugin.agentsDir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      if (!isMarkdownFile(entry)) continue
+
+      const agentPath = join(plugin.agentsDir, entry.name)
+      const agentName = basename(entry.name, ".md")
+      const namespacedName = `${plugin.name}:${agentName}`
+
+      try {
+        const content = readFileSync(agentPath, "utf-8")
+        const { data, body } = parseFrontmatter<AgentFrontmatter>(content)
+
+        const name = data.name || agentName
+        const originalDescription = data.description || ""
+        const formattedDescription = `(plugin: ${plugin.name}) ${originalDescription}`
+
+        const config: AgentConfig = {
+          description: formattedDescription,
+          mode: "subagent",
+          prompt: body.trim(),
+        }
+
+        const toolsConfig = parseToolsConfig(data.tools)
+        if (toolsConfig) {
+          config.tools = toolsConfig
+        }
+
+        agents[namespacedName] = config
+        log(`Loaded plugin agent: ${namespacedName}`, { path: agentPath })
+      } catch (error) {
+        log(`Failed to load plugin agent: ${agentPath}`, error)
+      }
+    }
+  }
+
+  return agents
+}
+
+export async function loadPluginMcpServers(
+  plugins: LoadedPlugin[]
+): Promise<Record<string, McpServerConfig>> {
+  const servers: Record<string, McpServerConfig> = {}
+
+  for (const plugin of plugins) {
+    if (!plugin.mcpPath || !existsSync(plugin.mcpPath)) continue
+
+    try {
+      const content = await Bun.file(plugin.mcpPath).text()
+      let config = JSON.parse(content) as ClaudeCodeMcpConfig
+
+      config = resolvePluginPaths(config, plugin.installPath)
+      config = expandEnvVarsInObject(config)
+
+      if (!config.mcpServers) continue
+
+      for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        if (serverConfig.disabled) {
+          log(`Skipping disabled MCP server "${name}" from plugin ${plugin.name}`)
+          continue
+        }
+
+        try {
+          const transformed = transformMcpServer(name, serverConfig)
+          const namespacedName = `${plugin.name}:${name}`
+          servers[namespacedName] = transformed
+          log(`Loaded plugin MCP server: ${namespacedName}`, { path: plugin.mcpPath })
+        } catch (error) {
+          log(`Failed to transform plugin MCP server "${name}"`, error)
+        }
+      }
+    } catch (error) {
+      log(`Failed to load plugin MCP config: ${plugin.mcpPath}`, error)
+    }
+  }
+
+  return servers
+}
+
+export function loadPluginHooksConfigs(
+  plugins: LoadedPlugin[]
+): HooksConfig[] {
+  const configs: HooksConfig[] = []
+
+  for (const plugin of plugins) {
+    if (!plugin.hooksPath || !existsSync(plugin.hooksPath)) continue
+
+    try {
+      const content = readFileSync(plugin.hooksPath, "utf-8")
+      let config = JSON.parse(content) as HooksConfig
+
+      config = resolvePluginPaths(config, plugin.installPath)
+
+      configs.push(config)
+      log(`Loaded plugin hooks config from ${plugin.name}`, { path: plugin.hooksPath })
+    } catch (error) {
+      log(`Failed to load plugin hooks config: ${plugin.hooksPath}`, error)
+    }
+  }
+
+  return configs
+}
+
+export interface PluginComponentsResult {
+  commands: Record<string, CommandDefinition>
+  skills: Record<string, CommandDefinition>
+  agents: Record<string, AgentConfig>
+  mcpServers: Record<string, McpServerConfig>
+  hooksConfigs: HooksConfig[]
+  plugins: LoadedPlugin[]
+  errors: PluginLoadError[]
+}
+
+export async function loadAllPluginComponents(options?: PluginLoaderOptions): Promise<PluginComponentsResult> {
+  const { plugins, errors } = discoverInstalledPlugins(options)
+
+  const commands = loadPluginCommands(plugins)
+  const skills = loadPluginSkillsAsCommands(plugins)
+  const agents = loadPluginAgents(plugins)
+  const mcpServers = await loadPluginMcpServers(plugins)
+  const hooksConfigs = loadPluginHooksConfigs(plugins)
+
+  log(`Loaded ${plugins.length} plugins with ${Object.keys(commands).length} commands, ${Object.keys(skills).length} skills, ${Object.keys(agents).length} agents, ${Object.keys(mcpServers).length} MCP servers`)
+
+  return {
+    commands,
+    skills,
+    agents,
+    mcpServers,
+    hooksConfigs,
+    plugins,
+    errors,
+  }
+}

src/features/claude-code-plugin-loader/types.ts

@@ -0,0 +1,210 @@
+/**
+ * Claude Code Plugin Types
+ * 
+ * Type definitions for Claude Code plugin system compatibility.
+ * Based on https://code.claude.com/docs/en/plugins-reference
+ */
+
+export type PluginScope = "user" | "project" | "local" | "managed"
+
+/**
+ * Plugin installation entry in installed_plugins.json
+ */
+export interface PluginInstallation {
+  scope: PluginScope
+  installPath: string
+  version: string
+  installedAt: string
+  lastUpdated: string
+  gitCommitSha?: string
+  isLocal?: boolean
+}
+
+/**
+ * Installed plugins database v1 (legacy)
+ * plugins stored as direct objects
+ */
+export interface InstalledPluginsDatabaseV1 {
+  version: 1
+  plugins: Record<string, PluginInstallation>
+}
+
+/**
+ * Installed plugins database v2 (current)
+ * plugins stored as arrays
+ */
+export interface InstalledPluginsDatabaseV2 {
+  version: 2
+  plugins: Record<string, PluginInstallation[]>
+}
+
+/**
+ * Installed plugins database structure
+ * Located at ~/.claude/plugins/installed_plugins.json
+ */
+export type InstalledPluginsDatabase = InstalledPluginsDatabaseV1 | InstalledPluginsDatabaseV2
+
+/**
+ * Plugin author information
+ */
+export interface PluginAuthor {
+  name?: string
+  email?: string
+  url?: string
+}
+
+/**
+ * Plugin manifest (plugin.json)
+ * Located at <plugin_root>/.claude-plugin/plugin.json
+ */
+export interface PluginManifest {
+  name: string
+  version?: string
+  description?: string
+  author?: PluginAuthor
+  homepage?: string
+  repository?: string
+  license?: string
+  keywords?: string[]
+  
+  // Component paths (can be string or array)
+  commands?: string | string[]
+  agents?: string | string[]
+  skills?: string | string[]
+  hooks?: string | HooksConfig
+  mcpServers?: string | McpServersConfig
+  lspServers?: string | LspServersConfig
+  outputStyles?: string | string[]
+}
+
+/**
+ * Hooks configuration
+ */
+export interface HookEntry {
+  type: "command" | "prompt" | "agent"
+  command?: string
+  prompt?: string
+  agent?: string
+}
+
+export interface HookMatcher {
+  matcher?: string
+  hooks: HookEntry[]
+}
+
+export interface HooksConfig {
+  hooks?: {
+    PreToolUse?: HookMatcher[]
+    PostToolUse?: HookMatcher[]
+    PostToolUseFailure?: HookMatcher[]
+    PermissionRequest?: HookMatcher[]
+    UserPromptSubmit?: HookMatcher[]
+    Notification?: HookMatcher[]
+    Stop?: HookMatcher[]
+    SubagentStart?: HookMatcher[]
+    SubagentStop?: HookMatcher[]
+    SessionStart?: HookMatcher[]
+    SessionEnd?: HookMatcher[]
+    PreCompact?: HookMatcher[]
+  }
+}
+
+/**
+ * MCP servers configuration in plugin
+ */
+export interface PluginMcpServer {
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  cwd?: string
+  url?: string
+  type?: "stdio" | "http" | "sse"
+  disabled?: boolean
+}
+
+export interface McpServersConfig {
+  mcpServers?: Record<string, PluginMcpServer>
+}
+
+/**
+ * LSP server configuration
+ */
+export interface LspServerConfig {
+  command: string
+  args?: string[]
+  extensionToLanguage: Record<string, string>
+  transport?: "stdio" | "socket"
+  env?: Record<string, string>
+  initializationOptions?: Record<string, unknown>
+  settings?: Record<string, unknown>
+  workspaceFolder?: string
+  startupTimeout?: number
+  shutdownTimeout?: number
+  restartOnCrash?: boolean
+  maxRestarts?: number
+  loggingConfig?: {
+    args?: string[]
+    env?: Record<string, string>
+  }
+}
+
+export interface LspServersConfig {
+  [language: string]: LspServerConfig
+}
+
+/**
+ * Loaded plugin with all resolved components
+ */
+export interface LoadedPlugin {
+  name: string
+  version: string
+  scope: PluginScope
+  installPath: string
+  manifest?: PluginManifest
+  pluginKey: string
+  
+  // Resolved paths for components
+  commandsDir?: string
+  agentsDir?: string
+  skillsDir?: string
+  hooksPath?: string
+  mcpPath?: string
+  lspPath?: string
+}
+
+/**
+ * Plugin load result with all components
+ */
+export interface PluginLoadResult {
+  plugins: LoadedPlugin[]
+  errors: PluginLoadError[]
+}
+
+export interface PluginLoadError {
+  pluginKey: string
+  installPath: string
+  error: string
+}
+
+/**
+ * Claude settings from ~/.claude/settings.json
+ */
+export interface ClaudeSettings {
+  enabledPlugins?: Record<string, boolean>
+  // Other settings we don't use
+  [key: string]: unknown
+}
+
+/**
+ * Plugin loader options
+ */
+export interface PluginLoaderOptions {
+  /**
+   * Override enabled plugins from oh-my-opencode config.
+   * Key format: "pluginName@marketplace" (e.g., "shell-scripting@claude-code-workflows")
+   * Value: true = enabled, false = disabled
+   * 
+   * This takes precedence over ~/.claude/settings.json enabledPlugins
+   */
+  enabledPluginsOverride?: Record<string, boolean>
+}

src/features/claude-code-skill-loader/loader.ts

@@ -1,9 +1,9 @@
 import { existsSync, readdirSync, readFileSync } from "fs"
-import { homedir } from "os"
 import { join } from "path"
 import { parseFrontmatter } from "../../shared/frontmatter"
 import { sanitizeModelField } from "../../shared/model-sanitizer"
 import { resolveSymlink } from "../../shared/file-utils"
+import { getClaudeConfigDir } from "../../shared"
 import type { CommandDefinition } from "../claude-code-command-loader/types"
 import type { SkillScope, SkillMetadata, LoadedSkillAsCommand } from "./types"
 
@@ -68,7 +68,7 @@ $ARGUMENTS
 }
 
 export function loadUserSkillsAsCommands(): Record<string, CommandDefinition> {
-  const userSkillsDir = join(homedir(), ".claude", "skills")
+  const userSkillsDir = join(getClaudeConfigDir(), "skills")
   const skills = loadSkillsFromDir(userSkillsDir, "user")
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition

src/features/hook-message-injector/constants.ts

@@ -1,8 +1,6 @@
 import { join } from "node:path"
-import { homedir } from "node:os"
+import { getOpenCodeStorageDir } from "../../shared/data-path"
 
-const xdgData = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share")
-
-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")

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)

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",

src/hooks/anthropic-auto-compact/executor.test.ts

@@ -0,0 +1,261 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test"
+import { executeCompact } from "./executor"
+import type { AutoCompactState } from "./types"
+
+describe("executeCompact lock management", () => {
+  let autoCompactState: AutoCompactState
+  let mockClient: any
+  const sessionID = "test-session-123"
+  const directory = "/test/dir"
+  const msg = { providerID: "anthropic", modelID: "claude-opus-4-5" }
+
+  beforeEach(() => {
+    // #given: Fresh state for each test
+    autoCompactState = {
+      pendingCompact: new Set<string>(),
+      errorDataBySession: new Map(),
+      retryStateBySession: new Map(),
+      fallbackStateBySession: new Map(),
+      truncateStateBySession: new Map(),
+      dcpStateBySession: new Map(),
+      emptyContentAttemptBySession: new Map(),
+      compactionInProgress: new Set<string>(),
+    }
+
+    mockClient = {
+      session: {
+        messages: mock(() => Promise.resolve({ data: [] })),
+        summarize: mock(() => Promise.resolve()),
+        revert: mock(() => Promise.resolve()),
+        prompt_async: mock(() => Promise.resolve()),
+      },
+      tui: {
+        showToast: mock(() => Promise.resolve()),
+      },
+    }
+  })
+
+  test("clears lock on successful summarize completion", async () => {
+    // #given: Valid session with providerID/modelID
+    autoCompactState.errorDataBySession.set(sessionID, {
+      errorType: "token_limit",
+      currentTokens: 100000,
+      maxTokens: 200000,
+    })
+
+    // #when: Execute compaction successfully
+    await executeCompact(sessionID, msg, autoCompactState, mockClient, directory)
+
+    // #then: Lock should be cleared
+    expect(autoCompactState.compactionInProgress.has(sessionID)).toBe(false)
+  })
+
+  test("clears lock when summarize throws exception", async () => {
+    // #given: Summarize will fail
+    mockClient.session.summarize = mock(() =>
+      Promise.reject(new Error("Network timeout")),
+    )
+    autoCompactState.errorDataBySession.set(sessionID, {
+      errorType: "token_limit",
+      currentTokens: 100000,
+      maxTokens: 200000,
+    })
+
+    // #when: Execute compaction
+    await executeCompact(sessionID, msg, autoCompactState, mockClient, directory)
+
+    // #then: Lock should still be cleared despite exception
+    expect(autoCompactState.compactionInProgress.has(sessionID)).toBe(false)
+  })
+
+  test("clears lock when revert throws exception", async () => {
+    // #given: Force revert path by exhausting retry attempts and making revert fail
+    mockClient.session.revert = mock(() =>
+      Promise.reject(new Error("Revert failed")),
+    )
+    mockClient.session.messages = mock(() =>
+      Promise.resolve({
+        data: [
+          { info: { id: "msg1", role: "user" } },
+          { info: { id: "msg2", role: "assistant" } },
+        ],
+      }),
+    )
+
+    // Exhaust retry attempts
+    autoCompactState.retryStateBySession.set(sessionID, {
+      attempt: 5,
+      lastAttemptTime: Date.now(),
+    })
+    autoCompactState.errorDataBySession.set(sessionID, {
+      errorType: "token_limit",
+      currentTokens: 100000,
+      maxTokens: 200000,
+    })
+
+    // #when: Execute compaction
+    await executeCompact(sessionID, msg, autoCompactState, mockClient, directory)
+
+    // #then: Lock cleared even though revert failed
+    expect(autoCompactState.compactionInProgress.has(sessionID)).toBe(false)
+  })
+
+  test("shows toast when lock already held", async () => {
+    // #given: Lock already held
+    autoCompactState.compactionInProgress.add(sessionID)
+
+    // #when: Try to execute compaction
+    await executeCompact(sessionID, msg, autoCompactState, mockClient, directory)
+
+    // #then: Toast should be shown with warning message
+    expect(mockClient.tui.showToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        body: expect.objectContaining({
+          title: "Compact In Progress",
+          message: expect.stringContaining("Recovery already running"),
+          variant: "warning",
+        }),
+      }),
+    )
+
+    // #then: compactionInProgress should still have the lock
+    expect(autoCompactState.compactionInProgress.has(sessionID)).toBe(true)
+  })
+
+  test("clears lock when fixEmptyMessages path executes", async () => {
+    // #given: Empty content error scenario
+    autoCompactState.errorDataBySession.set(sessionID, {
+      errorType: "non-empty content required",
+      messageIndex: 0,
+      currentTokens: 100000,
+      maxTokens: 200000,
+    })
+
+    // #when: Execute compaction (fixEmptyMessages will be called)
+    await executeCompact(sessionID, msg, autoCompactState, mockClient, directory)
+
+    // #then: Lock should be cleared
+    expect(autoCompactState.compactionInProgress.has(sessionID)).toBe(false)
+  })
+
+  test("clears lock when truncation is sufficient", async () => {
+    // #given: Aggressive truncation scenario with sufficient truncation
+    // This test verifies the early return path in aggressive truncation
+    autoCompactState.errorDataBySession.set(sessionID, {
+      errorType: "token_limit",
+      currentTokens: 250000,
+      maxTokens: 200000,
+    })
+
+    const experimental = {
+      truncate_all_tool_outputs: false,
+      aggressive_truncation: true,
+    }
+
+    // #when: Execute compaction with experimental flag
+    await executeCompact(
+      sessionID,
+      msg,
+      autoCompactState,
+      mockClient,
+      directory,
+      experimental,
+    )
+
+    // #then: Lock should be cleared even on early return
+    expect(autoCompactState.compactionInProgress.has(sessionID)).toBe(false)
+  })
+
+  test("prevents concurrent compaction attempts", async () => {
+    // #given: Lock already held (simpler test)
+    autoCompactState.compactionInProgress.add(sessionID)
+
+    // #when: Try to execute compaction while lock is held
+    await executeCompact(sessionID, msg, autoCompactState, mockClient, directory)
+
+    // #then: Toast should be shown
+    const toastCalls = (mockClient.tui.showToast as any).mock.calls
+    const blockedToast = toastCalls.find(
+      (call: any) => call[0]?.body?.title === "Compact In Progress",
+    )
+    expect(blockedToast).toBeDefined()
+
+    // #then: Lock should still be held (not cleared by blocked attempt)
+    expect(autoCompactState.compactionInProgress.has(sessionID)).toBe(true)
+  })
+
+  test("clears lock after max recovery attempts exhausted", async () => {
+    // #given: All retry/revert attempts exhausted
+    mockClient.session.messages = mock(() => Promise.resolve({ data: [] }))
+
+    // Max out all attempts
+    autoCompactState.retryStateBySession.set(sessionID, {
+      attempt: 5,
+      lastAttemptTime: Date.now(),
+    })
+    autoCompactState.fallbackStateBySession.set(sessionID, {
+      revertAttempt: 5,
+    })
+    autoCompactState.truncateStateBySession.set(sessionID, {
+      truncateAttempt: 5,
+    })
+    autoCompactState.errorDataBySession.set(sessionID, {
+      errorType: "token_limit",
+      currentTokens: 100000,
+      maxTokens: 200000,
+    })
+
+    // #when: Execute compaction
+    await executeCompact(sessionID, msg, autoCompactState, mockClient, directory)
+
+    // #then: Should show failure toast
+    const toastCalls = (mockClient.tui.showToast as any).mock.calls
+    const failureToast = toastCalls.find(
+      (call: any) => call[0]?.body?.title === "Auto Compact Failed",
+    )
+    expect(failureToast).toBeDefined()
+
+    // #then: Lock should still be cleared
+    expect(autoCompactState.compactionInProgress.has(sessionID)).toBe(false)
+  })
+
+  test("clears lock when client.tui.showToast throws", async () => {
+    // #given: Toast will fail (this should never happen but testing robustness)
+    mockClient.tui.showToast = mock(() =>
+      Promise.reject(new Error("Toast failed")),
+    )
+    autoCompactState.errorDataBySession.set(sessionID, {
+      errorType: "token_limit",
+      currentTokens: 100000,
+      maxTokens: 200000,
+    })
+
+    // #when: Execute compaction
+    await executeCompact(sessionID, msg, autoCompactState, mockClient, directory)
+
+    // #then: Lock should be cleared even if toast fails
+    expect(autoCompactState.compactionInProgress.has(sessionID)).toBe(false)
+  })
+
+  test("clears lock when prompt_async in continuation throws", async () => {
+    // #given: prompt_async will fail during continuation
+    mockClient.session.prompt_async = mock(() =>
+      Promise.reject(new Error("Prompt failed")),
+    )
+    autoCompactState.errorDataBySession.set(sessionID, {
+      errorType: "token_limit",
+      currentTokens: 100000,
+      maxTokens: 200000,
+    })
+
+    // #when: Execute compaction
+    await executeCompact(sessionID, msg, autoCompactState, mockClient, directory)
+
+    // Wait for setTimeout callback
+    await new Promise((resolve) => setTimeout(resolve, 600))
+
+    // #then: Lock should be cleared
+    // The continuation happens in setTimeout, but lock is cleared in finally before that
+    expect(autoCompactState.compactionInProgress.has(sessionID)).toBe(false)
+  })
+})

src/hooks/anthropic-auto-compact/index.ts

@@ -16,6 +16,7 @@ function createAutoCompactState(): AutoCompactState {
     retryStateBySession: new Map(),
     fallbackStateBySession: new Map(),
     truncateStateBySession: new Map(),
+    dcpStateBySession: new Map(),
     emptyContentAttemptBySession: new Map(),
     compactionInProgress: new Set<string>(),
   }
@@ -36,6 +37,7 @@ export function createAnthropicAutoCompactHook(ctx: PluginInput, options?: Anthr
         autoCompactState.retryStateBySession.delete(sessionInfo.id)
         autoCompactState.fallbackStateBySession.delete(sessionInfo.id)
         autoCompactState.truncateStateBySession.delete(sessionInfo.id)
+        autoCompactState.dcpStateBySession.delete(sessionInfo.id)
         autoCompactState.emptyContentAttemptBySession.delete(sessionInfo.id)
         autoCompactState.compactionInProgress.delete(sessionInfo.id)
       }
@@ -148,6 +150,6 @@ export function createAnthropicAutoCompactHook(ctx: PluginInput, options?: Anthr
   }
 }
 
-export type { AutoCompactState, FallbackState, ParsedTokenLimitError, TruncateState } from "./types"
+export type { AutoCompactState, DcpState, FallbackState, ParsedTokenLimitError, TruncateState } from "./types"
 export { parseAnthropicTokenLimitError } from "./parser"
 export { executeCompact, getLastAssistant } from "./executor"

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) {

src/hooks/anthropic-auto-compact/pruning-deduplication.test.ts

@@ -0,0 +1,33 @@
+import { describe, test, expect } from "bun:test"
+import { createToolSignature } from "./pruning-deduplication"
+
+describe("createToolSignature", () => {
+  test("creates consistent signature for same input", () => {
+    const input1 = { filePath: "/foo/bar.ts", content: "hello" }
+    const input2 = { content: "hello", filePath: "/foo/bar.ts" }
+    
+    const sig1 = createToolSignature("read", input1)
+    const sig2 = createToolSignature("read", input2)
+    
+    expect(sig1).toBe(sig2)
+  })
+  
+  test("creates different signature for different input", () => {
+    const input1 = { filePath: "/foo/bar.ts" }
+    const input2 = { filePath: "/foo/baz.ts" }
+    
+    const sig1 = createToolSignature("read", input1)
+    const sig2 = createToolSignature("read", input2)
+    
+    expect(sig1).not.toBe(sig2)
+  })
+  
+  test("includes tool name in signature", () => {
+    const input = { filePath: "/foo/bar.ts" }
+    
+    const sig1 = createToolSignature("read", input)
+    const sig2 = createToolSignature("write", input)
+    
+    expect(sig1).not.toBe(sig2)
+  })
+})

src/hooks/anthropic-auto-compact/pruning-deduplication.ts

@@ -0,0 +1,184 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+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[]
+}
+
+interface ToolPart {
+  type: string
+  callID?: string
+  tool?: string
+  state?: {
+    input?: unknown
+    output?: string
+  }
+}
+
+interface MessagePart {
+  type: string
+  parts?: ToolPart[]
+}
+
+export function createToolSignature(toolName: string, input: unknown): string {
+  const sortedInput = sortObject(input)
+  return `${toolName}::${JSON.stringify(sortedInput)}`
+}
+
+function sortObject(obj: unknown): unknown {
+  if (obj === null || obj === undefined) return obj
+  if (typeof obj !== "object") return obj
+  if (Array.isArray(obj)) return obj.map(sortObject)
+  
+  const sorted: Record<string, unknown> = {}
+  const keys = Object.keys(obj as Record<string, unknown>).sort()
+  for (const key of keys) {
+    sorted[key] = sortObject((obj as Record<string, unknown>)[key])
+  }
+  return sorted
+}
+
+function getMessageDir(sessionID: string): string | null {
+  if (!existsSync(MESSAGE_STORAGE)) return null
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) return directPath
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) return sessionPath
+  }
+
+  return null
+}
+
+function readMessages(sessionID: string): MessagePart[] {
+  const messageDir = getMessageDir(sessionID)
+  if (!messageDir) return []
+
+  const messages: MessagePart[] = []
+  
+  try {
+    const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
+    for (const file of files) {
+      const content = readFileSync(join(messageDir, file), "utf-8")
+      const data = JSON.parse(content)
+      if (data.parts) {
+        messages.push(data)
+      }
+    }
+  } catch {
+    return []
+  }
+
+  return messages
+}
+
+export function executeDeduplication(
+  sessionID: string,
+  state: PruningState,
+  config: DeduplicationConfig,
+  protectedTools: Set<string>
+): number {
+  if (!config.enabled) return 0
+
+  const messages = readMessages(sessionID)
+  const signatures = new Map<string, ToolCallSignature[]>()
+  
+  let currentTurn = 0
+  
+  for (const msg of messages) {
+    if (!msg.parts) continue
+    
+    for (const part of msg.parts) {
+      if (part.type === "step-start") {
+        currentTurn++
+        continue
+      }
+      
+      if (part.type !== "tool" || !part.callID || !part.tool) continue
+      
+      if (protectedTools.has(part.tool)) continue
+      
+      if (config.protectedTools?.includes(part.tool)) continue
+      
+      if (state.toolIdsToPrune.has(part.callID)) continue
+      
+      const signature = createToolSignature(part.tool, part.state?.input)
+      
+      if (!signatures.has(signature)) {
+        signatures.set(signature, [])
+      }
+      
+      signatures.get(signature)!.push({
+        toolName: part.tool,
+        signature,
+        callID: part.callID,
+        turn: currentTurn,
+      })
+      
+      if (!state.toolSignatures.has(signature)) {
+        state.toolSignatures.set(signature, [])
+      }
+      state.toolSignatures.get(signature)!.push({
+        toolName: part.tool,
+        signature,
+        callID: part.callID,
+        turn: currentTurn,
+      })
+    }
+  }
+  
+  let prunedCount = 0
+  let tokensSaved = 0
+  
+  for (const [signature, calls] of signatures) {
+    if (calls.length > 1) {
+      const toPrune = calls.slice(0, -1)
+      
+      for (const call of toPrune) {
+        state.toolIdsToPrune.add(call.callID)
+        prunedCount++
+        
+        const output = findToolOutput(messages, call.callID)
+        if (output) {
+          tokensSaved += estimateTokens(output)
+        }
+        
+        log("[pruning-deduplication] pruned duplicate", {
+          tool: call.toolName,
+          callID: call.callID,
+          turn: call.turn,
+          signature: signature.substring(0, 100),
+        })
+      }
+    }
+  }
+  
+  log("[pruning-deduplication] complete", {
+    prunedCount,
+    tokensSaved,
+    uniqueSignatures: signatures.size,
+  })
+  
+  return prunedCount
+}
+
+function findToolOutput(messages: MessagePart[], callID: string): string | null {
+  for (const msg of messages) {
+    if (!msg.parts) continue
+    
+    for (const part of msg.parts) {
+      if (part.type === "tool" && part.callID === callID && part.state?.output) {
+        return part.state.output
+      }
+    }
+  }
+  
+  return null
+}

src/hooks/anthropic-auto-compact/pruning-executor.ts

@@ -0,0 +1,126 @@
+import type { DynamicContextPruningConfig } from "../../config"
+import type { PruningState, PruningResult } from "./pruning-types"
+import { executeDeduplication } from "./pruning-deduplication"
+import { executeSupersedeWrites } from "./pruning-supersede"
+import { executePurgeErrors } from "./pruning-purge-errors"
+import { applyPruning } from "./pruning-storage"
+import { log } from "../../shared/logger"
+
+const DEFAULT_PROTECTED_TOOLS = new Set([
+  "task",
+  "todowrite",
+  "todoread",
+  "lsp_rename",
+  "lsp_code_action_resolve",
+  "session_read",
+  "session_write",
+  "session_search",
+])
+
+function createPruningState(): PruningState {
+  return {
+    toolIdsToPrune: new Set<string>(),
+    currentTurn: 0,
+    fileOperations: new Map(),
+    toolSignatures: new Map(),
+    erroredTools: new Map(),
+  }
+}
+
+export async function executeDynamicContextPruning(
+  sessionID: string,
+  config: DynamicContextPruningConfig,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  client: any
+): Promise<PruningResult> {
+  const state = createPruningState()
+  
+  const protectedTools = new Set([
+    ...DEFAULT_PROTECTED_TOOLS,
+    ...(config.protected_tools || []),
+  ])
+  
+  log("[pruning-executor] starting DCP", {
+    sessionID,
+    notification: config.notification,
+    turnProtection: config.turn_protection,
+  })
+  
+  let dedupCount = 0
+  let supersedeCount = 0
+  let purgeCount = 0
+  
+  if (config.strategies?.deduplication?.enabled !== false) {
+    dedupCount = executeDeduplication(
+      sessionID,
+      state,
+      { enabled: true },
+      protectedTools
+    )
+  }
+  
+  if (config.strategies?.supersede_writes?.enabled !== false) {
+    supersedeCount = executeSupersedeWrites(
+      sessionID,
+      state,
+      {
+        enabled: true,
+        aggressive: config.strategies?.supersede_writes?.aggressive || false,
+      },
+      protectedTools
+    )
+  }
+  
+  if (config.strategies?.purge_errors?.enabled !== false) {
+    purgeCount = executePurgeErrors(
+      sessionID,
+      state,
+      {
+        enabled: true,
+        turns: config.strategies?.purge_errors?.turns || 5,
+      },
+      protectedTools
+    )
+  }
+  
+  const totalPruned = state.toolIdsToPrune.size
+  const tokensSaved = await applyPruning(sessionID, state)
+  
+  log("[pruning-executor] DCP complete", {
+    totalPruned,
+    tokensSaved,
+    deduplication: dedupCount,
+    supersede: supersedeCount,
+    purge: purgeCount,
+  })
+  
+  const result: PruningResult = {
+    itemsPruned: totalPruned,
+    totalTokensSaved: tokensSaved,
+    strategies: {
+      deduplication: dedupCount,
+      supersedeWrites: supersedeCount,
+      purgeErrors: purgeCount,
+    },
+  }
+  
+  if (config.notification !== "off" && totalPruned > 0) {
+    const message =
+      config.notification === "detailed"
+        ? `Pruned ${totalPruned} tool outputs (~${Math.round(tokensSaved / 1000)}k tokens). Dedup: ${dedupCount}, Supersede: ${supersedeCount}, Purge: ${purgeCount}`
+        : `Pruned ${totalPruned} tool outputs (~${Math.round(tokensSaved / 1000)}k tokens)`
+    
+    await client.tui
+      .showToast({
+        body: {
+          title: "Dynamic Context Pruning",
+          message,
+          variant: "success",
+          duration: 3000,
+        },
+      })
+      .catch(() => {})
+  }
+  
+  return result
+}

src/hooks/anthropic-auto-compact/pruning-purge-errors.ts

@@ -0,0 +1,152 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+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
+  turns: number
+  protectedTools?: string[]
+}
+
+interface ToolPart {
+  type: string
+  callID?: string
+  tool?: string
+  state?: {
+    input?: unknown
+    output?: string
+    status?: string
+  }
+}
+
+interface MessagePart {
+  type: string
+  parts?: ToolPart[]
+}
+
+function getMessageDir(sessionID: string): string | null {
+  if (!existsSync(MESSAGE_STORAGE)) return null
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) return directPath
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) return sessionPath
+  }
+
+  return null
+}
+
+function readMessages(sessionID: string): MessagePart[] {
+  const messageDir = getMessageDir(sessionID)
+  if (!messageDir) return []
+
+  const messages: MessagePart[] = []
+  
+  try {
+    const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
+    for (const file of files) {
+      const content = readFileSync(join(messageDir, file), "utf-8")
+      const data = JSON.parse(content)
+      if (data.parts) {
+        messages.push(data)
+      }
+    }
+  } catch {
+    return []
+  }
+
+  return messages
+}
+
+export function executePurgeErrors(
+  sessionID: string,
+  state: PruningState,
+  config: PurgeErrorsConfig,
+  protectedTools: Set<string>
+): number {
+  if (!config.enabled) return 0
+
+  const messages = readMessages(sessionID)
+  
+  let currentTurn = 0
+  
+  for (const msg of messages) {
+    if (!msg.parts) continue
+    
+    for (const part of msg.parts) {
+      if (part.type === "step-start") {
+        currentTurn++
+      }
+    }
+  }
+  
+  state.currentTurn = currentTurn
+  
+  let turnCounter = 0
+  let prunedCount = 0
+  let tokensSaved = 0
+  
+  for (const msg of messages) {
+    if (!msg.parts) continue
+    
+    for (const part of msg.parts) {
+      if (part.type === "step-start") {
+        turnCounter++
+        continue
+      }
+      
+      if (part.type !== "tool" || !part.callID || !part.tool) continue
+      
+      if (protectedTools.has(part.tool)) continue
+      
+      if (config.protectedTools?.includes(part.tool)) continue
+      
+      if (state.toolIdsToPrune.has(part.callID)) continue
+      
+      if (part.state?.status !== "error") continue
+      
+      const turnAge = currentTurn - turnCounter
+      
+      if (turnAge >= config.turns) {
+        state.toolIdsToPrune.add(part.callID)
+        prunedCount++
+        
+        const input = part.state.input
+        if (input) {
+          tokensSaved += estimateTokens(JSON.stringify(input))
+        }
+        
+        const errorInfo: ErroredToolCall = {
+          callID: part.callID,
+          toolName: part.tool,
+          turn: turnCounter,
+          errorAge: turnAge,
+        }
+        
+        state.erroredTools.set(part.callID, errorInfo)
+        
+        log("[pruning-purge-errors] pruned old error", {
+          tool: part.tool,
+          callID: part.callID,
+          turn: turnCounter,
+          errorAge: turnAge,
+          threshold: config.turns,
+        })
+      }
+    }
+  }
+  
+  log("[pruning-purge-errors] complete", {
+    prunedCount,
+    tokensSaved,
+    currentTurn,
+    threshold: config.turns,
+  })
+  
+  return prunedCount
+}

src/hooks/anthropic-auto-compact/pruning-storage.ts

@@ -0,0 +1,101 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import type { PruningState } from "./pruning-types"
+import { estimateTokens } from "./pruning-types"
+import { log } from "../../shared/logger"
+import { MESSAGE_STORAGE } from "../../features/hook-message-injector"
+
+function getMessageDir(sessionID: string): string | null {
+  if (!existsSync(MESSAGE_STORAGE)) return null
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) return directPath
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) return sessionPath
+  }
+
+  return null
+}
+
+interface ToolPart {
+  type: string
+  callID?: string
+  tool?: string
+  state?: {
+    input?: unknown
+    output?: string
+    status?: string
+  }
+}
+
+interface MessageData {
+  parts?: ToolPart[]
+  [key: string]: unknown
+}
+
+export async function applyPruning(
+  sessionID: string,
+  state: PruningState
+): Promise<number> {
+  const messageDir = getMessageDir(sessionID)
+  if (!messageDir) {
+    log("[pruning-storage] message dir not found", { sessionID })
+    return 0
+  }
+
+  let totalTokensSaved = 0
+  let filesModified = 0
+
+  try {
+    const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
+    
+    for (const file of files) {
+      const filePath = join(messageDir, file)
+      const content = readFileSync(filePath, "utf-8")
+      const data: MessageData = JSON.parse(content)
+      
+      if (!data.parts) continue
+      
+      let modified = false
+      
+      for (const part of data.parts) {
+        if (part.type !== "tool" || !part.callID) continue
+        
+        if (!state.toolIdsToPrune.has(part.callID)) continue
+        
+        if (part.state?.input) {
+          const inputStr = JSON.stringify(part.state.input)
+          totalTokensSaved += estimateTokens(inputStr)
+          part.state.input = { __pruned: true, reason: "DCP" }
+          modified = true
+        }
+        
+        if (part.state?.output) {
+          totalTokensSaved += estimateTokens(part.state.output)
+          part.state.output = "[Content pruned by Dynamic Context Pruning]"
+          modified = true
+        }
+      }
+      
+      if (modified) {
+        writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8")
+        filesModified++
+      }
+    }
+  } catch (error) {
+    log("[pruning-storage] error applying pruning", {
+      sessionID,
+      error: String(error),
+    })
+  }
+
+  log("[pruning-storage] applied pruning", {
+    sessionID,
+    filesModified,
+    totalTokensSaved,
+  })
+
+  return totalTokensSaved
+}

src/hooks/anthropic-auto-compact/pruning-supersede.ts

@@ -0,0 +1,212 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+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
+}
+
+interface ToolPart {
+  type: string
+  callID?: string
+  tool?: string
+  state?: {
+    input?: unknown
+    output?: string
+  }
+}
+
+interface MessagePart {
+  type: string
+  parts?: ToolPart[]
+}
+
+function getMessageDir(sessionID: string): string | null {
+  if (!existsSync(MESSAGE_STORAGE)) return null
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) return directPath
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) return sessionPath
+  }
+
+  return null
+}
+
+function readMessages(sessionID: string): MessagePart[] {
+  const messageDir = getMessageDir(sessionID)
+  if (!messageDir) return []
+
+  const messages: MessagePart[] = []
+  
+  try {
+    const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
+    for (const file of files) {
+      const content = readFileSync(join(messageDir, file), "utf-8")
+      const data = JSON.parse(content)
+      if (data.parts) {
+        messages.push(data)
+      }
+    }
+  } catch {
+    return []
+  }
+
+  return messages
+}
+
+function extractFilePath(toolName: string, input: unknown): string | null {
+  if (!input || typeof input !== "object") return null
+  
+  const inputObj = input as Record<string, unknown>
+  
+  if (toolName === "write" || toolName === "edit" || toolName === "read") {
+    if (typeof inputObj.filePath === "string") {
+      return inputObj.filePath
+    }
+  }
+  
+  return null
+}
+
+export function executeSupersedeWrites(
+  sessionID: string,
+  state: PruningState,
+  config: SupersedeWritesConfig,
+  protectedTools: Set<string>
+): number {
+  if (!config.enabled) return 0
+
+  const messages = readMessages(sessionID)
+  const writesByFile = new Map<string, FileOperation[]>()
+  const readsByFile = new Map<string, number[]>()
+  
+  let currentTurn = 0
+  
+  for (const msg of messages) {
+    if (!msg.parts) continue
+    
+    for (const part of msg.parts) {
+      if (part.type === "step-start") {
+        currentTurn++
+        continue
+      }
+      
+      if (part.type !== "tool" || !part.callID || !part.tool) continue
+      
+      if (protectedTools.has(part.tool)) continue
+      
+      if (state.toolIdsToPrune.has(part.callID)) continue
+      
+      const filePath = extractFilePath(part.tool, part.state?.input)
+      if (!filePath) continue
+      
+      if (part.tool === "write" || part.tool === "edit") {
+        if (!writesByFile.has(filePath)) {
+          writesByFile.set(filePath, [])
+        }
+        writesByFile.get(filePath)!.push({
+          callID: part.callID,
+          tool: part.tool,
+          filePath,
+          turn: currentTurn,
+        })
+        
+        if (!state.fileOperations.has(filePath)) {
+          state.fileOperations.set(filePath, [])
+        }
+        state.fileOperations.get(filePath)!.push({
+          callID: part.callID,
+          tool: part.tool,
+          filePath,
+          turn: currentTurn,
+        })
+      } else if (part.tool === "read") {
+        if (!readsByFile.has(filePath)) {
+          readsByFile.set(filePath, [])
+        }
+        readsByFile.get(filePath)!.push(currentTurn)
+      }
+    }
+  }
+  
+  let prunedCount = 0
+  let tokensSaved = 0
+  
+  for (const [filePath, writes] of writesByFile) {
+    const reads = readsByFile.get(filePath) || []
+    
+    if (config.aggressive) {
+      for (const write of writes) {
+        const superseded = reads.some(readTurn => readTurn > write.turn)
+        if (superseded) {
+          state.toolIdsToPrune.add(write.callID)
+          prunedCount++
+          
+          const input = findToolInput(messages, write.callID)
+          if (input) {
+            tokensSaved += estimateTokens(JSON.stringify(input))
+          }
+          
+          log("[pruning-supersede] pruned superseded write", {
+            tool: write.tool,
+            callID: write.callID,
+            turn: write.turn,
+            filePath,
+          })
+        }
+      }
+    } else {
+      if (writes.length > 1) {
+        for (const write of writes.slice(0, -1)) {
+          const superseded = reads.some(readTurn => readTurn > write.turn)
+          if (superseded) {
+            state.toolIdsToPrune.add(write.callID)
+            prunedCount++
+            
+            const input = findToolInput(messages, write.callID)
+            if (input) {
+              tokensSaved += estimateTokens(JSON.stringify(input))
+            }
+            
+            log("[pruning-supersede] pruned superseded write (conservative)", {
+              tool: write.tool,
+              callID: write.callID,
+              turn: write.turn,
+              filePath,
+            })
+          }
+        }
+      }
+    }
+  }
+  
+  log("[pruning-supersede] complete", {
+    prunedCount,
+    tokensSaved,
+    filesTracked: writesByFile.size,
+    mode: config.aggressive ? "aggressive" : "conservative",
+  })
+  
+  return prunedCount
+}
+
+function findToolInput(messages: MessagePart[], callID: string): unknown | null {
+  for (const msg of messages) {
+    if (!msg.parts) continue
+    
+    for (const part of msg.parts) {
+      if (part.type === "tool" && part.callID === callID && part.state?.input) {
+        return part.state.input
+      }
+    }
+  }
+  
+  return null
+}

src/hooks/anthropic-auto-compact/pruning-types.ts

@@ -0,0 +1,44 @@
+export interface ToolCallSignature {
+  toolName: string
+  signature: string
+  callID: string
+  turn: number
+}
+
+export interface FileOperation {
+  callID: string
+  tool: string
+  filePath: string
+  turn: number
+}
+
+export interface ErroredToolCall {
+  callID: string
+  toolName: string
+  turn: number
+  errorAge: number
+}
+
+export interface PruningResult {
+  itemsPruned: number
+  totalTokensSaved: number
+  strategies: {
+    deduplication: number
+    supersedeWrites: number
+    purgeErrors: number
+  }
+}
+
+export interface PruningState {
+  toolIdsToPrune: Set<string>
+  currentTurn: number
+  fileOperations: Map<string, FileOperation[]>
+  toolSignatures: Map<string, ToolCallSignature[]>
+  erroredTools: Map<string, ErroredToolCall>
+}
+
+export const CHARS_PER_TOKEN = 4
+
+export function estimateTokens(text: string): number {
+  return Math.ceil(text.length / CHARS_PER_TOKEN)
+}

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")
 

src/hooks/anthropic-auto-compact/types.ts

@@ -23,12 +23,18 @@ export interface TruncateState {
   lastTruncatedPartId?: string
 }
 
+export interface DcpState {
+  attempted: boolean
+  itemsPruned: number
+}
+
 export interface AutoCompactState {
   pendingCompact: Set<string>
   errorDataBySession: Map<string, ParsedTokenLimitError>
   retryStateBySession: Map<string, RetryState>
   fallbackStateBySession: Map<string, FallbackState>
   truncateStateBySession: Map<string, TruncateState>
+  dcpStateBySession: Map<string, DcpState>
   emptyContentAttemptBySession: Map<string, number>
   compactionInProgress: Set<string>
 }

src/hooks/auto-update-checker/index.ts

@@ -34,12 +34,12 @@ export function createAutoUpdateCheckerHook(ctx: PluginInput, options: AutoUpdat
 
       hasChecked = true
 
-      setTimeout(() => {
+      setTimeout(async () => {
         const cachedVersion = getCachedVersion()
         const localDevVersion = getLocalDevVersion(ctx.directory)
         const displayVersion = localDevVersion ?? cachedVersion
 
-        showConfigErrorsIfAny(ctx).catch(() => {})
+        await showConfigErrorsIfAny(ctx)
 
         if (localDevVersion) {
           if (showStartupToast) {

src/hooks/claude-code-hooks/config.ts

@@ -1,6 +1,6 @@
-import { homedir } from "os"
 import { join } from "path"
 import { existsSync } from "fs"
+import { getClaudeConfigDir } from "../../shared"
 import type { ClaudeHooksConfig, HookMatcher, HookCommand } from "./types"
 
 interface RawHookMatcher {
@@ -44,9 +44,9 @@ function normalizeHooksConfig(raw: RawClaudeHooksConfig): ClaudeHooksConfig {
 }
 
 export function getClaudeSettingsPaths(customPath?: string): string[] {
-  const home = homedir()
+  const claudeConfigDir = getClaudeConfigDir()
   const paths = [
-    join(home, ".claude", "settings.json"),
+    join(claudeConfigDir, "settings.json"),
     join(process.cwd(), ".claude", "settings.json"),
     join(process.cwd(), ".claude", "settings.local.json"),
   ]

src/hooks/claude-code-hooks/todo.ts

@@ -1,9 +1,9 @@
 import { join } from "path"
 import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync } from "fs"
-import { homedir } from "os"
+import { getClaudeConfigDir } from "../../shared"
 import type { TodoFile, TodoItem, ClaudeCodeTodoItem } from "./types"
 
-const TODO_DIR = join(homedir(), ".claude", "todos")
+const TODO_DIR = join(getClaudeConfigDir(), "todos")
 
 export function getTodoPath(sessionId: string): string {
   return join(TODO_DIR, `${sessionId}-agent-${sessionId}.json`)

src/hooks/claude-code-hooks/transcript.ts

@@ -1,15 +1,12 @@
-/**
- * Transcript Manager
- * Creates and manages Claude Code compatible transcript files
- */
 import { join } from "path"
 import { mkdirSync, appendFileSync, existsSync, writeFileSync, unlinkSync } from "fs"
-import { homedir, tmpdir } from "os"
+import { tmpdir } from "os"
 import { randomUUID } from "crypto"
 import type { TranscriptEntry } from "./types"
 import { transformToolName } from "../../shared/tool-name"
+import { getClaudeConfigDir } from "../../shared"
 
-const TRANSCRIPT_DIR = join(homedir(), ".claude", "transcripts")
+const TRANSCRIPT_DIR = join(getClaudeConfigDir(), "transcripts")
 
 export function getTranscriptPath(sessionId: string): string {
   return join(TRANSCRIPT_DIR, `${sessionId}.jsonl`)

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",

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")

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",

src/hooks/directory-agents-injector/index.ts

@@ -7,6 +7,7 @@ import {
   clearInjectedPaths,
 } from "./storage";
 import { AGENTS_FILENAME } from "./constants";
+import { createDynamicTruncator } from "../../shared/dynamic-truncator";
 
 interface ToolExecuteInput {
   tool: string;
@@ -39,6 +40,7 @@ interface EventInput {
 export function createDirectoryAgentsInjectorHook(ctx: PluginInput) {
   const sessionCaches = new Map<string, Set<string>>();
   const pendingBatchReads = new Map<string, string[]>();
+  const truncator = createDynamicTruncator(ctx);
 
   function getSessionCache(sessionID: string): Set<string> {
     if (!sessionCaches.has(sessionID)) {
@@ -73,11 +75,11 @@ export function createDirectoryAgentsInjectorHook(ctx: PluginInput) {
     return found.reverse();
   }
 
-  function processFilePathForInjection(
+  async function processFilePathForInjection(
     filePath: string,
     sessionID: string,
     output: ToolExecuteOutput,
-  ): void {
+  ): Promise<void> {
     const resolved = resolveFilePath(filePath);
     if (!resolved) return;
 
@@ -91,7 +93,11 @@ export function createDirectoryAgentsInjectorHook(ctx: PluginInput) {
 
       try {
         const content = readFileSync(agentsPath, "utf-8");
-        output.output += `\n\n[Directory Context: ${agentsPath}]\n${content}`;
+        const { result, truncated } = await truncator.truncate(sessionID, content);
+        const truncationNotice = truncated
+          ? `\n\n[Note: Content was truncated to save context window space. For full context, please read the file directly: ${agentsPath}]`
+          : "";
+        output.output += `\n\n[Directory Context: ${agentsPath}]\n${result}${truncationNotice}`;
         cache.add(agentsDir);
       } catch {}
     }
@@ -127,7 +133,7 @@ export function createDirectoryAgentsInjectorHook(ctx: PluginInput) {
     const toolName = input.tool.toLowerCase();
 
     if (toolName === "read") {
-      processFilePathForInjection(output.title, input.sessionID, output);
+      await processFilePathForInjection(output.title, input.sessionID, output);
       return;
     }
 
@@ -135,7 +141,7 @@ export function createDirectoryAgentsInjectorHook(ctx: PluginInput) {
       const filePaths = pendingBatchReads.get(input.callID);
       if (filePaths) {
         for (const filePath of filePaths) {
-          processFilePathForInjection(filePath, input.sessionID, output);
+          await processFilePathForInjection(filePath, input.sessionID, output);
         }
         pendingBatchReads.delete(input.callID);
       }

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",

src/hooks/directory-readme-injector/index.ts

@@ -7,6 +7,7 @@ import {
   clearInjectedPaths,
 } from "./storage";
 import { README_FILENAME } from "./constants";
+import { createDynamicTruncator } from "../../shared/dynamic-truncator";
 
 interface ToolExecuteInput {
   tool: string;
@@ -39,6 +40,7 @@ interface EventInput {
 export function createDirectoryReadmeInjectorHook(ctx: PluginInput) {
   const sessionCaches = new Map<string, Set<string>>();
   const pendingBatchReads = new Map<string, string[]>();
+  const truncator = createDynamicTruncator(ctx);
 
   function getSessionCache(sessionID: string): Set<string> {
     if (!sessionCaches.has(sessionID)) {
@@ -73,11 +75,11 @@ export function createDirectoryReadmeInjectorHook(ctx: PluginInput) {
     return found.reverse();
   }
 
-  function processFilePathForInjection(
+  async function processFilePathForInjection(
     filePath: string,
     sessionID: string,
     output: ToolExecuteOutput,
-  ): void {
+  ): Promise<void> {
     const resolved = resolveFilePath(filePath);
     if (!resolved) return;
 
@@ -91,7 +93,11 @@ export function createDirectoryReadmeInjectorHook(ctx: PluginInput) {
 
       try {
         const content = readFileSync(readmePath, "utf-8");
-        output.output += `\n\n[Project README: ${readmePath}]\n${content}`;
+        const { result, truncated } = await truncator.truncate(sessionID, content);
+        const truncationNotice = truncated
+          ? `\n\n[Note: Content was truncated to save context window space. For full context, please read the file directly: ${readmePath}]`
+          : "";
+        output.output += `\n\n[Project README: ${readmePath}]\n${result}${truncationNotice}`;
         cache.add(readmeDir);
       } catch {}
     }
@@ -127,7 +133,7 @@ export function createDirectoryReadmeInjectorHook(ctx: PluginInput) {
     const toolName = input.tool.toLowerCase();
 
     if (toolName === "read") {
-      processFilePathForInjection(output.title, input.sessionID, output);
+      await processFilePathForInjection(output.title, input.sessionID, output);
       return;
     }
 
@@ -135,7 +141,7 @@ export function createDirectoryReadmeInjectorHook(ctx: PluginInput) {
       const filePaths = pendingBatchReads.get(input.callID);
       if (filePaths) {
         for (const filePath of filePaths) {
-          processFilePathForInjection(filePath, input.sessionID, output);
+          await processFilePathForInjection(filePath, input.sessionID, output);
         }
         pendingBatchReads.delete(input.callID);
       }

src/hooks/index.ts

@@ -21,3 +21,4 @@ export { createKeywordDetectorHook } from "./keyword-detector";
 export { createNonInteractiveEnvHook } from "./non-interactive-env";
 export { createInteractiveBashSessionHook } from "./interactive-bash-session";
 export { createEmptyMessageSanitizerHook } from "./empty-message-sanitizer";
+export { createThinkingBlockValidatorHook } from "./thinking-block-validator";

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",

src/hooks/keyword-detector/constants.ts

@@ -31,11 +31,23 @@ TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
 3. Always Use Plan agent with gathered context to create detailed work breakdown
 4. Execute with continuous verification against original requirements
 
+## TDD (if test infrastructure exists)
+
+1. Write spec (requirements)
+2. Write tests (failing)
+3. RED: tests fail
+4. Implement minimal code
+5. GREEN: tests pass
+6. Refactor if needed (must stay green)
+7. Next feature, repeat
+
 ## ZERO TOLERANCE FAILURES
 - **NO Scope Reduction**: Never make "demo", "skeleton", "simplified", "basic" versions - deliver FULL implementation
+- **NO MockUp Work**: When user asked you to do "port A", you must "port A", fully, 100%. No Extra feature, No reduced feature, no mock data, fully working 100% port.
 - **NO Partial Completion**: Never stop at 60-80% saying "you can extend this..." - finish 100%
 - **NO Assumed Shortcuts**: Never skip requirements you deem "optional" or "can be added later"
 - **NO Premature Stopping**: Never declare done until ALL TODOs are completed and verified
+- **NO TEST DELETION**: Never delete or skip failing tests to make the build pass. Fix the code, not the tests.
 
 THE USER ASKED FOR X. DELIVER EXACTLY X. NOT A SUBSET. NOT A DEMO. NOT A STARTING POINT.
 

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 = [

src/hooks/rules-injector/index.ts

@@ -15,6 +15,7 @@ import {
   loadInjectedRules,
   saveInjectedRules,
 } from "./storage";
+import { createDynamicTruncator } from "../../shared/dynamic-truncator";
 
 interface ToolExecuteInput {
   tool: string;
@@ -59,6 +60,7 @@ export function createRulesInjectorHook(ctx: PluginInput) {
     { contentHashes: Set<string>; realPaths: Set<string> }
   >();
   const pendingBatchFiles = new Map<string, string[]>();
+  const truncator = createDynamicTruncator(ctx);
 
   function getSessionCache(sessionID: string): {
     contentHashes: Set<string>;
@@ -76,11 +78,11 @@ export function createRulesInjectorHook(ctx: PluginInput) {
     return resolve(ctx.directory, path);
   }
 
-  function processFilePathForInjection(
+  async function processFilePathForInjection(
     filePath: string,
     sessionID: string,
     output: ToolExecuteOutput
-  ): void {
+  ): Promise<void> {
     const resolved = resolveFilePath(filePath);
     if (!resolved) return;
 
@@ -125,7 +127,11 @@ export function createRulesInjectorHook(ctx: PluginInput) {
     toInject.sort((a, b) => a.distance - b.distance);
 
     for (const rule of toInject) {
-      output.output += `\n\n[Rule: ${rule.relativePath}]\n[Match: ${rule.matchReason}]\n${rule.content}`;
+      const { result, truncated } = await truncator.truncate(sessionID, rule.content);
+      const truncationNotice = truncated
+        ? `\n\n[Note: Content was truncated to save context window space. For full context, please read the file directly: ${rule.relativePath}]`
+        : "";
+      output.output += `\n\n[Rule: ${rule.relativePath}]\n[Match: ${rule.matchReason}]\n${result}${truncationNotice}`;
     }
 
     saveInjectedRules(sessionID, cache);
@@ -167,7 +173,7 @@ export function createRulesInjectorHook(ctx: PluginInput) {
     const toolName = input.tool.toLowerCase();
 
     if (TRACKED_TOOLS.includes(toolName)) {
-      processFilePathForInjection(output.title, input.sessionID, output);
+      await processFilePathForInjection(output.title, input.sessionID, output);
       return;
     }
 
@@ -175,7 +181,7 @@ export function createRulesInjectorHook(ctx: PluginInput) {
       const filePaths = pendingBatchFiles.get(input.callID);
       if (filePaths) {
         for (const filePath of filePaths) {
-          processFilePathForInjection(filePath, input.sessionID, output);
+          await processFilePathForInjection(filePath, input.sessionID, output);
         }
         pendingBatchFiles.delete(input.callID);
       }

src/hooks/session-notification-utils.ts

@@ -0,0 +1,140 @@
+import { spawn } from "bun"
+
+type Platform = "darwin" | "linux" | "win32" | "unsupported"
+
+let notifySendPath: string | null = null
+let notifySendPromise: Promise<string | null> | null = null
+
+let osascriptPath: string | null = null
+let osascriptPromise: Promise<string | null> | null = null
+
+let powershellPath: string | null = null
+let powershellPromise: Promise<string | null> | null = null
+
+let afplayPath: string | null = null
+let afplayPromise: Promise<string | null> | null = null
+
+let paplayPath: string | null = null
+let paplayPromise: Promise<string | null> | null = null
+
+let aplayPath: string | null = null
+let aplayPromise: Promise<string | null> | null = null
+
+async function findCommand(commandName: string): Promise<string | null> {
+  const isWindows = process.platform === "win32"
+  const cmd = isWindows ? "where" : "which"
+
+  try {
+    const proc = spawn([cmd, commandName], {
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    const exitCode = await proc.exited
+    if (exitCode !== 0) {
+      return null
+    }
+
+    const stdout = await new Response(proc.stdout).text()
+    const path = stdout.trim().split("\n")[0]
+
+    if (!path) {
+      return null
+    }
+
+    return path
+  } catch {
+    return null
+  }
+}
+
+export async function getNotifySendPath(): Promise<string | null> {
+  if (notifySendPath !== null) return notifySendPath
+  if (notifySendPromise) return notifySendPromise
+
+  notifySendPromise = (async () => {
+    const path = await findCommand("notify-send")
+    notifySendPath = path
+    return path
+  })()
+
+  return notifySendPromise
+}
+
+export async function getOsascriptPath(): Promise<string | null> {
+  if (osascriptPath !== null) return osascriptPath
+  if (osascriptPromise) return osascriptPromise
+
+  osascriptPromise = (async () => {
+    const path = await findCommand("osascript")
+    osascriptPath = path
+    return path
+  })()
+
+  return osascriptPromise
+}
+
+export async function getPowershellPath(): Promise<string | null> {
+  if (powershellPath !== null) return powershellPath
+  if (powershellPromise) return powershellPromise
+
+  powershellPromise = (async () => {
+    const path = await findCommand("powershell")
+    powershellPath = path
+    return path
+  })()
+
+  return powershellPromise
+}
+
+export async function getAfplayPath(): Promise<string | null> {
+  if (afplayPath !== null) return afplayPath
+  if (afplayPromise) return afplayPromise
+
+  afplayPromise = (async () => {
+    const path = await findCommand("afplay")
+    afplayPath = path
+    return path
+  })()
+
+  return afplayPromise
+}
+
+export async function getPaplayPath(): Promise<string | null> {
+  if (paplayPath !== null) return paplayPath
+  if (paplayPromise) return paplayPromise
+
+  paplayPromise = (async () => {
+    const path = await findCommand("paplay")
+    paplayPath = path
+    return path
+  })()
+
+  return paplayPromise
+}
+
+export async function getAplayPath(): Promise<string | null> {
+  if (aplayPath !== null) return aplayPath
+  if (aplayPromise) return aplayPromise
+
+  aplayPromise = (async () => {
+    const path = await findCommand("aplay")
+    aplayPath = path
+    return path
+  })()
+
+  return aplayPromise
+}
+
+export function startBackgroundCheck(platform: Platform): void {
+  if (platform === "darwin") {
+    getOsascriptPath().catch(() => {})
+    getAfplayPath().catch(() => {})
+  } else if (platform === "linux") {
+    getNotifySendPath().catch(() => {})
+    getPaplayPath().catch(() => {})
+    getAplayPath().catch(() => {})
+  } else if (platform === "win32") {
+    getPowershellPath().catch(() => {})
+  }
+}

src/hooks/session-notification.test.ts

@@ -1,16 +1,20 @@
-import { describe, expect, test, beforeEach, afterEach } from "bun:test"
+import { describe, expect, test, beforeEach, afterEach, spyOn } from "bun:test"
 
 import { createSessionNotification } from "./session-notification"
 import { setMainSession, subagentSessions } from "../features/claude-code-session-state"
+import * as utils from "./session-notification-utils"
 
 describe("session-notification", () => {
   let notificationCalls: string[]
 
   function createMockPluginInput() {
     return {
-      $: async (cmd: TemplateStringsArray | string) => {
+      $: async (cmd: TemplateStringsArray | string, ...values: any[]) => {
         // #given - track notification commands (osascript, notify-send, powershell)
-        const cmdStr = typeof cmd === "string" ? cmd : cmd.join("")
+        const cmdStr = typeof cmd === "string" 
+          ? cmd 
+          : cmd.reduce((acc, part, i) => acc + part + (values[i] ?? ""), "")
+        
         if (cmdStr.includes("osascript") || cmdStr.includes("notify-send") || cmdStr.includes("powershell")) {
           notificationCalls.push(cmdStr)
         }
@@ -26,8 +30,15 @@ describe("session-notification", () => {
   }
 
   beforeEach(() => {
-    // #given - reset state before each test
     notificationCalls = []
+    
+    spyOn(utils, "getOsascriptPath").mockResolvedValue("/usr/bin/osascript")
+    spyOn(utils, "getNotifySendPath").mockResolvedValue("/usr/bin/notify-send")
+    spyOn(utils, "getPowershellPath").mockResolvedValue("powershell")
+    spyOn(utils, "getAfplayPath").mockResolvedValue("/usr/bin/afplay")
+    spyOn(utils, "getPaplayPath").mockResolvedValue("/usr/bin/paplay")
+    spyOn(utils, "getAplayPath").mockResolvedValue("/usr/bin/aplay")
+    spyOn(utils, "startBackgroundCheck").mockImplementation(() => {})
   })
 
   afterEach(() => {

src/hooks/session-notification.ts

@@ -1,6 +1,15 @@
 import type { PluginInput } from "@opencode-ai/plugin"
 import { platform } from "os"
 import { subagentSessions, getMainSessionID } from "../features/claude-code-session-state"
+import {
+  getOsascriptPath,
+  getNotifySendPath,
+  getPowershellPath,
+  getAfplayPath,
+  getPaplayPath,
+  getAplayPath,
+  startBackgroundCheck,
+} from "./session-notification-utils"
 
 interface Todo {
   content: string
@@ -51,15 +60,25 @@ async function sendNotification(
 ): Promise<void> {
   switch (p) {
     case "darwin": {
+      const osascriptPath = await getOsascriptPath()
+      if (!osascriptPath) return
+
       const esTitle = title.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
       const esMessage = message.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
-      await ctx.$`osascript -e ${"display notification \"" + esMessage + "\" with title \"" + esTitle + "\""}`
+      await ctx.$`${osascriptPath} -e ${"display notification \"" + esMessage + "\" with title \"" + esTitle + "\""}`.catch(() => {})
       break
     }
-    case "linux":
-      await ctx.$`notify-send ${title} ${message} 2>/dev/null`.catch(() => {})
+    case "linux": {
+      const notifySendPath = await getNotifySendPath()
+      if (!notifySendPath) return
+
+      await ctx.$`${notifySendPath} ${title} ${message} 2>/dev/null`.catch(() => {})
       break
+    }
     case "win32": {
+      const powershellPath = await getPowershellPath()
+      if (!powershellPath) return
+
       const psTitle = title.replace(/'/g, "''")
       const psMessage = message.replace(/'/g, "''")
       const toastScript = `
@@ -74,7 +93,7 @@ $Toast = [Windows.UI.Notifications.ToastNotification]::new($SerializedXml)
 $Notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('OpenCode')
 $Notifier.Show($Toast)
 `.trim().replace(/\n/g, "; ")
-      await ctx.$`powershell -Command ${toastScript}`.catch(() => {})
+      await ctx.$`${powershellPath} -Command ${toastScript}`.catch(() => {})
       break
     }
   }
@@ -82,17 +101,30 @@ $Notifier.Show($Toast)
 
 async function playSound(ctx: PluginInput, p: Platform, soundPath: string): Promise<void> {
   switch (p) {
-    case "darwin":
-      ctx.$`afplay ${soundPath}`.catch(() => {})
+    case "darwin": {
+      const afplayPath = await getAfplayPath()
+      if (!afplayPath) return
+      ctx.$`${afplayPath} ${soundPath}`.catch(() => {})
       break
-    case "linux":
-      ctx.$`paplay ${soundPath} 2>/dev/null`.catch(() => {
-        ctx.$`aplay ${soundPath} 2>/dev/null`.catch(() => {})
-      })
+    }
+    case "linux": {
+      const paplayPath = await getPaplayPath()
+      if (paplayPath) {
+        ctx.$`${paplayPath} ${soundPath} 2>/dev/null`.catch(() => {})
+      } else {
+        const aplayPath = await getAplayPath()
+        if (aplayPath) {
+          ctx.$`${aplayPath} ${soundPath} 2>/dev/null`.catch(() => {})
+        }
+      }
       break
-    case "win32":
-      ctx.$`powershell -Command ${"(New-Object Media.SoundPlayer '" + soundPath + "').PlaySync()"}`.catch(() => {})
+    }
+    case "win32": {
+      const powershellPath = await getPowershellPath()
+      if (!powershellPath) return
+      ctx.$`${powershellPath} -Command ${"(New-Object Media.SoundPlayer '" + soundPath + "').PlaySync()"}`.catch(() => {})
       break
+    }
   }
 }
 
@@ -114,6 +146,8 @@ export function createSessionNotification(
   const currentPlatform = detectPlatform()
   const defaultSoundPath = getDefaultSoundPath(currentPlatform)
 
+  startBackgroundCheck(currentPlatform)
+
   const mergedConfig = {
     title: "OpenCode",
     message: "Agent is ready for input",

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")
 

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
@@ -223,6 +232,41 @@ export function findMessagesWithOrphanThinking(sessionID: string): string[] {
   return result
 }
 
+/**
+ * Find the most recent thinking content from previous assistant messages
+ * Following Anthropic's recommendation to include thinking blocks from previous turns
+ */
+function findLastThinkingContent(sessionID: string, beforeMessageID: string): string {
+  const messages = readMessages(sessionID)
+
+  // Find the index of the current message
+  const currentIndex = messages.findIndex(m => m.id === beforeMessageID)
+  if (currentIndex === -1) return ""
+
+  // Search backwards through previous assistant messages
+  for (let i = currentIndex - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (msg.role !== "assistant") continue
+
+    // Look for thinking parts in this message
+    const parts = readParts(msg.id)
+    for (const part of parts) {
+      if (THINKING_TYPES.has(part.type)) {
+        // Found thinking content - return it
+        // Note: 'thinking' type uses 'thinking' property, 'reasoning' type uses 'text' property
+        const thinking = (part as { thinking?: string; text?: string }).thinking
+        const reasoning = (part as { thinking?: string; text?: string }).text
+        const content = thinking || reasoning
+        if (content && content.trim().length > 0) {
+          return content
+        }
+      }
+    }
+  }
+
+  return ""
+}
+
 export function prependThinkingPart(sessionID: string, messageID: string): boolean {
   const partDir = join(PART_STORAGE, messageID)
 
@@ -230,13 +274,16 @@ export function prependThinkingPart(sessionID: string, messageID: string): boole
     mkdirSync(partDir, { recursive: true })
   }
 
+  // Try to get thinking content from previous turns (Anthropic's recommendation)
+  const previousThinking = findLastThinkingContent(sessionID, messageID)
+
   const partId = `prt_0000000000_thinking`
   const part = {
     id: partId,
     sessionID,
     messageID,
     type: "thinking",
-    thinking: "",
+    thinking: previousThinking || "[Continuing from previous reasoning]",
     synthetic: true,
   }
 

src/hooks/thinking-block-validator/index.ts

@@ -0,0 +1,171 @@
+/**
+ * Proactive Thinking Block Validator Hook
+ *
+ * Prevents "Expected thinking/redacted_thinking but found tool_use" errors
+ * by validating and fixing message structure BEFORE sending to Anthropic API.
+ *
+ * This hook runs on the "experimental.chat.messages.transform" hook point,
+ * which is called before messages are converted to ModelMessage format and
+ * sent to the API.
+ *
+ * Key differences from session-recovery hook:
+ * - PROACTIVE (prevents error) vs REACTIVE (fixes after error)
+ * - Runs BEFORE API call vs AFTER API error
+ * - User never sees the error vs User sees error then recovery
+ */
+
+import type { Message, Part } from "@opencode-ai/sdk"
+
+interface MessageWithParts {
+  info: Message
+  parts: Part[]
+}
+
+type MessagesTransformHook = {
+  "experimental.chat.messages.transform"?: (
+    input: Record<string, never>,
+    output: { messages: MessageWithParts[] }
+  ) => Promise<void>
+}
+
+/**
+ * Check if a model has extended thinking enabled
+ * Uses patterns from think-mode/switcher.ts for consistency
+ */
+function isExtendedThinkingModel(modelID: string): boolean {
+  if (!modelID) return false
+  const lower = modelID.toLowerCase()
+
+  // Check for explicit thinking/high variants (always enabled)
+  if (lower.includes("thinking") || lower.endsWith("-high")) {
+    return true
+  }
+
+  // Check for thinking-capable models (claude-4 family, claude-3)
+  // Aligns with THINKING_CAPABLE_MODELS in think-mode/switcher.ts
+  return (
+    lower.includes("claude-sonnet-4") ||
+    lower.includes("claude-opus-4") ||
+    lower.includes("claude-3")
+  )
+}
+
+/**
+ * Check if a message has any content parts (tool_use, text, or other non-thinking content)
+ */
+function hasContentParts(parts: Part[]): boolean {
+  if (!parts || parts.length === 0) return false
+
+  return parts.some((part: Part) => {
+    const type = part.type as string
+    // Include tool parts and text parts (anything that's not thinking/reasoning)
+    return type === "tool" || type === "tool_use" || type === "text"
+  })
+}
+
+/**
+ * Check if a message starts with a thinking/reasoning block
+ */
+function startsWithThinkingBlock(parts: Part[]): boolean {
+  if (!parts || parts.length === 0) return false
+
+  const firstPart = parts[0]
+  const type = firstPart.type as string
+  return type === "thinking" || type === "reasoning"
+}
+
+/**
+ * Find the most recent thinking content from previous assistant messages
+ */
+function findPreviousThinkingContent(
+  messages: MessageWithParts[],
+  currentIndex: number
+): string {
+  // Search backwards from current message
+  for (let i = currentIndex - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (msg.info.role !== "assistant") continue
+
+    // Look for thinking parts
+    if (!msg.parts) continue
+    for (const part of msg.parts) {
+      const type = part.type as string
+      if (type === "thinking" || type === "reasoning") {
+        const thinking = (part as any).thinking || (part as any).text
+        if (thinking && typeof thinking === "string" && thinking.trim().length > 0) {
+          return thinking
+        }
+      }
+    }
+  }
+
+  return ""
+}
+
+/**
+ * Prepend a thinking block to a message's parts array
+ */
+function prependThinkingBlock(
+  message: MessageWithParts,
+  thinkingContent: string
+): void {
+  if (!message.parts) {
+    message.parts = []
+  }
+
+  // Create synthetic thinking part
+  const thinkingPart = {
+    type: "thinking" as const,
+    id: `prt_0000000000_synthetic_thinking`,
+    sessionID: (message.info as any).sessionID || "",
+    messageID: message.info.id,
+    thinking: thinkingContent,
+    synthetic: true,
+  }
+
+  // Prepend to parts array
+  message.parts.unshift(thinkingPart as unknown as Part)
+}
+
+/**
+ * Validate and fix assistant messages that have tool_use but no thinking block
+ */
+export function createThinkingBlockValidatorHook(): MessagesTransformHook {
+  return {
+    "experimental.chat.messages.transform": async (_input, output) => {
+      const { messages } = output
+
+      if (!messages || messages.length === 0) {
+        return
+      }
+
+      // Get the model info from the last user message
+      const lastUserMessage = messages.findLast(m => m.info.role === "user")
+      const modelID = (lastUserMessage?.info as any)?.modelID || ""
+
+      // Only process if extended thinking might be enabled
+      if (!isExtendedThinkingModel(modelID)) {
+        return
+      }
+
+      // Process all assistant messages
+      for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i]
+
+        // Only check assistant messages
+        if (msg.info.role !== "assistant") continue
+
+        // 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)
+
+          // Prepend thinking block with content from previous turn or placeholder
+          const thinkingContent = previousThinking || "[Continuing from previous reasoning]"
+
+          prependThinkingBlock(msg, thinkingContent)
+        }
+      }
+    },
+  }
+}

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"
 
@@ -37,6 +36,32 @@ 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 MIN_INJECTION_INTERVAL_MS = 10_000
+
+// ============================================================================
+// STATE MACHINE TYPES
+// ============================================================================
+
+type SessionMode =
+  | "idle"           // Observed idle, no countdown started yet
+  | "countingDown"   // Waiting N seconds before injecting
+  | "injecting"      // Currently calling session.prompt
+  | "recovering"     // Session recovery in progress (external control)
+  | "errorBypass"    // Bypass mode after session.error/interrupt
+
+interface SessionState {
+  version: number                          // Monotonic generation token - increment to invalidate pending callbacks
+  mode: SessionMode
+  timer?: ReturnType<typeof setTimeout>    // Pending countdown timer
+  lastAttemptedAt?: number                 // Timestamp of last injection attempt (throttle all attempts)
+}
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
 function getMessageDir(sessionID: string): string | null {
   if (!existsSync(MESSAGE_STORAGE)) return null
 
@@ -68,104 +93,354 @@ function detectInterrupt(error: unknown): boolean {
   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
 }
 
+// ============================================================================
+// MAIN IMPLEMENTATION
+// ============================================================================
+
 export function createTodoContinuationEnforcer(
   ctx: PluginInput,
   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>()
+  
+  // Single source of truth: per-session state machine
+  const sessions = new Map<string, SessionState>()
+
+  // ============================================================================
+  // STATE HELPERS
+  // ============================================================================
+
+  function getOrCreateState(sessionID: string): SessionState {
+    let state = sessions.get(sessionID)
+    if (!state) {
+      state = { version: 0, mode: "idle" }
+      sessions.set(sessionID, state)
+    }
+    return state
+  }
+
+  function clearTimer(state: SessionState): void {
+    if (state.timer) {
+      clearTimeout(state.timer)
+      state.timer = undefined
+    }
+  }
+
+  /**
+   * Invalidate any pending or in-flight operation by incrementing version.
+   * ALWAYS bumps version regardless of current mode to prevent last-mile races.
+   */
+  function invalidate(sessionID: string, reason: string): void {
+    const state = sessions.get(sessionID)
+    if (!state) return
+
+    // Skip if in recovery mode (external control)
+    if (state.mode === "recovering") return
+
+    state.version++
+    clearTimer(state)
+    
+    if (state.mode !== "idle" && state.mode !== "errorBypass") {
+      log(`[${HOOK_NAME}] Invalidated`, { sessionID, reason, prevMode: state.mode, newVersion: state.version })
+      state.mode = "idle"
+    }
+  }
+
+  /**
+   * Check if this is the main session (not a subagent session).
+   */
+  function isMainSession(sessionID: string): boolean {
+    const mainSessionID = getMainSessionID()
+    // If no main session is set, allow all. If set, only allow main.
+    return !mainSessionID || sessionID === mainSessionID
+  }
+
+  // ============================================================================
+  // EXTERNAL API
+  // ============================================================================
 
   const markRecovering = (sessionID: string): void => {
-    recoveringSessions.add(sessionID)
+    const state = getOrCreateState(sessionID)
+    invalidate(sessionID, "entering recovery mode")
+    state.mode = "recovering"
+    log(`[${HOOK_NAME}] Session marked as recovering`, { sessionID })
   }
 
   const markRecoveryComplete = (sessionID: string): void => {
-    recoveringSessions.delete(sessionID)
+    const state = sessions.get(sessionID)
+    if (state && state.mode === "recovering") {
+      state.mode = "idle"
+      log(`[${HOOK_NAME}] Session recovery complete`, { sessionID })
+    }
   }
 
+  // ============================================================================
+  // TOAST HELPER
+  // ============================================================================
+
+  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(() => {})
+  }
+
+  // ============================================================================
+  // CORE INJECTION LOGIC
+  // ============================================================================
+
+  async function executeInjection(sessionID: string, capturedVersion: number): Promise<void> {
+    const state = sessions.get(sessionID)
+    if (!state) return
+
+    // Version check: if version changed since we started, abort
+    if (state.version !== capturedVersion) {
+      log(`[${HOOK_NAME}] Injection aborted: version mismatch`, { 
+        sessionID, capturedVersion, currentVersion: state.version 
+      })
+      return
+    }
+
+    // Mode check: must still be in countingDown mode
+    if (state.mode !== "countingDown") {
+      log(`[${HOOK_NAME}] Injection aborted: mode changed`, { 
+        sessionID, mode: state.mode 
+      })
+      return
+    }
+
+    // Throttle check: minimum interval between injection attempts
+    if (state.lastAttemptedAt) {
+      const elapsed = Date.now() - state.lastAttemptedAt
+      if (elapsed < MIN_INJECTION_INTERVAL_MS) {
+        log(`[${HOOK_NAME}] Injection throttled: too soon since last injection`, { 
+          sessionID, elapsedMs: elapsed, minIntervalMs: MIN_INJECTION_INTERVAL_MS 
+        })
+        state.mode = "idle"
+        return
+      }
+    }
+
+    state.mode = "injecting"
+
+    // Re-verify todos (CRITICAL: always re-check before injecting)
+    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 for injection`, { sessionID, error: String(err) })
+      state.mode = "idle"
+      return
+    }
+
+    // Version check again after async operation
+    if (state.version !== capturedVersion) {
+      log(`[${HOOK_NAME}] Injection aborted after todo fetch: version mismatch`, { sessionID })
+      state.mode = "idle"
+      return
+    }
+
+    const incompleteCount = getIncompleteCount(todos)
+    if (incompleteCount === 0) {
+      log(`[${HOOK_NAME}] No incomplete todos at injection time`, { sessionID, total: todos.length })
+      state.mode = "idle"
+      return
+    }
+
+    // Skip entirely if background tasks are running (no false positives)
+    const hasRunningBgTasks = backgroundManager
+      ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running")
+      : false
+
+    if (hasRunningBgTasks) {
+      log(`[${HOOK_NAME}] Skipped: background tasks still running`, { sessionID })
+      state.mode = "idle"
+      return
+    }
+
+    // Get previous message agent info
+    const messageDir = getMessageDir(sessionID)
+    const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
+
+    // Check write permission
+    const agentHasWritePermission = !prevMessage?.tools || 
+      (prevMessage.tools.write !== false && prevMessage.tools.edit !== false)
+    
+    if (!agentHasWritePermission) {
+      log(`[${HOOK_NAME}] Skipped: agent lacks write permission`, {
+        sessionID, agent: prevMessage?.agent, tools: prevMessage?.tools
+      })
+      state.mode = "idle"
+      return
+    }
+
+    // Plan mode agents only analyze and plan, not implement - skip todo continuation
+    const agentName = prevMessage?.agent?.toLowerCase() ?? ""
+    const isPlanModeAgent = agentName === "plan" || agentName === "planner-sisyphus"
+    if (isPlanModeAgent) {
+      log(`[${HOOK_NAME}] Skipped: plan mode agent detected`, {
+        sessionID, agent: prevMessage?.agent
+      })
+      state.mode = "idle"
+      return
+    }
+
+    const prompt = `${CONTINUATION_PROMPT}\n\n[Status: ${todos.length - incompleteCount}/${todos.length} completed, ${incompleteCount} remaining]`
+
+    // Final version check right before API call (last-mile race mitigation)
+    if (state.version !== capturedVersion) {
+      log(`[${HOOK_NAME}] Injection aborted: version changed before API call`, { sessionID })
+      state.mode = "idle"
+      return
+    }
+
+    // Set lastAttemptedAt BEFORE calling API (throttle attempts, not just successes)
+    state.lastAttemptedAt = Date.now()
+
+    try {
+      log(`[${HOOK_NAME}] Injecting continuation prompt`, { 
+        sessionID, 
+        agent: prevMessage?.agent,
+        incompleteCount
+      })
+
+      await ctx.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          agent: prevMessage?.agent,
+          parts: [{ type: "text", text: prompt }],
+        },
+        query: { directory: ctx.directory },
+      })
+
+      log(`[${HOOK_NAME}] Continuation prompt injected successfully`, { sessionID })
+    } catch (err) {
+      log(`[${HOOK_NAME}] Prompt injection failed`, { sessionID, error: String(err) })
+    }
+
+    state.mode = "idle"
+  }
+
+  // ============================================================================
+  // COUNTDOWN STARTER
+  // ============================================================================
+
+  function startCountdown(sessionID: string, incompleteCount: number): void {
+    const state = getOrCreateState(sessionID)
+
+    // Cancel any existing countdown
+    invalidate(sessionID, "starting new countdown")
+
+    // Increment version for this new countdown
+    state.version++
+    state.mode = "countingDown"
+    const capturedVersion = state.version
+
+    log(`[${HOOK_NAME}] Starting countdown`, { 
+      sessionID, 
+      seconds: COUNTDOWN_SECONDS, 
+      version: capturedVersion,
+      incompleteCount
+    })
+
+    // Show initial toast
+    showCountdownToast(COUNTDOWN_SECONDS, incompleteCount)
+
+    // Show countdown toasts
+    let secondsRemaining = COUNTDOWN_SECONDS
+    const toastInterval = setInterval(() => {
+      // Check if countdown was cancelled
+      if (state.version !== capturedVersion) {
+        clearInterval(toastInterval)
+        return
+      }
+      secondsRemaining--
+      if (secondsRemaining > 0) {
+        showCountdownToast(secondsRemaining, incompleteCount)
+      }
+    }, 1000)
+
+    // Schedule the injection
+    state.timer = setTimeout(() => {
+      clearInterval(toastInterval)
+      clearTimer(state)
+      executeInjection(sessionID, capturedVersion)
+    }, COUNTDOWN_SECONDS * 1000)
+  }
+
+  // ============================================================================
+  // EVENT HANDLER
+  // ============================================================================
+
   const handler = async ({ event }: { event: { type: string; properties?: unknown } }): Promise<void> => {
     const props = event.properties as Record<string, unknown> | undefined
 
+    // -------------------------------------------------------------------------
+    // SESSION.ERROR - Enter error bypass mode
+    // -------------------------------------------------------------------------
     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 isInterrupt = detectInterrupt(props?.error)
+      const state = getOrCreateState(sessionID)
+      
+      invalidate(sessionID, isInterrupt ? "user interrupt" : "session error")
+      state.mode = "errorBypass"
+      
+      log(`[${HOOK_NAME}] session.error received`, { sessionID, isInterrupt, error: props?.error })
       return
     }
 
+    // -------------------------------------------------------------------------
+    // SESSION.IDLE - Main trigger for todo continuation
+    // -------------------------------------------------------------------------
     if (event.type === "session.idle") {
       const sessionID = props?.sessionID as string | undefined
       if (!sessionID) return
 
       log(`[${HOOK_NAME}] session.idle received`, { sessionID })
 
-      const mainSessionID = getMainSessionID()
-      if (mainSessionID && sessionID !== mainSessionID) {
-        log(`[${HOOK_NAME}] Skipped: not main session`, { sessionID, mainSessionID })
+      // Skip if not main session
+      if (!isMainSession(sessionID)) {
+        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 = getOrCreateState(sessionID)
 
-      // Check if session is in recovery mode - if so, skip entirely without clearing state
-      if (recoveringSessions.has(sessionID)) {
+      // Skip if in recovery mode
+      if (state.mode === "recovering") {
         log(`[${HOOK_NAME}] Skipped: session in recovery mode`, { 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 })
+      // Skip if in error bypass mode (DO NOT clear - wait for user message)
+      if (state.mode === "errorBypass") {
+        log(`[${HOOK_NAME}] Skipped: error bypass (awaiting user message to resume)`, { sessionID })
         return
       }
 
-      if (remindedSessions.has(sessionID)) {
-        log(`[${HOOK_NAME}] Skipped: already reminded this session`, { sessionID })
+      // Skip if already counting down or injecting
+      if (state.mode === "countingDown" || state.mode === "injecting") {
+        log(`[${HOOK_NAME}] Skipped: already ${state.mode}`, { sessionID })
         return
       }
 
-      // Check for incomplete todos BEFORE starting countdown
+      // Fetch todos
       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) })
         return
@@ -176,206 +451,107 @@ export function createTodoContinuationEnforcer(
         return
       }
 
-      const incomplete = todos.filter(
-        (t) => t.status !== "completed" && t.status !== "cancelled"
-      )
-
-      if (incomplete.length === 0) {
+      const incompleteCount = getIncompleteCount(todos)
+      if (incompleteCount === 0) {
         log(`[${HOOK_NAME}] All todos completed`, { sessionID, total: todos.length })
         return
       }
 
-      log(`[${HOOK_NAME}] Found incomplete todos, starting countdown`, { sessionID, incomplete: incomplete.length, total: todos.length })
+      // Skip if background tasks are running (avoid toast spam with no injection)
+      const hasRunningBgTasks = backgroundManager
+        ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running")
+        : false
 
-      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(() => {})
+      if (hasRunningBgTasks) {
+        log(`[${HOOK_NAME}] Skipped: background tasks still running`, { sessionID })
+        return
       }
 
-      const executeAfterCountdown = async (): Promise<void> => {
-        pendingCountdowns.delete(sessionID)
-        log(`[${HOOK_NAME}] Countdown finished, executing continuation`, { sessionID })
+      log(`[${HOOK_NAME}] Found incomplete todos`, { 
+        sessionID, 
+        incomplete: incompleteCount, 
+        total: todos.length 
+      })
 
-        // 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
-        }
-
-        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: ${todos.length - incomplete.length}/${todos.length} completed, ${incomplete.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)
+      return
     }
 
+    // -------------------------------------------------------------------------
+    // MESSAGE.UPDATED - Cancel countdown on activity
+    // -------------------------------------------------------------------------
     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
+
+      // User message: Always cancel countdown and clear errorBypass
+      if (role === "user") {
+        const state = sessions.get(sessionID)
+        if (state?.mode === "errorBypass") {
+          state.mode = "idle"
+          log(`[${HOOK_NAME}] User message cleared errorBypass mode`, { sessionID })
         }
-        remindedSessions.delete(sessionID)
-        preemptivelyInjectedSessions.delete(sessionID)
+        invalidate(sessionID, "user message received")
+        return
       }
 
-      if (sessionID && role === "assistant" && finish) {
-        remindedSessions.delete(sessionID)
-        log(`[${HOOK_NAME}] Cleared reminded 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)
-            }
-          }
-        }
+      // Assistant message WITHOUT finish: Agent is working, cancel countdown
+      if (role === "assistant" && !finish) {
+        invalidate(sessionID, "assistant is working (streaming)")
+        return
       }
+
+      // Assistant message WITH finish: Agent finished a turn (let session.idle handle it)
+      if (role === "assistant" && finish) {
+        log(`[${HOOK_NAME}] Assistant turn finished`, { sessionID, finish })
+        return
+      }
+      return
     }
 
+    // -------------------------------------------------------------------------
+    // MESSAGE.PART.UPDATED - Cancel countdown on streaming activity
+    // -------------------------------------------------------------------------
+    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") {
+        invalidate(sessionID, "assistant streaming")
+      }
+      return
+    }
+
+    // -------------------------------------------------------------------------
+    // TOOL EVENTS - Cancel countdown when tools are executing
+    // -------------------------------------------------------------------------
+    if (event.type === "tool.execute.before" || event.type === "tool.execute.after") {
+      const sessionID = props?.sessionID as string | undefined
+      if (sessionID) {
+        invalidate(sessionID, `tool execution (${event.type})`)
+      }
+      return
+    }
+
+    // -------------------------------------------------------------------------
+    // SESSION.DELETED - Cleanup
+    // -------------------------------------------------------------------------
     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)
+        const state = sessions.get(sessionInfo.id)
+        if (state) {
+          clearTimer(state)
         }
+        sessions.delete(sessionInfo.id)
+        log(`[${HOOK_NAME}] Session deleted, state cleaned up`, { sessionID: sessionInfo.id })
       }
+      return
     }
   }
 

src/hooks/tool-output-truncator.ts

@@ -24,7 +24,7 @@ interface ToolOutputTruncatorOptions {
 
 export function createToolOutputTruncatorHook(ctx: PluginInput, options?: ToolOutputTruncatorOptions) {
   const truncator = createDynamicTruncator(ctx)
-  const truncateAll = options?.experimental?.truncate_all_tool_outputs ?? false
+  const truncateAll = options?.experimental?.truncate_all_tool_outputs ?? true
 
   const toolExecuteAfter = async (
     input: { tool: string; sessionID: string; callID: string },

src/index.ts

@@ -23,6 +23,7 @@ import {
   createNonInteractiveEnvHook,
   createInteractiveBashSessionHook,
   createEmptyMessageSanitizerHook,
+  createThinkingBlockValidatorHook,
 } from "./hooks";
 import { createGoogleAntigravityAuthPlugin } from "./auth/antigravity";
 import {
@@ -31,15 +32,14 @@ import {
   loadOpencodeGlobalCommands,
   loadOpencodeProjectCommands,
 } from "./features/claude-code-command-loader";
-import {
-  loadUserSkillsAsCommands,
-  loadProjectSkillsAsCommands,
-} from "./features/claude-code-skill-loader";
+import { loadBuiltinCommands } from "./features/builtin-commands";
+
 import {
   loadUserAgents,
   loadProjectAgents,
 } from "./features/claude-code-agent-loader";
 import { loadMcpConfigs } from "./features/claude-code-mcp-loader";
+import { loadAllPluginComponents } from "./features/claude-code-plugin-loader";
 import {
   setMainSession,
   getMainSessionID,
@@ -48,7 +48,7 @@ import { builtinTools, createCallOmoAgent, createBackgroundTools, createLookAt,
 import { BackgroundManager } from "./features/background-agent";
 import { createBuiltinMcps } from "./mcp";
 import { OhMyOpenCodeConfigSchema, type OhMyOpenCodeConfig, type HookName } from "./config";
-import { log, deepMerge, getUserConfigDir, addConfigLoadError } from "./shared";
+import { log, deepMerge, getUserConfigDir, addConfigLoadError, parseJsonc, detectConfigFile } from "./shared";
 import { PLAN_SYSTEM_PROMPT, PLAN_PERMISSION } from "./agents/plan-prompt";
 import * as fs from "fs";
 import * as path from "path";
@@ -116,11 +116,11 @@ function migrateConfigFile(configPath: string, rawConfig: Record<string, unknown
   return needsWrite;
 }
 
-function loadConfigFromPath(configPath: string): OhMyOpenCodeConfig | null {
+function loadConfigFromPath(configPath: string, ctx: any): OhMyOpenCodeConfig | null {
   try {
     if (fs.existsSync(configPath)) {
       const content = fs.readFileSync(configPath, "utf-8");
-      const rawConfig = JSON.parse(content);
+      const rawConfig = parseJsonc<Record<string, unknown>>(content);
 
       migrateConfigFile(configPath, rawConfig);
 
@@ -170,30 +170,32 @@ function mergeConfigs(
         ...(override.disabled_hooks ?? []),
       ]),
     ],
+    disabled_commands: [
+      ...new Set([
+        ...(base.disabled_commands ?? []),
+        ...(override.disabled_commands ?? []),
+      ]),
+    ],
     claude_code: deepMerge(base.claude_code, override.claude_code),
   };
 }
 
-function loadPluginConfig(directory: string): OhMyOpenCodeConfig {
-  // User-level config path (OS-specific)
-  const userConfigPath = path.join(
-    getUserConfigDir(),
-    "opencode",
-    "oh-my-opencode.json"
-  );
+function loadPluginConfig(directory: string, ctx: any): OhMyOpenCodeConfig {
+  // User-level config path (OS-specific) - prefer .jsonc over .json
+  const userBasePath = path.join(getUserConfigDir(), "opencode", "oh-my-opencode");
+  const userDetected = detectConfigFile(userBasePath);
+  const userConfigPath = userDetected.format !== "none" ? userDetected.path : userBasePath + ".json";
 
-  // Project-level config path
-  const projectConfigPath = path.join(
-    directory,
-    ".opencode",
-    "oh-my-opencode.json"
-  );
+  // Project-level config path - prefer .jsonc over .json
+  const projectBasePath = path.join(directory, ".opencode", "oh-my-opencode");
+  const projectDetected = detectConfigFile(projectBasePath);
+  const projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : projectBasePath + ".json";
 
   // Load user config first (base)
-  let config: OhMyOpenCodeConfig = loadConfigFromPath(userConfigPath) ?? {};
+  let config: OhMyOpenCodeConfig = loadConfigFromPath(userConfigPath, ctx) ?? {};
 
   // Override with project config
-  const projectConfig = loadConfigFromPath(projectConfigPath);
+  const projectConfig = loadConfigFromPath(projectConfigPath, ctx);
   if (projectConfig) {
     config = mergeConfigs(config, projectConfig);
   }
@@ -209,7 +211,7 @@ function loadPluginConfig(directory: string): OhMyOpenCodeConfig {
 }
 
 const OhMyOpenCodePlugin: Plugin = async (ctx) => {
-  const pluginConfig = loadPluginConfig(ctx.directory);
+  const pluginConfig = loadPluginConfig(ctx.directory, ctx);
   const disabledHooks = new Set(pluginConfig.disabled_hooks ?? []);
   const isHookEnabled = (hookName: HookName) => !disabledHooks.has(hookName);
 
@@ -238,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 })
@@ -292,6 +294,9 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
   const emptyMessageSanitizer = isHookEnabled("empty-message-sanitizer")
     ? createEmptyMessageSanitizerHook()
     : null;
+  const thinkingBlockValidator = isHookEnabled("thinking-block-validator")
+    ? createThinkingBlockValidatorHook()
+    : null;
 
   const backgroundManager = new BackgroundManager(ctx);
 
@@ -338,6 +343,8 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
       input: Record<string, never>,
       output: { messages: Array<{ info: unknown; parts: unknown[] }> }
     ) => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await thinkingBlockValidator?.["experimental.chat.messages.transform"]?.(input, output as any);
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       await emptyMessageSanitizer?.["experimental.chat.messages.transform"]?.(input, output as any);
     },
@@ -368,6 +375,22 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
         }
       }
 
+      const pluginComponents = (pluginConfig.claude_code?.plugins ?? true)
+        ? await loadAllPluginComponents({
+            enabledPluginsOverride: pluginConfig.claude_code?.plugins_override,
+          })
+        : { commands: {}, skills: {}, agents: {}, mcpServers: {}, hooksConfigs: [], plugins: [], errors: [] };
+
+      if (pluginComponents.plugins.length > 0) {
+        log(`Loaded ${pluginComponents.plugins.length} Claude Code plugins`, {
+          plugins: pluginComponents.plugins.map(p => `${p.name}@${p.version}`),
+        });
+      }
+
+      if (pluginComponents.errors.length > 0) {
+        log(`Plugin load errors`, { errors: pluginComponents.errors });
+      }
+
       const builtinAgents = createBuiltinAgents(
         pluginConfig.disabled_agents,
         pluginConfig.agents,
@@ -377,42 +400,77 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
 
       const userAgents = (pluginConfig.claude_code?.agents ?? true) ? loadUserAgents() : {};
       const projectAgents = (pluginConfig.claude_code?.agents ?? true) ? loadProjectAgents() : {};
+      const pluginAgents = pluginComponents.agents;
 
       const isSisyphusEnabled = pluginConfig.sisyphus_agent?.disabled !== true;
+      const builderEnabled = pluginConfig.sisyphus_agent?.default_builder_enabled ?? false;
+      const plannerEnabled = pluginConfig.sisyphus_agent?.planner_enabled ?? true;
+      const replacePlan = pluginConfig.sisyphus_agent?.replace_plan ?? true;
 
       if (isSisyphusEnabled && builtinAgents.Sisyphus) {
-        // TODO: When OpenCode releases `default_agent` config option (PR #5313),
-        // use `config.default_agent = "Sisyphus"` instead of demoting build/plan.
-        // Tracking: https://github.com/sst/opencode/pull/5313
-        const { name: _planName, ...planConfigWithoutName } = config.agent?.plan ?? {};
-        const plannerSisyphusOverride = pluginConfig.agents?.["Planner-Sisyphus"];
-        const plannerSisyphusBase = {
-          ...planConfigWithoutName,
-          prompt: PLAN_SYSTEM_PROMPT,
-          permission: PLAN_PERMISSION,
-          description: `${config.agent?.plan?.description ?? "Plan agent"} (OhMyOpenCode version)`,
-          color: config.agent?.plan?.color ?? "#6495ED",
+        // Set Sisyphus as default agent (feature added in OpenCode PR #5843)
+        (config as { default_agent?: string }).default_agent = "Sisyphus";
+
+        const agentConfig: Record<string, unknown> = {
+          Sisyphus: builtinAgents.Sisyphus,
         };
 
-        const plannerSisyphusConfig = plannerSisyphusOverride
-          ? { ...plannerSisyphusBase, ...plannerSisyphusOverride }
-          : plannerSisyphusBase;
+        if (builderEnabled) {
+          const { name: _buildName, ...buildConfigWithoutName } = config.agent?.build ?? {};
+          const openCodeBuilderOverride = pluginConfig.agents?.["OpenCode-Builder"];
+          const openCodeBuilderBase = {
+            ...buildConfigWithoutName,
+            description: `${config.agent?.build?.description ?? "Build agent"} (OpenCode default)`,
+          };
+
+          agentConfig["OpenCode-Builder"] = openCodeBuilderOverride
+            ? { ...openCodeBuilderBase, ...openCodeBuilderOverride }
+            : openCodeBuilderBase;
+        }
+
+        if (plannerEnabled) {
+          const { name: _planName, ...planConfigWithoutName } = config.agent?.plan ?? {};
+          const plannerSisyphusOverride = pluginConfig.agents?.["Planner-Sisyphus"];
+          const plannerSisyphusBase = {
+            ...planConfigWithoutName,
+            prompt: PLAN_SYSTEM_PROMPT,
+            permission: PLAN_PERMISSION,
+            description: `${config.agent?.plan?.description ?? "Plan agent"} (OhMyOpenCode version)`,
+            color: config.agent?.plan?.color ?? "#6495ED",
+          };
+
+          agentConfig["Planner-Sisyphus"] = plannerSisyphusOverride
+            ? { ...plannerSisyphusBase, ...plannerSisyphusOverride }
+            : plannerSisyphusBase;
+        }
+
+        // Filter out build/plan from config.agent - they'll be re-added as subagents if replaced
+        const filteredConfigAgents = config.agent ? 
+          Object.fromEntries(
+            Object.entries(config.agent).filter(([key]) => {
+              if (key === "build") return false;
+              if (key === "plan" && replacePlan) return false;
+              return true;
+            })
+          ) : {};
 
         config.agent = {
-          Sisyphus: builtinAgents.Sisyphus,
-          "Planner-Sisyphus": plannerSisyphusConfig,
+          ...agentConfig,
           ...Object.fromEntries(Object.entries(builtinAgents).filter(([k]) => k !== "Sisyphus")),
           ...userAgents,
           ...projectAgents,
-          ...config.agent,
+          ...pluginAgents,
+          ...filteredConfigAgents,  // Filtered config agents (excludes build/plan if replaced)
+          // Demote build/plan to subagent mode when replaced
           build: { ...config.agent?.build, mode: "subagent" },
-          plan: { ...config.agent?.plan, mode: "subagent" },
+          ...(replacePlan ? { plan: { ...config.agent?.plan, mode: "subagent" } } : {}),
         };
       } else {
         config.agent = {
           ...builtinAgents,
           ...userAgents,
           ...projectAgents,
+          ...pluginAgents,
           ...config.agent,
         };
       }
@@ -451,28 +509,28 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
       const mcpResult = (pluginConfig.claude_code?.mcp ?? true)
         ? await loadMcpConfigs()
         : { servers: {} };
+
       config.mcp = {
         ...config.mcp,
         ...createBuiltinMcps(pluginConfig.disabled_mcps),
         ...mcpResult.servers,
+        ...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();
-      const userSkills = (pluginConfig.claude_code?.skills ?? true) ? loadUserSkillsAsCommands() : {};
-      const projectSkills = (pluginConfig.claude_code?.skills ?? true) ? loadProjectSkillsAsCommands() : {};
-
       config.command = {
+        ...builtinCommands,
         ...userCommands,
-        ...userSkills,
         ...opencodeGlobalCommands,
         ...systemCommands,
         ...projectCommands,
-        ...projectSkills,
         ...opencodeProjectCommands,
+        ...pluginComponents.commands,
       };
     },
 
@@ -583,6 +641,7 @@ export type {
   AgentOverrides,
   McpName,
   HookName,
+  BuiltinCommandName,
 } from "./config";
 
 // NOTE: Do NOT export functions from main index.ts!

src/shared/claude-config-dir.test.ts

@@ -0,0 +1,60 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { getClaudeConfigDir } from "./claude-config-dir"
+
+describe("getClaudeConfigDir", () => {
+  let originalEnv: string | undefined
+
+  beforeEach(() => {
+    originalEnv = process.env.CLAUDE_CONFIG_DIR
+  })
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.CLAUDE_CONFIG_DIR = originalEnv
+    } else {
+      delete process.env.CLAUDE_CONFIG_DIR
+    }
+  })
+
+  test("returns CLAUDE_CONFIG_DIR when env var is set", () => {
+    process.env.CLAUDE_CONFIG_DIR = "/custom/claude/path"
+    
+    const result = getClaudeConfigDir()
+    
+    expect(result).toBe("/custom/claude/path")
+  })
+
+  test("returns ~/.claude when env var is not set", () => {
+    delete process.env.CLAUDE_CONFIG_DIR
+    
+    const result = getClaudeConfigDir()
+    
+    expect(result).toBe(join(homedir(), ".claude"))
+  })
+
+  test("returns ~/.claude when env var is empty string", () => {
+    process.env.CLAUDE_CONFIG_DIR = ""
+    
+    const result = getClaudeConfigDir()
+    
+    expect(result).toBe(join(homedir(), ".claude"))
+  })
+
+  test("handles absolute paths with trailing slash", () => {
+    process.env.CLAUDE_CONFIG_DIR = "/custom/path/"
+    
+    const result = getClaudeConfigDir()
+    
+    expect(result).toBe("/custom/path/")
+  })
+
+  test("handles relative paths", () => {
+    process.env.CLAUDE_CONFIG_DIR = "./my-claude-config"
+    
+    const result = getClaudeConfigDir()
+    
+    expect(result).toBe("./my-claude-config")
+  })
+})

src/shared/claude-config-dir.ts

@@ -0,0 +1,11 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export function getClaudeConfigDir(): string {
+  const envConfigDir = process.env.CLAUDE_CONFIG_DIR
+  if (envConfigDir) {
+    return envConfigDir
+  }
+  
+  return join(homedir(), ".claude")
+}

src/shared/data-path.ts

@@ -0,0 +1,22 @@
+import * as path from "node:path"
+import * as os from "node:os"
+
+/**
+ * Returns the user-level data directory.
+ * Matches OpenCode's behavior via xdg-basedir:
+ * - All platforms: XDG_DATA_HOME or ~/.local/share
+ *
+ * Note: OpenCode uses xdg-basedir which returns ~/.local/share on ALL platforms
+ * including Windows, so we match that behavior exactly.
+ */
+export function getDataDir(): string {
+  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share")
+}
+
+/**
+ * Returns the OpenCode storage directory path.
+ * All platforms: ~/.local/share/opencode/storage
+ */
+export function getOpenCodeStorageDir(): string {
+  return path.join(getDataDir(), "opencode", "storage")
+}

src/shared/dynamic-truncator.ts

@@ -1,164 +1,189 @@
-import type { PluginInput } from "@opencode-ai/plugin"
+import type { PluginInput } from "@opencode-ai/plugin";
 
-const ANTHROPIC_ACTUAL_LIMIT = 200_000
-const CHARS_PER_TOKEN_ESTIMATE = 4
-const DEFAULT_TARGET_MAX_TOKENS = 50_000
+const ANTHROPIC_ACTUAL_LIMIT = 200_000;
+const CHARS_PER_TOKEN_ESTIMATE = 4;
+const DEFAULT_TARGET_MAX_TOKENS = 50_000;
 
 interface AssistantMessageInfo {
-  role: "assistant"
-  tokens: {
-    input: number
-    output: number
-    reasoning: number
-    cache: { read: number; write: number }
-  }
+	role: "assistant";
+	tokens: {
+		input: number;
+		output: number;
+		reasoning: number;
+		cache: { read: number; write: number };
+	};
 }
 
 interface MessageWrapper {
-  info: { role: string } & Partial<AssistantMessageInfo>
+	info: { role: string } & Partial<AssistantMessageInfo>;
 }
 
 export interface TruncationResult {
-  result: string
-  truncated: boolean
-  removedCount?: number
+	result: string;
+	truncated: boolean;
+	removedCount?: number;
 }
 
 export interface TruncationOptions {
-  targetMaxTokens?: number
-  preserveHeaderLines?: number
-  contextWindowLimit?: number
+	targetMaxTokens?: number;
+	preserveHeaderLines?: number;
+	contextWindowLimit?: number;
 }
 
 function estimateTokens(text: string): number {
-  return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE)
+	return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE);
 }
 
 export function truncateToTokenLimit(
-  output: string,
-  maxTokens: number,
-  preserveHeaderLines = 3
+	output: string,
+	maxTokens: number,
+	preserveHeaderLines = 3,
 ): TruncationResult {
-  const currentTokens = estimateTokens(output)
+	const currentTokens = estimateTokens(output);
 
-  if (currentTokens <= maxTokens) {
-    return { result: output, truncated: false }
-  }
+	if (currentTokens <= maxTokens) {
+		return { result: output, truncated: false };
+	}
 
-  const lines = output.split("\n")
+	const lines = output.split("\n");
 
-  if (lines.length <= preserveHeaderLines) {
-    const maxChars = maxTokens * CHARS_PER_TOKEN_ESTIMATE
-    return {
-      result: output.slice(0, maxChars) + "\n\n[Output truncated due to context window limit]",
-      truncated: true,
-    }
-  }
+	if (lines.length <= preserveHeaderLines) {
+		const maxChars = maxTokens * CHARS_PER_TOKEN_ESTIMATE;
+		return {
+			result:
+				output.slice(0, maxChars) +
+				"\n\n[Output truncated due to context window limit]",
+			truncated: true,
+		};
+	}
 
-  const headerLines = lines.slice(0, preserveHeaderLines)
-  const contentLines = lines.slice(preserveHeaderLines)
+	const headerLines = lines.slice(0, preserveHeaderLines);
+	const contentLines = lines.slice(preserveHeaderLines);
 
-  const headerText = headerLines.join("\n")
-  const headerTokens = estimateTokens(headerText)
-  const truncationMessageTokens = 50
-  const availableTokens = maxTokens - headerTokens - truncationMessageTokens
+	const headerText = headerLines.join("\n");
+	const headerTokens = estimateTokens(headerText);
+	const truncationMessageTokens = 50;
+	const availableTokens = maxTokens - headerTokens - truncationMessageTokens;
 
-  if (availableTokens <= 0) {
-    return {
-      result: headerText + "\n\n[Content truncated due to context window limit]",
-      truncated: true,
-      removedCount: contentLines.length,
-    }
-  }
+	if (availableTokens <= 0) {
+		return {
+			result:
+				headerText + "\n\n[Content truncated due to context window limit]",
+			truncated: true,
+			removedCount: contentLines.length,
+		};
+	}
 
-  const resultLines: string[] = []
-  let currentTokenCount = 0
+	const resultLines: string[] = [];
+	let currentTokenCount = 0;
 
-  for (const line of contentLines) {
-    const lineTokens = estimateTokens(line + "\n")
-    if (currentTokenCount + lineTokens > availableTokens) {
-      break
-    }
-    resultLines.push(line)
-    currentTokenCount += lineTokens
-  }
+	for (const line of contentLines) {
+		const lineTokens = estimateTokens(line + "\n");
+		if (currentTokenCount + lineTokens > availableTokens) {
+			break;
+		}
+		resultLines.push(line);
+		currentTokenCount += lineTokens;
+	}
 
-  const truncatedContent = [...headerLines, ...resultLines].join("\n")
-  const removedCount = contentLines.length - resultLines.length
+	const truncatedContent = [...headerLines, ...resultLines].join("\n");
+	const removedCount = contentLines.length - resultLines.length;
 
-  return {
-    result: truncatedContent + `\n\n[${removedCount} more lines truncated due to context window limit]`,
-    truncated: true,
-    removedCount,
-  }
+	return {
+		result:
+			truncatedContent +
+			`\n\n[${removedCount} more lines truncated due to context window limit]`,
+		truncated: true,
+		removedCount,
+	};
 }
 
 export async function getContextWindowUsage(
-  ctx: PluginInput,
-  sessionID: string
-): Promise<{ usedTokens: number; remainingTokens: number; usagePercentage: number } | null> {
-  try {
-    const response = await ctx.client.session.messages({
-      path: { id: sessionID },
-    })
+	ctx: PluginInput,
+	sessionID: string,
+): Promise<{
+	usedTokens: number;
+	remainingTokens: number;
+	usagePercentage: number;
+} | null> {
+	try {
+		const response = await ctx.client.session.messages({
+			path: { id: sessionID },
+		});
 
-    const messages = (response.data ?? response) as MessageWrapper[]
+		const messages = (response.data ?? response) as MessageWrapper[];
 
-    const assistantMessages = messages
-      .filter((m) => m.info.role === "assistant")
-      .map((m) => m.info as AssistantMessageInfo)
+		const assistantMessages = messages
+			.filter((m) => m.info.role === "assistant")
+			.map((m) => m.info as AssistantMessageInfo);
 
-    if (assistantMessages.length === 0) return null
+		if (assistantMessages.length === 0) return null;
 
-    const lastAssistant = assistantMessages[assistantMessages.length - 1]
-    const lastTokens = lastAssistant.tokens
-    const usedTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0)
-    const remainingTokens = ANTHROPIC_ACTUAL_LIMIT - usedTokens
+		const lastAssistant = assistantMessages[assistantMessages.length - 1];
+		const lastTokens = lastAssistant.tokens;
+		const usedTokens =
+			(lastTokens?.input ?? 0) +
+			(lastTokens?.cache?.read ?? 0) +
+			(lastTokens?.output ?? 0);
+		const remainingTokens = ANTHROPIC_ACTUAL_LIMIT - usedTokens;
 
-    return {
-      usedTokens,
-      remainingTokens,
-      usagePercentage: usedTokens / ANTHROPIC_ACTUAL_LIMIT,
-    }
-  } catch {
-    return null
-  }
+		return {
+			usedTokens,
+			remainingTokens,
+			usagePercentage: usedTokens / ANTHROPIC_ACTUAL_LIMIT,
+		};
+	} catch {
+		return null;
+	}
 }
 
 export async function dynamicTruncate(
-  ctx: PluginInput,
-  sessionID: string,
-  output: string,
-  options: TruncationOptions = {}
+	ctx: PluginInput,
+	sessionID: string,
+	output: string,
+	options: TruncationOptions = {},
 ): Promise<TruncationResult> {
-  const { targetMaxTokens = DEFAULT_TARGET_MAX_TOKENS, preserveHeaderLines = 3 } = options
+	const {
+		targetMaxTokens = DEFAULT_TARGET_MAX_TOKENS,
+		preserveHeaderLines = 3,
+	} = options;
 
-  const usage = await getContextWindowUsage(ctx, sessionID)
+	const usage = await getContextWindowUsage(ctx, sessionID);
 
-  if (!usage) {
-    return { result: output, truncated: false }
-  }
+	if (!usage) {
+		// Fallback: apply conservative truncation when context usage unavailable
+		return truncateToTokenLimit(output, targetMaxTokens, preserveHeaderLines);
+	}
 
-  const maxOutputTokens = Math.min(usage.remainingTokens * 0.5, targetMaxTokens)
+	const maxOutputTokens = Math.min(
+		usage.remainingTokens * 0.5,
+		targetMaxTokens,
+	);
 
-  if (maxOutputTokens <= 0) {
-    return {
-      result: "[Output suppressed - context window exhausted]",
-      truncated: true,
-    }
-  }
+	if (maxOutputTokens <= 0) {
+		return {
+			result: "[Output suppressed - context window exhausted]",
+			truncated: true,
+		};
+	}
 
-  return truncateToTokenLimit(output, maxOutputTokens, preserveHeaderLines)
+	return truncateToTokenLimit(output, maxOutputTokens, preserveHeaderLines);
 }
 
 export function createDynamicTruncator(ctx: PluginInput) {
-  return {
-    truncate: (sessionID: string, output: string, options?: TruncationOptions) =>
-      dynamicTruncate(ctx, sessionID, output, options),
+	return {
+		truncate: (
+			sessionID: string,
+			output: string,
+			options?: TruncationOptions,
+		) => dynamicTruncate(ctx, sessionID, output, options),
 
-    getUsage: (sessionID: string) => getContextWindowUsage(ctx, sessionID),
+		getUsage: (sessionID: string) => getContextWindowUsage(ctx, sessionID),
 
-    truncateSync: (output: string, maxTokens: number, preserveHeaderLines?: number) =>
-      truncateToTokenLimit(output, maxTokens, preserveHeaderLines),
-  }
+		truncateSync: (
+			output: string,
+			maxTokens: number,
+			preserveHeaderLines?: number,
+		) => truncateToTokenLimit(output, maxTokens, preserveHeaderLines),
+	};
 }

src/shared/index.ts

@@ -11,4 +11,7 @@ export * from "./deep-merge"
 export * from "./file-utils"
 export * from "./dynamic-truncator"
 export * from "./config-path"
+export * from "./data-path"
 export * from "./config-errors"
+export * from "./claude-config-dir"
+export * from "./jsonc-parser"

src/shared/jsonc-parser.test.ts

@@ -0,0 +1,266 @@
+import { describe, expect, test } from "bun:test"
+import { detectConfigFile, parseJsonc, parseJsoncSafe, readJsoncFile } from "./jsonc-parser"
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+
+describe("parseJsonc", () => {
+  test("parses plain JSON", () => {
+    //#given
+    const json = `{"key": "value"}`
+
+    //#when
+    const result = parseJsonc<{ key: string }>(json)
+
+    //#then
+    expect(result.key).toBe("value")
+  })
+
+  test("parses JSONC with line comments", () => {
+    //#given
+    const jsonc = `{
+      // This is a comment
+      "key": "value"
+    }`
+
+    //#when
+    const result = parseJsonc<{ key: string }>(jsonc)
+
+    //#then
+    expect(result.key).toBe("value")
+  })
+
+  test("parses JSONC with block comments", () => {
+    //#given
+    const jsonc = `{
+      /* Block comment */
+      "key": "value"
+    }`
+
+    //#when
+    const result = parseJsonc<{ key: string }>(jsonc)
+
+    //#then
+    expect(result.key).toBe("value")
+  })
+
+  test("parses JSONC with multi-line block comments", () => {
+    //#given
+    const jsonc = `{
+      /* Multi-line
+         comment
+         here */
+      "key": "value"
+    }`
+
+    //#when
+    const result = parseJsonc<{ key: string }>(jsonc)
+
+    //#then
+    expect(result.key).toBe("value")
+  })
+
+  test("parses JSONC with trailing commas", () => {
+    //#given
+    const jsonc = `{
+      "key1": "value1",
+      "key2": "value2",
+    }`
+
+    //#when
+    const result = parseJsonc<{ key1: string; key2: string }>(jsonc)
+
+    //#then
+    expect(result.key1).toBe("value1")
+    expect(result.key2).toBe("value2")
+  })
+
+  test("parses JSONC with trailing comma in array", () => {
+    //#given
+    const jsonc = `{
+      "arr": [1, 2, 3,]
+    }`
+
+    //#when
+    const result = parseJsonc<{ arr: number[] }>(jsonc)
+
+    //#then
+    expect(result.arr).toEqual([1, 2, 3])
+  })
+
+  test("preserves URLs with // in strings", () => {
+    //#given
+    const jsonc = `{
+      "url": "https://example.com"
+    }`
+
+    //#when
+    const result = parseJsonc<{ url: string }>(jsonc)
+
+    //#then
+    expect(result.url).toBe("https://example.com")
+  })
+
+  test("parses complex JSONC config", () => {
+    //#given
+    const jsonc = `{
+      // This is an example config
+      "agents": {
+        "oracle": { "model": "openai/gpt-5.2" }, // GPT for strategic reasoning
+      },
+      /* Agent overrides */
+      "disabled_agents": [],
+    }`
+
+    //#when
+    const result = parseJsonc<{
+      agents: { oracle: { model: string } }
+      disabled_agents: string[]
+    }>(jsonc)
+
+    //#then
+    expect(result.agents.oracle.model).toBe("openai/gpt-5.2")
+    expect(result.disabled_agents).toEqual([])
+  })
+
+  test("throws on invalid JSON", () => {
+    //#given
+    const invalid = `{ "key": invalid }`
+
+    //#when
+    //#then
+    expect(() => parseJsonc(invalid)).toThrow()
+  })
+
+  test("throws on unclosed string", () => {
+    //#given
+    const invalid = `{ "key": "unclosed }`
+
+    //#when
+    //#then
+    expect(() => parseJsonc(invalid)).toThrow()
+  })
+})
+
+describe("parseJsoncSafe", () => {
+  test("returns data on valid JSONC", () => {
+    //#given
+    const jsonc = `{ "key": "value" }`
+
+    //#when
+    const result = parseJsoncSafe<{ key: string }>(jsonc)
+
+    //#then
+    expect(result.data).not.toBeNull()
+    expect(result.data?.key).toBe("value")
+    expect(result.errors).toHaveLength(0)
+  })
+
+  test("returns errors on invalid JSONC", () => {
+    //#given
+    const invalid = `{ "key": invalid }`
+
+    //#when
+    const result = parseJsoncSafe(invalid)
+
+    //#then
+    expect(result.data).toBeNull()
+    expect(result.errors.length).toBeGreaterThan(0)
+  })
+})
+
+describe("readJsoncFile", () => {
+  const testDir = join(__dirname, ".test-jsonc")
+  const testFile = join(testDir, "config.jsonc")
+
+  test("reads and parses valid JSONC file", () => {
+    //#given
+    if (!existsSync(testDir)) mkdirSync(testDir, { recursive: true })
+    const content = `{
+      // Comment
+      "test": "value"
+    }`
+    writeFileSync(testFile, content)
+
+    //#when
+    const result = readJsoncFile<{ test: string }>(testFile)
+
+    //#then
+    expect(result).not.toBeNull()
+    expect(result?.test).toBe("value")
+
+    rmSync(testDir, { recursive: true, force: true })
+  })
+
+  test("returns null for non-existent file", () => {
+    //#given
+    const nonExistent = join(testDir, "does-not-exist.jsonc")
+
+    //#when
+    const result = readJsoncFile(nonExistent)
+
+    //#then
+    expect(result).toBeNull()
+  })
+
+  test("returns null for malformed JSON", () => {
+    //#given
+    if (!existsSync(testDir)) mkdirSync(testDir, { recursive: true })
+    writeFileSync(testFile, "{ invalid }")
+
+    //#when
+    const result = readJsoncFile(testFile)
+
+    //#then
+    expect(result).toBeNull()
+
+    rmSync(testDir, { recursive: true, force: true })
+  })
+})
+
+describe("detectConfigFile", () => {
+  const testDir = join(__dirname, ".test-detect")
+
+  test("prefers .jsonc over .json", () => {
+    //#given
+    if (!existsSync(testDir)) mkdirSync(testDir, { recursive: true })
+    const basePath = join(testDir, "config")
+    writeFileSync(`${basePath}.json`, "{}")
+    writeFileSync(`${basePath}.jsonc`, "{}")
+
+    //#when
+    const result = detectConfigFile(basePath)
+
+    //#then
+    expect(result.format).toBe("jsonc")
+    expect(result.path).toBe(`${basePath}.jsonc`)
+
+    rmSync(testDir, { recursive: true, force: true })
+  })
+
+  test("detects .json when .jsonc doesn't exist", () => {
+    //#given
+    if (!existsSync(testDir)) mkdirSync(testDir, { recursive: true })
+    const basePath = join(testDir, "config")
+    writeFileSync(`${basePath}.json`, "{}")
+
+    //#when
+    const result = detectConfigFile(basePath)
+
+    //#then
+    expect(result.format).toBe("json")
+    expect(result.path).toBe(`${basePath}.json`)
+
+    rmSync(testDir, { recursive: true, force: true })
+  })
+
+  test("returns none when neither exists", () => {
+    //#given
+    const basePath = join(testDir, "nonexistent")
+
+    //#when
+    const result = detectConfigFile(basePath)
+
+    //#then
+    expect(result.format).toBe("none")
+  })
+})

src/shared/jsonc-parser.ts

@@ -0,0 +1,66 @@
+import { existsSync, readFileSync } from "node:fs"
+import { parse, ParseError, printParseErrorCode } from "jsonc-parser"
+
+export interface JsoncParseResult<T> {
+  data: T | null
+  errors: Array<{ message: string; offset: number; length: number }>
+}
+
+export function parseJsonc<T = unknown>(content: string): T {
+  const errors: ParseError[] = []
+  const result = parse(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false,
+  }) as T
+
+  if (errors.length > 0) {
+    const errorMessages = errors
+      .map((e) => `${printParseErrorCode(e.error)} at offset ${e.offset}`)
+      .join(", ")
+    throw new SyntaxError(`JSONC parse error: ${errorMessages}`)
+  }
+
+  return result
+}
+
+export function parseJsoncSafe<T = unknown>(content: string): JsoncParseResult<T> {
+  const errors: ParseError[] = []
+  const data = parse(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false,
+  }) as T | null
+
+  return {
+    data: errors.length > 0 ? null : data,
+    errors: errors.map((e) => ({
+      message: printParseErrorCode(e.error),
+      offset: e.offset,
+      length: e.length,
+    })),
+  }
+}
+
+export function readJsoncFile<T = unknown>(filePath: string): T | null {
+  try {
+    const content = readFileSync(filePath, "utf-8")
+    return parseJsonc<T>(content)
+  } catch {
+    return null
+  }
+}
+
+export function detectConfigFile(basePath: string): {
+  format: "json" | "jsonc" | "none"
+  path: string
+} {
+  const jsoncPath = `${basePath}.jsonc`
+  const jsonPath = `${basePath}.json`
+
+  if (existsSync(jsoncPath)) {
+    return { format: "jsonc", path: jsoncPath }
+  }
+  if (existsSync(jsonPath)) {
+    return { format: "json", path: jsonPath }
+  }
+  return { format: "none", path: jsonPath }
+}

src/tools/AGENTS.md

@@ -23,6 +23,12 @@ tools/
 │   ├── config.ts       # Server configurations
 │   ├── tools.ts        # Tool implementations
 │   └── types.ts
+├── session-manager/    # OpenCode session file management
+│   ├── constants.ts    # Storage paths, descriptions
+│   ├── types.ts        # Session data interfaces
+│   ├── storage.ts      # File I/O operations
+│   ├── utils.ts        # Formatting, filtering
+│   └── tools.ts        # Tool implementations
 ├── slashcommand/       # Slash command execution
 └── index.ts            # builtinTools export
 ```
@@ -34,6 +40,7 @@ tools/
 | LSP | lsp_hover, lsp_goto_definition, lsp_find_references, lsp_document_symbols, lsp_workspace_symbols, lsp_diagnostics, lsp_servers, lsp_prepare_rename, lsp_rename, lsp_code_actions, lsp_code_action_resolve | IDE-like code intelligence |
 | AST | ast_grep_search, ast_grep_replace | Pattern-based code search/replace |
 | File Search | grep, glob | Content and file pattern matching |
+| Session | session_list, session_read, session_search, session_info | OpenCode session file management |
 | Background | background_task, background_output, background_cancel | Async agent orchestration |
 | Multimodal | look_at | PDF/image analysis via Gemini |
 | Terminal | interactive_bash | Tmux session control |

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

src/tools/ast-grep/index.ts

@@ -1,6 +1,7 @@
+import type { ToolDefinition } from "@opencode-ai/plugin"
 import { ast_grep_search, ast_grep_replace } from "./tools"
 
-export const builtinTools = {
+export const builtinTools: Record<string, ToolDefinition> = {
   ast_grep_search,
   ast_grep_replace,
 }

src/tools/ast-grep/tools.ts

@@ -1,4 +1,4 @@
-import { tool } from "@opencode-ai/plugin/tool"
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
 import { CLI_LANGUAGES } from "./constants"
 import { runSg } from "./cli"
 import { formatSearchResult, formatReplaceResult } from "./utils"
@@ -32,7 +32,7 @@ function getEmptyResultHint(pattern: string, lang: CliLanguage): string | null {
   return null
 }
 
-export const ast_grep_search = tool({
+export const ast_grep_search: ToolDefinition = tool({
   description:
     "Search code patterns across filesystem using AST-aware matching. Supports 25 languages. " +
     "Use meta-variables: $VAR (single node), $$$ (multiple nodes). " +
@@ -75,7 +75,7 @@ export const ast_grep_search = tool({
   },
 })
 
-export const ast_grep_replace = tool({
+export const ast_grep_replace: ToolDefinition = tool({
   description:
     "Replace code patterns across filesystem with AST-aware rewriting. " +
     "Dry-run by default. Use meta-variables in rewrite to preserve matched content. " +

src/tools/background-task/tools.ts

@@ -1,10 +1,27 @@
-import { tool, type PluginInput } from "@opencode-ai/plugin"
+import { tool, type PluginInput, type ToolDefinition } from "@opencode-ai/plugin"
+import { existsSync, readdirSync } from "node:fs"
+import { join } from "node:path"
 import type { BackgroundManager, BackgroundTask } from "../../features/background-agent"
 import type { BackgroundTaskArgs, BackgroundOutputArgs, BackgroundCancelArgs } from "./types"
 import { BACKGROUND_TASK_DESCRIPTION, BACKGROUND_OUTPUT_DESCRIPTION, BACKGROUND_CANCEL_DESCRIPTION } from "./constants"
+import { findNearestMessageWithFields, MESSAGE_STORAGE } from "../../features/hook-message-injector"
 
 type OpencodeClient = PluginInput["client"]
 
+function getMessageDir(sessionID: string): string | null {
+  if (!existsSync(MESSAGE_STORAGE)) return null
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) return directPath
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) return sessionPath
+  }
+
+  return null
+}
+
 function formatDuration(start: Date, end?: Date): string {
   const duration = (end ?? new Date()).getTime() - start.getTime()
   const seconds = Math.floor(duration / 1000)
@@ -20,7 +37,15 @@ function formatDuration(start: Date, end?: Date): string {
   }
 }
 
-export function createBackgroundTask(manager: BackgroundManager) {
+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,
     args: {
@@ -29,17 +54,31 @@ export function createBackgroundTask(manager: BackgroundManager) {
       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(ctx.sessionID)
+        const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
+        const parentModel = prevMessage?.model?.providerID && prevMessage?.model?.modelID
+          ? { providerID: prevMessage.model.providerID, modelID: prevMessage.model.modelID }
+          : undefined
+
         const task = await manager.launch({
           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.
@@ -193,7 +232,7 @@ Session ID: ${task.sessionID}
 ${textContent || "(No text output)"}`
 }
 
-export function createBackgroundOutput(manager: BackgroundManager, client: OpencodeClient) {
+export function createBackgroundOutput(manager: BackgroundManager, client: OpencodeClient): ToolDefinition {
   return tool({
     description: BACKGROUND_OUTPUT_DESCRIPTION,
     args: {
@@ -259,7 +298,7 @@ export function createBackgroundOutput(manager: BackgroundManager, client: Openc
   })
 }
 
-export function createBackgroundCancel(manager: BackgroundManager, client: OpencodeClient) {
+export function createBackgroundCancel(manager: BackgroundManager, client: OpencodeClient): ToolDefinition {
   return tool({
     description: BACKGROUND_CANCEL_DESCRIPTION,
     args: {

src/tools/call-omo-agent/tools.ts

@@ -1,13 +1,21 @@
-import { tool, type PluginInput } from "@opencode-ai/plugin"
+import { tool, type PluginInput, type ToolDefinition } from "@opencode-ai/plugin"
 import { ALLOWED_AGENTS, CALL_OMO_AGENT_DESCRIPTION } from "./constants"
 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
-) {
+): ToolDefinition {
   const agentDescriptions = ALLOWED_AGENTS.map(
     (name) => `- ${name}: Specialized agent for ${name} tasks`
   ).join("\n")
@@ -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))
 

src/tools/glob/tools.ts

@@ -1,8 +1,8 @@
-import { tool } from "@opencode-ai/plugin/tool"
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
 import { runRgFiles } from "./cli"
 import { formatGlobResult } from "./utils"
 
-export const glob = tool({
+export const glob: ToolDefinition = tool({
   description:
     "Fast file pattern matching tool with safety limits (60s timeout, 100 file limit). " +
     "Supports glob patterns like \"**/*.js\" or \"src/**/*.ts\". " +

src/tools/grep/tools.ts

@@ -1,8 +1,8 @@
-import { tool } from "@opencode-ai/plugin/tool"
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
 import { runRg } from "./cli"
 import { formatGrepResult } from "./utils"
 
-export const grep = tool({
+export const grep: ToolDefinition = tool({
   description:
     "Fast content search tool with safety limits (60s timeout, 10MB output). " +
     "Searches file contents using regular expressions. " +