release: v2.6.1

@devxoul has signed the CLA in code-yeongyu/oh-my-opencode#288
release: v2.6.0
2025-12-27 17:22:11 +00:00 · 2025-12-27 17:06:00 +00:00 · 2025-12-27 15:55:06 +00:00 · 2025-12-28 00:46:05 +09:00 · 2025-12-28 00:45:17 +09:00 · 2025-12-28 00:43:37 +09:00
66 changed files with 3197 additions and 358 deletions
--- a/README.ja.md
+++ b/README.ja.md
@@ -601,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 ツールが空の応答を返すと検知します。既に空の応答が返ってきているのに、いつまでも待ち続ける状況を防ぎます。
@@ -795,6 +794,8 @@ Oh My OpenCode は以下の場所からフックを読み込んで実行しま

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

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

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

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

@@ -902,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) に感謝します*
--- a/README.ko.md
+++ b/README.ko.md
@@ -595,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 도구가 빈 응답을 반환하면 감지합니다. 이미 빈 응답이 왔는데 무한정 기다리는 상황을 방지합니다.
@@ -789,6 +788,8 @@ Schema 자동 완성이 지원됩니다:

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

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

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

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

@@ -896,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) 께 감사드립니다*
--- a/README.md
+++ b/README.md
@@ -667,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.
@@ -697,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).
@@ -861,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.
@@ -911,7 +942,8 @@ Opt-in experimental features that may change or be removed in future versions. U
  "experimental": {
    "aggressive_truncation": true,
    "auto_resume": true,
-    "truncate_all_tool_outputs": false
+    "truncate_all_tool_outputs": false,
+    "dcp_on_compaction_failure": true
  }
 }
 ```
@@ -921,6 +953,7 @@ Opt-in experimental features that may change or be removed in future versions. U
 | `aggressive_truncation`     | `false` | When token limit is exceeded, aggressively truncates tool outputs to fit within limits. More aggressive than the default truncation behavior. Falls back to summarize/revert if insufficient. |
 | `auto_resume`               | `false` | Automatically resumes session after successful recovery from thinking block errors or thinking disabled violations. Extracts the last user message and continues.                            |
 | `truncate_all_tool_outputs` | `true`  | Dynamically truncates ALL tool outputs based on context window usage to prevent prompts from becoming too long. Disable by setting to `false` if you need full tool outputs.                 |
+| `dcp_on_compaction_failure` | `false` | When enabled, Dynamic Context Pruning (DCP) runs only after compaction (summarize) fails, then retries compaction. DCP does NOT run during normal operations. Enable this for smarter recovery when hitting token limits. |

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

@@ -968,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.*
--- a/README.zh-cn.md
+++ b/README.zh-cn.md
@@ -606,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 工具回了个寂寞？立马报警，别傻傻等一个永远不会来的响应。
@@ -795,6 +794,8 @@ Sisyphus Agent 也能自定义：

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

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

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

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

@@ -901,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 图。*
--- a/assets/oh-my-opencode.schema.json
+++ b/assets/oh-my-opencode.schema.json
@@ -59,7 +59,8 @@
          "agent-usage-reminder",
          "non-interactive-env",
          "interactive-bash-session",
-          "empty-message-sanitizer"
+          "empty-message-sanitizer",
+          "thinking-block-validator"
        ]
      }
    },
@@ -1339,6 +1340,18 @@
        },
        "hooks": {
          "type": "boolean"
+        },
+        "plugins": {
+          "type": "boolean"
+        },
+        "plugins_override": {
+          "type": "object",
+          "propertyNames": {
+            "type": "string"
+          },
+          "additionalProperties": {
+            "type": "boolean"
+          }
        }
      }
    },
@@ -1382,6 +1395,100 @@
        "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_on_compaction_failure": {
+          "type": "boolean"
        }
      }
    },
--- a/bun.lock
+++ b/bun.lock
@@ -14,6 +14,7 @@
        "@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",
@@ -110,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=="],
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "oh-my-opencode",
-  "version": "2.5.4",
+  "version": "2.6.1",
  "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
@@ -59,6 +59,7 @@
    "@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",
--- a/signatures/cla.json
+++ b/signatures/cla.json
@@ -39,6 +39,30 @@
      "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
    }
  ]
 }
--- a/src/cli/config-manager.ts
+++ b/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
  }
@@ -252,8 +183,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 +414,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 ?? {}

--- a/src/cli/get-local-version/formatter.ts
+++ b/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)
+}
--- a/src/cli/get-local-version/index.ts
+++ b/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"
--- a/src/cli/get-local-version/types.ts
+++ b/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
+}
--- a/src/cli/index.ts
+++ b/src/cli/index.ts
@@ -2,8 +2,10 @@
 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
@@ -73,6 +75,32 @@ Unlike 'opencode run', this command waits until:
    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")
--- a/src/cli/run/runner.ts
+++ b/src/cli/run/runner.ts
@@ -91,19 +91,15 @@ export async function run(options: RunOptions): Promise<number> {
        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."))
-          abortController.abort()
-          await eventProcessor.catch(() => {})
          cleanup()
-          return 1
+          process.exit(1)
        }

        const shouldExit = await checkCompletionConditions(ctx)
        if (shouldExit) {
          console.log(pc.green("\n\nAll tasks completed."))
-          abortController.abort()
-          await eventProcessor.catch(() => {})
          cleanup()
-          return 0
+          process.exit(0)
        }
      }

--- a/src/config/index.ts
+++ b/src/config/index.ts
@@ -18,4 +18,5 @@ export type {
  HookName,
  SisyphusAgentConfig,
  ExperimentalConfig,
+  DynamicContextPruningConfig,
 } from "./schema"
--- a/src/config/schema.ts
+++ b/src/config/schema.ts
@@ -64,6 +64,7 @@ export const HookNameSchema = z.enum([
  "non-interactive-env",
  "interactive-bash-session",
  "empty-message-sanitizer",
+  "thinking-block-validator",
 ])

 export const AgentOverrideConfigSchema = z.object({
@@ -103,6 +104,8 @@ 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({
@@ -112,6 +115,42 @@ export const SisyphusAgentConfigSchema = z.object({
  replace_plan: z.boolean().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({
  aggressive_truncation: z.boolean().optional(),
  auto_resume: z.boolean().optional(),
@@ -121,6 +160,10 @@ export const ExperimentalConfigSchema = z.object({
  preemptive_compaction_threshold: z.number().min(0.5).max(0.95).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(),
+  /** Run DCP only when compaction (summarize) fails, then retry compaction (default: false) */
+  dcp_on_compaction_failure: z.boolean().optional(),
 })

 export const OhMyOpenCodeConfigSchema = z.object({
@@ -143,5 +186,6 @@ export type AgentName = z.infer<typeof AgentNameSchema>
 export type HookName = z.infer<typeof HookNameSchema>
 export type SisyphusAgentConfig = z.infer<typeof SisyphusAgentConfigSchema>
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>
+export type DynamicContextPruningConfig = z.infer<typeof DynamicContextPruningConfigSchema>

 export { McpNameSchema, type McpName } from "../mcp/types"
--- a/src/features/background-agent/manager.ts
+++ b/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()
@@ -287,6 +287,7 @@ export class BackgroundManager {
    this.pollingInterval = setInterval(() => {
      this.pollRunningTasks()
    }, 2000)
+    this.pollingInterval.unref()
  }

  private stopPolling(): void {
@@ -296,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)

--- a/src/features/claude-code-agent-loader/loader.ts
+++ b/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> = {}
--- a/src/features/claude-code-command-loader/loader.ts
+++ b/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)
--- a/src/features/claude-code-mcp-loader/loader.ts
+++ b/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" },
  ]
--- a/src/features/claude-code-plugin-loader/index.ts
+++ b/src/features/claude-code-plugin-loader/index.ts
@@ -0,0 +1,3 @@
+export * from "./types"
+export * from "./loader"
+export type { PluginLoaderOptions, ClaudeSettings } from "./types"
--- a/src/features/claude-code-plugin-loader/loader.ts
+++ b/src/features/claude-code-plugin-loader/loader.ts
@@ -0,0 +1,471 @@
+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,
+  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
+}
+
+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, installations] of Object.entries(db.plugins)) {
+    if (!installations || installations.length === 0) continue
+
+    if (!isPluginEnabled(pluginKey, settingsEnabledPlugins, overrideEnabledPlugins)) {
+      log(`Plugin disabled: ${pluginKey}`)
+      continue
+    }
+
+    const installation = installations[0]
+    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,
+  }
+}
--- a/src/features/claude-code-plugin-loader/types.ts
+++ b/src/features/claude-code-plugin-loader/types.ts
@@ -0,0 +1,195 @@
+/**
+ * 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 structure
+ * Located at ~/.claude/plugins/installed_plugins.json
+ */
+export interface InstalledPluginsDatabase {
+  version: number
+  plugins: Record<string, PluginInstallation[]>
+}
+
+/**
+ * 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>
+}
--- a/src/features/claude-code-skill-loader/loader.ts
+++ b/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
--- a/src/hooks/anthropic-auto-compact/executor.test.ts
+++ b/src/hooks/anthropic-auto-compact/executor.test.ts
@@ -17,6 +17,7 @@ describe("executeCompact lock management", () => {
      retryStateBySession: new Map(),
      fallbackStateBySession: new Map(),
      truncateStateBySession: new Map(),
+      dcpStateBySession: new Map(),
      emptyContentAttemptBySession: new Map(),
      compactionInProgress: new Set<string>(),
    }
--- a/src/hooks/anthropic-auto-compact/executor.ts
+++ b/src/hooks/anthropic-auto-compact/executor.ts
@@ -1,11 +1,13 @@
 import type {
  AutoCompactState,
+  DcpState,
  FallbackState,
  RetryState,
  TruncateState,
 } from "./types";
 import type { ExperimentalConfig } from "../../config";
 import { FALLBACK_CONFIG, RETRY_CONFIG, TRUNCATE_CONFIG } from "./types";
+import { executeDynamicContextPruning } from "./pruning-executor";
 import {
  findLargestToolResult,
  truncateToolResult,
@@ -89,6 +91,18 @@ function getOrCreateTruncateState(
  return state;
 }

+function getOrCreateDcpState(
+  autoCompactState: AutoCompactState,
+  sessionID: string,
+): DcpState {
+  let state = autoCompactState.dcpStateBySession.get(sessionID);
+  if (!state) {
+    state = { attempted: false, itemsPruned: 0 };
+    autoCompactState.dcpStateBySession.set(sessionID, state);
+  }
+  return state;
+}
+
 async function getLastMessagePair(
  sessionID: string,
  client: Client,
@@ -184,6 +198,7 @@ function clearSessionState(
  autoCompactState.retryStateBySession.delete(sessionID);
  autoCompactState.fallbackStateBySession.delete(sessionID);
  autoCompactState.truncateStateBySession.delete(sessionID);
+  autoCompactState.dcpStateBySession.delete(sessionID);
  autoCompactState.emptyContentAttemptBySession.delete(sessionID);
  autoCompactState.compactionInProgress.delete(sessionID);
 }
@@ -567,6 +582,67 @@ export async function executeCompact(
      }
    }

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

    if (fallbackState.revertAttempt < FALLBACK_CONFIG.maxRevertAttempts) {
--- a/src/hooks/anthropic-auto-compact/index.ts
+++ b/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"
--- a/src/hooks/anthropic-auto-compact/pruning-deduplication.test.ts
+++ b/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)
+  })
+})
--- a/src/hooks/anthropic-auto-compact/pruning-deduplication.ts
+++ b/src/hooks/anthropic-auto-compact/pruning-deduplication.ts
@@ -0,0 +1,190 @@
+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"
+
+export interface DeduplicationConfig {
+  enabled: boolean
+  protectedTools?: string[]
+}
+
+const MESSAGE_STORAGE = join(
+  process.env.HOME || process.env.USERPROFILE || "",
+  ".config",
+  "opencode",
+  "sessions"
+)
+
+interface ToolPart {
+  type: string
+  callID?: string
+  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
+}
--- a/src/hooks/anthropic-auto-compact/pruning-executor.ts
+++ b/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
+}
--- a/src/hooks/anthropic-auto-compact/pruning-purge-errors.ts
+++ b/src/hooks/anthropic-auto-compact/pruning-purge-errors.ts
@@ -0,0 +1,158 @@
+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"
+
+export interface PurgeErrorsConfig {
+  enabled: boolean
+  turns: number
+  protectedTools?: string[]
+}
+
+const MESSAGE_STORAGE = join(
+  process.env.HOME || process.env.USERPROFILE || "",
+  ".config",
+  "opencode",
+  "sessions"
+)
+
+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
+}
--- a/src/hooks/anthropic-auto-compact/pruning-storage.ts
+++ b/src/hooks/anthropic-auto-compact/pruning-storage.ts
@@ -0,0 +1,107 @@
+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"
+
+const MESSAGE_STORAGE = join(
+  process.env.HOME || process.env.USERPROFILE || "",
+  ".config",
+  "opencode",
+  "sessions"
+)
+
+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
+}
--- a/src/hooks/anthropic-auto-compact/pruning-supersede.ts
+++ b/src/hooks/anthropic-auto-compact/pruning-supersede.ts
@@ -0,0 +1,218 @@
+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"
+
+export interface SupersedeWritesConfig {
+  enabled: boolean
+  aggressive: boolean
+}
+
+const MESSAGE_STORAGE = join(
+  process.env.HOME || process.env.USERPROFILE || "",
+  ".config",
+  "opencode",
+  "sessions"
+)
+
+interface ToolPart {
+  type: string
+  callID?: string
+  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
+}
--- a/src/hooks/anthropic-auto-compact/pruning-types.ts
+++ b/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)
+}
--- a/src/hooks/anthropic-auto-compact/types.ts
+++ b/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>
 }
--- a/src/hooks/auto-update-checker/index.ts
+++ b/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) {
--- a/src/hooks/claude-code-hooks/config.ts
+++ b/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"),
  ]
--- a/src/hooks/claude-code-hooks/todo.ts
+++ b/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`)
--- a/src/hooks/claude-code-hooks/transcript.ts
+++ b/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`)
--- a/src/hooks/index.ts
+++ b/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";
--- a/src/hooks/keyword-detector/constants.ts
+++ b/src/hooks/keyword-detector/constants.ts
@@ -31,12 +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.

--- a/src/hooks/session-notification-utils.ts
+++ b/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(() => {})
+  }
+}
--- a/src/hooks/session-notification.test.ts
+++ b/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(() => {
--- a/src/hooks/session-notification.ts
+++ b/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",
--- a/src/hooks/session-recovery/storage.ts
+++ b/src/hooks/session-recovery/storage.ts
@@ -223,6 +223,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 +265,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,
  }

--- a/src/hooks/thinking-block-validator/index.ts
+++ b/src/hooks/thinking-block-validator/index.ts
@@ -0,0 +1,170 @@
+/**
+ * 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 tool parts (tool_use)
+ */
+function hasToolParts(parts: Part[]): boolean {
+  if (!parts || parts.length === 0) return false
+
+  return parts.some((part: Part) => {
+    const type = part.type as string
+    return type === "tool" || type === "tool_use"
+  })
+}
+
+/**
+ * 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 tool parts but doesn't start with thinking
+        if (hasToolParts(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)
+        }
+      }
+    },
+  }
+}
--- a/src/index.ts
+++ b/src/index.ts
@@ -23,6 +23,7 @@ import {
  createNonInteractiveEnvHook,
  createInteractiveBashSessionHook,
  createEmptyMessageSanitizerHook,
+  createThinkingBlockValidatorHook,
 } from "./hooks";
 import { createGoogleAntigravityAuthPlugin } from "./auth/antigravity";
 import {
@@ -31,15 +32,13 @@ import {
  loadOpencodeGlobalCommands,
  loadOpencodeProjectCommands,
 } from "./features/claude-code-command-loader";
-import {
-  loadUserSkillsAsCommands,
-  loadProjectSkillsAsCommands,
-} from "./features/claude-code-skill-loader";
+
 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 +47,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";
@@ -120,7 +119,7 @@ function loadConfigFromPath(configPath: string, ctx: any): OhMyOpenCodeConfig |
  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);

@@ -130,20 +129,6 @@ function loadConfigFromPath(configPath: string, ctx: any): OhMyOpenCodeConfig |
        const errorMsg = result.error.issues.map(i => `${i.path.join(".")}: ${i.message}`).join(", ");
        log(`Config validation error in ${configPath}:`, result.error.issues);
        addConfigLoadError({ path: configPath, error: `Validation error: ${errorMsg}` });
-        
-        const errorList = result.error.issues
-          .map(issue => `• ${issue.path.join(".")}: ${issue.message}`)
-          .join("\n");
-        
-        ctx.client.tui.showToast({
-          body: {
-            title: "❌ OhMyOpenCode: Config Validation Failed",
-            message: `Failed to load ${configPath}\n\nValidation errors:\n${errorList}\n\nConfig will be ignored. Please fix the errors above.`,
-            variant: "error" as const,
-            duration: 10000,
-          },
-        }).catch(() => {});
-        
        return null;
      }

@@ -154,19 +139,6 @@ function loadConfigFromPath(configPath: string, ctx: any): OhMyOpenCodeConfig |
    const errorMsg = err instanceof Error ? err.message : String(err);
    log(`Error loading config from ${configPath}:`, err);
    addConfigLoadError({ path: configPath, error: errorMsg });
-    
-    const hint = err instanceof SyntaxError
-      ? "\n\nHint: Check for syntax errors in your JSON file (missing commas, quotes, brackets, etc.)"
-      : "";
-    
-    ctx.client.tui.showToast({
-      body: {
-        title: "❌ OhMyOpenCode: Config Load Failed",
-        message: `Failed to load ${configPath}\n\nError: ${errorMsg}${hint}\n\nConfig will be ignored. Please fix the error above.`,
-        variant: "error" as const,
-        duration: 10000,
-      },
-    }).catch(() => {});
  }
  return null;
 }
@@ -202,19 +174,15 @@ function mergeConfigs(
 }

 function loadPluginConfig(directory: string, ctx: any): OhMyOpenCodeConfig {
-  // User-level config path (OS-specific)
-  const userConfigPath = path.join(
-    getUserConfigDir(),
-    "opencode",
-    "oh-my-opencode.json"
-  );
+  // 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, ctx) ?? {};
@@ -319,6 +287,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);

@@ -365,6 +336,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);
    },
@@ -395,6 +368,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,
@@ -404,6 +393,7 @@ 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;
@@ -411,9 +401,8 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
      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
+        // 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,
@@ -463,6 +452,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
          ...Object.fromEntries(Object.entries(builtinAgents).filter(([k]) => k !== "Sisyphus")),
          ...userAgents,
          ...projectAgents,
+          ...pluginAgents,
          ...filteredConfigAgents,  // Filtered config agents (excludes build/plan if replaced)
          // Demote build/plan to subagent mode when replaced
          build: { ...config.agent?.build, mode: "subagent" },
@@ -473,6 +463,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
          ...builtinAgents,
          ...userAgents,
          ...projectAgents,
+          ...pluginAgents,
          ...config.agent,
        };
      }
@@ -511,10 +502,12 @@ 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 userCommands = (pluginConfig.claude_code?.commands ?? true) ? loadUserCommands() : {};
@@ -522,17 +515,13 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
      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 = {
        ...userCommands,
-        ...userSkills,
        ...opencodeGlobalCommands,
        ...systemCommands,
        ...projectCommands,
-        ...projectSkills,
        ...opencodeProjectCommands,
+        ...pluginComponents.commands,
      };
    },

--- a/src/shared/claude-config-dir.test.ts
+++ b/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")
+  })
+})
--- a/src/shared/claude-config-dir.ts
+++ b/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")
+}
--- a/src/shared/dynamic-truncator.ts
+++ b/src/shared/dynamic-truncator.ts
@@ -1,167 +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) +
-      (lastTokens?.output ?? 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),
+	};
 }
--- a/src/shared/index.ts
+++ b/src/shared/index.ts
@@ -13,3 +13,5 @@ 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"
--- a/src/shared/jsonc-parser.test.ts
+++ b/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")
+  })
+})
--- a/src/shared/jsonc-parser.ts
+++ b/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 }
+}
--- a/src/tools/ast-grep/index.ts
+++ b/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,
 }
--- a/src/tools/ast-grep/tools.ts
+++ b/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. " +
--- a/src/tools/background-task/tools.ts
+++ b/src/tools/background-task/tools.ts
@@ -1,4 +1,4 @@
-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"
@@ -37,7 +37,7 @@ function formatDuration(start: Date, end?: Date): string {
  }
 }

-export function createBackgroundTask(manager: BackgroundManager) {
+export function createBackgroundTask(manager: BackgroundManager): ToolDefinition {
  return tool({
    description: BACKGROUND_TASK_DESCRIPTION,
    args: {
@@ -217,7 +217,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: {
@@ -283,7 +283,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: {
--- a/src/tools/call-omo-agent/tools.ts
+++ b/src/tools/call-omo-agent/tools.ts
@@ -1,4 +1,4 @@
-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"
@@ -7,7 +7,7 @@ import { log } from "../../shared/logger"
 export function createCallOmoAgent(
  ctx: PluginInput,
  backgroundManager: BackgroundManager
-) {
+): ToolDefinition {
  const agentDescriptions = ALLOWED_AGENTS.map(
    (name) => `- ${name}: Specialized agent for ${name} tasks`
  ).join("\n")
--- a/src/tools/glob/tools.ts
+++ b/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\". " +
--- a/src/tools/grep/tools.ts
+++ b/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. " +
--- a/src/tools/index.ts
+++ b/src/tools/index.ts
@@ -37,7 +37,7 @@ import {
  createBackgroundCancel,
 } from "./background-task"

-import type { PluginInput } from "@opencode-ai/plugin"
+import type { PluginInput, ToolDefinition } from "@opencode-ai/plugin"
 import type { BackgroundManager } from "../features/background-agent"

 type OpencodeClient = PluginInput["client"]
@@ -45,7 +45,7 @@ type OpencodeClient = PluginInput["client"]
 export { createCallOmoAgent } from "./call-omo-agent"
 export { createLookAt } from "./look-at"

-export function createBackgroundTools(manager: BackgroundManager, client: OpencodeClient) {
+export function createBackgroundTools(manager: BackgroundManager, client: OpencodeClient): Record<string, ToolDefinition> {
  return {
    background_task: createBackgroundTask(manager),
    background_output: createBackgroundOutput(manager, client),
@@ -53,7 +53,7 @@ export function createBackgroundTools(manager: BackgroundManager, client: Openco
  }
 }

-export const builtinTools = {
+export const builtinTools: Record<string, ToolDefinition> = {
  lsp_hover,
  lsp_goto_definition,
  lsp_find_references,
--- a/src/tools/interactive-bash/tools.ts
+++ b/src/tools/interactive-bash/tools.ts
@@ -1,4 +1,4 @@
-import { tool } from "@opencode-ai/plugin/tool"
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
 import { BLOCKED_TMUX_SUBCOMMANDS, DEFAULT_TIMEOUT_MS, INTERACTIVE_BASH_DESCRIPTION } from "./constants"
 import { getCachedTmuxPath } from "./utils"

@@ -47,7 +47,7 @@ export function tokenizeCommand(cmd: string): string[] {
  return tokens
 }

-export const interactive_bash = tool({
+export const interactive_bash: ToolDefinition = tool({
  description: INTERACTIVE_BASH_DESCRIPTION,
  args: {
    tmux_command: tool.schema.string().describe("The tmux command to execute (without 'tmux' prefix)"),
--- a/src/tools/look-at/tools.ts
+++ b/src/tools/look-at/tools.ts
@@ -1,5 +1,6 @@
 import { extname, basename } from "node:path"
-import { tool, type PluginInput } from "@opencode-ai/plugin"
+import { pathToFileURL } from "node:url"
+import { tool, type PluginInput, type ToolDefinition } from "@opencode-ai/plugin"
 import { LOOK_AT_DESCRIPTION, MULTIMODAL_LOOKER_AGENT } from "./constants"
 import type { LookAtArgs } from "./types"
 import { log } from "../../shared/logger"
@@ -28,7 +29,7 @@ function inferMimeType(filePath: string): string {
  return mimeTypes[ext] || "application/octet-stream"
 }

-export function createLookAt(ctx: PluginInput) {
+export function createLookAt(ctx: PluginInput): ToolDefinition {
  return tool({
    description: LOOK_AT_DESCRIPTION,
    args: {
@@ -78,7 +79,7 @@ If the requested information is not found, clearly state what is missing.`
          },
          parts: [
            { type: "text", text: prompt },
-            { type: "file", mime: mimeType, url: `file://${args.file_path}`, filename },
+            { type: "file", mime: mimeType, url: pathToFileURL(args.file_path).href, filename },
          ],
        },
      })
--- a/src/tools/lsp/tools.ts
+++ b/src/tools/lsp/tools.ts
@@ -1,4 +1,4 @@
-import { tool } from "@opencode-ai/plugin/tool"
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
 import { getAllServers } from "./config"
 import {
  DEFAULT_MAX_REFERENCES,
@@ -34,7 +34,7 @@ import type {



-export const lsp_hover = tool({
+export const lsp_hover: ToolDefinition = tool({
  description: "Get type info, docs, and signature for a symbol at position.",
  args: {
    filePath: tool.schema.string(),
@@ -55,7 +55,7 @@ export const lsp_hover = tool({
  },
 })

-export const lsp_goto_definition = tool({
+export const lsp_goto_definition: ToolDefinition = tool({
  description: "Jump to symbol definition. Find WHERE something is defined.",
  args: {
    filePath: tool.schema.string(),
@@ -92,7 +92,7 @@ export const lsp_goto_definition = tool({
  },
 })

-export const lsp_find_references = tool({
+export const lsp_find_references: ToolDefinition = tool({
  description: "Find ALL usages/references of a symbol across the entire workspace.",
  args: {
    filePath: tool.schema.string(),
@@ -129,7 +129,7 @@ export const lsp_find_references = tool({
  },
 })

-export const lsp_document_symbols = tool({
+export const lsp_document_symbols: ToolDefinition = tool({
  description: "Get hierarchical outline of all symbols in a file.",
  args: {
    filePath: tool.schema.string(),
@@ -167,7 +167,7 @@ export const lsp_document_symbols = tool({
  },
 })

-export const lsp_workspace_symbols = tool({
+export const lsp_workspace_symbols: ToolDefinition = tool({
  description: "Search symbols by name across ENTIRE workspace.",
  args: {
    filePath: tool.schema.string(),
@@ -202,7 +202,7 @@ export const lsp_workspace_symbols = tool({
  },
 })

-export const lsp_diagnostics = tool({
+export const lsp_diagnostics: ToolDefinition = tool({
  description: "Get errors, warnings, hints from language server BEFORE running build.",
  args: {
    filePath: tool.schema.string(),
@@ -249,7 +249,7 @@ export const lsp_diagnostics = tool({
  },
 })

-export const lsp_servers = tool({
+export const lsp_servers: ToolDefinition = tool({
  description: "List available LSP servers and installation status.",
  args: {},
  execute: async (_args, context) => {
@@ -271,7 +271,7 @@ export const lsp_servers = tool({
  },
 })

-export const lsp_prepare_rename = tool({
+export const lsp_prepare_rename: ToolDefinition = tool({
  description: "Check if rename is valid. Use BEFORE lsp_rename.",
  args: {
    filePath: tool.schema.string(),
@@ -295,7 +295,7 @@ export const lsp_prepare_rename = tool({
  },
 })

-export const lsp_rename = tool({
+export const lsp_rename: ToolDefinition = tool({
  description: "Rename symbol across entire workspace. APPLIES changes to all files.",
  args: {
    filePath: tool.schema.string(),
@@ -318,7 +318,7 @@ export const lsp_rename = tool({
  },
 })

-export const lsp_code_actions = tool({
+export const lsp_code_actions: ToolDefinition = tool({
  description: "Get available quick fixes, refactorings, and source actions (organize imports, fix all).",
  args: {
    filePath: tool.schema.string(),
@@ -362,7 +362,7 @@ export const lsp_code_actions = tool({
  },
 })

-export const lsp_code_action_resolve = tool({
+export const lsp_code_action_resolve: ToolDefinition = tool({
  description: "Resolve and APPLY a code action from lsp_code_actions.",
  args: {
    filePath: tool.schema.string(),
--- a/src/tools/session-manager/constants.ts
+++ b/src/tools/session-manager/constants.ts
@@ -1,12 +1,12 @@
 import { join } from "node:path"
-import { homedir } from "node:os"
 import { getOpenCodeStorageDir } from "../../shared/data-path"
+import { getClaudeConfigDir } from "../../shared"

 export const OPENCODE_STORAGE = getOpenCodeStorageDir()
 export const MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message")
 export const PART_STORAGE = join(OPENCODE_STORAGE, "part")
-export const TODO_DIR = join(homedir(), ".claude", "todos")
-export const TRANSCRIPT_DIR = join(homedir(), ".claude", "transcripts")
+export const TODO_DIR = join(getClaudeConfigDir(), "todos")
+export const TRANSCRIPT_DIR = join(getClaudeConfigDir(), "transcripts")
 export const SESSION_LIST_DESCRIPTION = `List all OpenCode sessions with optional filtering.

 Returns a list of available session IDs with metadata including message count, date range, and agents used.
--- a/src/tools/session-manager/tools.ts
+++ b/src/tools/session-manager/tools.ts
@@ -1,4 +1,4 @@
-import { tool } from "@opencode-ai/plugin/tool"
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
 import {
  SESSION_LIST_DESCRIPTION,
  SESSION_READ_DESCRIPTION,
@@ -9,7 +9,7 @@ import { getAllSessions, getSessionInfo, readSessionMessages, readSessionTodos,
 import { filterSessionsByDate, formatSessionInfo, formatSessionList, formatSessionMessages, formatSearchResults, searchInSession } from "./utils"
 import type { SessionListArgs, SessionReadArgs, SessionSearchArgs, SessionInfoArgs } from "./types"

-export const session_list = tool({
+export const session_list: ToolDefinition = tool({
  description: SESSION_LIST_DESCRIPTION,
  args: {
    limit: tool.schema.number().optional().describe("Maximum number of sessions to return"),
@@ -35,7 +35,7 @@ export const session_list = tool({
  },
 })

-export const session_read = tool({
+export const session_read: ToolDefinition = tool({
  description: SESSION_READ_DESCRIPTION,
  args: {
    session_id: tool.schema.string().describe("Session ID to read"),
@@ -64,7 +64,7 @@ export const session_read = tool({
  },
 })

-export const session_search = tool({
+export const session_search: ToolDefinition = tool({
  description: SESSION_SEARCH_DESCRIPTION,
  args: {
    query: tool.schema.string().describe("Search query string"),
@@ -87,7 +87,7 @@ export const session_search = tool({
  },
 })

-export const session_info = tool({
+export const session_info: ToolDefinition = tool({
  description: SESSION_INFO_DESCRIPTION,
  args: {
    session_id: tool.schema.string().describe("Session ID to inspect"),
--- a/src/tools/slashcommand/tools.ts
+++ b/src/tools/slashcommand/tools.ts
@@ -1,9 +1,9 @@
-import { tool } from "@opencode-ai/plugin"
+import { tool, type ToolDefinition } from "@opencode-ai/plugin"
 import { existsSync, readdirSync, readFileSync } from "fs"
-import { homedir } from "os"
 import { join, basename, dirname } from "path"
 import { parseFrontmatter, resolveCommandsInText, resolveFileReferencesInText, sanitizeModelField } from "../../shared"
 import { isMarkdownFile } from "../../shared/file-utils"
+import { getClaudeConfigDir } from "../../shared"
 import type { CommandScope, CommandMetadata, CommandInfo } from "./types"

 function discoverCommandsFromDir(commandsDir: string, scope: CommandScope): CommandInfo[] {
@@ -50,7 +50,8 @@ function discoverCommandsFromDir(commandsDir: string, scope: CommandScope): Comm
 }

 function discoverCommandsSync(): CommandInfo[] {
-  const userCommandsDir = join(homedir(), ".claude", "commands")
+  const { homedir } = require("os")
+  const userCommandsDir = join(getClaudeConfigDir(), "commands")
  const projectCommandsDir = join(process.cwd(), ".claude", "commands")
  const opencodeGlobalDir = join(homedir(), ".config", "opencode", "command")
  const opencodeProjectDir = join(process.cwd(), ".opencode", "command")
@@ -126,7 +127,7 @@ function formatCommandList(commands: CommandInfo[]): string {
  return lines.join("\n")
 }

-export const slashcommand = tool({
+export const slashcommand: ToolDefinition = tool({
  description: `Execute a slash command within the main conversation.

 When you use this tool, the slash command gets expanded to a full prompt that provides detailed instructions on how to complete the task.
@@ -145,7 +146,7 @@ Commands are loaded from (priority order, highest wins):
 - .opencode/command/ (opencode-project - OpenCode project-specific commands)
 - ./.claude/commands/ (project - Claude Code project-specific commands)
 - ~/.config/opencode/command/ (opencode - OpenCode global commands)
- ~/.claude/commands/ (user - Claude Code global commands)
+- $CLAUDE_CONFIG_DIR/commands/ or ~/.claude/commands/ (user - Claude Code global commands)

 Each command is a markdown file with:
 - YAML frontmatter: description, argument-hint, model, agent, subtask (optional)
Author	SHA1	Message	Date
github-actions[bot]	262f0c3f1f	release: v2.6.1	2025-12-27 17:22:11 +00:00
github-actions[bot]	aace1982ec	@devxoul has signed the CLA in code-yeongyu/oh-my-opencode#288	2025-12-27 17:06:00 +00:00
github-actions[bot]	8d8ea4079d	release: v2.6.0	2025-12-27 15:55:06 +00:00
YeonGyu-Kim	c5f51030f0	fix: defer config error toast to session.created for TUI readiness (#286 ) * fix: defer config error toast to session.created for TUI readiness Removed showToast calls from loadConfigFromPath() function. Error notifications were not visible during plugin initialization because the TUI was not ready yet. Changes: - Removed immediate showToast calls from validation error handler - Removed immediate showToast calls from file load error handler - Errors are still captured via addConfigLoadError() for later display - auto-update-checker hook will display errors via showConfigErrorsIfAny() after session.created event This ensures error messages are displayed when the TUI is fully ready and able to render them properly. 🤖 Generated with assistance of [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode) * fix: await config error toast before showing startup toast Ensure config errors are awaited and displayed before the startup spinner toast is shown. Changed showConfigErrorsIfAny(ctx).catch(() => {}) to await showConfigErrorsIfAny(ctx) to guarantee proper error handling order. 🤖 Generated with assistance of [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 00:46:05 +09:00
Sisyphus	b2c2c6eab7	feat: Add JSONC support for oh-my-opencode config files (#275 ) Uses Microsoft's jsonc-parser package for reliable JSONC parsing: - oh-my-opencode.jsonc (preferred) or oh-my-opencode.json - Supports line comments (//), block comments (/* */), and trailing commas - Better error reporting with line/column positions Core changes: - Added jsonc-parser dependency (Microsoft's VS Code parser) - Shared JSONC utilities (parseJsonc, parseJsoncSafe, readJsoncFile, detectConfigFile) - Main plugin config loader uses detectConfigFile for .jsonc priority - CLI config manager supports JSONC parsing Comprehensive test suite with 18 tests for JSONC parsing. Fixes #265 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode) Co-authored-by: sisyphus-dev-ai <sisyphus-dev-ai@users.noreply.github.com>	2025-12-28 00:45:17 +09:00
YeonGyu-Kim	c4c0d82f97	fix(anthropic-auto-compact): run DCP only on compaction failure and retry after pruning (#284 ) Make DCP behavior opt-in via new 'dcp_on_compaction_failure' experimental flag (disabled by default). When enabled, Dynamic Context Pruning only executes after summarization fails, then retries compaction. By default, DCP runs before truncation as before. Changes: - Add 'dcp_on_compaction_failure' boolean flag to experimental config (default: false) - Update executor.ts to check flag before running DCP behavior - Add corresponding documentation to all 4 README files (EN, KO, JA, ZH-CN) - Update JSON schema 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 00:43:37 +09:00
YeonGyu-Kim	3e180cd9f1	docs: add Aaron Iker as sponsor to all README files (#287 ) Add Aaron Iker (@aaroniker) with GitHub and X links to the sponsors section in all language README files (EN, KO, JA, ZH-CN). 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 00:42:35 +09:00
YeonGyu-Kim	776d857fd2	feat: set Sisyphus as default agent when enabled (#285 ) Uses OpenCode's `default_agent` config (PR #5843) Sets Sisyphus as default when sisyphus_agent is not disabled Closes #283 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 00:28:26 +09:00
Harsha Vardhan	90d43dc292	fix(dynamic-truncator): apply fallback truncation when context usage unavailable (#268 ) When getContextWindowUsage returns null (no assistant messages yet, API failure, or first request in session), the truncator was returning untruncated output. This caused context overflow crashes on early requests or when usage lookup failed. Now applies conservative truncation (50k tokens) as fallback, preventing prompt-too-long errors that crash sessions.	2025-12-28 00:22:02 +09:00
YeonGyu-Kim	6bc9a31ee4	feat(ultrawork-prompt): add TDD workflow integration with conditional applicability (#246 ) - Add TDD cycle specification (SPEC → RED → GREEN → REFACTOR → NEXT) - Add applicability check for test infrastructure and implementation tasks - Add TDD execution rules (TEST FIRST, MINIMAL IMPLEMENTATION, etc.) - Add 'NO TEST DELETION' to ZERO TOLERANCE FAILURES section - Add skip notation requirement for non-applicable tasks Addresses: #243 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-28 00:14:06 +09:00
github-actions[bot]	5c8cfbfad8	@adam2am has signed the CLA in code-yeongyu/oh-my-opencode#281	2025-12-27 14:49:14 +00:00
YeonGyu-Kim	1d2dc69ae5	fix: use pathToFileURL for Windows-compatible file URLs in look_at tool (#279 ) Fixes #276 - The look_at tool was constructing invalid file:// URLs on Windows by using template literals. Now uses Node.js pathToFileURL() which correctly handles backslashes, spaces, and the triple-slash prefix required on Windows. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-27 23:47:59 +09:00
Sisyphus	0cee39dafb	fix: properly mock utility functions in session-notification tests (#274 ) The test mock for ctx.$ was not handling tagged template literals correctly, causing it to ignore interpolated values. Additionally, utility functions that check for command availability (osascript, notify-send, etc.) were returning null in test environments, causing sendNotification to exit early. Changes: - Fixed template literal reconstruction in mock $ function - Added spyOn mocks for all utility path functions - All session-notification tests now passing (11/11) Fixes #273 Co-authored-by: sisyphus-dev-ai <sisyphus-dev-ai@users.noreply.github.com>	2025-12-27 23:22:17 +09:00
YeonGyu-Kim	dd12928390	fix: resolve GitHub Actions workflow hang after task completion - Add process.exit(0) in runner.ts for immediate termination - Fix Timer type to ReturnType<typeof setInterval> in manager.ts - Add .unref() to BackgroundManager polling interval - Add cleanup() method to BackgroundManager 🤖 Generated with assistance of [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-27 23:06:44 +09:00
Lukin	2246d1c5ef	feat: add Claude Code plugin support (#240 )	2025-12-27 18:56:40 +09:00
sisyphus-dev-ai	1fc7fe7122	feat(compaction): add dynamic context pruning as recovery stage Implements DCP-style pruning strategies inspired by opencode-dynamic-context-pruning plugin: - Deduplication: removes duplicate tool calls (same tool + args) - Supersede writes: prunes write inputs when file subsequently read - Purge errors: removes old error tool inputs after N turns Integration: - Added as Stage 2.5 in compaction pipeline (after truncation, before summarize) - Configurable via experimental.dynamic_context_pruning - Opt-in by default (experimental feature) - Protected tools list prevents pruning critical tools Configuration: - Turn protection (default: 3 turns) - Per-strategy enable/disable - Aggressive/conservative modes for supersede writes - Configurable error purge threshold (default: 5 turns) - Toast notifications (off/minimal/detailed) Testing: - Added unit tests for deduplication signature creation - Type check passes - Schema regenerated Closes #271	2025-12-27 09:20:42 +00:00
Sisyphus	3ba7e6d46b	docs: clarify auto-update-checker and startup-toast relationship (#270 )	2025-12-27 17:43:55 +09:00
Sisyphus	dec4994fd6	fix: check command existence before calling notify-send (#264 )	2025-12-27 17:17:13 +09:00
github-actions[bot]	c5205e7e2f	@harshav167 has signed the CLA in code-yeongyu/oh-my-opencode#268	2025-12-27 04:40:45 +00:00
Sisyphus	8e2fda870a	feat: add get-local-version CLI command for version checking (#262 ) - Add new CLI command 'get-local-version' to display current version and check for updates - Reuses existing version checking infrastructure from auto-update-checker - Supports both human-readable and JSON output formats - Handles edge cases: local dev mode, pinned versions, network errors - Provides colored terminal output with picocolors - Closes #260 Co-authored-by: sisyphus-dev-ai <sisyphus-dev-ai@users.noreply.github.com>	2025-12-27 02:07:55 +09:00
Sisyphus	cad6425a4a	fix: honor CLAUDE_CONFIG_DIR environment variable (#261 ) Fixes #255 - Add getClaudeConfigDir() utility function that respects CLAUDE_CONFIG_DIR env var - Update all hardcoded ~/.claude paths to use the new utility - Add comprehensive tests for getClaudeConfigDir() - Maintain backward compatibility with default ~/.claude when env var is not set Files updated: - src/shared/claude-config-dir.ts (new utility) - src/shared/claude-config-dir.test.ts (tests) - src/hooks/claude-code-hooks/config.ts - src/hooks/claude-code-hooks/todo.ts - src/hooks/claude-code-hooks/transcript.ts - src/features/claude-code-command-loader/loader.ts - src/features/claude-code-agent-loader/loader.ts - src/features/claude-code-skill-loader/loader.ts - src/features/claude-code-mcp-loader/loader.ts - src/tools/session-manager/constants.ts - src/tools/slashcommand/tools.ts Co-authored-by: sisyphus-dev-ai <sisyphus-dev-ai@users.noreply.github.com>	2025-12-26 23:28:33 +09:00
Steven Vo	15de6f637e	feat: add two-layer thinking block validation (proactive + reactive) (#248 ) - Add thinking-block-validator hook for proactive prevention before API calls - Enhance session-recovery to include previous thinking content - Fix hook registration to actually invoke the validator Addresses extended thinking errors with Claude Opus/Sonnet 4.5 using tool calls. Related: https://github.com/vercel/ai/issues/7729 Related: https://github.com/sst/opencode/issues/2599	2025-12-26 23:14:11 +09:00
YeonGyu-Kim	e05d9dfc35	feat: add sponsors section to localized README files - Add Sponsors section to README.ko.md, README.ja.md, README.zh-cn.md, README.md - List Numman Ali as the first sponsor - Move thanks message to end of file to match structure 🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)	2025-12-26 16:52:58 +09:00